home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1990 / 10 / int / source / scan.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-06-19  |  5.8 KB  |  253 lines
  1. /**********************************************************/
  2. /*                        SCAN.C                          */
  3. /*            Der Scanner für den Interpreter             */
  4. /*                                                        */
  5. /*          (c) 1989 Michael Beising & TOOLBOX            */
  6. /**********************************************************/
  7.  
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. #include <ctype.h>
  11. #include "interp.h"
  12.  
  13. /* lokale Funktionen dieses Files */
  14. static  void GetChar (void);
  15. static  void GetNextChar (void);
  16. static  void GetZahl (char *buffer);
  17. static  void GetBezeichner (char *buffer);
  18. static  void GetString (char *buffer);
  19. static  void SkipSpace (void);
  20.  
  21. /* In diesem File benutzte Globalvariablen */
  22.                   /* Zeichenposition der aktuellen Zeile  */
  23. extern  char *LinePos;
  24.                  /* der aufrufenden Routine wird mitgeteilt,
  25.                                   um was es sich handelt. */
  26. extern  int  Steuer;
  27.                            /* Ergebnisbuffer des Scanners */
  28. extern  char ScanBuffer[ZEILENLAENGE];
  29.  
  30. /* Modulglobale Variablen */
  31. static  int   NeedNext;
  32. static  char  Charakter;
  33.  
  34. /*      Scan
  35.         liest den Quelltext Zeichen um Zeichen ein
  36.         und meldet zusammengehörige Zeichenfolge
  37. */
  38.  
  39. int
  40. Scan ()
  41. {
  42. unsigned int test;
  43. char    *buffer;
  44.  
  45.   GetChar ();
  46.   SkipSpace ();                /* Leerzeichen überlesen   */
  47.  
  48.   if ((test = isalpha(Charakter)) != FALSE)
  49.     test = ALPHA;
  50.   else
  51.     if ((test = isdigit (Charakter)) != FALSE)
  52.       test = ZIFFER;
  53.     else
  54.       test = Charakter;
  55.  
  56.   switch (test) {
  57.     case ALPHA :                    /* Zeichenkette lesen */
  58.       Steuer = ALPHA;
  59.       GetBezeichner (ScanBuffer);
  60.       NoSkipChar ();
  61.       break;
  62.     case ZIFFER :                   /* Ziffernfolge lesen */
  63.       Steuer = ZIFFER;
  64.       GetZahl (ScanBuffer);
  65.       NoSkipChar ();
  66.       break;
  67.     case '"'        :     /* beliebige Zeichenkette lesen */
  68.       Steuer = STRING;
  69.       GetString (ScanBuffer);
  70.       break;
  71.     case '('        :
  72.     case ')'        :
  73.     case '='        :
  74.     case '<'        :
  75.     case '>'        :
  76.     case '/'        :
  77.     case '*'        :
  78.     case '+'        :
  79.     case '-'        :
  80.       ScanBuffer[0] = Charakter;   /* Charakter in Buffer */
  81.       ScanBuffer[1] = '\0';        /* Stringende setzen   */
  82.       Steuer = SONDER;
  83.       break;
  84.     case ';':
  85.       ScanBuffer[0] = Charakter;   /* Charakter in Buffer */
  86.       ScanBuffer[1] = '\0';        /* Stringende setzen   */
  87.       Steuer = EOLCHAR;
  88.       break;
  89.     case EOLFEHLER:
  90.       return (UNEOL);
  91.     default :                    /* Default-Scanergebnis  */
  92.       Steuer = UNKNOWN;
  93.       fatal_error (" Ungültiges Zeichen gefunden! ");
  94.       return (INVCHAR);
  95.   }                                             /* switch */
  96.  
  97. return (SCANOK);
  98. }
  99.  
  100. /*      SkipSpace
  101.         Überspringen von Leerzeichen im Eingabedatenstrom
  102. */
  103.  
  104. void
  105. SkipSpace ()
  106. {
  107.         while (Charakter == SPACE)
  108.           GetChar ();            /* Leerzeichen überlesen */
  109. }
  110.  
  111. /* GetChar liest, wenn notwendig, das nächste Zeichen oder
  112.    beläßt das alte im Eingabebuffer.
  113.    Für Lookahead notwendig.                               */
  114.  
  115. void
  116. GetChar ()
  117. {
  118. extern int      NeedNext;
  119.  
  120.   if (NeedNext == TRUE)
  121.     GetNextChar ();
  122.   else
  123.     NeedNext = TRUE;            /* beim nächsten Mal erst */
  124. }
  125.  
  126. /* GetNextChar
  127.    liest das nächste gültige Zeichen vom Eingabebuffer */
  128.  
  129. void
  130. GetNextChar ()
  131.  
  132. {
  133. extern char Charakter;
  134. extern char *LinePos;
  135.  
  136.  if (*LinePos != '\0') {
  137.    Charakter = *LinePos++;
  138.  }
  139.  else
  140.    Charakter = EOLFEHLER;     /* Zeile zu Ende - Befehl noch
  141.                                         nicht vollständig */
  142. }
  143.  
  144. /*      GetBezeichner
  145.         Befehl oder Variablenname Einlesen
  146. */
  147.  
  148. void
  149. GetBezeichner (buffer)
  150. char *buffer;
  151.  
  152. {
  153. int count = 0;
  154.  
  155.  while ((isalpha (Charakter) || isdigit (Charakter)) &&
  156.        (Charakter != ';') && (count++ < NAMLEN))
  157.  {
  158.    *buffer++ = Charakter;
  159.    GetChar ();
  160.  }
  161.  *buffer = '\0';
  162. }
  163.  
  164. /*      GetZahl ()
  165.         Ziffernfoge in Buffer einlesen
  166. */
  167.  
  168. void
  169. GetZahl (buffer)
  170. char *buffer;
  171.  
  172. {
  173. int count = 0;
  174.  
  175.   while (((Charakter == '.') || isdigit (Charakter)) &&
  176.          (count++ < NAMLEN))
  177.   {
  178.     if (Charakter == '.') Steuer = FLONUM;
  179.     *buffer++ = Charakter;
  180.     *buffer = '\0';
  181.     GetChar ();
  182.   }
  183. }
  184.  
  185. /*      GetString
  186.         Einen Sting einlesen.
  187. */
  188.  
  189. void
  190. GetString (buffer)
  191. char *buffer;
  192.  
  193. {
  194. int count = 0;
  195.  
  196.   GetChar ();                   /* Stringanfang überlesen */
  197.  
  198.   while ( (Charakter != '"') &&
  199.           (count++ < ZEILENLAENGE))
  200.   {
  201.     *buffer++ = Charakter;
  202.     GetChar ();
  203.     *buffer = '\0';
  204.     if (Charakter == EOLFEHLER) {
  205.       fatal_error ("Stringende läßt sich nicht finden!");
  206.       break;
  207.     }
  208.   }
  209.   GetChar ();     /* erstes Zeichen nach Stringende lesen */
  210. }
  211.  
  212. /*      GetGeklammert
  213.         einen durch Klammern eingeschlossenen Ausdruck
  214.         einlesen
  215. */
  216.  
  217. void
  218. GetGeklammert (buffer)
  219. char *buffer;
  220.  
  221. {
  222. int count = 0;
  223.  
  224.   GetChar ();                          /* NeedNext = TRUE */
  225.  
  226.   while ( (Charakter != ')') &&
  227.           (count++ < ZEILENLAENGE))
  228.   {
  229.     *buffer++ = Charakter;
  230.     GetChar ();
  231.     *buffer = '\0';
  232.     if (Charakter == EOLFEHLER)
  233.       fatal_error ("Rechte Klammer nicht gefunden! ");
  234.   }
  235.   GetChar ();                   /* nächstes Zeichen nach der
  236.                                             Klammer lesen */
  237. }
  238.  
  239. void
  240. NoSkipChar ()
  241. {
  242.   NeedNext = FALSE;             /* kein neues Zeichen holen,
  243.                                         altes noch gültig */
  244. }
  245.  
  246. void
  247. SkipChar ()
  248. {
  249.   NeedNext = TRUE;                /* neues Zeichen holen  */
  250. }
  251.  
  252. /******************** Ende des Files SCAN.C ***************/
  253.