00053                     {
00054         chainp d0 = datastack;
00055         if (d0->datap)
00056                 curdtp = (chainp)d0->datap;
00057         datastack = d0->nextp;
00058         d0->nextp = 0;
00059         frchain(&d0);
00060         }

01187 {
01188     int newsize, i;
01189     short *newss;
01190     YYSTYPE *newvs;
01191 
01192     if ((newsize = yystacksize) == 0)
01193         newsize = YYINITSTACKSIZE;
01194     else if (newsize >= YYMAXDEPTH)
01195         return -1;
01196     else if ((newsize *= 2) > YYMAXDEPTH)
01197         newsize = YYMAXDEPTH;
01198     i = yyssp - yyss;
01199     if ((newss = (short *)realloc(yyss, newsize * sizeof *newss)) == NULL)
01200         return -1;
01201     yyss = newss;
01202     yyssp = newss + i;
01203     if ((newvs = (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs)) == NULL)
01204         return -1;
01205     yyvs = newvs;
01206     yyvsp = newvs + i;
01207     yystacksize = newsize;
01208     yysslim = yyss + newsize - 1;
01209     return 0;
01210 }

01218 {
01219     int yym, yyn, yystate;
01220 #if YYDEBUG
01221     char *yys;
01222 
01223     if ((yys = getenv("YYDEBUG")) != NULL)
01224     {
01225         yyn = *yys;
01226         if (yyn >= '0' && yyn <= '9')
01227             yydebug = yyn - '0';
01228     }
01229 #endif
01230 
01231     yynerrs = 0;
01232     yyerrflag = 0;
01233     yychar = (-1);
01234 
01235     if (yyss == NULL && yygrowstack()) goto yyoverflow;
01236     yyssp = yyss;
01237     yyvsp = yyvs;
01238     *yyssp = yystate = 0;
01239 
01240 yyloop:
01241     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
01242     if (yychar < 0)
01243     {
01244         if ((yychar = yylex()) < 0) yychar = 0;
01245 #if YYDEBUG
01246         if (yydebug)
01247         {
01248             yys = 0;
01249             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
01250             if (!yys) yys = "illegal-symbol";
01251             printf("%sdebug: state %d, reading %d (%s)\n",
01252                     YYPREFIX, yystate, yychar, yys);
01253         }
01254 #endif
01255     }
01256     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
01257             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
01258     {
01259 #if YYDEBUG
01260         if (yydebug)
01261             printf("%sdebug: state %d, shifting to state %d\n",
01262                     YYPREFIX, yystate, yytable[yyn]);
01263 #endif
01264         if (yyssp >= yysslim && yygrowstack())
01265         {
01266             goto yyoverflow;
01267         }
01268         *++yyssp = yystate = yytable[yyn];
01269         *++yyvsp = yylval;
01270         yychar = (-1);
01271         if (yyerrflag > 0)  --yyerrflag;
01272         goto yyloop;
01273     }
01274     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
01275             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
01276     {
01277         yyn = yytable[yyn];
01278         goto yyreduce;
01279     }
01280     if (yyerrflag) goto yyinrecovery;
01281     goto yynewerror;
01282 yynewerror:
01283     yyerror("syntax error");
01284     goto yyerrlab;
01285 yyerrlab:
01286     ++yynerrs;
01287 yyinrecovery:
01288     if (yyerrflag < 3)
01289     {
01290         yyerrflag = 3;
01291         for (;;)
01292         {
01293             if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
01294                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
01295             {
01296 #if YYDEBUG
01297                 if (yydebug)
01298                     printf("%sdebug: state %d, error recovery shifting\
01299  to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
01300 #endif
01301                 if (yyssp >= yysslim && yygrowstack())
01302                 {
01303                     goto yyoverflow;
01304                 }
01305                 *++yyssp = yystate = yytable[yyn];
01306                 *++yyvsp = yylval;
01307                 goto yyloop;
01308             }
01309             else
01310             {
01311 #if YYDEBUG
01312                 if (yydebug)
01313                     printf("%sdebug: error recovery discarding state %d\n",
01314                             YYPREFIX, *yyssp);
01315 #endif
01316                 if (yyssp <= yyss) goto yyabort;
01317                 --yyssp;
01318                 --yyvsp;
01319             }
01320         }
01321     }
01322     else
01323     {
01324         if (yychar == 0) goto yyabort;
01325 #if YYDEBUG
01326         if (yydebug)
01327         {
01328             yys = 0;
01329             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
01330             if (!yys) yys = "illegal-symbol";
01331             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
01332                     YYPREFIX, yystate, yychar, yys);
01333         }
01334 #endif
01335         yychar = (-1);
01336         goto yyloop;
01337     }
01338 yyreduce:
01339 #if YYDEBUG
01340     if (yydebug)
01341         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
01342                 YYPREFIX, yystate, yyn, yyrule[yyn]);
01343 #endif
01344     yym = yylen[yyn];
01345     yyval = yyvsp[1-yym];
01346     switch (yyn)
01347     {
01348 case 3:
01349 #line 219 "gram.in"
01350 {
01351 /* stat:   is the nonterminal for Fortran statements */
01352 
01353                   lastwasbranch = NO; }
01354 break;
01355 case 5:
01356 #line 225 "gram.in"
01357 { /* forbid further statement function definitions... */
01358                   if (parstate == INDATA && laststfcn != thisstno)
01359                         parstate = INEXEC;
01360                   thisstno++;
01361                   if(yyvsp[-1].labval && (yyvsp[-1].labval->labelno==dorange))
01362                         enddo(yyvsp[-1].labval->labelno);
01363                   if(lastwasbranch && thislabel==NULL)
01364                         warn("statement cannot be reached");
01365                   lastwasbranch = thiswasbranch;
01366                   thiswasbranch = NO;
01367                   if(yyvsp[-1].labval)
01368                         {
01369                         if(yyvsp[-1].labval->labtype == LABFORMAT)
01370                                 err("label already that of a format");
01371                         else
01372                                 yyvsp[-1].labval->labtype = LABEXEC;
01373                         }
01374                   freetemps();
01375                 }
01376 break;
01377 case 6:
01378 #line 245 "gram.in"
01379 { if (can_include)
01380                         doinclude( yyvsp[0].charpval );
01381                   else {
01382                         fprintf(diagfile, "Cannot open file %s\n", yyvsp[0].charpval);
01383                         done(1);
01384                         }
01385                 }
01386 break;
01387 case 7:
01388 #line 253 "gram.in"
01389 { if (yyvsp[-2].labval)
01390                         lastwasbranch = NO;
01391                   endproc(); /* lastwasbranch = NO; -- set in endproc() */
01392                 }
01393 break;
01394 case 8:
01395 #line 258 "gram.in"
01396 { unclassifiable();
01397 
01398 /* flline flushes the current line, ignoring the rest of the text there */
01399 
01400                   flline(); }
01401 break;
01402 case 9:
01403 #line 264 "gram.in"
01404 { flline();  needkwd = NO;  inioctl = NO;
01405                   yyerrok; yyclearin; }
01406 break;
01407 case 10:
01408 #line 269 "gram.in"
01409 {
01410                 if(yystno != 0)
01411                         {
01412                         yyval.labval = thislabel =  mklabel(yystno);
01413                         if( ! headerdone ) {
01414                                 if (procclass == CLUNKNOWN)
01415                                         procclass = CLMAIN;
01416                                 puthead(CNULL, procclass);
01417                                 }
01418                         if(thislabel->labdefined)
01419                                 execerr("label %s already defined",
01420                                         convic(thislabel->stateno) );
01421                         else    {
01422                                 if(thislabel->blklevel!=0 && thislabel->blklevel<blklevel
01423                                     && thislabel->labtype!=LABFORMAT)
01424                                         warn1("there is a branch to label %s from outside block",
01425                                               convic( (ftnint) (thislabel->stateno) ) );
01426                                 thislabel->blklevel = blklevel;
01427                                 thislabel->labdefined = YES;
01428                                 if(thislabel->labtype != LABFORMAT)
01429                                         p1_label((long)(thislabel - labeltab));
01430                                 }
01431                         }
01432                 else    yyval.labval = thislabel = NULL;
01433                 }
01434 break;
01435 case 11:
01436 #line 297 "gram.in"
01437 {startproc(yyvsp[0].extval, CLMAIN); }
01438 break;
01439 case 12:
01440 #line 299 "gram.in"
01441 {       warn("ignoring arguments to main program");
01442                         /* hashclear(); */
01443                         startproc(yyvsp[-1].extval, CLMAIN); }
01444 break;
01445 case 13:
01446 #line 303 "gram.in"
01447 { if(yyvsp[0].extval) NO66("named BLOCKDATA");
01448                   startproc(yyvsp[0].extval, CLBLOCK); }
01449 break;
01450 case 14:
01451 #line 306 "gram.in"
01452 { entrypt(CLPROC, TYSUBR, (ftnint) 0,  yyvsp[-1].extval, yyvsp[0].chval); }
01453 break;
01454 case 15:
01455 #line 308 "gram.in"
01456 { entrypt(CLPROC, TYUNKNOWN, (ftnint) 0, yyvsp[-1].extval, yyvsp[0].chval); }
01457 break;
01458 case 16:
01459 #line 310 "gram.in"
01460 { entrypt(CLPROC, yyvsp[-4].ival, varleng, yyvsp[-1].extval, yyvsp[0].chval); }
01461 break;
01462 case 17:
01463 #line 312 "gram.in"
01464 { if(parstate==OUTSIDE || procclass==CLMAIN
01465                         || procclass==CLBLOCK)
01466                                 execerr("misplaced entry statement", CNULL);
01467                   entrypt(CLENTRY, 0, (ftnint) 0, yyvsp[-1].extval, yyvsp[0].chval);
01468                 }
01469 break;
01470 case 18:
01471 #line 320 "gram.in"
01472 { newproc(); }
01473 break;
01474 case 19:
01475 #line 324 "gram.in"
01476 { yyval.extval = newentry(yyvsp[0].namval, 1); }
01477 break;
01478 case 20:
01479 #line 328 "gram.in"
01480 { yyval.namval = mkname(token); }
01481 break;
01482 case 21:
01483 #line 331 "gram.in"
01484 { yyval.extval = NULL; }
01485 break;
01486 case 29:
01487 #line 349 "gram.in"
01488 { yyval.chval = 0; }
01489 break;
01490 case 30:
01491 #line 351 "gram.in"
01492 { NO66(" () argument list");
01493                   yyval.chval = 0; }
01494 break;
01495 case 31:
01496 #line 354 "gram.in"
01497 {yyval.chval = yyvsp[-1].chval; }
01498 break;
01499 case 32:
01500 #line 358 "gram.in"
01501 { yyval.chval = (yyvsp[0].namval ? mkchain((char *)yyvsp[0].namval,CHNULL) : CHNULL ); }
01502 break;
01503 case 33:
01504 #line 360 "gram.in"
01505 { if(yyvsp[0].namval) yyvsp[-2].chval = yyval.chval = mkchain((char *)yyvsp[0].namval, yyvsp[-2].chval); }
01506 break;
01507 case 34:
01508 #line 364 "gram.in"
01509 { if(yyvsp[0].namval->vstg!=STGUNKNOWN && yyvsp[0].namval->vstg!=STGARG)
01510                         dclerr("name declared as argument after use", yyvsp[0].namval);
01511                   yyvsp[0].namval->vstg = STGARG;
01512                 }
01513 break;
01514 case 35:
01515 #line 369 "gram.in"
01516 { NO66("altenate return argument");
01517 
01518 /* substars   means that '*'ed formal parameters should be replaced.
01519    This is used to specify alternate return labels; in theory, only
01520    parameter slots which have '*' should accept the statement labels.
01521    This compiler chooses to ignore the '*'s in the formal declaration, and
01522    always return the proper value anyway.
01523 
01524    This variable is only referred to in   proc.c   */
01525 
01526                   yyval.namval = 0;  substars = YES; }
01527 break;
01528 case 36:
01529 #line 385 "gram.in"
01530 {
01531                 char *s;
01532                 s = copyn(toklen+1, token);
01533                 s[toklen] = '\0';
01534                 yyval.charpval = s;
01535                 }
01536 break;
01537 case 45:
01538 #line 401 "gram.in"
01539 { NO66("SAVE statement");
01540                   saveall = YES; }
01541 break;
01542 case 46:
01543 #line 404 "gram.in"
01544 { NO66("SAVE statement"); }
01545 break;
01546 case 47:
01547 #line 406 "gram.in"
01548 { fmtstmt(thislabel); setfmt(thislabel); }
01549 break;
01550 case 48:
01551 #line 408 "gram.in"
01552 { NO66("PARAMETER statement"); }
01553 break;
01554 case 49:
01555 #line 412 "gram.in"
01556 { settype(yyvsp[-4].namval, yyvsp[-6].ival, yyvsp[0].lval);
01557                   if(ndim>0) setbound(yyvsp[-4].namval,ndim,dims);
01558                 }
01559 break;
01560 case 50:
01561 #line 416 "gram.in"
01562 { settype(yyvsp[-2].namval, yyvsp[-4].ival, yyvsp[0].lval);
01563                   if(ndim>0) setbound(yyvsp[-2].namval,ndim,dims);
01564                 }
01565 break;
01566 case 51:
01567 #line 420 "gram.in"
01568 { if (new_dcl == 2) {
01569                         err("attempt to give DATA in type-declaration");
01570                         new_dcl = 1;
01571                         }
01572                 }
01573 break;
01574 case 52:
01575 #line 427 "gram.in"
01576 { new_dcl = 2; }
01577 break;
01578 case 53:
01579 #line 430 "gram.in"
01580 { varleng = yyvsp[0].lval; }
01581 break;
01582 case 54:
01583 #line 434 "gram.in"
01584 { varleng = (yyvsp[0].ival<0 || ONEOF(yyvsp[0].ival,M(TYLOGICAL)|M(TYLONG))
01585                                 ? 0 : typesize[yyvsp[0].ival]);
01586                   vartype = yyvsp[0].ival; }
01587 break;
01588 case 55:
01589 #line 439 "gram.in"
01590 { yyval.ival = TYLONG; }
01591 break;
01592 case 56:
01593 #line 440 "gram.in"
01594 { yyval.ival = tyreal; }
01595 break;
01596 case 57:
01597 #line 441 "gram.in"
01598 { ++complex_seen; yyval.ival = tycomplex; }
01599 break;
01600 case 58:
01601 #line 442 "gram.in"
01602 { yyval.ival = TYDREAL; }
01603 break;
01604 case 59:
01605 #line 443 "gram.in"
01606 { ++dcomplex_seen; NOEXT("DOUBLE COMPLEX statement"); yyval.ival = TYDCOMPLEX; }
01607 break;
01608 case 60:
01609 #line 444 "gram.in"
01610 { yyval.ival = TYLOGICAL; }
01611 break;
01612 case 61:
01613 #line 445 "gram.in"
01614 { NO66("CHARACTER statement"); yyval.ival = TYCHAR; }
01615 break;
01616 case 62:
01617 #line 446 "gram.in"
01618 { yyval.ival = TYUNKNOWN; }
01619 break;
01620 case 63:
01621 #line 447 "gram.in"
01622 { yyval.ival = TYUNKNOWN; }
01623 break;
01624 case 64:
01625 #line 448 "gram.in"
01626 { NOEXT("AUTOMATIC statement"); yyval.ival = - STGAUTO; }
01627 break;
01628 case 65:
01629 #line 449 "gram.in"
01630 { NOEXT("STATIC statement"); yyval.ival = - STGBSS; }
01631 break;
01632 case 66:
01633 #line 450 "gram.in"
01634 { yyval.ival = TYINT1; }
01635 break;
01636 case 67:
01637 #line 454 "gram.in"
01638 { yyval.lval = varleng; }
01639 break;
01640 case 68:
01641 #line 456 "gram.in"
01642 {
01643                 expptr p;
01644                 p = yyvsp[-1].expval;
01645                 NO66("length specification *n");
01646                 if( ! ISICON(p) || p->constblock.Const.ci <= 0 )
01647                         {
01648                         yyval.lval = 0;
01649                         dclerr("length must be a positive integer constant",
01650                                 NPNULL);
01651                         }
01652                 else {
01653                         if (vartype == TYCHAR)
01654                                 yyval.lval = p->constblock.Const.ci;
01655                         else switch((int)p->constblock.Const.ci) {
01656                                 case 1: yyval.lval = 1; break;
01657                                 case 2: yyval.lval = typesize[TYSHORT]; break;
01658                                 case 4: yyval.lval = typesize[TYLONG];  break;
01659                                 case 8: yyval.lval = typesize[TYDREAL]; break;
01660                                 case 16: yyval.lval = typesize[TYDCOMPLEX]; break;
01661                                 default:
01662                                         dclerr("invalid length",NPNULL);
01663                                         yyval.lval = varleng;
01664                                 }
01665                         }
01666                 }
01667 break;
01668 case 69:
01669 #line 482 "gram.in"
01670 { NO66("length specification *(*)"); yyval.lval = -1; }
01671 break;
01672 case 70:
01673 #line 486 "gram.in"
01674 { incomm( yyval.extval = comblock("") , yyvsp[0].namval ); }
01675 break;
01676 case 71:
01677 #line 488 "gram.in"
01678 { yyval.extval = yyvsp[-1].extval;  incomm(yyvsp[-1].extval, yyvsp[0].namval); }
01679 break;
01680 case 72:
01681 #line 490 "gram.in"
01682 { yyval.extval = yyvsp[-2].extval;  incomm(yyvsp[-2].extval, yyvsp[0].namval); }
01683 break;
01684 case 73:
01685 #line 492 "gram.in"
01686 { incomm(yyvsp[-2].extval, yyvsp[0].namval); }
01687 break;
01688 case 74:
01689 #line 496 "gram.in"
01690 { yyval.extval = comblock(""); }
01691 break;
01692 case 75:
01693 #line 498 "gram.in"
01694 { yyval.extval = comblock(token); }
01695 break;
01696 case 76:
01697 #line 502 "gram.in"
01698 { setext(yyvsp[0].namval); }
01699 break;
01700 case 77:
01701 #line 504 "gram.in"
01702 { setext(yyvsp[0].namval); }
01703 break;
01704 case 78:
01705 #line 508 "gram.in"
01706 { NO66("INTRINSIC statement"); setintr(yyvsp[0].namval); }
01707 break;
01708 case 79:
01709 #line 510 "gram.in"
01710 { setintr(yyvsp[0].namval); }
01711 break;
01712 case 82:
01713 #line 518 "gram.in"
01714 {
01715                 struct Equivblock *p;
01716                 if(nequiv >= maxequiv)
01717                         many("equivalences", 'q', maxequiv);
01718                 p  =  & eqvclass[nequiv++];
01719                 p->eqvinit = NO;
01720                 p->eqvbottom = 0;
01721                 p->eqvtop = 0;
01722                 p->equivs = yyvsp[-1].eqvval;
01723                 }
01724 break;
01725 case 83:
01726 #line 531 "gram.in"
01727 { yyval.eqvval=ALLOC(Eqvchain);
01728                   yyval.eqvval->eqvitem.eqvlhs = primchk(yyvsp[0].expval);
01729                 }
01730 break;
01731 case 84:
01732 #line 535 "gram.in"
01733 { yyval.eqvval=ALLOC(Eqvchain);
01734                   yyval.eqvval->eqvitem.eqvlhs = primchk(yyvsp[0].expval);
01735                   yyval.eqvval->eqvnextp = yyvsp[-2].eqvval;
01736                 }
01737 break;
01738 case 87:
01739 #line 546 "gram.in"
01740 { if(parstate == OUTSIDE)
01741                         {
01742                         newproc();
01743                         startproc(ESNULL, CLMAIN);
01744                         }
01745                   if(parstate < INDATA)
01746                         {
01747                         enddcl();
01748                         parstate = INDATA;
01749                         datagripe = 1;
01750                         }
01751                 }
01752 break;
01753 case 88:
01754 #line 561 "gram.in"
01755 { ftnint junk;
01756                   if(nextdata(&junk) != NULL)
01757                         err("too few initializers");
01758                   frdata(yyvsp[-4].chval);
01759                   frrpl();
01760                 }
01761 break;
01762 case 89:
01763 #line 569 "gram.in"
01764 { frchain(&datastack); curdtp = 0; }
01765 break;
01766 case 90:
01767 #line 571 "gram.in"
01768 { pop_datastack(); }
01769 break;
01770 case 91:
01771 #line 573 "gram.in"
01772 { toomanyinit = NO; }
01773 break;
01774 case 94:
01775 #line 578 "gram.in"
01776 { dataval(ENULL, yyvsp[0].expval); }
01777 break;
01778 case 95:
01779 #line 580 "gram.in"
01780 { dataval(yyvsp[-2].expval, yyvsp[0].expval); }
01781 break;
01782 case 97:
01783 #line 585 "gram.in"
01784 { if( yyvsp[-1].ival==OPMINUS && ISCONST(yyvsp[0].expval) )
01785                         consnegop((Constp)yyvsp[0].expval);
01786                   yyval.expval = yyvsp[0].expval;
01787                 }
01788 break;
01789 case 101:
01790 #line 597 "gram.in"
01791 { int k;
01792                   yyvsp[0].namval->vsave = YES;
01793                   k = yyvsp[0].namval->vstg;
01794                 if( ! ONEOF(k, M(STGUNKNOWN)|M(STGBSS)|M(STGINIT)) )
01795                         dclerr("can only save static variables", yyvsp[0].namval);
01796                 }
01797 break;
01798 case 105:
01799 #line 611 "gram.in"
01800 { if(yyvsp[-2].namval->vclass == CLUNKNOWN)
01801                         make_param((struct Paramblock *)yyvsp[-2].namval, yyvsp[0].expval);
01802                   else dclerr("cannot make into parameter", yyvsp[-2].namval);
01803                 }
01804 break;
01805 case 106:
01806 #line 618 "gram.in"
01807 { if(ndim>0) setbound(yyvsp[-1].namval, ndim, dims); }
01808 break;
01809 case 107:
01810 #line 622 "gram.in"
01811 { Namep np;
01812                   struct Primblock *pp = (struct Primblock *)yyvsp[0].expval;
01813                   int tt = yyvsp[0].expval->tag;
01814                   if (tt != TPRIM) {
01815                         if (tt == TCONST)
01816                                 err("parameter in data statement");
01817                         else
01818                                 erri("tag %d in data statement",tt);
01819                         yyval.chval = 0;
01820                         err_lineno = lineno;
01821                         break;
01822                         }
01823                   np = pp -> namep;
01824                   vardcl(np);
01825                   if ((pp->fcharp || pp->lcharp)
01826                    && (np->vtype != TYCHAR || np->vdim))
01827                         sserr(np);
01828                   if(np->vstg == STGCOMMON)
01829                         extsymtab[np->vardesc.varno].extinit = YES;
01830                   else if(np->vstg==STGEQUIV)
01831                         eqvclass[np->vardesc.varno].eqvinit = YES;
01832                   else if(np->vstg!=STGINIT && np->vstg!=STGBSS) {
01833                         errstr(np->vstg == STGARG
01834                                 ? "Dummy argument \"%.60s\" in data statement."
01835                                 : "Cannot give data to \"%.75s\"",
01836                                 np->fvarname);
01837                         yyval.chval = 0;
01838                         err_lineno = lineno;
01839                         break;
01840                         }
01841                   yyval.chval = mkchain((char *)yyvsp[0].expval, CHNULL);
01842                 }
01843 break;
01844 case 108:
01845 #line 655 "gram.in"
01846 { chainp p; struct Impldoblock *q;
01847                 pop_datastack();
01848                 q = ALLOC(Impldoblock);
01849                 q->tag = TIMPLDO;
01850                 (q->varnp = (Namep) (yyvsp[-1].chval->datap))->vimpldovar = 1;
01851                 p = yyvsp[-1].chval->nextp;
01852                 if(p)  { q->implb = (expptr)(p->datap); p = p->nextp; }
01853                 if(p)  { q->impub = (expptr)(p->datap); p = p->nextp; }
01854                 if(p)  { q->impstep = (expptr)(p->datap); }
01855                 frchain( & (yyvsp[-1].chval) );
01856                 yyval.chval = mkchain((char *)q, CHNULL);
01857                 q->datalist = hookup(yyvsp[-3].chval, yyval.chval);
01858                 }
01859 break;
01860 case 109:
01861 #line 671 "gram.in"
01862 { if (!datastack)
01863                         curdtp = 0;
01864                   datastack = mkchain((char *)curdtp, datastack);
01865                   curdtp = yyvsp[0].chval; curdtelt = 0;
01866                   }
01867 break;
01868 case 110:
01869 #line 677 "gram.in"
01870 { yyval.chval = hookup(yyvsp[-2].chval, yyvsp[0].chval); }
01871 break;
01872 case 111:
01873 #line 681 "gram.in"
01874 { ndim = 0; }
01875 break;
01876 case 113:
01877 #line 685 "gram.in"
01878 { ndim = 0; }
01879 break;
01880 case 116:
01881 #line 690 "gram.in"
01882 {
01883                   if(ndim == maxdim)
01884                         err("too many dimensions");
01885                   else if(ndim < maxdim)
01886                         { dims[ndim].lb = 0;
01887                           dims[ndim].ub = yyvsp[0].expval;
01888                         }
01889                   ++ndim;
01890                 }
01891 break;
01892 case 117:
01893 #line 700 "gram.in"
01894 {
01895                   if(ndim == maxdim)
01896                         err("too many dimensions");
01897                   else if(ndim < maxdim)
01898                         { dims[ndim].lb = yyvsp[-2].expval;
01899                           dims[ndim].ub = yyvsp[0].expval;
01900                         }
01901                   ++ndim;
01902                 }
01903 break;
01904 case 118:
01905 #line 712 "gram.in"
01906 { yyval.expval = 0; }
01907 break;
01908 case 120:
01909 #line 717 "gram.in"
01910 { nstars = 1; labarray[0] = yyvsp[0].labval; }
01911 break;
01912 case 121:
01913 #line 719 "gram.in"
01914 { if(nstars < maxlablist)  labarray[nstars++] = yyvsp[0].labval; }
01915 break;
01916 case 122:
01917 #line 723 "gram.in"
01918 { yyval.labval = execlab( convci(toklen, token) ); }
01919 break;
01920 case 123:
01921 #line 727 "gram.in"
01922 { NO66("IMPLICIT statement"); }
01923 break;
01924 case 126:
01925 #line 733 "gram.in"
01926 { if (vartype != TYUNKNOWN)
01927                         dclerr("-- expected letter range",NPNULL);
01928                   setimpl(vartype, varleng, 'a', 'z'); }
01929 break;
01930 case 127:
01931 #line 738 "gram.in"
01932 { needkwd = 1; }
01933 break;
01934 case 131:
01935 #line 747 "gram.in"
01936 { setimpl(vartype, varleng, yyvsp[0].ival, yyvsp[0].ival); }
01937 break;
01938 case 132:
01939 #line 749 "gram.in"
01940 { setimpl(vartype, varleng, yyvsp[-2].ival, yyvsp[0].ival); }
01941 break;
01942 case 133:
01943 #line 753 "gram.in"
01944 { if(toklen!=1 || token[0]<'a' || token[0]>'z')
01945                         {
01946                         dclerr("implicit item must be single letter", NPNULL);
01947                         yyval.ival = 0;
01948                         }
01949                   else yyval.ival = token[0];
01950                 }
01951 break;
01952 case 136:
01953 #line 767 "gram.in"
01954 {
01955                 if(yyvsp[-2].namval->vclass == CLUNKNOWN)
01956                         {
01957                         yyvsp[-2].namval->vclass = CLNAMELIST;
01958                         yyvsp[-2].namval->vtype = TYINT;
01959                         yyvsp[-2].namval->vstg = STGBSS;
01960                         yyvsp[-2].namval->varxptr.namelist = yyvsp[0].chval;
01961                         yyvsp[-2].namval->vardesc.varno = ++lastvarno;
01962                         }
01963                 else dclerr("cannot be a namelist name", yyvsp[-2].namval);
01964                 }
01965 break;
01966 case 137:
01967 #line 781 "gram.in"
01968 { yyval.chval = mkchain((char *)yyvsp[0].namval, CHNULL); }
01969 break;
01970 case 138:
01971 #line 783 "gram.in"
01972 { yyval.chval = hookup(yyvsp[-2].chval, mkchain((char *)yyvsp[0].namval, CHNULL)); }
01973 break;
01974 case 139:
01975 #line 787 "gram.in"
01976 { switch(parstate)
01977                         {
01978                         case OUTSIDE:   newproc();
01979                                         startproc(ESNULL, CLMAIN);
01980                         case INSIDE:    parstate = INDCL;
01981                         case INDCL:     break;
01982 
01983                         case INDATA:
01984                                 if (datagripe) {
01985                                         errstr(
01986                                 "Statement order error: declaration after DATA",
01987                                                 CNULL);
01988                                         datagripe = 0;
01989                                         }
01990                                 break;
01991 
01992                         default:
01993                                 dclerr("declaration among executables", NPNULL);
01994                         }
01995                 }
01996 break;
01997 case 140:
01998 #line 809 "gram.in"
01999 { yyval.chval = 0; }
02000 break;
02001 case 141:
02002 #line 811 "gram.in"
02003 { yyval.chval = revchain(yyvsp[0].chval); }
02004 break;
02005 case 142:
02006 #line 815 "gram.in"
02007 { yyval.chval = mkchain((char *)yyvsp[0].expval, CHNULL); }
02008 break;
02009 case 143:
02010 #line 817 "gram.in"
02011 { yyval.chval = mkchain((char *)yyvsp[0].expval, yyvsp[-2].chval); }
02012 break;
02013 case 145:
02014 #line 822 "gram.in"
02015 { yyval.expval = yyvsp[-1].expval; if (yyval.expval->tag == TPRIM)
02016                                         yyval.expval->primblock.parenused = 1; }
02017 break;
02018 case 149:
02019 #line 830 "gram.in"
02020 { yyval.expval = mkexpr(yyvsp[-1].ival, yyvsp[-2].expval, yyvsp[0].expval); }
02021 break;
02022 case 150:
02023 #line 832 "gram.in"
02024 { yyval.expval = mkexpr(OPSTAR, yyvsp[-2].expval, yyvsp[0].expval); }
02025 break;
02026 case 151:
02027 #line 834 "gram.in"
02028 { yyval.expval = mkexpr(OPSLASH, yyvsp[-2].expval, yyvsp[0].expval); }
02029 break;
02030 case 152:
02031 #line 836 "gram.in"
02032 { yyval.expval = mkexpr(OPPOWER, yyvsp[-2].expval, yyvsp[0].expval); }
02033 break;
02034 case 153:
02035 #line 838 "gram.in"
02036 { if(yyvsp[-1].ival == OPMINUS)
02037                         yyval.expval = mkexpr(OPNEG, yyvsp[0].expval, ENULL);
02038                   else  yyval.expval = yyvsp[0].expval;
02039                 }
02040 break;
02041 case 154:
02042 #line 843 "gram.in"
02043 { yyval.expval = mkexpr(yyvsp[-1].ival, yyvsp[-2].expval, yyvsp[0].expval); }
02044 break;
02045 case 155:
02046 #line 845 "gram.in"
02047 { NO66(".EQV. operator");
02048                   yyval.expval = mkexpr(OPEQV, yyvsp[-2].expval,yyvsp[0].expval); }
02049 break;
02050 case 156:
02051 #line 848 "gram.in"
02052 { NO66(".NEQV. operator");
02053                   yyval.expval = mkexpr(OPNEQV, yyvsp[-2].expval, yyvsp[0].expval); }
02054 break;
02055 case 157:
02056 #line 851 "gram.in"
02057 { yyval.expval = mkexpr(OPOR, yyvsp[-2].expval, yyvsp[0].expval); }
02058 break;
02059 case 158:
02060 #line 853 "gram.in"
02061 { yyval.expval = mkexpr(OPAND, yyvsp[-2].expval, yyvsp[0].expval); }
02062 break;
02063 case 159:
02064 #line 855 "gram.in"
02065 { yyval.expval = mkexpr(OPNOT, yyvsp[0].expval, ENULL); }
02066 break;
02067 case 160:
02068 #line 857 "gram.in"
02069 { NO66("concatenation operator //");
02070                   yyval.expval = mkexpr(OPCONCAT, yyvsp[-2].expval, yyvsp[0].expval); }
02071 break;
02072 case 161:
02073 #line 861 "gram.in"
02074 { yyval.ival = OPPLUS; }
02075 break;
02076 case 162:
02077 #line 862 "gram.in"
02078 { yyval.ival = OPMINUS; }
02079 break;
02080 case 163:
02081 #line 865 "gram.in"
02082 { yyval.ival = OPEQ; }
02083 break;
02084 case 164:
02085 #line 866 "gram.in"
02086 { yyval.ival = OPGT; }
02087 break;
02088 case 165:
02089 #line 867 "gram.in"
02090 { yyval.ival = OPLT; }
02091 break;
02092 case 166:
02093 #line 868 "gram.in"
02094 { yyval.ival = OPGE; }
02095 break;
02096 case 167:
02097 #line 869 "gram.in"
02098 { yyval.ival = OPLE; }
02099 break;
02100 case 168:
02101 #line 870 "gram.in"
02102 { yyval.ival = OPNE; }
02103 break;
02104 case 169:
02105 #line 874 "gram.in"
02106 { yyval.expval = mkprim(yyvsp[0].namval, LBNULL, CHNULL); }
02107 break;
02108 case 170:
02109 #line 876 "gram.in"
02110 { NO66("substring operator :");
02111                   yyval.expval = mkprim(yyvsp[-1].namval, LBNULL, yyvsp[0].chval); }
02112 break;
02113 case 171:
02114 #line 879 "gram.in"
02115 { yyval.expval = mkprim(yyvsp[-3].namval, mklist(yyvsp[-1].chval), CHNULL); }
02116 break;
02117 case 172:
02118 #line 881 "gram.in"
02119 { NO66("substring operator :");
02120                   yyval.expval = mkprim(yyvsp[-4].namval, mklist(yyvsp[-2].chval), yyvsp[0].chval); }
02121 break;
02122 case 173:
02123 #line 886 "gram.in"
02124 { yyval.chval = mkchain((char *)yyvsp[-3].expval, mkchain((char *)yyvsp[-1].expval,CHNULL)); }
02125 break;
02126 case 174:
02127 #line 890 "gram.in"
02128 { yyval.expval = 0; }
02129 break;
02130 case 176:
02131 #line 895 "gram.in"
02132 { if(yyvsp[0].namval->vclass == CLPARAM)
02133                         yyval.expval = (expptr) cpexpr(
02134                                 ( (struct Paramblock *) (yyvsp[0].namval) ) -> paramval);
02135                 }
02136 break;
02137 case 178:
02138 #line 902 "gram.in"
02139 { yyval.expval = mklogcon(1); }
02140 break;
02141 case 179:
02142 #line 903 "gram.in"
02143 { yyval.expval = mklogcon(0); }
02144 break;
02145 case 180:
02146 #line 904 "gram.in"
02147 { yyval.expval = mkstrcon(toklen, token); }
02148 break;
02149 case 181:
02150 #line 905 "gram.in"
02151  { yyval.expval = mkintcon( convci(toklen, token) ); }
02152 break;
02153 case 182:
02154 #line 906 "gram.in"
02155  { yyval.expval = mkrealcon(tyreal, token); }
02156 break;
02157 case 183:
02158 #line 907 "gram.in"
02159  { yyval.expval = mkrealcon(TYDREAL, token); }
02160 break;
02161 case 185:
02162 #line 912 "gram.in"
02163 { yyval.expval = mkcxcon(yyvsp[-3].expval,yyvsp[-1].expval); }
02164 break;
02165 case 186:
02166 #line 916 "gram.in"
02167 { NOEXT("hex constant");
02168                   yyval.expval = mkbitcon(4, toklen, token); }
02169 break;
02170 case 187:
02171 #line 919 "gram.in"
02172 { NOEXT("octal constant");
02173                   yyval.expval = mkbitcon(3, toklen, token); }
02174 break;
02175 case 188:
02176 #line 922 "gram.in"
02177 { NOEXT("binary constant");
02178                   yyval.expval = mkbitcon(1, toklen, token); }
02179 break;
02180 case 190:
02181 #line 928 "gram.in"
02182 { yyval.expval = yyvsp[-1].expval; }
02183 break;
02184 case 193:
02185 #line 934 "gram.in"
02186 { yyval.expval = mkexpr(yyvsp[-1].ival, yyvsp[-2].expval, yyvsp[0].expval); }
02187 break;
02188 case 194:
02189 #line 936 "gram.in"
02190 { yyval.expval = mkexpr(OPSTAR, yyvsp[-2].expval, yyvsp[0].expval); }
02191 break;
02192 case 195:
02193 #line 938 "gram.in"
02194 { yyval.expval = mkexpr(OPSLASH, yyvsp[-2].expval, yyvsp[0].expval); }
02195 break;
02196 case 196:
02197 #line 940 "gram.in"
02198 { yyval.expval = mkexpr(OPPOWER, yyvsp[-2].expval, yyvsp[0].expval); }
02199 break;
02200 case 197:
02201 #line 942 "gram.in"
02202 { if(yyvsp[-1].ival == OPMINUS)
02203                         yyval.expval = mkexpr(OPNEG, yyvsp[0].expval, ENULL);
02204                   else  yyval.expval = yyvsp[0].expval;
02205                 }
02206 break;
02207 case 198:
02208 #line 947 "gram.in"
02209 { NO66("concatenation operator //");
02210                   yyval.expval = mkexpr(OPCONCAT, yyvsp[-2].expval, yyvsp[0].expval); }
02211 break;
02212 case 200:
02213 #line 952 "gram.in"
02214 {
02215                 if(yyvsp[-3].labval->labdefined)
02216                         execerr("no backward DO loops", CNULL);
02217                 yyvsp[-3].labval->blklevel = blklevel+1;
02218                 exdo(yyvsp[-3].labval->labelno, NPNULL, yyvsp[0].chval);
02219                 }
02220 break;
02221 case 201:
02222 #line 959 "gram.in"
02223 {
02224                 exdo((int)(ctls - ctlstack - 2), NPNULL, yyvsp[0].chval);
02225                 NOEXT("DO without label");
02226                 }
02227 break;
02228 case 202:
02229 #line 964 "gram.in"
02230 { exenddo(NPNULL); }
02231 break;
02232 case 203:
02233 #line 966 "gram.in"
02234 { exendif();  thiswasbranch = NO; }
02235 break;
02236 case 205:
02237 #line 969 "gram.in"
02238 { exelif(yyvsp[-2].expval); lastwasbranch = NO; }
02239 break;
02240 case 206:
02241 #line 971 "gram.in"
02242 { exelse(); lastwasbranch = NO; }
02243 break;
02244 case 207:
02245 #line 973 "gram.in"
02246 { exendif(); lastwasbranch = NO; }
02247 break;
02248 case 208:
02249 #line 977 "gram.in"
02250 { exif(yyvsp[-1].expval); }
02251 break;
02252 case 209:
02253 #line 981 "gram.in"
02254 { yyval.chval = mkchain((char *)yyvsp[-2].namval, yyvsp[0].chval); }
02255 break;
02256 case 211:
02257 #line 986 "gram.in"
02258 { yyval.chval = mkchain(CNULL, (chainp)yyvsp[-1].expval); }
02259 break;
02260 case 212:
02261 #line 990 "gram.in"
02262 { exequals((struct Primblock *)yyvsp[-2].expval, yyvsp[0].expval); }
02263 break;
02264 case 213:
02265 #line 992 "gram.in"
02266 { exassign(yyvsp[0].namval, yyvsp[-2].labval); }
02267 break;
02268 case 216:
02269 #line 996 "gram.in"
02270 { inioctl = NO; }
02271 break;
02272 case 217:
02273 #line 998 "gram.in"
02274 { exarif(yyvsp[-6].expval, yyvsp[-4].labval, yyvsp[-2].labval, yyvsp[0].labval);  thiswasbranch = YES; }
02275 break;
02276 case 218:
02277 #line 1000 "gram.in"
02278 { excall(yyvsp[0].namval, LBNULL, 0, labarray); }
02279 break;
02280 case 219:
02281 #line 1002 "gram.in"
02282 { excall(yyvsp[-2].namval, LBNULL, 0, labarray); }
02283 break;
02284 case 220:
02285 #line 1004 "gram.in"
02286 { if(nstars < maxlablist)
02287                         excall(yyvsp[-3].namval, mklist(revchain(yyvsp[-1].chval)), nstars, labarray);
02288                   else
02289                         many("alternate returns", 'l', maxlablist);
02290                 }
02291 break;
02292 case 221:
02293 #line 1010 "gram.in"
02294 { exreturn(yyvsp[0].expval);  thiswasbranch = YES; }
02295 break;
02296 case 222:
02297 #line 1012 "gram.in"
02298 { exstop(yyvsp[-2].ival, yyvsp[0].expval);  thiswasbranch = yyvsp[-2].ival; }
02299 break;
02300 case 223:
02301 #line 1016 "gram.in"
02302 { yyval.labval = mklabel( convci(toklen, token) ); }
02303 break;
02304 case 224:
02305 #line 1020 "gram.in"
02306 { if(parstate == OUTSIDE)
02307                         {
02308                         newproc();
02309                         startproc(ESNULL, CLMAIN);
02310                         }
02311                 }
02312 break;
02313 case 225:
02314 #line 1029 "gram.in"
02315 { exgoto(yyvsp[0].labval);  thiswasbranch = YES; }
02316 break;
02317 case 226:
02318 #line 1031 "gram.in"
02319 { exasgoto(yyvsp[0].namval);  thiswasbranch = YES; }
02320 break;
02321 case 227:
02322 #line 1033 "gram.in"
02323 { exasgoto(yyvsp[-4].namval);  thiswasbranch = YES; }
02324 break;
02325 case 228:
02326 #line 1035 "gram.in"
02327 { if(nstars < maxlablist)
02328                         putcmgo(putx(fixtype(yyvsp[0].expval)), nstars, labarray);
02329                   else
02330                         many("labels in computed GOTO list", 'l', maxlablist);
02331                 }
02332 break;
02333 case 231:
02334 #line 1047 "gram.in"
02335 { nstars = 0; yyval.namval = yyvsp[0].namval; }
02336 break;
02337 case 232:
02338 #line 1051 "gram.in"
02339 { yyval.chval = yyvsp[0].expval ? mkchain((char *)yyvsp[0].expval,CHNULL) : CHNULL; }
02340 break;
02341 case 233:
02342 #line 1053 "gram.in"
02343 { yyval.chval = yyvsp[0].expval ? mkchain((char *)yyvsp[0].expval, yyvsp[-2].chval) : yyvsp[-2].chval; }
02344 break;
02345 case 235:
02346 #line 1058 "gram.in"
02347 { if(nstars < maxlablist) labarray[nstars++] = yyvsp[0].labval; yyval.expval = 0; }
02348 break;
02349 case 236:
02350 #line 1062 "gram.in"
02351 { yyval.ival = 0; }
02352 break;
02353 case 237:
02354 #line 1064 "gram.in"
02355 { yyval.ival = 2; }
02356 break;
02357 case 238:
02358 #line 1068 "gram.in"
02359 { yyval.chval = mkchain((char *)yyvsp[0].expval, CHNULL); }
02360 break;
02361 case 239:
02362 #line 1070 "gram.in"
02363 { yyval.chval = hookup(yyvsp[-2].chval, mkchain((char *)yyvsp[0].expval,CHNULL) ); }
02364 break;
02365 case 240:
02366 #line 1074 "gram.in"
02367 { if(parstate == OUTSIDE)
02368                         {
02369                         newproc();
02370                         startproc(ESNULL, CLMAIN);
02371                         }
02372 
02373 /* This next statement depends on the ordering of the state table encoding */
02374 
02375                   if(parstate < INDATA) enddcl();
02376                 }
02377 break;
02378 case 241:
02379 #line 1087 "gram.in"
02380 { intonly = YES; }
02381 break;
02382 case 242:
02383 #line 1091 "gram.in"
02384 { intonly = NO; }
02385 break;
02386 case 243:
02387 #line 1096 "gram.in"
02388 { endio(); }
02389 break;
02390 case 245:
02391 #line 1101 "gram.in"
02392 { ioclause(IOSUNIT, yyvsp[0].expval); endioctl(); }
02393 break;
02394 case 246:
02395 #line 1103 "gram.in"
02396 { ioclause(IOSUNIT, ENULL); endioctl(); }
02397 break;
02398 case 247:
02399 #line 1105 "gram.in"
02400 { ioclause(IOSUNIT, IOSTDERR); endioctl(); }
02401 break;
02402 case 249:
02403 #line 1108 "gram.in"
02404 { doio(CHNULL); }
02405 break;
02406 case 250:
02407 #line 1110 "gram.in"
02408 { doio(CHNULL); }
02409 break;
02410 case 251:
02411 #line 1112 "gram.in"
02412 { doio(revchain(yyvsp[0].chval)); }
02413 break;
02414 case 252:
02415 #line 1114 "gram.in"
02416 { doio(revchain(yyvsp[0].chval)); }
02417 break;
02418 case 253:
02419 #line 1116 "gram.in"
02420 { doio(revchain(yyvsp[0].chval)); }
02421 break;
02422 case 254:
02423 #line 1118 "gram.in"
02424 { doio(CHNULL); }
02425 break;
02426 case 255:
02427 #line 1120 "gram.in"
02428 { doio(revchain(yyvsp[0].chval)); }
02429 break;
02430 case 256:
02431 #line 1122 "gram.in"
02432 { doio(CHNULL); }
02433 break;
02434 case 257:
02435 #line 1124 "gram.in"
02436 { doio(revchain(yyvsp[0].chval)); }
02437 break;
02438 case 259:
02439 #line 1131 "gram.in"
02440 { iostmt = IOBACKSPACE; }
02441 break;
02442 case 260:
02443 #line 1133 "gram.in"
02444 { iostmt = IOREWIND; }
02445 break;
02446 case 261:
02447 #line 1135 "gram.in"
02448 { iostmt = IOENDFILE; }
02449 break;
02450 case 263:
02451 #line 1142 "gram.in"
02452 { iostmt = IOINQUIRE; }
02453 break;
02454 case 264:
02455 #line 1144 "gram.in"
02456 { iostmt = IOOPEN; }
02457 break;
02458 case 265:
02459 #line 1146 "gram.in"
02460 { iostmt = IOCLOSE; }
02461 break;
02462 case 266:
02463 #line 1150 "gram.in"
02464 {
02465                 ioclause(IOSUNIT, ENULL);
02466                 ioclause(IOSFMT, yyvsp[0].expval);
02467                 endioctl();
02468                 }
02469 break;
02470 case 267:
02471 #line 1156 "gram.in"
02472 {
02473                 ioclause(IOSUNIT, ENULL);
02474                 ioclause(IOSFMT, ENULL);
02475                 endioctl();
02476                 }
02477 break;
02478 case 268:
02479 #line 1164 "gram.in"
02480 {
02481                   ioclause(IOSUNIT, yyvsp[-1].expval);
02482                   endioctl();
02483                 }
02484 break;
02485 case 269:
02486 #line 1169 "gram.in"
02487 { endioctl(); }
02488 break;
02489 case 272:
02490 #line 1177 "gram.in"
02491 { ioclause(IOSPOSITIONAL, yyvsp[0].expval); }
02492 break;
02493 case 273:
02494 #line 1179 "gram.in"
02495 { ioclause(IOSPOSITIONAL, ENULL); }
02496 break;
02497 case 274:
02498 #line 1181 "gram.in"
02499 { ioclause(IOSPOSITIONAL, IOSTDERR); }
02500 break;
02501 case 275:
02502 #line 1183 "gram.in"
02503 { ioclause(yyvsp[-1].ival, yyvsp[0].expval); }
02504 break;
02505 case 276:
02506 #line 1185 "gram.in"
02507 { ioclause(yyvsp[-1].ival, ENULL); }
02508 break;
02509 case 277:
02510 #line 1187 "gram.in"
02511 { ioclause(yyvsp[-1].ival, IOSTDERR); }
02512 break;
02513 case 278:
02514 #line 1191 "gram.in"
02515 { yyval.ival = iocname(); }
02516 break;
02517 case 279:
02518 #line 1195 "gram.in"
02519 { iostmt = IOREAD; }
02520 break;
02521 case 280:
02522 #line 1199 "gram.in"
02523 { iostmt = IOWRITE; }
02524 break;
02525 case 281:
02526 #line 1203 "gram.in"
02527 {
02528                 iostmt = IOWRITE;
02529                 ioclause(IOSUNIT, ENULL);
02530                 ioclause(IOSFMT, yyvsp[-1].expval);
02531                 endioctl();
02532                 }
02533 break;
02534 case 282:
02535 #line 1210 "gram.in"
02536 {
02537                 iostmt = IOWRITE;
02538                 ioclause(IOSUNIT, ENULL);
02539                 ioclause(IOSFMT, ENULL);
02540                 endioctl();
02541                 }
02542 break;
02543 case 283:
02544 #line 1219 "gram.in"
02545 { yyval.chval = mkchain((char *)yyvsp[0].tagval, CHNULL); }
02546 break;
02547 case 284:
02548 #line 1221 "gram.in"
02549 { yyval.chval = mkchain((char *)yyvsp[0].tagval, yyvsp[-2].chval); }
02550 break;
02551 case 285:
02552 #line 1225 "gram.in"
02553 { yyval.tagval = (tagptr) yyvsp[0].expval; }
02554 break;
02555 case 286:
02556 #line 1227 "gram.in"
02557 { yyval.tagval = (tagptr) mkiodo(yyvsp[-1].chval,revchain(yyvsp[-3].chval)); }
02558 break;
02559 case 287:
02560 #line 1231 "gram.in"
02561 { yyval.chval = mkchain((char *)yyvsp[0].expval, CHNULL); }
02562 break;
02563 case 288:
02564 #line 1233 "gram.in"
02565 { yyval.chval = mkchain((char *)yyvsp[0].tagval, CHNULL); }
02566 break;
02567 case 290:
02568 #line 1238 "gram.in"
02569 { yyval.chval = mkchain((char *)yyvsp[0].expval, mkchain((char *)yyvsp[-2].expval, CHNULL) ); }
02570 break;
02571 case 291:
02572 #line 1240 "gram.in"
02573 { yyval.chval = mkchain((char *)yyvsp[0].tagval, mkchain((char *)yyvsp[-2].expval, CHNULL) ); }
02574 break;
02575 case 292:
02576 #line 1242 "gram.in"
02577 { yyval.chval = mkchain((char *)yyvsp[0].expval, mkchain((char *)yyvsp[-2].tagval, CHNULL) ); }
02578 break;
02579 case 293:
02580 #line 1244 "gram.in"
02581 { yyval.chval = mkchain((char *)yyvsp[0].tagval, mkchain((char *)yyvsp[-2].tagval, CHNULL) ); }
02582 break;
02583 case 294:
02584 #line 1246 "gram.in"
02585 { yyval.chval = mkchain((char *)yyvsp[0].expval, yyvsp[-2].chval); }
02586 break;
02587 case 295:
02588 #line 1248 "gram.in"
02589 { yyval.chval = mkchain((char *)yyvsp[0].tagval, yyvsp[-2].chval); }
02590 break;
02591 case 296:
02592 #line 1252 "gram.in"
02593 { yyval.tagval = (tagptr) yyvsp[0].expval; }
02594 break;
02595 case 297:
02596 #line 1254 "gram.in"
02597 { yyval.tagval = (tagptr) yyvsp[-1].expval; }
02598 break;
02599 case 298:
02600 #line 1256 "gram.in"
02601 { yyval.tagval = (tagptr) mkiodo(yyvsp[-1].chval, mkchain((char *)yyvsp[-3].expval, CHNULL) ); }
02602 break;
02603 case 299:
02604 #line 1258 "gram.in"
02605 { yyval.tagval = (tagptr) mkiodo(yyvsp[-1].chval, mkchain((char *)yyvsp[-3].tagval, CHNULL) ); }
02606 break;
02607 case 300:
02608 #line 1260 "gram.in"
02609 { yyval.tagval = (tagptr) mkiodo(yyvsp[-1].chval, revchain(yyvsp[-3].chval)); }
02610 break;
02611 case 301:
02612 #line 1264 "gram.in"
02613 { startioctl(); }
02614 break;
02615 #line 2616 "y.tab.c"
02616     }
02617     yyssp -= yym;
02618     yystate = *yyssp;
02619     yyvsp -= yym;
02620     yym = yylhs[yyn];
02621     if (yystate == 0 && yym == 0)
02622     {
02623 #if YYDEBUG
02624         if (yydebug)
02625             printf("%sdebug: after reduction, shifting from state 0 to\
02626  state %d\n", YYPREFIX, YYFINAL);
02627 #endif
02628         yystate = YYFINAL;
02629         *++yyssp = YYFINAL;
02630         *++yyvsp = yyval;
02631         if (yychar < 0)
02632         {
02633             if ((yychar = yylex()) < 0) yychar = 0;
02634 #if YYDEBUG
02635             if (yydebug)
02636             {
02637                 yys = 0;
02638                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
02639                 if (!yys) yys = "illegal-symbol";
02640                 printf("%sdebug: state %d, reading %d (%s)\n",
02641                         YYPREFIX, YYFINAL, yychar, yys);
02642             }
02643 #endif
02644         }
02645         if (yychar == 0) goto yyaccept;
02646         goto yyloop;
02647     }
02648     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
02649             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
02650         yystate = yytable[yyn];
02651     else
02652         yystate = yydgoto[yym];
02653 #if YYDEBUG
02654     if (yydebug)
02655         printf("%sdebug: after reduction, shifting from state %d \
02656 to state %d\n", YYPREFIX, *yyssp, yystate);
02657 #endif
02658     if (yyssp >= yysslim && yygrowstack())
02659     {
02660         goto yyoverflow;
02661     }
02662     *++yyssp = yystate;
02663     *++yyvsp = yyval;
02664     goto yyloop;
02665 yyoverflow:
02666     yyerror("yacc stack overflow");
02667 yyabort:
02668     return (1);
02669 yyaccept:
02670     return (0);
02671 }

 {                                       1,
    4,  308,  185,  276,  271,   62,   63,   64,   65,  405,
  222,  341,   66,  258,  135,   93,  290,  291,  445,  357,
  358,  294,  295,  241,  198,  301,  474,  272,  277,  278,
  253,  151,  303,   67,  190,  223,  279,  225,  360,  169,
  217,  468,  438,  439,  243,  227,  228,  172,   68,  126,
  186,  187,  305,    5,   69,   70,   71,   94,   95,  321,
  414,  415,   72,   73,   74,   75,   76,   77,  127,   97,
  315,  133,  429,  287,  192,  350,  195,  393,  200,   99,
  193,  472,  442,  351,  128,  316,  386,  469,  387,  309,
  209,  210,  406,  211,  407,  148,   78,   79,   80,   81,
   82,   83,   84,  173,   85,   86,  179,   87,   88,   89,
  219,   90,  260,  261,
}

 {                                      0,
    0, -110,    0, -231, -333,  540,    0,    0,    0,  266,
   31,    0,    0,    0, -332,    0, -342,  468,    0,    0,
    0, -227,  277,    0, -181,    0,    0,    8,  578,  477,
  321,  -29,  375,    0, -137,  421,  275, -151, -118, -109,
  227,  262, -408,  278,  419, -174,  -27,    0,    0,  -65,
  -20,  656,    0,    0,    0,    0,    0, 1500,  -11,    0,
    0,  291,    0,    0,    0,    0,    0,    0,    0,  -15,
    0,  -63,    0, -234,  649,  315,  659, -335,  648,    0,
  638,    0,  357,    0,  564,  388,    0,  334,    0,  401,
  660,    0,    0,    0,  318,    0,  726,    0,    0,    0,
    0,    0,    0,  452,    0,    0,    0,    0,    0,    0,
 -119,    0,    0,  441,
}