/* Print the symbols being reduced, and their result.  */      for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)	YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);      YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);    }#endif  switch (yyn) {case 1:#line 153 "plural.y"{	    if (yyvsp[0].exp == NULL)	      YYABORT;	    ((struct parse_args *) arg)->res = yyvsp[0].exp;	  }    break;case 2:#line 161 "plural.y"{	    yyval.exp = new_exp_3 (qmop, yyvsp[-4].exp, yyvsp[-2].exp, yyvsp[0].exp);	  }    break;case 3:#line 165 "plural.y"{	    yyval.exp = new_exp_2 (lor, yyvsp[-2].exp, yyvsp[0].exp);	  }    break;case 4:#line 169 "plural.y"{	    yyval.exp = new_exp_2 (land, yyvsp[-2].exp, yyvsp[0].exp);	  }    break;case 5:#line 173 "plural.y"{	    yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);	  }    break;case 6:#line 177 "plural.y"{	    yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);	  }    break;case 7:#line 181 "plural.y"{	    yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);	  }    break;case 8:#line 185 "plural.y"{	    yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);	  }    break;case 9:#line 189 "plural.y"{	    yyval.exp = new_exp_1 (lnot, yyvsp[0].exp);	  }    break;case 10:#line 193 "plural.y"{	    yyval.exp = new_exp_0 (var);	  }    break;case 11:#line 197 "plural.y"{	    if ((yyval.exp = new_exp_0 (num)) != NULL)	      yyval.exp->val.num = yyvsp[0].num;	  }    break;case 12:#line 202 "plural.y"{	    yyval.exp = yyvsp[-1].exp;	  }    break;}#line 705 "bison.simple"  yyvsp -= yylen;  yyssp -= yylen;#if YYLSP_NEEDED  yylsp -= yylen;#endif#if YYDEBUG  if (yydebug)    {      short *yyssp1 = yyss - 1;      YYFPRINTF (stderr, "state stack now");      while (yyssp1 != yyssp)	YYFPRINTF (stderr, " %d", *++yyssp1);      YYFPRINTF (stderr, "\n");    }#endif  *++yyvsp = yyval;#if YYLSP_NEEDED  *++yylsp = yyloc;#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;  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)    yystate = yytable[yystate];  else    yystate = yydefgoto[yyn - YYNTBASE];  goto yynewstate;/*------------------------------------.| yyerrlab -- here on detecting error |`------------------------------------*/yyerrlab:  /* If not already recovering from an error, report this error.  */  if (!yyerrstatus)    {      ++yynerrs;#ifdef YYERROR_VERBOSE      yyn = yypact[yystate];      if (yyn > YYFLAG && yyn < YYLAST)	{	  YYSIZE_T yysize = 0;	  char *yymsg;	  int yyx, yycount;	  yycount = 0;	  /* Start YYX at -YYN if negative to avoid negative indexes in	     YYCHECK.  */	  for (yyx = yyn < 0 ? -yyn : 0;	       yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)	    if (yycheck[yyx + yyn] == yyx)	      yysize += yystrlen (yytname[yyx]) + 15, yycount++;	  yysize += yystrlen ("parse error, unexpected ") + 1;	  yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);	  yymsg = (char *) YYSTACK_ALLOC (yysize);	  if (yymsg != 0)	    {	      char *yyp = yystpcpy (yymsg, "parse error, unexpected ");	      yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);	      if (yycount < 5)		{		  yycount = 0;		  for (yyx = yyn < 0 ? -yyn : 0;		       yyx < (int) (sizeof (yytname) / sizeof (char *));		       yyx++)		    if (yycheck[yyx + yyn] == yyx)		      {			const char *yyq = ! yycount ? ", expecting " : " or ";			yyp = yystpcpy (yyp, yyq);			yyp = yystpcpy (yyp, yytname[yyx]);			yycount++;		      }		}	      yyerror (yymsg);	      YYSTACK_FREE (yymsg);	    }	  else	    yyerror ("parse error; also virtual memory exhausted");	}      else#endif /* defined (YYERROR_VERBOSE) */	yyerror ("parse error");    }  goto yyerrlab1;/*--------------------------------------------------.| yyerrlab1 -- error raised explicitly by an action |`--------------------------------------------------*/yyerrlab1:  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;      YYDPRINTF ((stderr, "Discarding token %d (%s).\n",		  yychar, yytname[yychar1]));      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.                                                       |`-------------------------------------------------------------------*/yyerrdefault:#if 0  /* This is wrong; only states that explicitly want error tokens     should shift them.  */  /* If its default is to accept any token, ok.  Otherwise pop it.  */  yyn = yydefact[yystate];  if (yyn)    goto yydefault;#endif/*---------------------------------------------------------------.| yyerrpop -- pop the current state because it cannot handle the || error token                                                    |`---------------------------------------------------------------*/yyerrpop:  if (yyssp == yyss)    YYABORT;  yyvsp--;  yystate = *--yyssp;#if YYLSP_NEEDED  yylsp--;#endif#if YYDEBUG  if (yydebug)    {      short *yyssp1 = yyss - 1;      YYFPRINTF (stderr, "Error: state stack now");      while (yyssp1 != yyssp)	YYFPRINTF (stderr, " %d", *++yyssp1);      YYFPRINTF (stderr, "\n");    }#endif/*--------------.| yyerrhandle.  |`--------------*/yyerrhandle:  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;  YYDPRINTF ((stderr, "Shifting error token, "));  *++yyvsp = yylval;#if YYLSP_NEEDED  *++yylsp = yylloc;#endif  yystate = yyn;  goto yynewstate;/*-------------------------------------.| yyacceptlab -- YYACCEPT comes here.  |`-------------------------------------*/yyacceptlab:  yyresult = 0;  goto yyreturn;/*-----------------------------------.| yyabortlab -- YYABORT comes here.  |`-----------------------------------*/yyabortlab:  yyresult = 1;  goto yyreturn;/*---------------------------------------------.| yyoverflowab -- parser overflow comes here.  |`---------------------------------------------*/yyoverflowlab:  yyerror ("parser stack overflow");  yyresult = 2;  /* Fall through.  */yyreturn:#ifndef yyoverflow  if (yyss != yyssa)    YYSTACK_FREE (yyss);#endif  return yyresult;}#line 207 "plural.y"voidinternal_functionFREE_EXPRESSION (struct expression *exp){  if (exp == NULL)    return;  /* Handle the recursive case.  */  switch (exp->nargs)    {    case 3:      FREE_EXPRESSION (exp->val.args[2]);      /* FALLTHROUGH */    case 2:      FREE_EXPRESSION (exp->val.args[1]);      /* FALLTHROUGH */    case 1:      FREE_EXPRESSION (exp->val.args[0]);      /* FALLTHROUGH */    default:      break;    }  free (exp);}static intyylex (YYSTYPE *lval, const char **pexp){  const char *exp = *pexp;  int result;  while (1)    {      if (exp[0] == '\0')	{	  *pexp = exp;	  return YYEOF;	}      if (exp[0] != ' ' && exp[0] != '\t')	break;      ++exp;    }  result = *exp++;  switch (result)    {    case '0': case '1': case '2': case '3': case '4':    case '5': case '6': case '7': case '8': case '9':      {	unsigned long int n = result - '0';	while (exp[0] >= '0' && exp[0] <= '9')	  {	    n *= 10;	    n += exp[0] - '0';	    ++exp;	  }	lval->num = n;	result = NUMBER;      }      break;    case '=':      if (exp[0] == '=')	{	  ++exp;	  lval->op = equal;	  result = EQUOP2;	}      else	result = YYERRCODE;      break;    case '!':      if (exp[0] == '=')	{	  ++exp;	  lval->op = not_equal;	  result = EQUOP2;	}      break;    case '&':    case '|':      if (exp[0] == result)	++exp;      else	result = YYERRCODE;      break;    case '<':      if (exp[0] == '=')	{	  ++exp;	  lval->op = less_or_equal;	}      else	lval->op = less_than;      result = CMPOP2;      break;    case '>':      if (exp[0] == '=')	{	  ++exp;	  lval->op = greater_or_equal;	}      else	lval->op = greater_than;      result = CMPOP2;      break;    case '*':      lval->op = mult;      result = MULOP2;      break;    case '/':      lval->op = divide;      result = MULOP2;      break;    case '%':      lval->op = module;      result = MULOP2;      break;    case '+':      lval->op = plus;      result = ADDOP2;      break;    case '-':      lval->op = minus;      result = ADDOP2;      break;    case 'n':    case '?':    case ':':    case '(':    case ')':      /* Nothing, just return the character.  */      break;    case ';':    case '\n':    case '\0':      /* Be safe and let the user call this function again.  */      --exp;      result = YYEOF;      break;    default:      result = YYERRCODE;#if YYDEBUG != 0      --exp;#endif      break;    }  *pexp = exp;  return result;}static voidyyerror (const char *str){  /* Do nothing.  We don't print error messages here.  */}