Return to y.tab.c CVS log

Up to [Research Unix] / researchv9 / cmd / eqn

Annotation of researchv9/cmd/eqn/y.tab.c, revision 1.1

1.1     ! root        1: # define CONTIG 257
        !             2: # define QTEXT 258
        !             3: # define SPACE 259
        !             4: # define THIN 260
        !             5: # define TAB 261
        !             6: # define MATRIX 262
        !             7: # define LCOL 263
        !             8: # define CCOL 264
        !             9: # define RCOL 265
        !            10: # define COL 266
        !            11: # define ABOVE 267
        !            12: # define MARK 268
        !            13: # define LINEUP 269
        !            14: # define SUM 270
        !            15: # define INT 271
        !            16: # define PROD 272
        !            17: # define UNION 273
        !            18: # define INTER 274
        !            19: # define DEFINE 275
        !            20: # define TDEFINE 276
        !            21: # define NDEFINE 277
        !            22: # define DELIM 278
        !            23: # define GSIZE 279
        !            24: # define GFONT 280
        !            25: # define INCLUDE 281
        !            26: # define IFDEF 282
        !            27: # define DOTEQ 283
        !            28: # define DOTEN 284
        !            29: # define FROM 285
        !            30: # define TO 286
        !            31: # define OVER 287
        !            32: # define SQRT 288
        !            33: # define SUP 289
        !            34: # define SUB 290
        !            35: # define SIZE 291
        !            36: # define FONT 292
        !            37: # define ROMAN 293
        !            38: # define ITALIC 294
        !            39: # define BOLD 295
        !            40: # define FAT 296
        !            41: # define UP 297
        !            42: # define DOWN 298
        !            43: # define BACK 299
        !            44: # define FWD 300
        !            45: # define LEFT 301
        !            46: # define RIGHT 302
        !            47: # define DOT 303
        !            48: # define DOTDOT 304
        !            49: # define HAT 305
        !            50: # define TILDE 306
        !            51: # define BAR 307
        !            52: # define LOWBAR 308
        !            53: # define HIGHBAR 309
        !            54: # define UNDER 310
        !            55: # define VEC 311
        !            56: # define DYAD 312
        !            57: # define UTILDE 313
        !            58: 
        !            59: # line 17 "eqn.y"
        !            60: #include "e.h"
        !            61: #define yyclearin yychar = -1
        !            62: #define yyerrok yyerrflag = 0
        !            63: extern int yychar;
        !            64: extern short yyerrflag;
        !            65: #ifndef YYMAXDEPTH
        !            66: #define YYMAXDEPTH 150
        !            67: #endif
        !            68: #ifndef YYSTYPE
        !            69: #define YYSTYPE int
        !            70: #endif
        !            71: YYSTYPE yylval, yyval;
        !            72: # define YYERRCODE 256
        !            73: 
        !            74: # line 138 "eqn.y"
        !            75: 
        !            76: short yyexca[] ={
        !            77: -1, 0,
        !            78:        0, 3,
        !            79:        -2, 0,
        !            80: -1, 1,
        !            81:        0, -1,
        !            82:        -2, 0,
        !            83:        };
        !            84: # define YYNPROD 90
        !            85: # define YYLAST 527
        !            86: short yyact[]={
        !            87: 
        !            88:    6,  51,  52,  48, 118,  50,  49,  72,  71, 102,
        !            89:  130, 103,  51, 122,  48, 124,  50,  49, 116,  61,
        !            90:   64,  54,  62,  57,  58,  59,  60,  55,  56,  63,
        !            91:   61,  64,  54,  62,  57,  58,  59,  60,  55,  56,
        !            92:   63,  50,  49,  80,  81, 105,   6, 119,  97,  40,
        !            93:  114,  78, 120,  49,  26,  61,  64,  54,  62,  57,
        !            94:   58,  59,  60,  55,  56,  63,  61,  64,  54,  62,
        !            95:   57,  58,  59,  60,  55,  56,  63,  61,  64,  54,
        !            96:   62,  57,  58,  59,  60,  55,  56,  63,  41,  42,
        !            97:   43,  44,   6,  25, 104,   2,  24,  23,  27,  53,
        !            98:  100,  65,  22,  96,  95,  99,  98,  21,  94,  93,
        !            99:   18,  17, 113,  89, 121,  84,  46,  73,   1,   0,
        !           100:    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        !           101:  127,   0,   0,   0,   8,   7,   9,  10,  11,  28,
        !           102:   41,  42,  43,  44,   6,  16,  47,  12,  34,  13,
        !           103:   14,  15, 117,  41,  42,  43,  44,   0, 123,   0,
        !           104:  117,   0,   0,   0,   0,  20,   0,   0,  29,  33,
        !           105:   30,  31,  32,  19,  37,  39,  38,  36,  35, 101,
        !           106:    8,   7,   9,  10,  11,  28,  41,  42,  43,  44,
        !           107:    6,  16,  47,  12,  34,  13,  14,  15,   0,   0,
        !           108:    0, 115,   0,   0,   0,   0,   0,   0,   0,   0,
        !           109:    0,  20, 126, 125,  29,  33,  30,  31,  32,  19,
        !           110:   37,  39,  38,  36,  35,   3,   8,   7,   9,  10,
        !           111:   11,  28,  41,  42,  43,  44,   6,  16,   5,  12,
        !           112:   34,  13,  14,  15,  80,  81,   0,  80,  81,  80,
        !           113:   81,   0,   0,   0,   0,   0,   0,  20,   0,   0,
        !           114:   29,  33,  30,  31,  32,  19,  37,  39,  38,  36,
        !           115:   35,   0,   0,   0,   0,   0,   0,   0,   8,   7,
        !           116:    9,  10,  11,  28,  41,  42,  43,  44,   0,  16,
        !           117:   47,  12,  34,  13,  14,  15,   0,   0,   0,   0,
        !           118:    0,   0,   0,   0,   0,   0,   0,   0,   0,  20,
        !           119:    0,   0,  29,  33,  30,  31,  32,  19,  37,  39,
        !           120:   38,  36,  35,   0,   8,   7,   9,  10,  11,  28,
        !           121:   41,  42,  43,  44,   0,  16,   5,  12,  34,  13,
        !           122:   14,  15,   0,   0,   0,   0,   0,   0,   0,   0,
        !           123:    0,   0,   0,   0,  79,  20,   0,   0,  29,  33,
        !           124:   30,  31,  32,  19,  37,  39,  38,  36,  35,   0,
        !           125:    8,   7,   9,  10,  11,  28,  41,  42,  43,  44,
        !           126:    0,  16,   0,  12,  34,  13,  14,  15,  82,   0,
        !           127:   83,  85,  86,  87,  88,  90,   0,   0,   0,   4,
        !           128:    0,  20,  45,   0,  29,  33,  30,  31,  32,  19,
        !           129:   37,  39,  38,  36,  35,   0,  66,  67,  68,  69,
        !           130:   70,   0,   0,  74,  75,  76,  77,   0,   0,   0,
        !           131:    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        !           132:    0,   0,   0,   0,   0,   0,   0,  91,  92,   0,
        !           133:    0,   0,   0,   0,   0,   0, 112,   0,   0,   0,
        !           134:    0,   0,   0,   0,   0,  45,   0,   0,   0,   0,
        !           135:    0,   0,   0,  45,   0,   0,   0,   0,   0,   0,
        !           136:    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        !           137:    0,   0,   0, 106, 107, 108, 109,   0, 110, 111,
        !           138:    0,   0,   0,   0,  45,   0,   0,   0,   0,   0,
        !           139:    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
        !           140:  128,   0, 129,   0,   0,   0,  45 };
        !           141: short yypact[]={
        !           142: 
        !           143:  -31,-1000,  21,-1000,-284,-1000,  67,-1000,-1000,-1000,
        !           144: -1000,-1000,-1000,-1000,-1000,-1000, 113, 113, 113, 113,
        !           145:  113,-282,  67, 113, 113, 113, 113,-1000,-1000,-214,
        !           146: -1000,-1000,-1000,-214,-1000,  -8,-214,-214,-214,-214,
        !           147:  -10,-1000,-1000,-1000,-1000,-284,-1000, 113, 113,-1000,
        !           148: -1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
        !           149: -1000,-1000,-1000,-1000,-1000, -77,-284,-226,-226,-226,
        !           150: -248,-1000,-1000,-123,-226,-226,-226,-226,-114,-1000,
        !           151: -1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,  67,
        !           152: -1000,-284,-248, 113, 113, 113, 113,-1000, 113, 113,
        !           153: -1000, -13,-175,-107,  21,-119,-237,-248,-273,-284,
        !           154: -237,-248,-1000,-1000,-110,-1000,-1000,  67,  67,-1000,
        !           155:  113,-1000, 113,-1000,-1000,-1000,  21,-115,-248,-284,
        !           156: -1000 };
        !           157: short yypgo[]={
        !           158: 
        !           159:    0, 118,  94, 399, 116,  47, 114, 111, 110, 109,
        !           160:  108, 107, 106, 105, 104, 103, 102, 100,  99,  97,
        !           161:   96,  93,  54,  98,  51,  50, 354,  49,  11,  45 };
        !           162: short yyr1[]={
        !           163: 
        !           164:    0,   1,   1,   1,   2,   2,   2,   2,   4,   5,
        !           165:    5,   6,   6,   3,   3,   3,   3,   3,   3,   3,
        !           166:    3,   3,   3,   3,   3,   3,   3,   3,   3,   9,
        !           167:    3,  10,   3,  12,   3,  13,   3,   3,  14,   3,
        !           168:   15,   3,   3,   3,   3,   3,   3,   3,   3,   3,
        !           169:   24,   3,  11,  19,  20,  21,  22,  18,  18,  18,
        !           170:   18,  18,  18,  18,  18,  18,  18,  18,  16,  16,
        !           171:   17,  17,  25,  25,  23,  29,  23,  27,  27,  27,
        !           172:   27,  28,  28,   7,   8,   8,   8,   8,  26,  26 };
        !           173: short yyr2[]={
        !           174: 
        !           175:    0,   1,   1,   0,   1,   2,   2,   1,   2,   2,
        !           176:    0,   2,   0,   3,   1,   1,   1,   1,   1,   1,
        !           177:    1,   1,   1,   3,   2,   2,   2,   2,   2,   0,
        !           178:    5,   0,   4,   0,   5,   0,   4,   1,   0,   5,
        !           179:    0,   4,   3,   2,   2,   2,   2,   2,   2,   1,
        !           180:    0,   5,   1,   2,   2,   2,   2,   1,   1,   1,
        !           181:    1,   1,   1,   1,   1,   1,   1,   1,   2,   2,
        !           182:    2,   2,   1,   2,   4,   0,   6,   1,   1,   1,
        !           183:    1,   1,   3,   2,   1,   1,   1,   2,   1,   1 };
        !           184: short yychk[]={
        !           185: 
        !           186: -1000,  -1,  -2, 256,  -3, 269, 123, 258, 257, 259,
        !           187:  260, 261, 270, 272, 273, 274, 268,  -7,  -8, 296,
        !           188:  288, -11, -16, -19, -20, -21, -22, -23, 262, 291,
        !           189:  293, 294, 295, 292, 271, 301, 300, 297, 299, 298,
        !           190:  -27, 263, 264, 265, 266,  -3,  -4, 269, 287, 290,
        !           191:  289, 285, 286, -18, 305, 311, 312, 307, 308, 309,
        !           192:  310, 303, 306, 313, 304,  -2,  -3,  -3,  -3,  -3,
        !           193:   -3, 290, 289,  -2,  -3,  -3,  -3,  -3, -24, -26,
        !           194:  257, 258, -26, -26, 123, -26, -26, -26, -26, 123,
        !           195:  -26,  -3,  -3,  -9, -10, -14, -15, 125, -12, -13,
        !           196:  -17, 302, 123, -28,  -2, -29,  -3,  -3,  -3,  -3,
        !           197:   -3,  -3, -26, 125, -25, -23, 125, 267, 123,  -5,
        !           198:  289,  -6, 286,  -5, 125, -23,  -2, -28,  -3,  -3,
        !           199:  125 };
        !           200: short yydef[]={
        !           201: 
        !           202:   -2,  -2,   1,   2,   4,   7,   0,  14,  15,  16,
        !           203:   17,  18,  19,  20,  21,  22,   0,   0,   0,   0,
        !           204:    0,  37,   0,   0,   0,   0,   0,  49,  50,   0,
        !           205:   84,  85,  86,   0,  52,   0,   0,   0,   0,   0,
        !           206:    0,  77,  78,  79,  80,   5,   6,   0,   0,  29,
        !           207:   31,  38,  40,  44,  57,  58,  59,  60,  61,  62,
        !           208:   63,  64,  65,  66,  67,   0,  24,  25,  26,  27,
        !           209:   28,  33,  35,  43,  45,  46,  47,  48,   0,  83,
        !           210:   88,  89,  87,  68,  69,  53,  54,  55,  56,   0,
        !           211:   75,   8,  23,   0,   0,   0,   0,  13,   0,   0,
        !           212:   42,   0,   0,   0,  81,   0,  10,  32,  12,  41,
        !           213:   10,  36,  70,  71,   0,  72,  74,   0,   0,  30,
        !           214:    0,  39,   0,  34,  51,  73,  82,   0,   9,  11,
        !           215:   76 };
        !           216: # ifdef YYDEBUG
        !           217: # include "y.debug"
        !           218: # endif
        !           219: 
        !           220: # define YYFLAG -1000
        !           221: # define YYERROR goto yyerrlab
        !           222: # define YYACCEPT return(0)
        !           223: # define YYABORT return(1)
        !           224: 
        !           225: /*     parser for yacc output  */
        !           226: 
        !           227: #ifdef YYDEBUG
        !           228: int yydebug = 0; /* 1 for debugging */
        !           229: #endif
        !           230: YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
        !           231: int yychar = -1; /* current input token number */
        !           232: int yynerrs = 0;  /* number of errors */
        !           233: short yyerrflag = 0;  /* error recovery flag */
        !           234: 
        !           235: yyparse()
        !           236: {      short yys[YYMAXDEPTH];
        !           237:        int yyj, yym;
        !           238:        register YYSTYPE *yypvt;
        !           239:        register int yystate, yyn;
        !           240:        register short *yyps;
        !           241:        register YYSTYPE *yypv;
        !           242:        register short *yyxi;
        !           243: 
        !           244:        yystate = 0;
        !           245:        yychar = -1;
        !           246:        yynerrs = 0;
        !           247:        yyerrflag = 0;
        !           248:        yyps= &yys[-1];
        !           249:        yypv= &yyv[-1];
        !           250: 
        !           251: yystack:    /* put a state and value onto the stack */
        !           252: #ifdef YYDEBUG
        !           253:        if(yydebug >= 3)
        !           254:                if(yychar < 0 || yytoknames[yychar] == 0)
        !           255:                        printf("char %d in %s", yychar, yystates[yystate]);
        !           256:                else
        !           257:                        printf("%s in %s", yytoknames[yychar], yystates[yystate]);
        !           258: #endif
        !           259:        if( ++yyps >= &yys[YYMAXDEPTH] ) { 
        !           260:                yyerror( "yacc stack overflow" ); 
        !           261:                return(1); 
        !           262:        }
        !           263:        *yyps = yystate;
        !           264:        ++yypv;
        !           265:        *yypv = yyval;
        !           266: yynewstate:
        !           267:        yyn = yypact[yystate];
        !           268:        if(yyn <= YYFLAG) goto yydefault; /* simple state */
        !           269:        if(yychar<0) {
        !           270:                yychar = yylex();
        !           271: #ifdef YYDEBUG
        !           272:                if(yydebug >= 2) {
        !           273:                        if(yychar <= 0)
        !           274:                                printf("lex EOF\n");
        !           275:                        else if(yytoknames[yychar])
        !           276:                                printf("lex %s\n", yytoknames[yychar]);
        !           277:                        else
        !           278:                                printf("lex (%c)\n", yychar);
        !           279:                }
        !           280: #endif
        !           281:                if(yychar < 0)
        !           282:                        yychar = 0;
        !           283:        }
        !           284:        if((yyn += yychar) < 0 || yyn >= YYLAST)
        !           285:                goto yydefault;
        !           286:        if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
        !           287:                yychar = -1;
        !           288:                yyval = yylval;
        !           289:                yystate = yyn;
        !           290:                if( yyerrflag > 0 ) --yyerrflag;
        !           291:                goto yystack;
        !           292:        }
        !           293: yydefault:
        !           294:        /* default state action */
        !           295:        if( (yyn=yydef[yystate]) == -2 ) {
        !           296:                if(yychar < 0) {
        !           297:                        yychar = yylex();
        !           298: #ifdef YYDEBUG
        !           299:                        if(yydebug >= 2)
        !           300:                                if(yychar < 0)
        !           301:                                        printf("lex EOF\n");
        !           302:                                else
        !           303:                                        printf("lex %s\n", yytoknames[yychar]);
        !           304: #endif
        !           305:                        if(yychar < 0)
        !           306:                                yychar = 0;
        !           307:                }
        !           308:                /* look through exception table */
        !           309:                for(yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate);
        !           310:                        yyxi += 2 ) ; /* VOID */
        !           311:                while( *(yyxi+=2) >= 0 ){
        !           312:                        if( *yyxi == yychar ) break;
        !           313:                }
        !           314:                if( (yyn = yyxi[1]) < 0 ) return(0);   /* accept */
        !           315:        }
        !           316:        if( yyn == 0 ){ /* error */
        !           317:                /* error ... attempt to resume parsing */
        !           318:                switch( yyerrflag ){
        !           319:                case 0:   /* brand new error */
        !           320: #ifdef YYDEBUG
        !           321:                        yyerror("syntax error\n%s", yystates[yystate]);
        !           322:                        if(yytoknames[yychar])
        !           323:                                yyerror("saw %s\n", yytoknames[yychar]);
        !           324:                        else if(yychar >= ' ' && yychar < '\177')
        !           325:                                yyerror("saw `%c'\n", yychar);
        !           326:                        else if(yychar == 0)
        !           327:                                yyerror("saw EOF\n");
        !           328:                        else
        !           329:                                yyerror("saw char 0%o\n", yychar);
        !           330: #else
        !           331:                        yyerror( "syntax error" );
        !           332: #endif
        !           333: yyerrlab:
        !           334:                        ++yynerrs;
        !           335:                case 1:
        !           336:                case 2: /* incompletely recovered error ... try again */
        !           337:                        yyerrflag = 3;
        !           338:                        /* find a state where "error" is a legal shift action */
        !           339:                        while ( yyps >= yys ) {
        !           340:                                yyn = yypact[*yyps] + YYERRCODE;
        !           341:                                if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
        !           342:                                        yystate = yyact[yyn];  /* simulate a shift of "error" */
        !           343:                                        goto yystack;
        !           344:                                }
        !           345:                                yyn = yypact[*yyps];
        !           346:                                /* the current yyps has no shift onn "error", pop stack */
        !           347: #ifdef YYDEBUG
        !           348:                                if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
        !           349: #endif
        !           350:                                --yyps;
        !           351:                                --yypv;
        !           352:                        }
        !           353:                        /* there is no state on the stack with an error shift ... abort */
        !           354: yyabort:
        !           355:                        return(1);
        !           356:                case 3:  /* no shift yet; clobber input char */
        !           357: #ifdef YYDEBUG
        !           358:                        if( yydebug ) {
        !           359:                                printf("error recovery discards ");
        !           360:                                if(yytoknames[yychar])
        !           361:                                        printf("%s\n", yytoknames[yychar]);
        !           362:                                else if(yychar >= ' ' && yychar < '\177')
        !           363:                                        printf("`%c'\n", yychar);
        !           364:                                else if(yychar == 0)
        !           365:                                        printf("EOF\n");
        !           366:                                else
        !           367:                                        printf("char 0%o\n", yychar);
        !           368:                        }
        !           369: #endif
        !           370:                        if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
        !           371:                        yychar = -1;
        !           372:                        goto yynewstate;   /* try again in the same state */
        !           373:                }
        !           374:        }
        !           375:        /* reduction by production yyn */
        !           376: #ifdef YYDEBUG
        !           377:        if(yydebug) {   char *s;
        !           378:                printf("reduce %d in:\n\t", yyn);
        !           379:                for(s = yystates[yystate]; *s; s++) {
        !           380:                        putchar(*s);
        !           381:                        if(*s == '\n' && *(s+1))
        !           382:                                putchar('\t');
        !           383:                }
        !           384:        }
        !           385: #endif
        !           386:        yyps -= yyr2[yyn];
        !           387:        yypvt = yypv;
        !           388:        yypv -= yyr2[yyn];
        !           389:        yyval = yypv[1];
        !           390:        yym=yyn;
        !           391:        /* consult goto table to find next state */
        !           392:        yyn = yyr1[yyn];
        !           393:        yyj = yypgo[yyn] + *yyps + 1;
        !           394:        if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
        !           395:        switch(yym){
        !           396:                
        !           397: case 1:
        !           398: # line 22 "eqn.y"
        !           399: { putout(yypvt[-0]); } break;
        !           400: case 2:
        !           401: # line 23 "eqn.y"
        !           402: { error(!FATAL, "syntax error"); } break;
        !           403: case 3:
        !           404: # line 24 "eqn.y"
        !           405: { eqnreg = 0; } break;
        !           406: case 5:
        !           407: # line 28 "eqn.y"
        !           408: { eqnbox(yypvt[-1], yypvt[-0], 0); } break;
        !           409: case 6:
        !           410: # line 29 "eqn.y"
        !           411: { eqnbox(yypvt[-1], yypvt[-0], 1); } break;
        !           412: case 7:
        !           413: # line 30 "eqn.y"
        !           414: { lineup(0); } break;
        !           415: case 8:
        !           416: # line 33 "eqn.y"
        !           417: { yyval = yypvt[-0]; lineup(1); } break;
        !           418: case 9:
        !           419: # line 36 "eqn.y"
        !           420: { yyval = yypvt[-0]; } break;
        !           421: case 10:
        !           422: # line 37 "eqn.y"
        !           423: { yyval = 0; } break;
        !           424: case 11:
        !           425: # line 40 "eqn.y"
        !           426: { yyval = yypvt[-0]; } break;
        !           427: case 12:
        !           428: # line 41 "eqn.y"
        !           429: { yyval = 0; } break;
        !           430: case 13:
        !           431: # line 44 "eqn.y"
        !           432: { yyval = yypvt[-1]; } break;
        !           433: case 14:
        !           434: # line 45 "eqn.y"
        !           435: { text(QTEXT, (char *) yypvt[-0]); } break;
        !           436: case 15:
        !           437: # line 46 "eqn.y"
        !           438: { text(CONTIG, (char *) yypvt[-0]); } break;
        !           439: case 16:
        !           440: # line 47 "eqn.y"
        !           441: { text(SPACE, 0); } break;
        !           442: case 17:
        !           443: # line 48 "eqn.y"
        !           444: { text(THIN, 0); } break;
        !           445: case 18:
        !           446: # line 49 "eqn.y"
        !           447: { text(TAB, 0); } break;
        !           448: case 19:
        !           449: # line 50 "eqn.y"
        !           450: { funny(SUM); } break;
        !           451: case 20:
        !           452: # line 51 "eqn.y"
        !           453: { funny(PROD); } break;
        !           454: case 21:
        !           455: # line 52 "eqn.y"
        !           456: { funny(UNION); } break;
        !           457: case 22:
        !           458: # line 53 "eqn.y"
        !           459: { funny(INTER); } break;
        !           460: case 23:
        !           461: # line 54 "eqn.y"
        !           462: { boverb(yypvt[-2], yypvt[-0]); } break;
        !           463: case 24:
        !           464: # line 55 "eqn.y"
        !           465: { mark(yypvt[-0]); } break;
        !           466: case 25:
        !           467: # line 56 "eqn.y"
        !           468: { size(yypvt[-1], yypvt[-0]); } break;
        !           469: case 26:
        !           470: # line 57 "eqn.y"
        !           471: { font(yypvt[-1], yypvt[-0]); } break;
        !           472: case 27:
        !           473: # line 58 "eqn.y"
        !           474: { fatbox(yypvt[-0]); } break;
        !           475: case 28:
        !           476: # line 59 "eqn.y"
        !           477: { sqrt(yypvt[-0]); } break;
        !           478: case 29:
        !           479: # line 60 "eqn.y"
        !           480: {ps -= deltaps;} break;
        !           481: case 30:
        !           482: # line 60 "eqn.y"
        !           483: { subsup(yypvt[-4], yypvt[-1], yypvt[-0]); } break;
        !           484: case 31:
        !           485: # line 61 "eqn.y"
        !           486: {ps -= deltaps;} break;
        !           487: case 32:
        !           488: # line 61 "eqn.y"
        !           489: { subsup(yypvt[-3], 0, yypvt[-0]); } break;
        !           490: case 33:
        !           491: # line 62 "eqn.y"
        !           492: {ps -= deltaps;} break;
        !           493: case 34:
        !           494: # line 62 "eqn.y"
        !           495: { integral(yypvt[-4], yypvt[-1], yypvt[-0]); } break;
        !           496: case 35:
        !           497: # line 63 "eqn.y"
        !           498: {ps -= deltaps;} break;
        !           499: case 36:
        !           500: # line 63 "eqn.y"
        !           501: { integral(yypvt[-3], 0, yypvt[-0]); } break;
        !           502: case 37:
        !           503: # line 64 "eqn.y"
        !           504: { integral(yypvt[-0], 0, 0); } break;
        !           505: case 38:
        !           506: # line 65 "eqn.y"
        !           507: {ps -= deltaps;} break;
        !           508: case 39:
        !           509: # line 65 "eqn.y"
        !           510: { fromto(yypvt[-4], yypvt[-1], yypvt[-0]); } break;
        !           511: case 40:
        !           512: # line 66 "eqn.y"
        !           513: {ps -= deltaps;} break;
        !           514: case 41:
        !           515: # line 66 "eqn.y"
        !           516: { fromto(yypvt[-3], 0, yypvt[-0]); } break;
        !           517: case 42:
        !           518: # line 67 "eqn.y"
        !           519: { paren(yypvt[-2], yypvt[-1], yypvt[-0]); } break;
        !           520: case 43:
        !           521: # line 68 "eqn.y"
        !           522: { paren(yypvt[-1], yypvt[-0], 0); } break;
        !           523: case 44:
        !           524: # line 69 "eqn.y"
        !           525: { diacrit(yypvt[-1], yypvt[-0]); } break;
        !           526: case 45:
        !           527: # line 70 "eqn.y"
        !           528: { move(FWD, yypvt[-1], yypvt[-0]); } break;
        !           529: case 46:
        !           530: # line 71 "eqn.y"
        !           531: { move(UP, yypvt[-1], yypvt[-0]); } break;
        !           532: case 47:
        !           533: # line 72 "eqn.y"
        !           534: { move(BACK, yypvt[-1], yypvt[-0]); } break;
        !           535: case 48:
        !           536: # line 73 "eqn.y"
        !           537: { move(DOWN, yypvt[-1], yypvt[-0]); } break;
        !           538: case 49:
        !           539: # line 74 "eqn.y"
        !           540: { pile(yypvt[-0]); ct = yypvt[-0]; } break;
        !           541: case 50:
        !           542: # line 75 "eqn.y"
        !           543: {yyval=ct;} break;
        !           544: case 51:
        !           545: # line 75 "eqn.y"
        !           546: { matrix(yypvt[-3]); ct = yypvt[-3]; } break;
        !           547: case 52:
        !           548: # line 78 "eqn.y"
        !           549: { setintegral(); } break;
        !           550: case 53:
        !           551: # line 81 "eqn.y"
        !           552: { yyval = atoi((char *) yypvt[-1]); } break;
        !           553: case 54:
        !           554: # line 82 "eqn.y"
        !           555: { yyval = atoi((char *) yypvt[-1]); } break;
        !           556: case 55:
        !           557: # line 83 "eqn.y"
        !           558: { yyval = atoi((char *) yypvt[-1]); } break;
        !           559: case 56:
        !           560: # line 84 "eqn.y"
        !           561: { yyval = atoi((char *) yypvt[-1]); } break;
        !           562: case 57:
        !           563: # line 86 "eqn.y"
        !           564: { yyval = HAT; } break;
        !           565: case 58:
        !           566: # line 87 "eqn.y"
        !           567: { yyval = VEC; } break;
        !           568: case 59:
        !           569: # line 88 "eqn.y"
        !           570: { yyval = DYAD; } break;
        !           571: case 60:
        !           572: # line 89 "eqn.y"
        !           573: { yyval = BAR; } break;
        !           574: case 61:
        !           575: # line 90 "eqn.y"
        !           576: { yyval = LOWBAR; } break;
        !           577: case 62:
        !           578: # line 91 "eqn.y"
        !           579: { yyval = HIGHBAR; } break;
        !           580: case 63:
        !           581: # line 92 "eqn.y"
        !           582: { yyval = UNDER; } break;
        !           583: case 64:
        !           584: # line 93 "eqn.y"
        !           585: { yyval = DOT; } break;
        !           586: case 65:
        !           587: # line 94 "eqn.y"
        !           588: { yyval = TILDE; } break;
        !           589: case 66:
        !           590: # line 95 "eqn.y"
        !           591: { yyval = UTILDE; } break;
        !           592: case 67:
        !           593: # line 96 "eqn.y"
        !           594: { yyval = DOTDOT; } break;
        !           595: case 68:
        !           596: # line 99 "eqn.y"
        !           597: { yyval = ((char *)yypvt[-0])[0]; } break;
        !           598: case 69:
        !           599: # line 100 "eqn.y"
        !           600: { yyval = '{'; } break;
        !           601: case 70:
        !           602: # line 103 "eqn.y"
        !           603: { yyval = ((char *)yypvt[-0])[0]; } break;
        !           604: case 71:
        !           605: # line 104 "eqn.y"
        !           606: { yyval = '}'; } break;
        !           607: case 74:
        !           608: # line 111 "eqn.y"
        !           609: { column(yypvt[-3], DEFGAP); } break;
        !           610: case 75:
        !           611: # line 112 "eqn.y"
        !           612: {yyval=atoi((char*)yypvt[-0]);} break;
        !           613: case 76:
        !           614: # line 112 "eqn.y"
        !           615: { column(yypvt[-5], yypvt[-3]); } break;
        !           616: case 77:
        !           617: # line 115 "eqn.y"
        !           618: { yyval = startcol(LCOL); } break;
        !           619: case 78:
        !           620: # line 116 "eqn.y"
        !           621: { yyval = startcol(CCOL); } break;
        !           622: case 79:
        !           623: # line 117 "eqn.y"
        !           624: { yyval = startcol(RCOL); } break;
        !           625: case 80:
        !           626: # line 118 "eqn.y"
        !           627: { yyval = startcol(COL); } break;
        !           628: case 81:
        !           629: # line 121 "eqn.y"
        !           630: { lp[ct++] = yypvt[-0]; } break;
        !           631: case 82:
        !           632: # line 122 "eqn.y"
        !           633: { lp[ct++] = yypvt[-0]; } break;
        !           634: case 83:
        !           635: # line 125 "eqn.y"
        !           636: { yyval = ps; setsize((char *) yypvt[-0]); } break;
        !           637: case 84:
        !           638: # line 128 "eqn.y"
        !           639: { setfont("R"); } break;
        !           640: case 85:
        !           641: # line 129 "eqn.y"
        !           642: { setfont("I"); } break;
        !           643: case 86:
        !           644: # line 130 "eqn.y"
        !           645: { setfont("B"); } break;
        !           646: case 87:
        !           647: # line 131 "eqn.y"
        !           648: { setfont((char *)yypvt[-0]); } break;
        !           649:        }
        !           650:        goto yystack;  /* stack new state and value */
        !           651: }

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