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. 
/*****************************************************************************
*						       		             *
*                             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--------------------------------------*/