case 53:
case 56:
yyparse(YYPARSE_PARAM_ARG)     YYPARSE_PARAM_DECL{  register int yystate;  register int yyn;  register short *yyssp;  register YYSTYPE *yyvsp;  int yyerrstatus;	/*  number of tokens to shift before error messages enabled */  int yychar1 = 0;		/*  lookahead token as an internal (translated) token number */  short	yyssa[YYINITDEPTH];	/*  the state stack			*/  YYSTYPE yyvsa[YYINITDEPTH];	/*  the semantic value stack		*/  short *yyss = yyssa;		/*  refer to the stacks thru separate pointers */  YYSTYPE *yyvs = yyvsa;	/*  to allow yyoverflow to reallocate them elsewhere */#ifdef YYLSP_NEEDED  YYLTYPE yylsa[YYINITDEPTH];	/*  the location stack			*/  YYLTYPE *yyls = yylsa;  YYLTYPE *yylsp;#define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)#else#define YYPOPSTACK   (yyvsp--, yyssp--)#endif  int yystacksize = YYINITDEPTH;#ifdef YYPURE  int yychar;  YYSTYPE yylval;  int yynerrs;#ifdef YYLSP_NEEDED  YYLTYPE yylloc;#endif#endif  YYSTYPE yyval;		/*  the variable used to return		*/				/*  semantic values from the action	*/				/*  routines				*/  int yylen;#if YYDEBUG != 0  if (yydebug)    fprintf(stderr, "Starting parse\n");#endif  yystate = 0;  yyerrstatus = 0;  yynerrs = 0;  yychar = YYEMPTY;		/* Cause a token to be read.  */  /* Initialize stack pointers.     Waste one element of value and location stack     so that they stay on the same level as the state stack.     The wasted elements are never initialized.  */  yyssp = yyss;  yyvsp = yyvs;#ifdef YYLSP_NEEDED  yylsp = yyls;#endif/* Push a new state, which is found in  yystate  .  *//* In all cases, when you get here, the value and location stacks   have just been pushed. so pushing a state here evens the stacks.  */yynewstate:  *yyssp++ = yystate;  if (yyssp >= yyss + yystacksize)    {      /* Give user a chance to reallocate the stack */      /* Use copies of these so that the &'s don't force the real ones into memory. */      YYSTYPE *yyvs1 = yyvs;      short *yyss1 = yyss;#ifdef YYLSP_NEEDED      YYLTYPE *yyls1 = yyls;#endif      /* Get the current used size of the three stacks, in elements.  */      int size = yyssp - yyss;#ifdef yyoverflow      /* Each stack pointer address is followed by the size of	 the data in use in that stack, in bytes.  */#ifdef YYLSP_NEEDED      /* This used to be a conditional around just the two extra args,	 but that might be undefined if yyoverflow is a macro.  */      yyoverflow("parser stack overflow",		 &yyss1, size * sizeof (*yyssp),		 &yyvs1, size * sizeof (*yyvsp),		 &yyls1, size * sizeof (*yylsp),		 &yystacksize);#else      yyoverflow("parser stack overflow",		 &yyss1, size * sizeof (*yyssp),		 &yyvs1, size * sizeof (*yyvsp),		 &yystacksize);#endif      yyss = yyss1; yyvs = yyvs1;#ifdef YYLSP_NEEDED      yyls = yyls1;#endif#else /* no yyoverflow */      /* Extend the stack our own way.  */      if (yystacksize >= YYMAXDEPTH)	{	  yyerror("parser stack overflow");	  return 2;	}      yystacksize *= 2;      if (yystacksize > YYMAXDEPTH)	yystacksize = YYMAXDEPTH;      yyss = (short *) alloca (yystacksize * sizeof (*yyssp));      __yy_memcpy ((char *)yyss, (char *)yyss1, size * sizeof (*yyssp));      yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));      __yy_memcpy ((char *)yyvs, (char *)yyvs1, size * sizeof (*yyvsp));#ifdef YYLSP_NEEDED      yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));      __yy_memcpy ((char *)yyls, (char *)yyls1, size * sizeof (*yylsp));#endif#endif /* no yyoverflow */      yyssp = yyss + size;      yyvsp = yyvs + size - 1;#ifdef YYLSP_NEEDED      yylsp = yyls + size - 1;#endif#if YYDEBUG != 0      if (yydebug)	fprintf(stderr, "Stack size increased to %d\n", yystacksize);#endif      if (yyssp >= yyss + yystacksize)	YYABORT;    }#if YYDEBUG != 0  if (yydebug)    fprintf(stderr, "Entering state %d\n", yystate);#endif  goto yybackup; yybackup:/* Do appropriate processing given the current state.  *//* Read a lookahead token if we need one and don't already have one.  *//* yyresume: */  /* First try to decide what to do without reference to lookahead token.  */  yyn = yypact[yystate];  if (yyn == YYFLAG)    goto yydefault;  /* Not known => get a lookahead token if don't already have one.  */  /* yychar is either YYEMPTY or YYEOF     or a valid token in external form.  */  if (yychar == YYEMPTY)    {#if YYDEBUG != 0      if (yydebug)	fprintf(stderr, "Reading a token: ");#endif      yychar = YYLEX;    }  /* Convert token to internal form (in yychar1) for indexing tables with */  if (yychar <= 0)		/* This means end of input. */    {      yychar1 = 0;      yychar = YYEOF;		/* Don't call YYLEX any more */#if YYDEBUG != 0      if (yydebug)	fprintf(stderr, "Now at end of input.\n");#endif    }  else    {      yychar1 = YYTRANSLATE(yychar);#if YYDEBUG != 0      if (yydebug)	{	  fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);	  /* Give the individual parser a way to print the precise meaning	     of a token, for further debugging info.  */#ifdef YYPRINT	  YYPRINT (stderr, yychar, yylval);#endif	  fprintf (stderr, ")\n");	}#endif    }  yyn += yychar1;  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)    goto yydefault;  yyn = yytable[yyn];  /* yyn is what to do for this token type in this state.     Negative => reduce, -yyn is rule number.     Positive => shift, yyn is new state.       New state is final state => don't bother to shift,       just return success.     0, or most negative number => error.  */  if (yyn < 0)    {      if (yyn == YYFLAG)	goto yyerrlab;      yyn = -yyn;      goto yyreduce;    }  else if (yyn == 0)    goto yyerrlab;  if (yyn == YYFINAL)    YYACCEPT;  /* Shift the lookahead token.  */#if YYDEBUG != 0  if (yydebug)    fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);#endif  /* Discard the token being shifted unless it is eof.  */  if (yychar != YYEOF)    yychar = YYEMPTY;  *++yyvsp = yylval;#ifdef YYLSP_NEEDED  *++yylsp = yylloc;#endif  /* count tokens shifted since error; after three, turn off error status.  */  if (yyerrstatus) yyerrstatus--;  yystate = yyn;  goto yynewstate;/* Do the default action for the current state.  */yydefault:  yyn = yydefact[yystate];  if (yyn == 0)    goto yyerrlab;/* Do a reduction.  yyn is the number of a rule to reduce with.  */yyreduce:  yylen = yyr2[yyn];  if (yylen > 0)    yyval = yyvsp[1-yylen]; /* implement default value of the action */#if YYDEBUG != 0  if (yydebug)    {      int i;      fprintf (stderr, "Reducing via rule %d (line %d), ",	       yyn, yyrline[yyn]);      /* Print the symbols being reduced, and their result.  */      for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)	fprintf (stderr, "%s ", yytname[yyrhs[i]]);      fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);    }#endif  switch (yyn) {case 2:{ parse_save( yyvsp[0].parse ); ;    break;}case 3:{ yyval.parse = pnull(); ;    break;}case 4:{ yyval.parse = yyvsp[0].parse; ;    break;}case 5:{ yyval.parse = yyvsp[0].parse; ;    break;}case 6:{ yyval.parse = prules( yyvsp[-1].parse, yyvsp[0].parse ); ;    break;}case 7:{ yyval.parse = plocal( yyvsp[-3].parse, yyvsp[-2].parse, yyvsp[0].parse ); ;    break;}case 8:{ yyval.parse = pnull(); ;    break;}case 9:{ yyval.parse = yyvsp[0].parse; ;    break;}case 10:{ yyval.parse = yyvsp[-1].parse; ;    break;}case 11:{ yyval.parse = pincl( yyvsp[-1].parse ); ;    break;}case 12:{ yyval.parse = prule( yyvsp[-2].string, yyvsp[-1].parse ); ;    break;}case 13:{ yyval.parse = pset( yyvsp[-3].parse, yyvsp[-1].parse, yyvsp[-2].number ); ;    break;}case 14:{ yyval.parse = psetmodule( yyvsp[-2].parse, yyvsp[-1].parse ); ;    break;}case 15:{ yyval.parse = pset1( yyvsp[-5].parse, yyvsp[-3].parse, yyvsp[-1].parse, yyvsp[-2].number ); ;    break;}case 16:{ yyval.parse = yyvsp[-1].parse; ;    break;}case 17:{ yyval.parse = pfor( yyvsp[-5].string, yyvsp[-3].parse, yyvsp[-1].parse, 0 ); ;    break;}case 18:{ yyval.parse = pfor( yyvsp[-5].string, yyvsp[-3].parse, yyvsp[-1].parse, 1 ); ;    break;}case 19:{ yyval.parse = pswitch( yyvsp[-3].parse, yyvsp[-1].parse ); ;    break;}case 20:{ yyval.parse = pif( yyvsp[-3].parse, yyvsp[-1].parse, pnull() ); ;    break;}case 21:{ yyval.parse = pmodule( yyvsp[-3].parse, yyvsp[-1].parse ); ;    break;}case 22:{ yyval.parse = pwhile( yyvsp[-3].parse, yyvsp[-1].parse ); ;    break;}case 23:{ yyval.parse = pif( yyvsp[-5].parse, yyvsp[-3].parse, yyvsp[0].parse ); ;    break;}case 24:{ yyval.parse = psetc_args( yyvsp[-4].string, yyvsp[0].parse, yyvsp[-2].parse ); ;    break;}case 25:{ yyval.parse = psetc( yyvsp[-1].string, yyvsp[0].parse ); ;    break;}case 26:{ yymode( SCAN_STRING ); ;    break;}case 27:{ yymode( SCAN_NORMAL ); ;    break;}case 28:{ yyval.parse = psete( yyvsp[-6].string,yyvsp[-5].parse,yyvsp[-2].string,yyvsp[-7].number ); ;    break;}case 29:{ yyval.number = ASSIGN_SET; ;    break;}case 30:{ yyval.number = ASSIGN_APPEND; ;    break;}case 31:{ yyval.number = ASSIGN_DEFAULT; ;    break;}case 32:{ yyval.number = ASSIGN_DEFAULT; ;    break;}case 33:{ yyval.parse = pcnode( COND_EXISTS, yyvsp[0].parse, pnull() ); ;    break;}case 34:{ yyval.parse = pcnode( COND_EQUALS, yyvsp[-2].parse, yyvsp[0].parse ); ;    break;}case 35:{ yyval.parse = pcnode( COND_NOTEQ, yyvsp[-2].parse, yyvsp[0].parse ); ;    break;}case 36:{ yyval.parse = pcnode( COND_LESS, yyvsp[-2].parse, yyvsp[0].parse ); ;    break;}case 37:{ yyval.parse = pcnode( COND_LESSEQ, yyvsp[-2].parse, yyvsp[0].parse ); ;    break;}case 38:{ yyval.parse = pcnode( COND_MORE, yyvsp[-2].parse, yyvsp[0].parse ); ;    break;}case 39:{ yyval.parse = pcnode( COND_MOREEQ, yyvsp[-2].parse, yyvsp[0].parse ); ;    break;}case 40:{ yyval.parse = pcnode( COND_IN, yyvsp[-2].parse, yyvsp[0].parse ); ;    break;}case 41:{ yyval.parse = pcnode( COND_NOT, yyvsp[0].parse, P0 ); ;    break;}case 42:{ yyval.parse = pcnode( COND_AND, yyvsp[-2].parse, yyvsp[0].parse ); ;    break;}case 43:{ yyval.parse = pcnode( COND_OR, yyvsp[-2].parse, yyvsp[0].parse ); ;    break;}case 44:{ yyval.parse = yyvsp[-1].parse; ;    break;}case 45:{ yyval.parse = P0; ;    break;}case 46:{ yyval.parse = pnode( yyvsp[-1].parse, yyvsp[0].parse ); ;    break;}case 47:{ yyval.parse = psnode( yyvsp[-2].string, yyvsp[0].parse ); ;    break;}case 48:{ yyval.parse = pnode( P0, yyvsp[0].parse ); ;    break;}case 49:{ yyval.parse = pnode( yyvsp[0].parse, yyvsp[-2].parse ); ;    break;}case 50:{ yyval.parse = yyvsp[0].parse; yymode( SCAN_NORMAL ); ;    break;}case 51:{ yyval.parse = pnull(); yymode( SCAN_PUNCT ); ;    break;}case 52:{ yyval.parse = pappend( yyvsp[-1].parse, yyvsp[0].parse ); ;    break;}case 53:{ yyval.parse = plist( yyvsp[0].string ); ;    break;}case 54:{ yyval.parse = prule( yyvsp[-2].string, yyvsp[-1].parse ); ;    break;}case 55:{ yyval.number = 0; ;    break;}case 56:{ yyval.number = yyvsp[-1].number | yyvsp[0].number; ;    break;}case 57:{ yyval.number = EXEC_UPDATED; ;    break;}case 58:{ yyval.number = EXEC_TOGETHER; ;    break;}case 59:{ yyval.number = EXEC_IGNORE; ;    break;}case 60:{ yyval.number = EXEC_QUIETLY; ;    break;}case 61:{ yyval.number = EXEC_PIECEMEAL; ;    break;}case 62:{ yyval.number = EXEC_EXISTING; ;    break;}case 63:{ yyval.parse = pnull(); ;    break;}case 64:{ yyval.parse = yyvsp[0].parse; ;    break;}}   /* the action file gets copied in in place of this dollarsign */  yyvsp -= yylen;  yyssp -= yylen;#ifdef YYLSP_NEEDED  yylsp -= yylen;#endif#if YYDEBUG != 0  if (yydebug)    {      short *ssp1 = yyss;      fprintf (stderr, "state stack now");      while (ssp1 != yyssp)	fprintf (stderr, " %d", *ssp1++);      fprintf (stderr, "\n");    }#endif  *++yyvsp = yyval;#ifdef YYLSP_NEEDED  yylsp++;  if (yylen == 0)    {      yylsp->first_line = yylloc.first_line;      yylsp->first_column = yylloc.first_column;      yylsp->last_line = (yylsp-1)->last_line;      yylsp->last_column = (yylsp-1)->last_column;      yylsp->text = 0;    }  else    {      yylsp->last_line = (yylsp+yylen-1)->last_line;      yylsp->last_column = (yylsp+yylen-1)->last_column;    }#endif  /* Now "shift" the result of the reduction.     Determine what state that goes to,     based on the state we popped back to     and the rule number reduced by.  */  yyn = yyr1[yyn];  yystate = yypgoto[yyn - YYNTBASE] + *(yyssp - 1);  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *(yyssp - 1))    yystate = yytable[yystate];  else    yystate = yydefgoto[yyn - YYNTBASE];  goto yynewstate;yyerrlab:   /* here on detecting error */  if (! yyerrstatus)    /* If not already recovering from an error, report this error.  */    {      ++yynerrs;#ifdef YYERROR_VERBOSE      yyn = yypact[yystate];      if (yyn > YYFLAG && yyn < YYLAST)	{	  int size = 0;	  char *msg;	  int x, count;	  count = 0;	  /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */	  for (x = (yyn < 0 ? -yyn : 0);	       x < (sizeof(yytname) / sizeof(char *)); x++)	    if (yycheck[x + yyn] == x)	      size += strlen(yytname[x]) + 15, count++;	  msg = (char *) malloc(size + 15);	  if (msg != 0)	    {	      strcpy(msg, "parse error");	      if (count < 5)		{		  count = 0;		  for (x = (yyn < 0 ? -yyn : 0);		       x < (sizeof(yytname) / sizeof(char *)); x++)		    if (yycheck[x + yyn] == x)		      {			strcat(msg, count == 0 ? ", expecting `" : " or `");			strcat(msg, yytname[x]);			strcat(msg, "'");			count++;		      }		}	      yyerror(msg);	      free(msg);	    }	  else	    yyerror ("parse error; also virtual memory exceeded");	}      else#endif /* YYERROR_VERBOSE */	yyerror("parse error");    }  goto yyerrlab1;yyerrlab1:   /* here on error raised explicitly by an action */  if (yyerrstatus == 3)    {      /* if just tried and failed to reuse lookahead token after an error, discard it.  */      /* return failure if at end of input */      if (yychar == YYEOF)	YYABORT;#if YYDEBUG != 0      if (yydebug)	fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);#endif      yychar = YYEMPTY;    }  /* Else will try to reuse lookahead token     after shifting the error token.  */  yyerrstatus = 3;		/* Each real token shifted decrements this */  goto yyerrhandle;yyerrdefault:  /* current state does not do anything special for the error token. */#if 0  /* This is wrong; only states that explicitly want error tokens     should shift them.  */  yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/  if (yyn) goto yydefault;#endifyyerrpop:   /* pop the current state because it cannot handle the error token */  if (yyssp - 1 == yyss) YYABORT;  yyvsp--;  yyssp--;  yystate = *(yyssp - 1);#ifdef YYLSP_NEEDED  yylsp--;#endif#if YYDEBUG != 0  if (yydebug)    {      short *ssp1 = yyss;      fprintf (stderr, "Error: state stack now");      while (ssp1 != yyssp)	fprintf (stderr, " %d", *ssp1++);      fprintf (stderr, "\n");    }#endifyyerrhandle:  yyn = yypact[yystate];  if (yyn == YYFLAG)    goto yyerrdefault;  yyn += YYTERROR;  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)    goto yyerrdefault;  yyn = yytable[yyn];  if (yyn < 0)    {      if (yyn == YYFLAG)	goto yyerrpop;      yyn = -yyn;      goto yyreduce;    }  else if (yyn == 0)    goto yyerrpop;  if (yyn == YYFINAL)    YYACCEPT;#if YYDEBUG != 0  if (yydebug)    fprintf(stderr, "Shifting error token, ");#endif  *++yyvsp = yylval;#ifdef YYLSP_NEEDED  *++yylsp = yylloc;#endif  yystate = yyn;  goto yynewstate;}