int yyparse(void) { register YYSTYPE *yypvt = 0;	  #if defined(__cplusplus) || defined(lint)  static int __yaccpar_lint_hack__ = 0; switch (__yaccpar_lint_hack__) { case 1: goto yyerrlab; case 2: goto yynewstate; } #endif   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) { yyerror("yacc initialization error"); YYABORT; } } #endif  { register YYSTYPE *yy_pv;	 register int *yy_ps;		 register int yy_state;		 register int  yy_n;		 goto yystack;	   yynewstate: yy_pv = yypv; yy_ps = yyps; yy_state = yystate; goto yy_newstate;   yystack: yy_pv = yypv; yy_ps = yyps; yy_state = yystate;   yy_stack:  #if YYDEBUG  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  if ( ++yy_ps >= &yys[ yymaxdepth ] )	 {  int yyps_index = (yy_ps - yys); int yypv_index = (yy_pv - yyv); int yypvt_index = (yypvt - yyv); int yynewmax; #ifdef YYEXPAND yynewmax = YYEXPAND(yymaxdepth); #else yynewmax = 2 * yymaxdepth;	 if (yymaxdepth == YYMAXDEPTH)	 { char *newyys = (char *)YYNEW(int); char *newyyv = (char *)YYNEW(YYSTYPE); if (newyys != 0 && newyyv != 0) { yys = YYCOPY(newyys, yys, int); yyv = YYCOPY(newyyv, yyv, YYSTYPE); } else yynewmax = 0;	 } else				 { yys = YYENLARGE(yys, int); yyv = YYENLARGE(yyv, YYSTYPE); if (yys == 0 || yyv == 0) yynewmax = 0;	 } #endif if (yynewmax <= yymaxdepth)	 { yyerror( "yacc stack overflow" ); YYABORT; } yymaxdepth = yynewmax;  yy_ps = yys + yyps_index; yy_pv = yyv + yypv_index; yypvt = yyv + yypvt_index; } *yy_ps = yy_state; *++yy_pv = yyval;   yy_newstate: if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG ) goto yydefault;		 #if YYDEBUG  yytmp = yychar < 0; #endif if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) ) yychar = 0;		 #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  if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) ) goto yydefault; if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar )	 { 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;		 #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   { register const 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; } }   if ( yy_n == 0 )	 {  switch ( yyerrflag ) { case 0:		 yyerror( "syntax error" ); goto skip_init; yyerrlab:  yy_pv = yypv; yy_ps = yyps; yy_state = yystate; skip_init: yynerrs++;  case 1: case 2:		  yyerrflag = 3;  while ( yy_ps >= yys ) { yy_n = yypact[ *yy_ps ] + YYERRCODE; if ( yy_n >= 0 && yy_n < YYLAST && yychk[yyact[yy_n]] == YYERRCODE)					{  yy_state = yyact[ yy_n ]; goto yy_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--; }  YYABORT; case 3:		 #if YYDEBUG  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  if ( yychar == 0 )	 YYABORT; yychar = -1; goto yy_newstate; } }  #if YYDEBUG  if ( yydebug ) printf( "Reduce by (%d) \"%s\"\n", yy_n, yyreds[ yy_n ] ); #endif yytmp = yy_n;			 yypvt = yy_pv;			  {  register int yy_len = yyr2[ yy_n ];  if ( !( yy_len & 01 ) ) { yy_len >>= 1; yyval = ( yy_pv -= yy_len )[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];	 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 ] ]; } }  yystate = yy_state; yyps = yy_ps; yypv = yy_pv; }  switch( yytmp ) {
yyparse() { register int yym, yyn, yystate; #if YYDEBUG register char *yys; extern char *getenv();  if (yys = getenv("YYDEBUG")) { yyn = *yys; if (yyn >= '0' && yyn <= '9') yydebug = yyn - '0'; } #endif  yynerrs = 0; yyerrflag = 0; yychar = (-1);  yyssp = yyss; yyvsp = yyvs; *yyssp = yystate = 0;  yyloop: if (yyn = yydefred[yystate]) goto yyreduce; if (yychar < 0) { if ((yychar = yylex()) < 0) yychar = 0; #if YYDEBUG if (yydebug) { yys = 0; if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; if (!yys) yys = "illegal-symbol"; printf("yydebug: state %d, reading %d (%s)\n", yystate, yychar, yys); } #endif } if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 && yyn <= YYTABLESIZE && yycheck[yyn] == yychar) { #if YYDEBUG if (yydebug) printf("yydebug: state %d, shifting to state %d\n", yystate, yytable[yyn]); #endif if (yyssp >= yyss + yystacksize - 1) { goto yyoverflow; } *++yyssp = yystate = yytable[yyn]; *++yyvsp = yylval; yychar = (-1); if (yyerrflag > 0)  --yyerrflag; goto yyloop; } if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 && yyn <= YYTABLESIZE && yycheck[yyn] == yychar) { yyn = yytable[yyn]; goto yyreduce; } if (yyerrflag) goto yyinrecovery; #ifdef lint goto yynewerror; #endif yynewerror: yyerror("syntax error"); #ifdef lint goto yyerrlab; #endif yyerrlab: ++yynerrs; yyinrecovery: if (yyerrflag < 3) { yyerrflag = 3; for (;;) { if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 && yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE) { #if YYDEBUG if (yydebug) printf("yydebug: state %d, error recovery shifting\ to state %d\n", *yyssp, yytable[yyn]); #endif if (yyssp >= yyss + yystacksize - 1) { goto yyoverflow; } *++yyssp = yystate = yytable[yyn]; *++yyvsp = yylval; goto yyloop; } else { #if YYDEBUG if (yydebug) printf("yydebug: error recovery discarding state %d\n", *yyssp); #endif if (yyssp <= yyss) goto yyabort; --yyssp; --yyvsp; } } } else { if (yychar == 0) goto yyabort; #if YYDEBUG if (yydebug) { yys = 0; if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; if (!yys) yys = "illegal-symbol"; printf("yydebug: state %d, error recovery discards token %d (%s)\n", yystate, yychar, yys); } #endif yychar = (-1); goto yyloop; } yyreduce: #if YYDEBUG if (yydebug) printf("yydebug: state %d, reducing by rule %d (%s)\n", yystate, yyn, yyrule[yyn]); #endif yym = yylen[yyn]; yyval = yyvsp[1-yym]; switch (yyn) {
int yyparse(void)#elseint yyparse()#endif{	register YYSTYPE *yypvt = 0;	/* top of value stack for $vars */#if defined(__cplusplus) || defined(lint)/*	hacks to please C++ and lint - goto's inside	switch should never be executed*/	static int __yaccpar_lint_hack__ = 0;	switch (__yaccpar_lint_hack__)	{		case 1: goto yyerrlab;		case 2: goto yynewstate;	}#endif	/*	** 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)		{			yyerror("yacc initialization error");			YYABORT;		}	}#endif	{		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 */	goto yystack;	/* moved from 6 lines above to here to please C++ */		/*		** 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? */		{			/*			** 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);			int yynewmax;#ifdef YYEXPAND			yynewmax = YYEXPAND(yymaxdepth);#else			yynewmax = 2 * yymaxdepth;	/* double table size */			if (yymaxdepth == YYMAXDEPTH)	/* first time growth */			{				char *newyys = (char *)YYNEW(int);				char *newyyv = (char *)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 */			{				yyerror( "yacc stack overflow" );				YYABORT;			}			yymaxdepth = yynewmax;			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 */#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 const 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;			skip_init:				yynerrs++;				/* FALLTHRU */			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 )	{		case 1:# line 84 "installparse.y"{	Pk11Install_valueList = yypvt[-0].list;} break;case 2:# line 89 "installparse.y"{ 	Pk11Install_ValueList_AddItem(yypvt[-0].list,yypvt[-1].value);	yyval.list = yypvt[-0].list; } break;case 3:# line 94 "installparse.y"{ 	yyval.list = Pk11Install_ValueList_new(); } break;case 4:# line 99 "installparse.y"{	yyval.value= Pk11Install_Value_new(PAIR_VALUE,yypvt[-0]);} break;case 5:# line 103 "installparse.y"{	yyval.value= Pk11Install_Value_new(STRING_VALUE, yypvt[-0]);} break;case 6:# line 108 "installparse.y"{	yyval.pair = Pk11Install_Pair_new(yypvt[-3].string,yypvt[-1].list);} break;case 7:# line 113 "installparse.y"{	yyval.string = yypvt[-0].string;} break;# line	531 "/usr/ccs/bin/yaccpar"	}	goto yystack;		/* reset registers in driver code */}