![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dtime.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / mh / zotnet / tws|
Return to dtime.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / mh / zotnet / tws |
1.1 root 1: /* dtime.c - routines to do ``ARPA-style'' time structures */
2:
3: /* LINTLIBRARY */
4:
5:
6: #include "tws.h"
7: #ifndef INETONLY
8: #include "../h/strings.h"
9: #else INETONLY
10: #include "strings.h"
11: #endif INETONLY
12: #include <stdio.h>
13: #include <sys/types.h>
14: #ifndef SYS5
15: #include <sys/timeb.h>
16: #endif not SYS5
17: #ifndef BSD42
18: #include <time.h>
19: #else BSD42
20: #include <sys/time.h>
21: #endif BSD42
22:
23: #ifdef SYS5
24: extern int daylight;
25: extern long timezone;
26: extern char *tzname[];
27: #endif SYS5
28:
29: /* */
30:
31: #define abs(a) (a >= 0 ? a : -a)
32:
33: #define dysize(y) \
34: (((y) % 4) ? 365 : (((y) % 100) ? 366 : (((y) % 400) ? 365 : 366)))
35:
36: /* */
37:
38: char *tw_moty[] = {
39: "Jan", "Feb", "Mar", "Apr", "May", "Jun",
40: "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", NULL
41: };
42:
43: char *tw_dotw[] = {
44: "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", NULL
45: };
46:
47: char *tw_ldotw[] = {
48: "Sunday", "Monday", "Tuesday", "Wednesday",
49: "Thursday", "Friday", "Saturday", NULL
50: };
51:
52: /* */
53:
54: static struct zone {
55: char *std,
56: *dst;
57: int shift;
58: } zones[] = {
59: "GMT", "BST", 0,
60: "EST", "EDT", -5,
61: "CST", "CDT", -6,
62: "MST", NULL, -7,
63: "PST", "PDT", -8,
64: "A", NULL, -1,
65: "B", NULL, -2,
66: "C", NULL, -3,
67: "D", NULL, -4,
68: "E", NULL, -5,
69: "F", NULL, -6,
70: "G", NULL, -7,
71: "H", NULL, -8,
72: "I", NULL, -9,
73: "K", NULL, -10,
74: "L", NULL, -11,
75: "M", NULL, -12,
76: "N", NULL, 1,
77: #ifndef HUJI
78: "O", NULL, 2,
79: #else HUJI
80: "JST", "JDT", 2,
81: #endif HUJI
82: "P", NULL, 3,
83: "Q", NULL, 4,
84: "R", NULL, 5,
85: "S", NULL, 6,
86: "T", NULL, 7,
87: "U", NULL, 8,
88: "V", NULL, 9,
89: "W", NULL, 10,
90: "X", NULL, 11,
91: "Y", NULL, 12,
92:
93: NULL
94: };
95:
96: #define CENTURY 19
97:
98: long time ();
99: struct tm *localtime ();
100:
101: /* */
102:
103: char *dtimenow () {
104: long clock;
105:
106: (void) time (&clock);
107: return dtime (&clock);
108: }
109:
110:
111: char *dctime (tw)
112: register struct tws *tw;
113: {
114: static char buffer[25];
115:
116: if (!tw)
117: return NULL;
118:
119: (void) sprintf (buffer, "%.3s %.3s %02d %02d:%02d:%02d %.4d\n",
120: tw_dotw[tw -> tw_wday], tw_moty[tw -> tw_mon], tw -> tw_mday,
121: tw -> tw_hour, tw -> tw_min, tw -> tw_sec,
122: tw -> tw_year >= 100 ? tw -> tw_year : 1900 + tw -> tw_year);
123:
124: return buffer;
125: }
126:
127: /* */
128:
129: struct tws *dtwstime () {
130: long clock;
131:
132: (void) time (&clock);
133: return dlocaltime (&clock);
134: }
135:
136:
137: struct tws *dlocaltime (clock)
138: register long *clock;
139: {
140: register struct tm *tm;
141: #ifndef SYS5
142: struct timeb tb;
143: #endif not SYS5
144: static struct tws tw;
145:
146: if (!clock)
147: return NULL;
148: tw.tw_flags = TW_NULL;
149:
150: tm = localtime (clock);
151: tw.tw_sec = tm -> tm_sec;
152: tw.tw_min = tm -> tm_min;
153: tw.tw_hour = tm -> tm_hour;
154: tw.tw_mday = tm -> tm_mday;
155: tw.tw_mon = tm -> tm_mon;
156: tw.tw_year = tm -> tm_year;
157: tw.tw_wday = tm -> tm_wday;
158: tw.tw_yday = tm -> tm_yday;
159: if (tm -> tm_isdst)
160: tw.tw_flags |= TW_DST;
161: #ifndef SYS5
162: ftime (&tb);
163: tw.tw_zone = -tb.timezone;
164: #else SYS5
165: tzset ();
166: tw.tw_zone = -(timezone / 60);
167: #endif SYS5
168: tw.tw_flags &= ~TW_SDAY, tw.tw_flags |= TW_SEXP;
169: tw.tw_clock = *clock;
170:
171: return (&tw);
172: }
173:
174:
175: struct tws *dgmtime (clock)
176: register long *clock;
177: {
178: register struct tm *tm;
179: static struct tws tw;
180:
181: if (!clock)
182: return NULL;
183: tw.tw_flags = TW_NULL;
184:
185: tm = gmtime (clock);
186: tw.tw_sec = tm -> tm_sec;
187: tw.tw_min = tm -> tm_min;
188: tw.tw_hour = tm -> tm_hour;
189: tw.tw_mday = tm -> tm_mday;
190: tw.tw_mon = tm -> tm_mon;
191: tw.tw_year = tm -> tm_year;
192: tw.tw_wday = tm -> tm_wday;
193: tw.tw_yday = tm -> tm_yday;
194: if (tm -> tm_isdst)
195: tw.tw_flags |= TW_DST;
196: tw.tw_zone = 0;
197: tw.tw_flags &= ~TW_SDAY, tw.tw_flags |= TW_SEXP;
198: tw.tw_clock = *clock;
199:
200: return (&tw);
201: }
202:
203: /* */
204:
205: char *dasctime (tw, flags)
206: register struct tws *tw;
207: int flags;
208: {
209: static char buffer[80],
210: result[80];
211:
212: if (!tw)
213: return NULL;
214:
215: (void) sprintf (buffer, "%02d %s %02d %02d:%02d:%02d %s",
216: tw -> tw_mday, tw_moty[tw -> tw_mon], tw -> tw_year,
217: tw -> tw_hour, tw -> tw_min, tw -> tw_sec,
218: dtimezone (tw -> tw_zone, tw -> tw_flags | flags));
219:
220: if ((tw -> tw_flags & TW_SDAY) == TW_SEXP)
221: (void) sprintf (result, "%s, %s", tw_dotw[tw -> tw_wday], buffer);
222: else
223: if ((tw -> tw_flags & TW_SDAY) == TW_SNIL)
224: (void) strcpy (result, buffer);
225: else
226: (void) sprintf (result, "%s (%s)", buffer, tw_dotw[tw -> tw_wday]);
227:
228: return result;
229: }
230:
231: /* */
232:
233: char *dtimezone (offset, flags)
234: register int offset,
235: flags;
236: {
237: register int hours,
238: mins;
239: register struct zone *z;
240: static char buffer[10];
241:
242: if (offset < 0) {
243: mins = -((-offset) % 60);
244: hours = -((-offset) / 60);
245: }
246: else {
247: mins = offset % 60;
248: hours = offset / 60;
249: }
250:
251: if (!(flags & TW_ZONE) && mins == 0)
252: for (z = zones; z -> std; z++)
253: if (z -> shift == hours)
254: return (z -> dst && (flags & TW_DST) ? z -> dst : z -> std);
255:
256: (void) sprintf (buffer, "%s%02d%02d",
257: offset < 0 ? "-" : "+", abs (hours), abs (mins));
258: return buffer;
259: }
260:
261: /* */
262:
263: void twscopy (tb, tw)
264: register struct tws *tb,
265: *tw;
266: {
267: #ifdef notdef
268: tb -> tw_sec = tw -> tw_sec;
269: tb -> tw_min = tw -> tw_min;
270: tb -> tw_hour = tw -> tw_hour;
271: tb -> tw_mday = tw -> tw_mday;
272: tb -> tw_mon = tw -> tw_mon;
273: tb -> tw_year = tw -> tw_year;
274: tb -> tw_wday = tw -> tw_wday;
275: tb -> tw_yday = tw -> tw_yday;
276: tb -> tw_zone = tw -> tw_zone;
277: tb -> tw_clock = tw -> tw_clock;
278: tb -> tw_flags = tw -> tw_flags;
279: #else not notdef
280: *tb = *tw;
281: #endif not notdef
282: }
283:
284:
285: int twsort (tw1, tw2)
286: register struct tws *tw1,
287: *tw2;
288: {
289: register long c1,
290: c2;
291:
292: if (tw1 -> tw_clock == 0L)
293: (void) twclock (tw1);
294: if (tw2 -> tw_clock == 0L)
295: (void) twclock (tw2);
296:
297: return ((c1 = tw1 -> tw_clock) > (c2 = tw2 -> tw_clock) ? 1
298: : c1 == c2 ? 0 : -1);
299: }
300:
301: /* */
302:
303: /* This routine is based on the gtime() routine written by Steven Shafer
304: (sas) at CMU. It was forwarded to MTR by Jay Lepreau at Utah-CS.
305: */
306:
307: static int dmsize[] = {
308: 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
309: };
310:
311:
312: long twclock (tw)
313: register struct tws *tw;
314: {
315: register int i,
316: sec,
317: min,
318: hour,
319: mday,
320: mon,
321: year;
322: register long result;
323:
324: if (tw -> tw_clock != 0L)
325: return tw -> tw_clock;
326:
327: if ((sec = tw -> tw_sec) < 0 || sec > 59
328: || (min = tw -> tw_min) < 0 || min > 59
329: || (hour = tw -> tw_hour) < 0 || hour > 23
330: || (mday = tw -> tw_mday) < 1 || mday > 31
331: || (mon = tw -> tw_mon + 1) < 1 || mon > 12)
332: return (tw -> tw_clock = -1L);
333: year = tw -> tw_year;
334:
335: result = 0L;
336: year += 1900;
337: for (i = 1970; i < year; i++)
338: result += dysize (i);
339: if (dysize (year) == 366 && mon >= 3)
340: result++;
341: while (--mon)
342: result += dmsize[mon - 1];
343: result += mday - 1;
344: result = 24 * result + hour;
345: result = 60 * result + min;
346: result = 60 * result + sec;
347: result -= 60 * tw -> tw_zone;
348: if (tw -> tw_flags & TW_DST)
349: result -= 60 * 60;
350:
351: return (tw -> tw_clock = result);
352: }
353:
354: /* */
355:
356: /*
357: * Simple calculation of day of the week. Algorithm used is Zeller's
358: * congruence. Currently, we assume if tw -> tw_year < 100
359: * then the century is CENTURY.
360: */
361:
362: set_dotw (tw)
363: register struct tws *tw;
364: {
365: register int month,
366: day,
367: year,
368: century;
369:
370: month = tw -> tw_mon - 1;
371: day = tw -> tw_mday;
372: year = tw -> tw_year % 100;
373: century = tw -> tw_year >= 100 ? tw -> tw_year / 100 : CENTURY;
374:
375: if (month <= 0) {
376: month += 12;
377: if (--year < 0) {
378: year += 100;
379: century--;
380: }
381: }
382:
383: tw -> tw_wday =
384: ((26 * month - 2) / 10 + day + year + year / 4
385: - 3 * century / 4 + 1) % 7;
386:
387: tw -> tw_flags &= ~TW_SDAY, tw -> tw_flags |= TW_SIMP;
388: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.