Return to yyparse.c CVS log

Up to [MW Coherent from dump] / coherent / d / bin / yacc

Annotation of coherent/d/bin/yacc/yyparse.c, revision 1.1

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

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