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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > IP电话/视频会议 > 查看源码
getdate.y
资源名称：pwlib_1.1pl17.zip　[点击查看]
上传用户：hzhsqp
上传日期：2007-01-06
资源大小：1600k
文件大小：24k
源码类别：

IP电话/视频会议

开发平台：

Visual C++

getdate.y：源码内容
  1. %expect 10
  3. %{
  4. /*
  5. **  Originally written by Steven M. Bellovin <smb@research.att.com> while
  6. **  at the University of North Carolina at Chapel Hill.  Later tweaked by
  7. **  a couple of people on Usenet.  Completely overhauled by Rich $alz
  8. **  <rsalz@bbn.com> and Jim Berets <jberets@bbn.com> in August, 1990;
  9. **
  10. **  Major hack to coerce it into use with the Equivalence Portable
  11. **  Windows Library.
  12. **
  13. **  This grammar has 10 shift/reduce conflicts.
  14. **
  15. **  This code is in the public domain and has no copyright.
  16. */
  17. /* SUPPRESS 287 on yaccpar_sccsid *//* Unused static variable */
  18. /* SUPPRESS 288 on yyerrlab *//* Label unused */
  21. #include <time.h>
  22. #include <string.h>
  23. #include <ctype.h>
  25. #ifdef _MSC_VER
  26. #pragma warning(disable:4131 4701)
  27. #define STDAPICALLTYPE __stdcall
  28. #define MSDOS
  29. #else
  30. #define STDAPICALLTYPE
  31. #endif
  34. extern int  STDAPICALLTYPE PTimeGetChar(void * stream);
  35. extern void STDAPICALLTYPE PTimeUngetChar(void * stream, int c);
  36. int STDAPICALLTYPE PTimeGetDateOrder();
  37. int STDAPICALLTYPE PTimeIsMonthName(const char *, int, int);
  38. int STDAPICALLTYPE PTimeIsDayName(const char *, int, int);
  41. #define EPOCH 1970
  42. #define HOUR(x) ((time_t)(x) * 60)
  43. #define SECSPERDAY (24L * 60L * 60L)
  46. /*
  47. **  An entry in the lexical lookup table.
  48. */
  49. typedef struct _TABLE {
  50.     char *name;
  51.     int type;
  52.     time_t value;
  53. } TABLE;
  56. /*
  57. **  Daylight-savings mode:  on, off, or not yet known.
  58. */
  59. typedef enum _DSTMODE {
  60.     DSTon, DSToff, DSTmaybe
  61. } DSTMODE;
  63. /*
  64. **  Meridian:  am, pm, or 24-hour style.
  65. */
  66. typedef enum _MERIDIAN {
  67.     MERam, MERpm, MER24
  68. } MERIDIAN;
  71. /*
  72. **  Global variables.  We could get rid of most of these by using a good
  73. **  union as the yacc stack.  (This routine was originally written before
  74. **  yacc had the %union construct.)  Maybe someday; right now we only use
  75. **  the %union very rarely.
  76. */
  77. struct Variables {
  78.     void *yyInput;
  79.     DSTMODE yyDSTmode;
  80.     time_t yyDayOrdinal;
  81.     time_t yyDayNumber;
  82.     int yyHaveDate;
  83.     int yyHaveDay;
  84.     int yyHaveRel;
  85.     int yyHaveTime;
  86.     int yyHaveZone;
  87.     time_t yyTimezone;
  88.     time_t yyDay;
  89.     time_t yyHour;
  90.     time_t yyMinutes;
  91.     time_t yyMonth;
  92.     time_t yySeconds;
  93.     time_t yyYear;
  94.     MERIDIAN yyMeridian;
  95.     time_t yyRelMonth;
  96.     time_t yyRelSeconds;
  97. };
  99. #define VARIABLE ((struct Variables*)parseParam)
  102. #define YYPURE
  103. #define YYLEX_PARAM VARIABLE->yyInput
  104. #define YYPARSE_PARAM parseParam
  106. #define yyparse PTime_yyparse
  107. #define yylex PTime_yylex
  108. #define yyerror PTime_yyerror
  110. static int yyparse(void *); 
  111. #ifdef __GNUC__
  112. static int yyerror();
  113. static int yylex();
  114. #endif
  115. static void SetPossibleDate(struct Variables*, time_t, time_t, time_t);
  117. %}
  119. %union {
  120.     time_t Number;
  121.     enum _MERIDIAN Meridian;
  122. }
  124. %token tAGO tDAY tDAYZONE tID tMERIDIAN tMINUTE_UNIT tMONTH tMONTH_UNIT
  125. %token tSEC_UNIT tSNUMBER tUNUMBER tZONE tDST
  127. %type <Number> tDAY tDAYZONE tMINUTE_UNIT tMONTH tMONTH_UNIT
  128. %type <Number> tSEC_UNIT tSNUMBER tUNUMBER tZONE
  129. %type <Meridian> tMERIDIAN o_merid
  131. %%
  133. spec : /* NULL */
  134. | spec item
  135. ;
  137. item : time {
  138.     VARIABLE->yyHaveTime++;
  139. }
  140. | zone {
  141.     VARIABLE->yyHaveZone++;
  142. }
  143. | date {
  144.     VARIABLE->yyHaveDate++;
  145. }
  146. | day {
  147.     VARIABLE->yyHaveDay++;
  148. }
  149. | rel {
  150.     VARIABLE->yyHaveRel++;
  151. }
  152. | number
  153. ;
  155. time : tUNUMBER tMERIDIAN {
  156.     VARIABLE->yyHour = $1;
  157.     VARIABLE->yyMinutes = 0;
  158.     VARIABLE->yySeconds = 0;
  159.     VARIABLE->yyMeridian = $2;
  160. }
  161. | tUNUMBER ':' tUNUMBER o_merid {
  162.     VARIABLE->yyHour = $1;
  163.     VARIABLE->yyMinutes = $3;
  164.     VARIABLE->yySeconds = 0;
  165.     VARIABLE->yyMeridian = $4;
  166. }
  167. | tUNUMBER ':' tUNUMBER tSNUMBER {
  168.     VARIABLE->yyHour = $1;
  169.     VARIABLE->yyMinutes = $3;
  170.     VARIABLE->yyMeridian = MER24;
  171.     VARIABLE->yyDSTmode = DSToff;
  172.     VARIABLE->yyTimezone = - ($4 % 100 + ($4 / 100) * 60);
  173. }
  174. | tUNUMBER ':' tUNUMBER ':' tUNUMBER o_merid {
  175.     VARIABLE->yyHour = $1;
  176.     VARIABLE->yyMinutes = $3;
  177.     VARIABLE->yySeconds = $5;
  178.     VARIABLE->yyMeridian = $6;
  179. }
  180. | tUNUMBER ':' tUNUMBER ':' tUNUMBER tSNUMBER {
  181.     VARIABLE->yyHour = $1;
  182.     VARIABLE->yyMinutes = $3;
  183.     VARIABLE->yySeconds = $5;
  184.     VARIABLE->yyMeridian = MER24;
  185.     VARIABLE->yyDSTmode = DSToff;
  186.     VARIABLE->yyTimezone = - ($6 % 100 + ($6 / 100) * 60);
  187. }
  188. ;
  190. zone : tZONE {
  191.     VARIABLE->yyTimezone = $1;
  192.     VARIABLE->yyDSTmode = DSToff;
  193. }
  194. | tDAYZONE {
  195.     VARIABLE->yyTimezone = $1;
  196.     VARIABLE->yyDSTmode = DSTon;
  197. }
  198. |
  199.   tZONE tDST {
  200.     VARIABLE->yyTimezone = $1;
  201.     VARIABLE->yyDSTmode = DSTon;
  202. }
  203. ;
  205. day : tDAY {
  206.     VARIABLE->yyDayOrdinal = 1;
  207.     VARIABLE->yyDayNumber = $1;
  208. }
  209. | tDAY ',' {
  210.     VARIABLE->yyDayOrdinal = 1;
  211.     VARIABLE->yyDayNumber = $1;
  212. }
  213. | tUNUMBER tDAY {
  214.     VARIABLE->yyDayOrdinal = $1;
  215.     VARIABLE->yyDayNumber = $2;
  216. }
  217. ;
  219. date : tUNUMBER '/' tUNUMBER {
  220.     SetPossibleDate(VARIABLE, $1, $3, VARIABLE->yyYear);
  221. }
  222. | tUNUMBER '/' tUNUMBER '/' tUNUMBER {
  223.     SetPossibleDate(VARIABLE, $1, $3, $5);
  224. }
  225. | tUNUMBER tSNUMBER tSNUMBER {
  226.     /* ISO 8601 format.  yyyy-mm-dd.  */
  227.     if ($1 > 31) {
  228. VARIABLE->yyYear = $1;
  229. VARIABLE->yyMonth = -$2;
  230. VARIABLE->yyDay = -$3;
  231.     }
  232.     else
  233. SetPossibleDate(VARIABLE, $1, -$2, -$3);
  234. }
  235. | tUNUMBER tMONTH tSNUMBER {
  236.     /* e.g. 17-JUN-1992.  */
  237.     VARIABLE->yyDay = $1;
  238.     VARIABLE->yyMonth = $2;
  239.     VARIABLE->yyYear = -$3;
  240. }
  241. | tMONTH tUNUMBER {
  242.     VARIABLE->yyMonth = $1;
  243.     VARIABLE->yyDay = $2;
  244. }
  245. | tMONTH tUNUMBER ',' tUNUMBER {
  246.     VARIABLE->yyMonth = $1;
  247.     VARIABLE->yyDay = $2;
  248.     VARIABLE->yyYear = $4;
  249. }
  250. | tUNUMBER tMONTH {
  251.     VARIABLE->yyMonth = $2;
  252.     VARIABLE->yyDay = $1;
  253. }
  254. | tUNUMBER tMONTH tUNUMBER {
  255.     VARIABLE->yyMonth = $2;
  256.     VARIABLE->yyDay = $1;
  257.     VARIABLE->yyYear = $3;
  258. }
  259. ;
  261. rel : relunit tAGO {
  262.     VARIABLE->yyRelSeconds = -VARIABLE->yyRelSeconds;
  263.     VARIABLE->yyRelMonth = -VARIABLE->yyRelMonth;
  264. }
  265. | relunit
  266. ;
  268. relunit : tUNUMBER tMINUTE_UNIT {
  269.     VARIABLE->yyRelSeconds += $1 * $2 * 60L;
  270. }
  271. | tSNUMBER tMINUTE_UNIT {
  272.     VARIABLE->yyRelSeconds += $1 * $2 * 60L;
  273. }
  274. | tMINUTE_UNIT {
  275.     VARIABLE->yyRelSeconds += $1 * 60L;
  276. }
  277. | tSNUMBER tSEC_UNIT {
  278.     VARIABLE->yyRelSeconds += $1;
  279. }
  280. | tUNUMBER tSEC_UNIT {
  281.     VARIABLE->yyRelSeconds += $1;
  282. }
  283. | tSEC_UNIT {
  284.     VARIABLE->yyRelSeconds++;
  285. }
  286. | tSNUMBER tMONTH_UNIT {
  287.     VARIABLE->yyRelMonth += $1 * $2;
  288. }
  289. | tUNUMBER tMONTH_UNIT {
  290.     VARIABLE->yyRelMonth += $1 * $2;
  291. }
  292. | tMONTH_UNIT {
  293.     VARIABLE->yyRelMonth += $1;
  294. }
  295. ;
  297. number : tUNUMBER {
  298.     if (VARIABLE->yyHaveTime && VARIABLE->yyHaveDate && !VARIABLE->yyHaveRel)
  299. VARIABLE->yyYear = $1;
  300.     else {
  301. if($1>10000) {
  302.     VARIABLE->yyHaveDate++;
  303.     VARIABLE->yyDay= ($1)%100;
  304.     VARIABLE->yyMonth= ($1/100)%100;
  305.     VARIABLE->yyYear = $1/10000;
  306. }
  307. else {
  308.     VARIABLE->yyHaveTime++;
  309.     if ($1 < 100) {
  310. VARIABLE->yyHour = $1;
  311. VARIABLE->yyMinutes = 0;
  312.     }
  313.     else {
  314.      VARIABLE->yyHour = $1 / 100;
  315.      VARIABLE->yyMinutes = $1 % 100;
  316.     }
  317.     VARIABLE->yySeconds = 0;
  318.     VARIABLE->yyMeridian = MER24;
  319.         }
  320.     }
  321. }
  322. ;
  324. o_merid : /* NULL */ {
  325.     $$ = MER24;
  326. }
  327. | tMERIDIAN {
  328.     $$ = $1;
  329. }
  330. ;
  332. %%
  334. /* Month and day table. */
  335. static TABLE const MonthDayTable[] = {
  336.     { "january", tMONTH,  1 },
  337.     { "february", tMONTH,  2 },
  338.     { "march", tMONTH,  3 },
  339.     { "april", tMONTH,  4 },
  340.     { "may", tMONTH,  5 },
  341.     { "june", tMONTH,  6 },
  342.     { "july", tMONTH,  7 },
  343.     { "august", tMONTH,  8 },
  344.     { "september", tMONTH,  9 },
  345.     { "sept", tMONTH,  9 },
  346.     { "october", tMONTH, 10 },
  347.     { "november", tMONTH, 11 },
  348.     { "december", tMONTH, 12 },
  349.     { "sunday", tDAY, 0 },
  350.     { "monday", tDAY, 1 },
  351.     { "tuesday", tDAY, 2 },
  352.     { "tues", tDAY, 2 },
  353.     { "wednesday", tDAY, 3 },
  354.     { "wednes", tDAY, 3 },
  355.     { "thursday", tDAY, 4 },
  356.     { "thur", tDAY, 4 },
  357.     { "thurs", tDAY, 4 },
  358.     { "friday", tDAY, 5 },
  359.     { "saturday", tDAY, 6 },
  360.     { NULL }
  361. };
  363. /* Time units table. */
  364. static TABLE const UnitsTable[] = {
  365.     { "year", tMONTH_UNIT, 12 },
  366.     { "month", tMONTH_UNIT, 1 },
  367.     { "fortnight", tMINUTE_UNIT, 14 * 24 * 60 },
  368.     { "week", tMINUTE_UNIT, 7 * 24 * 60 },
  369.     { "day", tMINUTE_UNIT, 1 * 24 * 60 },
  370.     { "hour", tMINUTE_UNIT, 60 },
  371.     { "minute", tMINUTE_UNIT, 1 },
  372.     { "min", tMINUTE_UNIT, 1 },
  373.     { "second", tSEC_UNIT, 1 },
  374.     { "sec", tSEC_UNIT, 1 },
  375.     { NULL }
  376. };
  378. /* Assorted relative-time words. */
  379. static TABLE const OtherTable[] = {
  380.     { "tomorrow", tMINUTE_UNIT, 1 * 24 * 60 },
  381.     { "yesterday", tMINUTE_UNIT, -1 * 24 * 60 },
  382.     { "today", tMINUTE_UNIT, 0 },
  383.     { "now", tMINUTE_UNIT, 0 },
  384.     { "last", tUNUMBER, -1 },
  385.     { "this", tMINUTE_UNIT, 0 },
  386.     { "next", tUNUMBER, 2 },
  387.     { "first", tUNUMBER, 1 },
  388. /*  { "second", tUNUMBER, 2 }, */
  389.     { "third", tUNUMBER, 3 },
  390.     { "fourth", tUNUMBER, 4 },
  391.     { "fifth", tUNUMBER, 5 },
  392.     { "sixth", tUNUMBER, 6 },
  393.     { "seventh", tUNUMBER, 7 },
  394.     { "eighth", tUNUMBER, 8 },
  395.     { "ninth", tUNUMBER, 9 },
  396.     { "tenth", tUNUMBER, 10 },
  397.     { "eleventh", tUNUMBER, 11 },
  398.     { "twelfth", tUNUMBER, 12 },
  399.     { "ago", tAGO, 1 },
  400.     { NULL }
  401. };
  403. /* The timezone table. */
  404. /* Some of these are commented out because a time_t can't store a float. */
  405. static TABLE const TimezoneTable[] = {
  406.     { "gmt", tZONE,     HOUR( 0) }, /* Greenwich Mean */
  407.     { "ut", tZONE,     HOUR( 0) }, /* Universal (Coordinated) */
  408.     { "utc", tZONE,     HOUR( 0) },
  409.     { "wet", tZONE,     HOUR( 0) }, /* Western European */
  410.     { "bst", tDAYZONE,  HOUR( 0) }, /* British Summer */
  411.     { "wat", tZONE,     HOUR( 1) }, /* West Africa */
  412.     { "at", tZONE,     HOUR( 2) }, /* Azores */
  413. #if 0
  414.     /* For completeness.  BST is also British Summer, and GST is
  415.      * also Guam Standard. */
  416.     { "bst", tZONE,     HOUR( 3) }, /* Brazil Standard */
  417.     { "gst", tZONE,     HOUR( 3) }, /* Greenland Standard */
  418. #endif
  419. #if 0
  420.     { "nft", tZONE,     HOUR(3.5) }, /* Newfoundland */
  421.     { "nst", tZONE,     HOUR(3.5) }, /* Newfoundland Standard */
  422.     { "ndt", tDAYZONE,  HOUR(3.5) }, /* Newfoundland Daylight */
  423. #endif
  424.     { "ast", tZONE,     HOUR( 4) }, /* Atlantic Standard */
  425.     { "adt", tDAYZONE,  HOUR( 4) }, /* Atlantic Daylight */
  426.     { "est", tZONE,     HOUR( 5) }, /* Eastern Standard */
  427.     { "edt", tDAYZONE,  HOUR( 5) }, /* Eastern Daylight */
  428.     { "cst", tZONE,     HOUR( 6) }, /* Central Standard */
  429.     { "cdt", tDAYZONE,  HOUR( 6) }, /* Central Daylight */
  430.     { "mst", tZONE,     HOUR( 7) }, /* Mountain Standard */
  431.     { "mdt", tDAYZONE,  HOUR( 7) }, /* Mountain Daylight */
  432.     { "pst", tZONE,     HOUR( 8) }, /* Pacific Standard */
  433.     { "pdt", tDAYZONE,  HOUR( 8) }, /* Pacific Daylight */
  434.     { "yst", tZONE,     HOUR( 9) }, /* Yukon Standard */
  435.     { "ydt", tDAYZONE,  HOUR( 9) }, /* Yukon Daylight */
  436.     { "hst", tZONE,     HOUR(10) }, /* Hawaii Standard */
  437.     { "hdt", tDAYZONE,  HOUR(10) }, /* Hawaii Daylight */
  438.     { "cat", tZONE,     HOUR(10) }, /* Central Alaska */
  439.     { "ahst", tZONE,     HOUR(10) }, /* Alaska-Hawaii Standard */
  440.     { "nt", tZONE,     HOUR(11) }, /* Nome */
  441.     { "idlw", tZONE,     HOUR(12) }, /* International Date Line West */
  442.     { "cet", tZONE,     -HOUR(1) }, /* Central European */
  443.     { "met", tZONE,     -HOUR(1) }, /* Middle European */
  444.     { "mewt", tZONE,     -HOUR(1) }, /* Middle European Winter */
  445.     { "mest", tDAYZONE,  -HOUR(1) }, /* Middle European Summer */
  446.     { "swt", tZONE,     -HOUR(1) }, /* Swedish Winter */
  447.     { "sst", tDAYZONE,  -HOUR(1) }, /* Swedish Summer */
  448.     { "fwt", tZONE,     -HOUR(1) }, /* French Winter */
  449.     { "fst", tDAYZONE,  -HOUR(1) }, /* French Summer */
  450.     { "eet", tZONE,     -HOUR(2) }, /* Eastern Europe, USSR Zone 1 */
  451.     { "bt", tZONE,     -HOUR(3) }, /* Baghdad, USSR Zone 2 */
  452. #if 0
  453.     { "it", tZONE,     -HOUR(3.5) },/* Iran */
  454. #endif
  455.     { "zp4", tZONE,     -HOUR(4) }, /* USSR Zone 3 */
  456.     { "zp5", tZONE,     -HOUR(5) }, /* USSR Zone 4 */
  457. #if 0
  458.     { "ist", tZONE,     -HOUR(5.5) },/* Indian Standard */
  459. #endif
  460.     { "zp6", tZONE,     -HOUR(6) }, /* USSR Zone 5 */
  461. #if 0
  462.     /* For completeness.  NST is also Newfoundland Stanard, and SST is
  463.      * also Swedish Summer. */
  464.     { "nst", tZONE,     -HOUR(6.5) },/* North Sumatra */
  465.     { "sst", tZONE,     -HOUR(7) }, /* South Sumatra, USSR Zone 6 */
  466. #endif /* 0 */
  467.     { "wast", tZONE,     -HOUR(7) }, /* West Australian Standard */
  468.     { "wadt", tDAYZONE,  -HOUR(7) }, /* West Australian Daylight */
  469. #if 0
  470.     { "jt", tZONE,     -HOUR(7.5) },/* Java (3pm in Cronusland!) */
  471. #endif
  472.     { "cct", tZONE,     -HOUR(8) }, /* China Coast, USSR Zone 7 */
  473.     { "jst", tZONE,     -HOUR(9) }, /* Japan Standard, USSR Zone 8 */
  474. #if 0
  475.     { "cast", tZONE,     -HOUR(9.5) },/* Central Australian Standard */
  476.     { "cadt", tDAYZONE,  -HOUR(9.5) },/* Central Australian Daylight */
  477. #endif
  478.     { "east", tZONE,     -HOUR(10) }, /* Eastern Australian Standard */
  479.     { "eadt", tDAYZONE,  -HOUR(10) }, /* Eastern Australian Daylight */
  480.     { "gst", tZONE,     -HOUR(10) }, /* Guam Standard, USSR Zone 9 */
  481.     { "nzt", tZONE,     -HOUR(12) }, /* New Zealand */
  482.     { "nzst", tZONE,     -HOUR(12) }, /* New Zealand Standard */
  483.     { "nzdt", tDAYZONE,  -HOUR(12) }, /* New Zealand Daylight */
  484.     { "idle", tZONE,     -HOUR(12) }, /* International Date Line East */
  485.     {  NULL  }
  486. };
  488. /* Military timezone table. */
  489. static TABLE const MilitaryTable[] = {
  490.     { "a", tZONE, HOUR(  1) },
  491.     { "b", tZONE, HOUR(  2) },
  492.     { "c", tZONE, HOUR(  3) },
  493.     { "d", tZONE, HOUR(  4) },
  494.     { "e", tZONE, HOUR(  5) },
  495.     { "f", tZONE, HOUR(  6) },
  496.     { "g", tZONE, HOUR(  7) },
  497.     { "h", tZONE, HOUR(  8) },
  498.     { "i", tZONE, HOUR(  9) },
  499.     { "k", tZONE, HOUR( 10) },
  500.     { "l", tZONE, HOUR( 11) },
  501.     { "m", tZONE, HOUR( 12) },
  502.     { "n", tZONE, HOUR(- 1) },
  503.     { "o", tZONE, HOUR(- 2) },
  504.     { "p", tZONE, HOUR(- 3) },
  505.     { "q", tZONE, HOUR(- 4) },
  506.     { "r", tZONE, HOUR(- 5) },
  507.     { "s", tZONE, HOUR(- 6) },
  508.     { "t", tZONE, HOUR(- 7) },
  509.     { "u", tZONE, HOUR(- 8) },
  510.     { "v", tZONE, HOUR(- 9) },
  511.     { "w", tZONE, HOUR(-10) },
  512.     { "x", tZONE, HOUR(-11) },
  513.     { "y", tZONE, HOUR(-12) },
  514.     { "z", tZONE, HOUR(  0) },
  515.     { NULL }
  516. };
  518. static int LookupWord(char * buff, YYSTYPE * yylval)
  519. {
  520.     register char *p;
  521.     register char *q;
  522.     register const TABLE *tp;
  523.     int i;
  524.     int abbrev;
  526.     /* Make it lowercase. */
  527.     for (p = buff; *p != ''; p++)
  528.         *p = (char)tolower(*p);
  530.     if (strcmp(buff, "am") == 0 || strcmp(buff, "a.m.") == 0) {
  531. yylval->Meridian = MERam;
  532. return tMERIDIAN;
  533.     }
  534.     if (strcmp(buff, "pm") == 0 || strcmp(buff, "p.m.") == 0) {
  535. yylval->Meridian = MERpm;
  536. return tMERIDIAN;
  537.     }
  539.     /* See if we have an abbreviation for a month. */
  540.     if (strlen(buff) == 3)
  541. abbrev = 1;
  542.     else if (strlen(buff) == 4 && buff[3] == '.') {
  543. abbrev = 1;
  544. buff[3] = '';
  545.     }
  546.     else
  547. abbrev = 0;
  549.     for (tp = MonthDayTable; tp->name; tp++) {
  550. if (abbrev) {
  551.     if (strncmp(buff, tp->name, 3) == 0) {
  552. yylval->Number = tp->value;
  553. return tp->type;
  554.     }
  555. }
  556. else if (strcmp(buff, tp->name) == 0) {
  557.     yylval->Number = tp->value;
  558.     return tp->type;
  559. }
  560.     }
  562.     for (tp = TimezoneTable; tp->name; tp++)
  563. if (strcmp(buff, tp->name) == 0) {
  564.     yylval->Number = tp->value;
  565.     return tp->type;
  566. }
  568.     if (strcmp(buff, "dst") == 0) 
  569. return tDST;
  571.     for (tp = UnitsTable; tp->name; tp++)
  572. if (strcmp(buff, tp->name) == 0) {
  573.     yylval->Number = tp->value;
  574.     return tp->type;
  575. }
  577.     /* Strip off any plural and try the units table again. */
  578.     i = strlen(buff) - 1;
  579.     if (buff[i] == 's') {
  580. buff[i] = '';
  581. for (tp = UnitsTable; tp->name; tp++)
  582.     if (strcmp(buff, tp->name) == 0) {
  583. yylval->Number = tp->value;
  584. return tp->type;
  585.     }
  586. buff[i] = 's'; /* Put back for "this" in OtherTable. */
  587.     }
  589.     for (tp = OtherTable; tp->name; tp++)
  590. if (strcmp(buff, tp->name) == 0) {
  591.     yylval->Number = tp->value;
  592.     return tp->type;
  593. }
  595.     /* Military timezones. */
  596.     if (buff[1] == '' && isalpha(*buff)) {
  597. for (tp = MilitaryTable; tp->name; tp++)
  598.     if (strcmp(buff, tp->name) == 0) {
  599. yylval->Number = tp->value;
  600. return tp->type;
  601.     }
  602.     }
  604.     /* Drop out any periods and try the timezone table again. */
  605.     for (i = 0, p = q = buff; *q; q++)
  606. if (*q != '.')
  607.     *p++ = *q;
  608. else
  609.     i++;
  610.     *p = '';
  611.     if (i)
  612. for (tp = TimezoneTable; tp->name; tp++)
  613.     if (strcmp(buff, tp->name) == 0) {
  614. yylval->Number = tp->value;
  615. return tp->type;
  616.     }
  618.     for (i = 1; i <= 12; i++)
  619. for (abbrev = 0; abbrev < 2; abbrev++)
  620.     if (PTimeIsMonthName(buff, i, abbrev)) {
  621. yylval->Number = i;
  622. return tMONTH;
  623.     }
  625.     for (i = 1; i <= 7; i++)
  626. for (abbrev = 0; abbrev < 2; abbrev++)
  627.     if (PTimeIsDayName(buff, i, abbrev)) {
  628. yylval->Number = i;
  629. return tDAY;
  630.     }
  632.     return tID;
  633. }
  636. #ifdef _MSC_VER
  637. #pragma warning(disable:4211)
  638. #endif
  640. #ifndef __GNUC__
  641. static
  642. #endif
  643. int yylex(YYSTYPE * yylval, void * yyInput)
  644. {
  645.     register char *p;
  646.     char buff[20];
  647.     int Count;
  648.     int sign;
  649.     register int c = PTimeGetChar(yyInput);
  651.     while (c != EOF && c != '' && c != 'n') {
  652. while (isspace(c))
  653.     c = PTimeGetChar(yyInput);
  655. if (isdigit(c) || c == '-' || c == '+') {
  656.     if (c == '-' || c == '+') {
  657. sign = c == '-' ? -1 : 1;
  658. if (!isdigit(c = PTimeGetChar(yyInput)))
  659.     /* skip the '-' sign */
  660.     continue;
  661.     }
  662.     else
  663. sign = 0;
  664.     yylval->Number = 0;
  665.     while (isdigit(c)) {
  666. yylval->Number = 10 * yylval->Number + c - '0';
  667. c = PTimeGetChar(yyInput);
  668.     }
  669.     PTimeUngetChar(yyInput, c);
  670.     if (sign < 0)
  671. yylval->Number = -yylval->Number;
  672.     return sign ? tSNUMBER : tUNUMBER;
  673. }
  675. if (isalpha(c)) {
  676.     for (p = buff; isalpha(c) || c == '.'; c = PTimeGetChar(yyInput)) {
  677. if (p < &buff[sizeof(buff)-1])
  678.     *p++ = (char)c;
  679.     }
  680.     *p = '';
  681.     PTimeUngetChar(yyInput, c);
  682.     return LookupWord(buff, yylval);
  683. }
  685. if (c != '(')
  686.     return c;
  688. Count = 0;
  689. do {
  690.     c = PTimeGetChar(yyInput);
  691.     if (c == '' || c == EOF)
  692. return c;
  693.     if (c == '(')
  694. Count++;
  695.     else if (c == ')')
  696. Count--;
  697. } while (Count > 0);
  698.     }
  700.     return EOF;
  701. }
  703. #ifdef _MSC_VER
  704. #pragma warning(default:4211)
  705. #endif
  708. static time_t ToSeconds(time_t Hours, time_t Minutes, time_t Seconds,
  709. MERIDIAN Meridian)
  710. {
  711.     if (Minutes < 0 || Minutes > 59 || Seconds < 0 || Seconds > 59)
  712. return -1;
  713.     switch (Meridian) {
  714.     case MER24:
  715. if (Hours < 0 || Hours > 23)
  716.     return -1;
  717. return (Hours * 60L + Minutes) * 60L + Seconds;
  718.     case MERam:
  719. if (Hours < 1 || Hours > 12)
  720.     return -1;
  721. if (Hours == 12)
  722.     Hours = 0;
  723. return (Hours * 60L + Minutes) * 60L + Seconds;
  724.     case MERpm:
  725. if (Hours < 1 || Hours > 12)
  726.     return -1;
  727. if (Hours == 12)
  728.     Hours = 0;
  729. return ((Hours + 12) * 60L + Minutes) * 60L + Seconds;
  730.     }
  732.     return -1;
  733. }
  736. static time_t Convert(time_t Month, time_t Day, time_t Year,
  737.       time_t Hours, time_t Minutes, time_t Seconds,
  738.       MERIDIAN Meridian, DSTMODE DSTmode, time_t yyTimezone)
  739. {
  740.     static int DaysInMonth[12] = {
  741. 31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
  742.     };
  743.     time_t tod;
  744.     time_t Julian;
  745.     int i;
  747.     if (Year < 0)
  748. Year = -Year;
  749.     if (Year < 70)
  750. Year += 2000;
  751.     else if (Year < 100)
  752. Year += 1900;
  753.     DaysInMonth[1] = Year % 4 == 0 && (Year % 100 != 0 || Year % 400 == 0)
  754.     ? 29 : 28;
  755.     /* Checking for 2038 bogusly assumes that time_t is 32 bits.  But
  756.        I'm too lazy to try to check for time_t overflow in another way.  */
  757.     if (Year < EPOCH || Year > 2038
  758.      || Month < 1 || Month > 12
  759.      /* Lint fluff:  "conversion from long may lose accuracy" */
  760.      || Day < 1 || Day > DaysInMonth[(int)--Month])
  761. return -1;
  763.     for (Julian = Day - 1, i = 0; i < Month; i++)
  764. Julian += DaysInMonth[i];
  765.     for (i = EPOCH; i < Year; i++)
  766. Julian += 365 + (i % 4 == 0);
  767.     Julian *= SECSPERDAY;
  768.     Julian += yyTimezone * 60L;
  769.     if ((tod = ToSeconds(Hours, Minutes, Seconds, Meridian)) < 0)
  770. return -1;
  771.     Julian += tod;
  772.     if (DSTmode == DSTon
  773.      || (DSTmode == DSTmaybe && localtime(&Julian)->tm_isdst))
  774. Julian -= 60 * 60;
  775.     return Julian;
  776. }
  779. static time_t DSTcorrect(time_t Start, time_t Future)
  780. {
  781.     time_t StartDay;
  782.     time_t FutureDay;
  784.     StartDay = (localtime(&Start)->tm_hour + 1) % 24;
  785.     FutureDay = (localtime(&Future)->tm_hour + 1) % 24;
  786.     return (Future - Start) + (StartDay - FutureDay) * 60L * 60L;
  787. }
  790. static time_t RelativeDate(time_t Start, time_t DayOrdinal, time_t DayNumber)
  791. {
  792.     struct tm *tm;
  793.     time_t now;
  795.     now = Start;
  796.     tm = localtime(&now);
  797.     now += SECSPERDAY * ((DayNumber - tm->tm_wday + 7) % 7);
  798.     now += 7 * SECSPERDAY * (DayOrdinal <= 0 ? DayOrdinal : DayOrdinal - 1);
  799.     return DSTcorrect(Start, now);
  800. }
  803. static time_t RelativeMonth(time_t Start, time_t RelMonth, time_t yyTimezone)
  804. {
  805.     struct tm *tm;
  806.     time_t Month;
  807.     time_t Year;
  809.     if (RelMonth == 0)
  810. return 0;
  811.     tm = localtime(&Start);
  812.     Month = 12 * tm->tm_year + tm->tm_mon + RelMonth;
  813.     Year = Month / 12;
  814.     Month = Month % 12 + 1;
  815.     return DSTcorrect(Start,
  816.     Convert(Month, (time_t)tm->tm_mday, Year,
  817. (time_t)tm->tm_hour, (time_t)tm->tm_min, (time_t)tm->tm_sec,
  818. MER24, DSTmaybe, yyTimezone));
  819. }
  822. static void SetPossibleDate(struct Variables * var,
  823.       time_t possible_day,
  824.       time_t possible_month,
  825.       time_t possible_year)
  826. {
  827.     int date_order;
  829.     if (possible_day > 31) /* test for ymd */
  830. date_order = 2;
  831.     else if (possible_day > 12) /* test for dmy */
  832. date_order = 1;
  833.     else if (possible_month > 12) /* test for mdy */
  834. date_order = 0;
  835.     else {
  836. static int default_date_order = -1;
  837. if (default_date_order < 0)
  838.     default_date_order = PTimeGetDateOrder();
  839. date_order = default_date_order;
  840.     }
  842.     switch (date_order) {
  843.       case 0 :
  844. var->yyDay   = possible_month;
  845. var->yyMonth = possible_day;
  846. var->yyYear  = possible_year;
  847. break;
  848.       case 1 :
  849. var->yyDay   = possible_day;
  850. var->yyMonth = possible_month;
  851. var->yyYear  = possible_year;
  852. break;
  853.       default :
  854. var->yyDay   = possible_year;
  855. var->yyMonth = possible_month;
  856. var->yyYear  = possible_day;
  857.     }
  858. }
  861. time_t STDAPICALLTYPE PTimeParse(void * inputStream, struct tm * now, int timezone)
  862. {
  863.     time_t Start;
  864.     struct Variables var;
  867.     var.yyInput = inputStream;
  868.     var.yyYear = now->tm_year + 1900;
  869.     var.yyMonth = now->tm_mon + 1;
  870.     var.yyDay = now->tm_mday;
  871.     var.yyTimezone = -timezone;
  872.     var.yyDSTmode = DSTmaybe;
  873.     var.yyHour = 0;
  874.     var.yyMinutes = 0;
  875.     var.yySeconds = 0;
  876.     var.yyMeridian = MER24;
  877.     var.yyRelSeconds = 0;
  878.     var.yyRelMonth = 0;
  879.     var.yyHaveDate = 0;
  880.     var.yyHaveDay = 0;
  881.     var.yyHaveRel = 0;
  882.     var.yyHaveTime = 0;
  883.     var.yyHaveZone = 0;
  885.     yyparse(&var);
  887.     if (var.yyHaveTime > 1 || var.yyHaveZone > 1 ||
  888. var.yyHaveDate > 1 || var.yyHaveDay > 1)
  889. return -1;
  891.     if (var.yyHaveTime == 0 && var.yyHaveZone == 0 &&
  892. var.yyHaveDate == 0 && var.yyHaveDay == 0 && var.yyHaveRel == 0)
  893. return -1;
  895.     if (var.yyHaveDate || var.yyHaveTime || var.yyHaveDay) {
  896. Start = Convert(var.yyMonth, var.yyDay, var.yyYear,
  897. var.yyHour, var.yyMinutes, var.yySeconds,
  898. var.yyMeridian, var.yyDSTmode, var.yyTimezone);
  899. if (Start < 0)
  900.     return -1;
  901.     }
  902.     else {
  903. time(&Start);
  904. if (!var.yyHaveRel)
  905.     Start -= ((now->tm_hour * 60L + now->tm_min) * 60L) + now->tm_sec;
  906.     }
  908.     Start += var.yyRelSeconds;
  909.     Start += RelativeMonth(Start, var.yyRelMonth, var.yyTimezone);
  911.     if (var.yyHaveDay && !var.yyHaveDate)
  912. Start += RelativeDate(Start, var.yyDayOrdinal, var.yyDayNumber);
  914.     /* Have to do *something* with a legitimate -1 so it's distinguishable
  915.      * from the error return value.  (Alternately could set errno on error.) */
  916.     return Start == -1 ? 0 : Start;
  917. }
  920. #ifdef _MSC_VER
  921. #pragma warning(disable:4100 4211)
  922. #endif
  924. #ifdef __GNUC__
  925. int yyerror(const char * s)
  926. {
  927.   return 0;
  928. }
  929. #else
  930. static void yyerror(const char * s)
  931. {
  932. }
  933. #endif
  935. #ifdef _MSC_VER
  936. #pragma warning(default:4100 4211)
  937. #endif
  940. /* End of file ***************************************************************/