Return to yyparse.c CVS log

Up to [MW Coherent from dump] / coherent / a / lib

Annotation of coherent/a/lib/yyparse.c, revision 1.1

1.1     ! root        1: /* (-lgl
        !             2:  *     COHERENT Version 3.0
        !             3:  *     Copyright (c) 1982, 1990 by Mark Williams Company.
        !             4:  *     All rights reserved. May not be copied without permission.
        !             5:  -lgl) */
        !             6: #include "action.h"
        !             7: #define YYNOCHAR (-1000)
        !             8: #define        yyerrok yyerrflag=0
        !             9: #define        yyclearin       yylval=YYNOCHAR
        !            10: int yystack[YYMAXDEPTH];
        !            11: YYSTYPE yyvstack[YYMAXDEPTH], *yyv;
        !            12: int yychar;
        !            13: 
        !            14: #ifdef YYDEBUG
        !            15: int yydebug = 1;       /* No sir, not in the BSS */
        !            16: #include <stdio.h>
        !            17: #endif
        !            18: 
        !            19: short yyerrflag;
        !            20: int *yys;
        !            21: 
        !            22: yyparse()
        !            23: {
        !            24:        register YYSTYPE *yypvt;
        !            25:        int act;
        !            26:        register unsigned *ip, yystate;
        !            27:        int pno;
        !            28:        yystate = 0;
        !            29:        yychar = YYNOCHAR;
        !            30:        yyv = &yyvstack[-1];
        !            31:        yys = &yystack[-1];
        !            32: 
        !            33: stack:
        !            34:        if( ++yys >= &yystack[YYMAXDEPTH] ) {
        !            35:                write(2, "Stack overflow\n", 15);
        !            36:                exit(1);
        !            37:        }
        !            38:        *yys = yystate;
        !            39:        *++yyv = yyval;
        !            40: #ifdef YYDEBUG
        !            41:        if( yydebug )
        !            42:                fprintf(stdout, "Stack state %d, char %d\n", yystate, yychar);
        !            43: #endif
        !            44: 
        !            45: read:
        !            46:        ip = &yyact[yypa[yystate]];
        !            47:        if( ip[1] != YYNOCHAR ) {
        !            48:                if( yychar == YYNOCHAR ) {
        !            49:                        yychar = yylex();
        !            50: #ifdef YYDEBUG
        !            51:                        if( yydebug )
        !            52:                                fprintf(stdout, "lex read char %d, val %d\n", yychar, yylval);
        !            53: #endif
        !            54:                }
        !            55:                while (ip[1]!=YYNOCHAR) {
        !            56:                        if (ip[1]==yychar)
        !            57:                                break;
        !            58:                        ip += 2;
        !            59:                }
        !            60:        }
        !            61:        act = ip[0];
        !            62:        switch( act>>YYACTSH ) {
        !            63:        case YYSHIFTACT:
        !            64:                if( ip[1]==YYNOCHAR )
        !            65:                        goto YYerract;
        !            66:                if( yychar != -1 )
        !            67:                        yychar = YYNOCHAR; /* dont throw away EOF */
        !            68:                yystate = act&YYAMASK;
        !            69:                yyval = yylval;
        !            70: #ifdef YYDEBUG
        !            71:                if( yydebug )
        !            72:                        fprintf(stdout, "shift %d\n", yystate);
        !            73: #endif
        !            74:                if( yyerrflag )
        !            75:                        --yyerrflag;
        !            76:                goto stack;
        !            77: 
        !            78:        case YYACCEPTACT:
        !            79: #ifdef YYDEBUG
        !            80:                if( yydebug )
        !            81:                        fprintf(stdout, "accept\n");
        !            82: #endif
        !            83:                return(0);
        !            84: 
        !            85:        case YYERRACT:
        !            86:        YYerract:
        !            87:                switch (yyerrflag) {
        !            88:                case 0:
        !            89:                        yyerror("Syntax error");
        !            90: 
        !            91:                case 1:
        !            92:                case 2:
        !            93: 
        !            94:                        yyerrflag = 3;
        !            95:                        while( yys >= & yystack[0] ) {
        !            96:                                ip = &yyact[yypa[*yys]];
        !            97:                                while( ip[1]!=YYNOCHAR )
        !            98:                                        ip += 2;
        !            99:                                if( (*ip&~YYAMASK) == (YYSHIFTACT<<YYACTSH) ) {
        !           100:                                        yystate = *ip&YYAMASK;
        !           101:                                        goto stack;
        !           102:                                }
        !           103: #ifdef YYDEBUG
        !           104:                                if( yydebug )
        !           105:                                        fprintf(stderr, "error recovery leaves state %d, uncovers %d\n", *yys, yys[-1]);
        !           106: #endif
        !           107:                                yys--;
        !           108:                                yyv--;
        !           109:                        }
        !           110: #ifdef YYDEBUG
        !           111:                        if( yydebug )
        !           112:                                fprintf(stderr, "no shift on error; abort\n");
        !           113: #endif
        !           114:                        return(1);
        !           115: 
        !           116:                case 3:
        !           117: #ifdef YYDEBUG
        !           118:                        if( yydebug )
        !           119:                                fprintf(stderr, "Error recovery clobbers char %o\n", yychar);
        !           120: #endif
        !           121:                        if( yychar==YYEOFVAL )
        !           122:                                return(1);
        !           123:                        yychar = YYNOCHAR;
        !           124:                        goto read;
        !           125:                }
        !           126: 
        !           127:        case YYREDACT:
        !           128:                pno = act&YYAMASK;
        !           129: #ifdef YYDEBUG
        !           130:                if( yydebug )
        !           131:                        fprintf(stdout, "reduce %d\n", pno);
        !           132: #endif
        !           133:                yypvt = yyv;
        !           134:                yyv -= yypn[pno];
        !           135:                yys -= yypn[pno];
        !           136:                yyval = yyv[1];
        !           137:                switch(pno) {
        !           138: $A
        !           139:                }
        !           140:                ip = &yygo[ yypgo[yypdnt[pno]] ];
        !           141:                while( *ip!=*yys && *ip!=YYNOCHAR )
        !           142:                        ip += 2;
        !           143:                yystate = ip[1];
        !           144:                goto stack;
        !           145:        }
        !           146: }
        !           147: 
        !           148: 
        !           149: 
        !           150: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.