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