Program rieši problém generovania testov prostredníctvom Boolovskej diferencie

Delphi & Pascal (česká wiki)
Přejít na: navigace, hledání
Kategórie: Programy v C, C++

Program: Prac_ndf.c,  Booldif.zip
Soubor exe: Booldif.exe
Potřebné: 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
Příklady: 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

Program rieši problém generovania testov prostredníctvom Boolovskej diferencie. Riešenie vyplýva z metódy matematicej derivácie logických zápisov funkcie v tvare Boolovského zápisu. Vytvára vektory porúch pre daný obvod, pričom zohľadňuje všetky vetviace sa vodiče. Výsledkom je úplný test.
Je implementovaný v programovacom jazyku C pre operačný systém MS-DOS, alebo iný s ním kompatibilným. Program je vhodný pre interaktívny spôsob komunikácie s užívateľom, čo umožňuje pohodlné pracovné prostredie podobné systémom Turbo Vision.

Ako príklad skúste nasledovné.
  • Menu->Voľby->Vstup->Zo Súboru. Vyberte si niektorý z ukážkových súborov.
  • Menu->Činnosť->Boolovské diferencie->Primárne vodiče
  • Menu->Činnosť->Boolovské diferencie->Vnútorné vodiče
  • Menu->Výsledky - môžete si pozrieť výsledky práce programu


POZNÁMKA: Zdrojové kódy ktoré simulujú prostredie Turbo Vision niesu dielom autora. 
/*****************************************************************************
*						       		             *
*                             Subor ADRESAR.C                                *
*									     *
*****************************************************************************/
 
#include <dir.h>
#include <alloc.h>
#include <errno.h>
#include <dos.h>
#include <string.h>
#include <ctype.h>
 
#include "key.h"
#include "glob.h"
#include "menu.h"
#include "video.h"
#include "okno.h"
#include "line_edi.h"
#include "error.h"
#include "util.h"
#include "adresar.h"
 
 
//************************************************************************//
// CITAJ_MENO_SUBORU				  		          //
// i:meno, typ citania o:meno                                 30.10.1997  //
//************************************************************************//
 
int citaj_meno_suboru(char *meno, int citanie)
 
{
   int zx;
   int zy;
   char pom[256];
   int koniec=-1;
   strcpy(pom,meno);
 
   zx=_stlpcov/2-24;
   zy=_riadkov/2-10;
   if(otvor_okno(zx,zy,zx+48,zy+20,atributy[10],atributy[11],3)==FALSE)
      return FALSE;
   tlac_riadok_help(" ~F1 Pomoc ł ~Tab Adres r->SŁbor ~Enter V˜ber",atributy[4],atributy[5]);
   if (citanie) tlac_retazec(zx+16,zy,atributy[11]," €Ątaj sŁbor ");
	   else tlac_retazec(zx+16,zy,atributy[11]," ZapĄ¨ sŁbor ");
   tlac_retazec(zx+2,zy+18,atributy[14],   "                                            ");
   tlac_retazec(zx+2,zy+2,atributy[12],    "                                            ");
   tlac_retazec(zx+2,zy+1,atributy[10],    "SŁbor");
   tlac_retazec(zx+2,zy+4,atributy[10],   "Adres r");
   tlac_retazec(zx+2,zy+17,atributy[10],   "Cesta");
   zobraz_aktualny_adresar(zx,zy,meno);
   riadkovy_editor(zx+2,zy+2,43,80,atributy[13],atributy[12],pom);
   koniec=FALSE;
 
   if ( strchr(pom,'*')  || strchr(meno,'?') )	// ak je hviezdickova konvencia pokracuj
      {
      while (koniec==FALSE)
	    switch(adresar(zx,zy,pom,meno))
	     {
	      case TRUE:  koniec=TRUE;
			  break;
	      case FALSE: koniec=riadkovy_editor(zx+2,zy+2,43,80,atributy[13],atributy[12],pom);
			  break;
	      case ESC:   koniec=FALSE;
                          zatvor_okno();
                          return koniec;
			  break;
	     }
       }
     else			// k if (citanie
      {
       koniec=TRUE;
       strcpy( meno,pom );
      }
 
   zatvor_okno();
   return koniec;
}
 
 
 
//************************************************************************//
// ADRESAR zobrazi adresarovu strukturu                                   //
//                                                            30.10.1997  //
//************************************************************************//
 
int adresar(int zx,int zy,char *path,char *plne_meno)
 
 {
   char cesta[80];
   char meno[80];
   char *p;
   struct Adresar *adresar;
   int pocet_riadkov;
   int zaciatocny;
   int aktualny;
   register int i=0;
   int kl;
   int posun;
   int zmena_katalogu;
 
 
   adresar=farmalloc( 512 * sizeof(struct Adresar));
   pamet();
   if(adresar == NULL)
   	{
        error(3);
        return FALSE;
        }
   switch(kontroluj_path(path,cesta,meno))
	 {
	 case 4:chybove_okno(chyba[0]);
		chyba_hard=0;
 		farfree(adresar);
                pamet();
		return FALSE;
	 case 3:chybove_okno(chyba[3]);
 		farfree(adresar);
                pamet();
		return FALSE;
	 case 2:chybove_okno(chyba[6]);
 		farfree(adresar);
                pamet();
		return FALSE;
	 case 1:strcpy(plne_meno,cesta);
		strcat(plne_meno,meno);
 		farfree(adresar);
                pamet();
		return TRUE;
	 }
   while(1)
      {
      zmena_katalogu=0;
      posun=1;
      aktualny=0;
      zaciatocny=0;
      if(strlen(cesta)>44)
	 {
	 tlac_retazec(zx+2,zy+18,atributy[14],&cesta[strlen(cesta)-45]);
	 tlac_znak(zx+2,zy+18,atributy[14],17);
	 }
      else
	 {
	 tlac_retazec(zx+2,zy+18,atributy[14],cesta);
	 for(i=strlen(cesta);i<44;i++)
	    tlac_znak(zx+2+i,zy+18,atributy[14],' ');
	 }
      if((pocet_riadkov=vypln_adresar(meno,cesta,adresar))!=0)
	 {
	 while(!zmena_katalogu)
	    {
	    if(posun==1)
	       {
	       tlac_adresar(zx,zy,zaciatocny,pocet_riadkov,adresar);
	       posun=0;
	       }
	    obdlznik(zx,zy,aktualny,atributy[16]);
	    kl=key();
	    obdlznik(zx,zy,aktualny,atributy[15]);
	    switch(kl)
	       {
	       case ESC:
 			farfree(adresar);
                        pamet();
	       		return ESC;
	       case TAB:
 			farfree(adresar);
                        pamet();
	       		return FALSE;
	       case ENTER:if(adresar[zaciatocny+aktualny].meno[0]=='.')
			     {
			     i=strlen(cesta)-2;
			     while(cesta[i]!='\\')i--;
			     cesta[i+1]='\0';
			     zmena_katalogu=1;
			     }
			  else
			     if(adresar[zaciatocny+aktualny].typ==DIRECTORY)
				{
				strcat(cesta,adresar[zaciatocny+aktualny].meno);
				p=&cesta[strlen(cesta)-1];
				while(*p==' ')p--;
				p++;
				*p++='\\';
				*p='\0';
				zmena_katalogu=1;
				}
			     else
				{
				strcpy(plne_meno,cesta);
				strcat(plne_meno,adresar[zaciatocny+aktualny].meno);
				strcat(plne_meno,".");
				strcat(plne_meno,adresar[zaciatocny+aktualny].konc);
	 			farfree(adresar);
                                pamet();
				return TRUE;
				}
			  strcpy(path,cesta);
			  strcat(path,meno);
			  break;
	       case UP:if(--aktualny<0)
			  if(zaciatocny!=0)
			     {
			     aktualny=10;
			     if(zaciatocny>11)zaciatocny-=11;
			     else zaciatocny=0;
			     posun=1;
			     }
			  else aktualny++;
			  break;
	       case DOWN:if(++aktualny>=33)
			    if(aktualny+zaciatocny<pocet_riadkov)
			       {
			       aktualny=22;
			       zaciatocny+=11;
			       posun=1;
			       }
			    else aktualny--;
			 else if(aktualny+zaciatocny>=pocet_riadkov)aktualny--;
			 break;
	       case LEFT:if(aktualny>10)aktualny-=11;break;
	       case RIGHT:if(aktualny<22 && zaciatocny+aktualny+11<pocet_riadkov)aktualny+=11;break;
	       case HOME:aktualny=0;break;
	       case END:aktualny=32;
			   if(zaciatocny+aktualny>=pocet_riadkov)
			      aktualny=pocet_riadkov-zaciatocny-1;
			break;
	       }
	    }
	 }
      }
 }
 
 
 
//************************************************************************//
// ZOBRAZ_AKTUALNY_ADRESAR zobrazi aktualny adresar                       //
//                                                            30.10.1997  //
//************************************************************************//
 
void zobraz_aktualny_adresar(int zx,int zy,char *meno)
 
{
   char cesta[256];
   char pom[256];
   struct Adresar *adresar;
   register int i=0;
 
   adresar=farmalloc(512 * sizeof(struct Adresar));
   pamet();
   if(adresar == NULL)
   	{
        error(3);
        return;
        }
   for(i=5;i<16;i++)
      tlac_retazec(zx+2,zy+i,atributy[15],"              ł              ł              ");
   strcpy(cesta,"a:\\");
   cesta[0]=getdisk()+'A';
   getcurdir(0,pom);
   strcat(cesta,pom);
   strcat(cesta,"\\");
   i=vypln_adresar(meno,cesta,adresar);
   tlac_adresar(zx,zy,0,i,adresar);
   if(strlen(cesta)>44)
	 {
	 tlac_retazec(zx+2,zy+18,atributy[14],&cesta[strlen(cesta)-45]);
	 tlac_znak(zx+2,zy+18,atributy[14],17);
	 }
      else
	 {
	 tlac_retazec(zx+2,zy+18,atributy[14],cesta);
	 for(i=strlen(cesta);i<44;i++)
	    tlac_znak(zx+2+i,zy+18,atributy[14],' ');
	 }
 farfree(adresar);
 pamet();
 }
 
 
 
//************************************************************************//
// VYPLN_ADRESAR			                                  //
//                                                            30.10.1997  //
//************************************************************************//
 
int vypln_adresar(char *meno,char *cesta,struct Adresar *adresar)
 
{
   char pom[100];
   char *p;
   register int i=0,koniec=0;
   struct ffblk ffblk;
 
   strcpy(pom,cesta);
   strcat(pom,"*");
   koniec=findfirst(pom,&ffblk,FA_DIREC);
   if(chyba_hard)
      {
      chybove_okno(chyba[0]);
      return 0;
      }
   if(strcmp(ffblk.ff_name,".")==0)
      koniec=findnext(&ffblk);
   while(!koniec)
      {
      if(chyba_hard)
	 {
	 chybove_okno(chyba[0]);
	 return 0;
	 }
      if(ffblk.ff_attrib==FA_DIREC)
	 {
	 adresar[i].typ=DIRECTORY;
	 vytvor_riadok(adresar[i].meno,adresar[i].konc,ffblk.ff_name);
	 i++;
	 }
      koniec=findnext(&ffblk);
      }
   strcpy(pom,cesta);
   strcat(pom,meno);
   koniec=findfirst(pom,&ffblk,FA_ARCH);
   if(chyba_hard)
      {
      chybove_okno(chyba[0]);
      return 0;
      }
   while(!koniec)
      {
      if(chyba_hard)
	 {
	 chybove_okno(chyba[0]);
	 return 0;
	 }
      if(ffblk.ff_attrib==FA_ARCH)
	 {
	 adresar[i].typ=FILENAME;
	 p=ffblk.ff_name;
	 while(*p!='\0')
	    {
	    *p=tolower(*p);
	    p++;
	    }
	 vytvor_riadok(adresar[i].meno,adresar[i].konc,ffblk.ff_name);
	 i++;
	 }
      koniec=findnext(&ffblk);
      }
   return i;
}
 
 
 
//************************************************************************//
// VYTVOR_RIADOK						          //
//                                                            30.10.1997  //
//************************************************************************//
 
void vytvor_riadok(char *meno,char *konc,char *nazov)
 
{
   if(*nazov=='.')
      strcpy(meno,"..          ");
   else
      {
      while(*nazov!='\0' && *nazov!='.')
	 *meno++=*nazov++;
      *meno='\0';
      if(*nazov!='\0')
	 {
	 nazov++;
	 while(*nazov!='\0')
	    *konc++=*nazov++;
	 }
      *konc='\0';
      }
}
 
 
 
//************************************************************************//
// KONTROLUJ_PATH  funkcia vygeneruje z path plnu cestu a meno suboru     //
// funkcia vrati 0 ak treba rozbalit directory                            //
// vrati 1 ak netreba rozbalit directory, ide o konkretny subor           //
// vrati 2 ak je neplatny adresar                                         //
// vrati 3 ak subor sa neda otvorit                                       //
// vrati 4 ak hardware chyba                                              //
//                                                            30.10.1997  //
//************************************************************************//
 
int kontroluj_path(char *path,char *cesta,char *meno)
 
{
    char drive[5];
    char dir[80];
    char name[15];
    char ext[8];
    char pom[100];
    struct ffblk ff;
    unsigned typ;
    int chyba,i;
 
    typ=fnsplit(path,drive,dir,name,ext);
    if((FILENAME&typ) == 0) /* treba implicitne meno */
       {
       strcpy(name,"*");
       typ= typ|WILDCARDS;
       }
    if((DRIVE&typ) == 0) /* nie je drive */
       {
       drive[0] = 'A'+ getdisk();
       drive[1] = ':';
       drive[2] = '\0';
       }
    else
       drive[0] = toupper(drive[0]);
    if((DIRECTORY&typ)==0 || dir[0]!='\\') /* ci je popisany adresar - */
	{
	pom[0]='\\';                  /* - vylomitkovana cesta */
	if(getcurdir(drive[0]-'A'+1,&pom[1]) == -1) /* vrati chybu */
	    return 4;              /* alebo uplne meno cesty, az do */
	if(strlen(pom) > 1)        /* aktualneho adresara na urcenom */
	    strcat(pom,"\\");                      /* disku */
	if((DIRECTORY&typ) != 0)
	    strcat(pom,dir);
	strcpy(dir,pom);
	}
    i=0;
    while(dir[i] != '\0')
       {
       dir[i]=toupper(dir[i]);
       i++;
       }
    strcpy(cesta,drive);
    strcat(cesta,dir);
    /* test spravnosti adresara */
    strcpy(pom,cesta);
    strcat(pom,"*");
    if(strlen(cesta) > 3) /* koren netreba kontrolovat */
       {
       chyba=findfirst(pom,&ff,FA_DIREC); /* prehladavanie adresara */
       if(chyba_hard)                      /* podla zvolenej masky */
	  return 4;
       if(chyba == -1)
	  return 2;
       }
    strcpy(meno,name);
    if((EXTENSION&typ) == 0)
       strcpy(ext,".*");
    strcat(meno,ext);
    if((WILDCARDS&typ) == 0)
       {
       strcpy(pom,cesta);
       strcat(pom,meno);
       chyba=findfirst(pom,&ff,FA_ARCH);  /* to iste pre subor */
       if(chyba_hard)
	  return 4;
       if(chyba == -1)
	  return 3;
	return 1;
       }
    return 0;
}
 
 
 
//************************************************************************//
// OBDLZNIK                                                               //
//                                                            30.10.1997  //
//************************************************************************//
 
void obdlznik(int zacx,int zacy,int pozicia,unsigned char attr)
 
{
   register int i,x;
   x=zacx+2+15*(pozicia/11);
   for(i=0;i<14;i++)
      nastav_atribut(x+i,zacy+5+(pozicia%11),attr);
}
 
 
 
 
//************************************************************************//
// TLAC_ADRESAR							          //
//                                                            30.10.1997  //
//************************************************************************//
 
void tlac_adresar(int zacx,int zacy,int zaciatocny,int pocet,struct Adresar *adresar)
 
{
   register int i,j;
   for(i=5;i<16;i++)
      tlac_retazec(zacx+2,zacy+i,atributy[15],"              ł              ł              ");
   j=zaciatocny;
   for(i=0;i<33;i++)
      if(j>=pocet)break;
      else {
	   tlac_retazec(zacx+3+15*(i/11),zacy+5+(i%11),atributy[15],adresar[j].meno);
	   tlac_retazec(zacx+15*(i/11)+12,zacy+5+(i%11),atributy[15],adresar[j].konc);
	   j++;
	   }
   for(j=i;j<33;j++)
      tlac_retazec(zacx+3+15*(j/11),zacy+5+(j%11),atributy[15],"             ");
}
 
/*---------------------------------END--------------------------------------*/