home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1990 / 10 / int / source / interp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-06-19  |  6.3 KB  |  206 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.  
  14. /* Benoetigte Globalvariablen */
  15. extern  PRGZEILE  *FirstLine; /* erste Interpreterzeile   */
  16. extern  PRGZEILE  *ActLine;   /* aktuelle interp. Zeile   */
  17. extern  char      *LinePos;   /* Zeilenpos. der Akt. Zeile*/
  18. extern  int       Steuer;    /* der aufrufenden Routine wird
  19.                        mitgeteilt, um was es sich handelt.*/
  20.                            /* Ergebnisbuffer des Scanners */
  21. extern  char ScanBuffer[ZEILENLAENGE];
  22. extern  VAR  *FirstVar;  /* Zeiger auf die erste Variable */
  23.  
  24. /* lokale Funktionen und deren Prototypen dieses Files */
  25.  
  26. static  int     TestBefehl (int *Befehl);
  27.  
  28. void
  29. InterAct ()
  30. {
  31. PRGZEILE NewLine;         /* interaktiv eingegebene Zeile */
  32. int      Error;           /* Fehlermeldungen zwischensp.  */
  33. char     ReadBuffer[255];  /* Buffer für eine Eingabezeile*/
  34.  
  35.   FirstLine = NULL;     /* kein Interpretertext vorhanden */
  36.   ActLine   = NULL;
  37.   FirstVar  = NULL;          /* keine Variablen vorhanden */
  38.   SetFileName ("work.mbl");     /* Defaultfilename setzen */
  39.  
  40.   while (TRUE) {
  41.     ResetError ();     /* Fehlermeldungsflag zurücksetzen */
  42.     *NewLine.Zeile = '\0'; /* Zwischenspeicher rücksetzen */
  43.  
  44.     putchar (0x0d);putchar(0x0a);   /* <cr>-<lf> ausgeben */
  45.     putchar ('>');                     /* Prompt ausgeben */
  46.     gets (ReadBuffer);          /* Benutzerzeile einlesen */
  47.  
  48.               /* beginnt die Zeile mit einer Ziffernfolge */
  49.     LinePos = ReadBuffer;
  50.     SkipChar ();
  51.     Scan ();                         /* Zeile untersuchen */
  52.                                                                             /* Überprüfe Zeilenanfang auf Ziffer */
  53.     if (Steuer == ZIFFER) {     /* Zeilennummer vorhanden */
  54.       NewLine.LineNumber = atoi (ScanBuffer);
  55.       ActLine =                   /* setze aktuelle,
  56.                                     zu bearbeitende Zeile */
  57.       if (MakeToken () == OK)  /* erzeuge eine Tokenzeile */
  58.       InsIntLine ();   /* Prog.zeile in Prg.text einfügen */
  59.       else {
  60.         printf ("\n Zeile [%d] ist gelöscht!",
  61.                 NewLine.LineNumber);
  62.         DelLine (NewLine.LineNumber);
  63.       }
  64.     }
  65.     else {               /* ansonsten interpretiere Zeile */
  66.       ActLine = 
  67.       SkipChar ();           /* Mit neuem Zeichen starten */
  68.       LinePos = ReadBuffer;  /* Zeilenzeiger zurücksetzen */
  69.       if (MakeToken () == OK) {    /* Tokenzeile erzeugen */
  70.         LinePos = ActLine->Zeile;
  71.         InterpLine ();          /* Zeile ausführen lassen */
  72.       }
  73.       else {
  74.         sprintf (ReadBuffer,"Befehl <%s> unbekannt",
  75.                  ScanBuffer);
  76.         serror (ReadBuffer);
  77.       }
  78.     }
  79.   }
  80. }
  81.  
  82. /* InterpLine
  83.    Die Zeile, auf welche ActLine zeigt, wird interpretiert
  84. */
  85.  
  86. extern  TOKBEF  TokBefDesc[];
  87.  
  88. int
  89. InterpLine ()
  90. {
  91. register int i,error;
  92.  
  93.   i = 0xff & *LinePos;                   /* make unsigned */
  94.   if ((i >= TOKMIN) && (i <= TOKMAX)) {
  95.     LinePos++;              /* aktuellen Befehl überlesen */
  96.     SkipChar ();
  97.                                       /* Befehl ausführen */
  98.     error = TokBefDesc[i-TOKMIN].function ();
  99.   }
  100.   else {
  101.     serror ("Unbekannter Befehl! ");
  102.     error = FALSE;
  103.   }
  104. return (error);
  105. }
  106.  
  107. /* DoProgram
  108.    arbeitet ein Interpreterprogramm zeilenweise so lange
  109.    ab, bis entweder das Programmtextende erreicht wird, ein
  110.    Fehler auftritt oder die Endeanweisung gefunden wurde.
  111. */
  112. extern  int     IntError;
  113. int     GetNextLine;
  114.  
  115. int
  116. DoProgram ()
  117. {
  118. register int error = TRUE;
  119.  
  120.   while (ActLine && error) {    /* Solange, bis Programmende
  121.                                                  erreicht */
  122.     LinePos = ActLine->Zeile;
  123.     GetNextLine = TRUE;
  124.     error = InterpLine ();    /* Aktuelle Zeile ausführen */
  125.     if (GetNextLine)   /* nächste Programmzeile ausführen */
  126.       ActLine = ActLine->NextZeile;
  127.                          /* Fehler aufgetreten => Abbruch */
  128.       if (IntError) break;
  129.     }
  130.  
  131. return (error);
  132. }
  133.  
  134. /* MakeToken
  135.    Es wird versucht, einen Quelltext, auf den LinePos zeigt,
  136.    in Token zu verwandeln.
  137. */
  138.  
  139. extern  TOKBEF  TokBefDesc[];
  140.  
  141. int
  142. MakeToken ()
  143. {
  144. int     i,j;
  145. int     LineSym;
  146. char    *TokLine;
  147.                             /* Tokenpointer auf Zielzeile */
  148.   TokLine = ActLine->Zeile;
  149.   if (Scan () == UNEOL)       /* Lies nächstes Symbol ein */
  150.   return (ERROR);
  151.  
  152.             /* suche nach einem gültigen Interpreter-Befehl */
  153.   if (TestBefehl(&i) == 0) {           /* Befehl gefunden */
  154.                           /* Token in Zielzeile speichern */
  155.     *TokLine++ = i + TOKMIN;
  156.     *TokLine = '\0';
  157.     if (TokBefDesc[i].CopyRest) {
  158.                             /* kopiere den Rest der Zeile */
  159.       strcat (TokLine,LinePos);
  160.       return (OK);          /* das war's. Zeile fertig    */
  161.     }
  162.     else        /* anderenfalls alle Einzelsymbole holen  */
  163.       for (LineSym = TokBefDesc[i].ParaCount;
  164.            LineSym ; LineSym--) {
  165.                          /* nächste Zeichenkette einlesen */
  166.       if (Scan () == SCANOK)
  167.         if (TestBefehl(&i) == 0) {
  168.                           /* Token in Zielzeile speichern */
  169.           *TokLine++ = i + TOKMIN;
  170.           *TokLine = '\0';
  171.         }
  172.         else {
  173.           strcat (TokLine,ScanBuffer);
  174.                                  /* Zeiger ans Zeilenende */
  175.           TokLine = strchr (TokLine,'\0');
  176.         }
  177.       else
  178.         return (ERROR);
  179.     }
  180.   }
  181.   else
  182.     return (ERROR);
  183. return (OK);
  184. }
  185.  
  186. /*      TestBefehl
  187.         suche nach einem gültigen Interpreter-Befehl
  188. */
  189.  
  190. int
  191. TestBefehl (Befehl)
  192. int     *Befehl;
  193. {
  194. register int i,j;
  195.  
  196.   for (i = 0;
  197.        (TokBefDesc[i].function != NULL) &&
  198.        ((j = strcmp(TokBefDesc[i].Befehl,ScanBuffer)) != 0)
  199.        ; i++) {
  200.     }
  201.   *Befehl = i;
  202. return (j);
  203. }
  204.  
  205. /**************** Ende des Files INTERP.C *****************/
  206.