Removed in laer C9x draft.
[kopensolaris-gnu/glibc.git] / time / strftime.c
1 /* Copyright (C) 1991,92,93,94,95,96,97,98 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3
4    The GNU C Library is free software; you can redistribute it and/or
5    modify it under the terms of the GNU Library General Public License as
6    published by the Free Software Foundation; either version 2 of the
7    License, or (at your option) any later version.
8
9    The GNU C Library is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12    Library General Public License for more details.
13
14    You should have received a copy of the GNU Library General Public
15    License along with the GNU C Library; see the file COPYING.LIB.  If not,
16    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17    Boston, MA 02111-1307, USA.  */
18
19 #ifdef HAVE_CONFIG_H
20 # include <config.h>
21 #endif
22
23 #ifdef _LIBC
24 # define HAVE_LIMITS_H 1
25 # define HAVE_MBLEN 1
26 # define HAVE_MBRLEN 1
27 # define HAVE_STRUCT_ERA_ENTRY 1
28 # define HAVE_TM_GMTOFF 1
29 # define HAVE_TM_ZONE 1
30 # define HAVE_TZNAME 1
31 # define HAVE_TZSET 1
32 # define MULTIBYTE_IS_FORMAT_SAFE 1
33 # define STDC_HEADERS 1
34 # include "../locale/localeinfo.h"
35 #endif
36
37 #if defined emacs && !defined HAVE_BCOPY
38 # define HAVE_MEMCPY 1
39 #endif
40
41 #include <ctype.h>
42 #include <sys/types.h>          /* Some systems define `time_t' here.  */
43
44 #ifdef TIME_WITH_SYS_TIME
45 # include <sys/time.h>
46 # include <time.h>
47 #else
48 # ifdef HAVE_SYS_TIME_H
49 #  include <sys/time.h>
50 # else
51 #  include <time.h>
52 # endif
53 #endif
54 #if HAVE_TZNAME
55 extern char *tzname[];
56 #endif
57
58 /* Do multibyte processing if multibytes are supported, unless
59    multibyte sequences are safe in formats.  Multibyte sequences are
60    safe if they cannot contain byte sequences that look like format
61    conversion specifications.  The GNU C Library uses UTF8 multibyte
62    encoding, which is safe for formats, but strftime.c can be used
63    with other C libraries that use unsafe encodings.  */
64 #define DO_MULTIBYTE (HAVE_MBLEN && ! MULTIBYTE_IS_FORMAT_SAFE)
65
66 #if DO_MULTIBYTE
67 # if HAVE_MBRLEN
68 #  include <wchar.h>
69 # else
70    /* Simulate mbrlen with mblen as best we can.  */
71 #  define mbstate_t int
72 #  define mbrlen(s, n, ps) mblen (s, n)
73 #  define mbsinit(ps) (*(ps) == 0)
74 # endif
75   static const mbstate_t mbstate_zero;
76 #endif
77
78 #if HAVE_LIMITS_H
79 # include <limits.h>
80 #endif
81
82 #if STDC_HEADERS
83 # include <stddef.h>
84 # include <stdlib.h>
85 # include <string.h>
86 #else
87 # ifndef HAVE_MEMCPY
88 #  define memcpy(d, s, n) bcopy ((s), (d), (n))
89 # endif
90 #endif
91
92 #ifdef _LIBC
93 # define MEMPCPY(d, s, n) __mempcpy (d, s, n)
94 #else
95 # ifndef HAVE_MEMPCPY
96 #  define MEMPCPY(d, s, n) ((void *) ((char *) memcpy (d, s, n) + (n)))
97 # endif
98 #endif
99
100 #ifndef __P
101 # if defined (__GNUC__) || (defined (__STDC__) && __STDC__)
102 #  define __P(args) args
103 # else
104 #  define __P(args) ()
105 # endif  /* GCC.  */
106 #endif  /* Not __P.  */
107
108 #ifndef PTR
109 # ifdef __STDC__
110 #  define PTR void *
111 # else
112 #  define PTR char *
113 # endif
114 #endif
115
116 #ifndef CHAR_BIT
117 # define CHAR_BIT 8
118 #endif
119
120 #ifndef NULL
121 # define NULL 0
122 #endif
123
124 #define TYPE_SIGNED(t) ((t) -1 < 0)
125
126 /* Bound on length of the string representing an integer value of type t.
127    Subtract one for the sign bit if t is signed;
128    302 / 1000 is log10 (2) rounded up;
129    add one for integer division truncation;
130    add one more for a minus sign if t is signed.  */
131 #define INT_STRLEN_BOUND(t) \
132  ((sizeof (t) * CHAR_BIT - TYPE_SIGNED (t)) * 302 / 1000 + 1 + TYPE_SIGNED (t))
133
134 #define TM_YEAR_BASE 1900
135
136 #ifndef __isleap
137 /* Nonzero if YEAR is a leap year (every 4 years,
138    except every 100th isn't, and every 400th is).  */
139 # define __isleap(year) \
140   ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
141 #endif
142
143
144 #ifdef _LIBC
145 # define my_strftime_gmtime_r __gmtime_r
146 # define my_strftime_localtime_r __localtime_r
147 # define tzname __tzname
148 # define tzset __tzset
149 #else
150
151 /* If we're a strftime substitute in a GNU program, then prefer gmtime
152    to gmtime_r, since many gmtime_r implementations are buggy.
153    Similarly for localtime_r.  */
154
155 # if ! HAVE_TM_GMTOFF
156 static struct tm *my_strftime_gmtime_r __P ((const time_t *, struct tm *));
157 static struct tm *
158 my_strftime_gmtime_r (t, tp)
159      const time_t *t;
160      struct tm *tp;
161 {
162   struct tm *l = gmtime (t);
163   if (! l)
164     return 0;
165   *tp = *l;
166   return tp;
167 }
168 # endif /* ! HAVE_TM_GMTOFF */
169
170 static struct tm *my_strftime_localtime_r __P ((const time_t *, struct tm *));
171 static struct tm *
172 my_strftime_localtime_r (t, tp)
173      const time_t *t;
174      struct tm *tp;
175 {
176   struct tm *l = localtime (t);
177   if (! l)
178     return 0;
179   *tp = *l;
180   return tp;
181 }
182 #endif /* ! defined _LIBC */
183
184
185 #if !defined memset && !defined HAVE_MEMSET && !defined _LIBC
186 /* Some systems lack the `memset' function and we don't want to
187    introduce additional dependencies.  */
188 /* The SGI compiler reportedly barfs on the trailing null
189    if we use a string constant as the initializer.  28 June 1997, rms.  */
190 static const char spaces[16] = /* "                " */
191   { ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ' };
192 static const char zeroes[16] = /* "0000000000000000" */
193   { '0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0' };
194
195 # define memset_space(P, Len) \
196   do {                                                                        \
197     int _len = (Len);                                                         \
198                                                                               \
199     do                                                                        \
200       {                                                                       \
201         int _this = _len > 16 ? 16 : _len;                                    \
202         (P) = MEMPCPY ((P), spaces, _this);                                   \
203         _len -= _this;                                                        \
204       }                                                                       \
205     while (_len > 0);                                                         \
206   } while (0)
207
208 # define memset_zero(P, Len) \
209   do {                                                                        \
210     int _len = (Len);                                                         \
211                                                                               \
212     do                                                                        \
213       {                                                                       \
214         int _this = _len > 16 ? 16 : _len;                                    \
215         (P) = MEMPCPY ((P), zeroes, _this);                                   \
216         _len -= _this;                                                        \
217       }                                                                       \
218     while (_len > 0);                                                         \
219   } while (0)
220 #else
221 # define memset_space(P, Len) (memset ((P), ' ', (Len)), (P) += (Len))
222 # define memset_zero(P, Len) (memset ((P), '0', (Len)), (P) += (Len))
223 #endif
224
225 #define add(n, f)                                                             \
226   do                                                                          \
227     {                                                                         \
228       int _n = (n);                                                           \
229       int _delta = width - _n;                                                \
230       int _incr = _n + (_delta > 0 ? _delta : 0);                             \
231       if (i + _incr >= maxsize)                                               \
232         return 0;                                                             \
233       if (p)                                                                  \
234         {                                                                     \
235           if (_delta > 0)                                                     \
236             {                                                                 \
237               if (pad == '0')                                                 \
238                 memset_zero (p, _delta);                                      \
239               else                                                            \
240                 memset_space (p, _delta);                                     \
241             }                                                                 \
242           f;                                                                  \
243           p += _n;                                                            \
244         }                                                                     \
245       i += _incr;                                                             \
246     } while (0)
247
248 #define cpy(n, s) \
249     add ((n),                                                                 \
250          if (to_lowcase)                                                      \
251            memcpy_lowcase (p, (s), _n);                                       \
252          else if (to_uppcase)                                                 \
253            memcpy_uppcase (p, (s), _n);                                       \
254          else                                                                 \
255            memcpy ((PTR) p, (PTR) (s), _n))
256
257
258
259 #ifdef _LIBC
260 # define TOUPPER(Ch) toupper (Ch)
261 # define TOLOWER(Ch) tolower (Ch)
262 #else
263 # define TOUPPER(Ch) (islower (Ch) ? toupper (Ch) : (Ch))
264 # define TOLOWER(Ch) (isupper (Ch) ? tolower (Ch) : (Ch))
265 #endif
266 /* We don't use `isdigit' here since the locale dependent
267    interpretation is not what we want here.  We only need to accept
268    the arabic digits in the ASCII range.  One day there is perhaps a
269    more reliable way to accept other sets of digits.  */
270 #define ISDIGIT(Ch) ((unsigned int) (Ch) - '0' <= 9)
271
272 static char *memcpy_lowcase __P ((char *dest, const char *src, size_t len));
273
274 static char *
275 memcpy_lowcase (dest, src, len)
276      char *dest;
277      const char *src;
278      size_t len;
279 {
280   while (len-- > 0)
281     dest[len] = TOLOWER ((unsigned char) src[len]);
282   return dest;
283 }
284
285 static char *memcpy_uppcase __P ((char *dest, const char *src, size_t len));
286
287 static char *
288 memcpy_uppcase (dest, src, len)
289      char *dest;
290      const char *src;
291      size_t len;
292 {
293   while (len-- > 0)
294     dest[len] = TOUPPER ((unsigned char) src[len]);
295   return dest;
296 }
297
298
299 #if ! HAVE_TM_GMTOFF
300 /* Yield the difference between *A and *B,
301    measured in seconds, ignoring leap seconds.  */
302 # define tm_diff ftime_tm_diff
303 static int tm_diff __P ((const struct tm *, const struct tm *));
304 static int
305 tm_diff (a, b)
306      const struct tm *a;
307      const struct tm *b;
308 {
309   /* Compute intervening leap days correctly even if year is negative.
310      Take care to avoid int overflow in leap day calculations,
311      but it's OK to assume that A and B are close to each other.  */
312   int a4 = (a->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (a->tm_year & 3);
313   int b4 = (b->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (b->tm_year & 3);
314   int a100 = a4 / 25 - (a4 % 25 < 0);
315   int b100 = b4 / 25 - (b4 % 25 < 0);
316   int a400 = a100 >> 2;
317   int b400 = b100 >> 2;
318   int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
319   int years = a->tm_year - b->tm_year;
320   int days = (365 * years + intervening_leap_days
321               + (a->tm_yday - b->tm_yday));
322   return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
323                 + (a->tm_min - b->tm_min))
324           + (a->tm_sec - b->tm_sec));
325 }
326 #endif /* ! HAVE_TM_GMTOFF */
327
328
329
330 /* The number of days from the first day of the first ISO week of this
331    year to the year day YDAY with week day WDAY.  ISO weeks start on
332    Monday; the first ISO week has the year's first Thursday.  YDAY may
333    be as small as YDAY_MINIMUM.  */
334 #define ISO_WEEK_START_WDAY 1 /* Monday */
335 #define ISO_WEEK1_WDAY 4 /* Thursday */
336 #define YDAY_MINIMUM (-366)
337 static int iso_week_days __P ((int, int));
338 #ifdef __GNUC__
339 __inline__
340 #endif
341 static int
342 iso_week_days (yday, wday)
343      int yday;
344      int wday;
345 {
346   /* Add enough to the first operand of % to make it nonnegative.  */
347   int big_enough_multiple_of_7 = (-YDAY_MINIMUM / 7 + 2) * 7;
348   return (yday
349           - (yday - wday + ISO_WEEK1_WDAY + big_enough_multiple_of_7) % 7
350           + ISO_WEEK1_WDAY - ISO_WEEK_START_WDAY);
351 }
352
353
354 #if !(defined _NL_CURRENT || HAVE_STRFTIME)
355 static char const weekday_name[][10] =
356   {
357     "Sunday", "Monday", "Tuesday", "Wednesday",
358     "Thursday", "Friday", "Saturday"
359   };
360 static char const month_name[][10] =
361   {
362     "January", "February", "March", "April", "May", "June",
363     "July", "August", "September", "October", "November", "December"
364   };
365 #endif
366
367
368 #ifdef emacs
369 # define my_strftime emacs_strftimeu
370 # define ut_argument , ut
371 # define ut_argument_spec int ut;
372 # define ut_argument_spec_iso , int ut
373 #else
374 # define my_strftime strftime
375 # define ut_argument
376 # define ut_argument_spec
377 # define ut_argument_spec_iso
378 /* We don't have this information in general.  */
379 # define ut 0
380 #endif
381
382 #if !defined _LIBC && HAVE_TZNAME && HAVE_TZSET
383   /* Solaris 2.5 tzset sometimes modifies the storage returned by localtime.
384      Work around this bug by copying *tp before it might be munged.  */
385   size_t _strftime_copytm __P ((char *, size_t, const char *,
386                                 const struct tm * ut_argument_spec_iso));
387   size_t
388   my_strftime (s, maxsize, format, tp ut_argument)
389       char *s;
390       size_t maxsize;
391       const char *format;
392       const struct tm *tp;
393       ut_argument_spec
394   {
395     struct tm tmcopy;
396     tmcopy = *tp;
397     return _strftime_copytm (s, maxsize, format, &tmcopy ut_argument);
398   }
399 # undef my_strftime
400 # define my_strftime(S, Maxsize, Format, Tp) \
401   _strftime_copytm (S, Maxsize, Format, Tp)
402 #endif
403
404
405 /* Write information from TP into S according to the format
406    string FORMAT, writing no more that MAXSIZE characters
407    (including the terminating '\0') and returning number of
408    characters written.  If S is NULL, nothing will be written
409    anywhere, so to determine how many characters would be
410    written, use NULL for S and (size_t) UINT_MAX for MAXSIZE.  */
411 size_t
412 my_strftime (s, maxsize, format, tp ut_argument)
413       char *s;
414       size_t maxsize;
415       const char *format;
416       const struct tm *tp;
417       ut_argument_spec
418 {
419   int hour12 = tp->tm_hour;
420 #ifdef _NL_CURRENT
421   /* We cannot make the following values variables since we must delay
422      the evaluation of these values until really needed since some
423      expressions might not be valid in every situation.  The `struct tm'
424      might be generated by a strptime() call that initialized
425      only a few elements.  Dereference the pointers only if the format
426      requires this.  Then it is ok to fail if the pointers are invalid.  */
427 # define a_wkday _NL_CURRENT (LC_TIME, ABDAY_1 + tp->tm_wday)
428 # define f_wkday _NL_CURRENT (LC_TIME, DAY_1 + tp->tm_wday)
429 # define a_month _NL_CURRENT (LC_TIME, ABMON_1 + tp->tm_mon)
430 # define f_month _NL_CURRENT (LC_TIME, MON_1 + tp->tm_mon)
431 # define ampm _NL_CURRENT (LC_TIME, tp->tm_hour > 11 ? PM_STR : AM_STR)
432
433 # define aw_len strlen (a_wkday)
434 # define am_len strlen (a_month)
435 # define ap_len strlen (ampm)
436 #else
437 # if !HAVE_STRFTIME
438 # define f_wkday (weekday_name[tp->tm_wday])
439 # define f_month (month_name[tp->tm_mon])
440 # define a_wkday f_wkday
441 # define a_month f_month
442 # define ampm ("AMPM" + 2 * (tp->tm_hour > 11))
443
444   size_t aw_len = 3;
445   size_t am_len = 3;
446   size_t ap_len = 2;
447 # endif
448 #endif
449   const char *zone;
450   size_t i = 0;
451   char *p = s;
452   const char *f;
453
454   zone = NULL;
455 #if HAVE_TM_ZONE
456   /* The POSIX test suite assumes that setting
457      the environment variable TZ to a new value before calling strftime()
458      will influence the result (the %Z format) even if the information in
459      TP is computed with a totally different time zone.
460      This is bogus: though POSIX allows bad behavior like this,
461      POSIX does not require it.  Do the right thing instead.  */
462   zone = (const char *) tp->tm_zone;
463 #endif
464 #if HAVE_TZNAME
465   if (ut)
466     {
467       if (! (zone && *zone))
468         zone = "GMT";
469     }
470   else
471     {
472       /* POSIX.1 8.1.1 requires that whenever strftime() is called, the
473          time zone names contained in the external variable `tzname' shall
474          be set as if the tzset() function had been called.  */
475 # if HAVE_TZSET
476       tzset ();
477 # endif
478     }
479 #endif
480
481   if (hour12 > 12)
482     hour12 -= 12;
483   else
484     if (hour12 == 0)
485       hour12 = 12;
486
487   for (f = format; *f != '\0'; ++f)
488     {
489       int pad = 0;              /* Padding for number ('-', '_', or 0).  */
490       int modifier;             /* Field modifier ('E', 'O', or 0).  */
491       int digits;               /* Max digits for numeric format.  */
492       int number_value;         /* Numeric value to be printed.  */
493       int negative_number;      /* 1 if the number is negative.  */
494       const char *subfmt;
495       char *bufp;
496       char buf[1 + (sizeof (int) < sizeof (time_t)
497                     ? INT_STRLEN_BOUND (time_t)
498                     : INT_STRLEN_BOUND (int))];
499       int width = -1;
500       int to_lowcase = 0;
501       int to_uppcase = 0;
502       int change_case = 0;
503       int format_char;
504
505 #if DO_MULTIBYTE
506
507        switch (*f)
508         {
509         case '%':
510           break;
511
512         case '\a': case '\b': case '\t': case '\n':
513         case '\v': case '\f': case '\r':
514         case ' ': case '!': case '"': case '#': case '&': case'\'':
515         case '(': case ')': case '*': case '+': case ',': case '-':
516         case '.': case '/': case '0': case '1': case '2': case '3':
517         case '4': case '5': case '6': case '7': case '8': case '9':
518         case ':': case ';': case '<': case '=': case '>': case '?':
519         case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
520         case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
521         case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
522         case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
523         case 'Y': case 'Z': case '[': case'\\': case ']': case '^':
524         case '_': case 'a': case 'b': case 'c': case 'd': case 'e':
525         case 'f': case 'g': case 'h': case 'i': case 'j': case 'k':
526         case 'l': case 'm': case 'n': case 'o': case 'p': case 'q':
527         case 'r': case 's': case 't': case 'u': case 'v': case 'w':
528         case 'x': case 'y': case 'z': case '{': case '|': case '}':
529         case '~':
530           /* The C Standard requires these 98 characters (plus '%') to
531              be in the basic execution character set.  None of these
532              characters can start a multibyte sequence, so they need
533              not be analyzed further.  */
534           add (1, *p = *f);
535           continue;
536
537         default:
538           /* Copy this multibyte sequence until we reach its end, find
539              an error, or come back to the initial shift state.  */
540           {
541             mbstate_t mbstate = mbstate_zero;
542             size_t len = 0;
543
544             do
545               {
546                 size_t bytes = mbrlen (f + len, (size_t) -1, &mbstate);
547
548                 if (bytes == 0)
549                   break;
550
551                 if (bytes == (size_t) -2)
552                   {
553                     len += strlen (f + len);
554                     break;
555                   }
556
557                 if (bytes == (size_t) -1)
558                   {
559                     len++;
560                     break;
561                   }
562
563                 len += bytes;
564               }
565             while (! mbsinit (&mbstate));
566
567             cpy (len, f);
568             f += len - 1;
569             continue;
570           }
571         }
572
573 #else /* ! DO_MULTIBYTE */
574
575       /* Either multibyte encodings are not supported, or they are
576          safe for formats, so any non-'%' byte can be copied through.  */
577       if (*f != '%')
578         {
579           add (1, *p = *f);
580           continue;
581         }
582
583 #endif /* ! DO_MULTIBYTE */
584
585       /* Check for flags that can modify a format.  */
586       while (1)
587         {
588           switch (*++f)
589             {
590               /* This influences the number formats.  */
591             case '_':
592             case '-':
593             case '0':
594               pad = *f;
595               continue;
596
597               /* This changes textual output.  */
598             case '^':
599               to_uppcase = 1;
600               continue;
601             case '#':
602               change_case = 1;
603               continue;
604
605             default:
606               break;
607             }
608           break;
609         }
610
611       /* As a GNU extension we allow to specify the field width.  */
612       if (ISDIGIT (*f))
613         {
614           width = 0;
615           do
616             {
617               width *= 10;
618               width += *f - '0';
619               ++f;
620             }
621           while (ISDIGIT (*f));
622         }
623
624       /* Check for modifiers.  */
625       switch (*f)
626         {
627         case 'E':
628         case 'O':
629           modifier = *f++;
630           break;
631
632         default:
633           modifier = 0;
634           break;
635         }
636
637       /* Now do the specified format.  */
638       format_char = *f;
639       switch (format_char)
640         {
641 #define DO_NUMBER(d, v) \
642           digits = width == -1 ? d : width;                                   \
643           number_value = v; goto do_number
644 #define DO_NUMBER_SPACEPAD(d, v) \
645           digits = width == -1 ? d : width;                                   \
646           number_value = v; goto do_number_spacepad
647
648         case '%':
649           if (modifier != 0)
650             goto bad_format;
651           add (1, *p = *f);
652           break;
653
654         case 'a':
655           if (modifier != 0)
656             goto bad_format;
657           if (change_case)
658             {
659               to_uppcase = 1;
660               to_lowcase = 0;
661             }
662 #if defined _NL_CURRENT || !HAVE_STRFTIME
663           cpy (aw_len, a_wkday);
664           break;
665 #else
666           goto underlying_strftime;
667 #endif
668
669         case 'A':
670           if (modifier != 0)
671             goto bad_format;
672           if (change_case)
673             {
674               to_uppcase = 1;
675               to_lowcase = 0;
676             }
677 #if defined _NL_CURRENT || !HAVE_STRFTIME
678           cpy (strlen (f_wkday), f_wkday);
679           break;
680 #else
681           goto underlying_strftime;
682 #endif
683
684         case 'b':
685         case 'h':               /* POSIX.2 extension.  */
686           if (modifier != 0)
687             goto bad_format;
688 #if defined _NL_CURRENT || !HAVE_STRFTIME
689           cpy (am_len, a_month);
690           break;
691 #else
692           goto underlying_strftime;
693 #endif
694
695         case 'B':
696           if (modifier != 0)
697             goto bad_format;
698           if (change_case)
699             {
700               to_uppcase = 1;
701               to_lowcase = 0;
702             }
703 #if defined _NL_CURRENT || !HAVE_STRFTIME
704           cpy (strlen (f_month), f_month);
705           break;
706 #else
707           goto underlying_strftime;
708 #endif
709
710         case 'c':
711           if (modifier == 'O')
712             goto bad_format;
713 #ifdef _NL_CURRENT
714           if (! (modifier == 'E'
715                  && *(subfmt = _NL_CURRENT (LC_TIME, ERA_D_T_FMT)) != '\0'))
716             subfmt = _NL_CURRENT (LC_TIME, D_T_FMT);
717 #else
718 # if HAVE_STRFTIME
719           goto underlying_strftime;
720 # else
721           subfmt = "%a %b %e %H:%M:%S %Y";
722 # endif
723 #endif
724
725         subformat:
726           {
727             char *old_start = p;
728             size_t len = my_strftime (NULL, (size_t) -1, subfmt, tp);
729             add (len, my_strftime (p, maxsize - i, subfmt, tp));
730
731             if (to_uppcase)
732               while (old_start < p)
733                 {
734                   *old_start = TOUPPER ((unsigned char) *old_start);
735                   ++old_start;
736                 }
737           }
738           break;
739
740 #if HAVE_STRFTIME && ! (defined _NL_CURRENT && HAVE_STRUCT_ERA_ENTRY)
741         underlying_strftime:
742           {
743             /* The relevant information is available only via the
744                underlying strftime implementation, so use that.  */
745             char ufmt[4];
746             char *u = ufmt;
747             char ubuf[1024]; /* enough for any single format in practice */
748             size_t len;
749             *u++ = '%';
750             if (modifier != 0)
751               *u++ = modifier;
752             *u++ = format_char;
753             *u = '\0';
754             len = strftime (ubuf, sizeof ubuf, ufmt, tp);
755             if (len == 0 && ubuf[0] != '\0')
756               return 0;
757             cpy (len, ubuf);
758           }
759           break;
760 #endif
761
762         case 'C':               /* POSIX.2 extension.  */
763           if (modifier == 'O')
764             goto bad_format;
765           if (modifier == 'E')
766             {
767 #if HAVE_STRUCT_ERA_ENTRY
768               struct era_entry *era = _nl_get_era_entry (tp);
769               if (era)
770                 {
771                   size_t len = strlen (era->name_fmt);
772                   cpy (len, era->name_fmt);
773                   break;
774                 }
775 #else
776 # if HAVE_STRFTIME
777               goto underlying_strftime;
778 # endif
779 #endif
780             }
781
782           {
783             int year = tp->tm_year + TM_YEAR_BASE;
784             DO_NUMBER (1, year / 100 - (year % 100 < 0));
785           }
786
787         case 'x':
788           if (modifier == 'O')
789             goto bad_format;
790 #ifdef _NL_CURRENT
791           if (! (modifier == 'E'
792                  && *(subfmt = _NL_CURRENT (LC_TIME, ERA_D_FMT)) != '\0'))
793             subfmt = _NL_CURRENT (LC_TIME, D_FMT);
794           goto subformat;
795 #else
796 # if HAVE_STRFTIME
797           goto underlying_strftime;
798 # else
799           /* Fall through.  */
800 # endif
801 #endif
802         case 'D':               /* POSIX.2 extension.  */
803           if (modifier != 0)
804             goto bad_format;
805           subfmt = "%m/%d/%y";
806           goto subformat;
807
808         case 'd':
809           if (modifier == 'E')
810             goto bad_format;
811
812           DO_NUMBER (2, tp->tm_mday);
813
814         case 'e':               /* POSIX.2 extension.  */
815           if (modifier == 'E')
816             goto bad_format;
817
818           DO_NUMBER_SPACEPAD (2, tp->tm_mday);
819
820           /* All numeric formats set DIGITS and NUMBER_VALUE and then
821              jump to one of these two labels.  */
822
823         do_number_spacepad:
824           /* Force `_' flag unless overwritten by `0' flag.  */
825           if (pad != '0')
826             pad = '_';
827
828         do_number:
829           /* Format the number according to the MODIFIER flag.  */
830
831           if (modifier == 'O' && 0 <= number_value)
832             {
833 #ifdef _NL_CURRENT
834               /* Get the locale specific alternate representation of
835                  the number NUMBER_VALUE.  If none exist NULL is returned.  */
836               const char *cp = _nl_get_alt_digit (number_value);
837
838               if (cp != NULL)
839                 {
840                   size_t digitlen = strlen (cp);
841                   if (digitlen != 0)
842                     {
843                       cpy (digitlen, cp);
844                       break;
845                     }
846                 }
847 #else
848 # if HAVE_STRFTIME
849               goto underlying_strftime;
850 # endif
851 #endif
852             }
853           {
854             unsigned int u = number_value;
855
856             bufp = buf + sizeof (buf);
857             negative_number = number_value < 0;
858
859             if (negative_number)
860               u = -u;
861
862             do
863               *--bufp = u % 10 + '0';
864             while ((u /= 10) != 0);
865           }
866
867         do_number_sign_and_padding:
868           if (negative_number)
869             *--bufp = '-';
870
871           if (pad != '-')
872             {
873               int padding = digits - (buf + sizeof (buf) - bufp);
874
875               if (pad == '_')
876                 {
877                   while (0 < padding--)
878                     *--bufp = ' ';
879                 }
880               else
881                 {
882                   bufp += negative_number;
883                   while (0 < padding--)
884                     *--bufp = '0';
885                   if (negative_number)
886                     *--bufp = '-';
887                 }
888             }
889
890           cpy (buf + sizeof (buf) - bufp, bufp);
891           break;
892
893         case 'F':
894           if (modifier != 0)
895             goto bad_format;
896           subfmt = "%Y-%m-%d";
897           goto subformat;
898
899         case 'H':
900           if (modifier == 'E')
901             goto bad_format;
902
903           DO_NUMBER (2, tp->tm_hour);
904
905         case 'I':
906           if (modifier == 'E')
907             goto bad_format;
908
909           DO_NUMBER (2, hour12);
910
911         case 'k':               /* GNU extension.  */
912           if (modifier == 'E')
913             goto bad_format;
914
915           DO_NUMBER_SPACEPAD (2, tp->tm_hour);
916
917         case 'l':               /* GNU extension.  */
918           if (modifier == 'E')
919             goto bad_format;
920
921           DO_NUMBER_SPACEPAD (2, hour12);
922
923         case 'j':
924           if (modifier == 'E')
925             goto bad_format;
926
927           DO_NUMBER (3, 1 + tp->tm_yday);
928
929         case 'M':
930           if (modifier == 'E')
931             goto bad_format;
932
933           DO_NUMBER (2, tp->tm_min);
934
935         case 'm':
936           if (modifier == 'E')
937             goto bad_format;
938
939           DO_NUMBER (2, tp->tm_mon + 1);
940
941         case 'n':               /* POSIX.2 extension.  */
942           add (1, *p = '\n');
943           break;
944
945         case 'P':
946           to_lowcase = 1;
947 #if !defined _NL_CURRENT && HAVE_STRFTIME
948           format_char = 'p';
949 #endif
950           /* FALLTHROUGH */
951
952         case 'p':
953           if (change_case)
954             {
955               to_uppcase = 0;
956               to_lowcase = 1;
957             }
958 #if defined _NL_CURRENT || !HAVE_STRFTIME
959           cpy (ap_len, ampm);
960           break;
961 #else
962           goto underlying_strftime;
963 #endif
964
965         case 'R':               /* GNU extension.  */
966           subfmt = "%H:%M";
967           goto subformat;
968
969         case 'r':               /* POSIX.2 extension.  */
970 #ifdef _NL_CURRENT
971           if (*(subfmt = _NL_CURRENT (LC_TIME, T_FMT_AMPM)) == '\0')
972 #endif
973             subfmt = "%I:%M:%S %p";
974           goto subformat;
975
976         case 'S':
977           if (modifier == 'E')
978             goto bad_format;
979
980           DO_NUMBER (2, tp->tm_sec);
981
982         case 's':               /* GNU extension.  */
983           {
984             struct tm ltm;
985             time_t t;
986
987             ltm = *tp;
988             t = mktime (&ltm);
989
990             /* Generate string value for T using time_t arithmetic;
991                this works even if sizeof (long) < sizeof (time_t).  */
992
993             bufp = buf + sizeof (buf);
994             negative_number = t < 0;
995
996             do
997               {
998                 int d = t % 10;
999                 t /= 10;
1000
1001                 if (negative_number)
1002                   {
1003                     d = -d;
1004
1005                     /* Adjust if division truncates to minus infinity.  */
1006                     if (0 < -1 % 10 && d < 0)
1007                       {
1008                         t++;
1009                         d += 10;
1010                       }
1011                   }
1012
1013                 *--bufp = d + '0';
1014               }
1015             while (t != 0);
1016
1017             digits = 1;
1018             goto do_number_sign_and_padding;
1019           }
1020
1021         case 'X':
1022           if (modifier == 'O')
1023             goto bad_format;
1024 #ifdef _NL_CURRENT
1025           if (! (modifier == 'E'
1026                  && *(subfmt = _NL_CURRENT (LC_TIME, ERA_T_FMT)) != '\0'))
1027             subfmt = _NL_CURRENT (LC_TIME, T_FMT);
1028           goto subformat;
1029 #else
1030 # if HAVE_STRFTIME
1031           goto underlying_strftime;
1032 # else
1033           /* Fall through.  */
1034 # endif
1035 #endif
1036         case 'T':               /* POSIX.2 extension.  */
1037           subfmt = "%H:%M:%S";
1038           goto subformat;
1039
1040         case 't':               /* POSIX.2 extension.  */
1041           add (1, *p = '\t');
1042           break;
1043
1044         case 'u':               /* POSIX.2 extension.  */
1045           DO_NUMBER (1, (tp->tm_wday - 1 + 7) % 7 + 1);
1046
1047         case 'U':
1048           if (modifier == 'E')
1049             goto bad_format;
1050
1051           DO_NUMBER (2, (tp->tm_yday - tp->tm_wday + 7) / 7);
1052
1053         case 'V':
1054         case 'g':               /* GNU extension.  */
1055         case 'G':               /* GNU extension.  */
1056           if (modifier == 'E')
1057             goto bad_format;
1058           {
1059             int year = tp->tm_year + TM_YEAR_BASE;
1060             int days = iso_week_days (tp->tm_yday, tp->tm_wday);
1061
1062             if (days < 0)
1063               {
1064                 /* This ISO week belongs to the previous year.  */
1065                 year--;
1066                 days = iso_week_days (tp->tm_yday + (365 + __isleap (year)),
1067                                       tp->tm_wday);
1068               }
1069             else
1070               {
1071                 int d = iso_week_days (tp->tm_yday - (365 + __isleap (year)),
1072                                        tp->tm_wday);
1073                 if (0 <= d)
1074                   {
1075                     /* This ISO week belongs to the next year.  */
1076                     year++;
1077                     days = d;
1078                   }
1079               }
1080
1081             switch (*f)
1082               {
1083               case 'g':
1084                 DO_NUMBER (2, (year % 100 + 100) % 100);
1085
1086               case 'G':
1087                 DO_NUMBER (1, year);
1088
1089               default:
1090                 DO_NUMBER (2, days / 7 + 1);
1091               }
1092           }
1093
1094         case 'W':
1095           if (modifier == 'E')
1096             goto bad_format;
1097
1098           DO_NUMBER (2, (tp->tm_yday - (tp->tm_wday - 1 + 7) % 7 + 7) / 7);
1099
1100         case 'w':
1101           if (modifier == 'E')
1102             goto bad_format;
1103
1104           DO_NUMBER (1, tp->tm_wday);
1105
1106         case 'Y':
1107           if (modifier == 'E')
1108             {
1109 #if HAVE_STRUCT_ERA_ENTRY
1110               struct era_entry *era = _nl_get_era_entry (tp);
1111               if (era)
1112                 {
1113                   subfmt = strchr (era->name_fmt, '\0') + 1;
1114                   goto subformat;
1115                 }
1116 #else
1117 # if HAVE_STRFTIME
1118               goto underlying_strftime;
1119 # endif
1120 #endif
1121             }
1122           if (modifier == 'O')
1123             goto bad_format;
1124           else
1125             DO_NUMBER (1, tp->tm_year + TM_YEAR_BASE);
1126
1127         case 'y':
1128           if (modifier == 'E')
1129             {
1130 #if HAVE_STRUCT_ERA_ENTRY
1131               struct era_entry *era = _nl_get_era_entry (tp);
1132               if (era)
1133                 {
1134                   int delta = tp->tm_year - era->start_date[0];
1135                   DO_NUMBER (1, (era->offset
1136                                  + (era->direction == '-' ? -delta : delta)));
1137                 }
1138 #else
1139 # if HAVE_STRFTIME
1140               goto underlying_strftime;
1141 # endif
1142 #endif
1143             }
1144           DO_NUMBER (2, (tp->tm_year % 100 + 100) % 100);
1145
1146         case 'Z':
1147           if (change_case)
1148             {
1149               to_uppcase = 0;
1150               to_lowcase = 1;
1151             }
1152
1153 #if HAVE_TZNAME
1154           /* The tzset() call might have changed the value.  */
1155           if (!(zone && *zone) && tp->tm_isdst >= 0)
1156             zone = tzname[tp->tm_isdst];
1157 #endif
1158           if (! zone)
1159             zone = "";          /* POSIX.2 requires the empty string here.  */
1160
1161           cpy (strlen (zone), zone);
1162           break;
1163
1164         case 'z':               /* GNU extension.  */
1165           if (tp->tm_isdst < 0)
1166             break;
1167
1168           {
1169             int diff;
1170 #if HAVE_TM_GMTOFF
1171             diff = tp->tm_gmtoff;
1172 #else
1173             if (ut)
1174               diff = 0;
1175             else
1176               {
1177                 struct tm gtm;
1178                 struct tm ltm;
1179                 time_t lt;
1180
1181                 ltm = *tp;
1182                 lt = mktime (&ltm);
1183
1184                 if (lt == (time_t) -1)
1185                   {
1186                     /* mktime returns -1 for errors, but -1 is also a
1187                        valid time_t value.  Check whether an error really
1188                        occurred.  */
1189                     struct tm tm;
1190
1191                     if (! my_strftime_localtime_r (&lt, &tm)
1192                         || ((ltm.tm_sec ^ tm.tm_sec)
1193                             | (ltm.tm_min ^ tm.tm_min)
1194                             | (ltm.tm_hour ^ tm.tm_hour)
1195                             | (ltm.tm_mday ^ tm.tm_mday)
1196                             | (ltm.tm_mon ^ tm.tm_mon)
1197                             | (ltm.tm_year ^ tm.tm_year)))
1198                       break;
1199                   }
1200
1201                 if (! my_strftime_gmtime_r (&lt, &gtm))
1202                   break;
1203
1204                 diff = tm_diff (&ltm, &gtm);
1205               }
1206 #endif
1207
1208             if (diff < 0)
1209               {
1210                 add (1, *p = '-');
1211                 diff = -diff;
1212               }
1213             else
1214               add (1, *p = '+');
1215
1216             diff /= 60;
1217             DO_NUMBER (4, (diff / 60) * 100 + diff % 60);
1218           }
1219
1220         case '\0':              /* GNU extension: % at end of format.  */
1221             --f;
1222             /* Fall through.  */
1223         default:
1224           /* Unknown format; output the format, including the '%',
1225              since this is most likely the right thing to do if a
1226              multibyte string has been misparsed.  */
1227         bad_format:
1228           {
1229             int flen;
1230             for (flen = 1; f[1 - flen] != '%'; flen++)
1231               continue;
1232             cpy (flen, &f[1 - flen]);
1233           }
1234           break;
1235         }
1236     }
1237
1238   if (p && maxsize != 0)
1239     *p = '\0';
1240   return i;
1241 }
1242
1243
1244 #ifdef emacs
1245 /* For Emacs we have a separate interface which corresponds to the normal
1246    strftime function and does not have the extra information whether the
1247    TP arguments comes from a `gmtime' call or not.  */
1248 size_t
1249 emacs_strftime (s, maxsize, format, tp)
1250       char *s;
1251       size_t maxsize;
1252       const char *format;
1253       const struct tm *tp;
1254 {
1255   return my_strftime (s, maxsize, format, tp, 0);
1256 }
1257 #endif