![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to parse_date.re CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / date / lib|
Return to parse_date.re CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / date / lib |
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
5: | Copyright (c) 1997-2010 The PHP Group |
6: +----------------------------------------------------------------------+
7: | This source file is subject to version 3.01 of the PHP license, |
8: | that is bundled with this package in the file LICENSE, and is |
9: | available through the world-wide-web at the following url: |
10: | http://www.php.net/license/3_01.txt |
11: | If you did not receive a copy of the PHP license and are unable to |
12: | obtain it through the world-wide-web, please send a note to |
13: | license@php.net so we can mail you a copy immediately. |
14: +----------------------------------------------------------------------+
15: | Authors: Derick Rethans <derick@derickrethans.nl> |
16: +----------------------------------------------------------------------+
17: */
18:
19: /* $Id: parse_date.re 320481 2011-12-06 06:21:08Z derick $ */
20:
21: #include "timelib.h"
22:
23: #include <stdio.h>
24: #include <ctype.h>
25: #include <math.h>
26: #include <assert.h>
27:
28: #ifdef HAVE_STDLIB_H
29: #include <stdlib.h>
30: #endif
31: #ifdef HAVE_STRING_H
32: #include <string.h>
33: #else
34: #include <strings.h>
35: #endif
36:
37: #if defined(_MSC_VER)
38: # define strtoll(s, f, b) _atoi64(s)
39: #elif !defined(HAVE_STRTOLL)
40: # if defined(HAVE_ATOLL)
41: # define strtoll(s, f, b) atoll(s)
42: # else
43: # define strtoll(s, f, b) strtol(s, f, b)
44: # endif
45: #endif
46:
47: #define TIMELIB_UNSET -99999
48:
49: #define TIMELIB_SECOND 1
50: #define TIMELIB_MINUTE 2
51: #define TIMELIB_HOUR 3
52: #define TIMELIB_DAY 4
53: #define TIMELIB_MONTH 5
54: #define TIMELIB_YEAR 6
55: #define TIMELIB_WEEKDAY 7
56: #define TIMELIB_SPECIAL 8
57:
58: #define EOI 257
59: #define TIME 258
60: #define DATE 259
61:
62: #define TIMELIB_XMLRPC_SOAP 260
63: #define TIMELIB_TIME12 261
64: #define TIMELIB_TIME24 262
65: #define TIMELIB_GNU_NOCOLON 263
66: #define TIMELIB_GNU_NOCOLON_TZ 264
67: #define TIMELIB_ISO_NOCOLON 265
68:
69: #define TIMELIB_AMERICAN 266
70: #define TIMELIB_ISO_DATE 267
71: #define TIMELIB_DATE_FULL 268
72: #define TIMELIB_DATE_TEXT 269
73: #define TIMELIB_DATE_NOCOLON 270
74: #define TIMELIB_PG_YEARDAY 271
75: #define TIMELIB_PG_TEXT 272
76: #define TIMELIB_PG_REVERSE 273
77: #define TIMELIB_CLF 274
78: #define TIMELIB_DATE_NO_DAY 275
79: #define TIMELIB_SHORTDATE_WITH_TIME 276
80: #define TIMELIB_DATE_FULL_POINTED 277
81: #define TIMELIB_TIME24_WITH_ZONE 278
82: #define TIMELIB_ISO_WEEK 279
83: #define TIMELIB_LF_DAY_OF_MONTH 280
84: #define TIMELIB_WEEK_DAY_OF_MONTH 281
85:
86: #define TIMELIB_TIMEZONE 300
87: #define TIMELIB_AGO 301
88:
89: #define TIMELIB_RELATIVE 310
90:
91: #define TIMELIB_ERROR 999
92:
93: /* Some compilers like AIX, defines uchar in sys/types.h */
94: #undef uchar
95: typedef unsigned char uchar;
96:
97: #define BSIZE 8192
98:
99: #define YYCTYPE uchar
100: #define YYCURSOR cursor
101: #define YYLIMIT s->lim
102: #define YYMARKER s->ptr
103: #define YYFILL(n) return EOI;
104:
105: #define RET(i) {s->cur = cursor; return i;}
106:
107: #define timelib_string_free free
108:
109: #define TIMELIB_HAVE_TIME() { if (s->time->have_time) { add_error(s, "Double time specification"); timelib_string_free(str); return TIMELIB_ERROR; } else { s->time->have_time = 1; s->time->h = 0; s->time->i = 0; s->time->s = 0; s->time->f = 0; } }
110: #define TIMELIB_UNHAVE_TIME() { s->time->have_time = 0; s->time->h = 0; s->time->i = 0; s->time->s = 0; s->time->f = 0; }
111: #define TIMELIB_HAVE_DATE() { if (s->time->have_date) { add_error(s, "Double date specification"); timelib_string_free(str); return TIMELIB_ERROR; } else { s->time->have_date = 1; } }
112: #define TIMELIB_UNHAVE_DATE() { s->time->have_date = 0; s->time->d = 0; s->time->m = 0; s->time->y = 0; }
113: #define TIMELIB_HAVE_RELATIVE() { s->time->have_relative = 1; }
114: #define TIMELIB_HAVE_WEEKDAY_RELATIVE() { s->time->have_relative = 1; s->time->relative.have_weekday_relative = 1; }
115: #define TIMELIB_HAVE_SPECIAL_RELATIVE() { s->time->have_relative = 1; s->time->relative.have_special_relative = 1; }
116: #define TIMELIB_HAVE_TZ() { s->cur = cursor; if (s->time->have_zone) { s->time->have_zone > 1 ? add_error(s, "Double timezone specification") : add_warning(s, "Double timezone specification"); timelib_string_free(str); s->time->have_zone++; return TIMELIB_ERROR; } else { s->time->have_zone++; } }
117:
118: #define TIMELIB_INIT s->cur = cursor; str = timelib_string(s); ptr = str
119: #define TIMELIB_DEINIT timelib_string_free(str)
120: #define TIMELIB_ADJUST_RELATIVE_WEEKDAY() if (in->time.have_weekday_relative && (in.rel.d > 0)) { in.rel.d -= 7; }
121:
122: #define TIMELIB_PROCESS_YEAR(x, l) { \
123: if (((x) == TIMELIB_UNSET) || ((l) >= 4)) { \
124: /* (x) = 0; */ \
125: } else if ((x) < 100) { \
126: if ((x) < 70) { \
127: (x) += 2000; \
128: } else { \
129: (x) += 1900; \
130: } \
131: } \
132: }
133:
134: #ifdef DEBUG_PARSER
135: #define DEBUG_OUTPUT(s) printf("%s\n", s);
136: #define YYDEBUG(s,c) { if (s != -1) { printf("state: %d ", s); printf("[%c]\n", c); } }
137: #else
138: #define DEBUG_OUTPUT(s)
139: #define YYDEBUG(s,c)
140: #endif
141:
142: #include "timelib_structs.h"
143:
144: typedef struct timelib_elems {
145: unsigned int c; /* Number of elements */
146: char **v; /* Values */
147: } timelib_elems;
148:
149: typedef struct Scanner {
150: int fd;
151: uchar *lim, *str, *ptr, *cur, *tok, *pos;
152: unsigned int line, len;
153: struct timelib_error_container *errors;
154:
155: struct timelib_time *time;
156: const timelib_tzdb *tzdb;
157: } Scanner;
158:
159: typedef struct _timelib_lookup_table {
160: const char *name;
161: int type;
162: int value;
163: } timelib_lookup_table;
164:
165: typedef struct _timelib_relunit {
166: const char *name;
167: int unit;
168: int multiplier;
169: } timelib_relunit;
170:
171: #define HOUR(a) (int)(a * 60)
172:
173: /* The timezone table. */
174: const static timelib_tz_lookup_table timelib_timezone_lookup[] = {
175: #include "timezonemap.h"
176: { NULL, 0, 0, NULL },
177: };
178:
179: const static timelib_tz_lookup_table timelib_timezone_fallbackmap[] = {
180: #include "fallbackmap.h"
181: { NULL, 0, 0, NULL },
182: };
183:
184: const static timelib_tz_lookup_table timelib_timezone_utc[] = {
185: { "utc", 0, 0, "UTC" },
186: };
187:
188: static timelib_relunit const timelib_relunit_lookup[] = {
189: { "sec", TIMELIB_SECOND, 1 },
190: { "secs", TIMELIB_SECOND, 1 },
191: { "second", TIMELIB_SECOND, 1 },
192: { "seconds", TIMELIB_SECOND, 1 },
193: { "min", TIMELIB_MINUTE, 1 },
194: { "mins", TIMELIB_MINUTE, 1 },
195: { "minute", TIMELIB_MINUTE, 1 },
196: { "minutes", TIMELIB_MINUTE, 1 },
197: { "hour", TIMELIB_HOUR, 1 },
198: { "hours", TIMELIB_HOUR, 1 },
199: { "day", TIMELIB_DAY, 1 },
200: { "days", TIMELIB_DAY, 1 },
201: { "week", TIMELIB_DAY, 7 },
202: { "weeks", TIMELIB_DAY, 7 },
203: { "fortnight", TIMELIB_DAY, 14 },
204: { "fortnights", TIMELIB_DAY, 14 },
205: { "forthnight", TIMELIB_DAY, 14 },
206: { "forthnights", TIMELIB_DAY, 14 },
207: { "month", TIMELIB_MONTH, 1 },
208: { "months", TIMELIB_MONTH, 1 },
209: { "year", TIMELIB_YEAR, 1 },
210: { "years", TIMELIB_YEAR, 1 },
211:
212: { "monday", TIMELIB_WEEKDAY, 1 },
213: { "mon", TIMELIB_WEEKDAY, 1 },
214: { "tuesday", TIMELIB_WEEKDAY, 2 },
215: { "tue", TIMELIB_WEEKDAY, 2 },
216: { "wednesday", TIMELIB_WEEKDAY, 3 },
217: { "wed", TIMELIB_WEEKDAY, 3 },
218: { "thursday", TIMELIB_WEEKDAY, 4 },
219: { "thu", TIMELIB_WEEKDAY, 4 },
220: { "friday", TIMELIB_WEEKDAY, 5 },
221: { "fri", TIMELIB_WEEKDAY, 5 },
222: { "saturday", TIMELIB_WEEKDAY, 6 },
223: { "sat", TIMELIB_WEEKDAY, 6 },
224: { "sunday", TIMELIB_WEEKDAY, 0 },
225: { "sun", TIMELIB_WEEKDAY, 0 },
226:
227: { "weekday", TIMELIB_SPECIAL, TIMELIB_SPECIAL_WEEKDAY },
228: { "weekdays", TIMELIB_SPECIAL, TIMELIB_SPECIAL_WEEKDAY },
229: { NULL, 0, 0 }
230: };
231:
232: /* The relative text table. */
233: static timelib_lookup_table const timelib_reltext_lookup[] = {
234: { "first", 0, 1 },
235: { "next", 0, 1 },
236: { "second", 0, 2 },
237: { "third", 0, 3 },
238: { "fourth", 0, 4 },
239: { "fifth", 0, 5 },
240: { "sixth", 0, 6 },
241: { "seventh", 0, 7 },
242: { "eight", 0, 8 },
243: { "eighth", 0, 8 },
244: { "ninth", 0, 9 },
245: { "tenth", 0, 10 },
246: { "eleventh", 0, 11 },
247: { "twelfth", 0, 12 },
248: { "last", 0, -1 },
249: { "previous", 0, -1 },
250: { "this", 1, 0 },
251: { NULL, 1, 0 }
252: };
253:
254: /* The month table. */
255: static timelib_lookup_table const timelib_month_lookup[] = {
256: { "jan", 0, 1 },
257: { "feb", 0, 2 },
258: { "mar", 0, 3 },
259: { "apr", 0, 4 },
260: { "may", 0, 5 },
261: { "jun", 0, 6 },
262: { "jul", 0, 7 },
263: { "aug", 0, 8 },
264: { "sep", 0, 9 },
265: { "sept", 0, 9 },
266: { "oct", 0, 10 },
267: { "nov", 0, 11 },
268: { "dec", 0, 12 },
269: { "i", 0, 1 },
270: { "ii", 0, 2 },
271: { "iii", 0, 3 },
272: { "iv", 0, 4 },
273: { "v", 0, 5 },
274: { "vi", 0, 6 },
275: { "vii", 0, 7 },
276: { "viii", 0, 8 },
277: { "ix", 0, 9 },
278: { "x", 0, 10 },
279: { "xi", 0, 11 },
280: { "xii", 0, 12 },
281:
282: { "january", 0, 1 },
283: { "february", 0, 2 },
284: { "march", 0, 3 },
285: { "april", 0, 4 },
286: { "may", 0, 5 },
287: { "june", 0, 6 },
288: { "july", 0, 7 },
289: { "august", 0, 8 },
290: { "september", 0, 9 },
291: { "october", 0, 10 },
292: { "november", 0, 11 },
293: { "december", 0, 12 },
294: { NULL, 0, 0 }
295: };
296:
297: #if 0
298: static char* timelib_ltrim(char *s)
299: {
300: char *ptr = s;
301: while (ptr[0] == ' ' || ptr[0] == '\t') {
302: ptr++;
303: }
304: return ptr;
305: }
306: #endif
307:
308: #if 0
309: uchar *fill(Scanner *s, uchar *cursor){
310: if(!s->eof){
311: unsigned int cnt = s->tok - s->bot;
312: if(cnt){
313: memcpy(s->bot, s->tok, s->lim - s->tok);
314: s->tok = s->bot;
315: s->ptr -= cnt;
316: cursor -= cnt;
317: s->pos -= cnt;
318: s->lim -= cnt;
319: }
320: if((s->top - s->lim) < BSIZE){
321: uchar *buf = (uchar*) malloc(((s->lim - s->bot) + BSIZE)*sizeof(uchar));
322: memcpy(buf, s->tok, s->lim - s->tok);
323: s->tok = buf;
324: s->ptr = &buf[s->ptr - s->bot];
325: cursor = &buf[cursor - s->bot];
326: s->pos = &buf[s->pos - s->bot];
327: s->lim = &buf[s->lim - s->bot];
328: s->top = &s->lim[BSIZE];
329: free(s->bot);
330: s->bot = buf;
331: }
332: if((cnt = read(s->fd, (char*) s->lim, BSIZE)) != BSIZE){
333: s->eof = &s->lim[cnt]; *(s->eof)++ = '\n';
334: }
335: s->lim += cnt;
336: }
337: return cursor;
338: }
339: #endif
340:
341: static void add_warning(Scanner *s, char *error)
342: {
343: s->errors->warning_count++;
344: s->errors->warning_messages = realloc(s->errors->warning_messages, s->errors->warning_count * sizeof(timelib_error_message));
345: s->errors->warning_messages[s->errors->warning_count - 1].position = s->tok ? s->tok - s->str : 0;
346: s->errors->warning_messages[s->errors->warning_count - 1].character = s->tok ? *s->tok : 0;
347: s->errors->warning_messages[s->errors->warning_count - 1].message = strdup(error);
348: }
349:
350: static void add_error(Scanner *s, char *error)
351: {
352: s->errors->error_count++;
353: s->errors->error_messages = realloc(s->errors->error_messages, s->errors->error_count * sizeof(timelib_error_message));
354: s->errors->error_messages[s->errors->error_count - 1].position = s->tok ? s->tok - s->str : 0;
355: s->errors->error_messages[s->errors->error_count - 1].character = s->tok ? *s->tok : 0;
356: s->errors->error_messages[s->errors->error_count - 1].message = strdup(error);
357: }
358:
359: static void add_pbf_warning(Scanner *s, char *error, char *sptr, char *cptr)
360: {
361: s->errors->warning_count++;
362: s->errors->warning_messages = realloc(s->errors->warning_messages, s->errors->warning_count * sizeof(timelib_error_message));
363: s->errors->warning_messages[s->errors->warning_count - 1].position = cptr - sptr;
364: s->errors->warning_messages[s->errors->warning_count - 1].character = *cptr;
365: s->errors->warning_messages[s->errors->warning_count - 1].message = strdup(error);
366: }
367:
368: static void add_pbf_error(Scanner *s, char *error, char *sptr, char *cptr)
369: {
370: s->errors->error_count++;
371: s->errors->error_messages = realloc(s->errors->error_messages, s->errors->error_count * sizeof(timelib_error_message));
372: s->errors->error_messages[s->errors->error_count - 1].position = cptr - sptr;
373: s->errors->error_messages[s->errors->error_count - 1].character = *cptr;
374: s->errors->error_messages[s->errors->error_count - 1].message = strdup(error);
375: }
376:
377: static timelib_sll timelib_meridian(char **ptr, timelib_sll h)
378: {
379: timelib_sll retval = 0;
380:
381: while (!strchr("AaPp", **ptr)) {
382: ++*ptr;
383: }
384: if (**ptr == 'a' || **ptr == 'A') {
385: if (h == 12) {
386: retval = -12;
387: }
388: } else if (h != 12) {
389: retval = 12;
390: }
391: ++*ptr;
392: if (**ptr == '.') {
393: *ptr += 3;
394: } else {
395: ++*ptr;
396: }
397: return retval;
398: }
399:
400: static timelib_sll timelib_meridian_with_check(char **ptr, timelib_sll h)
401: {
402: timelib_sll retval = 0;
403:
404: while (!strchr("AaPp", **ptr)) {
405: ++*ptr;
406: }
407: if (**ptr == 'a' || **ptr == 'A') {
408: if (h == 12) {
409: retval = -12;
410: }
411: } else if (h != 12) {
412: retval = 12;
413: }
414: ++*ptr;
415: if (**ptr == '.') {
416: ++*ptr;
417: if (**ptr != 'm' && **ptr != 'M') {
418: return TIMELIB_UNSET;
419: }
420: ++*ptr;
421: if (**ptr != '.' ) {
422: return TIMELIB_UNSET;
423: }
424: ++*ptr;
425: } else if (**ptr == 'm' || **ptr == 'M') {
426: ++*ptr;
427: } else {
428: return TIMELIB_UNSET;
429: }
430: return retval;
431: }
432:
433: static char *timelib_string(Scanner *s)
434: {
435: char *tmp = calloc(1, s->cur - s->tok + 1);
436: memcpy(tmp, s->tok, s->cur - s->tok);
437:
438: return tmp;
439: }
440:
441: static timelib_sll timelib_get_nr_ex(char **ptr, int max_length, int *scanned_length)
442: {
443: char *begin, *end, *str;
444: timelib_sll tmp_nr = TIMELIB_UNSET;
445: int len = 0;
446:
447: while ((**ptr < '0') || (**ptr > '9')) {
448: if (**ptr == '\0') {
449: return TIMELIB_UNSET;
450: }
451: ++*ptr;
452: }
453: begin = *ptr;
454: while ((**ptr >= '0') && (**ptr <= '9') && len < max_length) {
455: ++*ptr;
456: ++len;
457: }
458: end = *ptr;
459: if (scanned_length) {
460: *scanned_length = end - begin;
461: }
462: str = calloc(1, end - begin + 1);
463: memcpy(str, begin, end - begin);
464: tmp_nr = strtoll(str, NULL, 10);
465: free(str);
466: return tmp_nr;
467: }
468:
469: static timelib_sll timelib_get_nr(char **ptr, int max_length)
470: {
471: return timelib_get_nr_ex(ptr, max_length, NULL);
472: }
473:
474: static void timelib_skip_day_suffix(char **ptr)
475: {
476: if (isspace(**ptr)) {
477: return;
478: }
479: if (!strncasecmp(*ptr, "nd", 2) || !strncasecmp(*ptr, "rd", 2) ||!strncasecmp(*ptr, "st", 2) || !strncasecmp(*ptr, "th", 2)) {
480: *ptr += 2;
481: }
482: }
483:
484: static double timelib_get_frac_nr(char **ptr, int max_length)
485: {
486: char *begin, *end, *str;
487: double tmp_nr = TIMELIB_UNSET;
488: int len = 0;
489:
490: while ((**ptr != '.') && (**ptr != ':') && ((**ptr < '0') || (**ptr > '9'))) {
491: if (**ptr == '\0') {
492: return TIMELIB_UNSET;
493: }
494: ++*ptr;
495: }
496: begin = *ptr;
497: while (((**ptr == '.') || (**ptr == ':') || ((**ptr >= '0') && (**ptr <= '9'))) && len < max_length) {
498: ++*ptr;
499: ++len;
500: }
501: end = *ptr;
502: str = calloc(1, end - begin + 1);
503: memcpy(str, begin, end - begin);
504: if (str[0] == ':') {
505: str[0] = '.';
506: }
507: tmp_nr = strtod(str, NULL);
508: free(str);
509: return tmp_nr;
510: }
511:
512: static timelib_ull timelib_get_unsigned_nr(char **ptr, int max_length)
513: {
514: timelib_ull dir = 1;
515:
516: while (((**ptr < '0') || (**ptr > '9')) && (**ptr != '+') && (**ptr != '-')) {
517: if (**ptr == '\0') {
518: return TIMELIB_UNSET;
519: }
520: ++*ptr;
521: }
522:
523: while (**ptr == '+' || **ptr == '-')
524: {
525: if (**ptr == '-') {
526: dir *= -1;
527: }
528: ++*ptr;
529: }
530: return dir * timelib_get_nr(ptr, max_length);
531: }
532:
533: static long timelib_parse_tz_cor(char **ptr)
534: {
535: char *begin = *ptr, *end;
536: long tmp;
537:
538: while (isdigit(**ptr) || **ptr == ':') {
539: ++*ptr;
540: }
541: end = *ptr;
542: switch (end - begin) {
543: case 1:
544: case 2:
545: return HOUR(strtol(begin, NULL, 10));
546: break;
547: case 3:
548: case 4:
549: if (begin[1] == ':') {
550: tmp = HOUR(strtol(begin, NULL, 10)) + strtol(begin + 2, NULL, 10);
551: return tmp;
552: } else if (begin[2] == ':') {
553: tmp = HOUR(strtol(begin, NULL, 10)) + strtol(begin + 3, NULL, 10);
554: return tmp;
555: } else {
556: tmp = strtol(begin, NULL, 10);
557: return HOUR(tmp / 100) + tmp % 100;
558: }
559: case 5:
560: tmp = HOUR(strtol(begin, NULL, 10)) + strtol(begin + 3, NULL, 10);
561: return tmp;
562: }
563: return 0;
564: }
565:
566: static timelib_sll timelib_lookup_relative_text(char **ptr, int *behavior)
567: {
568: char *word;
569: char *begin = *ptr, *end;
570: timelib_sll value = 0;
571: const timelib_lookup_table *tp;
572:
573: while ((**ptr >= 'A' && **ptr <= 'Z') || (**ptr >= 'a' && **ptr <= 'z')) {
574: ++*ptr;
575: }
576: end = *ptr;
577: word = calloc(1, end - begin + 1);
578: memcpy(word, begin, end - begin);
579:
580: for (tp = timelib_reltext_lookup; tp->name; tp++) {
581: if (strcasecmp(word, tp->name) == 0) {
582: value = tp->value;
583: *behavior = tp->type;
584: }
585: }
586:
587: free(word);
588: return value;
589: }
590:
591: static timelib_sll timelib_get_relative_text(char **ptr, int *behavior)
592: {
593: while (**ptr == ' ' || **ptr == '\t' || **ptr == '-' || **ptr == '/') {
594: ++*ptr;
595: }
596: return timelib_lookup_relative_text(ptr, behavior);
597: }
598:
599: static long timelib_lookup_month(char **ptr)
600: {
601: char *word;
602: char *begin = *ptr, *end;
603: long value = 0;
604: const timelib_lookup_table *tp;
605:
606: while ((**ptr >= 'A' && **ptr <= 'Z') || (**ptr >= 'a' && **ptr <= 'z')) {
607: ++*ptr;
608: }
609: end = *ptr;
610: word = calloc(1, end - begin + 1);
611: memcpy(word, begin, end - begin);
612:
613: for (tp = timelib_month_lookup; tp->name; tp++) {
614: if (strcasecmp(word, tp->name) == 0) {
615: value = tp->value;
616: }
617: }
618:
619: free(word);
620: return value;
621: }
622:
623: static long timelib_get_month(char **ptr)
624: {
625: while (**ptr == ' ' || **ptr == '\t' || **ptr == '-' || **ptr == '.' || **ptr == '/') {
626: ++*ptr;
627: }
628: return timelib_lookup_month(ptr);
629: }
630:
631: static void timelib_eat_spaces(char **ptr)
632: {
633: while (**ptr == ' ' || **ptr == '\t') {
634: ++*ptr;
635: }
636: }
637:
638: static void timelib_eat_until_separator(char **ptr)
639: {
640: ++*ptr;
641: while (strchr(" \t.,:;/-0123456789", **ptr) == NULL) {
642: ++*ptr;
643: }
644: }
645:
646: static const timelib_relunit* timelib_lookup_relunit(char **ptr)
647: {
648: char *word;
649: char *begin = *ptr, *end;
650: const timelib_relunit *tp, *value = NULL;
651:
652: while (**ptr != '\0' && **ptr != ' ' && **ptr != ',' && **ptr != '\t') {
653: ++*ptr;
654: }
655: end = *ptr;
656: word = calloc(1, end - begin + 1);
657: memcpy(word, begin, end - begin);
658:
659: for (tp = timelib_relunit_lookup; tp->name; tp++) {
660: if (strcasecmp(word, tp->name) == 0) {
661: value = tp;
662: break;
663: }
664: }
665:
666: free(word);
667: return value;
668: }
669:
670: static void timelib_set_relative(char **ptr, timelib_sll amount, int behavior, Scanner *s)
671: {
672: const timelib_relunit* relunit;
673:
674: if (!(relunit = timelib_lookup_relunit(ptr))) {
675: return;
676: }
677:
678: switch (relunit->unit) {
679: case TIMELIB_SECOND: s->time->relative.s += amount * relunit->multiplier; break;
680: case TIMELIB_MINUTE: s->time->relative.i += amount * relunit->multiplier; break;
681: case TIMELIB_HOUR: s->time->relative.h += amount * relunit->multiplier; break;
682: case TIMELIB_DAY: s->time->relative.d += amount * relunit->multiplier; break;
683: case TIMELIB_MONTH: s->time->relative.m += amount * relunit->multiplier; break;
684: case TIMELIB_YEAR: s->time->relative.y += amount * relunit->multiplier; break;
685:
686: case TIMELIB_WEEKDAY:
687: TIMELIB_HAVE_WEEKDAY_RELATIVE();
688: TIMELIB_UNHAVE_TIME();
689: s->time->relative.d += (amount > 0 ? amount - 1 : amount) * 7;
690: s->time->relative.weekday = relunit->multiplier;
691: s->time->relative.weekday_behavior = behavior;
692: break;
693:
694: case TIMELIB_SPECIAL:
695: TIMELIB_HAVE_SPECIAL_RELATIVE();
696: TIMELIB_UNHAVE_TIME();
697: s->time->relative.special.type = relunit->multiplier;
698: s->time->relative.special.amount = amount;
699: }
700: }
701:
702: const static timelib_tz_lookup_table* zone_search(const char *word, long gmtoffset, int isdst)
703: {
704: int first_found = 0;
705: const timelib_tz_lookup_table *tp, *first_found_elem = NULL;
706: const timelib_tz_lookup_table *fmp;
707:
708: if (strcasecmp("utc", word) == 0 || strcasecmp("gmt", word) == 0) {
709: return timelib_timezone_utc;
710: }
711:
712: for (tp = timelib_timezone_lookup; tp->name; tp++) {
713: if (strcasecmp(word, tp->name) == 0) {
714: if (!first_found) {
715: first_found = 1;
716: first_found_elem = tp;
717: if (gmtoffset == -1) {
718: return tp;
719: }
720: }
721: if (tp->gmtoffset == gmtoffset) {
722: return tp;
723: }
724: }
725: }
726: if (first_found) {
727: return first_found_elem;
728: }
729:
730: for (tp = timelib_timezone_lookup; tp->name; tp++) {
731: if (tp->full_tz_name && strcasecmp(word, tp->full_tz_name) == 0) {
732: if (!first_found) {
733: first_found = 1;
734: first_found_elem = tp;
735: if (gmtoffset == -1) {
736: return tp;
737: }
738: }
739: if (tp->gmtoffset == gmtoffset) {
740: return tp;
741: }
742: }
743: }
744: if (first_found) {
745: return first_found_elem;
746: }
747:
748:
749: /* Still didn't find anything, let's find the zone solely based on
750: * offset/isdst then */
751: for (fmp = timelib_timezone_fallbackmap; fmp->name; fmp++) {
752: if ((fmp->gmtoffset * 3600) == gmtoffset && fmp->type == isdst) {
753: return fmp;
754: }
755: }
756: return NULL;
757: }
758:
759: static long timelib_lookup_zone(char **ptr, int *dst, char **tz_abbr, int *found)
760: {
761: char *word;
762: char *begin = *ptr, *end;
763: long value = 0;
764: const timelib_tz_lookup_table *tp;
765:
766: while (**ptr != '\0' && **ptr != ')' && **ptr != ' ') {
767: ++*ptr;
768: }
769: end = *ptr;
770: word = calloc(1, end - begin + 1);
771: memcpy(word, begin, end - begin);
772:
773: if ((tp = zone_search(word, -1, 0))) {
774: value = -tp->gmtoffset / 60;
775: *dst = tp->type;
776: value += tp->type * 60;
777: *found = 1;
778: } else {
779: *found = 0;
780: }
781:
782: *tz_abbr = word;
783: return value;
784: }
785:
786: static long timelib_get_zone(char **ptr, int *dst, timelib_time *t, int *tz_not_found, const timelib_tzdb *tzdb, timelib_tz_get_wrapper tz_wrapper)
787: {
788: timelib_tzinfo *res;
789: long retval = 0;
790:
791: *tz_not_found = 0;
792:
793: while (**ptr == ' ' || **ptr == '\t' || **ptr == '(') {
794: ++*ptr;
795: }
796: if ((*ptr)[0] == 'G' && (*ptr)[1] == 'M' && (*ptr)[2] == 'T' && ((*ptr)[3] == '+' || (*ptr)[3] == '-')) {
797: *ptr += 3;
798: }
799: if (**ptr == '+') {
800: ++*ptr;
801: t->is_localtime = 1;
802: t->zone_type = TIMELIB_ZONETYPE_OFFSET;
803: *tz_not_found = 0;
804: t->dst = 0;
805:
806: retval = -1 * timelib_parse_tz_cor(ptr);
807: } else if (**ptr == '-') {
808: ++*ptr;
809: t->is_localtime = 1;
810: t->zone_type = TIMELIB_ZONETYPE_OFFSET;
811: *tz_not_found = 0;
812: t->dst = 0;
813:
814: retval = timelib_parse_tz_cor(ptr);
815: } else {
816: int found = 0;
817: long offset;
818: char *tz_abbr;
819:
820: t->is_localtime = 1;
821:
822: offset = timelib_lookup_zone(ptr, dst, &tz_abbr, &found);
823: if (found) {
824: t->zone_type = TIMELIB_ZONETYPE_ABBR;
825: }
826: #if 0
827: /* If we found a TimeZone identifier, use it */
828: if (tz_name) {
829: t->tz_info = timelib_parse_tzfile(tz_name);
830: t->zone_type = TIMELIB_ZONETYPE_ID;
831: }
832: #endif
833: /* If we have a TimeZone identifier to start with, use it */
834: if (strstr(tz_abbr, "/") || strcmp(tz_abbr, "UTC") == 0) {
835: if ((res = tz_wrapper(tz_abbr, tzdb)) != NULL) {
836: t->tz_info = res;
837: t->zone_type = TIMELIB_ZONETYPE_ID;
838: found++;
839: }
840: }
841: if (found && t->zone_type != TIMELIB_ZONETYPE_ID) {
842: timelib_time_tz_abbr_update(t, tz_abbr);
843: }
844: free(tz_abbr);
845: *tz_not_found = (found == 0);
846: retval = offset;
847: }
848: while (**ptr == ')') {
849: ++*ptr;
850: }
851: return retval;
852: }
853:
854: #define timelib_split_free(arg) { \
855: int i; \
856: for (i = 0; i < arg.c; i++) { \
857: free(arg.v[i]); \
858: } \
859: if (arg.v) { \
860: free(arg.v); \
861: } \
862: }
863:
864: static int scan(Scanner *s, timelib_tz_get_wrapper tz_get_wrapper)
865: {
866: uchar *cursor = s->cur;
867: char *str, *ptr = NULL;
868:
869: std:
870: s->tok = cursor;
871: s->len = 0;
872: /*!re2c
873: any = [\000-\377];
874:
875: space = [ \t]+;
876: frac = "."[0-9]+;
877:
878: ago = 'ago';
879:
880: hour24 = [01]?[0-9] | "2"[0-4];
881: hour24lz = [01][0-9] | "2"[0-4];
882: hour12 = "0"?[1-9] | "1"[0-2];
883: minute = [0-5]?[0-9];
884: minutelz = [0-5][0-9];
885: second = minute | "60";
886: secondlz = minutelz | "60";
887: meridian = ([AaPp] "."? [Mm] "."?) [\000\t ];
888: tz = "("? [A-Za-z]{1,6} ")"? | [A-Z][a-z]+([_/-][A-Za-z]+)+;
889: tzcorrection = "GMT"? [+-] hour24 ":"? minute?;
890:
891: daysuf = "st" | "nd" | "rd" | "th";
892:
893: month = "0"? [0-9] | "1"[0-2];
894: day = (([0-2]?[0-9]) | ("3"[01])) daysuf?;
895: year = [0-9]{1,4};
896: year2 = [0-9]{2};
897: year4 = [0-9]{4};
898: year4withsign = [+-]? [0-9]{4};
899:
900: dayofyear = "00"[1-9] | "0"[1-9][0-9] | [1-2][0-9][0-9] | "3"[0-5][0-9] | "36"[0-6];
901: weekofyear = "0"[1-9] | [1-4][0-9] | "5"[0-3];
902:
903: monthlz = "0" [0-9] | "1" [0-2];
904: daylz = "0" [0-9] | [1-2][0-9] | "3" [01];
905:
906: dayfull = 'sunday' | 'monday' | 'tuesday' | 'wednesday' | 'thursday' | 'friday' | 'saturday';
907: dayabbr = 'sun' | 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat' | 'sun';
908: dayspecial = 'weekday' | 'weekdays';
909: daytext = dayfull | dayabbr | dayspecial;
910:
911: monthfull = 'january' | 'february' | 'march' | 'april' | 'may' | 'june' | 'july' | 'august' | 'september' | 'october' | 'november' | 'december';
912: monthabbr = 'jan' | 'feb' | 'mar' | 'apr' | 'may' | 'jun' | 'jul' | 'aug' | 'sep' | 'sept' | 'oct' | 'nov' | 'dec';
913: monthroman = "I" | "II" | "III" | "IV" | "V" | "VI" | "VII" | "VIII" | "IX" | "X" | "XI" | "XII";
914: monthtext = monthfull | monthabbr | monthroman;
915:
916: /* Time formats */
917: timetiny12 = hour12 space? meridian;
918: timeshort12 = hour12[:.]minutelz space? meridian;
919: timelong12 = hour12[:.]minute[:.]secondlz space? meridian;
920:
921: timeshort24 = 't'? hour24[:.]minute;
922: timelong24 = 't'? hour24[:.]minute[:.]second;
923: iso8601long = 't'? hour24 [:.] minute [:.] second frac;
924:
925: /* iso8601shorttz = hour24 [:] minutelz space? (tzcorrection | tz); */
926: iso8601normtz = 't'? hour24 [:.] minute [:.] secondlz space? (tzcorrection | tz);
927: /* iso8601longtz = hour24 [:] minute [:] secondlz frac space? (tzcorrection | tz); */
928:
929: gnunocolon = 't'? hour24lz minutelz;
930: /* gnunocolontz = hour24lz minutelz space? (tzcorrection | tz); */
931: iso8601nocolon = 't'? hour24lz minutelz secondlz;
932: /* iso8601nocolontz = hour24lz minutelz secondlz space? (tzcorrection | tz); */
933:
934: /* Date formats */
935: americanshort = month "/" day;
936: american = month "/" day "/" year;
937: iso8601dateslash = year4 "/" monthlz "/" daylz "/"?;
938: dateslash = year4 "/" month "/" day;
939: iso8601date4 = year4withsign "-" monthlz "-" daylz;
940: iso8601date2 = year2 "-" monthlz "-" daylz;
941: gnudateshorter = year4 "-" month;
942: gnudateshort = year "-" month "-" day;
943: pointeddate4 = day [.\t-] month [.-] year4;
944: pointeddate2 = day [.\t] month "." year2;
945: datefull = day ([ \t.-])* monthtext ([ \t.-])* year;
946: datenoday = monthtext ([ .\t-])* year4;
947: datenodayrev = year4 ([ .\t-])* monthtext;
948: datetextual = monthtext ([ .\t-])* day [,.stndrh\t ]+ year;
949: datenoyear = monthtext ([ .\t-])* day [,.stndrh\t ]*;
950: datenoyearrev = day ([ .\t-])* monthtext;
951: datenocolon = year4 monthlz daylz;
952:
953: /* Special formats */
954: soap = year4 "-" monthlz "-" daylz "T" hour24lz ":" minutelz ":" secondlz frac tzcorrection?;
955: xmlrpc = year4 monthlz daylz "T" hour24 ":" minutelz ":" secondlz;
956: xmlrpcnocolon = year4 monthlz daylz 't' hour24 minutelz secondlz;
957: wddx = year4 "-" month "-" day "T" hour24 ":" minute ":" second;
958: pgydotd = year4 "."? dayofyear;
959: pgtextshort = monthabbr "-" daylz "-" year;
960: pgtextreverse = year "-" monthabbr "-" daylz;
961: mssqltime = hour12 ":" minutelz ":" secondlz [:.] [0-9]+ meridian;
962: isoweekday = year4 "-"? "W" weekofyear "-"? [0-7];
963: isoweek = year4 "-"? "W" weekofyear;
964: exif = year4 ":" monthlz ":" daylz " " hour24lz ":" minutelz ":" secondlz;
965: firstdayof = 'first day of'?;
966: lastdayof = 'last day of'?;
967: backof = 'back of ' hour24 space? meridian?;
968: frontof = 'front of ' hour24 space? meridian?;
969:
970: /* Common Log Format: 10/Oct/2000:13:55:36 -0700 */
971: clf = day "/" monthabbr "/" year4 ":" hour24lz ":" minutelz ":" secondlz space tzcorrection;
972:
973: /* Timestamp format: @1126396800 */
974: timestamp = "@" "-"? [0-9]+;
975:
976: /* To fix some ambiguities */
977: dateshortwithtimeshort12 = datenoyear timeshort12;
978: dateshortwithtimelong12 = datenoyear timelong12;
979: dateshortwithtimeshort = datenoyear timeshort24;
980: dateshortwithtimelong = datenoyear timelong24;
981: dateshortwithtimelongtz = datenoyear iso8601normtz;
982:
983: /*
984: * Relative regexps
985: */
986: reltextnumber = 'first'|'second'|'third'|'fourth'|'fifth'|'sixth'|'seventh'|'eight'|'eighth'|'ninth'|'tenth'|'eleventh'|'twelfth';
987: reltexttext = 'next'|'last'|'previous'|'this';
988: reltextunit = (('sec'|'second'|'min'|'minute'|'hour'|'day'|'fortnight'|'forthnight'|'month'|'year') 's'?) | 'weeks' | daytext;
989:
990: relnumber = ([+-]*[ \t]*[0-9]+);
991: relative = relnumber space? (reltextunit | 'week' );
992: relativetext = (reltextnumber|reltexttext) space reltextunit;
993: relativetextweek = reltexttext space 'week';
994:
995: weekdayof = (reltextnumber|reltexttext) space (dayfull|dayabbr) space 'of';
996:
997: */
998:
999: /*!re2c
1000: /* so that vim highlights correctly */
1001: 'yesterday'
1002: {
1003: DEBUG_OUTPUT("yesterday");
1004: TIMELIB_INIT;
1005: TIMELIB_HAVE_RELATIVE();
1006: TIMELIB_UNHAVE_TIME();
1007:
1008: s->time->relative.d = -1;
1009: TIMELIB_DEINIT;
1010: return TIMELIB_RELATIVE;
1011: }
1012:
1013: 'now'
1014: {
1015: DEBUG_OUTPUT("now");
1016: TIMELIB_INIT;
1017:
1018: TIMELIB_DEINIT;
1019: return TIMELIB_RELATIVE;
1020: }
1021:
1022: 'noon'
1023: {
1024: DEBUG_OUTPUT("noon");
1025: TIMELIB_INIT;
1026: TIMELIB_UNHAVE_TIME();
1027: TIMELIB_HAVE_TIME();
1028: s->time->h = 12;
1029:
1030: TIMELIB_DEINIT;
1031: return TIMELIB_RELATIVE;
1032: }
1033:
1034: 'midnight' | 'today'
1035: {
1036: DEBUG_OUTPUT("midnight | today");
1037: TIMELIB_INIT;
1038: TIMELIB_UNHAVE_TIME();
1039:
1040: TIMELIB_DEINIT;
1041: return TIMELIB_RELATIVE;
1042: }
1043:
1044: 'tomorrow'
1045: {
1046: DEBUG_OUTPUT("tomorrow");
1047: TIMELIB_INIT;
1048: TIMELIB_HAVE_RELATIVE();
1049: TIMELIB_UNHAVE_TIME();
1050:
1051: s->time->relative.d = 1;
1052: TIMELIB_DEINIT;
1053: return TIMELIB_RELATIVE;
1054: }
1055:
1056: timestamp
1057: {
1058: timelib_ull i;
1059:
1060: TIMELIB_INIT;
1061: TIMELIB_HAVE_RELATIVE();
1062: TIMELIB_UNHAVE_DATE();
1063: TIMELIB_UNHAVE_TIME();
1064: TIMELIB_HAVE_TZ();
1065:
1066: i = timelib_get_unsigned_nr((char **) &ptr, 24);
1067: s->time->y = 1970;
1068: s->time->m = 1;
1069: s->time->d = 1;
1070: s->time->h = s->time->i = s->time->s = 0;
1071: s->time->f = 0.0;
1072: s->time->relative.s += i;
1073: s->time->is_localtime = 1;
1074: s->time->zone_type = TIMELIB_ZONETYPE_OFFSET;
1075: s->time->z = 0;
1076:
1077: TIMELIB_DEINIT;
1078: return TIMELIB_RELATIVE;
1079: }
1080:
1081: firstdayof | lastdayof
1082: {
1083: DEBUG_OUTPUT("firstdayof | lastdayof");
1084: TIMELIB_INIT;
1085: TIMELIB_HAVE_RELATIVE();
1086:
1087: /* skip "last day of" or "first day of" */
1088: if (*ptr == 'l') {
1089: s->time->relative.first_last_day_of = 2;
1090: } else {
1091: s->time->relative.first_last_day_of = 1;
1092: }
1093:
1094: TIMELIB_DEINIT;
1095: return TIMELIB_LF_DAY_OF_MONTH;
1096: }
1097:
1098: backof | frontof
1099: {
1100: DEBUG_OUTPUT("backof | frontof");
1101: TIMELIB_INIT;
1102: TIMELIB_UNHAVE_TIME();
1103: TIMELIB_HAVE_TIME();
1104:
1105: if (*ptr == 'b') {
1106: s->time->h = timelib_get_nr((char **) &ptr, 2);
1107: s->time->i = 15;
1108: } else {
1109: s->time->h = timelib_get_nr((char **) &ptr, 2) - 1;
1110: s->time->i = 45;
1111: }
1112: if (*ptr != '\0' ) {
1113: timelib_eat_spaces((char **) &ptr);
1114: s->time->h += timelib_meridian((char **) &ptr, s->time->h);
1115: }
1116:
1117: TIMELIB_DEINIT;
1118: return TIMELIB_LF_DAY_OF_MONTH;
1119: }
1120:
1121: weekdayof
1122: {
1123: timelib_sll i;
1124: int behavior = 0;
1125: DEBUG_OUTPUT("weekdayof");
1126: TIMELIB_INIT;
1127: TIMELIB_HAVE_RELATIVE();
1128: TIMELIB_HAVE_SPECIAL_RELATIVE();
1129:
1130: i = timelib_get_relative_text((char **) &ptr, &behavior);
1131: timelib_eat_spaces((char **) &ptr);
1132: if (i > 0) { /* first, second... etc */
1133: s->time->relative.special.type = TIMELIB_SPECIAL_DAY_OF_WEEK_IN_MONTH;
1134: timelib_set_relative((char **) &ptr, i, 1, s);
1135: } else { /* last */
1136: s->time->relative.special.type = TIMELIB_SPECIAL_LAST_DAY_OF_WEEK_IN_MONTH;
1137: timelib_set_relative((char **) &ptr, i, behavior, s);
1138: }
1139: TIMELIB_DEINIT;
1140: return TIMELIB_WEEK_DAY_OF_MONTH;
1141: }
1142:
1143: timetiny12 | timeshort12 | timelong12
1144: {
1145: DEBUG_OUTPUT("timetiny12 | timeshort12 | timelong12");
1146: TIMELIB_INIT;
1147: TIMELIB_HAVE_TIME();
1148: s->time->h = timelib_get_nr((char **) &ptr, 2);
1149: if (*ptr == ':' || *ptr == '.') {
1150: s->time->i = timelib_get_nr((char **) &ptr, 2);
1151: if (*ptr == ':' || *ptr == '.') {
1152: s->time->s = timelib_get_nr((char **) &ptr, 2);
1153: }
1154: }
1155: s->time->h += timelib_meridian((char **) &ptr, s->time->h);
1156: TIMELIB_DEINIT;
1157: return TIMELIB_TIME12;
1158: }
1159:
1160: mssqltime
1161: {
1162: DEBUG_OUTPUT("mssqltime");
1163: TIMELIB_INIT;
1164: TIMELIB_HAVE_TIME();
1165: s->time->h = timelib_get_nr((char **) &ptr, 2);
1166: s->time->i = timelib_get_nr((char **) &ptr, 2);
1167: if (*ptr == ':' || *ptr == '.') {
1168: s->time->s = timelib_get_nr((char **) &ptr, 2);
1169:
1170: if (*ptr == ':' || *ptr == '.') {
1171: s->time->f = timelib_get_frac_nr((char **) &ptr, 8);
1172: }
1173: }
1174: timelib_eat_spaces((char **) &ptr);
1175: s->time->h += timelib_meridian((char **) &ptr, s->time->h);
1176: TIMELIB_DEINIT;
1177: return TIMELIB_TIME24_WITH_ZONE;
1178: }
1179:
1180: timeshort24 | timelong24 /* | iso8601short | iso8601norm */ | iso8601long /*| iso8601shorttz | iso8601normtz | iso8601longtz*/
1181: {
1182: int tz_not_found;
1183: DEBUG_OUTPUT("timeshort24 | timelong24 | iso8601long");
1184: TIMELIB_INIT;
1185: TIMELIB_HAVE_TIME();
1186: s->time->h = timelib_get_nr((char **) &ptr, 2);
1187: s->time->i = timelib_get_nr((char **) &ptr, 2);
1188: if (*ptr == ':' || *ptr == '.') {
1189: s->time->s = timelib_get_nr((char **) &ptr, 2);
1190:
1191: if (*ptr == '.') {
1192: s->time->f = timelib_get_frac_nr((char **) &ptr, 8);
1193: }
1194: }
1195:
1196: if (*ptr != '\0') {
1197: s->time->z = timelib_get_zone((char **) &ptr, &s->time->dst, s->time, &tz_not_found, s->tzdb, tz_get_wrapper);
1198: if (tz_not_found) {
1199: add_error(s, "The timezone could not be found in the database");
1200: }
1201: }
1202: TIMELIB_DEINIT;
1203: return TIMELIB_TIME24_WITH_ZONE;
1204: }
1205:
1206: gnunocolon
1207: {
1208: DEBUG_OUTPUT("gnunocolon");
1209: TIMELIB_INIT;
1210: switch (s->time->have_time) {
1211: case 0:
1212: s->time->h = timelib_get_nr((char **) &ptr, 2);
1213: s->time->i = timelib_get_nr((char **) &ptr, 2);
1214: s->time->s = 0;
1215: break;
1216: case 1:
1217: s->time->y = timelib_get_nr((char **) &ptr, 4);
1218: break;
1219: default:
1220: TIMELIB_DEINIT;
1221: add_error(s, "Double time specification");
1222: return TIMELIB_ERROR;
1223: }
1224: s->time->have_time++;
1225: TIMELIB_DEINIT;
1226: return TIMELIB_GNU_NOCOLON;
1227: }
1228: /*
1229: gnunocolontz
1230: {
1231: DEBUG_OUTPUT("gnunocolontz");
1232: TIMELIB_INIT;
1233: switch (s->time->have_time) {
1234: case 0:
1235: s->time->h = timelib_get_nr((char **) &ptr, 2);
1236: s->time->i = timelib_get_nr((char **) &ptr, 2);
1237: s->time->s = 0;
1238: s->time->z = timelib_get_zone((char **) &ptr, &s->time->dst, s->time, s->tzdb, tz_get_wrapper);
1239: break;
1240: case 1:
1241: s->time->y = timelib_get_nr((char **) &ptr, 4);
1242: break;
1243: default:
1244: TIMELIB_DEINIT;
1245: return TIMELIB_ERROR;
1246: }
1247: s->time->have_time++;
1248: TIMELIB_DEINIT;
1249: return TIMELIB_GNU_NOCOLON_TZ;
1250: }
1251: */
1252: iso8601nocolon /*| iso8601nocolontz*/
1253: {
1254: int tz_not_found;
1255: DEBUG_OUTPUT("iso8601nocolon");
1256: TIMELIB_INIT;
1257: TIMELIB_HAVE_TIME();
1258: s->time->h = timelib_get_nr((char **) &ptr, 2);
1259: s->time->i = timelib_get_nr((char **) &ptr, 2);
1260: s->time->s = timelib_get_nr((char **) &ptr, 2);
1261:
1262: if (*ptr != '\0') {
1263: s->time->z = timelib_get_zone((char **) &ptr, &s->time->dst, s->time, &tz_not_found, s->tzdb, tz_get_wrapper);
1264: if (tz_not_found) {
1265: add_error(s, "The timezone could not be found in the database");
1266: }
1267: }
1268: TIMELIB_DEINIT;
1269: return TIMELIB_ISO_NOCOLON;
1270: }
1271:
1272: americanshort | american
1273: {
1274: int length = 0;
1275: DEBUG_OUTPUT("americanshort | american");
1276: TIMELIB_INIT;
1277: TIMELIB_HAVE_DATE();
1278: s->time->m = timelib_get_nr((char **) &ptr, 2);
1279: s->time->d = timelib_get_nr((char **) &ptr, 2);
1280: if (*ptr == '/') {
1281: s->time->y = timelib_get_nr_ex((char **) &ptr, 4, &length);
1282: TIMELIB_PROCESS_YEAR(s->time->y, length);
1283: }
1284: TIMELIB_DEINIT;
1285: return TIMELIB_AMERICAN;
1286: }
1287:
1288: iso8601date4 | iso8601dateslash | dateslash
1289: {
1290: DEBUG_OUTPUT("iso8601date4 | iso8601date2 | iso8601dateslash | dateslash");
1291: TIMELIB_INIT;
1292: TIMELIB_HAVE_DATE();
1293: s->time->y = timelib_get_unsigned_nr((char **) &ptr, 4);
1294: s->time->m = timelib_get_nr((char **) &ptr, 2);
1295: s->time->d = timelib_get_nr((char **) &ptr, 2);
1296: TIMELIB_DEINIT;
1297: return TIMELIB_ISO_DATE;
1298: }
1299:
1300: iso8601date2
1301: {
1302: int length = 0;
1303: DEBUG_OUTPUT("iso8601date2");
1304: TIMELIB_INIT;
1305: TIMELIB_HAVE_DATE();
1306: s->time->y = timelib_get_nr_ex((char **) &ptr, 4, &length);
1307: s->time->m = timelib_get_nr((char **) &ptr, 2);
1308: s->time->d = timelib_get_nr((char **) &ptr, 2);
1309: TIMELIB_PROCESS_YEAR(s->time->y, length);
1310: TIMELIB_DEINIT;
1311: return TIMELIB_ISO_DATE;
1312: }
1313:
1314: gnudateshorter
1315: {
1316: int length = 0;
1317: DEBUG_OUTPUT("gnudateshorter");
1318: TIMELIB_INIT;
1319: TIMELIB_HAVE_DATE();
1320: s->time->y = timelib_get_nr_ex((char **) &ptr, 4, &length);
1321: s->time->m = timelib_get_nr((char **) &ptr, 2);
1322: s->time->d = 1;
1323: TIMELIB_PROCESS_YEAR(s->time->y, length);
1324: TIMELIB_DEINIT;
1325: return TIMELIB_ISO_DATE;
1326: }
1327:
1328: gnudateshort
1329: {
1330: int length = 0;
1331: DEBUG_OUTPUT("gnudateshort");
1332: TIMELIB_INIT;
1333: TIMELIB_HAVE_DATE();
1334: s->time->y = timelib_get_nr_ex((char **) &ptr, 4, &length);
1335: s->time->m = timelib_get_nr((char **) &ptr, 2);
1336: s->time->d = timelib_get_nr((char **) &ptr, 2);
1337: TIMELIB_PROCESS_YEAR(s->time->y, length);
1338: TIMELIB_DEINIT;
1339: return TIMELIB_ISO_DATE;
1340: }
1341:
1342: datefull
1343: {
1344: int length = 0;
1345: DEBUG_OUTPUT("datefull");
1346: TIMELIB_INIT;
1347: TIMELIB_HAVE_DATE();
1348: s->time->d = timelib_get_nr((char **) &ptr, 2);
1349: timelib_skip_day_suffix((char **) &ptr);
1350: s->time->m = timelib_get_month((char **) &ptr);
1351: s->time->y = timelib_get_nr_ex((char **) &ptr, 4, &length);
1352: TIMELIB_PROCESS_YEAR(s->time->y, length);
1353: TIMELIB_DEINIT;
1354: return TIMELIB_DATE_FULL;
1355: }
1356:
1357: pointeddate4
1358: {
1359: DEBUG_OUTPUT("pointed date YYYY");
1360: TIMELIB_INIT;
1361: TIMELIB_HAVE_DATE();
1362: s->time->d = timelib_get_nr((char **) &ptr, 2);
1363: s->time->m = timelib_get_nr((char **) &ptr, 2);
1364: s->time->y = timelib_get_nr((char **) &ptr, 4);
1365: TIMELIB_DEINIT;
1366: return TIMELIB_DATE_FULL_POINTED;
1367: }
1368:
1369: pointeddate2
1370: {
1371: int length = 0;
1372: DEBUG_OUTPUT("pointed date YY");
1373: TIMELIB_INIT;
1374: TIMELIB_HAVE_DATE();
1375: s->time->d = timelib_get_nr((char **) &ptr, 2);
1376: s->time->m = timelib_get_nr((char **) &ptr, 2);
1377: s->time->y = timelib_get_nr_ex((char **) &ptr, 2, &length);
1378: TIMELIB_PROCESS_YEAR(s->time->y, length);
1379: TIMELIB_DEINIT;
1380: return TIMELIB_DATE_FULL_POINTED;
1381: }
1382:
1383: datenoday
1384: {
1385: int length = 0;
1386: DEBUG_OUTPUT("datenoday");
1387: TIMELIB_INIT;
1388: TIMELIB_HAVE_DATE();
1389: s->time->m = timelib_get_month((char **) &ptr);
1390: s->time->y = timelib_get_nr_ex((char **) &ptr, 4, &length);
1391: s->time->d = 1;
1392: TIMELIB_PROCESS_YEAR(s->time->y, length);
1393: TIMELIB_DEINIT;
1394: return TIMELIB_DATE_NO_DAY;
1395: }
1396:
1397: datenodayrev
1398: {
1399: int length = 0;
1400: DEBUG_OUTPUT("datenodayrev");
1401: TIMELIB_INIT;
1402: TIMELIB_HAVE_DATE();
1403: s->time->y = timelib_get_nr_ex((char **) &ptr, 4, &length);
1404: s->time->m = timelib_get_month((char **) &ptr);
1405: s->time->d = 1;
1406: TIMELIB_PROCESS_YEAR(s->time->y, length);
1407: TIMELIB_DEINIT;
1408: return TIMELIB_DATE_NO_DAY;
1409: }
1410:
1411: datetextual | datenoyear
1412: {
1413: int length = 0;
1414: DEBUG_OUTPUT("datetextual | datenoyear");
1415: TIMELIB_INIT;
1416: TIMELIB_HAVE_DATE();
1417: s->time->m = timelib_get_month((char **) &ptr);
1418: s->time->d = timelib_get_nr((char **) &ptr, 2);
1419: s->time->y = timelib_get_nr_ex((char **) &ptr, 4, &length);
1420: TIMELIB_PROCESS_YEAR(s->time->y, length);
1421: TIMELIB_DEINIT;
1422: return TIMELIB_DATE_TEXT;
1423: }
1424:
1425: datenoyearrev
1426: {
1427: DEBUG_OUTPUT("datenoyearrev");
1428: TIMELIB_INIT;
1429: TIMELIB_HAVE_DATE();
1430: s->time->d = timelib_get_nr((char **) &ptr, 2);
1431: timelib_skip_day_suffix((char **) &ptr);
1432: s->time->m = timelib_get_month((char **) &ptr);
1433: TIMELIB_DEINIT;
1434: return TIMELIB_DATE_TEXT;
1435: }
1436:
1437: datenocolon
1438: {
1439: DEBUG_OUTPUT("datenocolon");
1440: TIMELIB_INIT;
1441: TIMELIB_HAVE_DATE();
1442: s->time->y = timelib_get_nr((char **) &ptr, 4);
1443: s->time->m = timelib_get_nr((char **) &ptr, 2);
1444: s->time->d = timelib_get_nr((char **) &ptr, 2);
1445: TIMELIB_DEINIT;
1446: return TIMELIB_DATE_NOCOLON;
1447: }
1448:
1449: xmlrpc | xmlrpcnocolon | soap | wddx | exif
1450: {
1451: int tz_not_found;
1452: DEBUG_OUTPUT("xmlrpc | xmlrpcnocolon | soap | wddx | exif");
1453: TIMELIB_INIT;
1454: TIMELIB_HAVE_TIME();
1455: TIMELIB_HAVE_DATE();
1456: s->time->y = timelib_get_nr((char **) &ptr, 4);
1457: s->time->m = timelib_get_nr((char **) &ptr, 2);
1458: s->time->d = timelib_get_nr((char **) &ptr, 2);
1459: s->time->h = timelib_get_nr((char **) &ptr, 2);
1460: s->time->i = timelib_get_nr((char **) &ptr, 2);
1461: s->time->s = timelib_get_nr((char **) &ptr, 2);
1462: if (*ptr == '.') {
1463: s->time->f = timelib_get_frac_nr((char **) &ptr, 9);
1464: if (*ptr) { /* timezone is optional */
1465: s->time->z = timelib_get_zone((char **) &ptr, &s->time->dst, s->time, &tz_not_found, s->tzdb, tz_get_wrapper);
1466: if (tz_not_found) {
1467: add_error(s, "The timezone could not be found in the database");
1468: }
1469: }
1470: }
1471: TIMELIB_DEINIT;
1472: return TIMELIB_XMLRPC_SOAP;
1473: }
1474:
1475: pgydotd
1476: {
1477: int length = 0;
1478: DEBUG_OUTPUT("pgydotd");
1479: TIMELIB_INIT;
1480: TIMELIB_HAVE_DATE();
1481: s->time->y = timelib_get_nr_ex((char **) &ptr, 4, &length);
1482: s->time->d = timelib_get_nr((char **) &ptr, 3);
1483: s->time->m = 1;
1484: TIMELIB_PROCESS_YEAR(s->time->y, length);
1485: TIMELIB_DEINIT;
1486: return TIMELIB_PG_YEARDAY;
1487: }
1488:
1489: isoweekday
1490: {
1491: timelib_sll w, d;
1492: DEBUG_OUTPUT("isoweekday");
1493: TIMELIB_INIT;
1494: TIMELIB_HAVE_DATE();
1495: TIMELIB_HAVE_RELATIVE();
1496:
1497: s->time->y = timelib_get_nr((char **) &ptr, 4);
1498: w = timelib_get_nr((char **) &ptr, 2);
1499: d = timelib_get_nr((char **) &ptr, 1);
1500: s->time->m = 1;
1501: s->time->d = 1;
1502: s->time->relative.d = timelib_daynr_from_weeknr(s->time->y, w, d);
1503:
1504: TIMELIB_DEINIT;
1505: return TIMELIB_ISO_WEEK;
1506: }
1507:
1508: isoweek
1509: {
1510: timelib_sll w, d;
1511: DEBUG_OUTPUT("isoweek");
1512: TIMELIB_INIT;
1513: TIMELIB_HAVE_DATE();
1514: TIMELIB_HAVE_RELATIVE();
1515:
1516: s->time->y = timelib_get_nr((char **) &ptr, 4);
1517: w = timelib_get_nr((char **) &ptr, 2);
1518: d = 1;
1519: s->time->m = 1;
1520: s->time->d = 1;
1521: s->time->relative.d = timelib_daynr_from_weeknr(s->time->y, w, d);
1522:
1523: TIMELIB_DEINIT;
1524: return TIMELIB_ISO_WEEK;
1525: }
1526:
1527: pgtextshort
1528: {
1529: int length = 0;
1530: DEBUG_OUTPUT("pgtextshort");
1531: TIMELIB_INIT;
1532: TIMELIB_HAVE_DATE();
1533: s->time->m = timelib_get_month((char **) &ptr);
1534: s->time->d = timelib_get_nr((char **) &ptr, 2);
1535: s->time->y = timelib_get_nr_ex((char **) &ptr, 4, &length);
1536: TIMELIB_PROCESS_YEAR(s->time->y, length);
1537: TIMELIB_DEINIT;
1538: return TIMELIB_PG_TEXT;
1539: }
1540:
1541: pgtextreverse
1542: {
1543: int length = 0;
1544: DEBUG_OUTPUT("pgtextreverse");
1545: TIMELIB_INIT;
1546: TIMELIB_HAVE_DATE();
1547: s->time->y = timelib_get_nr_ex((char **) &ptr, 4, &length);
1548: s->time->m = timelib_get_month((char **) &ptr);
1549: s->time->d = timelib_get_nr((char **) &ptr, 2);
1550: TIMELIB_PROCESS_YEAR(s->time->y, length);
1551: TIMELIB_DEINIT;
1552: return TIMELIB_PG_TEXT;
1553: }
1554:
1555: clf
1556: {
1557: int tz_not_found;
1558: DEBUG_OUTPUT("clf");
1559: TIMELIB_INIT;
1560: TIMELIB_HAVE_TIME();
1561: TIMELIB_HAVE_DATE();
1562: s->time->d = timelib_get_nr((char **) &ptr, 2);
1563: s->time->m = timelib_get_month((char **) &ptr);
1564: s->time->y = timelib_get_nr((char **) &ptr, 4);
1565: s->time->h = timelib_get_nr((char **) &ptr, 2);
1566: s->time->i = timelib_get_nr((char **) &ptr, 2);
1567: s->time->s = timelib_get_nr((char **) &ptr, 2);
1568: s->time->z = timelib_get_zone((char **) &ptr, &s->time->dst, s->time, &tz_not_found, s->tzdb, tz_get_wrapper);
1569: if (tz_not_found) {
1570: add_error(s, "The timezone could not be found in the database");
1571: }
1572: TIMELIB_DEINIT;
1573: return TIMELIB_CLF;
1574: }
1575:
1576: year4
1577: {
1578: DEBUG_OUTPUT("year4");
1579: TIMELIB_INIT;
1580: s->time->y = timelib_get_nr((char **) &ptr, 4);
1581: TIMELIB_DEINIT;
1582: return TIMELIB_CLF;
1583: }
1584:
1585: ago
1586: {
1587: DEBUG_OUTPUT("ago");
1588: TIMELIB_INIT;
1589: s->time->relative.y = 0 - s->time->relative.y;
1590: s->time->relative.m = 0 - s->time->relative.m;
1591: s->time->relative.d = 0 - s->time->relative.d;
1592: s->time->relative.h = 0 - s->time->relative.h;
1593: s->time->relative.i = 0 - s->time->relative.i;
1594: s->time->relative.s = 0 - s->time->relative.s;
1595: s->time->relative.weekday = 0 - s->time->relative.weekday;
1596: if (s->time->relative.weekday == 0) {
1597: s->time->relative.weekday = -7;
1598: }
1599: if (s->time->relative.have_special_relative && s->time->relative.special.type == TIMELIB_SPECIAL_WEEKDAY) {
1600: s->time->relative.special.amount = 0 - s->time->relative.special.amount;
1601: }
1602: TIMELIB_DEINIT;
1603: return TIMELIB_AGO;
1604: }
1605:
1606: daytext
1607: {
1608: const timelib_relunit* relunit;
1609: DEBUG_OUTPUT("daytext");
1610: TIMELIB_INIT;
1611: TIMELIB_HAVE_RELATIVE();
1612: TIMELIB_HAVE_WEEKDAY_RELATIVE();
1613: TIMELIB_UNHAVE_TIME();
1614: relunit = timelib_lookup_relunit((char**) &ptr);
1615: s->time->relative.weekday = relunit->multiplier;
1616: if (s->time->relative.weekday_behavior != 2) {
1617: s->time->relative.weekday_behavior = 1;
1618: }
1619:
1620: TIMELIB_DEINIT;
1621: return TIMELIB_WEEKDAY;
1622: }
1623:
1624: relativetextweek
1625: {
1626: timelib_sll i;
1627: int behavior = 0;
1628: DEBUG_OUTPUT("relativetextweek");
1629: TIMELIB_INIT;
1630: TIMELIB_HAVE_RELATIVE();
1631:
1632: while(*ptr) {
1633: i = timelib_get_relative_text((char **) &ptr, &behavior);
1634: timelib_eat_spaces((char **) &ptr);
1635: timelib_set_relative((char **) &ptr, i, behavior, s);
1636: s->time->relative.weekday_behavior = 2;
1637:
1638: /* to handle the format weekday + last/this/next week */
1639: if (s->time->relative.have_weekday_relative == 0) {
1640: TIMELIB_HAVE_WEEKDAY_RELATIVE();
1641: s->time->relative.weekday = 1;
1642: }
1643: }
1644: TIMELIB_DEINIT;
1645: return TIMELIB_RELATIVE;
1646: }
1647:
1648: relativetext
1649: {
1650: timelib_sll i;
1651: int behavior = 0;
1652: DEBUG_OUTPUT("relativetext");
1653: TIMELIB_INIT;
1654: TIMELIB_HAVE_RELATIVE();
1655:
1656: while(*ptr) {
1657: i = timelib_get_relative_text((char **) &ptr, &behavior);
1658: timelib_eat_spaces((char **) &ptr);
1659: timelib_set_relative((char **) &ptr, i, behavior, s);
1660: }
1661: TIMELIB_DEINIT;
1662: return TIMELIB_RELATIVE;
1663: }
1664:
1665: monthfull | monthabbr
1666: {
1667: DEBUG_OUTPUT("monthtext");
1668: TIMELIB_INIT;
1669: TIMELIB_HAVE_DATE();
1670: s->time->m = timelib_lookup_month((char **) &ptr);
1671: TIMELIB_DEINIT;
1672: return TIMELIB_DATE_TEXT;
1673: }
1674:
1675: tzcorrection | tz
1676: {
1677: int tz_not_found;
1678: DEBUG_OUTPUT("tzcorrection | tz");
1679: TIMELIB_INIT;
1680: TIMELIB_HAVE_TZ();
1681: s->time->z = timelib_get_zone((char **) &ptr, &s->time->dst, s->time, &tz_not_found, s->tzdb, tz_get_wrapper);
1682: if (tz_not_found) {
1683: add_error(s, "The timezone could not be found in the database");
1684: }
1685: TIMELIB_DEINIT;
1686: return TIMELIB_TIMEZONE;
1687: }
1688:
1689: dateshortwithtimeshort12 | dateshortwithtimelong12
1690: {
1691: DEBUG_OUTPUT("dateshortwithtimeshort12 | dateshortwithtimelong12");
1692: TIMELIB_INIT;
1693: TIMELIB_HAVE_DATE();
1694: s->time->m = timelib_get_month((char **) &ptr);
1695: s->time->d = timelib_get_nr((char **) &ptr, 2);
1696:
1697: TIMELIB_HAVE_TIME();
1698: s->time->h = timelib_get_nr((char **) &ptr, 2);
1699: s->time->i = timelib_get_nr((char **) &ptr, 2);
1700: if (*ptr == ':' || *ptr == '.') {
1701: s->time->s = timelib_get_nr((char **) &ptr, 2);
1702:
1703: if (*ptr == '.') {
1704: s->time->f = timelib_get_frac_nr((char **) &ptr, 8);
1705: }
1706: }
1707:
1708: s->time->h += timelib_meridian((char **) &ptr, s->time->h);
1709: TIMELIB_DEINIT;
1710: return TIMELIB_SHORTDATE_WITH_TIME;
1711: }
1712:
1713: dateshortwithtimeshort | dateshortwithtimelong | dateshortwithtimelongtz
1714: {
1715: int tz_not_found;
1716: DEBUG_OUTPUT("dateshortwithtimeshort | dateshortwithtimelong | dateshortwithtimelongtz");
1717: TIMELIB_INIT;
1718: TIMELIB_HAVE_DATE();
1719: s->time->m = timelib_get_month((char **) &ptr);
1720: s->time->d = timelib_get_nr((char **) &ptr, 2);
1721:
1722: TIMELIB_HAVE_TIME();
1723: s->time->h = timelib_get_nr((char **) &ptr, 2);
1724: s->time->i = timelib_get_nr((char **) &ptr, 2);
1725: if (*ptr == ':') {
1726: s->time->s = timelib_get_nr((char **) &ptr, 2);
1727:
1728: if (*ptr == '.') {
1729: s->time->f = timelib_get_frac_nr((char **) &ptr, 8);
1730: }
1731: }
1732:
1733: if (*ptr != '\0') {
1734: s->time->z = timelib_get_zone((char **) &ptr, &s->time->dst, s->time, &tz_not_found, s->tzdb, tz_get_wrapper);
1735: if (tz_not_found) {
1736: add_error(s, "The timezone could not be found in the database");
1737: }
1738: }
1739: TIMELIB_DEINIT;
1740: return TIMELIB_SHORTDATE_WITH_TIME;
1741: }
1742:
1743: relative
1744: {
1745: timelib_ull i;
1746: DEBUG_OUTPUT("relative");
1747: TIMELIB_INIT;
1748: TIMELIB_HAVE_RELATIVE();
1749:
1750: while(*ptr) {
1751: i = timelib_get_unsigned_nr((char **) &ptr, 24);
1752: timelib_eat_spaces((char **) &ptr);
1753: timelib_set_relative((char **) &ptr, i, 1, s);
1754: }
1755: TIMELIB_DEINIT;
1756: return TIMELIB_RELATIVE;
1757: }
1758:
1759: [ .,\t]
1760: {
1761: goto std;
1762: }
1763:
1764: "\000"|"\n"
1765: {
1766: s->pos = cursor; s->line++;
1767: goto std;
1768: }
1769:
1770: any
1771: {
1772: add_error(s, "Unexpected character");
1773: goto std;
1774: }
1775: */
1776: }
1777:
1778: /*!max:re2c */
1779:
1780: timelib_time* timelib_strtotime(char *s, int len, struct timelib_error_container **errors, const timelib_tzdb *tzdb, timelib_tz_get_wrapper tz_get_wrapper)
1781: {
1782: Scanner in;
1783: int t;
1784: char *e = s + len - 1;
1785:
1786: memset(&in, 0, sizeof(in));
1787: in.errors = malloc(sizeof(struct timelib_error_container));
1788: in.errors->warning_count = 0;
1789: in.errors->warning_messages = NULL;
1790: in.errors->error_count = 0;
1791: in.errors->error_messages = NULL;
1792:
1793: if (len > 0) {
1794: while (isspace(*s) && s < e) {
1795: s++;
1796: }
1797: while (isspace(*e) && e > s) {
1798: e--;
1799: }
1800: }
1801: if (e - s < 0) {
1802: in.time = timelib_time_ctor();
1803: add_error(&in, "Empty string");
1804: if (errors) {
1805: *errors = in.errors;
1806: } else {
1807: timelib_error_container_dtor(in.errors);
1808: }
1809: in.time->y = in.time->d = in.time->m = in.time->h = in.time->i = in.time->s = in.time->f = in.time->dst = in.time->z = TIMELIB_UNSET;
1810: in.time->is_localtime = in.time->zone_type = 0;
1811: return in.time;
1812: }
1813: e++;
1814:
1815: in.str = malloc((e - s) + YYMAXFILL);
1816: memset(in.str, 0, (e - s) + YYMAXFILL);
1817: memcpy(in.str, s, (e - s));
1818: in.lim = in.str + (e - s) + YYMAXFILL;
1819: in.cur = in.str;
1820: in.time = timelib_time_ctor();
1821: in.time->y = TIMELIB_UNSET;
1822: in.time->d = TIMELIB_UNSET;
1823: in.time->m = TIMELIB_UNSET;
1824: in.time->h = TIMELIB_UNSET;
1825: in.time->i = TIMELIB_UNSET;
1826: in.time->s = TIMELIB_UNSET;
1827: in.time->f = TIMELIB_UNSET;
1828: in.time->z = TIMELIB_UNSET;
1829: in.time->dst = TIMELIB_UNSET;
1830: in.tzdb = tzdb;
1831: in.time->is_localtime = 0;
1832: in.time->zone_type = 0;
1833:
1834: do {
1835: t = scan(&in, tz_get_wrapper);
1836: #ifdef DEBUG_PARSER
1837: printf("%d\n", t);
1838: #endif
1839: } while(t != EOI);
1840:
1841: /* do funky checking whether the parsed time was valid time */
1842: if (in.time->have_time && !timelib_valid_time( in.time->h, in.time->i, in.time->s)) {
1843: add_warning(&in, "The parsed time was invalid");
1844: }
1845: /* do funky checking whether the parsed date was valid date */
1846: if (in.time->have_date && !timelib_valid_date( in.time->y, in.time->m, in.time->d)) {
1847: add_warning(&in, "The parsed date was invalid");
1848: }
1849:
1850: free(in.str);
1851: if (errors) {
1852: *errors = in.errors;
1853: } else {
1854: timelib_error_container_dtor(in.errors);
1855: }
1856: return in.time;
1857: }
1858:
1859: #define TIMELIB_CHECK_NUMBER \
1860: if (strchr("0123456789", *ptr) == NULL) \
1861: { \
1862: add_pbf_error(s, "Unexpected data found.", string, begin); \
1863: }
1864:
1865: static void timelib_time_reset_fields(timelib_time *time)
1866: {
1867: assert(time != NULL);
1868:
1869: time->y = 1970;
1870: time->m = 1;
1871: time->d = 1;
1872: time->h = time->i = time->s = 0;
1873: time->f = 0.0;
1874: time->tz_info = NULL;
1875: }
1876:
1877: static void timelib_time_reset_unset_fields(timelib_time *time)
1878: {
1879: assert(time != NULL);
1880:
1881: if (time->y == TIMELIB_UNSET ) time->y = 1970;
1882: if (time->m == TIMELIB_UNSET ) time->m = 1;
1883: if (time->d == TIMELIB_UNSET ) time->d = 1;
1884: if (time->h == TIMELIB_UNSET ) time->h = 0;
1885: if (time->i == TIMELIB_UNSET ) time->i = 0;
1886: if (time->s == TIMELIB_UNSET ) time->s = 0;
1887: if (time->f == TIMELIB_UNSET ) time->f = 0.0;
1888: }
1889:
1890: timelib_time *timelib_parse_from_format(char *format, char *string, int len, timelib_error_container **errors, const timelib_tzdb *tzdb, timelib_tz_get_wrapper tz_get_wrapper)
1891: {
1892: char *fptr = format;
1893: char *ptr = string;
1894: char *begin;
1895: timelib_sll tmp;
1896: Scanner in;
1897: Scanner *s = ∈
1898: int allow_extra = 0;
1899:
1900: memset(&in, 0, sizeof(in));
1901: in.errors = malloc(sizeof(struct timelib_error_container));
1902: in.errors->warning_count = 0;
1903: in.errors->warning_messages = NULL;
1904: in.errors->error_count = 0;
1905: in.errors->error_messages = NULL;
1906:
1907: in.time = timelib_time_ctor();
1908: in.time->y = TIMELIB_UNSET;
1909: in.time->d = TIMELIB_UNSET;
1910: in.time->m = TIMELIB_UNSET;
1911: in.time->h = TIMELIB_UNSET;
1912: in.time->i = TIMELIB_UNSET;
1913: in.time->s = TIMELIB_UNSET;
1914: in.time->f = TIMELIB_UNSET;
1915: in.time->z = TIMELIB_UNSET;
1916: in.time->dst = TIMELIB_UNSET;
1917: in.tzdb = tzdb;
1918: in.time->is_localtime = 0;
1919: in.time->zone_type = 0;
1920:
1921: /* Loop over the format string */
1922: while (*fptr && *ptr) {
1923: begin = ptr;
1924: switch (*fptr) {
1925: case 'D': /* three letter day */
1926: case 'l': /* full day */
1927: {
1928: const timelib_relunit* tmprel = 0;
1929:
1930: tmprel = timelib_lookup_relunit((char **) &ptr);
1931: if (!tmprel) {
1932: add_pbf_error(s, "A textual day could not be found", string, begin);
1933: break;
1934: } else {
1935: in.time->have_relative = 1;
1936: in.time->relative.have_weekday_relative = 1;
1937: in.time->relative.weekday = tmprel->multiplier;
1938: in.time->relative.weekday_behavior = 1;
1939: }
1940: }
1941: break;
1942: case 'd': /* two digit day, with leading zero */
1943: case 'j': /* two digit day, without leading zero */
1944: TIMELIB_CHECK_NUMBER;
1945: if ((s->time->d = timelib_get_nr((char **) &ptr, 2)) == TIMELIB_UNSET) {
1946: add_pbf_error(s, "A two digit day could not be found", string, begin);
1947: }
1948: break;
1949: case 'S': /* day suffix, ignored, nor checked */
1950: timelib_skip_day_suffix((char **) &ptr);
1951: break;
1952: case 'z': /* day of year - resets month (0 based) - also initializes everything else to !TIMELIB_UNSET */
1953: TIMELIB_CHECK_NUMBER;
1954: if ((tmp = timelib_get_nr((char **) &ptr, 3)) == TIMELIB_UNSET) {
1955: add_pbf_error(s, "A three digit day-of-year could not be found", string, begin);
1956: } else {
1957: s->time->m = 1;
1958: s->time->d = tmp + 1;
1959: timelib_do_normalize(s->time);
1960: }
1961: break;
1962:
1963: case 'm': /* two digit month, with leading zero */
1964: case 'n': /* two digit month, without leading zero */
1965: TIMELIB_CHECK_NUMBER;
1966: if ((s->time->m = timelib_get_nr((char **) &ptr, 2)) == TIMELIB_UNSET) {
1967: add_pbf_error(s, "A two digit month could not be found", string, begin);
1968: }
1969: break;
1970: case 'M': /* three letter month */
1971: case 'F': /* full month */
1972: tmp = timelib_lookup_month((char **) &ptr);
1973: if (!tmp) {
1974: add_pbf_error(s, "A textual month could not be found", string, begin);
1975: } else {
1976: s->time->m = tmp;
1977: }
1978: break;
1979: case 'y': /* two digit year */
1980: {
1981: int length = 0;
1982: TIMELIB_CHECK_NUMBER;
1983: if ((s->time->y = timelib_get_nr_ex((char **) &ptr, 2, &length)) == TIMELIB_UNSET) {
1984: add_pbf_error(s, "A two digit year could not be found", string, begin);
1985: }
1986: TIMELIB_PROCESS_YEAR(s->time->y, length);
1987: }
1988: break;
1989: case 'Y': /* four digit year */
1990: TIMELIB_CHECK_NUMBER;
1991: if ((s->time->y = timelib_get_nr((char **) &ptr, 4)) == TIMELIB_UNSET) {
1992: add_pbf_error(s, "A four digit year could not be found", string, begin);
1993: }
1994: break;
1995: case 'g': /* two digit hour, with leading zero */
1996: case 'h': /* two digit hour, without leading zero */
1997: TIMELIB_CHECK_NUMBER;
1998: if ((s->time->h = timelib_get_nr((char **) &ptr, 2)) == TIMELIB_UNSET) {
1999: add_pbf_error(s, "A two digit hour could not be found", string, begin);
2000: }
2001: if (s->time->h > 12) {
2002: add_pbf_error(s, "Hour can not be higher than 12", string, begin);
2003: }
2004: break;
2005: case 'G': /* two digit hour, with leading zero */
2006: case 'H': /* two digit hour, without leading zero */
2007: TIMELIB_CHECK_NUMBER;
2008: if ((s->time->h = timelib_get_nr((char **) &ptr, 2)) == TIMELIB_UNSET) {
2009: add_pbf_error(s, "A two digit hour could not be found", string, begin);
2010: }
2011: break;
2012: case 'a': /* am/pm/a.m./p.m. */
2013: case 'A': /* AM/PM/A.M./P.M. */
2014: if (s->time->h == TIMELIB_UNSET) {
2015: add_pbf_error(s, "Meridian can only come after an hour has been found", string, begin);
2016: } else if ((tmp = timelib_meridian_with_check((char **) &ptr, s->time->h)) == TIMELIB_UNSET) {
2017: add_pbf_error(s, "A meridian could not be found", string, begin);
2018: } else {
2019: s->time->h += tmp;
2020: }
2021: break;
2022: case 'i': /* two digit minute, with leading zero */
2023: {
2024: int length;
2025: timelib_sll min;
2026:
2027: TIMELIB_CHECK_NUMBER;
2028: min = timelib_get_nr_ex((char **) &ptr, 2, &length);
2029: if (min == TIMELIB_UNSET || length != 2) {
2030: add_pbf_error(s, "A two digit minute could not be found", string, begin);
2031: } else {
2032: s->time->i = min;
2033: }
2034: }
2035: break;
2036: case 's': /* two digit second, with leading zero */
2037: {
2038: int length;
2039: timelib_sll sec;
2040:
2041: TIMELIB_CHECK_NUMBER;
2042: sec = timelib_get_nr_ex((char **) &ptr, 2, &length);
2043: if (sec == TIMELIB_UNSET || length != 2) {
2044: add_pbf_error(s, "A two second minute could not be found", string, begin);
2045: } else {
2046: s->time->s = sec;
2047: }
2048: }
2049: break;
2050: case 'u': /* up to six digit millisecond */
2051: {
2052: double f;
2053: char *tptr;
2054:
2055: TIMELIB_CHECK_NUMBER;
2056: tptr = ptr;
2057: if ((f = timelib_get_nr((char **) &ptr, 6)) == TIMELIB_UNSET || (ptr - tptr < 1)) {
2058: add_pbf_error(s, "A six digit millisecond could not be found", string, begin);
2059: } else {
2060: s->time->f = (f / pow(10, (ptr - tptr)));
2061: }
2062: }
2063: break;
2064: case ' ': /* any sort of whitespace (' ' and \t) */
2065: timelib_eat_spaces((char **) &ptr);
2066: break;
2067: case 'U': /* epoch seconds */
2068: TIMELIB_CHECK_NUMBER;
2069: TIMELIB_HAVE_RELATIVE();
2070: tmp = timelib_get_unsigned_nr((char **) &ptr, 24);
2071: s->time->y = 1970;
2072: s->time->m = 1;
2073: s->time->d = 1;
2074: s->time->h = s->time->i = s->time->s = 0;
2075: s->time->f = 0.0;
2076: s->time->relative.s += tmp;
2077: s->time->is_localtime = 1;
2078: s->time->zone_type = TIMELIB_ZONETYPE_OFFSET;
2079: s->time->z = 0;
2080: break;
2081:
2082: case 'e': /* timezone */
2083: case 'P': /* timezone */
2084: case 'T': /* timezone */
2085: case 'O': /* timezone */
2086: {
2087: int tz_not_found;
2088: s->time->z = timelib_get_zone((char **) &ptr, &s->time->dst, s->time, &tz_not_found, s->tzdb, tz_get_wrapper);
2089: if (tz_not_found) {
2090: add_pbf_error(s, "The timezone could not be found in the database", string, begin);
2091: }
2092: }
2093: break;
2094:
2095: case '#': /* separation symbol */
2096: if (*ptr == ';' || *ptr == ':' || *ptr == '/' || *ptr == '.' || *ptr == ',' || *ptr == '-' || *ptr == '(' || *ptr == ')') {
2097: ++ptr;
2098: } else {
2099: add_pbf_error(s, "The separation symbol ([;:/.,-]) could not be found", string, begin);
2100: }
2101: break;
2102:
2103: case ';':
2104: case ':':
2105: case '/':
2106: case '.':
2107: case ',':
2108: case '-':
2109: case '(':
2110: case ')':
2111: if (*ptr == *fptr) {
2112: ++ptr;
2113: } else {
2114: add_pbf_error(s, "The separation symbol could not be found", string, begin);
2115: }
2116: break;
2117:
2118: case '!': /* reset all fields to default */
2119: timelib_time_reset_fields(s->time);
2120: break; /* break intentionally not missing */
2121:
2122: case '|': /* reset all fields to default when not set */
2123: timelib_time_reset_unset_fields(s->time);
2124: break; /* break intentionally not missing */
2125:
2126: case '?': /* random char */
2127: ++ptr;
2128: break;
2129:
2130: case '\\': /* escaped char */
2131: *fptr++;
2132: if (*ptr == *fptr) {
2133: ++ptr;
2134: } else {
2135: add_pbf_error(s, "The escaped character could not be found", string, begin);
2136: }
2137: break;
2138:
2139: case '*': /* random chars until a separator or number ([ \t.,:;/-0123456789]) */
2140: timelib_eat_until_separator((char **) &ptr);
2141: break;
2142:
2143: case '+': /* allow extra chars in the format */
2144: allow_extra = 1;
2145: break;
2146:
2147: default:
2148: if (*fptr != *ptr) {
2149: add_pbf_error(s, "The format separator does not match", string, begin);
2150: }
2151: ptr++;
2152: }
2153: fptr++;
2154: }
2155: if (*ptr) {
2156: if (allow_extra) {
2157: add_pbf_warning(s, "Trailing data", string, ptr);
2158: } else {
2159: add_pbf_error(s, "Trailing data", string, ptr);
2160: }
2161: }
2162: /* ignore trailing +'s */
2163: while (*fptr == '+') {
2164: fptr++;
2165: }
2166: if (*fptr) {
2167: /* Trailing | and ! specifiers are valid. */
2168: int done = 0;
2169: while (*fptr && !done) {
2170: switch (*fptr++) {
2171: case '!': /* reset all fields to default */
2172: timelib_time_reset_fields(s->time);
2173: break;
2174:
2175: case '|': /* reset all fields to default when not set */
2176: timelib_time_reset_unset_fields(s->time);
2177: break;
2178:
2179: default:
2180: add_pbf_error(s, "Data missing", string, ptr);
2181: done = 1;
2182: }
2183: }
2184: }
2185:
2186: /* clean up a bit */
2187: if (s->time->h != TIMELIB_UNSET || s->time->i != TIMELIB_UNSET || s->time->s != TIMELIB_UNSET) {
2188: if (s->time->h == TIMELIB_UNSET ) {
2189: s->time->h = 0;
2190: }
2191: if (s->time->i == TIMELIB_UNSET ) {
2192: s->time->i = 0;
2193: }
2194: if (s->time->s == TIMELIB_UNSET ) {
2195: s->time->s = 0;
2196: }
2197: }
2198:
2199: /* do funky checking whether the parsed time was valid time */
2200: if (s->time->h != TIMELIB_UNSET && s->time->i != TIMELIB_UNSET &&
2201: s->time->s != TIMELIB_UNSET &&
2202: !timelib_valid_time( s->time->h, s->time->i, s->time->s)) {
2203: add_pbf_warning(s, "The parsed time was invalid", string, ptr);
2204: }
2205: /* do funky checking whether the parsed date was valid date */
2206: if (s->time->y != TIMELIB_UNSET && s->time->m != TIMELIB_UNSET &&
2207: s->time->d != TIMELIB_UNSET &&
2208: !timelib_valid_date( s->time->y, s->time->m, s->time->d)) {
2209: add_pbf_warning(s, "The parsed date was invalid", string, ptr);
2210: }
2211:
2212: if (errors) {
2213: *errors = in.errors;
2214: } else {
2215: timelib_error_container_dtor(in.errors);
2216: }
2217: return in.time;
2218: }
2219:
2220: void timelib_fill_holes(timelib_time *parsed, timelib_time *now, int options)
2221: {
2222: if (!(options & TIMELIB_OVERRIDE_TIME) && parsed->have_date && !parsed->have_time) {
2223: parsed->h = 0;
2224: parsed->i = 0;
2225: parsed->s = 0;
2226: parsed->f = 0;
2227: }
2228: if (parsed->y == TIMELIB_UNSET) parsed->y = now->y != TIMELIB_UNSET ? now->y : 0;
2229: if (parsed->d == TIMELIB_UNSET) parsed->d = now->d != TIMELIB_UNSET ? now->d : 0;
2230: if (parsed->m == TIMELIB_UNSET) parsed->m = now->m != TIMELIB_UNSET ? now->m : 0;
2231: if (parsed->h == TIMELIB_UNSET) parsed->h = now->h != TIMELIB_UNSET ? now->h : 0;
2232: if (parsed->i == TIMELIB_UNSET) parsed->i = now->i != TIMELIB_UNSET ? now->i : 0;
2233: if (parsed->s == TIMELIB_UNSET) parsed->s = now->s != TIMELIB_UNSET ? now->s : 0;
2234: if (parsed->f == TIMELIB_UNSET) parsed->f = now->f != TIMELIB_UNSET ? now->f : 0;
2235: if (parsed->z == TIMELIB_UNSET) parsed->z = now->z != TIMELIB_UNSET ? now->z : 0;
2236: if (parsed->dst == TIMELIB_UNSET) parsed->dst = now->dst != TIMELIB_UNSET ? now->dst : 0;
2237:
2238: if (!parsed->tz_abbr) {
2239: parsed->tz_abbr = now->tz_abbr ? strdup(now->tz_abbr) : NULL;
2240: }
2241: if (!parsed->tz_info) {
2242: parsed->tz_info = now->tz_info ? (!(options & TIMELIB_NO_CLONE) ? timelib_tzinfo_clone(now->tz_info) : now->tz_info) : NULL;
2243: }
2244: if (parsed->zone_type == 0 && now->zone_type != 0) {
2245: parsed->zone_type = now->zone_type;
2246: /* parsed->tz_abbr = now->tz_abbr ? strdup(now->tz_abbr) : NULL;
2247: parsed->tz_info = now->tz_info ? timelib_tzinfo_clone(now->tz_info) : NULL;
2248: */ parsed->is_localtime = 1;
2249: }
2250: /* timelib_dump_date(parsed, 2);
2251: timelib_dump_date(now, 2);
2252: */
2253: }
2254:
2255: char *timelib_timezone_id_from_abbr(const char *abbr, long gmtoffset, int isdst)
2256: {
2257: const timelib_tz_lookup_table *tp;
2258:
2259: tp = zone_search(abbr, gmtoffset, isdst);
2260: if (tp) {
2261: return (tp->full_tz_name);
2262: } else {
2263: return NULL;
2264: }
2265: }
2266:
2267: const timelib_tz_lookup_table *timelib_timezone_abbreviations_list(void)
2268: {
2269: return timelib_timezone_lookup;
2270: }
2271:
2272: #ifdef DEBUG_PARSER_STUB
2273: int main(void)
2274: {
2275: timelib_time time = timelib_strtotime("May 12");
2276:
2277: printf ("%04d-%02d-%02d %02d:%02d:%02d.%-5d %+04d %1d",
2278: time.y, time.m, time.d, time.h, time.i, time.s, time.f, time.z, time.dst);
2279: if (time.have_relative) {
2280: printf ("%3dY %3dM %3dD / %3dH %3dM %3dS",
2281: time.relative.y, time.relative.m, time.relative.d, time.relative.h, time.relative.i, time.relative.s);
2282: }
2283: if (time.have_weekday_relative) {
2284: printf (" / %d", time.relative.weekday);
2285: }
2286: if (time.have_weeknr_day) {
2287: printf(" / %dW%d", time.relative.weeknr_day.weeknr, time.relative.weeknr_day.dayofweek);
2288: }
2289: return 0;
2290: }
2291: #endif
2292:
2293: /*
2294: * vim: syntax=c
2295: */