home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1991 / 04 / txl / 3_preis / fast / interp.c < prev    next >
Text File  |  1990-11-17  |  10KB  |  315 lines
  1. /**********************************************************/
  2. /*                       INTERP.C                         */
  3. /*   Hier werden Interpreterbefehle erkannt und dann die  */
  4. /*   notwendigen ausführenden Routinen gestartet.         */
  5. /*                                                        */
  6. /*          (c) 1990 Michael Beising & TOOLBOX            */
  7. /**********************************************************/
  8.  
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <string.h>
  12. #include "interp.h"
  13. #include "neuutil.h"
  14.  
  15. /* Benoetigte Globalvariablen */
  16. extern  PRGZEILE  *FirstLine; /* erste Interpreterzeile   */
  17. extern  PRGZEILE  *ActLine;   /* aktuelle interp. Zeile   */
  18. extern  char      *LinePos;   /* Zeilenpos. der Akt. Zeile*/
  19. extern  int       Steuer;    /* der aufrufenden Routine wird
  20.                        mitgeteilt, um was es sich handelt.*/
  21.                            /* Ergebnisbuffer des Scanners */
  22. extern  char ScanBuffer[ZEILENLAENGE];
  23. extern  VAR  *FirstVar;         /* Zeiger auf die erste Variable */
  24.  
  25. extern  TOKBEF  TokBefDesc[];   /*  NEU     für Befehlsfindung       */
  26.  
  27. /* lokale Funktionen und deren Prototypen dieses Files */
  28.  
  29. static  int     TestBefehl (int *Befehl);
  30.  
  31. void
  32. InterAct ()
  33. {
  34. PRGZEILE NewLine;         /* interaktiv eingegebene Zeile */
  35. PRGZEILE *EditZeile;      /* NEU    Editierzeile         */
  36. int      Error;           /* Fehlermeldungen zwischensp.  */
  37. int abbruch[3];           /* NEU    intarray für Abbruchtasten von LESE() */
  38. int i;                    /* NEU    Zähler                 */
  39. int loesch=1;             /* NEU    Switch für ReadBuffer-Löschung   */
  40. register int reg;         /* NEU    für Befehlsfindung               */
  41. int farbe_v,farbe_h;      /* NEU    für Farbsicherung                */
  42. char     ReadBuffer[ZEILENLAENGE];  /* Buffer für eine Eingabezeile*/
  43.  
  44.   abbruch[0]=ESC;        /* NEU     ESC-Abbruch für LESE()   */
  45.   abbruch[1]=F1;         /* NEU      F1-Abbruch für LESE()   */
  46.   abbruch[2]='\0';
  47.   FirstLine = NULL;      /* kein Interpretertext vorhanden */
  48.   ActLine   = NULL;
  49.   FirstVar  = NULL;          /* keine Variablen vorhanden */
  50.   SetFileName ("work.mbl");     /* Defaultfilename setzen */
  51.  
  52.   while (TRUE) {
  53.     ResetError ();     /* Fehlermeldungsflag zurücksetzen */
  54.     *NewLine.Zeile = '\0'; /* Zwischenspeicher rücksetzen */
  55.     setcr(24,0);
  56.     putchar (0x0d);putchar(0x0a);   /* <cr>-<lf> ausgeben */
  57.     putchar ('>');                     /* Prompt ausgeben */
  58.  
  59.  
  60.     /*         NEUE VERSION    */
  61.  
  62.     _lastkey=ESC;
  63.  
  64.     if(loesch)                           /* ReadBuffer Löschen  */
  65.     for(i=0;i<=ZEILENLAENGE-1;i++)
  66.         ReadBuffer[i]=' ';
  67.     else                                 /* ReadBuffer auf orginallänge setzen */
  68.     for(i=strlen(ReadBuffer); i<=(ZEILENLAENGE-1) ;i++)
  69.         ReadBuffer[i]=' ';
  70.  
  71.     ReadBuffer[ZEILENLAENGE-1]='\0';    /* Stringende setzen    */
  72.  
  73.     loesch=1;                           /*  Lösch-Switch Initialisieren  */
  74.  
  75.     while(_lastkey == ESC || _lastkey == F1)  /* While letzte Taste ESC oder F1 */
  76.     {
  77.     putchar ('>');                     /* Prompt ausgeben */
  78.     farbe_v=_set_f_v;
  79.     farbe_h=_set_f_h;
  80.     set_color(7,0);
  81.     /*  ReadBuffer einlesen  auf Zeile 24 Spalte 1  */
  82.     lese(24,1,ReadBuffer,"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",abbruch);
  83.     if (_lastkey==F1)    /*   Hilfe ausgeben  */
  84.         {
  85.         LinePos = ReadBuffer;
  86.         SkipChar ();
  87.         chilfe();
  88.         setcr(24,0);
  89.         }
  90.     set_color(farbe_v,farbe_h);
  91.     }
  92.  
  93.     /*  ReadBuffer auf Eingabelänge kürzen  */
  94.     for(i=strlen(ReadBuffer)-1;ReadBuffer[i] == ' ' && i >= 0;i--)
  95.     ;
  96.     ReadBuffer[++i] = '\0';
  97.  
  98.     /*    ENDE NEU   */
  99.  
  100.  
  101.     /* beginnt die Zeile mit einer Ziffernfolge */
  102.     LinePos = ReadBuffer;
  103.     SkipChar ();
  104.     Scan ();                         /* Zeile untersuchen */
  105.                                                                             /* Überprüfe Zeilenanfang auf Ziffer */
  106.     if (Steuer == ZIFFER)      /* Zeilennummer vorhanden */
  107.       {
  108.       NewLine.LineNumber = atoi (ScanBuffer);
  109.       ActLine =                   /* setze aktuelle,
  110.                                     zu bearbeitende Zeile */
  111.       if (MakeToken () == OK)  /* erzeuge eine Tokenzeile */
  112.     InsIntLine ();   /* Prog.zeile in Prg.text einfügen */
  113.       else
  114. /*                          NEUE VERSION            */
  115.     {
  116.     Scan();
  117.     if(strlen(ScanBuffer)==1 && Steuer == ALPHA)  /* 1 Alphazeichen */
  118.         {
  119.         switch ((int)ScanBuffer[0])
  120.             {
  121.             case 'D':    /*     Zeile löschen  */
  122.             case 'd':
  123.                 /* Wenn Zeilennummer vorhanden , Zeile löschen */
  124.                 if (FindInsPos(ActLine->LineNumber,&EditZeile))
  125.                     {
  126.                     printf ("\n Zeile [%d] ist gelöscht !",NewLine.LineNumber);
  127.                     DelLine (NewLine.LineNumber);
  128.                     }
  129.                 else
  130.                 /* Sonst Fehlermeldung        */
  131.                     printf("\n Zeile [%d] nicht gefunden !",NewLine.LineNumber);
  132.  
  133.                 break;
  134.  
  135.             case 'E':   /*     Zeile editieren  */
  136.             case 'e':
  137.                 /* Wenn Zeilennummer vorhanden , Zeile aufbereiten */
  138.                 if (FindInsPos(ActLine->LineNumber,&EditZeile))
  139.                     /* Kopiere den alten Inhalt in die Eingabe Zeile */
  140.                     {
  141.                     itoa(EditZeile->LineNumber,ReadBuffer,10);
  142.                     strcat(ReadBuffer," ");
  143.                     reg = 0xff & *(EditZeile->Zeile);
  144.                     strncat(ReadBuffer,TokBefDesc[reg-TOKMIN].Befehl,10);
  145.                     strcat(ReadBuffer," ");
  146.                     strcat(ReadBuffer,(EditZeile->Zeile+1));
  147.                     loesch=0;
  148.                     }
  149.                 else
  150.                 /* Sonst Fehlermeldung        */
  151.                     printf("\n Zeile [%d] nicht gefunden !",NewLine.LineNumber);
  152.                 break;
  153.  
  154.             default:
  155.                 /*   Falsches Argument    */
  156.                 loesch=0;
  157.                 printf("\n Zeile [%d] ist fehlerhaft !",
  158.                     NewLine.LineNumber);
  159.             }
  160.         }
  161.     else
  162.         /*   Kein Argument oder ungültiger Befehl      */
  163.         {
  164.         printf("\n Zeile [%d] ist fehlerhaft !",NewLine.LineNumber);
  165.         loesch=0;
  166.         }
  167.     }
  168. /*                    ENDE NEUE VERSION                    */
  169.  
  170.       }
  171.     else                /* ansonsten interpretiere Zeile */
  172.       {
  173.       ActLine = 
  174.       SkipChar ();           /* Mit neuem Zeichen starten */
  175.       LinePos = ReadBuffer;  /* Zeilenzeiger zurücksetzen */
  176.       if (MakeToken () == OK)     /* Tokenzeile erzeugen */
  177.     {
  178.         LinePos = ActLine->Zeile;
  179.         InterpLine ();          /* Zeile ausführen lassen */
  180.     }
  181.       else
  182.     {
  183.     sprintf (ReadBuffer,"Befehl <%s> unbekannt",ScanBuffer);
  184.         serror (ReadBuffer);
  185.     }
  186.       }
  187.   }
  188. }
  189.  
  190.  
  191. /* InterpLine
  192.    Die Zeile, auf welche ActLine zeigt, wird interpretiert
  193. */
  194.  
  195. extern  TOKBEF  TokBefDesc[];
  196.  
  197. int
  198. InterpLine ()
  199. {
  200. register int i,error;
  201.  
  202.   i = 0xff & *LinePos;                   /* make unsigned */
  203.   if ((i >= TOKMIN) && (i <= TOKMAX)) {
  204.     LinePos++;              /* aktuellen Befehl überlesen */
  205.     SkipChar ();
  206.                                       /* Befehl ausführen */
  207.     error = TokBefDesc[i-TOKMIN].function ();
  208.   }
  209.   else {
  210.     serror ("<InterpLine> Unbekannter Befehl! ");
  211.     error = FALSE;
  212.   }
  213. return (error);
  214. }
  215.  
  216. /* DoProgram
  217.    arbeitet ein Interpreterprogramm zeilenweise so lange
  218.    ab, bis entweder das Programmtextende erreicht wird, ein
  219.    Fehler auftritt oder die Endeanweisung gefunden wurde.
  220. */
  221. extern  int     IntError;
  222. int     GetNextLine;
  223.  
  224. int
  225. DoProgram ()
  226. {
  227. register int error = TRUE;
  228.  
  229.   while (ActLine && error) {    /* Solange, bis Programmende
  230.                                                  erreicht */
  231.     LinePos = ActLine->Zeile;
  232.     GetNextLine = TRUE;
  233.     error = InterpLine ();    /* Aktuelle Zeile ausführen */
  234.     if (GetNextLine)   /* nächste Programmzeile ausführen */
  235.       ActLine = ActLine->NextZeile;
  236.                          /* Fehler aufgetreten => Abbruch */
  237.       if (IntError) break;
  238.     }
  239.  
  240. return (error);
  241. }
  242.  
  243. /* MakeToken
  244.    Es wird versucht, einen Quelltext, auf den LinePos zeigt,
  245.    in Token zu verwandeln.
  246. */
  247.  
  248. extern  TOKBEF  TokBefDesc[];
  249.  
  250. int
  251. MakeToken ()
  252. {
  253. int     i,j;
  254. int     LineSym;
  255. char    *TokLine;
  256.                             /* Tokenpointer auf Zielzeile */
  257.   TokLine = ActLine->Zeile;
  258.   if (Scan () == UNEOL)       /* Lies nächstes Symbol ein */
  259.   return (ERROR);
  260.  
  261.             /* suche nach einem gültigen Interpreter-Befehl */
  262.   if (TestBefehl(&i) == 0) {           /* Befehl gefunden */
  263.                           /* Token in Zielzeile speichern */
  264.     *TokLine++ = i + TOKMIN;
  265.     *TokLine = '\0';
  266.     if (TokBefDesc[i].CopyRest) {
  267.                             /* kopiere den Rest der Zeile */
  268.       strcat (TokLine,LinePos);
  269.       return (OK);          /* das war's. Zeile fertig    */
  270.     }
  271.     else        /* anderenfalls alle Einzelsymbole holen  */
  272.       for (LineSym = TokBefDesc[i].ParaCount;
  273.            LineSym ; LineSym--) {
  274.                          /* nächste Zeichenkette einlesen */
  275.       if (Scan () == SCANOK)
  276.         if (TestBefehl(&i) == 0) {
  277.                           /* Token in Zielzeile speichern */
  278.           *TokLine++ = i + TOKMIN;
  279.           *TokLine = '\0';
  280.         }
  281.         else {
  282.           strcat (TokLine,ScanBuffer);
  283.                                  /* Zeiger ans Zeilenende */
  284.           TokLine = strchr (TokLine,'\0');
  285.         }
  286.       else
  287.         return (ERROR);
  288.     }
  289.   }
  290.   else
  291.     return (ERROR);
  292. return (OK);
  293. }
  294.  
  295. /*      TestBefehl
  296.         suche nach einem gültigen Interpreter-Befehl
  297. */
  298.  
  299. int
  300. TestBefehl (Befehl)
  301. int     *Befehl;
  302. {
  303. register int i,j;
  304.  
  305.   for (i = 0;
  306.        (TokBefDesc[i].function != NULL) &&
  307.        ((j = strcmp(TokBefDesc[i].Befehl,ScanBuffer)) != 0)
  308.        ; i++) {
  309.     }
  310.   *Befehl = i;
  311. return (j);
  312. }
  313.  
  314. /**************** Ende des Files INTERP.C *****************/
  315.