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