开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Telnet服务器 > 查看源码
parsdate.y
资源名称：3.0-20000220-SNAP.tar.gz　[点击查看]
上传用户：minyiyu
上传日期：2018-12-24
资源大小：864k
文件大小：23k
源码类别：

Telnet服务器

开发平台：

Unix_Linux

parsdate.y：源码内容
  1. %{
  2. /*
  3.  *  Project   : tin - a Usenet reader
  4.  *  Module    : parsedate.y
  5.  *  Author    : S.Bellovin & R.$alz & J.Berets & P.Eggert
  6.  *  Created   : 01-08-90
  7.  *  Updated   : 04-12-92
  8.  *  Notes     : This grammar has 6 shift/reduce conflicts.
  9.  *              Originally written by Steven M. Bellovin <smb@research.att.com> 
  10.  *              while at the University of North Carolina at Chapel Hill.  
  11.  *              Later tweaked by a couple of people on Usenet.  Completely 
  12.  *              overhauled by Rich $alz <rsalz@osf.org> and Jim Berets 
  13.  *              <jberets@bbn.com> in August, 1990. 
  14.  *              Further revised (removed obsolete constructs and cleaned up 
  15.  *              timezone names) in August, 1991, by Rich.
  16.  *              Paul Eggert <eggert@twinsun.com> helped in September 1992.
  17.  *  Revision  : 1.12
  18.  *  Copyright : This code is in the public domain and has no copyright.
  19.  */
  21. /* SUPPRESS 530 *//* Empty body for statement */
  22. /* SUPPRESS 593 on yyerrlab *//* Label was not used */
  23. /* SUPPRESS 593 on yynewstate *//* Label was not used */
  24. /* SUPPRESS 595 on yypvt *//* Automatic variable may be used before set */
  26. /*#include "tin.h"*/
  27. #include "innbbsconf.h"
  28. #include <stdio.h>
  29. #include <time.h>
  30. typedef struct _TIMEINFO 
  31. {
  32.      time_t      time;
  33.      long        usec;
  34.      long        tzone;
  35. } TIMEINFO;
  36. /*
  37. **  Get the number of elements in a fixed-size array, or a pointer just
  38. **  past the end of it.
  39. */
  40. #define SIZEOF(array) ((int)(sizeof array / sizeof array[0]))
  41. #define ENDOF(array) (&array[SIZEOF(array)])
  43. #define CTYPE(isXXXXX, c) ((isascii((c)) && isXXXXX((c))))
  45. typedef char *STRING;
  47. #define yyparse date_parse
  48. #define yylex date_lex
  49. #define yyerror date_error
  52.     /* See the LeapYears table in Convert. */
  53. #define EPOCH 1970
  54. #define END_OF_TIME 2038
  56.     /* Constants for general time calculations. */
  57. #define DST_OFFSET 1
  58. #define SECSPERDAY (24L * 60L * 60L)
  59.     /* Readability for TABLE stuff. */
  60. #define HOUR(x) (x * 60)
  62. #define LPAREN '('
  63. #define RPAREN ')'
  64. #define IS7BIT(x) ((unsigned int)(x) < 0200)
  67. /*
  68. **  An entry in the lexical lookup table.
  69. */
  70. typedef struct _TABLE {
  71.     STRING name;
  72.     int type;
  73.     time_t value;
  74. } TABLE;
  76. /*
  77. **  Daylight-savings mode:  on, off, or not yet known.
  78. */
  79. typedef enum _DSTMODE {
  80.     DSTon, DSToff, DSTmaybe
  81. } DSTMODE;
  83. /*
  84. **  Meridian:  am, pm, or 24-hour style.
  85. */
  86. typedef enum _MERIDIAN {
  87.     MERam, MERpm, MER24
  88. } MERIDIAN;
  91. /*
  92. **  Global variables.  We could get rid of most of them by using a yacc
  93. **  union, but this is more efficient.  (This routine predates the
  94. **  yacc %union construct.)
  95. */
  96. static char *yyInput;
  97. static DSTMODE yyDSTmode;
  98. static int yyHaveDate;
  99. static int yyHaveRel;
  100. static int yyHaveTime;
  101. static time_t yyTimezone;
  102. static time_t yyDay;
  103. static time_t yyHour;
  104. static time_t yyMinutes;
  105. static time_t yyMonth;
  106. static time_t yySeconds;
  107. static time_t yyYear;
  108. static MERIDIAN yyMeridian;
  109. static time_t yyRelMonth;
  110. static time_t yyRelSeconds;
  113. extern struct tm *localtime();
  115. static void date_error();
  116. %}
  118. %union {
  119.     time_t Number;
  120.     enum _MERIDIAN Meridian;
  121. }
  123. %token tDAY tDAYZONE tMERIDIAN tMONTH tMONTH_UNIT tSEC_UNIT tSNUMBER
  124. %token tUNUMBER tZONE
  126. %type <Number> tDAYZONE tMONTH tMONTH_UNIT tSEC_UNIT
  127. %type <Number> tSNUMBER tUNUMBER tZONE numzone zone
  128. %type <Meridian> tMERIDIAN o_merid
  130. %%
  132. spec : /* NULL */
  133. | spec item
  134. ;
  136. item : time {
  137.     yyHaveTime++;
  138. #if defined(lint)
  139.     /* I am compulsive about lint natterings... */
  140.     if (yyHaveTime == -1) {
  141. YYERROR;
  142.     }
  143. #endif /* defined(lint) */
  144. }
  145. | time zone {
  146.     yyHaveTime++;
  147.     yyTimezone = $2;
  148. }
  149. | date {
  150.     yyHaveDate++;
  151. }
  152. | rel {
  153.     yyHaveRel = 1;
  154. }
  155. ;
  157. time : tUNUMBER o_merid {
  158.     if ($1 < 100) {
  159. yyHour = $1;
  160. yyMinutes = 0;
  161.     }
  162.     else {
  163. yyHour = $1 / 100;
  164. yyMinutes = $1 % 100;
  165.     }
  166.     yySeconds = 0;
  167.     yyMeridian = $2;
  168. }
  169. | tUNUMBER ':' tUNUMBER o_merid {
  170.     yyHour = $1;
  171.     yyMinutes = $3;
  172.     yySeconds = 0;
  173.     yyMeridian = $4;
  174. }
  175. | tUNUMBER ':' tUNUMBER numzone {
  176.     yyHour = $1;
  177.     yyMinutes = $3;
  178.     yyTimezone = $4;
  179.     yyMeridian = MER24;
  180.     yyDSTmode = DSToff;
  181. }
  182. | tUNUMBER ':' tUNUMBER ':' tUNUMBER o_merid {
  183.     yyHour = $1;
  184.     yyMinutes = $3;
  185.     yySeconds = $5;
  186.     yyMeridian = $6;
  187. }
  188. | tUNUMBER ':' tUNUMBER ':' tUNUMBER numzone {
  189.     yyHour = $1;
  190.     yyMinutes = $3;
  191.     yySeconds = $5;
  192.     yyTimezone = $6;
  193.     yyMeridian = MER24;
  194.     yyDSTmode = DSToff;
  195. }
  196. ;
  198. zone : tZONE {
  199.     $$ = $1;
  200.     yyDSTmode = DSToff;
  201. }
  202. | tDAYZONE {
  203.     $$ = $1;
  204.     yyDSTmode = DSTon;
  205. }
  206. | tZONE numzone {
  207.     /* Only allow "GMT+300" and "GMT-0800" */
  208.     if ($1 != 0) {
  209. YYABORT;
  210.     }
  211.     $$ = $2;
  212.     yyDSTmode = DSToff;
  213. }
  214. | numzone {
  215.     $$ = $1;
  216.     yyDSTmode = DSToff;
  217. }
  218. ;
  220. numzone : tSNUMBER {
  221.     int i;
  222.                 
  223.     /* Unix and GMT and numeric timezones -- a little confusing. */
  224.     if ($1 < 0) {
  225. /* Don't work with negative modulus. */
  226. $1 = -$1;
  227.   if ($1 > 9999 || (i = $1 % 100) >= 60) {
  228.   YYABORT;
  229.   }
  230. $$ = ($1 / 100) * 60 + i;
  231.     }
  232.     else {
  233.   if ($1 > 9999 || (i = $1 % 100) >= 60) {
  234.   YYABORT;
  235.   }
  236. $$ = -(($1 / 100) * 60 + i);
  237.     }
  238. }
  239. ;
  241. date : tUNUMBER '/' tUNUMBER {
  242.     yyMonth = $1;
  243.     yyDay = $3;
  244. }
  245. | tUNUMBER '/' tUNUMBER '/' tUNUMBER {
  246.     if ($1 > 100) {
  247. yyYear = $1;
  248. yyMonth = $3;
  249. yyDay = $5;
  250.     }
  251.     else {
  252. yyMonth = $1;
  253. yyDay = $3;
  254. yyYear = $5;
  255.     }
  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.     yyDay = $1;
  268.     yyMonth = $2;
  269. }
  270. | tUNUMBER tMONTH tUNUMBER {
  271.     yyDay = $1;
  272.     yyMonth = $2;
  273.     yyYear = $3;
  274. }
  275. | tDAY ',' tUNUMBER tMONTH tUNUMBER {
  276.     yyDay = $3;
  277.     yyMonth = $4;
  278.     yyYear = $5;
  279. }
  280. ;
  282. rel : tSNUMBER tSEC_UNIT {
  283.     yyRelSeconds += $1 * $2;
  284. }
  285. | tUNUMBER tSEC_UNIT {
  286.     yyRelSeconds += $1 * $2;
  287. }
  288. | tSNUMBER tMONTH_UNIT {
  289.     yyRelMonth += $1 * $2;
  290. }
  291. | tUNUMBER tMONTH_UNIT {
  292.     yyRelMonth += $1 * $2;
  293. }
  294. ;
  296. o_merid : /* NULL */ {
  297.     $$ = MER24;
  298. }
  299. | tMERIDIAN {
  300.     $$ = $1;
  301. }
  302. ;
  304. %%
  306. /* Month and day table. */
  307. static TABLE MonthDayTable[] = {
  308.     { "january", tMONTH,  1 },
  309.     { "february", tMONTH,  2 },
  310.     { "march", tMONTH,  3 },
  311.     { "april", tMONTH,  4 },
  312.     { "may", tMONTH,  5 },
  313.     { "june", tMONTH,  6 },
  314.     { "july", tMONTH,  7 },
  315.     { "august", tMONTH,  8 },
  316.     { "september", tMONTH,  9 },
  317.     { "october", tMONTH, 10 },
  318.     { "november", tMONTH, 11 },
  319.     { "december", tMONTH, 12 },
  320. /* The value of the day isn't used... */
  321.     { "sunday", tDAY, 0 },
  322.     { "monday", tDAY, 0 },
  323.     { "tuesday", tDAY, 0 },
  324.     { "wednesday", tDAY, 0 },
  325.     { "thursday", tDAY, 0 },
  326.     { "friday", tDAY, 0 },
  327.     { "saturday", tDAY, 0 },
  328. };
  330. /* Time units table. */
  331. static TABLE UnitsTable[] = {
  332.     { "year", tMONTH_UNIT, 12 },
  333.     { "month", tMONTH_UNIT, 1 },
  334. #ifdef QNX4
  335.     { "week", tSEC_UNIT, 604800 },
  336.     { "day", tSEC_UNIT, 86400 },
  337. #else
  338.     { "week", tSEC_UNIT, 7 * 24 * 60 * 60 },
  339.     { "day", tSEC_UNIT, 1 * 24 * 60 * 60 },
  340. #endif
  341.     { "hour", tSEC_UNIT, 60 * 60 },
  342.     { "minute", tSEC_UNIT, 60 },
  343.     { "min", tSEC_UNIT, 60 },
  344.     { "second", tSEC_UNIT, 1 },
  345.     { "sec", tSEC_UNIT, 1 },
  346. };
  348. /* Timezone table. */
  349. static TABLE TimezoneTable[] = {
  350.     { "gmt", tZONE,     HOUR( 0) }, /* Greenwich Mean */
  351.     { "ut", tZONE,     HOUR( 0) }, /* Universal */
  352.     { "utc", tZONE,     HOUR( 0) }, /* Universal Coordinated */
  353.     { "cut", tZONE,     HOUR( 0) }, /* Coordinated Universal */
  354.     { "z", tZONE,     HOUR( 0) }, /* Greenwich Mean */
  355.     { "wet", tZONE,     HOUR( 0) }, /* Western European */
  356.     { "bst", tDAYZONE,  HOUR( 0) }, /* British Summer */
  357.     { "nst", tZONE,     HOUR(3)+30 }, /* Newfoundland Standard */
  358.     { "ndt", tDAYZONE,  HOUR(3)+30 }, /* Newfoundland Daylight */
  359.     { "ast", tZONE,     HOUR( 4) }, /* Atlantic Standard */
  360.     { "adt", tDAYZONE,  HOUR( 4) }, /* Atlantic Daylight */
  361.     { "est", tZONE,     HOUR( 5) }, /* Eastern Standard */
  362.     { "edt", tDAYZONE,  HOUR( 5) }, /* Eastern Daylight */
  363.     { "cst", tZONE,     HOUR( 6) }, /* Central Standard */
  364.     { "cdt", tDAYZONE,  HOUR( 6) }, /* Central Daylight */
  365.     { "mst", tZONE,     HOUR( 7) }, /* Mountain Standard */
  366.     { "mdt", tDAYZONE,  HOUR( 7) }, /* Mountain Daylight */
  367.     { "pst", tZONE,     HOUR( 8) }, /* Pacific Standard */
  368.     { "pdt", tDAYZONE,  HOUR( 8) }, /* Pacific Daylight */
  369.     { "yst", tZONE,     HOUR( 9) }, /* Yukon Standard */
  370.     { "ydt", tDAYZONE,  HOUR( 9) }, /* Yukon Daylight */
  371.     { "akst", tZONE,     HOUR( 9) }, /* Alaska Standard */
  372.     { "akdt", tDAYZONE,  HOUR( 9) }, /* Alaska Daylight */
  373.     { "hst", tZONE,     HOUR(10) }, /* Hawaii Standard */
  374.     { "hast", tZONE,     HOUR(10) }, /* Hawaii-Aleutian Standard */
  375.     { "hadt", tDAYZONE,  HOUR(10) }, /* Hawaii-Aleutian Daylight */
  376.     { "ces", tDAYZONE,  -HOUR(1) }, /* Central European Summer */
  377.     { "cest", tDAYZONE,  -HOUR(1) }, /* Central European Summer */
  378.     { "mez", tZONE,     -HOUR(1) }, /* Middle European */
  379.     { "mezt", tDAYZONE,  -HOUR(1) }, /* Middle European Summer */
  380.     { "cet", tZONE,     -HOUR(1) }, /* Central European */
  381.     { "met", tZONE,     -HOUR(1) }, /* Middle European */
  382.     { "eet", tZONE,     -HOUR(2) }, /* Eastern Europe */
  383.     { "msk", tZONE,     -HOUR(3) }, /* Moscow Winter */
  384.     { "msd", tDAYZONE,  -HOUR(3) }, /* Moscow Summer */
  385.     { "wast", tZONE,     -HOUR(8) }, /* West Australian Standard */
  386.     { "wadt", tDAYZONE,  -HOUR(8) }, /* West Australian Daylight */
  387.     { "hkt", tZONE,     -HOUR(8) }, /* Hong Kong */
  388.     { "cct", tZONE,     -HOUR(8) }, /* China Coast */
  389.     { "jst", tZONE,     -HOUR(9) }, /* Japan Standard */
  390.     { "kst", tZONE,     -HOUR(9) }, /* Korean Standard */
  391.     { "kdt", tZONE,     -HOUR(9) }, /* Korean Daylight */
  392.     { "cast", tZONE,     -(HOUR(9)+30) }, /* Central Australian Standard */
  393.     { "cadt", tDAYZONE,  -(HOUR(9)+30) }, /* Central Australian Daylight */
  394.     { "east", tZONE,     -HOUR(10) }, /* Eastern Australian Standard */
  395.     { "eadt", tDAYZONE,  -HOUR(10) }, /* Eastern Australian Daylight */
  396.     { "nzst", tZONE,     -HOUR(12) }, /* New Zealand Standard */
  397.     { "nzdt", tDAYZONE,  -HOUR(12) }, /* New Zealand Daylight */
  399.     /* For completeness we include the following entries. */
  400. #if 0
  402.     /* Duplicate names.  Either they conflict with a zone listed above
  403.      * (which is either more likely to be seen or just been in circulation
  404.      * longer), or they conflict with another zone in this section and
  405.      * we could not reasonably choose one over the other. */
  406.     { "fst", tZONE,     HOUR( 2) }, /* Fernando De Noronha Standard */
  407.     { "fdt", tDAYZONE,  HOUR( 2) }, /* Fernando De Noronha Daylight */
  408.     { "bst", tZONE,     HOUR( 3) }, /* Brazil Standard */
  409.     { "est", tZONE,     HOUR( 3) }, /* Eastern Standard (Brazil) */
  410.     { "edt", tDAYZONE,  HOUR( 3) }, /* Eastern Daylight (Brazil) */
  411.     { "wst", tZONE,     HOUR( 4) }, /* Western Standard (Brazil) */
  412.     { "wdt", tDAYZONE,  HOUR( 4) }, /* Western Daylight (Brazil) */
  413.     { "cst", tZONE,     HOUR( 5) }, /* Chile Standard */
  414.     { "cdt", tDAYZONE,  HOUR( 5) }, /* Chile Daylight */
  415.     { "ast", tZONE,     HOUR( 5) }, /* Acre Standard */
  416.     { "adt", tDAYZONE,  HOUR( 5) }, /* Acre Daylight */
  417.     { "cst", tZONE,     HOUR( 5) }, /* Cuba Standard */
  418.     { "cdt", tDAYZONE,  HOUR( 5) }, /* Cuba Daylight */
  419.     { "est", tZONE,     HOUR( 6) }, /* Easter Island Standard */
  420.     { "edt", tDAYZONE,  HOUR( 6) }, /* Easter Island Daylight */
  421.     { "sst", tZONE,     HOUR(11) }, /* Samoa Standard */
  422.     { "ist", tZONE,     -HOUR(2) }, /* Israel Standard */
  423.     { "idt", tDAYZONE,  -HOUR(2) }, /* Israel Daylight */
  424.     { "idt", tDAYZONE,  -(HOUR(3)+30) }, /* Iran Daylight */
  425.     { "ist", tZONE,     -(HOUR(3)+30) }, /* Iran Standard */
  426.     { "cst",  tZONE,     -HOUR(8) }, /* China Standard */
  427.     { "cdt",  tDAYZONE,  -HOUR(8) }, /* China Daylight */
  428.     { "sst",  tZONE,     -HOUR(8) }, /* Singapore Standard */
  430.     /* Dubious (e.g., not in Olson's TIMEZONE package) or obsolete. */
  431.     { "gst", tZONE,     HOUR( 3) }, /* Greenland Standard */
  432.     { "wat", tZONE,     -HOUR(1) }, /* West Africa */
  433.     { "at", tZONE,     HOUR( 2) }, /* Azores */
  434.     { "gst", tZONE,     -HOUR(10) }, /* Guam Standard */
  435.     { "nft", tZONE,     HOUR(3)+30 }, /* Newfoundland */
  436.     { "idlw", tZONE,     HOUR(12) }, /* International Date Line West */
  437.     { "mewt", tZONE,     -HOUR(1) }, /* Middle European Winter */
  438.     { "mest", tDAYZONE,  -HOUR(1) }, /* Middle European Summer */
  439.     { "swt", tZONE,     -HOUR(1) }, /* Swedish Winter */
  440.     { "sst", tDAYZONE,  -HOUR(1) }, /* Swedish Summer */
  441.     { "fwt", tZONE,     -HOUR(1) }, /* French Winter */
  442.     { "fst", tDAYZONE,  -HOUR(1) }, /* French Summer */
  443.     { "bt", tZONE,     -HOUR(3) }, /* Baghdad */
  444.     { "it", tZONE,     -(HOUR(3)+30) }, /* Iran */
  445.     { "zp4", tZONE,     -HOUR(4) }, /* USSR Zone 3 */
  446.     { "zp5", tZONE,     -HOUR(5) }, /* USSR Zone 4 */
  447.     { "ist", tZONE,     -(HOUR(5)+30) }, /* Indian Standard */
  448.     { "zp6", tZONE,     -HOUR(6) }, /* USSR Zone 5 */
  449.     { "nst", tZONE,     -HOUR(7) }, /* North Sumatra */
  450.     { "sst", tZONE,     -HOUR(7) }, /* South Sumatra */
  451.     { "jt", tZONE,     -(HOUR(7)+30) }, /* Java (3pm in Cronusland!) */
  452.     { "nzt", tZONE,     -HOUR(12) }, /* New Zealand */
  453.     { "idle", tZONE,     -HOUR(12) }, /* International Date Line East */
  454.     { "cat", tZONE,     HOUR(10) }, /* -- expired 1967 */
  455.     { "nt", tZONE,     HOUR(11) }, /* -- expired 1967 */
  456.     { "ahst", tZONE,     HOUR(10) }, /* -- expired 1983 */
  457.     { "hdt", tDAYZONE,  HOUR(10) }, /* -- expired 1986 */
  458. #endif /* 0 */
  459. };
  463. /* ARGSUSED */
  464. static void
  465. date_error(s)
  466.     char *s;
  467. {
  468.     /* NOTREACHED */
  469. }
  472. static time_t
  473. ToSeconds(Hours, Minutes, Seconds, Meridian)
  474.     time_t Hours;
  475.     time_t Minutes;
  476.     time_t Seconds;
  477.     MERIDIAN Meridian;
  478. {
  479.     if (Minutes < 0 || Minutes > 59 || Seconds < 0 || Seconds > 61)
  480. return -1;
  481.     if (Meridian == MER24) {
  482. if (Hours < 0 || Hours > 23)
  483.     return -1;
  484.     }
  485.     else {
  486. if (Hours < 1 || Hours > 12)
  487.     return -1;
  488. if (Meridian == MERpm)
  489.     Hours += 12;
  490.     }
  491.     return (Hours * 60L + Minutes) * 60L + Seconds;
  492. }
  495. static time_t
  496. Convert(Month, Day, Year, Hours, Minutes, Seconds, Meridian, dst)
  497.     time_t Month;
  498.     time_t Day;
  499.     time_t Year;
  500.     time_t Hours;
  501.     time_t Minutes;
  502.     time_t Seconds;
  503.     MERIDIAN Meridian;
  504.     DSTMODE dst;
  505. {
  506.     static int DaysNormal[13] = {
  507. 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
  508.     };
  509.     static int DaysLeap[13] = {
  510. 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
  511.     };
  512.     static int LeapYears[] = {
  513. 1972, 1976, 1980, 1984, 1988, 1992, 1996,
  514. 2000, 2004, 2008, 2012, 2016, 2020, 2024, 2028, 2032, 2036
  515.     };
  516.     register int *yp;
  517.     register int *mp;
  518.     register time_t Julian;
  519.     register int i;
  520.     time_t tod;
  522.     if (Year < 0)
  523. Year = -Year;
  524.     if (Year < 100)
  525. Year += 1900;
  526.     if (Year < EPOCH)
  527. Year += 100;
  528.     for (mp = DaysNormal, yp = LeapYears; yp < ENDOF(LeapYears); yp++)
  529. if (Year == *yp) {
  530.     mp = DaysLeap;
  531.     break;
  532. }
  533.     if (Year < EPOCH || Year > END_OF_TIME
  534.      || Month < 1 || Month > 12
  535.      /* NOSTRICT *//* conversion from long may lose accuracy */
  536.      || Day < 1 || Day > mp[(int)Month])
  537. return -1;
  539.     Julian = Day - 1 + (Year - EPOCH) * 365;
  540.     for (yp = LeapYears; yp < ENDOF(LeapYears); yp++, Julian++)
  541. if (Year <= *yp)
  542.     break;
  543.     for (i = 1; i < Month; i++)
  544. Julian += *++mp;
  545.     Julian *= SECSPERDAY;
  546.     Julian += yyTimezone * 60L;
  547.     if ((tod = ToSeconds(Hours, Minutes, Seconds, Meridian)) < 0)
  548. return -1;
  549.     Julian += tod;
  550.     tod = Julian;
  551.     if (dst == DSTon || (dst == DSTmaybe && localtime(&tod)->tm_isdst))
  552. Julian -= DST_OFFSET * 60 * 60;
  553.     return Julian;
  554. }
  557. static time_t
  558. DSTcorrect(Start, Future)
  559.     time_t Start;
  560.     time_t Future;
  561. {
  562.     time_t StartDay;
  563.     time_t FutureDay;
  565.     StartDay = (localtime(&Start)->tm_hour + 1) % 24;
  566.     FutureDay = (localtime(&Future)->tm_hour + 1) % 24;
  567.     return (Future - Start) + (StartDay - FutureDay) * DST_OFFSET * 60 * 60;
  568. }
  571. static time_t
  572. RelativeMonth(Start, RelMonth)
  573.     time_t Start;
  574.     time_t RelMonth;
  575. {
  576.     struct tm *tm;
  577.     time_t Month;
  578.     time_t Year;
  580.     tm = localtime(&Start);
  581.     Month = 12 * tm->tm_year + tm->tm_mon + RelMonth;
  582.     Year = Month / 12;
  583.     Month = Month % 12 + 1;
  584.     return DSTcorrect(Start,
  585.     Convert(Month, (time_t)tm->tm_mday, Year,
  586. (time_t)tm->tm_hour, (time_t)tm->tm_min, (time_t)tm->tm_sec,
  587. MER24, DSTmaybe));
  588. }
  591. static int
  592. LookupWord(buff, length)
  593.     char *buff;
  594.     register int length;
  595. {
  596.     register char *p;
  597.     register STRING q;
  598.     register TABLE *tp;
  599.     register int c;
  601.     p = buff;
  602.     c = p[0];
  603.     
  604.     /* See if we have an abbreviation for a month. */
  605.     if (length == 3 || (length == 4 && p[3] == '.'))
  606. for (tp = MonthDayTable; tp < ENDOF(MonthDayTable); tp++) {
  607.     q = tp->name;
  608.     if (c == q[0] && p[1] == q[1] && p[2] == q[2]) {
  609. yylval.Number = tp->value;
  610. return tp->type;
  611.     }
  612. }
  613.     else
  614. for (tp = MonthDayTable; tp < ENDOF(MonthDayTable); tp++)
  615.     if (c == tp->name[0] && strcmp(p, tp->name) == 0) {
  616. yylval.Number = tp->value;
  617. return tp->type;
  618.     }
  620.     /* Try for a timezone. */
  621.     for (tp = TimezoneTable; tp < ENDOF(TimezoneTable); tp++)
  622. if (c == tp->name[0] && p[1] == tp->name[1]
  623.  && strcmp(p, tp->name) == 0) {
  624.     yylval.Number = tp->value;
  625.     return tp->type;
  626. }
  628.     /* Try the units table. */
  629.     for (tp = UnitsTable; tp < ENDOF(UnitsTable); tp++)
  630. if (c == tp->name[0] && strcmp(p, tp->name) == 0) {
  631.     yylval.Number = tp->value;
  632.     return tp->type;
  633. }
  635.     /* Strip off any plural and try the units table again. */
  636.     if (--length > 0 && p[length] == 's') {
  637. p[length] = '';
  638. for (tp = UnitsTable; tp < ENDOF(UnitsTable); tp++)
  639.     if (c == tp->name[0] && strcmp(p, tp->name) == 0) {
  640. p[length] = 's';
  641. yylval.Number = tp->value;
  642. return tp->type;
  643.     }
  644. p[length] = 's';
  645.     }
  646.     length++;
  648.     /* Drop out any periods. */
  649.     for (p = buff, q = (STRING)buff; *q; q++)
  650. if (*q != '.')
  651.     *p++ = *q;
  652.     *p = '';
  654.     /* Try the meridians. */
  655.     if (buff[1] == 'm' && buff[2] == '') {
  656. if (buff[0] == 'a') {
  657.     yylval.Meridian = MERam;
  658.     return tMERIDIAN;
  659. }
  660. if (buff[0] == 'p') {
  661.     yylval.Meridian = MERpm;
  662.     return tMERIDIAN;
  663. }
  664.     }
  666.     /* If we saw any periods, try the timezones again. */
  667.     if (p - buff != length) {
  668. c = buff[0];    
  669. for (p = buff, tp = TimezoneTable; tp < ENDOF(TimezoneTable); tp++)
  670.     if (c == tp->name[0] && p[1] == tp->name[1]
  671.     && strcmp(p, tp->name) == 0) {
  672. yylval.Number = tp->value;
  673. return tp->type;
  674.     }
  675.     }
  676.     
  677.     /* Unknown word -- assume GMT timezone. */
  678.     yylval.Number = 0;
  679.     return tZONE;
  680. }
  683. static int
  684. date_lex()
  685. {
  686.     register char c;
  687.     register char *p;
  688.     char buff[20];
  689.     register int sign;
  690.     register int i;
  691.     register int nesting;
  693.     for ( ; ; ) {
  694. /* Get first character after the whitespace. */
  695. for ( ; ; ) {
  696.     while (CTYPE(isspace, *yyInput))
  697. yyInput++;
  698.     c = *yyInput;
  700.     /* Ignore RFC 822 comments, typically time zone names. */
  701.     if (c != LPAREN)
  702. break;
  703.     for (nesting = 1; (c = *++yyInput) != RPAREN || --nesting; )
  704. if (c == LPAREN)
  705.     nesting++;
  706. else if (!IS7BIT(c) || c == '' || c == 'r'
  707.      || (c == '\' && ((c = *++yyInput) == '' || !IS7BIT(c))))
  708.     /* Lexical error: bad comment. */
  709.     return '?';
  710.     yyInput++;
  711. }
  713. /* A number? */
  714. if (CTYPE(isdigit, c) || c == '-' || c == '+') {
  715.     if (c == '-' || c == '+') {
  716. sign = c == '-' ? -1 : 1;
  717. yyInput++;
  718. if (!CTYPE(isdigit, *yyInput))
  719.     /* Skip the plus or minus sign. */
  720.     continue;
  721.     }
  722.     else
  723. sign = 0;
  724.     for (i = 0; (c = *yyInput++) != '' && CTYPE(isdigit, c); )
  725. i = 10 * i + c - '0';
  726.     yyInput--;
  727.     yylval.Number = sign < 0 ? -i : i;
  728.     return sign ? tSNUMBER : tUNUMBER;
  729. }
  731. /* A word? */
  732. if (CTYPE(isalpha, c)) {
  733.     for (p = buff; (c = *yyInput++) == '.' || CTYPE(isalpha, c); )
  734. if (p < &buff[sizeof buff - 1])
  735.     *p++ = CTYPE(isupper, c) ? tolower(c) : c;
  736.     *p = '';
  737.     yyInput--;
  738.     return LookupWord(buff, p - buff);
  739. }
  741. return *yyInput++;
  742.     }
  743. }
  746. int
  747. GetTimeInfo(Now)
  748.     TIMEINFO *Now;
  749. {
  750.     static time_t LastTime;
  751.     static long LastTzone;
  752.     struct tm *tm;
  753. #if defined(DO_HAVE_GETTIMEOFDAY)
  754.     struct timeval tv;
  755. #endif /* defined(DO_HAVE_GETTIMEOFDAY) */
  756. #if     !defined(WITH_GM_GMTOFF)
  757. # define DONT_HAVE_TM_GMTOFF
  758. #endif
  759. #if defined(DONT_HAVE_TM_GMTOFF)
  760.     struct tm local;
  761.     struct tm gmt;
  762. #endif /* !defined(DONT_HAVE_TM_GMTOFF) */
  764.     /* Get the basic time. */
  765. #if defined(DO_HAVE_GETTIMEOFDAY)
  766.     if (gettimeofday(&tv, (struct timezone *)NULL) == -1)
  767. return -1;
  768.     Now->time = tv.tv_sec;
  769.     Now->usec = tv.tv_usec;
  770. #else
  771.     /* Can't check for -1 since that might be a time, I guess. */
  772.     (void)time(&Now->time);
  773.     Now->usec = 0;
  774. #endif /* defined(DO_HAVE_GETTIMEOFDAY) */
  776.     /* Now get the timezone if it's been an hour since the last time. */
  777.     if (Now->time - LastTime > 60 * 60) {
  778. LastTime = Now->time;
  779. if ((tm = localtime(&Now->time)) == NULL)
  780.     return -1;
  781. #if defined(DONT_HAVE_TM_GMTOFF)
  782. /* To get the timezone, compare localtime with GMT. */
  783. local = *tm;
  784. if ((tm = gmtime(&Now->time)) == NULL)
  785.     return -1;
  786. gmt = *tm;
  788. /* Assume we are never more than 24 hours away. */
  789. LastTzone = gmt.tm_yday - local.tm_yday;
  790. if (LastTzone > 1)
  791.     LastTzone = -24;
  792. else if (LastTzone < -1)
  793.     LastTzone = 24;
  794. else
  795.     LastTzone *= 24;
  797. /* Scale in the hours and minutes; ignore seconds. */
  798. LastTzone += gmt.tm_hour - local.tm_hour;
  799. LastTzone *= 60;
  800. LastTzone += gmt.tm_min - local.tm_min;
  801. #else
  802. LastTzone =  (0 - tm->tm_gmtoff) / 60;
  803. #endif /* defined(DONT_HAVE_TM_GMTOFF) */
  804.     }
  805.     Now->tzone = LastTzone;
  806.     return 0;
  807. }
  810. time_t
  811. parsedate(p, now)
  812.     char *p;
  813.     TIMEINFO *now;
  814. {
  815.     extern int date_parse();
  816.     struct tm *tm;
  817.     TIMEINFO ti;
  818.     time_t Start;
  820.     yyInput = p;
  821.     if (now == NULL) {
  822. now = &ti;
  823. (void)GetTimeInfo(&ti);
  824.     }
  826.     tm = localtime(&now->time);
  827.     yyYear = tm->tm_year;
  828.     yyMonth = tm->tm_mon + 1;
  829.     yyDay = tm->tm_mday;
  830.     yyTimezone = now->tzone;
  831.     yyDSTmode = DSTmaybe;
  832.     yyHour = 0;
  833.     yyMinutes = 0;
  834.     yySeconds = 0;
  835.     yyMeridian = MER24;
  836.     yyRelSeconds = 0;
  837.     yyRelMonth = 0;
  838.     yyHaveDate = 0;
  839.     yyHaveRel = 0;
  840.     yyHaveTime = 0;
  842.     if (date_parse() || yyHaveTime > 1 || yyHaveDate > 1)
  843. return -1;
  845.     if (yyHaveDate || yyHaveTime) {
  846. Start = Convert(yyMonth, yyDay, yyYear, yyHour, yyMinutes, yySeconds,
  847.     yyMeridian, yyDSTmode);
  848. if (Start < 0)
  849.     return -1;
  850.     }
  851.     else {
  852. Start = now->time;
  853. if (!yyHaveRel)
  854.     Start -= (tm->tm_hour * 60L + tm->tm_min) * 60L + tm->tm_sec;
  855.     }
  857.     Start += yyRelSeconds;
  858.     if (yyRelMonth)
  859. Start += RelativeMonth(Start, yyRelMonth);
  861.     /* Have to do *something* with a legitimate -1 so it's distinguishable
  862.      * from the error return value.  (Alternately could set errno on error.) */
  863.     return Start == -1 ? 0 : Start;
  864. }