2.11BSD#431 - /usr/src/new/OLD/apl/src/y.tab.c

   1: 
   2: # line 2 "apl.y"
   3: static char apl_y_Sccsid[] = "apl.y @(#)apl.y	1.3	10/5/82 Berkeley ";
   4: 
   5: # line 4 "apl.y"
   6: typedef union  {
   7:     char    *charptr;
   8:     char    charval;
   9: } YYSTYPE;
  10: # define lex0 257
  11: # define lex1 258
  12: # define lex2 259
  13: # define lex3 260
  14: # define lex4 261
  15: # define lex5 262
  16: # define lex6 263
  17: # define lpar 264
  18: # define rpar 265
  19: # define lbkt 266
  20: # define rbkt 267
  21: # define eol 268
  22: # define unk 269
  23: # define com 270
  24: # define com0 271
  25: # define Quad 272
  26: # define asg 273
  27: # define null 274
  28: # define dot 275
  29: # define cln 276
  30: # define semi 277
  31: # define comnt 278
  32: # define tran 279
  33: # define strng 280
  34: # define nam 281
  35: # define numb 282
  36: # define nfun 283
  37: # define mfun 284
  38: # define dfun 285
  39: # define comexpr 286
  40: # define comnam 287
  41: # define comnull 288
  42: # define comlist 289
  43: # define dscal 290
  44: # define mdscal 291
  45: # define m 292
  46: # define d 293
  47: # define md 294
  48: # define msub 295
  49: # define mdsub 296
  50: 
  51: # line 26 "apl.y"
  52: #include "apl.h"
  53:     int vcount;
  54:     int scount;
  55:     int litflag;
  56:     int nlexsym;
  57:     int context;
  58:     char    *iline;
  59:     char    *ccharp, *ccharp2;
  60:     data    lnumb;      /* current label number */
  61:     char    *labcpp;    /* label prologue */
  62:     char    *labcpe;    /* label epilogue */
  63:     int immedcmd;   /* immediate command number */
  64: #define yyclearin yychar = -1
  65: #define yyerrok yyerrflag = 0
  66: extern int yychar;
  67: extern short yyerrflag;
  68: #ifndef YYMAXDEPTH
  69: #define YYMAXDEPTH 150
  70: #endif
  71: YYSTYPE yylval, yyval;
  72: # define YYERRCODE 256
  73: 
  74: # line 515 "apl.y"
  75: 
  76: #include "tab.c"
  77: #include "lex.c"
  78: short yyexca[] ={
  79: -1, 1,
  80:     0, -1,
  81:     -2, 0,
  82: -1, 31,
  83:     266, 69,
  84:     -2, 67,
  85: -1, 33,
  86:     266, 70,
  87:     -2, 90,
  88: -1, 34,
  89:     270, 91,
  90:     271, 91,
  91:     275, 91,
  92:     -2, 88,
  93: -1, 57,
  94:     276, 93,
  95:     -2, 48,
  96: -1, 58,
  97:     276, 94,
  98:     -2, 47,
  99: -1, 59,
 100:     276, 95,
 101:     -2, 63,
 102: -1, 77,
 103:     275, 92,
 104:     -2, 81,
 105: -1, 81,
 106:     266, 87,
 107:     -2, 85,
 108: -1, 83,
 109:     266, 86,
 110:     -2, 90,
 111:     };
 112: # define YYNPROD 97
 113: # define YYLAST 278
 114: short yyact[]={
 115: 
 116:   28,  35, 130,  43,  11,  44,  45,  46,  29,  61,
 117:   62,  64,  63,  38,  14,  55,  26,  57,  38,  58,
 118:   59,  46, 126,  69, 103, 132,  35,  34,  30,  98,
 119:   37,  31,  33,  28,  13, 133, 127,  11,  97, 116,
 120:  115,  29,  90,  91, 109, 104,  67,  14,  10,  26,
 121:   25,  38,  24,  22,  28, 134,  42,  88,  11,  35,
 122:   34,  30,  29,  37,  31,  33,  86, 122,  14, 118,
 123:   26,  25,  38,  24,  22,  28,  68,  16,  96, 101,
 124:   35,  34,  30,  29,  37,  31,  33, 107,  50,   9,
 125:    1,  26,  25,  38,  24,  22,  28,  82,  71,  89,
 126:   65,  35,  34,  30,  29,  37,  31,  33,  87,  72,
 127:   21,  23,  26,  25,  38,  24,  22,  28,  20,  27,
 128:   85,  15,  35,  34,  30,  29,  37,  31,  33,  75,
 129:   52,  60,  66,  26,  25,  38,  24,  22,  81,  79,
 130:   84,  80,  74,  35,  34,  30, 112,  37,  31,  33,
 131:   92, 123,  41,  73,  53,  94,  93,  32,  77,  34,
 132:   56,  78,  37,  43,  83,  44,  45,  46,   2,   3,
 133:    4,   5,   6,   7,  70,  76,  54, 102,  40,   8,
 134:   39, 114,  99, 105,  48,  49,  18, 117,  36,  19,
 135:  111,  17, 113, 110,  95,  12,  51,  47,   0, 121,
 136:    0,   0,   0, 136,  56, 135, 100, 119,   0,   0,
 137:  120,   0,   0,   0,   0, 106, 108,   0,   0,   0,
 138:    0,   0,   0,   0,   0,   0,   0, 129, 131,   0,
 139:    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 140:    0,   0,   0,   0,   0,   0,   0, 124, 125,   0,
 141:    0,   0,   0,   0,   0, 119,   0,   0,   0,   0,
 142:  128,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 143:    0,   0,   0,   0,   0,   0,   0,  95 };
 144: short yypact[]={
 145: 
 146:  -89,-1000,-231,-210,-278,-278,-278,-264,-1000,-277,
 147: -168,-1000,-222,-1000,-1000,-254,-1000,-132,-147,-200,
 148: -1000,-209,-1000,-228,-1000,-1000,-1000,-1000,-147,-1000,
 149: -1000,-1000,-1000,-1000,-1000,-1000,-269,-1000,-1000,-1000,
 150: -1000,-118,-1000,-1000,-1000,-1000,-1000,-239,-1000,-1000,
 151: -1000,-264,-1000,-1000,-1000,-189,-252,-1000,-1000,-1000,
 152: -223,-147,-278,-278,-1000,-1000,-224,-1000,-147,-1000,
 153: -147,-1000,-209,-1000,-235,-236,-1000,-1000,-1000,-1000,
 154: -1000,-1000,-1000,-1000,-1000,-147,-1000,-1000,-147,-1000,
 155: -209,-1000,-198,-1000,-278,-278,-1000,-259,-1000,-1000,
 156: -1000,-1000,-232,-1000,-1000,-1000,-1000,-278,-1000,-1000,
 157: -1000,-254,-1000,-1000,-1000,-289,-289,-242,-1000,-1000,
 158: -212,-1000,-1000,-1000,-278,-1000,-239,-1000,-1000,-1000,
 159: -1000,-1000,-1000,-147,-1000,-1000,-1000 };
 160: short yypgo[]={
 161: 
 162:    0, 178,  56, 197,  78, 196, 154, 130, 176, 195,
 163:  193, 121, 191, 189, 188, 187,  69, 186, 174, 108,
 164:  152,  77, 131, 120, 118, 110, 109,  99,  98,  97,
 165:  157, 111,  90,  89,  88,  87,  76, 119 };
 166: short yyr1[]={
 167: 
 168:    0,  32,  32,  32,  32,  32,  32,  32,  32,  32,
 169:    1,   1,   2,   3,   3,   3,   4,   4,  33,  22,
 170:   22,  22,  22,  35,  35,  34,  34,   5,   5,   6,
 171:    7,   7,   7,   8,   8,   9,   9,   9,  21,  10,
 172:   10,  36,  11,  11,  11,  12,  12,  13,  13,  13,
 173:   13,  13,  13,  37,  37,  14,  23,  15,  15,  16,
 174:   16,  17,  17,  17,  17,  17,  24,  24,  24,  25,
 175:   25,  18,  18,  18,  18,  18,  26,  19,  27,  27,
 176:   28,  28,  28,  28,  28,  28,  29,  29,  30,  30,
 177:   30,  31,  31,  20,  20,  20,  20 };
 178: short yyr2[]={
 179: 
 180:    0,   2,   4,   3,   4,   2,   2,   2,   2,   2,
 181:    3,   1,   2,   3,   2,   1,   3,   1,   1,   2,
 182:    2,   2,   1,   2,   1,   2,   1,   1,   2,   2,
 183:    1,   2,   3,   1,   2,   1,   1,   1,   3,   1,
 184:    1,   1,   1,   2,   3,   1,   4,   1,   1,   1,
 185:    1,   3,   1,   2,   1,   1,   1,   1,   3,   1,
 186:    0,   1,   2,   1,   2,   3,   1,   1,   1,   1,
 187:    1,   1,   2,   1,   3,   3,   1,   3,   1,   1,
 188:    1,   1,   1,   1,   1,   1,   1,   1,   1,   1,
 189:    1,   1,   1,   1,   1,   1,   1 };
 190: short yychk[]={
 191: 
 192: -1000, -32, 257, 258, 259, 260, 261, 262,  -8, -33,
 193:  279, 268,  -9, 265, 278, -11, -21, -12, -17, -13,
 194:  -24, -25, 284, -31, 283, 281, 280, -37, 264, 272,
 195:  292, 295, -30, 296, 291, 290, -14, 294, 282,  -8,
 196:   -1, -20,  -2, 281, 283, 284, 285,  -3,  -1,  -1,
 197:  -34,  -5,  -7,  -6,  -8, 279, -20, 281, 283, 284,
 198:  -22, 286, 287, 289, 288, 268, -11, 268, -36, 277,
 199:  -18, -28, -26, 285, 274, -31, -30, 290, 293, 271,
 200:  273, 270, -29, 296, -11, -23, 266, -19, 266, -27,
 201:  270, 271, -11, -37, 273, -20,  -4, 277, 268,  -7,
 202:   -6, 268, -11, 276, 268, -11, -20, -35, -20, 268,
 203:  -10, -11, -21, -11, -19, 275, 275, -15, -16, -11,
 204:  -11, -19, 265,  -2, -20, -20, 281, 268, -20, -31,
 205:  291, -31, 267, 277, 267,  -4, -16 };
 206: short yydef[]={
 207: 
 208:    0,  -2,   0,   0,   0,   0,   0,   0,   1,   0,
 209:    0,  33,   0,  18,  35,  36,  37,  42,   0,  45,
 210:   61,   0,  63,   0,  47,  48,  49,  50,   0,  52,
 211:   66,  -2,  68,  -2,  -2,  92,  54,  89,  55,   5,
 212:    6,  15,  11,  93,  94,  95,  96,   0,   7,   8,
 213:    9,   0,  26,  27,  30,   0,   0,  -2,  -2,  -2,
 214:    0,   0,   0,   0,  22,   3,   0,  34,   0,  41,
 215:    0,  71,   0,  73,   0,   0,  80,  -2,  82,  83,
 216:   84,  -2,  76,  -2,  43,  60,  56,  62,   0,  64,
 217:   78,  79,   0,  53,   0,  14,  12,   0,  17,  25,
 218:   28,  31,   0,  29,   2,  19,  20,  21,  24,   4,
 219:   38,  39,  40,  44,  72,   0,   0,   0,  57,  59,
 220:    0,  65,  51,  10,  15,  13,   0,  32,  23,  74,
 221:   91,  75,  46,  60,  77,  16,  58 };
 222: #ifndef lint
 223: static char yaccpar_sccsid[] = "@(#)yaccpar	4.1	(Berkeley)	2/11/83";
 224: #endif not lint
 225: 
 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: #ifdef YYDEBUG
 235: int yydebug = 0; /* 1 for debugging */
 236: #endif
 237: YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
 238: int yychar = -1; /* current input token number */
 239: int yynerrs = 0;  /* number of errors */
 240: short yyerrflag = 0;  /* error recovery flag */
 241: 
 242: yyparse() {
 243: 
 244:     short yys[YYMAXDEPTH];
 245:     short yyj, yym;
 246:     register YYSTYPE *yypvt;
 247:     register short yystate, *yyps, yyn;
 248:     register YYSTYPE *yypv;
 249:     register short *yyxi;
 250: 
 251:     yystate = 0;
 252:     yychar = -1;
 253:     yynerrs = 0;
 254:     yyerrflag = 0;
 255:     yyps= &yys[-1];
 256:     yypv= &yyv[-1];
 257: 
 258:  yystack:    /* put a state and value onto the stack */
 259: 
 260: #ifdef YYDEBUG
 261:     if( yydebug  ) printf( "state %d, char 0%o\n", yystate, yychar );
 262: #endif
 263:         if( ++yyps> &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" ); return(1); }
 264:         *yyps = yystate;
 265:         ++yypv;
 266:         *yypv = yyval;
 267: 
 268:  yynewstate:
 269: 
 270:     yyn = yypact[yystate];
 271: 
 272:     if( yyn<= YYFLAG ) goto yydefault; /* simple state */
 273: 
 274:     if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
 275:     if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;
 276: 
 277:     if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
 278:         yychar = -1;
 279:         yyval = yylval;
 280:         yystate = yyn;
 281:         if( yyerrflag > 0 ) --yyerrflag;
 282:         goto yystack;
 283:         }
 284: 
 285:  yydefault:
 286:     /* default state action */
 287: 
 288:     if( (yyn=yydef[yystate]) == -2 ) {
 289:         if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
 290:         /* look through exception table */
 291: 
 292:         for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */
 293: 
 294:         while( *(yyxi+=2) >= 0 ){
 295:             if( *yyxi == yychar ) break;
 296:             }
 297:         if( (yyn = yyxi[1]) < 0 ) return(0);   /* accept */
 298:         }
 299: 
 300:     if( yyn == 0 ){ /* error */
 301:         /* error ... attempt to resume parsing */
 302: 
 303:         switch( yyerrflag ){
 304: 
 305:         case 0:   /* brand new error */
 306: 
 307:             yyerror( "syntax error" );
 308:         yyerrlab:
 309:             ++yynerrs;
 310: 
 311:         case 1:
 312:         case 2: /* incompletely recovered error ... try again */
 313: 
 314:             yyerrflag = 3;
 315: 
 316:             /* find a state where "error" is a legal shift action */
 317: 
 318:             while ( yyps >= yys ) {
 319:                yyn = yypact[*yyps] + YYERRCODE;
 320:                if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
 321:                   yystate = yyact[yyn];  /* simulate a shift of "error" */
 322:                   goto yystack;
 323:                   }
 324:                yyn = yypact[*yyps];
 325: 
 326:                /* the current yyps has no shift onn "error", pop stack */
 327: 
 328: #ifdef YYDEBUG
 329:                if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
 330: #endif
 331:                --yyps;
 332:                --yypv;
 333:                }
 334: 
 335:             /* there is no state on the stack with an error shift ... abort */
 336: 
 337:     yyabort:
 338:             return(1);
 339: 
 340: 
 341:         case 3:  /* no shift yet; clobber input char */
 342: 
 343: #ifdef YYDEBUG
 344:             if( yydebug ) printf( "error recovery discards char %d\n", yychar );
 345: #endif
 346: 
 347:             if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
 348:             yychar = -1;
 349:             goto yynewstate;   /* try again in the same state */
 350: 
 351:             }
 352: 
 353:         }
 354: 
 355:     /* reduction by production yyn */
 356: 
 357: #ifdef YYDEBUG
 358:         if( yydebug ) printf("reduce %d\n",yyn);
 359: #endif
 360:         yyps -= yyr2[yyn];
 361:         yypvt = yypv;
 362:         yypv -= yyr2[yyn];
 363:         yyval = yypv[1];
 364:         yym=yyn;
 365:             /* consult goto table to find next state */
 366:         yyn = yyr1[yyn];
 367:         yyj = yypgo[yyn] + *yyps + 1;
 368:         if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
 369:         switch(yym){
 370: 
 371: case 1:
 372: # line 51 "apl.y"
 373: 
 374:     {
 375:         integ = ccharp[-1];
 376:         if(integ != ASGN && integ != PRINT && integ != COMNT)
 377:             *ccharp++ = PRINT;
 378:         *ccharp++ = EOL;
 379:     } break;
 380: case 2:
 381: # line 58 "apl.y"
 382: 
 383:     {
 384:         *ccharp++ = IMMED;
 385:         *ccharp++ = yypvt[-1].charval;
 386:     } break;
 387: case 3:
 388: # line 66 "apl.y"
 389: 
 390:     {
 391:         *ccharp++ = SICLR0;
 392:     } break;
 393: case 4:
 394: # line 70 "apl.y"
 395: 
 396:     {
 397:         *ccharp++ = SICLR;
 398:     } break;
 399: case 10:
 400: # line 107 "apl.y"
 401: 
 402:     {
 403:         switch(context) {
 404: 
 405:         case lex3:
 406:             name(yyval.charptr, AUTO);
 407:             /*
 408: 			 * see comments in ai.c/funcomp() concerning
 409: 			 * label processing.
 410: 			 */
 411:             *ccharp++ = ELID;
 412:             break;
 413: 
 414:         case lex4:
 415:             ccharp2 = ccharp;
 416:             *ccharp++ = EOL;
 417:             name(yyval.charptr, RVAL);
 418:             name(yyval.charptr, REST);
 419:             invert(yypvt[-0].charptr, ccharp2);
 420:         }
 421:     } break;
 422: case 11:
 423: # line 128 "apl.y"
 424: 
 425:     {
 426:         if(context == lex3)
 427:             *ccharp++ = ELID;
 428:         if(context == lex4){
 429:             *ccharp++ = EOL;    /* pop previous result */
 430:             *ccharp++ = NILRET; /* return empty result */
 431:         }
 432:     } break;
 433: case 12:
 434: # line 138 "apl.y"
 435: 
 436:     {
 437:         if(context == lex4)
 438:             invert(yyval.charptr, yypvt[-0].charptr);
 439:     } break;
 440: case 13:
 441: # line 145 "apl.y"
 442: 
 443:     {
 444:         yyval.charptr = ccharp;
 445:         switch(context) {
 446: 
 447:         case lex2:
 448:             name(yypvt[-1].charptr, DF);
 449:             break;
 450: 
 451:         case lex3:
 452:             name(yypvt[-0].charptr, ARG2);
 453:             name(yypvt[-2].charptr, ARG1);
 454:             break;
 455: 
 456:         case lex4:
 457:             name(yypvt[-2].charptr, REST);
 458:             name(yypvt[-0].charptr, REST);
 459:         }
 460:     } break;
 461: case 14:
 462: # line 164 "apl.y"
 463: 
 464:     {
 465:         yyval.charptr = ccharp;
 466:         switch(context) {
 467: 
 468:         case lex2:
 469:             name(yypvt[-1].charptr, MF);
 470:             break;
 471: 
 472:         case lex3:
 473:             name(yypvt[-0].charptr, ARG1);
 474:             break;
 475: 
 476:         case lex4:
 477:             name(yypvt[-0].charptr, REST);
 478:         }
 479:     } break;
 480: case 15:
 481: # line 181 "apl.y"
 482: 
 483:     {
 484:         if(context == lex2)
 485:             name(yyval.charptr, NF);
 486:         yyval.charptr = ccharp;
 487:     } break;
 488: case 16:
 489: # line 188 "apl.y"
 490: 
 491:     {
 492:         yyval.charptr = yypvt[-0].charptr;
 493:         switch(context) {
 494: 
 495:         case lex3:
 496:             name(yypvt[-1].charptr, AUTO);
 497:             break;
 498: 
 499:         case lex4:
 500:             ccharp2 = name(yypvt[-1].charptr, REST);
 501:             invert(yyval.charptr, ccharp2);
 502:         }
 503:     } break;
 504: case 17:
 505: # line 202 "apl.y"
 506: 
 507:     {
 508:         yyval.charptr = ccharp;
 509:     } break;
 510: case 18:
 511: # line 211 "apl.y"
 512: 
 513:     {
 514:         litflag = -1;
 515:     } break;
 516: case 20:
 517: # line 217 "apl.y"
 518: 
 519:     {
 520:         name(yypvt[-0].charptr, NAME);
 521:     } break;
 522: case 23:
 523: # line 225 "apl.y"
 524: 
 525:     {
 526:         *ccharp++ = IMMED;
 527:         *ccharp++ = immedcmd;
 528:         name(yypvt[-0].charptr, NAME);
 529:     } break;
 530: case 24:
 531: # line 231 "apl.y"
 532: 
 533:     {
 534:         name(yypvt[-0].charptr, NAME);
 535:     } break;
 536: case 29:
 537: # line 251 "apl.y"
 538:  {
 539:         if(labgen)
 540:             genlab(yypvt[-1].charptr);
 541:     } break;
 542: case 30:
 543: # line 257 "apl.y"
 544: 
 545:     {
 546:         integ = ccharp[-1];
 547:         if(integ != ASGN && integ != PRINT && integ != COMNT)
 548:             *ccharp++ = PRINT;
 549:     } break;
 550: case 31:
 551: # line 263 "apl.y"
 552: 
 553:     {
 554:         yyval.charptr = ccharp;
 555:         *ccharp++ = BRAN0;
 556:     } break;
 557: case 32:
 558: # line 268 "apl.y"
 559: 
 560:     {
 561:         yyval.charptr = yypvt[-1].charptr;
 562:         *ccharp++ = BRAN;
 563:     } break;
 564: case 33:
 565: # line 274 "apl.y"
 566: 
 567:     {
 568:         yyval.charptr = ccharp;
 569:         *ccharp++ = COMNT;
 570:     } break;
 571: case 35:
 572: # line 281 "apl.y"
 573: 
 574:     {
 575:         litflag = 1;
 576:         yyval.charptr = ccharp;
 577:         *ccharp++ = COMNT;
 578:     } break;
 579: case 39:
 580: # line 292 "apl.y"
 581: 
 582:     {
 583:         *ccharp++ = PRINT;
 584:     } break;
 585: case 41:
 586: # line 298 "apl.y"
 587: 
 588:     {
 589:         *ccharp++ = HPRINT;
 590:     } break;
 591: case 43:
 592: # line 304 "apl.y"
 593: 
 594:     {
 595:         invert(yyval.charptr, yypvt[-0].charptr);
 596:     } break;
 597: case 44:
 598: # line 308 "apl.y"
 599: 
 600:     {
 601:         invert(yyval.charptr, yypvt[-0].charptr);
 602:     } break;
 603: case 46:
 604: # line 314 "apl.y"
 605: 
 606:     {
 607:         invert(yyval.charptr, yypvt[-1].charptr);
 608:         *ccharp++ = INDEX;
 609:         *ccharp++ = scount;
 610:         scount = yypvt[-2].charval;
 611:     } break;
 612: case 47:
 613: # line 322 "apl.y"
 614: 
 615:     {
 616:         yyval.charptr = name(yyval.charptr, FUN);
 617:     } break;
 618: case 48:
 619: # line 326 "apl.y"
 620: 
 621:     {
 622:         yyval.charptr = name(yyval.charptr, NAME);
 623:     } break;
 624: case 49:
 625: # line 330 "apl.y"
 626: 
 627:     {
 628:         yyval.charptr = ccharp;
 629:         ccharp += 2;
 630:         integ = iline[-1];
 631:         vcount = 0;
 632:         for(;;) {
 633:             if(*iline == '\n') {
 634:                 nlexsym = unk;
 635:                 break;
 636:             }
 637:             if(*iline == integ) {
 638:                 iline++;
 639:                 if(*iline != integ)
 640:                     break;
 641:             }
 642:             *ccharp++ = *iline++;
 643:             vcount++;
 644:         }
 645:         ((struct chrstrct *)yyval.charptr)->c[0] = QUOT;
 646:         ((struct chrstrct *)yyval.charptr)->c[1] = vcount;
 647:     } break;
 648: case 50:
 649: # line 352 "apl.y"
 650: 
 651:     {
 652:         *ccharp++ = CONST;
 653:         *ccharp++ = vcount;
 654:         invert(yyval.charptr, ccharp-2);
 655:     } break;
 656: case 51:
 657: # line 358 "apl.y"
 658: 
 659:     {
 660:         yyval.charptr = yypvt[-1].charptr;
 661:     } break;
 662: case 52:
 663: # line 362 "apl.y"
 664: 
 665:     {
 666:         yyval.charptr = ccharp;
 667:         *ccharp++ = yypvt[-0].charval;
 668:     } break;
 669: case 53:
 670: # line 368 "apl.y"
 671: 
 672:     {
 673:         vcount++;
 674:     } break;
 675: case 54:
 676: # line 372 "apl.y"
 677: 
 678:     {
 679:         vcount = 1;
 680:     } break;
 681: case 55:
 682: # line 377 "apl.y"
 683: 
 684:     {
 685:         yyval.charptr = ccharp;
 686:         ccharp += copy(DA,&datum,ccharp,1);
 687:     } break;
 688: case 56:
 689: # line 388 "apl.y"
 690: 
 691:     {
 692:         yyval.charval = scount;
 693:         scount = 1;
 694:     } break;
 695: case 58:
 696: # line 395 "apl.y"
 697: 
 698:     {
 699:         invert(yyval.charptr, yypvt[-0].charptr);
 700:         scount++;
 701:     } break;
 702: case 60:
 703: # line 402 "apl.y"
 704: 
 705:     {
 706:         yyval.charptr = ccharp;
 707:         *ccharp++ = ELID;
 708:     } break;
 709: case 61:
 710: # line 412 "apl.y"
 711: 
 712:     {
 713:         yyval.charptr = ccharp;
 714:         *ccharp++ = yypvt[-0].charval;
 715:     } break;
 716: case 62:
 717: # line 417 "apl.y"
 718: 
 719:     {
 720:         yyval.charptr = yypvt[-0].charptr;
 721:         *ccharp++ = yypvt[-1].charval+1;
 722:     } break;
 723: case 63:
 724: # line 422 "apl.y"
 725: 
 726:     {
 727:         yyval.charptr = name(yyval.charptr, FUN);
 728:     } break;
 729: case 64:
 730: # line 426 "apl.y"
 731: 
 732:     {
 733:         yyval.charptr = ccharp;
 734:         *ccharp++ = yypvt[-0].charval+1;
 735:         *ccharp++ = yypvt[-1].charval;
 736:     } break;
 737: case 65:
 738: # line 432 "apl.y"
 739: 
 740:     {
 741:         yyval.charptr = yypvt[-0].charptr;
 742:         *ccharp++ = yypvt[-1].charval+3;
 743:         *ccharp++ = yypvt[-2].charval;
 744:     } break;
 745: case 68:
 746: # line 441 "apl.y"
 747: 
 748:     {
 749:         yyval.charval++;
 750:     } break;
 751: case 70:
 752: # line 447 "apl.y"
 753: 
 754:     {
 755:         yyval.charval += 2;
 756:     } break;
 757: case 71:
 758: # line 456 "apl.y"
 759: 
 760:     {
 761:         yyval.charptr = ccharp;
 762:         *ccharp++ = yypvt[-0].charval;
 763:     } break;
 764: case 72:
 765: # line 461 "apl.y"
 766: 
 767:     {
 768:         yyval.charptr = yypvt[-0].charptr;
 769:         *ccharp++ = yypvt[-1].charval;
 770:     } break;
 771: case 73:
 772: # line 466 "apl.y"
 773: 
 774:     {
 775:         yyval.charptr = name(yyval.charptr, FUN);
 776:     } break;
 777: case 74:
 778: # line 470 "apl.y"
 779: 
 780:     {
 781:         yyval.charptr = ccharp;
 782:         *ccharp++ = OPROD;
 783:         *ccharp++ = yypvt[-0].charval;
 784:     } break;
 785: case 75:
 786: # line 476 "apl.y"
 787: 
 788:     {
 789:         yyval.charptr = ccharp;
 790:         *ccharp++ = IPROD;
 791:         *ccharp++ = yypvt[-2].charval;
 792:         *ccharp++ = yypvt[-0].charval;
 793:     } break;
 794: case 76:
 795: # line 484 "apl.y"
 796: 
 797:     {
 798:         yyval.charval += 2;
 799:     } break;
 800: case 77:
 801: # line 495 "apl.y"
 802: 
 803:     {
 804:         yyval.charptr = yypvt[-1].charptr;
 805:     } break;
 806:         }
 807:         goto yystack;  /* stack new state and value */
 808: 
 809:     }

Defined functions

Defined variables

Defined macros