# define INTEGER 257 # define NREF 258 # define PREF 259 # define FIRST 260 # define LAST 261 # define NEXT 262 # define PREV 263 # define FREF 264 # define LREF 265 # define CUR 266 # define NEW 267 # define ALL 268 # define AREF 269 # line 4 "trn_expr.y" #include #include #include "globals.h" static trn_info *trnexpr_curtrn; static mtg_info *trnexpr_curmtg; static int trnexpr_low, trnexpr_high; static int trnexpr_aref; static char *cp; static int trnexpr_err; #define yyclearin yychar = -1 #define yyerrok yyerrflag = 0 extern int yychar; extern int yyerrflag; #ifndef YYMAXDEPTH #define YYMAXDEPTH 150 #endif #ifndef YYSTYPE #define YYSTYPE int #endif YYSTYPE yylval, yyval; typedef int yytabelem; # define YYERRCODE 256 # line 62 "trn_expr.y" /* * * Copyright (C) 1989 by the Massachusetts Institute of Technology * Developed by the MIT Student Information Processing Board (SIPB). * For copying information, see the file mit-copyright.h in this release. * */ static yyerror(msg) char *msg; { #ifdef lint msg = msg; #endif lint trnexpr_err = DISC_INVALID_TRN_SPECS; } /* * * see if second string is beginning of first string, except for case * differences.. * */ #define to_lower(c) (((c)<'_')?((c)+'a'-'A'):(c)) static match(s1, s2) register char *s1, *s2; { while (*s2) { if (to_lower(*s1) != *s2) return(0); s1++; s2++; } return(1); } static yylex() { if (!*cp) return -1; if(isdigit(*cp)) { yylval=0; do { yylval = *(cp++) - '0' + yylval*10; } while (*cp && isdigit(*cp)); return( INTEGER ); } else if (*cp=='.') { cp++; yylval=trnexpr_curtrn->current; return(CUR); } else if (*cp==':' || *cp=='+' || *cp=='-') { return(*cp++); } else if (match(cp, "current")) { cp += 7; yylval=trnexpr_curtrn->current; return(CUR); } else if (match(cp, "new")) { cp += 3; return(NEW); } else if (match(cp, "all")) { cp += 3; return(ALL); } else if (match(cp, "aref")) { cp += 4; return(AREF); } else if (match(cp, "next")) { cp += 4; yylval=trnexpr_curtrn->next; return(NEXT); } else if (match(cp, "prev")) { cp += 4; yylval=trnexpr_curtrn->prev; return(PREV); } else if (match(cp, "nref")) { cp += 4; yylval=trnexpr_curtrn->nref; return(NREF); } else if (match(cp, "pref")) { cp += 4; yylval=trnexpr_curtrn->pref; return(PREF); } else if (match(cp, "first")) { cp += 5; yylval=trnexpr_curmtg->first; return(FIRST); } else if (match(cp, "last")) { cp += 4; yylval=trnexpr_curmtg->last; return(LAST); } else if (match(cp, "fref")) { cp += 4; yylval=trnexpr_curtrn->fref; return(FREF); } else if (match(cp, "lref")) { cp += 4; yylval=trnexpr_curtrn->lref; return(LREF); } else if (*cp=='n' || *cp=='N') { cp++; yylval=trnexpr_curtrn->next; return(NEXT); } else if (*cp=='p' || *cp=='P') { cp++; yylval=trnexpr_curtrn->prev; return(PREV); } else if (*cp=='l' || *cp=='L') { cp++; yylval=trnexpr_curmtg->last; return(LAST); } else if (*cp=='f' || *cp == 'F') { cp++; yylval=trnexpr_curmtg->first; return(FIRST); } else return (*cp++); } int trnexpr_parse(mtg, trn, string, lorange, highrange, flags) mtg_info *mtg; trn_info *trn; char *string; int *lorange, *highrange, *flags; { cp = string; trnexpr_curmtg = mtg; trnexpr_curtrn = trn; trnexpr_aref = 0; trnexpr_err = 0; (void) yyparse(); if(lorange) *lorange = trnexpr_low; if(highrange) *highrange = trnexpr_high; if(flags) *flags = (trnexpr_aref) ? flag_AREF : 0; return(trnexpr_err); } #ifdef notdef mtg_info mtg = { 0, "/tmp/foo", "bar", "quux", 1, 30, 22, 23, 1 }; trn_info trn = { 0, 7, 6, 8, 5, 9, 2, 17, 3, 42, 7, 48, "Qux", "me" }; main(argc, argv) int argc; char **argv; { int low, high; argv++; argc--; while(argc--) { low = -1; high = -1; trnexpr_parse(&mtg, &trn, *argv, &low, &high); printf("%s: %d:%d\n", *argv, low, high); if(trnexpr_err) { printf("Error %d\n", trnexpr_err); trnexpr_err=0; } argv++; } } #endif notdef yytabelem yyexca[] ={ -1, 1, 0, -1, -2, 0, }; # define YYNPROD 21 # define YYLAST 48 yytabelem yyact[]={ 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 19, 21, 18, 19, 2, 18, 16, 17, 1, 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 22, 23, 24 }; yytabelem yypact[]={ -257, -1000, -20, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -244, -244, -244, -1000, -1000, -17, -1000, -1000 }; yytabelem yypgo[]={ 0, 31, 27, 30, 29 }; yytabelem yyr1[]={ 0, 1, 1, 1, 1, 1, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4, 4 }; yytabelem yyr2[]={ 0, 3, 7, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 7, 7 }; yytabelem yychk[]={ -1000, -1, -2, 267, 268, 269, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, -4, -3, 45, 43, 58, 44, -2, -2, -2 }; yytabelem yydef[]={ 0, -2, 1, 3, 4, 5, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 0, 0, 0, 6, 7, 2, 19, 20 }; typedef struct { char *t_name; int t_val; } yytoktype; #ifndef YYDEBUG # define YYDEBUG 0 /* don't allow debugging */ #endif #if YYDEBUG yytoktype yytoks[] = { "INTEGER", 257, "NREF", 258, "PREF", 259, "FIRST", 260, "LAST", 261, "NEXT", 262, "PREV", 263, "FREF", 264, "LREF", 265, "CUR", 266, "NEW", 267, "ALL", 268, "AREF", 269, "+", 43, "-", 45, "-unknown-", -1 /* ends search */ }; char * yyreds[] = { "-no such reduction-", "range : trn_no", "range : trn_no sep trn_no", "range : NEW", "range : ALL", "range : AREF", "sep : ':'", "sep : ','", "trn_no : INTEGER", "trn_no : NREF", "trn_no : PREF", "trn_no : FIRST", "trn_no : LAST", "trn_no : NEXT", "trn_no : PREV", "trn_no : FREF", "trn_no : LREF", "trn_no : CUR", "trn_no : expr", "expr : trn_no '-' trn_no", "expr : trn_no '+' trn_no", }; #endif /* YYDEBUG */ /* @(#)27 1.7.1.1 com/cmd/lang/yacc/yaccpar, cmdlang, bos320, 9209320f 2/19/92 16:36:02 */ /* * COMPONENT_NAME: (CMDLANG) Language Utilities * * FUNCTIONS: yyparse * ORIGINS: 03 */ /* ** Skeleton parser driver for yacc output */ /* ** yacc user known macros and defines */ #ifdef YYSPLIT # define YYERROR return(-2) #else # define YYERROR goto yyerrlab #endif #ifdef YACC_MSG #ifndef _XOPEN_SOURCE #define _XOPEN_SOURCE #endif #include nl_catd catd; #endif #define YYACCEPT return(0) #define YYABORT return(1) #ifndef YACC_MSG #define YYBACKUP( newtoken, newvalue )\ {\ if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\ {\ yyerror( "syntax error - cannot backup" );\ YYERROR;\ }\ yychar = newtoken;\ yystate = *yyps;\ yylval = newvalue;\ goto yynewstate;\ } #else #define YYBACKUP( newtoken, newvalue )\ {\ if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\ {\ catd=catopen("yacc_user.cat",0);\ yyerror(catgets(catd,1,1,"syntax error - cannot backup" ));\ YYERROR;\ }\ yychar = newtoken;\ yystate = *yyps;\ yylval = newvalue;\ goto yynewstate;\ } #endif #define YYRECOVERING() (!!yyerrflag) #ifndef YYDEBUG # define YYDEBUG 1 /* make debugging available */ #endif /* ** user known globals */ int yydebug; /* set to 1 to get debugging */ /* ** driver internal defines */ #define YYFLAG (-1000) #ifdef YYSPLIT # define YYSCODE { \ extern int (*_yyf[])(); \ register int yyret; \ if (_yyf[yytmp]) \ if ((yyret=(*_yyf[yytmp])()) == -2) \ goto yyerrlab; \ else if (yyret>=0) return(yyret); \ } #endif /* ** global variables used by the parser */ YYSTYPE yyv[ YYMAXDEPTH ]; /* value stack */ int yys[ YYMAXDEPTH ]; /* state stack */ YYSTYPE *yypv; /* top of value stack */ YYSTYPE *yypvt; /* top of value stack for $vars */ int *yyps; /* top of state stack */ int yystate; /* current state */ int yytmp; /* extra var (lasts between blocks) */ int yynerrs; /* number of errors */ int yyerrflag; /* error recovery flag */ int yychar; /* current input token number */ #ifdef __cplusplus #ifdef _CPP_IOSTREAMS #include extern void yyerror (char *); /* error message routine -- iostream version */ #else #include extern "C" void yyerror (char *); /* error message routine -- stdio version */ #endif /* _CPP_IOSTREAMS */ extern "C" int yylex(void); /* return the next token */ #endif /* __cplusplus */ /* ** yyparse - return 0 if worked, 1 if syntax error not recovered from */ #ifdef __cplusplus extern "C" #endif /* __cplusplus */ int yyparse() { /* ** Initialize externals - yyparse may be called more than once */ yypv = &yyv[-1]; yyps = &yys[-1]; yystate = 0; yytmp = 0; yynerrs = 0; yyerrflag = 0; yychar = -1; #ifdef YACC_MSG catd=catopen("yacc_user.cat",0); #endif goto yystack; { register YYSTYPE *yy_pv; /* top of value stack */ register int *yy_ps; /* top of state stack */ register int yy_state; /* current state */ register int yy_n; /* internal state number info */ /* ** get globals into registers. ** branch to here only if YYBACKUP was called. */ yynewstate: yy_pv = yypv; yy_ps = yyps; yy_state = yystate; goto yy_newstate; /* ** get globals into registers. ** either we just started, or we just finished a reduction */ yystack: yy_pv = yypv; yy_ps = yyps; yy_state = yystate; /* ** top of for (;;) loop while no reductions done */ yy_stack: /* ** put a state and value onto the stacks */ #if YYDEBUG /* ** if debugging, look up token value in list of value vs. ** name pairs. 0 and negative (-1) are special values. ** Note: linear search is used since time is not a real ** consideration while debugging. */ if ( yydebug ) { register int yy_i; #if defined(__cplusplus) && defined(_CPP_IOSTREAMS) cout << "State " << yy_state << " token "; if ( yychar == 0 ) cout << "end-of-file" << endl; else if ( yychar < 0 ) cout << "-none-" << endl; #else printf( "State %d, token ", yy_state ); if ( yychar == 0 ) printf( "end-of-file\n" ); else if ( yychar < 0 ) printf( "-none-\n" ); #endif /* defined(__cplusplus) && defined(_CPP_IOSTREAMS) */ else { for ( yy_i = 0; yytoks[yy_i].t_val >= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) break; } #if defined(__cplusplus) && defined(_CPP_IOSTREAMS) cout << yytoks[yy_i].t_name << endl; #else printf( "%s\n", yytoks[yy_i].t_name ); #endif /* defined(__cplusplus) && defined(_CPP_IOSTREAMS) */ } } #endif /* YYDEBUG */ if ( ++yy_ps >= &yys[ YYMAXDEPTH ] ) /* room on stack? */ { #ifndef YACC_MSG yyerror( "yacc stack overflow" ); #else yyerror(catgets(catd,1,2,"yacc stack overflow" )); #endif YYABORT; } *yy_ps = yy_state; *++yy_pv = yyval; /* ** we have a new state - find out what to do */ yy_newstate: if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG ) goto yydefault; /* simple state */ #if YYDEBUG /* ** if debugging, need to mark whether new token grabbed */ yytmp = yychar < 0; #endif if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) ) yychar = 0; /* reached EOF */ #if YYDEBUG if ( yydebug && yytmp ) { register int yy_i; #if defined(__cplusplus) && defined(_CPP_IOSTREAMS) cout << "Received token " << endl; if ( yychar == 0 ) cout << "end-of-file" << endl; else if ( yychar < 0 ) cout << "-none-" << endl; #else printf( "Received token " ); if ( yychar == 0 ) printf( "end-of-file\n" ); else if ( yychar < 0 ) printf( "-none-\n" ); #endif /* defined(__cplusplus) && defined(_CPP_IOSTREAMS) */ else { for ( yy_i = 0; yytoks[yy_i].t_val >= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) break; } #if defined(__cplusplus) && defined(_CPP_IOSTREAMS) cout << yytoks[yy_i].t_name << endl; #else printf( "%s\n", yytoks[yy_i].t_name ); #endif /* defined(__cplusplus) && defined(_CPP_IOSTREAMS) */ } } #endif /* YYDEBUG */ if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) ) goto yydefault; if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar ) /*valid shift*/ { yychar = -1; yyval = yylval; yy_state = yy_n; if ( yyerrflag > 0 ) yyerrflag--; goto yy_stack; } yydefault: if ( ( yy_n = yydef[ yy_state ] ) == -2 ) { #if YYDEBUG yytmp = yychar < 0; #endif if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) ) yychar = 0; /* reached EOF */ #if YYDEBUG if ( yydebug && yytmp ) { register int yy_i; #if defined(__cplusplus) && defined(_CPP_IOSTREAMS) cout << "Received token " << endl; if ( yychar == 0 ) cout << "end-of-file" << endl; else if ( yychar < 0 ) cout << "-none-" << endl; #else printf( "Received token " ); if ( yychar == 0 ) printf( "end-of-file\n" ); else if ( yychar < 0 ) printf( "-none-\n" ); #endif /* defined(__cplusplus) && defined(_CPP_IOSTREAMS) */ else { for ( yy_i = 0; yytoks[yy_i].t_val >= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) { break; } } #if defined(__cplusplus) && defined(_CPP_IOSTREAMS) cout << yytoks[yy_i].t_name << endl; #else printf( "%s\n", yytoks[yy_i].t_name ); #endif /* defined(__cplusplus) && defined(_CPP_IOSTREAMS) */ } } #endif /* YYDEBUG */ /* ** look through exception table */ { register int *yyxi = yyexca; while ( ( *yyxi != -1 ) || ( yyxi[1] != yy_state ) ) { yyxi += 2; } while ( ( *(yyxi += 2) >= 0 ) && ( *yyxi != yychar ) ) ; if ( ( yy_n = yyxi[1] ) < 0 ) YYACCEPT; } } /* ** check for syntax error */ if ( yy_n == 0 ) /* have an error */ { /* no worry about speed here! */ switch ( yyerrflag ) { case 0: /* new error */ #ifndef YACC_MSG yyerror( "syntax error" ); #else yyerror(catgets(catd,1,3,"syntax error" )); #endif goto skip_init; yyerrlab: /* ** get globals into registers. ** we have a user generated syntax type error */ yy_pv = yypv; yy_ps = yyps; yy_state = yystate; yynerrs++; skip_init: case 1: case 2: /* incompletely recovered error */ /* try again... */ yyerrflag = 3; /* ** find state where "error" is a legal ** shift action */ while ( yy_ps >= yys ) { yy_n = yypact[ *yy_ps ] + YYERRCODE; if ( yy_n >= 0 && yy_n < YYLAST && yychk[yyact[yy_n]] == YYERRCODE) { /* ** simulate shift of "error" */ yy_state = yyact[ yy_n ]; goto yy_stack; } /* ** current state has no shift on ** "error", pop stack */ #if YYDEBUG if ( yydebug ) #if defined(__cplusplus) && defined(_CPP_IOSTREAMS) cout << "Error recovery pops state " << (*yy_ps) << ", uncovers state " << yy_ps[-1] << endl; #else # define _POP_ "Error recovery pops state %d, uncovers state %d\n" printf( _POP_, *yy_ps, yy_ps[-1] ); # undef _POP_ #endif /* defined(__cplusplus) && defined(_CPP_IOSTREAMS) */ #endif yy_ps--; yy_pv--; } /* ** there is no state on stack with "error" as ** a valid shift. give up. */ YYABORT; case 3: /* no shift yet; eat a token */ #if YYDEBUG /* ** if debugging, look up token in list of ** pairs. 0 and negative shouldn't occur, ** but since timing doesn't matter when ** debugging, it doesn't hurt to leave the ** tests here. */ if ( yydebug ) { register int yy_i; #if defined(__cplusplus) && defined(_CPP_IOSTREAMS) cout << "Error recovery discards "; if ( yychar == 0 ) cout << "token end-of-file" << endl; else if ( yychar < 0 ) cout << "token -none-" << endl; #else printf( "Error recovery discards " ); if ( yychar == 0 ) printf( "token end-of-file\n" ); else if ( yychar < 0 ) printf( "token -none-\n" ); #endif /* defined(__cplusplus) && defined(_CPP_IOSTREAMS) */ else { for ( yy_i = 0; yytoks[yy_i].t_val >= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) { break; } } #if defined(__cplusplus) && defined(_CPP_IOSTREAMS) cout << "token " << yytoks[yy_i].t_name << endl; #else printf( "token %s\n", yytoks[yy_i].t_name ); #endif /* defined(__cplusplus) && defined(_CPP_IOSTREAMS) */ } } #endif /* YYDEBUG */ if ( yychar == 0 ) /* reached EOF. quit */ YYABORT; yychar = -1; goto yy_newstate; } }/* end if ( yy_n == 0 ) */ /* ** reduction by production yy_n ** put stack tops, etc. so things right after switch */ #if YYDEBUG /* ** if debugging, print the string that is the user's ** specification of the reduction which is just about ** to be done. */ if ( yydebug ) #if defined(__cplusplus) && defined(_CPP_IOSTREAMS) cout << "Reduce by (" << yy_n << ") \"" << yyreds[ yy_n ] << "\"\n"; #else printf( "Reduce by (%d) \"%s\"\n", yy_n, yyreds[ yy_n ] ); #endif /* defined(__cplusplus) && defined(_CPP_IOSTREAMS) */ #endif yytmp = yy_n; /* value to switch over */ yypvt = yy_pv; /* $vars top of value stack */ /* ** Look in goto table for next state ** Sorry about using yy_state here as temporary ** register variable, but why not, if it works... ** If yyr2[ yy_n ] doesn't have the low order bit ** set, then there is no action to be done for ** this reduction. So, no saving & unsaving of ** registers done. The only difference between the ** code just after the if and the body of the if is ** the goto yy_stack in the body. This way the test ** can be made before the choice of what to do is needed. */ { /* length of production doubled with extra bit */ register int yy_len = yyr2[ yy_n ]; if ( !( yy_len & 01 ) ) { yy_len >>= 1; yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + *( yy_ps -= yy_len ) + 1; if ( yy_state >= YYLAST || yychk[ yy_state = yyact[ yy_state ] ] != -yy_n ) { yy_state = yyact[ yypgo[ yy_n ] ]; } goto yy_stack; } yy_len >>= 1; yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + *( yy_ps -= yy_len ) + 1; if ( yy_state >= YYLAST || yychk[ yy_state = yyact[ yy_state ] ] != -yy_n ) { yy_state = yyact[ yypgo[ yy_n ] ]; } } /* save until reenter driver code */ yystate = yy_state; yyps = yy_ps; yypv = yy_pv; } /* ** code supplied by user is placed in this switch */ switch(yytmp){ case 1: # line 18 "trn_expr.y" { trnexpr_low = yypvt[-0]; trnexpr_high = yypvt[-0]; } /*NOTREACHED*/ break; case 2: # line 22 "trn_expr.y" { trnexpr_low = yypvt[-2]; trnexpr_high = yypvt[-0]; } /*NOTREACHED*/ break; case 3: # line 26 "trn_expr.y" { trnexpr_low = dsc_public.highest_seen+1; trnexpr_high = trnexpr_curmtg->last; } /*NOTREACHED*/ break; case 4: # line 30 "trn_expr.y" { trnexpr_low = trnexpr_curmtg->first; trnexpr_high = trnexpr_curmtg->last; } /*NOTREACHED*/ break; case 5: # line 34 "trn_expr.y" { trnexpr_low = trnexpr_curtrn->current; trnexpr_high = trnexpr_curtrn->current; trnexpr_aref = 1; } /*NOTREACHED*/ break; case 19: # line 58 "trn_expr.y" { yyval = yypvt[-2] - yypvt[-0]; } /*NOTREACHED*/ break; case 20: # line 60 "trn_expr.y" { yyval = yypvt[-2] + yypvt[-0]; } /*NOTREACHED*/ break; } goto yystack; /* reset registers in driver code */ }