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

//************************************************************************//
// OBSLUHA.C                                                              //
// Tuto su standartne rutiny pre spravu programu
//                                                             25.8.1997  //
//************************************************************************//
 
#include <math.h>
#include "mbooldif.h"
#include "line_edit.h"
#include "funkcie.h"
#include "okno.h"
#include "glob.h"
#include "video.h"
#include "menu.h"
#include "util.h"
#include "error.h"
#include "key.h"
 
//************************************************************************//
// Znuluje polozky ak nieco ostalo v premennych. Zacneme s cistim stitom  //
// aj_mem urcuje ci uvolnovat pamat                            25.8.1997  //
//************************************************************************//
 
void znuluj(zapis_NDF *NDFka, int aj_mem)
{
int i,pokial;
 
 // haus numera mozu mat zvlastny vysledok
 pokial=NDFka->poc_NDF;
 // skus tu nedat max_NDF-1 budes sa divit ako uvolni stack volania funkcii
 // a znenazdajky ukonci program
 if ( pokial>max_NDF ) pokial=max_NDF-1;
 if ( pokial<0 ) pokial=0;
 
 // Najprv to co sa patri
 for (i=0; i<=pokial; i++) {
     NDFka->adept[i] = 0;
     NDFka->t_vodic[i] = 0;
     NDFka->t_chyba[i] = 0;
     NDFka->index[i] = ' ';
     if (( NDFka->pNDF[i] != NULL) && (aj_mem) )
	   farfree( NDFka->pNDF[i] );
     if (( NDFka->pSubst[i] != NULL) && (aj_mem) )
	   farfree( NDFka->pSubst[i] );
     NDFka->pSubst[i] = NULL;
     NDFka->pNDF[i] = NULL;
    }
 
 // ostatne nastav na NULL
 for (i=pokial+1; i<max_NDF; i++) {
     NDFka->adept[i] = 0;
     NDFka->t_vodic[i] = 0;
     NDFka->t_chyba[i] = 0;
     NDFka->index[i] = ' ';
     NDFka->pNDF[i] = NULL;
     NDFka->pSubst[i] = NULL;
    }
 
 NDFka->pv_NDF=0;
 NDFka->poc_NDF=0;
 pamet();                    // ukaz ako si na tom z pametou
}
 
 
//************************************************************************//
// Zmaze znak z pozicie ktoru mu urcim                                    //
//                                                             25.8.1997  //
//************************************************************************//
 
void strdel(char vstr[], int od)
{
int x;
if( strlen( vstr ) != 0 )
  for (x=od; x<strlen(vstr); x++) vstr[x]=vstr[x+1];
}
 
 
//************************************************************************//
// Nacita z klavesnice retazec a vypocita NDF                             //
//                                                             22.9.1997  //
//************************************************************************//
 
int from_keyb( void )
{
int zx,zy;
 
 strcpy(ret_f,"");
 init_jadro();			// odznova
 znuluj(&slovnik,1);            // slovnik znulovany
 del_tmp("*.tmp");
 
 zx=_stlpcov/2-38;
 zy=_riadkov/2-2;
 otvor_okno(zx,zy,zx+76,zy+6,atributy[39],atributy[40],1);
 tlac_retazec(zx+2,zy+1,atributy[39],"Zadaj funkciu f= a-priamy z pis <shift>+a-invertovan˜ napr.(ŕbc+aáâ)");
 tlac_retazec(zx+2,zy+3,atributy[39],"f=");
 
 riadkovy_editor(zx+5,zy+3,65,max_ret-1,atributy[13],atributy[12],ret_f);
 zatvor_okno();
 return;
}
 
 
//************************************************************************//
// Zisti ci sa dva funkcie rovnaju pri preverovacom rezime                //
// POZOR vynuluje premennu adept vo fnc2                                  //
// i:funkcie v tvare NDF o:1-ok 0-nieco v neporiadku          20.10.1997  //
//************************************************************************//
 
int rovnaju_sa( zapis_NDF *fnc1, zapis_NDF *fnc2 )
{
int x,y,ok=0;
				// najprv hruby filter
 if( fnc1->poc_NDF != fnc2->poc_NDF ) return(0);
 if( fnc1->pv_NDF != fnc2->pv_NDF ) return(0);
 
 for( x=1; x<=fnc1->poc_NDF; x++ )
   for ( y=1; y<=fnc2->poc_NDF; y++ )
       if ( (strcmp( fnc1->pNDF[x],fnc2->pNDF[y] ) == 0) && ( fnc2->adept[y] == 0 ) )
	  {
	   fnc2->adept[y]=1;
	   ok++;
	  }
 
 for( x=1; x<=fnc1->poc_NDF; x++ ) fnc2->adept[y]=0;
 
 // nasiel tolko zhodnych clenov, kolko ich je v strukture
 if ( ok == fnc2->poc_NDF ) return(1);
		       else return(0);
}
 
 
//************************************************************************//
// Polozi mu otazku na spravnu odpoved a porovnava vysledky               //
// i:pocet chyb, pocet pokusov atd                             22.9.1997  //
//************************************************************************//
 
int prever_uziv( zapis_NDF *deriv_f, int *p_chyb )
{
int zx,zy;
char od_uziv[max_ret];
int escape,pp=0,i;
zapis_NDF uziv_fnc;
 
 zx=_stlpcov/2-36;
 zy=_riadkov/2;
 znuluj(&uziv_fnc,0);
 // tam a spat sa kolisem
 NDF_do_ret( deriv_f, od_uziv );
 ret_do_NDF( od_uziv, deriv_f, TmpSubor[5] );
 
 otvor_okno(zx,zy,zx+72,zy+5,atributy[39],atributy[40],1);
 tlac_retazec(zx+2,zy+1,atributy[39],"Zadaj deriv ciu, a-priamy z pis <shift>+a-invertovan˜ 1,0-logick  1,0");
 tlac_retazec(zx+2,zy+2,atributy[39],"dF/");
 tlac_retazec(zx+5,zy+2,atributy[39],index);
 tlac_retazec(zx+7,zy+2,atributy[39],"=");
 
 do {
    pp++;i=0;
    strcpy( od_uziv,"" );
    if ( riadkovy_editor(zx+9,zy+2,58,max_ret-1,atributy[13],atributy[12],od_uziv) == FALSE )
       {
	escape=ESC;
       }
      else {
        // tam a spat sa kolisem
	ret_do_NDF( od_uziv, &uziv_fnc, TmpSubor[0] );  // prelozime do nami zrozumitelnej NDF
							// ci sa aspon trochu podobaju
	if ( ((i=rovnaju_sa( deriv_f, &uziv_fnc )) == 0 ) && ( Rezim == VYUK ) )
	   chybove_okno(chyba[21]);
	}
 
    znuluj(&uziv_fnc,1);
   } while ( (i == 0) && ( Rezim == VYUK ) && ( pp < 3 ) && ( escape != ESC ) );
 
 zatvor_okno();
 if (( i==0 ) && ( Rezim == VYUK )) key();
 if (( i!=0 ) && ( Rezim == VYUK )) hlasky(chyba[22]);
 if ( i==0 ) *p_chyb=*p_chyb+1;
 
 return( escape );
}
 
 
//************************************************************************//
// Zobrazi vysledok skusania                                              //
// i:pocet pokusov, pocet chyb                                20.10.1997  //
//************************************************************************//
 
void result_skusania( int p_chyb, int p_pokusov )
{
 int zx,zy;
 char pom_r[max_ret];
 
 zx=_stlpcov/2-36;
 zy=_riadkov/2-8;
 otvor_okno(zx,zy,zx+72,zy+13,atributy[42],atributy[43],1);
 tlac_retazec(zx+4,zy+2,atributy[42],"Vyhodnotenie");
 
 sprintf(pom_r,"Po‡et v¨etk˜ch ot zok bolo      : %d", p_pokusov );
 tlac_retazec(zx+4,zy+4,atributy[42],pom_r);
 sprintf(pom_r,"Po‡et nespr vnych odpovedĄ bolo : %d", p_chyb );
 tlac_retazec(zx+4,zy+6,atributy[42],pom_r);
 sprintf(pom_r,"Po‡et spr vnych odpovedĄ bolo   : %d", p_pokusov-p_chyb );
 tlac_retazec(zx+4,zy+8,atributy[42],pom_r);
 sprintf(pom_r,"Percentu lna Łspe¨nosŸ bola     : %2.0f %", 100.0*(p_pokusov-p_chyb)/p_pokusov );
 tlac_retazec(zx+4,zy+10,atributy[42],pom_r);
 
 key();
 zatvor_okno();
}
 
 
//************************************************************************//
// Zrusi veskeru diaktitiku, ked zapisuje do suboru                       //
// i: meno suboru o:podarilo sa ? FALSE/TRUE                  22.10.1997  //
//************************************************************************//
 
int anti_ascii( char odkial[], char kam[] )	// s Prahy do Brna clovece
{
FILE *f,*g,*fopen();
unsigned char znak;    		// do i nacitavam znaky
int i;				// devka
char *diak[]={" „‡ƒ‚ĄŒ¤˘¨ŸŁ˜‘€…‹œŠĽ›†—’Źúűüýţ˙","aacdeillnostuyzACDEILLNSTUYZ~K10i+0"};
 
 if( ( g=fopen( strspoj( temp,kam) ,"wb" )) == NULL )
    {
     chybove_okno(chyba[9]);
     return (FALSE);
    }
 
 if( ( f=fopen( strspoj( temp,odkial) ,"rb" )) != NULL )
    {
    fscanf(f,"%c", &znak );
    do {
	   if ( je_znak( znak, nclen ) == TRUE )
               znak=znak - ( 'ŕ'-'A' );// znaky negacii
	   if ( znak >= 128 )
	      for ( i=0; i <= strlen( diak[0] ); i++ )	// diakriticke znaky
		  if ( znak == diak[0][i] ) znak=diak[1][i];
	   fprintf(g,"%c",znak);
 
	   fscanf(f,"%c", &znak );
	  } while ( !feof(f) );
 
    fclose(f);
   }		// if f=fopen( odkial
 
 fclose(g);
 return ( TRUE );
}
 
 
//************************************************************************//
// JE_ZNAK zistuje ci danny znak je znakom a..z, alebo A..Z               //
// i:znak ASCII o:1-je 0-nieco ine                             4.11.1997  //
//************************************************************************//
int je_znak( char znak, int typ )
{
 if ( (( znak >= 'a' ) && ( znak <= 'z' )) && ( typ == jclen ))
    return( TRUE );
 
 if ( (( znak >= 'ŕ' ) && ( znak <= 'ů' )) && ( typ == nclen ))
    return( TRUE );
 
 if ( (( znak >= 'a' ) && ( znak <= 'z' )) || (( znak >= 'ŕ' ) && ( znak <= 'ů' )) ||
       ( znak == vstup_0[0] ) || ( znak == vstup_1[0] ) )
      if ( typ == nic ) return( TRUE );
 
 return( FALSE );
}
 
//************************************************************************//
// STRCHAR prida na koniec retazca znak nieco ako strcat                  //
// i: retazec, znak o:retazec+znak                            30.10.1997  //
//************************************************************************//
char *strchar( char retazec[], char znak )
{
 strcat( retazec, " " );
 retazec[ strlen( retazec ) -1 ] = znak;
 return( retazec );
}
 
//************************************************************************//
// _FSTRCHAR prida na koniec retazca znak nieco ako strcat pre FAR        //
// i: retazec, znak o:retazec+znak                            30.10.1997  //
//************************************************************************//
char far * _fstrchar( char far *retazec, char znak )
{
 strcat( retazec, " " );
 retazec[ strlen( retazec ) -1 ] = znak;
 return( retazec );
}
 
//************************************************************************//
// Zmaze znak z pozicie ktoru mu urcim pre FAR                            //
//                                                             25.8.1997  //
//************************************************************************//
 
void _fstrdel(char far *vstr, int od)
{
int x;
for (x=od; x<strlen(vstr); x++) vstr[x]=vstr[x+1];
}
 
//************************************************************************//
// VON_BLBOSTI vyhadzuje z retazcoveho zapisu blbosti, tak aby nemal      //
// zbytocne dlhe ked aj tak potom pojdu do p...                           //
// i:retazec s nadbytocnymi o:upraveny                        30.10.1997  //
//************************************************************************//
 
char *von_blbosti( char vstr[] )
{
char vysl[ max_ret ];           // tu bude odkladat tie, ktore vyhovuju
char pom[ 256 ];                // devka retazec, takze devkos
int x,y,i;                      // devky, tri gracie
int adept;                      // urcuje ci je adept
 
 // nulujeme
 vysl[0]='\0'; pom[0]='\0';
 
 for( i=0; i <= strlen( vstr ); i++ )
    {
     if( je_znak( vstr[i], nic ) == TRUE ) {
       // ukladam NDF
       if(( pom[ strlen( pom ) -1 ] != '+') || (vstr[i] != '+' ))
            strchar( pom, vstr[i] );
       // ateraz sa uvidi !!!
       }
      else {
       // najprv von opakujuce sa, alebo I
       x=0;y=0;
       while(( x < strlen( pom ) ) && ( strlen( pom ) != 0 )) {
         y=x+1;
         while(( y < strlen( pom ) ) && ( strlen( pom ) != 0 )) {
            if( pom[x] == pom[y] ) strdel( pom, y );
                              else y++;
           }
        x++;
       }
 
       adept=0;
       // kazdy s kazdym
       for( x=0; x < strlen( pom ); x++ )
        for( y=x+1; y < strlen( pom ); y++ )
         if(( ( pom[x]-pom[y] ) == ( 'a'-224 ) ) ||
            ( ( pom[y]-pom[x] ) == ( 'a'-224 ) ) ||
              ( pom[x] == vstup_0[0] ) || ( pom[y] == vstup_0[0] ))
               adept=1;   // mas po vtakoch
       // tak toto beriem
       if(( adept == 0 ) && ( strlen( pom ) != 0 )) {
         strcat( vysl, pom );
         strchar( vysl, vstr[i] );
        }         // end if(adept==0)
 
      pom[0]='\0';
     }            // end else
   }
 
 while(( vysl[ strlen( vysl ) -1 ] == '+' ) && ( strlen( vysl ) != 0 ))
     strdel( vysl, strlen( vysl ) -1 );
 
 // dame do pamete, ktora ostane, pretoze odchod z funkcie
 // odalokuje lokalky HA-HA to si nevedel co ??? ty nahodny citatel
 // to mu predsa nemozeme urobit
 if(( strlen( vysl ) == 0 ) && ( strlen( vstr ) != 0 ))
     strcpy( vstr, vstup_0 );
    else strcpy( vstr, vysl );
 
 return( vstr );
}
 
 
//************************************************************************//
// JED_ODPOVED nedava nahodou jednoznacnu odpoved 0, alebo I              //
// i:retazec o:bud ten isty, alebo 0,I ak je jed. odpoved     28.11.1997  //
//************************************************************************//
void jed_odpoved( char retazec[] )
{
int x,y,i;      // devky
int poc_p=0;    // kolko vstupov je ???
int pom_poc=0;
char pom_f[ max_ret ], pomoc[ max_ret ];
unsigned int vyst;
char doteraz=' ';   // aky bol doteraz vstup
 
 // lahodka, mame po vtakoch
 if( strlen( pom_f ) == 0 ) return;
 // odpamatame
 strcpy( pomoc, retazec );
 filter( pomoc );
 odstran_zatvorky( pomoc, 1 );
 strcpy( pom_f, pomoc );
 // zistime kolko premennych potrebujeme
 for( x=0; x <= strlen( pom_f ); x++ )
    {// znulujeme
     pom_poc=0;
     if( je_znak( pom_f[x], jclen ) == TRUE ) pom_poc = pom_f[x] - 'a' +1 ;
     if( je_znak( pom_f[x], nclen ) == TRUE ) pom_poc = pom_f[x] - 'ŕ' +1 ;
     if( pom_poc > poc_p ) poc_p=pom_poc;
    }
 
 pom_poc=1;
 for( i=0; i < poc_p; i++ ) pom_poc=pom_poc*2;
 poc_p=pom_poc;
 // teraz budem doplnat bity ako maju byt
 for( y=0; y < poc_p ; y++ ) {
    for( x=0; x < strlen( pom_f ); x++ )
       {// ideme zistovat jednotlive bity
        vyst=y;
        // je znak nenegovany
        if( je_znak( pom_f[x], jclen ) == TRUE )
           {
            pom_poc=1;
            for( i=0; i<( pom_f[x] - 'a' ); i++ ) pom_poc=pom_poc*2;
            if(( vyst & pom_poc ) != 0 ) pom_f[x] = vstup_1[0];
                                    else pom_f[x] = vstup_0[0];
           }
 
        // je negovany znak
        if( je_znak( pom_f[x], nclen ) == TRUE )
           {
            pom_poc=1;
            for( i=0; i<( pom_f[x] - 'ŕ' ); i++ ) pom_poc=pom_poc*2;
            if(( vyst & pom_poc ) != 0 ) pom_f[x] = vstup_0[0];
                                    else pom_f[x] = vstup_1[0];
           }
        }
        von_blbosti( pom_f );
        if(( strlen( pom_f ) == 1 ) &&
           (( doteraz == ' ' ) || (doteraz == pom_f[0] ))) doteraz=pom_f[0];
           else return;
        // nevyskytuje sa tam nieco ine ako doteraz ???
        if(( doteraz == vstup_0[0] ) && ( strpbrk( pom_f, vstup_1 ) > 0 ))
             return;
        if(( doteraz == vstup_1[0] ) && ( strpbrk( pom_f, vstup_0 ) > 0 ))
             return;
 
        strcpy( pom_f, pomoc );
       }
 
 if(( doteraz == vstup_1[0] ) || ( doteraz == vstup_0[0] )) {
      retazec[0]='\0';
      strchar( retazec, doteraz );
     }
}
 
/*---------------------------------END--------------------------------------*/