rem: yysize += yystrlen (yytname[yyx]) + 15, yycount++; yysize += yystrlen ("syntax error, unexpected ") + 1; yysize += yystrlen (yytname[yytype]);
add: { yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]); yycount += 1; if (yycount == 5) { yysize = 0; break; } } yysize += (sizeof ("syntax error, unexpected ") + yystrlen (yytname[yytype]));
context: int yyparse (void *YYPARSE_PARAM)# elseint yyparse (YYPARSE_PARAM)  void *YYPARSE_PARAM;# endif#else /* ! YYPARSE_PARAM */#if defined (__STDC__) || defined (__cplusplus)intyyparse (void)#elseintyyparse ()#endif#endif{  /* The lookahead symbol.  */int yychar;/* The semantic value of the lookahead symbol.  */YYSTYPE yylval;/* Number of syntax errors so far.  */int yynerrs;  register int yystate;  register int yyn;  int yyresult;  /* Number of tokens to shift before error messages enabled.  */  int yyerrstatus;  /* Lookahead token as an internal (translated) token number.  */  int yytoken = 0;  /* Three stacks and their tools:     `yyss': related to states,     `yyvs': related to semantic values,     `yyls': related to locations.     Refer to the stacks thru separate pointers, to allow yyoverflow     to reallocate them elsewhere.  */  /* The state stack.  */  short	yyssa[YYINITDEPTH];  short *yyss = yyssa;  register short *yyssp;  /* The semantic value stack.  */  YYSTYPE yyvsa[YYINITDEPTH];  YYSTYPE *yyvs = yyvsa;  register YYSTYPE *yyvsp;#define YYPOPSTACK   (yyvsp--, yyssp--)  YYSIZE_T yystacksize = YYINITDEPTH;  /* The variables used to return semantic value and location from the     action routines.  */  YYSTYPE yyval;  /* When reducing, the number of symbols on the RHS of the reduced     rule.  */  int yylen;  YYDPRINTF ((stderr, "Starting parse\n"));  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;  goto yysetstate;/*------------------------------------------------------------.| yynewstate -- Push a new state, which is found in yystate.  |`------------------------------------------------------------*/ yynewstate:  /* In all cases, when you get here, the value and location stacks     have just been pushed. so pushing a state here evens the stacks.     */  yyssp++; yysetstate:  *yyssp = yystate;  if (yyss + yystacksize - 1 <= yyssp)    {      /* Get the current used size of the three stacks, in elements.  */      YYSIZE_T yysize = yyssp - yyss + 1;#ifdef yyoverflow      {	/* 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;	/* Each stack pointer address is followed by the size of the	   data in use in that stack, in bytes.  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, yysize * sizeof (*yyssp),		    &yyvs1, yysize * sizeof (*yyvsp),		    &yystacksize);	yyss = yyss1;	yyvs = yyvs1;      }#else /* no yyoverflow */# ifndef YYSTACK_RELOCATE      goto yyoverflowlab;# else      /* Extend the stack our own way.  */      if (YYMAXDEPTH <= yystacksize)	goto yyoverflowlab;      yystacksize *= 2;      if (YYMAXDEPTH < yystacksize)	yystacksize = YYMAXDEPTH;      {	short *yyss1 = yyss;	union yyalloc *yyptr =	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));	if (! yyptr)	  goto yyoverflowlab;	YYSTACK_RELOCATE (yyss);	YYSTACK_RELOCATE (yyvs);#  undef YYSTACK_RELOCATE	if (yyss1 != yyssa)	  YYSTACK_FREE (yyss1);      }# endif#endif /* no yyoverflow */      yyssp = yyss + yysize - 1;      yyvsp = yyvs + yysize - 1;      YYDPRINTF ((stderr, "Stack size increased to %lu\n",		  (unsigned long int) yystacksize));      if (yyss + yystacksize - 1 <= yyssp)	YYABORT;    }  YYDPRINTF ((stderr, "Entering state %d\n", yystate));  goto yybackup;/*-----------.| 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 == YYPACT_NINF)    goto yydefault;  /* Not known => get a lookahead token if don't already have one.  */  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */  if (yychar == YYEMPTY)    {      YYDPRINTF ((stderr, "Reading a token: "));      yychar = YYLEX;    }  if (yychar <= YYEOF)    {      yychar = yytoken = YYEOF;      YYDPRINTF ((stderr, "Now at end of input.\n"));    }  else    {      yytoken = YYTRANSLATE (yychar);      YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);    }  /* If the proper action on seeing token YYTOKEN is to reduce or to     detect an error, take that action.  */  yyn += yytoken;  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)    goto yydefault;  yyn = yytable[yyn];  if (yyn <= 0)    {      if (yyn == 0 || yyn == YYTABLE_NINF)	goto yyerrlab;      yyn = -yyn;      goto yyreduce;    }  if (yyn == YYFINAL)    YYACCEPT;  /* Shift the lookahead token.  */  YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));  /* Discard the token being shifted unless it is eof.  */  if (yychar != YYEOF)    yychar = YYEMPTY;  *++yyvsp = yylval;  /* Count tokens shifted since error; after three, turn off error     status.  */  if (yyerrstatus)    yyerrstatus--;  yystate = yyn;  goto yynewstate;/*-----------------------------------------------------------.| yydefault -- do the default action for the current state.  |`-----------------------------------------------------------*/yydefault:  yyn = yydefact[yystate];  if (yyn == 0)    goto yyerrlab;  goto yyreduce;/*-----------------------------.| yyreduce -- Do a reduction.  |`-----------------------------*/yyreduce:  /* yyn is the number of a rule to reduce with.  */  yylen = yyr2[yyn];  /* If YYLEN is nonzero, implement the default value of the action:     `$$ = $1'.     Otherwise, the following line sets YYVAL to garbage.     This behavior is undocumented and Bison     users should not rely upon it.  Assigning to YYVAL     unconditionally makes the parser a bit smaller, and it avoids a     GCC warning that YYVAL may be used uninitialized.  */  yyval = yyvsp[1-yylen];  YY_REDUCE_PRINT (yyn);  switch (yyn)    {        case 4:#line 195 "getdate.y"    { PC.times_seen++; }    break;  case 5:#line 197 "getdate.y"    { PC.local_zones_seen++; }    break;  case 6:#line 199 "getdate.y"    { PC.zones_seen++; }    break;  case 7:#line 201 "getdate.y"    { PC.dates_seen++; }    break;  case 8:#line 203 "getdate.y"    { PC.days_seen++; }    break;  case 9:#line 205 "getdate.y"    { PC.rels_seen++; }    break;  case 11:#line 211 "getdate.y"    {	PC.hour = yyvsp[-1].textintval.value;	PC.minutes = 0;	PC.seconds = 0;	PC.meridian = yyvsp[0].intval;      }    break;  case 12:#line 218 "getdate.y"    {	PC.hour = yyvsp[-3].textintval.value;	PC.minutes = yyvsp[-1].textintval.value;	PC.seconds = 0;	PC.meridian = yyvsp[0].intval;      }    break;  case 13:#line 225 "getdate.y"    {	PC.hour = yyvsp[-3].textintval.value;	PC.minutes = yyvsp[-1].textintval.value;	PC.meridian = MER24;	PC.zones_seen++;	PC.time_zone = yyvsp[0].textintval.value % 100 + (yyvsp[0].textintval.value / 100) * 60;      }    break;  case 14:#line 233 "getdate.y"    {	PC.hour = yyvsp[-5].textintval.value;	PC.minutes = yyvsp[-3].textintval.value;	PC.seconds = yyvsp[-1].textintval.value;	PC.meridian = yyvsp[0].intval;      }    break;  case 15:#line 240 "getdate.y"    {	PC.hour = yyvsp[-5].textintval.value;	PC.minutes = yyvsp[-3].textintval.value;	PC.seconds = yyvsp[-1].textintval.value;	PC.meridian = MER24;	PC.zones_seen++;	PC.time_zone = yyvsp[0].textintval.value % 100 + (yyvsp[0].textintval.value / 100) * 60;      }    break;  case 16:#line 252 "getdate.y"    { PC.local_isdst = yyvsp[0].intval; }    break;  case 17:#line 254 "getdate.y"    { PC.local_isdst = yyvsp[-1].intval < 0 ? 1 : yyvsp[-1].intval + 1; }    break;  case 18:#line 259 "getdate.y"    { PC.time_zone = yyvsp[0].intval; }    break;  case 19:#line 261 "getdate.y"    { PC.time_zone = yyvsp[0].intval + 60; }    break;  case 20:#line 263 "getdate.y"    { PC.time_zone = yyvsp[-1].intval + 60; }    break;  case 21:#line 268 "getdate.y"    {	PC.day_ordinal = 1;	PC.day_number = yyvsp[0].intval;      }    break;  case 22:#line 273 "getdate.y"    {	PC.day_ordinal = 1;	PC.day_number = yyvsp[-1].intval;      }    break;  case 23:#line 278 "getdate.y"    {	PC.day_ordinal = yyvsp[-1].textintval.value;	PC.day_number = yyvsp[0].intval;      }    break;  case 24:#line 286 "getdate.y"    {	PC.month = yyvsp[-2].textintval.value;	PC.day = yyvsp[0].textintval.value;      }    break;  case 25:#line 291 "getdate.y"    {	/* Interpret as YYYY/MM/DD if the first value has 4 or more digits,	   otherwise as MM/DD/YY.	   The goal in recognizing YYYY/MM/DD is solely to support legacy	   machine-generated dates like those in an RCS log listing.  If	   you want portability, use the ISO 8601 format.  */	if (4 <= yyvsp[-4].textintval.digits)	  {	    PC.year = yyvsp[-4].textintval;	    PC.month = yyvsp[-2].textintval.value;	    PC.day = yyvsp[0].textintval.value;	  }	else	  {	    PC.month = yyvsp[-4].textintval.value;	    PC.day = yyvsp[-2].textintval.value;	    PC.year = yyvsp[0].textintval;	  }      }    break;  case 26:#line 311 "getdate.y"    {	/* ISO 8601 format.  YYYY-MM-DD.  */	PC.year = yyvsp[-2].textintval;	PC.month = -yyvsp[-1].textintval.value;	PC.day = -yyvsp[0].textintval.value;      }    break;  case 27:#line 318 "getdate.y"    {	/* e.g. 17-JUN-1992.  */	PC.day = yyvsp[-2].textintval.value;	PC.month = yyvsp[-1].intval;	PC.year.value = -yyvsp[0].textintval.value;	PC.year.digits = yyvsp[0].textintval.digits;      }    break;  case 28:#line 326 "getdate.y"    {	PC.month = yyvsp[-1].intval;	PC.day = yyvsp[0].textintval.value;      }    break;  case 29:#line 331 "getdate.y"    {	PC.month = yyvsp[-3].intval;	PC.day = yyvsp[-2].textintval.value;	PC.year = yyvsp[0].textintval;      }    break;  case 30:#line 337 "getdate.y"    {	PC.day = yyvsp[-1].textintval.value;	PC.month = yyvsp[0].intval;      }    break;  case 31:#line 342 "getdate.y"    {	PC.day = yyvsp[-2].textintval.value;	PC.month = yyvsp[-1].intval;	PC.year = yyvsp[0].textintval;      }    break;  case 32:#line 351 "getdate.y"    {	PC.rel_seconds = -PC.rel_seconds;	PC.rel_minutes = -PC.rel_minutes;	PC.rel_hour = -PC.rel_hour;	PC.rel_day = -PC.rel_day;	PC.rel_month = -PC.rel_month;	PC.rel_year = -PC.rel_year;      }    break;  case 34:#line 364 "getdate.y"    { PC.rel_year += yyvsp[-1].textintval.value * yyvsp[0].intval; }    break;  case 35:#line 366 "getdate.y"    { PC.rel_year += yyvsp[-1].textintval.value * yyvsp[0].intval; }    break;  case 36:#line 368 "getdate.y"    { PC.rel_year += yyvsp[0].intval; }    break;  case 37:#line 370 "getdate.y"    { PC.rel_month += yyvsp[-1].textintval.value * yyvsp[0].intval; }    break;  case 38:#line 372 "getdate.y"    { PC.rel_month += yyvsp[-1].textintval.value * yyvsp[0].intval; }    break;  case 39:#line 374 "getdate.y"    { PC.rel_month += yyvsp[0].intval; }    break;  case 40:#line 376 "getdate.y"    { PC.rel_day += yyvsp[-1].textintval.value * yyvsp[0].intval; }    break;  case 41:#line 378 "getdate.y"    { PC.rel_day += yyvsp[-1].textintval.value * yyvsp[0].intval; }    break;  case 42:#line 380 "getdate.y"    { PC.rel_day += yyvsp[0].intval; }    break;  case 43:#line 382 "getdate.y"    { PC.rel_hour += yyvsp[-1].textintval.value * yyvsp[0].intval; }    break;  case 44:#line 384 "getdate.y"    { PC.rel_hour += yyvsp[-1].textintval.value * yyvsp[0].intval; }    break;  case 45:#line 386 "getdate.y"    { PC.rel_hour += yyvsp[0].intval; }    break;  case 46:#line 388 "getdate.y"    { PC.rel_minutes += yyvsp[-1].textintval.value * yyvsp[0].intval; }    break;  case 47:#line 390 "getdate.y"    { PC.rel_minutes += yyvsp[-1].textintval.value * yyvsp[0].intval; }    break;  case 48:#line 392 "getdate.y"    { PC.rel_minutes += yyvsp[0].intval; }    break;  case 49:#line 394 "getdate.y"    { PC.rel_seconds += yyvsp[-1].textintval.value * yyvsp[0].intval; }    break;  case 50:#line 396 "getdate.y"    { PC.rel_seconds += yyvsp[-1].textintval.value * yyvsp[0].intval; }    break;  case 51:#line 398 "getdate.y"    { PC.rel_seconds += yyvsp[0].intval; }    break;  case 52:#line 403 "getdate.y"    {	if (PC.dates_seen	    && ! PC.rels_seen && (PC.times_seen || 2 < yyvsp[0].textintval.digits))	  PC.year = yyvsp[0].textintval;	else	  {	    if (4 < yyvsp[0].textintval.digits)	      {		PC.dates_seen++;		PC.day = yyvsp[0].textintval.value % 100;		PC.month = (yyvsp[0].textintval.value / 100) % 100;		PC.year.value = yyvsp[0].textintval.value / 10000;		PC.year.digits = yyvsp[0].textintval.digits - 4;	      }	    else	      {		PC.times_seen++;		if (yyvsp[0].textintval.digits <= 2)		  {		    PC.hour = yyvsp[0].textintval.value;		    PC.minutes = 0;		  }		else		  {		    PC.hour = yyvsp[0].textintval.value / 100;		    PC.minutes = yyvsp[0].textintval.value % 100;		  }		PC.seconds = 0;		PC.meridian = MER24;	      }	  }      }    break;  case 53:#line 439 "getdate.y"    { yyval.intval = MER24; }    break;  case 54:#line 441 "getdate.y"    { yyval.intval = yyvsp[0].intval; }    break;    }/* Line 999 of yacc.c.  */#line 1593 "getdate.c"  yyvsp -= yylen;  yyssp -= yylen;  YY_STACK_PRINT (yyss, yyssp);  *++yyvsp = yyval;  /* 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 - YYNTOKENS] + *yyssp;  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)    yystate = yytable[yystate];  else    yystate = yydefgoto[yyn - YYNTOKENS];  goto yynewstate;/*------------------------------------.| yyerrlab -- here on detecting error |`------------------------------------*/yyerrlab:  /* If not already recovering from an error, report this error.  */  if (!yyerrstatus)    {      ++yynerrs;#if YYERROR_VERBOSE      yyn = yypact[yystate];      if (YYPACT_NINF < yyn && yyn < YYLAST)	{	  YYSIZE_T yysize = 0;	  int yytype = YYTRANSLATE (yychar);	  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 && yyx != YYTERROR)	      yysize += yystrlen (yytname[yyx]) + 15, yycount++;	  yysize += yystrlen ("syntax error, unexpected ") + 1;	  yysize += yystrlen (yytname[yytype]);	  yymsg = (char *) YYSTACK_ALLOC (yysize);	  if (yymsg != 0)	    {	      char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");	      yyp = yystpcpy (yyp, yytname[yytype]);	      if (yycount < 5)		{		  yycount = 0;		  for (yyx = yyn < 0 ? -yyn : 0;		       yyx < (int) (sizeof (yytname) / sizeof (char *));		       yyx++)		    if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)		      {			const char *yyq = ! yycount ? ", expecting " : " or ";			yyp = yystpcpy (yyp, yyq);			yyp = yystpcpy (yyp, yytname[yyx]);			yycount++;		      }		}	      yyerror (yymsg);	      YYSTACK_FREE (yymsg);	    }	  else	    yyerror ("syntax error; also virtual memory exhausted");	}      else#endif /* YYERROR_VERBOSE */	yyerror ("syntax error");    }  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)        {	  /* Pop the error token.  */          YYPOPSTACK;	  /* Pop the rest of the stack.  */	  while (yyss < yyssp)	    {	      YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);	      yydestruct (yystos[*yyssp], yyvsp);	      YYPOPSTACK;	    }	  YYABORT;        }      YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);      yydestruct (yytoken, &yylval);      yychar = YYEMPTY;    }  /* Else will try to reuse lookahead token after shifting the error     token.  */  goto yyerrlab1;/*----------------------------------------------------.| yyerrlab1 -- error raised explicitly by an action.  |`----------------------------------------------------*/yyerrlab1:  yyerrstatus = 3;	/* Each real token shifted decrements this.  */  for (;;)    {      yyn = yypact[yystate];      if (yyn != YYPACT_NINF)	{	  yyn += YYTERROR;	  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)	    {	      yyn = yytable[yyn];	      if (0 < yyn)		break;	    }	}      /* Pop the current state because it cannot handle the error token.  */      if (yyssp == yyss)	YYABORT;      YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);      yydestruct (yystos[yystate], yyvsp);      yyvsp--;      yystate = *--yyssp;      YY_STACK_PRINT (yyss, yyssp);    }  if (yyn == YYFINAL)    YYACCEPT;  YYDPRINTF ((stderr, "Shifting error token, "));  *++yyvsp = yylval;  yystate = yyn;  goto yynewstate;/*-------------------------------------.| yyacceptlab -- YYACCEPT comes here.  |`-------------------------------------*/yyacceptlab:  yyresult = 0;  goto yyreturn;/*-----------------------------------.| yyabortlab -- YYABORT comes here.  |`-----------------------------------*/yyabortlab:  yyresult = 1;  goto yyreturn;#ifndef yyoverflow/*----------------------------------------------.| yyoverflowlab -- parser overflow comes here.  |`----------------------------------------------*/yyoverflowlab:  yyerror ("parser stack overflow");  yyresult = 2;  /* Fall through.  */#endifyyreturn:#ifndef yyoverflow  if (yyss != yyssa)    YYSTACK_FREE (yyss);#endif  return yyresult;}