home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 20 / dos_txl / source / db_txl.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-02-19  |  11.2 KB  |  674 lines
  1. /***
  2.   Schnittstelle Datenbank - TXL, 
  3.   Stackfunktionen und Menüs
  4.   (c) 1991 by Elmar Warken
  5. ***/
  6.  
  7.  
  8. #include <string.h>
  9. #include <conio.h>
  10. #include <alloc.h>
  11. #include "interp.h"
  12. #include "windows.h"
  13. #include "db.h"
  14. #include "macros.c"
  15.  
  16. extern    int    Steuer;                
  17. extern    char    ScanBuffer[ZEILENLAENGE]; 
  18.  
  19. extern struct windowdata *FirstWindow;
  20. extern int WEITER; 
  21.  
  22. int cdefDB(void)
  23. {
  24.   long nr,str,len;
  25.   if ( GetIntegerParam(&nr) &&
  26.        GetIntegerParam(&str) &&
  27.        GetIntegerParam(&len) )
  28.     AddDefinition(nr,str,len);
  29.  
  30.   else 
  31.   {
  32.     serror(" Parameterfehler bei 'DefDB'! ");
  33.     return(FALSE);
  34.   }
  35.  
  36.   return(OK);
  37. }
  38.  
  39. int copenDB(void)
  40. {
  41.   long nr;
  42.   char *name;
  43.  
  44.   if ( GetIntegerParam(&nr) &&
  45.        GetStringParam(&name) )
  46.   {
  47.     if (!OpenFile(nr,name))
  48.     {
  49.       serror(" Fehler beim Öffnen der Datei! ");
  50.       return(FALSE);
  51.     }
  52.   }
  53.   else 
  54.   {
  55.     serror(" Parameterfehler bei 'OpenDB'! ");
  56.     return(FALSE);
  57.   }
  58.  
  59.   return(OK);
  60. }
  61.  
  62. int ccreateDB(void)
  63. {
  64.   long nr;
  65.   char *name;
  66.  
  67.   if ( GetIntegerParam(&nr) &&
  68.        GetStringParam(&name) )
  69.   {
  70.     if (!CreateFile(nr,name))
  71.     {
  72.       serror(" Fehler beim Erstellen der Datei! ");
  73.       return(FALSE);
  74.     }
  75.   }
  76.   else 
  77.   {
  78.     serror(" Parameterfehler bei 'CreateDB'! ");
  79.     return(FALSE);
  80.   }
  81.  
  82.   return(OK);
  83. }
  84.  
  85. int cWriteDB(void)
  86. {
  87.   long dbnr,satznr,zahl;
  88.   char *str, string[200];
  89.  
  90.   if ( GetIntegerParam(&dbnr) &&
  91.        GetIntegerParam(&satznr) &&
  92.        GetStringParam(&str) && strcpy(string,str) &&
  93.        GetIntegerParam(&zahl) )
  94.  
  95.     BeschreibeSatz(dbnr,satznr,string,zahl);
  96.  
  97.   else 
  98.   {
  99.     serror(" Parameterfehler bei 'WriteDB'! ");
  100.     return(FALSE);
  101.   }
  102.  
  103.   return(OK);
  104. }
  105.  
  106. int cReadDB(void)
  107. {
  108.   long dbnr,feldnr;
  109.   int zahl;
  110.   char str[300];
  111.   char VarName1[50],VarName2[50];
  112.  
  113.  
  114.   if ( GetIntegerParam(&dbnr) &&
  115.        GetIntegerParam(&feldnr) )
  116.   { 
  117.     Scan();
  118.     if (Steuer == ALPHA) {
  119.       strcpy (VarName1,ScanBuffer);    
  120.  
  121.       Scan();
  122.       if (Steuer==ALPHA)
  123.     strcpy(VarName2,ScanBuffer);
  124.       else 
  125.       {
  126.     serror ("Variablenname erwartet! ");
  127.     return(FALSE);
  128.       }
  129.  
  130.       LeseSatz(dbnr,feldnr,str,&zahl);
  131.  
  132.       SetVarStr(VarName1,str);
  133.       SetVarInt(VarName2,zahl);
  134.     } 
  135.     else 
  136.     {
  137.       serror ("Variablenname erwartet! ");
  138.       return(FALSE);
  139.     }
  140.   }
  141.   else 
  142.   {
  143.     serror(" Parameterfehler bei 'ReadDB'! ");
  144.     return(FALSE);
  145.   }
  146.  
  147.   return(OK);
  148. }
  149.  
  150. int cAddDB(void)
  151. {
  152.   long dbnr;
  153.  
  154.   if (GetIntegerParam(&dbnr))
  155.     WriteToFile(dbnr);
  156.   else 
  157.   {
  158.     serror(" Parameterfehler bei 'AddDB'! ");
  159.     return(FALSE);
  160.   }
  161.   return(OK);
  162. }
  163.  
  164. int cGotoBegin(void)
  165. {
  166.   long dbnr;
  167.  
  168.   if (GetIntegerParam(&dbnr))
  169.     GotoFileBegin(dbnr);
  170.   else 
  171.   {
  172.     serror(" Parameterfehler bei 'GotoFileBegin'! ");
  173.     return(FALSE);
  174.   }
  175.   return(OK);
  176. }
  177.  
  178. int cGotoEnd(void)
  179. {
  180.   long dbnr;
  181.  
  182.   if (GetIntegerParam(&dbnr))
  183.     GotoFileEnd(dbnr);
  184.   else 
  185.   {
  186.     serror(" Parameterfehler bei 'GotoFileEnd'! ");
  187.     return(FALSE);
  188.   }
  189.   return(OK);
  190. }
  191.  
  192. int cGoBackward(void)
  193. {
  194.   long dbnr;
  195.  
  196.   if (GetIntegerParam(&dbnr))
  197.     GoBackward(dbnr);
  198.   else 
  199.   {
  200.     serror(" Parameterfehler bei 'GoBackward'! ");
  201.     return(FALSE);
  202.   }
  203.   return(OK);
  204. }
  205.  
  206. int cGoForward(void)
  207. {
  208.   long dbnr;
  209.  
  210.   if (GetIntegerParam(&dbnr))
  211.     GoForward(dbnr);
  212.   else 
  213.   {
  214.     serror(" Parameterfehler bei 'GoForward'! ");
  215.     return(FALSE);
  216.   }
  217.   return(OK);
  218. }
  219.  
  220. int cGoTo(void)
  221. {
  222.   long dbnr,spos;
  223.  
  224.   if (GetIntegerParam(&dbnr) &&
  225.       GetIntegerParam(&spos) )
  226.  
  227.     GoTo(dbnr,spos);
  228.   else 
  229.   {
  230.     serror(" Parameterfehler bei 'GoTo'! ");
  231.     return(FALSE);
  232.   }
  233.   return(OK);
  234. }
  235.  
  236. int cGoToNr(void)
  237. {
  238.   long dbnr,snr;
  239.  
  240.   if (GetIntegerParam(&dbnr) &&
  241.       GetIntegerParam(&snr) )
  242.  
  243.     GoToNr(dbnr,snr);
  244.   else 
  245.   {
  246.     serror(" Parameterfehler bei 'GoToNr'! ");
  247.     return(FALSE);
  248.   }
  249.   return(OK);
  250. }
  251.  
  252. int cCloseFile(void)
  253. {
  254.   long dbnr;
  255.  
  256.   if (GetIntegerParam(&dbnr))
  257.     CloseFile(dbnr);
  258.   else 
  259.   {
  260.     serror(" Parameterfehler bei 'CloseFile'! ");
  261.     return(FALSE);
  262.   }
  263.   return(OK);
  264. }
  265.  
  266. int cMakeTree(void)
  267. {
  268.   long dbnr,fnr;
  269.  
  270.   if (GetIntegerParam(&dbnr) &&
  271.       GetIntegerParam(&fnr) )
  272.  
  273.     MakeTree(dbnr,fnr);
  274.   else 
  275.   {
  276.     serror(" Parameterfehler bei 'MakeTree'! ");
  277.     return(FALSE);
  278.   }
  279.   return(OK);
  280. }
  281.  
  282. int cMarkCurrent(void)
  283. {
  284.   long dbnr,markval;
  285.  
  286.   if (GetIntegerParam(&dbnr) &&
  287.       GetIntegerParam(&markval) )
  288.  
  289.     MarkCurrent(dbnr,markval);
  290.   else 
  291.   {
  292.     serror(" Parameterfehler bei 'MarkCurrent'! ");
  293.     return(FALSE);
  294.   }
  295.   return(OK);
  296. }
  297.  
  298. int cUnMarkAll(void)
  299. {
  300.   long dbnr,markval;
  301.  
  302.   if (GetIntegerParam(&dbnr))
  303.     UnMarkAll(dbnr);
  304.   else 
  305.   {
  306.     serror(" Parameterfehler bei 'UnMarkAll'! ");
  307.     return(FALSE);
  308.   }
  309.   return(OK);
  310. }
  311.  
  312. int cDelTree(void)
  313. {
  314.   long dbnr;
  315.  
  316.   if (GetIntegerParam(&dbnr))
  317.     DelTree(dbnr);
  318.   else 
  319.   {
  320.     serror(" Parameterfehler bei 'DelTree'! ");
  321.     return(FALSE);
  322.   }
  323.   return(OK);
  324. }
  325.  
  326. int cDelMarked(void)
  327. {
  328.   long dbnr;
  329.  
  330.   if (GetIntegerParam(&dbnr))
  331.     DelMarked(dbnr);
  332.   else 
  333.   {
  334.     serror(" Parameterfehler bei 'DelMarked'! ");
  335.     return(FALSE);
  336.   }
  337.   return(OK);
  338. }
  339.  
  340. int cListTree(void)
  341. {
  342.   long dbnr;
  343.  
  344.   if (GetIntegerParam(&dbnr))
  345.     ListTree(dbnr);
  346.   else 
  347.   {
  348.     serror(" Parameterfehler bei 'ListTree'! ");
  349.     return(FALSE);
  350.   }
  351.   return(OK);
  352. }
  353.  
  354. long testprog,ausgproc;
  355. int gefunden;
  356.  
  357. int cGefundenOK(void)
  358. {
  359.   gefunden=1;
  360.  
  361.   return(OK);
  362. }
  363.  
  364. int cStopSearch(void)
  365. {
  366.   WEITER=0;
  367.  
  368.   return(OK);
  369. }
  370.  
  371. int TestP() 
  372. { 
  373.   gefunden=0;
  374.  
  375.   if (testprog==0) 
  376.     gefunden=1;
  377.   else dogosub(testprog);
  378.  
  379.   return(gefunden); 
  380. }
  381.  
  382. void AusgP()
  383. {
  384.   dogosub(ausgproc);
  385. }
  386.  
  387. int cSearchDB(void)
  388. {
  389.   long nr;
  390.  
  391.   if ( GetIntegerParam(&nr) &&
  392.        GetIntegerParam(&testprog) &&
  393.        GetIntegerParam(&ausgproc) )
  394.  
  395.   DurchSuche(nr,TestP,AusgP);
  396.  
  397.   else 
  398.   {
  399.     serror(" Parameterfehler bei 'SearchDB'! ");
  400.     return(FALSE);
  401.   }
  402.  
  403.   return(OK);
  404. }
  405.  
  406. int cSearchTree(void)
  407. {
  408.   long dbnr,pos;
  409.   char VarName[50];
  410.   char *str;
  411.  
  412.   if ( GetIntegerParam(&dbnr) )
  413.   { 
  414.     Scan();
  415.     if (Steuer == ALPHA) {
  416.       strcpy (VarName,ScanBuffer);    
  417.  
  418.       if (GetStringParam(&str))
  419.       {
  420.     if (!SearchTree(dbnr,&pos,str))
  421.       pos=1000000000; /** Position 1 Milliarde bedeutet Fehler, da **/
  422.               /** Gigabyte-Dateien sehr unwahrscheinlich   **/
  423.       } else
  424.       {
  425.     serror(" Parameterfehler bei 'SearchTree'! ");
  426.     return(FALSE);
  427.       }
  428.  
  429.       SetVarInt(VarName,pos);
  430.     } 
  431.     else 
  432.     {
  433.       serror ("Variablenname erwartet! ");
  434.       return(FALSE);
  435.     }
  436.   }
  437.   else 
  438.   {
  439.     serror(" Parameterfehler bei 'SearchTree'! ");
  440.     return(FALSE);
  441.   }
  442.  
  443.   return(OK);
  444. }
  445.  
  446.  
  447. int cDurchsucheTree(void)
  448. {
  449.   long nr;
  450.  
  451.   if ( GetIntegerParam(&nr) &&
  452.        GetIntegerParam(&testprog) &&
  453.        GetIntegerParam(&ausgproc) )
  454.  
  455.   DurchsucheTree(nr,TestP,AusgP);
  456.  
  457.   else 
  458.   {
  459.     serror(" Parameterfehler bei 'DurchsucheTree'! ");
  460.     return(FALSE);
  461.   }
  462.  
  463.   return(OK);
  464. }
  465.  
  466. /** Pulldownmenüs für TXL : **/
  467. /** Es werden solange Unterprogramme aufgerufen, bis ESC gedrückt wird. **/
  468. int cMenue(void)
  469. {
  470.   char Punkte[20][30];  /*** 20 Punkte je maximal 29 Zeichen ***/
  471.   long Subs[20];    /*** 20 Unterprogramme ***/
  472.   char *str;
  473.   int x1,y1,i,breite=0,punkte=0;
  474.   int wahl;
  475.   char c;
  476.  
  477.   while (GetStringParam(&str))
  478.   {
  479.     strcpy(Punkte[punkte],str);
  480.     if (strlen(str) > breite)
  481.       breite=strlen(str);
  482.     if (!GetIntegerParam(&Subs[punkte]))
  483.     {
  484.       serror(" Unterprogrammzeile für Menüpunkt erwartet. ");
  485.       return(FALSE);
  486.     }
  487.     punkte++;
  488.   }
  489.   if (!FirstWindow)
  490.   { 
  491.     serror(" Das Fenster für das Menü muß bereits geöffnet sein. ");
  492.     return(FALSE);
  493.   }
  494.   x1=FirstWindow->x1;  y1=FirstWindow->y1;
  495.   for (i=0; i<punkte; i++)
  496.   {
  497.     SET_POS(x1+1,y1+i+1);
  498.     WR_STRMAX(Punkte[i],FirstWindow->BackCol,breite);
  499.   }
  500.   wahl=1;
  501.   SET_POS(x1+1,y1+wahl);
  502.   WR_STRMAX(Punkte[wahl-1],FirstWindow->FrameCol,breite);  
  503.   while ((c=getch())!=27)
  504.   {
  505.     SET_POS(x1+1,y1+wahl);
  506.     WR_STRMAX(Punkte[wahl-1],FirstWindow->BackCol,breite);  
  507.     switch (c)
  508.     {
  509.       case 0 : 
  510.     c=getch();
  511.     switch(c)
  512.     {
  513.       case 80 : wahl++; break;
  514.       case 72 : wahl--; break;
  515.       case 71 : wahl=1; break;
  516.       case 79 : wahl=punkte; 
  517.     } break;
  518.       case 13 :
  519.     dogosub(Subs[wahl-1]);
  520.     }
  521.     if (wahl==0) wahl=punkte;
  522.     if (wahl>punkte) wahl=1;
  523.     SET_POS(x1+1,y1+wahl);
  524.     WR_STRMAX(Punkte[wahl-1],FirstWindow->FrameCol,breite);  
  525.   }
  526.   return(OK);
  527. }
  528.  
  529. typedef struct stack
  530. {
  531.   long val;
  532.   struct stack *Next;
  533. } Stack;
  534.  
  535. Stack *Top;
  536.  
  537. int cpush()
  538. {
  539.   long wert;
  540.   Stack *new;
  541.  
  542.   if (GetIntegerParam(&wert))
  543.   { 
  544.     if ((new=malloc(sizeof(Stack)))==NULL)
  545.     {
  546.       serror(" Stacküberlauf bzw. Speicher voll. ");
  547.       return(FALSE);
  548.     }
  549.     new->val=wert;
  550.     new->Next=Top;
  551.     Top=new;
  552.   } else
  553.   {
  554.     serror(" Falscher Parameter von 'push' ");
  555.     return(FALSE);
  556.   }
  557.   return(OK);
  558. }
  559.  
  560. int cpop()
  561. {
  562.   long *wert;
  563.   Stack *alt;
  564.  
  565.   if (GetNumbVarParam(&wert))
  566.   {
  567.     if (Top)
  568.     {
  569.       *wert=Top->val;
  570.       alt=Top;
  571.       Top=Top->Next;
  572.       free(alt);
  573.     }
  574.     else 
  575.     {
  576.       serror(" Stack ist leer. ");
  577.       return(FALSE);
  578.     }
  579.   } else
  580.   {
  581.     serror(" Falscher Parameter von 'pop' ");
  582.     return(FALSE);
  583.   }
  584.   return(OK);
  585. }
  586.  
  587. /** Auswahlliste für TXL : **/
  588. /** Ein Menüpunkt wird ausgewählt und dessen 
  589.     Nummer auf dem Stack zurückgegeben.      **/
  590.  
  591. int cAuswahl(void)
  592. {
  593.   char Punkte[20][30];  /*** 20 Punkte je maximal 29 Zeichen ***/
  594.   long Subs[20];    /*** 20 Unterprogramme ***/
  595.   char *str;
  596.   int x1,y1,i,breite=0,punkte=0;
  597.   int wahl;
  598.   char c;
  599.   Stack *new;
  600.  
  601.   while (GetStringParam(&str))
  602.   {
  603.     strcpy(Punkte[punkte],str);
  604.     if (strlen(str) > breite)
  605.       breite=strlen(str);
  606.     punkte++;
  607.   }
  608.   if (!FirstWindow)
  609.   { 
  610.     serror(" Das Fenster für das Menü muß bereits geöffnet sein. ");
  611.     return(FALSE);
  612.   }
  613.   x1=FirstWindow->x1;  y1=FirstWindow->y1;
  614.   for (i=0; i<punkte; i++)
  615.   {
  616.     SET_POS(x1+1,y1+i+1);
  617.     WR_STRMAX(Punkte[i],FirstWindow->BackCol,breite);
  618.   }
  619.   wahl=1;
  620.   SET_POS(x1+1,y1+wahl);
  621.   WR_STRMAX(Punkte[wahl-1],FirstWindow->FrameCol,breite);  
  622.   while ((c=getch())!=13)
  623.   {
  624.     SET_POS(x1+1,y1+wahl);
  625.     WR_STRMAX(Punkte[wahl-1],FirstWindow->BackCol,breite);  
  626.     if (c==0)
  627.     {
  628.       c=getch();
  629.       switch(c)
  630.       {
  631.     case 80 : wahl++; break;
  632.     case 72 : wahl--; break;
  633.     case 71 : wahl=1; break;
  634.     case 79 : wahl=punkte; 
  635.       } 
  636.     }
  637.     if (wahl==0) wahl=punkte;
  638.     if (wahl>punkte) wahl=1;
  639.     SET_POS(x1+1,y1+wahl);
  640.     WR_STRMAX(Punkte[wahl-1],FirstWindow->FrameCol,breite);  
  641.   }
  642.  
  643.   if ((new=malloc(sizeof(Stack)))==NULL)
  644.   {
  645.     serror(" Stacküberlauf bzw. Speicher voll. ");
  646.     return(FALSE);
  647.   }
  648.   new->val=wahl;
  649.   new->Next=Top;
  650.   Top=new;
  651.  
  652.   return(OK);
  653. }
  654.  
  655. int cReadKey()
  656. {
  657.   long *val;
  658.   char c;
  659.  
  660.   if (GetNumbVarParam(&val))
  661.   {
  662.     if ((c=getch())==0)
  663.       *val=(getch() << 8) & c;
  664.     else *val=c;
  665.   } 
  666.   else
  667.   {
  668.     serror(" ReadKey : Integervariable erwartet. ");
  669.     return(FALSE);
  670.   }
  671.   return(OK);
  672. }
  673.  
  674.