home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / text / misc / cvt / source / cvtparse.c < prev    next >
C/C++ Source or Header  |  1994-05-28  |  41KB  |  1,412 lines
  1. /*                                                               -*- C -*-
  2.  *  CVTPARSE.C
  3.  *
  4.  *  (c)Copyright 1993 by Tobias Ferber,  All Rights Reserved
  5.  */
  6.  
  7. #include <stdarg.h>
  8. #include <string.h>
  9. #include <stdlib.h>
  10. #include <stdio.h>
  11.  
  12. #include "cvt.h"
  13.  
  14. #ifndef isprint
  15. #define isprint(c) (' '<=(c) && (c)<='~')
  16. #endif /* !isprint */
  17.  
  18.  
  19. /*** / LERROR / ***/
  20.  
  21. void lerror(long line, const char *fmt, ...)
  22. /* gibt eine Fehlermeldung 'fmt' f"ur die Zeile #line aus. */
  23. { 
  24.   va_list argp;
  25.   va_start(argp,fmt);
  26.   fprintf(ferr,"line %ld: ",line);
  27.   vfprintf(ferr,(char *)fmt,argp);
  28.   fprintf(ferr,"\n");
  29.   fflush(ferr);
  30.   ++global_numerrors;
  31.   va_end(argp);
  32. }
  33.  
  34.  
  35. /*** / READCRULE / ***/
  36.  
  37. crule_t *readcrule(FILE *fp)
  38. /*
  39.    Diese Funktion bildet den lexical Scanner.  Sie überliest Leerzeichen,
  40.    TABs, Zeilenwechsel und Kommentare, liest die nächste Transformationsregel
  41.    ein und baut daraus eine crule_t Struktur auf.  Ein Zeiger auf diese
  42.    crule_t Struktur (vom Typ crule_t *) wird zurückgegeben.
  43.  
  44.    Fehlermeldungen werden mit lerror() ausgegeben, die Zeilennummern werden
  45.    hier gezählt.  Man beachte, daß deshalb keine andere Funktion 'fp'
  46.    über ein Zeilenende schieben darf, da sonst die Nummerierung falsch wird.
  47.  
  48.    Diese Funktion überliest alle Zeichen, die Teil eines Kommentares sind.
  49.    Ein Kommentar ist (wie in C) alles zwischen einem '/' + '*' Token
  50.    und dem korrespondierenden '*' + '/'.  Es sind auch C++ Kommentare
  51.    (hier 'remark' genannt) erlaubt.  Letztere werden durch zwei Slashes
  52.    '/' + '/' eingeleitet und reichen dann bis zum Ende der Zeile in der
  53.    sie auftreten.  Genau wie in C (und C++) sind geschachtelte Kommentare
  54.    (nested comments) hier NICHT erlaubt.
  55. */
  56.  
  57. {
  58.   static unsigned char *xhsbuf= (unsigned char *)0L;
  59.   static unsigned long bufsize= 0L;
  60.  
  61.   /* Der xhs-Buffer ist statisch & dynamisch und wird beim jungfräulichen
  62.      Aufruf dieser Funktion aufgebaut.  Dabei werden zunächst 'XHSBUFSIZE'
  63.      Bytes allokiert und bei jedem Überlauf ebensoviele mittels realloc()
  64.      angehängt. */
  65.  
  66.   static unsigned long line= 1;  /* line counter */
  67.  
  68.   crule_t *cr;               /* current rule */
  69.   unsigned long n=0;         /* #of chars read into xhsbuf[] */
  70.   unsigned char c;           /* currently read character */
  71.  
  72.   int ccode= 0;              /* char code built up by collecting digits */
  73.   int ccdigits= 0;           /* #of digits collected for ccode */
  74.  
  75.   char xhs='l';              /* working on the lhs ('l') or rhs ('r') */
  76.  
  77.   /* local script file scanner modes */
  78.  
  79.   typedef enum {
  80.  
  81.     data_mode,               /* Im data_mode werden "white" characters
  82.                               * enfernt.  Vom data_mode aus kann bis auf
  83.                               * in den instruction_mode in jeden anderen
  84.                               * scanner mode übergegangen werden. */
  85.  
  86.     instruction_mode,        /* In den instruction_mode wird übergegangen,
  87.                               * wenn ein data packet beendet ist.
  88.                               * Der Scanner erwartet dann entweder ein
  89.                               * concatenation token (CATSYM) oder ein
  90.                               * derivation token `->'.  Auch in diesem
  91.                               * scanner mode werden "white" characters
  92.                               * entfernt. */
  93.  
  94.     decimal_mode,
  95.     hex_mode,
  96.     octal_mode,              /* In diesen Modi werden die Ziffern für ein
  97.                               * character token eingesammelt.  In den
  98.                               * decimal_mode kann nur vom data_mode aus
  99.                               * übergegangen werden, während die beiden
  100.                               * anderen Modi auch über den string_mode
  101.                               * erreicht werden können. */
  102.  
  103.     string_mode,             /* Im string_mode werden die Zeichen für
  104.                               * ein data packet direkt eingesammelt, also
  105.                               * ohne Umweg über die character codes.
  106.                               * In den string_mode wird übergegangen, wenn
  107.                               * der Scanner im data_mode auf ein double
  108.                               * quote `"' stößt.  Ein weiteres (nicht mit
  109.                               * einem Backslash "escapetes" double quote
  110.                               * bringt den scanner in den instruction_mode. */
  111.  
  112.     remark_mode,
  113.     comment_mode,            /* Diese Modi können sowohl vom data_mode
  114.                               * als auch vom instruction_mode aus erreicht
  115.                               * werden, wenn der Scanner auf den entsprechenden
  116.                               * comment leader (s.o) trifft.
  117.                               * In diesem Fall wird der momentane scanner
  118.                               * mode in einen Stack gepushed und am Ende
  119.                               * des Kommentars wieder gepoppt. */
  120.  
  121.     return_mode,             /* In den return_mode wird übergegangen, wenn
  122.                               * die Transformationsregel komplett ist, also
  123.                               * wenn ein RTERM im instruction_mode auf der
  124.                               * rechten Seite gefunden wurde. */
  125.  
  126.     error_mode,              /* Wenn etwas in den Schlüpfer geht, so geht
  127.                               * auch der Scanner.  Nämlich in den error_mode
  128.                               * über ;)  Die Zeichen bis zum nächsten RTERM
  129.                               * oder EOF werden dann überlesen. */
  130.  
  131.     panic_mode,              /* Im Vergleich zum error_mode kehrt der scanner
  132.                               * im panic_mode sofort zurück ohne bis zum
  133.                               * nächsten RTERM weiterzulesen. */
  134.   } smode_t;
  135.  
  136.   smode_t smode;             /* current scanner mode */
  137.   smode_t smstack;           /* previous scanner mode; needed to restore
  138.                               * 'smode' e.g. when leaving 'remark_mode' */
  139.  
  140.   /* Um den von dieser Funktion allokierten xhsbuf wieder freizugeben
  141.      genügt es, diese mit einem FILE *fp == NULL aufzurufen.
  142.      Unabhängig von der Existenz des xhsbuf ist ein Aufruf dieser Funktion
  143.      mit fp == NULL ungefährlich. */
  144.  
  145.   if(!fp)
  146.   { if(xhsbuf)
  147.     { free(xhsbuf);
  148.       xhsbuf= (unsigned char *)0L;
  149.     }
  150.     bufsize= 0L;
  151.     line= 1;
  152.     return NIL(crule_t);
  153.   }
  154.  
  155.   /* Initially we expect some char data */
  156.   smode= smstack= data_mode;
  157.  
  158.   if(!xhsbuf)
  159.   {
  160.     xhsbuf= (unsigned char *)malloc(XHSBUFSIZE * sizeof(char));
  161.  
  162.     if(!xhsbuf)
  163.     { echo("Not enough memory to read rules.");
  164.       return NIL(crule_t);
  165.     }
  166.     bufsize= XHSBUFSIZE;
  167.   }
  168.  
  169.   if( ! (cr= new()) )
  170.   {
  171.     lerror(line,"Ran out of memory w/ %ld rules read.",global_numrules);
  172.     smode= panic_mode;
  173.   }
  174.  
  175.   /* let's roll... */
  176.   while( smode != return_mode  &&
  177.          smode != error_mode   &&
  178.          smode != panic_mode   &&  !ferror(fp) && !feof(fp) )
  179.   {
  180.     c= fgetc(fp);
  181.  
  182.     if(feof(fp) && c!=(unsigned char)EOF)
  183.     {
  184. #ifdef DEBUG
  185.       printf("scanner: line %ld: feof()==TRUE but fgetc()==0x%02x\n",
  186.         line, (int)(c&0xFF));
  187. #endif /* DEBUG */
  188.       c= (unsigned char)EOF;
  189.     }
  190.  
  191. #ifdef _DCC /* buggy shareware DICE */
  192.     switch( (int) c & 0xFF )
  193.  
  194. #else
  195.     switch(c)
  196.  
  197. #endif
  198.     {
  199.  
  200. /**/  case ' ':
  201.       case '\t':
  202.         switch(smode)
  203.         {
  204.           case decimal_mode:
  205.             xhsbuf[n++]= (char)ccode;
  206.             smode= instruction_mode;
  207.             break;
  208.  
  209.           case hex_mode:
  210.           case octal_mode:
  211.             if(smstack==string_mode)
  212.             {
  213.               if(ccdigits==0)
  214.               { /* can not happen in octal_mode in string_mode */
  215.                 lerror(line,"\\x used with no following hex digits");
  216.                 smode= error_mode;
  217.               }
  218.               else /* ccdigits > 0 */
  219.               {
  220.                 xhsbuf[n++]= (char)ccode;
  221.                 smode= smstack; /* == string_mode */
  222.                 ungetc(c,fp);
  223.               }
  224.             }
  225.             else /* smstack != string_mode */
  226.             {
  227.               if(ccdigits==0)
  228.               {
  229.                 if(smode==hex_mode)
  230.                 {
  231.                   lerror(line,"$ used with no following hex digits");
  232.                   smode= error_mode;
  233.                 }
  234.                 else /* smode==octal_mode */
  235.                 {
  236.                   xhsbuf[n++]= (char)ccode; /* == 0 */
  237.                   smode= instruction_mode;
  238.                 }
  239.               }
  240.               else /* ccdigits > 0 */
  241.               {
  242.                 xhsbuf[n++]= (char)ccode;
  243.                 smode= instruction_mode;
  244.               }
  245.             }
  246.             break;
  247.  
  248.           case string_mode:
  249.             xhsbuf[n++]= c;
  250.             break;
  251.  
  252.           case data_mode:
  253.           case instruction_mode:
  254.           case remark_mode:
  255.           case comment_mode:
  256.           case return_mode:
  257.           case error_mode:
  258.           case panic_mode:
  259.             break;
  260.         }
  261.         break;
  262.  
  263. /**/  case '\n':
  264.       case '\r':
  265.         switch(smode)
  266.         {
  267.           case decimal_mode:
  268.             xhsbuf[n++]= (char)ccode;
  269.             smode= instruction_mode;
  270.             break;
  271.  
  272.           case hex_mode:
  273.           case octal_mode:
  274.             if(smstack==string_mode)
  275.             {
  276.               lerror(line,"unterminated string at EOL; missing quotes");
  277.               smode= error_mode;
  278.             }
  279.             else /* smstack != string_mode */
  280.             {
  281.               if(ccdigits==0)
  282.               {
  283.                 if(smode==hex_mode)
  284.                 {
  285.                   lerror(line,"$ used with no following hex digits");
  286.                   smode= error_mode;
  287.                 }
  288.                 else /* smode==octal_mode */
  289.                 {
  290.                   xhsbuf[n++]= (char)ccode; /* == 0 */
  291.                   smode= smstack; /* == instruction_mode */
  292.                 }
  293.               }
  294.               else /* ccdigits > 0 */
  295.               {
  296.                 xhsbuf[n++]= (char)ccode;
  297.                 smode= smstack; /* == instruction_mode */
  298.               }
  299.             }
  300.             break;
  301.  
  302.           case string_mode:
  303.             lerror(line,"unterminated string at EOL; missing quotes");
  304.             smode= error_mode;
  305.             break;
  306.  
  307.           case remark_mode:
  308.             smode= smstack;
  309.             break;
  310.  
  311.           case data_mode:
  312.           case instruction_mode:
  313.           case comment_mode:
  314.           case return_mode:
  315.           case error_mode:
  316.           case panic_mode:
  317.             break;
  318.         }
  319.         line++; /* in any case */
  320.  
  321.         /*
  322.          * look foreward and forget about the second character of
  323.          * the newline tuple if there is one.
  324.          */
  325.  
  326.         { int d= fgetc(fp);
  327.           if(!( (c=='\n' && d=='\r') || (c=='\r' && d=='\n') ))
  328.             ungetc(d,fp);
  329.         }
  330.         break;
  331.  
  332. /**/  case CATSYM:
  333.         switch(smode)
  334.         {
  335.           case data_mode:
  336.             lerror(line,"extra `%c' or missing character data",c);
  337.             smode= error_mode;
  338.             break;
  339.  
  340.           case instruction_mode:
  341.             smode= data_mode;
  342.             break;
  343.  
  344.           case decimal_mode:
  345.             xhsbuf[n++]= (char)ccode;
  346.             smode= data_mode;
  347.             break;
  348.  
  349.           case hex_mode:
  350.           case octal_mode:
  351.             if(smstack==string_mode)
  352.             {
  353.               if(ccdigits==0)
  354.               { /* can not happen in octal_mode in string mode */
  355.                 lerror(line,"\\x used with no following hex digits");
  356.                 smode= error_mode;
  357.               }
  358.               else /* ccdigits > 0 */
  359.               {
  360.                 xhsbuf[n++]= (char)ccode;
  361.                 smode= smstack; /* == string_mode */
  362.                 ungetc(c,fp);
  363.               }
  364.             }
  365.             else /* smstack != string_mode */
  366.             {
  367.               if(ccdigits==0)
  368.               {
  369.                 if(smode==hex_mode)
  370.                 {
  371.                   lerror(line,"$ used with no following hex digits");
  372.                   smode= error_mode;
  373.                 }
  374.                 else /* smode==octal_mode */
  375.                 {
  376.                   xhsbuf[n++]= (char)ccode; /* == 0 */
  377.                   smode= data_mode;
  378.                 }
  379.               }
  380.               else /* ccdigits > 0 */
  381.               {
  382.                 xhsbuf[n++]= (char)ccode;
  383.                 smode= data_mode;
  384.               }
  385.             }
  386.             break;
  387.  
  388.           case string_mode:
  389.             xhsbuf[n++]= c;
  390.             break;
  391.  
  392.           case remark_mode:
  393.           case comment_mode:
  394.           case return_mode:
  395.           case error_mode:
  396.           case panic_mode:
  397.             break;
  398.         }
  399.         break;
  400.  
  401. /**/  case '-':
  402.         switch(smode)
  403.         {
  404.           case data_mode:
  405.             lerror(line,"misplaced unary minus `%c'",c);
  406.             smode= error_mode;
  407.             break;
  408.  
  409.           case instruction_mode:
  410.             switch(c= fgetc(fp))
  411.             {
  412.               case '>':
  413.                 if(xhs=='l')
  414.                 {
  415.                   if(n>0)
  416.                   {
  417.                     char *t;
  418.  
  419.                     if( t= (char *)malloc(n*sizeof(char)) )
  420.                     {
  421.                       memcpy(t, xhsbuf, n);
  422.                       cr->lhs= t;
  423.                       cr->l= n;
  424.                       xhs= 'r';
  425.                       smode= data_mode;
  426.                       n= 0;
  427.                     }
  428.                     else /* t == (char *)0 */
  429.                     {
  430.                       lerror(line,"not enough memory for another %d bytes lhs",n);
  431.                       smode= panic_mode;
  432.                     }
  433.                   }
  434.                   else /* n==0 */
  435.                   {
  436.                     lerror(line,"malformed or empty lhs; misplaced `->'");
  437.                     smode= error_mode;
  438.                   }
  439.                 }
  440.                 else /* xhs=='r' */
  441.                 {
  442.                   lerror(line,"more than one derivation token `->' in this rule");
  443.                   smode= error_mode;
  444.                 }
  445.                 break;
  446.  
  447.               default:
  448.                 lerror(line,"misplaced minus sign `-'; subtraction not supported",c);
  449.                 smode= error_mode;
  450.                 break;
  451.             }
  452.             break;
  453.  
  454.           case decimal_mode:
  455.             xhsbuf[n++]= (char)ccode;
  456.             smode= instruction_mode;
  457.             ungetc(c,fp);
  458.             break;
  459.  
  460.           case hex_mode:
  461.           case octal_mode:
  462.             if(smstack==string_mode)
  463.             {
  464.               if(ccdigits==0)
  465.               { /* can not happen in octal_mode in string_mode */
  466.                 lerror(line,"\\x used with no following hex digits");
  467.                 smode= error_mode;
  468.               }
  469.               else /* ccdigits > 0 */
  470.               {
  471.                 xhsbuf[n++]= (char)ccode;
  472.                 smode= smstack; /* == string_mode */
  473.                 ungetc(c,fp);
  474.               }
  475.             }
  476.             else /* smstack != string_mode */
  477.             {
  478.               if(ccdigits==0)
  479.               {
  480.                 if(smode==hex_mode)
  481.                 {
  482.                   lerror(line,"$ used with no following hex digits");
  483.                   smode= error_mode;
  484.                 }
  485.                 else /* smode==octal_mode */
  486.                 {
  487.                   xhsbuf[n++]= (char)ccode; /* == 0 */
  488.                   smode= instruction_mode;
  489.                   ungetc(c,fp);
  490.                 }
  491.               }
  492.               else /* ccdigits > 0 */
  493.               {
  494.                 xhsbuf[n++]= (char)ccode;
  495.                 smode= instruction_mode;
  496.                 ungetc(c,fp);
  497.               }
  498.             }
  499.             break;
  500.  
  501.           case string_mode:
  502.             xhsbuf[n++]= c;
  503.             break;
  504.  
  505.           case remark_mode:
  506.           case comment_mode:
  507.           case return_mode:
  508.           case error_mode:
  509.           case panic_mode:
  510.             break;
  511.         }
  512.         break;
  513.  
  514. /**/  case RTERM:
  515.         switch(smode)
  516.         {
  517.           case data_mode:
  518.             if(xhs=='r')
  519.             {
  520.               if(n==0) /* allow an empty RHS */
  521.               {
  522.                 smode= return_mode;
  523.               }
  524.               else
  525.               {
  526.                 lerror(line,"extra `%c' or `->' before `%c'",CATSYM,c);
  527.                 smode= error_mode;
  528.               }
  529.             }
  530.             else /* xhs=='l' */
  531.             {
  532.               if(n==0)
  533.               {
  534.                 lerror(line,"empty rule or extra `%c'",c);
  535.               }
  536.               else
  537.               {
  538.                 lerror(line,"extra `%c' before `%c'",CATSYM,c);
  539.                 lerror(line,"missing derivation token `->'");
  540.               }
  541.               smode= error_mode;
  542.             }
  543.             break;
  544.  
  545.           case instruction_mode:
  546.             if(xhs=='r')
  547.             {
  548.               smode= return_mode;
  549.             }
  550.             else
  551.             {
  552.               lerror(line,"missing derivation token `->'");
  553.               smode= error_mode;
  554.             }
  555.             break;
  556.  
  557.           case decimal_mode:
  558.             if(xhs=='r')
  559.             {
  560.               xhsbuf[n++]= (char)ccode;
  561.               smode= return_mode;
  562.             }
  563.             else /* xhs=='l' */
  564.             {
  565.               lerror(line,"missing derivation token `->'");
  566.               smode= error_mode;
  567.             }
  568.             break;
  569.  
  570.           case hex_mode:
  571.           case octal_mode:
  572.             if(xhs=='r')
  573.             {
  574.               if(smstack==string_mode)
  575.               {
  576.                 if(ccdigits==0)
  577.                 { /* can not happen in octal_mode in string_mode */
  578.                   lerror(line,"\\x used with no following hex digits");
  579.                   smode= error_mode;
  580.                 }
  581.                 else /* ccdigits > 0 */
  582.                 {
  583.                   xhsbuf[n++]= (char)ccode;
  584.                   smode= smstack; /* == string_mode */
  585.                   ungetc(c,fp);
  586.                 }
  587.               }
  588.               else /* smstack != string_mode */
  589.               {
  590.                 if(ccdigits==0)
  591.                 {
  592.                   if(smode==hex_mode)
  593.                   {
  594.                     lerror(line,"$ used with no following hex digits");
  595.                     smode= error_mode;
  596.                   }
  597.                   else /* smode==octal_mode */
  598.                   {
  599.                     xhsbuf[n++]= (char)ccode; /* == 0 */
  600.                     smode= return_mode;
  601.                   }
  602.                 }
  603.                 else /* ccdigits > 0 */
  604.                 {
  605.                   xhsbuf[n++]= (char)ccode;
  606.                   smode= return_mode;
  607.                 }
  608.               }
  609.             }
  610.             else /* xhs=='l' */
  611.             {
  612.               lerror(line,"missing derivation token `->'");
  613.               smode= error_mode;
  614.             }
  615.             break;
  616.  
  617.           case string_mode:
  618.             xhsbuf[n++]= c;
  619.             break;
  620.  
  621.           case remark_mode:
  622.           case comment_mode:
  623.           case return_mode:
  624.           case error_mode:
  625.           case panic_mode:
  626.             break;
  627.         }
  628.         break;
  629.  
  630.       /* Ein EOF character kann auch auftreten wenn das Ende des
  631.          Streams noch gar nicht erreicht ist.  Es werden also diese
  632.          beiden Fälle separat betrachtet: */
  633.  
  634. /**/  case (unsigned char)EOF:
  635.         switch(smode)
  636.         {
  637.           case data_mode:
  638.             if( feof(fp) )
  639.             {
  640.               if(xhs=='l')
  641.               {
  642.                 if(n > 0)
  643.                 {
  644.                   lerror(line,"malformed rule at EOF; missing `->'");
  645.                   smode= error_mode;
  646.                 }
  647.                 /* else wird am Ende der Schleife sowieso behandelt */
  648.               }
  649.               else /* xhs=='r' */
  650.               {
  651.                 if(n==0)
  652.                 {
  653.                   lerror(line,"missing `%c' at EOF; rhs is empty",RTERM);
  654.                 }
  655.                 else
  656.                 {
  657.                   lerror(line,"malformed rhs at EOF; expected `%c' (not `%c')",RTERM,CATSYM);
  658.                 }
  659.                 smode= error_mode;
  660.               }
  661.             }
  662.             else /* !feof(fp) */
  663.             {
  664.               lerror(line,"misplaced EOF character `\\x%02x'",c);
  665.               smode= error_mode;
  666.             }
  667.             break;
  668.  
  669.           case instruction_mode:
  670.             if( feof(fp) )
  671.             {
  672.               if(xhs=='l')
  673.               {
  674.                 lerror(line,"malformed rule at EOF; incomplete lhs");
  675.               }
  676.               else
  677.               {
  678.                 lerror(line,"unexpected EOF; missing `%c'",RTERM);
  679.               }
  680.               smode= error_mode;
  681.             }
  682.             else /* !feof(fp) */
  683.             {
  684.               lerror(line,"misplaced EOF character `\\x%02x'",c);
  685.               smode= error_mode;
  686.             }
  687.             break;
  688.  
  689.           case decimal_mode:
  690.           case hex_mode:
  691.           case octal_mode:
  692.             if( feof(fp) )
  693.             {
  694.               lerror(line,"unexpected end of input; missing `%c'",RTERM);
  695.             }
  696.             else
  697.             {
  698.               lerror(line,"misplaced EOF character `\\x%02x'",c);
  699.             }
  700.             smode= error_mode;
  701.             break;
  702.  
  703.           case string_mode:
  704.             if( feof(fp) )
  705.             {
  706.               lerror(line,"unterminated string at EOF");
  707.               smode= error_mode;
  708.             }
  709.             else /* !feof(fp) */
  710.             {
  711.               xhsbuf[n++]= c;
  712.             }
  713.             break;
  714.  
  715.           case comment_mode:
  716.             if( feof(fp) )  /* else ist dann Wurschd */
  717.             {
  718.               lerror(line,"unterminated comment at EOF; closing `*/' missing");
  719.               smode= error_mode;
  720.             }
  721.             break;
  722.  
  723.           case remark_mode:
  724.           case return_mode:
  725.           case error_mode:
  726.           case panic_mode:
  727.             break;
  728.         }
  729.         break;
  730.  
  731. /**/  case '$':
  732.         switch(smode)
  733.         {
  734.           case data_mode:
  735.             smstack= instruction_mode;
  736.             smode= hex_mode;
  737.             ccode= 0;
  738.             ccdigits= 0;
  739.             break;
  740.  
  741.           case instruction_mode:
  742.           case decimal_mode:
  743.             lerror(line,"misplaced hex token `%c' or missing `%c'",c,CATSYM);
  744.             smode= error_mode;
  745.             break;
  746.  
  747.           case hex_mode:
  748.           case octal_mode:
  749.             if(smstack==string_mode)
  750.             {
  751.               if(ccdigits==0)
  752.               { /* can not happen in octal_mode in string_mode */
  753.                 lerror(line,"\\x used with no following hex digits");
  754.                 smode= error_mode;
  755.               }
  756.               else /* ccdigits > 0 */
  757.               {
  758.                 xhsbuf[n++]= (char)ccode;
  759.                 smode= smstack; /* == string_mode */
  760.                 ungetc(c,fp);
  761.               }
  762.             }
  763.             else /* smstack != string_mode */
  764.             {
  765.               lerror(line,"misplaced hex token `%c' or missing `%c'",c,CATSYM);
  766.               smode= error_mode;
  767.             }
  768.             break;
  769.  
  770.           case string_mode:
  771.             xhsbuf[n++]= c;
  772.             break;
  773.  
  774.           case remark_mode:
  775.           case comment_mode:
  776.           case return_mode:
  777.           case error_mode:
  778.           case panic_mode:
  779.             break;
  780.         }
  781.         break;
  782.  
  783. /**/  case '\"':
  784.         switch(smode)
  785.         {
  786.           case data_mode:
  787.             smode= string_mode;
  788.             break;
  789.  
  790.           case instruction_mode:
  791.           case decimal_mode:
  792.             lerror(line,"unmatched quotes or missing `%c'",CATSYM);
  793.             smode= error_mode;
  794.             break;
  795.  
  796.           case hex_mode:
  797.           case octal_mode:
  798.             if(smstack==string_mode)
  799.             {
  800.               if(ccdigits==0)
  801.               { /* can not happen in octal_mode in string_mode */
  802.                 lerror(line,"\\x used with no following hex digits");
  803.                 smode= error_mode;
  804.               }
  805.               else /* ccdigits > 0 */
  806.               {
  807.                 xhsbuf[n++]= (char)ccode;
  808.                 smode= smstack; /* == string_mode */
  809.                 ungetc(c,fp);
  810.               }
  811.             }
  812.             else /* smstack != string_mode */
  813.             {
  814.               lerror(line,"unmatched quotes or missing `%c'",CATSYM);
  815.               smode= error_mode;
  816.             }
  817.             break;
  818.  
  819.           case string_mode:
  820.             smode= instruction_mode;
  821.             break;
  822.  
  823.           case remark_mode:
  824.           case comment_mode:
  825.           case return_mode:
  826.           case error_mode:
  827.           case panic_mode:
  828.             break;
  829.         }
  830.         break;
  831.  
  832. /**/  case '\\':
  833.         switch(smode)
  834.         {
  835.           case data_mode:
  836.           case instruction_mode:
  837.           case decimal_mode:
  838.             lerror(line,"misplaced escape character `%c' or missing quotes",c);
  839.             smode= error_mode;
  840.             break;
  841.  
  842.           case hex_mode:
  843.           case octal_mode:
  844.             if(smstack==string_mode)
  845.             {
  846.               if(ccdigits==0)
  847.               { /* can not happen in octal_mode in string_mode */
  848.                 lerror(line,"\\x used with no following hex digits");
  849.                 smode= error_mode;
  850.               }
  851.               else /* ccdigits > 0 */
  852.               {
  853.                 xhsbuf[n++]= (char)ccode;
  854.                 smode= smstack; /* == string_mode */
  855.                 ungetc(c,fp);
  856.               }
  857.             }
  858.             else /* smstack != string_mode */
  859.             {
  860.               lerror(line,"misplaced escape character `%c' or missing quotes",c);
  861.               smode= error_mode;
  862.             }
  863.             break;
  864.  
  865.           case string_mode:
  866.  
  867.             /* character constants taken from 'The C++ Programming Language'
  868.              * Second Edition, Bjarne Stroustup, AT&T Bell Laboratories */
  869.  
  870.             switch(c= fgetc(fp))
  871.             {
  872.               case 'n':  xhsbuf[n++]= '\n'; break;  /* newline */
  873.               case 't':  xhsbuf[n++]= '\t'; break;  /* horizontal tab */
  874.               case 'v':  xhsbuf[n++]= '\v'; break;  /* vertical tab */
  875.               case 'b':  xhsbuf[n++]= '\b'; break;  /* backspace */
  876.               case 'r':  xhsbuf[n++]= '\r'; break;  /* carriage return */
  877.               case 'f':  xhsbuf[n++]= '\f'; break;  /* form feed */
  878.               case 'a':  xhsbuf[n++]= '\a'; break;  /* alert */
  879.               case '\\': xhsbuf[n++]= '\\'; break;  /* backslash */
  880.               case '?':  xhsbuf[n++]= '\?'; break;  /* question mark */
  881.               case '\'': xhsbuf[n++]= '\''; break;  /* single quote */
  882.               case '\"': xhsbuf[n++]= '\"'; break;  /* double quote */
  883.               case '0':
  884.               case '1':
  885.               case '2':
  886.               case '3':
  887.               case '4':
  888.               case '5':
  889.               case '6':
  890.               case '7':
  891.                 smstack= smode; /* == string_mode */
  892.                 smode= octal_mode;
  893.                 ccode= (int)c-'0';
  894.                 ccdigits= 1;
  895.                 break;
  896.  
  897.               case 'x':
  898.               case 'X': /* how about the uppercase 'X' ? */
  899.                 smstack= smode; /* == string_mode */
  900.                 smode= hex_mode;
  901.                 ccode= 0;
  902.                 ccdigits= 0;
  903.                 break;
  904.  
  905.               default:
  906.                 lerror(line,
  907.                   ( isprint(c)
  908.                   ? "unknown escape sequence `\\%c'"
  909.                   : "unknown escape sequence: `\\' followed by char code 0x%x"
  910.                   ),c
  911.                 );
  912.                 smode= error_mode;
  913.                 break;
  914.             }
  915.             break;
  916.  
  917.           case remark_mode:
  918.           case comment_mode:
  919.           case return_mode:
  920.           case error_mode:
  921.           case panic_mode:
  922.             break;
  923.         }
  924.         break;
  925.  
  926. /**/  case '/':
  927.         switch(smode)
  928.         {
  929.           case data_mode:
  930.           case instruction_mode:
  931.             switch(c= fgetc(fp))
  932.             {
  933.               case '*':
  934.                 smstack= smode;
  935.                 smode= comment_mode;
  936.                 break;
  937.  
  938.               case '/':
  939.                 smstack= smode;
  940.                 smode= remark_mode;
  941.                 break;
  942.  
  943.               default:
  944.                 if(smode==data_mode)
  945.                 {
  946.                   lerror(line,"missing or unexpected slash `/'");
  947.                 }
  948.                 else /* smode==instruction_mode */
  949.                 {
  950.                   lerror(line,"misplaced single slash `/'; division not supported");
  951.                 }
  952.                 smode= error_mode;
  953.                 ungetc(c,fp);
  954.                 break;
  955.             }
  956.             break;
  957.  
  958.           case decimal_mode:
  959.             xhsbuf[n++]= (char)ccode;
  960.             smode= instruction_mode;
  961.             ungetc(c,fp);
  962.             break;
  963.  
  964.           case hex_mode:
  965.           case octal_mode:
  966.             if(smstack==string_mode)
  967.             {
  968.               if(ccdigits==0)
  969.               { /* can not happen in octal_mode in string_mode */
  970.                 lerror(line,"\\x used with no following hex digits");
  971.                 smode= error_mode;
  972.               }
  973.               else /* ccdigits > 0 */
  974.               {
  975.                 xhsbuf[n++]= (char)ccode;
  976.                 smode= smstack; /* == string_mode */
  977.                 ungetc(c,fp);
  978.               }
  979.             }
  980.             else /* smstack != string_mode */
  981.             { if(ccdigits==0)
  982.               {
  983.                 if(smode==hex_mode)
  984.                 {
  985.                   lerror(line,"$ used with no following hex digits");
  986.                   smode= error_mode;
  987.                 }
  988.                 else /* smode==octal_mode */
  989.                 {
  990.                   xhsbuf[n++]= (char)ccode; /* == 0 */
  991.                   smode= instruction_mode;
  992.                   ungetc(c,fp);
  993.                 }
  994.               }
  995.               else /* ccdigits > 0 */
  996.               {
  997.                 xhsbuf[n++]= (char)ccode;
  998.                 smode= instruction_mode;
  999.                 ungetc(c,fp);
  1000.               }
  1001.             }
  1002.             break;
  1003.  
  1004.           case string_mode:
  1005.             xhsbuf[n++]= c;
  1006.             break;
  1007.  
  1008.           case remark_mode:
  1009.           case comment_mode:
  1010.           case return_mode:
  1011.           case error_mode:
  1012.           case panic_mode:
  1013.             break;
  1014.         }
  1015.         break;
  1016.  
  1017. /**/  case '*':
  1018.         switch(smode)
  1019.         {
  1020.           case comment_mode:
  1021.             switch(c= fgetc(fp))
  1022.             {
  1023.               case '/':
  1024.                 smode= smstack; /* data_mode or instruction_mode */
  1025.                 break;
  1026. #ifdef OBSOLETE
  1027.               default:
  1028.                 ungetc(c,fp);
  1029.                 break;
  1030. #endif
  1031.             }
  1032.             break;
  1033.  
  1034.           case decimal_mode:
  1035.             lerror(line,"misplaced asterisk `%c'; multiplication not supported",c);
  1036.             smode= error_mode;
  1037.             break;
  1038.  
  1039.           case hex_mode:
  1040.           case octal_mode:
  1041.             if(smstack==string_mode)
  1042.             {
  1043.               if(ccdigits==0)
  1044.               { /* can not happen in octal_mode in string_mode */
  1045.                 lerror(line,"\\x used with no following hex digits");
  1046.                 smode= error_mode;
  1047.               }
  1048.               else /* ccdigits > 0 */
  1049.               {
  1050.                 xhsbuf[n++]= (char)ccode;
  1051.                 smode= smstack; /* == string_mode */
  1052.                 ungetc(c,fp);
  1053.               }
  1054.             }
  1055.             else /* smstack != string_mode */
  1056.             {
  1057.               lerror(line,"misplaced asterisk `%c'; multiplication not supported",c);
  1058.               smode= error_mode;
  1059.             }
  1060.             break;
  1061.  
  1062.           case string_mode:
  1063.             xhsbuf[n++]= c;
  1064.             break;
  1065.  
  1066.           case data_mode:
  1067.           case instruction_mode:
  1068.             lerror(line,"misplaced or unexpected asterisk `%c'",c);
  1069.             break;
  1070.  
  1071.           case remark_mode:
  1072.           case return_mode:
  1073.           case error_mode:
  1074.           case panic_mode:
  1075.             break;
  1076.         }
  1077.         break;
  1078.  
  1079. /**/  case '0':
  1080.       case '1':
  1081.       case '2':
  1082.       case '3':
  1083.       case '4':
  1084.       case '5':
  1085.       case '6':
  1086.       case '7':
  1087.       case '8':
  1088.       case '9':
  1089.         switch(smode)
  1090.         {
  1091.           case data_mode:
  1092.             smstack= instruction_mode;
  1093.             if(c=='0')
  1094.             {
  1095.               smode= octal_mode;
  1096.               ccdigits= 0; /* allow another 'global_maxoctdigits' */
  1097.             }
  1098.             else /* c > '0' */
  1099.             {
  1100.               smode= decimal_mode;
  1101.             }
  1102.             ccode= (int)c-'0';
  1103.             break;
  1104.  
  1105.           case instruction_mode:
  1106.             lerror(line,"misplaced digit `%c' -- extra space or missing `%c'",c,CATSYM);
  1107.             smode= error_mode;
  1108.             break;
  1109.  
  1110.           case decimal_mode:
  1111.             ccode= ccode * 10 + c-'0';
  1112.             if(ccode > global_numchars)
  1113.             {
  1114.               lerror(line,"decimal value out of range for character (> %d)",
  1115.                 global_numchars-1);
  1116.               smode= error_mode;
  1117.             }
  1118.             break;
  1119.  
  1120.           case hex_mode:
  1121.             {
  1122.               int cc= ccode * 0x10 + c-'0';
  1123.  
  1124.               if(cc >= global_numchars)
  1125.               {
  1126.                 if(smstack==string_mode)
  1127.                 {
  1128.                   if(ccdigits==0)
  1129.                   { /* can only happen if global_numchars < 0x0F */
  1130.                     lerror(line,"\\x used with no following hex digits");
  1131.                     smode= error_mode;
  1132.                   }
  1133.                   else /* ccdigits > 0 */
  1134.                   {
  1135.                     xhsbuf[n++]= (char)ccode;
  1136.                     smode= smstack; /* == string_mode */
  1137.                     ungetc(c,fp);
  1138.                   }
  1139.                 }
  1140.                 else /* smstack != string_mode */
  1141.                 {
  1142.                   lerror(line,"hex value out of range for character (> $%x)",
  1143.                     global_numchars-1);
  1144.                   smode= error_mode;
  1145.                 }
  1146.               }
  1147.               else /* cc < global_numchars */
  1148.               {
  1149.                 ++ccdigits;
  1150.                 if(smstack == string_mode &&
  1151.                   ccdigits >= global_maxhexdigits)
  1152.                 {
  1153.                   xhsbuf[n++]= (char)cc;
  1154.                   smode= smstack; /* == string_mode */
  1155.                 }
  1156.                 else ccode= cc;
  1157.               }
  1158.             }
  1159.             break;
  1160.  
  1161.           case octal_mode:
  1162.             if(c=='8' || c=='9')
  1163.             {
  1164.               if(smstack==string_mode)
  1165.               {
  1166.                 xhsbuf[n++]= (char)ccode;
  1167.                 smode= smstack; /* == string_mode */
  1168.                 ungetc(c,fp);
  1169.               }
  1170.               else /* smstack != string_mode */
  1171.               {
  1172.                 lerror(line,"not an octal digit: `%c'",c);
  1173.                 smode= error_mode;
  1174.               }
  1175.             }
  1176.             else /* '0'<=c && c<='7' */
  1177.             {
  1178.               int cc= ccode * 010 + c-'0';
  1179.  
  1180.               if(cc >= global_numchars)
  1181.               {
  1182.                 if(smstack==string_mode)
  1183.                 {
  1184.                   /* we can be sure that ccdigits is >= 1 */
  1185.                   xhsbuf[n++]= ccode;
  1186.                   smode= smstack; /* == string_mode */
  1187.                   ungetc(c,fp);
  1188.                 }
  1189.                 else /* smstack != string_mode */
  1190.                 {
  1191.                   lerror(line,"octal value out of range for character (> 0%o)",
  1192.                     global_numchars-1);
  1193.                   smode= error_mode;
  1194.                 }
  1195.               }
  1196.               else /* cc < gobal_numchars */
  1197.               {
  1198.                 ++ccdigits;
  1199.                 if(smstack == string_mode &&
  1200.                   ccdigits >= global_maxoctdigits)
  1201.                 {
  1202.                   xhsbuf[n++]= (char)cc;
  1203.                   smode= smstack; /* == string_mode */
  1204.                 }
  1205.                 else ccode= cc;
  1206.               }
  1207.             }
  1208.             break;
  1209.  
  1210.           case string_mode:
  1211.             xhsbuf[n++]= c;
  1212.             break;
  1213.  
  1214.           case remark_mode:
  1215.           case comment_mode:
  1216.           case return_mode:
  1217.           case error_mode:
  1218.           case panic_mode:
  1219.             break;
  1220.         }
  1221.         break;
  1222.  
  1223. /**/  case 'A': case 'a':
  1224.       case 'B': case 'b':
  1225.       case 'C': case 'c':
  1226.       case 'D': case 'd':
  1227.       case 'E': case 'e':
  1228.       case 'F': case 'f':
  1229.         switch(smode)
  1230.         {
  1231.           case data_mode:
  1232.             lerror(line,"misplaced character `%c' -- missing quotes or `$'",c);
  1233.             smode= error_mode;
  1234.             break;
  1235.  
  1236.           case instruction_mode:
  1237.             lerror(line,"misplaced character `%c' -- extra space or missing quotes",c);
  1238.             smode= error_mode;
  1239.             break;
  1240.  
  1241.           case decimal_mode:
  1242.             lerror(line,"not a decimal digit: `%c'",c);
  1243.             smode= error_mode;
  1244.             break;
  1245.  
  1246.           case hex_mode:
  1247.             {
  1248.               int cc= ccode * 0x10 + toupper(c)-'A' + 0x0A;
  1249.  
  1250.               if(cc >= global_numchars)
  1251.               {
  1252.                 if(smstack==string_mode)
  1253.                 {
  1254.                   if(ccdigits==0)
  1255.                   { /* can only happen if global_numchars < 0x0F */
  1256.                     lerror(line,"\\x used with no following hex digits");
  1257.                     smode= error_mode;
  1258.                   }
  1259.                   else /* ccdigits > 0 */
  1260.                   {
  1261.                     xhsbuf[n++]= (char)ccode;
  1262.                     smode= smstack; /* == string_mode */
  1263.                     ungetc(c,fp);
  1264.                   }
  1265.                 }
  1266.                 else /* smstack != string_mode */
  1267.                 {
  1268.                   lerror(line,"hex value out of range for character (> $%x)",
  1269.                     global_numchars-1);
  1270.                   smode= error_mode;
  1271.                 }
  1272.               }
  1273.               else /* cc < global_numchars */
  1274.               {
  1275.                 ++ccdigits;
  1276.                 if(smstack == string_mode &&
  1277.                   ccdigits >= global_maxhexdigits)
  1278.                 {
  1279.                   xhsbuf[n++]= (char)cc;
  1280.                   smode= smstack; /* == string_mode */
  1281.                 }
  1282.                 else ccode= cc;
  1283.               }
  1284.             }
  1285.             break;
  1286.  
  1287.           case octal_mode:
  1288.             if(smstack==string_mode)
  1289.             {
  1290.               xhsbuf[n++]= ccode;
  1291.               smode= smstack; /* == string_mode */
  1292.               ungetc(c,fp);
  1293.             }
  1294.             else
  1295.             {
  1296.               lerror(line,"not an octal digit: `%c'",c);
  1297.               smode= error_mode;
  1298.             }
  1299.             break;
  1300.  
  1301.           case string_mode:
  1302.             xhsbuf[n++]= c;
  1303.             break;
  1304.  
  1305.           case remark_mode:
  1306.           case comment_mode:
  1307.           case return_mode:
  1308.           case error_mode:
  1309.           case panic_mode:
  1310.             break;
  1311.         }
  1312.         break;
  1313.  
  1314. /**/  default:
  1315.         switch(smode)
  1316.         {
  1317.           case data_mode:
  1318.           case instruction_mode:
  1319.           case decimal_mode:
  1320.           case hex_mode:
  1321.           case octal_mode:
  1322.             if( isprint(c) )
  1323.             {
  1324.               lerror(line,"parse error: misplaced character `%c'",c);
  1325.             }
  1326.             else /* !isprint(c) */
  1327.             {
  1328.               lerror(line,"parse error: unknown character code 0x%x",c);
  1329.             }
  1330.             smode= error_mode;
  1331.             break;
  1332.  
  1333.           case string_mode:
  1334.             xhsbuf[n++]= c;
  1335.             break;
  1336.  
  1337.           case remark_mode:
  1338.           case comment_mode:
  1339.           case return_mode:
  1340.           case error_mode:
  1341.           case panic_mode:
  1342.             break;
  1343.         }
  1344.         break;
  1345.     }
  1346.  
  1347.     if(n >= bufsize)
  1348.     {
  1349.       bufsize += XHSBUFSIZE;
  1350.       xhsbuf= (unsigned char *)realloc(xhsbuf, bufsize);
  1351.       if(!xhsbuf)
  1352.       {
  1353.         lerror(line,"not enough memory to enlarge scanner buffer to %ld bytes",
  1354.           bufsize);
  1355.         smode= panic_mode;
  1356.       }
  1357. #ifdef DEBUG
  1358.       else if(debuglevel >= 1)
  1359.       {
  1360.         printf("scanner buffer enlarged to %ld bytes in line %ld\n",
  1361.           bufsize, line);
  1362.       }
  1363. #endif /* DEBUG */
  1364.     }
  1365.  
  1366.     /* avoid generation of further, spurious error messages */
  1367.  
  1368.     if( smode == error_mode && c != RTERM )
  1369.     {
  1370.       while( !feof(fp) && !ferror(fp) && (c= fgetc(fp)) != RTERM )
  1371.       {
  1372.         if(c=='\n' || c=='\r')
  1373.         {
  1374.           int d= fgetc(fp);
  1375.           if(!( (c=='\n' && d=='\r') || (c=='\r' && d=='\n') ))
  1376.             ungetc(d,fp);
  1377.  
  1378.           ++line;
  1379.         }
  1380.       }
  1381.     }
  1382.   }
  1383.  
  1384.   if(smode == return_mode)
  1385.   {
  1386.     cr->ln= line;
  1387.  
  1388.     if(n>0)
  1389.     { char *t;
  1390.       if( t= (char *)malloc(n*sizeof(char)) )
  1391.       { memcpy(t, xhsbuf, n);
  1392.         cr->rhs= t;
  1393.         cr->r= n;
  1394.         ++global_numrules;
  1395.       }
  1396.       else
  1397.       {
  1398.         lerror(line,"not enough memory for another %d bytes rhs",n);
  1399.         smode= panic_mode;
  1400.       }
  1401.     }
  1402.     else /* just to be sure... */
  1403.     {
  1404.       cr->rhs= (char *)0L;
  1405.       cr->r= 0L;
  1406.       ++global_numrules;
  1407.     }
  1408.   }
  1409.  
  1410.   return (smode == return_mode) ? cr : dispose(cr);
  1411. }
  1412.