#line 207 "plural.y"{	    yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);	  ;    break;}case 8:#line 211 "plural.y"{	    yyval.exp = new_exp_2 (yyvsp[-1].op, yyvsp[-2].exp, yyvsp[0].exp);	  ;    break;}case 9:#line 215 "plural.y"{	    yyval.exp = new_exp_1 (lnot, yyvsp[0].exp);	  ;    break;}case 10:#line 219 "plural.y"{	    yyval.exp = new_exp_0 (var);	  ;    break;}case 11:#line 223 "plural.y"{	    if ((yyval.exp = new_exp_0 (num)) != NULL)	      yyval.exp->val.num = yyvsp[0].num;	  ;    break;}case 12:#line 228 "plural.y"{	    yyval.exp = yyvsp[-1].exp;	  ;    break;}}   /* the action file gets copied in in place of this dollarsign */#line 543 "/home/haible/gnu/arch/linuxlibc6/share/bison.simple"  yyvsp -= yylen;  yyssp -= yylen;#ifdef YYLSP_NEEDED  yylsp -= yylen;#endif#if YYDEBUG != 0  if (yydebug)    {      short *ssp1 = yyss - 1;      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;  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)    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 == yyss) YYABORT;  yyvsp--;  yystate = *--yyssp;#ifdef YYLSP_NEEDED  yylsp--;#endif#if YYDEBUG != 0  if (yydebug)    {      short *ssp1 = yyss - 1;      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; yyacceptlab:  /* YYACCEPT comes here.  */  if (yyfree_stacks)    {      free (yyss);      free (yyvs);#ifdef YYLSP_NEEDED      free (yyls);#endif    }  return 0; yyabortlab:  /* YYABORT comes here.  */  if (yyfree_stacks)    {      free (yyss);      free (yyvs);#ifdef YYLSP_NEEDED      free (yyls);#endif    }  return 1;}#line 233 "plural.y"voidinternal_functionFREE_EXPRESSION (exp)     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 (lval, pexp)     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 (str)     const char *str;{  /* Do nothing.  We don't print error messages here.  */}