#include "logger.h"
#include <stdio.h>
#include <sys/types.h>
#include <time.h>
#include <ctype.h>
#include <sys/time.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
#define tAGO 257
#define tDAY 258
#define tDAY_UNIT 259
#define tDAYZONE 260
#define tDST 261
#define tHOUR_UNIT 262
#define tID 263
#define tMERIDIAN 264
#define tMINUTE_UNIT 265
#define tMONTH 266
#define tMONTH_UNIT 267
#define tSEC_UNIT 268
#define tSNUMBER 269
#define tUNUMBER 270
#define tYEAR_UNIT 271
#define tZONE 272
#define ISSPACE(c) (isascii (c) && isspace (c))
#define ISALPHA(c) (isascii (c) && isalpha (c))
#define ISUPPER(c) (isascii (c) && isupper (c))
#define ISDIGIT_LOCALE(c) (isascii (c) && isdigit (c))
#define ISDIGIT(c) ((unsigned) (c) - '0' <= 9) #define EPOCH 1970
#define HOUR(x) ((x) * 60)
#define MAX_BUFF_LEN 128
#define PARSE_DATE_FINAL 62
#define PARSE_DATE_FLAG -32768
#define PARSE_DATE_NTBASE 22
#define PARSE_DATE_TRANSLATE(x) ((unsigned)(x) <= 272 ? parse_date_translate[x] : 32)
#define PARSE_DATE_LAST 52
#define PARSE_DATE_TERROR 1
#define PARSE_DATE_ERRCODE 256
#define PARSE_DATE_INITDEPTH 200
#define PARSE_DATE_MAXDEPTH 10000
#define TM_YEAR_ORIGIN 1900
#define PARSE_DATE_BACKUP(token, value) \
do \
if (parse_date_char == -2 && parse_date_len == 1) \
{ parse_date_char = (token), parse_date_lval = (value); \
parse_date_char1 = PARSE_DATE_TRANSLATE (parse_date_char); \
parse_date_vsp--, parse_date_ssp--; \
goto parse_date_backup; \
} \
else \
{ parse_date_error ("syntax error: cannot back up"); goto parse_date_errlab1; } \
while (0)
typedef struct {
const char *name;
int type;
int value;
} TABLE;
typedef enum {
MERam, MERpm, MER24
} MERIDIAN;
typedef union {
int Number;
MERIDIAN Meridian;
} PARSE_DATE_STYPE;
int parse_date ();
static int parse_date_lex ();
static int parse_date_error ();
static const char *parse_date_Input;
static int parse_date_DayOrdinal;
static int parse_date_DayNumber;
static int parse_date_HaveDate;
static int parse_date_HaveDay;
static int parse_date_HaveRel;
static int parse_date_HaveTime;
static int parse_date_HaveZone;
static int parse_date_Timezone;
static int parse_date_Day;
static int parse_date_Hour;
static int parse_date_Minutes;
static int parse_date_Month;
static int parse_date_Seconds;
static int parse_date_Year;
static MERIDIAN parse_date_Meridian;
static int parse_date_RelDay;
static int parse_date_RelHour;
static int parse_date_RelMinutes;
static int parse_date_RelMonth;
static int parse_date_RelSeconds;
static int parse_date_RelYear;
int parse_date_char;
PARSE_DATE_STYPE parse_date_lval;
int parse_date_nerrs;
static const char parse_date_translate[] = { 0,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 20, 2, 2, 21, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 19, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 1, 3, 4, 5, 6,
7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18
};
static const char *const parse_date_tname[] =
{ "$", "error", "$undefined.", "tAGO", "tDAY",
"tDAY_UNIT", "tDAYZONE", "tDST", "tHOUR_UNIT", "tID", "tMERIDIAN",
"tMINUTE_UNIT",
"tMONTH", "tMONTH_UNIT", "tSEC_UNIT", "tSNUMBER", "tUNUMBER", "tYEAR_UNIT",
"tZONE",
"':'", "','", "'/'", "spec", "item", "time", "zone", "day", "date", "rel",
"relunit", "number",
"o_merid", NULL
};
static const short parse_date_r1[] = { 0,
22, 22, 23, 23, 23, 23, 23, 23, 24, 24,
24, 24, 24, 25, 25, 25, 26, 26, 26, 27,
27, 27, 27, 27, 27, 27, 27, 27, 28, 28,
29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
29, 29, 29, 29, 29, 29, 29, 29, 30, 31,
31
};
static const short parse_date_r2[] = { 0,
0, 2, 1, 1, 1, 1, 1, 1, 2, 4,
4, 6, 6, 1, 1, 2, 1, 2, 2, 3,
5, 3, 3, 3, 2, 4, 2, 3, 2, 1,
2, 2, 1, 2, 2, 1, 2, 2, 1, 2,
2, 1, 2, 2, 1, 2, 2, 1, 1, 0,
1
};
static const short parse_date_defact[] = { 1,
0, 17, 39, 15, 42, 45, 0, 36, 48, 0,
49, 33, 14, 2, 3, 4, 6, 5, 7, 30,
8, 18, 25, 38, 41, 44, 35, 47, 32, 19,
37, 40, 9, 43, 27, 34, 46, 0, 31, 0,
0, 16, 29, 24, 0, 23, 28, 22, 50, 20,
26, 51, 11, 0, 10, 0, 50, 21, 13, 12,
0, 0
};
static const short parse_date_defgoto[] = { 1,
14, 15, 16, 17, 18, 19, 20, 21, 55
};
static const short parse_date_pact[] = { -32768,
0, -19, -32768, -32768, -32768, -32768, -13, -32768, -32768, 30,
15, -32768, 14, -32768, -32768, -32768, -32768, -32768, -32768, 19,
-32768, -32768, 29, -32768, -32768, -32768, -32768, -32768, -32768, -32768,
-32768, -32768, -32768, -32768, -6, -32768, -32768, 9, -32768, 17,
23, -32768, -32768, -32768, 24, -32768, -32768, -32768, 27, 10,
-32768, -32768, -32768, 32, -32768, 34, -8, -32768, -32768, -32768,
51, -32768
};
static const short parse_date_pgoto[] = { -32768,
-32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768, -5
};
static const short parse_date_table[] = { 61,
22, 52, 23, 2, 3, 4, 59, 5, 46, 47,
6, 7, 8, 9, 10, 11, 12, 13, 30, 31,
42, 43, 32, 48, 33, 34, 35, 36, 37, 38,
56, 39, 49, 40, 24, 41, 52, 25, 50, 51,
26, 53, 27, 28, 44, 54, 29, 57, 45, 58,
62, 60
};
static const short parse_date_check[] = { 0,
20, 10, 16, 4, 5, 6, 15, 8, 15, 16,
11, 12, 13, 14, 15, 16, 17, 18, 4, 5,
7, 3, 8, 15, 10, 11, 12, 13, 14, 15,
21, 17, 16, 19, 5, 21, 10, 8, 16, 16,
11, 15, 13, 14, 16, 19, 17, 16, 20, 16,
0, 57
};
int
parse_date ()
{
register int parse_date_state;
register int parse_date_n;
register short *parse_date_ssp;
register PARSE_DATE_STYPE *parse_date_vsp;
int parse_date_errstatus;
int parse_date_char1 = 0;
short parse_date_ssa[PARSE_DATE_INITDEPTH];
PARSE_DATE_STYPE parse_date_vsa[PARSE_DATE_INITDEPTH];
short *parse_date_ss = parse_date_ssa;
PARSE_DATE_STYPE *parse_date_vs = parse_date_vsa;
int parse_date_stacksize = PARSE_DATE_INITDEPTH;
int parse_date_free_stacks = 0;
PARSE_DATE_STYPE parse_date_val; /* the variable used to return */
/* semantic values from the action */
/* routines */
int parse_date_len;
parse_date_state = 0;
parse_date_errstatus = 0;
parse_date_nerrs = 0;
parse_date_char = -2; /* Cause a token to be read. */
/* Initialize stack pointers.
Waste one element of value and location stack
so that they stay on the same level as the state stack.
The wasted elements are never initialized. */
parse_date_ssp = parse_date_ss - 1;
parse_date_vsp = parse_date_vs;
parse_date_constructstate:
*++parse_date_ssp = parse_date_state;
if (parse_date_ssp >= parse_date_ss + parse_date_stacksize - 1) {
PARSE_DATE_STYPE *parse_date_vs1 = parse_date_vs;
short *parse_date_ss1 = parse_date_ss;
/* Get the current used size of the three stacks, in elements. */
int size = parse_date_ssp - parse_date_ss + 1;
if (parse_date_stacksize >= PARSE_DATE_MAXDEPTH) {
parse_date_error ("parser stack overflow");
if (parse_date_free_stacks) {
free (parse_date_ss);
free (parse_date_vs);
}
return 2;
}
parse_date_stacksize *= 2;
if (parse_date_stacksize > PARSE_DATE_MAXDEPTH)
parse_date_stacksize = PARSE_DATE_MAXDEPTH;
parse_date_ss =
(short *) malloc (parse_date_stacksize * sizeof (*parse_date_ssp));
//__builtin_memcpy ((char *) parse_date_ss, (char *) parse_date_ss1,
// size * (unsigned int) sizeof (*parse_date_ssp));
memcpy ((char *) parse_date_ss, (char *) parse_date_ss1,
size * (unsigned int) sizeof (*parse_date_ssp));
parse_date_vs =
(PARSE_DATE_STYPE *) malloc (parse_date_stacksize *
sizeof (*parse_date_vsp));
//__builtin_memcpy ((char *) parse_date_vs, (char *) parse_date_vs1,
// size * (unsigned int) sizeof (*parse_date_vsp));
memcpy ((char *) parse_date_vs, (char *) parse_date_vs1,
size * (unsigned int) sizeof (*parse_date_vsp));
parse_date_ssp = parse_date_ss + size - 1;
parse_date_vsp = parse_date_vs + size - 1;
if (parse_date_ssp >= parse_date_ss + parse_date_stacksize - 1)
goto parse_date_abortlab;
}
goto parse_date_backup;
parse_date_backup:
parse_date_n = parse_date_pact[parse_date_state];
if (parse_date_n == PARSE_DATE_FLAG)
goto parse_date_default;
if (parse_date_char == -2) {
parse_date_char = parse_date_lex ();
}
if (parse_date_char <= 0) { /* This means end of input. */
parse_date_char1 = 0;
parse_date_char = 0; /* Don't call parse_date_lex() any more */
}
else {
parse_date_char1 = PARSE_DATE_TRANSLATE (parse_date_char);
}
parse_date_n += parse_date_char1;
if (parse_date_n < 0 || parse_date_n > PARSE_DATE_LAST
|| parse_date_check[parse_date_n] != parse_date_char1)
goto parse_date_default;
parse_date_n = parse_date_table[parse_date_n];
if (parse_date_n < 0) {
if (parse_date_n == PARSE_DATE_FLAG)
goto parse_date_errlab;
parse_date_n = -parse_date_n;
goto parse_date_reduce;
}
else if (parse_date_n == 0)
goto parse_date_errlab;
if (parse_date_n == PARSE_DATE_FINAL)
goto parse_date_acceptlab;
if (parse_date_char != 0)
parse_date_char = -2;
*++parse_date_vsp = parse_date_lval;
/* count tokens shifted since error; after three, turn off error status. */
if (parse_date_errstatus)
parse_date_errstatus--;
parse_date_state = parse_date_n;
goto parse_date_constructstate;
/* Do the default action for the current state. */
parse_date_default:
parse_date_n = parse_date_defact[parse_date_state];
if (parse_date_n == 0)
goto parse_date_errlab;
/* Do a reduction. parse_date_n is the number of a rule to reduce with. */
parse_date_reduce:
parse_date_len = parse_date_r2[parse_date_n];
if (parse_date_len > 0)
parse_date_val = parse_date_vsp[1 - parse_date_len]; /* implement default value of the action */
switch (parse_date_n) {
case 3:
{
parse_date_HaveTime++;
;
break;
}
case 4:
{
parse_date_HaveZone++;
;
break;
}
case 5:
{
parse_date_HaveDate++;
;
break;
}
case 6:
{
parse_date_HaveDay++;
;
break;
}
case 7:
{
parse_date_HaveRel++;
;
break;
}
case 9:
{
parse_date_Hour = parse_date_vsp[-1].Number;
parse_date_Minutes = 0;
parse_date_Seconds = 0;
parse_date_Meridian = parse_date_vsp[0].Meridian;
;
break;
}
case 10:
{
parse_date_Hour = parse_date_vsp[-3].Number;
parse_date_Minutes = parse_date_vsp[-1].Number;
parse_date_Seconds = 0;
parse_date_Meridian = parse_date_vsp[0].Meridian;
;
break;
}
case 11:
{
parse_date_Hour = parse_date_vsp[-3].Number;
parse_date_Minutes = parse_date_vsp[-1].Number;
parse_date_Meridian = MER24;
parse_date_HaveZone++;
parse_date_Timezone = (parse_date_vsp[0].Number < 0
? -parse_date_vsp[0].Number % 100 +
(-parse_date_vsp[0].Number / 100) *
60 : -(parse_date_vsp[0].Number % 100 +
(parse_date_vsp[0].Number / 100) * 60));
;
break;
}
case 12:
{
parse_date_Hour = parse_date_vsp[-5].Number;
parse_date_Minutes = parse_date_vsp[-3].Number;
parse_date_Seconds = parse_date_vsp[-1].Number;
parse_date_Meridian = parse_date_vsp[0].Meridian;
;
break;
}
case 13:
{
parse_date_Hour = parse_date_vsp[-5].Number;
parse_date_Minutes = parse_date_vsp[-3].Number;
parse_date_Seconds = parse_date_vsp[-1].Number;
parse_date_Meridian = MER24;
parse_date_HaveZone++;
parse_date_Timezone = (parse_date_vsp[0].Number < 0
? -parse_date_vsp[0].Number % 100 +
(-parse_date_vsp[0].Number / 100) *
60 : -(parse_date_vsp[0].Number % 100 +
(parse_date_vsp[0].Number / 100) * 60));
;
break;
}
case 14:
{
parse_date_Timezone = parse_date_vsp[0].Number;
;
break;
}
case 15:
{
parse_date_Timezone = parse_date_vsp[0].Number - 60;
;
break;
}
case 16:
{
parse_date_Timezone = parse_date_vsp[-1].Number - 60;
;
break;
}
case 17:
{
parse_date_DayOrdinal = 1;
parse_date_DayNumber = parse_date_vsp[0].Number;
;
break;
}
case 18:
{
parse_date_DayOrdinal = 1;
parse_date_DayNumber = parse_date_vsp[-1].Number;
;
break;
}
case 19:
{
parse_date_DayOrdinal = parse_date_vsp[-1].Number;
parse_date_DayNumber = parse_date_vsp[0].Number;
;
break;
}
case 20:
{
parse_date_Month = parse_date_vsp[-2].Number;
parse_date_Day = parse_date_vsp[0].Number;
;
break;
}
case 21:
{
/* Interpret as PARSE_DATE_PARSE_DATE_/MM/DD if $1 >= 1000, otherwise as MM/DD/PARSE_DATE_.
The goal in recognizing PARSE_DATE_PARSE_DATE_/MM/DD is solely to support legacy
machine-generated dates like those in an RCS log listing. If
you want portability, use the ISO 8601 format. */
if (parse_date_vsp[-4].Number >= 1000) {
parse_date_Year = parse_date_vsp[-4].Number;
parse_date_Month = parse_date_vsp[-2].Number;
parse_date_Day = parse_date_vsp[0].Number;
}
else {
parse_date_Month = parse_date_vsp[-4].Number;
parse_date_Day = parse_date_vsp[-2].Number;
parse_date_Year = parse_date_vsp[0].Number;
}
;
break;
}
case 22:
{
/* ISO 8601 format. parse_date_date_-mm-dd. */
parse_date_Year = parse_date_vsp[-2].Number;
parse_date_Month = -parse_date_vsp[-1].Number;
parse_date_Day = -parse_date_vsp[0].Number;
;
break;
}
case 23:
{
/* e.g. 17-JUN-1992. */
parse_date_Day = parse_date_vsp[-2].Number;
parse_date_Month = parse_date_vsp[-1].Number;
parse_date_Year = -parse_date_vsp[0].Number;
;
break;
}
case 24:
{
parse_date_Month = parse_date_vsp[-2].Number;
parse_date_Day = parse_date_vsp[-1].Number;
parse_date_Year = parse_date_vsp[0].Number;
;
break;
}
case 25:
{
parse_date_Month = parse_date_vsp[-1].Number;
parse_date_Day = parse_date_vsp[0].Number;
;
break;
}
case 26:
{
parse_date_Month = parse_date_vsp[-3].Number;
parse_date_Day = parse_date_vsp[-2].Number;
parse_date_Year = parse_date_vsp[0].Number;
;
break;
}
case 27:
{
parse_date_Month = parse_date_vsp[0].Number;
parse_date_Day = parse_date_vsp[-1].Number;
;
break;
}
case 28:
{
parse_date_Month = parse_date_vsp[-1].Number;
parse_date_Day = parse_date_vsp[-2].Number;
parse_date_Year = parse_date_vsp[0].Number;
;
break;
}
case 29:
{
parse_date_RelSeconds = -parse_date_RelSeconds;
parse_date_RelMinutes = -parse_date_RelMinutes;
parse_date_RelHour = -parse_date_RelHour;
parse_date_RelDay = -parse_date_RelDay;
parse_date_RelMonth = -parse_date_RelMonth;
parse_date_RelYear = -parse_date_RelYear;
;
break;
}
case 31:
{
parse_date_RelYear +=
parse_date_vsp[-1].Number * parse_date_vsp[0].Number;
;
break;
}
case 32:
{
parse_date_RelYear +=
parse_date_vsp[-1].Number * parse_date_vsp[0].Number;
;
break;
}
case 33:
{
parse_date_RelYear += parse_date_vsp[0].Number;
;
break;
}
case 34:
{
parse_date_RelMonth +=
parse_date_vsp[-1].Number * parse_date_vsp[0].Number;
;
break;
}
case 35:
{
parse_date_RelMonth +=
parse_date_vsp[-1].Number * parse_date_vsp[0].Number;
;
break;
}
case 36:
{
parse_date_RelMonth += parse_date_vsp[0].Number;
;
break;
}
case 37:
{
parse_date_RelDay +=
parse_date_vsp[-1].Number * parse_date_vsp[0].Number;
;
break;
}
case 38:
{
parse_date_RelDay +=
parse_date_vsp[-1].Number * parse_date_vsp[0].Number;
;
break;
}
case 39:
{
parse_date_RelDay += parse_date_vsp[0].Number;
;
break;
}
case 40:
{
parse_date_RelHour +=
parse_date_vsp[-1].Number * parse_date_vsp[0].Number;
;
break;
}
case 41:
{
parse_date_RelHour +=
parse_date_vsp[-1].Number * parse_date_vsp[0].Number;
;
break;
}
case 42:
{
parse_date_RelHour += parse_date_vsp[0].Number;
;
break;
}
case 43:
{
parse_date_RelMinutes +=
parse_date_vsp[-1].Number * parse_date_vsp[0].Number;
;
break;
}
case 44:
{
parse_date_RelMinutes +=
parse_date_vsp[-1].Number * parse_date_vsp[0].Number;
;
break;
}
case 45:
{
parse_date_RelMinutes += parse_date_vsp[0].Number;
;
break;
}
case 46:
{
parse_date_RelSeconds +=
parse_date_vsp[-1].Number * parse_date_vsp[0].Number;
;
break;
}
case 47:
{
parse_date_RelSeconds +=
parse_date_vsp[-1].Number * parse_date_vsp[0].Number;
;
break;
}
case 48:
{
parse_date_RelSeconds += parse_date_vsp[0].Number;
;
break;
}
case 49:
{
if (parse_date_HaveTime && parse_date_HaveDate && !parse_date_HaveRel)
parse_date_Year = parse_date_vsp[0].Number;
else {
if (parse_date_vsp[0].Number > 10000) {
parse_date_HaveDate++;
parse_date_Day = (parse_date_vsp[0].Number) % 100;
parse_date_Month = (parse_date_vsp[0].Number / 100) % 100;
parse_date_Year = parse_date_vsp[0].Number / 10000;
}
else {
parse_date_HaveTime++;
if (parse_date_vsp[0].Number < 100) {
parse_date_Hour = parse_date_vsp[0].Number;
parse_date_Minutes = 0;
}
else {
parse_date_Hour = parse_date_vsp[0].Number / 100;
parse_date_Minutes = parse_date_vsp[0].Number % 100;
}
parse_date_Seconds = 0;
parse_date_Meridian = MER24;
}
}
;
break;
}
case 50:
{
parse_date_val.Meridian = MER24;
;
break;
}
case 51:
{
parse_date_val.Meridian = parse_date_vsp[0].Meridian;
;
break;
}
}
/* the action file gets copied in in place of this dollarsign */
parse_date_vsp -= parse_date_len;
parse_date_ssp -= parse_date_len;
*++parse_date_vsp = parse_date_val;
/* Now "shift" the result of the reduction.
Determine what state that goes to,
based on the state we popped back to
and the rule number reduced by. */
parse_date_n = parse_date_r1[parse_date_n];
parse_date_state =
parse_date_pgoto[parse_date_n - PARSE_DATE_NTBASE] + *parse_date_ssp;
if (parse_date_state >= 0 && parse_date_state <= PARSE_DATE_LAST
&& parse_date_check[parse_date_state] == *parse_date_ssp)
parse_date_state = parse_date_table[parse_date_state];
else
parse_date_state = parse_date_defgoto[parse_date_n - PARSE_DATE_NTBASE];
goto parse_date_constructstate;
parse_date_errlab: /* here on detecting error */
if (!parse_date_errstatus)
/* If not already recovering from an error, report this error. */
{
++parse_date_nerrs;
parse_date_error ("parse error");
}
goto parse_date_errlab1;
parse_date_errlab1: /* here on error raised explicitly by an action */
if (parse_date_errstatus == 3) {
/* if just tried and failed to reuse lookahead token after an error, discard it. */
/* return failure if at end of input */
if (parse_date_char == 0)
goto parse_date_abortlab;
parse_date_char = -2;
}
/* Else will try to reuse lookahead token
after shifting the error token. */
parse_date_errstatus = 3; /* Each real token shifted decrements this */
goto parse_date_errhandle;
parse_date_errdefault: /* current state does not do anything special for the error token. */
parse_date_errpop: /* pop the current state because it cannot handle the error token */
if (parse_date_ssp == parse_date_ss)
goto parse_date_abortlab;
parse_date_vsp--;
parse_date_state = *--parse_date_ssp;
parse_date_errhandle:
parse_date_n = parse_date_pact[parse_date_state];
if (parse_date_n == PARSE_DATE_FLAG)
goto parse_date_errdefault;
parse_date_n += PARSE_DATE_TERROR;
if (parse_date_n < 0 || parse_date_n > PARSE_DATE_LAST
|| parse_date_check[parse_date_n] != PARSE_DATE_TERROR)
goto parse_date_errdefault;
parse_date_n = parse_date_table[parse_date_n];
if (parse_date_n < 0) {
if (parse_date_n == PARSE_DATE_FLAG)
goto parse_date_errpop;
parse_date_n = -parse_date_n;
goto parse_date_reduce;
}
else if (parse_date_n == 0)
goto parse_date_errpop;
if (parse_date_n == PARSE_DATE_FINAL)
goto parse_date_acceptlab;
*++parse_date_vsp = parse_date_lval;
parse_date_state = parse_date_n;
goto parse_date_constructstate;
parse_date_acceptlab:
/* goto parse_date_acceptlab comes here. */
if (parse_date_free_stacks) {
free (parse_date_ss);
free (parse_date_vs);
}
return 0;
parse_date_abortlab:
/* goto parse_date_abortlab comes here. */
if (parse_date_free_stacks) {
free (parse_date_ss);
free (parse_date_vs);
}
return 1;
}
time_t get_date (char *p, time_t * now);
/* Month and day table. */
static TABLE const MonthDayTable[] = {
{"january", tMONTH, 1},
{"february", tMONTH, 2},
{"march", tMONTH, 3},
{"april", tMONTH, 4},
{"may", tMONTH, 5},
{"june", tMONTH, 6},
{"july", tMONTH, 7},
{"august", tMONTH, 8},
{"september", tMONTH, 9},
{"sept", tMONTH, 9},
{"october", tMONTH, 10},
{"november", tMONTH, 11},
{"december", tMONTH, 12},
{"sunday", tDAY, 0},
{"monday", tDAY, 1},
{"tuesday", tDAY, 2},
{"tues", tDAY, 2},
{"wednesday", tDAY, 3},
{"wednes", tDAY, 3},
{"thursday", tDAY, 4},
{"thur", tDAY, 4},
{"thurs", tDAY, 4},
{"friday", tDAY, 5},
{"saturday", tDAY, 6},
{NULL, 0, 0}
};
/* Time units table. */
static TABLE const UnitsTable[] = {
{"year", tYEAR_UNIT, 1},
{"month", tMONTH_UNIT, 1},
{"fortnight", tDAY_UNIT, 14},
{"week", tDAY_UNIT, 7},
{"day", tDAY_UNIT, 1},
{"hour", tHOUR_UNIT, 1},
{"minute", tMINUTE_UNIT, 1},
{"min", tMINUTE_UNIT, 1},
{"second", tSEC_UNIT, 1},
{"sec", tSEC_UNIT, 1},
{NULL, 0, 0}
};
/* Assorted relative-time words. */
static TABLE const OtherTable[] = {
{"tomorrow", tDAY_UNIT, 1},
{"yesterday", tDAY_UNIT, -1},
{"today", tDAY_UNIT, 0},
{"now", tDAY_UNIT, 0},
{"last", tUNUMBER, -1},
{"this", tMINUTE_UNIT, 0},
{"next", tUNUMBER, 1},
{"first", tUNUMBER, 1},
/* { "second", tUNUMBER, 2 }, */
{"third", tUNUMBER, 3},
{"fourth", tUNUMBER, 4},
{"fifth", tUNUMBER, 5},
{"sixth", tUNUMBER, 6},
{"seventh", tUNUMBER, 7},
{"eighth", tUNUMBER, 8},
{"ninth", tUNUMBER, 9},
{"tenth", tUNUMBER, 10},
{"eleventh", tUNUMBER, 11},
{"twelfth", tUNUMBER, 12},
{"ago", tAGO, 1},
{NULL, 0, 0}
};
/* The timezone table. */
static TABLE const TimezoneTable[] = {
{"gmt", tZONE, HOUR (0)}, /* Greenwich Mean */
{"ut", tZONE, HOUR (0)}, /* Universal (Coordinated) */
{"utc", tZONE, HOUR (0)},
{"wet", tZONE, HOUR (0)}, /* Western European */
{"bst", tDAYZONE, HOUR (0)}, /* British Summer */
{"wat", tZONE, HOUR (1)}, /* West Africa */
{"at", tZONE, HOUR (2)}, /* Azores */
{"ast", tZONE, HOUR (4)}, /* Atlantic Standard */
{"adt", tDAYZONE, HOUR (4)}, /* Atlantic Daylight */
{"est", tZONE, HOUR (5)}, /* Eastern Standard */
{"edt", tDAYZONE, HOUR (5)}, /* Eastern Daylight */
{"cst", tZONE, HOUR (6)}, /* Central Standard */
{"cdt", tDAYZONE, HOUR (6)}, /* Central Daylight */
{"mst", tZONE, HOUR (7)}, /* Mountain Standard */
{"mdt", tDAYZONE, HOUR (7)}, /* Mountain Daylight */
{"pst", tZONE, HOUR (8)}, /* Pacific Standard */
{"pdt", tDAYZONE, HOUR (8)}, /* Pacific Daylight */
{"yst", tZONE, HOUR (9)}, /* Yukon Standard */
{"ydt", tDAYZONE, HOUR (9)}, /* Yukon Daylight */
{"hst", tZONE, HOUR (10)}, /* Hawaii Standard */
{"hdt", tDAYZONE, HOUR (10)}, /* Hawaii Daylight */
{"cat", tZONE, HOUR (10)}, /* Central Alaska */
{"akst", tZONE, HOUR (10)}, /* Alaska Standard */
{"akdt", tZONE, HOUR (10)}, /* Alaska Daylight */
{"ahst", tZONE, HOUR (10)}, /* Alaska-Hawaii Standard */
{"nt", tZONE, HOUR (11)}, /* Nome */
{"idlw", tZONE, HOUR (12)}, /* International Date Line West */
{"cet", tZONE, -HOUR (1)}, /* Central European */
{"met", tZONE, -HOUR (1)}, /* Middle European */
{"mewt", tZONE, -HOUR (1)}, /* Middle European Winter */
{"mest", tDAYZONE, -HOUR (1)}, /* Middle European Summer */
{"mesz", tDAYZONE, -HOUR (1)}, /* Middle European Summer */
{"swt", tZONE, -HOUR (1)}, /* Swedish Winter */
{"sst", tDAYZONE, -HOUR (1)}, /* Swedish Summer */
{"fwt", tZONE, -HOUR (1)}, /* French Winter */
{"fst", tDAYZONE, -HOUR (1)}, /* French Summer */
{"eet", tZONE, -HOUR (2)}, /* Eastern Europe, USSR Zone 1 */
{"bt", tZONE, -HOUR (3)}, /* Baghdad, USSR Zone 2 */
{"zp4", tZONE, -HOUR (4)}, /* USSR Zone 3 */
{"zp5", tZONE, -HOUR (5)}, /* USSR Zone 4 */
{"zp6", tZONE, -HOUR (6)}, /* USSR Zone 5 */
{"wast", tZONE, -HOUR (7)}, /* West Australian Standard */
{"wadt", tDAYZONE, -HOUR (7)}, /* West Australian Daylight */
{"cct", tZONE, -HOUR (8)}, /* China Coast, USSR Zone 7 */
{"jst", tZONE, -HOUR (9)}, /* Japan Standard, USSR Zone 8 */
{"east", tZONE, -HOUR (10)}, /* Eastern Australian Standard */
{"eadt", tDAYZONE, -HOUR (10)}, /* Eastern Australian Daylight */
{"gst", tZONE, -HOUR (10)}, /* Guam Standard, USSR Zone 9 */
{"nzt", tZONE, -HOUR (12)}, /* New Zealand */
{"nzst", tZONE, -HOUR (12)}, /* New Zealand Standard */
{"nzdt", tDAYZONE, -HOUR (12)}, /* New Zealand Daylight */
{"idle", tZONE, -HOUR (12)}, /* International Date Line East */
{NULL, 0, 0}
};
/* Military timezone table. */
static TABLE const MilitaryTable[] = {
{"a", tZONE, HOUR (1)},
{"b", tZONE, HOUR (2)},
{"c", tZONE, HOUR (3)},
{"d", tZONE, HOUR (4)},
{"e", tZONE, HOUR (5)},
{"f", tZONE, HOUR (6)},
{"g", tZONE, HOUR (7)},
{"h", tZONE, HOUR (8)},
{"i", tZONE, HOUR (9)},
{"k", tZONE, HOUR (10)},
{"l", tZONE, HOUR (11)},
{"m", tZONE, HOUR (12)},
{"n", tZONE, HOUR (-1)},
{"o", tZONE, HOUR (-2)},
{"p", tZONE, HOUR (-3)},
{"q", tZONE, HOUR (-4)},
{"r", tZONE, HOUR (-5)},
{"s", tZONE, HOUR (-6)},
{"t", tZONE, HOUR (-7)},
{"u", tZONE, HOUR (-8)},
{"v", tZONE, HOUR (-9)},
{"w", tZONE, HOUR (-10)},
{"x", tZONE, HOUR (-11)},
{"y", tZONE, HOUR (-12)},
{"z", tZONE, HOUR (0)},
{NULL, 0, 0}
};
static int parse_date_error (char *s) {
s = NULL;
return 0;
}
static int ToHour (int Hours, MERIDIAN Meridian) {
switch (Meridian) {
case MER24:
if (Hours < 0 || Hours > 23)
return -1;
return Hours;
case MERam:
if (Hours < 1 || Hours > 12)
return -1;
if (Hours == 12)
Hours = 0;
return Hours;
case MERpm:
if (Hours < 1 || Hours > 12)
return -1;
if (Hours == 12)
Hours = 0;
return Hours + 12;
default:
abort ();
}
return -1;
}
static int ToYear (int Year) {
if (Year < 0)
Year = -Year;
/* XPG4 suggests that years 00-68 map to 2000-2068, and
years 69-99 map to 1969-1999. */
if (Year < 69)
Year += 2000;
else if (Year < 100)
Year += 1900;
return Year;
}
static int LookupWord (char *buff) {
register char *p;
register char *q;
register const TABLE *tp;
int i;
int abbrev;
/* Make it lowercase. */
for (p = buff; *p; p++)
if (ISUPPER ((unsigned char) *p))
*p = tolower (*p);
if (strcmp (buff, "am") == 0 || strcmp (buff, "a.m.") == 0) {
parse_date_lval.Meridian = MERam;
return tMERIDIAN;
}
if (strcmp (buff, "pm") == 0 || strcmp (buff, "p.m.") == 0) {
parse_date_lval.Meridian = MERpm;
return tMERIDIAN;
}
/* See if we have an abbreviation for a month. */
if (strlen (buff) == 3)
abbrev = 1;
else if (strlen (buff) == 4 && buff[3] == '.') {
abbrev = 1;
buff[3] = '\0';
}
else
abbrev = 0;
for (tp = MonthDayTable; tp->name; tp++) {
if (abbrev) {
if (strncmp (buff, tp->name, 3) == 0) {
parse_date_lval.Number = tp->value;
return tp->type;
}
}
else if (strcmp (buff, tp->name) == 0) {
parse_date_lval.Number = tp->value;
return tp->type;
}
}
for (tp = TimezoneTable; tp->name; tp++)
if (strcmp (buff, tp->name) == 0) {
parse_date_lval.Number = tp->value;
return tp->type;
}
if (strcmp (buff, "dst") == 0)
return tDST;
for (tp = UnitsTable; tp->name; tp++)
if (strcmp (buff, tp->name) == 0) {
parse_date_lval.Number = tp->value;
return tp->type;
}
/* Strip off any plural and try the units table again. */
i = strlen (buff) - 1;
if (buff[i] == 's') {
buff[i] = '\0';
for (tp = UnitsTable; tp->name; tp++)
if (strcmp (buff, tp->name) == 0) {
parse_date_lval.Number = tp->value;
return tp->type;
}
buff[i] = 's'; /* Put back for "this" in OtherTable. */
}
for (tp = OtherTable; tp->name; tp++)
if (strcmp (buff, tp->name) == 0) {
parse_date_lval.Number = tp->value;
return tp->type;
}
/* Military timezones. */
if (buff[1] == '\0' && ISALPHA ((unsigned char) *buff)) {
for (tp = MilitaryTable; tp->name; tp++)
if (strcmp (buff, tp->name) == 0) {
parse_date_lval.Number = tp->value;
return tp->type;
}
}
/* Drop out any periods and try the timezone table again. */
for (i = 0, p = q = buff; *q; q++)
if (*q != '.')
*p++ = *q;
else
i++;
*p = '\0';
if (i)
for (tp = TimezoneTable; tp->name; tp++)
if (strcmp (buff, tp->name) == 0) {
parse_date_lval.Number = tp->value;
return tp->type;
}
return tID;
}
static int parse_date_lex () {
register unsigned char c;
register char *p;
char buff[20];
int Count;
int sign;
for (;;) {
while (ISSPACE ((unsigned char) *parse_date_Input))
parse_date_Input++;
if (ISDIGIT (c = *parse_date_Input) || c == '-' || c == '+') {
if (c == '-' || c == '+') {
sign = c == '-' ? -1 : 1;
if (!ISDIGIT (*++parse_date_Input))
/* skip the '-' sign */
continue;
}
else
sign = 0;
for (parse_date_lval.Number = 0; ISDIGIT (c = *parse_date_Input++);)
parse_date_lval.Number = 10 * parse_date_lval.Number + c - '0';
parse_date_Input--;
if (sign < 0)
parse_date_lval.Number = -parse_date_lval.Number;
return sign ? tSNUMBER : tUNUMBER;
}
if (ISALPHA (c)) {
for (p = buff; (c = *parse_date_Input++, ISALPHA (c)) || c == '.';)
if (p < &buff[sizeof buff - 1])
*p++ = c;
*p = '\0';
parse_date_Input--;
return LookupWord (buff);
}
if (c != '(')
return *parse_date_Input++;
Count = 0;
do {
c = *parse_date_Input++;
if (c == '\0')
return c;
if (c == '(')
Count++;
else if (c == ')')
Count--;
}
while (Count > 0);
}
}
/* Yield A - B, measured in seconds. */
static long difftm (struct tm *a, struct tm *b) {
int ay = a->tm_year + (TM_YEAR_ORIGIN - 1);
int by = b->tm_year + (TM_YEAR_ORIGIN - 1);
long days = (
/* difference in day of year */
a->tm_yday - b->tm_yday
/* + intervening leap days */
+ ((ay >> 2) - (by >> 2))
- (ay / 100 - by / 100) + ((ay / 100 >> 2) - (by / 100 >> 2))
/* + difference in years * 365 */
+ (long) (ay - by) * 365);
return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
+ (a->tm_min - b->tm_min)) + (a->tm_sec - b->tm_sec));
}
time_t get_timestamp (const char *date) {
struct tm tm, tm0, *tmp;
time_t Start;
if (date == NULL) {
return time(NULL);
}
parse_date_Input = date;
Start = time(NULL);
tmp = localtime(&Start);
if (!tmp)
return -1;
parse_date_Year = tmp->tm_year + TM_YEAR_ORIGIN;
parse_date_Month = tmp->tm_mon + 1;
parse_date_Day = tmp->tm_mday;
parse_date_Hour = tmp->tm_hour;
parse_date_Minutes = tmp->tm_min;
parse_date_Seconds = tmp->tm_sec;
tm.tm_isdst = tmp->tm_isdst;
parse_date_Meridian = MER24;
parse_date_RelSeconds = 0;
parse_date_RelMinutes = 0;
parse_date_RelHour = 0;
parse_date_RelDay = 0;
parse_date_RelMonth = 0;
parse_date_RelYear = 0;
parse_date_HaveDate = 0;
parse_date_HaveDay = 0;
parse_date_HaveRel = 0;
parse_date_HaveTime = 0;
parse_date_HaveZone = 0;
if (parse_date ()
|| parse_date_HaveTime > 1 || parse_date_HaveZone > 1
|| parse_date_HaveDate > 1 || parse_date_HaveDay > 1)
return -1;
tm.tm_year = ToYear (parse_date_Year) - TM_YEAR_ORIGIN + parse_date_RelYear;
tm.tm_mon = parse_date_Month - 1 + parse_date_RelMonth;
tm.tm_mday = parse_date_Day + parse_date_RelDay;
if (parse_date_HaveTime
|| (parse_date_HaveRel && !parse_date_HaveDate
&& !parse_date_HaveDay)) {
tm.tm_hour = ToHour (parse_date_Hour, parse_date_Meridian);
if (tm.tm_hour < 0)
return -1;
tm.tm_min = parse_date_Minutes;
tm.tm_sec = parse_date_Seconds;
}
else {
tm.tm_hour = tm.tm_min = tm.tm_sec = 0;
}
tm.tm_hour += parse_date_RelHour;
tm.tm_min += parse_date_RelMinutes;
tm.tm_sec += parse_date_RelSeconds;
if (parse_date_HaveDate | parse_date_HaveDay | parse_date_HaveTime |
parse_date_RelDay | parse_date_RelMonth | parse_date_RelYear)
tm.tm_isdst = -1;
tm0 = tm;
Start = mktime (&tm);
if (Start == (time_t) - 1) {
/* Guard against falsely reporting errors near the time_t boundaries
when parsing times in other time zones. For example, if the min
time_t value is 1970-01-01 00:00:00 UTC and we are 8 hours ahead
of UTC, then the min localtime value is 1970-01-01 08:00:00; if
we apply mktime to 1970-01-01 00:00:00 we will get an error, so
we apply mktime to 1970-01-02 08:00:00 instead and adjust the time
zone by 24 hours to compensate. This algorithm assumes that
there is no DST transition within a day of the time_t boundaries. */
if (parse_date_HaveZone) {
tm = tm0;
if (tm.tm_year <= EPOCH - TM_YEAR_ORIGIN) {
tm.tm_mday++;
parse_date_Timezone -= 24 * 60;
}
else {
tm.tm_mday--;
parse_date_Timezone += 24 * 60;
}
Start = mktime (&tm);
}
if (Start == (time_t) - 1)
return Start;
}
if (parse_date_HaveDay && !parse_date_HaveDate) {
tm.tm_mday += ((parse_date_DayNumber - tm.tm_wday + 7) % 7
+ 7 * (parse_date_DayOrdinal -
(0 < parse_date_DayOrdinal)));
Start = mktime (&tm);
if (Start == (time_t) - 1)
return Start;
}
if (parse_date_HaveZone) {
long delta;
struct tm *gmt = gmtime (&Start);
if (!gmt)
return -1;
delta = parse_date_Timezone * 60L + difftm (&tm, gmt);
if ((Start + delta < Start) != (delta < 0))
return -1; /* time_t overflow */
Start += delta;
}
return Start;
}
c日期格式化操作之timestamp
虽功未成，亦未敢藏私，众侠诸神通尽录于此，竟成一笈，名葵花宝典，以飨后世。
邮箱：steven9801@163.com
QQ: 48039387
邮箱：steven9801@163.com
QQ: 48039387