home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS - Coast to Coast / simteldosarchivecoasttocoast2.iso / awk / awk320sr.zip / AWKLEX.C < prev    next >
C/C++ Source or Header  |  1991-04-25  |  19KB  |  750 lines
  1. /*
  2.  * Created by LEX from "awklex.l"
  3.  */
  4.  
  5. #include <stdio.h>
  6.  
  7. extern int yyline, yyleng;
  8. extern char yytext[];
  9.  
  10. struct lexrej {
  11.     short   llfin;
  12.     short   lllen;
  13. };
  14.  
  15. struct lextab {
  16.     int     llendst;
  17.     int     llnxtmax;
  18.     short   *llbase;
  19.     short   *llnext;
  20.     short   *llcheck;
  21.     short   *lldefault;
  22.     short   *llfinal;
  23.     short   *lllook;
  24.     struct lexrej *llsave;
  25.     int     (*llactr)();
  26.     char    *llign;
  27.     char    *llbrk;
  28.     char    *llill;
  29. };
  30.  
  31. #define ERROR   256
  32. #define ECHO    yyecho()
  33. #define BEGIN   yystab=
  34. #define REJECT  return(-1)
  35. #define input() fgetc(stdin)
  36. #define output(c) fputc(c, stdout)
  37.  
  38. #line 1 "awklex.l"
  39.  
  40. /*
  41.  * Awk lexical analyser
  42.  *
  43.  * Copyright (C) 1988, 1989, 1990, 1991 by Rob Duff
  44.  * All rights reserved
  45.  */
  46. #include <string.h>
  47. #include <stdlib.h>
  48. #include <math.h>
  49. #include <alloc.h>
  50.  
  51. #include "awk.h"
  52. #include "awklex.h"
  53. #include "awkyacc.h"
  54. #undef input
  55. #pragma warn-rch
  56.  
  57. int input(void);
  58.  
  59. struct  func {
  60.     char    *name;
  61.     char    type, code;
  62. } *funcp, func[] = {
  63.     0,0,0
  64. };
  65.  
  66. static int comment(void);
  67. static void string(int);
  68. static void newline(void);
  69. static void eatspace(void);
  70.  
  71.  
  72. yyinp() { return input(); }
  73. yyout(c) char c; { return output(c); }
  74.  
  75. /* Action routine */
  76. int _Alextab(__na__) {
  77.     switch (__na__) {
  78.     case 0:
  79. #line 36 "awklex.l"
  80.         ;
  81.         break;
  82.     case 1:
  83. #line 37 "awklex.l"
  84.         eatspace();
  85.         break;
  86.     case 2:
  87. #line 38 "awklex.l"
  88.     {
  89.             newline();
  90.             return T_EOL;
  91.         }
  92.         break;
  93.     case 3:
  94. #line 42 "awklex.l"
  95.     {
  96.             comment();
  97.             newline();
  98.             return T_EOL;
  99.         }
  100.         break;
  101.     case 4:
  102. #line 47 "awklex.l"
  103.         return T_BEGIN;
  104.         break;
  105.     case 5:
  106. #line 48 "awklex.l"
  107.         return T_END;
  108.         break;
  109.     case 6:
  110. #line 49 "awklex.l"
  111.         return T_IF;
  112.         break;
  113.     case 7:
  114. #line 50 "awklex.l"
  115.         return T_IN;
  116.         break;
  117.     case 8:
  118. #line 51 "awklex.l"
  119.         return T_DO;
  120.         break;
  121.     case 9:
  122. #line 52 "awklex.l"
  123.         return T_FOR;
  124.         break;
  125.     case 10:
  126. #line 53 "awklex.l"
  127.         return T_ELSE;
  128.         break;
  129.     case 11:
  130. #line 54 "awklex.l"
  131.         return yydone?T_DONE:T_WHILE;
  132.         break;
  133.     case 12:
  134. #line 55 "awklex.l"
  135.         return T_BREAK;
  136.         break;
  137.     case 13:
  138. #line 56 "awklex.l"
  139.         return T_CONTINUE;
  140.         break;
  141.     case 14:
  142. #line 57 "awklex.l"
  143.         return T_FUNCTION;
  144.         break;
  145.     case 15:
  146. #line 58 "awklex.l"
  147.         return T_RETURN;
  148.         break;
  149.     case 16:
  150. #line 59 "awklex.l"
  151.         return T_NEXT;
  152.         break;
  153.     case 17:
  154. #line 60 "awklex.l"
  155.         return T_EXIT;
  156.         break;
  157.     case 18:
  158. #line 61 "awklex.l"
  159.         return T_CLOSE;
  160.         break;
  161.     case 19:
  162. #line 62 "awklex.l"
  163.         return T_PRINT;
  164.         break;
  165.     case 20:
  166. #line 63 "awklex.l"
  167.         return T_PRINTF;
  168.         break;
  169.     case 21:
  170. #line 64 "awklex.l"
  171.         return T_GETLINE;
  172.         break;
  173.     case 22:
  174. #line 65 "awklex.l"
  175.         return T_DELETE;
  176.         break;
  177.     case 23:
  178. #line 66 "awklex.l"
  179.         return T_INDEX;
  180.         break;
  181.     case 24:
  182. #line 67 "awklex.l"
  183.         return T_MATCH;
  184.         break;
  185.     case 25:
  186. #line 68 "awklex.l"
  187.         return T_SPLIT;
  188.         break;
  189.     case 26:
  190. #line 69 "awklex.l"
  191.         return T_SUBSTR;
  192.         break;
  193.     case 27:
  194. #line 70 "awklex.l"
  195.         return T_SPRINTF;
  196.         break;
  197.     case 28:
  198. #line 71 "awklex.l"
  199.         return T_SRAND;
  200.         break;
  201.     case 29:
  202. #line 72 "awklex.l"
  203.     { yylval.ival = P_LSUB; return T_SUB; }
  204.         break;
  205.     case 30:
  206. #line 73 "awklex.l"
  207.     { yylval.ival = P_GSUB; return T_SUB; }
  208.         break;
  209.     case 31:
  210. #line 74 "awklex.l"
  211.     { yylval.ival = C_RAND; return T_FUNC0; }
  212.         break;
  213.     case 32:
  214. #line 75 "awklex.l"
  215.     { yylval.ival = C_SYS; return T_FUNC1; }
  216.         break;
  217.     case 33:
  218. #line 76 "awklex.l"
  219.     { yylval.ival = C_LEN; return T_FUNC1; }
  220.         break;
  221.     case 34:
  222. #line 77 "awklex.l"
  223.     { yylval.ival = C_UPR; return T_FUNC1; }
  224.         break;
  225.     case 35:
  226. #line 78 "awklex.l"
  227.     { yylval.ival = C_LWR; return T_FUNC1; }
  228.         break;
  229.     case 36:
  230. #line 79 "awklex.l"
  231.     { yylval.ival = C_COS; return T_FUNC1; }
  232.         break;
  233.     case 37:
  234. #line 80 "awklex.l"
  235.     { yylval.ival = C_EXP; return T_FUNC1; }
  236.         break;
  237.     case 38:
  238. #line 81 "awklex.l"
  239.     { yylval.ival = C_INT; return T_FUNC1; }
  240.         break;
  241.     case 39:
  242. #line 82 "awklex.l"
  243.     { yylval.ival = C_LOG; return T_FUNC1; }
  244.         break;
  245.     case 40:
  246. #line 83 "awklex.l"
  247.     { yylval.ival = C_SIN; return T_FUNC1; }
  248.         break;
  249.     case 41:
  250. #line 84 "awklex.l"
  251.     { yylval.ival = C_SQRT; return T_FUNC1; }
  252.         break;
  253.     case 42:
  254. #line 85 "awklex.l"
  255.     { yylval.ival = C_ATAN2; return T_FUNC2; }
  256.         break;
  257.     case 43:
  258. #line 86 "awklex.l"
  259.     {
  260.             funcp = func;
  261.             while (funcp->name != 0) {
  262.                 if (strcmp(yytext, funcp->name) == 0) {
  263.                     yylval.ival = funcp->code;
  264.                     return funcp->type;
  265.                 }
  266.                 funcp++;
  267.             }
  268.             yylval.vptr = lookup(yytext);
  269.             if (yypeek() == '(')
  270.                 return T_USER;
  271.             return T_NAME;
  272.         }
  273.         break;
  274.     case 44:
  275. #line 100 "awklex.l"
  276.     case 45:
  277. #line 101 "awklex.l"
  278.     case 46:
  279. #line 102 "awklex.l"
  280.     case 47:
  281. #line 103 "awklex.l"
  282.     {
  283.             yylval.dval = atof(yytext);
  284.             return T_DCON;
  285.         }
  286.         break;
  287.     case 48:
  288. #line 107 "awklex.l"
  289.         return T_APPEND;
  290.         break;
  291.     case 49:
  292. #line 108 "awklex.l"
  293.         return T_NOMATCH;
  294.         break;
  295.     case 50:
  296. #line 109 "awklex.l"
  297.         return T_LAND;
  298.         break;
  299.     case 51:
  300. #line 110 "awklex.l"
  301.         return T_LIOR;
  302.         break;
  303.     case 52:
  304. #line 111 "awklex.l"
  305.     { yylval.ival = C_NE; return T_RELOP; }
  306.         break;
  307.     case 53:
  308. #line 112 "awklex.l"
  309.     { yylval.ival = C_EQ; return T_RELOP; }
  310.         break;
  311.     case 54:
  312. #line 113 "awklex.l"
  313.     { yylval.ival = C_LE; return T_RELOP; }
  314.         break;
  315.     case 55:
  316. #line 114 "awklex.l"
  317.     { yylval.ival = C_GE; return T_RELOP; }
  318.         break;
  319.     case 56:
  320. #line 115 "awklex.l"
  321.     { yylval.ival = C_ADD; return T_INCOP; }
  322.         break;
  323.     case 57:
  324. #line 116 "awklex.l"
  325.     { yylval.ival = C_SUB; return T_INCOP; }
  326.         break;
  327.     case 58:
  328. #line 117 "awklex.l"
  329.     { yylval.ival = C_POW; return T_STORE; }
  330.         break;
  331.     case 59:
  332. #line 118 "awklex.l"
  333.     { yylval.ival = C_MUL; return T_STORE; }
  334.         break;
  335.     case 60:
  336. #line 119 "awklex.l"
  337.     { yylval.ival = C_DIV; return T_STORE; }
  338.         break;
  339.     case 61:
  340. #line 120 "awklex.l"
  341.     { yylval.ival = C_MOD; return T_STORE; }
  342.         break;
  343.     case 62:
  344. #line 121 "awklex.l"
  345.     { yylval.ival = C_ADD; return T_STORE; }
  346.         break;
  347.     case 63:
  348. #line 122 "awklex.l"
  349.     { yylval.ival = C_SUB; return T_STORE; }
  350.         break;
  351.     case 64:
  352. #line 123 "awklex.l"
  353.     { yylval.ival = 0; return T_STORE; }
  354.         break;
  355.     case 65:
  356. #line 124 "awklex.l"
  357.     {
  358.             yyback('\n');
  359.             return '}';
  360.         }
  361.         break;
  362.     case 66:
  363. #line 128 "awklex.l"
  364.         return '-';
  365.         break;
  366.     case 67:
  367. #line 129 "awklex.l"
  368.         return ']';
  369.         break;
  370.     case 68:
  371. #line 130 "awklex.l"
  372.     {
  373.             return *yytext;
  374.         }
  375.         break;
  376.     case 69:
  377. #line 133 "awklex.l"
  378.     {
  379.             string('"');
  380.             return T_SCON;
  381.         }
  382.         break;
  383.     case 70:
  384. #line 137 "awklex.l"
  385.         return ERROR;
  386.         break;
  387.     }
  388.     return (-2);
  389. }
  390.  
  391. #line 138 "awklex.l"
  392.  
  393.  
  394. static void string(int ec)
  395. {
  396.     register int len;
  397.     register c;
  398.  
  399.     buffer[0] = '\377';
  400.     for (len = 1; len < 79 && (c = yymapc(ec, '\\')) != EOF; len++)
  401.         buffer[len] = c;
  402.     buffer[len] = '\0';
  403.     if (len == 1)
  404.         yylval.sptr = (char near *)nullstr;
  405.     else {
  406.         yylval.sptr = yyalloc(len+1);
  407.         strcpy(yylval.sptr, buffer);
  408.     }
  409. }
  410.  
  411. static int comment()
  412. {
  413.     register int ch;
  414.  
  415.     while ((ch = yynext()) != EOF && ch != '\n')
  416.         ;
  417.     return ch;
  418. }
  419.  
  420. static void newline()
  421. {
  422.     register int ch;
  423.  
  424.     while ((ch = yynext()) != EOF) {
  425.         if (ch == '#')
  426.             ch = comment();
  427.         if (ch != ' ' && ch != '\t' && ch != '\n') {
  428.             yyback(ch);
  429.             break;
  430.         }
  431.     }
  432. }
  433.  
  434. static void eatspace()
  435. {
  436.     register int ch;
  437.  
  438.     while ((ch = yynext()) == ' ' || ch == '\t')
  439.         ;
  440.     yyback(ch);
  441. }
  442.  
  443. int
  444. input()
  445. {
  446.     if (lineptr == NULL) {
  447.         if (awklist != NULL) {
  448.             yyline = 0;
  449.             yyname = awklist->name;
  450.             if (yyname == awkstdin)
  451.                 awkfile = stdin;
  452.             else {
  453.                 awkfile = fopen(yyname ,"r");
  454.                 if (awkfile == NULL)
  455.                     error("Can't open program file %s", yyname);
  456.             }
  457.             awklist = awklist->next;
  458.             lineptr = linebuf;
  459.             *lineptr = '\0';
  460.         }
  461.         else {
  462.             awkeof = 1;
  463.             return(EOF);
  464.         }
  465.     }
  466.     if (*lineptr == '\0') {
  467.         if (awkeof)
  468.             return(EOF);
  469.         lineptr = fgets(linebuf, 128, awkfile);
  470.         if (lineptr != linebuf) {
  471.             lineptr = NULL;
  472.             return('\n');
  473.         }
  474.         yyline++;
  475.         genline();
  476.         if (linebuf[0] == '.' && linebuf[1] == '\n') {
  477.             awkeof = 1;
  478.             lineptr = NULL;
  479.             return(EOF);
  480.         }
  481.     }
  482.     return(*lineptr++);
  483. }
  484.  
  485. IDENT *lookup(char *name)
  486. {
  487.     char    *sp;
  488.     IDENT   *vp;
  489.  
  490.     for (vp = ident; vp != NULL; vp = vp->vnext)
  491.         if (strcmp(name, vp->vname) == 0)
  492.             return vp;
  493.     if (nextvar >= vartab+MAXNAME)
  494.         yyerror("Too many variables");
  495.     
  496.     sp = yyalloc(strlen(name) + 1);
  497.     strcpy(sp, name);
  498.     vp = yyalloc(sizeof(IDENT));
  499.     vp->vitem = NULL;
  500.     vp->vname = sp;
  501.     vp->vfunc = NULL;
  502.     vp->vnext = ident;
  503.     ident = vp;
  504.     return vp;
  505. }
  506.  
  507. void *
  508. yyalloc(size)
  509. unsigned int size;
  510. {
  511.     void    *mp;
  512.  
  513.     mp = malloc(size);
  514.     if (mp == NULL)
  515.         yyerror("out of memory");
  516.     memset(mp, 0, size);
  517.     return(mp);
  518. }
  519.  
  520. void
  521. yyerror(str)
  522. char *str;
  523. {
  524.     char  *lp, *ep;
  525.  
  526.     fprintf(stderr, "%s", linebuf);
  527.     if ((char near *)lineptr != NULL) {
  528.         ep = (char near *)lineptr - 1 - yylook();
  529.         for (lp = linebuf; lp < ep; lp++)
  530.             fputc(*lp=='\t'?'\t':' ', stderr);
  531.         fprintf(stderr, "^\n");
  532.     }
  533.     error(str, NULL);
  534. }
  535.  
  536.  
  537. short _Flextab[] = { -1, 70, 69, 68, 67, 65, 68,
  538.     61, 68, 60, 68, 59, 68, 58, 66,
  539.     63, 57, 68, 62, 56, 68, 54, 64,
  540.     53, 70, 51, 70, 50, 68, 52, 49,
  541.     68, 55, 48, 44, -1, 46, -1, -1,
  542.     45, -1, 47, -1, 44, 43, 43, 43,
  543.     43, 43, 43, 42, 43, 43, 43, 43,
  544.     43, 43, 35, 43, 43, 43, 43, 34,
  545.     43, 43, 39, 43, 43, 43, 43, 33,
  546.     43, 43, 43, 41, 43, 40, 43, 43,
  547.     43, 43, 32, 43, 43, 43, 28, 43,
  548.     29, 43, 43, 26, 43, 43, 43, 43,
  549.     43, 27, 43, 43, 25, 43, 43, 43,
  550.     43, 24, 43, 43, 43, 30, 43, 43,
  551.     43, 43, 43, 21, 43, 43, 43, 43,
  552.     19, 20, 43, 43, 43, 16, 43, 43,
  553.     43, 31, 43, 43, 43, 43, 15, 43,
  554.     43, 43, 43, 18, 43, 36, 43, 43,
  555.     43, 43, 43, 13, 43, 43, 43, 43,
  556.     12, 43, 43, 43, 43, 11, 43, 43,
  557.     37, 43, 17, 43, 43, 10, 43, 43,
  558.     43, 43, 43, 43, 43, 14, 43, 9,
  559.     43, 43, 43, 43, 43, 22, 8, 43,
  560.     7, 38, 43, 43, 23, 6, 43, 43,
  561.     5, 43, 43, 43, 43, 4, 3, 2,
  562.     1, 70, 0, -1,
  563. };
  564.  
  565. struct lexrej _Vlextab[197];
  566.  
  567. #line 282 "awklex.l"
  568.  
  569. short _Nlextab[] = { 1, 1, 1, 1, 1, 1, 1,
  570.     1, 1, 199, 198, 1, 1, 1, 1,
  571.     1, 1, 1, 1, 1, 1, 1, 1,
  572.     1, 1, 1, 1, 1, 1, 1, 1,
  573.     1, 199, 28, 2, 197, 3, 6, 26,
  574.     1, 3, 3, 10, 17, 3, 14, 1,
  575.     8, 34, 34, 34, 34, 34, 34, 34,
  576.     34, 34, 34, 3, 3, 20, 22, 31,
  577.     3, 1, 44, 192, 44, 44, 189, 44,
  578.     44, 44, 44, 44, 44, 44, 44, 44,
  579.     44, 44, 44, 44, 44, 44, 44, 44,
  580.     44, 44, 44, 44, 3, 200, 4, 12,
  581.     44, 1, 46, 147, 134, 175, 157, 165,
  582.     105, 44, 182, 44, 44, 63, 100, 121,
  583.     44, 115, 44, 125, 71, 51, 44, 44,
  584.     152, 44, 44, 44, 3, 24, 5, 3,
  585.     1, 7, 9, 11, 13, 16, 19, 21,
  586.     23, 25, 27, 29, 32, 33, 202, 202,
  587.     202, 202, 202, 47, 202, 15, 48, 38,
  588.     18, 43, 43, 43, 43, 43, 43, 43,
  589.     43, 43, 43, 40, 202, 49, 202, 50,
  590.     52, 54, 37, 55, 37, 56, 35, 36,
  591.     36, 36, 36, 36, 36, 36, 36, 36,
  592.     36, 39, 39, 39, 39, 39, 39, 39,
  593.     39, 39, 39, 40, 57, 59, 53, 60,
  594.     61, 62, 65, 42, 30, 42, 35, 58,
  595.     41, 41, 41, 41, 41, 41, 41, 41,
  596.     41, 41, 45, 45, 45, 45, 45, 45,
  597.     45, 45, 45, 45, 67, 68, 69, 70,
  598.     73, 74, 76, 45, 45, 45, 45, 45,
  599.     45, 45, 45, 45, 45, 45, 45, 45,
  600.     45, 45, 45, 45, 45, 45, 45, 45,
  601.     45, 45, 45, 45, 45, 78, 79, 80,
  602.     81, 45, 83, 45, 45, 45, 45, 45,
  603.     45, 45, 45, 45, 45, 45, 45, 45,
  604.     45, 45, 45, 45, 45, 45, 45, 45,
  605.     45, 45, 45, 45, 45, 66, 84, 85,
  606.     87, 75, 88, 89, 90, 97, 93, 64,
  607.     91, 72, 82, 92, 94, 86, 95, 96,
  608.     98, 77, 99, 101, 102, 103, 104, 109,
  609.     107, 108, 110, 111, 112, 113, 114, 116,
  610.     117, 118, 119, 120, 122, 106, 123, 124,
  611.     126, 127, 128, 130, 129, 131, 132, 133,
  612.     135, 136, 137, 139, 138, 141, 142, 143,
  613.     144, 145, 140, 146, 148, 149, 150, 151,
  614.     153, 154, 155, 156, 162, 160, 161, 163,
  615.     164, 173, 167, 168, 159, 169, 170, 166,
  616.     158, 171, 172, 174, 176, 177, 178, 179,
  617.     180, 188, 185, 186, 187, 190, 181, 191,
  618.     193, 183, 194, 195, 196, 201, 202, 202,
  619.     202, 202, 184,
  620. };
  621.  
  622. short _Clextab[] = { 0, 0, 0, 0, 0, 0, 0,
  623.     0, 0, 0, 0, 0, 0, 0, 0,
  624.     0, 0, 0, 0, 0, 0, 0, 0,
  625.     0, 0, 0, 0, 0, 0, 0, 0,
  626.     0, 0, 0, 0, 0, 0, 0, 0,
  627.     0, 0, 0, 0, 0, 0, 0, 0,
  628.     0, 0, 0, 0, 0, 0, 0, 0,
  629.     0, 0, 0, 0, 0, 0, 0, 0,
  630.     0, 0, 0, 0, 0, 0, 0, 0,
  631.     0, 0, 0, 0, 0, 0, 0, 0,
  632.     0, 0, 0, 0, 0, 0, 0, 0,
  633.     0, 0, 0, 0, 0, 0, 0, 0,
  634.     0, 0, 0, 0, 0, 0, 0, 0,
  635.     0, 0, 0, 0, 0, 0, 0, 0,
  636.     0, 0, 0, 0, 0, 0, 0, 0,
  637.     0, 0, 0, 0, 0, 0, 0, 0,
  638.     0, 6, 8, 10, 12, 14, 17, 20,
  639.     22, 24, 26, 28, 31, 31, 36, 37,
  640.     36, 37, 41, 46, 41, 14, 47, 34,
  641.     17, 34, 34, 34, 34, 34, 34, 34,
  642.     34, 34, 34, 39, 42, 48, 42, 49,
  643.     51, 53, 35, 54, 35, 55, 34, 35,
  644.     35, 35, 35, 35, 35, 35, 35, 35,
  645.     35, 38, 38, 38, 38, 38, 38, 38,
  646.     38, 38, 38, 39, 56, 58, 52, 59,
  647.     60, 61, 64, 40, 28, 40, 34, 52,
  648.     40, 40, 40, 40, 40, 40, 40, 40,
  649.     40, 40, 44, 44, 44, 44, 44, 44,
  650.     44, 44, 44, 44, 66, 67, 68, 69,
  651.     72, 73, 75, 44, 44, 44, 44, 44,
  652.     44, 44, 44, 44, 44, 44, 44, 44,
  653.     44, 44, 44, 44, 44, 44, 44, 44,
  654.     44, 44, 44, 44, 44, 77, 78, 79,
  655.     80, 44, 82, 44, 44, 44, 44, 44,
  656.     44, 44, 44, 44, 44, 44, 44, 44,
  657.     44, 44, 44, 44, 44, 44, 44, 44,
  658.     44, 44, 44, 44, 44, 63, 83, 84,
  659.     86, 71, 87, 88, 89, 91, 92, 63,
  660.     71, 71, 71, 91, 93, 71, 94, 95,
  661.     97, 71, 98, 100, 101, 102, 103, 105,
  662.     106, 107, 109, 110, 111, 112, 113, 115,
  663.     116, 117, 118, 119, 121, 105, 122, 123,
  664.     125, 126, 127, 129, 125, 130, 131, 132,
  665.     134, 135, 136, 134, 137, 139, 141, 142,
  666.     143, 144, 139, 145, 147, 148, 149, 150,
  667.     152, 153, 154, 155, 157, 158, 160, 162,
  668.     163, 165, 166, 167, 158, 168, 169, 165,
  669.     157, 170, 171, 173, 175, 176, 177, 178,
  670.     179, 182, 183, 185, 186, 189, 175, 190,
  671.     192, 182, 193, 194, 195, 200, -1, -1,
  672.     -1, -1, 183,
  673. };
  674.  
  675. short _Dlextab[] = { 0312, 0312, 0312, 0312, 0312, 0312, 0312,
  676.     0312, 0312, 0312, 0312, 0312, 0312, 0312, 0312,
  677.     0312, 0312, 0312, 0312, 0312, 0312, 0312, 0312,
  678.     0312, 0312, 0312, 0312, 0312, 0312, 0312, 0312,
  679.     0312, 0312, 0312, 0312, 0312, 043, 044, 0312,
  680.     046, 0312, 050, 051, 042, 0312, 054, 054,
  681.     054, 054, 054, 054, 054, 054, 054, 054,
  682.     054, 054, 054, 054, 054, 054, 054, 054,
  683.     054, 054, 054, 054, 054, 054, 054, 054,
  684.     054, 054, 054, 054, 054, 054, 054, 054,
  685.     054, 054, 054, 054, 054, 054, 054, 054,
  686.     054, 054, 054, 054, 054, 054, 054, 054,
  687.     054, 054, 054, 054, 054, 054, 054, 054,
  688.     054, 054, 054, 054, 054, 054, 054, 054,
  689.     054, 054, 054, 054, 054, 054, 054, 054,
  690.     054, 054, 054, 054, 054, 054, 054, 054,
  691.     054, 054, 054, 054, 054, 054, 054, 054,
  692.     054, 054, 054, 054, 054, 054, 054, 054,
  693.     054, 054, 054, 054, 054, 054, 054, 054,
  694.     054, 054, 054, 054, 054, 054, 054, 054,
  695.     054, 054, 054, 054, 054, 054, 054, 054,
  696.     054, 054, 054, 054, 054, 054, 054, 054,
  697.     054, 054, 054, 054, 054, 054, 054, 054,
  698.     054, 054, 054, 054, 054, 054, 054, 054,
  699.     054, 054, 054, 054, 054, 054, 0312, 0312,
  700.     0312, 0312, 0312, 00,
  701. };
  702.  
  703. short _Blextab[] = { 00, 00, 00, 00, 00, 00, 0103,
  704.     00, 0104, 00, 0105, 00, 0106, 00, 0127,
  705.     00, 00, 0132, 00, 00, 0111, 00, 0112,
  706.     00, 014, 00, 0143, 00, 0115, 00, 00,
  707.     0116, 00, 00, 0150, 0176, 0142, 0143, 0210,
  708.     0135, 0237, 0146, 0170, 00, 0251, 00, 036,
  709.     064, 066, 0164, 00, 070, 0131, 071, 063,
  710.     0107, 0121, 00, 0124, 0126, 0142, 0126, 00,
  711.     0277, 0142, 00, 0165, 0175, 0161, 0176, 00,
  712.     0277, 0165, 0164, 00, 0173, 00, 0221, 0221,
  713.     0241, 0232, 00, 0250, 0267, 0302, 00, 0305,
  714.     0266, 0266, 0271, 00, 0300, 0304, 0305, 0301,
  715.     0320, 00, 0316, 0305, 00, 0331, 0307, 0331,
  716.     0325, 00, 0331, 0312, 0336, 00, 0315, 0326,
  717.     0332, 0326, 0340, 00, 0324, 0336, 0332, 0325,
  718.     0344, 00, 0346, 0325, 0332, 00, 0356, 0342,
  719.     0355, 00, 0336, 0337, 0343, 0350, 00, 0353,
  720.     0351, 0346, 0366, 00, 0356, 00, 0351, 0365,
  721.     0361, 0353, 0375, 00, 0361, 0377, 0404, 0373,
  722.     00, 0377, 0377, 0375, 0405, 00, 0377, 0403,
  723.     00, 0371, 00, 0373, 0412, 00, 0401, 0403,
  724.     0417, 0400, 0414, 0411, 0413, 00, 0410, 00,
  725.     0426, 0420, 0430, 0412, 0432, 00, 00, 0432,
  726.     0435, 00, 0435, 0413, 00, 00, 0466, 0502,
  727.     00, 0502, 0502, 0501, 0475, 00, 00, 00,
  728.     00, 0602, 00, 00,
  729. };
  730.  
  731. short _Slextab[] = { 00,
  732. };
  733.  
  734. struct lextab lextab = {
  735.     202,     /* Highest state */
  736.     401,     /* Index of last entry in next */
  737.     _Blextab,    /* -> Base table */
  738.     _Nlextab,    /* -> Next state table */
  739.     _Clextab,    /* -> Check value table */
  740.     _Dlextab,    /* -> Default state table */
  741.     _Flextab,    /* -> Final state table */
  742.     NULL,       /* -> Look-ahead vector */
  743.     _Vlextab,    /* -> length and look ahead save */
  744.     _Alextab,    /* -> Action routine */
  745.     NULL,        /* No Ignore class */
  746.     NULL,        /* No Break class */
  747.     NULL,        /* No Illegal class */
  748. };
  749.  
  750.