#include "defs.h"#include "p1defs.h"Include dependency graph for gram.c:
Go to the source code of this file.
Data Structures | |
| union | YYSTYPE |
Defines | |
| #define | SEOS 1 |
| #define | SCOMMENT 2 |
| #define | SLABEL 3 |
| #define | SUNKNOWN 4 |
| #define | SHOLLERITH 5 |
| #define | SICON 6 |
| #define | SRCON 7 |
| #define | SDCON 8 |
| #define | SBITCON 9 |
| #define | SOCTCON 10 |
| #define | SHEXCON 11 |
| #define | STRUE 12 |
| #define | SFALSE 13 |
| #define | SNAME 14 |
| #define | SNAMEEQ 15 |
| #define | SFIELD 16 |
| #define | SSCALE 17 |
| #define | SINCLUDE 18 |
| #define | SLET 19 |
| #define | SASSIGN 20 |
| #define | SAUTOMATIC 21 |
| #define | SBACKSPACE 22 |
| #define | SBLOCK 23 |
| #define | SCALL 24 |
| #define | SCHARACTER 25 |
| #define | SCLOSE 26 |
| #define | SCOMMON 27 |
| #define | SCOMPLEX 28 |
| #define | SCONTINUE 29 |
| #define | SDATA 30 |
| #define | SDCOMPLEX 31 |
| #define | SDIMENSION 32 |
| #define | SDO 33 |
| #define | SDOUBLE 34 |
| #define | SELSE 35 |
| #define | SELSEIF 36 |
| #define | SEND 37 |
| #define | SENDFILE 38 |
| #define | SENDIF 39 |
| #define | SENTRY 40 |
| #define | SEQUIV 41 |
| #define | SEXTERNAL 42 |
| #define | SFORMAT 43 |
| #define | SFUNCTION 44 |
| #define | SGOTO 45 |
| #define | SASGOTO 46 |
| #define | SCOMPGOTO 47 |
| #define | SARITHIF 48 |
| #define | SLOGIF 49 |
| #define | SIMPLICIT 50 |
| #define | SINQUIRE 51 |
| #define | SINTEGER 52 |
| #define | SINTRINSIC 53 |
| #define | SLOGICAL 54 |
| #define | SNAMELIST 55 |
| #define | SOPEN 56 |
| #define | SPARAM 57 |
| #define | SPAUSE 58 |
| #define | SPRINT 59 |
| #define | SPROGRAM 60 |
| #define | SPUNCH 61 |
| #define | SREAD 62 |
| #define | SREAL 63 |
| #define | SRETURN 64 |
| #define | SREWIND 65 |
| #define | SSAVE 66 |
| #define | SSTATIC 67 |
| #define | SSTOP 68 |
| #define | SSUBROUTINE 69 |
| #define | STHEN 70 |
| #define | STO 71 |
| #define | SUNDEFINED 72 |
| #define | SWRITE 73 |
| #define | SLPAR 74 |
| #define | SRPAR 75 |
| #define | SEQUALS 76 |
| #define | SCOLON 77 |
| #define | SCOMMA 78 |
| #define | SCURRENCY 79 |
| #define | SPLUS 80 |
| #define | SMINUS 81 |
| #define | SSTAR 82 |
| #define | SSLASH 83 |
| #define | SPOWER 84 |
| #define | SCONCAT 85 |
| #define | SAND 86 |
| #define | SOR 87 |
| #define | SNEQV 88 |
| #define | SEQV 89 |
| #define | SNOT 90 |
| #define | SEQ 91 |
| #define | SLT 92 |
| #define | SGT 93 |
| #define | SLE 94 |
| #define | SGE 95 |
| #define | SNE 96 |
| #define | SENDDO 97 |
| #define | SWHILE 98 |
| #define | SSLASHD 99 |
| #define | SBYTE 100 |
| #define | ESNULL (Extsym *)0 |
| #define | NPNULL (Namep)0 |
| #define | LBNULL (struct Listblock *)0 |
| #define | YYMAXDEPTH 150 |
| #define | YYEOFCODE 1 |
| #define | YYERRCODE 2 |
| #define | YYNPROD 305 |
| #define | YYPRIVATE 57344 |
| #define | YYLAST 1455 |
| #define | YYFLAG -1000 |
| #define | YYERROR goto yyerrlab |
| #define | YYACCEPT return(0) |
| #define | YYABORT return(1) |
| #define | yyclearin yychar = -1 |
| #define | yyerrok yyerrflag = 0 |
| #define | yydebug 0 |
Functions | |
| void endcheck | Argdcl ((void)) |
| Primblock *primchk | Argdcl ((expptr)) |
| static void | pop_datastack (Void) |
| int | fprint (int, char *,...) |
| int | sprint (char *, char *,...) |
| char * | yytokname (int yyc) |
| char * | yystatname (int yys) |
| long | yylex1 (void) |
| int | yyparse (void) |
Variables | |
| static int | nstars |
| static int | datagripe |
| static int | ndim |
| static int | vartype |
| int | new_dcl |
| static ftnint | varleng |
| static struct Dims | dims [MAXDIM+1] |
| Labelblock ** | labarray |
| int | maxlablist |
| int | lastwasbranch = NO |
| static int | thiswasbranch = NO |
| ftnint | yystno |
| flag | intonly |
| static chainp | datastack |
| long | laststfcn |
| long | thisstno |
| int | can_include |
| int | yyerrflag |
| YYSTYPE | yylval |
| YYSTYPE | yyval |
| short | yyexca [] |
| short | yyact [] |
| short | yypact [] |
| short | yypgo [] |
| short | yyr1 [] |
| short | yyr2 [] |
| short | yychk [] |
| short | yydef [] |
| short | yytok1 [] |
| short | yytok2 [] |
| long | yytok3 [] |
| char * | yytoknames [1] |
| char * | yystates [1] |
| int | yynerrs = 0 |
| int | yyerrflag = 0 |
| #define LBNULL (struct Listblock *)0 |
| #define SBITCON 9 |
| #define SHEXCON 11 |
| #define SNAME 14 |
| #define SOCTCON 10 |
| Cextern int fork getpid Argdcl | ( | (void) | ) |
| static void pop_datastack | ( | Void | ) | [static] |
Definition at line 137 of file gram.c.
References curdtp, Chain::datap, datastack, frchain(), and Chain::nextp.
Referenced by yyparse().
00137 { 00138 chainp d0 = datastack; 00139 if (d0->datap) 00140 curdtp = (chainp)d0->datap; 00141 datastack = d0->nextp; 00142 d0->nextp = 0; 00143 frchain(&d0); 00144 }
Here is the call graph for this function:
Here is the caller graph for this function:
| int sprint | ( | char * | , | |
| char * | , | |||
| ... | ||||
| ) |
| long yylex1 | ( | void | ) |
Definition at line 714 of file gram.c.
References out(), yydebug, yylex(), YYPRIVATE, and yytokname().
Referenced by yyparse().
00715 { 00716 long yychar; 00717 long *t3p; 00718 int c; 00719 00720 yychar = yylex(); 00721 if(yychar <= 0) { 00722 c = yytok1[0]; 00723 goto out; 00724 } 00725 if(yychar < sizeof(yytok1)/sizeof(yytok1[0])) { 00726 c = yytok1[yychar]; 00727 goto out; 00728 } 00729 if(yychar >= YYPRIVATE) 00730 if(yychar < YYPRIVATE+sizeof(yytok2)/sizeof(yytok2[0])) { 00731 c = yytok2[yychar-YYPRIVATE]; 00732 goto out; 00733 } 00734 for(t3p=yytok3;; t3p+=2) { 00735 c = t3p[0]; 00736 if(c == yychar) { 00737 c = t3p[1]; 00738 goto out; 00739 } 00740 if(c == 0) 00741 break; 00742 } 00743 c = 0; 00744 00745 out: 00746 if(c == 0) 00747 c = yytok2[1]; /* unknown char */ 00748 if(yydebug >= 3) 00749 printf("lex %.4lX %s\n", yychar, yytokname(c)); 00750 return c; 00751 }
Here is the call graph for this function:
Here is the caller graph for this function:
| int yyparse | ( | void | ) |
Definition at line 754 of file gram.c.
References ALLOC, blklevel, Labelblock::blklevel, can_include, YYSTYPE::charpval, CHNULL, YYSTYPE::chval, CLBLOCK, CLENTRY, CLMAIN, CLNAMELIST, CLPARAM, CLPROC, CLUNKNOWN, CNULL, comblock(), complex_seen, consnegop(), convci(), convic(), copyn(), cpexpr(), ctls, ctlstack, curdtelt, curdtp, datagripe, datastack, dataval(), dclerr(), dcomplex_seen, diagfile, dims, doinclude(), doio(), done, dorange, endcheck(), enddcl(), enddo(), endio(), endioctl(), endproc(), entrypt(), ENULL, eqvclass, Equivblock::eqvinit, Eqvchain::eqvitem, Eqvchain::eqvlhs, Eqvchain::eqvnextp, YYSTYPE::eqvval, err, err_lineno, erri(), errstr(), ESNULL, exarif(), exasgoto(), exassign(), excall(), exdo(), execerr(), execlab(), exelif(), exelse(), exenddo(), exendif(), exequals(), exgoto(), exif(), YYSTYPE::expval, exreturn(), exstop(), Extsym::extinit, extsymtab, YYSTYPE::extval, fixtype(), flline(), fmtstmt(), frchain(), frdata(), freetemps(), frrpl(), Nameblock::fvarname, headerdone, hookup(), Impldoblock::implb, Impldoblock::impstep, Impldoblock::impub, incomm(), INDATA, INDCL, INEXEC, inioctl, INSIDE, intonly, IOBACKSPACE, ioclause(), IOCLOSE, iocname(), IOENDFILE, IOINQUIRE, IOOPEN, IOREAD, IOREWIND, IOSFMT, IOSPOSITIONAL, IOSTDERR, iostmt, IOSUNIT, IOWRITE, ISCONST, ISICON, YYSTYPE::ival, labarray, Labelblock::labdefined, labeltab, LABEXEC, LABFORMAT, Labelblock::labtype, YYSTYPE::labval, laststfcn, lastvarno, lastwasbranch, Dims::lb, LBNULL, lineno, YYSTYPE::lval, M, make_param(), many(), maxdim, maxequiv, maxlablist, mkbitcon(), mkchain(), mkcxcon(), mkexpr(), mkintqcon(), mkiodo(), mklabel(), mklist(), mklogcon(), mkname(), mkprim(), mkrealcon(), mkstrcon(), Primblock::namep, YYSTYPE::namval, ndim, needkwd, nequiv, new_dcl, newentry(), newproc(), nextdata(), NO, NO66, NOEXT, NPNULL, nstars, NULL, ONEOF, OPAND, OPCONCAT, OPEQ, OPEQV, OPGE, OPGT, OPLE, OPLT, OPMINUS, OPNE, OPNEG, OPNEQV, OPNOT, OPOR, OPPLUS, OPPOWER, OPSLASH, OPSTAR, OUTSIDE, p, p1_label(), paren_used(), parstate, pop_datastack(), pp, Expression::primblock, primchk(), procclass, putcmgo(), puthead(), putx(), revchain(), s, saveall, setbound(), setext(), setfmt(), setimpl(), setintr(), settype(), sserr(), startioctl(), startproc(), Labelblock::stateno, STGARG, STGAUTO, STGBSS, STGCOMMON, STGEQUIV, STGINIT, STGUNKNOWN, substars, Expression::tag, Impldoblock::tag, YYSTYPE::tagval, TCONST, thislabel, thisstno, thiswasbranch, TIMPLDO, token, toklen, toomanyinit, TPRIM, TYCHAR, tycomplex, TYDCOMPLEX, TYDREAL, TYINT, TYINT1, TYLOGICAL, TYLONG, typesize, tyreal, TYSHORT, TYSUBR, TYUNKNOWN, Dims::ub, unclassifiable(), vardcl(), Nameblock::vardesc, varleng, Nameblock::varno, Impldoblock::varnp, vartype, Nameblock::vdim, Nameblock::vstg, Nameblock::vtype, warn(), warn1(), westart(), YES, yyclearin, yydebug, YYEOFCODE, YYERRCODE, yyerrok, yyerror(), YYFLAG, YYLAST, yylex1(), yylval, YYMAXDEPTH, yystatname(), yystno, yytokname(), and yyval.
00755 { 00756 struct 00757 { 00758 YYSTYPE yyv; 00759 int yys; 00760 } yys[YYMAXDEPTH], *yyp, *yypt; 00761 short *yyxi; 00762 int yyj, yym, yystate, yyn, yyg; 00763 YYSTYPE save1, save2; 00764 int save3, save4; 00765 long yychar; 00766 00767 save1 = yylval; 00768 save2 = yyval; 00769 save3 = yynerrs; 00770 save4 = yyerrflag; 00771 00772 yystate = 0; 00773 yychar = -1; 00774 yynerrs = 0; 00775 yyerrflag = 0; 00776 yyp = &yys[-1]; 00777 goto yystack; 00778 00779 ret0: 00780 yyn = 0; 00781 goto ret; 00782 00783 ret1: 00784 yyn = 1; 00785 goto ret; 00786 00787 ret: 00788 yylval = save1; 00789 yyval = save2; 00790 yynerrs = save3; 00791 yyerrflag = save4; 00792 return yyn; 00793 00794 yystack: 00795 /* put a state and value onto the stack */ 00796 if(yydebug >= 4) 00797 printf("char %s in %s", yytokname(yychar), yystatname(yystate)); 00798 00799 yyp++; 00800 if(yyp >= &yys[YYMAXDEPTH]) { 00801 yyerror("yacc stack overflow"); 00802 goto ret1; 00803 } 00804 yyp->yys = yystate; 00805 yyp->yyv = yyval; 00806 00807 yynewstate: 00808 yyn = yypact[yystate]; 00809 if(yyn <= YYFLAG) 00810 goto yydefault; /* simple state */ 00811 if(yychar < 0) 00812 yychar = yylex1(); 00813 yyn += yychar; 00814 if(yyn < 0 || yyn >= YYLAST) 00815 goto yydefault; 00816 yyn = yyact[yyn]; 00817 if(yychk[yyn] == yychar) { /* valid shift */ 00818 yychar = -1; 00819 yyval = yylval; 00820 yystate = yyn; 00821 if(yyerrflag > 0) 00822 yyerrflag--; 00823 goto yystack; 00824 } 00825 00826 yydefault: 00827 /* default state action */ 00828 yyn = yydef[yystate]; 00829 if(yyn == -2) { 00830 if(yychar < 0) 00831 yychar = yylex1(); 00832 00833 /* look through exception table */ 00834 for(yyxi=yyexca;; yyxi+=2) 00835 if(yyxi[0] == -1 && yyxi[1] == yystate) 00836 break; 00837 for(yyxi += 2;; yyxi += 2) { 00838 yyn = yyxi[0]; 00839 if(yyn < 0 || yyn == yychar) 00840 break; 00841 } 00842 yyn = yyxi[1]; 00843 if(yyn < 0) 00844 goto ret0; 00845 } 00846 if(yyn == 0) { 00847 /* error ... attempt to resume parsing */ 00848 switch(yyerrflag) { 00849 case 0: /* brand new error */ 00850 yyerror("syntax error"); 00851 if(yydebug >= 1) { 00852 printf("%s", yystatname(yystate)); 00853 printf("saw %s\n", yytokname(yychar)); 00854 } 00855 yynerrs++; 00856 00857 case 1: 00858 case 2: /* incompletely recovered error ... try again */ 00859 yyerrflag = 3; 00860 00861 /* find a state where "error" is a legal shift action */ 00862 while(yyp >= yys) { 00863 yyn = yypact[yyp->yys] + YYERRCODE; 00864 if(yyn >= 0 && yyn < YYLAST) { 00865 yystate = yyact[yyn]; /* simulate a shift of "error" */ 00866 if(yychk[yystate] == YYERRCODE) 00867 goto yystack; 00868 } 00869 00870 /* the current yyp has no shift onn "error", pop stack */ 00871 if(yydebug >= 2) 00872 printf("error recovery pops state %d, uncovers %d\n", 00873 yyp->yys, (yyp-1)->yys ); 00874 yyp--; 00875 } 00876 /* there is no state on the stack with an error shift ... abort */ 00877 goto ret1; 00878 00879 case 3: /* no shift yet; clobber input char */ 00880 if(yydebug >= YYEOFCODE) 00881 printf("error recovery discards %s\n", yytokname(yychar)); 00882 if(yychar == YYEOFCODE) 00883 goto ret1; 00884 yychar = -1; 00885 goto yynewstate; /* try again in the same state */ 00886 } 00887 } 00888 00889 /* reduction by production yyn */ 00890 if(yydebug >= 2) 00891 printf("reduce %d in:\n\t%s", yyn, yystatname(yystate)); 00892 00893 yypt = yyp; 00894 yyp -= yyr2[yyn]; 00895 yyval = (yyp+1)->yyv; 00896 yym = yyn; 00897 00898 /* consult goto table to find next state */ 00899 yyn = yyr1[yyn]; 00900 yyg = yypgo[yyn]; 00901 yyj = yyg + yyp->yys + 1; 00902 00903 if(yyj >= YYLAST || yychk[yystate=yyact[yyj]] != -yyn) 00904 yystate = yyact[yyg]; 00905 switch(yym) { 00906 00907 case 3: 00908 /* #line 220 "/n/bopp/v5/dmg/f2c/gram.in" */ 00909 { 00910 /* stat: is the nonterminal for Fortran statements */ 00911 00912 lastwasbranch = NO; } break; 00913 case 5: 00914 /* #line 226 "/n/bopp/v5/dmg/f2c/gram.in" */ 00915 { /* forbid further statement function definitions... */ 00916 if (parstate == INDATA && laststfcn != thisstno) 00917 parstate = INEXEC; 00918 thisstno++; 00919 if(yypt[-1].yyv.labval && (yypt[-1].yyv.labval->labelno==dorange)) 00920 enddo(yypt[-1].yyv.labval->labelno); 00921 if(lastwasbranch && thislabel==NULL) 00922 warn("statement cannot be reached"); 00923 lastwasbranch = thiswasbranch; 00924 thiswasbranch = NO; 00925 if(yypt[-1].yyv.labval) 00926 { 00927 if(yypt[-1].yyv.labval->labtype == LABFORMAT) 00928 err("label already that of a format"); 00929 else 00930 yypt[-1].yyv.labval->labtype = LABEXEC; 00931 } 00932 freetemps(); 00933 } break; 00934 case 6: 00935 /* #line 246 "/n/bopp/v5/dmg/f2c/gram.in" */ 00936 { if (can_include) 00937 doinclude( yypt[-0].yyv.charpval ); 00938 else { 00939 fprintf(diagfile, "Cannot open file %s\n", yypt[-0].yyv.charpval); 00940 done(1); 00941 } 00942 } break; 00943 case 7: 00944 /* #line 254 "/n/bopp/v5/dmg/f2c/gram.in" */ 00945 { if (yypt[-2].yyv.labval) 00946 lastwasbranch = NO; 00947 endcheck(); 00948 endproc(); /* lastwasbranch = NO; -- set in endproc() */ 00949 } break; 00950 case 8: 00951 /* #line 260 "/n/bopp/v5/dmg/f2c/gram.in" */ 00952 { unclassifiable(); 00953 00954 /* flline flushes the current line, ignoring the rest of the text there */ 00955 00956 flline(); } break; 00957 case 9: 00958 /* #line 266 "/n/bopp/v5/dmg/f2c/gram.in" */ 00959 { flline(); needkwd = NO; inioctl = NO; 00960 yyerrok; yyclearin; } break; 00961 case 10: 00962 /* #line 271 "/n/bopp/v5/dmg/f2c/gram.in" */ 00963 { 00964 if(yystno != 0) 00965 { 00966 yyval.labval = thislabel = mklabel(yystno); 00967 if( ! headerdone ) { 00968 if (procclass == CLUNKNOWN) 00969 procclass = CLMAIN; 00970 puthead(CNULL, procclass); 00971 } 00972 if(thislabel->labdefined) 00973 execerr("label %s already defined", 00974 convic(thislabel->stateno) ); 00975 else { 00976 if(thislabel->blklevel!=0 && (thislabel->blklevel)<(unsigned int)(blklevel) 00977 && thislabel->labtype!=LABFORMAT) 00978 warn1("there is a branch to label %s from outside block", 00979 convic( (ftnint) (thislabel->stateno) ) ); 00980 thislabel->blklevel = blklevel; 00981 thislabel->labdefined = YES; 00982 if(thislabel->labtype != LABFORMAT) 00983 p1_label((long)(thislabel - labeltab)); 00984 } 00985 } 00986 else yyval.labval = thislabel = NULL; 00987 } break; 00988 case 11: 00989 /* #line 299 "/n/bopp/v5/dmg/f2c/gram.in" */ 00990 {startproc(yypt[-0].yyv.extval, CLMAIN); } break; 00991 case 12: 00992 /* #line 301 "/n/bopp/v5/dmg/f2c/gram.in" */ 00993 { warn("ignoring arguments to main program"); 00994 /* hashclear(); */ 00995 startproc(yypt[-1].yyv.extval, CLMAIN); } break; 00996 case 13: 00997 /* #line 305 "/n/bopp/v5/dmg/f2c/gram.in" */ 00998 { if(yypt[-0].yyv.extval) NO66("named BLOCKDATA"); 00999 startproc(yypt[-0].yyv.extval, CLBLOCK); } break; 01000 case 14: 01001 /* #line 308 "/n/bopp/v5/dmg/f2c/gram.in" */ 01002 { entrypt(CLPROC, TYSUBR, (ftnint) 0, yypt[-1].yyv.extval, yypt[-0].yyv.chval); } break; 01003 case 15: 01004 /* #line 310 "/n/bopp/v5/dmg/f2c/gram.in" */ 01005 { entrypt(CLPROC, TYUNKNOWN, (ftnint) 0, yypt[-1].yyv.extval, yypt[-0].yyv.chval); } break; 01006 case 16: 01007 /* #line 312 "/n/bopp/v5/dmg/f2c/gram.in" */ 01008 { entrypt(CLPROC, yypt[-4].yyv.ival, varleng, yypt[-1].yyv.extval, yypt[-0].yyv.chval); } break; 01009 case 17: 01010 /* #line 314 "/n/bopp/v5/dmg/f2c/gram.in" */ 01011 { if(parstate==OUTSIDE || procclass==CLMAIN 01012 || procclass==CLBLOCK) 01013 execerr("misplaced entry statement", CNULL); 01014 entrypt(CLENTRY, 0, (ftnint) 0, yypt[-1].yyv.extval, yypt[-0].yyv.chval); 01015 } break; 01016 case 18: 01017 /* #line 322 "/n/bopp/v5/dmg/f2c/gram.in" */ 01018 { newproc(); } break; 01019 case 19: 01020 /* #line 326 "/n/bopp/v5/dmg/f2c/gram.in" */ 01021 { yyval.extval = newentry(yypt[-0].yyv.namval, 1); } break; 01022 case 20: 01023 /* #line 330 "/n/bopp/v5/dmg/f2c/gram.in" */ 01024 { yyval.namval = mkname(token); } break; 01025 case 21: 01026 /* #line 333 "/n/bopp/v5/dmg/f2c/gram.in" */ 01027 { yyval.extval = NULL; } break; 01028 case 29: 01029 /* #line 351 "/n/bopp/v5/dmg/f2c/gram.in" */ 01030 { yyval.chval = 0; } break; 01031 case 30: 01032 /* #line 353 "/n/bopp/v5/dmg/f2c/gram.in" */ 01033 { NO66(" () argument list"); 01034 yyval.chval = 0; } break; 01035 case 31: 01036 /* #line 356 "/n/bopp/v5/dmg/f2c/gram.in" */ 01037 {yyval.chval = yypt[-1].yyv.chval; } break; 01038 case 32: 01039 /* #line 360 "/n/bopp/v5/dmg/f2c/gram.in" */ 01040 { yyval.chval = (yypt[-0].yyv.namval ? mkchain((char *)yypt[-0].yyv.namval,CHNULL) : CHNULL ); } break; 01041 case 33: 01042 /* #line 362 "/n/bopp/v5/dmg/f2c/gram.in" */ 01043 { if(yypt[-0].yyv.namval) yypt[-2].yyv.chval = yyval.chval = mkchain((char *)yypt[-0].yyv.namval, yypt[-2].yyv.chval); } break; 01044 case 34: 01045 /* #line 366 "/n/bopp/v5/dmg/f2c/gram.in" */ 01046 { if(yypt[-0].yyv.namval->vstg!=STGUNKNOWN && yypt[-0].yyv.namval->vstg!=STGARG) 01047 dclerr("name declared as argument after use", yypt[-0].yyv.namval); 01048 yypt[-0].yyv.namval->vstg = STGARG; 01049 } break; 01050 case 35: 01051 /* #line 371 "/n/bopp/v5/dmg/f2c/gram.in" */ 01052 { NO66("altenate return argument"); 01053 01054 /* substars means that '*'ed formal parameters should be replaced. 01055 This is used to specify alternate return labels; in theory, only 01056 parameter slots which have '*' should accept the statement labels. 01057 This compiler chooses to ignore the '*'s in the formal declaration, and 01058 always return the proper value anyway. 01059 01060 This variable is only referred to in proc.c */ 01061 01062 yyval.namval = 0; substars = YES; } break; 01063 case 36: 01064 /* #line 387 "/n/bopp/v5/dmg/f2c/gram.in" */ 01065 { 01066 char *s; 01067 s = copyn(toklen+1, token); 01068 s[toklen] = '\0'; 01069 yyval.charpval = s; 01070 } break; 01071 case 45: 01072 /* #line 403 "/n/bopp/v5/dmg/f2c/gram.in" */ 01073 { NO66("SAVE statement"); 01074 saveall = YES; } break; 01075 case 46: 01076 /* #line 406 "/n/bopp/v5/dmg/f2c/gram.in" */ 01077 { NO66("SAVE statement"); } break; 01078 case 47: 01079 /* #line 408 "/n/bopp/v5/dmg/f2c/gram.in" */ 01080 { fmtstmt(thislabel); setfmt(thislabel); } break; 01081 case 48: 01082 /* #line 410 "/n/bopp/v5/dmg/f2c/gram.in" */ 01083 { NO66("PARAMETER statement"); } break; 01084 case 49: 01085 /* #line 414 "/n/bopp/v5/dmg/f2c/gram.in" */ 01086 { settype(yypt[-4].yyv.namval, yypt[-6].yyv.ival, yypt[-0].yyv.lval); 01087 if(ndim>0) setbound(yypt[-4].yyv.namval,ndim,dims); 01088 } break; 01089 case 50: 01090 /* #line 418 "/n/bopp/v5/dmg/f2c/gram.in" */ 01091 { settype(yypt[-2].yyv.namval, yypt[-4].yyv.ival, yypt[-0].yyv.lval); 01092 if(ndim>0) setbound(yypt[-2].yyv.namval,ndim,dims); 01093 } break; 01094 case 51: 01095 /* #line 422 "/n/bopp/v5/dmg/f2c/gram.in" */ 01096 { if (new_dcl == 2) { 01097 err("attempt to give DATA in type-declaration"); 01098 new_dcl = 1; 01099 } 01100 } break; 01101 case 52: 01102 /* #line 429 "/n/bopp/v5/dmg/f2c/gram.in" */ 01103 { new_dcl = 2; } break; 01104 case 53: 01105 /* #line 432 "/n/bopp/v5/dmg/f2c/gram.in" */ 01106 { varleng = yypt[-0].yyv.lval; } break; 01107 case 54: 01108 /* #line 436 "/n/bopp/v5/dmg/f2c/gram.in" */ 01109 { varleng = (yypt[-0].yyv.ival<0 || ONEOF(yypt[-0].yyv.ival,M(TYLOGICAL)|M(TYLONG)) 01110 ? 0 : typesize[yypt[-0].yyv.ival]); 01111 vartype = yypt[-0].yyv.ival; } break; 01112 case 55: 01113 /* #line 441 "/n/bopp/v5/dmg/f2c/gram.in" */ 01114 { yyval.ival = TYLONG; } break; 01115 case 56: 01116 /* #line 442 "/n/bopp/v5/dmg/f2c/gram.in" */ 01117 { yyval.ival = tyreal; } break; 01118 case 57: 01119 /* #line 443 "/n/bopp/v5/dmg/f2c/gram.in" */ 01120 { ++complex_seen; yyval.ival = tycomplex; } break; 01121 case 58: 01122 /* #line 444 "/n/bopp/v5/dmg/f2c/gram.in" */ 01123 { yyval.ival = TYDREAL; } break; 01124 case 59: 01125 /* #line 445 "/n/bopp/v5/dmg/f2c/gram.in" */ 01126 { ++dcomplex_seen; NOEXT("DOUBLE COMPLEX statement"); yyval.ival = TYDCOMPLEX; } break; 01127 case 60: 01128 /* #line 446 "/n/bopp/v5/dmg/f2c/gram.in" */ 01129 { yyval.ival = TYLOGICAL; } break; 01130 case 61: 01131 /* #line 447 "/n/bopp/v5/dmg/f2c/gram.in" */ 01132 { NO66("CHARACTER statement"); yyval.ival = TYCHAR; } break; 01133 case 62: 01134 /* #line 448 "/n/bopp/v5/dmg/f2c/gram.in" */ 01135 { yyval.ival = TYUNKNOWN; } break; 01136 case 63: 01137 /* #line 449 "/n/bopp/v5/dmg/f2c/gram.in" */ 01138 { yyval.ival = TYUNKNOWN; } break; 01139 case 64: 01140 /* #line 450 "/n/bopp/v5/dmg/f2c/gram.in" */ 01141 { NOEXT("AUTOMATIC statement"); yyval.ival = - STGAUTO; } break; 01142 case 65: 01143 /* #line 451 "/n/bopp/v5/dmg/f2c/gram.in" */ 01144 { NOEXT("STATIC statement"); yyval.ival = - STGBSS; } break; 01145 case 66: 01146 /* #line 452 "/n/bopp/v5/dmg/f2c/gram.in" */ 01147 { yyval.ival = TYINT1; } break; 01148 case 67: 01149 /* #line 456 "/n/bopp/v5/dmg/f2c/gram.in" */ 01150 { yyval.lval = varleng; } break; 01151 case 68: 01152 /* #line 458 "/n/bopp/v5/dmg/f2c/gram.in" */ 01153 { 01154 expptr p; 01155 p = yypt[-1].yyv.expval; 01156 NO66("length specification *n"); 01157 if( ! ISICON(p) || p->constblock.Const.ci <= 0 ) 01158 { 01159 yyval.lval = 0; 01160 dclerr("length must be a positive integer constant", 01161 NPNULL); 01162 } 01163 else { 01164 if (vartype == TYCHAR) 01165 yyval.lval = p->constblock.Const.ci; 01166 else switch((int)p->constblock.Const.ci) { 01167 case 1: yyval.lval = 1; break; 01168 case 2: yyval.lval = typesize[TYSHORT]; break; 01169 case 4: yyval.lval = typesize[TYLONG]; break; 01170 case 8: yyval.lval = typesize[TYDREAL]; break; 01171 case 16: yyval.lval = typesize[TYDCOMPLEX]; break; 01172 default: 01173 dclerr("invalid length",NPNULL); 01174 yyval.lval = varleng; 01175 } 01176 } 01177 } break; 01178 case 69: 01179 /* #line 484 "/n/bopp/v5/dmg/f2c/gram.in" */ 01180 { NO66("length specification *(*)"); yyval.lval = -1; } break; 01181 case 70: 01182 /* #line 488 "/n/bopp/v5/dmg/f2c/gram.in" */ 01183 { incomm( yyval.extval = comblock("") , yypt[-0].yyv.namval ); } break; 01184 case 71: 01185 /* #line 490 "/n/bopp/v5/dmg/f2c/gram.in" */ 01186 { yyval.extval = yypt[-1].yyv.extval; incomm(yypt[-1].yyv.extval, yypt[-0].yyv.namval); } break; 01187 case 72: 01188 /* #line 492 "/n/bopp/v5/dmg/f2c/gram.in" */ 01189 { yyval.extval = yypt[-2].yyv.extval; incomm(yypt[-2].yyv.extval, yypt[-0].yyv.namval); } break; 01190 case 73: 01191 /* #line 494 "/n/bopp/v5/dmg/f2c/gram.in" */ 01192 { incomm(yypt[-2].yyv.extval, yypt[-0].yyv.namval); } break; 01193 case 74: 01194 /* #line 498 "/n/bopp/v5/dmg/f2c/gram.in" */ 01195 { yyval.extval = comblock(""); } break; 01196 case 75: 01197 /* #line 500 "/n/bopp/v5/dmg/f2c/gram.in" */ 01198 { yyval.extval = comblock(token); } break; 01199 case 76: 01200 /* #line 504 "/n/bopp/v5/dmg/f2c/gram.in" */ 01201 { setext(yypt[-0].yyv.namval); } break; 01202 case 77: 01203 /* #line 506 "/n/bopp/v5/dmg/f2c/gram.in" */ 01204 { setext(yypt[-0].yyv.namval); } break; 01205 case 78: 01206 /* #line 510 "/n/bopp/v5/dmg/f2c/gram.in" */ 01207 { NO66("INTRINSIC statement"); setintr(yypt[-0].yyv.namval); } break; 01208 case 79: 01209 /* #line 512 "/n/bopp/v5/dmg/f2c/gram.in" */ 01210 { setintr(yypt[-0].yyv.namval); } break; 01211 case 82: 01212 /* #line 520 "/n/bopp/v5/dmg/f2c/gram.in" */ 01213 { 01214 struct Equivblock *p; 01215 if(nequiv >= maxequiv) 01216 many("equivalences", 'q', maxequiv); 01217 p = & eqvclass[nequiv++]; 01218 p->eqvinit = NO; 01219 p->eqvbottom = 0; 01220 p->eqvtop = 0; 01221 p->equivs = yypt[-1].yyv.eqvval; 01222 } break; 01223 case 83: 01224 /* #line 533 "/n/bopp/v5/dmg/f2c/gram.in" */ 01225 { yyval.eqvval=ALLOC(Eqvchain); 01226 yyval.eqvval->eqvitem.eqvlhs = primchk(yypt[-0].yyv.expval); 01227 } break; 01228 case 84: 01229 /* #line 537 "/n/bopp/v5/dmg/f2c/gram.in" */ 01230 { yyval.eqvval=ALLOC(Eqvchain); 01231 yyval.eqvval->eqvitem.eqvlhs = primchk(yypt[-0].yyv.expval); 01232 yyval.eqvval->eqvnextp = yypt[-2].yyv.eqvval; 01233 } break; 01234 case 87: 01235 /* #line 548 "/n/bopp/v5/dmg/f2c/gram.in" */ 01236 { if(parstate == OUTSIDE) 01237 { 01238 newproc(); 01239 startproc(ESNULL, CLMAIN); 01240 } 01241 if(parstate < INDATA) 01242 { 01243 enddcl(); 01244 parstate = INDATA; 01245 datagripe = 1; 01246 } 01247 } break; 01248 case 88: 01249 /* #line 563 "/n/bopp/v5/dmg/f2c/gram.in" */ 01250 { ftnint junk; 01251 if(nextdata(&junk) != NULL) 01252 err("too few initializers"); 01253 frdata(yypt[-4].yyv.chval); 01254 frrpl(); 01255 } break; 01256 case 89: 01257 /* #line 571 "/n/bopp/v5/dmg/f2c/gram.in" */ 01258 { frchain(&datastack); curdtp = 0; } break; 01259 case 90: 01260 /* #line 573 "/n/bopp/v5/dmg/f2c/gram.in" */ 01261 { pop_datastack(); } break; 01262 case 91: 01263 /* #line 575 "/n/bopp/v5/dmg/f2c/gram.in" */ 01264 { toomanyinit = NO; } break; 01265 case 94: 01266 /* #line 580 "/n/bopp/v5/dmg/f2c/gram.in" */ 01267 { dataval(ENULL, yypt[-0].yyv.expval); } break; 01268 case 95: 01269 /* #line 582 "/n/bopp/v5/dmg/f2c/gram.in" */ 01270 { dataval(yypt[-2].yyv.expval, yypt[-0].yyv.expval); } break; 01271 case 97: 01272 /* #line 587 "/n/bopp/v5/dmg/f2c/gram.in" */ 01273 { if( yypt[-1].yyv.ival==OPMINUS && ISCONST(yypt[-0].yyv.expval) ) 01274 consnegop((Constp)yypt[-0].yyv.expval); 01275 yyval.expval = yypt[-0].yyv.expval; 01276 } break; 01277 case 101: 01278 /* #line 599 "/n/bopp/v5/dmg/f2c/gram.in" */ 01279 { int k; 01280 yypt[-0].yyv.namval->vsave = YES; 01281 k = yypt[-0].yyv.namval->vstg; 01282 if( ! ONEOF(k, M(STGUNKNOWN)|M(STGBSS)|M(STGINIT)) ) 01283 dclerr("can only save static variables", yypt[-0].yyv.namval); 01284 } break; 01285 case 105: 01286 /* #line 613 "/n/bopp/v5/dmg/f2c/gram.in" */ 01287 { if(yypt[-2].yyv.namval->vclass == CLUNKNOWN) 01288 make_param((struct Paramblock *)yypt[-2].yyv.namval, yypt[-0].yyv.expval); 01289 else dclerr("cannot make into parameter", yypt[-2].yyv.namval); 01290 } break; 01291 case 106: 01292 /* #line 620 "/n/bopp/v5/dmg/f2c/gram.in" */ 01293 { if(ndim>0) setbound(yypt[-1].yyv.namval, ndim, dims); } break; 01294 case 107: 01295 /* #line 624 "/n/bopp/v5/dmg/f2c/gram.in" */ 01296 { Namep np; 01297 struct Primblock *pp = (struct Primblock *)yypt[-0].yyv.expval; 01298 int tt = yypt[-0].yyv.expval->tag; 01299 if (tt != TPRIM) { 01300 if (tt == TCONST) 01301 err("parameter in data statement"); 01302 else 01303 erri("tag %d in data statement",tt); 01304 yyval.chval = 0; 01305 err_lineno = lineno; 01306 break; 01307 } 01308 np = pp -> namep; 01309 vardcl(np); 01310 if ((pp->fcharp || pp->lcharp) 01311 && (np->vtype != TYCHAR || np->vdim && !pp->argsp)) 01312 sserr(np); 01313 if(np->vstg == STGCOMMON) 01314 extsymtab[np->vardesc.varno].extinit = YES; 01315 else if(np->vstg==STGEQUIV) 01316 eqvclass[np->vardesc.varno].eqvinit = YES; 01317 else if(np->vstg!=STGINIT && np->vstg!=STGBSS) { 01318 errstr(np->vstg == STGARG 01319 ? "Dummy argument \"%.60s\" in data statement." 01320 : "Cannot give data to \"%.75s\"", 01321 np->fvarname); 01322 yyval.chval = 0; 01323 err_lineno = lineno; 01324 break; 01325 } 01326 yyval.chval = mkchain((char *)yypt[-0].yyv.expval, CHNULL); 01327 } break; 01328 case 108: 01329 /* #line 657 "/n/bopp/v5/dmg/f2c/gram.in" */ 01330 { chainp p; struct Impldoblock *q; 01331 pop_datastack(); 01332 q = ALLOC(Impldoblock); 01333 q->tag = TIMPLDO; 01334 (q->varnp = (Namep) (yypt[-1].yyv.chval->datap))->vimpldovar = 1; 01335 p = yypt[-1].yyv.chval->nextp; 01336 if(p) { q->implb = (expptr)(p->datap); p = p->nextp; } 01337 if(p) { q->impub = (expptr)(p->datap); p = p->nextp; } 01338 if(p) { q->impstep = (expptr)(p->datap); } 01339 frchain( & (yypt[-1].yyv.chval) ); 01340 yyval.chval = mkchain((char *)q, CHNULL); 01341 q->datalist = hookup(yypt[-3].yyv.chval, yyval.chval); 01342 } break; 01343 case 109: 01344 /* #line 673 "/n/bopp/v5/dmg/f2c/gram.in" */ 01345 { if (!datastack) 01346 curdtp = 0; 01347 datastack = mkchain((char *)curdtp, datastack); 01348 curdtp = yypt[-0].yyv.chval; curdtelt = 0; 01349 } break; 01350 case 110: 01351 /* #line 679 "/n/bopp/v5/dmg/f2c/gram.in" */ 01352 { yyval.chval = hookup(yypt[-2].yyv.chval, yypt[-0].yyv.chval); } break; 01353 case 111: 01354 /* #line 683 "/n/bopp/v5/dmg/f2c/gram.in" */ 01355 { ndim = 0; } break; 01356 case 113: 01357 /* #line 687 "/n/bopp/v5/dmg/f2c/gram.in" */ 01358 { ndim = 0; } break; 01359 case 116: 01360 /* #line 692 "/n/bopp/v5/dmg/f2c/gram.in" */ 01361 { 01362 if(ndim == maxdim) 01363 err("too many dimensions"); 01364 else if(ndim < maxdim) 01365 { dims[ndim].lb = 0; 01366 dims[ndim].ub = yypt[-0].yyv.expval; 01367 } 01368 ++ndim; 01369 } break; 01370 case 117: 01371 /* #line 702 "/n/bopp/v5/dmg/f2c/gram.in" */ 01372 { 01373 if(ndim == maxdim) 01374 err("too many dimensions"); 01375 else if(ndim < maxdim) 01376 { dims[ndim].lb = yypt[-2].yyv.expval; 01377 dims[ndim].ub = yypt[-0].yyv.expval; 01378 } 01379 ++ndim; 01380 } break; 01381 case 118: 01382 /* #line 714 "/n/bopp/v5/dmg/f2c/gram.in" */ 01383 { yyval.expval = 0; } break; 01384 case 120: 01385 /* #line 719 "/n/bopp/v5/dmg/f2c/gram.in" */ 01386 { nstars = 1; labarray[0] = yypt[-0].yyv.labval; } break; 01387 case 121: 01388 /* #line 721 "/n/bopp/v5/dmg/f2c/gram.in" */ 01389 { if(nstars < maxlablist) labarray[nstars++] = yypt[-0].yyv.labval; } break; 01390 case 122: 01391 /* #line 725 "/n/bopp/v5/dmg/f2c/gram.in" */ 01392 { yyval.labval = execlab( convci(toklen, token) ); } break; 01393 case 123: 01394 /* #line 729 "/n/bopp/v5/dmg/f2c/gram.in" */ 01395 { NO66("IMPLICIT statement"); } break; 01396 case 126: 01397 /* #line 735 "/n/bopp/v5/dmg/f2c/gram.in" */ 01398 { if (vartype != TYUNKNOWN) 01399 dclerr("-- expected letter range",NPNULL); 01400 setimpl(vartype, varleng, 'a', 'z'); } break; 01401 case 127: 01402 /* #line 740 "/n/bopp/v5/dmg/f2c/gram.in" */ 01403 { needkwd = 1; } break; 01404 case 131: 01405 /* #line 749 "/n/bopp/v5/dmg/f2c/gram.in" */ 01406 { setimpl(vartype, varleng, yypt[-0].yyv.ival, yypt[-0].yyv.ival); } break; 01407 case 132: 01408 /* #line 751 "/n/bopp/v5/dmg/f2c/gram.in" */ 01409 { setimpl(vartype, varleng, yypt[-2].yyv.ival, yypt[-0].yyv.ival); } break; 01410 case 133: 01411 /* #line 755 "/n/bopp/v5/dmg/f2c/gram.in" */ 01412 { if(toklen!=1 || token[0]<'a' || token[0]>'z') 01413 { 01414 dclerr("implicit item must be single letter", NPNULL); 01415 yyval.ival = 0; 01416 } 01417 else yyval.ival = token[0]; 01418 } break; 01419 case 136: 01420 /* #line 769 "/n/bopp/v5/dmg/f2c/gram.in" */ 01421 { 01422 if(yypt[-2].yyv.namval->vclass == CLUNKNOWN) 01423 { 01424 yypt[-2].yyv.namval->vclass = CLNAMELIST; 01425 yypt[-2].yyv.namval->vtype = TYINT; 01426 yypt[-2].yyv.namval->vstg = STGBSS; 01427 yypt[-2].yyv.namval->varxptr.namelist = yypt[-0].yyv.chval; 01428 yypt[-2].yyv.namval->vardesc.varno = ++lastvarno; 01429 } 01430 else dclerr("cannot be a namelist name", yypt[-2].yyv.namval); 01431 } break; 01432 case 137: 01433 /* #line 783 "/n/bopp/v5/dmg/f2c/gram.in" */ 01434 { yyval.chval = mkchain((char *)yypt[-0].yyv.namval, CHNULL); } break; 01435 case 138: 01436 /* #line 785 "/n/bopp/v5/dmg/f2c/gram.in" */ 01437 { yyval.chval = hookup(yypt[-2].yyv.chval, mkchain((char *)yypt[-0].yyv.namval, CHNULL)); } break; 01438 case 139: 01439 /* #line 789 "/n/bopp/v5/dmg/f2c/gram.in" */ 01440 { switch(parstate) 01441 { 01442 case OUTSIDE: newproc(); 01443 startproc(ESNULL, CLMAIN); 01444 case INSIDE: parstate = INDCL; 01445 case INDCL: break; 01446 01447 case INDATA: 01448 if (datagripe) { 01449 errstr( 01450 "Statement order error: declaration after DATA", 01451 CNULL); 01452 datagripe = 0; 01453 } 01454 break; 01455 01456 default: 01457 dclerr("declaration among executables", NPNULL); 01458 } 01459 } break; 01460 case 140: 01461 /* #line 811 "/n/bopp/v5/dmg/f2c/gram.in" */ 01462 { yyval.chval = 0; } break; 01463 case 141: 01464 /* #line 813 "/n/bopp/v5/dmg/f2c/gram.in" */ 01465 { yyval.chval = revchain(yypt[-0].yyv.chval); } break; 01466 case 142: 01467 /* #line 817 "/n/bopp/v5/dmg/f2c/gram.in" */ 01468 { yyval.chval = mkchain((char *)yypt[-0].yyv.expval, CHNULL); } break; 01469 case 143: 01470 /* #line 819 "/n/bopp/v5/dmg/f2c/gram.in" */ 01471 { yyval.chval = mkchain((char *)yypt[-0].yyv.expval, yypt[-2].yyv.chval); } break; 01472 case 145: 01473 /* #line 824 "/n/bopp/v5/dmg/f2c/gram.in" */ 01474 { yyval.expval = yypt[-1].yyv.expval; if (yyval.expval->tag == TPRIM) 01475 paren_used(&yyval.expval->primblock); } break; 01476 case 149: 01477 /* #line 832 "/n/bopp/v5/dmg/f2c/gram.in" */ 01478 { yyval.expval = mkexpr(yypt[-1].yyv.ival, yypt[-2].yyv.expval, yypt[-0].yyv.expval); } break; 01479 case 150: 01480 /* #line 834 "/n/bopp/v5/dmg/f2c/gram.in" */ 01481 { yyval.expval = mkexpr(OPSTAR, yypt[-2].yyv.expval, yypt[-0].yyv.expval); } break; 01482 case 151: 01483 /* #line 836 "/n/bopp/v5/dmg/f2c/gram.in" */ 01484 { yyval.expval = mkexpr(OPSLASH, yypt[-2].yyv.expval, yypt[-0].yyv.expval); } break; 01485 case 152: 01486 /* #line 838 "/n/bopp/v5/dmg/f2c/gram.in" */ 01487 { yyval.expval = mkexpr(OPPOWER, yypt[-2].yyv.expval, yypt[-0].yyv.expval); } break; 01488 case 153: 01489 /* #line 840 "/n/bopp/v5/dmg/f2c/gram.in" */ 01490 { if(yypt[-1].yyv.ival == OPMINUS) 01491 yyval.expval = mkexpr(OPNEG, yypt[-0].yyv.expval, ENULL); 01492 else { 01493 yyval.expval = yypt[-0].yyv.expval; 01494 if (yyval.expval->tag == TPRIM) 01495 paren_used(&yyval.expval->primblock); 01496 } 01497 } break; 01498 case 154: 01499 /* #line 849 "/n/bopp/v5/dmg/f2c/gram.in" */ 01500 { yyval.expval = mkexpr(yypt[-1].yyv.ival, yypt[-2].yyv.expval, yypt[-0].yyv.expval); } break; 01501 case 155: 01502 /* #line 851 "/n/bopp/v5/dmg/f2c/gram.in" */ 01503 { NO66(".EQV. operator"); 01504 yyval.expval = mkexpr(OPEQV, yypt[-2].yyv.expval,yypt[-0].yyv.expval); } break; 01505 case 156: 01506 /* #line 854 "/n/bopp/v5/dmg/f2c/gram.in" */ 01507 { NO66(".NEQV. operator"); 01508 yyval.expval = mkexpr(OPNEQV, yypt[-2].yyv.expval, yypt[-0].yyv.expval); } break; 01509 case 157: 01510 /* #line 857 "/n/bopp/v5/dmg/f2c/gram.in" */ 01511 { yyval.expval = mkexpr(OPOR, yypt[-2].yyv.expval, yypt[-0].yyv.expval); } break; 01512 case 158: 01513 /* #line 859 "/n/bopp/v5/dmg/f2c/gram.in" */ 01514 { yyval.expval = mkexpr(OPAND, yypt[-2].yyv.expval, yypt[-0].yyv.expval); } break; 01515 case 159: 01516 /* #line 861 "/n/bopp/v5/dmg/f2c/gram.in" */ 01517 { yyval.expval = mkexpr(OPNOT, yypt[-0].yyv.expval, ENULL); } break; 01518 case 160: 01519 /* #line 863 "/n/bopp/v5/dmg/f2c/gram.in" */ 01520 { NO66("concatenation operator //"); 01521 yyval.expval = mkexpr(OPCONCAT, yypt[-2].yyv.expval, yypt[-0].yyv.expval); } break; 01522 case 161: 01523 /* #line 867 "/n/bopp/v5/dmg/f2c/gram.in" */ 01524 { yyval.ival = OPPLUS; } break; 01525 case 162: 01526 /* #line 868 "/n/bopp/v5/dmg/f2c/gram.in" */ 01527 { yyval.ival = OPMINUS; } break; 01528 case 163: 01529 /* #line 871 "/n/bopp/v5/dmg/f2c/gram.in" */ 01530 { yyval.ival = OPEQ; } break; 01531 case 164: 01532 /* #line 872 "/n/bopp/v5/dmg/f2c/gram.in" */ 01533 { yyval.ival = OPGT; } break; 01534 case 165: 01535 /* #line 873 "/n/bopp/v5/dmg/f2c/gram.in" */ 01536 { yyval.ival = OPLT; } break; 01537 case 166: 01538 /* #line 874 "/n/bopp/v5/dmg/f2c/gram.in" */ 01539 { yyval.ival = OPGE; } break; 01540 case 167: 01541 /* #line 875 "/n/bopp/v5/dmg/f2c/gram.in" */ 01542 { yyval.ival = OPLE; } break; 01543 case 168: 01544 /* #line 876 "/n/bopp/v5/dmg/f2c/gram.in" */ 01545 { yyval.ival = OPNE; } break; 01546 case 169: 01547 /* #line 880 "/n/bopp/v5/dmg/f2c/gram.in" */ 01548 { yyval.expval = mkprim(yypt[-0].yyv.namval, LBNULL, CHNULL); } break; 01549 case 170: 01550 /* #line 882 "/n/bopp/v5/dmg/f2c/gram.in" */ 01551 { NO66("substring operator :"); 01552 yyval.expval = mkprim(yypt[-1].yyv.namval, LBNULL, yypt[-0].yyv.chval); } break; 01553 case 171: 01554 /* #line 885 "/n/bopp/v5/dmg/f2c/gram.in" */ 01555 { yyval.expval = mkprim(yypt[-3].yyv.namval, mklist(yypt[-1].yyv.chval), CHNULL); } break; 01556 case 172: 01557 /* #line 887 "/n/bopp/v5/dmg/f2c/gram.in" */ 01558 { NO66("substring operator :"); 01559 yyval.expval = mkprim(yypt[-4].yyv.namval, mklist(yypt[-2].yyv.chval), yypt[-0].yyv.chval); } break; 01560 case 173: 01561 /* #line 892 "/n/bopp/v5/dmg/f2c/gram.in" */ 01562 { yyval.chval = mkchain((char *)yypt[-3].yyv.expval, mkchain((char *)yypt[-1].yyv.expval,CHNULL)); } break; 01563 case 174: 01564 /* #line 896 "/n/bopp/v5/dmg/f2c/gram.in" */ 01565 { yyval.expval = 0; } break; 01566 case 176: 01567 /* #line 901 "/n/bopp/v5/dmg/f2c/gram.in" */ 01568 { if(yypt[-0].yyv.namval->vclass == CLPARAM) 01569 yyval.expval = (expptr) cpexpr( 01570 ( (struct Paramblock *) (yypt[-0].yyv.namval) ) -> paramval); 01571 } break; 01572 case 178: 01573 /* #line 908 "/n/bopp/v5/dmg/f2c/gram.in" */ 01574 { yyval.expval = mklogcon(1); } break; 01575 case 179: 01576 /* #line 909 "/n/bopp/v5/dmg/f2c/gram.in" */ 01577 { yyval.expval = mklogcon(0); } break; 01578 case 180: 01579 /* #line 910 "/n/bopp/v5/dmg/f2c/gram.in" */ 01580 { yyval.expval = mkstrcon(toklen, token); } break; 01581 case 181: 01582 /* #line 911 "/n/bopp/v5/dmg/f2c/gram.in" */ 01583 { yyval.expval = mkintqcon(toklen, token); } break; 01584 case 182: 01585 /* #line 912 "/n/bopp/v5/dmg/f2c/gram.in" */ 01586 { yyval.expval = mkrealcon(tyreal, token); } break; 01587 case 183: 01588 /* #line 913 "/n/bopp/v5/dmg/f2c/gram.in" */ 01589 { yyval.expval = mkrealcon(TYDREAL, token); } break; 01590 case 185: 01591 /* #line 918 "/n/bopp/v5/dmg/f2c/gram.in" */ 01592 { yyval.expval = mkcxcon(yypt[-3].yyv.expval,yypt[-1].yyv.expval); } break; 01593 case 186: 01594 /* #line 922 "/n/bopp/v5/dmg/f2c/gram.in" */ 01595 { NOEXT("hex constant"); 01596 yyval.expval = mkbitcon(4, toklen, token); } break; 01597 case 187: 01598 /* #line 925 "/n/bopp/v5/dmg/f2c/gram.in" */ 01599 { NOEXT("octal constant"); 01600 yyval.expval = mkbitcon(3, toklen, token); } break; 01601 case 188: 01602 /* #line 928 "/n/bopp/v5/dmg/f2c/gram.in" */ 01603 { NOEXT("binary constant"); 01604 yyval.expval = mkbitcon(1, toklen, token); } break; 01605 case 190: 01606 /* #line 934 "/n/bopp/v5/dmg/f2c/gram.in" */ 01607 { yyval.expval = yypt[-1].yyv.expval; } break; 01608 case 193: 01609 /* #line 940 "/n/bopp/v5/dmg/f2c/gram.in" */ 01610 { yyval.expval = mkexpr(yypt[-1].yyv.ival, yypt[-2].yyv.expval, yypt[-0].yyv.expval); } break; 01611 case 194: 01612 /* #line 942 "/n/bopp/v5/dmg/f2c/gram.in" */ 01613 { yyval.expval = mkexpr(OPSTAR, yypt[-2].yyv.expval, yypt[-0].yyv.expval); } break; 01614 case 195: 01615 /* #line 944 "/n/bopp/v5/dmg/f2c/gram.in" */ 01616 { yyval.expval = mkexpr(OPSLASH, yypt[-2].yyv.expval, yypt[-0].yyv.expval); } break; 01617 case 196: 01618 /* #line 946 "/n/bopp/v5/dmg/f2c/gram.in" */ 01619 { yyval.expval = mkexpr(OPPOWER, yypt[-2].yyv.expval, yypt[-0].yyv.expval); } break; 01620 case 197: 01621 /* #line 948 "/n/bopp/v5/dmg/f2c/gram.in" */ 01622 { if(yypt[-1].yyv.ival == OPMINUS) 01623 yyval.expval = mkexpr(OPNEG, yypt[-0].yyv.expval, ENULL); 01624 else yyval.expval = yypt[-0].yyv.expval; 01625 } break; 01626 case 198: 01627 /* #line 953 "/n/bopp/v5/dmg/f2c/gram.in" */ 01628 { NO66("concatenation operator //"); 01629 yyval.expval = mkexpr(OPCONCAT, yypt[-2].yyv.expval, yypt[-0].yyv.expval); } break; 01630 case 200: 01631 /* #line 958 "/n/bopp/v5/dmg/f2c/gram.in" */ 01632 { 01633 if(yypt[-2].yyv.labval->labdefined) 01634 execerr("no backward DO loops", CNULL); 01635 yypt[-2].yyv.labval->blklevel = blklevel+1; 01636 exdo(yypt[-2].yyv.labval->labelno, NPNULL, yypt[-0].yyv.chval); 01637 } break; 01638 case 201: 01639 /* #line 965 "/n/bopp/v5/dmg/f2c/gram.in" */ 01640 { 01641 exdo((int)(ctls - ctlstack - 2), NPNULL, yypt[-0].yyv.chval); 01642 NOEXT("DO without label"); 01643 } break; 01644 case 202: 01645 /* #line 970 "/n/bopp/v5/dmg/f2c/gram.in" */ 01646 { exenddo(NPNULL); } break; 01647 case 203: 01648 /* #line 972 "/n/bopp/v5/dmg/f2c/gram.in" */ 01649 { exendif(); thiswasbranch = NO; } break; 01650 case 205: 01651 /* #line 974 "/n/bopp/v5/dmg/f2c/gram.in" */ 01652 {westart(1);} break; 01653 case 206: 01654 /* #line 975 "/n/bopp/v5/dmg/f2c/gram.in" */ 01655 { exelif(yypt[-2].yyv.expval); lastwasbranch = NO; } break; 01656 case 207: 01657 /* #line 977 "/n/bopp/v5/dmg/f2c/gram.in" */ 01658 { exelse(); lastwasbranch = NO; } break; 01659 case 208: 01660 /* #line 979 "/n/bopp/v5/dmg/f2c/gram.in" */ 01661 { exendif(); lastwasbranch = NO; } break; 01662 case 209: 01663 /* #line 983 "/n/bopp/v5/dmg/f2c/gram.in" */ 01664 { exif(yypt[-1].yyv.expval); } break; 01665 case 210: 01666 /* #line 987 "/n/bopp/v5/dmg/f2c/gram.in" */ 01667 { yyval.chval = mkchain((char *)yypt[-2].yyv.namval, yypt[-0].yyv.chval); } break; 01668 case 212: 01669 /* #line 991 "/n/bopp/v5/dmg/f2c/gram.in" */ 01670 {westart(0);} break; 01671 case 213: 01672 /* #line 992 "/n/bopp/v5/dmg/f2c/gram.in" */ 01673 { yyval.chval = mkchain(CNULL, (chainp)yypt[-1].yyv.expval); } break; 01674 case 214: 01675 /* #line 996 "/n/bopp/v5/dmg/f2c/gram.in" */ 01676 { exequals((struct Primblock *)yypt[-2].yyv.expval, yypt[-0].yyv.expval); } break; 01677 case 215: 01678 /* #line 998 "/n/bopp/v5/dmg/f2c/gram.in" */ 01679 { exassign(yypt[-0].yyv.namval, yypt[-2].yyv.labval); } break; 01680 case 218: 01681 /* #line 1002 "/n/bopp/v5/dmg/f2c/gram.in" */ 01682 { inioctl = NO; } break; 01683 case 219: 01684 /* #line 1004 "/n/bopp/v5/dmg/f2c/gram.in" */ 01685 { exarif(yypt[-6].yyv.expval, yypt[-4].yyv.labval, yypt[-2].yyv.labval, yypt[-0].yyv.labval); thiswasbranch = YES; } break; 01686 case 220: 01687 /* #line 1006 "/n/bopp/v5/dmg/f2c/gram.in" */ 01688 { excall(yypt[-0].yyv.namval, LBNULL, 0, labarray); } break; 01689 case 221: 01690 /* #line 1008 "/n/bopp/v5/dmg/f2c/gram.in" */ 01691 { excall(yypt[-2].yyv.namval, LBNULL, 0, labarray); } break; 01692 case 222: 01693 /* #line 1010 "/n/bopp/v5/dmg/f2c/gram.in" */ 01694 { if(nstars < maxlablist) 01695 excall(yypt[-3].yyv.namval, mklist(revchain(yypt[-1].yyv.chval)), nstars, labarray); 01696 else 01697 many("alternate returns", 'l', maxlablist); 01698 } break; 01699 case 223: 01700 /* #line 1016 "/n/bopp/v5/dmg/f2c/gram.in" */ 01701 { exreturn(yypt[-0].yyv.expval); thiswasbranch = YES; } break; 01702 case 224: 01703 /* #line 1018 "/n/bopp/v5/dmg/f2c/gram.in" */ 01704 { exstop(yypt[-2].yyv.ival, yypt[-0].yyv.expval); thiswasbranch = yypt[-2].yyv.ival; } break; 01705 case 225: 01706 /* #line 1022 "/n/bopp/v5/dmg/f2c/gram.in" */ 01707 { yyval.labval = mklabel( convci(toklen, token) ); } break; 01708 case 226: 01709 /* #line 1026 "/n/bopp/v5/dmg/f2c/gram.in" */ 01710 { if(parstate == OUTSIDE) 01711 { 01712 newproc(); 01713 startproc(ESNULL, CLMAIN); 01714 } 01715 } break; 01716 case 227: 01717 /* #line 1035 "/n/bopp/v5/dmg/f2c/gram.in" */ 01718 { exgoto(yypt[-0].yyv.labval); thiswasbranch = YES; } break; 01719 case 228: 01720 /* #line 1037 "/n/bopp/v5/dmg/f2c/gram.in" */ 01721 { exasgoto(yypt[-0].yyv.namval); thiswasbranch = YES; } break; 01722 case 229: 01723 /* #line 1039 "/n/bopp/v5/dmg/f2c/gram.in" */ 01724 { exasgoto(yypt[-4].yyv.namval); thiswasbranch = YES; } break; 01725 case 230: 01726 /* #line 1041 "/n/bopp/v5/dmg/f2c/gram.in" */ 01727 { if(nstars < maxlablist) 01728 putcmgo(putx(fixtype(yypt[-0].yyv.expval)), nstars, labarray); 01729 else 01730 many("labels in computed GOTO list", 'l', maxlablist); 01731 } break; 01732 case 233: 01733 /* #line 1053 "/n/bopp/v5/dmg/f2c/gram.in" */ 01734 { nstars = 0; yyval.namval = yypt[-0].yyv.namval; } break; 01735 case 234: 01736 /* #line 1057 "/n/bopp/v5/dmg/f2c/gram.in" */ 01737 { yyval.chval = yypt[-0].yyv.expval ? mkchain((char *)yypt[-0].yyv.expval,CHNULL) : CHNULL; } break; 01738 case 235: 01739 /* #line 1059 "/n/bopp/v5/dmg/f2c/gram.in" */ 01740 { yyval.chval = yypt[-0].yyv.expval ? mkchain((char *)yypt[-0].yyv.expval, yypt[-2].yyv.chval) : yypt[-2].yyv.chval; } break; 01741 case 237: 01742 /* #line 1064 "/n/bopp/v5/dmg/f2c/gram.in" */ 01743 { if(nstars < maxlablist) labarray[nstars++] = yypt[-0].yyv.labval; yyval.expval = 0; } break; 01744 case 238: 01745 /* #line 1068 "/n/bopp/v5/dmg/f2c/gram.in" */ 01746 { yyval.ival = 0; } break; 01747 case 239: 01748 /* #line 1070 "/n/bopp/v5/dmg/f2c/gram.in" */ 01749 { yyval.ival = 2; } break; 01750 case 240: 01751 /* #line 1074 "/n/bopp/v5/dmg/f2c/gram.in" */ 01752 { yyval.chval = mkchain((char *)yypt[-0].yyv.expval, CHNULL); } break; 01753 case 241: 01754 /* #line 1076 "/n/bopp/v5/dmg/f2c/gram.in" */ 01755 { yyval.chval = hookup(yypt[-2].yyv.chval, mkchain((char *)yypt[-0].yyv.expval,CHNULL) ); } break; 01756 case 242: 01757 /* #line 1080 "/n/bopp/v5/dmg/f2c/gram.in" */ 01758 { if(parstate == OUTSIDE) 01759 { 01760 newproc(); 01761 startproc(ESNULL, CLMAIN); 01762 } 01763 01764 /* This next statement depends on the ordering of the state table encoding */ 01765 01766 if(parstate < INDATA) enddcl(); 01767 } break; 01768 case 243: 01769 /* #line 1093 "/n/bopp/v5/dmg/f2c/gram.in" */ 01770 { intonly = YES; } break; 01771 case 244: 01772 /* #line 1097 "/n/bopp/v5/dmg/f2c/gram.in" */ 01773 { intonly = NO; } break; 01774 case 245: 01775 /* #line 1102 "/n/bopp/v5/dmg/f2c/gram.in" */ 01776 { endio(); } break; 01777 case 247: 01778 /* #line 1107 "/n/bopp/v5/dmg/f2c/gram.in" */ 01779 { ioclause(IOSUNIT, yypt[-0].yyv.expval); endioctl(); } break; 01780 case 248: 01781 /* #line 1109 "/n/bopp/v5/dmg/f2c/gram.in" */ 01782 { ioclause(IOSUNIT, ENULL); endioctl(); } break; 01783 case 249: 01784 /* #line 1111 "/n/bopp/v5/dmg/f2c/gram.in" */ 01785 { ioclause(IOSUNIT, IOSTDERR); endioctl(); } break; 01786 case 251: 01787 /* #line 1114 "/n/bopp/v5/dmg/f2c/gram.in" */ 01788 { doio(CHNULL); } break; 01789 case 252: 01790 /* #line 1116 "/n/bopp/v5/dmg/f2c/gram.in" */ 01791 { doio(CHNULL); } break; 01792 case 253: 01793 /* #line 1118 "/n/bopp/v5/dmg/f2c/gram.in" */ 01794 { doio(revchain(yypt[-0].yyv.chval)); } break; 01795 case 254: 01796 /* #line 1120 "/n/bopp/v5/dmg/f2c/gram.in" */ 01797 { doio(revchain(yypt[-0].yyv.chval)); } break; 01798 case 255: 01799 /* #line 1122 "/n/bopp/v5/dmg/f2c/gram.in" */ 01800 { doio(revchain(yypt[-0].yyv.chval)); } break; 01801 case 256: 01802 /* #line 1124 "/n/bopp/v5/dmg/f2c/gram.in" */ 01803 { doio(CHNULL); } break; 01804 case 257: 01805 /* #line 1126 "/n/bopp/v5/dmg/f2c/gram.in" */ 01806 { doio(revchain(yypt[-0].yyv.chval)); } break; 01807 case 258: 01808 /* #line 1128 "/n/bopp/v5/dmg/f2c/gram.in" */ 01809 { doio(revchain(yypt[-0].yyv.chval)); } break; 01810 case 259: 01811 /* #line 1130 "/n/bopp/v5/dmg/f2c/gram.in" */ 01812 { doio(CHNULL); } break; 01813 case 260: 01814 /* #line 1132 "/n/bopp/v5/dmg/f2c/gram.in" */ 01815 { doio(revchain(yypt[-0].yyv.chval)); } break; 01816 case 262: 01817 /* #line 1139 "/n/bopp/v5/dmg/f2c/gram.in" */ 01818 { iostmt = IOBACKSPACE; } break; 01819 case 263: 01820 /* #line 1141 "/n/bopp/v5/dmg/f2c/gram.in" */ 01821 { iostmt = IOREWIND; } break; 01822 case 264: 01823 /* #line 1143 "/n/bopp/v5/dmg/f2c/gram.in" */ 01824 { iostmt = IOENDFILE; } break; 01825 case 266: 01826 /* #line 1150 "/n/bopp/v5/dmg/f2c/gram.in" */ 01827 { iostmt = IOINQUIRE; } break; 01828 case 267: 01829 /* #line 1152 "/n/bopp/v5/dmg/f2c/gram.in" */ 01830 { iostmt = IOOPEN; } break; 01831 case 268: 01832 /* #line 1154 "/n/bopp/v5/dmg/f2c/gram.in" */ 01833 { iostmt = IOCLOSE; } break; 01834 case 269: 01835 /* #line 1158 "/n/bopp/v5/dmg/f2c/gram.in" */ 01836 { 01837 ioclause(IOSUNIT, ENULL); 01838 ioclause(IOSFMT, yypt[-0].yyv.expval); 01839 endioctl(); 01840 } break; 01841 case 270: 01842 /* #line 1164 "/n/bopp/v5/dmg/f2c/gram.in" */ 01843 { 01844 ioclause(IOSUNIT, ENULL); 01845 ioclause(IOSFMT, ENULL); 01846 endioctl(); 01847 } break; 01848 case 271: 01849 /* #line 1172 "/n/bopp/v5/dmg/f2c/gram.in" */ 01850 { 01851 ioclause(IOSUNIT, yypt[-1].yyv.expval); 01852 endioctl(); 01853 } break; 01854 case 272: 01855 /* #line 1177 "/n/bopp/v5/dmg/f2c/gram.in" */ 01856 { endioctl(); } break; 01857 case 275: 01858 /* #line 1185 "/n/bopp/v5/dmg/f2c/gram.in" */ 01859 { ioclause(IOSPOSITIONAL, yypt[-0].yyv.expval); } break; 01860 case 276: 01861 /* #line 1187 "/n/bopp/v5/dmg/f2c/gram.in" */ 01862 { ioclause(IOSPOSITIONAL, ENULL); } break; 01863 case 277: 01864 /* #line 1189 "/n/bopp/v5/dmg/f2c/gram.in" */ 01865 { ioclause(IOSPOSITIONAL, IOSTDERR); } break; 01866 case 278: 01867 /* #line 1191 "/n/bopp/v5/dmg/f2c/gram.in" */ 01868 { ioclause(yypt[-1].yyv.ival, yypt[-0].yyv.expval); } break; 01869 case 279: 01870 /* #line 1193 "/n/bopp/v5/dmg/f2c/gram.in" */ 01871 { ioclause(yypt[-1].yyv.ival, ENULL); } break; 01872 case 280: 01873 /* #line 1195 "/n/bopp/v5/dmg/f2c/gram.in" */ 01874 { ioclause(yypt[-1].yyv.ival, IOSTDERR); } break; 01875 case 281: 01876 /* #line 1199 "/n/bopp/v5/dmg/f2c/gram.in" */ 01877 { yyval.ival = iocname(); } break; 01878 case 282: 01879 /* #line 1203 "/n/bopp/v5/dmg/f2c/gram.in" */ 01880 { iostmt = IOREAD; } break; 01881 case 283: 01882 /* #line 1207 "/n/bopp/v5/dmg/f2c/gram.in" */ 01883 { iostmt = IOWRITE; } break; 01884 case 284: 01885 /* #line 1211 "/n/bopp/v5/dmg/f2c/gram.in" */ 01886 { 01887 iostmt = IOWRITE; 01888 ioclause(IOSUNIT, ENULL); 01889 ioclause(IOSFMT, yypt[-1].yyv.expval); 01890 endioctl(); 01891 } break; 01892 case 285: 01893 /* #line 1218 "/n/bopp/v5/dmg/f2c/gram.in" */ 01894 { 01895 iostmt = IOWRITE; 01896 ioclause(IOSUNIT, ENULL); 01897 ioclause(IOSFMT, ENULL); 01898 endioctl(); 01899 } break; 01900 case 286: 01901 /* #line 1227 "/n/bopp/v5/dmg/f2c/gram.in" */ 01902 { yyval.chval = mkchain((char *)yypt[-0].yyv.tagval, CHNULL); } break; 01903 case 287: 01904 /* #line 1229 "/n/bopp/v5/dmg/f2c/gram.in" */ 01905 { yyval.chval = mkchain((char *)yypt[-0].yyv.tagval, yypt[-2].yyv.chval); } break; 01906 case 288: 01907 /* #line 1233 "/n/bopp/v5/dmg/f2c/gram.in" */ 01908 { yyval.tagval = (tagptr) yypt[-0].yyv.expval; } break; 01909 case 289: 01910 /* #line 1235 "/n/bopp/v5/dmg/f2c/gram.in" */ 01911 { yyval.tagval = (tagptr) mkiodo(yypt[-1].yyv.chval,revchain(yypt[-3].yyv.chval)); } break; 01912 case 290: 01913 /* #line 1239 "/n/bopp/v5/dmg/f2c/gram.in" */ 01914 { yyval.chval = mkchain((char *)yypt[-0].yyv.expval, CHNULL); } break; 01915 case 291: 01916 /* #line 1241 "/n/bopp/v5/dmg/f2c/gram.in" */ 01917 { yyval.chval = mkchain((char *)yypt[-0].yyv.tagval, CHNULL); } break; 01918 case 293: 01919 /* #line 1246 "/n/bopp/v5/dmg/f2c/gram.in" */ 01920 { yyval.chval = mkchain((char *)yypt[-0].yyv.expval, mkchain((char *)yypt[-2].yyv.expval, CHNULL) ); } break; 01921 case 294: 01922 /* #line 1248 "/n/bopp/v5/dmg/f2c/gram.in" */ 01923 { yyval.chval = mkchain((char *)yypt[-0].yyv.tagval, mkchain((char *)yypt[-2].yyv.expval, CHNULL) ); } break; 01924 case 295: 01925 /* #line 1250 "/n/bopp/v5/dmg/f2c/gram.in" */ 01926 { yyval.chval = mkchain((char *)yypt[-0].yyv.expval, mkchain((char *)yypt[-2].yyv.tagval, CHNULL) ); } break; 01927 case 296: 01928 /* #line 1252 "/n/bopp/v5/dmg/f2c/gram.in" */ 01929 { yyval.chval = mkchain((char *)yypt[-0].yyv.tagval, mkchain((char *)yypt[-2].yyv.tagval, CHNULL) ); } break; 01930 case 297: 01931 /* #line 1254 "/n/bopp/v5/dmg/f2c/gram.in" */ 01932 { yyval.chval = mkchain((char *)yypt[-0].yyv.expval, yypt[-2].yyv.chval); } break; 01933 case 298: 01934 /* #line 1256 "/n/bopp/v5/dmg/f2c/gram.in" */ 01935 { yyval.chval = mkchain((char *)yypt[-0].yyv.tagval, yypt[-2].yyv.chval); } break; 01936 case 299: 01937 /* #line 1260 "/n/bopp/v5/dmg/f2c/gram.in" */ 01938 { yyval.tagval = (tagptr) yypt[-0].yyv.expval; } break; 01939 case 300: 01940 /* #line 1262 "/n/bopp/v5/dmg/f2c/gram.in" */ 01941 { yyval.tagval = (tagptr) yypt[-1].yyv.expval; } break; 01942 case 301: 01943 /* #line 1264 "/n/bopp/v5/dmg/f2c/gram.in" */ 01944 { yyval.tagval = (tagptr) mkiodo(yypt[-1].yyv.chval, mkchain((char *)yypt[-3].yyv.expval, CHNULL) ); } break; 01945 case 302: 01946 /* #line 1266 "/n/bopp/v5/dmg/f2c/gram.in" */ 01947 { yyval.tagval = (tagptr) mkiodo(yypt[-1].yyv.chval, mkchain((char *)yypt[-3].yyv.tagval, CHNULL) ); } break; 01948 case 303: 01949 /* #line 1268 "/n/bopp/v5/dmg/f2c/gram.in" */ 01950 { yyval.tagval = (tagptr) mkiodo(yypt[-1].yyv.chval, revchain(yypt[-3].yyv.chval)); } break; 01951 case 304: 01952 /* #line 1272 "/n/bopp/v5/dmg/f2c/gram.in" */ 01953 { startioctl(); } break; 01954 } 01955 goto yystack; /* stack new state and value */ 01956 }
Here is the call graph for this function:
| char* yystatname | ( | int | yys | ) |
Definition at line 702 of file gram.c.
References x.
Referenced by yyparse().
00703 { 00704 static char x[10]; 00705 00706 if(yys >= 0 && yys < sizeof(yystates)/sizeof(yystates[0])) 00707 if(yystates[yys]) 00708 return yystates[yys]; 00709 sprintf(x, "<%d>\n", yys); 00710 return x; 00711 }
Here is the caller graph for this function:
| char* yytokname | ( | int | yyc | ) |
Definition at line 690 of file gram.c.
References x.
Referenced by yylex1(), and yyparse().
00691 { 00692 static char x[10]; 00693 00694 if(yyc > 0 && yyc <= sizeof(yytoknames)/sizeof(yytoknames[0])) 00695 if(yytoknames[yyc-1]) 00696 return yytoknames[yyc-1]; 00697 sprintf(x, "<%d>", yyc); 00698 return x; 00699 }
Here is the caller graph for this function:
Definition at line 113 of file gram.c.
Referenced by __PARAMS(), copy_data(), get_mat_as_hmat(), setbound(), wr_ardecls(), x_rsne(), x_wsne(), and yyparse().
| struct Labelblock** labarray |
| int lastwasbranch = NO |
Definition at line 109 of file gram.c.
Referenced by copy_data(), doequiv(), hashclear(), wr_ardecls(), and yyparse().
int thiswasbranch = NO [static] |
int vartype [static] |
| short yypgo[] |
Initial value:
{
0, 654, 653, 1, 652, 167, 9, 30, 648, 647,
646, 4, 0, 645, 644, 643, 39, 642, 3, 26,
641, 634, 621, 18, 14, 620, 35, 618, 617, 29,
41, 33, 20, 362, 22, 616, 34, 352, 66, 270,
16, 57, 378, 2, 24, 25, 11, 207, 114, 610,
609, 38, 28, 43, 608, 606, 604, 603, 602,1205,
134, 601, 600, 7, 599, 598, 597, 596, 594, 592,
591, 31, 589, 19, 585, 21, 37, 6, 584, 5,
42, 583, 36, 582, 579, 12, 27, 10, 578, 577,
8, 13, 32, 576, 574, 572, 15, 569, 516, 568,
567, 566, 565, 564, 562, 561, 560, 454, 559, 558,
553, 551, 545, 540, 23, 535, 530, 17
}
| short yytok1[] |
Initial value:
{
1, 4, 5, 6, 7, 8, 9, 10, 11, 12,
13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
103
}
| char* yytoknames[1] |
1.5.1