1 %{ 2 /* 3 ** Originally written by Steven M. Bellovin <smb@research.att.com> while 4 ** at the University of North Carolina at Chapel Hill. Later tweaked by 5 ** a couple of people on Usenet. Completely overhauled by Rich $alz 6 ** <rsalz@bbn.com> and Jim Berets <jberets@bbn.com> in August, 1990; 7 ** 8 ** This grammar has 10 shift/reduce conflicts. 9 ** 10 ** This code is in the public domain and has no copyright. 11 */ 12 /* SUPPRESS 287 on yaccpar_sccsid *//* Unused static variable */ 13 /* SUPPRESS 288 on yyerrlab *//* Label unused */ 14 15 /* $FreeBSD$ */ 16 17 #include <stdio.h> 18 #include <ctype.h> 19 20 /* The code at the top of get_date which figures out the offset of the 21 current time zone checks various CPP symbols to see if special 22 tricks are need, but defaults to using the gettimeofday system call. 23 Include <sys/time.h> if that will be used. */ 24 25 #if defined(vms) 26 # include <types.h> 27 #else /* defined(vms) */ 28 # include <sys/types.h> 29 # include <sys/time.h> 30 # include <sys/timeb.h> 31 #endif /* !defined(vms) */ 32 33 #if defined (__STDC__) || defined (USG) 34 #include <string.h> 35 #endif 36 37 /* Some old versions of bison generate parsers that use bcopy. 38 That loses on systems that don't provide the function, so we have 39 to redefine it here. */ 40 #if !defined (HAVE_BCOPY) && defined (HAVE_MEMCPY) && !defined (bcopy) 41 #define bcopy(from, to, len) memcpy ((to), (from), (len)) 42 #endif 43 44 #if defined (__STDC__) 45 #include <stdlib.h> 46 #endif 47 48 /* NOTES on rebuilding getdate.c (particularly for inclusion in CVS 49 releases): 50 51 We don't want to mess with all the portability hassles of alloca. 52 In particular, most (all?) versions of bison will use alloca in 53 their parser. If bison works on your system (e.g. it should work 54 with gcc), then go ahead and use it, but the more general solution 55 is to use byacc instead of bison, which should generate a portable 56 parser. I played with adding "#define alloca dont_use_alloca", to 57 give an error if the parser generator uses alloca (and thus detect 58 unportable getdate.c's), but that seems to cause as many problems 59 as it solves. */ 60 61 extern struct tm *gmtime(); 62 extern struct tm *localtime(); 63 64 #define yyparse getdate_yyparse 65 #define yylex getdate_yylex 66 #define yyerror getdate_yyerror 67 68 static int yyparse (); 69 static int yylex (); 70 static int yyerror (); 71 72 #define EPOCH 1970 73 #define HOUR(x) ((time_t)(x) * 60) 74 #define SECSPERDAY (24L * 60L * 60L) 75 76 77 /* 78 ** An entry in the lexical lookup table. 79 */ 80 typedef struct _TABLE { 81 char *name; 82 int type; 83 time_t value; 84 } TABLE; 85 86 87 /* 88 ** Daylight-savings mode: on, off, or not yet known. 89 */ 90 typedef enum _DSTMODE { 91 DSTon, DSToff, DSTmaybe 92 } DSTMODE; 93 94 /* 95 ** Meridian: am, pm, or 24-hour style. 96 */ 97 typedef enum _MERIDIAN { 98 MERam, MERpm, MER24 99 } MERIDIAN; 100 101 102 /* 103 ** Global variables. We could get rid of most of these by using a good 104 ** union as the yacc stack. (This routine was originally written before 105 ** yacc had the %union construct.) Maybe someday; right now we only use 106 ** the %union very rarely. 107 */ 108 static char *yyInput; 109 static DSTMODE yyDSTmode; 110 static time_t yyDayOrdinal; 111 static time_t yyDayNumber; 112 static int yyHaveDate; 113 static int yyHaveDay; 114 static int yyHaveRel; 115 static int yyHaveTime; 116 static int yyHaveZone; 117 static time_t yyTimezone; 118 static time_t yyDay; 119 static time_t yyHour; 120 static time_t yyMinutes; 121 static time_t yyMonth; 122 static time_t yySeconds; 123 static time_t yyYear; 124 static MERIDIAN yyMeridian; 125 static time_t yyRelMonth; 126 static time_t yyRelSeconds; 127 128 %} 129 130 %union { 131 time_t Number; 132 enum _MERIDIAN Meridian; 133 } 134 135 %token tAGO tDAY tDAYZONE tID tMERIDIAN tMINUTE_UNIT tMONTH tMONTH_UNIT 136 %token tSEC_UNIT tSNUMBER tUNUMBER tZONE tDST 137 138 %type <Number> tDAY tDAYZONE tMINUTE_UNIT tMONTH tMONTH_UNIT 139 %type <Number> tSEC_UNIT tSNUMBER tUNUMBER tZONE 140 %type <Meridian> tMERIDIAN o_merid 141 142 %% 143 144 spec : /* NULL */ 145 | spec item 146 ; 147 148 item : time { 149 yyHaveTime++; 150 } 151 | zone { 152 yyHaveZone++; 153 } 154 | date { 155 yyHaveDate++; 156 } 157 | day { 158 yyHaveDay++; 159 } 160 | rel { 161 yyHaveRel++; 162 } 163 | number 164 ; 165 166 time : tUNUMBER tMERIDIAN { 167 yyHour = $1; 168 yyMinutes = 0; 169 yySeconds = 0; 170 yyMeridian = $2; 171 } 172 | tUNUMBER ':' tUNUMBER o_merid { 173 yyHour = $1; 174 yyMinutes = $3; 175 yySeconds = 0; 176 yyMeridian = $4; 177 } 178 | tUNUMBER ':' tUNUMBER tSNUMBER { 179 yyHour = $1; 180 yyMinutes = $3; 181 yyMeridian = MER24; 182 yyDSTmode = DSToff; 183 yyTimezone = - ($4 % 100 + ($4 / 100) * 60); 184 } 185 | tUNUMBER ':' tUNUMBER ':' tUNUMBER o_merid { 186 yyHour = $1; 187 yyMinutes = $3; 188 yySeconds = $5; 189 yyMeridian = $6; 190 } 191 | tUNUMBER ':' tUNUMBER ':' tUNUMBER tSNUMBER { 192 yyHour = $1; 193 yyMinutes = $3; 194 yySeconds = $5; 195 yyMeridian = MER24; 196 yyDSTmode = DSToff; 197 yyTimezone = - ($6 % 100 + ($6 / 100) * 60); 198 } 199 ; 200 201 zone : tZONE { 202 yyTimezone = $1; 203 yyDSTmode = DSToff; 204 } 205 | tDAYZONE { 206 yyTimezone = $1; 207 yyDSTmode = DSTon; 208 } 209 | 210 tZONE tDST { 211 yyTimezone = $1; 212 yyDSTmode = DSTon; 213 } 214 ; 215 216 day : tDAY { 217 yyDayOrdinal = 1; 218 yyDayNumber = $1; 219 } 220 | tDAY ',' { 221 yyDayOrdinal = 1; 222 yyDayNumber = $1; 223 } 224 | tUNUMBER tDAY { 225 yyDayOrdinal = $1; 226 yyDayNumber = $2; 227 } 228 ; 229 230 date : tUNUMBER '/' tUNUMBER { 231 yyMonth = $1; 232 yyDay = $3; 233 } 234 | tUNUMBER '/' tUNUMBER '/' tUNUMBER { 235 if ($1 >= 100) { 236 yyYear = $1; 237 yyMonth = $3; 238 yyDay = $5; 239 } else { 240 yyMonth = $1; 241 yyDay = $3; 242 yyYear = $5; 243 } 244 } 245 | tUNUMBER tSNUMBER tSNUMBER { 246 /* ISO 8601 format. yyyy-mm-dd. */ 247 yyYear = $1; 248 yyMonth = -$2; 249 yyDay = -$3; 250 } 251 | tUNUMBER tMONTH tSNUMBER { 252 /* e.g. 17-JUN-1992. */ 253 yyDay = $1; 254 yyMonth = $2; 255 yyYear = -$3; 256 } 257 | tMONTH tUNUMBER { 258 yyMonth = $1; 259 yyDay = $2; 260 } 261 | tMONTH tUNUMBER ',' tUNUMBER { 262 yyMonth = $1; 263 yyDay = $2; 264 yyYear = $4; 265 } 266 | tUNUMBER tMONTH { 267 yyMonth = $2; 268 yyDay = $1; 269 } 270 | tUNUMBER tMONTH tUNUMBER { 271 yyMonth = $2; 272 yyDay = $1; 273 yyYear = $3; 274 } 275 ; 276 277 rel : relunit tAGO { 278 yyRelSeconds = -yyRelSeconds; 279 yyRelMonth = -yyRelMonth; 280 } 281 | relunit 282 ; 283 284 relunit : tUNUMBER tMINUTE_UNIT { 285 yyRelSeconds += $1 * $2 * 60L; 286 } 287 | tSNUMBER tMINUTE_UNIT { 288 yyRelSeconds += $1 * $2 * 60L; 289 } 290 | tMINUTE_UNIT { 291 yyRelSeconds += $1 * 60L; 292 } 293 | tSNUMBER tSEC_UNIT { 294 yyRelSeconds += $1; 295 } 296 | tUNUMBER tSEC_UNIT { 297 yyRelSeconds += $1; 298 } 299 | tSEC_UNIT { 300 yyRelSeconds++; 301 } 302 | tSNUMBER tMONTH_UNIT { 303 yyRelMonth += $1 * $2; 304 } 305 | tUNUMBER tMONTH_UNIT { 306 yyRelMonth += $1 * $2; 307 } 308 | tMONTH_UNIT { 309 yyRelMonth += $1; 310 } 311 ; 312 313 number : tUNUMBER { 314 if (yyHaveTime && yyHaveDate && !yyHaveRel) 315 yyYear = $1; 316 else { 317 if($1>10000) { 318 yyHaveDate++; 319 yyDay= ($1)%100; 320 yyMonth= ($1/100)%100; 321 yyYear = $1/10000; 322 } 323 else { 324 yyHaveTime++; 325 if ($1 < 100) { 326 yyHour = $1; 327 yyMinutes = 0; 328 } 329 else { 330 yyHour = $1 / 100; 331 yyMinutes = $1 % 100; 332 } 333 yySeconds = 0; 334 yyMeridian = MER24; 335 } 336 } 337 } 338 ; 339 340 o_merid : /* NULL */ { 341 $$ = MER24; 342 } 343 | tMERIDIAN { 344 $$ = $1; 345 } 346 ; 347 348 %% 349 350 /* Month and day table. */ 351 static TABLE const MonthDayTable[] = { 352 { "january", tMONTH, 1 }, 353 { "february", tMONTH, 2 }, 354 { "march", tMONTH, 3 }, 355 { "april", tMONTH, 4 }, 356 { "may", tMONTH, 5 }, 357 { "june", tMONTH, 6 }, 358 { "july", tMONTH, 7 }, 359 { "august", tMONTH, 8 }, 360 { "september", tMONTH, 9 }, 361 { "sept", tMONTH, 9 }, 362 { "october", tMONTH, 10 }, 363 { "november", tMONTH, 11 }, 364 { "december", tMONTH, 12 }, 365 { "sunday", tDAY, 0 }, 366 { "monday", tDAY, 1 }, 367 { "tuesday", tDAY, 2 }, 368 { "tues", tDAY, 2 }, 369 { "wednesday", tDAY, 3 }, 370 { "wednes", tDAY, 3 }, 371 { "thursday", tDAY, 4 }, 372 { "thur", tDAY, 4 }, 373 { "thurs", tDAY, 4 }, 374 { "friday", tDAY, 5 }, 375 { "saturday", tDAY, 6 }, 376 { NULL } 377 }; 378 379 /* Time units table. */ 380 static TABLE const UnitsTable[] = { 381 { "year", tMONTH_UNIT, 12 }, 382 { "month", tMONTH_UNIT, 1 }, 383 { "fortnight", tMINUTE_UNIT, 14 * 24 * 60 }, 384 { "week", tMINUTE_UNIT, 7 * 24 * 60 }, 385 { "day", tMINUTE_UNIT, 1 * 24 * 60 }, 386 { "hour", tMINUTE_UNIT, 60 }, 387 { "minute", tMINUTE_UNIT, 1 }, 388 { "min", tMINUTE_UNIT, 1 }, 389 { "second", tSEC_UNIT, 1 }, 390 { "sec", tSEC_UNIT, 1 }, 391 { NULL } 392 }; 393 394 /* Assorted relative-time words. */ 395 static TABLE const OtherTable[] = { 396 { "tomorrow", tMINUTE_UNIT, 1 * 24 * 60 }, 397 { "yesterday", tMINUTE_UNIT, -1 * 24 * 60 }, 398 { "today", tMINUTE_UNIT, 0 }, 399 { "now", tMINUTE_UNIT, 0 }, 400 { "last", tUNUMBER, -1 }, 401 { "this", tMINUTE_UNIT, 0 }, 402 { "next", tUNUMBER, 2 }, 403 { "first", tUNUMBER, 1 }, 404 /* { "second", tUNUMBER, 2 }, */ 405 { "third", tUNUMBER, 3 }, 406 { "fourth", tUNUMBER, 4 }, 407 { "fifth", tUNUMBER, 5 }, 408 { "sixth", tUNUMBER, 6 }, 409 { "seventh", tUNUMBER, 7 }, 410 { "eighth", tUNUMBER, 8 }, 411 { "ninth", tUNUMBER, 9 }, 412 { "tenth", tUNUMBER, 10 }, 413 { "eleventh", tUNUMBER, 11 }, 414 { "twelfth", tUNUMBER, 12 }, 415 { "ago", tAGO, 1 }, 416 { NULL } 417 }; 418 419 /* The timezone table. */ 420 /* Some of these are commented out because a time_t can't store a float. */ 421 static TABLE const TimezoneTable[] = { 422 { "gmt", tZONE, HOUR( 0) }, /* Greenwich Mean */ 423 { "ut", tZONE, HOUR( 0) }, /* Universal (Coordinated) */ 424 { "utc", tZONE, HOUR( 0) }, 425 { "wet", tZONE, HOUR( 0) }, /* Western European */ 426 { "bst", tDAYZONE, HOUR( 0) }, /* British Summer */ 427 { "wat", tZONE, HOUR( 1) }, /* West Africa */ 428 { "at", tZONE, HOUR( 2) }, /* Azores */ 429 #if 0 430 /* For completeness. BST is also British Summer, and GST is 431 * also Guam Standard. */ 432 { "bst", tZONE, HOUR( 3) }, /* Brazil Standard */ 433 { "gst", tZONE, HOUR( 3) }, /* Greenland Standard */ 434 #endif 435 #if 0 436 { "nft", tZONE, HOUR(3.5) }, /* Newfoundland */ 437 { "nst", tZONE, HOUR(3.5) }, /* Newfoundland Standard */ 438 { "ndt", tDAYZONE, HOUR(3.5) }, /* Newfoundland Daylight */ 439 #endif 440 { "ast", tZONE, HOUR( 4) }, /* Atlantic Standard */ 441 { "adt", tDAYZONE, HOUR( 4) }, /* Atlantic Daylight */ 442 { "est", tZONE, HOUR( 5) }, /* Eastern Standard */ 443 { "edt", tDAYZONE, HOUR( 5) }, /* Eastern Daylight */ 444 { "cst", tZONE, HOUR( 6) }, /* Central Standard */ 445 { "cdt", tDAYZONE, HOUR( 6) }, /* Central Daylight */ 446 { "mst", tZONE, HOUR( 7) }, /* Mountain Standard */ 447 { "mdt", tDAYZONE, HOUR( 7) }, /* Mountain Daylight */ 448 { "pst", tZONE, HOUR( 8) }, /* Pacific Standard */ 449 { "pdt", tDAYZONE, HOUR( 8) }, /* Pacific Daylight */ 450 { "yst", tZONE, HOUR( 9) }, /* Yukon Standard */ 451 { "ydt", tDAYZONE, HOUR( 9) }, /* Yukon Daylight */ 452 { "hst", tZONE, HOUR(10) }, /* Hawaii Standard */ 453 { "hdt", tDAYZONE, HOUR(10) }, /* Hawaii Daylight */ 454 { "cat", tZONE, HOUR(10) }, /* Central Alaska */ 455 { "ahst", tZONE, HOUR(10) }, /* Alaska-Hawaii Standard */ 456 { "nt", tZONE, HOUR(11) }, /* Nome */ 457 { "idlw", tZONE, HOUR(12) }, /* International Date Line West */ 458 { "cet", tZONE, -HOUR(1) }, /* Central European */ 459 { "met", tZONE, -HOUR(1) }, /* Middle European */ 460 { "mewt", tZONE, -HOUR(1) }, /* Middle European Winter */ 461 { "mest", tDAYZONE, -HOUR(1) }, /* Middle European Summer */ 462 { "swt", tZONE, -HOUR(1) }, /* Swedish Winter */ 463 { "sst", tDAYZONE, -HOUR(1) }, /* Swedish Summer */ 464 { "fwt", tZONE, -HOUR(1) }, /* French Winter */ 465 { "fst", tDAYZONE, -HOUR(1) }, /* French Summer */ 466 { "eet", tZONE, -HOUR(2) }, /* Eastern Europe, USSR Zone 1 */ 467 { "bt", tZONE, -HOUR(3) }, /* Baghdad, USSR Zone 2 */ 468 #if 0 469 { "it", tZONE, -HOUR(3.5) },/* Iran */ 470 #endif 471 { "zp4", tZONE, -HOUR(4) }, /* USSR Zone 3 */ 472 { "zp5", tZONE, -HOUR(5) }, /* USSR Zone 4 */ 473 #if 0 474 { "ist", tZONE, -HOUR(5.5) },/* Indian Standard */ 475 #endif 476 { "zp6", tZONE, -HOUR(6) }, /* USSR Zone 5 */ 477 #if 0 478 /* For completeness. NST is also Newfoundland Stanard, and SST is 479 * also Swedish Summer. */ 480 { "nst", tZONE, -HOUR(6.5) },/* North Sumatra */ 481 { "sst", tZONE, -HOUR(7) }, /* South Sumatra, USSR Zone 6 */ 482 #endif /* 0 */ 483 { "wast", tZONE, -HOUR(7) }, /* West Australian Standard */ 484 { "wadt", tDAYZONE, -HOUR(7) }, /* West Australian Daylight */ 485 #if 0 486 { "jt", tZONE, -HOUR(7.5) },/* Java (3pm in Cronusland!) */ 487 #endif 488 { "cct", tZONE, -HOUR(8) }, /* China Coast, USSR Zone 7 */ 489 { "jst", tZONE, -HOUR(9) }, /* Japan Standard, USSR Zone 8 */ 490 #if 0 491 { "cast", tZONE, -HOUR(9.5) },/* Central Australian Standard */ 492 { "cadt", tDAYZONE, -HOUR(9.5) },/* Central Australian Daylight */ 493 #endif 494 { "east", tZONE, -HOUR(10) }, /* Eastern Australian Standard */ 495 { "eadt", tDAYZONE, -HOUR(10) }, /* Eastern Australian Daylight */ 496 { "gst", tZONE, -HOUR(10) }, /* Guam Standard, USSR Zone 9 */ 497 { "nzt", tZONE, -HOUR(12) }, /* New Zealand */ 498 { "nzst", tZONE, -HOUR(12) }, /* New Zealand Standard */ 499 { "nzdt", tDAYZONE, -HOUR(12) }, /* New Zealand Daylight */ 500 { "idle", tZONE, -HOUR(12) }, /* International Date Line East */ 501 { NULL } 502 }; 503 504 /* Military timezone table. */ 505 static TABLE const MilitaryTable[] = { 506 { "a", tZONE, HOUR( 1) }, 507 { "b", tZONE, HOUR( 2) }, 508 { "c", tZONE, HOUR( 3) }, 509 { "d", tZONE, HOUR( 4) }, 510 { "e", tZONE, HOUR( 5) }, 511 { "f", tZONE, HOUR( 6) }, 512 { "g", tZONE, HOUR( 7) }, 513 { "h", tZONE, HOUR( 8) }, 514 { "i", tZONE, HOUR( 9) }, 515 { "k", tZONE, HOUR( 10) }, 516 { "l", tZONE, HOUR( 11) }, 517 { "m", tZONE, HOUR( 12) }, 518 { "n", tZONE, HOUR(- 1) }, 519 { "o", tZONE, HOUR(- 2) }, 520 { "p", tZONE, HOUR(- 3) }, 521 { "q", tZONE, HOUR(- 4) }, 522 { "r", tZONE, HOUR(- 5) }, 523 { "s", tZONE, HOUR(- 6) }, 524 { "t", tZONE, HOUR(- 7) }, 525 { "u", tZONE, HOUR(- 8) }, 526 { "v", tZONE, HOUR(- 9) }, 527 { "w", tZONE, HOUR(-10) }, 528 { "x", tZONE, HOUR(-11) }, 529 { "y", tZONE, HOUR(-12) }, 530 { "z", tZONE, HOUR( 0) }, 531 { NULL } 532 }; 533 534 535 536 537 /* ARGSUSED */ 538 static int 539 yyerror(s) 540 char *s __unused; 541 { 542 return 0; 543 } 544 545 546 static time_t 547 ToSeconds(Hours, Minutes, Seconds, Meridian) 548 time_t Hours; 549 time_t Minutes; 550 time_t Seconds; 551 MERIDIAN Meridian; 552 { 553 if (Minutes < 0 || Minutes > 59 || Seconds < 0 || Seconds > 59) 554 return -1; 555 switch (Meridian) { 556 case MER24: 557 if (Hours < 0 || Hours > 23) 558 return -1; 559 return (Hours * 60L + Minutes) * 60L + Seconds; 560 case MERam: 561 if (Hours < 1 || Hours > 12) 562 return -1; 563 if (Hours == 12) 564 Hours = 0; 565 return (Hours * 60L + Minutes) * 60L + Seconds; 566 case MERpm: 567 if (Hours < 1 || Hours > 12) 568 return -1; 569 if (Hours == 12) 570 Hours = 0; 571 return ((Hours + 12) * 60L + Minutes) * 60L + Seconds; 572 default: 573 abort (); 574 } 575 /* NOTREACHED */ 576 } 577 578 579 /* Year is either 580 * A negative number, which means to use its absolute value (why?) 581 * A number from 0 to 99, which means a year from 1900 to 1999, or 582 * The actual year (>=100). */ 583 static time_t 584 Convert(Month, Day, Year, Hours, Minutes, Seconds, Meridian, DSTmode) 585 time_t Month; 586 time_t Day; 587 time_t Year; 588 time_t Hours; 589 time_t Minutes; 590 time_t Seconds; 591 MERIDIAN Meridian; 592 DSTMODE DSTmode; 593 { 594 static int DaysInMonth[12] = { 595 31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 596 }; 597 time_t tod; 598 time_t Julian; 599 int i; 600 601 if (Year < 0) 602 Year = -Year; 603 if (Year < 69) 604 Year += 2000; 605 else if (Year < 100) 606 Year += 1900; 607 DaysInMonth[1] = Year % 4 == 0 && (Year % 100 != 0 || Year % 400 == 0) 608 ? 29 : 28; 609 /* Checking for 2038 bogusly assumes that time_t is 32 bits. But 610 I'm too lazy to try to check for time_t overflow in another way. */ 611 if (Year < EPOCH || Year > 2038 612 || Month < 1 || Month > 12 613 /* Lint fluff: "conversion from long may lose accuracy" */ 614 || Day < 1 || Day > DaysInMonth[(int)--Month]) 615 return -1; 616 617 for (Julian = Day - 1, i = 0; i < Month; i++) 618 Julian += DaysInMonth[i]; 619 for (i = EPOCH; i < Year; i++) 620 Julian += 365 + (i % 4 == 0); 621 Julian *= SECSPERDAY; 622 Julian += yyTimezone * 60L; 623 if ((tod = ToSeconds(Hours, Minutes, Seconds, Meridian)) < 0) 624 return -1; 625 Julian += tod; 626 if (DSTmode == DSTon 627 || (DSTmode == DSTmaybe && localtime(&Julian)->tm_isdst)) 628 Julian -= 60 * 60; 629 return Julian; 630 } 631 632 633 static time_t 634 DSTcorrect(Start, Future) 635 time_t Start; 636 time_t Future; 637 { 638 time_t StartDay; 639 time_t FutureDay; 640 641 StartDay = (localtime(&Start)->tm_hour + 1) % 24; 642 FutureDay = (localtime(&Future)->tm_hour + 1) % 24; 643 return (Future - Start) + (StartDay - FutureDay) * 60L * 60L; 644 } 645 646 647 static time_t 648 RelativeDate(Start, DayOrdinal, DayNumber) 649 time_t Start; 650 time_t DayOrdinal; 651 time_t DayNumber; 652 { 653 struct tm *tm; 654 time_t now; 655 656 now = Start; 657 tm = localtime(&now); 658 now += SECSPERDAY * ((DayNumber - tm->tm_wday + 7) % 7); 659 now += 7 * SECSPERDAY * (DayOrdinal <= 0 ? DayOrdinal : DayOrdinal - 1); 660 return DSTcorrect(Start, now); 661 } 662 663 664 static time_t 665 RelativeMonth(Start, RelMonth) 666 time_t Start; 667 time_t RelMonth; 668 { 669 struct tm *tm; 670 time_t Month; 671 time_t Year; 672 673 if (RelMonth == 0) 674 return 0; 675 tm = localtime(&Start); 676 Month = 12 * (tm->tm_year + 1900) + tm->tm_mon + RelMonth; 677 Year = Month / 12; 678 Month = Month % 12 + 1; 679 return DSTcorrect(Start, 680 Convert(Month, (time_t)tm->tm_mday, Year, 681 (time_t)tm->tm_hour, (time_t)tm->tm_min, (time_t)tm->tm_sec, 682 MER24, DSTmaybe)); 683 } 684 685 686 static int 687 LookupWord(buff) 688 char *buff; 689 { 690 register char *p; 691 register char *q; 692 register const TABLE *tp; 693 int i; 694 int abbrev; 695 696 /* Make it lowercase. */ 697 for (p = buff; *p; p++) 698 if (isupper(*p)) 699 *p = tolower(*p); 700 701 if (strcmp(buff, "am") == 0 || strcmp(buff, "a.m.") == 0) { 702 yylval.Meridian = MERam; 703 return tMERIDIAN; 704 } 705 if (strcmp(buff, "pm") == 0 || strcmp(buff, "p.m.") == 0) { 706 yylval.Meridian = MERpm; 707 return tMERIDIAN; 708 } 709 710 /* See if we have an abbreviation for a month. */ 711 if (strlen(buff) == 3) 712 abbrev = 1; 713 else if (strlen(buff) == 4 && buff[3] == '.') { 714 abbrev = 1; 715 buff[3] = '\0'; 716 } 717 else 718 abbrev = 0; 719 720 for (tp = MonthDayTable; tp->name; tp++) { 721 if (abbrev) { 722 if (strncmp(buff, tp->name, 3) == 0) { 723 yylval.Number = tp->value; 724 return tp->type; 725 } 726 } 727 else if (strcmp(buff, tp->name) == 0) { 728 yylval.Number = tp->value; 729 return tp->type; 730 } 731 } 732 733 for (tp = TimezoneTable; tp->name; tp++) 734 if (strcmp(buff, tp->name) == 0) { 735 yylval.Number = tp->value; 736 return tp->type; 737 } 738 739 if (strcmp(buff, "dst") == 0) 740 return tDST; 741 742 for (tp = UnitsTable; tp->name; tp++) 743 if (strcmp(buff, tp->name) == 0) { 744 yylval.Number = tp->value; 745 return tp->type; 746 } 747 748 /* Strip off any plural and try the units table again. */ 749 i = strlen(buff) - 1; 750 if (buff[i] == 's') { 751 buff[i] = '\0'; 752 for (tp = UnitsTable; tp->name; tp++) 753 if (strcmp(buff, tp->name) == 0) { 754 yylval.Number = tp->value; 755 return tp->type; 756 } 757 buff[i] = 's'; /* Put back for "this" in OtherTable. */ 758 } 759 760 for (tp = OtherTable; tp->name; tp++) 761 if (strcmp(buff, tp->name) == 0) { 762 yylval.Number = tp->value; 763 return tp->type; 764 } 765 766 /* Military timezones. */ 767 if (buff[1] == '\0' && isalpha(*buff)) { 768 for (tp = MilitaryTable; tp->name; tp++) 769 if (strcmp(buff, tp->name) == 0) { 770 yylval.Number = tp->value; 771 return tp->type; 772 } 773 } 774 775 /* Drop out any periods and try the timezone table again. */ 776 for (i = 0, p = q = buff; *q; q++) 777 if (*q != '.') 778 *p++ = *q; 779 else 780 i++; 781 *p = '\0'; 782 if (i) 783 for (tp = TimezoneTable; tp->name; tp++) 784 if (strcmp(buff, tp->name) == 0) { 785 yylval.Number = tp->value; 786 return tp->type; 787 } 788 789 return tID; 790 } 791 792 793 static int 794 yylex() 795 { 796 register char c; 797 register char *p; 798 char buff[20]; 799 int Count; 800 int sign; 801 802 for ( ; ; ) { 803 while (isspace(*yyInput)) 804 yyInput++; 805 806 if (isdigit(c = *yyInput) || c == '-' || c == '+') { 807 if (c == '-' || c == '+') { 808 sign = c == '-' ? -1 : 1; 809 if (!isdigit(*++yyInput)) 810 /* skip the '-' sign */ 811 continue; 812 } 813 else 814 sign = 0; 815 for (yylval.Number = 0; isdigit(c = *yyInput++); ) 816 yylval.Number = 10 * yylval.Number + c - '0'; 817 yyInput--; 818 if (sign < 0) 819 yylval.Number = -yylval.Number; 820 return sign ? tSNUMBER : tUNUMBER; 821 } 822 if (isalpha(c)) { 823 for (p = buff; isalpha(c = *yyInput++) || c == '.'; ) 824 if (p < &buff[sizeof buff - 1]) 825 *p++ = c; 826 *p = '\0'; 827 yyInput--; 828 return LookupWord(buff); 829 } 830 if (c != '(') 831 return *yyInput++; 832 Count = 0; 833 do { 834 c = *yyInput++; 835 if (c == '\0') 836 return c; 837 if (c == '(') 838 Count++; 839 else if (c == ')') 840 Count--; 841 } while (Count > 0); 842 } 843 } 844 845 #define TM_YEAR_ORIGIN 1900 846 847 /* Yield A - B, measured in seconds. */ 848 static long 849 difftm (a, b) 850 struct tm *a, *b; 851 { 852 int ay = a->tm_year + (TM_YEAR_ORIGIN - 1); 853 int by = b->tm_year + (TM_YEAR_ORIGIN - 1); 854 int days = ( 855 /* difference in day of year */ 856 a->tm_yday - b->tm_yday 857 /* + intervening leap days */ 858 + ((ay >> 2) - (by >> 2)) 859 - (ay/100 - by/100) 860 + ((ay/100 >> 2) - (by/100 >> 2)) 861 /* + difference in years * 365 */ 862 + (long)(ay-by) * 365 863 ); 864 return (60*(60*(24*days + (a->tm_hour - b->tm_hour)) 865 + (a->tm_min - b->tm_min)) 866 + (a->tm_sec - b->tm_sec)); 867 } 868 869 time_t 870 get_date(p, now) 871 char *p; 872 struct timeb *now; 873 { 874 struct tm *tm, gmt; 875 struct timeb ftz; 876 time_t Start; 877 time_t tod; 878 time_t nowtime; 879 880 yyInput = p; 881 if (now == NULL) { 882 struct tm *gmt_ptr; 883 884 now = &ftz; 885 (void)time (&nowtime); 886 887 gmt_ptr = gmtime (&nowtime); 888 if (gmt_ptr != NULL) 889 { 890 /* Make a copy, in case localtime modifies *tm (I think 891 that comment now applies to *gmt_ptr, but I am too 892 lazy to dig into how gmtime and locatime allocate the 893 structures they return pointers to). */ 894 gmt = *gmt_ptr; 895 } 896 897 if (! (tm = localtime (&nowtime))) 898 return -1; 899 900 if (gmt_ptr != NULL) 901 ftz.timezone = difftm (&gmt, tm) / 60; 902 else 903 /* We are on a system like VMS, where the system clock is 904 in local time and the system has no concept of timezones. 905 Hopefully we can fake this out (for the case in which the 906 user specifies no timezone) by just saying the timezone 907 is zero. */ 908 ftz.timezone = 0; 909 910 if(tm->tm_isdst) 911 ftz.timezone += 60; 912 } 913 else 914 { 915 nowtime = now->time; 916 } 917 918 tm = localtime(&nowtime); 919 yyYear = tm->tm_year + 1900; 920 yyMonth = tm->tm_mon + 1; 921 yyDay = tm->tm_mday; 922 yyTimezone = now->timezone; 923 yyDSTmode = DSTmaybe; 924 yyHour = 0; 925 yyMinutes = 0; 926 yySeconds = 0; 927 yyMeridian = MER24; 928 yyRelSeconds = 0; 929 yyRelMonth = 0; 930 yyHaveDate = 0; 931 yyHaveDay = 0; 932 yyHaveRel = 0; 933 yyHaveTime = 0; 934 yyHaveZone = 0; 935 936 if (yyparse() 937 || yyHaveTime > 1 || yyHaveZone > 1 || yyHaveDate > 1 || yyHaveDay > 1) 938 return -1; 939 940 if (yyHaveDate || yyHaveTime || yyHaveDay) { 941 Start = Convert(yyMonth, yyDay, yyYear, yyHour, yyMinutes, yySeconds, 942 yyMeridian, yyDSTmode); 943 if (Start < 0) 944 return -1; 945 } 946 else { 947 Start = nowtime; 948 if (!yyHaveRel) 949 Start -= ((tm->tm_hour * 60L + tm->tm_min) * 60L) + tm->tm_sec; 950 } 951 952 Start += yyRelSeconds; 953 Start += RelativeMonth(Start, yyRelMonth); 954 955 if (yyHaveDay && !yyHaveDate) { 956 tod = RelativeDate(Start, yyDayOrdinal, yyDayNumber); 957 Start += tod; 958 } 959 960 /* Have to do *something* with a legitimate -1 so it's distinguishable 961 * from the error return value. (Alternately could set errno on error.) */ 962 return Start == -1 ? 0 : Start; 963 } 964 965 966 #if defined(TEST) 967 968 /* ARGSUSED */ 969 int 970 main(ac, av) 971 int ac; 972 char *av[]; 973 { 974 char buff[128]; 975 time_t d; 976 977 (void)printf("Enter date, or blank line to exit.\n\t> "); 978 (void)fflush(stdout); 979 while (gets(buff) && buff[0]) { 980 d = get_date(buff, (struct timeb *)NULL); 981 if (d == -1) 982 (void)printf("Bad format - couldn't convert.\n"); 983 else 984 (void)printf("%s", ctime(&d)); 985 (void)printf("\t> "); 986 (void)fflush(stdout); 987 } 988 exit(0); 989 /* NOTREACHED */ 990 } 991 #endif /* defined(TEST) */ 992