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.c,  Booldif.zip
File exe: Booldif.exe
need: Adresar.c,  Color.c,  Derivac.c,  Error.c,  Funkcie.c,  Help.c,  Key.c,  Line_edi.c,  Main.c,  Menu.c,  Obsluha.c,  Okno.c,  Prac_ndf.c,  Slovnik.c,  Slov_fon.c,  Statist.c,  Util.c,  Video.c,  Vystupy.c,  Adresar.h,  Color.h,  Define.h,  Error.h,  Funkcie.h,  Glob.h,  Key.h,  Line_edi.h,  Mbooldif.h,  Menu.h,  Okno.h,  Slov_fon.h,  Util.h,  Video.h
Example: Example.zip,  Bin_10_o.ndf,  Bin_10_o.ndf,  Bin_1and.ndf,  Bin_2rad.ndf,  Bin_3rad.ndf,  Bin_4rad.ndf,  Hard.ndf,  I_reg_lo.ndf,  Reg_jk.ndf,  Scitac_s.ndf,  Scp_1rad.ndf,  Scp_2rad.ndf,  Scp_2r_1.ndf,  Scp_3rad.ndf,  Scp_4r_2.ndf,  Scp_6r_3.ndf,  Scp_8r_4.ndf,  Sc_1r_pj.ndf,  Sc_1r_sj.ndf,  Sc_1_aoi.ndf,  Sc_2r_4.ndf,  Sc_3r_6.ndf,  Sc_7400n.ndf,  Sc_aon.ndf,  Simp3_a.ndf,  Simp3_b.ndf,  Simp4_a.ndf,  Simp4_b.ndf,  Simp4_c.ndf,  Simp6_a.ndf,  Test_vod.ndf,  Zle.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. 
//************************************************************************//
// SLOVNIK.C                                                              //
// Vsetky vypoctove operacie nad slovnikmi                                //
//                                                            12.11.1997  //
//************************************************************************//
 
#include "mbooldif.h"
#include "glob.h"
#include "okno.h"
#include "key.h"
#include "util.h"
#include "video.h"
#include "menu.h"
#include "error.h"
 
//************************************************************************//
// SLOVNIK_POR vytvori slovnik poruch                                     //
//                                                            12.11.1997  //
//************************************************************************//
 
int slovnik_por( void )
{
int zx,zy;
int x,y;                 // devky
int sv;                  // sirka vstupu pre text
char tsv[256];           // prazdny text
char pom[ max_ret ];     // pomocna devka
char ind_prem[ 3 ];      // bude nazov premennej a jej index
char last_p[3];          // ci som uz raz vypisal chyba na a0 atd..
zapis_NDF my_slov;       // moj slovnik, pretoze znicim strukturu
FILE *tmp,*fopen();      // ulozi slovnik
 
 znuluj( &my_slov, 0 );   // najprv nastavime NULL
 min_mem=0;
 
 if(( slovnik.pv_NDF == 0 ) && ( slovnik.poc_NDF == 0 )) {
     chybove_okno( chyba[20] );
     return(0);
    }
 
 zx=_stlpcov/2-20;
 zy=_riadkov/2-3;
 if( view_okno(zx,zy,zx+40,zy+5,atributy[20],atributy[21],2,"")==FALSE) {
   chybove_okno( chyba[1] );
   return(0);
   }
 
 tlac_retazec(zx+4,zy+2,atributy[20]," Vytv ram diagnostick‚ pokrytia ");
 
 // dame do statistickych udajov
 zarad_stat( "Diagnostick‚ pokrytie",0 );
 
 // pocet premennych je ten isty
 my_slov.pv_NDF = slovnik.pv_NDF;
 // odkopirujeme
 for( x=1; x <= slovnik.poc_NDF; x++ ) {
     dalsie_NDF( &my_slov, 0 );
     // dobre strcpy co ???
     for( y=0; y< strlen( slovnik.pNDF[x] ); y++ )
         my_slov.pNDF[x][y] = slovnik.pNDF[x][y];
     my_slov.t_chyba[x] = slovnik.t_chyba[x];
     my_slov.t_vodic[x] = slovnik.t_vodic[x];
     my_slov.index[x] = slovnik.index[x];
     my_slov.adept[x]=0;
    }
 
 // dame do statistickych udajov
 zarad_stat( "",1 );
 // dame do statistickych udajov
 
 zarad_stat( "Pokr˜vaj£ce sa vektory",0 );
 
 // zistujem cleny, ktore sa pohlcuju
 for( x=1; x <= my_slov.poc_NDF; x++ )
    if( my_slov.adept[x] == 0 )
        for( y=x+1; y <= my_slov.poc_NDF; y++ )
           // podobaju sa a clen je volny ???
           if(( bool_cmp( my_slov.pNDF[x], my_slov.pNDF[y], pom ) == 0 ) &&
              ( my_slov.adept[y] == 0 )){
              my_slov.adept[y]=1;
              strcpy( my_slov.pNDF[x], pom );   // nech X nahradi ak su take
             }
 
 pamet();
 // dame do statistickych udajov
 zarad_stat( "",1 );
 
 // ideme zapisovat do suboru
 tmp=fopen( strspoj( temp,TmpSubor[2] ) ,"w+t" );// tmp subor SLOVNIK.TMP
 if ( tmp == NULL ) {
    chybove_okno(chyba[17]);		// disk chraneny proti zapisu, alebo tak neako
    return( FALSE );
   }
 
 // znulujeme
 last_p[0]=' '; last_p[1]=' '; last_p[2]=' ';
 
 fprintf(tmp,"\n Diagnostick‚ pokrytia  \n\n");
 // aka bude sirka pre vstup ???
 if( my_slov.pv_NDF > 5 ) sv = my_slov.pv_NDF;
                     else sv = 5;
 
 tsv[0]='\0';
 for( x = my_slov.pv_NDF; x<=sv; x++ ) strchar( tsv, ' ' );
 
 fprintf(tmp," ÚÄÄÄÄÄÄ");for( y=5; y<sv; y++ ) fprintf(tmp,"Ä");fprintf(tmp,"ÄÂÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄ¿\n");
 fprintf(tmp," ³ Vstup");for( y=5; y<sv; y++ ) fprintf(tmp," ");fprintf(tmp," ³ V˜stup ³ Pokrytie ³\n",tsv);
 fprintf(tmp," ÃÄÄÄÄÄÄ");for( y=5; y<sv; y++ ) fprintf(tmp,"Ä");fprintf(tmp,"ÄÅÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄ´\n");
 
 for( x=1; x <= my_slov.poc_NDF; x++ )
    if( my_slov.adept[x] == 0 ) {
      // vypisem aky vektor
      strcpy( pom, my_slov.pNDF[x] );
      strdel( pom, strlen( pom ) -1 );
      // ze som vypisal a0 atd ...
      last_p[0] = my_slov.t_vodic[x];
      last_p[1] = my_slov.t_chyba[x];
      last_p[2] = my_slov.index[x];
      // bude nazov premennej a jej index
      ind_prem[0]='\0';
      strchar( ind_prem, my_slov.t_vodic[x] );
      if( my_slov.index[x] != ' ' ) strchar( ind_prem, my_slov.index[x] );
 
      fprintf( tmp," ³ %s%s ³   %c    ³ %s\\%d ", pom, tsv, my_slov.pNDF[x][ strlen( my_slov.pNDF[x] ) -1 ],
                   ind_prem, my_slov.t_chyba[x] );
 
         for( y=x+1; y <= my_slov.poc_NDF; y++ )
           // ak sa podobaju vypisem
           if( bool_cmp( my_slov.pNDF[x], my_slov.pNDF[y], pom ) == 0 ) {
                // vypisem len vtedy ak som uz raz nevypisal
                if(( last_p[0] != my_slov.t_vodic[y] ) ||
                   ( last_p[1] != my_slov.t_chyba[y] ) ||
                   ( last_p[2] != my_slov.index[y] )) {
                   // bude nazov premennej a jej index
                   ind_prem[0]='\0';
                   strchar( ind_prem, my_slov.t_vodic[y] );
                   if( my_slov.index[y] != ' ' ) strchar( ind_prem, my_slov.index[y] );
                   // tak a toto zapiseme
                   fprintf( tmp,"%s\\%d ", ind_prem, my_slov.t_chyba[y] );
                  }
 
                last_p[0] = my_slov.t_vodic[y];
                last_p[1] = my_slov.t_chyba[y];
                last_p[2] = my_slov.index[y];
               }
      // uzavrieme zatvorkami
      fprintf( tmp,"³\n" );
     }
 
 fprintf(tmp," ÀÄÄÄÄÄÄ");for( y=5; y<sv; y++ ) fprintf(tmp,"Ä");fprintf(tmp,"ÄÁÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÙ\n");
 fclose(tmp);
 // uprav aby nemal ulatene sirky riadkov
 norm_subor( TmpSubor[2] );
 // koncime
 
 // ak je DEMO tak zobrazuj
 if ( Rezim == DEMO ) zobraz_tmp2();
 
 // ulozi do vystupneho suboru
 if ( Vystup == TLC ) {                 // ak tlaciaren
     anti_ascii( TmpSubor[2] , TmpSubor[5] );
     sprintf( pom,"type %s%s > prn", temp, TmpSubor[5] );
     system( pom );
    }
 
 if ( Vystup == SUB ) {                 // ak ukladat do suboru
     anti_ascii( TmpSubor[2], TmpSubor[5] );
     sprintf( pom,"if exist %s%s type %s%s >> %s", temp, TmpSubor[5], temp, TmpSubor[5], TmpSubor[4] );
     system( pom );
    }
 
 zatvor_okno();
 hlasky(chyba[24]);
 
 return(0);
}
 
//************************************************************************//
// VSETKY_VEKTORY vytvori vsetky vektory poruch                           //
//                                                            12.11.1997  //
//************************************************************************//
 
int vsetky_vektory( void )
{
int zx,zy;
int x;                   // devka
char pom[ max_ret ];     // pomocna devka
char last_p[2];          // ci som uz raz vypisal chyba na a0 atd..
FILE *tmp,*fopen();      // ulozi slovnik
 
 if(( slovnik.pv_NDF == 0 ) && ( slovnik.poc_NDF == 0 )) {
     chybove_okno( chyba[20] );
     return(0);
    }
 
 zx=_stlpcov/2-20;
 zy=_riadkov/2-3;
 if( view_okno(zx,zy,zx+40,zy+5,atributy[20],atributy[21],2," €innosŸ ")==FALSE) {
   chybove_okno( chyba[1] );
   return(0);
   }
 
 tlac_retazec(zx+1,zy+2,atributy[20]," Vytv ram zoznam v¨etk˜ch vektorov por£ch ");
 
 // ideme zapisovat do suboru
 tmp=fopen( strspoj( temp,TmpSubor[6] ) ,"w+t" );// tmp subor SLOV_VSE.TMP
 if ( tmp == NULL ) {
    chybove_okno(chyba[17]);		// disk chraneny proti zapisu, alebo tak neako
    return( FALSE );
   }
 
 // znulujeme
 last_p[0]=' '; last_p[1]=' '; last_p[2]='\0';
 
 fprintf(tmp,"\n Zoznam krokov testu \n");
 for( x=1; x <= slovnik.poc_NDF; x++ ) {
      // vypisem aky vektor
      strcpy( pom, slovnik.pNDF[x] );
      strdel( pom, strlen( pom ) -1 );
 
      // vypisem len vtedy ak som este nevypisal
      if(( last_p[0] != slovnik.t_vodic[x] ) ||
         ( last_p[1] != slovnik.t_chyba[x] ))
         fprintf( tmp,"\n %c%c\\%d : ( %s ):%c ", slovnik.t_vodic[x], slovnik.index[x], slovnik.t_chyba[x],
                  pom, slovnik.pNDF[x][ strlen( slovnik.pNDF[x] ) -1 ] );
        else // inac zavinac
         fprintf( tmp," ( %s ):%c ", pom, slovnik.pNDF[x][ strlen( slovnik.pNDF[x] ) -1 ] );
 
      // koncim riadok ???
      if( slovnik.t_chyba[x] == slovnik.t_chyba[x+1] ) fprintf( tmp,"," );
 
      // koncim riadok pre vodic ???
      if( slovnik.t_vodic[x] != slovnik.t_vodic[x+1] ) fprintf( tmp,"\n" );
 
      // ze som vypisal a0 atd ...
      last_p[0] = slovnik.t_vodic[x];
      last_p[1] = slovnik.t_chyba[x];
     }
 
 fclose(tmp);
 zatvor_okno();
 zobraz_tmp6();
 
 // ulozi do vystupneho suboru
 if ( Vystup == TLC ) {                 // ak tlaciaren
     anti_ascii( TmpSubor[2] , TmpSubor[5] );
     sprintf( pom,"type %s%s > prn", temp, TmpSubor[5] );
     system( pom );
    }
 
 if ( Vystup == SUB ) {                 // ak ukladat do suboru
     anti_ascii( TmpSubor[2], TmpSubor[5] );
     sprintf( pom,"if exist %s%s type %s%s >> %s", temp, TmpSubor[5], temp, TmpSubor[5], TmpSubor[4] );
     system( pom );
    }
 
 return(0);
}
 
 
//************************************************************************//
// BOOL_CMP porovna dva retazce boolovskou logikou X je zhodne s hoccim   //
// i:ret1,ret2 o:0-OK                                         12.11.1997  //
//                                      Toto uz je zbytocnost  2.12.1997  //
//************************************************************************//
 
int bool_cmp( char ret1[], char ret2[], char *pom )
{
int i;                    // devka
int resl=0;               // result 0=zhodne 1=nezhodne
 
 pom[0]='\0';             // znulujeme
 for( i=0; i <= strlen( ret1 ); i++ ) {
     // ak je X daj clen, ktory bol v ret2   XI0X+IIX0=II00
     if( ret1[i] == vstup_x[0] ) strchar( pom, ret2[i] );
                            else strchar( pom, ret1[i] );
     // ak je X je to jedno
     if(( ret1[i] != vstup_x[0] ) && (ret2[i] != vstup_x[0] ))
        if( ret1[i] != ret2[i] ) resl=1;
    }
 
 return( resl );
}
 
 
//************************************************************************//
// Z boolovskej diferencie vyrobi slovnik poruch v tvare 00I0             //
// !!! Pozor !!! nech je vzdy naplnena zac_subst                          //
// o:FALSE nieco nieje v poriadku                              8.10.1997  //
//************************************************************************//
int uloz_slovnik( char pom_f[], int premenna, zapis_NDF *h_fnc, char meno[], char subst[] )
{
FILE *tmp,*fopen();
int x,y;				// dalsie devky premenne
int len_NDF,t_chyba;                    // len tolko premennych z NDF zobraz, pre chybu 0,1
char pom[ max_ret ], vys_pom[ max_ret ];// pomocne
char p_sub[ max_ret ];                  // dalsia pomocna
char p_vodic[3];                        // vypisuj, ale pravdu
zapis_NDF NDFko;                        // pomocne v zmysle (aby si vedel ze sa s tebou poje... )
char v_vektor[max_NDF];			// uchovava vstupny vektor pre zistenie
					// aku odozvu ma na funkciu
 
 tmp=fopen( strspoj( temp,meno) ,"a+t" );// tmp subor SLOVNIK.TMP
 if ( tmp == NULL ) {
    chybove_okno(chyba[17]);		// disk chraneny proti zapisu, alebo tak neako
    return( FALSE );
   }
 fprintf(tmp,"\n");
 fclose(tmp);
 
 znuluj( &NDFko, 0 );
 // odkopirujeme aby sa nevratil s neakou somarinou naspat
 strcpy( p_sub, subst );
 
 for( t_chyba=0; t_chyba<=1; t_chyba++ ) {     // pre chybu 0,1
  // otvor tmp subor SLOVNIK.TMP
  tmp=fopen( strspoj( temp,meno) ,"a+t" );
 
  p_vodic[0]='\0';
  strchar( p_vodic, index[0] );
 
  // toto bol substituovany vodic ???
  if(( index[1] != ' ' ) && ( t_chyba == 0 ))
     fprintf(tmp,"\n subst( %s=%s ) ", index, p_sub);
 
  if( index[1] == ' ' ) fprintf(tmp,"\n %c\\%d : ", index[0], t_chyba);
                   else fprintf(tmp,"\n %s\\%d : ", index, t_chyba);
 
   if( strlen( p_sub ) < 1 ) {
    p_sub[1]='\0';
    strchar( p_sub, 'a'+premenna ); // nasobit budeme tymto znakom
   }
 
 if( strlen( pom_f ) > 0 ) {
     if( t_chyba == 1 ) {                       // v tom pripade znegujeme
         vytvor_formu( &NDFko, p_sub );
         strcpy( p_sub, K_negovane( &NDFko ) );
        }
     sprintf( vys_pom,"(%s)(%s)", pom_f, p_sub );// pridam nasobenie clenom
     substitucie( vys_pom, ' ' );                // vyluc substitucie
     ret_do_NDF( vys_pom, &NDFko, TmpSubor[5] ); // spat do NDF zapisu
    }
 
 fclose(tmp);
 // zobraz len tolko clenov
 if( (&NDFko)->pv_NDF > (zac_subst-1) ) len_NDF = zac_subst-1;
                                   else len_NDF = (&NDFko)->pv_NDF;
 
 for ( x=1; x<= (&NDFko)->poc_NDF; x++ ) {	     // ideme cyklus
     strcpy( v_vektor,"" );
     for ( y=0; y<len_NDF; y++ ) {
	 if ( (&NDFko)->pNDF[x][y] == jclen ) strcat( v_vektor,vstup_1 );	// "I"
	 if ( (&NDFko)->pNDF[x][y] == nclen ) strcat( v_vektor,vstup_0 );	// "0"
	 if ( (&NDFko)->pNDF[x][y] == nic   ) strcat( v_vektor,vstup_x );	// "x"
	 }
     // aby bol vyplneny cely vstup
     for ( y=len_NDF; y<zac_subst-1; y++ )
     	 strcat( v_vektor,vstup_x );		// "X"
 
     uloz_vektor( v_vektor, t_chyba, h_fnc, meno );
    } // end for ( x=1; x<=NDFko->poc_NDF; x++ )
 
  // nema ziaden slovnik
  if( (&NDFko)->poc_NDF < 1 ) uloz_vektor( "", t_chyba, h_fnc, meno );
 } // end for( t_chyba=0; t_chyba<=1; t_chyba++ )
 
 znuluj( &NDFko,1 );
 
 // ulozi do vystupneho suboru
 if ( Vystup == TLC ) {                 // ak tlaciaren
     anti_ascii( meno, TmpSubor[5] );
     sprintf( pom,"type %s%s > prn", temp, TmpSubor[5] );
     system( pom );
    }
 
 if ( Vystup == SUB ) {                 // ak ukladat do suboru
     anti_ascii( meno, TmpSubor[5] );
     sprintf( pom,"if exist %s%s type %s%s >> %s", temp, TmpSubor[5], temp, TmpSubor[5], TmpSubor[4] );
     system( pom );
    }
 
 return( FALSE );
}
 
//************************************************************************//
// ULOZ_VEKTOR ulozi vektor, ak ma X zavola rekurzivne samu seba          //
// i:vektor, NDFko, funkcia o:                                 2.12.1997  //
//************************************************************************//
void uloz_vektor( char vektor[], int t_chyba, zapis_NDF *h_fnc, char meno[] )
{
FILE *tmp,*fopen();
char odpoved;                           // odpoved funkcie
int i;                                  // devka
 
 // ak obsahuje X zavola samu seba
 if( strchr(vektor, vstup_x[0]) > 0 ) {
     i=0;
     while( ( vektor[i] != vstup_x[0]) && ( i < strlen( vektor ) )) i++;
     // nahrad 0 a podme este raz
     vektor[i] = vstup_0[0];
     uloz_vektor( vektor, t_chyba, h_fnc, meno );
     // nahrad 1 a podme este raz
     vektor[i] = vstup_1[0];
     uloz_vektor( vektor, t_chyba, h_fnc, meno );
     // uz sa o to postarali rekurzie mna to nezaujima
     return;
    }
 
 tmp=fopen( strspoj( temp,meno) ,"a+t" );// tmp subor SLOVNIK.TMP
 if ( tmp == NULL ) {
    chybove_okno(chyba[17]);		// disk chraneny proti zapisu, alebo tak neako
    return;
   }
 
 if( strlen( vektor ) == 0 ) {   // nema ziaden slovnik
    fprintf( tmp, "%s", ziaden );
    fclose(tmp);
    return;
   }
 
 odpoved = odpoved_f( vektor,h_fnc );
 fprintf( tmp, "( %s ):%c ", vektor, odpoved );
 
 dalsie_NDF( &slovnik,0 );             // ulozim slovnik poruch, vektor+odpoved->NDFko
 
 slovnik.t_vodic[ slovnik.poc_NDF ] = index[0];     // t_vodic vzhladom na aku premennu
 slovnik.t_chyba[ slovnik.poc_NDF ] = t_chyba;      // t_chyba aku chybu detekujem
 slovnik.index[ slovnik.poc_NDF ] = index[1];       // aky index ma tato premenna ak bola
                                                        // vetviacim sa vodicom
 for( i=0; i<slovnik.pv_NDF-1; i++ )		        // tu v_vektor
     slovnik.pNDF[ slovnik.poc_NDF ][i] = vektor[i];
 slovnik.pNDF[ slovnik.poc_NDF ][ slovnik.pv_NDF-1 ] = odpoved;// posledny je vystup z f()
 
 fclose(tmp);
}
 
/*---------------------------------END--------------------------------------*/