/* A Bison parser, made from getdate.y */ #define ID 258 #define MONTH 259 #define DAY 260 #define MERIDIAN 261 #define NUMBER 262 #define UNIT 263 #define MUNIT 264 #define SUNIT 265 #define ZONE 266 #define DAYZONE 267 #define AGO 268 #line 2 "getdate.y" /* Steven M. Bellovin (unc!smb) */ /* Dept. of Computer Science */ /* University of North Carolina at Chapel Hill */ /* @(#)getdate.y 2.13 9/16/86 */ #ifdef unix # include # include # include #else # ifdef AMIGA # define __C_MACROS__ # include # define toupper _toupper # define tolower _tolower extern char *envparm(char *var); # endif /* AMIGA */ #endif /* unix */ #include #ifndef NULL # define NULL 0 #endif /* !NULL */ #define daysec (24L*60L*60L) static int timeflag, zoneflag, dateflag, dayflag, relflag; static time_t relsec, relmonth; static int hh, mm, ss, merid, daylight; static int dayord, dayreq; static int month, day, year; static int ourzone; #define AM 1 #define PM 2 #define DAYLIGHT 1 #define STANDARD 2 #define MAYBE 3 #ifndef YYLTYPE typedef struct yyltype { int timestamp; int first_line; int first_column; int last_line; int last_column; char *text; } yyltype; #define YYLTYPE yyltype #endif #define YYACCEPT return(0) #define YYABORT return(1) #define YYERROR return(1) #ifndef YYSTYPE #define YYSTYPE int #endif #include #ifdef __STDC__ #define CONST const #else #define CONST #endif #define YYFINAL 42 #define YYFLAG -32768 #define YYNTBASE 17 #define YYTRANSLATE(x) ((unsigned)(x) <= 268 ? yytranslate[x] : 25) static CONST char yytranslate[] = { 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, 15, 2, 2, 16, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 14, 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, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 }; static CONST short yyrline[] = { 0, 44, 45, 47, 49, 51, 53, 55, 57, 59, 63, 65, 67, 69, 72, 74, 76, 80, 82, 85, 87, 89, 92, 94, 96, 98, 100, 102, 106, 108, 110, 112, 114, 116, 118 }; static CONST char * yytname[] = { 0, "error","$illegal.","ID","MONTH","DAY","MERIDIAN","NUMBER","UNIT","MUNIT","SUNIT", "ZONE","DAYZONE","AGO","':'","','","'/'","timedate" }; static CONST short yyr1[] = { 0, 17, 17, 18, 18, 18, 18, 18, 18, 19, 20, 20, 20, 20, 20, 20, 20, 21, 21, 22, 22, 22, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24 }; static CONST short yyr2[] = { 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 2, 3, 4, 4, 5, 6, 6, 1, 1, 1, 2, 2, 3, 5, 2, 4, 2, 3, 2, 2, 2, 1, 1, 1, 2 }; static CONST short yydefact[] = { 1, 0, 0, 19, 9, 31, 32, 33, 17, 18, 2, 8, 3, 4, 6, 5, 7, 24, 20, 26, 21, 10, 28, 29, 30, 0, 0, 34, 0, 27, 11, 22, 25, 12, 13, 0, 0, 14, 23, 15, 16, 0, 0 }; static CONST short yydefgoto[] = { 1, 10, 11, 12, 13, 14, 15, 16 }; static CONST short yypact[] = {-32768, 0, -4, -9, 9,-32768,-32768,-32768,-32768,-32768,-32768, -32768,-32768,-32768,-32768,-32768, 3, 7,-32768, 17,-32768, -32768,-32768,-32768,-32768, 19, 20,-32768, 22,-32768, 14, 15,-32768,-32768,-32768, 23, 25, -5,-32768,-32768,-32768, 33,-32768 }; static CONST short yypgoto[] = {-32768, -32768,-32768,-32768,-32768,-32768,-32768,-32768 }; #define YYLAST 33 static CONST short yytable[] = { 41, 39, 40, 17, 2, 3, 18, 4, 5, 6, 7, 8, 9, 19, 20, 21, 27, 22, 23, 24, 33, 34, 28, 25, 29, 26, 30, 31, 35, 32, 37, 36, 38, 42 }; static CONST short yycheck[] = { 0, 6, 7, 7, 4, 5, 15, 7, 8, 9, 10, 11, 12, 4, 5, 6, 13, 8, 9, 10, 6, 7, 15, 14, 7, 16, 7, 7, 14, 7, 7, 16, 7, 0 }; #define YYPURE 1 #ifdef AMIGA # define bzero(b, length) setmem((b), (length), 0) # define bcopy(b1, b2, length) movmem((b2), (b1), (length)) # define alloca(x) malloc(x) extern void *malloc(); #endif /* AMIGA */ #if 0 /* [FJE] #ifdef AMIGA */ #define bzero(b, length) memset((b),'\0',(length)) #define bcopy(b1, b2, length) memcpy((b1),(b2),(length)) /* #define bcmp(b1, b2, length) memcmp((b1),(b2),(length)) */ void memory_full() { printf ("Memory exhausted.\n"); exit(1); } char *xmalloc(size) int size; { extern char *malloc(); register char *ptr = malloc(size); if (ptr != 0) return (ptr); memory_full(); /* NOTREACHED */ } char *xrealloc(old, size) char *old; int size; { extern char *realloc(); register char *ptr = realloc(old, size); if (ptr != 0) return(ptr); memory_full(); /* NOTREACHED */ } char *xcalloc(number, size) int number, size; { extern char *malloc(); register int total = number * size; register char *ptr = malloc(total); if (ptr != 0) { if (total > 100) bzero(ptr, total); else { register long *zp = (long *) ptr; register long *zl = (long *) (ptr + total - 4); register int i = total - 4; /* * It's not too long, so loop, zeroing by longs. * It must be safe because malloc values are always * well aligned. */ while (zp < zl) *zp++ = 0; if (i < 0) i = 0; while (i < total) ptr[i++] = 0; } return ptr; } memory_full(); /*NOTREACHED*/ } typedef char *pointer; /* generic pointer type */ extern void free(); extern pointer xmalloc(); /* Define STACK_DIRECTION if you know the direction of stack growth for your system; otherwise it will be automatically deduced at run-time. STACK_DIRECTION > 0 => grows toward higher addresses STACK_DIRECTION < 0 => grows toward lower addresses STACK_DIRECTION = 0 => direction of growth unknown */ #define STACK_DIRECTION -1 #define STACK_DIR STACK_DIRECTION /* known at compile-time */ /* An "alloca header" is used to: (a) chain together all alloca()'ed blocks; (b) keep track of stack depth. It is very important that sizeof(header) agree with malloc() alignment chunk size. The following default should work okay. */ #ifndef ALIGN_SIZE # define ALIGN_SIZE sizeof(double) #endif typedef union hdr { char align[ALIGN_SIZE]; /* to force sizeof(header) */ struct { union hdr *next; /* for chaining headers */ char *deep; /* for stack depth measure */ } h; } header; static header *last_alloca_header = NULL; /* -> last alloca header */ pointer alloca(size) /* returns pointer to storage */ unsigned size; /* # bytes to allocate */ { auto char probe; /* probes stack depth: */ register char *depth = &probe; /* * Reclaim garbage, defined as all alloca()ed storage that * was allocated from deeper in the stack than currently. */ { register header *hp; /* traverses linked list */ for (hp = last_alloca_header; hp != NULL;) if (STACK_DIR > 0 && hp->h.deep > depth || STACK_DIR < 0 && hp->h.deep < depth) { register header *np = hp->h.next; free ((pointer) hp); /* collect garbage */ hp = np; /* -> next header */ } else break; /* rest are not deeper */ last_alloca_header = hp; /* -> last valid storage */ } if (size == 0) return NULL; /* no allocation required */ /* Allocate combined header + user data storage. */ { register pointer new = xmalloc(sizeof(header) + size); /* address of header */ ((header *)new)->h.next = last_alloca_header; ((header *)new)->h.deep = depth; last_alloca_header = (header *)new; /* User storage begins just after header. */ return (pointer)((char *)new + sizeof(header)); } } #endif /* AMIGA */ #define yyerrok (yyerrstatus = 0) #define yyclearin (yychar = YYEMPTY) #define YYEMPTY -2 #define YYEOF 0 #define YYFAIL goto yyerrlab; #define YYTERROR 1 #ifndef YYIMPURE #define YYLEX yylex() #endif #ifndef YYPURE #define YYLEX yylex(&yylval, &yylloc) #endif /* If nonreentrant, generate the variables here */ #ifndef YYIMPURE int yychar; /* the lookahead symbol */ YYSTYPE yylval; /* the semantic value of the */ /* lookahead symbol */ YYLTYPE yylloc; /* location data for the lookahead */ /* symbol */ int yynerr; /* number of parse errors so far */ #ifdef YYDEBUG int yydebug = 0; /* nonzero means print parse trace */ #endif #endif /* YYIMPURE */ /* YYMAXDEPTH indicates the initial size of the parser's stacks */ #ifndef YYMAXDEPTH #define YYMAXDEPTH 200 #endif /* YYMAXLIMIT is the maximum size the stacks can grow to (effective only if the built-in stack extension method is used). */ #ifndef YYMAXLIMIT #define YYMAXLIMIT 10000 #endif #line 203 "bison.simple" int yyparse() { register int yystate; register int yyn; register short *yyssp; register YYSTYPE *yyvsp; YYLTYPE *yylsp; int yyerrstatus; /* number of tokens to shift before error messages enabled */ int yychar1; /* lookahead token as an internal (translated) token number */ short yyssa[YYMAXDEPTH]; /* the state stack */ YYSTYPE yyvsa[YYMAXDEPTH]; /* the semantic value stack */ YYLTYPE yylsa[YYMAXDEPTH]; /* the location stack */ short *yyss = yyssa; /* refer to the stacks thru separate pointers */ YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ YYLTYPE *yyls = yylsa; int yymaxdepth = YYMAXDEPTH; #ifndef YYPURE int yychar; YYSTYPE yylval; YYLTYPE yylloc; #endif #ifdef YYDEBUG extern int yydebug; #endif YYSTYPE yyval; /* the variable used to return */ /* semantic values from the action */ /* routines */ int yylen; #ifdef YYDEBUG if (yydebug) fprintf(stderr, "Starting parse\n"); #endif yystate = 0; yyerrstatus = 0; yynerr = 0; yychar = YYEMPTY; /* 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. */ yyssp = yyss - 1; yyvsp = yyvs; yylsp = yyls; /* Push a new state, which is found in yystate . */ /* In all cases, when you get here, the value and location stacks have just been pushed. so pushing a state here evens the stacks. */ yynewstate: *++yyssp = yystate; if (yyssp >= yyss + yymaxdepth - 1) { /* Give user a chance to reallocate the stack */ /* Use copies of these so that the &'s don't force the real ones into memory. */ YYSTYPE *yyvs1 = yyvs; YYLTYPE *yyls1 = yyls; short *yyss1 = yyss; /* Get the current used size of the three stacks, in elements. */ int size = yyssp - yyss + 1; #ifdef yyoverflow /* Each stack pointer address is followed by the size of the data in use in that stack, in bytes. */ yyoverflow("parser stack overflow", &yyss1, size * sizeof (*yyssp), &yyvs1, size * sizeof (*yyvsp), &yyls1, size * sizeof (*yylsp), &yymaxdepth); yyss = yyss1; yyvs = yyvs1; yyls = yyls1; #else /* no yyoverflow */ /* Extend the stack our own way. */ if (yymaxdepth >= YYMAXLIMIT) yyerror("parser stack overflow"); yymaxdepth *= 2; if (yymaxdepth > YYMAXLIMIT) yymaxdepth = YYMAXLIMIT; yyss = (short *) alloca (yymaxdepth * sizeof (*yyssp)); bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp)); yyvs = (YYSTYPE *) alloca (yymaxdepth * sizeof (*yyvsp)); bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp)); #ifdef YYLSP_NEEDED yyls = (YYLTYPE *) alloca (yymaxdepth * sizeof (*yylsp)); bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp)); #endif #endif /* no yyoverflow */ yyssp = yyss + size - 1; yyvsp = yyvs + size - 1; #ifdef YYLSP_NEEDED yylsp = yyls + size - 1; #endif #ifdef YYDEBUG if (yydebug) fprintf(stderr, "Stack size increased to %d\n", yymaxdepth); #endif if (yyssp >= yyss + yymaxdepth - 1) YYERROR; } #ifdef YYDEBUG if (yydebug) fprintf(stderr, "Entering state %d\n", yystate); #endif /* Do appropriate processing given the current state. */ /* Read a lookahead token if we need one and don't already have one. */ yyresume: /* First try to decide what to do without reference to lookahead token. */ yyn = yypact[yystate]; if (yyn == YYFLAG) goto yydefault; /* Not known => get a lookahead token if don't already have one. */ /* yychar is either YYEMPTY or YYEOF or a valid token in external form. */ if (yychar == YYEMPTY) { #ifdef YYDEBUG if (yydebug) fprintf(stderr, "Reading a token: "); #endif yychar = YYLEX; } /* Convert token to internal form (in yychar1) for indexing tables with */ if (yychar <= 0) /* This means end of input. */ { yychar1 = 0; yychar = YYEOF; /* Don't call YYLEX any more */ #ifdef YYDEBUG if (yydebug) fprintf(stderr, "Now at end of input.\n"); #endif } else { yychar1 = YYTRANSLATE(yychar); #ifdef YYDEBUG if (yydebug) fprintf(stderr, "Next token is %d (%s)\n", yychar, yytname[yychar1]); #endif } yyn += yychar1; if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) goto yydefault; yyn = yytable[yyn]; /* yyn is what to do for this token type in this state. Negative => reduce, -yyn is rule number. Positive => shift, yyn is new state. New state is final state => don't bother to shift, just return success. 0, or most negative number => error. */ if (yyn < 0) { if (yyn == YYFLAG) goto yyerrlab; yyn = -yyn; goto yyreduce; } else if (yyn == 0) goto yyerrlab; if (yyn == YYFINAL) YYACCEPT; /* Shift the lookahead token. */ #ifdef YYDEBUG if (yydebug) fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); #endif /* Discard the token being shifted unless it is eof. */ if (yychar != YYEOF) yychar = YYEMPTY; *++yyvsp = yylval; #ifdef YYLSP_NEEDED *++yylsp = yylloc; #endif /* count tokens shifted since error; after three, turn off error status. */ if (yyerrstatus) yyerrstatus--; yystate = yyn; goto yynewstate; /* Do the default action for the current state. */ yydefault: yyn = yydefact[yystate]; if (yyn == 0) goto yyerrlab; /* Do a reduction. yyn is the number of a rule to reduce with. */ yyreduce: yylen = yyr2[yyn]; yyval = yyvsp[1-yylen]; /* implement default value of the action */ #ifdef YYDEBUG if (yydebug) { if (yylen == 1) fprintf (stderr, "Reducing 1 value via line %d, ", yyrline[yyn]); else fprintf (stderr, "Reducing %d values via line %d, ", yylen, yyrline[yyn]); } #endif switch (yyn) { case 3: #line 48 "getdate.y" {timeflag++;; break;} case 4: #line 50 "getdate.y" {zoneflag++;; break;} case 5: #line 52 "getdate.y" {dateflag++;; break;} case 6: #line 54 "getdate.y" {dayflag++;; break;} case 7: #line 56 "getdate.y" {relflag++;; break;} case 9: #line 60 "getdate.y" {if (timeflag && dateflag && !relflag) year = yyvsp[0]; else {timeflag++;hh = yyvsp[0]/100;mm = yyvsp[0]%100;ss = 0;merid = 24;}; break;} case 10: #line 64 "getdate.y" {hh = yyvsp[-1]; mm = 0; ss = 0; merid = yyvsp[0];; break;} case 11: #line 66 "getdate.y" {hh = yyvsp[-2]; mm = yyvsp[0]; merid = 24;; break;} case 12: #line 68 "getdate.y" {hh = yyvsp[-3]; mm = yyvsp[-1]; merid = yyvsp[0];; break;} case 13: #line 70 "getdate.y" {hh = yyvsp[-3]; mm = yyvsp[-1]; merid = 24; daylight = STANDARD; ourzone = yyvsp[0]%100 + 60*yyvsp[0]/100;; break;} case 14: #line 73 "getdate.y" {hh = yyvsp[-4]; mm = yyvsp[-2]; ss = yyvsp[0]; merid = 24;; break;} case 15: #line 75 "getdate.y" {hh = yyvsp[-5]; mm = yyvsp[-3]; ss = yyvsp[-1]; merid = yyvsp[0];; break;} case 16: #line 77 "getdate.y" {hh = yyvsp[-5]; mm = yyvsp[-3]; ss = yyvsp[-1]; merid = 24; daylight = STANDARD; ourzone = yyvsp[0]%100 + 60*yyvsp[0]/100;; break;} case 17: #line 81 "getdate.y" {ourzone = yyvsp[0]; daylight = STANDARD;; break;} case 18: #line 83 "getdate.y" {ourzone = yyvsp[0]; daylight = DAYLIGHT;; break;} case 19: #line 86 "getdate.y" {dayord = 1; dayreq = yyvsp[0];; break;} case 20: #line 88 "getdate.y" {dayord = 1; dayreq = yyvsp[-1];; break;} case 21: #line 90 "getdate.y" {dayord = yyvsp[-1]; dayreq = yyvsp[0];; break;} case 22: #line 93 "getdate.y" {month = yyvsp[-2]; day = yyvsp[0];; break;} case 23: #line 95 "getdate.y" {month = yyvsp[-4]; day = yyvsp[-2]; year = yyvsp[0];; break;} case 24: #line 97 "getdate.y" {month = yyvsp[-1]; day = yyvsp[0];; break;} case 25: #line 99 "getdate.y" {month = yyvsp[-3]; day = yyvsp[-2]; year = yyvsp[0];; break;} case 26: #line 101 "getdate.y" {month = yyvsp[0]; day = yyvsp[-1];; break;} case 27: #line 103 "getdate.y" {month = yyvsp[-1]; day = yyvsp[-2]; year = yyvsp[0];; break;} case 28: #line 107 "getdate.y" {relsec += 60L * yyvsp[-1] * yyvsp[0];; break;} case 29: #line 109 "getdate.y" {relmonth += yyvsp[-1] * yyvsp[0];; break;} case 30: #line 111 "getdate.y" {relsec += yyvsp[-1];; break;} case 31: #line 113 "getdate.y" {relsec += 60L * yyvsp[0];; break;} case 32: #line 115 "getdate.y" {relmonth += yyvsp[0];; break;} case 33: #line 117 "getdate.y" {relsec++;; break;} case 34: #line 119 "getdate.y" {relsec = -relsec; relmonth = -relmonth;; break;} } /* the action file gets copied in in place of this dollarsign */ #line 444 "bison.simple" yyvsp -= yylen; yyssp -= yylen; #ifdef YYLSP_NEEDED yylsp -= yylen; #endif #ifdef YYDEBUG if (yydebug) { short *ssp1 = yyss - 1; fprintf (stderr, "state stack now"); while (ssp1 != yyssp) fprintf (stderr, " %d", *++ssp1); fprintf (stderr, "\n"); } #endif *++yyvsp = yyval; #ifdef YYLSP_NEEDED yylsp++; if (yylen == 0) { yylsp->first_line = yylloc.first_line; yylsp->first_column = yylloc.first_column; yylsp->last_line = (yylsp-1)->last_line; yylsp->last_column = (yylsp-1)->last_column; yylsp->text = 0; } else { yylsp->last_line = (yylsp+yylen-1)->last_line; yylsp->last_column = (yylsp+yylen-1)->last_column; } #endif /* 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. */ yyn = yyr1[yyn]; yystate = yypgoto[yyn - YYNTBASE] + *yyssp; if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) yystate = yytable[yystate]; else yystate = yydefgoto[yyn - YYNTBASE]; goto yynewstate; yyerrlab: /* here on detecting error */ if (! yyerrstatus) /* If not already recovering from an error, report this error. */ { ++yynerr; yyerror("parse error"); } if (yyerrstatus == 3) { /* if just tried and failed to reuse lookahead token after an error, discard it. */ /* return failure if at end of input */ if (yychar == YYEOF) YYERROR; #ifdef YYDEBUG if (yydebug) fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); #endif yychar = YYEMPTY; } /* Else will try to reuse lookahead token after shifting the error token. */ yyerrstatus = 3; /* Each real token shifted decrements this */ goto yyerrhandle; yyerrdefault: /* current state does not do anything special for the error token. */ #if 0 /* This is wrong; only states that explicitly want error tokens should shift them. */ yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ if (yyn) goto yydefault; #endif yyerrpop: /* pop the current state because it cannot handle the error token */ if (yyssp == yyss) YYERROR; yyvsp--; yystate = *--yyssp; #ifdef YYLSP_NEEDED yylsp--; #endif #ifdef YYDEBUG if (yydebug) { short *ssp1 = yyss - 1; fprintf (stderr, "Error: state stack now"); while (ssp1 != yyssp) fprintf (stderr, " %d", *++ssp1); fprintf (stderr, "\n"); } #endif yyerrhandle: yyn = yypact[yystate]; if (yyn == YYFLAG) goto yyerrdefault; yyn += YYTERROR; if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) goto yyerrdefault; yyn = yytable[yyn]; if (yyn < 0) { if (yyn == YYFLAG) goto yyerrpop; yyn = -yyn; goto yyreduce; } else if (yyn == 0) goto yyerrpop; if (yyn == YYFINAL) YYACCEPT; #ifdef YYDEBUG if (yydebug) fprintf(stderr, "Shifting error token, "); #endif *++yyvsp = yylval; #ifdef YYLSP_NEEDED *++yylsp = yylloc; #endif yystate = yyn; goto yynewstate; } #line 120 "getdate.y" static int mdays[12] = {31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; #define epoch 1970 extern struct tm *localtime(); time_t dateconv(mm, dd, yy, h, m, s, mer, zone, dayflag) int mm, dd, yy, h, m, s, mer, zone, dayflag; { time_t tod, jdate; register int i; time_t timeconv(); if (yy < 0) yy = -yy; if (yy < 100) yy += 1900; mdays[1] = 28 + (yy%4 == 0 && (yy%100 != 0 || yy%400 == 0)); if (yy < epoch || yy > 1999 || mm < 1 || mm > 12 || dd < 1 || dd > mdays[--mm]) return (-1); jdate = dd-1; for (i=0; itm_isdst)) jdate += -1*60*60; return (jdate); } time_t dayconv(ord, day, now) int ord, day; time_t now; { register struct tm *loctime; time_t tod; time_t daylcorr(); tod = now; loctime = localtime(&tod); tod += daysec * ((day - loctime->tm_wday + 7) % 7); tod += 7*daysec*(ord<=0?ord:ord-1); return daylcorr(tod, now); } time_t timeconv(hh, mm, ss, mer) register int hh, mm, ss, mer; { if (mm < 0 || mm > 59 || ss < 0 || ss > 59) return (-1); switch (mer) { case AM: if (hh < 1 || hh > 12) return(-1); return (60L * ((hh%12)*60L + mm)+ss); case PM: if (hh < 1 || hh > 12) return(-1); return (60L * ((hh%12 +12)*60L + mm)+ss); case 24: if (hh < 0 || hh > 23) return (-1); return (60L * (hh*60L + mm)+ss); } return(-1); } time_t monthadd(sdate, relmonth) time_t sdate, relmonth; { struct tm *ltime; time_t dateconv(); time_t daylcorr(); int mm, yy; if (relmonth == 0) return 0; ltime = localtime(&sdate); mm = 12*ltime->tm_year + ltime->tm_mon + relmonth; yy = mm/12; mm = mm%12 + 1; return daylcorr(dateconv(mm, ltime->tm_mday, yy, ltime->tm_hour, ltime->tm_min, ltime->tm_sec, 24, ourzone, MAYBE), sdate); } time_t daylcorr(future, now) time_t future, now; { int fdayl, nowdayl; nowdayl = (localtime(&now)->tm_hour+1) % 24; fdayl = (localtime(&future)->tm_hour+1) % 24; return (future-now) + 60L*60L*(nowdayl-fdayl); } static char *lptr; yylex() { extern int yylval; int sign; register char c; register char *p; char idbuf[20]; int pcnt; for (;;) { while (isspace(*lptr)) lptr++; if (isdigit(c = *lptr) || c == '-' || c == '+') { if (c== '-' || c == '+') { if (c=='-') sign = -1; else sign = 1; if (!isdigit(*++lptr)) { /* yylval = sign; return (NUMBER); */ return yylex(); /* skip the '-' sign */ } } else sign = 1; yylval = 0; while (isdigit(c = *lptr++)) yylval = 10*yylval + c - '0'; yylval *= sign; lptr--; return (NUMBER); } else if (isalpha(c)) { p = idbuf; while (isalpha(c = *lptr++) || c=='.') if (p < &idbuf[sizeof(idbuf)-1]) *p++ = c; *p = '\0'; lptr--; return (lookup(idbuf)); } else if (c == '(') { pcnt = 0; do { c = *lptr++; if (c == '\0') return(c); else if (c == '(') pcnt++; else if (c == ')') pcnt--; } while (pcnt > 0); } else return (*lptr++); } } struct table { char *name; int type, value; }; struct table mdtab[] = { {"January", MONTH, 1}, {"February", MONTH, 2}, {"March", MONTH, 3}, {"April", MONTH, 4}, {"May", MONTH, 5}, {"June", MONTH, 6}, {"July", MONTH, 7}, {"August", MONTH, 8}, {"September", MONTH, 9}, {"Sept", MONTH, 9}, {"October", MONTH, 10}, {"November", MONTH, 11}, {"December", MONTH, 12}, {"Sunday", DAY, 0}, {"Monday", DAY, 1}, {"Tuesday", DAY, 2}, {"Tues", DAY, 2}, {"Wednesday", DAY, 3}, {"Wednes", DAY, 3}, {"Thursday", DAY, 4}, {"Thur", DAY, 4}, {"Thurs", DAY, 4}, {"Friday", DAY, 5}, {"Saturday", DAY, 6}, {0, 0, 0}}; #define HRS *60 #define HALFHR 30 struct table mztab[] = { {"a.m.", MERIDIAN, AM}, {"am", MERIDIAN, AM}, {"p.m.", MERIDIAN, PM}, {"pm", MERIDIAN, PM}, {"nst", ZONE, 3 HRS + HALFHR}, /* Newfoundland */ {"n.s.t.", ZONE, 3 HRS + HALFHR}, {"ast", ZONE, 4 HRS}, /* Atlantic */ {"a.s.t.", ZONE, 4 HRS}, {"adt", DAYZONE, 4 HRS}, {"a.d.t.", DAYZONE, 4 HRS}, {"est", ZONE, 5 HRS}, /* Eastern */ {"e.s.t.", ZONE, 5 HRS}, {"edt", DAYZONE, 5 HRS}, {"e.d.t.", DAYZONE, 5 HRS}, {"cst", ZONE, 6 HRS}, /* Central */ {"c.s.t.", ZONE, 6 HRS}, {"cdt", DAYZONE, 6 HRS}, {"c.d.t.", DAYZONE, 6 HRS}, {"mst", ZONE, 7 HRS}, /* Mountain */ {"m.s.t.", ZONE, 7 HRS}, {"mdt", DAYZONE, 7 HRS}, {"m.d.t.", DAYZONE, 7 HRS}, {"pst", ZONE, 8 HRS}, /* Pacific */ {"p.s.t.", ZONE, 8 HRS}, {"pdt", DAYZONE, 8 HRS}, {"p.d.t.", DAYZONE, 8 HRS}, {"yst", ZONE, 9 HRS}, /* Yukon */ {"y.s.t.", ZONE, 9 HRS}, {"ydt", DAYZONE, 9 HRS}, {"y.d.t.", DAYZONE, 9 HRS}, {"hst", ZONE, 10 HRS}, /* Hawaii */ {"h.s.t.", ZONE, 10 HRS}, {"hdt", DAYZONE, 10 HRS}, {"h.d.t.", DAYZONE, 10 HRS}, {"gmt", ZONE, 0 HRS}, {"g.m.t.", ZONE, 0 HRS}, {"bst", DAYZONE, 0 HRS}, /* British Summer Time */ {"b.s.t.", DAYZONE, 0 HRS}, {"eet", ZONE, 0 HRS}, /* European Eastern Time */ {"e.e.t.", ZONE, 0 HRS}, {"eest", DAYZONE, 0 HRS}, /* European Eastern Summer Time */ {"e.e.s.t.", DAYZONE, 0 HRS}, {"met", ZONE, -1 HRS}, /* Middle European Time */ {"m.e.t.", ZONE, -1 HRS}, {"mest", DAYZONE, -1 HRS}, /* Middle European Summer Time */ {"m.e.s.t.", DAYZONE, -1 HRS}, {"wet", ZONE, -2 HRS }, /* Western European Time */ {"w.e.t.", ZONE, -2 HRS }, {"west", DAYZONE, -2 HRS}, /* Western European Summer Time */ {"w.e.s.t.", DAYZONE, -2 HRS}, {"jst", ZONE, -9 HRS}, /* Japan Standard Time */ {"j.s.t.", ZONE, -9 HRS}, /* Japan Standard Time */ /* No daylight savings time */ {"aest", ZONE, -10 HRS}, /* Australian Eastern Time */ {"a.e.s.t.", ZONE, -10 HRS}, {"aesst", DAYZONE, -10 HRS}, /* Australian Eastern Summer Time */ {"a.e.s.s.t.", DAYZONE, -10 HRS}, {"acst", ZONE, -(9 HRS + HALFHR)}, /* Australian Central Time */ {"a.c.s.t.", ZONE, -(9 HRS + HALFHR)}, {"acsst", DAYZONE, -(9 HRS + HALFHR)}, /* Australian Central Summer */ {"a.c.s.s.t.", DAYZONE, -(9 HRS + HALFHR)}, {"awst", ZONE, -8 HRS}, /* Australian Western Time */ {"a.w.s.t.", ZONE, -8 HRS}, /* (no daylight time there, I'm told */ {0, 0, 0}}; struct table unittb[] = { {"year", MUNIT, 12}, {"month", MUNIT, 1}, {"fortnight", UNIT, 14*24*60}, {"week", UNIT, 7*24*60}, {"day", UNIT, 1*24*60}, {"hour", UNIT, 60}, {"minute", UNIT, 1}, {"min", UNIT, 1}, {"second", SUNIT, 1}, {"sec", SUNIT, 1}, {0, 0, 0}}; struct table othertb[] = { {"tomorrow", UNIT, 1*24*60}, {"yesterday", UNIT, -1*24*60}, {"today", UNIT, 0}, {"now", UNIT, 0}, {"last", NUMBER, -1}, {"this", UNIT, 0}, {"next", NUMBER, 2}, {"first", NUMBER, 1}, /* {"second", NUMBER, 2}, */ {"third", NUMBER, 3}, {"fourth", NUMBER, 4}, {"fifth", NUMBER, 5}, {"sixth", NUMBER, 6}, {"seventh", NUMBER, 7}, {"eigth", NUMBER, 8}, {"ninth", NUMBER, 9}, {"tenth", NUMBER, 10}, {"eleventh", NUMBER, 11}, {"twelfth", NUMBER, 12}, {"ago", AGO, 1}, {0, 0, 0}}; struct table milzone[] = { {"a", ZONE, 1 HRS}, {"b", ZONE, 2 HRS}, {"c", ZONE, 3 HRS}, {"d", ZONE, 4 HRS}, {"e", ZONE, 5 HRS}, {"f", ZONE, 6 HRS}, {"g", ZONE, 7 HRS}, {"h", ZONE, 8 HRS}, {"i", ZONE, 9 HRS}, {"k", ZONE, 10 HRS}, {"l", ZONE, 11 HRS}, {"m", ZONE, 12 HRS}, {"n", ZONE, -1 HRS}, {"o", ZONE, -2 HRS}, {"p", ZONE, -3 HRS}, {"q", ZONE, -4 HRS}, {"r", ZONE, -5 HRS}, {"s", ZONE, -6 HRS}, {"t", ZONE, -7 HRS}, {"u", ZONE, -8 HRS}, {"v", ZONE, -9 HRS}, {"w", ZONE, -10 HRS}, {"x", ZONE, -11 HRS}, {"y", ZONE, -12 HRS}, {"z", ZONE, 0 HRS}, {0, 0, 0}}; lookup(id) char *id; { #define gotit (yylval=i->value, i->type) #define getid for(j=idvar, k=id; *j++ = *k++; ) char idvar[20]; register char *j, *k; register struct table *i; int abbrev; getid; if (strlen(idvar) == 3) abbrev = 1; else if (strlen(idvar) == 4 && idvar[3] == '.') { abbrev = 1; idvar[3] = '\0'; } else abbrev = 0; if (islower(*idvar)) *idvar = toupper(*idvar); for (i = mdtab; i->name; i++) { k = idvar; for (j = i->name; *j++ == *k++;) { if (abbrev && j==i->name+3) return gotit; if (j[-1] == 0) return gotit; } } getid; for (i = mztab; i->name; i++) if (strcmp(i->name, idvar) == 0) return gotit; for (j = idvar; *j; j++) if (isupper(*j)) *j = tolower(*j); for (i=mztab; i->name; i++) if (strcmp(i->name, idvar) == 0) return gotit; getid; for (i=unittb; i->name; i++) if (strcmp(i->name, idvar) == 0) return gotit; if (idvar[strlen(idvar)-1] == 's') idvar[strlen(idvar)-1] = '\0'; for (i=unittb; i->name; i++) if (strcmp(i->name, idvar) == 0) return gotit; getid; for (i = othertb; i->name; i++) if (strcmp(i->name, idvar) == 0) return gotit; getid; if (strlen(idvar) == 1 && isalpha(*idvar)) { if (isupper(*idvar)) *idvar = tolower(*idvar); for (i = milzone; i->name; i++) if (strcmp(i->name, idvar) == 0) return gotit; } return(ID); } #ifdef AMIGA struct fake_timeb { time_t time; long timezone; }; # define TIME_T struct fake_timeb #else # define TIME_T struct timeb #endif /* AMIGA */ time_t getdate(p, now) char *p; TIME_T *now; { #define mcheck(f) if (f>1) err++ time_t monthadd(); int err; struct tm *lt; TIME_T ftz; time_t sdate, tod; lptr = p; if (now == (TIME_T *)0) { #ifdef AMIGA register char *tz; now = &ftz; (void) time( (time_t *)now ); now->timezone = atoi( (tz=envparm("TZ")) ? tz : (tz=envparm("TIMEZONE")) ? tz : "0500"); #else now = &ftz; ftime(&ftz); #endif /* AMIGA */ } lt = localtime(&now->time); year = lt->tm_year; month = lt->tm_mon+1; day = lt->tm_mday; relsec = 0; relmonth = 0; timeflag = 0, zoneflag = 0, dateflag = 0, dayflag = 0, relflag = 0; ourzone = now->timezone; daylight = MAYBE; hh = mm = ss = 0; merid = 24; if (err = yyparse()) return (-1); mcheck(timeflag); mcheck(zoneflag); mcheck(dateflag); mcheck(dayflag); if (err) return (-1); if (dateflag || timeflag || dayflag) { sdate = dateconv(month,day,year,hh,mm,ss,merid,ourzone,daylight); if (sdate < 0) return -1; } else { sdate = now->time; if (relflag == 0) sdate -= (lt->tm_sec + lt->tm_min*60 + lt->tm_hour*(60L*60L)); } sdate += relsec; sdate += monthadd(sdate, relmonth); if (dayflag && !dateflag) { tod = dayconv(dayord, dayreq, sdate); sdate += tod; } return sdate; } yyerror(s) char *s; { return( 0 ); }