mirror of
https://github.com/autc04/Retro68.git
synced 2024-08-30 17:29:33 +00:00
1789 lines
52 KiB
C
1789 lines
52 KiB
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
|
|
<<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 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 *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) ] */
|