![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dtimep.lex CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / mh / zotnet / tws|
Return to dtimep.lex CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / mh / zotnet / tws |
1.1 root 1: %{
2: #ifndef lint
3: static char rcsid[] =
4: #ifdef FLEX_SCANNER
5: "@(#) $Header: dtimep.lex,v 1.14 89/12/16 00:29:17 leres Locked $ (LBL) (flex generated scanner)";
6: #else
7: "@(#) $Header: dtimep.lex,v 1.14 89/12/16 00:29:17 leres Locked $ (LBL) (lex generated scanner)";
8: #endif
9: #endif
10: %}
11: /*
12: %e 2000
13: %p 5000
14: %n 1000
15: %a 4000
16: */
17:
18: %START Z
19: sun (sun(day)?)
20: mon (mon(day)?)
21: tue (tue(sday)?)
22: wed (wed(nesday)?)
23: thu (thu(rsday)?)
24: fri (fri(day)?)
25: sat (sat(urday)?)
26:
27: DAY ({sun}|{mon}|{tue}|{wed}|{thu}|{fri}|{sat})
28:
29: jan (jan(uary)?)
30: feb (feb(ruary)?)
31: mar (mar(ch)?)
32: apr (apr(il)?)
33: may (may)
34: jun (jun(e)?)
35: jul (jul(y)?)
36: aug (aug(ust)?)
37: sep (sep(tember)?)
38: oct (oct(ober)?)
39: nov (nov(ember)?)
40: dec (dec(ember)?)
41:
42: MONTH ({jan}|{feb}|{mar}|{apr}|{may}|{jun}|{jul}|{aug}|{sep}|{oct}|{nov}|{dec})
43:
44: w ([ \t]*)
45: W ([ \t]+)
46: D ([0-9]?[0-9])
47: d [0-9]
48: %{
49: #include "tws.h"
50: #include <ctype.h>
51:
52: /*
53: * Patchable flag that says how to interpret NN/NN/NN dates. When
54: * true, we do it European style: DD/MM/YY. When false, we do it
55: * American style: MM/DD/YY.
56: */
57: int europeandate = 0;
58:
59: /*
60: * Table to convert month names to numeric month. We use the
61: * fact that the low order 5 bits of the sum of the 2nd & 3rd
62: * characters of the name is a hash with no collisions for the 12
63: * valid month names. (The mask to 5 bits maps any combination of
64: * upper and lower case into the same hash value).
65: */
66: static int month_map[] = {
67: 0,
68: 6, /* 1 - Jul */
69: 3, /* 2 - Apr */
70: 5, /* 3 - Jun */
71: 0,
72: 10, /* 5 - Nov */
73: 0,
74: 1, /* 7 - Feb */
75: 11, /* 8 - Dec */
76: 0,
77: 0,
78: 0,
79: 0,
80: 0,
81: 0,
82: 0, /*15 - Jan */
83: 0,
84: 0,
85: 0,
86: 2, /*19 - Mar */
87: 0,
88: 8, /*21 - Sep */
89: 0,
90: 9, /*23 - Oct */
91: 0,
92: 0,
93: 4, /*26 - May */
94: 0,
95: 7 /*28 - Aug */
96: };
97: /*
98: * Same trick for day-of-week using the hash function
99: * (c1 & 7) + (c2 & 4)
100: */
101: static int day_map[] = {
102: 0,
103: 0,
104: 0,
105: 6, /* 3 - Sat */
106: 4, /* 4 - Thu */
107: 0,
108: 5, /* 6 - Fri */
109: 0, /* 7 - Sun */
110: 2, /* 8 - Tue */
111: 1 /* 9 - Mon */,
112: 0,
113: 3 /*11 - Wed */
114: };
115: #define SETDAY { tw.tw_wday= day_map[(cp[0] & 7) + (cp[1] & 4)];\
116: tw.tw_flags &= ~TW_SDAY; tw.tw_flags |= TW_SEXP;\
117: cp += 2; }
118: #define SETMONTH { tw.tw_mon = month_map[(cp[0] + cp[1]) & 0x1f]; gotdate++;\
119: cp += 2;\
120: SKIPD;}
121: #define CVT2 (i=(*cp++ - '0'),isdigit(*cp)? i*10 + (*cp++ - '0') : i)
122: #define SKIPD { while ( !isdigit(*cp++) ) ; --cp; }
123: #define EXPZONE { tw.tw_flags &= ~TW_SZONE; tw.tw_flags |= TW_SZEXP; }
124: #define ZONE(x) { tw.tw_zone=(x); EXPZONE; }
125: #define ZONED(x) { ZONE(x); tw.tw_flags |= TW_DST; }
126: #define LC(c) (isupper(c) ? tolower(c) : (c))
127:
128: #ifdef FLEX_SCANNER
129: /* We get passed a string and return a pointer to a static tws struct */
130: #undef YY_DECL
131: #define YY_DECL struct tws *dparsetime(str) char *str;
132:
133: /* We assume that we're never passed more than max_size characters */
134: #undef YY_INPUT
135: #define YY_INPUT(buf,result,max_size) \
136: if (gstr) { \
137: register char *xp; \
138: xp = gstr; \
139: while (isspace(*xp)) \
140: xp++; \
141: gstr = xp; \
142: while (*xp != '\0') \
143: ++xp; \
144: result = xp - gstr; \
145: bcopy(gstr, buf, result); \
146: gstr = 0; \
147: } else \
148: result = YY_NULL;
149:
150: /* Date strings aren't usually very long */
151: #undef YY_READ_BUF_SIZE
152: #define YY_READ_BUF_SIZE 128
153:
154: /* Use mh error reporting routine */
155: #undef YY_FATAL_ERROR
156: #define YY_FATAL_ERROR(s) adios("dparsetime()", s);
157:
158: /* We need a pointer to the matched text we can modify */
159: #undef YY_USER_ACTION
160: #define YY_USER_ACTION cp = yytext
161:
162: /* Used to initialize */
163: static struct tws ztw = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
164:
165: /* Global for use by YY_INPUT() macro */
166: static char *gstr;
167: #endif
168:
169: %}
170:
171: %%
172: register int i, gotdate;
173: register char *cp;
174: static struct tws tw;
175: static void zonehack();
176:
177: BEGIN(INITIAL);
178: yy_init = 1;
179: tw = ztw;
180: gstr = str;
181: gotdate = 0;
182:
183: {DAY}","?{w} SETDAY;
184: "("{DAY}")"(","?) {
185: cp++;
186: SETDAY;
187: }
188:
189: {D}"/"{D}"/"(19)?[0-9][0-9]{w} {
190: if (europeandate) {
191: /* European: DD/MM/YY */
192: tw.tw_mday = CVT2;
193: cp++;
194: tw.tw_mon = CVT2 - 1;
195: } else {
196: /* American: MM/DD/YY */
197: tw.tw_mon = CVT2 - 1;
198: cp++;
199: tw.tw_mday = CVT2;
200: }
201: cp++;
202: for (i = 0; isdigit(*cp); )
203: i = i*10 + (*cp++ - '0');
204: tw.tw_year = i % 100;
205: gotdate++;
206: }
207: {D}{w}(-)?{w}{MONTH}{w}(-)?{w}(19)?{D}{w}(\,{w}|at{W})? {
208: tw.tw_mday = CVT2;
209: while (!isalpha(*cp++))
210: ;
211: SETMONTH;
212: for (i = 0; isdigit(*cp); )
213: i = i*10 + (*cp++ - '0');
214: tw.tw_year = i % 100;
215: }
216: {MONTH}{W}{D}","{W}(19)?{D}{w} {
217: cp++;
218: SETMONTH;
219: tw.tw_mday = CVT2;
220: SKIPD;
221: for (i = 0; isdigit(*cp); )
222: i = i*10 + (*cp++ - '0');
223: tw.tw_year = i % 100;
224: }
225:
226: {MONTH}{W}{D}{w} {
227: cp++;
228: SETMONTH;
229: tw.tw_mday = CVT2;
230: }
231:
232: {D}:{D}:{D}{w} {
233: tw.tw_hour = CVT2; cp++;
234: tw.tw_min = CVT2; cp++;
235: tw.tw_sec = CVT2;
236: BEGIN Z;
237: }
238: {D}:{D}{w} {
239: tw.tw_hour = CVT2; cp++;
240: tw.tw_min = CVT2;
241: BEGIN Z;
242: }
243: {D}:{D}{w}am{w} {
244: tw.tw_hour = CVT2; cp++;
245: if (tw.tw_hour == 12)
246: tw.tw_hour = 0;
247: tw.tw_min = CVT2;
248: BEGIN Z;
249: }
250: {D}:{D}{w}pm{w} {
251: tw.tw_hour = CVT2; cp++;
252: if (tw.tw_hour != 12)
253: tw.tw_hour += 12;
254: tw.tw_min = CVT2;
255: BEGIN Z;
256: }
257: [0-2]{d}{d}{d}{d}{d}{w} {
258: tw.tw_hour = CVT2;
259: tw.tw_min = CVT2;
260: tw.tw_sec = CVT2;
261: BEGIN Z;
262: }
263: 19[6-9]{d}{w} {
264: /*
265: * Luckly, 4 digit times in the range
266: * 1960-1999 aren't legal as hour
267: * and minutes. This rule must come
268: * the 4 digit hour and minute rule.
269: */
270: cp += 2;
271: tw.tw_year = CVT2;
272: }
273: [0-2]{d}{d}{d}{w} {
274: tw.tw_hour = CVT2;
275: tw.tw_min = CVT2;
276: BEGIN Z;
277: }
278: <Z>"-"?ut ZONE(0 * 60);
279: <Z>"-"?gmt ZONE(0 * 60);
280: <Z>"-"?jst ZONE(2 * 60);
281: <Z>"-"?jdt ZONED(2 * 60);
282: <Z>"-"?est ZONE(-5 * 60);
283: <Z>"-"?edt ZONED(-5 * 60);
284: <Z>"-"?cst ZONE(-6 * 60);
285: <Z>"-"?cdt ZONED(-6 * 60);
286: <Z>"-"?mst ZONE(-7 * 60);
287: <Z>"-"?mdt ZONED(-7 * 60);
288: <Z>"-"?pst ZONE(-8 * 60);
289: <Z>"-"?pdt ZONED(-8 * 60);
290: <Z>"-"?nst ZONE(-(3 * 60 + 30));
291: <Z>"-"?ast ZONE(-4 * 60);
292: <Z>"-"?adt ZONED(-4 * 60);
293: <Z>"-"?yst ZONE(-9 * 60);
294: <Z>"-"?ydt ZONED(-9 * 60);
295: <Z>"-"?hst ZONE(-10 * 60);
296: <Z>"-"?hdt ZONED(-10 * 60);
297: <Z>"-"?bst ZONED(-1 * 60);
298: <Z>[a-i] {
299: tw.tw_zone = 60 * (('a'-1) - LC(*cp));
300: EXPZONE;
301: }
302: <Z>[k-m] {
303: tw.tw_zone = 60 * ('a' - LC(*cp));
304: EXPZONE;
305: }
306: <Z>[n-y] {
307: tw.tw_zone = 60 * (LC(*cp) - 'm');
308: EXPZONE;
309: }
310: <Z>"+"[0-1]{d}{d}{d} {
311: cp++;
312: tw.tw_zone = ((cp[0] * 10 + cp[1])
313: -('0' * 10 + '0'))*60
314: +((cp[2] * 10 + cp[3])
315: -('0' * 10 + '0'));
316: #ifdef DSTXXX
317: zonehack (&tw);
318: #endif DSTXXX
319: cp += 4;
320: EXPZONE;
321: }
322: <Z>"-"[0-1]{d}{d}{d} {
323: cp++;
324: tw.tw_zone = (('0' * 10 + '0')
325: -(cp[0] * 10 + cp[1]))*60
326: +(('0' * 10 + '0')
327: -(cp[2] * 10 + cp[3]));
328: #ifdef DSTXXX
329: zonehack (&tw);
330: #endif DSTXXX
331: cp += 4;
332: EXPZONE;
333: }
334:
335: \n |
336: {W} ;
337:
338: <INITIAL,Z><<EOF>> return(&tw);
339:
340: . {
341: /*
342: * We jammed; it's an error if we
343: * didn't parse anything.
344: */
345: if (!gotdate || tw.tw_year == 0)
346: return(0);
347: return(&tw);
348: }
349:
350: %%
351:
352: #ifdef DSTXXX
353: #include <sys/types.h>
354: #ifndef BSD42
355: #include <time.h>
356: #else BSD42
357: #include <sys/time.h>
358: #endif BSD42
359:
360: static void
361: zonehack(tw)
362: register struct tws *tw;
363: {
364: register struct tm *tm;
365:
366: if (twclock (tw) == -1L)
367: return;
368:
369: tm = localtime (&tw -> tw_clock);
370: if (tm -> tm_isdst) {
371: tw -> tw_flags |= TW_DST;
372: tw -> tw_zone -= 60;
373: }
374: }
375: #endif DSTXXX
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.