Subversion Repositories Kolibri OS

/* 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 *restrict <[s]>, size_t <[maxsize]>,

			const char *restrict <[format]>,

                        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

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<>

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,

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<>

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 time elapsed, in seconds, since the start of the Unix epoch at

1970-01-01 00:00:00 UTC.

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

/* 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) - 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 len = 0;

  const CHAR *ctloc;

#if defined (MAKE_WCSFTIME) && !defined (__HAVE_LOCALE_INFO_EXTENDED__)

  CHAR ctlocbuf[CTLOCBUFLEN];

#endif

  size_t i, ctloclen;

  CHAR alt;

  CHAR pad;

  unsigned long width;

  int tzset_called = 0;

  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;