date.c

Bug Summary

File:	src/usr.bin/cvs/obj/date.c
Warning:	line 1445, column 14 Use of zero-allocated memory
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name date.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/usr.bin/cvs/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/usr.bin/cvs -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/usr.bin/cvs/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c date.c
1#include <stdlib.h>
2#include <string.h>
3#define YYBYACC1 1
4#define YYMAJOR1 1
5#define YYMINOR9 9
6#define YYLEXyylex() yylex()
7#define YYEMPTY-1 -1
8#define yyclearin(yychar=(-1)) (yychar=(YYEMPTY-1))
9#define yyerrok(yyerrflag=0) (yyerrflag=0)
10#define YYRECOVERING()(yyerrflag!=0) (yyerrflag!=0)
11#define YYPREFIX"yy" "yy"
12#line 2 "/usr/src/usr.bin/cvs/date.y"
13/*	$OpenBSD: date.y,v 1.26 2017/07/20 13:39:11 okan Exp $	*/
14 
15/*
16**  Originally written by Steven M. Bellovin <smb@research.att.com> while
17**  at the University of North Carolina at Chapel Hill.  Later tweaked by
18**  a couple of people on Usenet.  Completely overhauled by Rich $alz
19**  <rsalz@bbn.com> and Jim Berets <jberets@bbn.com> in August, 1990;
20**
21**  This grammar has 10 shift/reduce conflicts.
22**
23**  This code is in the public domain and has no copyright.
24*/
25/* SUPPRESS 287 on yaccpar_sccsid *//* Unused static variable */
26/* SUPPRESS 288 on yyerrlab *//* Label unused */
27 
28#include <ctype.h>
29#include <string.h>
30#include <time.h>
31 
32#include "cvs.h"
33 
34#define YEAR_EPOCH1970	1970
35#define YEAR_TMORIGIN1900	1900
36#define HOUR(x)((time_t)(x) * 60)		((time_t)(x) * 60)
37#define SECSPERDAY(24L * 60L * 60L)	(24L * 60L * 60L)
38 
39 
40/* An entry in the lexical lookup table */
41typedef struct _TABLE {
42	char	*name;
43	int	type;
44	time_t	value;
45} TABLE;
46 
47 
48/*  Daylight-savings mode:  on, off, or not yet known. */
49typedef enum _DSTMODE {
50	DSTon, DSToff, DSTmaybe
51} DSTMODE;
52 
53/*  Meridian:  am, pm, or 24-hour style. */
54typedef enum _MERIDIAN {
55	MERam, MERpm, MER24
56} MERIDIAN;
57 
58 
59/*
60 *  Global variables.  We could get rid of most of these by using a good
61 *  union as the yacc stack.  (This routine was originally written before
62 *  yacc had the %union construct.)  Maybe someday; right now we only use
63 *  the %union very rarely.
64 */
65static const char	*yyInput;
66static DSTMODE	yyDSTmode;
67static time_t	yyDayOrdinal;
68static time_t	yyDayNumber;
69static int	yyHaveDate;
70static int	yyHaveDay;
71static int	yyHaveRel;
72static int	yyHaveTime;
73static int	yyHaveZone;
74static time_t	yyTimezone;
75static time_t	yyDay;
76static time_t	yyHour;
77static time_t	yyMinutes;
78static time_t	yyMonth;
79static time_t	yySeconds;
80static time_t	yyYear;
81static MERIDIAN	yyMeridian;
82static time_t	yyRelMonth;
83static time_t	yyRelSeconds;
84 
85 
86static int	yyerror(const char *);
87static int	yylex(void);
88static int	yyparse(void);
89static int	lookup(char *);
90 
91#line 82 "/usr/src/usr.bin/cvs/date.y"
92#ifndef YYSTYPE_DEFINED
93#define YYSTYPE_DEFINED
94typedef union {
95	time_t		Number;
96	enum _MERIDIAN	Meridian;
97} YYSTYPE;
98#endif /* YYSTYPE_DEFINED */
99#line 100 "date.c"
100#define tAGO257 257
101#define tDAY258 258
102#define tDAYZONE259 259
103#define tID260 260
104#define tMERIDIAN261 261
105#define tMINUTE_UNIT262 262
106#define tMONTH263 263
107#define tMONTH_UNIT264 264
108#define tSEC_UNIT265 265
109#define tSNUMBER266 266
110#define tUNUMBER267 267
111#define tZONE268 268
112#define tDST269 269
113#define YYERRCODE256 256
114const short yylhs[] =
115	{                                        -1,
116    0,    0,    2,    2,    2,    2,    2,    2,    3,    3,
117    3,    3,    3,    4,    4,    4,    6,    6,    6,    5,
118    5,    5,    5,    5,    5,    5,    5,    7,    7,    9,
119    9,    9,    9,    9,    9,    9,    9,    9,    8,    1,
120    1,
121};
122const short yylen[] =
123	{                                         2,
124    0,    2,    1,    1,    1,    1,    1,    1,    2,    4,
125    4,    6,    6,    1,    1,    2,    1,    2,    2,    3,
126    5,    3,    3,    2,    4,    2,    3,    2,    1,    2,
127    2,    1,    2,    2,    1,    2,    2,    1,    1,    0,
128    1,
129};
130const short yydefred[] =
131	{                                      1,
132    0,    0,   15,   32,    0,   38,   35,    0,    0,    0,
133    2,    3,    4,    5,    6,    7,    8,    0,   18,    0,
134   31,   36,   33,   19,    9,   30,    0,   37,   34,    0,
135    0,    0,   16,   28,    0,   23,   27,   22,    0,    0,
136   25,   41,   11,    0,   10,    0,    0,   21,   13,   12,
137};
138const short yydgoto[] =
139	{                                       1,
140   45,   11,   12,   13,   14,   15,   16,   17,   18,
141};
142const short yysindex[] =
143	{                                      0,
144 -249,  -38,    0,    0, -260,    0,    0, -240,  -47, -248,
145    0,    0,    0,    0,    0,    0,    0, -237,    0,  -18,
146    0,    0,    0,    0,    0,    0, -262,    0,    0, -239,
147 -238, -236,    0,    0, -235,    0,    0,    0,  -56,  -19,
148    0,    0,    0, -234,    0, -232, -258,    0,    0,    0,};
149const short yyrindex[] =
150	{                                      0,
151    0,    1,    0,    0,    0,    0,    0,    0,   69,   12,
152    0,    0,    0,    0,    0,    0,    0,   23,    0,   34,
153    0,    0,    0,    0,    0,    0,   67,    0,    0,    0,
154    0,    0,    0,    0,    0,    0,    0,    0,   56,   45,
155    0,    0,    0,    0,    0,    0,   56,    0,    0,    0,};
156const short yygindex[] =
157	{                                      0,
158  -17,    0,    0,    0,    0,    0,    0,    0,    0,
159};
160#define YYTABLESIZE337 337
161const short yytable[] =
162	{                                      32,
163   17,   44,   42,   36,   37,   19,   20,   49,    2,    3,
164   31,   14,    4,    5,    6,    7,    8,    9,   10,   34,
165   33,   21,   29,   22,   23,   35,   38,   46,   39,   50,
166   40,   41,   47,   24,   48,    0,    0,    0,    0,    0,
167    0,    0,    0,    0,   20,    0,    0,    0,    0,    0,
168    0,    0,    0,    0,    0,   40,    0,    0,    0,    0,
169    0,    0,    0,    0,    0,    0,   26,    0,   39,    0,
170    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
171    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
172    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
173    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
174    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
175    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
176    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
177    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
178    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
179    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
180    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
181    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
182    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
183    0,    0,    0,    0,   42,    0,    0,    0,    0,   43,
184   24,    0,    0,   25,   26,   27,   28,   29,   30,    0,
185    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
186    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
187    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
188    0,    0,    0,    0,    0,    0,    0,    0,   17,   17,
189    0,    0,   17,   17,   17,   17,   17,   17,   17,   14,
190   14,    0,    0,   14,   14,   14,   14,   14,   14,   14,
191   29,   29,    0,    0,   29,   29,   29,   29,   29,   29,
192   29,   24,   24,    0,    0,   24,   24,   24,   24,   24,
193   24,   24,   20,   20,    0,    0,   20,   20,   20,   20,
194   20,   20,   20,   40,   40,    0,    0,   40,   40,   40,
195   40,    0,   40,   40,   26,   26,    0,   39,   26,   26,
196   26,   26,    0,    0,   26,   39,   39,
197};
198const short yycheck[] =
199	{                                      47,
200    0,   58,  261,  266,  267,   44,  267,  266,  258,  259,
201   58,    0,  262,  263,  264,  265,  266,  267,  268,  257,
202  269,  262,    0,  264,  265,   44,  266,   47,  267,   47,
203  267,  267,  267,    0,  267,   -1,   -1,   -1,   -1,   -1,
204   -1,   -1,   -1,   -1,    0,   -1,   -1,   -1,   -1,   -1,
205   -1,   -1,   -1,   -1,   -1,    0,   -1,   -1,   -1,   -1,
206   -1,   -1,   -1,   -1,   -1,   -1,    0,   -1,    0,   -1,
207   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
208   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
209   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
210   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
211   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
212   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
213   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
214   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
215   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
216   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
217   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
218   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
219   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
220   -1,   -1,   -1,   -1,  261,   -1,   -1,   -1,   -1,  266,
221  258,   -1,   -1,  261,  262,  263,  264,  265,  266,   -1,
222   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
223   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
224   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
225   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  258,  259,
226   -1,   -1,  262,  263,  264,  265,  266,  267,  268,  258,
227  259,   -1,   -1,  262,  263,  264,  265,  266,  267,  268,
228  258,  259,   -1,   -1,  262,  263,  264,  265,  266,  267,
229  268,  258,  259,   -1,   -1,  262,  263,  264,  265,  266,
230  267,  268,  258,  259,   -1,   -1,  262,  263,  264,  265,
231  266,  267,  268,  258,  259,   -1,   -1,  262,  263,  264,
232  265,   -1,  267,  268,  258,  259,   -1,  259,  262,  263,
233  264,  265,   -1,   -1,  268,  267,  268,
234};
235#define YYFINAL1 1
236#ifndef YYDEBUG0
237#define YYDEBUG0 0
238#endif
239#define YYMAXTOKEN269 269
240#if YYDEBUG0
241const char * const yyname[] =
242	{
243"end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2440,0,0,0,0,0,0,0,0,0,"','",0,0,"'/'",0,0,0,0,0,0,0,0,0,0,"':'",0,0,0,0,0,0,0,0,0,
2450,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2460,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2470,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2480,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
2490,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"tAGO","tDAY",
250"tDAYZONE","tID","tMERIDIAN","tMINUTE_UNIT","tMONTH","tMONTH_UNIT","tSEC_UNIT",
251"tSNUMBER","tUNUMBER","tZONE","tDST",
252};
253const char * const yyrule[] =
254	{"$accept : spec",
255"spec :",
256"spec : spec item",
257"item : time",
258"item : zone",
259"item : date",
260"item : day",
261"item : rel",
262"item : number",
263"time : tUNUMBER tMERIDIAN",
264"time : tUNUMBER ':' tUNUMBER o_merid",
265"time : tUNUMBER ':' tUNUMBER tSNUMBER",
266"time : tUNUMBER ':' tUNUMBER ':' tUNUMBER o_merid",
267"time : tUNUMBER ':' tUNUMBER ':' tUNUMBER tSNUMBER",
268"zone : tZONE",
269"zone : tDAYZONE",
270"zone : tZONE tDST",
271"day : tDAY",
272"day : tDAY ','",
273"day : tUNUMBER tDAY",
274"date : tUNUMBER '/' tUNUMBER",
275"date : tUNUMBER '/' tUNUMBER '/' tUNUMBER",
276"date : tUNUMBER tSNUMBER tSNUMBER",
277"date : tUNUMBER tMONTH tSNUMBER",
278"date : tMONTH tUNUMBER",
279"date : tMONTH tUNUMBER ',' tUNUMBER",
280"date : tUNUMBER tMONTH",
281"date : tUNUMBER tMONTH tUNUMBER",
282"rel : relunit tAGO",
283"rel : relunit",
284"relunit : tUNUMBER tMINUTE_UNIT",
285"relunit : tSNUMBER tMINUTE_UNIT",
286"relunit : tMINUTE_UNIT",
287"relunit : tSNUMBER tSEC_UNIT",
288"relunit : tUNUMBER tSEC_UNIT",
289"relunit : tSEC_UNIT",
290"relunit : tSNUMBER tMONTH_UNIT",
291"relunit : tUNUMBER tMONTH_UNIT",
292"relunit : tMONTH_UNIT",
293"number : tUNUMBER",
294"o_merid :",
295"o_merid : tMERIDIAN",
296};
297#endif
298#ifdef YYSTACKSIZE10000
299#undef YYMAXDEPTH10000
300#define YYMAXDEPTH10000 YYSTACKSIZE10000
301#else
302#ifdef YYMAXDEPTH10000
303#define YYSTACKSIZE10000 YYMAXDEPTH10000
304#else
305#define YYSTACKSIZE10000 10000
306#define YYMAXDEPTH10000 10000
307#endif
308#endif
309#define YYINITSTACKSIZE200 200
310/* LINTUSED */
311int yydebug;
312int yynerrs;
313int yyerrflag;
314int yychar;
315short *yyssp;
316YYSTYPE *yyvsp;
317YYSTYPE yyval;
318YYSTYPE yylval;
319short *yyss;
320short *yysslim;
321YYSTYPE *yyvs;
322unsigned int yystacksize;
323int yyparse(void);
324#line 298 "/usr/src/usr.bin/cvs/date.y"
325 
326/* Month and day table. */
327static TABLE const MonthDayTable[] = {
328	{ "january",	tMONTH263,	1 },
329	{ "february",	tMONTH263,	2 },
330	{ "march",	tMONTH263,	3 },
331	{ "april",	tMONTH263,	4 },
332	{ "may",	tMONTH263,	5 },
333	{ "june",	tMONTH263,	6 },
334	{ "july",	tMONTH263,	7 },
335	{ "august",	tMONTH263,	8 },
336	{ "september",	tMONTH263,	9 },
337	{ "sept",	tMONTH263,	9 },
338	{ "october",	tMONTH263,	10 },
339	{ "november",	tMONTH263,	11 },
340	{ "december",	tMONTH263,	12 },
341	{ "sunday",	tDAY258,	0 },
342	{ "monday",	tDAY258,	1 },
343	{ "tuesday",	tDAY258,	2 },
344	{ "tues",	tDAY258,	2 },
345	{ "wednesday",	tDAY258,	3 },
346	{ "wednes",	tDAY258,	3 },
347	{ "thursday",	tDAY258,	4 },
348	{ "thur",	tDAY258,	4 },
349	{ "thurs",	tDAY258,	4 },
350	{ "friday",	tDAY258,	5 },
351	{ "saturday",	tDAY258,	6 },
352	{ NULL((void *)0) }
353};
354 
355/* Time units table. */
356static TABLE const UnitsTable[] = {
357	{ "year",	tMONTH_UNIT264,	12 },
358	{ "month",	tMONTH_UNIT264,	1 },
359	{ "fortnight",	tMINUTE_UNIT262,	14 * 24 * 60 },
360	{ "week",	tMINUTE_UNIT262,	7 * 24 * 60 },
361	{ "day",	tMINUTE_UNIT262,	1 * 24 * 60 },
362	{ "hour",	tMINUTE_UNIT262,	60 },
363	{ "minute",	tMINUTE_UNIT262,	1 },
364	{ "min",	tMINUTE_UNIT262,	1 },
365	{ "second",	tSEC_UNIT265,	1 },
366	{ "sec",	tSEC_UNIT265,	1 },
367	{ NULL((void *)0) }
368};
369 
370/* Assorted relative-time words. */
371static TABLE const OtherTable[] = {
372	{ "tomorrow",	tMINUTE_UNIT262,	1 * 24 * 60 },
373	{ "yesterday",	tMINUTE_UNIT262,	-1 * 24 * 60 },
374	{ "today",	tMINUTE_UNIT262,	0 },
375	{ "now",	tMINUTE_UNIT262,	0 },
376	{ "last",	tUNUMBER267,	-1 },
377	{ "this",	tMINUTE_UNIT262,	0 },
378	{ "next",	tUNUMBER267,	2 },
379	{ "first",	tUNUMBER267,	1 },
380/*  { "second",		tUNUMBER,	2 }, */
381	{ "third",	tUNUMBER267,	3 },
382	{ "fourth",	tUNUMBER267,	4 },
383	{ "fifth",	tUNUMBER267,	5 },
384	{ "sixth",	tUNUMBER267,	6 },
385	{ "seventh",	tUNUMBER267,	7 },
386	{ "eighth",	tUNUMBER267,	8 },
387	{ "ninth",	tUNUMBER267,	9 },
388	{ "tenth",	tUNUMBER267,	10 },
389	{ "eleventh",	tUNUMBER267,	11 },
390	{ "twelfth",	tUNUMBER267,	12 },
391	{ "ago",	tAGO257,	1 },
392	{ NULL((void *)0) }
393};
394 
395/* The timezone table. */
396/* Some of these are commented out because a time_t can't store a float. */
397static TABLE const TimezoneTable[] = {
398	{ "gmt",	tZONE268,     HOUR( 0)((time_t)(0) * 60) },	/* Greenwich Mean */
399	{ "ut",		tZONE268,     HOUR( 0)((time_t)(0) * 60) },	/* Universal (Coordinated) */
400	{ "utc",	tZONE268,     HOUR( 0)((time_t)(0) * 60) },
401	{ "wet",	tZONE268,     HOUR( 0)((time_t)(0) * 60) },	/* Western European */
402	{ "bst",	tDAYZONE259,  HOUR( 0)((time_t)(0) * 60) },	/* British Summer */
403	{ "wat",	tZONE268,     HOUR( 1)((time_t)(1) * 60) },	/* West Africa */
404	{ "at",		tZONE268,     HOUR( 2)((time_t)(2) * 60) },	/* Azores */
405#if	0
406	/* For completeness.  BST is also British Summer, and GST is
407	 * also Guam Standard. */
408	{ "bst",	tZONE268,     HOUR( 3)((time_t)(3) * 60) },	/* Brazil Standard */
409	{ "gst",	tZONE268,     HOUR( 3)((time_t)(3) * 60) },	/* Greenland Standard */
410#endif
411#if 0
412	{ "nft",	tZONE268,     HOUR(3.5)((time_t)(3.5) * 60) },	/* Newfoundland */
413	{ "nst",	tZONE268,     HOUR(3.5)((time_t)(3.5) * 60) },	/* Newfoundland Standard */
414	{ "ndt",	tDAYZONE259,  HOUR(3.5)((time_t)(3.5) * 60) },	/* Newfoundland Daylight */
415#endif
416	{ "ast",	tZONE268,     HOUR( 4)((time_t)(4) * 60) },	/* Atlantic Standard */
417	{ "adt",	tDAYZONE259,  HOUR( 4)((time_t)(4) * 60) },	/* Atlantic Daylight */
418	{ "est",	tZONE268,     HOUR( 5)((time_t)(5) * 60) },	/* Eastern Standard */
419	{ "edt",	tDAYZONE259,  HOUR( 5)((time_t)(5) * 60) },	/* Eastern Daylight */
420	{ "cst",	tZONE268,     HOUR( 6)((time_t)(6) * 60) },	/* Central Standard */
421	{ "cdt",	tDAYZONE259,  HOUR( 6)((time_t)(6) * 60) },	/* Central Daylight */
422	{ "mst",	tZONE268,     HOUR( 7)((time_t)(7) * 60) },	/* Mountain Standard */
423	{ "mdt",	tDAYZONE259,  HOUR( 7)((time_t)(7) * 60) },	/* Mountain Daylight */
424	{ "pst",	tZONE268,     HOUR( 8)((time_t)(8) * 60) },	/* Pacific Standard */
425	{ "pdt",	tDAYZONE259,  HOUR( 8)((time_t)(8) * 60) },	/* Pacific Daylight */
426	{ "yst",	tZONE268,     HOUR( 9)((time_t)(9) * 60) },	/* Yukon Standard */
427	{ "ydt",	tDAYZONE259,  HOUR( 9)((time_t)(9) * 60) },	/* Yukon Daylight */
428	{ "hst",	tZONE268,     HOUR(10)((time_t)(10) * 60) },	/* Hawaii Standard */
429	{ "hdt",	tDAYZONE259,  HOUR(10)((time_t)(10) * 60) },	/* Hawaii Daylight */
430	{ "cat",	tZONE268,     HOUR(10)((time_t)(10) * 60) },	/* Central Alaska */
431	{ "ahst",	tZONE268,     HOUR(10)((time_t)(10) * 60) },	/* Alaska-Hawaii Standard */
432	{ "nt",		tZONE268,     HOUR(11)((time_t)(11) * 60) },	/* Nome */
433	{ "idlw",	tZONE268,     HOUR(12)((time_t)(12) * 60) },	/* International Date Line West */
434	{ "cet",	tZONE268,     -HOUR(1)((time_t)(1) * 60) },	/* Central European */
435	{ "met",	tZONE268,     -HOUR(1)((time_t)(1) * 60) },	/* Middle European */
436	{ "mewt",	tZONE268,     -HOUR(1)((time_t)(1) * 60) },	/* Middle European Winter */
437	{ "mest",	tDAYZONE259,  -HOUR(1)((time_t)(1) * 60) },	/* Middle European Summer */
438	{ "swt",	tZONE268,     -HOUR(1)((time_t)(1) * 60) },	/* Swedish Winter */
439	{ "sst",	tDAYZONE259,  -HOUR(1)((time_t)(1) * 60) },	/* Swedish Summer */
440	{ "fwt",	tZONE268,     -HOUR(1)((time_t)(1) * 60) },	/* French Winter */
441	{ "fst",	tDAYZONE259,  -HOUR(1)((time_t)(1) * 60) },	/* French Summer */
442	{ "eet",	tZONE268,     -HOUR(2)((time_t)(2) * 60) },	/* Eastern Europe, USSR Zone 1 */
443	{ "bt",		tZONE268,     -HOUR(3)((time_t)(3) * 60) },	/* Baghdad, USSR Zone 2 */
444#if 0
445	{ "it",		tZONE268,     -HOUR(3.5)((time_t)(3.5) * 60) },/* Iran */
446#endif
447	{ "zp4",	tZONE268,     -HOUR(4)((time_t)(4) * 60) },	/* USSR Zone 3 */
448	{ "zp5",	tZONE268,     -HOUR(5)((time_t)(5) * 60) },	/* USSR Zone 4 */
449#if 0
450	{ "ist",	tZONE268,     -HOUR(5.5)((time_t)(5.5) * 60) },/* Indian Standard */
451#endif
452	{ "zp6",	tZONE268,     -HOUR(6)((time_t)(6) * 60) },	/* USSR Zone 5 */
453#if	0
454	/* For completeness.  NST is also Newfoundland Stanard, and SST is
455	 * also Swedish Summer. */
456	{ "nst",	tZONE268,     -HOUR(6.5)((time_t)(6.5) * 60) },/* North Sumatra */
457	{ "sst",	tZONE268,     -HOUR(7)((time_t)(7) * 60) },	/* South Sumatra, USSR Zone 6 */
458#endif	/* 0 */
459	{ "wast",	tZONE268,     -HOUR(7)((time_t)(7) * 60) },	/* West Australian Standard */
460	{ "wadt",	tDAYZONE259,  -HOUR(7)((time_t)(7) * 60) },	/* West Australian Daylight */
461#if 0
462	{ "jt",		tZONE268,     -HOUR(7.5)((time_t)(7.5) * 60) },/* Java (3pm in Cronusland!) */
463#endif
464	{ "cct",	tZONE268,     -HOUR(8)((time_t)(8) * 60) },	/* China Coast, USSR Zone 7 */
465	{ "jst",	tZONE268,     -HOUR(9)((time_t)(9) * 60) },	/* Japan Standard, USSR Zone 8 */
466#if 0
467	{ "cast",	tZONE268,     -HOUR(9.5)((time_t)(9.5) * 60) },/* Central Australian Standard */
468	{ "cadt",	tDAYZONE259,  -HOUR(9.5)((time_t)(9.5) * 60) },/* Central Australian Daylight */
469#endif
470	{ "east",	tZONE268,     -HOUR(10)((time_t)(10) * 60) },	/* Eastern Australian Standard */
471	{ "eadt",	tDAYZONE259,  -HOUR(10)((time_t)(10) * 60) },	/* Eastern Australian Daylight */
472	{ "gst",	tZONE268,     -HOUR(10)((time_t)(10) * 60) },	/* Guam Standard, USSR Zone 9 */
473	{ "nzt",	tZONE268,     -HOUR(12)((time_t)(12) * 60) },	/* New Zealand */
474	{ "nzst",	tZONE268,     -HOUR(12)((time_t)(12) * 60) },	/* New Zealand Standard */
475	{ "nzdt",	tDAYZONE259,  -HOUR(12)((time_t)(12) * 60) },	/* New Zealand Daylight */
476	{ "idle",	tZONE268,     -HOUR(12)((time_t)(12) * 60) },	/* International Date Line East */
477	{  NULL((void *)0)  }
478};
479 
480/* Military timezone table. */
481static TABLE const MilitaryTable[] = {
482	{ "a",	tZONE268,	HOUR(  1)((time_t)(1) * 60) },
483	{ "b",	tZONE268,	HOUR(  2)((time_t)(2) * 60) },
484	{ "c",	tZONE268,	HOUR(  3)((time_t)(3) * 60) },
485	{ "d",	tZONE268,	HOUR(  4)((time_t)(4) * 60) },
486	{ "e",	tZONE268,	HOUR(  5)((time_t)(5) * 60) },
487	{ "f",	tZONE268,	HOUR(  6)((time_t)(6) * 60) },
488	{ "g",	tZONE268,	HOUR(  7)((time_t)(7) * 60) },
489	{ "h",	tZONE268,	HOUR(  8)((time_t)(8) * 60) },
490	{ "i",	tZONE268,	HOUR(  9)((time_t)(9) * 60) },
491	{ "k",	tZONE268,	HOUR( 10)((time_t)(10) * 60) },
492	{ "l",	tZONE268,	HOUR( 11)((time_t)(11) * 60) },
493	{ "m",	tZONE268,	HOUR( 12)((time_t)(12) * 60) },
494	{ "n",	tZONE268,	HOUR(- 1)((time_t)(- 1) * 60) },
495	{ "o",	tZONE268,	HOUR(- 2)((time_t)(- 2) * 60) },
496	{ "p",	tZONE268,	HOUR(- 3)((time_t)(- 3) * 60) },
497	{ "q",	tZONE268,	HOUR(- 4)((time_t)(- 4) * 60) },
498	{ "r",	tZONE268,	HOUR(- 5)((time_t)(- 5) * 60) },
499	{ "s",	tZONE268,	HOUR(- 6)((time_t)(- 6) * 60) },
500	{ "t",	tZONE268,	HOUR(- 7)((time_t)(- 7) * 60) },
501	{ "u",	tZONE268,	HOUR(- 8)((time_t)(- 8) * 60) },
502	{ "v",	tZONE268,	HOUR(- 9)((time_t)(- 9) * 60) },
503	{ "w",	tZONE268,	HOUR(-10)((time_t)(-10) * 60) },
504	{ "x",	tZONE268,	HOUR(-11)((time_t)(-11) * 60) },
505	{ "y",	tZONE268,	HOUR(-12)((time_t)(-12) * 60) },
506	{ "z",	tZONE268,	HOUR(  0)((time_t)(0) * 60) },
507	{ NULL((void *)0) }
508};
509 
510 
511static int
512yyerror(const char *s)
513{
514#if !defined(TEST)
515	char *str;
516 
517	(void)xasprintf(&str, "parsing date string: %s", s);
518	cvs_log(LP_ERR1, "%s", str);
519	free(str);
520#endif
521	return (0);
522}
523 
524 
525static time_t
526ToSeconds(time_t Hours, time_t Minutes, time_t	Seconds, MERIDIAN Meridian)
527{
528	if (Minutes < 0 || Minutes > 59 || Seconds < 0 || Seconds > 59)
529		return (-1);
530 
531	switch (Meridian) {
532	case MER24:
533		if (Hours < 0 || Hours > 23)
534			return (-1);
535		return (Hours * 60L + Minutes) * 60L + Seconds;
536	case MERam:
537		if (Hours < 1 || Hours > 12)
538			return (-1);
539		if (Hours == 12)
540			Hours = 0;
541		return (Hours * 60L + Minutes) * 60L + Seconds;
542	case MERpm:
543		if (Hours < 1 || Hours > 12)
544			return (-1);
545		if (Hours == 12)
546			Hours = 0;
547		return ((Hours + 12) * 60L + Minutes) * 60L + Seconds;
548	default:
549		return (-1);
550	}
551	/* NOTREACHED */
552}
553 
554 
555/* Year is either
556 * A negative number, which means to use its absolute value (why?)
557 * A number from 0 to 99, which means a year from 1900 to 1999, or
558 * The actual year (>=100).
559 */
560static time_t
561Convert(time_t Month, time_t Day, time_t Year, time_t Hours, time_t Minutes,
562    time_t Seconds, MERIDIAN Meridian, DSTMODE DSTmode)
563{
564	static int DaysInMonth[12] = {
565		31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
566	};
567	time_t	tod;
568	time_t	julian;
569	int	i;
570 
571	if (Year < 0)
572		Year = -Year;
573	if (Year < 69)
574		Year += 2000;
575	else if (Year < 100) {
576		Year += 1900;
577		if (Year < YEAR_EPOCH1970)
578			Year += 100;
579	}
580	DaysInMonth[1] = Year % 4 == 0 && (Year % 100 != 0 || Year % 400 == 0)
581	    ? 29 : 28;
582	/* XXX Sloppily check for 2038 if time_t is 32 bits */
583	if (Year < YEAR_EPOCH1970 ||
584	    (sizeof(time_t) == sizeof(int) && Year > 2038) ||
585	    Month < 1 || Month > 12 ||
586	    /* Lint fluff:  "conversion from long may lose accuracy" */
587	     Day < 1 || Day > DaysInMonth[(int)--Month])
588		return (-1);
589 
590	for (julian = Day - 1, i = 0; i < Month; i++)
591		julian += DaysInMonth[i];
592 
593	for (i = YEAR_EPOCH1970; i < Year; i++)
594		julian += 365 + (i % 4 == 0);
595	julian *= SECSPERDAY(24L * 60L * 60L);
596	julian += yyTimezone * 60L;
597 
598	if ((tod = ToSeconds(Hours, Minutes, Seconds, Meridian)) < 0)
599		return (-1);
600	julian += tod;
601	if ((DSTmode == DSTon) ||
602	    (DSTmode == DSTmaybe && localtime(&julian)->tm_isdst))
603	julian -= 60 * 60;
604	return (julian);
605}
606 
607 
608static time_t
609DSTcorrect(time_t Start, time_t Future)
610{
611	time_t	StartDay;
612	time_t	FutureDay;
613 
614	StartDay = (localtime(&Start)->tm_hour + 1) % 24;
615	FutureDay = (localtime(&Future)->tm_hour + 1) % 24;
616	return (Future - Start) + (StartDay - FutureDay) * 60L * 60L;
617}
618 
619 
620static time_t
621RelativeDate(time_t Start, time_t DayOrdinal, time_t DayNumber)
622{
623	struct tm	*tm;
624	time_t	now;
625 
626	now = Start;
627	tm = localtime(&now);
628	now += SECSPERDAY(24L * 60L * 60L) * ((DayNumber - tm->tm_wday + 7) % 7);
629	now += 7 * SECSPERDAY(24L * 60L * 60L) * (DayOrdinal <= 0 ? DayOrdinal : DayOrdinal - 1);
630	return DSTcorrect(Start, now);
631}
632 
633 
634static time_t
635RelativeMonth(time_t Start, time_t RelMonth)
636{
637	struct tm	*tm;
638	time_t	Month;
639	time_t	Year;
640 
641	if (RelMonth == 0)
642		return (0);
643	tm = localtime(&Start);
644	Month = 12 * (tm->tm_year + 1900) + tm->tm_mon + RelMonth;
645	Year = Month / 12;
646	Month = Month % 12 + 1;
647	return DSTcorrect(Start,
648	    Convert(Month, (time_t)tm->tm_mday, Year,
649	    (time_t)tm->tm_hour, (time_t)tm->tm_min, (time_t)tm->tm_sec,
650	    MER24, DSTmaybe));
651}
652 
653 
654static int
655lookup(char *buff)
656{
657	size_t		len;
658	char		*p, *q;
659	int		i, abbrev;
660	const TABLE	*tp;
661 
662	/* Make it lowercase. */
663	for (p = buff; *p; p++)
664		if (isupper(*p))
665			*p = tolower(*p);
666 
667	if (strcmp(buff, "am") == 0 || strcmp(buff, "a.m.") == 0) {
668		yylval.Meridian = MERam;
669		return (tMERIDIAN261);
670	}
671	if (strcmp(buff, "pm") == 0 || strcmp(buff, "p.m.") == 0) {
672		yylval.Meridian = MERpm;
673		return (tMERIDIAN261);
674	}
675 
676	len = strlen(buff);
677	/* See if we have an abbreviation for a month. */
678	if (len == 3)
679		abbrev = 1;
680	else if (len == 4 && buff[3] == '.') {
681		abbrev = 1;
682		buff[3] = '\0';
683		--len;
684	} else
685		abbrev = 0;
686 
687	for (tp = MonthDayTable; tp->name; tp++) {
688		if (abbrev) {
689			if (strncmp(buff, tp->name, 3) == 0) {
690				yylval.Number = tp->value;
691				return (tp->type);
692			}
693		} else if (strcmp(buff, tp->name) == 0) {
694			yylval.Number = tp->value;
695			return (tp->type);
696		}
697	}
698 
699	for (tp = TimezoneTable; tp->name; tp++)
700		if (strcmp(buff, tp->name) == 0) {
701			yylval.Number = tp->value;
702			return (tp->type);
703		}
704 
705	if (strcmp(buff, "dst") == 0)
706		return (tDST269);
707 
708	for (tp = UnitsTable; tp->name; tp++)
709		if (strcmp(buff, tp->name) == 0) {
710			yylval.Number = tp->value;
711			return (tp->type);
712		}
713 
714	/* Strip off any plural and try the units table again. */
715	if (len != 0 && buff[len - 1] == 's') {
716		buff[len - 1] = '\0';
717		for (tp = UnitsTable; tp->name; tp++)
718			if (strcmp(buff, tp->name) == 0) {
719				yylval.Number = tp->value;
720				return (tp->type);
721			}
722		buff[len - 1] = 's';	/* Put back for "this" in OtherTable. */
723	}
724 
725	for (tp = OtherTable; tp->name; tp++)
726		if (strcmp(buff, tp->name) == 0) {
727			yylval.Number = tp->value;
728			return (tp->type);
729		}
730 
731	/* Military timezones. */
732	if (len == 1 && isalpha(*buff)) {
733		for (tp = MilitaryTable; tp->name; tp++)
734			if (strcmp(buff, tp->name) == 0) {
735				yylval.Number = tp->value;
736				return (tp->type);
737			}
738	}
739 
740	/* Drop out any periods and try the timezone table again. */
741	for (i = 0, p = q = buff; *q; q++)
742		if (*q != '.')
743			*p++ = *q;
744		else
745			i++;
746	*p = '\0';
747	if (i)
748		for (tp = TimezoneTable; tp->name; tp++)
749			if (strcmp(buff, tp->name) == 0) {
750				yylval.Number = tp->value;
751				return (tp->type);
752			}
753 
754	return (tID260);
755}
756 
757 
758static int
759yylex(void)
760{
761	char	c, *p, buff[20];
762	int	count, sign;
763 
764	for (;;) {
765		while (isspace(*yyInput))
766			yyInput++;
767 
768		if (isdigit(c = *yyInput) || c == '-' || c == '+') {
769			if (c == '-' || c == '+') {
770				sign = c == '-' ? -1 : 1;
771				if (!isdigit(*++yyInput))
772					/* skip the '-' sign */
773					continue;
774			}
775			else
776				sign = 0;
777 
778			for (yylval.Number = 0; isdigit(c = *yyInput++); )
779				yylval.Number = 10 * yylval.Number + c - '0';
780			yyInput--;
781			if (sign < 0)
782				yylval.Number = -yylval.Number;
783			return sign ? tSNUMBER266 : tUNUMBER267;
784		}
785 
786		if (isalpha(c)) {
787			for (p = buff; isalpha(c = *yyInput++) || c == '.'; )
788				if (p < &buff[sizeof buff - 1])
789					*p++ = c;
790			*p = '\0';
791			yyInput--;
792			return lookup(buff);
793		}
794		if (c != '(')
795			return *yyInput++;
796 
797		count = 0;
798		do {
799			c = *yyInput++;
800			if (c == '\0')
801				return (c);
802			if (c == '(')
803				count++;
804			else if (c == ')')
805				count--;
806		} while (count > 0);
807	}
808}
809 
810/* Yield A - B, measured in seconds.  */
811static long
812difftm(struct tm *a, struct tm *b)
813{
814	int ay = a->tm_year + (YEAR_TMORIGIN1900 - 1);
815	int by = b->tm_year + (YEAR_TMORIGIN1900 - 1);
816	int days = (
817	    /* difference in day of year */
818	    a->tm_yday - b->tm_yday
819	    /* + intervening leap days */
820	    +  ((ay >> 2) - (by >> 2))
821	    -  (ay/100 - by/100)
822	    +  ((ay/100 >> 2) - (by/100 >> 2))
823	    /* + difference in years * 365 */
824	    +  (long)(ay-by) * 365);
825	return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
826	    + (a->tm_min - b->tm_min)) + (a->tm_sec - b->tm_sec));
827}
828 
829/*
830 * date_parse()
831 *
832 * Returns the number of seconds since the Epoch corresponding to the date.
833 */
834time_t
835date_parse(const char *p)
836{
837	struct tm	gmt, tm;
838	time_t		Start, tod, nowtime, tz;
839 
840	yyInput = p;
841 
842	if (time(&nowtime) == -1 || !gmtime_r(&nowtime, &gmt) ||
843	    !localtime_r(&nowtime, &tm))
844		return -1;
845 
846	tz = difftm(&gmt, &tm) / 60;
847 
848	if (tm.tm_isdst)
849		tz += 60;
850 
851	yyYear = tm.tm_year + 1900;
852	yyMonth = tm.tm_mon + 1;
853	yyDay = tm.tm_mday;
854	yyTimezone = tz;
855	yyDSTmode = DSTmaybe;
856	yyHour = 0;
857	yyMinutes = 0;
858	yySeconds = 0;
859	yyMeridian = MER24;
860	yyRelSeconds = 0;
861	yyRelMonth = 0;
862	yyHaveDate = 0;
863	yyHaveDay = 0;
864	yyHaveRel = 0;
865	yyHaveTime = 0;
866	yyHaveZone = 0;
867 
868	if (yyparse() || yyHaveTime > 1 || yyHaveZone > 1 ||
869	    yyHaveDate > 1 || yyHaveDay > 1)
870		return (-1);
871 
872	if (yyHaveDate || yyHaveTime || yyHaveDay) {
873		Start = Convert(yyMonth, yyDay, yyYear, yyHour, yyMinutes,
874		    yySeconds, yyMeridian, yyDSTmode);
875		if (Start < 0)
876			return (-1);
877	} else {
878		Start = nowtime;
879		if (!yyHaveRel)
880			Start -= ((tm.tm_hour * 60L + tm.tm_min) * 60L) +
881			    tm.tm_sec;
882	}
883 
884	Start += yyRelSeconds;
885	Start += RelativeMonth(Start, yyRelMonth);
886 
887	if (yyHaveDay && !yyHaveDate) {
888		tod = RelativeDate(Start, yyDayOrdinal, yyDayNumber);
889		Start += tod;
890	}
891 
892	return Start;
893}
894 
895#if defined(TEST)
896/* ARGSUSED */
897int
898main(int argc, char **argv)
899{
900	char	buff[128];
901	time_t	d;
902 
903	(void)printf("Enter date, or blank line to exit.\n\t> ");
904	(void)fflush(stdout(&__sF[1]));
905	while (fgets(buff, sizeof(buff), stdin(&__sF[0])) && buff[0]) {
906		d = date_parse(buff);
907		if (d == -1)
908			(void)printf("Bad format - couldn't convert.\n");
909		else
910			(void)printf("%s", ctime(&d));
911		(void)printf("\t> ");
912		(void)fflush(stdout(&__sF[1]));
913	}
914 
915	return (0);
916}
917#endif	/* defined(TEST) */
918#line 911 "date.c"
919/* allocate initial stack or double stack size, up to YYMAXDEPTH */
920static int yygrowstack(void)
921{
922    unsigned int newsize;
923    long sslen;
924    short *newss;
925    YYSTYPE *newvs;
926 
927    if ((newsize = yystacksize) == 0)
40
←
Assuming the condition is false→
41
←
Taking false branch→
928        newsize = YYINITSTACKSIZE200;
929    else if (newsize >= YYMAXDEPTH10000)
42
←
Assuming 'newsize' is < YYMAXDEPTH→
43
←
Taking false branch→
930        return -1;
931    else if ((newsize *= 2) > YYMAXDEPTH10000)
44
←
Assuming the condition is false→
45
←
Taking false branch→
932        newsize = YYMAXDEPTH10000;
933    sslen = yyssp - yyss;
934#ifdef SIZE_MAX
935#define YY_SIZE_MAX0xffffffffU SIZE_MAX
936#else
937#define YY_SIZE_MAX0xffffffffU 0xffffffffU
938#endif
939    if (newsize && YY_SIZE_MAX0xffffffffU / newsize < sizeof *newss)
46
←
Assuming 'newsize' is 0→
940        goto bail;
941    newss = (short *)realloc(yyss, newsize * sizeof *newss);
942    if (newss == NULL((void *)0))
47
←
Assuming 'newss' is not equal to NULL→
48
←
Taking false branch→
943        goto bail;
944    yyss = newss;
945    yyssp = newss + sslen;
946    if (newsize48.1
'newsize' is 0
 && YY_SIZE_MAX0xffffffffU / newsize < sizeof *newvs)
947        goto bail;
948    newvs = (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs);
949    if (newvs == NULL((void *)0))
49
←
Assuming 'newvs' is not equal to NULL→
50
←
Taking false branch→
950        goto bail;
951    yyvs = newvs;
952    yyvsp = newvs + sslen;
953    yystacksize = newsize;
954    yysslim = yyss + newsize - 1;
955    return 0;
956bail:
957    if (yyss)
958            free(yyss);
959    if (yyvs)
960            free(yyvs);
961    yyss = yyssp = NULL((void *)0);
962    yyvs = yyvsp = NULL((void *)0);
963    yystacksize = 0;
964    return -1;
965}
966 
967#define YYABORTgoto yyabort goto yyabort
968#define YYREJECTgoto yyabort goto yyabort
969#define YYACCEPTgoto yyaccept goto yyaccept
970#define YYERRORgoto yyerrlab goto yyerrlab
971int
972yyparse(void)
973{
974    int yym, yyn, yystate;
975#if YYDEBUG0
976    const char *yys;
977 
978    if ((yys = getenv("YYDEBUG")))
979    {
980        yyn = *yys;
981        if (yyn >= '0' && yyn <= '9')
982            yydebug = yyn - '0';
983    }
984#endif /* YYDEBUG */
985 
986    yynerrs = 0;
987    yyerrflag = 0;
988    yychar = (-1);
989 
990    if (yyss == NULL((void *)0) && yygrowstack()) goto yyoverflow;
1
Assuming 'yyss' is not equal to NULL→
991    yyssp = yyss;
992    yyvsp = yyvs;
993    *yyssp = yystate = 0;
994 
995yyloop:
996    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
2
←
Taking true branch→
3
←
Control jumps to line 1103→
13
←
Taking false branch→
30
←
Assuming the condition is true→
31
←
Taking true branch→
32
←
Control jumps to line 1103→
997    if (yychar13.1
'yychar' is >= 0
 < 0)
14
←
Taking false branch→
998    {
999        if ((yychar = yylex()) < 0) yychar = 0;
1000#if YYDEBUG0
1001        if (yydebug)
1002        {
1003            yys = 0;
1004            if (yychar <= YYMAXTOKEN269) yys = yyname[yychar];
1005            if (!yys) yys = "illegal-symbol";
1006            printf("%sdebug: state %d, reading %d (%s)\n",
1007                    YYPREFIX"yy", yystate, yychar, yys);
1008        }
1009#endif
1010    }
1011    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
15
←
Assuming 'yyn' is not equal to 0→
1012            yyn <= YYTABLESIZE337 && yycheck[yyn] == yychar)
1013    {
1014#if YYDEBUG0
1015        if (yydebug)
1016            printf("%sdebug: state %d, shifting to state %d\n",
1017                    YYPREFIX"yy", yystate, yytable[yyn]);
1018#endif
1019        if (yyssp >= yysslim && yygrowstack())
1020        {
1021            goto yyoverflow;
1022        }
1023        *++yyssp = yystate = yytable[yyn];
1024        *++yyvsp = yylval;
1025        yychar = (-1);
1026        if (yyerrflag > 0)  --yyerrflag;
1027        goto yyloop;
1028    }
1029    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
16
←
Assuming 'yyn' is 0→
1030            yyn <= YYTABLESIZE337 && yycheck[yyn] == yychar)
1031    {
1032        yyn = yytable[yyn];
1033        goto yyreduce;
1034    }
1035    if (yyerrflag16.1
'yyerrflag' is 0
) goto yyinrecovery;
17
←
Taking false branch→
1036#if defined(__GNUC__4)
1037    goto yynewerror;
18
←
Control jumps to line 1040→
1038#endif
1039yynewerror:
1040    yyerror("syntax error");
1041#if defined(__GNUC__4)
1042    goto yyerrlab;
19
←
Control jumps to line 1045→
1043#endif
1044yyerrlab:
1045    ++yynerrs;
1046yyinrecovery:
1047    if (yyerrflag < 3)
20
←
Assuming 'yyerrflag' is < 3→
21
←
Taking true branch→
1048    {
1049        yyerrflag = 3;
1050        for (;;)
22
←
Loop condition is true.  Entering loop body→
1051        {
1052            if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE256) >= 0 &&
23
←
Assuming 'yyn' is not equal to 0→
24
←
Assuming the condition is true→
27
←
Taking true branch→
1053                    yyn <= YYTABLESIZE337 && yycheck[yyn] == YYERRCODE256)
25
←
Assuming 'yyn' is <= YYTABLESIZE→
26
←
Assuming the condition is true→
1054            {
1055#if YYDEBUG0
1056                if (yydebug)
1057                    printf("%sdebug: state %d, error recovery shifting\
1058 to state %d\n", YYPREFIX"yy", *yyssp, yytable[yyn]);
1059#endif
1060                if (yyssp >= yysslim && yygrowstack())
28
←
Assuming 'yyssp' is < 'yysslim'→
1061                {
1062                    goto yyoverflow;
1063                }
1064                *++yyssp = yystate = yytable[yyn];
1065                *++yyvsp = yylval;
1066                goto yyloop;
29
←
Control jumps to line 996→
1067            }
1068            else
1069            {
1070#if YYDEBUG0
1071                if (yydebug)
1072                    printf("%sdebug: error recovery discarding state %d\n",
1073                            YYPREFIX"yy", *yyssp);
1074#endif
1075                if (yyssp <= yyss) goto yyabort;
1076                --yyssp;
1077                --yyvsp;
1078            }
1079        }
1080    }
1081    else
1082    {
1083        if (yychar == 0) goto yyabort;
1084#if YYDEBUG0
1085        if (yydebug)
1086        {
1087            yys = 0;
1088            if (yychar <= YYMAXTOKEN269) yys = yyname[yychar];
1089            if (!yys) yys = "illegal-symbol";
1090            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
1091                    YYPREFIX"yy", yystate, yychar, yys);
1092        }
1093#endif
1094        yychar = (-1);
1095        goto yyloop;
1096    }
1097yyreduce:
1098#if YYDEBUG0
1099    if (yydebug)
1100        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
1101                YYPREFIX"yy", yystate, yyn, yyrule[yyn]);
1102#endif
1103    yym = yylen[yyn];
1104    if (yym3.1
'yym' is 0
)
4
←
Taking false branch→
33
←
Assuming 'yym' is not equal to 0→
34
←
Taking true branch→
1105        yyval = yyvsp[1-yym];
1106    else
1107        memset(&yyval, 0, sizeof yyval);
1108    switch (yyn)
5
←
'Default' branch taken. Execution continues on line 1400→
35
←
'Default' branch taken. Execution continues on line 1400→
1109    {
1110case 3:
1111#line 100 "/usr/src/usr.bin/cvs/date.y"
1112{
1113		yyHaveTime++;
1114	}
1115break;
1116case 4:
1117#line 103 "/usr/src/usr.bin/cvs/date.y"
1118{
1119		yyHaveZone++;
1120	}
1121break;
1122case 5:
1123#line 106 "/usr/src/usr.bin/cvs/date.y"
1124{
1125		yyHaveDate++;
1126	}
1127break;
1128case 6:
1129#line 109 "/usr/src/usr.bin/cvs/date.y"
1130{
1131		yyHaveDay++;
1132	}
1133break;
1134case 7:
1135#line 112 "/usr/src/usr.bin/cvs/date.y"
1136{
1137		yyHaveRel++;
1138	}
1139break;
1140case 9:
1141#line 118 "/usr/src/usr.bin/cvs/date.y"
1142{
1143		yyHour = yyvsp[-1].Number;
1144		yyMinutes = 0;
1145		yySeconds = 0;
1146		yyMeridian = yyvsp[0].Meridian;
1147	}
1148break;
1149case 10:
1150#line 124 "/usr/src/usr.bin/cvs/date.y"
1151{
1152		yyHour = yyvsp[-3].Number;
1153		yyMinutes = yyvsp[-1].Number;
1154		yySeconds = 0;
1155		yyMeridian = yyvsp[0].Meridian;
1156	}
1157break;
1158case 11:
1159#line 130 "/usr/src/usr.bin/cvs/date.y"
1160{
1161		yyHour = yyvsp[-3].Number;
1162		yyMinutes = yyvsp[-1].Number;
1163		yyMeridian = MER24;
1164		yyDSTmode = DSToff;
1165		yyTimezone = - (yyvsp[0].Number % 100 + (yyvsp[0].Number / 100) * 60);
1166	}
1167break;
1168case 12:
1169#line 137 "/usr/src/usr.bin/cvs/date.y"
1170{
1171		yyHour = yyvsp[-5].Number;
1172		yyMinutes = yyvsp[-3].Number;
1173		yySeconds = yyvsp[-1].Number;
1174		yyMeridian = yyvsp[0].Meridian;
1175	}
1176break;
1177case 13:
1178#line 143 "/usr/src/usr.bin/cvs/date.y"
1179{
1180		yyHour = yyvsp[-5].Number;
1181		yyMinutes = yyvsp[-3].Number;
1182		yySeconds = yyvsp[-1].Number;
1183		yyMeridian = MER24;
1184		yyDSTmode = DSToff;
1185		yyTimezone = - (yyvsp[0].Number % 100 + (yyvsp[0].Number / 100) * 60);
1186	}
1187break;
1188case 14:
1189#line 153 "/usr/src/usr.bin/cvs/date.y"
1190{
1191		yyTimezone = yyvsp[0].Number;
1192		yyDSTmode = DSToff;
1193	}
1194break;
1195case 15:
1196#line 157 "/usr/src/usr.bin/cvs/date.y"
1197{
1198		yyTimezone = yyvsp[0].Number;
1199		yyDSTmode = DSTon;
1200	}
1201break;
1202case 16:
1203#line 161 "/usr/src/usr.bin/cvs/date.y"
1204{
1205		yyTimezone = yyvsp[-1].Number;
1206		yyDSTmode = DSTon;
1207	}
1208break;
1209case 17:
1210#line 167 "/usr/src/usr.bin/cvs/date.y"
1211{
1212		yyDayOrdinal = 1;
1213		yyDayNumber = yyvsp[0].Number;
1214	}
1215break;
1216case 18:
1217#line 171 "/usr/src/usr.bin/cvs/date.y"
1218{
1219		yyDayOrdinal = 1;
1220		yyDayNumber = yyvsp[-1].Number;
1221	}
1222break;
1223case 19:
1224#line 175 "/usr/src/usr.bin/cvs/date.y"
1225{
1226		yyDayOrdinal = yyvsp[-1].Number;
1227		yyDayNumber = yyvsp[0].Number;
1228	}
1229break;
1230case 20:
1231#line 181 "/usr/src/usr.bin/cvs/date.y"
1232{
1233		yyMonth = yyvsp[-2].Number;
1234		yyDay = yyvsp[0].Number;
1235	}
1236break;
1237case 21:
1238#line 185 "/usr/src/usr.bin/cvs/date.y"
1239{
1240		if (yyvsp[-4].Number >= 100) {
1241			yyYear = yyvsp[-4].Number;
1242			yyMonth = yyvsp[-2].Number;
1243			yyDay = yyvsp[0].Number;
1244		} else {
1245			yyMonth = yyvsp[-4].Number;
1246			yyDay = yyvsp[-2].Number;
1247			yyYear = yyvsp[0].Number;
1248		}
1249	}
1250break;
1251case 22:
1252#line 196 "/usr/src/usr.bin/cvs/date.y"
1253{
1254		/* ISO 8601 format.  yyyy-mm-dd.  */
1255		yyYear = yyvsp[-2].Number;
1256		yyMonth = -yyvsp[-1].Number;
1257		yyDay = -yyvsp[0].Number;
1258	}
1259break;
1260case 23:
1261#line 202 "/usr/src/usr.bin/cvs/date.y"
1262{
1263		/* e.g. 17-JUN-1992.  */
1264		yyDay = yyvsp[-2].Number;
1265		yyMonth = yyvsp[-1].Number;
1266		yyYear = -yyvsp[0].Number;
1267	}
1268break;
1269case 24:
1270#line 208 "/usr/src/usr.bin/cvs/date.y"
1271{
1272		yyMonth = yyvsp[-1].Number;
1273		yyDay = yyvsp[0].Number;
1274	}
1275break;
1276case 25:
1277#line 212 "/usr/src/usr.bin/cvs/date.y"
1278{
1279		yyMonth = yyvsp[-3].Number;
1280		yyDay = yyvsp[-2].Number;
1281		yyYear = yyvsp[0].Number;
1282	}
1283break;
1284case 26:
1285#line 217 "/usr/src/usr.bin/cvs/date.y"
1286{
1287		yyMonth = yyvsp[0].Number;
1288		yyDay = yyvsp[-1].Number;
1289	}
1290break;
1291case 27:
1292#line 221 "/usr/src/usr.bin/cvs/date.y"
1293{
1294		yyMonth = yyvsp[-1].Number;
1295		yyDay = yyvsp[-2].Number;
1296		yyYear = yyvsp[0].Number;
1297	}
1298break;
1299case 28:
1300#line 228 "/usr/src/usr.bin/cvs/date.y"
1301{
1302		yyRelSeconds = -yyRelSeconds;
1303		yyRelMonth = -yyRelMonth;
1304	}
1305break;
1306case 30:
1307#line 235 "/usr/src/usr.bin/cvs/date.y"
1308{
1309		yyRelSeconds += yyvsp[-1].Number * yyvsp[0].Number * 60L;
1310	}
1311break;
1312case 31:
1313#line 238 "/usr/src/usr.bin/cvs/date.y"
1314{
1315		yyRelSeconds += yyvsp[-1].Number * yyvsp[0].Number * 60L;
1316	}
1317break;
1318case 32:
1319#line 241 "/usr/src/usr.bin/cvs/date.y"
1320{
1321		yyRelSeconds += yyvsp[0].Number * 60L;
1322	}
1323break;
1324case 33:
1325#line 244 "/usr/src/usr.bin/cvs/date.y"
1326{
1327		yyRelSeconds += yyvsp[-1].Number;
1328	}
1329break;
1330case 34:
1331#line 247 "/usr/src/usr.bin/cvs/date.y"
1332{
1333		yyRelSeconds += yyvsp[-1].Number;
1334	}
1335break;
1336case 35:
1337#line 250 "/usr/src/usr.bin/cvs/date.y"
1338{
1339		yyRelSeconds++;
1340	}
1341break;
1342case 36:
1343#line 253 "/usr/src/usr.bin/cvs/date.y"
1344{
1345		yyRelMonth += yyvsp[-1].Number * yyvsp[0].Number;
1346	}
1347break;
1348case 37:
1349#line 256 "/usr/src/usr.bin/cvs/date.y"
1350{
1351		yyRelMonth += yyvsp[-1].Number * yyvsp[0].Number;
1352	}
1353break;
1354case 38:
1355#line 259 "/usr/src/usr.bin/cvs/date.y"
1356{
1357		yyRelMonth += yyvsp[0].Number;
1358	}
1359break;
1360case 39:
1361#line 264 "/usr/src/usr.bin/cvs/date.y"
1362{
1363		if (yyHaveTime && yyHaveDate && !yyHaveRel)
1364			yyYear = yyvsp[0].Number;
1365		else {
1366			if (yyvsp[0].Number > 10000) {
1367				yyHaveDate++;
1368				yyDay= (yyvsp[0].Number)%100;
1369				yyMonth= (yyvsp[0].Number/100)%100;
1370				yyYear = yyvsp[0].Number/10000;
1371			} else {
1372				yyHaveTime++;
1373				if (yyvsp[0].Number < 100) {
1374					yyHour = yyvsp[0].Number;
1375					yyMinutes = 0;
1376				} else {
1377					yyHour = yyvsp[0].Number / 100;
1378					yyMinutes = yyvsp[0].Number % 100;
1379				}
1380				yySeconds = 0;
1381				yyMeridian = MER24;
1382			}
1383		}
1384	}
1385break;
1386case 40:
1387#line 289 "/usr/src/usr.bin/cvs/date.y"
1388{
1389		yyval.Meridian = MER24;
1390	}
1391break;
1392case 41:
1393#line 292 "/usr/src/usr.bin/cvs/date.y"
1394{
1395		yyval.Meridian = yyvsp[0].Meridian;
1396	}
1397break;
1398#line 1391 "date.c"
1399    }
1400    yyssp -= yym;
1401    yystate = *yyssp;
1402    yyvsp -= yym;
1403    yym = yylhs[yyn];
1404    if (yystate5.1
'yystate' is equal to 0
 == 0 && yym5.2
'yym' is equal to 0
 == 0)
6
←
Taking true branch→
36
←
Assuming 'yystate' is not equal to 0→
1405    {
1406#if YYDEBUG0
1407        if (yydebug)
1408            printf("%sdebug: after reduction, shifting from state 0 to\
1409 state %d\n", YYPREFIX"yy", YYFINAL1);
1410#endif
1411        yystate = YYFINAL1;
1412        *++yyssp = YYFINAL1;
1413        *++yyvsp = yyval;
1414        if (yychar6.1
'yychar' is < 0
 < 0)
7
←
Taking true branch→
1415        {
1416            if ((yychar = yylex()) < 0) yychar = 0;
8
←
Assuming the condition is false→
9
←
Taking false branch→
1417#if YYDEBUG0
1418            if (yydebug)
1419            {
1420                yys = 0;
1421                if (yychar <= YYMAXTOKEN269) yys = yyname[yychar];
1422                if (!yys) yys = "illegal-symbol";
1423                printf("%sdebug: state %d, reading %d (%s)\n",
1424                        YYPREFIX"yy", YYFINAL1, yychar, yys);
1425            }
1426#endif
1427        }
1428        if (yychar == 0) goto yyaccept;
10
←
Assuming 'yychar' is not equal to 0→
11
←
Taking false branch→
1429        goto yyloop;
12
←
Control jumps to line 996→
1430    }
1431    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
37
←
Assuming 'yyn' is 0→
1432            yyn <= YYTABLESIZE337 && yycheck[yyn] == yystate)
1433        yystate = yytable[yyn];
1434    else
1435        yystate = yydgoto[yym];
1436#if YYDEBUG0
1437    if (yydebug)
1438        printf("%sdebug: after reduction, shifting from state %d \
1439to state %d\n", YYPREFIX"yy", *yyssp, yystate);
1440#endif
1441    if (yyssp >= yysslim && yygrowstack())
38
←
Assuming 'yyssp' is >= 'yysslim'→
39
←
Calling 'yygrowstack'→
51
←
Returning from 'yygrowstack'→
52
←
Taking false branch→
1442    {
1443        goto yyoverflow;
1444    }
1445    *++yyssp = yystate;
53
←
Use of zero-allocated memory
1446    *++yyvsp = yyval;
1447    goto yyloop;
1448yyoverflow:
1449    yyerror("yacc stack overflow");
1450yyabort:
1451    if (yyss)
1452            free(yyss);
1453    if (yyvs)
1454            free(yyvs);
1455    yyss = yyssp = NULL((void *)0);
1456    yyvs = yyvsp = NULL((void *)0);
1457    yystacksize = 0;
1458    return (1);
1459yyaccept:
1460    if (yyss)
1461            free(yyss);
1462    if (yyvs)
1463            free(yyvs);
1464    yyss = yyssp = NULL((void *)0);
1465    yyvs = yyvsp = NULL((void *)0);
1466    yystacksize = 0;
1467    return (0);
1468}