← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to gnulib/mktime.c

Merged trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gnulib/mktime.c
17
17
   with this program; if not, write to the Free Software Foundation,
18
18
   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
19
19
 
20
 
/* Define this to have a standalone program to test this implementation of
21
 
   mktime.  */
22
 
/* #define DEBUG 1 */
23
 
 
24
20
#ifndef _LIBC
25
21
# include <config.h>
26
22
#endif
38
34
 
39
35
#include <string.h>             /* For the real memcpy prototype.  */
40
36
 
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
37
 
48
38
/* Shift A right by B bits portably, by dividing A by 2**B and
49
39
   truncating towards minus infinity.  A and B should be free of side
262
252
}
263
253
 
264
254
 
 
255
extern time_t
 
256
__mktime_internal (struct tm *tp,
 
257
                   struct tm *(*convert) (const time_t *, struct tm *),
 
258
                   time_t *offset);
265
259
/* Convert *TP to a time_t value, inverting
266
260
   the monotonic and mostly-unit-linear conversion function CONVERT.
267
261
   Use *OFFSET to keep track of a guess at the offset of the result,
523
517
libc_hidden_def (mktime)
524
518
libc_hidden_weak (timelocal)
525
519
#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
 
*/