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