mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
929 lines
22 KiB
929 lines
22 KiB
/*
|
|
* Created by CSD YACC (IBM PC) from "parse.y" */
|
|
# define CHAR 257
|
|
# define NUMBER 258
|
|
# define SECTEND 259
|
|
# define SCDECL 260
|
|
# define XSCDECL 261
|
|
# define WHITESPACE 262
|
|
# define NAME 263
|
|
# define PREVCCL 264
|
|
# define EOF_OP 265
|
|
|
|
#line 7 "parse.y"
|
|
/*-
|
|
* Copyright (c) 1990 The Regents of the University of California.
|
|
* All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to Berkeley by
|
|
* Vern Paxson.
|
|
*
|
|
* The United States Government has rights in this work pursuant
|
|
* to contract no. DE-AC03-76SF00098 between the United States
|
|
* Department of Energy and the University of California.
|
|
*
|
|
* Redistribution and use in source and binary forms are permitted provided
|
|
* that: (1) source distributions retain this entire copyright notice and
|
|
* comment, and (2) distributions including binaries display the following
|
|
* acknowledgement: ``This product includes software developed by the
|
|
* University of California, Berkeley and its contributors'' in the
|
|
* documentation or other materials provided with the distribution and in
|
|
* all advertising materials mentioning features or use of this software.
|
|
* Neither the name of the University nor the names of its contributors may
|
|
* be used to endorse or promote products derived from this software without
|
|
* specific prior written permission.
|
|
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
|
*/
|
|
|
|
#ifndef lint
|
|
static char rcsid[] =
|
|
"@(#) $Header: /usr/fsys/odin/a/vern/flex/RCS/parse.y,v 2.7 90/06/27 23:48:31 vern Exp $ (LBL)";
|
|
#endif
|
|
|
|
#include "flexdef.h"
|
|
|
|
int pat, scnum, eps, headcnt, trailcnt, anyccl, lastchar, i, actvp, rulelen;
|
|
int trlcontxt, xcluflg, cclsorted, varlength, variable_trail_rule;
|
|
Char clower();
|
|
|
|
static int madeany = false; /* whether we've made the '.' character class */
|
|
int previous_continued_action; /* whether the previous rule's action was '|' */
|
|
|
|
#define yyclearin yychar = -1
|
|
#define yyerrok yyerrflag = 0
|
|
#ifndef YYMAXDEPTH
|
|
#define YYMAXDEPTH 150
|
|
#endif
|
|
#ifndef YYSTYPE
|
|
#define YYSTYPE int
|
|
#endif
|
|
YYSTYPE yylval, yyval;
|
|
# define YYERRCODE 256
|
|
|
|
#line 627 "parse.y"
|
|
|
|
|
|
|
|
/* build_eof_action - build the "<<EOF>>" action for the active start
|
|
* conditions
|
|
*/
|
|
|
|
void build_eof_action()
|
|
|
|
{
|
|
register int i;
|
|
|
|
for ( i = 1; i <= actvp; ++i )
|
|
{
|
|
if ( sceof[actvsc[i]] )
|
|
format_pinpoint_message(
|
|
"multiple <<EOF>> rules for start condition %s",
|
|
scname[actvsc[i]] );
|
|
|
|
else
|
|
{
|
|
sceof[actvsc[i]] = true;
|
|
fprintf( temp_action_file, "case YY_STATE_EOF(%s):\n",
|
|
scname[actvsc[i]] );
|
|
}
|
|
}
|
|
|
|
line_directive_out( temp_action_file );
|
|
}
|
|
|
|
|
|
/* synerr - report a syntax error */
|
|
|
|
void synerr( str )
|
|
char str[];
|
|
|
|
{
|
|
syntaxerror = true;
|
|
pinpoint_message( str );
|
|
}
|
|
|
|
|
|
/* format_pinpoint_message - write out a message formatted with one string,
|
|
* pinpointing its location
|
|
*/
|
|
|
|
void format_pinpoint_message( msg, arg )
|
|
char msg[], arg[];
|
|
|
|
{
|
|
char errmsg[MAXLINE];
|
|
|
|
(void) sprintf( errmsg, msg, arg );
|
|
pinpoint_message( errmsg );
|
|
}
|
|
|
|
|
|
/* pinpoint_message - write out a message, pinpointing its location */
|
|
|
|
void pinpoint_message( str )
|
|
char str[];
|
|
|
|
{
|
|
fprintf( stderr, "\"%s\", line %d: %s\n", infilename, linenum, str );
|
|
}
|
|
|
|
|
|
/* yyerror - eat up an error message from the parser;
|
|
* currently, messages are ignore
|
|
*/
|
|
|
|
void yyerror( msg )
|
|
char msg[];
|
|
|
|
{
|
|
}
|
|
short yyexca[] ={
|
|
-1, 1,
|
|
0, -1,
|
|
-2, 0,
|
|
};
|
|
# define YYNPROD 54
|
|
# define YYLAST 258
|
|
short yyact[]={
|
|
|
|
31, 71, 31, 58, 31, 35, 32, 12, 32, 77,
|
|
32, 44, 28, 16, 28, 75, 28, 68, 43, 65,
|
|
15, 7, 8, 9, 64, 78, 23, 4, 72, 50,
|
|
51, 79, 46, 67, 62, 57, 27, 61, 56, 26,
|
|
37, 25, 74, 48, 10, 20, 54, 29, 24, 42,
|
|
52, 18, 17, 14, 6, 60, 13, 34, 11, 34,
|
|
19, 34, 38, 49, 39, 41, 45, 5, 3, 2,
|
|
1, 0, 0, 0, 55, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 59, 0, 0, 63, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 70, 0, 0, 0,
|
|
49, 0, 0, 0, 0, 0, 0, 0, 0, 73,
|
|
53, 0, 0, 0, 0, 0, 47, 0, 0, 0,
|
|
47, 0, 47, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 76, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 69,
|
|
0, 69, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 22, 33, 0, 33, 0, 33, 0, 0,
|
|
30, 21, 30, 40, 30, 0, 0, 0, 0, 0,
|
|
0, 0, 66, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 36 };
|
|
short yypact[]={
|
|
|
|
-1000,-1000,-229,-238, 34,-1000,-255,-1000,-1000,-1000,
|
|
-1000,-1000,-243, -34, -5,-1000,-1000, 30, -32, -30,
|
|
-1000,-1000,-1000,-245, -30, -4, -30, -13,-1000,-1000,
|
|
-1000,-1000, -30,-1000, -59,-1000,-260,-1000, -30,-1000,
|
|
-1000,-1000, -7,-1000,-1000, -2,-1000, -30,-1000, -13,
|
|
-1000,-1000,-1000,-234, -15, -8, -76,-1000,-1000,-1000,
|
|
-1000,-262,-1000, -30, -16,-1000,-1000,-1000,-1000, -3,
|
|
-78,-1000,-116,-1000,-232,-1000, -94,-1000,-1000,-1000 };
|
|
short yypgo[]={
|
|
|
|
0, 70, 69, 68, 67, 58, 56, 54, 53, 52,
|
|
51, 45, 49, 48, 41, 39, 36, 47, 46, 38 };
|
|
short yyr1[]={
|
|
|
|
0, 1, 2, 3, 3, 3, 4, 7, 7, 8,
|
|
8, 8, 5, 5, 6, 9, 9, 9, 9, 9,
|
|
9, 9, 10, 12, 12, 12, 11, 11, 11, 11,
|
|
14, 14, 13, 15, 15, 16, 16, 16, 16, 16,
|
|
16, 16, 16, 16, 16, 16, 16, 17, 17, 19,
|
|
19, 19, 18, 18 };
|
|
short yyr2[]={
|
|
|
|
0, 5, 0, 5, 0, 2, 1, 1, 1, 3,
|
|
1, 1, 4, 0, 0, 3, 2, 2, 1, 2,
|
|
1, 1, 3, 3, 1, 1, 2, 3, 2, 1,
|
|
3, 1, 2, 2, 1, 2, 2, 2, 6, 5,
|
|
4, 1, 1, 1, 3, 3, 1, 3, 4, 4,
|
|
2, 0, 2, 0 };
|
|
short yychk[]={
|
|
|
|
-1000, -1, -2, -3, 256, -4, -7, 259, 260, 261,
|
|
10, -5, 262, -6, -8, 263, 256, -9, -10, 94,
|
|
-11, 265, 256, 60, -13, -14, -15, -16, 46, -17,
|
|
264, 34, 40, 257, 91, 10, 262, 10, 94, -11,
|
|
265, -11, -12, 263, 256, -14, 36, 124, 47, -16,
|
|
42, 43, 63, 123, -18, -14, -19, 94, 263, -11,
|
|
62, 44, 36, -15, 258, 34, 257, 41, 93, 257,
|
|
-19, 263, 44, 125, 45, 93, 258, 125, 257, 125 };
|
|
short yydef[]={
|
|
|
|
2, -2, 4, 0, 0, 13, 0, 6, 7, 8,
|
|
5, 14, 0, 1, 0, 10, 11, 0, 0, 0,
|
|
18, 20, 21, 0, 0, 29, 31, 34, 41, 42,
|
|
43, 53, 0, 46, 51, 3, 0, 12, 0, 16,
|
|
19, 17, 0, 24, 25, 26, 28, 0, 32, 33,
|
|
35, 36, 37, 0, 0, 0, 0, 51, 9, 15,
|
|
22, 0, 27, 30, 0, 44, 52, 45, 47, 50,
|
|
0, 23, 0, 40, 0, 48, 0, 39, 49, 38 };
|
|
# define YYFLAG -1000
|
|
# define YYERROR goto yyerrlab
|
|
# define YYACCEPT return(0)
|
|
# define YYABORT return(1)
|
|
|
|
#ifdef YYDEBUG /* RRR - 10/9/85 */
|
|
#define yyprintf(a, b, c) printf(a, b, c)
|
|
#else
|
|
#define yyprintf(a, b, c)
|
|
#endif
|
|
|
|
/* parser for yacc output */
|
|
|
|
YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
|
|
int yychar = -1; /* current input token number */
|
|
int yynerrs = 0; /* number of errors */
|
|
short yyerrflag = 0; /* error recovery flag */
|
|
|
|
yyparse()
|
|
{
|
|
|
|
short yys[YYMAXDEPTH];
|
|
short yyj, yym;
|
|
register YYSTYPE *yypvt;
|
|
register short yystate, *yyps, yyn;
|
|
register YYSTYPE *yypv;
|
|
register short *yyxi;
|
|
|
|
yystate = 0;
|
|
yychar = -1;
|
|
yynerrs = 0;
|
|
yyerrflag = 0;
|
|
yyps= &yys[-1];
|
|
yypv= &yyv[-1];
|
|
|
|
yystack: /* put a state and value onto the stack */
|
|
|
|
yyprintf( "state %d, char 0%o\n", yystate, yychar );
|
|
if( ++yyps> &yys[YYMAXDEPTH] )
|
|
{
|
|
yyerror( "yacc stack overflow" );
|
|
return(1);
|
|
}
|
|
*yyps = yystate;
|
|
++yypv;
|
|
*yypv = yyval;
|
|
yynewstate:
|
|
|
|
yyn = yypact[yystate];
|
|
|
|
if( yyn<= YYFLAG ) goto yydefault; /* simple state */
|
|
|
|
if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
|
|
if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;
|
|
|
|
if( yychk[ yyn=yyact[ yyn ] ] == yychar )
|
|
{
|
|
/* valid shift */
|
|
yychar = -1;
|
|
yyval = yylval;
|
|
yystate = yyn;
|
|
if( yyerrflag > 0 ) --yyerrflag;
|
|
goto yystack;
|
|
}
|
|
yydefault:
|
|
/* default state action */
|
|
|
|
if( (yyn=yydef[yystate]) == -2 )
|
|
{
|
|
if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
|
|
/* look through exception table */
|
|
|
|
for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */
|
|
|
|
for(yyxi+=2; *yyxi >= 0; yyxi+=2)
|
|
{
|
|
if( *yyxi == yychar ) break;
|
|
}
|
|
if( (yyn = yyxi[1]) < 0 ) return(0); /* accept */
|
|
}
|
|
|
|
if( yyn == 0 )
|
|
{
|
|
/* error */
|
|
/* error ... attempt to resume parsing */
|
|
|
|
switch( yyerrflag )
|
|
{
|
|
|
|
case 0: /* brand new error */
|
|
|
|
yyerror( "syntax error" );
|
|
yyerrlab:
|
|
++yynerrs;
|
|
|
|
case 1:
|
|
case 2: /* incompletely recovered error ... try again */
|
|
|
|
yyerrflag = 3;
|
|
|
|
/* find a state where "error" is a legal shift action */
|
|
|
|
while ( yyps >= yys )
|
|
{
|
|
yyn = yypact[*yyps] + YYERRCODE;
|
|
if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE )
|
|
{
|
|
yystate = yyact[yyn]; /* simulate a shift of "error" */
|
|
goto yystack;
|
|
}
|
|
yyn = yypact[*yyps];
|
|
|
|
/* the current yyps has no shift onn "error", pop stack */
|
|
|
|
yyprintf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
|
|
--yyps;
|
|
--yypv;
|
|
}
|
|
|
|
/* there is no state on the stack with an error shift ... abort */
|
|
|
|
yyabort:
|
|
return(1);
|
|
|
|
|
|
case 3: /* no shift yet; clobber input char */
|
|
yyprintf( "error recovery discards char %d\n", yychar, 0 );
|
|
|
|
if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
|
|
yychar = -1;
|
|
goto yynewstate; /* try again in the same state */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* reduction by production yyn */
|
|
|
|
yyprintf("reduce %d\n",yyn, 0);
|
|
yyps -= yyr2[yyn];
|
|
yypvt = yypv;
|
|
yypv -= yyr2[yyn];
|
|
yyval = yypv[1];
|
|
yym=yyn;
|
|
/* consult goto table to find next state */
|
|
yyn = yyr1[yyn];
|
|
yyj = yypgo[yyn] + *yyps + 1;
|
|
if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
|
|
switch(yym)
|
|
{
|
|
|
|
case 1:
|
|
#line 51 "parse.y"
|
|
{ /* add default rule */
|
|
int def_rule;
|
|
|
|
pat = cclinit();
|
|
cclnegate( pat );
|
|
|
|
def_rule = mkstate( -pat );
|
|
|
|
finish_rule( def_rule, false, 0, 0 );
|
|
|
|
for ( i = 1; i <= lastsc; ++i )
|
|
scset[i] = mkbranch( scset[i], def_rule );
|
|
|
|
if ( spprdflt )
|
|
fputs( "YY_FATAL_ERROR( \"flex scanner jammed\" )",
|
|
temp_action_file );
|
|
else
|
|
fputs( "ECHO", temp_action_file );
|
|
|
|
fputs( ";\n\tYY_BREAK\n", temp_action_file );
|
|
} break;
|
|
case 2:
|
|
#line 75 "parse.y"
|
|
{
|
|
/* initialize for processing rules */
|
|
|
|
/* create default DFA start condition */
|
|
scinstal( "INITIAL", false );
|
|
} break;
|
|
case 5:
|
|
#line 86 "parse.y"
|
|
{ synerr( "unknown error processing section 1" ); } break;
|
|
case 7:
|
|
#line 93 "parse.y"
|
|
{
|
|
/* these productions are separate from the s1object
|
|
* rule because the semantics must be done before
|
|
* we parse the remainder of an s1object
|
|
*/
|
|
|
|
xcluflg = false;
|
|
} break;
|
|
case 8:
|
|
#line 103 "parse.y"
|
|
{ xcluflg = true; } break;
|
|
case 9:
|
|
#line 107 "parse.y"
|
|
{ scinstal( nmstr, xcluflg ); } break;
|
|
case 10:
|
|
#line 110 "parse.y"
|
|
{ scinstal( nmstr, xcluflg ); } break;
|
|
case 11:
|
|
#line 113 "parse.y"
|
|
{ synerr( "bad start condition list" ); } break;
|
|
case 14:
|
|
#line 121 "parse.y"
|
|
{
|
|
/* initialize for a parse of one rule */
|
|
trlcontxt = variable_trail_rule = varlength = false;
|
|
trailcnt = headcnt = rulelen = 0;
|
|
current_state_type = STATE_NORMAL;
|
|
previous_continued_action = continued_action;
|
|
new_rule();
|
|
} break;
|
|
case 15:
|
|
#line 132 "parse.y"
|
|
{
|
|
pat = yypvt[-0];
|
|
finish_rule( pat, variable_trail_rule,
|
|
headcnt, trailcnt );
|
|
|
|
for ( i = 1; i <= actvp; ++i )
|
|
scbol[actvsc[i]] =
|
|
mkbranch( scbol[actvsc[i]], pat );
|
|
|
|
if ( ! bol_needed )
|
|
{
|
|
bol_needed = true;
|
|
|
|
if ( performance_report )
|
|
pinpoint_message(
|
|
"'^' operator results in sub-optimal performance" );
|
|
}
|
|
} break;
|
|
case 16:
|
|
#line 152 "parse.y"
|
|
{
|
|
pat = yypvt[-0];
|
|
finish_rule( pat, variable_trail_rule,
|
|
headcnt, trailcnt );
|
|
|
|
for ( i = 1; i <= actvp; ++i )
|
|
scset[actvsc[i]] =
|
|
mkbranch( scset[actvsc[i]], pat );
|
|
} break;
|
|
case 17:
|
|
#line 163 "parse.y"
|
|
{
|
|
pat = yypvt[-0];
|
|
finish_rule( pat, variable_trail_rule,
|
|
headcnt, trailcnt );
|
|
|
|
/* add to all non-exclusive start conditions,
|
|
* including the default (0) start condition
|
|
*/
|
|
|
|
for ( i = 1; i <= lastsc; ++i )
|
|
if ( ! scxclu[i] )
|
|
scbol[i] = mkbranch( scbol[i], pat );
|
|
|
|
if ( ! bol_needed )
|
|
{
|
|
bol_needed = true;
|
|
|
|
if ( performance_report )
|
|
pinpoint_message(
|
|
"'^' operator results in sub-optimal performance" );
|
|
}
|
|
} break;
|
|
case 18:
|
|
#line 187 "parse.y"
|
|
{
|
|
pat = yypvt[-0];
|
|
finish_rule( pat, variable_trail_rule,
|
|
headcnt, trailcnt );
|
|
|
|
for ( i = 1; i <= lastsc; ++i )
|
|
if ( ! scxclu[i] )
|
|
scset[i] = mkbranch( scset[i], pat );
|
|
} break;
|
|
case 19:
|
|
#line 198 "parse.y"
|
|
{ build_eof_action(); } break;
|
|
case 20:
|
|
#line 201 "parse.y"
|
|
{
|
|
/* this EOF applies to all start conditions
|
|
* which don't already have EOF actions
|
|
*/
|
|
actvp = 0;
|
|
|
|
for ( i = 1; i <= lastsc; ++i )
|
|
if ( ! sceof[i] )
|
|
actvsc[++actvp] = i;
|
|
|
|
if ( actvp == 0 )
|
|
pinpoint_message(
|
|
"warning - all start conditions already have <<EOF>> rules" );
|
|
|
|
else
|
|
build_eof_action();
|
|
} break;
|
|
case 21:
|
|
#line 220 "parse.y"
|
|
{ synerr( "unrecognized rule" ); } break;
|
|
case 23:
|
|
#line 227 "parse.y"
|
|
{
|
|
if ( (scnum = sclookup( nmstr )) == 0 )
|
|
format_pinpoint_message(
|
|
"undeclared start condition %s", nmstr );
|
|
|
|
else
|
|
actvsc[++actvp] = scnum;
|
|
} break;
|
|
case 24:
|
|
#line 237 "parse.y"
|
|
{
|
|
if ( (scnum = sclookup( nmstr )) == 0 )
|
|
format_pinpoint_message(
|
|
"undeclared start condition %s", nmstr );
|
|
else
|
|
actvsc[actvp = 1] = scnum;
|
|
} break;
|
|
case 25:
|
|
#line 246 "parse.y"
|
|
{ synerr( "bad start condition list" ); } break;
|
|
case 26:
|
|
#line 250 "parse.y"
|
|
{
|
|
if ( transchar[lastst[yypvt[-0]]] != SYM_EPSILON )
|
|
/* provide final transition \now/ so it
|
|
* will be marked as a trailing context
|
|
* state
|
|
*/
|
|
yypvt[-0] = link_machines( yypvt[-0], mkstate( SYM_EPSILON ) );
|
|
|
|
mark_beginning_as_normal( yypvt[-0] );
|
|
current_state_type = STATE_NORMAL;
|
|
|
|
if ( previous_continued_action )
|
|
{
|
|
/* we need to treat this as variable trailing
|
|
* context so that the backup does not happen
|
|
* in the action but before the action switch
|
|
* statement. If the backup happens in the
|
|
* action, then the rules "falling into" this
|
|
* one's action will *also* do the backup,
|
|
* erroneously.
|
|
*/
|
|
if ( ! varlength || headcnt != 0 )
|
|
{
|
|
fprintf( stderr,
|
|
"%s: warning - trailing context rule at line %d made variable because\n",
|
|
program_name, linenum );
|
|
fprintf( stderr,
|
|
" of preceding '|' action\n" );
|
|
}
|
|
|
|
/* mark as variable */
|
|
varlength = true;
|
|
headcnt = 0;
|
|
}
|
|
|
|
if ( varlength && headcnt == 0 )
|
|
{ /* variable trailing context rule */
|
|
/* mark the first part of the rule as the accepting
|
|
* "head" part of a trailing context rule
|
|
*/
|
|
/* by the way, we didn't do this at the beginning
|
|
* of this production because back then
|
|
* current_state_type was set up for a trail
|
|
* rule, and add_accept() can create a new
|
|
* state ...
|
|
*/
|
|
add_accept( yypvt[-1], num_rules | YY_TRAILING_HEAD_MASK );
|
|
variable_trail_rule = true;
|
|
}
|
|
|
|
else
|
|
trailcnt = rulelen;
|
|
|
|
yyval = link_machines( yypvt[-1], yypvt[-0] );
|
|
} break;
|
|
case 27:
|
|
#line 307 "parse.y"
|
|
{ synerr( "trailing context used twice" ); } break;
|
|
case 28:
|
|
#line 310 "parse.y"
|
|
{
|
|
if ( trlcontxt )
|
|
{
|
|
synerr( "trailing context used twice" );
|
|
yyval = mkstate( SYM_EPSILON );
|
|
}
|
|
|
|
else if ( previous_continued_action )
|
|
{
|
|
/* see the comment in the rule for "re2 re"
|
|
* above
|
|
*/
|
|
if ( ! varlength || headcnt != 0 )
|
|
{
|
|
fprintf( stderr,
|
|
"%s: warning - trailing context rule at line %d made variable because\n",
|
|
program_name, linenum );
|
|
fprintf( stderr,
|
|
" of preceding '|' action\n" );
|
|
}
|
|
|
|
/* mark as variable */
|
|
varlength = true;
|
|
headcnt = 0;
|
|
}
|
|
|
|
trlcontxt = true;
|
|
|
|
if ( ! varlength )
|
|
headcnt = rulelen;
|
|
|
|
++rulelen;
|
|
trailcnt = 1;
|
|
|
|
eps = mkstate( SYM_EPSILON );
|
|
yyval = link_machines( yypvt[-1],
|
|
link_machines( eps, mkstate( '\n' ) ) );
|
|
} break;
|
|
case 29:
|
|
#line 350 "parse.y"
|
|
{
|
|
yyval = yypvt[-0];
|
|
|
|
if ( trlcontxt )
|
|
{
|
|
if ( varlength && headcnt == 0 )
|
|
/* both head and trail are variable-length */
|
|
variable_trail_rule = true;
|
|
else
|
|
trailcnt = rulelen;
|
|
}
|
|
} break;
|
|
case 30:
|
|
#line 366 "parse.y"
|
|
{
|
|
varlength = true;
|
|
yyval = mkor( yypvt[-2], yypvt[-0] );
|
|
} break;
|
|
case 31:
|
|
#line 372 "parse.y"
|
|
{ yyval = yypvt[-0]; } break;
|
|
case 32:
|
|
#line 377 "parse.y"
|
|
{
|
|
/* this rule is written separately so
|
|
* the reduction will occur before the trailing
|
|
* series is parsed
|
|
*/
|
|
|
|
if ( trlcontxt )
|
|
synerr( "trailing context used twice" );
|
|
else
|
|
trlcontxt = true;
|
|
|
|
if ( varlength )
|
|
/* we hope the trailing context is fixed-length */
|
|
varlength = false;
|
|
else
|
|
headcnt = rulelen;
|
|
|
|
rulelen = 0;
|
|
|
|
current_state_type = STATE_TRAILING_CONTEXT;
|
|
yyval = yypvt[-1];
|
|
} break;
|
|
case 33:
|
|
#line 402 "parse.y"
|
|
{
|
|
/* this is where concatenation of adjacent patterns
|
|
* gets done
|
|
*/
|
|
yyval = link_machines( yypvt[-1], yypvt[-0] );
|
|
} break;
|
|
case 34:
|
|
#line 410 "parse.y"
|
|
{ yyval = yypvt[-0]; } break;
|
|
case 35:
|
|
#line 414 "parse.y"
|
|
{
|
|
varlength = true;
|
|
|
|
yyval = mkclos( yypvt[-1] );
|
|
} break;
|
|
case 36:
|
|
#line 421 "parse.y"
|
|
{
|
|
varlength = true;
|
|
|
|
yyval = mkposcl( yypvt[-1] );
|
|
} break;
|
|
case 37:
|
|
#line 428 "parse.y"
|
|
{
|
|
varlength = true;
|
|
|
|
yyval = mkopt( yypvt[-1] );
|
|
} break;
|
|
case 38:
|
|
#line 435 "parse.y"
|
|
{
|
|
varlength = true;
|
|
|
|
if ( yypvt[-3] > yypvt[-1] || yypvt[-3] < 0 )
|
|
{
|
|
synerr( "bad iteration values" );
|
|
yyval = yypvt[-5];
|
|
}
|
|
else
|
|
{
|
|
if ( yypvt[-3] == 0 )
|
|
yyval = mkopt( mkrep( yypvt[-5], yypvt[-3], yypvt[-1] ) );
|
|
else
|
|
yyval = mkrep( yypvt[-5], yypvt[-3], yypvt[-1] );
|
|
}
|
|
} break;
|
|
case 39:
|
|
#line 453 "parse.y"
|
|
{
|
|
varlength = true;
|
|
|
|
if ( yypvt[-2] <= 0 )
|
|
{
|
|
synerr( "iteration value must be positive" );
|
|
yyval = yypvt[-4];
|
|
}
|
|
|
|
else
|
|
yyval = mkrep( yypvt[-4], yypvt[-2], INFINITY );
|
|
} break;
|
|
case 40:
|
|
#line 467 "parse.y"
|
|
{
|
|
/* the singleton could be something like "(foo)",
|
|
* in which case we have no idea what its length
|
|
* is, so we punt here.
|
|
*/
|
|
varlength = true;
|
|
|
|
if ( yypvt[-1] <= 0 )
|
|
{
|
|
synerr( "iteration value must be positive" );
|
|
yyval = yypvt[-3];
|
|
}
|
|
|
|
else
|
|
yyval = link_machines( yypvt[-3], copysingl( yypvt[-3], yypvt[-1] - 1 ) );
|
|
} break;
|
|
case 41:
|
|
#line 485 "parse.y"
|
|
{
|
|
if ( ! madeany )
|
|
{
|
|
/* create the '.' character class */
|
|
anyccl = cclinit();
|
|
ccladd( anyccl, '\n' );
|
|
cclnegate( anyccl );
|
|
|
|
if ( useecs )
|
|
mkeccl( ccltbl + cclmap[anyccl],
|
|
ccllen[anyccl], nextecm,
|
|
ecgroup, csize, csize );
|
|
|
|
madeany = true;
|
|
}
|
|
|
|
++rulelen;
|
|
|
|
yyval = mkstate( -anyccl );
|
|
} break;
|
|
case 42:
|
|
#line 507 "parse.y"
|
|
{
|
|
if ( ! cclsorted )
|
|
/* sort characters for fast searching. We use a
|
|
* shell sort since this list could be large.
|
|
*/
|
|
cshell( ccltbl + cclmap[yypvt[-0]], ccllen[yypvt[-0]], true );
|
|
|
|
if ( useecs )
|
|
mkeccl( ccltbl + cclmap[yypvt[-0]], ccllen[yypvt[-0]],
|
|
nextecm, ecgroup, csize, csize );
|
|
|
|
++rulelen;
|
|
|
|
yyval = mkstate( -yypvt[-0] );
|
|
} break;
|
|
case 43:
|
|
#line 524 "parse.y"
|
|
{
|
|
++rulelen;
|
|
|
|
yyval = mkstate( -yypvt[-0] );
|
|
} break;
|
|
case 44:
|
|
#line 531 "parse.y"
|
|
{ yyval = yypvt[-1]; } break;
|
|
case 45:
|
|
#line 534 "parse.y"
|
|
{ yyval = yypvt[-1]; } break;
|
|
case 46:
|
|
#line 537 "parse.y"
|
|
{
|
|
++rulelen;
|
|
|
|
if ( caseins && yypvt[-0] >= 'A' && yypvt[-0] <= 'Z' )
|
|
yypvt[-0] = clower( yypvt[-0] );
|
|
|
|
yyval = mkstate( yypvt[-0] );
|
|
} break;
|
|
case 47:
|
|
#line 548 "parse.y"
|
|
{ yyval = yypvt[-1]; } break;
|
|
case 48:
|
|
#line 551 "parse.y"
|
|
{
|
|
/* *Sigh* - to be compatible Unix lex, negated ccls
|
|
* match newlines
|
|
*/
|
|
#ifdef NOTDEF
|
|
ccladd( yypvt[-1], '\n' ); /* negated ccls don't match '\n' */
|
|
cclsorted = false; /* because we added the newline */
|
|
#endif
|
|
cclnegate( yypvt[-1] );
|
|
yyval = yypvt[-1];
|
|
} break;
|
|
case 49:
|
|
#line 565 "parse.y"
|
|
{
|
|
if ( yypvt[-2] > yypvt[-0] )
|
|
synerr( "negative range in character class" );
|
|
|
|
else
|
|
{
|
|
if ( caseins )
|
|
{
|
|
if ( yypvt[-2] >= 'A' && yypvt[-2] <= 'Z' )
|
|
yypvt[-2] = clower( yypvt[-2] );
|
|
if ( yypvt[-0] >= 'A' && yypvt[-0] <= 'Z' )
|
|
yypvt[-0] = clower( yypvt[-0] );
|
|
}
|
|
|
|
for ( i = yypvt[-2]; i <= yypvt[-0]; ++i )
|
|
ccladd( yypvt[-3], i );
|
|
|
|
/* keep track if this ccl is staying in alphabetical
|
|
* order
|
|
*/
|
|
cclsorted = cclsorted && (yypvt[-2] > lastchar);
|
|
lastchar = yypvt[-0];
|
|
}
|
|
|
|
yyval = yypvt[-3];
|
|
} break;
|
|
case 50:
|
|
#line 593 "parse.y"
|
|
{
|
|
if ( caseins )
|
|
if ( yypvt[-0] >= 'A' && yypvt[-0] <= 'Z' )
|
|
yypvt[-0] = clower( yypvt[-0] );
|
|
|
|
ccladd( yypvt[-1], yypvt[-0] );
|
|
cclsorted = cclsorted && (yypvt[-0] > lastchar);
|
|
lastchar = yypvt[-0];
|
|
yyval = yypvt[-1];
|
|
} break;
|
|
case 51:
|
|
#line 605 "parse.y"
|
|
{
|
|
cclsorted = true;
|
|
lastchar = 0;
|
|
yyval = cclinit();
|
|
} break;
|
|
case 52:
|
|
#line 613 "parse.y"
|
|
{
|
|
if ( caseins )
|
|
if ( yypvt[-0] >= 'A' && yypvt[-0] <= 'Z' )
|
|
yypvt[-0] = clower( yypvt[-0] );
|
|
|
|
++rulelen;
|
|
|
|
yyval = link_machines( yypvt[-1], mkstate( yypvt[-0] ) );
|
|
} break;
|
|
case 53:
|
|
#line 624 "parse.y"
|
|
{ yyval = mkstate( SYM_EPSILON ); } break;/* End of actions */
|
|
}
|
|
goto yystack; /* stack new state and value */
|
|
|
|
}
|
|
|