home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1991 / 04 / txl / 3_preis / fast / scan.c < prev    next >
Text File  |  1990-11-16  |  6KB  |  259 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.   if ((test = isalpha(Charakter)) != FALSE)
  48.     test = ALPHA;
  49.   else
  50.     if ((test = isdigit (Charakter)) != FALSE)
  51.       test = ZIFFER;
  52.     else
  53.       test = Charakter;
  54.  
  55.   switch (test) {
  56.     case ALPHA :                    /* Zeichenkette lesen */
  57.       Steuer = ALPHA;
  58.       GetBezeichner (ScanBuffer);
  59.       NoSkipChar ();
  60.       break;
  61.     case ZIFFER :                   /* Ziffernfolge lesen */
  62.       Steuer = ZIFFER;
  63.       GetZahl (ScanBuffer);
  64.       NoSkipChar ();
  65.       break;
  66.     case '"'        :     /* beliebige Zeichenkette lesen */
  67.       Steuer = STRING;
  68.       GetString (ScanBuffer);
  69.       break;
  70.     case '('        :
  71.     case ')'        :
  72.     case '='        :
  73.     case '<'        :
  74.     case '>'        :
  75.     case '/'        :
  76.     case '*'        :
  77.     case '+'        :
  78.     case '-'        :
  79.       ScanBuffer[0] = Charakter;   /* Charakter in Buffer */
  80.       ScanBuffer[1] = '\0';        /* Stringende setzen   */
  81.       Steuer = SONDER;
  82.       break;
  83.     case ';':
  84.       ScanBuffer[0] = Charakter;   /* Charakter in Buffer */
  85.       ScanBuffer[1] = '\0';        /* Stringende setzen   */
  86.       Steuer = EOLCHAR;
  87.       break;
  88.     case EOLFEHLER:
  89.       return (UNEOL);
  90.     default :                    /* Default-Scanergebnis  */
  91.       Steuer = UNKNOWN;
  92.       fatal_error (" Ungültiges Zeichen gefunden! ");
  93.       return (INVCHAR);
  94.   }                                             /* switch */
  95.  
  96. return (SCANOK);
  97. }
  98.  
  99. /*      SkipSpace
  100.         Überspringen von Leerzeichen im Eingabedatenstrom
  101. */
  102.  
  103. void
  104. SkipSpace ()
  105. {
  106.         while (Charakter == SPACE)
  107.           GetChar ();            /* Leerzeichen überlesen */
  108. }
  109.  
  110. /* GetChar liest, wenn notwendig, das nächste Zeichen oder
  111.    beläßt das alte im Eingabebuffer.
  112.    Für Lookahead notwendig.                               */
  113.  
  114. void
  115. GetChar ()
  116. {
  117. extern int      NeedNext;
  118.  
  119.   if (NeedNext == TRUE)
  120.     GetNextChar ();
  121.   else
  122.     NeedNext = TRUE;            /* beim nächsten Mal erst */
  123. }
  124.  
  125. /* GetNextChar
  126.    liest das nächste gültige Zeichen vom Eingabebuffer */
  127.  
  128. void
  129. GetNextChar ()
  130.  
  131. {
  132. extern char Charakter;
  133. extern char *LinePos;
  134.  
  135.  if (*LinePos != '\0') {
  136.    Charakter = *LinePos++;
  137.  }
  138.  else
  139.    Charakter = EOLFEHLER;     /* Zeile zu Ende - Befehl noch
  140.                                         nicht vollständig */
  141. }
  142.  
  143. /*      GetBezeichner
  144.         Befehl oder Variablenname Einlesen
  145. */
  146.  
  147. void
  148. GetBezeichner (buffer)
  149. char *buffer;
  150.  
  151. {
  152. int count = 0;
  153.  
  154.  while ((isalpha (Charakter) || isdigit (Charakter)) &&
  155.        (Charakter != ';') && (count++ < NAMLEN))
  156.  {
  157.    *buffer++ = Charakter;
  158.    GetChar ();
  159.  }
  160.  *buffer = '\0';
  161. }
  162.  
  163. /*      GetZahl ()
  164.         Ziffernfoge in Buffer einlesen
  165. */
  166.  
  167. void
  168. GetZahl (buffer)
  169. char *buffer;
  170.  
  171. {
  172. int count = 0;
  173.  
  174.   while (((Charakter == '.') || isdigit (Charakter)) &&
  175.          (count++ < NAMLEN))
  176.   {
  177.     if (Charakter == '.')
  178.     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. char *save;
  196.  
  197.   save = buffer;
  198.   GetChar ();                   /* Stringanfang überlesen */
  199.  
  200.   while ( (Charakter != '"') &&
  201.           (count++ < ZEILENLAENGE))
  202.   {
  203.     *buffer++ = Charakter;
  204.     GetChar ();
  205.     *buffer = '\0';
  206.     if (Charakter == EOLFEHLER) {
  207.       *(save+5) = '\0';
  208.       fatal_error ("Stringende läßt sich nicht finden!");
  209.       break;
  210.     }
  211.   }
  212.   GetChar ();     /* erstes Zeichen nach Stringende lesen */
  213. }
  214.  
  215. /*      GetGeklammert
  216.         einen durch Klammern eingeschlossenen Ausdruck
  217.         einlesen
  218. */
  219.  
  220. void
  221. GetGeklammert (buffer)
  222. char *buffer;
  223.  
  224. {
  225. int count = 0;
  226.  
  227.   GetChar ();                          /* NeedNext = TRUE */
  228.  
  229.   while ( (Charakter != ')') &&
  230.           (count++ < ZEILENLAENGE))
  231.   {
  232.     *buffer++ = Charakter;
  233.     GetChar ();
  234.     *buffer = '\0';
  235.     if (Charakter == EOLFEHLER)
  236.       {
  237.       fatal_error ("Rechte Klammer nicht gefunden! ");
  238.       return;
  239.       }
  240.   }
  241.   GetChar ();                   /* nächstes Zeichen nach der
  242.                                             Klammer lesen */
  243. }
  244.  
  245. void
  246. NoSkipChar ()
  247. {
  248.   NeedNext = FALSE;             /* kein neues Zeichen holen,
  249.                                         altes noch gültig */
  250. }
  251.  
  252. void
  253. SkipChar ()
  254. {
  255.   NeedNext = TRUE;                /* neues Zeichen holen  */
  256. }
  257.  
  258. /******************** Ende des Files SCAN.C ***************/
  259.