Define _POSIX_THREAD_PRIORITY_SCHEDULING.
[glibc/pb-stable.git] / time / tzset.c
blob6de96762e957735ff385375d4480a918025d72a4
1 /* Copyright (C) 1991-2002, 2003 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library; if not, write to the Free
16 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
17 02111-1307 USA. */
19 #include <ctype.h>
20 #include <errno.h>
21 #include <bits/libc-lock.h>
22 #include <stddef.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <time.h>
29 #define NOID
30 #include <timezone/tzfile.h>
32 char *__tzname[2] = { (char *) "GMT", (char *) "GMT" };
33 int __daylight = 0;
34 long int __timezone = 0L;
36 weak_alias (__tzname, tzname)
37 weak_alias (__daylight, daylight)
38 weak_alias (__timezone, timezone)
40 /* This locks all the state variables in tzfile.c and this file. */
41 __libc_lock_define_initialized (static, tzset_lock)
44 #define min(a, b) ((a) < (b) ? (a) : (b))
45 #define max(a, b) ((a) > (b) ? (a) : (b))
46 #define sign(x) ((x) < 0 ? -1 : 1)
49 /* This structure contains all the information about a
50 timezone given in the POSIX standard TZ envariable. */
51 typedef struct
53 const char *name;
55 /* When to change. */
56 enum { J0, J1, M } type; /* Interpretation of: */
57 unsigned short int m, n, d; /* Month, week, day. */
58 unsigned int secs; /* Time of day. */
60 long int offset; /* Seconds east of GMT (west if < 0). */
62 /* We cache the computed time of change for a
63 given year so we don't have to recompute it. */
64 time_t change; /* When to change to this zone. */
65 int computed_for; /* Year above is computed for. */
66 } tz_rule;
68 /* tz_rules[0] is standard, tz_rules[1] is daylight. */
69 static tz_rule tz_rules[2];
72 static void compute_change __P ((tz_rule *rule, int year)) internal_function;
73 static void tz_compute __P ((const struct tm *tm))
74 internal_function;
75 static void tzset_internal __P ((int always)) internal_function;
77 /* List of buffers containing time zone strings. */
78 struct tzstring_l
80 struct tzstring_l *next;
81 size_t len; /* strlen(data) - doesn't count terminating NUL! */
82 char data[0];
85 static struct tzstring_l *tzstring_list;
87 /* Allocate a permanent home for S. It will never be moved or deallocated,
88 but may share space with other strings.
89 Don't modify the returned string. */
90 char *
91 __tzstring (const char *s)
93 char *p;
94 struct tzstring_l *t, *u, *new;
95 size_t len = strlen(s);
97 /* Walk the list and look for a match. If this string is the same
98 as the end of an already-allocated string, it can share space. */
99 for (u = t = tzstring_list; t; u = t, t = t->next)
100 if (len <= t->len)
102 p = &t->data[t->len - len];
103 if (strcmp (s, p) == 0)
104 return p;
107 /* Not found; allocate a new buffer. */
108 new = malloc (sizeof (struct tzstring_l) + len + 1);
109 if (!new)
110 return NULL;
112 new->next = NULL;
113 new->len = len;
114 strcpy (new->data, s);
116 if (u)
117 u->next = new;
118 else
119 tzstring_list = new;
121 return new->data;
124 /* Maximum length of a timezone name. tzset_internal keeps this up to date
125 (never decreasing it) when ! __use_tzfile.
126 tzfile.c keeps it up to date when __use_tzfile. */
127 size_t __tzname_cur_max;
129 long int
130 __tzname_max ()
132 __libc_lock_lock (tzset_lock);
134 tzset_internal (0);
136 __libc_lock_unlock (tzset_lock);
138 return __tzname_cur_max;
141 static char *old_tz;
143 /* Interpret the TZ envariable. */
144 static void
145 internal_function
146 tzset_internal (always)
147 int always;
149 static int is_initialized;
150 register const char *tz;
151 register size_t l;
152 char *tzbuf;
153 unsigned short int hh, mm, ss;
154 unsigned short int whichrule;
156 if (is_initialized && !always)
157 return;
158 is_initialized = 1;
160 /* Examine the TZ environment variable. */
161 tz = getenv ("TZ");
162 if (tz == NULL)
163 /* No user specification; use the site-wide default. */
164 tz = TZDEFAULT;
165 else if (*tz == '\0')
166 /* User specified the empty string; use UTC explicitly. */
167 tz = "Universal";
169 /* A leading colon means "implementation defined syntax".
170 We ignore the colon and always use the same algorithm:
171 try a data file, and if none exists parse the 1003.1 syntax. */
172 if (tz && *tz == ':')
173 ++tz;
175 /* Check whether the value changes since the last run. */
176 if (old_tz != NULL && tz != NULL && strcmp (tz, old_tz) == 0)
177 /* No change, simply return. */
178 return;
180 tz_rules[0].name = NULL;
181 tz_rules[1].name = NULL;
183 /* Save the value of `tz'. */
184 if (old_tz != NULL)
185 free (old_tz);
186 old_tz = tz ? __strdup (tz) : NULL;
188 /* Try to read a data file. */
189 __tzfile_read (tz, 0, NULL);
190 if (__use_tzfile)
191 return;
193 /* No data file found. Default to UTC if nothing specified. */
195 if (tz == NULL || *tz == '\0'
196 || (TZDEFAULT != NULL && strcmp (tz, TZDEFAULT) == 0))
198 tz_rules[0].name = tz_rules[1].name = "UTC";
199 tz_rules[0].type = tz_rules[1].type = J0;
200 tz_rules[0].m = tz_rules[0].n = tz_rules[0].d = 0;
201 tz_rules[1].m = tz_rules[1].n = tz_rules[1].d = 0;
202 tz_rules[0].secs = tz_rules[1].secs = 0;
203 tz_rules[0].offset = tz_rules[1].offset = 0L;
204 tz_rules[0].change = tz_rules[1].change = (time_t) -1;
205 tz_rules[0].computed_for = tz_rules[1].computed_for = 0;
206 goto out;
209 /* Clear out old state and reset to unnamed UTC. */
210 memset (tz_rules, 0, sizeof tz_rules);
211 tz_rules[0].name = tz_rules[1].name = "";
213 /* Get the standard timezone name. */
214 tzbuf = strdupa (tz);
216 if (sscanf (tz, "%[^0-9,+-]", tzbuf) != 1 ||
217 (l = strlen (tzbuf)) < 3)
218 goto out;
220 tz_rules[0].name = __tzstring (tzbuf);
222 tz += l;
224 /* Figure out the standard offset from UTC. */
225 if (*tz == '\0' || (*tz != '+' && *tz != '-' && !isdigit (*tz)))
226 goto out;
228 if (*tz == '-' || *tz == '+')
229 tz_rules[0].offset = *tz++ == '-' ? 1L : -1L;
230 else
231 tz_rules[0].offset = -1L;
232 switch (sscanf (tz, "%hu:%hu:%hu", &hh, &mm, &ss))
234 default:
235 goto out;
236 case 1:
237 mm = 0;
238 case 2:
239 ss = 0;
240 case 3:
241 break;
243 tz_rules[0].offset *= (min (ss, 59) + (min (mm, 59) * 60) +
244 (min (hh, 23) * 60 * 60));
246 for (l = 0; l < 3; ++l)
248 while (isdigit(*tz))
249 ++tz;
250 if (l < 2 && *tz == ':')
251 ++tz;
254 /* Get the DST timezone name (if any). */
255 if (*tz != '\0')
257 char *n = tzbuf + strlen (tzbuf) + 1;
258 if (sscanf (tz, "%[^0-9,+-]", n) != 1 ||
259 (l = strlen (n)) < 3)
260 goto done_names; /* Punt on name, set up the offsets. */
262 tz_rules[1].name = __tzstring (n);
264 tz += l;
266 /* Figure out the DST offset from GMT. */
267 if (*tz == '-' || *tz == '+')
268 tz_rules[1].offset = *tz++ == '-' ? 1L : -1L;
269 else
270 tz_rules[1].offset = -1L;
272 switch (sscanf (tz, "%hu:%hu:%hu", &hh, &mm, &ss))
274 default:
275 /* Default to one hour later than standard time. */
276 tz_rules[1].offset = tz_rules[0].offset + (60 * 60);
277 break;
279 case 1:
280 mm = 0;
281 case 2:
282 ss = 0;
283 case 3:
284 tz_rules[1].offset *= (min (ss, 59) + (min (mm, 59) * 60) +
285 (min (hh, 23) * (60 * 60)));
286 break;
288 for (l = 0; l < 3; ++l)
290 while (isdigit (*tz))
291 ++tz;
292 if (l < 2 && *tz == ':')
293 ++tz;
295 if (*tz == '\0' || (tz[0] == ',' && tz[1] == '\0'))
297 /* There is no rule. See if there is a default rule file. */
298 __tzfile_default (tz_rules[0].name, tz_rules[1].name,
299 tz_rules[0].offset, tz_rules[1].offset);
300 if (__use_tzfile)
302 free (old_tz);
303 old_tz = NULL;
304 return;
308 else
310 /* There is no DST. */
311 tz_rules[1].name = tz_rules[0].name;
312 tz_rules[1].offset = tz_rules[0].offset;
313 goto out;
316 done_names:
317 /* Figure out the standard <-> DST rules. */
318 for (whichrule = 0; whichrule < 2; ++whichrule)
320 register tz_rule *tzr = &tz_rules[whichrule];
322 /* Ignore comma to support string following the incorrect
323 specification in early POSIX.1 printings. */
324 tz += *tz == ',';
326 /* Get the date of the change. */
327 if (*tz == 'J' || isdigit (*tz))
329 char *end;
330 tzr->type = *tz == 'J' ? J1 : J0;
331 if (tzr->type == J1 && !isdigit (*++tz))
332 goto out;
333 tzr->d = (unsigned short int) strtoul (tz, &end, 10);
334 if (end == tz || tzr->d > 365)
335 goto out;
336 else if (tzr->type == J1 && tzr->d == 0)
337 goto out;
338 tz = end;
340 else if (*tz == 'M')
342 int n;
343 tzr->type = M;
344 if (sscanf (tz, "M%hu.%hu.%hu%n",
345 &tzr->m, &tzr->n, &tzr->d, &n) != 3 ||
346 tzr->m < 1 || tzr->m > 12 ||
347 tzr->n < 1 || tzr->n > 5 || tzr->d > 6)
348 goto out;
349 tz += n;
351 else if (*tz == '\0')
353 /* United States Federal Law, the equivalent of "M4.1.0,M10.5.0". */
354 tzr->type = M;
355 if (tzr == &tz_rules[0])
357 tzr->m = 4;
358 tzr->n = 1;
359 tzr->d = 0;
361 else
363 tzr->m = 10;
364 tzr->n = 5;
365 tzr->d = 0;
368 else
369 goto out;
371 if (*tz != '\0' && *tz != '/' && *tz != ',')
372 goto out;
373 else if (*tz == '/')
375 /* Get the time of day of the change. */
376 ++tz;
377 if (*tz == '\0')
378 goto out;
379 switch (sscanf (tz, "%hu:%hu:%hu", &hh, &mm, &ss))
381 default:
382 hh = 2; /* Default to 2:00 AM. */
383 case 1:
384 mm = 0;
385 case 2:
386 ss = 0;
387 case 3:
388 break;
390 for (l = 0; l < 3; ++l)
392 while (isdigit (*tz))
393 ++tz;
394 if (l < 2 && *tz == ':')
395 ++tz;
397 tzr->secs = (hh * 60 * 60) + (mm * 60) + ss;
399 else
400 /* Default to 2:00 AM. */
401 tzr->secs = 2 * 60 * 60;
403 tzr->computed_for = -1;
406 out:
407 __daylight = tz_rules[0].offset != tz_rules[1].offset;
408 __timezone = -tz_rules[0].offset;
409 __tzname[0] = (char *) tz_rules[0].name;
410 __tzname[1] = (char *) tz_rules[1].name;
413 /* Keep __tzname_cur_max up to date. */
414 size_t len0 = strlen (__tzname[0]);
415 size_t len1 = strlen (__tzname[1]);
416 if (len0 > __tzname_cur_max)
417 __tzname_cur_max = len0;
418 if (len1 > __tzname_cur_max)
419 __tzname_cur_max = len1;
423 /* Figure out the exact time (as a time_t) in YEAR
424 when the change described by RULE will occur and
425 put it in RULE->change, saving YEAR in RULE->computed_for. */
426 static void
427 internal_function
428 compute_change (rule, year)
429 tz_rule *rule;
430 int year;
432 register time_t t;
434 if (year != -1 && rule->computed_for == year)
435 /* Operations on times in 2 BC will be slower. Oh well. */
436 return;
438 /* First set T to January 1st, 0:00:00 GMT in YEAR. */
439 if (year > 1970)
440 t = ((year - 1970) * 365
441 + /* Compute the number of leapdays between 1970 and YEAR
442 (exclusive). There is a leapday every 4th year ... */
443 + ((year - 1) / 4 - 1970 / 4)
444 /* ... except every 100th year ... */
445 - ((year - 1) / 100 - 1970 / 100)
446 /* ... but still every 400th year. */
447 + ((year - 1) / 400 - 1970 / 400)) * SECSPERDAY;
448 else
449 t = 0;
451 switch (rule->type)
453 case J1:
454 /* Jn - Julian day, 1 == January 1, 60 == March 1 even in leap years.
455 In non-leap years, or if the day number is 59 or less, just
456 add SECSPERDAY times the day number-1 to the time of
457 January 1, midnight, to get the day. */
458 t += (rule->d - 1) * SECSPERDAY;
459 if (rule->d >= 60 && __isleap (year))
460 t += SECSPERDAY;
461 break;
463 case J0:
464 /* n - Day of year.
465 Just add SECSPERDAY times the day number to the time of Jan 1st. */
466 t += rule->d * SECSPERDAY;
467 break;
469 case M:
470 /* Mm.n.d - Nth "Dth day" of month M. */
472 unsigned int i;
473 int d, m1, yy0, yy1, yy2, dow;
474 const unsigned short int *myday =
475 &__mon_yday[__isleap (year)][rule->m];
477 /* First add SECSPERDAY for each day in months before M. */
478 t += myday[-1] * SECSPERDAY;
480 /* Use Zeller's Congruence to get day-of-week of first day of month. */
481 m1 = (rule->m + 9) % 12 + 1;
482 yy0 = (rule->m <= 2) ? (year - 1) : year;
483 yy1 = yy0 / 100;
484 yy2 = yy0 % 100;
485 dow = ((26 * m1 - 2) / 10 + 1 + yy2 + yy2 / 4 + yy1 / 4 - 2 * yy1) % 7;
486 if (dow < 0)
487 dow += 7;
489 /* DOW is the day-of-week of the first day of the month. Get the
490 day-of-month (zero-origin) of the first DOW day of the month. */
491 d = rule->d - dow;
492 if (d < 0)
493 d += 7;
494 for (i = 1; i < rule->n; ++i)
496 if (d + 7 >= (int) myday[0] - myday[-1])
497 break;
498 d += 7;
501 /* D is the day-of-month (zero-origin) of the day we want. */
502 t += d * SECSPERDAY;
504 break;
507 /* T is now the Epoch-relative time of 0:00:00 GMT on the day we want.
508 Just add the time of day and local offset from GMT, and we're done. */
510 rule->change = t - rule->offset + rule->secs;
511 rule->computed_for = year;
515 /* Figure out the correct timezone for TM and set `__tzname',
516 `__timezone', and `__daylight' accordingly. */
517 static void
518 internal_function
519 tz_compute (tm)
520 const struct tm *tm;
522 compute_change (&tz_rules[0], 1900 + tm->tm_year);
523 compute_change (&tz_rules[1], 1900 + tm->tm_year);
526 /* Reinterpret the TZ environment variable and set `tzname'. */
527 #undef tzset
529 void
530 __tzset (void)
532 __libc_lock_lock (tzset_lock);
534 tzset_internal (1);
536 if (!__use_tzfile)
538 /* Set `tzname'. */
539 __tzname[0] = (char *) tz_rules[0].name;
540 __tzname[1] = (char *) tz_rules[1].name;
543 __libc_lock_unlock (tzset_lock);
545 weak_alias (__tzset, tzset)
547 /* Return the `struct tm' representation of *TIMER in the local timezone.
548 Use local time if USE_LOCALTIME is nonzero, UTC otherwise. */
549 struct tm *
550 __tz_convert (const time_t *timer, int use_localtime, struct tm *tp)
552 long int leap_correction;
553 int leap_extra_secs;
555 if (timer == NULL)
557 __set_errno (EINVAL);
558 return NULL;
561 __libc_lock_lock (tzset_lock);
563 /* Update internal database according to current TZ setting.
564 POSIX.1 8.3.7.2 says that localtime_r is not required to set tzname.
565 This is a good idea since this allows at least a bit more parallelism.
566 By analogy we apply the same rule to gmtime_r. */
567 tzset_internal (tp == &_tmbuf);
569 if (__use_tzfile)
570 __tzfile_compute (*timer, use_localtime, &leap_correction,
571 &leap_extra_secs, tp);
572 else
574 if (! __offtime (timer, 0, tp))
575 tp = NULL;
576 else
577 tz_compute (tp);
578 leap_correction = 0L;
579 leap_extra_secs = 0;
582 if (tp)
584 if (use_localtime)
586 if (!__use_tzfile)
588 int isdst;
590 /* We have to distinguish between northern and southern
591 hemisphere. For the latter the daylight saving time
592 ends in the next year. */
593 if (__builtin_expect (tz_rules[0].change
594 > tz_rules[1].change, 0))
595 isdst = (*timer < tz_rules[1].change
596 || *timer >= tz_rules[0].change);
597 else
598 isdst = (*timer >= tz_rules[0].change
599 && *timer < tz_rules[1].change);
600 tp->tm_isdst = isdst;
601 tp->tm_zone = __tzname[isdst];
602 tp->tm_gmtoff = tz_rules[isdst].offset;
605 else
607 tp->tm_isdst = 0;
608 tp->tm_zone = "GMT";
609 tp->tm_gmtoff = 0L;
612 if (__offtime (timer, tp->tm_gmtoff - leap_correction, tp))
613 tp->tm_sec += leap_extra_secs;
614 else
615 tp = NULL;
618 __libc_lock_unlock (tzset_lock);
620 return tp;
624 libc_freeres_fn (free_mem)
626 while (tzstring_list != NULL)
628 struct tzstring_l *old = tzstring_list;
630 tzstring_list = tzstring_list->next;
631 free (old);
633 free (old_tz);
634 old_tz = NULL;