155 |
#endif |
#endif |
156 |
|
|
157 |
|
|
158 |
#ifdef COMPILE_WIDE |
#ifndef FPRINTFTIME |
159 |
|
# define FPRINTFTIME 0 |
160 |
|
#endif |
161 |
|
|
162 |
|
#if FPRINTFTIME |
163 |
|
# define STREAM_OR_CHAR_T FILE |
164 |
|
# define STRFTIME_ARG(x) /* empty */ |
165 |
|
#else |
166 |
|
# define STREAM_OR_CHAR_T CHAR_T |
167 |
|
# define STRFTIME_ARG(x) x, |
168 |
|
#endif |
169 |
|
|
170 |
|
#if FPRINTFTIME |
171 |
|
# define memset_byte(P, Len, Byte) \ |
172 |
|
do { size_t _i; for (_i = 0; _i < Len; _i++) fputc (Byte, P); } while (0) |
173 |
|
# define memset_space(P, Len) memset_byte (P, Len, ' ') |
174 |
|
# define memset_zero(P, Len) memset_byte (P, Len, '0') |
175 |
|
#elif defined COMPILE_WIDE |
176 |
# define memset_space(P, Len) (wmemset (P, L' ', Len), (P) += (Len)) |
# define memset_space(P, Len) (wmemset (P, L' ', Len), (P) += (Len)) |
177 |
# define memset_zero(P, Len) (wmemset (P, L'0', Len), (P) += (Len)) |
# define memset_zero(P, Len) (wmemset (P, L'0', Len), (P) += (Len)) |
178 |
#else |
#else |
190 |
return 0; \ |
return 0; \ |
191 |
if (p) \ |
if (p) \ |
192 |
{ \ |
{ \ |
193 |
if (_delta > 0) \ |
if (digits == 0 && _delta > 0) \ |
194 |
{ \ |
{ \ |
195 |
if (pad == L_('0')) \ |
if (pad == L_('0')) \ |
196 |
memset_zero (p, _delta); \ |
memset_zero (p, _delta); \ |
198 |
memset_space (p, _delta); \ |
memset_space (p, _delta); \ |
199 |
} \ |
} \ |
200 |
f; \ |
f; \ |
201 |
p += _n; \ |
p += FPRINTFTIME ? 0 : _n; \ |
202 |
} \ |
} \ |
203 |
i += _incr; \ |
i += _incr; \ |
204 |
} while (0) |
} while (0) |
205 |
|
|
206 |
#define cpy(n, s) \ |
#if FPRINTFTIME |
207 |
|
# define add1(C) add (1, fputc (C, p)) |
208 |
|
#else |
209 |
|
# define add1(C) add (1, *p = C) |
210 |
|
#endif |
211 |
|
|
212 |
|
#if FPRINTFTIME |
213 |
|
# define cpy(n, s) \ |
214 |
|
add ((n), \ |
215 |
|
if (to_lowcase) \ |
216 |
|
fwrite_lowcase (p, (s), _n); \ |
217 |
|
else if (to_uppcase) \ |
218 |
|
fwrite_uppcase (p, (s), _n); \ |
219 |
|
else \ |
220 |
|
fwrite ((s), _n, 1, p)) |
221 |
|
#else |
222 |
|
# define cpy(n, s) \ |
223 |
add ((n), \ |
add ((n), \ |
224 |
if (to_lowcase) \ |
if (to_lowcase) \ |
225 |
memcpy_lowcase (p, (s), _n LOCALE_ARG); \ |
memcpy_lowcase (p, (s), _n LOCALE_ARG); \ |
227 |
memcpy_uppcase (p, (s), _n LOCALE_ARG); \ |
memcpy_uppcase (p, (s), _n LOCALE_ARG); \ |
228 |
else \ |
else \ |
229 |
MEMCPY ((void *) p, (void const *) (s), _n)) |
MEMCPY ((void *) p, (void const *) (s), _n)) |
230 |
|
#endif |
231 |
|
|
232 |
#ifdef COMPILE_WIDE |
#ifdef COMPILE_WIDE |
233 |
# ifndef USE_IN_EXTENDED_LOCALE_MODEL |
# ifndef USE_IN_EXTENDED_LOCALE_MODEL |
297 |
more reliable way to accept other sets of digits. */ |
more reliable way to accept other sets of digits. */ |
298 |
#define ISDIGIT(Ch) ((unsigned int) (Ch) - L_('0') <= 9) |
#define ISDIGIT(Ch) ((unsigned int) (Ch) - L_('0') <= 9) |
299 |
|
|
300 |
|
#if FPRINTFTIME |
301 |
|
static void |
302 |
|
fwrite_lowcase (FILE *fp, const CHAR_T *src, size_t len) |
303 |
|
{ |
304 |
|
while (len-- > 0) |
305 |
|
{ |
306 |
|
fputc (TOLOWER ((UCHAR_T) *src, loc), fp); |
307 |
|
++src; |
308 |
|
} |
309 |
|
} |
310 |
|
|
311 |
|
static void |
312 |
|
fwrite_uppcase (FILE *fp, const CHAR_T *src, size_t len) |
313 |
|
{ |
314 |
|
while (len-- > 0) |
315 |
|
{ |
316 |
|
fputc (TOUPPER ((UCHAR_T) *src, loc), fp); |
317 |
|
++src; |
318 |
|
} |
319 |
|
} |
320 |
|
#else |
321 |
static CHAR_T * |
static CHAR_T * |
322 |
memcpy_lowcase (CHAR_T *dest, const CHAR_T *src, |
memcpy_lowcase (CHAR_T *dest, const CHAR_T *src, |
323 |
size_t len LOCALE_PARAM_PROTO) |
size_t len LOCALE_PARAM_PROTO) |
335 |
dest[len] = TOUPPER ((UCHAR_T) src[len], loc); |
dest[len] = TOUPPER ((UCHAR_T) src[len], loc); |
336 |
return dest; |
return dest; |
337 |
} |
} |
338 |
|
#endif |
339 |
|
|
340 |
|
|
341 |
#if ! HAVE_TM_GMTOFF |
#if ! HAVE_TM_GMTOFF |
411 |
# define my_strftime nstrftime |
# define my_strftime nstrftime |
412 |
#endif |
#endif |
413 |
|
|
414 |
|
#if FPRINTFTIME |
415 |
|
# undef my_strftime |
416 |
|
# define my_strftime fprintftime |
417 |
|
#endif |
418 |
|
|
419 |
#ifdef my_strftime |
#ifdef my_strftime |
420 |
# define extra_args , ut, ns |
# define extra_args , ut, ns |
421 |
# define extra_args_spec , int ut, int ns |
# define extra_args_spec , int ut, int ns |
422 |
#else |
#else |
423 |
# ifdef COMPILE_WIDE |
# if defined COMPILE_WIDE |
424 |
# define my_strftime wcsftime |
# define my_strftime wcsftime |
425 |
# define nl_get_alt_digit _nl_get_walt_digit |
# define nl_get_alt_digit _nl_get_walt_digit |
426 |
# else |
# else |
435 |
#endif |
#endif |
436 |
|
|
437 |
|
|
438 |
/* Write information from TP into S according to the format |
/* Just like my_strftime, below, but with one more parameter, UPCASE, |
439 |
string FORMAT, writing no more that MAXSIZE characters |
to indicate that the result should be converted to upper case. */ |
440 |
(including the terminating '\0') and returning number of |
static size_t |
441 |
characters written. If S is NULL, nothing will be written |
strftime_case_ (bool upcase, STREAM_OR_CHAR_T *s, |
442 |
anywhere, so to determine how many characters would be |
STRFTIME_ARG (size_t maxsize) |
443 |
written, use NULL for S and (size_t) -1 for MAXSIZE. */ |
const CHAR_T *format, |
444 |
size_t |
const struct tm *tp extra_args_spec LOCALE_PARAM_PROTO) |
|
my_strftime (CHAR_T *s, size_t maxsize, const CHAR_T *format, |
|
|
const struct tm *tp extra_args_spec LOCALE_PARAM_PROTO) |
|
445 |
{ |
{ |
446 |
#if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL |
#if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL |
447 |
struct locale_data *const current = loc->__locales[LC_TIME]; |
struct locale_data *const current = loc->__locales[LC_TIME]; |
448 |
#endif |
#endif |
449 |
|
#if FPRINTFTIME |
450 |
|
size_t maxsize = (size_t) -1; |
451 |
|
#endif |
452 |
|
|
453 |
int hour12 = tp->tm_hour; |
int hour12 = tp->tm_hour; |
454 |
#ifdef _NL_CURRENT |
#ifdef _NL_CURRENT |
488 |
#endif |
#endif |
489 |
const char *zone; |
const char *zone; |
490 |
size_t i = 0; |
size_t i = 0; |
491 |
CHAR_T *p = s; |
STREAM_OR_CHAR_T *p = s; |
492 |
const CHAR_T *f; |
const CHAR_T *f; |
493 |
#if DO_MULTIBYTE && !defined COMPILE_WIDE |
#if DO_MULTIBYTE && !defined COMPILE_WIDE |
494 |
const char *format_end = NULL; |
const char *format_end = NULL; |
539 |
{ |
{ |
540 |
int pad = 0; /* Padding for number ('-', '_', or 0). */ |
int pad = 0; /* Padding for number ('-', '_', or 0). */ |
541 |
int modifier; /* Field modifier ('E', 'O', or 0). */ |
int modifier; /* Field modifier ('E', 'O', or 0). */ |
542 |
int digits; /* Max digits for numeric format. */ |
int digits = 0; /* Max digits for numeric format. */ |
543 |
int number_value; /* Numeric value to be printed. */ |
int number_value; /* Numeric value to be printed. */ |
544 |
unsigned int u_number_value; /* (unsigned int) number_value. */ |
unsigned int u_number_value; /* (unsigned int) number_value. */ |
545 |
bool negative_number; /* 1 if the number is negative. */ |
bool negative_number; /* The number is negative. */ |
546 |
|
bool always_output_a_sign; /* +/- should always be output. */ |
547 |
|
int tz_colon_mask; /* Bitmask of where ':' should appear. */ |
548 |
const CHAR_T *subfmt; |
const CHAR_T *subfmt; |
549 |
|
CHAR_T sign_char; |
550 |
CHAR_T *bufp; |
CHAR_T *bufp; |
551 |
CHAR_T buf[1 + (sizeof (int) < sizeof (time_t) |
CHAR_T buf[1 |
552 |
? INT_STRLEN_BOUND (time_t) |
+ 2 /* for the two colons in a %::z or %:::z time zone */ |
553 |
: INT_STRLEN_BOUND (int))]; |
+ (sizeof (int) < sizeof (time_t) |
554 |
|
? INT_STRLEN_BOUND (time_t) |
555 |
|
: INT_STRLEN_BOUND (int))]; |
556 |
int width = -1; |
int width = -1; |
557 |
bool to_lowcase = false; |
bool to_lowcase = false; |
558 |
bool to_uppcase = false; |
bool to_uppcase = upcase; |
559 |
|
size_t colons; |
560 |
bool change_case = false; |
bool change_case = false; |
561 |
int format_char; |
int format_char; |
562 |
|
|
591 |
be in the basic execution character set. None of these |
be in the basic execution character set. None of these |
592 |
characters can start a multibyte sequence, so they need |
characters can start a multibyte sequence, so they need |
593 |
not be analyzed further. */ |
not be analyzed further. */ |
594 |
add (1, *p = *f); |
add1 (*f); |
595 |
continue; |
continue; |
596 |
|
|
597 |
default: |
default: |
642 |
or this is the wide character version. */ |
or this is the wide character version. */ |
643 |
if (*f != L_('%')) |
if (*f != L_('%')) |
644 |
{ |
{ |
645 |
add (1, *p = *f); |
add1 (*f); |
646 |
continue; |
continue; |
647 |
} |
} |
648 |
|
|
718 |
digits = d; \ |
digits = d; \ |
719 |
negative_number = negative; \ |
negative_number = negative; \ |
720 |
u_number_value = v; goto do_signed_number |
u_number_value = v; goto do_signed_number |
721 |
|
|
722 |
|
/* The mask is not what you might think. |
723 |
|
When the ordinal i'th bit is set, insert a colon |
724 |
|
before the i'th digit of the time zone representation. */ |
725 |
|
#define DO_TZ_OFFSET(d, negative, mask, v) \ |
726 |
|
digits = d; \ |
727 |
|
negative_number = negative; \ |
728 |
|
tz_colon_mask = mask; \ |
729 |
|
u_number_value = v; goto do_tz_offset |
730 |
#define DO_NUMBER_SPACEPAD(d, v) \ |
#define DO_NUMBER_SPACEPAD(d, v) \ |
731 |
digits = d; \ |
digits = d; \ |
732 |
number_value = v; goto do_number_spacepad |
number_value = v; goto do_number_spacepad |
734 |
case L_('%'): |
case L_('%'): |
735 |
if (modifier != 0) |
if (modifier != 0) |
736 |
goto bad_format; |
goto bad_format; |
737 |
add (1, *p = *f); |
add1 (*f); |
738 |
break; |
break; |
739 |
|
|
740 |
case L_('a'): |
case L_('a'): |
818 |
|
|
819 |
subformat: |
subformat: |
820 |
{ |
{ |
821 |
CHAR_T *old_start = p; |
size_t len = strftime_case_ (to_uppcase, |
822 |
size_t len = my_strftime (NULL, (size_t) -1, subfmt, |
NULL, STRFTIME_ARG ((size_t) -1) |
823 |
tp extra_args LOCALE_ARG); |
subfmt, |
824 |
add (len, my_strftime (p, maxsize - i, subfmt, |
tp extra_args LOCALE_ARG); |
825 |
tp extra_args LOCALE_ARG)); |
add (len, strftime_case_ (to_uppcase, p, |
826 |
|
STRFTIME_ARG (maxsize - i) |
827 |
if (to_uppcase) |
subfmt, |
828 |
while (old_start < p) |
tp extra_args LOCALE_ARG)); |
|
{ |
|
|
*old_start = TOUPPER ((UCHAR_T) *old_start, loc); |
|
|
++old_start; |
|
|
} |
|
829 |
} |
} |
830 |
break; |
break; |
831 |
|
|
928 |
DO_NUMBER_SPACEPAD (2, tp->tm_mday); |
DO_NUMBER_SPACEPAD (2, tp->tm_mday); |
929 |
|
|
930 |
/* All numeric formats set DIGITS and NUMBER_VALUE (or U_NUMBER_VALUE) |
/* All numeric formats set DIGITS and NUMBER_VALUE (or U_NUMBER_VALUE) |
931 |
and then jump to one of these three labels. */ |
and then jump to one of these labels. */ |
932 |
|
|
933 |
|
do_tz_offset: |
934 |
|
always_output_a_sign = true; |
935 |
|
goto do_number_body; |
936 |
|
|
937 |
do_number_spacepad: |
do_number_spacepad: |
938 |
/* Force `_' flag unless overridden by `0' or `-' flag. */ |
/* Force `_' flag unless overridden by `0' or `-' flag. */ |
945 |
u_number_value = number_value; |
u_number_value = number_value; |
946 |
|
|
947 |
do_signed_number: |
do_signed_number: |
948 |
|
always_output_a_sign = false; |
949 |
|
tz_colon_mask = 0; |
950 |
|
|
951 |
|
do_number_body: |
952 |
/* Format U_NUMBER_VALUE according to the MODIFIER flag. |
/* Format U_NUMBER_VALUE according to the MODIFIER flag. |
953 |
NEGATIVE_NUMBER is nonzero if the original number was |
NEGATIVE_NUMBER is nonzero if the original number was |
954 |
negative; in this case it was converted directly to |
negative; in this case it was converted directly to |
985 |
|
|
986 |
do |
do |
987 |
{ |
{ |
988 |
|
if (tz_colon_mask & 1) |
989 |
|
*--bufp = ':'; |
990 |
|
tz_colon_mask >>= 1; |
991 |
*--bufp = u_number_value % 10 + L_('0'); |
*--bufp = u_number_value % 10 + L_('0'); |
992 |
u_number_value /= 10; |
u_number_value /= 10; |
993 |
} |
} |
994 |
while (u_number_value != 0); |
while (u_number_value != 0 || tz_colon_mask != 0); |
995 |
|
|
996 |
do_number_sign_and_padding: |
do_number_sign_and_padding: |
997 |
if (digits < width) |
if (digits < width) |
998 |
digits = width; |
digits = width; |
999 |
|
|
1000 |
if (negative_number) |
sign_char = (negative_number ? L_('-') |
1001 |
*--bufp = L_('-'); |
: always_output_a_sign ? L_('+') |
1002 |
|
: 0); |
1003 |
|
|
1004 |
if (pad != L_('-')) |
if (pad == L_('-')) |
1005 |
|
{ |
1006 |
|
if (sign_char) |
1007 |
|
add1 (sign_char); |
1008 |
|
} |
1009 |
|
else |
1010 |
{ |
{ |
1011 |
int padding = digits - (buf + (sizeof (buf) / sizeof (buf[0])) |
int padding = digits - (buf + (sizeof (buf) / sizeof (buf[0])) |
1012 |
- bufp); |
- bufp) - !!sign_char; |
1013 |
|
|
1014 |
if (padding > 0) |
if (padding > 0) |
1015 |
{ |
{ |
1022 |
memset_space (p, padding); |
memset_space (p, padding); |
1023 |
i += padding; |
i += padding; |
1024 |
width = width > padding ? width - padding : 0; |
width = width > padding ? width - padding : 0; |
1025 |
|
if (sign_char) |
1026 |
|
add1 (sign_char); |
1027 |
} |
} |
1028 |
else |
else |
1029 |
{ |
{ |
1030 |
if ((size_t) digits >= maxsize - i) |
if ((size_t) digits >= maxsize - i) |
1031 |
return 0; |
return 0; |
1032 |
|
|
1033 |
if (negative_number) |
if (sign_char) |
1034 |
{ |
add1 (sign_char); |
|
++bufp; |
|
|
|
|
|
if (p) |
|
|
*p++ = L_('-'); |
|
|
++i; |
|
|
} |
|
1035 |
|
|
1036 |
if (p) |
if (p) |
1037 |
memset_zero (p, padding); |
memset_zero (p, padding); |
1039 |
width = 0; |
width = 0; |
1040 |
} |
} |
1041 |
} |
} |
1042 |
|
else |
1043 |
|
{ |
1044 |
|
if (sign_char) |
1045 |
|
add1 (sign_char); |
1046 |
|
} |
1047 |
} |
} |
1048 |
|
|
1049 |
cpy (buf + sizeof (buf) / sizeof (buf[0]) - bufp, bufp); |
cpy (buf + sizeof (buf) / sizeof (buf[0]) - bufp, bufp); |
1103 |
goto bad_format; |
goto bad_format; |
1104 |
|
|
1105 |
number_value = ns; |
number_value = ns; |
1106 |
if (width != -1) |
if (width == -1) |
1107 |
|
width = 9; |
1108 |
|
else |
1109 |
{ |
{ |
1110 |
/* Take an explicit width less than 9 as a precision. */ |
/* Take an explicit width less than 9 as a precision. */ |
1111 |
int j; |
int j; |
1113 |
number_value /= 10; |
number_value /= 10; |
1114 |
} |
} |
1115 |
|
|
1116 |
DO_NUMBER (9, number_value); |
DO_NUMBER (width, number_value); |
1117 |
#endif |
#endif |
1118 |
|
|
1119 |
case L_('n'): |
case L_('n'): |
1120 |
add (1, *p = L_('\n')); |
add1 (L_('\n')); |
1121 |
break; |
break; |
1122 |
|
|
1123 |
case L_('P'): |
case L_('P'): |
1186 |
while (t != 0); |
while (t != 0); |
1187 |
|
|
1188 |
digits = 1; |
digits = 1; |
1189 |
|
always_output_a_sign = false; |
1190 |
goto do_number_sign_and_padding; |
goto do_number_sign_and_padding; |
1191 |
} |
} |
1192 |
|
|
1212 |
goto subformat; |
goto subformat; |
1213 |
|
|
1214 |
case L_('t'): |
case L_('t'): |
1215 |
add (1, *p = L_('\t')); |
add1 (L_('\t')); |
1216 |
break; |
break; |
1217 |
|
|
1218 |
case L_('u'): |
case L_('u'): |
1374 |
#endif |
#endif |
1375 |
break; |
break; |
1376 |
|
|
1377 |
|
case L_(':'): |
1378 |
|
/* :, ::, and ::: are valid only just before 'z'. |
1379 |
|
:::: etc. are rejected later. */ |
1380 |
|
for (colons = 1; f[colons] == L_(':'); colons++) |
1381 |
|
continue; |
1382 |
|
if (f[colons] != L_('z')) |
1383 |
|
goto bad_format; |
1384 |
|
f += colons; |
1385 |
|
goto do_z_conversion; |
1386 |
|
|
1387 |
case L_('z'): |
case L_('z'): |
1388 |
|
colons = 0; |
1389 |
|
|
1390 |
|
do_z_conversion: |
1391 |
if (tp->tm_isdst < 0) |
if (tp->tm_isdst < 0) |
1392 |
break; |
break; |
1393 |
|
|
1394 |
{ |
{ |
1395 |
int diff; |
int diff; |
1396 |
|
int hour_diff; |
1397 |
|
int min_diff; |
1398 |
|
int sec_diff; |
1399 |
#if HAVE_TM_GMTOFF |
#if HAVE_TM_GMTOFF |
1400 |
diff = tp->tm_gmtoff; |
diff = tp->tm_gmtoff; |
1401 |
#else |
#else |
1434 |
} |
} |
1435 |
#endif |
#endif |
1436 |
|
|
1437 |
if (diff < 0) |
hour_diff = diff / 60 / 60; |
1438 |
|
min_diff = diff / 60 % 60; |
1439 |
|
sec_diff = diff % 60; |
1440 |
|
|
1441 |
|
switch (colons) |
1442 |
{ |
{ |
1443 |
add (1, *p = L_('-')); |
case 0: /* +hhmm */ |
1444 |
diff = -diff; |
DO_TZ_OFFSET (5, diff < 0, 0, hour_diff * 100 + min_diff); |
1445 |
} |
|
1446 |
else |
case 1: tz_hh_mm: /* +hh:mm */ |
1447 |
add (1, *p = L_('+')); |
DO_TZ_OFFSET (6, diff < 0, 04, hour_diff * 100 + min_diff); |
1448 |
|
|
1449 |
diff /= 60; |
case 2: tz_hh_mm_ss: /* +hh:mm:ss */ |
1450 |
DO_NUMBER (4, (diff / 60) * 100 + diff % 60); |
DO_TZ_OFFSET (9, diff < 0, 024, |
1451 |
|
hour_diff * 10000 + min_diff * 100 + sec_diff); |
1452 |
|
|
1453 |
|
case 3: /* +hh if possible, else +hh:mm, else +hh:mm:ss */ |
1454 |
|
if (sec_diff != 0) |
1455 |
|
goto tz_hh_mm_ss; |
1456 |
|
if (min_diff != 0) |
1457 |
|
goto tz_hh_mm; |
1458 |
|
DO_TZ_OFFSET (3, diff < 0, 0, hour_diff); |
1459 |
|
|
1460 |
|
default: |
1461 |
|
goto bad_format; |
1462 |
|
} |
1463 |
} |
} |
1464 |
|
|
1465 |
case L_('\0'): /* GNU extension: % at end of format. */ |
case L_('\0'): /* GNU extension: % at end of format. */ |
1480 |
} |
} |
1481 |
} |
} |
1482 |
|
|
1483 |
|
#if ! FPRINTFTIME |
1484 |
if (p && maxsize != 0) |
if (p && maxsize != 0) |
1485 |
*p = L_('\0'); |
*p = L_('\0'); |
1486 |
|
#endif |
1487 |
|
|
1488 |
return i; |
return i; |
1489 |
} |
} |
1490 |
#ifdef _LIBC |
|
1491 |
|
/* Write information from TP into S according to the format |
1492 |
|
string FORMAT, writing no more that MAXSIZE characters |
1493 |
|
(including the terminating '\0') and returning number of |
1494 |
|
characters written. If S is NULL, nothing will be written |
1495 |
|
anywhere, so to determine how many characters would be |
1496 |
|
written, use NULL for S and (size_t) -1 for MAXSIZE. */ |
1497 |
|
size_t |
1498 |
|
my_strftime (STREAM_OR_CHAR_T *s, STRFTIME_ARG (size_t maxsize) |
1499 |
|
const CHAR_T *format, |
1500 |
|
const struct tm *tp extra_args_spec LOCALE_PARAM_PROTO) |
1501 |
|
{ |
1502 |
|
return strftime_case_ (false, s, STRFTIME_ARG (maxsize) |
1503 |
|
format, tp extra_args LOCALE_ARG); |
1504 |
|
} |
1505 |
|
|
1506 |
|
#if defined _LIBC && ! FPRINTFTIME |
1507 |
libc_hidden_def (my_strftime) |
libc_hidden_def (my_strftime) |
1508 |
#endif |
#endif |
1509 |
|
|
1510 |
|
|
1511 |
#ifdef emacs |
#if defined emacs && ! FPRINTFTIME |
1512 |
/* For Emacs we have a separate interface which corresponds to the normal |
/* For Emacs we have a separate interface which corresponds to the normal |
1513 |
strftime function plus the ut argument, but without the ns argument. */ |
strftime function plus the ut argument, but without the ns argument. */ |
1514 |
size_t |
size_t |