date.c

Bug Summary

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