home *** CD-ROM | disk | FTP | other *** search
/ ftp.cs.arizona.edu / ftp.cs.arizona.edu.tar / ftp.cs.arizona.edu / icon / historic / v941.tgz / icon.v941src.tar / icon.v941src / src / common / lextab.h < prev    next >
C/C++ Source or Header  |  2002-01-18  |  21KB  |  577 lines
  1. /*
  2.  * NOTE: this file is generated automatically by mktoktab
  3.  *  from tokens.txt and op.txt.
  4.  */
  5.  
  6. /*
  7.  * Token table - contains an entry for each token type
  8.  * with printable name of token, token type, and flags
  9.  * for semicolon insertion.
  10.  */
  11.  
  12. struct toktab toktab[] = {
  13. /*  token        token type    flags */
  14.  
  15.    /* primitives */
  16.    "identifier",      IDENT,         Beginner+Ender,    /*   0 */
  17.    "integer-literal", INTLIT,        Beginner+Ender,    /*   1 */
  18.    "real-literal",    REALLIT,       Beginner+Ender,    /*   2 */
  19.    "string-literal",  STRINGLIT,     Beginner+Ender,    /*   3 */
  20.    "cset-literal",    CSETLIT,       Beginner+Ender,    /*   4 */
  21.    "end-of-file",     EOFX,          0,                 /*   5 */
  22.  
  23.    /* reserved words */
  24.    "break",           BREAK,         Beginner+Ender,    /*   6 */
  25.    "by",              BY,            0,                 /*   7 */
  26.    "case",            CASE,          Beginner,          /*   8 */
  27.    "create",          CREATE,        Beginner,          /*   9 */
  28.    "default",         DEFAULT,       Beginner,          /*  10 */
  29.    "do",              DO,            0,                 /*  11 */
  30.    "else",            ELSE,          0,                 /*  12 */
  31.    "end",             END,           Beginner,          /*  13 */
  32.    "every",           EVERY,         Beginner,          /*  14 */
  33.    "fail",            FAIL,          Beginner+Ender,    /*  15 */
  34.    "global",          GLOBAL,        0,                 /*  16 */
  35.    "if",              IF,            Beginner,          /*  17 */
  36.    "initial",         INITIAL,       Beginner,          /*  18 */
  37.    "invocable",       INVOCABLE,     0,                 /*  19 */
  38.    "link",            LINK,          0,                 /*  20 */
  39.    "local",           LOCAL,         Beginner,          /*  21 */
  40.    "next",            NEXT,          Beginner+Ender,    /*  22 */
  41.    "not",             NOT,           Beginner,          /*  23 */
  42.    "of",              OF,            0,                 /*  24 */
  43.    "procedure",       PROCEDURE,     0,                 /*  25 */
  44.    "record",          RECORD,        0,                 /*  26 */
  45.    "repeat",          REPEAT,        Beginner,          /*  27 */
  46.    "return",          RETURN,        Beginner+Ender,    /*  28 */
  47.    "static",          STATIC,        Beginner,          /*  29 */
  48.    "suspend",         SUSPEND,       Beginner+Ender,    /*  30 */
  49.    "then",            THEN,          0,                 /*  31 */
  50.    "to",              TO,            0,                 /*  32 */
  51.    "until",           UNTIL,         Beginner,          /*  33 */
  52.    "while",           WHILE,         Beginner,          /*  34 */
  53.    "end-of-file",     0,             0,
  54.    };
  55.  
  56. /*
  57.  * restab[c] points to the first reserved word in toktab which
  58.  * begins with the letter c.
  59.  */
  60.  
  61. struct toktab *restab[] = {
  62.    NULL,        &toktab[ 6], &toktab[ 8], &toktab[10], /* 61-64 abcd */
  63.    &toktab[12], &toktab[15], &toktab[16], NULL,        /* 65-68 efgh */
  64.    &toktab[17], NULL,        NULL,        &toktab[20], /* 69-6C ijkl */
  65.    NULL,        &toktab[22], &toktab[24], &toktab[25], /* 6D-70 mnop */
  66.    NULL,        &toktab[26], &toktab[29], &toktab[31], /* 71-74 qrst */
  67.    &toktab[33], NULL,        &toktab[34], NULL,        /* 75-78 uvwx */
  68.    NULL,        NULL,                                  /* 79-7A yz */
  69.    };
  70.  
  71. /*
  72.  * The operator table acts to extend the token table, it
  73.  *  indicates what implementations are expected from rtt,
  74.  *  and it has pointers for the implementation information.
  75.  */
  76.  
  77. struct optab optab[] = {
  78.    {{"!",      BANG,       Beginner}, Unary,          NULL, NULL}, /* 0 */
  79.    {{"%",      MOD,        0},        Binary,         NULL, NULL}, /* 1 */
  80.    {{"%:=",    AUGMOD,     0},        0,              NULL, NULL}, /* 2 */
  81.    {{"&",      AND,        Beginner}, Binary,         NULL, NULL}, /* 3 */
  82.    {{"&:=",    AUGAND,     0},        0,              NULL, NULL}, /* 4 */
  83.    {{"*",      STAR,       Beginner}, Unary | Binary, NULL, NULL}, /* 5 */
  84.    {{"*:=",    AUGSTAR,    0},        0,              NULL, NULL}, /* 6 */
  85.    {{"**",     INTER,      Beginner}, Binary,         NULL, NULL}, /* 7 */
  86.    {{"**:=",   AUGINTER,   0},        0,              NULL, NULL}, /* 8 */
  87.    {{"+",      PLUS,       Beginner}, Unary | Binary, NULL, NULL}, /* 9 */
  88.    {{"+:=",    AUGPLUS,    0},        0,              NULL, NULL}, /* 10 */
  89.    {{"++",     UNION,      Beginner}, Binary,         NULL, NULL}, /* 11 */
  90.    {{"++:=",   AUGUNION,   0},        0,              NULL, NULL}, /* 12 */
  91.    {{"-",      MINUS,      Beginner}, Unary | Binary, NULL, NULL}, /* 13 */
  92.    {{"-:=",    AUGMINUS,   0},        0,              NULL, NULL}, /* 14 */
  93.    {{"--",     DIFF,       Beginner}, Binary,         NULL, NULL}, /* 15 */
  94.    {{"--:=",   AUGDIFF,    0},        0,              NULL, NULL}, /* 16 */
  95.    {{".",      DOT,        Beginner}, Unary,          NULL, NULL}, /* 17 */
  96.    {{"/",      SLASH,      Beginner}, Unary | Binary, NULL, NULL}, /* 18 */
  97.    {{"/:=",    AUGSLASH,   0},        0,              NULL, NULL}, /* 19 */
  98.    {{":=",     ASSIGN,     0},        Binary,         NULL, NULL}, /* 20 */
  99.    {{":=:",    SWAP,       0},        Binary,         NULL, NULL}, /* 21 */
  100.    {{"<",      NMLT,       0},        Binary,         NULL, NULL}, /* 22 */
  101.    {{"<:=",    AUGNMLT,    0},        0,              NULL, NULL}, /* 23 */
  102.    {{"<-",     REVASSIGN,  0},        Binary,         NULL, NULL}, /* 24 */
  103.    {{"<->",    REVSWAP,    0},        Binary,         NULL, NULL}, /* 25 */
  104.    {{"<<",     SLT,        0},        Binary,         NULL, NULL}, /* 26 */
  105.    {{"<<:=",   AUGSLT,     0},        0,              NULL, NULL}, /* 27 */
  106.    {{"<<=",    SLE,        0},        Binary,         NULL, NULL}, /* 28 */
  107.    {{"<<=:=",  AUGSLE,     0},        0,              NULL, NULL}, /* 29 */
  108.    {{"<=",     NMLE,       0},        Binary,         NULL, NULL}, /* 30 */
  109.    {{"<=:=",   AUGNMLE,    0},        0,              NULL, NULL}, /* 31 */
  110.    {{"=",      NMEQ,       Beginner}, Unary | Binary, NULL, NULL}, /* 32 */
  111.    {{"=:=",    AUGNMEQ,    0},        0,              NULL, NULL}, /* 33 */
  112.    {{"==",     SEQ,        Beginner}, Binary,         NULL, NULL}, /* 34 */
  113.    {{"==:=",   AUGSEQ,     0},        0,              NULL, NULL}, /* 35 */
  114.    {{"===",    EQUIV,      Beginner}, Binary,         NULL, NULL}, /* 36 */
  115.    {{"===:=",  AUGEQUIV,   0},        0,              NULL, NULL}, /* 37 */
  116.    {{">",      NMGT,       0},        Binary,         NULL, NULL}, /* 38 */
  117.    {{">:=",    AUGNMGT,    0},        0,              NULL, NULL}, /* 39 */
  118.    {{">=",     NMGE,       0},        Binary,         NULL, NULL}, /* 40 */
  119.    {{">=:=",   AUGNMGE,    0},        0,              NULL, NULL}, /* 41 */
  120.    {{">>",     SGT,        0},        Binary,         NULL, NULL}, /* 42 */
  121.    {{">>:=",   AUGSGT,     0},        0,              NULL, NULL}, /* 43 */
  122.    {{">>=",    SGE,        0},        Binary,         NULL, NULL}, /* 44 */
  123.    {{">>=:=",  AUGSGE,     0},        0,              NULL, NULL}, /* 45 */
  124.    {{"?",      QMARK,      Beginner}, Unary,          NULL, NULL}, /* 46 */
  125.    {{"?:=",    AUGQMARK,   0},        0,              NULL, NULL}, /* 47 */
  126.    {{"@",      AT,         Beginner}, 0,              NULL, NULL}, /* 48 */
  127.    {{"@:=",    AUGAT,      0},        0,              NULL, NULL}, /* 49 */
  128.    {{"\\",     BACKSLASH,  Beginner}, Unary,          NULL, NULL}, /* 50 */
  129.    {{"^",      CARET,      Beginner}, Unary | Binary, NULL, NULL}, /* 51 */
  130.    {{"^:=",    AUGCARET,   0},        0,              NULL, NULL}, /* 52 */
  131.    {{"|",      BAR,        Beginner}, 0,              NULL, NULL}, /* 53 */
  132.    {{"||",     CONCAT,     Beginner}, Binary,         NULL, NULL}, /* 54 */
  133.    {{"||:=",   AUGCONCAT,  0},        0,              NULL, NULL}, /* 55 */
  134.    {{"|||",    LCONCAT,    Beginner}, Binary,         NULL, NULL}, /* 56 */
  135.    {{"|||:=",  AUGLCONCAT, 0},        0,              NULL, NULL}, /* 57 */
  136.    {{"~",      TILDE,      Beginner}, Unary,          NULL, NULL}, /* 58 */
  137.    {{"~=",     NMNE,       Beginner}, Binary,         NULL, NULL}, /* 59 */
  138.    {{"~=:=",   AUGNMNE,    0},        0,              NULL, NULL}, /* 60 */
  139.    {{"~==",    SNE,        Beginner}, Binary,         NULL, NULL}, /* 61 */
  140.    {{"~==:=",  AUGSNE,     0},        0,              NULL, NULL}, /* 62 */
  141.    {{"~===",   NEQUIV,     Beginner}, Binary,         NULL, NULL}, /* 63 */
  142.    {{"~===:=", AUGNEQUIV,  0},        0,              NULL, NULL}, /* 64 */
  143.    {{"(",      LPAREN,     Beginner}, 0,              NULL, NULL}, /* 65 */
  144.    {{")",      RPAREN,     Ender},    0,              NULL, NULL}, /* 66 */
  145.    {{"+:",     PCOLON,     0},        0,              NULL, NULL}, /* 67 */
  146.    {{",",      COMMA,      0},        0,              NULL, NULL}, /* 68 */
  147.    {{"-:",     MCOLON,     0},        0,              NULL, NULL}, /* 69 */
  148.    {{":",      COLON,      0},        0,              NULL, NULL}, /* 70 */
  149.    {{";",      SEMICOL,    0},        0,              NULL, NULL}, /* 71 */
  150.    {{"[",      LBRACK,     Beginner}, 0,              NULL, NULL}, /* 72 */
  151.    {{"]",      RBRACK,     Ender},    0,              NULL, NULL}, /* 73 */
  152.    {{"{",      LBRACE,     Beginner}, 0,              NULL, NULL}, /* 74 */
  153.    {{"}",      RBRACE,     Ender},    0,              NULL, NULL}, /* 75 */
  154.    {{"$(",     LBRACE,     Beginner}, 0,              NULL, NULL}, /* 76 */
  155.    {{"$)",     RBRACE,     Ender},    0,              NULL, NULL}, /* 77 */
  156.    {{"$<",     LBRACK,     Beginner}, 0,              NULL, NULL}, /* 78 */
  157.    {{"$>",     RBRACK,     Ender},    0,              NULL, NULL}, /* 79 */
  158.    {{NULL,          0,     0},        0,              NULL, NULL}
  159.    };
  160.  
  161. int asgn_loc = 20;
  162. int semicol_loc = 71;
  163. int plus_loc = 9;
  164. int minus_loc = 13;
  165.  
  166. /*
  167.  * getopr - find the longest legal operator and return the
  168.  *  index to its entry in the operator table.
  169.  */
  170.  
  171. int getopr(ac, cc)
  172. int ac;
  173. int *cc;
  174.    {
  175.    register char c;
  176.  
  177.    *cc = ' ';
  178.    switch (c = ac) {
  179.       case '!':
  180.          return 0;   /* ! */
  181.       case '$':
  182.          switch (c = NextChar) {
  183.             case '(':
  184.                return 76;   /* $( */
  185.             case ')':
  186.                return 77;   /* $) */
  187.             case '<':
  188.                return 78;   /* $< */
  189.             case '>':
  190.                return 79;   /* $> */
  191.             }
  192.          break;
  193.       case '%':
  194.          if ((c = NextChar) == ':') {
  195.             if ((c = NextChar) == '=') {
  196.                return 2;   /* %:= */
  197.                }
  198.             }
  199.          else {
  200.             *cc = c;
  201.             return 1;   /* % */
  202.             }
  203.          break;
  204.       case '&':
  205.          if ((c = NextChar) == ':') {
  206.             if ((c = NextChar) == '=') {
  207.                return 4;   /* &:= */
  208.                }
  209.             }
  210.          else {
  211.             *cc = c;
  212.             return 3;   /* & */
  213.             }
  214.          break;
  215.       case '(':
  216.          return 65;   /* ( */
  217.       case ')':
  218.          return 66;   /* ) */
  219.       case '*':
  220.          switch (c = NextChar) {
  221.             case '*':
  222.                if ((c = NextChar) == ':') {
  223.                   if ((c = NextChar) == '=') {
  224.                      return 8;   /* **:= */
  225.                      }
  226.                   }
  227.                else {
  228.                   *cc = c;
  229.                   return 7;   /* ** */
  230.                   }
  231.                break;
  232.             case ':':
  233.                if ((c = NextChar) == '=') {
  234.                   return 6;   /* *:= */
  235.                   }
  236.                break;
  237.             default:
  238.                *cc = c;
  239.                return 5;   /* * */
  240.             }
  241.          break;
  242.       case '+':
  243.          switch (c = NextChar) {
  244.             case '+':
  245.                if ((c = NextChar) == ':') {
  246.                   if ((c = NextChar) == '=') {
  247.                      return 12;   /* ++:= */
  248.                      }
  249.                   }
  250.                else {
  251.                   *cc = c;
  252.                   return 11;   /* ++ */
  253.                   }
  254.                break;
  255.             case ':':
  256.                if ((c = NextChar) == '=') {
  257.                   return 10;   /* +:= */
  258.                   }
  259.                else {
  260.                   *cc = c;
  261.                   return 67;   /* +: */
  262.                   }
  263.             default:
  264.                *cc = c;
  265.                return 9;   /* + */
  266.             }
  267.          break;
  268.       case ',':
  269.          return 68;   /* , */
  270.       case '-':
  271.          switch (c = NextChar) {
  272.             case '-':
  273.                if ((c = NextChar) == ':') {
  274.                   if ((c = NextChar) == '=') {
  275.                      return 16;   /* --:= */
  276.                      }
  277.                   }
  278.                else {
  279.                   *cc = c;
  280.                   return 15;   /* -- */
  281.                   }
  282.                break;
  283.             case ':':
  284.                if ((c = NextChar) == '=') {
  285.                   return 14;   /* -:= */
  286.                   }
  287.                else {
  288.                   *cc = c;
  289.                   return 69;   /* -: */
  290.                   }
  291.             default:
  292.                *cc = c;
  293.                return 13;   /* - */
  294.             }
  295.          break;
  296.       case '.':
  297.          return 17;   /* . */
  298.       case '/':
  299.          if ((c = NextChar) == ':') {
  300.             if ((c = NextChar) == '=') {
  301.                return 19;   /* /:= */
  302.                }
  303.             }
  304.          else {
  305.             *cc = c;
  306.             return 18;   /* / */
  307.             }
  308.          break;
  309.       case ':':
  310.          if ((c = NextChar) == '=') {
  311.             if ((c = NextChar) == ':') {
  312.                return 21;   /* :=: */
  313.                }
  314.             else {
  315.                *cc = c;
  316.                return 20;   /* := */
  317.                }
  318.             }
  319.          else {
  320.             *cc = c;
  321.             return 70;   /* : */
  322.             }
  323.       case ';':
  324.          return 71;   /* ; */
  325.       case '<':
  326.          switch (c = NextChar) {
  327.             case '-':
  328.                if ((c = NextChar) == '>') {
  329.                   return 25;   /* <-> */
  330.                   }
  331.                else {
  332.                   *cc = c;
  333.                   return 24;   /* <- */
  334.                   }
  335.             case ':':
  336.                if ((c = NextChar) == '=') {
  337.                   return 23;   /* <:= */
  338.                   }
  339.                break;
  340.             case '<':
  341.                switch (c = NextChar) {
  342.                   case ':':
  343.                      if ((c = NextChar) == '=') {
  344.                         return 27;   /* <<:= */
  345.                         }
  346.                      break;
  347.                   case '=':
  348.                      if ((c = NextChar) == ':') {
  349.                         if ((c = NextChar) == '=') {
  350.                            return 29;   /* <<=:= */
  351.                            }
  352.                         }
  353.                      else {
  354.                         *cc = c;
  355.                         return 28;   /* <<= */
  356.                         }
  357.                      break;
  358.                   default:
  359.                      *cc = c;
  360.                      return 26;   /* << */
  361.                   }
  362.                break;
  363.             case '=':
  364.                if ((c = NextChar) == ':') {
  365.                   if ((c = NextChar) == '=') {
  366.                      return 31;   /* <=:= */
  367.                      }
  368.                   }
  369.                else {
  370.                   *cc = c;
  371.                   return 30;   /* <= */
  372.                   }
  373.                break;
  374.             default:
  375.                *cc = c;
  376.                return 22;   /* < */
  377.             }
  378.          break;
  379.       case '=':
  380.          switch (c = NextChar) {
  381.             case ':':
  382.                if ((c = NextChar) == '=') {
  383.                   return 33;   /* =:= */
  384.                   }
  385.                break;
  386.             case '=':
  387.                switch (c = NextChar) {
  388.                   case ':':
  389.                      if ((c = NextChar) == '=') {
  390.                         return 35;   /* ==:= */
  391.                         }
  392.                      break;
  393.                   case '=':
  394.                      if ((c = NextChar) == ':') {
  395.                         if ((c = NextChar) == '=') {
  396.                            return 37;   /* ===:= */
  397.                            }
  398.                         }
  399.                      else {
  400.                         *cc = c;
  401.                         return 36;   /* === */
  402.                         }
  403.                      break;
  404.                   default:
  405.                      *cc = c;
  406.                      return 34;   /* == */
  407.                   }
  408.                break;
  409.             default:
  410.                *cc = c;
  411.                return 32;   /* = */
  412.             }
  413.          break;
  414.       case '>':
  415.          switch (c = NextChar) {
  416.             case ':':
  417.                if ((c = NextChar) == '=') {
  418.                   return 39;   /* >:= */
  419.                   }
  420.                break;
  421.             case '=':
  422.                if ((c = NextChar) == ':') {
  423.                   if ((c = NextChar) == '=') {
  424.                      return 41;   /* >=:= */
  425.                      }
  426.                   }
  427.                else {
  428.                   *cc = c;
  429.                   return 40;   /* >= */
  430.                   }
  431.                break;
  432.             case '>':
  433.                switch (c = NextChar) {
  434.                   case ':':
  435.                      if ((c = NextChar) == '=') {
  436.                         return 43;   /* >>:= */
  437.                         }
  438.                      break;
  439.                   case '=':
  440.                      if ((c = NextChar) == ':') {
  441.                         if ((c = NextChar) == '=') {
  442.                            return 45;   /* >>=:= */
  443.                            }
  444.                         }
  445.                      else {
  446.                         *cc = c;
  447.                         return 44;   /* >>= */
  448.                         }
  449.                      break;
  450.                   default:
  451.                      *cc = c;
  452.                      return 42;   /* >> */
  453.                   }
  454.                break;
  455.             default:
  456.                *cc = c;
  457.                return 38;   /* > */
  458.             }
  459.          break;
  460.       case '?':
  461.          if ((c = NextChar) == ':') {
  462.             if ((c = NextChar) == '=') {
  463.                return 47;   /* ?:= */
  464.                }
  465.             }
  466.          else {
  467.             *cc = c;
  468.             return 46;   /* ? */
  469.             }
  470.          break;
  471.       case '@':
  472.          if ((c = NextChar) == ':') {
  473.             if ((c = NextChar) == '=') {
  474.                return 49;   /* @:= */
  475.                }
  476.             }
  477.          else {
  478.             *cc = c;
  479.             return 48;   /* @ */
  480.             }
  481.          break;
  482.       case '[':
  483.          return 72;   /* [ */
  484.       case '\\':
  485.          return 50;   /* \ */
  486.       case ']':
  487.          return 73;   /* ] */
  488.       case '^':
  489.          if ((c = NextChar) == ':') {
  490.             if ((c = NextChar) == '=') {
  491.                return 52;   /* ^:= */
  492.                }
  493.             }
  494.          else {
  495.             *cc = c;
  496.             return 51;   /* ^ */
  497.             }
  498.          break;
  499.       case '{':
  500.          return 74;   /* { */
  501.       case '|':
  502.          if ((c = NextChar) == '|') {
  503.             switch (c = NextChar) {
  504.                case ':':
  505.                   if ((c = NextChar) == '=') {
  506.                      return 55;   /* ||:= */
  507.                      }
  508.                   break;
  509.                case '|':
  510.                   if ((c = NextChar) == ':') {
  511.                      if ((c = NextChar) == '=') {
  512.                         return 57;   /* |||:= */
  513.                         }
  514.                      }
  515.                   else {
  516.                      *cc = c;
  517.                      return 56;   /* ||| */
  518.                      }
  519.                   break;
  520.                default:
  521.                   *cc = c;
  522.                   return 54;   /* || */
  523.                }
  524.             }
  525.          else {
  526.             *cc = c;
  527.             return 53;   /* | */
  528.             }
  529.          break;
  530.       case '}':
  531.          return 75;   /* } */
  532.       case '~':
  533.          if ((c = NextChar) == '=') {
  534.             switch (c = NextChar) {
  535.                case ':':
  536.                   if ((c = NextChar) == '=') {
  537.                      return 60;   /* ~=:= */
  538.                      }
  539.                   break;
  540.                case '=':
  541.                   switch (c = NextChar) {
  542.                      case ':':
  543.                         if ((c = NextChar) == '=') {
  544.                            return 62;   /* ~==:= */
  545.                            }
  546.                         break;
  547.                      case '=':
  548.                         if ((c = NextChar) == ':') {
  549.                            if ((c = NextChar) == '=') {
  550.                               return 64;   /* ~===:= */
  551.                               }
  552.                            }
  553.                         else {
  554.                            *cc = c;
  555.                            return 63;   /* ~=== */
  556.                            }
  557.                         break;
  558.                      default:
  559.                         *cc = c;
  560.                         return 61;   /* ~== */
  561.                      }
  562.                   break;
  563.                default:
  564.                   *cc = c;
  565.                   return 59;   /* ~= */
  566.                }
  567.             }
  568.          else {
  569.             *cc = c;
  570.             return 58;   /* ~ */
  571.             }
  572.          break;
  573.       }
  574.    tfatal("invalid character", (char *)NULL);
  575.    return -1;
  576.    }
  577.