home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c410 / 1.ddi / LEX / YTAB.C < prev    next >
Encoding:
C/C++ Source or Header  |  1980-01-01  |  25.8 KB  |  948 lines
  1. /*
  2.   HEADER:              CUG  nnn.nn;
  3.   TITLE:               LEX - A Lexical Analyser Generator
  4.   VERSION:             1.1 for IBM-PC
  5.   DATE:                Jan 30, 1985
  6.   DESCRIPTION:         A Lexical Analyser Generator. From UNIX
  7.   KEYWORDS:            Lexical Analyser Generator YACC C PREP
  8.   SYSTEM:              IBM-PC and Compatiables
  9.   FILENAME:            YTAB.C
  10.   WARNINGS:            This program is not for the casual user. It will
  11.                        be useful primarily to expert developers.
  12.   CRC:                 N/A
  13.   SEE-ALSO:            YACC and PREP
  14.   AUTHORS:             Charles H. Forsyth
  15.                        Scott Guthery 11100 leafwood lane Austin, TX 78750
  16.                        Andrew M. Ward, Jr.  Houston, Texas (Modifications)
  17.   COMPILERS:           LATTICE C
  18.   REFERENCES:          UNIX Systems Manuals -- Lex Manual on distribution disks
  19. */
  20. /*
  21.  * Copyright (c) 1978 Charles H. Forsyth
  22.  *
  23.  * Modified 02-Dec-80 Bob Denny -- Conditionalize debug code for reduced size
  24.  * Modified 29-May-81 Bob Denny -- Clean up overlay stuff for RSX.
  25.  * More     19-Mar-82 Bob Denny -- New C library & compiler
  26.  * More     03-May-82 Bob Denny -- Final touches, remove unreferenced autos
  27.  * More     29-Aug-82 Bob Denny -- Clean up -d printouts
  28.  * More     29-Aug-82 Bob Denny -- Reformat for readability and comment
  29.  *                                 while learning about LEX.
  30.  * More     20-Nov-83 Scott Guthery -- Adapt for IBM PC & DeSmet C
  31.  *
  32.  * Modified 22-Jun-86 Andrew Ward -- Modified code to compile under Lattice C
  33.  *                                 version 3.0h.  Corrected several errors
  34.  *                                 from the assumption that pointers and
  35.  *                                 integers are the same size.     
  36.  *                                 New debug code for LATTICE C using assert
  37.  *                                 to test for wild pointers.
  38.  */
  39.  
  40. #include <stdio.h>
  41. #include <assert.h>
  42. #include <stdlib.h>
  43. #include <string.h>
  44. #include "lexlex.h"
  45.  
  46. char    ccl[ (NCHARS+1) / NBPC ];
  47. int  sz_ccl = (NCHARS+1) / NBPC;
  48.     char *yysterm[] = {
  49.        "error",
  50.        "NAME",
  51.        "CCLASS",
  52.        "STRING",
  53.        "CONCAT",
  54.        0     };
  55.     extern char *progname;
  56.     extern char *breakc;
  57.     extern char *ignore;
  58.     extern char *illeg;
  59.     extern int  nlook;
  60.     char *lalloc();
  61.     struct des {
  62.        struct nfa *d_start;
  63.        struct nfa *d_final;
  64.     };
  65.     struct nlist {
  66.        struct  nlist   *nl_next;
  67.        struct  nfa     *nl_base;
  68.        struct  nfa     *nl_end;
  69.        struct  nfa     *nl_start;
  70.        struct  nfa     *nl_final;
  71.        char    *nl_name;
  72.     }
  73.     *nlist;
  74.     extern  int str_len;
  75.     extern  struct  nfa     *nfap;
  76.     extern  struct  nfa     *elem(int, char *);
  77.     extern  struct  des     *newdp(struct nfa *, struct nfa *);
  78.     extern  struct  nlist   *lookup(char *);
  79.     extern int     mapc(int);
  80.     extern int     cclass(void);
  81.     extern void    name(int);
  82.     extern void    action(void);
  83.     extern void    skipstr(int);
  84.     extern void    copycode(void);
  85.     extern void    string(int);
  86.     extern void    copynfa(struct nlist *, struct nfa *, struct des *);
  87.     extern void    spccl(char *, char *, struct des *, char **);
  88.     extern void    unget( int );
  89.     extern void    copy(char *, char *, int);
  90.     extern void    errmsg(char *);
  91.     extern void    yyerror(char *, char *);
  92.     extern void    newcase(int);
  93.     extern void    llactr(void);
  94.     extern void    setline(void);
  95.     extern void    cclprint(char *);
  96.     extern  int     yyline;
  97.  
  98. typedef union  {
  99.     char   *buff;
  100.     struct nlist *list;
  101.     struct des   *des_ptr;
  102.     struct nfa   *elem_ptr;
  103. } YYSTYPE;
  104. #define NAME 257
  105. #define CCLASS 258
  106. #define STRING 259
  107. #define CONCAT 260
  108. #define yyclearin yychar = -1
  109. #define yyerrok yyerrflag = 0
  110. extern int yychar;
  111. extern short yyerrflag;
  112. #ifndef YYMAXDEPTH
  113. #define YYMAXDEPTH 150
  114. #endif
  115. YYSTYPE yylval, yyval;
  116.  
  117.     struct nfa *np, *nbase;
  118.     char *cp;
  119.     struct des *dp, *dp1;
  120.     struct trans *tp;
  121.     struct nlist *nl;
  122.     int i, c;
  123.     #define YYERRCODE 256
  124.  
  125.  
  126.     /*
  127.  * Lexical analyser
  128.  * (it isn't done with lex...)
  129.  */
  130.        char    buffer[150];
  131.  
  132. int yylex()
  133.     {
  134.  
  135.        int c;
  136.        /*      char *cp; */
  137.        int lno;
  138.  
  139.        if (yyline == 0)
  140.            yyline++;
  141. loop:
  142.        c = get();
  143.        if (isupper(c)) {
  144.            name(c);
  145.            yylval.buff = strlwr( yylval.buff );
  146.            return(STRING);
  147.        }
  148.        else if (islower(c) || c == '_') {
  149.            name(c);
  150.            return(NAME);
  151.        }
  152.        switch (c) {
  153.        case EOF:
  154.            return(0);
  155.  
  156.        case '[':
  157.            return(cclass());
  158.  
  159.        case '(':
  160.        case ')':
  161.        case '{':
  162.        case '}':
  163.        case '*':
  164.        case '|':
  165.        case '=':
  166.        case ';':
  167.        case '%':
  168.            return(c);
  169.  
  170.        case '/':
  171.            if ((c = get()) != '*') {
  172.                unget(c);
  173.                return('/');
  174.            }
  175.            lno = yyline;
  176.            for (; c != EOF; c = get())
  177.                if (c == '*')
  178.                    if ((c = get()) == '/')
  179.                        goto loop;
  180.                    else
  181.                        unget(c);
  182.            yyline = lno;
  183.            errmsg("End of file in comment");
  184.  
  185.        case '\'':
  186.        case '"':
  187.            yylval.buff = buffer;
  188.            string(c);
  189.            return(STRING);
  190.  
  191.        case '\n':
  192.        case '\r':
  193.        case ' ':
  194.        case '\t':
  195.            goto loop;
  196.  
  197.        default:
  198.  
  199.            yylval.buff = buffer;
  200. /*         if (c == '\\') {
  201.                unget(c);
  202.                c = mapch(EOF);
  203.            }
  204. */
  205.            buffer[0] = c;
  206.            buffer[1] = '\0';
  207.            str_len = 1;
  208.            return(STRING);
  209.        }
  210. /* ERR: Warning 85: function return value mismatch */
  211.     }
  212.  
  213.  
  214. int cclass()
  215.     {
  216.        int c, i, lc;
  217.        int compl;
  218.  
  219.        compl = 0;
  220.        /* Zero the ccl array */
  221.        for (i = 0; i < sz_ccl; i++)  ccl[i] = '\0';
  222.        /* Check if exclusion definition */
  223.        if ((c = get()) == '^') compl++;
  224.        else  unget(c);
  225.  
  226.        lc = -1;
  227.        while( ( c = mapc(']') ) != EOF)
  228.        {
  229.            if (c == '-' && lc >= 0)
  230.            {
  231.                if((c = mapc(']')) == EOF)   break;
  232.                /* Map 'c' into bit pattern */
  233.                for(i = lc; i <= c; i++)  ccl[ i / NBPC ] |= 1 << (i % NBPC);
  234.                lc = -1;
  235.                continue;
  236.            }
  237.  
  238.            ccl[ c / NBPC ] |= 1 << ( c % NBPC );
  239.            lc = c;
  240.        }
  241.  
  242.        if (compl) {
  243.            for (i = 0; i < sz_ccl; i++)
  244.                ccl[i] ^= -1;
  245.            if (aflag == 0)
  246.                for (i = 0200; i < ( 1 << NBPC ); i++)
  247.                    ccl[i/NBPC] &= ~(1 << (i%NBPC));
  248.        }
  249.        yylval.buff = newccl( ccl );
  250.        return(CCLASS);
  251.     }
  252.  
  253. void string(ec)
  254. int ec;
  255.     {
  256.        char *cp;
  257.        int c;
  258.        extern int str_len;
  259.        for(cp = buffer; (c = mapc(ec)) != EOF;)
  260.            *cp++ = c;
  261.        *cp = '\0';
  262.        str_len = strlen( buffer );
  263.     }
  264.  
  265. int mapc(ec)
  266.        int ec;
  267.     {
  268.  
  269.        int c, v, i;
  270.  
  271.        if((c = get()) == ec)  return(EOF);
  272.        switch(c) {
  273.        case EOF:
  274.            errmsg("End of file in string");
  275.            return(c);
  276.  
  277.        case '\\':
  278.            if ((c = get()) >= '0' && c <= '7') {
  279.                i = 0;
  280.                for (v = 0; c>='0' && c<='7' && i++<3; c = get())
  281.                    v = v*010 + c-'0';
  282.                unget(c);
  283.                return(v&CMASK);
  284.            }
  285.            switch (c) {
  286.            case 'n':
  287.                return('\n');
  288.  
  289.            case 't':
  290.                return('\t');
  291.  
  292.            case 'b':
  293.                return('\b');
  294.  
  295.            case 'r':
  296.                return('\r');
  297.  
  298.            case '\n':
  299.                yyline++;
  300.                return(mapc(ec));
  301.            }
  302.  
  303.        default:
  304.        }
  305.        return(c);
  306.     }
  307.  
  308. void name(c)
  309.        int c;
  310.     {
  311.        char *cp;
  312.  
  313.        for (yylval.buff=cp=buffer; isalpha(c) || isdigit(c) || c=='_'; c=get())
  314.            *cp++ = c;
  315.        *cp = '\0';
  316.        str_len = strlen( buffer );
  317.        unget(c);
  318.     }
  319.  
  320. /*
  321.  * Miscellaneous functions
  322.  * used only by lex.y
  323.  */
  324. struct nfa *elem(k, v)
  325. int k;
  326. char *v;
  327.     {
  328.        struct nfa *fp;
  329.        fp = newnfa(k, (struct nfa *)NULL, (struct nfa *)NULL);
  330.  
  331.        if (k == CCL)
  332.            fp->n_ccl = v;
  333.        return(fp);
  334.     }
  335.  
  336. struct des *newdp(st, fi)
  337.     struct nfa *st, *fi;
  338.     {
  339.        struct des *dp;
  340.  
  341.        dp = (struct des *)lalloc(1, sizeof(struct des), "dfa input");
  342.        if( st != NULL) assert( isdata( (char *)st, sizeof( struct nfa ) ) );
  343.        if( fi != NULL) assert( isdata( (char *)fi, sizeof( struct nfa ) ) );
  344.        dp->d_start = st;
  345.        dp->d_final = fi;
  346.        return(dp);
  347.     }
  348.  
  349. void action()
  350.     {
  351.        int c;
  352.        int lno, lev;
  353.  
  354.        newcase(transp-trans);
  355.        lno = yyline;
  356.        lev = 0;
  357.        for (; (c = get()) != EOF && (c != '}' || lev); putc(c, llout))
  358.            if (c == '{')
  359.                lev++;
  360.            else if (c == '}')
  361.                lev--;
  362.            else if (c == '\'' || c == '"') {
  363.                putc(c, llout);
  364.                skipstr(c);
  365.            }
  366.        fprintf(llout, "\n\tbreak;\n");
  367.        if (c == EOF) {
  368.            yyline = lno;
  369.            errmsg("End of file in action");
  370.        }
  371.     }
  372.  
  373. void skipstr(ec)
  374.        int ec;
  375.     {
  376.        int c;
  377.  
  378.        while ((c = get()) != ec && c != EOF) {
  379.            putc(c, llout);
  380.            if (c == '\\' && (c = get()) != EOF)
  381.                putc(c, llout);
  382.        }
  383.     }
  384.  
  385.  
  386. void copycode()
  387.     {
  388.        int lno;
  389.        int c;
  390.  
  391.        setline();
  392.        lno = yyline;
  393.        for (; (c = get()) != EOF; putc(c, llout))
  394.            if (c == '%')
  395.            {
  396.                if ((c = get()) == '}')
  397.                    return;
  398.                unget(c);
  399.                c = '%';
  400.            }
  401.        yyline = lno;
  402.        errmsg("Incomplete %{ declaration");
  403.        exit(1);
  404.     }
  405.  
  406. struct nlist *lookup(s)
  407.        char *s;
  408.     {
  409.        struct nlist *nl;
  410.        char *cp;
  411.  
  412.        for (nl = nlist; nl; nl = nl->nl_next)
  413.            if (!strcmp(s, nl->nl_name))
  414.                return(nl);
  415.        nl = (struct nlist *)lalloc(1, sizeof(struct nlist), "namelist");
  416.        nl->nl_start = nl->nl_end = nl->nl_base = nl->nl_final = (struct nfa *)NULL;
  417.        nl->nl_next = nlist;
  418.        nlist = nl;
  419.        nl->nl_name = cp = strdup( s );
  420.        return(nl);
  421.     }
  422.  
  423. void copynfa(nl, nbase, dp)
  424.        struct nlist *nl;
  425.        struct des *dp;
  426.        struct nfa *nbase;
  427. {
  428.        struct nfa *np, *ob;
  429.        int j;
  430.        int i;
  431.  
  432.        ob = nl->nl_base;
  433.        i = nl->nl_end - ob;
  434.  
  435. #ifdef DEBUG
  436.        fprintf(stdout, "\nCOPYNFA: index i = %d",i);
  437. #endif
  438.        np = nbase;
  439.        copy((char *)np, (char *)ob, sizeof(struct nfa)*i);
  440.        for (np = nbase; i-- > 0; np++) {
  441.            np->n_flag &= ~NPRT;
  442.            for (j = 0; j < 2; j++)
  443.                if (np->n_succ[j])
  444.                    np->n_succ[j] = nbase + (np->n_succ[j] - ob);
  445.        }
  446.        dp->d_start = nbase + (int)(nl->nl_start-ob);
  447.        dp->d_final = nbase + (int)(nl->nl_final-ob);
  448. }
  449.  
  450. void spccl(nm, isit, dp, where)
  451.     char       *nm, *isit;
  452.     struct des *dp;
  453.     char       **where;
  454.     {
  455.        if (!strcmp(nm, isit))
  456.        {
  457.             if(*where != 0 )
  458.                  yyerror("redefinition of %s class", isit);
  459.             if (dp->d_start->n_char == CCL &&
  460.                  dp->d_start->n_succ[0] == dp->d_final)
  461.                  *where = dp->d_start->n_ccl;
  462.             else
  463.                  yyerror("Illegal %s class", isit);
  464.        }
  465.     }
  466.  
  467. int get()
  468.     {
  469.        int c;
  470.  
  471.        if ((c = getc(lexin)) == '\n')
  472.            yyline++;
  473.        return(c);
  474.     }
  475.  
  476. void unget(c)
  477.     int c;
  478.     {
  479.        if (c == '\n')
  480.            yyline--;
  481.        ungetc(c, lexin);
  482.     }
  483.  
  484. void errmsg(s)
  485.        char *s;
  486.     {
  487.        if (yyline)
  488.            fprintf(stderr, "%d: ", yyline);
  489.        fprintf(stderr, "%r", &s);
  490.        if (yychar > 256)
  491.            fprintf(stderr, " near `%s'", yysterm[yychar-256]);
  492.        else if (yychar < 256 && yychar > 0)
  493.            fprintf(stderr, " near `%c'", yychar);
  494.        fprintf(stderr, "\n");
  495.     }
  496.  
  497. void copy(out, in, count)
  498. char   *out;
  499. char   *in;
  500. int    count;
  501. {
  502.         while (--count >= 0)
  503.                 *out++ = *in++;
  504. }
  505.  
  506. void yyerror(format, value)
  507. char *format, *value;
  508. {
  509.         if (yyline)
  510.                 fprintf(stderr, "%d: ", yyline);
  511.         fprintf(stderr, format, value);
  512.         if (yychar > 256)
  513.                 fprintf(stderr, " near '%s'", yysterm[yychar-256]);
  514.         else if (yychar < 256 && yychar > 0)
  515.                 fprintf(stderr, " near '%c'", yychar);
  516.         fprintf(stderr, "\n");
  517. }
  518. int nterms = 15;
  519. int nnonter = 13;
  520. int nstate = 41;
  521.  
  522. char *yysnter[14] = {
  523. "$accept",
  524. "lexfile",
  525. "auxiliary_section",
  526. "translation_section",
  527. "auxiliaries",
  528. "auxiliary",
  529. "namedef",
  530. "regexp",
  531. "name",
  532. "translations",
  533. "translation",
  534. "llactr",
  535. "pattern",
  536. "action" };
  537.  
  538.  
  539.  
  540.  
  541.  
  542.  
  543. short yyexca[] ={
  544. -1, 1,
  545.         0, -1,
  546.         -2, 0,
  547. -1, 2,
  548.         0, 19,
  549.         -2, 22,
  550.         };
  551. #define YYNPROD 29
  552. #define YYLAST 244
  553. short yyact[]={
  554.  
  555.   18,  31,  26,  23,  32,  13,  23,  40,  32,  23,
  556.   29,  32,  23,  16,  32,  23,  34,  32,  23,  35,
  557.   32,  23,  11,   4,  25,   5,  19,  19,  37,  12,
  558.   28,  15,  27,  10,   9,   3,   8,   2,   1,  17,
  559.   36,  22,   6,   0,   0,   0,   0,   0,   0,   0,
  560.   38,   0,  39,   0,   0,   0,   0,   0,   0,   0,
  561.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  562.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  563.    0,   0,   0,   0,   0,   0,   0,  30,  14,   0,
  564.   33,  14,   0,  33,   0,   0,  33,   0,   0,  33,
  565.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  566.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  567.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  568.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  569.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  570.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  571.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  572.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  573.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  574.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  575.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  576.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  577.   24,  20,  21,  24,  20,  21,  24,  20,  21,  24,
  578.   20,  21,  24,  20,  21,  24,  20,  21,  24,  20,
  579.   21,   0,   7,   7 };
  580. short yypact[]={
  581.  
  582.  -14,-1000,-1000, -15, -32,-1000, -30,-1000,-1000, -37,
  583.  -37, -35,-1000,-1000,-1000, -19,-1000,-113, -36, -28,
  584. -1000,-1000,-1000, -19,-1000,-1000,-1000, -31,-1000,-1000,
  585. -1000,-1000,-1000, -19, -38, -19, -34,-1000, -22, -25,
  586. -1000 };
  587. short yypgo[]={
  588.  
  589.    0,  42,  41,  39,  16,  38,  37,  36,  35,  25,
  590.   34,  13,  33,  30 };
  591. short yyr1[]={
  592.  
  593.    0,   5,   5,   6,   6,   8,   8,   9,   9,   1,
  594.    2,   4,   4,   4,   4,   4,   4,   4,   7,   7,
  595.   10,  10,  12,  11,  11,  11,  13,   3,   3 };
  596. short yyr2[]={
  597.  
  598.    0,   2,   0,   3,   2,   2,   1,   4,   2,   1,
  599.    1,   1,   1,   1,   2,   3,   2,   3,   1,   0,
  600.    2,   2,   0,   2,   2,   2,   1,   3,   1 };
  601. short yychk[]={
  602.  
  603. -1000,  -5,  -6,  -8,  37,  -9,  -1, 257,  -7, -10,
  604.  -12,  37,  -9,  37, 123,  61, -11,  -3,  37,  -4,
  605.  258, 259,  -2,  40, 257, -11,  37,  -4, -13, 123,
  606.  123,  37,  42, 124,  -4,  47,  -4,  59,  -4,  -4,
  607.   41 };
  608. short yydef[]={
  609.  
  610.    2,  -2,  -2,   0,   0,   6,   0,   9,   1,  18,
  611.    0,   0,   5,   4,   8,   0,  20,   0,   0,  28,
  612.   11,  12,  13,   0,  10,  21,   3,   0,  23,  26,
  613.   24,  25,  14,   0,  16,   0,   0,   7,  15,  27,
  614.   17 };
  615. #define YYFLAG -1000
  616. #define YYERROR goto yyerrlab
  617. #define YYACCEPT return(0)
  618. #define YYABORT return(1)
  619. #ifdef  MSDOS
  620. #define Move(s,d) movmem( (char *)s,(char *)d,sizeof(YYSTYPE))
  621. #endif
  622.  
  623. /*      parser for yacc output  */
  624.  
  625. int     yydebug = 0;         /* 1 for debugging */
  626. YYSTYPE yyv[YYMAXDEPTH];     /* where the values are stored */
  627. int     yychar = -1;         /* current input token number */
  628. int     yynerrs = 0;         /* number of errors */
  629. short   yyerrflag = 0;       /* error recovery flag */
  630.  
  631. yyparse()
  632. {
  633.  
  634.         short    yys[YYMAXDEPTH];
  635.         short    yyj, yym;
  636.         register YYSTYPE *yypvt;
  637.         register short yystate, *yyps, yyn;
  638.         register YYSTYPE *yypv;
  639.         register short *yyxi;
  640.  
  641.         yystate = 0;
  642.         yychar = -1;
  643.         yynerrs = 0;
  644.         yyerrflag = 0;
  645.         yyps= &yys[-1];
  646.         yypv= &yyv[-1];
  647.  
  648.  yystack:    /* put a state and value onto the stack */
  649.  
  650.         if( yydebug  ) printf( "state %d, char 0%o\n", yystate, yychar );
  651.         /* The next statement produces a warning when compiled by LATTICE */
  652.         /* Ver 2.15, i.e. beyound object size.  The code still works  */
  653.         if( ++yyps > &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" ); return(1); }
  654.                 *yyps = yystate;
  655.                 ++yypv;
  656. #ifdef MSDOS
  657.              Move(&yyval,yypv); /* LATTICE and Ver. 7 conflict resolution */
  658. #else
  659.              *yypv = yyval;
  660. #endif
  661.  yynewstate:
  662.  
  663.         yyn = yypact[yystate];
  664.  
  665.         if( yyn<= YYFLAG ) goto yydefault; /* simple state */
  666.  
  667.         if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
  668.         if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;
  669.  
  670.         if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
  671.                 yychar = -1;
  672. #ifdef MSDOS
  673.                 Move(&yylval, &yyval); /* AMW */
  674. #else
  675.                 yyval = yylval;
  676. #endif
  677.                 yystate = yyn;
  678.                 if( yyerrflag > 0 ) --yyerrflag;
  679.                 goto yystack;
  680.                 }
  681.  
  682.  yydefault:
  683.         /* default state action */
  684.  
  685.         if( (yyn=yydef[yystate]) == -2 ) {
  686.                 if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
  687.                 /* look through exception table */
  688.  
  689.                 for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */
  690.                 while( *(yyxi+=2) >= 0 ){
  691.                         if( *yyxi == yychar ) break;
  692.                         }
  693.                 if( (yyn = yyxi[1]) < 0 ) return(0);   /* accept */
  694.                 }
  695.  
  696.         if( yyn == 0 ){ /* error */
  697.                 /* error ... attempt to resume parsing */
  698.  
  699.                 switch( yyerrflag ){
  700.  
  701.                 case 0:   /* brand new error */
  702.  
  703.                         yyerror( "syntax error" );
  704.                 yyerrlab:
  705.                         ++yynerrs;
  706.  
  707.                 case 1:
  708.                 case 2: /* incompletely recovered error ... try again */
  709.  
  710.                         yyerrflag = 3;
  711.  
  712.                         /* find a state where "error" is a legal shift action */
  713.  
  714.                         while ( yyps >= yys ) {
  715.                            yyn = yypact[*yyps] + YYERRCODE;
  716.                            if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
  717.                               yystate = yyact[yyn];  /* simulate a shift of "error" */
  718.                               goto yystack;
  719.                               }
  720.                            yyn = yypact[*yyps];
  721.  
  722.                            /* the current yyps has no shift onn "error", pop stack */
  723.  
  724.                            if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
  725.                            --yyps;
  726.                            --yypv;
  727.                            }
  728.  
  729.                         /* there is no state on the stack with an error shift ... abort */
  730.  
  731.         yyabort:
  732.                         return(1);
  733.  
  734.  
  735.                 case 3:  /* no shift yet; clobber input char */
  736.  
  737.                         if( yydebug ) printf( "error recovery discards char %d\n", yychar );
  738.  
  739.                         if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
  740.                         yychar = -1;
  741.                         goto yynewstate;   /* try again in the same state */
  742.  
  743.                         }
  744.  
  745.                 }
  746.  
  747.         /* reduction by production yyn */
  748.  
  749.                 if( yydebug ) printf("reduce %d\n",yyn);
  750.                 yyps -= yyr2[yyn];
  751.                 yypvt = yypv;
  752.                 yypv -= yyr2[yyn];
  753. #ifdef MSDOS
  754.                 Move(&yypv[1],&yyval); /* LATTICE and Ver. 7 conflict resolution */
  755. #else
  756.                 yyval = yypv[1];       /* Ver 7 permits asignments of this type */
  757. #endif
  758.                 yym=yyn;
  759.                         /* consult goto table to find next state */
  760.                 yyn = yyr1[yyn];
  761.                 yyj = yypgo[yyn] + *yyps + 1;
  762.                 if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
  763.                 switch(yym)
  764. {
  765.  
  766. case 7:
  767. {
  768.     dp = yypvt[-1].des_ptr;
  769.     nl = yypvt[-3].list;
  770.     np = nl->nl_base;
  771.     nl->nl_start = dp->d_start;
  772.     nl->nl_final = dp->d_final;
  773.     nl->nl_end = nfap;
  774. /* */
  775.     printf("NFA for %s\n", nl->nl_name);
  776.     nfaprint(dp->d_start, nl->nl_base);
  777. /* */
  778.     i = nl->nl_end - nl->nl_base;
  779.     nbase = (struct nfa *)lalloc(i, sizeof(struct nfa), "nfa storage");
  780.     copynfa(nl, nbase, dp);
  781.     nl->nl_start = dp->d_start;
  782.     nl->nl_final = dp->d_final;
  783.     nl->nl_end = nbase+i;
  784.     nl->nl_base = nbase;
  785.     nfap = np;
  786.     spccl(nl->nl_name, "ignore", dp, &ignore);
  787.     spccl(nl->nl_name, "break", dp, &breakc);
  788.     spccl(nl->nl_name, "illegal", dp, &illeg);
  789. } break;
  790. case 8:
  791. {
  792.     copycode();
  793. } break;
  794. case 9:
  795. {
  796.     yyval.list = lookup(yypvt[-0].buff);
  797.     yyval.list->nl_base = nfap;
  798.     if (yyval.list->nl_start)
  799.        yyerror("%s redefined", yyval.list->nl_name);
  800. } break;
  801. case 10:
  802.  {
  803.     yyval.list = lookup(yypvt[-0].buff);
  804. } break;
  805. case 11:
  806.  {
  807.     np = elem(CCL, yypvt[-0].buff);
  808.     yyval.des_ptr = newdp(np, (np->n_succ[0] = elem(FIN, (char *)NULL ) ) );
  809. } break;
  810. case 12:
  811. {
  812.     cp = yypvt[-0].buff;
  813.     if (str_len == 0) {
  814.        np = elem(EPSILON, (char *)NULL );
  815.        yyval.des_ptr = newdp(np, (np->n_succ[0] = elem(FIN, (char *)NULL ) ) );
  816.        return(0); /* AMW: the return here appears in error */
  817.        }
  818.     else /* AMW: else stmt added 1 May 1986 $$->d_start added */
  819.        {
  820.        yyval.des_ptr->d_start = np = elem(*cp++, (char *)NULL);
  821.        while(--str_len > 0)
  822.            np = np->n_succ[0] = elem(*cp++,(char *)NULL);
  823.        yyval.des_ptr = newdp(yyval.des_ptr->d_start, ( np->n_succ[0] = elem( FIN, (char *)NULL ) ) );
  824.        }
  825.     } break;
  826. case 13:
  827. {
  828.        if ((nl = yypvt[-0].list)->nl_end == NULL)
  829.        {
  830.            yyerror("%s not defined", nl->nl_name);
  831.            nl->nl_base = nl->nl_end = elem(FIN, (char *)NULL);
  832.            nl->nl_start = nl->nl_final = nl->nl_base;
  833.        }
  834.        yyval.des_ptr = dp = (struct des *)lalloc(1, sizeof(struct des), "dfa input");
  835.        nbase = nfap;
  836.        i = nl->nl_end - nl->nl_base;
  837.        if ((nfap += i) >= &nfa[MAXNFA]) {
  838.            errmsg("Out of NFA nodes");
  839.            exit(1);
  840.        }
  841.        copynfa(nl, nbase, dp);
  842.     } break;
  843. case 14:
  844. {
  845.        yyval.des_ptr = dp = yypvt[-1].des_ptr;
  846.        dp->d_start = newnfa(EPSILON, (np = dp->d_start), (struct nfa *)NULL);
  847.        dp->d_final->n_char = EPSILON;
  848.        dp->d_final->n_succ[0] = np;
  849.        dp->d_final->n_succ[1] = np = elem(FIN, (char *)NULL);
  850.        dp->d_start->n_succ[1] = np;
  851.        dp->d_final = np;
  852.     } break;
  853. case 15:
  854. {
  855.        yyval.des_ptr = dp = yypvt[-2].des_ptr;
  856.        dp->d_start = newnfa(EPSILON, dp->d_start, yypvt[-0].des_ptr->d_start);
  857.        dp->d_final->n_char = EPSILON;
  858.        dp->d_final = dp->d_final->n_succ[0] = np = elem(FIN, (char *)NULL );
  859.        dp = yypvt[-0].des_ptr;
  860.        dp->d_final->n_char = EPSILON;
  861.        dp->d_final->n_succ[0] = np;
  862.        assert( isdata( (char *)yypvt[-0].des_ptr, sizeof( struct des) ) );
  863.        free((char *)yypvt[-0].des_ptr);
  864.     } break;
  865. case 16:
  866. {
  867.        yyval.des_ptr = yypvt[-1].des_ptr;
  868.        dp = yypvt[-0].des_ptr;
  869.        np = yyval.des_ptr->d_final;
  870.        yyval.des_ptr->d_final = dp->d_final;
  871.        np->n_char = dp->d_start->n_char;
  872.        np->n_ccl = dp->d_start->n_ccl;
  873.        np->n_succ[0] = dp->d_start->n_succ[0];
  874.        np->n_succ[1] = dp->d_start->n_succ[1];
  875.  
  876.        assert( isdata( (char *)yypvt[-0].des_ptr, sizeof( struct nlist) ) );
  877.        free((char *)yypvt[-0].des_ptr);
  878.     } break;
  879. case 17:
  880. {
  881.        yyval.des_ptr = yypvt[-1].des_ptr;
  882.     } break;
  883. case 18:
  884. {
  885.        ending();
  886. trans1:
  887.  
  888.        printf("\nNFA for complete syntax\n");
  889.        printf("state 0\n");
  890.        for (tp = trans; tp < transp; tp++)
  891.            printf("\tepsilon\t%d\n", tp->t_start-nfa);
  892.        for (tp = trans; tp < transp; tp++)
  893.            nfaprint(tp->t_start, nfa);
  894.        ;
  895.     } break;
  896. case 19:
  897. {
  898.        goto trans1;
  899.     } ;
  900. case 22:
  901. {
  902.        llactr();
  903.     } break;
  904. case 23:
  905. {
  906.        dp = yypvt[-1].des_ptr;
  907.        newtrans(dp->d_start, dp->d_final);
  908.     } break;
  909. case 24:
  910. {
  911.        copycode();
  912.     } break;
  913. case 25:
  914. {
  915.        ending();
  916.        while ((c = get()) != EOF)
  917.            putc(c, llout);
  918.     } break;
  919. case 26:
  920. {
  921.        action();
  922.     } break;
  923. case 27:
  924. {
  925.        if (nlook >= NBPW)
  926.            yyerror("More than %d translations with lookahead",NBPW);
  927.        yyval.des_ptr = dp = yypvt[-2].des_ptr;
  928.        np = dp->d_final;
  929.        np->n_char = EPSILON;
  930.        np->n_flag |= LOOK;
  931.        np->n_succ[0] = yypvt[-0].des_ptr->d_start;
  932.        dp->d_final = yypvt[-0].des_ptr->d_final;
  933.        np->n_look = nlook;
  934.        dp->d_final->n_look = nlook++;
  935.        dp->d_final->n_flag |= FLOOK;
  936.  
  937.        assert( isdata( (char *)yypvt[-0].des_ptr, sizeof( struct des) ) );
  938.        free((char *)yypvt[-0].des_ptr);
  939.     } break;
  940. }
  941.                 goto yystack;  /* stack new state and value */
  942.  
  943. /* ERR: Warning 85: function return value mismatch */
  944. }
  945.  
  946.  
  947.  
  948.