1 /* -*- c-file-style: "linux" -*- */
6 * Public-domain implementation of ANSI C library routine.
8 * It's written in old-style C for maximal portability.
9 * However, since I'm used to prototypes, I've included them too.
11 * If you want stuff in the System V ascftime routine, add the SYSV_EXT define.
12 * For extensions from SunOS, add SUNOS_EXT.
13 * For stuff needed to implement the P1003.2 date command, add POSIX2_DATE.
14 * For VMS dates, add VMS_EXT.
15 * For a an RFC822 time format, add MAILHEADER_EXT.
16 * For ISO week years, add ISO_DATE_EXT.
17 * For complete POSIX semantics, add POSIX_SEMANTICS.
19 * The code for %c, %x, and %X now follows the 1003.2 specification for
21 * This version ignores LOCALE information.
22 * It also doesn't worry about multi-byte characters.
25 * This file is also shipped with GAWK (GNU Awk), gawk specific bits of
26 * code are included if GAWK is defined.
29 * January, February, March, 1991
30 * Updated March, April 1992
32 * Updated February, 1994
34 * Updated January, 1995
35 * Updated September, 1995
36 * Updated January, 1996
38 * Fixes from ado@elsie.nci.nih.gov
39 * February 1991, May 1992
40 * Fixes from Tor Lillqvist tml@tik.vtt.fi
42 * Further fixes from ado@elsie.nci.nih.gov
44 * %z code from chip@chinacat.unicom.com
45 * Applied September 1995
46 * %V code fixed (again) and %G, %g added,
50 #include "ruby/internal/config.h"
57 #include <sys/types.h>
60 #if defined(TM_IN_SYS_TIME) || !defined(GAWK)
61 #include <sys/types.h>
62 #ifdef HAVE_SYS_TIME_H
69 #include "internal/encoding.h"
70 #include "internal/string.h"
71 #include "internal/vm.h"
72 #include "ruby/encoding.h"
73 #include "ruby/ruby.h"
74 #include "ruby/util.h"
77 /* defaults: season to taste */
78 #define SYSV_EXT 1 /* stuff in System V ascftime routine */
79 #define SUNOS_EXT 1 /* stuff in SunOS strftime routine */
80 #define POSIX2_DATE 1 /* stuff in Posix 1003.2 date command */
81 #define VMS_EXT 1 /* include %v for VMS date format */
82 #define MAILHEADER_EXT 1 /* add %z for HHMM format */
83 #define ISO_DATE_EXT 1 /* %G and %g for year of ISO week */
85 #if defined(ISO_DATE_EXT)
86 #if ! defined(POSIX2_DATE)
91 #if defined(POSIX2_DATE)
92 #if ! defined(SYSV_EXT)
95 #if ! defined(SUNOS_EXT)
100 #if defined(POSIX2_DATE)
101 #define adddecl(stuff) stuff
103 #define adddecl(stuff)
106 #undef strchr /* avoid AIX weirdness */
108 #if !defined __STDC__ && !defined _WIN32
110 static int weeknumber();
111 adddecl(static int iso8601wknum();)
112 static int weeknumber_v();
113 adddecl(static int iso8601wknum_v();)
115 static int weeknumber(const struct tm
*timeptr
, int firstweekday
);
116 adddecl(static int iso8601wknum(const struct tm
*timeptr
);)
117 static int weeknumber_v(const struct vtm
*vtm
, int firstweekday
);
118 adddecl(static int iso8601wknum_v(const struct vtm
*vtm
);)
125 extern void *malloc();
126 extern void *realloc();
127 extern char *getenv();
128 extern char *strchr();
131 #define range(low, item, hi) max((low), min((item), (hi)))
133 #undef min /* just in case */
135 /* min --- return minimum of two numbers */
140 return (a
< b
? a
: b
);
143 #undef max /* also, just in case */
145 /* max --- return maximum of two numbers */
150 return (a
> b
? a
: b
);
153 #ifdef NO_STRING_LITERAL_CONCATENATION
154 #error No string literal concatenation
157 #define add(x,y) (rb_funcall((x), '+', 1, (y)))
158 #define sub(x,y) (rb_funcall((x), '-', 1, (y)))
159 #define mul(x,y) (rb_funcall((x), '*', 1, (y)))
160 #define quo(x,y) (rb_funcall((x), rb_intern("quo"), 1, (y)))
161 #define div(x,y) (rb_funcall((x), rb_intern("div"), 1, (y)))
162 #define mod(x,y) (rb_funcall((x), '%', 1, (y)))
164 /* strftime --- produce formatted time */
166 enum {LEFT
, CHCASE
, LOWER
, UPPER
};
167 #define BIT_OF(n) (1U<<(n))
170 resize_buffer(VALUE ftime
, char *s
, const char **start
, const char **endp
,
171 ptrdiff_t n
, size_t maxsize
)
173 size_t len
= s
- *start
;
174 size_t nlen
= len
+ n
* 2;
176 if (nlen
< len
|| nlen
> maxsize
) {
179 rb_str_set_len(ftime
, len
);
180 rb_str_modify_expand(ftime
, nlen
-len
);
181 s
= RSTRING_PTR(ftime
);
188 buffer_size_check(const char *s
,
189 const char *format_end
, size_t format_len
,
193 const char *format
= format_end
-format_len
;
194 VALUE fmt
= rb_enc_str_new(format
, format_len
, enc
);
195 rb_syserr_fail_str(ERANGE
, fmt
);
200 case_conv(char *s
, ptrdiff_t i
, int flags
)
202 switch (flags
& (BIT_OF(UPPER
)|BIT_OF(LOWER
))) {
205 if (ISLOWER(*s
)) *s
= TOUPPER(*s
);
210 if (ISUPPER(*s
)) *s
= TOLOWER(*s
);
221 format_value(VALUE val
, int base
)
223 if (!RB_BIGNUM_TYPE_P(val
))
224 val
= rb_Integer(val
);
225 return rb_big2str(val
, base
);
229 * enc is the encoding of the format. It is used as the encoding of resulted
230 * string, but the name of the month and weekday are always US-ASCII. So it
231 * is only used for the timezone name on Windows.
234 rb_strftime_with_timespec(VALUE ftime
, const char *format
, size_t format_len
,
235 rb_encoding
*enc
, VALUE time
, const struct vtm
*vtm
,
236 VALUE timev
, struct timespec
*ts
, int gmt
, size_t maxsize
)
238 size_t len
= RSTRING_LEN(ftime
);
239 char *s
= RSTRING_PTR(ftime
);
240 const char *start
= s
;
241 const char *endp
= start
+ rb_str_capacity(ftime
);
242 const char *const format_end
= format
+ format_len
;
245 auto char tbuf
[TBUFSIZE
];
250 int precision
, flags
, colons
;
252 #ifdef MAILHEADER_EXT
257 /* various tables, useful in North America */
258 static const char days_l
[][10] = {
259 "Sunday", "Monday", "Tuesday", "Wednesday",
260 "Thursday", "Friday", "Saturday",
262 static const char months_l
[][10] = {
263 "January", "February", "March", "April",
264 "May", "June", "July", "August", "September",
265 "October", "November", "December",
267 static const char ampm
[][3] = { "AM", "PM", };
269 if (format
== NULL
|| format_len
== 0 || vtm
== NULL
) {
274 (rb_is_usascii_enc(enc
) ||
275 rb_is_ascii8bit_enc(enc
) ||
276 rb_is_locale_enc(enc
))) {
281 for (; format
< format_end
; format
++) {
282 #define FLAG_FOUND() do { \
286 #define NEEDS(n) do { \
287 if (s >= endp || (n) >= endp - s - 1) { \
288 s = resize_buffer(ftime, s, &start, &endp, (n), maxsize); \
289 buffer_size_check(s, format_end, format_len, enc); \
292 #define FILL_PADDING(i) do { \
293 if (!(flags & BIT_OF(LEFT)) && precision > (i)) { \
295 memset(s, padding ? padding : ' ', precision - (i)); \
296 s += precision - (i); \
302 #define FMT_PADDING(fmt, def_pad) \
303 (&"%*"fmt"\0""%0*"fmt[\
304 (padding == '0' || (!padding && (def_pad) == '0')) ? \
305 rb_strlen_lit("%*"fmt)+1 : 0])
306 #define FMT_PRECISION(def_prec) \
307 ((flags & BIT_OF(LEFT)) ? (1) : \
308 (precision <= 0) ? (def_prec) : (precision))
309 #define FMT(def_pad, def_prec, fmt, val) \
311 precision = FMT_PRECISION(def_prec); \
314 rb_str_set_len(ftime, len); \
315 rb_str_catf(ftime, FMT_PADDING(fmt, def_pad), \
317 RSTRING_GETMEM(ftime, s, len); \
318 endp = (start = s) + rb_str_capacity(ftime); \
321 #define STRFTIME(fmt) \
324 rb_str_set_len(ftime, len); \
325 if (!rb_strftime_with_timespec(ftime, (fmt), rb_strlen_lit(fmt), \
326 enc, time, vtm, timev, ts, gmt, maxsize)) \
328 s = RSTRING_PTR(ftime); \
329 i = RSTRING_LEN(ftime) - len; \
330 endp = (start = s) + rb_str_capacity(ftime); \
332 if (i > 0) case_conv(s, i, flags); \
333 if (precision > i) {\
337 memmove(s + precision - i, s, i);\
338 memset(s, padding ? padding : ' ', precision - i); \
343 #define FMTV(def_pad, def_prec, fmt, val) \
346 if (FIXNUM_P(tmp)) { \
347 FMT((def_pad), (def_prec), "l"fmt, FIX2LONG(tmp)); \
350 const int base = ((fmt[0] == 'x') ? 16 : \
351 (fmt[0] == 'o') ? 8 : \
353 precision = FMT_PRECISION(def_prec); \
354 if (!padding) padding = (def_pad); \
355 tmp = format_value(tmp, base); \
356 i = RSTRING_LEN(tmp); \
358 rb_str_set_len(ftime, s-start); \
359 rb_str_append(ftime, tmp); \
360 RSTRING_GETMEM(ftime, s, len); \
361 endp = (start = s) + rb_str_capacity(ftime); \
366 tp
= memchr(format
, '%', format_end
- format
);
367 if (!tp
) tp
= format_end
;
369 memcpy(s
, format
, tp
- format
);
372 if (format
== format_end
) break;
381 if (++format
>= format_end
) goto unknown
;
388 case 'a': /* abbreviated weekday name */
389 if (flags
& BIT_OF(CHCASE
)) {
390 flags
&= ~(BIT_OF(LOWER
)|BIT_OF(CHCASE
));
391 flags
|= BIT_OF(UPPER
);
396 i
= 3, tp
= days_l
[vtm
->wday
];
399 case 'A': /* full weekday name */
400 if (flags
& BIT_OF(CHCASE
)) {
401 flags
&= ~(BIT_OF(LOWER
)|BIT_OF(CHCASE
));
402 flags
|= BIT_OF(UPPER
);
407 i
= strlen(tp
= days_l
[vtm
->wday
]);
411 case 'h': /* abbreviated month name */
413 case 'b': /* abbreviated month name */
414 if (flags
& BIT_OF(CHCASE
)) {
415 flags
&= ~(BIT_OF(LOWER
)|BIT_OF(CHCASE
));
416 flags
|= BIT_OF(UPPER
);
418 if (vtm
->mon
< 1 || vtm
->mon
> 12)
421 i
= 3, tp
= months_l
[vtm
->mon
-1];
424 case 'B': /* full month name */
425 if (flags
& BIT_OF(CHCASE
)) {
426 flags
&= ~(BIT_OF(LOWER
)|BIT_OF(CHCASE
));
427 flags
|= BIT_OF(UPPER
);
429 if (vtm
->mon
< 1 || vtm
->mon
> 12)
432 i
= strlen(tp
= months_l
[vtm
->mon
-1]);
435 case 'c': /* appropriate date and time representation */
436 STRFTIME("%a %b %e %H:%M:%S %Y");
439 case 'd': /* day of the month, 01 - 31 */
440 i
= range(1, vtm
->mday
, 31);
441 FMT('0', 2, "d", (int)i
);
444 case 'H': /* hour, 24-hour clock, 00 - 23 */
445 i
= range(0, vtm
->hour
, 23);
446 FMT('0', 2, "d", (int)i
);
449 case 'I': /* hour, 12-hour clock, 01 - 12 */
450 i
= range(0, vtm
->hour
, 23);
455 FMT('0', 2, "d", (int)i
);
458 case 'j': /* day of the year, 001 - 366 */
459 i
= range(1, vtm
->yday
, 366);
460 FMT('0', 3, "d", (int)i
);
463 case 'm': /* month, 01 - 12 */
464 i
= range(1, vtm
->mon
, 12);
465 FMT('0', 2, "d", (int)i
);
468 case 'M': /* minute, 00 - 59 */
469 i
= range(0, vtm
->min
, 59);
470 FMT('0', 2, "d", (int)i
);
473 case 'p': /* AM or PM based on 12-hour clock */
474 case 'P': /* am or pm based on 12-hour clock */
475 if ((*format
== 'p' && (flags
& BIT_OF(CHCASE
))) ||
476 (*format
== 'P' && !(flags
& (BIT_OF(CHCASE
)|BIT_OF(UPPER
))))) {
477 flags
&= ~(BIT_OF(UPPER
)|BIT_OF(CHCASE
));
478 flags
|= BIT_OF(LOWER
);
480 i
= range(0, vtm
->hour
, 23);
490 time_t sec
= ts
->tv_sec
;
492 FMT('0', 1, PRI_TIMET_PREFIX
"d", sec
);
494 FMT('0', 1, PRI_TIMET_PREFIX
"u", sec
);
497 VALUE sec
= div(timev
, INT2FIX(1));
498 FMTV('0', 1, "d", sec
);
502 case 'S': /* second, 00 - 60 */
503 i
= range(0, vtm
->sec
, 60);
504 FMT('0', 2, "d", (int)i
);
507 case 'U': /* week of year, Sunday is first day of week */
508 FMT('0', 2, "d", weeknumber_v(vtm
, 0));
511 case 'w': /* weekday, Sunday == 0, 0 - 6 */
512 i
= range(0, vtm
->wday
, 6);
513 FMT('0', 1, "d", (int)i
);
516 case 'W': /* week of year, Monday is first day of week */
517 FMT('0', 2, "d", weeknumber_v(vtm
, 1));
520 case 'x': /* appropriate date representation */
521 STRFTIME("%m/%d/%y");
524 case 'X': /* appropriate time representation */
525 STRFTIME("%H:%M:%S");
528 case 'y': /* year without a century, 00 - 99 */
529 i
= NUM2INT(mod(vtm
->year
, INT2FIX(100)));
530 FMT('0', 2, "d", (int)i
);
533 case 'Y': /* year with century */
534 if (FIXNUM_P(vtm
->year
)) {
535 long y
= FIX2LONG(vtm
->year
);
536 FMT('0', 0 <= y
? 4 : 5, "ld", y
);
539 FMTV('0', 4, "d", vtm
->year
);
543 #ifdef MAILHEADER_EXT
544 case 'z': /* time zone offset east of GMT e.g. -0600 */
549 off
= NUM2LONG(rb_funcall(vtm
->utc_offset
, rb_intern("round"), 0));
551 if (off
< 0 || (gmt
&& (flags
& BIT_OF(LEFT
)))) {
559 case 0: /* %z -> +hhmm */
560 precision
= precision
<= 5 ? 2 : precision
-3;
561 NEEDS(precision
+ 3);
564 case 1: /* %:z -> +hh:mm */
565 precision
= precision
<= 6 ? 2 : precision
-4;
566 NEEDS(precision
+ 4);
569 case 2: /* %::z -> +hh:mm:ss */
570 precision
= precision
<= 9 ? 2 : precision
-7;
571 NEEDS(precision
+ 7);
574 case 3: /* %:::z -> +hh[:mm[:ss]] */
575 if (off
% 3600 == 0) {
576 precision
= precision
<= 3 ? 2 : precision
-1;
577 NEEDS(precision
+ 3);
579 else if (off
% 60 == 0) {
580 precision
= precision
<= 6 ? 2 : precision
-4;
581 NEEDS(precision
+ 4);
584 precision
= precision
<= 9 ? 2 : precision
-7;
585 NEEDS(precision
+ 9);
593 i
= snprintf(s
, endp
- s
, (padding
== ' ' ? "%+*ld" : "%+.*ld"),
594 precision
+ (padding
== ' '), sign
* (off
/ 3600));
596 if (sign
< 0 && off
< 3600) {
597 *(padding
== ' ' ? s
+ i
- 2 : s
) = '-';
601 if (colons
== 3 && off
== 0)
605 i
= snprintf(s
, endp
- s
, "%02d", (int)(off
/ 60));
609 if (colons
== 3 && off
== 0)
613 i
= snprintf(s
, endp
- s
, "%02d", (int)off
);
618 #endif /* MAILHEADER_EXT */
620 case 'Z': /* time zone name or abbreviation */
621 if (flags
& BIT_OF(CHCASE
)) {
622 flags
&= ~(BIT_OF(UPPER
)|BIT_OF(CHCASE
));
623 flags
|= BIT_OF(LOWER
);
630 if (NIL_P(vtm
->zone
)) {
635 zone
= rb_time_zone_abbreviation(vtm
->zone
, time
);
637 tp
= RSTRING_PTR(zone
);
639 for (i
= 0; i
< TBUFSIZE
&& tp
[i
]; i
++) {
640 if ((unsigned char)tp
[i
] > 0x7F) {
641 VALUE str
= rb_str_conv_enc_opts(rb_str_new_cstr(tp
), rb_locale_encoding(), enc
, ECONV_UNDEF_REPLACE
|ECONV_INVALID_REPLACE
, Qnil
);
642 i
= strlcpy(tbuf
, RSTRING_PTR(str
), TBUFSIZE
);
654 case 'n': /* same as \n */
659 case 't': /* same as \t */
664 case 'D': /* date as %m/%d/%y */
665 STRFTIME("%m/%d/%y");
668 case 'e': /* day of month, blank padded */
669 FMT(' ', 2, "d", range(1, vtm
->mday
, 31));
672 case 'r': /* time as %I:%M:%S %p */
673 STRFTIME("%I:%M:%S %p");
676 case 'R': /* time as %H:%M */
680 case 'T': /* time as %H:%M:%S */
681 STRFTIME("%H:%M:%S");
686 case 'k': /* hour, 24-hour clock, blank pad */
687 i
= range(0, vtm
->hour
, 23);
688 FMT(' ', 2, "d", (int)i
);
691 case 'l': /* hour, 12-hour clock, 1 - 12, blank pad */
692 i
= range(0, vtm
->hour
, 23);
697 FMT(' ', 2, "d", (int)i
);
703 case 'v': /* date as dd-bbb-YYYY */
704 STRFTIME("%e-%^b-%4Y");
711 FMTV('0', 2, "d", div(vtm
->year
, INT2FIX(100)));
715 /* POSIX locale extensions, ignored for now */
716 if (!format
[1] || !strchr("cCxXyY", format
[1]))
720 /* POSIX locale extensions, ignored for now */
721 if (!format
[1] || !strchr("deHkIlmMSuUVwWy", format
[1]))
725 case 'V': /* week of year according ISO 8601 */
726 FMT('0', 2, "d", iso8601wknum_v(vtm
));
730 /* ISO 8601: Weekday as a decimal number [1 (Monday) - 7] */
731 FMT('0', 1, "d", vtm
->wday
== 0 ? 7 : vtm
->wday
);
733 #endif /* POSIX2_DATE */
741 * If it's December but the ISO week number is one,
742 * that week is in next year.
743 * If it's January but the ISO week number is 52 or
744 * 53, that week is in last year.
745 * Otherwise, it's this year.
748 VALUE yv
= vtm
->year
;
749 w
= iso8601wknum_v(vtm
);
750 if (vtm
->mon
== 12 && w
== 1)
751 yv
= add(yv
, INT2FIX(1));
752 else if (vtm
->mon
== 1 && w
>= 52)
753 yv
= sub(yv
, INT2FIX(1));
755 if (*format
== 'G') {
757 const long y
= FIX2LONG(yv
);
758 FMT('0', 0 <= y
? 4 : 5, "ld", y
);
761 FMTV('0', 4, "d", yv
);
765 yv
= mod(yv
, INT2FIX(100));
767 FMT('0', 2, "ld", y
);
772 #endif /* ISO_DATE_EXT */
781 * fractional second digits. default is 9 digits
784 * %3N millisecond (3 digits)
785 * %6N microsecond (6 digits)
786 * %9N nanosecond (9 digits)
790 if (precision
<= 0) {
796 long subsec
= ts
->tv_nsec
;
798 snprintf(s
, endp
- s
, "%09ld", subsec
);
799 memset(s
+9, '0', precision
-9);
804 for (i
= 0; i
< 9-precision
; i
++)
806 snprintf(s
, endp
- s
, "%0*ld", precision
, subsec
);
811 VALUE subsec
= mod(timev
, INT2FIX(1));
817 subsec
= mul(subsec
, INT2FIX(1000000000));
824 subsec
= mul(subsec
, INT2FIX(n
));
825 subsec
= div(subsec
, INT2FIX(1));
827 if (FIXNUM_P(subsec
)) {
828 (void)snprintf(s
, endp
- s
, "%0*ld", precision
, FIX2LONG(subsec
));
832 VALUE args
[2], result
;
833 args
[0] = INT2FIX(precision
);
835 result
= rb_str_format(2, args
,
836 rb_fstring_lit("%0*d"));
837 (void)strlcpy(s
, StringValueCStr(result
), endp
-s
);
843 case 'F': /* Equivalent to %Y-%m-%d */
844 STRFTIME("%Y-%m-%d");
849 flags
|= BIT_OF(LEFT
);
850 padding
= precision
= 0;
855 flags
|= BIT_OF(UPPER
);
860 flags
|= BIT_OF(CHCASE
);
869 for (colons
= 1; colons
<= 3; ++colons
) {
870 if (format
+colons
>= format_end
) goto unknown
;
871 if (format
[colons
] == 'z') break;
872 if (format
[colons
] != ':') goto unknown
;
874 format
+= colons
- 1;
879 case '1': case '2': case '3': case '4':
880 case '5': case '6': case '7': case '8': case '9':
884 unsigned long u
= ruby_scan_digits(format
, format_end
-format
, 10, &n
, &ov
);
885 if (ov
|| u
> INT_MAX
) goto unknown
;
904 s
= case_conv(s
, i
, flags
);
907 if (format
!= format_end
) {
911 rb_str_set_len(ftime
, len
);
912 rb_str_resize(ftime
, len
);
920 strftime_size_limit(size_t format_len
)
922 size_t limit
= format_len
* (1*1024*1024);
923 if (limit
< format_len
) limit
= format_len
;
924 else if (limit
< 1024) limit
= 1024;
929 rb_strftime(const char *format
, size_t format_len
, rb_encoding
*enc
,
930 VALUE time
, const struct vtm
*vtm
, VALUE timev
, int gmt
)
932 VALUE result
= rb_enc_str_new(0, 0, enc
);
933 return rb_strftime_with_timespec(result
, format
, format_len
, enc
,
934 time
, vtm
, timev
, NULL
, gmt
,
935 strftime_size_limit(format_len
));
939 rb_strftime_timespec(const char *format
, size_t format_len
, rb_encoding
*enc
,
940 VALUE time
, const struct vtm
*vtm
, struct timespec
*ts
, int gmt
)
942 VALUE result
= rb_enc_str_new(0, 0, enc
);
943 return rb_strftime_with_timespec(result
, format
, format_len
, enc
,
944 time
, vtm
, Qnil
, ts
, gmt
,
945 strftime_size_limit(format_len
));
950 rb_strftime_limit(const char *format
, size_t format_len
, rb_encoding
*enc
,
951 VALUE time
, const struct vtm
*vtm
, struct timespec
*ts
,
952 int gmt
, size_t maxsize
)
954 VALUE result
= rb_enc_str_new(0, 0, enc
);
955 return rb_strftime_with_timespec(result
, format
, format_len
, enc
,
956 time
, vtm
, Qnil
, ts
, gmt
, maxsize
);
960 /* isleap --- is a year a leap year? */
965 return ((year
% 4 == 0 && year
% 100 != 0) || year
% 400 == 0);
970 vtm2tm_noyear(const struct vtm
*vtm
, struct tm
*result
)
974 /* for isleap() in iso8601wknum. +100 is -1900 (mod 400). */
975 tm
.tm_year
= FIX2INT(mod(vtm
->year
, INT2FIX(400))) + 100;
977 tm
.tm_mon
= vtm
->mon
-1;
978 tm
.tm_mday
= vtm
->mday
;
979 tm
.tm_hour
= vtm
->hour
;
980 tm
.tm_min
= vtm
->min
;
981 tm
.tm_sec
= vtm
->sec
;
982 tm
.tm_wday
= vtm
->wday
;
983 tm
.tm_yday
= vtm
->yday
-1;
984 tm
.tm_isdst
= vtm
->isdst
;
985 #if defined(HAVE_STRUCT_TM_TM_GMTOFF)
986 tm
.tm_gmtoff
= NUM2LONG(vtm
->utc_offset
);
988 #if defined(HAVE_TM_ZONE)
989 tm
.tm_zone
= (char *)vtm
->zone
;
995 /* iso8601wknum --- compute week number according to ISO 8601 */
998 iso8601wknum(const struct tm
*timeptr
)
1002 * If the week (Monday to Sunday) containing January 1
1003 * has four or more days in the new year, then it is week 1;
1004 * otherwise it is the highest numbered week of the previous
1005 * year (52 or 53), and the next week is week 1.
1007 * ADR: This means if Jan 1 was Monday through Thursday,
1008 * it was week 1, otherwise week 52 or 53.
1010 * XPG4 erroneously included POSIX.2 rationale text in the
1011 * main body of the standard. Thus it requires week 53.
1014 int weeknum
, jan1day
;
1016 /* get week number, Monday as first day of the week */
1017 weeknum
= weeknumber(timeptr
, 1);
1020 * With thanks and tip of the hatlo to tml@tik.vtt.fi
1022 * What day of the week does January 1 fall on?
1024 * (timeptr->tm_yday - jan1.tm_yday) MOD 7 ==
1025 * (timeptr->tm_wday - jan1.tm_wday) MOD 7
1029 * timeptr->tm_wday MOD 7 == timeptr->tm_wday
1030 * from which it follows that. . .
1032 jan1day
= timeptr
->tm_wday
- (timeptr
->tm_yday
% 7);
1037 * If Jan 1 was a Monday through Thursday, it was in
1038 * week 1. Otherwise it was last year's highest week, which is
1039 * this year's week 0.
1041 * What does that mean?
1042 * If Jan 1 was Monday, the week number is exactly right, it can
1044 * If it was Tuesday through Thursday, the weeknumber is one
1045 * less than it should be, so we add one.
1046 * Otherwise, Friday, Saturday or Sunday, the week number is
1047 * OK, but if it is 0, it needs to be 52 or 53.
1050 case 1: /* Monday */
1052 case 2: /* Tuesday */
1053 case 3: /* Wednesday */
1054 case 4: /* Thursday */
1057 case 5: /* Friday */
1058 case 6: /* Saturday */
1059 case 0: /* Sunday */
1061 #ifdef USE_BROKEN_XPG4
1062 /* XPG4 (as of March 1994) says 53 unconditionally */
1065 /* get week number of last week of last year */
1066 struct tm dec31ly
; /* 12/31 last year */
1069 dec31ly
.tm_mon
= 11;
1070 dec31ly
.tm_mday
= 31;
1071 dec31ly
.tm_wday
= (jan1day
== 0) ? 6 : jan1day
- 1;
1072 dec31ly
.tm_yday
= 364 + isleap(dec31ly
.tm_year
+ 1900L);
1073 weeknum
= iso8601wknum(& dec31ly
);
1079 if (timeptr
->tm_mon
== 11) {
1081 * The last week of the year
1082 * can be in week 1 of next year.
1085 * This can only happen if
1093 wday
= timeptr
->tm_wday
;
1094 mday
= timeptr
->tm_mday
;
1095 if ( (wday
== 1 && (mday
>= 29 && mday
<= 31))
1096 || (wday
== 2 && (mday
== 30 || mday
== 31))
1097 || (wday
== 3 && mday
== 31))
1105 iso8601wknum_v(const struct vtm
*vtm
)
1108 vtm2tm_noyear(vtm
, &tm
);
1109 return iso8601wknum(&tm
);
1114 /* weeknumber --- figure how many weeks into the year */
1116 /* With thanks and tip of the hatlo to ado@elsie.nci.nih.gov */
1119 weeknumber(const struct tm
*timeptr
, int firstweekday
)
1121 int wday
= timeptr
->tm_wday
;
1124 if (firstweekday
== 1) {
1125 if (wday
== 0) /* sunday */
1130 ret
= ((timeptr
->tm_yday
+ 7 - wday
) / 7);
1137 weeknumber_v(const struct vtm
*vtm
, int firstweekday
)
1140 vtm2tm_noyear(vtm
, &tm
);
1141 return weeknumber(&tm
, firstweekday
);
1145 /* ADR --- I'm loathe to mess with ado's code ... */
1147 Date
: Wed
, 24 Apr
91 20:54:08 MDT
1148 From
: Michal Jaegermann
<audfax
!emory
!vm
.ucs
.UAlberta
.CA
!NTOMCZAK
>
1149 To
: arnold@audiofax
.com
1152 in a process of fixing of
strftime() in libraries on Atari ST I grabbed
1153 some pieces of code from your own strftime
. When doing that it came
1154 to mind that your
weeknumber() function compiles a little bit nicer
1155 in the following form
:
1157 * firstweekday is 0 if starting in Sunday, non-zero if in Monday
1160 return (timeptr
->tm_yday
- timeptr
->tm_wday
+
1161 (firstweekday
? (timeptr
->tm_wday
? 8 : 1) : 7)) / 7;
1163 How nicer it depends on a compiler
, of course
, but always a tiny bit
.
1167 ntomczak@vm
.ucs
.ualberta
.ca
1170 #ifdef TEST_STRFTIME
1180 * "tst" is a test driver for the function "strftime".
1187 * Control Data Systems, Inc.
1188 * vogelke@c-17igp.wpafb.af.mil
1194 * cc -o tst -DTEST_STRFTIME strftime.c
1197 /* ADR: I reformatted this to my liking, and deleted some unneeded code. */
1202 #include <sys/time.h>
1208 * Array of time formats.
1211 static char *array
[] =
1213 "(%%A) full weekday name, var length (Sunday..Saturday) %A",
1214 "(%%B) full month name, var length (January..December) %B",
1216 "(%%D) date (%%m/%%d/%%y) %D",
1217 "(%%E) Locale extensions (ignored) %E",
1218 "(%%H) hour (24-hour clock, 00..23) %H",
1219 "(%%I) hour (12-hour clock, 01..12) %I",
1220 "(%%M) minute (00..59) %M",
1221 "(%%O) Locale extensions (ignored) %O",
1222 "(%%R) time, 24-hour (%%H:%%M) %R",
1223 "(%%S) second (00..60) %S",
1224 "(%%T) time, 24-hour (%%H:%%M:%%S) %T",
1225 "(%%U) week of year, Sunday as first day of week (00..53) %U",
1226 "(%%V) week of year according to ISO 8601 %V",
1227 "(%%W) week of year, Monday as first day of week (00..53) %W",
1228 "(%%X) appropriate locale time representation (%H:%M:%S) %X",
1229 "(%%Y) year with century (1970...) %Y",
1230 "(%%Z) timezone (EDT), or blank if timezone not determinable %Z",
1231 "(%%a) locale's abbreviated weekday name (Sun..Sat) %a",
1232 "(%%b) locale's abbreviated month name (Jan..Dec) %b",
1233 "(%%c) full date (Sat Nov 4 12:02:33 1989)%n%t%t%t %c",
1234 "(%%d) day of the month (01..31) %d",
1235 "(%%e) day of the month, blank-padded ( 1..31) %e",
1236 "(%%h) should be same as (%%b) %h",
1237 "(%%j) day of the year (001..366) %j",
1238 "(%%k) hour, 24-hour clock, blank pad ( 0..23) %k",
1239 "(%%l) hour, 12-hour clock, blank pad ( 1..12) %l",
1240 "(%%m) month (01..12) %m",
1241 "(%%p) locale's AM or PM based on 12-hour clock %p",
1242 "(%%r) time, 12-hour (same as %%I:%%M:%%S %%p) %r",
1243 "(%%u) ISO 8601: Weekday as decimal number [1 (Monday) - 7] %u",
1244 "(%%v) VMS date (dd-bbb-YYYY) %v",
1245 "(%%w) day of week (0..6, Sunday == 0) %w",
1246 "(%%x) appropriate locale date representation %x",
1247 "(%%y) last two digits of year (00..99) %y",
1248 "(%%z) timezone offset east of GMT as HHMM (e.g. -0500) %z",
1255 main(int argc
, char **argv
)
1260 char string
[MAXTIME
];
1269 /* Call the function. */
1271 clock
= time((long *) 0);
1272 tm
= localtime(&clock
);
1274 for (k
= 0; next
= array
[k
]; k
++) {
1275 length
= strftime(string
, MAXTIME
, next
, tm
);
1276 printf("%s\n", string
);
1281 #endif /* TEST_STRFTIME */