home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 20 / dos_txl / source / database.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-02-19  |  10.4 KB  |  557 lines
  1. /* DATABASE.C
  2.    Datenbanken für TXL-Interpreter
  3.    (c) 1991 Elmar Warken  */
  4.  
  5. #include <stdlib.h>
  6. #include <fcntl.h>
  7. #include <mem.h>
  8. #include <stdio.h>
  9. #include <string.h>
  10. #include <conio.h>
  11. #include <alloc.h>
  12. #include "interp.h"
  13. #include "db.h"
  14.  
  15. #define STRFELD 0
  16. #define INTFELD 1
  17. #define MAXFELDER 20
  18. #define MAXBANKEN 3
  19.  
  20. extern    int        Steuer;                
  21. extern    char    ScanBuffer[ZEILENLAENGE]; 
  22.  
  23. typedef struct feld
  24. { 
  25.   int typ,      /*** Typ (INTFELD oder STRFELD         ***/
  26.       strlen,   /*** für Strings : Länge         ***/    
  27.       offset;    /*** Offset innerhalb eines Satzes    ***/
  28. } Feld;
  29.  
  30. typedef struct key /*** Binärer Baum von Strings ***/
  31. {
  32.   char *str;
  33.   long filepos;
  34.   struct key *R,*L; /** rechter und linker Ast **/
  35. } Key;
  36.  
  37. typedef struct dfile
  38. {
  39.   Feld Felder[MAXFELDER];
  40.   int felder,satzlaenge;
  41.   FILE *f;
  42.   char *satz;   /* aktueller Datensatz */
  43.   long satzpos; /* Position des Datensatzes */
  44.   int initialized;
  45.   char dateiname[50];
  46.   Key *wurzel;
  47.   int keyfeld;  /* Welches Feld ist im Baum sortiert ? */
  48. } DFile;
  49.  
  50. /***** Globale Variablen für DATABASE.C *****/
  51.  
  52. DFile defs[MAXBANKEN];
  53. int WEITER; /** Flag für Durchsuchfunktion (nicht bei DurchsucheTree) **/
  54. int AktFeld,AktDef; /** intern benötigt **/
  55.  
  56. void AddDefinition(int defnr, int typ, int len)
  57. {
  58.   DFile *d;
  59.   Feld *f;
  60.  
  61.   d=&defs[defnr];
  62.   if (d->felder<MAXFELDER)
  63.   {
  64.     f=&d->Felder[d->felder];
  65.     f->typ=typ;
  66.     f->strlen=len;
  67.     f->offset=d->satzlaenge;
  68.     if (typ==STRFELD)
  69.       d->satzlaenge+=len;
  70.     else d->satzlaenge+=sizeof(int);
  71.     d->felder++;
  72.   }
  73. }
  74.  
  75. int OpenFile(int defnr, char *name)
  76. {       
  77.   DFile *d;
  78.   Feld NewFeld,*f;
  79.   char vollname[60];
  80.   FILE *F;
  81.         
  82.   d=&defs[defnr];
  83.   d->felder=0;
  84.   d->satzlaenge=1; /* Statusbyte : Satz zum Löschen markiert ? */
  85.   strcpy(vollname,name);
  86.   strcat(vollname,".DEF");
  87.   if ((F=fopen(vollname,"rb"))==NULL) return(FALSE);
  88.   while (fread(&NewFeld,sizeof(Feld),1,F) > 0)
  89.   {
  90.     f=&d->Felder[d->felder];
  91.     *f=NewFeld;
  92.     d->felder++;
  93.     if (f->typ==STRFELD)
  94.       d->satzlaenge+=f->strlen;
  95.     else d->satzlaenge+=sizeof(int);
  96.   }
  97.   fclose(F);
  98.  
  99.   strcpy(d->dateiname,name);
  100.   d->satz=malloc(defs[defnr].satzlaenge);
  101.   strcpy(vollname,name);
  102.   strcat(vollname,".DAT");
  103.   if ((d->f=fopen(vollname,"r+b"))==NULL) 
  104.     return(FALSE);
  105.   d->initialized=1;
  106.   *((char *)(d->satz+d->satzlaenge-1))=0;
  107.   return(OK);
  108. }
  109.  
  110. int CreateFile(int defnr, char *name)
  111. {
  112.   DFile *d;
  113.   int i;
  114.   char vollname[60],help[3];
  115.   FILE *f;
  116.             
  117.   strcpy(vollname,name);
  118.   strcat(vollname,".DEF");
  119.   d=&defs[defnr];
  120.   if ((f=fopen(vollname, "wb"))==NULL) 
  121.     return(FALSE);
  122.  
  123.   errno=0;
  124.   for (i=0; i<d->felder && 
  125.           (fwrite(&d->Felder[i],sizeof(Feld),1,f) != 0); i++);
  126.   if (errno) return(FALSE);
  127.   fclose(f);
  128.  
  129.   strcpy(d->dateiname,name);
  130.   d->satzlaenge+=1; /* Gelöscht-Bit */
  131.   d->satz=malloc(defs[defnr].satzlaenge);
  132.  
  133.   strcpy(vollname,name);
  134.   strcat(vollname,".DAT");
  135.   if ((d->f=fopen(vollname, "w+b"))==NULL) 
  136.     return(FALSE);  
  137.  
  138.   d->initialized=1;
  139.   *((char *)(d->satz+d->satzlaenge-1))=0;
  140.   return(OK);
  141. }
  142.  
  143. void BeschreibeSatz(int defnr, int feldnr, char *str, int wert)
  144. {
  145.   DFile *d;
  146.   Feld *f;
  147.  
  148.   d=&defs[defnr];
  149.   if (d->felder>=feldnr)
  150.   {
  151.     f=&d->Felder[feldnr-1];
  152.     if (f->typ==STRFELD)
  153.       strcpy((char *)(d->satz+f->offset),str);
  154.     else *(int *)(d->satz+f->offset)=wert;
  155.   }
  156.   *((char *)(d->satz+d->satzlaenge-1))=0;
  157. }
  158.  
  159. void LeseSatz(int defnr, int feldnr, char *str, int *wert)
  160. {
  161.   DFile *d;
  162.   Feld *f;
  163.  
  164.   d=&defs[defnr];
  165.   if (d->felder>=feldnr)
  166.   {
  167.     f=&d->Felder[feldnr-1];
  168.     if (f->typ==STRFELD)
  169.       strcpy(str,(char *)(d->satz+f->offset));
  170.     else *wert=*(int *)(d->satz+f->offset);
  171.   }
  172. }
  173.  
  174. void WriteToFile(int defnr)
  175. {
  176.   DFile *d;
  177.  
  178.   d=&defs[defnr];
  179.   if (d->f)
  180.   {
  181.     fseek(d->f,d->satzpos,SEEK_SET);
  182.     fwrite(d->satz,d->satzlaenge,1,d->f);
  183.   }
  184.   d->satzpos=ftell(d->f);
  185. }  
  186.  
  187. void GotoFileEnd(int defnr)
  188. {
  189.   DFile *d;
  190.   int i;
  191.  
  192.   d=&defs[defnr];
  193.   if (d->f)
  194.   {
  195.     fseek(d->f,0L,SEEK_END);
  196.     d->satzpos=ftell(d->f);
  197.   }
  198.   *(char *)(d->satz+d->satzlaenge-1)=0;
  199. }
  200.  
  201. void GotoFileBegin(int defnr)
  202. {
  203.   DFile *d;
  204.   int i;
  205.  
  206.   d=&defs[defnr];
  207.   if (d->f)
  208.   {
  209.     fseek(d->f,0L,SEEK_SET);
  210.     d->satzpos=ftell(d->f);
  211.     fread(d->satz,d->satzlaenge,1,d->f);
  212.   }
  213. }
  214.  
  215. void GoForward(int defnr)
  216. {
  217.   DFile *d;
  218.   int i;
  219.  
  220.   d=&defs[defnr];
  221.   if (d->f)
  222.   {
  223.     d->satzpos+=d->satzlaenge;
  224.     fseek(d->f,d->satzpos,SEEK_SET);
  225.     d->satzpos=ftell(d->f);
  226.     fread(d->satz,d->satzlaenge,1,d->f);
  227.   }
  228. }
  229.  
  230. void GoBackward(int defnr)
  231. {
  232.   DFile *d;
  233.   int i;
  234.  
  235.   d=&defs[defnr];
  236.   if (d->f && d->satzpos)  /** wenn Position bereits 0, dann Abbrechen **/
  237.   {
  238.     d->satzpos-=d->satzlaenge;
  239.     fseek(d->f,d->satzpos,SEEK_SET);
  240.     d->satzpos=ftell(d->f);
  241.     fread(d->satz,d->satzlaenge,1,d->f);
  242.   }
  243. }
  244.  
  245. void GoTo(int defnr, long satzpos)
  246. {
  247.   DFile *d;
  248.   int i;
  249.  
  250.   d=&defs[defnr];
  251.   if (d->f) 
  252.   {
  253.     d->satzpos=satzpos;
  254.     fseek(d->f,d->satzpos,SEEK_SET);
  255.     d->satzpos=ftell(d->f);
  256.     fread(d->satz,d->satzlaenge,1,d->f);
  257.   }
  258. }
  259.  
  260. void GoToNr(int defnr, int satznr)
  261. {
  262.   GoTo(defnr, defs[defnr].satzlaenge*satznr);
  263. }
  264.  
  265. void MarkCurrent(int defnr, int Mark_On)
  266. {
  267.   DFile *d;
  268.   int i;
  269.  
  270.   d=&defs[defnr];
  271.   if (d->f)
  272.     *(char *)(d->satz+d->satzlaenge-1)=Mark_On;
  273.   WriteToFile(defnr);
  274. }
  275.  
  276. void CloseFile(int defnr)
  277. {
  278.   DFile *d;
  279.   int i;
  280.  
  281.   d=&defs[defnr];
  282.  
  283.   if (d->f)
  284.     fclose(d->f);
  285.   d->f=NULL;
  286.   free(d->satz);
  287. }
  288.  
  289. int T_ImmerWahr() { return(1==1); }
  290.  
  291. void A_AddTree()
  292. {
  293.   char str[30];
  294.   int i;
  295.  
  296.   LeseSatz(AktDef,AktFeld,str,&i);
  297.   AddTree(AktDef,defs[AktDef].satzpos,str);
  298. }
  299.  
  300. void DurchSuche(int defnr, TestFunktion t, AusgabeFunktion a)
  301. {
  302.   DFile *d;
  303.   Feld *f;
  304.   long p;
  305.  
  306.   WEITER=1;
  307.   d=&defs[defnr];
  308.   if (d->f)
  309.   {
  310.     rewind(d->f);
  311.     d->satzpos=ftell(d->f);
  312.     while (fread(d->satz,d->satzlaenge,1,d->f) && WEITER) 
  313.       if (!*(char *)(d->satz+d->satzlaenge-1))
  314.       { 
  315.     p=ftell(d->f);
  316.     if (t())  a();
  317.     d->satzpos=p;
  318.     fseek(d->f,p,SEEK_SET);
  319.       }
  320.   }
  321. }
  322.  
  323. void UnMarkAll(int defnr)
  324. {
  325.   DFile *d;
  326.   Feld *f;
  327.   long p;
  328.  
  329.   d=&defs[defnr];
  330.   if (d->f)
  331.   {
  332.     rewind(d->f);
  333.     d->satzpos=ftell(d->f);
  334.     while (fread(d->satz,d->satzlaenge,1,d->f)) 
  335.       if (*(char *)(d->satz+d->satzlaenge-1))
  336.       { 
  337.     *((char *)(d->satz+d->satzlaenge-1))=0;
  338.     p=ftell(d->f);
  339.     WriteToFile(defnr);
  340.     d->satzpos=p;
  341.     fseek(d->f,p,SEEK_SET);
  342.       }
  343.   }
  344. }
  345.  
  346. void DelMarked(int defnr)
  347. {
  348.   FILE *new;
  349.   DFile *d;
  350.   Feld *f;
  351.   char newname[60],oldname[60];
  352.  
  353.   d=&defs[defnr];
  354.   fclose(d->f);
  355.   strcpy(newname,d->dateiname);
  356.   strcat(newname,".ALT");
  357.   strcpy(oldname,d->dateiname);
  358.   strcat(oldname,".DAT");
  359.  
  360.   if (rename(oldname,newname)==-1) return;
  361.   if ((d->f=fopen(oldname,"wb"))==NULL) 
  362.   { remove(newname);  return;  }
  363.   if ((new=fopen(newname,"rb"))==NULL) 
  364.   { remove(newname);  return;  }
  365.  
  366.   while (fread(d->satz,d->satzlaenge,1,new)) 
  367.     if (!*(char *)(d->satz+d->satzlaenge-1))
  368.       fwrite(d->satz,d->satzlaenge,1,d->f);
  369.  
  370.   fclose(new);
  371.   remove(newname);
  372. }
  373.  
  374.  
  375. /*****************************************************************/
  376. /**********  Funktionen für die Sortierung in Bäumen *************/
  377. /*****************************************************************/
  378.  
  379. void MakeTree(int defnr, int feldnr)
  380. {
  381.   AktDef=defnr;
  382.   AktFeld=feldnr;
  383.   if (CreateTree(defnr,feldnr))
  384.     DurchSuche(defnr,T_ImmerWahr,A_AddTree);
  385. }
  386.  
  387. void _del(Key *k)
  388. {
  389.   if (k)
  390.   {
  391.     _del(k->L);
  392.     _del(k->R);
  393.     free(k->str);
  394.     free(k);
  395.   }
  396. }
  397.  
  398. void DelTree(int defnr)
  399. {
  400.   DFile *d;
  401.   d=&defs[defnr];
  402.   _del(d->wurzel);
  403.   d->wurzel=NULL;
  404.   d->keyfeld=0;
  405. }
  406.  
  407. void _list(Key *k)
  408. {
  409.   if (k)
  410.   {
  411.     _list(k->L);
  412.     puts(k->str);
  413.     _list(k->R);
  414.   }
  415. }
  416.  
  417. void ListTree(int defnr)
  418. {
  419.   if (defs[defnr].keyfeld)
  420.     _list(defs[defnr].wurzel);
  421. }
  422.  
  423. void _durch(int defnr, Key *k, TestFunktion t, AusgabeFunktion a)
  424. {
  425.   if (k)
  426.   {
  427.     _durch(defnr,k->L,t,a);
  428.     GoTo(defnr, k->filepos);
  429.     if (t()) a();
  430.     _durch(defnr,k->R,t,a);
  431.   }
  432. }
  433.  
  434. void DurchsucheTree(int defnr, TestFunktion t, AusgabeFunktion a)
  435. {
  436.   if (defs[defnr].keyfeld)
  437.     _durch(defnr,defs[defnr].wurzel,t,a);
  438. }
  439.  
  440. int CreateTree(int defnr, int feldnr)
  441. {
  442.   DFile *d;
  443.   Feld *f;
  444.  
  445.   d=&defs[defnr];
  446.   if (d->keyfeld!=0) DelTree(defnr);
  447.   if (feldnr<=d->felder)
  448.   {
  449.     f=&d->Felder[d->felder];
  450.     if (f->typ==STRFELD) 
  451.     {
  452.       d->keyfeld=feldnr;
  453.       return(OK);
  454.     }
  455.   }
  456.   return(FALSE);
  457. }
  458.  
  459. int _add(Key **k, long filepos, char *str)
  460. {
  461.   if (!*k)
  462.   {
  463.     if ((*k=malloc(sizeof(Key)))==NULL) return(FALSE);
  464.     if (((*k)->str=malloc(strlen(str)+1))==NULL) return(FALSE);
  465.     strcpy((*k)->str,str);
  466.     (*k)->filepos=filepos;
  467.     (*k)->R=NULL; (*k)->L=NULL;
  468.   } else
  469.   {
  470.     if (strcmp(str,(*k)->str) > 0)
  471.       return(_add(&(*k)->R,filepos,str));
  472.     else return(_add(&(*k)->L,filepos,str));
  473.   }
  474.   return(OK);
  475. }
  476.  
  477. int AddTree(int defnr, long filepos, char *str)
  478. {
  479.   if (defs[defnr].keyfeld)
  480.     return(_add(&defs[defnr].wurzel,filepos,str));
  481.   return(FALSE);
  482. }
  483.  
  484. int _search(Key *k, long *filepos, char *str)
  485. {
  486.   int compare;
  487.  
  488.   if (!k) return(FALSE);
  489.   compare=strcmp(k->str,str);
  490.   if (compare==0)
  491.   {
  492.     *filepos=k->filepos;
  493.     return(OK);
  494.   } else 
  495.   if (compare<0)
  496.     return(_search(k->R, filepos, str));
  497.   else return(_search(k->L, filepos, str));
  498. }
  499.  
  500. int SearchTree(int defnr, long *filepos, char *str)
  501. {
  502.   if (defs[defnr].keyfeld)
  503.     if (_search(defs[defnr].wurzel, filepos, str))
  504.     {
  505.       GoTo(0,*filepos);
  506.       return(OK);
  507.     }
  508.   return(FALSE);
  509. }
  510.  
  511. int cReadDBFormat(void)
  512. {
  513.   long dbnr,feldnr;
  514.   int zahl,i,max;
  515.   char str[300],*p;
  516.   char VarName1[50];
  517.  
  518.  
  519.   if ( GetIntegerParam(&dbnr) &&
  520.        GetIntegerParam(&feldnr) )
  521.   { 
  522.     Scan();
  523.     if (Steuer == ALPHA) {
  524.       strcpy (VarName1,ScanBuffer);    
  525.  
  526.       LeseSatz(dbnr,feldnr,str,&zahl);
  527.  
  528.       if (defs[dbnr].Felder[feldnr-1].typ==STRFELD)
  529.         max=defs[dbnr].Felder[feldnr-1].strlen;
  530.       else {
  531.         max=6;
  532.         itoa(zahl,str,10);
  533.       }
  534.  
  535.       p=str; i=0;
  536.       while (*p++) i++;
  537.       p--; i--;
  538.       while (i++ < max) *p++=' ';
  539.       *p=0;
  540.  
  541.       SetVarStr(VarName1,str);
  542.     } 
  543.     else 
  544.     {
  545.       serror ("Variablenname erwartet! ");
  546.       return(FALSE);
  547.     }
  548.   }
  549.   else 
  550.   {
  551.     serror(" Parameterfehler bei 'ReadDBForm'! ");
  552.     return(FALSE);
  553.   }
  554.  
  555.   return(OK);
  556. }
  557.