smpar.c

基于单片机的 snmp协议解析的一些原代码 给有用的 同行

	"SZdotdot : tokDOTDOT",

	"SZdotdot : /* empty */",

	"SZdotdot : tokBADDOTDOT",

	"SZdotdot : chDOT",

	"srVal : tokNUMBER",

	"srVal : tokBSTR",

	"srVal : tokHSTR",

	"seqMemberList : seqMember",

	"seqMemberList : seqMemberList seqComma seqMember",

	"seqComma : chCOMMA",

	"seqComma : /* empty */",

	"seqMember : tokNAME simpleSyntax",

	"seqMember : tokNAME",

	"seqMember : tokNAME chCOMMA simpleSyntax",

	"seqMember : tokNAME error",

	"optVar : /* empty */",

	"optVar : kwVARIABLES chLCB varList chRCB",

	"optVar : kwVARIABLES chLCB varList chCOMMA chRCB",

	"optVar : kwVARIABLES error chRCB",

	"optVar : kwVARIABLES error",

	"varList : var",

	"varList : varList varComma var",

	"varComma : chCOMMA",

	"varComma : /* empty */",

	"var : tokNAME",

};

#endif /* YYDEBUG */

/* RDR -- #line 1 "/usr/lib/yaccpar" */

/*	@(#)yaccpar 1.10 89/04/04 SMI; from S5R3 1.10	*/



/*

** Skeleton parser driver for yacc output

*/



/*

** yacc user known macros and defines

*/

#define YYERROR		goto yyerrlab

#define YYACCEPT	{ free(yys); free(yyv); return(0); }

#define YYABORT		{ free(yys); free(yyv); return(1); }

#define YYBACKUP( newtoken, newvalue )
/* RDR ---
\

{\

	if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\

	{\

		yyerror( "syntax error - cannot backup" );\

		goto yyerrlab;\

	}\

	yychar = newtoken;\

	yystate = *yyps;\

	yylval = newvalue;\

	goto yynewstate;\

}
*/

#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)



/*

** static variables used by the parser

*/

static YYSTYPE *yyv;			/* value stack */

static int *yys;			/* state stack */



static YYSTYPE *yypv;			/* top of value stack */

static int *yyps;			/* top of state stack */



static int yystate;			/* current state */

static 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

*/

int

yyparse()

{

	register YYSTYPE *yypvt;	/* top of value stack for $vars */

	unsigned yymaxdepth = YYMAXDEPTH;



	/*

	** Initialize externals - yyparse may be called more than once

	*/

	yyv = (YYSTYPE*)malloc(yymaxdepth*sizeof(YYSTYPE));

	yys = (int*)malloc(yymaxdepth*sizeof(int));

	if (!yyv || !yys)

	{

		yyerror( "out of memory" );

		return(1);

	}
#if 0
//
// These lines were "OBVIOUSLY" commented out. Initialize
// these pointers some other way.
// 11/26/96
	yypv = &yyv[-1];

	yyps = &yys[-1];
#endif
	/* Initialize yypv to the first element of yyv */
   yypv = &yyv[0];

   /* Initialize yyps to the first element of yys */
   yyps = &yys[0];

	yystate = 0;

	yytmp = 0;

	yynerrs = 0;

	yyerrflag = 0;

	yychar = -1;



	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

		*/

#ifdef 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;



			(void)printf( "State %d, token ", yy_state );

			if ( yychar == 0 )

				(void)printf( "end-of-file\n" );

			else if ( yychar < 0 )

				(void)printf( "-none-\n" );

			else

			{

				for ( yy_i = 0; yytoks[yy_i].t_val >= 0;

					yy_i++ )

				{

					if ( yytoks[yy_i].t_val == yychar )

						break;

				}

				(void)printf( "%s\n", yytoks[yy_i].t_name );

			}

		}

#endif /* YYDEBUG */

		if ( ++yy_ps >= &yys[ yymaxdepth ] )	/* room on stack? */

		{

			/*

			** reallocate and recover.  Note that pointers

			** have to be reset, or bad things will happen

			*/

			int yyps_index = (yy_ps - yys);

			int yypv_index = (yy_pv - yyv);

			int yypvt_index = (yypvt - yyv);

			yymaxdepth += YYMAXDEPTH;

			yyv = (YYSTYPE*)realloc((char*)yyv,

				yymaxdepth * sizeof(YYSTYPE));

			yys = (int*)realloc((char*)yys,

				yymaxdepth * sizeof(int));

			if (!yyv || !yys)

			{

				yyerror( "yacc stack overflow" );

				return(1);

			}

			yy_ps = yys + yyps_index;

			yy_pv = yyv + yypv_index;

			yypvt = yyv + yypvt_index;

		}

		*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 */

#ifdef YYDEBUG

		/*

		** if debugging, need to mark whether new token grabbed

		*/

		yytmp = yychar < 0;

#endif

		if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )

			yychar = 0;		/* reached EOF */

#ifdef YYDEBUG

		if ( yydebug && yytmp )

		{

			register int yy_i;



			(void)printf( "Received token " );

			if ( yychar == 0 )

				(void)printf( "end-of-file\n" );

			else if ( yychar < 0 )

				(void)printf( "-none-\n" );

			else

			{

				for ( yy_i = 0; yytoks[yy_i].t_val >= 0;

					yy_i++ )

				{

					if ( yytoks[yy_i].t_val == yychar )

						break;

				}

				(void)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 )

		{

#ifdef YYDEBUG

			yytmp = yychar < 0;

#endif

			if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )

				yychar = 0;		/* reached EOF */

#ifdef YYDEBUG

			if ( yydebug && yytmp )

			{

				register int yy_i;



				(void)printf( "Received token " );

				if ( yychar == 0 )

					(void)printf( "end-of-file\n" );

				else if ( yychar < 0 )

					(void)printf( "-none-\n" );

				else

				{

					for ( yy_i = 0;

						yytoks[yy_i].t_val >= 0;

						yy_i++ )

					{

						if ( yytoks[yy_i].t_val

							== yychar )

						{

							break;

						}

					}

					(void)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 */

				yyerror( "syntax error" );

				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;