Delphi & Pascal (Ŕeskß wiki)
P°ejÝt na: navigace, hledßnÝ
//************************************************************************//
// 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--------------------------------------*/