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

Delphi & Pascal (česká wiki)
Přejít na: navigace, hledání
Category: Programs in C, C++

Program: Prac_ndf.cBooldif.zip
File exe: Booldif.exe
need: Adresar.cColor.cDerivac.cError.cFunkcie.cHelp.cKey.cLine_edi.cMain.cMenu.cObsluha.cOkno.cPrac_ndf.cSlovnik.cSlov_fon.cStatist.cUtil.cVideo.cVystupy.cAdresar.hColor.hDefine.hError.hFunkcie.hGlob.hKey.hLine_edi.hMbooldif.hMenu.hOkno.hSlov_fon.hUtil.hVideo.h
Example: Example.zipBin_10_o.ndfBin_10_o.ndfBin_1and.ndfBin_2rad.ndfBin_3rad.ndfBin_4rad.ndfHard.ndfI_reg_lo.ndfReg_jk.ndfScitac_s.ndfScp_1rad.ndfScp_2rad.ndfScp_2r_1.ndfScp_3rad.ndfScp_4r_2.ndfScp_6r_3.ndfScp_8r_4.ndfSc_1r_pj.ndfSc_1r_sj.ndfSc_1_aoi.ndfSc_2r_4.ndfSc_3r_6.ndfSc_7400n.ndfSc_aon.ndfSimp3_a.ndfSimp3_b.ndfSimp4_a.ndfSimp4_b.ndfSimp4_c.ndfSimp6_a.ndfTest_vod.ndfZle.ndf
Manual: Prirucky.zip

This thesis contains program coding module for generation logics test by Boolean gap. Compile vector of fault for existent circuit, forth about all boughs herself chauffeur. Results is absolute gauge. Program application enables four modes It is implemented in the C programming language for the operating system MS-DOS, or another compatible with it. The program is suitable for an interactive way to communicate with the user, allowing a comfortable working environment are similar to Turbo Vision.
//************************************************************************//
// 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--------------------------------------*/