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

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

Telnet服务器

开发平台：

Unix_Linux

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