← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to gnulib/mktime.c

  • Committer: Monty Taylor
  • Date: 2008-09-16 01:37:05 UTC
  • mto: This revision was merged to the branch mainline in revision 391.
  • Revision ID: monty@inaugust.com-20080916013705-772d1t7rh9ah9j1x
Moved more functions into drizzle.c as part of the split of code.
Added accessor function for drizzle_port.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gnulib/mktime.c
1
 
/* Convert a `struct tm' to a time_t value.
2
 
   Copyright (C) 1993-1999, 2002-2005, 2006, 2007 Free Software Foundation, Inc.
3
 
   This file is part of the GNU C Library.
4
 
   Contributed by Paul Eggert <eggert@twinsun.com>.
5
 
 
6
 
   This program is free software; you can redistribute it and/or modify
7
 
   it under the terms of the GNU Lesser General Public License as published by
8
 
   the Free Software Foundation; either version 2, or (at your option)
9
 
   any later version.
10
 
 
11
 
   This program is distributed in the hope that it will be useful,
12
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
   GNU Lesser General Public License for more details.
15
 
 
16
 
   You should have received a copy of the GNU Lesser General Public License along
17
 
   with this program; if not, write to the Free Software Foundation,
18
 
   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
19
 
 
20
 
/* Define this to have a standalone program to test this implementation of
21
 
   mktime.  */
22
 
/* #define DEBUG 1 */
23
 
 
24
 
#ifndef _LIBC
25
 
# include <config.h>
26
 
#endif
27
 
 
28
 
/* Assume that leap seconds are possible, unless told otherwise.
29
 
   If the host has a `zic' command with a `-L leapsecondfilename' option,
30
 
   then it supports leap seconds; otherwise it probably doesn't.  */
31
 
#ifndef LEAP_SECONDS_POSSIBLE
32
 
# define LEAP_SECONDS_POSSIBLE 1
33
 
#endif
34
 
 
35
 
#include <time.h>
36
 
 
37
 
#include <limits.h>
38
 
 
39
 
#include <string.h>             /* For the real memcpy prototype.  */
40
 
 
41
 
#if DEBUG
42
 
# include <stdio.h>
43
 
# include <stdlib.h>
44
 
/* Make it work even if the system's libc has its own mktime routine.  */
45
 
# define mktime my_mktime
46
 
#endif /* DEBUG */
47
 
 
48
 
/* Shift A right by B bits portably, by dividing A by 2**B and
49
 
   truncating towards minus infinity.  A and B should be free of side
50
 
   effects, and B should be in the range 0 <= B <= INT_BITS - 2, where
51
 
   INT_BITS is the number of useful bits in an int.  GNU code can
52
 
   assume that INT_BITS is at least 32.
53
 
 
54
 
   ISO C99 says that A >> B is implementation-defined if A < 0.  Some
55
 
   implementations (e.g., UNICOS 9.0 on a Cray Y-MP EL) don't shift
56
 
   right in the usual way when A < 0, so SHR falls back on division if
57
 
   ordinary A >> B doesn't seem to be the usual signed shift.  */
58
 
#define SHR(a, b)       \
59
 
  (-1 >> 1 == -1        \
60
 
   ? (a) >> (b)         \
61
 
   : (a) / (1 << (b)) - ((a) % (1 << (b)) < 0))
62
 
 
63
 
/* The extra casts in the following macros work around compiler bugs,
64
 
   e.g., in Cray C 5.0.3.0.  */
65
 
 
66
 
/* True if the arithmetic type T is an integer type.  bool counts as
67
 
   an integer.  */
68
 
#define TYPE_IS_INTEGER(t) ((t) 1.5 == 1)
69
 
 
70
 
/* True if negative values of the signed integer type T use two's
71
 
   complement, ones' complement, or signed magnitude representation,
72
 
   respectively.  Much GNU code assumes two's complement, but some
73
 
   people like to be portable to all possible C hosts.  */
74
 
#define TYPE_TWOS_COMPLEMENT(t) ((t) ~ (t) 0 == (t) -1)
75
 
#define TYPE_ONES_COMPLEMENT(t) ((t) ~ (t) 0 == 0)
76
 
#define TYPE_SIGNED_MAGNITUDE(t) ((t) ~ (t) 0 < (t) -1)
77
 
 
78
 
/* True if the arithmetic type T is signed.  */
79
 
#define TYPE_SIGNED(t) (! ((t) 0 < (t) -1))
80
 
 
81
 
/* The maximum and minimum values for the integer type T.  These
82
 
   macros have undefined behavior if T is signed and has padding bits.
83
 
   If this is a problem for you, please let us know how to fix it for
84
 
   your host.  */
85
 
#define TYPE_MINIMUM(t) \
86
 
  ((t) (! TYPE_SIGNED (t) \
87
 
        ? (t) 0 \
88
 
        : TYPE_SIGNED_MAGNITUDE (t) \
89
 
        ? ~ (t) 0 \
90
 
        : ~ (t) 0 << (sizeof (t) * CHAR_BIT - 1)))
91
 
#define TYPE_MAXIMUM(t) \
92
 
  ((t) (! TYPE_SIGNED (t) \
93
 
        ? (t) -1 \
94
 
        : ~ (~ (t) 0 << (sizeof (t) * CHAR_BIT - 1))))
95
 
 
96
 
#ifndef TIME_T_MIN
97
 
# define TIME_T_MIN TYPE_MINIMUM (time_t)
98
 
#endif
99
 
#ifndef TIME_T_MAX
100
 
# define TIME_T_MAX TYPE_MAXIMUM (time_t)
101
 
#endif
102
 
#define TIME_T_MIDPOINT (SHR (TIME_T_MIN + TIME_T_MAX, 1) + 1)
103
 
 
104
 
/* Verify a requirement at compile-time (unlike assert, which is runtime).  */
105
 
#define verify(name, assertion) struct name { char a[(assertion) ? 1 : -1]; }
106
 
 
107
 
verify (time_t_is_integer, TYPE_IS_INTEGER (time_t));
108
 
verify (twos_complement_arithmetic, TYPE_TWOS_COMPLEMENT (int));
109
 
/* The code also assumes that signed integer overflow silently wraps
110
 
   around, but this assumption can't be stated without causing a
111
 
   diagnostic on some hosts.  */
112
 
 
113
 
#define EPOCH_YEAR 1970
114
 
#define TM_YEAR_BASE 1900
115
 
verify (base_year_is_a_multiple_of_100, TM_YEAR_BASE % 100 == 0);
116
 
 
117
 
/* Return 1 if YEAR + TM_YEAR_BASE is a leap year.  */
118
 
static inline int
119
 
leapyear (long int year)
120
 
{
121
 
  /* Don't add YEAR to TM_YEAR_BASE, as that might overflow.
122
 
     Also, work even if YEAR is negative.  */
123
 
  return
124
 
    ((year & 3) == 0
125
 
     && (year % 100 != 0
126
 
         || ((year / 100) & 3) == (- (TM_YEAR_BASE / 100) & 3)));
127
 
}
128
 
 
129
 
/* How many days come before each month (0-12).  */
130
 
#ifndef _LIBC
131
 
static
132
 
#endif
133
 
const unsigned short int __mon_yday[2][13] =
134
 
  {
135
 
    /* Normal years.  */
136
 
    { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
137
 
    /* Leap years.  */
138
 
    { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
139
 
  };
140
 
 
141
 
 
142
 
#ifndef _LIBC
143
 
/* Portable standalone applications should supply a <time.h> that
144
 
   declares a POSIX-compliant localtime_r, for the benefit of older
145
 
   implementations that lack localtime_r or have a nonstandard one.
146
 
   See the gnulib time_r module for one way to implement this.  */
147
 
# undef __localtime_r
148
 
# define __localtime_r localtime_r
149
 
# define __mktime_internal mktime_internal
150
 
#endif
151
 
 
152
 
/* Return an integer value measuring (YEAR1-YDAY1 HOUR1:MIN1:SEC1) -
153
 
   (YEAR0-YDAY0 HOUR0:MIN0:SEC0) in seconds, assuming that the clocks
154
 
   were not adjusted between the time stamps.
155
 
 
156
 
   The YEAR values uses the same numbering as TP->tm_year.  Values
157
 
   need not be in the usual range.  However, YEAR1 must not be less
158
 
   than 2 * INT_MIN or greater than 2 * INT_MAX.
159
 
 
160
 
   The result may overflow.  It is the caller's responsibility to
161
 
   detect overflow.  */
162
 
 
163
 
static inline time_t
164
 
ydhms_diff (long int year1, long int yday1, int hour1, int min1, int sec1,
165
 
            int year0, int yday0, int hour0, int min0, int sec0)
166
 
{
167
 
  verify (C99_integer_division, -1 / 2 == 0);
168
 
  verify (long_int_year_and_yday_are_wide_enough,
169
 
          INT_MAX <= LONG_MAX / 2 || TIME_T_MAX <= UINT_MAX);
170
 
 
171
 
  /* Compute intervening leap days correctly even if year is negative.
172
 
     Take care to avoid integer overflow here.  */
173
 
  int a4 = SHR (year1, 2) + SHR (TM_YEAR_BASE, 2) - ! (year1 & 3);
174
 
  int b4 = SHR (year0, 2) + SHR (TM_YEAR_BASE, 2) - ! (year0 & 3);
175
 
  int a100 = a4 / 25 - (a4 % 25 < 0);
176
 
  int b100 = b4 / 25 - (b4 % 25 < 0);
177
 
  int a400 = SHR (a100, 2);
178
 
  int b400 = SHR (b100, 2);
179
 
  int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
180
 
 
181
 
  /* Compute the desired time in time_t precision.  Overflow might
182
 
     occur here.  */
183
 
  time_t tyear1 = year1;
184
 
  time_t years = tyear1 - year0;
185
 
  time_t days = 365 * years + yday1 - yday0 + intervening_leap_days;
186
 
  time_t hours = 24 * days + hour1 - hour0;
187
 
  time_t minutes = 60 * hours + min1 - min0;
188
 
  time_t seconds = 60 * minutes + sec1 - sec0;
189
 
  return seconds;
190
 
}
191
 
 
192
 
 
193
 
/* Return a time_t value corresponding to (YEAR-YDAY HOUR:MIN:SEC),
194
 
   assuming that *T corresponds to *TP and that no clock adjustments
195
 
   occurred between *TP and the desired time.
196
 
   If TP is null, return a value not equal to *T; this avoids false matches.
197
 
   If overflow occurs, yield the minimal or maximal value, except do not
198
 
   yield a value equal to *T.  */
199
 
static time_t
200
 
guess_time_tm (long int year, long int yday, int hour, int min, int sec,
201
 
               const time_t *t, const struct tm *tp)
202
 
{
203
 
  if (tp)
204
 
    {
205
 
      time_t d = ydhms_diff (year, yday, hour, min, sec,
206
 
                             tp->tm_year, tp->tm_yday,
207
 
                             tp->tm_hour, tp->tm_min, tp->tm_sec);
208
 
      time_t t1 = *t + d;
209
 
      if ((t1 < *t) == (TYPE_SIGNED (time_t) ? d < 0 : TIME_T_MAX / 2 < d))
210
 
        return t1;
211
 
    }
212
 
 
213
 
  /* Overflow occurred one way or another.  Return the nearest result
214
 
     that is actually in range, except don't report a zero difference
215
 
     if the actual difference is nonzero, as that would cause a false
216
 
     match; and don't oscillate between two values, as that would
217
 
     confuse the spring-forward gap detector.  */
218
 
  return (*t < TIME_T_MIDPOINT
219
 
          ? (*t <= TIME_T_MIN + 1 ? *t + 1 : TIME_T_MIN)
220
 
          : (TIME_T_MAX - 1 <= *t ? *t - 1 : TIME_T_MAX));
221
 
}
222
 
 
223
 
/* Use CONVERT to convert *T to a broken down time in *TP.
224
 
   If *T is out of range for conversion, adjust it so that
225
 
   it is the nearest in-range value and then convert that.  */
226
 
static struct tm *
227
 
ranged_convert (struct tm *(*convert) (const time_t *, struct tm *),
228
 
                time_t *t, struct tm *tp)
229
 
{
230
 
  struct tm *r = convert (t, tp);
231
 
 
232
 
  if (!r && *t)
233
 
    {
234
 
      time_t bad = *t;
235
 
      time_t ok = 0;
236
 
 
237
 
      /* BAD is a known unconvertible time_t, and OK is a known good one.
238
 
         Use binary search to narrow the range between BAD and OK until
239
 
         they differ by 1.  */
240
 
      while (bad != ok + (bad < 0 ? -1 : 1))
241
 
        {
242
 
          time_t mid = *t = (bad < 0
243
 
                             ? bad + ((ok - bad) >> 1)
244
 
                             : ok + ((bad - ok) >> 1));
245
 
          r = convert (t, tp);
246
 
          if (r)
247
 
            ok = mid;
248
 
          else
249
 
            bad = mid;
250
 
        }
251
 
 
252
 
      if (!r && ok)
253
 
        {
254
 
          /* The last conversion attempt failed;
255
 
             revert to the most recent successful attempt.  */
256
 
          *t = ok;
257
 
          r = convert (t, tp);
258
 
        }
259
 
    }
260
 
 
261
 
  return r;
262
 
}
263
 
 
264
 
 
265
 
/* Convert *TP to a time_t value, inverting
266
 
   the monotonic and mostly-unit-linear conversion function CONVERT.
267
 
   Use *OFFSET to keep track of a guess at the offset of the result,
268
 
   compared to what the result would be for UTC without leap seconds.
269
 
   If *OFFSET's guess is correct, only one CONVERT call is needed.
270
 
   This function is external because it is used also by timegm.c.  */
271
 
time_t
272
 
__mktime_internal (struct tm *tp,
273
 
                   struct tm *(*convert) (const time_t *, struct tm *),
274
 
                   time_t *offset)
275
 
{
276
 
  time_t t, gt, t0, t1, t2;
277
 
  struct tm tm;
278
 
 
279
 
  /* The maximum number of probes (calls to CONVERT) should be enough
280
 
     to handle any combinations of time zone rule changes, solar time,
281
 
     leap seconds, and oscillations around a spring-forward gap.
282
 
     POSIX.1 prohibits leap seconds, but some hosts have them anyway.  */
283
 
  int remaining_probes = 6;
284
 
 
285
 
  /* Time requested.  Copy it in case CONVERT modifies *TP; this can
286
 
     occur if TP is localtime's returned value and CONVERT is localtime.  */
287
 
  int sec = tp->tm_sec;
288
 
  int min = tp->tm_min;
289
 
  int hour = tp->tm_hour;
290
 
  int mday = tp->tm_mday;
291
 
  int mon = tp->tm_mon;
292
 
  int year_requested = tp->tm_year;
293
 
  int isdst = tp->tm_isdst;
294
 
 
295
 
  /* 1 if the previous probe was DST.  */
296
 
  int dst2;
297
 
 
298
 
  /* Ensure that mon is in range, and set year accordingly.  */
299
 
  int mon_remainder = mon % 12;
300
 
  int negative_mon_remainder = mon_remainder < 0;
301
 
  int mon_years = mon / 12 - negative_mon_remainder;
302
 
  long int lyear_requested = year_requested;
303
 
  long int year = lyear_requested + mon_years;
304
 
 
305
 
  /* The other values need not be in range:
306
 
     the remaining code handles minor overflows correctly,
307
 
     assuming int and time_t arithmetic wraps around.
308
 
     Major overflows are caught at the end.  */
309
 
 
310
 
  /* Calculate day of year from year, month, and day of month.
311
 
     The result need not be in range.  */
312
 
  int mon_yday = ((__mon_yday[leapyear (year)]
313
 
                   [mon_remainder + 12 * negative_mon_remainder])
314
 
                  - 1);
315
 
  long int lmday = mday;
316
 
  long int yday = mon_yday + lmday;
317
 
 
318
 
  time_t guessed_offset = *offset;
319
 
 
320
 
  int sec_requested = sec;
321
 
 
322
 
  if (LEAP_SECONDS_POSSIBLE)
323
 
    {
324
 
      /* Handle out-of-range seconds specially,
325
 
         since ydhms_tm_diff assumes every minute has 60 seconds.  */
326
 
      if (sec < 0)
327
 
        sec = 0;
328
 
      if (59 < sec)
329
 
        sec = 59;
330
 
    }
331
 
 
332
 
  /* Invert CONVERT by probing.  First assume the same offset as last
333
 
     time.  */
334
 
 
335
 
  t0 = ydhms_diff (year, yday, hour, min, sec,
336
 
                   EPOCH_YEAR - TM_YEAR_BASE, 0, 0, 0, - guessed_offset);
337
 
 
338
 
  if (TIME_T_MAX / INT_MAX / 366 / 24 / 60 / 60 < 3)
339
 
    {
340
 
      /* time_t isn't large enough to rule out overflows, so check
341
 
         for major overflows.  A gross check suffices, since if t0
342
 
         has overflowed, it is off by a multiple of TIME_T_MAX -
343
 
         TIME_T_MIN + 1.  So ignore any component of the difference
344
 
         that is bounded by a small value.  */
345
 
 
346
 
      /* Approximate log base 2 of the number of time units per
347
 
         biennium.  A biennium is 2 years; use this unit instead of
348
 
         years to avoid integer overflow.  For example, 2 average
349
 
         Gregorian years are 2 * 365.2425 * 24 * 60 * 60 seconds,
350
 
         which is 63113904 seconds, and rint (log2 (63113904)) is
351
 
         26.  */
352
 
      int ALOG2_SECONDS_PER_BIENNIUM = 26;
353
 
      int ALOG2_MINUTES_PER_BIENNIUM = 20;
354
 
      int ALOG2_HOURS_PER_BIENNIUM = 14;
355
 
      int ALOG2_DAYS_PER_BIENNIUM = 10;
356
 
      int LOG2_YEARS_PER_BIENNIUM = 1;
357
 
 
358
 
      int approx_requested_biennia =
359
 
        (SHR (year_requested, LOG2_YEARS_PER_BIENNIUM)
360
 
         - SHR (EPOCH_YEAR - TM_YEAR_BASE, LOG2_YEARS_PER_BIENNIUM)
361
 
         + SHR (mday, ALOG2_DAYS_PER_BIENNIUM)
362
 
         + SHR (hour, ALOG2_HOURS_PER_BIENNIUM)
363
 
         + SHR (min, ALOG2_MINUTES_PER_BIENNIUM)
364
 
         + (LEAP_SECONDS_POSSIBLE
365
 
            ? 0
366
 
            : SHR (sec, ALOG2_SECONDS_PER_BIENNIUM)));
367
 
 
368
 
      int approx_biennia = SHR (t0, ALOG2_SECONDS_PER_BIENNIUM);
369
 
      int diff = approx_biennia - approx_requested_biennia;
370
 
      int abs_diff = diff < 0 ? - diff : diff;
371
 
 
372
 
      /* IRIX 4.0.5 cc miscaculates TIME_T_MIN / 3: it erroneously
373
 
         gives a positive value of 715827882.  Setting a variable
374
 
         first then doing math on it seems to work.
375
 
         (ghazi@caip.rutgers.edu) */
376
 
      time_t time_t_max = TIME_T_MAX;
377
 
      time_t time_t_min = TIME_T_MIN;
378
 
      time_t overflow_threshold =
379
 
        (time_t_max / 3 - time_t_min / 3) >> ALOG2_SECONDS_PER_BIENNIUM;
380
 
 
381
 
      if (overflow_threshold < abs_diff)
382
 
        {
383
 
          /* Overflow occurred.  Try repairing it; this might work if
384
 
             the time zone offset is enough to undo the overflow.  */
385
 
          time_t repaired_t0 = -1 - t0;
386
 
          approx_biennia = SHR (repaired_t0, ALOG2_SECONDS_PER_BIENNIUM);
387
 
          diff = approx_biennia - approx_requested_biennia;
388
 
          abs_diff = diff < 0 ? - diff : diff;
389
 
          if (overflow_threshold < abs_diff)
390
 
            return -1;
391
 
          guessed_offset += repaired_t0 - t0;
392
 
          t0 = repaired_t0;
393
 
        }
394
 
    }
395
 
 
396
 
  /* Repeatedly use the error to improve the guess.  */
397
 
 
398
 
  for (t = t1 = t2 = t0, dst2 = 0;
399
 
       (gt = guess_time_tm (year, yday, hour, min, sec, &t,
400
 
                            ranged_convert (convert, &t, &tm)),
401
 
        t != gt);
402
 
       t1 = t2, t2 = t, t = gt, dst2 = tm.tm_isdst != 0)
403
 
    if (t == t1 && t != t2
404
 
        && (tm.tm_isdst < 0
405
 
            || (isdst < 0
406
 
                ? dst2 <= (tm.tm_isdst != 0)
407
 
                : (isdst != 0) != (tm.tm_isdst != 0))))
408
 
      /* We can't possibly find a match, as we are oscillating
409
 
         between two values.  The requested time probably falls
410
 
         within a spring-forward gap of size GT - T.  Follow the common
411
 
         practice in this case, which is to return a time that is GT - T
412
 
         away from the requested time, preferring a time whose
413
 
         tm_isdst differs from the requested value.  (If no tm_isdst
414
 
         was requested and only one of the two values has a nonzero
415
 
         tm_isdst, prefer that value.)  In practice, this is more
416
 
         useful than returning -1.  */
417
 
      goto offset_found;
418
 
    else if (--remaining_probes == 0)
419
 
      return -1;
420
 
 
421
 
  /* We have a match.  Check whether tm.tm_isdst has the requested
422
 
     value, if any.  */
423
 
  if (isdst != tm.tm_isdst && 0 <= isdst && 0 <= tm.tm_isdst)
424
 
    {
425
 
      /* tm.tm_isdst has the wrong value.  Look for a neighboring
426
 
         time with the right value, and use its UTC offset.
427
 
 
428
 
         Heuristic: probe the adjacent timestamps in both directions,
429
 
         looking for the desired isdst.  This should work for all real
430
 
         time zone histories in the tz database.  */
431
 
 
432
 
      /* Distance between probes when looking for a DST boundary.  In
433
 
         tzdata2003a, the shortest period of DST is 601200 seconds
434
 
         (e.g., America/Recife starting 2000-10-08 01:00), and the
435
 
         shortest period of non-DST surrounded by DST is 694800
436
 
         seconds (Africa/Tunis starting 1943-04-17 01:00).  Use the
437
 
         minimum of these two values, so we don't miss these short
438
 
         periods when probing.  */
439
 
      int stride = 601200;
440
 
 
441
 
      /* The longest period of DST in tzdata2003a is 536454000 seconds
442
 
         (e.g., America/Jujuy starting 1946-10-01 01:00).  The longest
443
 
         period of non-DST is much longer, but it makes no real sense
444
 
         to search for more than a year of non-DST, so use the DST
445
 
         max.  */
446
 
      int duration_max = 536454000;
447
 
 
448
 
      /* Search in both directions, so the maximum distance is half
449
 
         the duration; add the stride to avoid off-by-1 problems.  */
450
 
      int delta_bound = duration_max / 2 + stride;
451
 
 
452
 
      int delta, direction;
453
 
 
454
 
      for (delta = stride; delta < delta_bound; delta += stride)
455
 
        for (direction = -1; direction <= 1; direction += 2)
456
 
          {
457
 
            time_t ot = t + delta * direction;
458
 
            if ((ot < t) == (direction < 0))
459
 
              {
460
 
                struct tm otm;
461
 
                ranged_convert (convert, &ot, &otm);
462
 
                if (otm.tm_isdst == isdst)
463
 
                  {
464
 
                    /* We found the desired tm_isdst.
465
 
                       Extrapolate back to the desired time.  */
466
 
                    t = guess_time_tm (year, yday, hour, min, sec, &ot, &otm);
467
 
                    ranged_convert (convert, &t, &tm);
468
 
                    goto offset_found;
469
 
                  }
470
 
              }
471
 
          }
472
 
    }
473
 
 
474
 
 offset_found:
475
 
  *offset = guessed_offset + t - t0;
476
 
 
477
 
  if (LEAP_SECONDS_POSSIBLE && sec_requested != tm.tm_sec)
478
 
    {
479
 
      /* Adjust time to reflect the tm_sec requested, not the normalized value.
480
 
         Also, repair any damage from a false match due to a leap second.  */
481
 
      int sec_adjustment = (sec == 0 && tm.tm_sec == 60) - sec;
482
 
      t1 = t + sec_requested;
483
 
      t2 = t1 + sec_adjustment;
484
 
      if (((t1 < t) != (sec_requested < 0))
485
 
          | ((t2 < t1) != (sec_adjustment < 0))
486
 
          | ! convert (&t2, &tm))
487
 
        return -1;
488
 
      t = t2;
489
 
    }
490
 
 
491
 
  *tp = tm;
492
 
  return t;
493
 
}
494
 
 
495
 
 
496
 
/* FIXME: This should use a signed type wide enough to hold any UTC
497
 
   offset in seconds.  'int' should be good enough for GNU code.  We
498
 
   can't fix this unilaterally though, as other modules invoke
499
 
   __mktime_internal.  */
500
 
static time_t localtime_offset;
501
 
 
502
 
/* Convert *TP to a time_t value.  */
503
 
time_t
504
 
mktime (struct tm *tp)
505
 
{
506
 
#ifdef _LIBC
507
 
  /* POSIX.1 8.1.1 requires that whenever mktime() is called, the
508
 
     time zone names contained in the external variable `tzname' shall
509
 
     be set as if the tzset() function had been called.  */
510
 
  __tzset ();
511
 
#endif
512
 
 
513
 
  return __mktime_internal (tp, __localtime_r, &localtime_offset);
514
 
}
515
 
 
516
 
#ifdef weak_alias
517
 
weak_alias (mktime, timelocal)
518
 
#endif
519
 
 
520
 
#ifdef _LIBC
521
 
libc_hidden_def (mktime)
522
 
libc_hidden_weak (timelocal)
523
 
#endif
524
 
 
525
 
#if DEBUG
526
 
 
527
 
static int
528
 
not_equal_tm (const struct tm *a, const struct tm *b)
529
 
{
530
 
  return ((a->tm_sec ^ b->tm_sec)
531
 
          | (a->tm_min ^ b->tm_min)
532
 
          | (a->tm_hour ^ b->tm_hour)
533
 
          | (a->tm_mday ^ b->tm_mday)
534
 
          | (a->tm_mon ^ b->tm_mon)
535
 
          | (a->tm_year ^ b->tm_year)
536
 
          | (a->tm_yday ^ b->tm_yday)
537
 
          | (a->tm_isdst ^ b->tm_isdst));
538
 
}
539
 
 
540
 
static void
541
 
print_tm (const struct tm *tp)
542
 
{
543
 
  if (tp)
544
 
    printf ("%04d-%02d-%02d %02d:%02d:%02d yday %03d wday %d isdst %d",
545
 
            tp->tm_year + TM_YEAR_BASE, tp->tm_mon + 1, tp->tm_mday,
546
 
            tp->tm_hour, tp->tm_min, tp->tm_sec,
547
 
            tp->tm_yday, tp->tm_wday, tp->tm_isdst);
548
 
  else
549
 
    printf ("0");
550
 
}
551
 
 
552
 
static int
553
 
check_result (time_t tk, struct tm tmk, time_t tl, const struct tm *lt)
554
 
{
555
 
  if (tk != tl || !lt || not_equal_tm (&tmk, lt))
556
 
    {
557
 
      printf ("mktime (");
558
 
      print_tm (lt);
559
 
      printf (")\nyields (");
560
 
      print_tm (&tmk);
561
 
      printf (") == %ld, should be %ld\n", (long int) tk, (long int) tl);
562
 
      return 1;
563
 
    }
564
 
 
565
 
  return 0;
566
 
}
567
 
 
568
 
int
569
 
main (int argc, char **argv)
570
 
{
571
 
  int status = 0;
572
 
  struct tm tm, tmk, tml;
573
 
  struct tm *lt;
574
 
  time_t tk, tl, tl1;
575
 
  char trailer;
576
 
 
577
 
  if ((argc == 3 || argc == 4)
578
 
      && (sscanf (argv[1], "%d-%d-%d%c",
579
 
                  &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &trailer)
580
 
          == 3)
581
 
      && (sscanf (argv[2], "%d:%d:%d%c",
582
 
                  &tm.tm_hour, &tm.tm_min, &tm.tm_sec, &trailer)
583
 
          == 3))
584
 
    {
585
 
      tm.tm_year -= TM_YEAR_BASE;
586
 
      tm.tm_mon--;
587
 
      tm.tm_isdst = argc == 3 ? -1 : atoi (argv[3]);
588
 
      tmk = tm;
589
 
      tl = mktime (&tmk);
590
 
      lt = localtime (&tl);
591
 
      if (lt)
592
 
        {
593
 
          tml = *lt;
594
 
          lt = &tml;
595
 
        }
596
 
      printf ("mktime returns %ld == ", (long int) tl);
597
 
      print_tm (&tmk);
598
 
      printf ("\n");
599
 
      status = check_result (tl, tmk, tl, lt);
600
 
    }
601
 
  else if (argc == 4 || (argc == 5 && strcmp (argv[4], "-") == 0))
602
 
    {
603
 
      time_t from = atol (argv[1]);
604
 
      time_t by = atol (argv[2]);
605
 
      time_t to = atol (argv[3]);
606
 
 
607
 
      if (argc == 4)
608
 
        for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1)
609
 
          {
610
 
            lt = localtime (&tl);
611
 
            if (lt)
612
 
              {
613
 
                tmk = tml = *lt;
614
 
                tk = mktime (&tmk);
615
 
                status |= check_result (tk, tmk, tl, &tml);
616
 
              }
617
 
            else
618
 
              {
619
 
                printf ("localtime (%ld) yields 0\n", (long int) tl);
620
 
                status = 1;
621
 
              }
622
 
            tl1 = tl + by;
623
 
            if ((tl1 < tl) != (by < 0))
624
 
              break;
625
 
          }
626
 
      else
627
 
        for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1)
628
 
          {
629
 
            /* Null benchmark.  */
630
 
            lt = localtime (&tl);
631
 
            if (lt)
632
 
              {
633
 
                tmk = tml = *lt;
634
 
                tk = tl;
635
 
                status |= check_result (tk, tmk, tl, &tml);
636
 
              }
637
 
            else
638
 
              {
639
 
                printf ("localtime (%ld) yields 0\n", (long int) tl);
640
 
                status = 1;
641
 
              }
642
 
            tl1 = tl + by;
643
 
            if ((tl1 < tl) != (by < 0))
644
 
              break;
645
 
          }
646
 
    }
647
 
  else
648
 
    printf ("Usage:\
649
 
\t%s YYYY-MM-DD HH:MM:SS [ISDST] # Test given time.\n\
650
 
\t%s FROM BY TO # Test values FROM, FROM+BY, ..., TO.\n\
651
 
\t%s FROM BY TO - # Do not test those values (for benchmark).\n",
652
 
            argv[0], argv[0], argv[0]);
653
 
 
654
 
  return status;
655
 
}
656
 
 
657
 
#endif /* DEBUG */
658
 
 
659
 
/*
660
 
Local Variables:
661
 
compile-command: "gcc -DDEBUG -Wall -W -O -g mktime.c -o mktime"
662
 
End:
663
 
*/