This thesis contains program coding module for generation logics test by Boolean gap

//************************************************************************//
// 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 <stdio.h>
#include <conio.h>
#include <stdio.h>
#include <string.h>
#include <bios.h>
#include <alloc.h>
#include <dos.h>
 
// 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----------------------------------------*/