← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to gnulib/mktime.c

  • Committer: Brian Aker
  • Date: 2009-07-11 19:23:04 UTC
  • mfrom: (1089.1.14 merge)
  • Revision ID: brian@gaz-20090711192304-ootijyl5yf9jq9kd
Merge Brian

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
  /* Normalize the value.  */
 
294
  int isdst = ((tp->tm_isdst >> (8 * sizeof (tp->tm_isdst) - 1))
 
295
               | (tp->tm_isdst != 0));
 
296
 
 
297
  /* 1 if the previous probe was DST.  */
 
298
  int dst2;
 
299
 
 
300
  /* Ensure that mon is in range, and set year accordingly.  */
 
301
  int mon_remainder = mon % 12;
 
302
  int negative_mon_remainder = mon_remainder < 0;
 
303
  int mon_years = mon / 12 - negative_mon_remainder;
 
304
  long int lyear_requested = year_requested;
 
305
  long int year = lyear_requested + mon_years;
 
306
 
 
307
  /* The other values need not be in range:
 
308
     the remaining code handles minor overflows correctly,
 
309
     assuming int and time_t arithmetic wraps around.
 
310
     Major overflows are caught at the end.  */
 
311
 
 
312
  /* Calculate day of year from year, month, and day of month.
 
313
     The result need not be in range.  */
 
314
  int mon_yday = ((__mon_yday[leapyear (year)]
 
315
                   [mon_remainder + 12 * negative_mon_remainder])
 
316
                  - 1);
 
317
  long int lmday = mday;
 
318
  long int yday = mon_yday + lmday;
 
319
 
 
320
  time_t guessed_offset = *offset;
 
321
 
 
322
  int sec_requested = sec;
 
323
 
 
324
  if (LEAP_SECONDS_POSSIBLE)
 
325
    {
 
326
      /* Handle out-of-range seconds specially,
 
327
         since ydhms_tm_diff assumes every minute has 60 seconds.  */
 
328
      if (sec < 0)
 
329
        sec = 0;
 
330
      if (59 < sec)
 
331
        sec = 59;
 
332
    }
 
333
 
 
334
  /* Invert CONVERT by probing.  First assume the same offset as last
 
335
     time.  */
 
336
 
 
337
  t0 = ydhms_diff (year, yday, hour, min, sec,
 
338
                   EPOCH_YEAR - TM_YEAR_BASE, 0, 0, 0, - guessed_offset);
 
339
 
 
340
  if (TIME_T_MAX / INT_MAX / 366 / 24 / 60 / 60 < 3)
 
341
    {
 
342
      /* time_t isn't large enough to rule out overflows, so check
 
343
         for major overflows.  A gross check suffices, since if t0
 
344
         has overflowed, it is off by a multiple of TIME_T_MAX -
 
345
         TIME_T_MIN + 1.  So ignore any component of the difference
 
346
         that is bounded by a small value.  */
 
347
 
 
348
      /* Approximate log base 2 of the number of time units per
 
349
         biennium.  A biennium is 2 years; use this unit instead of
 
350
         years to avoid integer overflow.  For example, 2 average
 
351
         Gregorian years are 2 * 365.2425 * 24 * 60 * 60 seconds,
 
352
         which is 63113904 seconds, and rint (log2 (63113904)) is
 
353
         26.  */
 
354
      int ALOG2_SECONDS_PER_BIENNIUM = 26;
 
355
      int ALOG2_MINUTES_PER_BIENNIUM = 20;
 
356
      int ALOG2_HOURS_PER_BIENNIUM = 14;
 
357
      int ALOG2_DAYS_PER_BIENNIUM = 10;
 
358
      int LOG2_YEARS_PER_BIENNIUM = 1;
 
359
 
 
360
      int approx_requested_biennia =
 
361
        (SHR (year_requested, LOG2_YEARS_PER_BIENNIUM)
 
362
         - SHR (EPOCH_YEAR - TM_YEAR_BASE, LOG2_YEARS_PER_BIENNIUM)
 
363
         + SHR (mday, ALOG2_DAYS_PER_BIENNIUM)
 
364
         + SHR (hour, ALOG2_HOURS_PER_BIENNIUM)
 
365
         + SHR (min, ALOG2_MINUTES_PER_BIENNIUM)
 
366
         + (LEAP_SECONDS_POSSIBLE
 
367
            ? 0
 
368
            : SHR (sec, ALOG2_SECONDS_PER_BIENNIUM)));
 
369
 
 
370
      int approx_biennia = SHR (t0, ALOG2_SECONDS_PER_BIENNIUM);
 
371
      int diff = approx_biennia - approx_requested_biennia;
 
372
      int abs_diff = diff < 0 ? - diff : diff;
 
373
 
 
374
      /* IRIX 4.0.5 cc miscaculates TIME_T_MIN / 3: it erroneously
 
375
         gives a positive value of 715827882.  Setting a variable
 
376
         first then doing math on it seems to work.
 
377
         (ghazi@caip.rutgers.edu) */
 
378
      time_t time_t_max = TIME_T_MAX;
 
379
      time_t time_t_min = TIME_T_MIN;
 
380
      time_t overflow_threshold =
 
381
        (time_t_max / 3 - time_t_min / 3) >> ALOG2_SECONDS_PER_BIENNIUM;
 
382
 
 
383
      if (overflow_threshold < abs_diff)
 
384
        {
 
385
          /* Overflow occurred.  Try repairing it; this might work if
 
386
             the time zone offset is enough to undo the overflow.  */
 
387
          time_t repaired_t0 = -1 - t0;
 
388
          approx_biennia = SHR (repaired_t0, ALOG2_SECONDS_PER_BIENNIUM);
 
389
          diff = approx_biennia - approx_requested_biennia;
 
390
          abs_diff = diff < 0 ? - diff : diff;
 
391
          if (overflow_threshold < abs_diff)
 
392
            return -1;
 
393
          guessed_offset += repaired_t0 - t0;
 
394
          t0 = repaired_t0;
 
395
        }
 
396
    }
 
397
 
 
398
  /* Repeatedly use the error to improve the guess.  */
 
399
 
 
400
  for (t = t1 = t2 = t0, dst2 = 0;
 
401
       (gt = guess_time_tm (year, yday, hour, min, sec, &t,
 
402
                            ranged_convert (convert, &t, &tm)),
 
403
        t != gt);
 
404
       t1 = t2, t2 = t, t = gt, dst2 = tm.tm_isdst != 0)
 
405
    if (t == t1 && t != t2
 
406
        && (tm.tm_isdst < 0
 
407
            || (isdst < 0
 
408
                ? dst2 <= (tm.tm_isdst != 0)
 
409
                : (isdst != 0) != (tm.tm_isdst != 0))))
 
410
      /* We can't possibly find a match, as we are oscillating
 
411
         between two values.  The requested time probably falls
 
412
         within a spring-forward gap of size GT - T.  Follow the common
 
413
         practice in this case, which is to return a time that is GT - T
 
414
         away from the requested time, preferring a time whose
 
415
         tm_isdst differs from the requested value.  (If no tm_isdst
 
416
         was requested and only one of the two values has a nonzero
 
417
         tm_isdst, prefer that value.)  In practice, this is more
 
418
         useful than returning -1.  */
 
419
      goto offset_found;
 
420
    else if (--remaining_probes == 0)
 
421
      return -1;
 
422
 
 
423
  /* We have a match.  Check whether tm.tm_isdst has the requested
 
424
     value, if any.  */
 
425
  if (isdst != tm.tm_isdst && 0 <= isdst && 0 <= tm.tm_isdst)
 
426
    {
 
427
      /* tm.tm_isdst has the wrong value.  Look for a neighboring
 
428
         time with the right value, and use its UTC offset.
 
429
 
 
430
         Heuristic: probe the adjacent timestamps in both directions,
 
431
         looking for the desired isdst.  This should work for all real
 
432
         time zone histories in the tz database.  */
 
433
 
 
434
      /* Distance between probes when looking for a DST boundary.  In
 
435
         tzdata2003a, the shortest period of DST is 601200 seconds
 
436
         (e.g., America/Recife starting 2000-10-08 01:00), and the
 
437
         shortest period of non-DST surrounded by DST is 694800
 
438
         seconds (Africa/Tunis starting 1943-04-17 01:00).  Use the
 
439
         minimum of these two values, so we don't miss these short
 
440
         periods when probing.  */
 
441
      int stride = 601200;
 
442
 
 
443
      /* The longest period of DST in tzdata2003a is 536454000 seconds
 
444
         (e.g., America/Jujuy starting 1946-10-01 01:00).  The longest
 
445
         period of non-DST is much longer, but it makes no real sense
 
446
         to search for more than a year of non-DST, so use the DST
 
447
         max.  */
 
448
      int duration_max = 536454000;
 
449
 
 
450
      /* Search in both directions, so the maximum distance is half
 
451
         the duration; add the stride to avoid off-by-1 problems.  */
 
452
      int delta_bound = duration_max / 2 + stride;
 
453
 
 
454
      int delta, direction;
 
455
 
 
456
      for (delta = stride; delta < delta_bound; delta += stride)
 
457
        for (direction = -1; direction <= 1; direction += 2)
 
458
          {
 
459
            time_t ot = t + delta * direction;
 
460
            if ((ot < t) == (direction < 0))
 
461
              {
 
462
                struct tm otm;
 
463
                ranged_convert (convert, &ot, &otm);
 
464
                if (otm.tm_isdst == isdst)
 
465
                  {
 
466
                    /* We found the desired tm_isdst.
 
467
                       Extrapolate back to the desired time.  */
 
468
                    t = guess_time_tm (year, yday, hour, min, sec, &ot, &otm);
 
469
                    ranged_convert (convert, &t, &tm);
 
470
                    goto offset_found;
 
471
                  }
 
472
              }
 
473
          }
 
474
    }
 
475
 
 
476
 offset_found:
 
477
  *offset = guessed_offset + t - t0;
 
478
 
 
479
  if (LEAP_SECONDS_POSSIBLE && sec_requested != tm.tm_sec)
 
480
    {
 
481
      /* Adjust time to reflect the tm_sec requested, not the normalized value.
 
482
         Also, repair any damage from a false match due to a leap second.  */
 
483
      int sec_adjustment = (sec == 0 && tm.tm_sec == 60) - sec;
 
484
      t1 = t + sec_requested;
 
485
      t2 = t1 + sec_adjustment;
 
486
      if (((t1 < t) != (sec_requested < 0))
 
487
          | ((t2 < t1) != (sec_adjustment < 0))
 
488
          | ! convert (&t2, &tm))
 
489
        return -1;
 
490
      t = t2;
 
491
    }
 
492
 
 
493
  *tp = tm;
 
494
  return t;
 
495
}
 
496
 
 
497
 
 
498
/* FIXME: This should use a signed type wide enough to hold any UTC
 
499
   offset in seconds.  'int' should be good enough for GNU code.  We
 
500
   can't fix this unilaterally though, as other modules invoke
 
501
   __mktime_internal.  */
 
502
static time_t localtime_offset;
 
503
 
 
504
/* Convert *TP to a time_t value.  */
 
505
time_t
 
506
mktime (struct tm *tp)
 
507
{
 
508
#ifdef _LIBC
 
509
  /* POSIX.1 8.1.1 requires that whenever mktime() is called, the
 
510
     time zone names contained in the external variable `tzname' shall
 
511
     be set as if the tzset() function had been called.  */
 
512
  __tzset ();
 
513
#endif
 
514
 
 
515
  return __mktime_internal (tp, __localtime_r, &localtime_offset);
 
516
}
 
517
 
 
518
#ifdef weak_alias
 
519
weak_alias (mktime, timelocal)
 
520
#endif
 
521
 
 
522
#ifdef _LIBC
 
523
libc_hidden_def (mktime)
 
524
libc_hidden_weak (timelocal)
 
525
#endif
 
526
 
 
527
#if DEBUG
 
528
 
 
529
static int
 
530
not_equal_tm (const struct tm *a, const struct tm *b)
 
531
{
 
532
  return ((a->tm_sec ^ b->tm_sec)
 
533
          | (a->tm_min ^ b->tm_min)
 
534
          | (a->tm_hour ^ b->tm_hour)
 
535
          | (a->tm_mday ^ b->tm_mday)
 
536
          | (a->tm_mon ^ b->tm_mon)
 
537
          | (a->tm_year ^ b->tm_year)
 
538
          | (a->tm_yday ^ b->tm_yday)
 
539
          | (a->tm_isdst ^ b->tm_isdst));
 
540
}
 
541
 
 
542
static void
 
543
print_tm (const struct tm *tp)
 
544
{
 
545
  if (tp)
 
546
    printf ("%04d-%02d-%02d %02d:%02d:%02d yday %03d wday %d isdst %d",
 
547
            tp->tm_year + TM_YEAR_BASE, tp->tm_mon + 1, tp->tm_mday,
 
548
            tp->tm_hour, tp->tm_min, tp->tm_sec,
 
549
            tp->tm_yday, tp->tm_wday, tp->tm_isdst);
 
550
  else
 
551
    printf ("0");
 
552
}
 
553
 
 
554
static int
 
555
check_result (time_t tk, struct tm tmk, time_t tl, const struct tm *lt)
 
556
{
 
557
  if (tk != tl || !lt || not_equal_tm (&tmk, lt))
 
558
    {
 
559
      printf ("mktime (");
 
560
      print_tm (lt);
 
561
      printf (")\nyields (");
 
562
      print_tm (&tmk);
 
563
      printf (") == %ld, should be %ld\n", (long int) tk, (long int) tl);
 
564
      return 1;
 
565
    }
 
566
 
 
567
  return 0;
 
568
}
 
569
 
 
570
int
 
571
main (int argc, char **argv)
 
572
{
 
573
  int status = 0;
 
574
  struct tm tm, tmk, tml;
 
575
  struct tm *lt;
 
576
  time_t tk, tl, tl1;
 
577
  char trailer;
 
578
 
 
579
  if ((argc == 3 || argc == 4)
 
580
      && (sscanf (argv[1], "%d-%d-%d%c",
 
581
                  &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &trailer)
 
582
          == 3)
 
583
      && (sscanf (argv[2], "%d:%d:%d%c",
 
584
                  &tm.tm_hour, &tm.tm_min, &tm.tm_sec, &trailer)
 
585
          == 3))
 
586
    {
 
587
      tm.tm_year -= TM_YEAR_BASE;
 
588
      tm.tm_mon--;
 
589
      tm.tm_isdst = argc == 3 ? -1 : atoi (argv[3]);
 
590
      tmk = tm;
 
591
      tl = mktime (&tmk);
 
592
      lt = localtime (&tl);
 
593
      if (lt)
 
594
        {
 
595
          tml = *lt;
 
596
          lt = &tml;
 
597
        }
 
598
      printf ("mktime returns %ld == ", (long int) tl);
 
599
      print_tm (&tmk);
 
600
      printf ("\n");
 
601
      status = check_result (tl, tmk, tl, lt);
 
602
    }
 
603
  else if (argc == 4 || (argc == 5 && strcmp (argv[4], "-") == 0))
 
604
    {
 
605
      time_t from = atol (argv[1]);
 
606
      time_t by = atol (argv[2]);
 
607
      time_t to = atol (argv[3]);
 
608
 
 
609
      if (argc == 4)
 
610
        for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1)
 
611
          {
 
612
            lt = localtime (&tl);
 
613
            if (lt)
 
614
              {
 
615
                tmk = tml = *lt;
 
616
                tk = mktime (&tmk);
 
617
                status |= check_result (tk, tmk, tl, &tml);
 
618
              }
 
619
            else
 
620
              {
 
621
                printf ("localtime (%ld) yields 0\n", (long int) tl);
 
622
                status = 1;
 
623
              }
 
624
            tl1 = tl + by;
 
625
            if ((tl1 < tl) != (by < 0))
 
626
              break;
 
627
          }
 
628
      else
 
629
        for (tl = from; by < 0 ? to <= tl : tl <= to; tl = tl1)
 
630
          {
 
631
            /* Null benchmark.  */
 
632
            lt = localtime (&tl);
 
633
            if (lt)
 
634
              {
 
635
                tmk = tml = *lt;
 
636
                tk = tl;
 
637
                status |= check_result (tk, tmk, tl, &tml);
 
638
              }
 
639
            else
 
640
              {
 
641
                printf ("localtime (%ld) yields 0\n", (long int) tl);
 
642
                status = 1;
 
643
              }
 
644
            tl1 = tl + by;
 
645
            if ((tl1 < tl) != (by < 0))
 
646
              break;
 
647
          }
 
648
    }
 
649
  else
 
650
    printf ("Usage:\
 
651
\t%s YYYY-MM-DD HH:MM:SS [ISDST] # Test given time.\n\
 
652
\t%s FROM BY TO # Test values FROM, FROM+BY, ..., TO.\n\
 
653
\t%s FROM BY TO - # Do not test those values (for benchmark).\n",
 
654
            argv[0], argv[0], argv[0]);
 
655
 
 
656
  return status;
 
657
}
 
658
 
 
659
#endif /* DEBUG */
 
660
 
 
661
/*
 
662
Local Variables:
 
663
compile-command: "gcc -DDEBUG -Wall -W -O -g mktime.c -o mktime"
 
664
End:
 
665
*/