//************************************************************************// // Nazov: MBOOLDIF.H // // Autor: Zdeno Sekerak // // Popis: kniznica na vsetko // // datum: 25.8.1997 // //************************************************************************// #define nic '0' #define jclen '1' // clen jednotkovy a,b,c #define nclen 'n' // clen negovany A,B,C #define ziaden "" // ak neaka funkcia zobrazuje {} NDF tak vypise toto #define vstup_0 "0" // logicka nula na vstup #define vstup_1 "I" // logicka nula na vstup !!! POZOR nedavaj 1, lebo bude problem #define vstup_x "X" // logicka nula na vstup #define max_NDF 300 // kolko NDF zapisov moze byt !!! #define max_stat 40 // kolko statistickych zapisov moze byt !!! #define max_ret 1800 // kolko znakov moze byt v retazci !!! nie menej ako 256 v zmysle // pascalovskeho retazca #define max_ria 200 // kolko maximalne riadkov bude prehliadac vstave zobrazit #include #include #include #include #include #include #include // Zakladna struktura do ktorej odkladam a potom pracujem s tymito udajmi #if !defined(zapis_NDF) typedef struct { int pv_NDF; // pocet premennych v NDF strukture aB+AB+ab =2 int poc_NDF; // pocet NDF zapisov napr. aB+AB+Cd =3 char adept[ max_NDF ]; // Existuje adept na vyhodenie zo struktury. Je pohlteny adt. // alebo aky clen substiujem ak je to slovnik substucii char *pNDF[ max_NDF ]; // smernik na sNDF char *pSubst[ max_NDF ]; // smernik na retazec po substitucii ( zbytocnost !?! ) char t_vodic[ max_NDF ]; // vzhladom na ktory t (a,b,c) zistujem chybu, // alebo ktory je to vetviaci sa vodic e1, e2 atd. char t_chyba[ max_NDF ]; // chyba je 0 alebo 1 char index[ max_NDF ]; // aky index ma premenna, ak je vetviaci vodit } zapis_NDF; #endif #if !defined(statist) typedef struct { char s_text[ 50 ]; // aka operacia long cas; // cas pri vzniku udalosti long pamet; // kolko zozralo pamete } statist; #endif #if !defined(Riadok) typedef struct { // mam rad nezavislost a ak nemusim int dlzka; // ako taky debil vsade davat #include char *riadok; } Riadok; #endif // ******************************* // *** HA-HA globalne premenne *** // ******************************* zapis_NDF h_fnc,deriv_f; // tu bude hlavna funkcia, a derivovana zapis_NDF slovnik; // tu bude odlozeny moj slovnik statist s_stat[ max_stat ]; // ukladam statisticke udaje zapis_NDF subst_NDF; // substitucie zacinam mat obavy, ma velke pamatove naroky // aby neprekrocil segment char ret_f[ max_ret ]; // retazec nacitany zo suboru (klavesnice) char temp[ max_ret ]; // kde je TMP adresar ??? char index[2]; // aky index ma danna premenna ak je substituovana int zac_subst; // od akej premennej zacina substitucia long min_mem; // najmensie mnozstvo pamete ake mal long volne_mem; // kolko mal pamete hned po spusteni ??? int p_stat; // pri akej premennej statistiky sa nachadzam char s12[ max_ret ]; // no comnent, hamba mi // Nachadza sa v OBSLUHA.C void znuluj(zapis_NDF *NDFka,int aj_mem); // vycisti strukturu ak v nej nieco ostalo void del_tmp( char subor[] ); // maze pomocne tmp subory int from_keyb( void ); // precita NDF do retazce ret_f a spracuje vramci NDF struktur int rovnaju_sa( zapis_NDF *fnc1, zapis_NDF *fnc2 );// porovna 2 funkcie i:1-OK 2-not OK int prever_uziv( zapis_NDF *deriv_f, int *p_chyb);//Preveri uzivatelove vedomosti // ak sa mu nechce dalej vrati ESC void result_skusania( int p_chyb, int p_pokusov );// zobrazi vysledok skusania int anti_ascii( char odkial[], char kam[] ); // odstrani zo suboru moju diakritiku int je_znak( char znak, int typ ); // zistuje ci danny znak je znakom // nclen = a..z, jclen = A..Z nic = a..z, A..Z, 0, 1 char *strchar( char retazec[], char znak ); // prida k retazecu znak char far * _fstrchar( char far *retazec, char znak );// pre far void strdel( char vstr[], int od ); // zmaze z urcenej pozicie znak void _fstrdel( char far *vstr, int od ); // pre far char *von_blbosti( char vstr[] ); // vyhadzuje z retazcoveho zapisu blbosti, tak aby nemal void jed_odpoved( char retazec[] ); // nedava nahodov jednoznacnu odpoved 0, alebo I // Nachadza sa vo VYSTUPY.C void hlas_chybu(int typ_op,int typ_chyby); // ohlasuje chybu programu void farba(int cback,int ccolor); // nastavi farbu podkladu, pisma void ukonc(void); // rozculi sa z uzivatelom // zapise upraveny format NDF do tmp suborov void uloz_NDF( zapis_NDF *NDFka, char ndpis[], char meno[] ); // zapis_NDF do retazca ak neaky je TRUE int NDF_do_ret( zapis_NDF *NDFka, char retazec[] ); void ukladaj_cinnost( char zariadenie[] ); // ulozi na disk, alebo tlaci na tlaciarni void suradnice( int x,int y ); // pri view okne ukazuje jeho suradnice void zob_ria( Riadok tex, int riad, int od, int kolko ); // rychlo zobrazi riadok // zobrazi okno prehliadaca int view_okno(int xl, int yl, int xp, int yp, int atr1, int atr2, int typ_o, char m_okna[] ); int zobraz_tmp ( char meno[], int iba_view ); // VIEW akehokovlek suboru v okne int zobraz_tmp0(void); // vstupna funkcia int zobraz_tmp1(void); // derivacia int zobraz_tmp2(void); // pred slovnikom poruch int zobraz_tmp3(void); // vektory poruch int zobraz_tmp4(void); // zobrazi medzivysledok pri vytvarani diferencii int zobraz_tmp5(void); // zobrazi medzivysledok pre skusanie // ulozi na disk slovnik poruch pre t0,t1 int zobraz_tmp6(void); // vektory vsetkych poruch int uloz_slovnik( char pom_f[], int premenna, zapis_NDF *h_fnc, char meno[], char subst[] ); void moje_ascii( char ret_asc[] ); // prevedie do mojej ascii sady void norm_subor( char meno[] ); // vyrovna prave okraje v subore WORDovske CTRL+J // Nachadza sa v PRAC_NDF.C int vytvor_formu(zapis_NDF *h_fnc,char skus[]); // prevedie zapis do vnutornej formy s ktorou pracujem int dalsie_NDF (zapis_NDF *h_fnc, int velkost);// vyrobi priestor pre dalsie NDF, kej velkosti bude pole 0-NDF.pv_NDF void von_adept(zapis_NDF *h_fnc); // vyhodi zo struktury vsetkych adeptov na vyhodenie void pohltenie(zapis_NDF *h_fnc); // najde take ktore sa pohlcuju napr. Abc je pohltene Ab int filter( char vstr[] ); // odfiltruje medzery, zatvorky atd. int ma_zatv ( char vstr[] ); // obsahuje danny vyraz zatvorky ??? 1-ak ano int odstran_zatvorky( char vstr[], int alge ); // zatvorky prevedie do NDF, alge=1 - vyhadzovat blbosti !!! // pozor rusi obsah prveho z nich char *nasob_NDF( char nc[], char nt[], int alge );// roznasobi dva zatvorky v NDF // Nachadza sa v DERIVAC.C int ukaz_NDF( void ); // zobrazi a upravi prvotnu NDF // pripravy derivaciu podla premennej int derivac_dF(zapis_NDF *h_fnc, int prem, zapis_NDF *K, zapis_NDF *K0, zapis_NDF *K1); char neguj( char clen ); // neguje jclen->nclen a naopak char bool_znak( char clen, int pozic ); // podla pozicie vyrobi znak a,b,c alebo A,B,C char *K_sucin( zapis_NDF *K ); // urobi sucin (ab+cd) z K char *K_negovane( zapis_NDF *K ); // zneguje cely vztah (ab+cd)=(A+B)(C+D) // to co pripravy derivac_dF on vyjadri do retazca char *zderivuj_dF( zapis_NDF *K, zapis_NDF *K0, zapis_NDF *K1 ); void ret_do_NDF(char skus[], zapis_NDF *fnc, char subor[] );// prevedie retazec do NDF int diferencie( int medzi_v ); // urobi derivacie // derivacie podla zadanej premennej int difer_podla( zapis_NDF *hp_fnc, int podla_p, char subst[], int *p_chyb, int *p_pokusov, int *a_rezim ); int slovnik_por( void ); // akoze robi slovnik poruch char odpoved_f( char v_vektor[], zapis_NDF *h_fnc );// Zisti ako by sa mala spravat funkcia ak je vsetko OK int nahrad_vetvy( char ret_f[], char subst[], zapis_NDF *subst_NDF );// substiuje podobne a nahraza ich dalsou premennou int substitucie( char subst[], char okrem ); // nahradzuje cleny substituovane skutocnymi vstupmi okrem premennej okrem int kontr_subst( char subst[], int odkial, int pokial );// najde podobne subst v strukture SUBST // hlada odkial - pokial int kolko_vetiev( char f_vstup[], int premenna ); // zistuje na kolko premennych sa deli primarny vstup // Nachadza sa v STATIST.C int statistika( void ); // statisticke udaje o vypocte void zarad_stat( char text[], int ako ); // zaradi statisticke informacie do struktury // Nachadza sa SLOVNIK.C int slovnik_por( void ); // vyrobi slovnik poruch int vsetky_vektory( void ); // vytvori vsetky vektory poruch int bool_cmp( char ret1[], char ret2[], char *pom );// porovna dva retazce boolovskou logikou X je zhodne s hoccim int uloz_slovnik( char pom_f[], int premenna, zapis_NDF *h_fnc, char meno[], char subst[] ); void uloz_vektor( char vektor[], int t_chyba, zapis_NDF *h_fnc, char meno[] ); // ulozi vektor, ak ma X zavola rekurzivne samu seba /*-------------------------------END----------------------------------------*/