694 lines
14 KiB
C
694 lines
14 KiB
C
// Copyright (c) 1993-1999 Microsoft Corporation
|
||
|
||
/*
|
||
* Created by CSD YACC (IBM PC) from "gram.y" */
|
||
|
||
|
||
/****************************************************************************
|
||
*** local defines
|
||
***************************************************************************/
|
||
|
||
#define pascal
|
||
#define FARDATA
|
||
#define NEARDATA
|
||
#define FARCODE
|
||
#define NEARCODE
|
||
#define NEARSWAP
|
||
|
||
#define PASCAL pascal
|
||
#define CDECL
|
||
#define VOID void
|
||
#define CONST const
|
||
#define GLOBAL
|
||
|
||
#define YYSTYPE lextype_t
|
||
#define YYNEAR NEARCODE
|
||
#define YYPASCAL PASCAL
|
||
#define YYPRINT printf
|
||
#define YYSTATIC static
|
||
#define YYLEX yylex
|
||
#define YYPARSER yyparse
|
||
|
||
#define MAXARRAY 1000
|
||
#define CASE_BUFFER_SIZE 10000
|
||
|
||
#define CASE_FN_FORMAT ("\nvoid\n%s_case_fn_%.4d()")
|
||
#define DISPATCH_ENTRY_FORMAT ("\n\t,%s_case_fn_%.4d")
|
||
#define DISPATCH_FIRST_ENTRY ("\n\t %s_case_fn_%.4d")
|
||
|
||
/****************************************************************************
|
||
*** include files
|
||
***************************************************************************/
|
||
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <ctype.h>
|
||
#include <assert.h>
|
||
#include "lex.h"
|
||
|
||
/****************************************************************************
|
||
*** externals
|
||
***************************************************************************/
|
||
|
||
extern int Incase;
|
||
extern int ActionSensed;
|
||
extern int yylex();
|
||
extern int yyparse();
|
||
extern char * name_prefix;
|
||
|
||
/****************************************************************************
|
||
*** local procs
|
||
***************************************************************************/
|
||
|
||
void Init( void );
|
||
void EmitCaseTableArray( void );
|
||
void EmitDefaultCase( void );
|
||
void EmitCaseBody( int );
|
||
void RegisterCase( int );
|
||
void BufferIt( char * pStr, int iLen );
|
||
void ResetBuffer();
|
||
void FlushBuffer();
|
||
|
||
/****************************************************************************
|
||
*** local data
|
||
***************************************************************************/
|
||
|
||
unsigned long SavedIDCount = 0;
|
||
unsigned long IDCount = 0;
|
||
unsigned char CaseTable[ MAXARRAY ] = { 0 };
|
||
int CaseNumber = 0;
|
||
int MaxCaseNumber = 0;
|
||
char * pBufStart;
|
||
char * pBufCur;
|
||
char * pBufEnd;
|
||
|
||
# define ID 257
|
||
# define NUMBER 258
|
||
# define TOKEN_CASE 259
|
||
# define TOKEN_CHAR 260
|
||
# define TOKEN_END 261
|
||
# define TOKEN_END_CASE 262
|
||
# define TOKEN_MYACT 263
|
||
# define TOKEN_START 264
|
||
#define yyclearin yychar = -1
|
||
#define yyerrok yyerrflag = 0
|
||
#ifndef YYMAXDEPTH
|
||
#define YYMAXDEPTH 150
|
||
#endif
|
||
YYSTYPE yylval, yyval;
|
||
#ifndef YYFARDATA
|
||
#define YYFARDATA /*nothing*/
|
||
#endif
|
||
#if ! defined YYSTATIC
|
||
#define YYSTATIC /*nothing*/
|
||
#endif
|
||
#ifndef YYOPTTIME
|
||
#define YYOPTTIME 0
|
||
#endif
|
||
#ifndef YYR_T
|
||
#define YYR_T int
|
||
#endif
|
||
typedef YYR_T yyr_t;
|
||
#ifndef YYEXIND_T
|
||
#define YYEXIND_T unsigned int
|
||
#endif
|
||
typedef YYEXIND_T yyexind_t;
|
||
#ifndef YYACT
|
||
#define YYACT yyact
|
||
#endif
|
||
#ifndef YYPACT
|
||
#define YYPACT yypact
|
||
#endif
|
||
#ifndef YYPGO
|
||
#define YYPGO yypgo
|
||
#endif
|
||
#ifndef YYR1
|
||
#define YYR1 yyr1
|
||
#endif
|
||
#ifndef YYR2
|
||
#define YYR2 yyr2
|
||
#endif
|
||
#ifndef YYCHK
|
||
#define YYCHK yychk
|
||
#endif
|
||
#ifndef YYDEF
|
||
#define YYDEF yydef
|
||
#endif
|
||
#ifndef YYLOCAL
|
||
#define YYLOCAL
|
||
#endif
|
||
# define YYERRCODE 256
|
||
|
||
|
||
|
||
/*****************************************************************************
|
||
* utility functions
|
||
*****************************************************************************/
|
||
YYSTATIC VOID FARCODE PASCAL
|
||
yyerror(char *szError)
|
||
{
|
||
extern int Line;
|
||
extern char LocalBuffer[];
|
||
|
||
fprintf(stderr, "%s at Line %d near %s\n", szError, Line, LocalBuffer);
|
||
}
|
||
void
|
||
Init()
|
||
{
|
||
pBufStart = pBufCur = malloc( CASE_BUFFER_SIZE );
|
||
if( !pBufStart )
|
||
{
|
||
fprintf(stderr,"Out Of Memory\n");
|
||
exit(1);
|
||
}
|
||
pBufEnd = pBufStart + CASE_BUFFER_SIZE;
|
||
}
|
||
|
||
void
|
||
BufferIt(
|
||
char * pStr,
|
||
int iLen )
|
||
{
|
||
if( pBufCur + iLen > pBufEnd )
|
||
{
|
||
printf("ALERT iLen = %d\n", iLen );
|
||
// assert( (pBufCur + iLen) <= pBufEnd );
|
||
exit(1);
|
||
}
|
||
strncpy( pBufCur , pStr, iLen );
|
||
pBufCur += iLen;
|
||
*pBufCur = '\0';
|
||
}
|
||
|
||
void
|
||
ResetBuffer()
|
||
{
|
||
pBufCur = pBufStart;
|
||
*pBufCur= '\0';
|
||
}
|
||
|
||
void
|
||
FlushBuffer()
|
||
{
|
||
fprintf(stdout, "%s", pBufStart);
|
||
ResetBuffer();
|
||
}
|
||
|
||
void
|
||
EmitCaseBody(
|
||
int CaseNumber )
|
||
{
|
||
fprintf( stdout, CASE_FN_FORMAT, name_prefix, CaseNumber );
|
||
FlushBuffer();
|
||
fprintf( stdout, "}\n" );
|
||
}
|
||
|
||
void
|
||
EmitCaseTableArray()
|
||
{
|
||
int i, iTemp;
|
||
|
||
fprintf( stdout, "const pfn\t %s_case_fn_array[] = \n\t{", name_prefix );
|
||
fprintf( stdout,DISPATCH_FIRST_ENTRY,name_prefix, 0 );
|
||
|
||
for( i = 1 ; i <= MaxCaseNumber ; ++i )
|
||
{
|
||
iTemp = CaseTable[ i ] ? i : 0;
|
||
fprintf(stdout,DISPATCH_ENTRY_FORMAT,name_prefix, iTemp );
|
||
}
|
||
|
||
fprintf( stdout, "\n\t};\n" );
|
||
fprintf( stdout, "\nstatic void\nyy_vc_init()\n{ \n\tpcase_fn_array = (pfn *) %s_case_fn_array;\n\tyym_vc_max = %d;\n}\n" , name_prefix, MaxCaseNumber);
|
||
}
|
||
|
||
void
|
||
EmitDefaultCase()
|
||
{
|
||
fprintf(stdout, "void\n%s_case_fn_%.4d() {\n\t}\n\n", name_prefix, 0 );
|
||
}
|
||
void
|
||
RegisterCase(
|
||
int iCase )
|
||
{
|
||
CaseTable[ iCase ] = 1;
|
||
}
|
||
YYSTATIC short yyexca[] ={
|
||
#if !(YYOPTTIME)
|
||
-1, 1,
|
||
#endif
|
||
0, -1,
|
||
-2, 0,
|
||
};
|
||
# define YYNPROD 16
|
||
#if YYOPTTIME
|
||
YYSTATIC yyexind_t yyexcaind[] = {
|
||
0,
|
||
0,
|
||
};
|
||
#endif
|
||
# define YYLAST 39
|
||
YYSTATIC short YYFARDATA YYACT[]={
|
||
|
||
8, 13, 28, 6, 7, 16, 5, 25, 23, 21,
|
||
24, 2, 20, 4, 3, 26, 19, 9, 15, 12,
|
||
10, 1, 11, 0, 14, 0, 0, 17, 18, 0,
|
||
0, 0, 22, 0, 0, 0, 0, 0, 27 };
|
||
YYSTATIC short YYFARDATA YYPACT[]={
|
||
|
||
-254,-1000,-264,-254,-1000,-1000,-1000,-1000,-1000,-1000,
|
||
-254,-262,-254,-1000,-256,-254,-254,-250,-1000,-250,
|
||
-1000,-252,-1000,-248,-253,-1000,-254,-260,-1000 };
|
||
YYSTATIC short YYFARDATA YYPGO[]={
|
||
|
||
0, 21, 11, 20, 19, 18, 16, 12, 15, 14,
|
||
13 };
|
||
YYSTATIC yyr_t YYFARDATA YYR1[]={
|
||
|
||
0, 3, 1, 5, 4, 6, 6, 8, 7, 2,
|
||
2, 9, 9, 10, 10, 10 };
|
||
YYSTATIC yyr_t YYFARDATA YYR2[]={
|
||
|
||
0, 0, 8, 0, 4, 2, 1, 0, 7, 1,
|
||
0, 2, 1, 1, 1, 1 };
|
||
YYSTATIC short YYFARDATA YYCHK[]={
|
||
|
||
-1000, -1, -2, -9, -10, 260, 257, 258, 264, -10,
|
||
-3, -2, -4, 263, -2, -5, 261, -2, -2, -6,
|
||
-7, 259, -7, 260, 258, 260, -8, -2, 262 };
|
||
YYSTATIC short YYFARDATA YYDEF[]={
|
||
|
||
10, -2, 0, 9, 12, 13, 14, 15, 1, 11,
|
||
10, 0, 10, 3, 0, 10, 10, 0, 2, 4,
|
||
6, 0, 5, 0, 0, 7, 10, 0, 8 };
|
||
#ifdef YYRECOVER
|
||
YYSTATIC short yyrecover[] = {
|
||
-1000 };
|
||
#endif
|
||
/* SCCSWHAT( "@(#)yypars.c 2.4 88/05/09 15:22:59 " ) */
|
||
static char *SCCSID = "@(#)yypars.c:1.3";
|
||
# 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, d, e) printf(a, b, c, d, e)
|
||
#else
|
||
#define yyprintf(a, b, c, d)
|
||
#endif
|
||
|
||
#ifndef YYPRINT
|
||
#define YYPRINT printf
|
||
#endif
|
||
|
||
#if ! defined YYSTATIC
|
||
#define YYSTATIC
|
||
#endif
|
||
|
||
/* parser for yacc output */
|
||
|
||
#ifdef YYDEBUG
|
||
YYSTATIC int yydebug = 0; /* 1 for debugging */
|
||
#endif
|
||
YYSTATIC YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
|
||
YYSTATIC short yys[YYMAXDEPTH]; /* the parse stack */
|
||
YYSTATIC int yychar = -1; /* current input token number */
|
||
YYSTATIC int yynerrs = 0; /* number of errors */
|
||
YYSTATIC short yyerrflag = 0; /* error recovery flag */
|
||
short yyexpected;
|
||
|
||
#ifdef YYRECOVER
|
||
/*
|
||
** yyscpy : copy f onto t and return a ptr to the null terminator at the
|
||
** end of t.
|
||
*/
|
||
YYSTATIC char *yyscpy(t,f)
|
||
register char *t, *f;
|
||
{
|
||
while(*t = *f++)
|
||
t++;
|
||
return(t); /* ptr to the null char */
|
||
}
|
||
#endif
|
||
|
||
#ifndef YYNEAR
|
||
#define YYNEAR
|
||
#endif
|
||
#ifndef YYPASCAL
|
||
#define YYPASCAL
|
||
#endif
|
||
#ifndef YYLOCAL
|
||
#define YYLOCAL
|
||
#endif
|
||
#if ! defined YYPARSER
|
||
#define YYPARSER yyparse
|
||
#endif
|
||
#if ! defined YYLEX
|
||
#define YYLEX yylex
|
||
#endif
|
||
#ifdef VC_ERRORS
|
||
static short yysavestate = 0;
|
||
#endif
|
||
|
||
YYLOCAL YYNEAR YYPASCAL YYPARSER()
|
||
{
|
||
register short yyn;
|
||
short yystate, *yyps;
|
||
YYSTYPE *yypv;
|
||
short yyj, yym;
|
||
|
||
#ifdef YYDEBUG
|
||
yydebug = 1;
|
||
#endif // YYDEBUG
|
||
|
||
yystate = 0;
|
||
yychar = -1;
|
||
yynerrs = 0;
|
||
yyerrflag = 0;
|
||
yyps= &yys[-1];
|
||
yypv= &yyv[-1];
|
||
|
||
yystack: /* put a state and value onto the stack */
|
||
|
||
#ifdef YYDEBUG
|
||
yyprintf( "[yydebug] state %d, char %d = %c\n", yystate, yychar,yychar, 0 );
|
||
#else // YYDEBUG
|
||
yyprintf( "[yydebug] state %d, char %d\n", yystate, yychar, 0 );
|
||
#endif // YYDEBUG
|
||
if( ++yyps > &yys[YYMAXDEPTH] ) {
|
||
#ifdef VC_ERRORS
|
||
yyerror( "yacc stack overflow", -1 );
|
||
#else // VC_ERRORS
|
||
yyerror( "yacc stack overflow");
|
||
#endif // VC_ERRORS
|
||
return(1);
|
||
}
|
||
*yyps = yystate;
|
||
++yypv;
|
||
|
||
#ifdef UNION
|
||
yyunion(yypv, &yyval);
|
||
#else
|
||
*yypv = yyval;
|
||
#endif
|
||
|
||
yynewstate:
|
||
|
||
#ifdef VC_ERRORS
|
||
yysavestate = yystate;
|
||
#endif
|
||
|
||
yyn = yypact[yystate];
|
||
|
||
yyexpected = -yyn;
|
||
|
||
if( yyn <= YYFLAG ) { /* simple state, no lookahead */
|
||
goto yydefault;
|
||
}
|
||
if( yychar < 0 ) { /* need a lookahead */
|
||
yychar = YYLEX();
|
||
}
|
||
if( ((yyn += (short) yychar) < 0) || (yyn >= YYLAST) ) {
|
||
goto yydefault;
|
||
}
|
||
if( yychk[ yyn = yyact[ yyn ] ] == yychar ) { /* valid shift */
|
||
yychar = -1;
|
||
#ifdef UNION
|
||
yyunion(&yyval, &yylval);
|
||
#else
|
||
yyval = yylval;
|
||
#endif
|
||
yystate = yyn;
|
||
if( yyerrflag > 0 ) {
|
||
--yyerrflag;
|
||
}
|
||
goto yystack;
|
||
}
|
||
|
||
yydefault:
|
||
/* default state action */
|
||
|
||
if( (yyn = yydef[yystate]) == -2 ) {
|
||
register short *yyxi;
|
||
|
||
if( yychar < 0 ) {
|
||
yychar = YYLEX();
|
||
}
|
||
/*
|
||
** search exception table, we find a -1 followed by the current state.
|
||
** if we find one, we'll look through terminal,state pairs. if we find
|
||
** a terminal which matches the current one, we have a match.
|
||
** the exception table is when we have a reduce on a terminal.
|
||
*/
|
||
|
||
#if YYOPTTIME
|
||
yyxi = yyexca + yyexcaind[yystate];
|
||
while(( *yyxi != yychar ) && ( *yyxi >= 0 )){
|
||
yyxi += 2;
|
||
}
|
||
#else
|
||
for(yyxi = yyexca;
|
||
(*yyxi != (-1)) || (yyxi[1] != yystate);
|
||
yyxi += 2
|
||
) {
|
||
; /* VOID */
|
||
}
|
||
|
||
while( *(yyxi += 2) >= 0 ){
|
||
if( *yyxi == yychar ) {
|
||
break;
|
||
}
|
||
}
|
||
#endif
|
||
if( (yyn = yyxi[1]) < 0 ) {
|
||
return(0); /* accept */
|
||
}
|
||
}
|
||
|
||
if( yyn == 0 ){ /* error */
|
||
/* error ... attempt to resume parsing */
|
||
|
||
switch( yyerrflag ){
|
||
|
||
case 0: /* brand new error */
|
||
#ifdef YYRECOVER
|
||
{
|
||
register int i,j;
|
||
|
||
for(i = 0;
|
||
(yyrecover[i] != -1000) && (yystate > yyrecover[i]);
|
||
i += 3
|
||
) {
|
||
;
|
||
}
|
||
if(yystate == yyrecover[i]) {
|
||
#ifdef YYDEBUG
|
||
yyprintf("recovered, from state %d to state %d on token %d\n",
|
||
yystate,yyrecover[i+2],yyrecover[i+1], 0
|
||
);
|
||
#else // YYDEBUG
|
||
yyprintf("recovered, from state %d to state %d on token %d\n",
|
||
yystate,yyrecover[i+2],yyrecover[i+1]
|
||
);
|
||
#endif // YYDEBUG
|
||
j = yyrecover[i + 1];
|
||
if(j < 0) {
|
||
/*
|
||
** here we have one of the injection set, so we're not quite
|
||
** sure that the next valid thing will be a shift. so we'll
|
||
** count it as an error and continue.
|
||
** actually we're not absolutely sure that the next token
|
||
** we were supposed to get is the one when j > 0. for example,
|
||
** for(+) {;} error recovery with yyerrflag always set, stops
|
||
** after inserting one ; before the +. at the point of the +,
|
||
** we're pretty sure the guy wants a 'for' loop. without
|
||
** setting the flag, when we're almost absolutely sure, we'll
|
||
** give him one, since the only thing we can shift on this
|
||
** error is after finding an expression followed by a +
|
||
*/
|
||
yyerrflag++;
|
||
j = -j;
|
||
}
|
||
if(yyerrflag <= 1) { /* only on first insertion */
|
||
yyrecerr(yychar,j); /* what was, what should be first */
|
||
}
|
||
yyval = yyeval(j);
|
||
yystate = yyrecover[i + 2];
|
||
goto yystack;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
#ifdef VC_ERRORS
|
||
yyerror("syntax error", yysavestate);
|
||
#else
|
||
yyerror("syntax error");
|
||
#endif
|
||
|
||
// 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 */
|
||
|
||
#ifdef YYDEBUG
|
||
yyprintf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1], 0, 0 );
|
||
#else // YYDEBUG
|
||
yyprintf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1], 0 );
|
||
#endif // YYDEBUG
|
||
--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 */
|
||
|
||
#ifdef YYDEBUG
|
||
yyprintf( "error recovery discards char %d\n", yychar, 0, 0, 0 );
|
||
#else // YYDEBUG
|
||
yyprintf( "error recovery discards char %d\n", yychar, 0, 0 );
|
||
#endif // YYDEBUG
|
||
if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
|
||
yychar = -1;
|
||
goto yynewstate; /* try again in the same state */
|
||
}
|
||
}
|
||
|
||
/* reduction by production yyn */
|
||
// yyreduce:
|
||
{
|
||
register YYSTYPE *yypvt;
|
||
#ifdef YYDEBUG
|
||
yyprintf("[yydebug] reduce %d\n",yyn, 0, 0, 0);
|
||
#else // YYDEBUG
|
||
yyprintf("[yydebug] reduce %d\n",yyn, 0, 0);
|
||
#endif // YYDEBUG
|
||
yypvt = yypv;
|
||
yyps -= yyr2[yyn];
|
||
yypv -= yyr2[yyn];
|
||
#ifdef UNION
|
||
yyunion(&yyval, &yypv[1]);
|
||
#else
|
||
yyval = yypv[1];
|
||
#endif
|
||
yym = yyn;
|
||
yyn = (short) yyr1[yyn]; /* consult goto table to find next state */
|
||
yyj = yypgo[yyn] + *yyps + 1;
|
||
if( (yyj >= YYLAST) || (yychk[ yystate = yyact[yyj] ] != -yyn) ) {
|
||
yystate = yyact[yypgo[yyn]];
|
||
}
|
||
switch(yym){
|
||
|
||
case 1:
|
||
{
|
||
Init();
|
||
} break;
|
||
case 2:
|
||
{
|
||
EmitDefaultCase();
|
||
EmitCaseTableArray();
|
||
} break;
|
||
case 3:
|
||
{
|
||
ActionSensed++;
|
||
ResetBuffer();
|
||
} break;
|
||
case 4:
|
||
{
|
||
} break;
|
||
case 5:
|
||
{
|
||
} break;
|
||
case 6:
|
||
{
|
||
} break;
|
||
case 7:
|
||
{
|
||
Incase = 1;
|
||
|
||
CaseNumber = yypvt[-1].yynumber;
|
||
if(yypvt[-1].yynumber >= MAXARRAY)
|
||
{
|
||
fprintf(stderr, "Case Limit Reached : Contact Dov/Vibhas\n");
|
||
return 1;
|
||
}
|
||
|
||
SavedIDCount = IDCount;
|
||
} break;
|
||
case 8:
|
||
{
|
||
if(SavedIDCount != IDCount)
|
||
{
|
||
RegisterCase( CaseNumber );
|
||
EmitCaseBody( CaseNumber );
|
||
}
|
||
|
||
ResetBuffer();
|
||
|
||
if(CaseNumber > MaxCaseNumber)
|
||
MaxCaseNumber = CaseNumber;
|
||
Incase = 0;
|
||
} break;
|
||
case 9:
|
||
{
|
||
} break;
|
||
case 10:
|
||
{
|
||
} break;
|
||
case 11:
|
||
{
|
||
} break;
|
||
case 12:
|
||
{
|
||
} break;
|
||
case 13:
|
||
{
|
||
if(!ActionSensed)
|
||
fprintf(stdout, "%c", yypvt[-0].yycharval);
|
||
else
|
||
BufferIt( &yypvt[-0].yycharval, 1);
|
||
} break;
|
||
case 14:
|
||
{
|
||
IDCount++;
|
||
if(!ActionSensed)
|
||
fprintf(stdout, "%s", yypvt[-0].yystring);
|
||
else
|
||
BufferIt( yypvt[-0].yystring, strlen(yypvt[-0].yystring) );
|
||
} break;
|
||
case 15:
|
||
{
|
||
if(!ActionSensed)
|
||
fprintf(stdout, "%d", yypvt[-0].yynumber);
|
||
else
|
||
{
|
||
char buffer[20];
|
||
sprintf(buffer,"%d", yypvt[-0].yynumber );
|
||
BufferIt( buffer, strlen(buffer) );
|
||
}
|
||
} break;/* End of actions */
|
||
}
|
||
}
|
||
goto yystack; /* stack new state and value */
|
||
}
|