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