y.tab.c

Functions

yyparse           X

Variables

fromflg           X
yyact             X
yychar            X
yychk             X
yydebug           X
yydef             X
yyerrflag         X
yyexca            X
yynerrs           X
yypact            X
yypgo             X
yyr1              X
yyr2              X

Macros

ABOVE             X
BACK              X
BAR               X
BOLD              X
CCOL              X
COL               X
CONTIG            X
CPILE             X
DEFINE            X
DELIM             X
DOT               X
DOTDOT            X
DOWN              X
DYAD              X
FAT               X
FONT              X
FROM              X
FWD               X
GFONT             X
GSIZE             X
HAT               X
INCLUDE           X
INT               X
INTER             X
ITALIC            X
LCOL              X
LEFT              X
LINEUP            X
LPILE             X
MARK              X
MATRIX            X
NDEFINE           X
OVER              X
PILE              X
PROD              X
QTEXT             X
RCOL              X
RIGHT             X
ROMAN             X
RPILE             X
SIZE              X
SPACE             X
SQRT              X
SUB               X
SUM               X
SUP               X
TAB               X
TDEFINE           X
THIN              X
TILDE             X
TO                X
UNDER             X
UNION             X
UP                X
VEC               X
YYABORT           X
YYACCEPT          X
YYERRCODE         X
YYERROR           X
YYFLAG            X
YYLAST            X
YYMAXDEPTH        X
YYNPROD           X
YYSTYPE           X
yyclearin         X
yyerrok           X

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

Defined functions

yyparse defined in line 240; used 2 times

in /usr/src/cmd/neqn/io.c line 35, 86

Defined variables

fromflg defined in line 6; used 4 times

in line 474, 537-542(3)

yyact defined in line 84; used 5 times

in line 273, 316-317(2), 358(2)

yychar declared in line 64; defined in line 236; used 32 times

in line 62, 250, 258, 270-274(6), 285(3), 291, 337-340(3)
in /usr/src/cmd/neqn/y.tab.c line 62, 250, 258, 270-274(6), 285(3), 291, 337-340(3)

yychk defined in line 190; used 3 times

in line 273, 316, 358

yydebug defined in line 234; used 4 times

in line 258, 324, 337, 349

yydef defined in line 208; used 1 times

in line 284

yyerrflag declared in line 65; defined in line 238; used 12 times

in line 63, 252, 277(2), 299, 310
in /usr/src/cmd/neqn/y.tab.c line 63, 252, 277(2), 299, 310

yyexca defined in line 77; used 1 times

in line 288

yynerrs defined in line 237; used 2 times

in line 251, 305

yypact defined in line 142; used 3 times

in line 266, 315-320(2)

yypgo defined in line 160; used 2 times

in line 357-358(2)

yyr1 defined in line 166; used 1 times

in line 356

yyr2 defined in line 178; used 2 times

in line 350-352(2)

Defined macros

ABOVE defined in line 28; never used

BACK defined in line 50; used 1 times

in line 489

BAR defined in line 58; used 1 times

in line 522

BOLD defined in line 46; never used

CCOL defined in line 14; never used

COL defined in line 16; never used

CONTIG defined in line 7; used 1 times

in line 607

CPILE defined in line 26; never used

DEFINE defined in line 29; never used

DELIM defined in line 32; never used

DOT defined in line 54; used 1 times

in line 528

DOTDOT defined in line 55; used 1 times

in line 534

DOWN defined in line 49; used 1 times

in line 492

DYAD defined in line 61; used 1 times

in line 519

FAT defined in line 47; never used

FONT defined in line 43; never used

FROM defined in line 36; never used

FWD defined in line 51; used 1 times

in line 483

GFONT defined in line 34; never used

GSIZE defined in line 33; never used

HAT defined in line 56; used 1 times

in line 513

INCLUDE defined in line 35; never used

INT defined in line 20; never used

INTER defined in line 23; used 1 times

in line 628

ITALIC defined in line 45; never used

LCOL defined in line 13; never used

LEFT defined in line 52; never used

LINEUP defined in line 18; never used

LPILE defined in line 24; never used

MARK defined in line 17; never used

MATRIX defined in line 12; never used

NDEFINE defined in line 31; never used

OVER defined in line 38; never used

PILE defined in line 25; never used

PROD defined in line 21; used 1 times

in line 622

QTEXT defined in line 8; used 1 times

in line 604

RCOL defined in line 15; never used

RIGHT defined in line 53; never used

ROMAN defined in line 44; never used

RPILE defined in line 27; never used

SIZE defined in line 42; never used

SPACE defined in line 9; used 1 times

in line 610

SQRT defined in line 39; never used

SUB defined in line 41; used 1 times

in line 595

SUM defined in line 19; used 1 times

in line 619

SUP defined in line 40; used 1 times

in line 598

TAB defined in line 11; used 1 times

in line 616

TDEFINE defined in line 30; never used

THIN defined in line 10; used 1 times

in line 613

TILDE defined in line 57; used 1 times

in line 531

TO defined in line 37; never used

UNDER defined in line 59; used 1 times

in line 525

UNION defined in line 22; used 1 times

in line 625

UP defined in line 48; used 1 times

in line 486

VEC defined in line 60; used 1 times

in line 516

YYABORT defined in line 230; never used

YYACCEPT defined in line 229; never used

YYERRCODE defined in line 73; used 2 times

in line 315-316(2)

YYERROR defined in line 228; never used

YYFLAG defined in line 227; used 1 times

in line 268

YYLAST defined in line 83; used 3 times

in line 271, 316, 358

YYMAXDEPTH defined in line 67; used 4 times

in line 66, 235, 242, 259

YYNPROD defined in line 82; never used

YYSTYPE defined in line 70; used 5 times

in line 69-72(2), 235, 244-246(2)

yyclearin defined in line 62; never used

yyerrok defined in line 63; never used

Last modified: 1981-11-02
Generated: 2016-12-26

Generated by src2html V0.67
page hit count: 1480