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