WebSVN – Kolibri OS – Diff – /contrib/sdk/sources/newlib/libc/time/strftime.c

 /* NOTE:  This file defines both strftime() and wcsftime().  Take care when
  * making changes.  See also wcsftime.c, and note the (small) overlap in the
  * manual description, taking care to edit both as needed.  */
 /*
  * strftime.c
  * Original Author:	G. Haley
  * Additions from:	Eric Blake
  * Changes to allow dual use as wcstime, also:	Craig Howland
+ *
  * Places characters into the array pointed to by s as controlled by the string
  * pointed to by format. If the total number of resulting characters including
  * the terminating null character is not more than maxsize, returns the number
  * of characters placed into the array pointed to by s (not including the
  * terminating null character); otherwise zero is returned and the contents of
  * the array indeterminate.
  */
 /*
 FUNCTION
 <>---convert date and time to a formatted string
 INDEX
 	strftime
 ANSI_SYNOPSIS
 	#include
-	size_t strftime(char *<[s]>, size_t <[maxsize]>,
+	size_t strftime(char *restrict <[s]>, size_t <[maxsize]>,
+			const char *restrict <[format]>,
-			const char *<[format]>, const struct tm *<[timp]>);
+                        const struct tm *restrict <[timp]>);
 TRAD_SYNOPSIS
 	#include
 	size_t strftime(<[s]>, <[maxsize]>, <[format]>, <[timp]>)
 	char *<[s]>;
 	size_t <[maxsize]>;
 	char *<[format]>;
 	struct tm *<[timp]>;
 DESCRIPTION
 <> converts a <> representation of the time (at
 <[timp]>) into a null-terminated string, starting at <[s]> and occupying
 no more than <[maxsize]> characters.
 You control the format of the output using the string at <[format]>.
 <<*<[format]>>> can contain two kinds of specifications: text to be
 copied literally into the formatted string, and time conversion
 specifications.  Time conversion specifications are two- and
 three-character sequences beginning with `<<%>>' (use `<<%%>>' to
 include a percent sign in the output).  Each defined conversion
 specification selects only the specified field(s) of calendar time
 data from <<*<[timp]>>>, and converts it to a string in one of the
 following ways:
 o+
 o %a
 The abbreviated weekday name according to the current locale. [tm_wday]
 o %A
 The full weekday name according to the current locale.
 In the default "C" locale, one of `<>', `<>', `<>',
 `<>', `<>', `<>', `<>'. [tm_wday]
 o %b
 The abbreviated month name according to the current locale. [tm_mon]
 o %B
 The full month name according to the current locale.
 In the default "C" locale, one of `<>', `<>',
 `<>', `<>', `<>', `<>', `<>',
 `<>', `<>', `<>', `<>',
 `<>'. [tm_mon]
 o %c
 The preferred date and time representation for the current locale.
 [tm_sec, tm_min, tm_hour, tm_mday, tm_mon, tm_year, tm_wday]
 o %C
 The century, that is, the year divided by 100 then truncated.  For
 -digit years, the result is zero-padded and exactly two characters;
 but for other years, there may a negative sign or more digits.  In
 this way, `<<%C%y>>' is equivalent to `<<%Y>>'. [tm_year]
 o %d
 The day of the month, formatted with two digits (from `<<01>>' to
 `<<31>>'). [tm_mday]
 o %D
 A string representing the date, in the form `<<"%m/%d/%y">>'.
 [tm_mday, tm_mon, tm_year]
 o %e
 The day of the month, formatted with leading space if single digit
 (from `<<1>>' to `<<31>>'). [tm_mday]
 o %E<>
 In some locales, the E modifier selects alternative representations of
 certain modifiers <>.  In newlib, it is ignored, and treated as %<>.
 o %F
 A string representing the ISO 8601:2000 date format, in the form
 `<<"%Y-%m-%d">>'. [tm_mday, tm_mon, tm_year]
 o %g
 The last two digits of the week-based year, see specifier %G (from
 `<<00>>' to `<<99>>'). [tm_year, tm_wday, tm_yday]
 o %G
 The week-based year. In the ISO 8601:2000 calendar, week 1 of the year
 includes January 4th, and begin on Mondays. Therefore, if January 1st,
 nd, or 3rd falls on a Sunday, that day and earlier belong to the last
 week of the previous year; and if December 29th, 30th, or 31st falls
 on Monday, that day and later belong to week 1 of the next year.  For
 consistency with %Y, it always has at least four characters.
 Example: "%G" for Saturday 2nd January 1999 gives "1998", and for
 Tuesday 30th December 1997 gives "1998". [tm_year, tm_wday, tm_yday]
 o %h
 Synonym for "%b". [tm_mon]
 o %H
 The hour (on a 24-hour clock), formatted with two digits (from
 `<<00>>' to `<<23>>'). [tm_hour]
 o %I
 The hour (on a 12-hour clock), formatted with two digits (from
 `<<01>>' to `<<12>>'). [tm_hour]
 o %j
 The count of days in the year, formatted with three digits
 (from `<<001>>' to `<<366>>'). [tm_yday]
 o %k
 The hour (on a 24-hour clock), formatted with leading space if single
 digit (from `<<0>>' to `<<23>>'). Non-POSIX extension (c.p. %I). [tm_hour]
 o %l
 The hour (on a 12-hour clock), formatted with leading space if single
 digit (from `<<1>>' to `<<12>>'). Non-POSIX extension (c.p. %H). [tm_hour]
 o %m
 The month number, formatted with two digits (from `<<01>>' to `<<12>>').
 [tm_mon]
 o %M
 The minute, formatted with two digits (from `<<00>>' to `<<59>>'). [tm_min]
 o %n
 A newline character (`<<\n>>').
 o %O<>
 In some locales, the O modifier selects alternative digit characters
 for certain modifiers <>.  In newlib, it is ignored, and treated as %<>.
 o %p
 Either `<>' or `<>' as appropriate, or the corresponding strings for
 the current locale. [tm_hour]
 o %P
 Same as '<<%p>>', but in lowercase.  This is a GNU extension. [tm_hour]
 o %r
 Replaced by the time in a.m. and p.m. notation.  In the "C" locale this
 is equivalent to "%I:%M:%S %p".  In locales which don't define a.m./p.m.
 notations, the result is an empty string. [tm_sec, tm_min, tm_hour]
 o %R
 The 24-hour time, to the minute.  Equivalent to "%H:%M". [tm_min, tm_hour]
 o %S
 The second, formatted with two digits (from `<<00>>' to `<<60>>').  The
 value 60 accounts for the occasional leap second. [tm_sec]
 o %t
 A tab character (`<<\t>>').
 o %T
 The 24-hour time, to the second.  Equivalent to "%H:%M:%S". [tm_sec,
 tm_min, tm_hour]
 o %u
 The weekday as a number, 1-based from Monday (from `<<1>>' to
 `<<7>>'). [tm_wday]
 o %U
 The week number, where weeks start on Sunday, week 1 contains the first
 Sunday in a year, and earlier days are in week 0.  Formatted with two
 digits (from `<<00>>' to `<<53>>').  See also <<%W>>. [tm_wday, tm_yday]
 o %V
 The week number, where weeks start on Monday, week 1 contains January 4th,
 and earlier days are in the previous year.  Formatted with two digits
 (from `<<01>>' to `<<53>>').  See also <<%G>>. [tm_year, tm_wday, tm_yday]
 o %w
 The weekday as a number, 0-based from Sunday (from `<<0>>' to `<<6>>').
 [tm_wday]
 o %W
 The week number, where weeks start on Monday, week 1 contains the first
 Monday in a year, and earlier days are in week 0.  Formatted with two
 digits (from `<<00>>' to `<<53>>'). [tm_wday, tm_yday]
 o %x
 Replaced by the preferred date representation in the current locale.
 In the "C" locale this is equivalent to "%m/%d/%y".
 [tm_mon, tm_mday, tm_year]
 o %X
 Replaced by the preferred time representation in the current locale.
 In the "C" locale this is equivalent to "%H:%M:%S". [tm_sec, tm_min, tm_hour]
 o %y
 The last two digits of the year (from `<<00>>' to `<<99>>'). [tm_year]
 (Implementation interpretation:  always positive, even for negative years.)
 o %Y
 The full year, equivalent to <<%C%y>>.  It will always have at least four
 characters, but may have more.  The year is accurate even when tm_year
 added to the offset of 1900 overflows an int. [tm_year]
 o %z
 The offset from UTC.  The format consists of a sign (negative is west of
 Greewich), two characters for hour, then two characters for minutes
 (-hhmm or +hhmm).  If tm_isdst is negative, the offset is unknown and no
 output is generated; if it is zero, the offset is the standard offset for
 the current time zone; and if it is positive, the offset is the daylight
 savings offset for the current timezone. The offset is determined from
 the TZ environment variable, as if by calling tzset(). [tm_isdst]
 o %Z
 The time zone name.  If tm_isdst is negative, no output is generated.
 Otherwise, the time zone name is based on the TZ environment variable,
 as if by calling tzset(). [tm_isdst]
 o %%
 A single character, `<<%>>'.
 o-
 RETURNS
 When the formatted time takes up no more than <[maxsize]> characters,
 the result is the length of the formatted string.  Otherwise, if the
 formatting operation was abandoned due to lack of room, the result is
 <<0>>, and the string starting at <[s]> corresponds to just those
 parts of <<*<[format]>>> that could be completely filled in within the
 <[maxsize]> limit.
 PORTABILITY
 ANSI C requires <>, but does not specify the contents of
 <<*<[s]>>> when the formatted string would require more than
 <[maxsize]> characters.  Unrecognized specifiers and fields of
 <> that are out of range cause undefined results.  Since some
 formats expand to 0 bytes, it is wise to set <<*<[s]>>> to a nonzero
 value beforehand to distinguish between failure and an empty string.
 This implementation does not support <> being NULL, nor overlapping
 <> and <>.
 <> requires no supporting OS subroutines.
 BUGS
 <> ignores the LC_TIME category of the current locale, hard-coding
 the "C" locale settings.
 */
 #include
 #include
 #include
 #include
 #include
 #include
 #include
 #include
 #include
 #include
+#include "local.h"
+#include "../locale/timelocal.h"
 /* Defines to make the file dual use for either strftime() or wcsftime().
  * To get wcsftime, define MAKE_WCSFTIME.
  * To get strftime, do not define MAKE_WCSFTIME.
  * Names are kept friendly to strftime() usage.  The biggest ugliness is the
  * use of the CQ() macro to make either regular character constants and
  * string literals or wide-character constants and wide-character-string
  * literals, as appropriate.  */
 #if !defined(MAKE_WCSFTIME)
 #  define CHAR      char        /* string type basis */
 #  define CQ(a)     a       /* character constant qualifier */
 #  define SFLG              /* %s flag (null for normal char) */
 #  define _ctloc(x) (ctloclen = strlen (ctloc = _CurrentTimeLocale->x), ctloc)
+#  define snprintf	sniprintf	/* avoid to pull in FP functions. */
 #  define TOLOWER(c)    tolower((int)(unsigned char)(c))
 #  define STRTOUL(c,p,b) strtoul((c),(p),(b))
 #  define STRCPY(a,b)   strcpy((a),(b))
 #  define STRCHR(a,b)   strchr((a),(b))
 #  define STRLEN(a) strlen(a)
 # else
 #  define strftime  wcsftime    /* Alternate function name */
 #  define CHAR      wchar_t     /* string type basis */
 #  define CQ(a)     L##a        /* character constant qualifier */
 #  define snprintf  swprintf    /* wide-char equivalent function name */
 #  define strncmp   wcsncmp     /* wide-char equivalent function name */
 #  define TOLOWER(c)    towlower((wint_t)(c))
 #  define STRTOUL(c,p,b) wcstoul((c),(p),(b))
 #  define STRCPY(a,b)   wcscpy((a),(b))
 #  define STRCHR(a,b)   wcschr((a),(b))
 #  define STRLEN(a) wcslen(a)
 #  define SFLG      "l"     /* %s flag (l for wide char) */
 #  ifdef __HAVE_LOCALE_INFO_EXTENDED__
 #   define _ctloc(x) (ctloclen = wcslen (ctloc = _CurrentTimeLocale->w##x), \
               ctloc)
 #  else
 #   define CTLOCBUFLEN   256        /* Arbitrary big buffer size */
     const wchar_t *
     __ctloc (wchar_t *buf, const char *elem, size_t *len_ret)
+    {
       buf[CTLOCBUFLEN - 1] = L'\0';
       *len_ret = mbstowcs (buf, elem, CTLOCBUFLEN - 1);
       if (*len_ret == (size_t) -1 )
     *len_ret = 0;
       return buf;
+    }
 #   define _ctloc(x) (ctloc = __ctloc (ctlocbuf, _CurrentTimeLocale->x, \
               &ctloclen))
 #  endif
 #endif  /* MAKE_WCSFTIME */
+#define CHECK_LENGTH()	if (len < 0 || (count += len) >= maxsize) \
+			  return 0
-size_t _DEFUN (strftime, (s, maxsize, format, tim_p),
+/* Enforce the coding assumptions that YEAR_BASE is positive.  (%C, %Y, etc.) */
+#if YEAR_BASE < 0
+#  error "YEAR_BASE < 0"
-	CHAR *s _AND
+#endif
+static _CONST int dname_len[7] =
+{6, 6, 7, 9, 8, 6, 8};
+/* Using the tm_year, tm_wday, and tm_yday components of TIM_P, return
+   -1, 0, or 1 as the adjustment to add to the year for the ISO week
+   numbering used in "%g%G%V", avoiding overflow.  */
-	size_t maxsize _AND
+static int
-	_CONST CHAR *format _AND
+_DEFUN (iso_year_adjust, (tim_p),
+	_CONST struct tm *tim_p)
+{
+  /* Account for fact that tm_year==0 is year 1900.  */
+  int leap = isleap (tim_p->tm_year + (YEAR_BASE
+				       - (tim_p->tm_year < 0 ? 0 : 2000)));
+  /* Pack the yday, wday, and leap year into a single int since there are so
+     many disparate cases.  */
+#define PACK(yd, wd, lp) (((yd) << 4) + (wd << 1) + (lp))
+  switch (PACK (tim_p->tm_yday, tim_p->tm_wday, leap))
+    {
+    case PACK (0, 5, 0): /* Jan 1 is Fri, not leap.  */
+    case PACK (0, 6, 0): /* Jan 1 is Sat, not leap.  */
+    case PACK (0, 0, 0): /* Jan 1 is Sun, not leap.  */
+    case PACK (0, 5, 1): /* Jan 1 is Fri, leap year.  */
+    case PACK (0, 6, 1): /* Jan 1 is Sat, leap year.  */
+    case PACK (0, 0, 1): /* Jan 1 is Sun, leap year.  */
+    case PACK (1, 6, 0): /* Jan 2 is Sat, not leap.  */
+    case PACK (1, 0, 0): /* Jan 2 is Sun, not leap.  */
+    case PACK (1, 6, 1): /* Jan 2 is Sat, leap year.  */
+    case PACK (1, 0, 1): /* Jan 2 is Sun, leap year.  */
+    case PACK (2, 0, 0): /* Jan 3 is Sun, not leap.  */
+    case PACK (2, 0, 1): /* Jan 3 is Sun, leap year.  */
+      return -1; /* Belongs to last week of previous year.  */
+    case PACK (362, 1, 0): /* Dec 29 is Mon, not leap.  */
+    case PACK (363, 1, 1): /* Dec 29 is Mon, leap year.  */
+    case PACK (363, 1, 0): /* Dec 30 is Mon, not leap.  */
+    case PACK (363, 2, 0): /* Dec 30 is Tue, not leap.  */
+    case PACK (364, 1, 1): /* Dec 30 is Mon, leap year.  */
+    case PACK (364, 2, 1): /* Dec 30 is Tue, leap year.  */
+    case PACK (364, 1, 0): /* Dec 31 is Mon, not leap.  */
+    case PACK (364, 2, 0): /* Dec 31 is Tue, not leap.  */
+    case PACK (364, 3, 0): /* Dec 31 is Wed, not leap.  */
+    case PACK (365, 1, 1): /* Dec 31 is Mon, leap year.  */
+    case PACK (365, 2, 1): /* Dec 31 is Tue, leap year.  */
+    case PACK (365, 3, 1): /* Dec 31 is Wed, leap year.  */
+      return 1; /* Belongs to first week of next year.  */
+    }
+  return 0; /* Belongs to specified year.  */
+#undef PACK
+}
+#ifdef _WANT_C99_TIME_FORMATS
+typedef struct {
+  int   year;
+  CHAR *era_C;
+  CHAR *era_Y;
+} era_info_t;
+static era_info_t *
+#if defined (MAKE_WCSFTIME) && defined (__HAVE_LOCALE_INFO_EXTENDED__)
+get_era_info (const struct tm *tim_p, const wchar_t *era)
+#else
+get_era_info (const struct tm *tim_p, const char *era)
+#endif
+{
+#if defined (MAKE_WCSFTIME) && defined (__HAVE_LOCALE_INFO_EXTENDED__)
+  wchar_t *c;
+  const wchar_t *dir;
+# define ERA_STRCHR(a,b)	wcschr((a),(b))
+# define ERA_STRNCPY(a,b,c)	wcsncpy((a),(b),(c))
+# define ERA_STRTOL(a,b,c)	wcstol((a),(b),(c))
+#else
+  char *c;
+  const char *dir;
+# define ERA_STRCHR(a,b)	strchr((a),(b))
+# define ERA_STRNCPY(a,b,c)	strncpy((a),(b),(c))
+# define ERA_STRTOL(a,b,c)	strtol((a),(b),(c))
+#endif
+  long offset;
+  struct tm stm, etm;
+  era_info_t *ei;
+  ei = (era_info_t *) calloc (1, sizeof (era_info_t));
+  if (!ei)
+    return NULL;
+  stm.tm_isdst = etm.tm_isdst = 0;
+  while (era)
+    {
+      dir = era;
+      era += 2;
+      offset = ERA_STRTOL (era, &c, 10);
+      era = c + 1;
+      stm.tm_year = ERA_STRTOL (era, &c, 10) - YEAR_BASE;
+      /* Adjust offset for negative gregorian dates. */
+      if (stm.tm_year <= -YEAR_BASE)
+      	++stm.tm_year;
+      stm.tm_mon = ERA_STRTOL (c + 1, &c, 10) - 1;
+      stm.tm_mday = ERA_STRTOL (c + 1, &c, 10);
+      stm.tm_hour = stm.tm_min = stm.tm_sec = 0;
+      era = c + 1;
+      if (era[0] == '-' && era[1] == '*')
+      	{
+	  etm = stm;
+	  stm.tm_year = INT_MIN;
+	  stm.tm_mon = stm.tm_mday = stm.tm_hour = stm.tm_min = stm.tm_sec = 0;
+	  era += 3;
+	}
+      else if (era[0] == '+' && era[1] == '*')
+	{
+	  etm.tm_year = INT_MAX;
+	  etm.tm_mon = 11;
+	  etm.tm_mday = 31;
+	  etm.tm_hour = 23;
+	  etm.tm_min = etm.tm_sec = 59;
+	  era += 3;
+	}
+      else
+      	{
+	  etm.tm_year = ERA_STRTOL (era, &c, 10) - YEAR_BASE;
+	  /* Adjust offset for negative gregorian dates. */
+	  if (etm.tm_year <= -YEAR_BASE)
+	    ++etm.tm_year;
+	  etm.tm_mon = ERA_STRTOL (c + 1, &c, 10) - 1;
+	  etm.tm_mday = ERA_STRTOL (c + 1, &c, 10);
+	  etm.tm_mday = 31;
+	  etm.tm_hour = 23;
+	  etm.tm_min = etm.tm_sec = 59;
+	  era = c + 1;
+	}
+      if ((tim_p->tm_year > stm.tm_year
+	   || (tim_p->tm_year == stm.tm_year
+	       && (tim_p->tm_mon > stm.tm_mon
+		   || (tim_p->tm_mon == stm.tm_mon
+		       && tim_p->tm_mday >= stm.tm_mday))))
+	  && (tim_p->tm_year < etm.tm_year
+	      || (tim_p->tm_year == etm.tm_year
+		  && (tim_p->tm_mon < etm.tm_mon
+		      || (tim_p->tm_mon == etm.tm_mon
+			  && tim_p->tm_mday <= etm.tm_mday)))))
+	{
+	  /* Gotcha */
+	  size_t len;
+	  /* year */
+	  if (*dir == '+' && stm.tm_year != INT_MIN)
+	    ei->year = tim_p->tm_year - stm.tm_year + offset;
+	  else
+	    ei->year = etm.tm_year - tim_p->tm_year + offset;
+	  /* era_C */
+	  c = ERA_STRCHR (era, ':');
+#if defined (MAKE_WCSFTIME) && !defined (__HAVE_LOCALE_INFO_EXTENDED__)
+	  len = mbsnrtowcs (NULL, &era, c - era, 0, NULL);
+	  if (len == (size_t) -1)
+	    {
+	      free (ei);
+	      return NULL;
+	    }
+#else
+	  len = c - era;
+#endif
+	  ei->era_C = (CHAR *) malloc ((len + 1) * sizeof (CHAR));
+	  if (!ei->era_C)
+	    {
+	      free (ei);
+	      return NULL;
+	    }
+#if defined (MAKE_WCSFTIME) && !defined (__HAVE_LOCALE_INFO_EXTENDED__)
+	  len = mbsnrtowcs (ei->era_C, &era, c - era, len + 1, NULL);
+#else
+	  ERA_STRNCPY (ei->era_C, era, len);
+	  era += len;
+#endif
+	  ei->era_C[len] = CQ('\0');
+	  /* era_Y */
+	  ++era;
+	  c = ERA_STRCHR (era, ';');
+	  if (!c)
+	    c = ERA_STRCHR (era, '\0');
+#if defined (MAKE_WCSFTIME) && !defined (__HAVE_LOCALE_INFO_EXTENDED__)
+	  len = mbsnrtowcs (NULL, &era, c - era, 0, NULL);
+	  if (len == (size_t) -1)
+	    {
+	      free (ei->era_C);
+	      free (ei);
+	      return NULL;
+	    }
+#else
+	  len = c - era;
+#endif
+	  ei->era_Y = (CHAR *) malloc ((len + 1) * sizeof (CHAR));
+	  if (!ei->era_Y)
+	    {
+	      free (ei->era_C);
+	      free (ei);
+	      return NULL;
+	    }
+#if defined (MAKE_WCSFTIME) && !defined (__HAVE_LOCALE_INFO_EXTENDED__)
+	  len = mbsnrtowcs (ei->era_Y, &era, c - era, len + 1, NULL);
+#else
+	  ERA_STRNCPY (ei->era_Y, era, len);
+	  era += len;
+#endif
+	  ei->era_Y[len] = CQ('\0');
+	  return ei;
+	}
+      else
+	era = ERA_STRCHR (era, ';');
+      if (era)
+	++era;
+    }
+  return NULL;
+}
+static void
+free_era_info (era_info_t *ei)
+{
+  free (ei->era_C);
+  free (ei->era_Y);
+  free (ei);
+}
+typedef struct {
+  size_t num;
+  CHAR **digit;
+  CHAR *buffer;
+} alt_digits_t;
+static alt_digits_t *
+#if defined (MAKE_WCSFTIME) && defined (__HAVE_LOCALE_INFO_EXTENDED__)
+get_alt_digits (const wchar_t *alt_digits)
+#else
+get_alt_digits (const char *alt_digits)
+#endif
+{
+  alt_digits_t *adi;
+#if defined (MAKE_WCSFTIME) && defined (__HAVE_LOCALE_INFO_EXTENDED__)
+  const wchar_t *a, *e;
+# define ALT_STRCHR(a,b)	wcschr((a),(b))
+# define ALT_STRCPY(a,b)	wcscpy((a),(b))
+# define ALT_STRLEN(a)		wcslen(a)
+#else
+  const char *a, *e;
+# define ALT_STRCHR(a,b)	strchr((a),(b))
+# define ALT_STRCPY(a,b)	strcpy((a),(b))
+# define ALT_STRLEN(a)		strlen(a)
+#endif
+  CHAR *aa, *ae;
+  size_t len;
+  adi = (alt_digits_t *) calloc (1, sizeof (alt_digits_t));
+  if (!adi)
+    return NULL;
+  /* Compute number of alt_digits. */
+  adi->num = 1;
+  for (a = alt_digits; (e = ALT_STRCHR (a, ';')) != NULL; a = e + 1)
+      ++adi->num;
+  /* Allocate the `digit' array, which is an array of `num' pointers into
+     `buffer'. */
+  adi->digit = (CHAR **) calloc (adi->num, sizeof (CHAR **));
+  if (!adi->digit)
+    {
+      free (adi);
+      return NULL;
+    }
+  /* Compute memory required for `buffer'. */
+#if defined (MAKE_WCSFTIME) && !defined (__HAVE_LOCALE_INFO_EXTENDED__)
+  len = mbstowcs (NULL, alt_digits, 0);
+  if (len == (size_t) -1)
+    {
+      free (adi->digit);
+      free (adi);
+      return NULL;
+    }
+#else
+  len = ALT_STRLEN (alt_digits);
+#endif
+  /* Allocate it. */
+  adi->buffer = (CHAR *) malloc ((len + 1) * sizeof (CHAR));
+  if (!adi->buffer)
+    {
+      free (adi->digit);
+      free (adi);
+      return NULL;
+    }
+  /* Store digits in it. */
+#if defined (MAKE_WCSFTIME) && !defined (__HAVE_LOCALE_INFO_EXTENDED__)
+  mbstowcs (adi->buffer, alt_digits, len + 1);
+#else
+  ALT_STRCPY (adi->buffer, alt_digits);
+#endif
+  /* Store the pointers into `buffer' into the appropriate `digit' slot. */
+  for (len = 0, aa = adi->buffer; (ae = STRCHR (aa, CQ(';'))) != NULL;
+       ++len, aa = ae + 1)
+    {
+      *ae = '\0';
+      adi->digit[len] = aa;
+    }
+  adi->digit[len] = aa;
+  return adi;
+}
+static void
+free_alt_digits (alt_digits_t *adi)
+{
+  free (adi->digit);
+  free (adi->buffer);
+  free (adi);
+}
+/* Return 0 if no alt_digit is available for a number.
+   Return -1 if buffer size isn't sufficient to hold alternative digit.
+   Return length of new digit otherwise. */
+static int
+conv_to_alt_digits (CHAR *buf, size_t bufsiz, unsigned num, alt_digits_t *adi)
+{
+  if (num < adi->num)
+    {
+      size_t len = STRLEN (adi->digit[num]);
+      if (bufsiz < len)
+      	return -1;
+      STRCPY (buf, adi->digit[num]);
+      return (int) len;
+    }
+  return 0;
+}
+static size_t __strftime (CHAR *, size_t, const CHAR *, const struct tm *,
+			  era_info_t **, alt_digits_t **);
+size_t
+_DEFUN (strftime, (s, maxsize, format, tim_p),
+	CHAR *__restrict s _AND
+	size_t maxsize _AND
+	_CONST CHAR *__restrict format _AND
+	_CONST struct tm *__restrict tim_p)
+{
+  era_info_t *era_info = NULL;
+  alt_digits_t *alt_digits = NULL;
+  size_t ret = __strftime (s, maxsize, format, tim_p, &era_info, &alt_digits);
+  if (era_info)
+    free_era_info (era_info);
+  if (alt_digits)
+    free_alt_digits (alt_digits);
+  return ret;
+}
+static size_t
+__strftime (CHAR *s, size_t maxsize, const CHAR *format,
+	    const struct tm *tim_p, era_info_t **era_info,
+	    alt_digits_t **alt_digits)
+#else /* !_WANT_C99_TIME_FORMATS */
+# define __strftime(s,m,f,t,e,a)	strftime((s),(m),(f),(t))
+size_t
+_DEFUN (strftime, (s, maxsize, format, tim_p),
+	CHAR *__restrict s _AND
+	size_t maxsize _AND
+	_CONST CHAR *__restrict format _AND
+	_CONST struct tm *__restrict tim_p)
+#endif /* !_WANT_C99_TIME_FORMATS */
+{
+  size_t count = 0;
+  int i, len = 0;
+  const CHAR *ctloc;
+#if defined (MAKE_WCSFTIME) && !defined (__HAVE_LOCALE_INFO_EXTENDED__)
+  CHAR ctlocbuf[CTLOCBUFLEN];
+#endif
+  size_t ctloclen;
+  CHAR alt;
+  CHAR pad;
+  unsigned long width;
+  struct lc_time_T *_CurrentTimeLocale = __get_current_time_locale ();
+  for (;;)
+    {
+      while (*format && *format != CQ('%'))
+	{
+	  if (count < maxsize - 1)
+	    s[count++] = *format++;
+	  else
+	    return 0;
+	}
+      if (*format == CQ('\0'))
+	break;
+      format++;
+      pad = '\0';
+      width = 0;
+      /* POSIX-1.2008 feature: '0' and '+' modifiers require 0-padding with
+         slightly different semantics. */
+      if (*format == CQ('0') || *format == CQ('+'))
+	pad = *format++;
+      /* POSIX-1.2008 feature: A minimum field width can be specified. */
+      if (*format >= CQ('1') && *format <= CQ('9'))
+      	{
+	  CHAR *fp;
+	  width = STRTOUL (format, &fp, 10);
+	  format = fp;
+	}
+      alt = CQ('\0');
+      if (*format == CQ('E'))
+	{
+	  alt = *format++;
+#ifdef _WANT_C99_TIME_FORMATS
+#if defined (MAKE_WCSFTIME) && defined (__HAVE_LOCALE_INFO_EXTENDED__)
+	  if (!*era_info && *_CurrentTimeLocale->wera)
+	    *era_info = get_era_info (tim_p, _CurrentTimeLocale->wera);
+#else
+	  if (!*era_info && *_CurrentTimeLocale->era)
+	    *era_info = get_era_info (tim_p, _CurrentTimeLocale->era);
+#endif
+#endif /* _WANT_C99_TIME_FORMATS */
+	}
+      else if (*format == CQ('O'))
+	{
+	  alt = *format++;
+#ifdef _WANT_C99_TIME_FORMATS
+#if defined (MAKE_WCSFTIME) && defined (__HAVE_LOCALE_INFO_EXTENDED__)
+	  if (!*alt_digits && *_CurrentTimeLocale->walt_digits)
+	    *alt_digits = get_alt_digits (_CurrentTimeLocale->walt_digits);
+#else
+	  if (!*alt_digits && *_CurrentTimeLocale->alt_digits)
+	    *alt_digits = get_alt_digits (_CurrentTimeLocale->alt_digits);
+#endif
+#endif /* _WANT_C99_TIME_FORMATS */
+	}
+      switch (*format)
+	{
+	case CQ('a'):
+	  _ctloc (wday[tim_p->tm_wday]);
+	  for (i = 0; i < ctloclen; i++)
+	    {
+	      if (count < maxsize - 1)
+		s[count++] = ctloc[i];
+	      else
+		return 0;
+	    }
+	  break;
+	case CQ('A'):
+	  _ctloc (weekday[tim_p->tm_wday]);
+	  for (i = 0; i < ctloclen; i++)
+	    {
+	      if (count < maxsize - 1)
+		s[count++] = ctloc[i];
+	      else
+		return 0;
+	    }
+	  break;
+	case CQ('b'):
+	case CQ('h'):
+	  _ctloc (mon[tim_p->tm_mon]);
+	  for (i = 0; i < ctloclen; i++)
+	    {
+	      if (count < maxsize - 1)
+		s[count++] = ctloc[i];
+	      else
+		return 0;
+	    }
+	  break;
+	case CQ('B'):
+	  _ctloc (month[tim_p->tm_mon]);
+	  for (i = 0; i < ctloclen; i++)
+	    {
+	      if (count < maxsize - 1)
+		s[count++] = ctloc[i];
+	      else
+		return 0;
+	    }
+	  break;
+	case CQ('c'):
+#ifdef _WANT_C99_TIME_FORMATS
+	  if (alt == 'E' && *era_info && *_CurrentTimeLocale->era_d_t_fmt)
+	    _ctloc (era_d_t_fmt);
+	  else
+#endif /* _WANT_C99_TIME_FORMATS */
+	    _ctloc (c_fmt);
+	  goto recurse;
+	case CQ('r'):
+	  _ctloc (ampm_fmt);
+	  goto recurse;
+	case CQ('x'):
+#ifdef _WANT_C99_TIME_FORMATS
+	  if (alt == 'E' && *era_info && *_CurrentTimeLocale->era_d_fmt)
+	    _ctloc (era_d_fmt);
+	  else
+#endif /* _WANT_C99_TIME_FORMATS */
+	    _ctloc (x_fmt);
+	  goto recurse;
+	case CQ('X'):
+#ifdef _WANT_C99_TIME_FORMATS
+	  if (alt == 'E' && *era_info && *_CurrentTimeLocale->era_t_fmt)
+	    _ctloc (era_t_fmt);
+	  else
+#endif /* _WANT_C99_TIME_FORMATS */
+	    _ctloc (X_fmt);
+recurse:
+	  if (*ctloc)
+	    {
+	      /* Recurse to avoid need to replicate %Y formation. */
+	      len = __strftime (&s[count], maxsize - count, ctloc, tim_p,
+				era_info, alt_digits);
+	      if (len > 0)
+		count += len;
+	      else
+		return 0;
+	    }
+	  break;
+	case CQ('C'):
+	  {
+	    /* Examples of (tm_year + YEAR_BASE) that show how %Y == %C%y
+	       with 32-bit int.
+	       %Y		%C		%y
+	       2147485547	21474855	47
+		100		00
+		99		99
+		09		99
+		00		99
+		00		01
+		00		00
+	       -001		-0		01
+	       -099		-0		99
+	       -999		-9		99
+	       -1000		-10		00
+	       -10000		-100		00
+	       -2147481748	-21474817	48
+	       Be careful of both overflow and sign adjustment due to the
+	       asymmetric range of years.
+	    */
+#ifdef _WANT_C99_TIME_FORMATS
+	    if (alt == 'E' && *era_info)
+	      len = snprintf (&s[count], maxsize - count, CQ("%" SFLG "s"),
+			      (*era_info)->era_C);
+	    else
+#endif /* _WANT_C99_TIME_FORMATS */
+	      {
+		CHAR *fmt = CQ("%s%.*d");
+		char *pos = "";
+		int neg = tim_p->tm_year < -YEAR_BASE;
+		int century = tim_p->tm_year >= 0
+		  ? tim_p->tm_year / 100 + YEAR_BASE / 100
+		  : abs (tim_p->tm_year + YEAR_BASE) / 100;
+		if (pad) /* '0' or '+' */
+		  {
+		    fmt = CQ("%s%0.*d");
+		    if (century >= 100 && pad == CQ('+'))
+		      pos = "+";
+		  }
+		if (width < 2)
+		  width = 2;
+		len = snprintf (&s[count], maxsize - count, fmt,
+				neg ? "-" : pos, width - neg, century);
+	      }
+            CHECK_LENGTH ();
+	  }
+	  break;
+	case CQ('d'):
+	case CQ('e'):
+#ifdef _WANT_C99_TIME_FORMATS
+	  if (alt == CQ('O') && *alt_digits)
+	    {
+	      if (tim_p->tm_mday < 10)
+	      	{
+		  if (*format == CQ('d'))
+		    {
+		      if (maxsize - count < 2) return 0;
+		      len = conv_to_alt_digits (&s[count], maxsize - count,
+, *alt_digits);
+		      CHECK_LENGTH ();
+		    }
+		  if (*format == CQ('e') || len == 0)
+		    s[count++] = CQ(' ');
+		}
+	      len = conv_to_alt_digits (&s[count], maxsize - count,
+					tim_p->tm_mday, *alt_digits);
+	      CHECK_LENGTH ();
+	      if (len > 0)
+		break;
+	    }
+#endif /* _WANT_C99_TIME_FORMATS */
+	  len = snprintf (&s[count], maxsize - count,
+			  *format == CQ('d') ? CQ("%.2d") : CQ("%2d"),
+			  tim_p->tm_mday);
+	  CHECK_LENGTH ();
+	  break;
+	case CQ('D'):
+	  /* %m/%d/%y */
+	  len = snprintf (&s[count], maxsize - count,
+			  CQ("%.2d/%.2d/%.2d"),
+			  tim_p->tm_mon + 1, tim_p->tm_mday,
+			  tim_p->tm_year >= 0 ? tim_p->tm_year % 100
+			  : abs (tim_p->tm_year + YEAR_BASE) % 100);
+          CHECK_LENGTH ();
+	  break;
+	case CQ('F'):
+	  { /* %F is equivalent to "%+4Y-%m-%d", flags and width can change
+	       that.  Recurse to avoid need to replicate %Y formation. */
+	    CHAR fmtbuf[32], *fmt = fmtbuf;
+	    *fmt++ = CQ('%');
+	    if (pad) /* '0' or '+' */
+	      *fmt++ = pad;
+	    else
+	      *fmt++ = '+';
+	    if (!pad)
+	      width = 10;
+	    if (width < 6)
+	      width = 6;
+	    width -= 6;
+	    if (width)
+	      {
+		len = snprintf (fmt, fmtbuf + 32 - fmt, CQ("%lu"), width);
+		if (len > 0)
+		  fmt += len;
+	      }
+	    STRCPY (fmt, CQ("Y-%m-%d"));
+	    len = __strftime (&s[count], maxsize - count, fmtbuf, tim_p,
+			      era_info, alt_digits);
+	    if (len > 0)
+	      count += len;
+	    else
+	      return 0;
+	  }
+          break;
+	case CQ('g'):
+	  /* Be careful of both overflow and negative years, thanks to
+		 the asymmetric range of years.  */
+	  {
+	    int adjust = iso_year_adjust (tim_p);
+	    int year = tim_p->tm_year >= 0 ? tim_p->tm_year % 100
+		: abs (tim_p->tm_year + YEAR_BASE) % 100;
+	    if (adjust < 0 && tim_p->tm_year <= -YEAR_BASE)
+		adjust = 1;
+	    else if (adjust > 0 && tim_p->tm_year < -YEAR_BASE)
+		adjust = -1;
+	    len = snprintf (&s[count], maxsize - count, CQ("%.2d"),
+			    ((year + adjust) % 100 + 100) % 100);
+            CHECK_LENGTH ();
+	  }
+          break;
+	case CQ('G'):
+	  {
+	    /* See the comments for 'C' and 'Y'; this is a variable length
+	       field.  Although there is no requirement for a minimum number
+	       of digits, we use 4 for consistency with 'Y'.  */
+	    int sign = tim_p->tm_year < -YEAR_BASE;
+	    int adjust = iso_year_adjust (tim_p);
+	    int century = tim_p->tm_year >= 0
+	      ? tim_p->tm_year / 100 + YEAR_BASE / 100
+	      : abs (tim_p->tm_year + YEAR_BASE) / 100;
+	    int year = tim_p->tm_year >= 0 ? tim_p->tm_year % 100
+	      : abs (tim_p->tm_year + YEAR_BASE) % 100;
+	    if (adjust < 0 && tim_p->tm_year <= -YEAR_BASE)
+	      sign = adjust = 1;
+	    else if (adjust > 0 && sign)
+	      adjust = -1;
+	    year += adjust;
+	    if (year == -1)
+	      {
+		year = 99;
+		--century;
+	      }
+	    else if (year == 100)
+	      {
+		year = 0;
+		++century;
+	      }
+	    CHAR fmtbuf[10], *fmt = fmtbuf;
+	    /* int potentially overflows, so use unsigned instead.  */
+	    unsigned p_year = century * 100 + year;
+	    if (sign)
+	      *fmt++ = CQ('-');
+	    else if (pad == CQ('+') && p_year >= 10000)
+	      {
+		*fmt++ = CQ('+');
+		sign = 1;
+	      }
+	    if (width && sign)
+	      --width;
+	    *fmt++ = CQ('%');
+	    if (pad)
+	      *fmt++ = CQ('0');
+	    STRCPY (fmt, CQ(".*u"));
+	    len = snprintf (&s[count], maxsize - count, fmtbuf, width, p_year);
+            if (len < 0  ||  (count+=len) >= maxsize)
+              return 0;
+	  }
+          break;
+	case CQ('H'):
+#ifdef _WANT_C99_TIME_FORMATS
+	  if (alt == CQ('O') && *alt_digits)
+	    {
+	      len = conv_to_alt_digits (&s[count], maxsize - count,
+					tim_p->tm_hour, *alt_digits);
+	      CHECK_LENGTH ();
+	      if (len > 0)
+		break;
+	    }
+#endif /* _WANT_C99_TIME_FORMATS */
+	  /*FALLTHRU*/
+	case CQ('k'):	/* newlib extension */
+	  len = snprintf (&s[count], maxsize - count,
+			  *format == CQ('k') ? CQ("%2d") : CQ("%.2d"),
+			  tim_p->tm_hour);
+          CHECK_LENGTH ();
+	  break;
+	case CQ('l'):	/* newlib extension */
+	  if (alt == CQ('O'))
+	    alt = CQ('\0');
+	  /*FALLTHRU*/
+	case CQ('I'):
+	  {
+	    register int  h12;
+	    h12 = (tim_p->tm_hour == 0 || tim_p->tm_hour == 12)  ?
+:  tim_p->tm_hour % 12;
+#ifdef _WANT_C99_TIME_FORMATS
+	    if (alt != CQ('O') || !*alt_digits
+		|| !(len = conv_to_alt_digits (&s[count], maxsize - count,
+					       h12, *alt_digits)))
+#endif /* _WANT_C99_TIME_FORMATS */
+	      len = snprintf (&s[count], maxsize - count,
+			      *format == CQ('I') ? CQ("%.2d") : CQ("%2d"), h12);
+	    CHECK_LENGTH ();
+	  }
+	  break;
+	case CQ('j'):
+	  len = snprintf (&s[count], maxsize - count, CQ("%.3d"),
+			  tim_p->tm_yday + 1);
+          CHECK_LENGTH ();
+	  break;
+	case CQ('m'):
+#ifdef _WANT_C99_TIME_FORMATS
+	  if (alt != CQ('O') || !*alt_digits
+	      || !(len = conv_to_alt_digits (&s[count], maxsize - count,
+					     tim_p->tm_mon + 1, *alt_digits)))
+#endif /* _WANT_C99_TIME_FORMATS */
+	    len = snprintf (&s[count], maxsize - count, CQ("%.2d"),
+			    tim_p->tm_mon + 1);
+          CHECK_LENGTH ();
+	  break;
+	case CQ('M'):
+#ifdef _WANT_C99_TIME_FORMATS
+	  if (alt != CQ('O') || !*alt_digits
+	      || !(len = conv_to_alt_digits (&s[count], maxsize - count,
+					     tim_p->tm_min, *alt_digits)))
+#endif /* _WANT_C99_TIME_FORMATS */
+	    len = snprintf (&s[count], maxsize - count, CQ("%.2d"),
+			    tim_p->tm_min);
+          CHECK_LENGTH ();
+	  break;
+	case CQ('n'):
+	  if (count < maxsize - 1)
+	    s[count++] = CQ('\n');
+	  else
+	    return 0;
+	  break;
+	case CQ('p'):
+	case CQ('P'):
+	  _ctloc (am_pm[tim_p->tm_hour < 12 ? 0 : 1]);
+	  for (i = 0; i < ctloclen; i++)
+	    {
+	      if (count < maxsize - 1)
+		s[count++] = (*format == CQ('P') ? TOLOWER (ctloc[i])
+						 : ctloc[i]);
+	      else
+		return 0;
+	    }
+	  break;
+	case CQ('R'):
+          len = snprintf (&s[count], maxsize - count, CQ("%.2d:%.2d"),
+			  tim_p->tm_hour, tim_p->tm_min);
+          CHECK_LENGTH ();
+          break;
+	case CQ('S'):
+#ifdef _WANT_C99_TIME_FORMATS
+	  if (alt != CQ('O') || !*alt_digits
+	      || !(len = conv_to_alt_digits (&s[count], maxsize - count,
+					     tim_p->tm_sec, *alt_digits)))
+#endif /* _WANT_C99_TIME_FORMATS */
+	    len = snprintf (&s[count], maxsize - count, CQ("%.2d"),
+			    tim_p->tm_sec);
+          CHECK_LENGTH ();
+	  break;
+	case CQ('t'):
+	  if (count < maxsize - 1)
+	    s[count++] = CQ('\t');
+	  else
+  return 0;
+	  break;
+	case CQ('T'):
+          len = snprintf (&s[count], maxsize - count, CQ("%.2d:%.2d:%.2d"),
+			  tim_p->tm_hour, tim_p->tm_min, tim_p->tm_sec);
+          CHECK_LENGTH ();
+          break;
+	case CQ('u'):
+#ifdef _WANT_C99_TIME_FORMATS
+	  if (alt == CQ('O') && *alt_digits)
+	    {
+	      len = conv_to_alt_digits (&s[count], maxsize - count,
+					tim_p->tm_wday == 0 ? 7
+							    : tim_p->tm_wday,
+					*alt_digits);
+	      CHECK_LENGTH ();
+	      if (len > 0)
+		break;
+	    }
+#endif /* _WANT_C99_TIME_FORMATS */
+          if (count < maxsize - 1)
+            {
+              if (tim_p->tm_wday == 0)
+                s[count++] = CQ('7');
+              else
+                s[count++] = CQ('0') + tim_p->tm_wday;
+            }
+          else
+            return 0;
+          break;
+	case CQ('U'):
+#ifdef _WANT_C99_TIME_FORMATS
+	  if (alt != CQ('O') || !*alt_digits
+	      || !(len = conv_to_alt_digits (&s[count], maxsize - count,
+					     (tim_p->tm_yday + 7 -
+					      tim_p->tm_wday) / 7,
+					     *alt_digits)))
+#endif /* _WANT_C99_TIME_FORMATS */
+	    len = snprintf (&s[count], maxsize - count, CQ("%.2d"),
+			 (tim_p->tm_yday + 7 -
+			  tim_p->tm_wday) / 7);
+          CHECK_LENGTH ();
+	  break;
+	case CQ('V'):
+	  {
+	    int adjust = iso_year_adjust (tim_p);
+	    int wday = (tim_p->tm_wday) ? tim_p->tm_wday - 1 : 6;
+	    int week = (tim_p->tm_yday + 10 - wday) / 7;
+	    if (adjust > 0)
+		week = 1;
+	    else if (adjust < 0)
+		/* Previous year has 53 weeks if current year starts on
+		   Fri, and also if current year starts on Sat and
+		   previous year was leap year.  */
+		week = 52 + (4 >= (wday - tim_p->tm_yday
+				   - isleap (tim_p->tm_year
+					     + (YEAR_BASE - 1
+						- (tim_p->tm_year < 0
+						   ? 0 : 2000)))));
+#ifdef _WANT_C99_TIME_FORMATS
+	    if (alt != CQ('O') || !*alt_digits
+		|| !(len = conv_to_alt_digits (&s[count], maxsize - count,
+					       week, *alt_digits)))
+#endif /* _WANT_C99_TIME_FORMATS */
+	      len = snprintf (&s[count], maxsize - count, CQ("%.2d"), week);
+            CHECK_LENGTH ();
+	  }
+          break;
+	case CQ('w'):
+#ifdef _WANT_C99_TIME_FORMATS
+	  if (alt == CQ('O') && *alt_digits)
+	    {
+	      len = conv_to_alt_digits (&s[count], maxsize - count,
+					tim_p->tm_wday, *alt_digits);
+	      CHECK_LENGTH ();
+	      if (len > 0)
+		break;
+	    }
+#endif /* _WANT_C99_TIME_FORMATS */
+	  if (count < maxsize - 1)
+            s[count++] = CQ('0') + tim_p->tm_wday;
+	  else
+	    return 0;
+	  break;
+	case CQ('W'):
+	  {
+	    int wday = (tim_p->tm_wday) ? tim_p->tm_wday - 1 : 6;
+	    wday = (tim_p->tm_yday + 7 - wday) / 7;
+#ifdef _WANT_C99_TIME_FORMATS
+	    if (alt != CQ('O') || !*alt_digits
+		|| !(len = conv_to_alt_digits (&s[count], maxsize - count,
+					       wday, *alt_digits)))
+#endif /* _WANT_C99_TIME_FORMATS */
+	      len = snprintf (&s[count], maxsize - count, CQ("%.2d"), wday);
+            CHECK_LENGTH ();
+	  }
+	  break;
+	case CQ('y'):
+	    {
+#ifdef _WANT_C99_TIME_FORMATS
+	      if (alt == 'E' && *era_info)
+		len = snprintf (&s[count], maxsize - count, CQ("%d"),
+				(*era_info)->year);
+	      else
+#endif /* _WANT_C99_TIME_FORMATS */
+		{
+		  /* Be careful of both overflow and negative years, thanks to
+		     the asymmetric range of years.  */
+		  int year = tim_p->tm_year >= 0 ? tim_p->tm_year % 100
+			     : abs (tim_p->tm_year + YEAR_BASE) % 100;
+#ifdef _WANT_C99_TIME_FORMATS
+		  if (alt != CQ('O') || !*alt_digits
+		      || !(len = conv_to_alt_digits (&s[count], maxsize - count,
+						     year, *alt_digits)))
+#endif /* _WANT_C99_TIME_FORMATS */
+		    len = snprintf (&s[count], maxsize - count, CQ("%.2d"),
+				    year);
+		}
+              CHECK_LENGTH ();
+	    }
+	  break;
+	case CQ('Y'):
+#ifdef _WANT_C99_TIME_FORMATS
+	  if (alt == 'E' && *era_info)
+	    {
+	      ctloc = (*era_info)->era_Y;
+	      goto recurse;
+	    }
+	  else
+#endif /* _WANT_C99_TIME_FORMATS */
+	    {
+	      CHAR fmtbuf[10], *fmt = fmtbuf;
+	      int sign = tim_p->tm_year < -YEAR_BASE;
+	      /* int potentially overflows, so use unsigned instead.  */
+	      register unsigned year = (unsigned) tim_p->tm_year
+				       + (unsigned) YEAR_BASE;
+	      if (sign)
+		{
+		  *fmt++ = CQ('-');
+		  year = UINT_MAX - year + 1;
+		}
+	      else if (pad == CQ('+') && year >= 10000)
+		{
+		  *fmt++ = CQ('+');
+		  sign = 1;
+		}
+	      if (width && sign)
+		--width;
+	      *fmt++ = CQ('%');
+	      if (pad)
+		*fmt++ = CQ('0');
+	      STRCPY (fmt, CQ(".*u"));
+	      len = snprintf (&s[count], maxsize - count, fmtbuf, width,
+			      year);
+	      CHECK_LENGTH ();
+	    }
+	  break;
+	case CQ('z'):
+          if (tim_p->tm_isdst >= 0)
+            {
+	      long offset;
+	      __tzinfo_type *tz = __gettzinfo ();
+	      TZ_LOCK;
+	      /* The sign of this is exactly opposite the envvar TZ.  We
+	         could directly use the global _timezone for tm_isdst==0,
+	         but have to use __tzrule for daylight savings.  */
+	      offset = -tz->__tzrule[tim_p->tm_isdst > 0].offset;
+	      TZ_UNLOCK;
+	      len = snprintf (&s[count], maxsize - count, CQ("%+03ld%.2ld"),
+			      offset / SECSPERHOUR,
+			      labs (offset / SECSPERMIN) % 60L);
+              CHECK_LENGTH ();
+            }
+          break;
+	case CQ('Z'):
+	  if (tim_p->tm_isdst >= 0)
+	    {
+	      int size;
+	      TZ_LOCK;
+	      size = strlen(_tzname[tim_p->tm_isdst > 0]);
+	      for (i = 0; i < size; i++)
+		{
+		  if (count < maxsize - 1)
+		    s[count++] = _tzname[tim_p->tm_isdst > 0][i];
-	_CONST struct tm *tim_p)
+		  else
+		    {
+		      TZ_UNLOCK;
+		      return 0;
+		    }
+		}
+	      TZ_UNLOCK;
+	    }
+	  break;
+	case CQ('%'):
+	  if (count < maxsize - 1)
+	    s[count++] = CQ('%');
+	  else
+	    return 0;
+	  break;
+	default:
+	  return 0;
+	}
+      if (*format)
+	format++;
+      else
+	break;
+    }
+  if (maxsize)
+    s[count] = CQ('\0');
+  return count;
+}
+/* The remainder of this file can serve as a regression test.  Compile
+ *  with -D_REGRESSION_TEST.  */
+#if defined(_REGRESSION_TEST)	/* [Test code:  */
+/* This test code relies on ANSI C features, in particular on the ability
+ * of adjacent strings to be pasted together into one string.  */
+/* Test output buffer size (should be larger than all expected results) */
+#define OUTSIZE	256
+struct test {
+	CHAR  *fmt;	/* Testing format */
+	size_t  max;	/* Testing maxsize */
+	size_t	ret;	/* Expected return value */
+	CHAR  *out;	/* Expected output string */
+	};
+struct list {
+	const struct tm  *tms;	/* Time used for these vectors */
+	const struct test *vec;	/* Test vectors */
+	int  cnt;		/* Number of vectors */
+	};
+const char  TZ[]="TZ=EST5EDT";
+/* Define list of test inputs and expected outputs, for the given time zone
+ * and time.  */
+const struct tm  tm0 = {
+	/* Tue Dec 30 10:53:47 EST 2008 (time_t=1230648827) */
+	.tm_sec 	= 47,
+	.tm_min 	= 53,
+	.tm_hour	= 9,
+	.tm_mday	= 30,
+	.tm_mon 	= 11,
+	.tm_year	= 108,
+	.tm_wday	= 2,
+	.tm_yday	= 364,
+	.tm_isdst	= 0
+	};
+const struct test  Vec0[] = {
+	/* Testing fields one at a time, expecting to pass, using exact
+	 * allowed length as what is needed.  */
+	/* Using tm0 for time: */
+	#define EXP(s)	sizeof(s)/sizeof(CHAR)-1, s
+	{ CQ("%a"), 3+1, EXP(CQ("Tue")) },
+	{ CQ("%A"), 7+1, EXP(CQ("Tuesday")) },
+	{ CQ("%b"), 3+1, EXP(CQ("Dec")) },
+	{ CQ("%B"), 8+1, EXP(CQ("December")) },
+	{ CQ("%c"), 24+1, EXP(CQ("Tue Dec 30 09:53:47 2008")) },
+	{ CQ("%C"), 2+1, EXP(CQ("20")) },
+	{ CQ("%d"), 2+1, EXP(CQ("30")) },
+	{ CQ("%D"), 8+1, EXP(CQ("12/30/08")) },
+	{ CQ("%e"), 2+1, EXP(CQ("30")) },
+	{ CQ("%F"), 10+1, EXP(CQ("2008-12-30")) },
+	{ CQ("%g"), 2+1, EXP(CQ("09")) },
+	{ CQ("%G"), 4+1, EXP(CQ("2009")) },
+	{ CQ("%h"), 3+1, EXP(CQ("Dec")) },
+	{ CQ("%H"), 2+1, EXP(CQ("09")) },
+	{ CQ("%I"), 2+1, EXP(CQ("09")) },
+	{ CQ("%j"), 3+1, EXP(CQ("365")) },
+	{ CQ("%k"), 2+1, EXP(CQ(" 9")) },
+	{ CQ("%l"), 2+1, EXP(CQ(" 9")) },
+	{ CQ("%m"), 2+1, EXP(CQ("12")) },
+	{ CQ("%M"), 2+1, EXP(CQ("53")) },
+	{ CQ("%n"), 1+1, EXP(CQ("\n")) },
+	{ CQ("%p"), 2+1, EXP(CQ("AM")) },
+	{ CQ("%r"), 11+1, EXP(CQ("09:53:47 AM")) },
+	{ CQ("%R"), 5+1, EXP(CQ("09:53")) },
+	{ CQ("%S"), 2+1, EXP(CQ("47")) },
+	{ CQ("%t"), 1+1, EXP(CQ("\t")) },
+	{ CQ("%T"), 8+1, EXP(CQ("09:53:47")) },
+	{ CQ("%u"), 1+1, EXP(CQ("2")) },
+	{ CQ("%U"), 2+1, EXP(CQ("52")) },
+	{ CQ("%V"), 2+1, EXP(CQ("01")) },
+	{ CQ("%w"), 1+1, EXP(CQ("2")) },
+	{ CQ("%W"), 2+1, EXP(CQ("52")) },
+	{ CQ("%x"), 8+1, EXP(CQ("12/30/08")) },
+	{ CQ("%X"), 8+1, EXP(CQ("09:53:47")) },
+	{ CQ("%y"), 2+1, EXP(CQ("08")) },
+	{ CQ("%Y"), 4+1, EXP(CQ("2008")) },
+	{ CQ("%z"), 5+1, EXP(CQ("-0500")) },
+	{ CQ("%Z"), 3+1, EXP(CQ("EST")) },
+	{ CQ("%%"), 1+1, EXP(CQ("%")) },
+	#undef EXP
+	};
+/* Define list of test inputs and expected outputs, for the given time zone
+ * and time.  */
+const struct tm  tm1 = {
+	/* Wed Jul  2 23:01:13 EDT 2008 (time_t=1215054073) */
+	.tm_sec 	= 13,
+	.tm_min 	= 1,
+	.tm_hour	= 23,
+	.tm_mday	= 2,
+	.tm_mon 	= 6,
+	.tm_year	= 108,
+	.tm_wday	= 3,
+	.tm_yday	= 183,
+	.tm_isdst	= 1
+	};
+const struct test  Vec1[] = {
+	/* Testing fields one at a time, expecting to pass, using exact
+	 * allowed length as what is needed.  */
+	/* Using tm1 for time: */
+	#define EXP(s)	sizeof(s)/sizeof(CHAR)-1, s
+	{ CQ("%a"), 3+1, EXP(CQ("Wed")) },
+	{ CQ("%A"), 9+1, EXP(CQ("Wednesday")) },
+	{ CQ("%b"), 3+1, EXP(CQ("Jul")) },
+	{ CQ("%B"), 4+1, EXP(CQ("July")) },
+	{ CQ("%c"), 24+1, EXP(CQ("Wed Jul  2 23:01:13 2008")) },
+	{ CQ("%C"), 2+1, EXP(CQ("20")) },
+	{ CQ("%d"), 2+1, EXP(CQ("02")) },
+	{ CQ("%D"), 8+1, EXP(CQ("07/02/08")) },
+	{ CQ("%e"), 2+1, EXP(CQ(" 2")) },
+	{ CQ("%F"), 10+1, EXP(CQ("2008-07-02")) },
+	{ CQ("%g"), 2+1, EXP(CQ("08")) },
+	{ CQ("%G"), 4+1, EXP(CQ("2008")) },
+	{ CQ("%h"), 3+1, EXP(CQ("Jul")) },
+	{ CQ("%H"), 2+1, EXP(CQ("23")) },
+	{ CQ("%I"), 2+1, EXP(CQ("11")) },
+	{ CQ("%j"), 3+1, EXP(CQ("184")) },
+	{ CQ("%k"), 2+1, EXP(CQ("23")) },
+	{ CQ("%l"), 2+1, EXP(CQ("11")) },
+	{ CQ("%m"), 2+1, EXP(CQ("07")) },
+	{ CQ("%M"), 2+1, EXP(CQ("01")) },
+	{ CQ("%n"), 1+1, EXP(CQ("\n")) },
+	{ CQ("%p"), 2+1, EXP(CQ("PM")) },
+	{ CQ("%r"), 11+1, EXP(CQ("11:01:13 PM")) },
+	{ CQ("%R"), 5+1, EXP(CQ("23:01")) },
+	{ CQ("%S"), 2+1, EXP(CQ("13")) },
+	{ CQ("%t"), 1+1, EXP(CQ("\t")) },
+	{ CQ("%T"), 8+1, EXP(CQ("23:01:13")) },
+	{ CQ("%u"), 1+1, EXP(CQ("3")) },
+	{ CQ("%U"), 2+1, EXP(CQ("26")) },
+	{ CQ("%V"), 2+1, EXP(CQ("27")) },
+	{ CQ("%w"), 1+1, EXP(CQ("3")) },
+	{ CQ("%W"), 2+1, EXP(CQ("26")) },
+	{ CQ("%x"), 8+1, EXP(CQ("07/02/08")) },
+	{ CQ("%X"), 8+1, EXP(CQ("23:01:13")) },
+	{ CQ("%y"), 2+1, EXP(CQ("08")) },
+	{ CQ("%Y"), 4+1, EXP(CQ("2008")) },
+	{ CQ("%z"), 5+1, EXP(CQ("-0400")) },
+	{ CQ("%Z"), 3+1, EXP(CQ("EDT")) },
+	{ CQ("%%"), 1+1, EXP(CQ("%")) },
+	#undef EXP
+	#define VEC(s)	s, sizeof(s)/sizeof(CHAR), sizeof(s)/sizeof(CHAR)-1, s
+	#define EXP(s)	sizeof(s)/sizeof(CHAR), sizeof(s)/sizeof(CHAR)-1, s
+	{ VEC(CQ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")) },
+	{ CQ("0123456789%%%h:`~"), EXP(CQ("0123456789%Jul:`~")) },
+	{ CQ("%R%h:`~ %x %w"), EXP(CQ("23:01Jul:`~ 07/02/08 3")) },
+	#undef VEC
+	#undef EXP
+	};
+#if YEAR_BASE == 1900  /* ( */
+/* Checks for very large years.  YEAR_BASE value relied upon so that the
+ * answer strings can be predetermined.
+ * Years more than 4 digits are not mentioned in the standard for %C, so the
+ * test for those cases are based on the design intent (which is to print the
+ * whole number, being the century).  */
+const struct tm  tmyr0 = {
+	/* Wed Jul  2 23:01:13 EDT [HUGE#] */
+	.tm_sec 	= 13,
+	.tm_min 	= 1,
+	.tm_hour	= 23,
+	.tm_mday	= 2,
+	.tm_mon 	= 6,
+	.tm_year	= INT_MAX - YEAR_BASE/2,
+	.tm_wday	= 3,
+	.tm_yday	= 183,
+	.tm_isdst	= 1
+	};
+#if INT_MAX == 32767
+#  define YEAR	CQ("33717")		/* INT_MAX + YEAR_BASE/2 */
+#  define CENT	CQ("337")
+#  define Year	   CQ("17")
+# elif INT_MAX == 2147483647
+#  define YEAR	CQ("2147484597")
+#  define CENT	CQ("21474845")
+#  define Year	        CQ("97")
+# elif INT_MAX == 9223372036854775807
+#  define YEAR	CQ("9223372036854776757")
+#  define CENT	CQ("92233720368547777")
+#  define Year	                 CQ("57")
+# else
+#  error "Unrecognized INT_MAX value:  enhance me to recognize what you have"
+#endif
+const struct test  Vecyr0[] = {
+	/* Testing fields one at a time, expecting to pass, using a larger
+	 * allowed length than what is needed.  */
+	/* Using tmyr0 for time: */
+	#define EXP(s)	sizeof(s)/sizeof(CHAR)-1, s
+	{ CQ("%C"), OUTSIZE, EXP(CENT) },
+	{ CQ("%c"), OUTSIZE, EXP(CQ("Wed Jul  2 23:01:13 ")YEAR) },
+	{ CQ("%D"), OUTSIZE, EXP(CQ("07/02/")Year) },
+	{ CQ("%F"), OUTSIZE, EXP(YEAR CQ("-07-02")) },
+	{ CQ("%x"), OUTSIZE, EXP(CQ("07/02/")Year) },
+	{ CQ("%y"), OUTSIZE, EXP(Year) },
+	{ CQ("%Y"), OUTSIZE, EXP(YEAR) },
+	#undef EXP
+	};
+#undef YEAR
+#undef CENT
+#undef Year
+/* Checks for very large negative years.  YEAR_BASE value relied upon so that
+ * the answer strings can be predetermined.  */
+const struct tm  tmyr1 = {
+	/* Wed Jul  2 23:01:13 EDT [HUGE#] */
+	.tm_sec 	= 13,
+	.tm_min 	= 1,
+	.tm_hour	= 23,
+	.tm_mday	= 2,
+	.tm_mon 	= 6,
+	.tm_year	= INT_MIN,
+	.tm_wday	= 3,
+	.tm_yday	= 183,
+	.tm_isdst	= 1
+	};
+#if INT_MAX == 32767
+#  define YEAR	CQ("-30868")		/* INT_MIN + YEAR_BASE */
+#  define CENT	CQ("-308")
+#  define Year	    CQ("68")
+# elif INT_MAX == 2147483647
+#  define YEAR	CQ("-2147481748")
+#  define CENT	CQ("-21474817")
+#  define Year	         CQ("48")
+# elif INT_MAX == 9223372036854775807
+#  define YEAR	CQ("-9223372036854773908")
+#  define CENT	CQ("-92233720368547739")
+#  define Year	                  CQ("08")
+# else
+#  error "Unrecognized INT_MAX value:  enhance me to recognize what you have"
+#endif
+const struct test  Vecyr1[] = {
+	/* Testing fields one at a time, expecting to pass, using a larger
+	 * allowed length than what is needed.  */
+	/* Using tmyr1 for time: */
+	#define EXP(s)	sizeof(s)/sizeof(CHAR)-1, s
+	{ CQ("%C"), OUTSIZE, EXP(CENT) },
+	{ CQ("%c"), OUTSIZE, EXP(CQ("Wed Jul  2 23:01:13 ")YEAR) },
+	{ CQ("%D"), OUTSIZE, EXP(CQ("07/02/")Year) },
+	{ CQ("%F"), OUTSIZE, EXP(YEAR CQ("-07-02")) },
+	{ CQ("%x"), OUTSIZE, EXP(CQ("07/02/")Year) },
+	{ CQ("%y"), OUTSIZE, EXP(Year) },
+	{ CQ("%Y"), OUTSIZE, EXP(YEAR) },
+	#undef EXP
+	};
+#undef YEAR
+#undef CENT
+#undef Year
+#endif /* YEAR_BASE ) */
+/* Checks for years just over zero (also test for s=60).
+ * Years less than 4 digits are not mentioned for %Y in the standard, so the
+ * test for that case is based on the design intent.  */
+const struct tm  tmyrzp = {
+	/* Wed Jul  2 23:01:60 EDT 0007 */
+	.tm_sec 	= 60,
+	.tm_min 	= 1,
+	.tm_hour	= 23,
+	.tm_mday	= 2,
+	.tm_mon 	= 6,
+	.tm_year	= 7-YEAR_BASE,
+	.tm_wday	= 3,
+	.tm_yday	= 183,
+	.tm_isdst	= 1
+	};
+#define YEAR	CQ("0007")	/* Design intent:  %Y=%C%y */
+#define CENT	CQ("00")
+#define Year	  CQ("07")
+const struct test  Vecyrzp[] = {
+	/* Testing fields one at a time, expecting to pass, using a larger
+	 * allowed length than what is needed.  */
+	/* Using tmyrzp for time: */
+	#define EXP(s)	sizeof(s)/sizeof(CHAR)-1, s
+	{ CQ("%C"), OUTSIZE, EXP(CENT) },
+	{ CQ("%c"), OUTSIZE, EXP(CQ("Wed Jul  2 23:01:60 ")YEAR) },
+	{ CQ("%D"), OUTSIZE, EXP(CQ("07/02/")Year) },
+	{ CQ("%F"), OUTSIZE, EXP(YEAR CQ("-07-02")) },
+	{ CQ("%x"), OUTSIZE, EXP(CQ("07/02/")Year) },
+	{ CQ("%y"), OUTSIZE, EXP(Year) },
+	{ CQ("%Y"), OUTSIZE, EXP(YEAR) },
+	#undef EXP
+	};
+#undef YEAR
+#undef CENT
+#undef Year
+/* Checks for years just under zero.
+ * Negative years are not handled by the standard, so the vectors here are
+ * verifying the chosen implemtation.  */
+const struct tm  tmyrzn = {
+	/* Wed Jul  2 23:01:00 EDT -004 */
+	.tm_sec 	= 00,
+	.tm_min 	= 1,
+	.tm_hour	= 23,
+	.tm_mday	= 2,
+	.tm_mon 	= 6,
+	.tm_year	= -4-YEAR_BASE,
+	.tm_wday	= 3,
+	.tm_yday	= 183,
+	.tm_isdst	= 1
+	};
+#define YEAR	CQ("-004")
+#define CENT	CQ("-0")
+#define Year	  CQ("04")
+const struct test  Vecyrzn[] = {
+	/* Testing fields one at a time, expecting to pass, using a larger
+	 * allowed length than what is needed.  */
+	/* Using tmyrzn for time: */
+	#define EXP(s)	sizeof(s)/sizeof(CHAR)-1, s
+	{ CQ("%C"), OUTSIZE, EXP(CENT) },
+	{ CQ("%c"), OUTSIZE, EXP(CQ("Wed Jul  2 23:01:00 ")YEAR) },
+	{ CQ("%D"), OUTSIZE, EXP(CQ("07/02/")Year) },
+	{ CQ("%F"), OUTSIZE, EXP(YEAR CQ("-07-02")) },
+	{ CQ("%x"), OUTSIZE, EXP(CQ("07/02/")Year) },
+	{ CQ("%y"), OUTSIZE, EXP(Year) },
+	{ CQ("%Y"), OUTSIZE, EXP(YEAR) },
+	#undef EXP
+	};
+#undef YEAR
+#undef CENT
+#undef Year
+const struct list  ListYr[] = {
+	{ &tmyrzp, Vecyrzp, sizeof(Vecyrzp)/sizeof(Vecyrzp[0]) },
+	{ &tmyrzn, Vecyrzn, sizeof(Vecyrzn)/sizeof(Vecyrzn[0]) },
+	#if YEAR_BASE == 1900
+	{ &tmyr0, Vecyr0, sizeof(Vecyr0)/sizeof(Vecyr0[0]) },
+	{ &tmyr1, Vecyr1, sizeof(Vecyr1)/sizeof(Vecyr1[0]) },
+	#endif
+	};
+/* List of tests to be run */
+const struct list  List[] = {
+	{ &tm0, Vec0, sizeof(Vec0)/sizeof(Vec0[0]) },
+	{ &tm1, Vec1, sizeof(Vec1)/sizeof(Vec1[0]) },
+	};
+#if defined(STUB_getenv_r)
+char *
+_getenv_r(struct _reent *p, const char *cp) { return getenv(cp); }
+#endif
+int
+main(void)
+{
+int  i, l, errr=0, erro=0, tot=0;
+const char  *cp;
+CHAR  out[OUTSIZE];
+size_t  ret;
+/* Set timezone so that %z and %Z tests come out right */
+cp = TZ;
+if((i=putenv(cp)))  {
+    printf( "putenv(%s) FAILED, ret %d\n", cp, i);
+    return(-1);
+    }
+if(strcmp(getenv("TZ"),strchr(TZ,'=')+1))  {
+    printf( "TZ not set properly in environment\n");
+    return(-2);
+    }
+tzset();
+#if defined(VERBOSE)
+printf("_timezone=%d, _daylight=%d, _tzname[0]=%s, _tzname[1]=%s\n", _timezone, _daylight, _tzname[0], _tzname[1]);
+{
+long offset;
+__tzinfo_type *tz = __gettzinfo ();
+/* The sign of this is exactly opposite the envvar TZ.  We
+   could directly use the global _timezone for tm_isdst==0,
+   but have to use __tzrule for daylight savings.  */
+printf("tz->__tzrule[0].offset=%d, tz->__tzrule[1].offset=%d\n", tz->__tzrule[0].offset, tz->__tzrule[1].offset);
+}
+#endif
+/* Run all of the exact-length tests as-given--results should match */
+for(l=0; l
+    const struct list  *test = &List[l];
+    for(i=0; icnt; i++)  {
+	tot++;	/* Keep track of number of tests */
+	ret = strftime(out, test->vec[i].max, test->vec[i].fmt, test->tms);
+	if(ret != test->vec[i].ret)  {
+	    errr++;
+	    fprintf(stderr,
+		"ERROR:  return %d != %d expected for List[%d].vec[%d]\n",
+						ret, test->vec[i].ret, l, i);
+	    }
+	if(strncmp(out, test->vec[i].out, test->vec[i].max-1))  {
+	    erro++;
+	    fprintf(stderr,
+		"ERROR:  \"%"SFLG"s\" != \"%"SFLG"s\" expected for List[%d].vec[%d]\n",
+						out, test->vec[i].out, l, i);
+	    }
+	}
+    }
+/* Run all of the exact-length tests with the length made too short--expect to
+ * fail.  */
+for(l=0; l
+    const struct list  *test = &List[l];
+    for(i=0; icnt; i++)  {
+	tot++;	/* Keep track of number of tests */
+	ret = strftime(out, test->vec[i].max-1, test->vec[i].fmt, test->tms);
+	if(ret != 0)  {
+	    errr++;
+	    fprintf(stderr,
+		"ERROR:  return %d != %d expected for List[%d].vec[%d]\n",
+						ret, 0, l, i);
+	    }
+	/* Almost every conversion puts out as many characters as possible, so
+	 * go ahead and test the output even though have failed.  (The test
+	 * times chosen happen to not hit any of the cases that fail this, so it
+	 * works.)  */
+	if(strncmp(out, test->vec[i].out, test->vec[i].max-1-1))  {
+	    erro++;
+	    fprintf(stderr,
+		"ERROR:  \"%"SFLG"s\" != \"%"SFLG"s\" expected for List[%d].vec[%d]\n",
+						out, test->vec[i].out, l, i);
+	    }
+	}
+    }
+/* Run all of the special year test cases */
+for(l=0; l
+    const struct list  *test = &ListYr[l];
+    for(i=0; icnt; i++)  {
+	tot++;	/* Keep track of number of tests */
+	ret = strftime(out, test->vec[i].max, test->vec[i].fmt, test->tms);
+	if(ret != test->vec[i].ret)  {
+	    errr++;
+	    fprintf(stderr,
+		"ERROR:  return %d != %d expected for ListYr[%d].vec[%d]\n",
+						ret, test->vec[i].ret, l, i);
+	    }
+	if(strncmp(out, test->vec[i].out, test->vec[i].max-1))  {
+	    erro++;
+	    fprintf(stderr,
+		"ERROR:  \"%"SFLG"s\" != \"%"SFLG"s\" expected for ListYr[%d].vec[%d]\n",
+						out, test->vec[i].out, l, i);
+	    }
+	}
+    }
+#define STRIZE(f)	#f
+#define NAME(f)	STRIZE(f)
+printf(NAME(strftime) "() test ");
+if(errr || erro)  printf("FAILED %d/%d of", errr, erro);
+  else    printf("passed");
 printf(" %d test cases.\n", tot);
   return 0;
 return(errr || erro);
--
+}
 #endif /* defined(_REGRESSION_TEST) ] */

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/newlib/libc/time/strftime.c – Rev 4874 → 4921