517 lines
11 KiB
Plaintext
517 lines
11 KiB
Plaintext
/*
|
|
* Copyright 1987 Silicon Graphics, Inc. - All Rights Reserved
|
|
*/
|
|
|
|
/* #ident "@(#)yacc:yaccpar 1.10" */
|
|
#ident "$Revision: 1.11 $"
|
|
|
|
/*
|
|
** Skeleton parser driver for yacc output
|
|
*/
|
|
#include "stddef.h"
|
|
|
|
/*
|
|
** yacc user known macros and defines
|
|
*/
|
|
#define YYERROR goto yyerrlab
|
|
#define YYACCEPT return(0)
|
|
#define YYABORT return(1)
|
|
#ifdef __cplusplus
|
|
#define YYBACKUP( newtoken, newvalue )\
|
|
{\
|
|
if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\
|
|
{\
|
|
yyerror( gettxt("uxlibc:78", "syntax error - cannot backup") );\
|
|
goto yyerrlab;\
|
|
}\
|
|
yychar = newtoken;\
|
|
yystate = *yyps;\
|
|
yylval = newvalue;\
|
|
goto yynewstate;\
|
|
}
|
|
#else
|
|
#define YYBACKUP( newtoken, newvalue )\
|
|
{\
|
|
if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\
|
|
{\
|
|
yyerror( gettxt("uxlibc:78", "Syntax error - cannot backup") );\
|
|
goto yyerrlab;\
|
|
}\
|
|
yychar = newtoken;\
|
|
yystate = *yyps;\
|
|
yylval = newvalue;\
|
|
goto yynewstate;\
|
|
}
|
|
#endif
|
|
#define YYRECOVERING() (!!yyerrflag)
|
|
#define YYNEW(type) malloc((size_t)(sizeof(type) * yynewmax))
|
|
#define YYCOPY(to, from, type) \
|
|
(type *) memcpy(to, (char *) from, (size_t)(yynewmax * sizeof(type)))
|
|
#define YYENLARGE( from, type) \
|
|
(type *) realloc((char *) from, (size_t)(yynewmax * sizeof(type)))
|
|
#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 (-10000000)
|
|
|
|
/*
|
|
** global variables used by the parser
|
|
*/
|
|
YYSTYPE *yypv; /* top of value stack */
|
|
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 */
|
|
|
|
|
|
|
|
/*
|
|
** yyparse - return 0 if worked, 1 if syntax error not recovered from
|
|
*/
|
|
#if defined(__STDC__) || defined(__cplusplus)
|
|
int yyparse(void)
|
|
#else
|
|
int yyparse()
|
|
#endif
|
|
{
|
|
register YYSTYPE *yypvt; /* top of value stack for $vars */
|
|
|
|
/*
|
|
** 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;
|
|
|
|
#if YYMAXDEPTH <= 0
|
|
if (yymaxdepth <= 0)
|
|
{
|
|
if ((yymaxdepth = YYEXPAND(0)) <= 0)
|
|
{
|
|
#ifdef __cplusplus
|
|
yyerror(gettxt("uxlibc:79", "yacc initialization error"));
|
|
#else
|
|
yyerror(gettxt("uxlibc:79", "Yacc initialization error"));
|
|
#endif
|
|
YYABORT;
|
|
}
|
|
}
|
|
#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;
|
|
|
|
printf( "State %d, token ", yy_state );
|
|
if ( yychar == 0 )
|
|
printf( "end-of-file\n" );
|
|
else if ( yychar < 0 )
|
|
printf( "-none-\n" );
|
|
else
|
|
{
|
|
for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
|
|
yy_i++ )
|
|
{
|
|
if ( yytoks[yy_i].t_val == yychar )
|
|
break;
|
|
}
|
|
printf( "%s\n", yytoks[yy_i].t_name );
|
|
}
|
|
}
|
|
#endif /* YYDEBUG */
|
|
if ( ++yy_ps >= &yys[ yymaxdepth ] ) /* room on stack? */
|
|
{
|
|
int yynewmax;
|
|
ptrdiff_t yys_off;
|
|
|
|
/* The following pointer-differences are safe, since
|
|
* yypvt, yy_pv, and yypv all are a multiple of
|
|
* sizeof(YYSTYPE) bytes from yyv.
|
|
*/
|
|
ptrdiff_t yypvt_off = yypvt - yyv;
|
|
ptrdiff_t yy_pv_off = yy_pv - yyv;
|
|
ptrdiff_t yypv_off = yypv - yyv;
|
|
|
|
int *yys_base = yys;
|
|
#ifdef YYEXPAND
|
|
yynewmax = YYEXPAND(yymaxdepth);
|
|
#else
|
|
yynewmax = 2 * yymaxdepth; /* double table size */
|
|
if (yymaxdepth == YYMAXDEPTH) /* first time growth */
|
|
{
|
|
void *newyys = YYNEW(int);
|
|
void *newyyv = YYNEW(YYSTYPE);
|
|
if (newyys != 0 && newyyv != 0)
|
|
{
|
|
yys = YYCOPY(newyys, yys, int);
|
|
yyv = YYCOPY(newyyv, yyv, YYSTYPE);
|
|
}
|
|
else
|
|
yynewmax = 0; /* failed */
|
|
}
|
|
else /* not first time */
|
|
{
|
|
yys = YYENLARGE(yys, int);
|
|
yyv = YYENLARGE(yyv, YYSTYPE);
|
|
if (yys == 0 || yyv == 0)
|
|
yynewmax = 0; /* failed */
|
|
}
|
|
#endif
|
|
if (yynewmax <= yymaxdepth) /* tables not expanded */
|
|
{
|
|
#ifdef __cplusplus
|
|
yyerror( gettxt("uxlibc:80", "yacc stack overflow") );
|
|
#else
|
|
yyerror( gettxt("uxlibc:80", "Yacc stack overflow") );
|
|
#endif
|
|
YYABORT;
|
|
}
|
|
yymaxdepth = yynewmax;
|
|
|
|
/* reset pointers into yys */
|
|
yys_off = yys - yys_base;
|
|
yy_ps = yy_ps + yys_off;
|
|
yyps = yyps + yys_off;
|
|
|
|
/* reset pointers into yyv */
|
|
yypvt = yyv + yypvt_off;
|
|
yy_pv = yyv + yy_pv_off;
|
|
yypv = yyv + yypv_off;
|
|
}
|
|
*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;
|
|
|
|
printf( "Received token " );
|
|
if ( yychar == 0 )
|
|
printf( "end-of-file\n" );
|
|
else if ( yychar < 0 )
|
|
printf( "-none-\n" );
|
|
else
|
|
{
|
|
for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
|
|
yy_i++ )
|
|
{
|
|
if ( yytoks[yy_i].t_val == yychar )
|
|
break;
|
|
}
|
|
printf( "%s\n", yytoks[yy_i].t_name );
|
|
}
|
|
}
|
|
#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;
|
|
|
|
printf( "Received token " );
|
|
if ( yychar == 0 )
|
|
printf( "end-of-file\n" );
|
|
else if ( yychar < 0 )
|
|
printf( "-none-\n" );
|
|
else
|
|
{
|
|
for ( yy_i = 0;
|
|
yytoks[yy_i].t_val >= 0;
|
|
yy_i++ )
|
|
{
|
|
if ( yytoks[yy_i].t_val
|
|
== yychar )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
printf( "%s\n", yytoks[yy_i].t_name );
|
|
}
|
|
}
|
|
#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 */
|
|
#ifdef __cplusplus
|
|
yyerror( gettxt("uxlibc:81", "syntax error") );
|
|
#else
|
|
yyerror( gettxt("uxlibc:81", "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++;
|
|
/* FALLTHRU */
|
|
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
|
|
# define _POP_ "Error recovery pops state %d, uncovers state %d\n"
|
|
if ( yydebug )
|
|
printf( _POP_, *yy_ps,
|
|
yy_ps[-1] );
|
|
# undef _POP_
|
|
#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;
|
|
|
|
printf( "Error recovery discards " );
|
|
if ( yychar == 0 )
|
|
printf( "token end-of-file\n" );
|
|
else if ( yychar < 0 )
|
|
printf( "token -none-\n" );
|
|
else
|
|
{
|
|
for ( yy_i = 0;
|
|
yytoks[yy_i].t_val >= 0;
|
|
yy_i++ )
|
|
{
|
|
if ( yytoks[yy_i].t_val
|
|
== yychar )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
printf( "token %s\n",
|
|
yytoks[yy_i].t_name );
|
|
}
|
|
}
|
|
#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 )
|
|
printf( "Reduce by (%d) \"%s\"\n",
|
|
yy_n, yyreds[ yy_n ] );
|
|
#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 )
|
|
{
|
|
$A
|
|
}
|
|
goto yystack; /* reset registers in driver code */
|
|
}
|