~drizzle-trunk/drizzle/development : revision 1702.2.1

1

/* Convert a `struct tm' to a time_t value.

2

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

#ifndef _LIBC

21

# include <config.h>

22

#endif

23

24

/* Assume that leap seconds are possible, unless told otherwise.

25

If the host has a `zic' command with a `-L leapsecondfilename' option,

26

then it supports leap seconds; otherwise it probably doesn't. */

27

#ifndef LEAP_SECONDS_POSSIBLE

28

# define LEAP_SECONDS_POSSIBLE 1

29

#endif

30

31

#include <time.h>

32

33

#include <limits.h>

34

35

#include <string.h> /* For the real memcpy prototype. */

36

37

38

/* Shift A right by B bits portably, by dividing A by 2**B and

39

truncating towards minus infinity. A and B should be free of side

40

effects, and B should be in the range 0 <= B <= INT_BITS - 2, where

41

INT_BITS is the number of useful bits in an int. GNU code can

42

assume that INT_BITS is at least 32.

43

44

ISO C99 says that A >> B is implementation-defined if A < 0. Some

45

implementations (e.g., UNICOS 9.0 on a Cray Y-MP EL) don't shift

46

right in the usual way when A < 0, so SHR falls back on division if

47

ordinary A >> B doesn't seem to be the usual signed shift. */

48

#define SHR(a, b) \

49

(-1 >> 1 == -1 \

50

? (a) >> (b) \

51

: (a) / (1 << (b)) - ((a) % (1 << (b)) < 0))

52

53

/* The extra casts in the following macros work around compiler bugs,

54

e.g., in Cray C 5.0.3.0. */

55

56

/* True if the arithmetic type T is an integer type. bool counts as

57

an integer. */

58

#define TYPE_IS_INTEGER(t) ((t) 1.5 == 1)

59

60

/* True if negative values of the signed integer type T use two's

61

complement, ones' complement, or signed magnitude representation,

62

respectively. Much GNU code assumes two's complement, but some

63

people like to be portable to all possible C hosts. */

64

#define TYPE_TWOS_COMPLEMENT(t) ((t) ~ (t) 0 == (t) -1)

65

#define TYPE_ONES_COMPLEMENT(t) ((t) ~ (t) 0 == 0)

66

#define TYPE_SIGNED_MAGNITUDE(t) ((t) ~ (t) 0 < (t) -1)

67

68

/* True if the arithmetic type T is signed. */

69

#define TYPE_SIGNED(t) (! ((t) 0 < (t) -1))

70

71

/* The maximum and minimum values for the integer type T. These

72

macros have undefined behavior if T is signed and has padding bits.

73

If this is a problem for you, please let us know how to fix it for

74

your host. */

75

#define TYPE_MINIMUM(t) \

76

((t) (! TYPE_SIGNED (t) \

77

? (t) 0 \

78

: TYPE_SIGNED_MAGNITUDE (t) \

79

? ~ (t) 0 \

80

: ~ (t) 0 << (sizeof (t) * CHAR_BIT - 1)))

81

#define TYPE_MAXIMUM(t) \

82

((t) (! TYPE_SIGNED (t) \

83

? (t) -1 \

84

: ~ (~ (t) 0 << (sizeof (t) * CHAR_BIT - 1))))

85

86

#ifndef TIME_T_MIN

87

# define TIME_T_MIN TYPE_MINIMUM (time_t)

88

#endif

89

#ifndef TIME_T_MAX

90

# define TIME_T_MAX TYPE_MAXIMUM (time_t)

91

#endif

92

#define TIME_T_MIDPOINT (SHR (TIME_T_MIN + TIME_T_MAX, 1) + 1)

93

94

/* Verify a requirement at compile-time (unlike assert, which is runtime). */

95

#define verify(name, assertion) struct name { char a[(assertion) ? 1 : -1]; }

96

97

verify (time_t_is_integer, TYPE_IS_INTEGER (time_t));

98

verify (twos_complement_arithmetic, TYPE_TWOS_COMPLEMENT (int));

99

/* The code also assumes that signed integer overflow silently wraps

100

around, but this assumption can't be stated without causing a

101

diagnostic on some hosts. */

102

103

#define EPOCH_YEAR 1970

104

#define TM_YEAR_BASE 1900

105

verify (base_year_is_a_multiple_of_100, TM_YEAR_BASE % 100 == 0);

106

107

/* Return 1 if YEAR + TM_YEAR_BASE is a leap year. */

108

static inline int

109

leapyear (long int year)

110

{

111

/* Don't add YEAR to TM_YEAR_BASE, as that might overflow.

112

Also, work even if YEAR is negative. */

113

return

114

((year & 3) == 0

115

&& (year % 100 != 0

116

|| ((year / 100) & 3) == (- (TM_YEAR_BASE / 100) & 3)));

117

}

118

119

/* How many days come before each month (0-12). */

120

#ifndef _LIBC

121

static

122

#endif

123

const unsigned short int __mon_yday[2][13] =

124

{

125

/* Normal years. */

126

{ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },

127

/* Leap years. */

128

{ 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }

129

};

130

131

132

#ifndef _LIBC

133

/* Portable standalone applications should supply a <time.h> that

134

declares a POSIX-compliant localtime_r, for the benefit of older

135

implementations that lack localtime_r or have a nonstandard one.

136

See the gnulib time_r module for one way to implement this. */

137

# undef __localtime_r

138

# define __localtime_r localtime_r

139

# define __mktime_internal mktime_internal

140

#endif

141

142

/* Return an integer value measuring (YEAR1-YDAY1 HOUR1:MIN1:SEC1) -

143

(YEAR0-YDAY0 HOUR0:MIN0:SEC0) in seconds, assuming that the clocks

144

were not adjusted between the time stamps.

145

146

The YEAR values uses the same numbering as TP->tm_year. Values

147

need not be in the usual range. However, YEAR1 must not be less

148

than 2 * INT_MIN or greater than 2 * INT_MAX.

149

150

The result may overflow. It is the caller's responsibility to

151

detect overflow. */

152

153

static inline time_t

154

ydhms_diff (long int year1, long int yday1, int hour1, int min1, int sec1,

155

int year0, int yday0, int hour0, int min0, int sec0)

156

{

157

verify (C99_integer_division, -1 / 2 == 0);

158

verify (long_int_year_and_yday_are_wide_enough,

159

INT_MAX <= LONG_MAX / 2 || TIME_T_MAX <= UINT_MAX);

160

161

/* Compute intervening leap days correctly even if year is negative.

162

Take care to avoid integer overflow here. */

163

int a4 = SHR (year1, 2) + SHR (TM_YEAR_BASE, 2) - ! (year1 & 3);

164

int b4 = SHR (year0, 2) + SHR (TM_YEAR_BASE, 2) - ! (year0 & 3);

165

int a100 = a4 / 25 - (a4 % 25 < 0);

166

int b100 = b4 / 25 - (b4 % 25 < 0);

167

int a400 = SHR (a100, 2);

168

int b400 = SHR (b100, 2);

169

int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);

170

171

/* Compute the desired time in time_t precision. Overflow might

172

occur here. */

173

time_t tyear1 = year1;

174

time_t years = tyear1 - year0;

175

time_t days = 365 * years + yday1 - yday0 + intervening_leap_days;

176

time_t hours = 24 * days + hour1 - hour0;

177

time_t minutes = 60 * hours + min1 - min0;

178

time_t seconds = 60 * minutes + sec1 - sec0;

179

return seconds;

180

}

181

182

183

/* Return a time_t value corresponding to (YEAR-YDAY HOUR:MIN:SEC),

184

assuming that *T corresponds to *TP and that no clock adjustments

185

occurred between *TP and the desired time.

186

If TP is null, return a value not equal to *T; this avoids false matches.

187

If overflow occurs, yield the minimal or maximal value, except do not

188

yield a value equal to *T. */

189

static time_t

190

guess_time_tm (long int year, long int yday, int hour, int min, int sec,

191

const time_t *t, const struct tm *tp)

192

{

193

if (tp)

194

{

195

time_t d = ydhms_diff (year, yday, hour, min, sec,

196

tp->tm_year, tp->tm_yday,

197

tp->tm_hour, tp->tm_min, tp->tm_sec);

198

time_t t1 = *t + d;

199

if ((t1 < *t) == (TYPE_SIGNED (time_t) ? d < 0 : TIME_T_MAX / 2 < d))

200

return t1;

201

}

202

203

/* Overflow occurred one way or another. Return the nearest result

204

that is actually in range, except don't report a zero difference

205

if the actual difference is nonzero, as that would cause a false

206

match; and don't oscillate between two values, as that would

207

confuse the spring-forward gap detector. */

208

return (*t < TIME_T_MIDPOINT

209

? (*t <= TIME_T_MIN + 1 ? *t + 1 : TIME_T_MIN)

210

: (TIME_T_MAX - 1 <= *t ? *t - 1 : TIME_T_MAX));

211

}

212

213

/* Use CONVERT to convert *T to a broken down time in *TP.

214

If *T is out of range for conversion, adjust it so that

215

it is the nearest in-range value and then convert that. */

216

static struct tm *

217

ranged_convert (struct tm *(*convert) (const time_t *, struct tm *),

218

time_t *t, struct tm *tp)

219

{

220

struct tm *r = convert (t, tp);

221

222

if (!r && *t)

223

{

224

time_t bad = *t;

225

time_t ok = 0;

226

227

/* BAD is a known unconvertible time_t, and OK is a known good one.

228

Use binary search to narrow the range between BAD and OK until

229

they differ by 1. */

230

while (bad != ok + (bad < 0 ? -1 : 1))

231

{

232

time_t mid = *t = (bad < 0

233

? bad + ((ok - bad) >> 1)

234

: ok + ((bad - ok) >> 1));

235

r = convert (t, tp);

236

if (r)

237

ok = mid;

238

else

239

bad = mid;

240

}

241

242

if (!r && ok)

243

{

244

/* The last conversion attempt failed;

245

revert to the most recent successful attempt. */

246

*t = ok;

247

r = convert (t, tp);

248

}

249

}

250

251

return r;

252

}

253

254

255

extern time_t

256

__mktime_internal (struct tm *tp,

257

struct tm *(*convert) (const time_t *, struct tm *),

258

time_t *offset);

259

/* Convert *TP to a time_t value, inverting

260

the monotonic and mostly-unit-linear conversion function CONVERT.

261

Use *OFFSET to keep track of a guess at the offset of the result,

262

compared to what the result would be for UTC without leap seconds.

263

If *OFFSET's guess is correct, only one CONVERT call is needed.

264

This function is external because it is used also by timegm.c. */

265

time_t

266

__mktime_internal (struct tm *tp,

267

struct tm *(*convert) (const time_t *, struct tm *),

268

time_t *offset)

269

{

270

time_t t, gt, t0, t1, t2;

271

struct tm tm;

272

273

/* The maximum number of probes (calls to CONVERT) should be enough

274

to handle any combinations of time zone rule changes, solar time,

275

leap seconds, and oscillations around a spring-forward gap.

276

POSIX.1 prohibits leap seconds, but some hosts have them anyway. */

277

int remaining_probes = 6;

278

279

/* Time requested. Copy it in case CONVERT modifies *TP; this can

280

occur if TP is localtime's returned value and CONVERT is localtime. */

281

int sec = tp->tm_sec;

282

int min = tp->tm_min;

283

int hour = tp->tm_hour;

284

int mday = tp->tm_mday;

285

int mon = tp->tm_mon;

286

int year_requested = tp->tm_year;

287

/* Normalize the value. */

288

int isdst = ((tp->tm_isdst >> (8 * sizeof (tp->tm_isdst) - 1))

289

| (tp->tm_isdst != 0));

290

291

/* 1 if the previous probe was DST. */

292

int dst2;

293

294

/* Ensure that mon is in range, and set year accordingly. */

295

int mon_remainder = mon % 12;

296

int negative_mon_remainder = mon_remainder < 0;

297

int mon_years = mon / 12 - negative_mon_remainder;

298

long int lyear_requested = year_requested;

299

long int year = lyear_requested + mon_years;

300

301

/* The other values need not be in range:

302

the remaining code handles minor overflows correctly,

303

assuming int and time_t arithmetic wraps around.

304

Major overflows are caught at the end. */

305

306

/* Calculate day of year from year, month, and day of month.

307

The result need not be in range. */

308

int mon_yday = ((__mon_yday[leapyear (year)]

309

[mon_remainder + 12 * negative_mon_remainder])

310

- 1);

311

long int lmday = mday;

312

long int yday = mon_yday + lmday;

313

314

time_t guessed_offset = *offset;

315

316

int sec_requested = sec;

317

318

if (LEAP_SECONDS_POSSIBLE)

319

{

320

/* Handle out-of-range seconds specially,

321

since ydhms_tm_diff assumes every minute has 60 seconds. */

322

if (sec < 0)

323

sec = 0;

324

if (59 < sec)

325

sec = 59;

326

}

327

328

/* Invert CONVERT by probing. First assume the same offset as last

329

time. */

330

331

t0 = ydhms_diff (year, yday, hour, min, sec,

332

EPOCH_YEAR - TM_YEAR_BASE, 0, 0, 0, - guessed_offset);

333

334

if (TIME_T_MAX / INT_MAX / 366 / 24 / 60 / 60 < 3)

335

{

336

/* time_t isn't large enough to rule out overflows, so check

337

for major overflows. A gross check suffices, since if t0

338

has overflowed, it is off by a multiple of TIME_T_MAX -

339

TIME_T_MIN + 1. So ignore any component of the difference

340

that is bounded by a small value. */

341

342

/* Approximate log base 2 of the number of time units per

343

biennium. A biennium is 2 years; use this unit instead of

344

years to avoid integer overflow. For example, 2 average

345

Gregorian years are 2 * 365.2425 * 24 * 60 * 60 seconds,

346

which is 63113904 seconds, and rint (log2 (63113904)) is

347

26. */

348

int ALOG2_SECONDS_PER_BIENNIUM = 26;

349

int ALOG2_MINUTES_PER_BIENNIUM = 20;

350

int ALOG2_HOURS_PER_BIENNIUM = 14;

351

int ALOG2_DAYS_PER_BIENNIUM = 10;

352

int LOG2_YEARS_PER_BIENNIUM = 1;

353

354

int approx_requested_biennia =

355

(SHR (year_requested, LOG2_YEARS_PER_BIENNIUM)

356

- SHR (EPOCH_YEAR - TM_YEAR_BASE, LOG2_YEARS_PER_BIENNIUM)

357

+ SHR (mday, ALOG2_DAYS_PER_BIENNIUM)

358

+ SHR (hour, ALOG2_HOURS_PER_BIENNIUM)

359

+ SHR (min, ALOG2_MINUTES_PER_BIENNIUM)

360

+ (LEAP_SECONDS_POSSIBLE

361

? 0

362

: SHR (sec, ALOG2_SECONDS_PER_BIENNIUM)));

363

364

int approx_biennia = SHR (t0, ALOG2_SECONDS_PER_BIENNIUM);

365

int diff = approx_biennia - approx_requested_biennia;

366

int abs_diff = diff < 0 ? - diff : diff;

367

368

/* IRIX 4.0.5 cc miscaculates TIME_T_MIN / 3: it erroneously

369

gives a positive value of 715827882. Setting a variable

370

first then doing math on it seems to work.

371

(ghazi@caip.rutgers.edu) */

372

time_t time_t_max = TIME_T_MAX;

373

time_t time_t_min = TIME_T_MIN;

374

time_t overflow_threshold =

375

(time_t_max / 3 - time_t_min / 3) >> ALOG2_SECONDS_PER_BIENNIUM;

376

377

if (overflow_threshold < abs_diff)

378

{

379

/* Overflow occurred. Try repairing it; this might work if

380

the time zone offset is enough to undo the overflow. */

381

time_t repaired_t0 = -1 - t0;

382

approx_biennia = SHR (repaired_t0, ALOG2_SECONDS_PER_BIENNIUM);

383

diff = approx_biennia - approx_requested_biennia;

384

abs_diff = diff < 0 ? - diff : diff;

385

if (overflow_threshold < abs_diff)

386

return -1;

387

guessed_offset += repaired_t0 - t0;

388

t0 = repaired_t0;

389

}

390

}

391

392

/* Repeatedly use the error to improve the guess. */

393

394

for (t = t1 = t2 = t0, dst2 = 0;

395

(gt = guess_time_tm (year, yday, hour, min, sec, &t,

396

ranged_convert (convert, &t, &tm)),

397

t != gt);

398

t1 = t2, t2 = t, t = gt, dst2 = tm.tm_isdst != 0)

399

if (t == t1 && t != t2

400

&& (tm.tm_isdst < 0

401

|| (isdst < 0

402

? dst2 <= (tm.tm_isdst != 0)

403

: (isdst != 0) != (tm.tm_isdst != 0))))

404

/* We can't possibly find a match, as we are oscillating

405

between two values. The requested time probably falls

406

within a spring-forward gap of size GT - T. Follow the common

407

practice in this case, which is to return a time that is GT - T

408

away from the requested time, preferring a time whose

409

tm_isdst differs from the requested value. (If no tm_isdst

410

was requested and only one of the two values has a nonzero

411

tm_isdst, prefer that value.) In practice, this is more

412

useful than returning -1. */

413

goto offset_found;

414

else if (--remaining_probes == 0)

415

return -1;

416

417

/* We have a match. Check whether tm.tm_isdst has the requested

418

value, if any. */

419

if (isdst != tm.tm_isdst && 0 <= isdst && 0 <= tm.tm_isdst)

420

{

421

/* tm.tm_isdst has the wrong value. Look for a neighboring

422

time with the right value, and use its UTC offset.

423

424

Heuristic: probe the adjacent timestamps in both directions,

425

looking for the desired isdst. This should work for all real

426

time zone histories in the tz database. */

427

428

/* Distance between probes when looking for a DST boundary. In

429

tzdata2003a, the shortest period of DST is 601200 seconds

430

(e.g., America/Recife starting 2000-10-08 01:00), and the

431

shortest period of non-DST surrounded by DST is 694800

432

seconds (Africa/Tunis starting 1943-04-17 01:00). Use the

433

minimum of these two values, so we don't miss these short

434

periods when probing. */

435

int stride = 601200;

436

437

/* The longest period of DST in tzdata2003a is 536454000 seconds

438

(e.g., America/Jujuy starting 1946-10-01 01:00). The longest

439

period of non-DST is much longer, but it makes no real sense

440

to search for more than a year of non-DST, so use the DST

441

max. */

442

int duration_max = 536454000;

443

444

/* Search in both directions, so the maximum distance is half

445

the duration; add the stride to avoid off-by-1 problems. */

446

int delta_bound = duration_max / 2 + stride;

447

448

int delta, direction;

449

450

for (delta = stride; delta < delta_bound; delta += stride)

451

for (direction = -1; direction <= 1; direction += 2)

452

{

453

time_t ot = t + delta * direction;

454

if ((ot < t) == (direction < 0))

455

{

456

struct tm otm;

457

ranged_convert (convert, &ot, &otm);

458

if (otm.tm_isdst == isdst)

459

{

460

/* We found the desired tm_isdst.

461

Extrapolate back to the desired time. */

462

t = guess_time_tm (year, yday, hour, min, sec, &ot, &otm);

463

ranged_convert (convert, &t, &tm);

464

goto offset_found;

465

}

466

}

467

}

468

}

469

470

offset_found:

471

*offset = guessed_offset + t - t0;

472

473

if (LEAP_SECONDS_POSSIBLE && sec_requested != tm.tm_sec)

474

{

475

/* Adjust time to reflect the tm_sec requested, not the normalized value.

476

Also, repair any damage from a false match due to a leap second. */

477

int sec_adjustment = (sec == 0 && tm.tm_sec == 60) - sec;

478

t1 = t + sec_requested;

479

t2 = t1 + sec_adjustment;

480

if (((t1 < t) != (sec_requested < 0))

481

| ((t2 < t1) != (sec_adjustment < 0))

482

| ! convert (&t2, &tm))

483

return -1;

484

t = t2;

485

}

486

487

*tp = tm;

488

return t;

489

}

490

491

492

/* FIXME: This should use a signed type wide enough to hold any UTC

493

offset in seconds. 'int' should be good enough for GNU code. We

494

can't fix this unilaterally though, as other modules invoke

495

__mktime_internal. */

496

static time_t localtime_offset;

497

498

/* Convert *TP to a time_t value. */

499

time_t

500

mktime (struct tm *tp)

501

{

502

#ifdef _LIBC

503

/* POSIX.1 8.1.1 requires that whenever mktime() is called, the

504

time zone names contained in the external variable `tzname' shall

505

be set as if the tzset() function had been called. */

506

__tzset ();

507

#endif

508

509

return __mktime_internal (tp, __localtime_r, &localtime_offset);

510

}

511

512

#ifdef weak_alias

513

weak_alias (mktime, timelocal)

514

#endif

515

516

#ifdef _LIBC

517

libc_hidden_def (mktime)

518

libc_hidden_weak (timelocal)

519

#endif