![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ctime.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / libc / gen|
Return to ctime.c CVS log | Up to [CSRG BSD Unix] / 3BSD / libc / gen |
1.1 root 1: /*
2: * This routine converts time as follows.
3: * The epoch is 0000 Jan 1 1970 GMT.
4: * The argument time is in seconds since then.
5: * The localtime(t) entry returns a pointer to an array
6: * containing
7: * seconds (0-59)
8: * minutes (0-59)
9: * hours (0-23)
10: * day of month (1-31)
11: * month (0-11)
12: * year-1970
13: * weekday (0-6, Sun is 0)
14: * day of the year
15: * daylight savings flag
16: *
17: * The routine calls the system to determine the local
18: * timezone and whether Daylight Saving Time is permitted locally.
19: * (DST is then determined by the current US standard rules)
20: * There is a table that accounts for the peculiarities
21: * undergone by daylight time in 1974-1975.
22: *
23: * The routine does not work
24: * in Saudi Arabia which runs on Solar time.
25: *
26: * asctime(tvec))
27: * where tvec is produced by localtime
28: * returns a ptr to a character string
29: * that has the ascii time in the form
30: * Thu Jan 01 00:00:00 1970n0\\
31: * 01234567890123456789012345
32: * 0 1 2
33: *
34: * ctime(t) just calls localtime, then asctime.
35: */
36:
37: #include <time.h>
38: #include <sys/types.h>
39: #include <sys/timeb.h>
40:
41: static char cbuf[26];
42: static int dmsize[12] =
43: {
44: 31,
45: 28,
46: 31,
47: 30,
48: 31,
49: 30,
50: 31,
51: 31,
52: 30,
53: 31,
54: 30,
55: 31
56: };
57:
58: /*
59: * The following table is used for 1974 and 1975 and
60: * gives the day number of the first day after the Sunday of the
61: * change.
62: */
63: static struct {
64: int daylb;
65: int dayle;
66: } daytab[] = {
67: 5, 333, /* 1974: Jan 6 - last Sun. in Nov */
68: 58, 303, /* 1975: Last Sun. in Feb - last Sun in Oct */
69: };
70:
71: struct tm *gmtime();
72: char *ct_numb();
73: struct tm *localtime();
74: char *ctime();
75: char *ct_num();
76: char *asctime();
77:
78: char *
79: ctime(t)
80: long *t;
81: {
82: return(asctime(localtime(t)));
83: }
84:
85: struct tm *
86: localtime(tim)
87: long *tim;
88: {
89: register int dayno;
90: register struct tm *ct;
91: register daylbegin, daylend;
92: long copyt;
93: struct timeb systime;
94:
95: ftime(&systime);
96: copyt = *tim - (long)systime.timezone*60;
97: ct = gmtime(©t);
98: dayno = ct->tm_yday;
99: daylbegin = 119; /* last Sun in Apr */
100: daylend = 303; /* Last Sun in Oct */
101: if (ct->tm_year==74 || ct->tm_year==75) {
102: daylbegin = daytab[ct->tm_year-74].daylb;
103: daylend = daytab[ct->tm_year-74].dayle;
104: }
105: daylbegin = sunday(ct, daylbegin);
106: daylend = sunday(ct, daylend);
107: if (systime.dstflag &&
108: (dayno>daylbegin || (dayno==daylbegin && ct->tm_hour>=2)) &&
109: (dayno<daylend || (dayno==daylend && ct->tm_hour<1))) {
110: copyt += 1*60*60;
111: ct = gmtime(©t);
112: ct->tm_isdst++;
113: }
114: return(ct);
115: }
116:
117: /*
118: * The argument is a 0-origin day number.
119: * The value is the day number of the first
120: * Sunday on or after the day.
121: */
122: static
123: sunday(t, d)
124: register struct tm *t;
125: register int d;
126: {
127: if (d >= 58)
128: d += dysize(t->tm_year) - 365;
129: return(d - (d - t->tm_yday + t->tm_wday + 700) % 7);
130: }
131:
132: struct tm *
133: gmtime(tim)
134: long *tim;
135: {
136: register int d0, d1;
137: long hms, day;
138: register int *tp;
139: static struct tm xtime;
140:
141: /*
142: * break initial number into days
143: */
144: hms = *tim % 86400;
145: day = *tim / 86400;
146: if (hms<0) {
147: hms += 86400;
148: day -= 1;
149: }
150: tp = (int *)&xtime;
151:
152: /*
153: * generate hours:minutes:seconds
154: */
155: *tp++ = hms%60;
156: d1 = hms/60;
157: *tp++ = d1%60;
158: d1 /= 60;
159: *tp++ = d1;
160:
161: /*
162: * day is the day number.
163: * generate day of the week.
164: * The addend is 4 mod 7 (1/1/1970 was Thursday)
165: */
166:
167: xtime.tm_wday = (day+7340036)%7;
168:
169: /*
170: * year number
171: */
172: if (day>=0) for(d1=70; day >= dysize(d1); d1++)
173: day -= dysize(d1);
174: else for (d1=70; day<0; d1--)
175: day += dysize(d1-1);
176: xtime.tm_year = d1;
177: xtime.tm_yday = d0 = day;
178:
179: /*
180: * generate month
181: */
182:
183: if (dysize(d1)==366)
184: dmsize[1] = 29;
185: for(d1=0; d0 >= dmsize[d1]; d1++)
186: d0 -= dmsize[d1];
187: dmsize[1] = 28;
188: *tp++ = d0+1;
189: *tp++ = d1;
190: xtime.tm_isdst = 0;
191: return(&xtime);
192: }
193:
194: char *
195: asctime(t)
196: struct tm *t;
197: {
198: register char *cp, *ncp;
199: register int *tp;
200:
201: cp = cbuf;
202: for (ncp = "Day Mon 00 00:00:00 1900\n"; *cp++ = *ncp++;);
203: ncp = &"SunMonTueWedThuFriSat"[3*t->tm_wday];
204: cp = cbuf;
205: *cp++ = *ncp++;
206: *cp++ = *ncp++;
207: *cp++ = *ncp++;
208: cp++;
209: tp = &t->tm_mon;
210: ncp = &"JanFebMarAprMayJunJulAugSepOctNovDec"[(*tp)*3];
211: *cp++ = *ncp++;
212: *cp++ = *ncp++;
213: *cp++ = *ncp++;
214: cp = ct_numb(cp, *--tp);
215: cp = ct_numb(cp, *--tp+100);
216: cp = ct_numb(cp, *--tp+100);
217: cp = ct_numb(cp, *--tp+100);
218: if (t->tm_year>=100) {
219: cp[1] = '2';
220: cp[2] = '0';
221: }
222: cp += 2;
223: cp = ct_numb(cp, t->tm_year+100);
224: return(cbuf);
225: }
226:
227: dysize(y)
228: {
229: if((y%4) == 0)
230: return(366);
231: return(365);
232: }
233:
234: static char *
235: ct_numb(cp, n)
236: register char *cp;
237: {
238: cp++;
239: if (n>=10)
240: *cp++ = (n/10)%10 + '0';
241: else
242: *cp++ = ' ';
243: *cp++ = n%10 + '0';
244: return(cp);
245: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.