| GCC Code Coverage Report | |||||||||||||||||||||
|
|||||||||||||||||||||
| Line | Branch | Exec | Source |
1 |
#include <stdlib.h> |
||
2 |
#include <string.h> |
||
3 |
#define YYBYACC 1 |
||
4 |
#define YYMAJOR 1 |
||
5 |
#define YYMINOR 9 |
||
6 |
#define YYLEX yylex() |
||
7 |
#define YYEMPTY -1 |
||
8 |
#define yyclearin (yychar=(YYEMPTY)) |
||
9 |
#define yyerrok (yyerrflag=0) |
||
10 |
#define YYRECOVERING() (yyerrflag!=0) |
||
11 |
#define YYPREFIX "yy" |
||
12 |
#line 2 "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_EPOCH 1970 |
||
36 |
#define YEAR_TMORIGIN 1900 |
||
37 |
#define HOUR(x) ((time_t)(x) * 60) |
||
38 |
#define SECSPERDAY (24L * 60L * 60L) |
||
39 |
|||
40 |
|||
41 |
/* An entry in the lexical lookup table */ |
||
42 |
typedef 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. */ |
||
50 |
typedef enum _DSTMODE { |
||
51 |
DSTon, DSToff, DSTmaybe |
||
52 |
} DSTMODE; |
||
53 |
|||
54 |
/* Meridian: am, pm, or 24-hour style. */ |
||
55 |
typedef 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 |
*/ |
||
66 |
static const char *yyInput; |
||
67 |
static DSTMODE yyDSTmode; |
||
68 |
static time_t yyDayOrdinal; |
||
69 |
static time_t yyDayNumber; |
||
70 |
static int yyHaveDate; |
||
71 |
static int yyHaveDay; |
||
72 |
static int yyHaveRel; |
||
73 |
static int yyHaveTime; |
||
74 |
static int yyHaveZone; |
||
75 |
static time_t yyTimezone; |
||
76 |
static time_t yyDay; |
||
77 |
static time_t yyHour; |
||
78 |
static time_t yyMinutes; |
||
79 |
static time_t yyMonth; |
||
80 |
static time_t yySeconds; |
||
81 |
static time_t yyYear; |
||
82 |
static MERIDIAN yyMeridian; |
||
83 |
static time_t yyRelMonth; |
||
84 |
static time_t yyRelSeconds; |
||
85 |
|||
86 |
|||
87 |
static int yyerror(const char *); |
||
88 |
static int yylex(void); |
||
89 |
static int yyparse(void); |
||
90 |
static int lookup(char *); |
||
91 |
|||
92 |
#line 83 "date.y" |
||
93 |
#ifndef YYSTYPE_DEFINED |
||
94 |
#define YYSTYPE_DEFINED |
||
95 |
typedef union { |
||
96 |
time_t Number; |
||
97 |
enum _MERIDIAN Meridian; |
||
98 |
} YYSTYPE; |
||
99 |
#endif /* YYSTYPE_DEFINED */ |
||
100 |
#line 101 "date.c" |
||
101 |
#define tAGO 257 |
||
102 |
4 |
#define tDAY 258 |
|
103 |
#define tDAYZONE 259 |
||
104 |
4 |
#define tID 260 |
|
105 |
#define tMERIDIAN 261 |
||
106 |
#define tMINUTE_UNIT 262 |
||
107 |
#define tMONTH 263 |
||
108 |
4 |
#define tMONTH_UNIT 264 |
|
109 |
#define tSEC_UNIT 265 |
||
110 |
4 |
#define tSNUMBER 266 |
|
111 |
#define tUNUMBER 267 |
||
112 |
#define tZONE 268 |
||
113 |
#define tDST 269 |
||
114 |
#define YYERRCODE 256 |
||
115 |
const 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 |
}; |
||
123 |
const 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 |
}; |
||
131 |
const 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 |
}; |
||
139 |
const short yydgoto[] = |
||
140 |
{ 1, |
||
141 |
45, 11, 12, 13, 14, 15, 16, 17, 18, |
||
142 |
}; |
||
143 |
const short yysindex[] = |
||
144 |
{ 0, |
||
145 |
4 |
-249, -38, 0, 0, -260, 0, 0, -240, -47, -248, |
|
146 |
4 |
0, 0, 0, 0, 0, 0, 0, -237, 0, -18, |
|
147 |
4 |
0, 0, 0, 0, 0, 0, -262, 0, 0, -239, |
|
148 |
4 |
-238, -236, 0, 0, -235, 0, 0, 0, -56, -19, |
|
149 |
4 |
0, 0, 0, -234, 0, -232, -258, 0, 0, 0,}; |
|
150 |
4 |
const short yyrindex[] = |
|
151 |
{ 0, |
||
152 |
4 |
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,}; |
||
157 |
const short yygindex[] = |
||
158 |
{ 0, |
||
159 |
-17, 0, 0, 0, 0, 0, 0, 0, 0, |
||
160 |
}; |
||
161 |
#define YYTABLESIZE 337 |
||
162 |
const 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 |
}; |
||
199 |
4 |
const short yycheck[] = |
|
200 |
4 |
{ 47, |
|
201 |
4 |
0, 58, 261, 266, 267, 44, 267, 266, 258, 259, |
|
202 |
58, 0, 262, 263, 264, 265, 266, 267, 268, 257, |
||
203 |
4 |
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 YYFINAL 1 |
||
237 |
#ifndef YYDEBUG |
||
238 |
#define YYDEBUG 0 |
||
239 |
#endif |
||
240 |
#define YYMAXTOKEN 269 |
||
241 |
#if YYDEBUG |
||
242 |
const 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, |
||
245 |
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, |
||
246 |
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,0, |
||
247 |
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,0, |
||
248 |
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,0, |
||
249 |
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,0, |
||
250 |
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,"tAGO","tDAY", |
||
251 |
"tDAYZONE","tID","tMERIDIAN","tMINUTE_UNIT","tMONTH","tMONTH_UNIT","tSEC_UNIT", |
||
252 |
"tSNUMBER","tUNUMBER","tZONE","tDST", |
||
253 |
}; |
||
254 |
const 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 YYSTACKSIZE |
||
300 |
#undef YYMAXDEPTH |
||
301 |
#define YYMAXDEPTH YYSTACKSIZE |
||
302 |
#else |
||
303 |
#ifdef YYMAXDEPTH |
||
304 |
#define YYSTACKSIZE YYMAXDEPTH |
||
305 |
#else |
||
306 |
#define YYSTACKSIZE 10000 |
||
307 |
#define YYMAXDEPTH 10000 |
||
308 |
#endif |
||
309 |
#endif |
||
310 |
#define YYINITSTACKSIZE 200 |
||
311 |
/* LINTUSED */ |
||
312 |
int yydebug; |
||
313 |
int yynerrs; |
||
314 |
int yyerrflag; |
||
315 |
int yychar; |
||
316 |
short *yyssp; |
||
317 |
YYSTYPE *yyvsp; |
||
318 |
YYSTYPE yyval; |
||
319 |
YYSTYPE yylval; |
||
320 |
short *yyss; |
||
321 |
short *yysslim; |
||
322 |
YYSTYPE *yyvs; |
||
323 |
unsigned int yystacksize; |
||
324 |
int yyparse(void); |
||
325 |
#line 299 "date.y" |
||
326 |
|||
327 |
/* Month and day table. */ |
||
328 |
static TABLE const MonthDayTable[] = { |
||
329 |
{ "january", tMONTH, 1 }, |
||
330 |
{ "february", tMONTH, 2 }, |
||
331 |
{ "march", tMONTH, 3 }, |
||
332 |
{ "april", tMONTH, 4 }, |
||
333 |
{ "may", tMONTH, 5 }, |
||
334 |
{ "june", tMONTH, 6 }, |
||
335 |
{ "july", tMONTH, 7 }, |
||
336 |
{ "august", tMONTH, 8 }, |
||
337 |
{ "september", tMONTH, 9 }, |
||
338 |
{ "sept", tMONTH, 9 }, |
||
339 |
{ "october", tMONTH, 10 }, |
||
340 |
{ "november", tMONTH, 11 }, |
||
341 |
{ "december", tMONTH, 12 }, |
||
342 |
{ "sunday", tDAY, 0 }, |
||
343 |
{ "monday", tDAY, 1 }, |
||
344 |
{ "tuesday", tDAY, 2 }, |
||
345 |
{ "tues", tDAY, 2 }, |
||
346 |
{ "wednesday", tDAY, 3 }, |
||
347 |
{ "wednes", tDAY, 3 }, |
||
348 |
{ "thursday", tDAY, 4 }, |
||
349 |
{ "thur", tDAY, 4 }, |
||
350 |
{ "thurs", tDAY, 4 }, |
||
351 |
{ "friday", tDAY, 5 }, |
||
352 |
{ "saturday", tDAY, 6 }, |
||
353 |
{ NULL } |
||
354 |
}; |
||
355 |
|||
356 |
/* Time units table. */ |
||
357 |
static TABLE const UnitsTable[] = { |
||
358 |
{ "year", tMONTH_UNIT, 12 }, |
||
359 |
{ "month", tMONTH_UNIT, 1 }, |
||
360 |
{ "fortnight", tMINUTE_UNIT, 14 * 24 * 60 }, |
||
361 |
{ "week", tMINUTE_UNIT, 7 * 24 * 60 }, |
||
362 |
{ "day", tMINUTE_UNIT, 1 * 24 * 60 }, |
||
363 |
{ "hour", tMINUTE_UNIT, 60 }, |
||
364 |
{ "minute", tMINUTE_UNIT, 1 }, |
||
365 |
{ "min", tMINUTE_UNIT, 1 }, |
||
366 |
{ "second", tSEC_UNIT, 1 }, |
||
367 |
{ "sec", tSEC_UNIT, 1 }, |
||
368 |
{ NULL } |
||
369 |
}; |
||
370 |
|||
371 |
/* Assorted relative-time words. */ |
||
372 |
static TABLE const OtherTable[] = { |
||
373 |
{ "tomorrow", tMINUTE_UNIT, 1 * 24 * 60 }, |
||
374 |
{ "yesterday", tMINUTE_UNIT, -1 * 24 * 60 }, |
||
375 |
{ "today", tMINUTE_UNIT, 0 }, |
||
376 |
{ "now", tMINUTE_UNIT, 0 }, |
||
377 |
{ "last", tUNUMBER, -1 }, |
||
378 |
{ "this", tMINUTE_UNIT, 0 }, |
||
379 |
{ "next", tUNUMBER, 2 }, |
||
380 |
{ "first", tUNUMBER, 1 }, |
||
381 |
/* { "second", tUNUMBER, 2 }, */ |
||
382 |
{ "third", tUNUMBER, 3 }, |
||
383 |
{ "fourth", tUNUMBER, 4 }, |
||
384 |
{ "fifth", tUNUMBER, 5 }, |
||
385 |
{ "sixth", tUNUMBER, 6 }, |
||
386 |
{ "seventh", tUNUMBER, 7 }, |
||
387 |
{ "eighth", tUNUMBER, 8 }, |
||
388 |
{ "ninth", tUNUMBER, 9 }, |
||
389 |
{ "tenth", tUNUMBER, 10 }, |
||
390 |
{ "eleventh", tUNUMBER, 11 }, |
||
391 |
{ "twelfth", tUNUMBER, 12 }, |
||
392 |
{ "ago", tAGO, 1 }, |
||
393 |
{ NULL } |
||
394 |
}; |
||
395 |
|||
396 |
/* The timezone table. */ |
||
397 |
/* Some of these are commented out because a time_t can't store a float. */ |
||
398 |
static TABLE const TimezoneTable[] = { |
||
399 |
{ "gmt", tZONE, HOUR( 0) }, /* Greenwich Mean */ |
||
400 |
{ "ut", tZONE, HOUR( 0) }, /* Universal (Coordinated) */ |
||
401 |
{ "utc", tZONE, HOUR( 0) }, |
||
402 |
{ "wet", tZONE, HOUR( 0) }, /* Western European */ |
||
403 |
{ "bst", tDAYZONE, HOUR( 0) }, /* British Summer */ |
||
404 |
{ "wat", tZONE, HOUR( 1) }, /* West Africa */ |
||
405 |
{ "at", tZONE, HOUR( 2) }, /* Azores */ |
||
406 |
#if 0 |
||
407 |
/* For completeness. BST is also British Summer, and GST is |
||
408 |
* also Guam Standard. */ |
||
409 |
{ "bst", tZONE, HOUR( 3) }, /* Brazil Standard */ |
||
410 |
{ "gst", tZONE, HOUR( 3) }, /* Greenland Standard */ |
||
411 |
#endif |
||
412 |
#if 0 |
||
413 |
{ "nft", tZONE, HOUR(3.5) }, /* Newfoundland */ |
||
414 |
{ "nst", tZONE, HOUR(3.5) }, /* Newfoundland Standard */ |
||
415 |
{ "ndt", tDAYZONE, HOUR(3.5) }, /* Newfoundland Daylight */ |
||
416 |
#endif |
||
417 |
{ "ast", tZONE, HOUR( 4) }, /* Atlantic Standard */ |
||
418 |
{ "adt", tDAYZONE, HOUR( 4) }, /* Atlantic Daylight */ |
||
419 |
{ "est", tZONE, HOUR( 5) }, /* Eastern Standard */ |
||
420 |
{ "edt", tDAYZONE, HOUR( 5) }, /* Eastern Daylight */ |
||
421 |
{ "cst", tZONE, HOUR( 6) }, /* Central Standard */ |
||
422 |
{ "cdt", tDAYZONE, HOUR( 6) }, /* Central Daylight */ |
||
423 |
{ "mst", tZONE, HOUR( 7) }, /* Mountain Standard */ |
||
424 |
{ "mdt", tDAYZONE, HOUR( 7) }, /* Mountain Daylight */ |
||
425 |
{ "pst", tZONE, HOUR( 8) }, /* Pacific Standard */ |
||
426 |
{ "pdt", tDAYZONE, HOUR( 8) }, /* Pacific Daylight */ |
||
427 |
{ "yst", tZONE, HOUR( 9) }, /* Yukon Standard */ |
||
428 |
{ "ydt", tDAYZONE, HOUR( 9) }, /* Yukon Daylight */ |
||
429 |
{ "hst", tZONE, HOUR(10) }, /* Hawaii Standard */ |
||
430 |
{ "hdt", tDAYZONE, HOUR(10) }, /* Hawaii Daylight */ |
||
431 |
{ "cat", tZONE, HOUR(10) }, /* Central Alaska */ |
||
432 |
{ "ahst", tZONE, HOUR(10) }, /* Alaska-Hawaii Standard */ |
||
433 |
{ "nt", tZONE, HOUR(11) }, /* Nome */ |
||
434 |
{ "idlw", tZONE, HOUR(12) }, /* International Date Line West */ |
||
435 |
{ "cet", tZONE, -HOUR(1) }, /* Central European */ |
||
436 |
{ "met", tZONE, -HOUR(1) }, /* Middle European */ |
||
437 |
{ "mewt", tZONE, -HOUR(1) }, /* Middle European Winter */ |
||
438 |
{ "mest", tDAYZONE, -HOUR(1) }, /* Middle European Summer */ |
||
439 |
{ "swt", tZONE, -HOUR(1) }, /* Swedish Winter */ |
||
440 |
{ "sst", tDAYZONE, -HOUR(1) }, /* Swedish Summer */ |
||
441 |
{ "fwt", tZONE, -HOUR(1) }, /* French Winter */ |
||
442 |
{ "fst", tDAYZONE, -HOUR(1) }, /* French Summer */ |
||
443 |
{ "eet", tZONE, -HOUR(2) }, /* Eastern Europe, USSR Zone 1 */ |
||
444 |
{ "bt", tZONE, -HOUR(3) }, /* Baghdad, USSR Zone 2 */ |
||
445 |
#if 0 |
||
446 |
{ "it", tZONE, -HOUR(3.5) },/* Iran */ |
||
447 |
#endif |
||
448 |
{ "zp4", tZONE, -HOUR(4) }, /* USSR Zone 3 */ |
||
449 |
{ "zp5", tZONE, -HOUR(5) }, /* USSR Zone 4 */ |
||
450 |
#if 0 |
||
451 |
{ "ist", tZONE, -HOUR(5.5) },/* Indian Standard */ |
||
452 |
#endif |
||
453 |
{ "zp6", tZONE, -HOUR(6) }, /* USSR Zone 5 */ |
||
454 |
#if 0 |
||
455 |
/* For completeness. NST is also Newfoundland Stanard, and SST is |
||
456 |
* also Swedish Summer. */ |
||
457 |
{ "nst", tZONE, -HOUR(6.5) },/* North Sumatra */ |
||
458 |
{ "sst", tZONE, -HOUR(7) }, /* South Sumatra, USSR Zone 6 */ |
||
459 |
#endif /* 0 */ |
||
460 |
{ "wast", tZONE, -HOUR(7) }, /* West Australian Standard */ |
||
461 |
{ "wadt", tDAYZONE, -HOUR(7) }, /* West Australian Daylight */ |
||
462 |
#if 0 |
||
463 |
{ "jt", tZONE, -HOUR(7.5) },/* Java (3pm in Cronusland!) */ |
||
464 |
#endif |
||
465 |
{ "cct", tZONE, -HOUR(8) }, /* China Coast, USSR Zone 7 */ |
||
466 |
{ "jst", tZONE, -HOUR(9) }, /* Japan Standard, USSR Zone 8 */ |
||
467 |
#if 0 |
||
468 |
{ "cast", tZONE, -HOUR(9.5) },/* Central Australian Standard */ |
||
469 |
{ "cadt", tDAYZONE, -HOUR(9.5) },/* Central Australian Daylight */ |
||
470 |
#endif |
||
471 |
{ "east", tZONE, -HOUR(10) }, /* Eastern Australian Standard */ |
||
472 |
{ "eadt", tDAYZONE, -HOUR(10) }, /* Eastern Australian Daylight */ |
||
473 |
{ "gst", tZONE, -HOUR(10) }, /* Guam Standard, USSR Zone 9 */ |
||
474 |
{ "nzt", tZONE, -HOUR(12) }, /* New Zealand */ |
||
475 |
{ "nzst", tZONE, -HOUR(12) }, /* New Zealand Standard */ |
||
476 |
{ "nzdt", tDAYZONE, -HOUR(12) }, /* New Zealand Daylight */ |
||
477 |
{ "idle", tZONE, -HOUR(12) }, /* International Date Line East */ |
||
478 |
{ NULL } |
||
479 |
}; |
||
480 |
|||
481 |
/* Military timezone table. */ |
||
482 |
static TABLE const MilitaryTable[] = { |
||
483 |
{ "a", tZONE, HOUR( 1) }, |
||
484 |
{ "b", tZONE, HOUR( 2) }, |
||
485 |
{ "c", tZONE, HOUR( 3) }, |
||
486 |
{ "d", tZONE, HOUR( 4) }, |
||
487 |
{ "e", tZONE, HOUR( 5) }, |
||
488 |
{ "f", tZONE, HOUR( 6) }, |
||
489 |
{ "g", tZONE, HOUR( 7) }, |
||
490 |
{ "h", tZONE, HOUR( 8) }, |
||
491 |
{ "i", tZONE, HOUR( 9) }, |
||
492 |
{ "k", tZONE, HOUR( 10) }, |
||
493 |
{ "l", tZONE, HOUR( 11) }, |
||
494 |
{ "m", tZONE, HOUR( 12) }, |
||
495 |
{ "n", tZONE, HOUR(- 1) }, |
||
496 |
{ "o", tZONE, HOUR(- 2) }, |
||
497 |
{ "p", tZONE, HOUR(- 3) }, |
||
498 |
{ "q", tZONE, HOUR(- 4) }, |
||
499 |
{ "r", tZONE, HOUR(- 5) }, |
||
500 |
{ "s", tZONE, HOUR(- 6) }, |
||
501 |
{ "t", tZONE, HOUR(- 7) }, |
||
502 |
{ "u", tZONE, HOUR(- 8) }, |
||
503 |
{ "v", tZONE, HOUR(- 9) }, |
||
504 |
{ "w", tZONE, HOUR(-10) }, |
||
505 |
{ "x", tZONE, HOUR(-11) }, |
||
506 |
{ "y", tZONE, HOUR(-12) }, |
||
507 |
{ "z", tZONE, HOUR( 0) }, |
||
508 |
{ NULL } |
||
509 |
}; |
||
510 |
|||
511 |
|||
512 |
static int |
||
513 |
yyerror(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 |
|||
530 |
static time_t |
||
531 |
ToSeconds(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 |
*/ |
||
565 |
static time_t |
||
566 |
Convert(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_EPOCH) |
||
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_EPOCH || |
||
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_EPOCH; i < Year; i++) |
||
599 |
julian += 365 + (i % 4 == 0); |
||
600 |
julian *= SECSPERDAY; |
||
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 |
|||
613 |
static time_t |
||
614 |
DSTcorrect(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 |
|||
625 |
static time_t |
||
626 |
RelativeDate(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 * ((DayNumber - tm->tm_wday + 7) % 7); |
||
634 |
now += 7 * SECSPERDAY * (DayOrdinal <= 0 ? DayOrdinal : DayOrdinal - 1); |
||
635 |
return DSTcorrect(Start, now); |
||
636 |
} |
||
637 |
|||
638 |
|||
639 |
static time_t |
||
640 |
RelativeMonth(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 |
|||
659 |
static int |
||
660 |
lookup(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 (tMERIDIAN); |
||
675 |
} |
||
676 |
if (strcmp(buff, "pm") == 0 || strcmp(buff, "p.m.") == 0) { |
||
677 |
yylval.Meridian = MERpm; |
||
678 |
return (tMERIDIAN); |
||
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 (tDST); |
||
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 (tID); |
||
760 |
} |
||
761 |
|||
762 |
|||
763 |
static int |
||
764 |
yylex(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 ? tSNUMBER : tUNUMBER; |
||
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. */ |
||
816 |
static long |
||
817 |
difftm(struct tm *a, struct tm *b) |
||
818 |
{ |
||
819 |
int ay = a->tm_year + (YEAR_TMORIGIN - 1); |
||
820 |
int by = b->tm_year + (YEAR_TMORIGIN - 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 |
*/ |
||
839 |
time_t |
||
840 |
date_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 */ |
||
902 |
int |
||
903 |
main(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); |
||
910 |
while (fgets(buff, sizeof(buff), stdin) && 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); |
||
918 |
} |
||
919 |
|||
920 |
return (0); |
||
921 |
} |
||
922 |
#endif /* defined(TEST) */ |
||
923 |
#line 916 "date.c" |
||
924 |
✓✗ | 8 |
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ |
925 |
4 |
static int yygrowstack(void) |
|
926 |
{ |
||
927 |
unsigned int newsize; |
||
928 |
long sslen; |
||
929 |
short *newss; |
||
930 |
4 |
YYSTYPE *newvs; |
|
931 |
|||
932 |
if ((newsize = yystacksize) == 0) |
||
933 |
newsize = YYINITSTACKSIZE; |
||
934 |
else if (newsize >= YYMAXDEPTH) |
||
935 |
return -1; |
||
936 |
✓✗✓✗ |
8 |
else if ((newsize *= 2) > YYMAXDEPTH) |
937 |
newsize = YYMAXDEPTH; |
||
938 |
✗✓ | 8 |
sslen = yyssp - yyss; |
939 |
4 |
#ifdef SIZE_MAX |
|
940 |
✓✗ | 4 |
#define YY_SIZE_MAX SIZE_MAX |
941 |
#else |
||
942 |
4 |
#define YY_SIZE_MAX 0xffffffffU |
|
943 |
4 |
#endif |
|
944 |
✓✗✓✗ |
8 |
if (newsize && YY_SIZE_MAX / newsize < sizeof *newss) |
945 |
goto bail; |
||
946 |
✗✓ | 8 |
newss = yyss ? (short *)realloc(yyss, newsize * sizeof *newss) : |
947 |
4 |
(short *)malloc(newsize * sizeof *newss); /* overflow check above */ |
|
948 |
✓✗ | 4 |
if (newss == NULL) |
949 |
goto bail; |
||
950 |
4 |
yyss = newss; |
|
951 |
4 |
yyssp = newss + sslen; |
|
952 |
4 |
if (newsize && YY_SIZE_MAX / newsize < sizeof *newvs) |
|
953 |
4 |
goto bail; |
|
954 |
4 |
newvs = yyvs ? (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs) : |
|
955 |
(YYSTYPE *)malloc(newsize * sizeof *newvs); /* overflow check above */ |
||
956 |
if (newvs == NULL) |
||
957 |
goto bail; |
||
958 |
yyvs = newvs; |
||
959 |
yyvsp = newvs + sslen; |
||
960 |
yystacksize = newsize; |
||
961 |
yysslim = yyss + newsize - 1; |
||
962 |
return 0; |
||
963 |
bail: |
||
964 |
4 |
if (yyss) |
|
965 |
free(yyss); |
||
966 |
if (yyvs) |
||
967 |
free(yyvs); |
||
968 |
yyss = yyssp = NULL; |
||
969 |
yyvs = yyvsp = NULL; |
||
970 |
yystacksize = 0; |
||
971 |
return -1; |
||
972 |
} |
||
973 |
|||
974 |
#define YYABORT goto yyabort |
||
975 |
#define YYREJECT goto yyabort |
||
976 |
#define YYACCEPT goto yyaccept |
||
977 |
#define YYERROR goto yyerrlab |
||
978 |
int |
||
979 |
yyparse(void) |
||
980 |
{ |
||
981 |
int yym, yyn, yystate; |
||
982 |
#if YYDEBUG |
||
983 |
const char *yys; |
||
984 |
|||
985 |
8 |
if ((yys = getenv("YYDEBUG"))) |
|
986 |
4 |
{ |
|
987 |
4 |
yyn = *yys; |
|
988 |
if (yyn >= '0' && yyn <= '9') |
||
989 |
✓✗✓✗ |
8 |
yydebug = yyn - '0'; |
990 |
4 |
} |
|
991 |
4 |
#endif /* YYDEBUG */ |
|
992 |
4 |
||
993 |
yynerrs = 0; |
||
994 |
yyerrflag = 0; |
||
995 |
✓✓ | 64 |
yychar = (-1); |
996 |
✓✓ | 36 |
|
997 |
if (yyss == NULL && yygrowstack()) goto yyoverflow; |
||
998 |
28 |
yyssp = yyss; |
|
999 |
yyvsp = yyvs; |
||
1000 |
*yyssp = yystate = 0; |
||
1001 |
|||
1002 |
yyloop: |
||
1003 |
if ((yyn = yydefred[yystate]) != 0) goto yyreduce; |
||
1004 |
if (yychar < 0) |
||
1005 |
{ |
||
1006 |
if ((yychar = yylex()) < 0) yychar = 0; |
||
1007 |
#if YYDEBUG |
||
1008 |
if (yydebug) |
||
1009 |
28 |
{ |
|
1010 |
✓✗✓✗ ✓✗ |
144 |
yys = 0; |
1011 |
72 |
if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; |
|
1012 |
if (!yys) yys = "illegal-symbol"; |
||
1013 |
printf("%sdebug: state %d, reading %d (%s)\n", |
||
1014 |
YYPREFIX, yystate, yychar, yys); |
||
1015 |
} |
||
1016 |
#endif |
||
1017 |
} |
||
1018 |
✗✓✗✗ |
36 |
if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 && |
1019 |
yyn <= YYTABLESIZE && yycheck[yyn] == yychar) |
||
1020 |
{ |
||
1021 |
#if YYDEBUG |
||
1022 |
36 |
if (yydebug) |
|
1023 |
36 |
printf("%sdebug: state %d, shifting to state %d\n", |
|
1024 |
36 |
YYPREFIX, yystate, yytable[yyn]); |
|
1025 |
✓✗ | 36 |
#endif |
1026 |
if (yyssp >= yysslim && yygrowstack()) |
||
1027 |
{ |
||
1028 |
goto yyoverflow; |
||
1029 |
} |
||
1030 |
*++yyssp = yystate = yytable[yyn]; |
||
1031 |
*++yyvsp = yylval; |
||
1032 |
yychar = (-1); |
||
1033 |
if (yyerrflag > 0) --yyerrflag; |
||
1034 |
goto yyloop; |
||
1035 |
} |
||
1036 |
if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 && |
||
1037 |
yyn <= YYTABLESIZE && yycheck[yyn] == yychar) |
||
1038 |
{ |
||
1039 |
yyn = yytable[yyn]; |
||
1040 |
goto yyreduce; |
||
1041 |
} |
||
1042 |
if (yyerrflag) goto yyinrecovery; |
||
1043 |
#if defined(__GNUC__) |
||
1044 |
goto yynewerror; |
||
1045 |
#endif |
||
1046 |
yynewerror: |
||
1047 |
yyerror("syntax error"); |
||
1048 |
#if defined(__GNUC__) |
||
1049 |
goto yyerrlab; |
||
1050 |
#endif |
||
1051 |
yyerrlab: |
||
1052 |
++yynerrs; |
||
1053 |
yyinrecovery: |
||
1054 |
if (yyerrflag < 3) |
||
1055 |
{ |
||
1056 |
yyerrflag = 3; |
||
1057 |
for (;;) |
||
1058 |
{ |
||
1059 |
if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 && |
||
1060 |
yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE) |
||
1061 |
{ |
||
1062 |
#if YYDEBUG |
||
1063 |
if (yydebug) |
||
1064 |
printf("%sdebug: state %d, error recovery shifting\ |
||
1065 |
to state %d\n", YYPREFIX, *yyssp, yytable[yyn]); |
||
1066 |
#endif |
||
1067 |
if (yyssp >= yysslim && yygrowstack()) |
||
1068 |
{ |
||
1069 |
goto yyoverflow; |
||
1070 |
} |
||
1071 |
*++yyssp = yystate = yytable[yyn]; |
||
1072 |
*++yyvsp = yylval; |
||
1073 |
goto yyloop; |
||
1074 |
} |
||
1075 |
else |
||
1076 |
{ |
||
1077 |
#if YYDEBUG |
||
1078 |
if (yydebug) |
||
1079 |
printf("%sdebug: error recovery discarding state %d\n", |
||
1080 |
YYPREFIX, *yyssp); |
||
1081 |
#endif |
||
1082 |
if (yyssp <= yyss) goto yyabort; |
||
1083 |
--yyssp; |
||
1084 |
--yyvsp; |
||
1085 |
} |
||
1086 |
} |
||
1087 |
} |
||
1088 |
else |
||
1089 |
{ |
||
1090 |
if (yychar == 0) goto yyabort; |
||
1091 |
#if YYDEBUG |
||
1092 |
if (yydebug) |
||
1093 |
{ |
||
1094 |
yys = 0; |
||
1095 |
if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; |
||
1096 |
if (!yys) yys = "illegal-symbol"; |
||
1097 |
printf("%sdebug: state %d, error recovery discards token %d (%s)\n", |
||
1098 |
YYPREFIX, yystate, yychar, yys); |
||
1099 |
} |
||
1100 |
#endif |
||
1101 |
yychar = (-1); |
||
1102 |
28 |
goto yyloop; |
|
1103 |
✓✓ | 28 |
} |
1104 |
24 |
yyreduce: |
|
1105 |
#if YYDEBUG |
||
1106 |
4 |
if (yydebug) |
|
1107 |
✓✗✓✗ ✗✗✗✗ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✓ |
44 |
printf("%sdebug: state %d, reducing by rule %d (%s)\n", |
1108 |
YYPREFIX, yystate, yyn, yyrule[yyn]); |
||
1109 |
#endif |
||
1110 |
yym = yylen[yyn]; |
||
1111 |
if (yym) |
||
1112 |
yyval = yyvsp[1-yym]; |
||
1113 |
else |
||
1114 |
memset(&yyval, 0, sizeof yyval); |
||
1115 |
switch (yyn) |
||
1116 |
{ |
||
1117 |
case 3: |
||
1118 |
#line 101 "date.y" |
||
1119 |
{ |
||
1120 |
yyHaveTime++; |
||
1121 |
} |
||
1122 |
break; |
||
1123 |
case 4: |
||
1124 |
#line 104 "date.y" |
||
1125 |
{ |
||
1126 |
yyHaveZone++; |
||
1127 |
} |
||
1128 |
break; |
||
1129 |
case 5: |
||
1130 |
#line 107 "date.y" |
||
1131 |
{ |
||
1132 |
yyHaveDate++; |
||
1133 |
} |
||
1134 |
break; |
||
1135 |
case 6: |
||
1136 |
#line 110 "date.y" |
||
1137 |
{ |
||
1138 |
yyHaveDay++; |
||
1139 |
} |
||
1140 |
break; |
||
1141 |
case 7: |
||
1142 |
#line 113 "date.y" |
||
1143 |
{ |
||
1144 |
yyHaveRel++; |
||
1145 |
} |
||
1146 |
break; |
||
1147 |
case 9: |
||
1148 |
#line 119 "date.y" |
||
1149 |
{ |
||
1150 |
yyHour = yyvsp[-1].Number; |
||
1151 |
yyMinutes = 0; |
||
1152 |
yySeconds = 0; |
||
1153 |
yyMeridian = yyvsp[0].Meridian; |
||
1154 |
} |
||
1155 |
break; |
||
1156 |
case 10: |
||
1157 |
#line 125 "date.y" |
||
1158 |
{ |
||
1159 |
yyHour = yyvsp[-3].Number; |
||
1160 |
yyMinutes = yyvsp[-1].Number; |
||
1161 |
yySeconds = 0; |
||
1162 |
yyMeridian = yyvsp[0].Meridian; |
||
1163 |
} |
||
1164 |
break; |
||
1165 |
case 11: |
||
1166 |
#line 131 "date.y" |
||
1167 |
{ |
||
1168 |
yyHour = yyvsp[-3].Number; |
||
1169 |
yyMinutes = yyvsp[-1].Number; |
||
1170 |
yyMeridian = MER24; |
||
1171 |
yyDSTmode = DSToff; |
||
1172 |
yyTimezone = - (yyvsp[0].Number % 100 + (yyvsp[0].Number / 100) * 60); |
||
1173 |
} |
||
1174 |
break; |
||
1175 |
case 12: |
||
1176 |
#line 138 "date.y" |
||
1177 |
{ |
||
1178 |
yyHour = yyvsp[-5].Number; |
||
1179 |
yyMinutes = yyvsp[-3].Number; |
||
1180 |
yySeconds = yyvsp[-1].Number; |
||
1181 |
yyMeridian = yyvsp[0].Meridian; |
||
1182 |
} |
||
1183 |
break; |
||
1184 |
case 13: |
||
1185 |
#line 144 "date.y" |
||
1186 |
{ |
||
1187 |
yyHour = yyvsp[-5].Number; |
||
1188 |
yyMinutes = yyvsp[-3].Number; |
||
1189 |
yySeconds = yyvsp[-1].Number; |
||
1190 |
yyMeridian = MER24; |
||
1191 |
yyDSTmode = DSToff; |
||
1192 |
yyTimezone = - (yyvsp[0].Number % 100 + (yyvsp[0].Number / 100) * 60); |
||
1193 |
} |
||
1194 |
break; |
||
1195 |
case 14: |
||
1196 |
#line 154 "date.y" |
||
1197 |
{ |
||
1198 |
yyTimezone = yyvsp[0].Number; |
||
1199 |
yyDSTmode = DSToff; |
||
1200 |
} |
||
1201 |
break; |
||
1202 |
case 15: |
||
1203 |
#line 158 "date.y" |
||
1204 |
{ |
||
1205 |
yyTimezone = yyvsp[0].Number; |
||
1206 |
yyDSTmode = DSTon; |
||
1207 |
} |
||
1208 |
break; |
||
1209 |
case 16: |
||
1210 |
#line 162 "date.y" |
||
1211 |
{ |
||
1212 |
yyTimezone = yyvsp[-1].Number; |
||
1213 |
yyDSTmode = DSTon; |
||
1214 |
} |
||
1215 |
break; |
||
1216 |
case 17: |
||
1217 |
#line 168 "date.y" |
||
1218 |
{ |
||
1219 |
yyDayOrdinal = 1; |
||
1220 |
yyDayNumber = yyvsp[0].Number; |
||
1221 |
} |
||
1222 |
break; |
||
1223 |
case 18: |
||
1224 |
#line 172 "date.y" |
||
1225 |
{ |
||
1226 |
yyDayOrdinal = 1; |
||
1227 |
yyDayNumber = yyvsp[-1].Number; |
||
1228 |
} |
||
1229 |
break; |
||
1230 |
case 19: |
||
1231 |
#line 176 "date.y" |
||
1232 |
{ |
||
1233 |
yyDayOrdinal = yyvsp[-1].Number; |
||
1234 |
yyDayNumber = yyvsp[0].Number; |
||
1235 |
} |
||
1236 |
break; |
||
1237 |
case 20: |
||
1238 |
#line 182 "date.y" |
||
1239 |
{ |
||
1240 |
yyMonth = yyvsp[-2].Number; |
||
1241 |
yyDay = yyvsp[0].Number; |
||
1242 |
} |
||
1243 |
break; |
||
1244 |
case 21: |
||
1245 |
#line 186 "date.y" |
||
1246 |
{ |
||
1247 |
if (yyvsp[-4].Number >= 100) { |
||
1248 |
yyYear = yyvsp[-4].Number; |
||
1249 |
yyMonth = yyvsp[-2].Number; |
||
1250 |
yyDay = yyvsp[0].Number; |
||
1251 |
} else { |
||
1252 |
yyMonth = yyvsp[-4].Number; |
||
1253 |
yyDay = yyvsp[-2].Number; |
||
1254 |
yyYear = yyvsp[0].Number; |
||
1255 |
} |
||
1256 |
} |
||
1257 |
break; |
||
1258 |
case 22: |
||
1259 |
#line 197 "date.y" |
||
1260 |
{ |
||
1261 |
/* ISO 8601 format. yyyy-mm-dd. */ |
||
1262 |
yyYear = yyvsp[-2].Number; |
||
1263 |
yyMonth = -yyvsp[-1].Number; |
||
1264 |
yyDay = -yyvsp[0].Number; |
||
1265 |
} |
||
1266 |
break; |
||
1267 |
case 23: |
||
1268 |
#line 203 "date.y" |
||
1269 |
{ |
||
1270 |
/* e.g. 17-JUN-1992. */ |
||
1271 |
yyDay = yyvsp[-2].Number; |
||
1272 |
yyMonth = yyvsp[-1].Number; |
||
1273 |
yyYear = -yyvsp[0].Number; |
||
1274 |
} |
||
1275 |
break; |
||
1276 |
case 24: |
||
1277 |
#line 209 "date.y" |
||
1278 |
{ |
||
1279 |
yyMonth = yyvsp[-1].Number; |
||
1280 |
yyDay = yyvsp[0].Number; |
||
1281 |
} |
||
1282 |
break; |
||
1283 |
case 25: |
||
1284 |
#line 213 "date.y" |
||
1285 |
{ |
||
1286 |
yyMonth = yyvsp[-3].Number; |
||
1287 |
yyDay = yyvsp[-2].Number; |
||
1288 |
yyYear = yyvsp[0].Number; |
||
1289 |
} |
||
1290 |
break; |
||
1291 |
case 26: |
||
1292 |
#line 218 "date.y" |
||
1293 |
{ |
||
1294 |
yyMonth = yyvsp[0].Number; |
||
1295 |
yyDay = yyvsp[-1].Number; |
||
1296 |
} |
||
1297 |
break; |
||
1298 |
case 27: |
||
1299 |
#line 222 "date.y" |
||
1300 |
{ |
||
1301 |
yyMonth = yyvsp[-1].Number; |
||
1302 |
yyDay = yyvsp[-2].Number; |
||
1303 |
yyYear = yyvsp[0].Number; |
||
1304 |
} |
||
1305 |
break; |
||
1306 |
case 28: |
||
1307 |
#line 229 "date.y" |
||
1308 |
{ |
||
1309 |
yyRelSeconds = -yyRelSeconds; |
||
1310 |
yyRelMonth = -yyRelMonth; |
||
1311 |
} |
||
1312 |
break; |
||
1313 |
case 30: |
||
1314 |
#line 236 "date.y" |
||
1315 |
{ |
||
1316 |
yyRelSeconds += yyvsp[-1].Number * yyvsp[0].Number * 60L; |
||
1317 |
} |
||
1318 |
break; |
||
1319 |
case 31: |
||
1320 |
#line 239 "date.y" |
||
1321 |
{ |
||
1322 |
yyRelSeconds += yyvsp[-1].Number * yyvsp[0].Number * 60L; |
||
1323 |
} |
||
1324 |
break; |
||
1325 |
case 32: |
||
1326 |
#line 242 "date.y" |
||
1327 |
{ |
||
1328 |
yyRelSeconds += yyvsp[0].Number * 60L; |
||
1329 |
} |
||
1330 |
break; |
||
1331 |
case 33: |
||
1332 |
#line 245 "date.y" |
||
1333 |
{ |
||
1334 |
yyRelSeconds += yyvsp[-1].Number; |
||
1335 |
} |
||
1336 |
break; |
||
1337 |
case 34: |
||
1338 |
#line 248 "date.y" |
||
1339 |
{ |
||
1340 |
yyRelSeconds += yyvsp[-1].Number; |
||
1341 |
} |
||
1342 |
break; |
||
1343 |
case 35: |
||
1344 |
#line 251 "date.y" |
||
1345 |
{ |
||
1346 |
yyRelSeconds++; |
||
1347 |
} |
||
1348 |
break; |
||
1349 |
case 36: |
||
1350 |
#line 254 "date.y" |
||
1351 |
{ |
||
1352 |
yyRelMonth += yyvsp[-1].Number * yyvsp[0].Number; |
||
1353 |
} |
||
1354 |
break; |
||
1355 |
case 37: |
||
1356 |
#line 257 "date.y" |
||
1357 |
{ |
||
1358 |
yyRelMonth += yyvsp[-1].Number * yyvsp[0].Number; |
||
1359 |
} |
||
1360 |
break; |
||
1361 |
case 38: |
||
1362 |
#line 260 "date.y" |
||
1363 |
{ |
||
1364 |
yyRelMonth += yyvsp[0].Number; |
||
1365 |
} |
||
1366 |
break; |
||
1367 |
case 39: |
||
1368 |
#line 265 "date.y" |
||
1369 |
{ |
||
1370 |
if (yyHaveTime && yyHaveDate && !yyHaveRel) |
||
1371 |
yyYear = yyvsp[0].Number; |
||
1372 |
else { |
||
1373 |
if (yyvsp[0].Number > 10000) { |
||
1374 |
yyHaveDate++; |
||
1375 |
yyDay= (yyvsp[0].Number)%100; |
||
1376 |
yyMonth= (yyvsp[0].Number/100)%100; |
||
1377 |
yyYear = yyvsp[0].Number/10000; |
||
1378 |
} else { |
||
1379 |
yyHaveTime++; |
||
1380 |
if (yyvsp[0].Number < 100) { |
||
1381 |
yyHour = yyvsp[0].Number; |
||
1382 |
yyMinutes = 0; |
||
1383 |
} else { |
||
1384 |
yyHour = yyvsp[0].Number / 100; |
||
1385 |
yyMinutes = yyvsp[0].Number % 100; |
||
1386 |
} |
||
1387 |
yySeconds = 0; |
||
1388 |
yyMeridian = MER24; |
||
1389 |
} |
||
1390 |
} |
||
1391 |
} |
||
1392 |
break; |
||
1393 |
case 40: |
||
1394 |
#line 290 "date.y" |
||
1395 |
{ |
||
1396 |
yyval.Meridian = MER24; |
||
1397 |
} |
||
1398 |
break; |
||
1399 |
28 |
case 41: |
|
1400 |
28 |
#line 293 "date.y" |
|
1401 |
28 |
{ |
|
1402 |
28 |
yyval.Meridian = yyvsp[0].Meridian; |
|
1403 |
✓✓ | 28 |
} |
1404 |
break; |
||
1405 |
#line 1398 "date.c" |
||
1406 |
} |
||
1407 |
yyssp -= yym; |
||
1408 |
yystate = *yyssp; |
||
1409 |
yyvsp -= yym; |
||
1410 |
yym = yylhs[yyn]; |
||
1411 |
12 |
if (yystate == 0 && yym == 0) |
|
1412 |
12 |
{ |
|
1413 |
✓✗ | 12 |
#if YYDEBUG |
1414 |
if (yydebug) |
||
1415 |
12 |
printf("%sdebug: after reduction, shifting from state 0 to\ |
|
1416 |
state %d\n", YYPREFIX, YYFINAL); |
||
1417 |
#endif |
||
1418 |
yystate = YYFINAL; |
||
1419 |
*++yyssp = YYFINAL; |
||
1420 |
*++yyvsp = yyval; |
||
1421 |
if (yychar < 0) |
||
1422 |
{ |
||
1423 |
if ((yychar = yylex()) < 0) yychar = 0; |
||
1424 |
#if YYDEBUG |
||
1425 |
if (yydebug) |
||
1426 |
12 |
{ |
|
1427 |
✓✓ | 12 |
yys = 0; |
1428 |
if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; |
||
1429 |
if (!yys) yys = "illegal-symbol"; |
||
1430 |
✗✓✗✗ ✗✗ |
16 |
printf("%sdebug: state %d, reading %d (%s)\n", |
1431 |
YYPREFIX, YYFINAL, yychar, yys); |
||
1432 |
} |
||
1433 |
#endif |
||
1434 |
16 |
} |
|
1435 |
if (yychar == 0) goto yyaccept; |
||
1436 |
goto yyloop; |
||
1437 |
} |
||
1438 |
if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 && |
||
1439 |
yyn <= YYTABLESIZE && yycheck[yyn] == yystate) |
||
1440 |
✗✓✗✗ |
16 |
yystate = yytable[yyn]; |
1441 |
else |
||
1442 |
yystate = yydgoto[yym]; |
||
1443 |
#if YYDEBUG |
||
1444 |
16 |
if (yydebug) |
|
1445 |
16 |
printf("%sdebug: after reduction, shifting from state %d \ |
|
1446 |
16 |
to state %d\n", YYPREFIX, *yyssp, yystate); |
|
1447 |
#endif |
||
1448 |
if (yyssp >= yysslim && yygrowstack()) |
||
1449 |
{ |
||
1450 |
goto yyoverflow; |
||
1451 |
} |
||
1452 |
*++yyssp = yystate; |
||
1453 |
*++yyvsp = yyval; |
||
1454 |
goto yyloop; |
||
1455 |
yyoverflow: |
||
1456 |
yyerror("yacc stack overflow"); |
||
1457 |
yyabort: |
||
1458 |
if (yyss) |
||
1459 |
✓✗ | 4 |
free(yyss); |
1460 |
4 |
if (yyvs) |
|
1461 |
✓✗ | 4 |
free(yyvs); |
1462 |
4 |
yyss = yyssp = NULL; |
|
1463 |
4 |
yyvs = yyvsp = NULL; |
|
1464 |
4 |
yystacksize = 0; |
|
1465 |
4 |
return (1); |
|
1466 |
4 |
yyaccept: |
|
1467 |
4 |
if (yyss) |
|
1468 |
free(yyss); |
||
1469 |
if (yyvs) |
||
1470 |
free(yyvs); |
||
1471 |
yyss = yyssp = NULL; |
||
1472 |
yyvs = yyvsp = NULL; |
||
1473 |
yystacksize = 0; |
||
1474 |
return (0); |
||
1475 |
} |
| Generated by: GCOVR (Version 3.3) |