/* 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
<<strftime>>---convert date and time to a formatted string

INDEX
	strftime

ANSI_SYNOPSIS
	#include <time.h>
	size_t strftime(char *<[s]>, size_t <[maxsize]>,
			const char *<[format]>, const struct tm *<[timp]>);

TRAD_SYNOPSIS
	#include <time.h>
	size_t strftime(<[s]>, <[maxsize]>, <[format]>, <[timp]>)
	char *<[s]>;
	size_t <[maxsize]>;
	char *<[format]>;
	struct tm *<[timp]>;

DESCRIPTION
<<strftime>> converts a <<struct tm>> 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 `<<Sunday>>', `<<Monday>>', `<<Tuesday>>',
`<<Wednesday>>', `<<Thursday>>', `<<Friday>>', `<<Saturday>>'. [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 `<<January>>', `<<February>>',
`<<March>>', `<<April>>', `<<May>>', `<<June>>', `<<July>>',
`<<August>>', `<<September>>', `<<October>>', `<<November>>',
`<<December>>'. [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
4-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<<x>>
In some locales, the E modifier selects alternative representations of
certain modifiers <<x>>.  In newlib, it is ignored, and treated as %<<x>>.

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,
2nd, 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<<x>>
In some locales, the O modifier selects alternative digit characters
for certain modifiers <<x>>.  In newlib, it is ignored, and treated as %<<x>>.

o %p
Either `<<AM>>' or `<<PM>>' 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 <<strftime>>, but does not specify the contents of
<<*<[s]>>> when the formatted string would require more than
<[maxsize]> characters.  Unrecognized specifiers and fields of
<<timp>> 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 <<s>> being NULL, nor overlapping
<<s>> and <<format>>.

<<strftime>> requires no supporting OS subroutines.

BUGS
<<strftime>> ignores the LC_TIME category of the current locale, hard-coding
the "C" locale settings.
*/

#include <newlib.h>
#include <sys/config.h>
#include <stddef.h>
#include <stdio.h>
#include <time.h>
#include <string.h>
#include <stdlib.h>
#include <limits.h>
#include <ctype.h>
#include <wctype.h>
#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 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

/* Enforce the coding assumptions that YEAR_BASE is positive.  (%C, %Y, etc.) */
#if YEAR_BASE < 0
#  error "YEAR_BASE < 0"
#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.  */
static int
_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);
      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 = 12;
	  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);
	  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 *s _AND
	size_t maxsize _AND
	_CONST CHAR *format _AND
	_CONST struct tm *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 *s _AND
	size_t maxsize _AND
	_CONST CHAR *format _AND
	_CONST struct tm *tim_p)
#endif /* !_WANT_C99_TIME_FORMATS */
{
  size_t count = 0;
  int i, len;
  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
	       10000		100		00
	       9999		99		99
	       0999		09		99
	       0099		00		99
	       0001		00		01
	       0000		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,
						0, *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)  ?
						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];
		  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<sizeof(List)/sizeof(List[0]); l++)  {
    const struct list  *test = &List[l];
    for(i=0; i<test->cnt; 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<sizeof(List)/sizeof(List[0]); l++)  {
    const struct list  *test = &List[l];
    for(i=0; i<test->cnt; 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<sizeof(ListYr)/sizeof(ListYr[0]); l++)  {
    const struct list  *test = &ListYr[l];
    for(i=0; i<test->cnt; 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(errr || erro);
}
#endif /* defined(_REGRESSION_TEST) ] */
