~drizzle-trunk/drizzle/development : revision 815.1.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

/* 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

*/