12#define _DEFAULT_SOURCE
14#include "ruby/internal/config.h"
30#if defined(HAVE_SYS_TIME_H)
36#include "internal/array.h"
37#include "internal/hash.h"
38#include "internal/compar.h"
39#include "internal/numeric.h"
40#include "internal/rational.h"
41#include "internal/string.h"
42#include "internal/time.h"
43#include "internal/variable.h"
49# include "timezoneapi.h"
54static ID id_submicro, id_nano_num, id_nano_den, id_offset, id_zone;
55static ID id_nanosecond, id_microsecond, id_millisecond, id_nsec, id_usec;
56static ID id_local_to_utc, id_utc_to_local, id_find_timezone;
57static ID id_year, id_mon, id_mday, id_hour, id_min, id_sec, id_isdst;
58static VALUE str_utc, str_empty;
61static VALUE sym_year, sym_month, sym_day, sym_yday, sym_wday;
62static VALUE sym_hour, sym_min, sym_sec, sym_subsec, sym_dst, sym_zone;
66#define id_divmod idDivmod
68#define UTC_ZONE Qundef
70#define NDIV(x,y) (-(-((x)+1)/(y))-1)
71#define NMOD(x,y) ((y)-(-((x)+1)%(y))-1)
72#define DIV(n,d) ((n)<0 ? NDIV((n),(d)) : (n)/(d))
73#define MOD(n,d) ((n)<0 ? NMOD((n),(d)) : (n)%(d))
74#define VTM_WDAY_INITVAL (7)
75#define VTM_ISDST_INITVAL (3)
90 if ((
long)x < (
long)y)
92 if ((
long)x > (
long)y)
96 if (RB_BIGNUM_TYPE_P(x))
return FIX2INT(rb_big_cmp(x, y));
97 return rb_cmpint(
rb_funcall(x, idCmp, 1, y), x, y);
100#define ne(x,y) (!eq((x),(y)))
101#define lt(x,y) (cmp((x),(y)) < 0)
102#define gt(x,y) (cmp((x),(y)) > 0)
103#define le(x,y) (cmp((x),(y)) <= 0)
104#define ge(x,y) (cmp((x),(y)) >= 0)
112 if (RB_BIGNUM_TYPE_P(x))
return rb_big_plus(x, y);
122 if (RB_BIGNUM_TYPE_P(x))
return rb_big_minus(x, y);
130 return rb_fix_mul_fix(x, y);
132 if (RB_BIGNUM_TYPE_P(x))
133 return rb_big_mul(x, y);
141 return rb_fix_div_fix(x, y);
143 if (RB_BIGNUM_TYPE_P(x))
144 return rb_big_div(x, y);
153 if (
FIXNUM_P(x))
return rb_fix_mod_fix(x, y);
155 if (RB_BIGNUM_TYPE_P(x))
return rb_big_modulo(x, y);
159#define neg(x) (subv(INT2FIX(0), (x)))
175 return rb_numeric_quo(x, y);
181 VALUE ret = quor(x, y);
183 RRATIONAL(ret)->den ==
INT2FIX(1)) {
184 ret = RRATIONAL(ret)->num;
189#define mulquov(x,y,z) (((y) == (z)) ? (x) : quov(mulv((x),(y)),(z)))
198 rb_fix_divmod_fix(n, d, q, r);
205 rb_raise(
rb_eTypeError,
"unexpected divmod result: into %"PRIsVALUE,
213# define INT64toNUM(x) LONG2NUM(x)
214#elif defined(HAVE_LONG_LONG) && SIZEOF_LONG_LONG == 8
215# define INT64toNUM(x) LL2NUM(x)
218#if defined(HAVE_UINT64_T) && SIZEOF_LONG*2 <= SIZEOF_UINT64_T
219 typedef uint64_t uwideint_t;
220 typedef int64_t wideint_t;
221 typedef uint64_t WIDEVALUE;
222 typedef int64_t SIGNED_WIDEVALUE;
223# define WIDEVALUE_IS_WIDER 1
224# define UWIDEINT_MAX UINT64_MAX
225# define WIDEINT_MAX INT64_MAX
226# define WIDEINT_MIN INT64_MIN
227# define FIXWINT_P(tv) ((tv) & 1)
228# define FIXWVtoINT64(tv) RSHIFT((SIGNED_WIDEVALUE)(tv), 1)
229# define INT64toFIXWV(wi) ((WIDEVALUE)((SIGNED_WIDEVALUE)(wi) << 1 | FIXNUM_FLAG))
230# define FIXWV_MAX (((int64_t)1 << 62) - 1)
231# define FIXWV_MIN (-((int64_t)1 << 62))
232# define FIXWVABLE(wi) (POSFIXWVABLE(wi) && NEGFIXWVABLE(wi))
233# define WINT2FIXWV(i) WIDEVAL_WRAP(INT64toFIXWV(i))
234# define FIXWV2WINT(w) FIXWVtoINT64(WIDEVAL_GET(w))
236 typedef unsigned long uwideint_t;
237 typedef long wideint_t;
238 typedef VALUE WIDEVALUE;
240# define WIDEVALUE_IS_WIDER 0
241# define UWIDEINT_MAX ULONG_MAX
242# define WIDEINT_MAX LONG_MAX
243# define WIDEINT_MIN LONG_MIN
244# define FIXWINT_P(v) FIXNUM_P(v)
245# define FIXWV_MAX FIXNUM_MAX
246# define FIXWV_MIN FIXNUM_MIN
247# define FIXWVABLE(i) FIXABLE(i)
248# define WINT2FIXWV(i) WIDEVAL_WRAP(LONG2FIX(i))
249# define FIXWV2WINT(w) FIX2LONG(WIDEVAL_GET(w))
252#define SIZEOF_WIDEINT SIZEOF_INT64_T
253#define POSFIXWVABLE(wi) ((wi) < FIXWV_MAX+1)
254#define NEGFIXWVABLE(wi) ((wi) >= FIXWV_MIN)
255#define FIXWV_P(w) FIXWINT_P(WIDEVAL_GET(w))
256#define MUL_OVERFLOW_FIXWV_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, FIXWV_MIN, FIXWV_MAX)
264 static inline wideval_t WIDEVAL_WRAP(WIDEVALUE v) { wideval_t w = { v };
return w; }
265# define WIDEVAL_GET(w) ((w).value)
267 typedef WIDEVALUE wideval_t;
268# define WIDEVAL_WRAP(v) (v)
269# define WIDEVAL_GET(w) (w)
272#if WIDEVALUE_IS_WIDER
273 static inline wideval_t
274 wint2wv(wideint_t wi)
277 return WINT2FIXWV(wi);
279 return WIDEVAL_WRAP(INT64toNUM(wi));
281# define WINT2WV(wi) wint2wv(wi)
283# define WINT2WV(wi) WIDEVAL_WRAP(LONG2NUM(wi))
289#if WIDEVALUE_IS_WIDER
291 return INT64toNUM(FIXWV2WINT(w));
292 return (
VALUE)WIDEVAL_GET(w);
294 return WIDEVAL_GET(w);
298#if WIDEVALUE_IS_WIDER
304 sign = rb_integer_pack(v, &u, 1,
sizeof(u), 0,
307 return WINT2FIXWV(0);
308 else if (sign == -1) {
310 return WINT2FIXWV(-(wideint_t)u);
312 else if (sign == +1) {
314 return WINT2FIXWV((wideint_t)u);
316 return WIDEVAL_WRAP(v);
320static inline wideval_t
324 if (RRATIONAL(v)->den !=
LONG2FIX(1))
325 return WIDEVAL_WRAP(v);
326 v = RRATIONAL(v)->num;
328#if WIDEVALUE_IS_WIDER
330 return WIDEVAL_WRAP((WIDEVALUE)(SIGNED_WIDEVALUE)(
long)v);
332 else if (RB_BIGNUM_TYPE_P(v) &&
333 rb_absint_size(v, NULL) <=
sizeof(WIDEVALUE)) {
334 return v2w_bignum(v);
337 return WIDEVAL_WRAP(v);
340#define NUM2WV(v) v2w(rb_Integer(v))
343weq(wideval_t wx, wideval_t wy)
345#if WIDEVALUE_IS_WIDER
346 if (FIXWV_P(wx) && FIXWV_P(wy)) {
347 return WIDEVAL_GET(wx) == WIDEVAL_GET(wy);
351 return eq(WIDEVAL_GET(wx), WIDEVAL_GET(wy));
356wcmp(wideval_t wx, wideval_t wy)
359#if WIDEVALUE_IS_WIDER
360 if (FIXWV_P(wx) && FIXWV_P(wy)) {
376#define wne(x,y) (!weq((x),(y)))
377#define wlt(x,y) (wcmp((x),(y)) < 0)
378#define wgt(x,y) (wcmp((x),(y)) > 0)
379#define wle(x,y) (wcmp((x),(y)) <= 0)
380#define wge(x,y) (wcmp((x),(y)) >= 0)
383wadd(wideval_t wx, wideval_t wy)
385#if WIDEVALUE_IS_WIDER
386 if (FIXWV_P(wx) && FIXWV_P(wy)) {
387 wideint_t r = FIXWV2WINT(wx) + FIXWV2WINT(wy);
391 return v2w(addv(w2v(wx), w2v(wy)));
395wsub(wideval_t wx, wideval_t wy)
397#if WIDEVALUE_IS_WIDER
398 if (FIXWV_P(wx) && FIXWV_P(wy)) {
399 wideint_t r = FIXWV2WINT(wx) - FIXWV2WINT(wy);
403 return v2w(subv(w2v(wx), w2v(wy)));
407wmul(wideval_t wx, wideval_t wy)
409#if WIDEVALUE_IS_WIDER
410 if (FIXWV_P(wx) && FIXWV_P(wy)) {
411 if (!MUL_OVERFLOW_FIXWV_P(FIXWV2WINT(wx), FIXWV2WINT(wy)))
412 return WINT2WV(FIXWV2WINT(wx) * FIXWV2WINT(wy));
415 return v2w(mulv(w2v(wx), w2v(wy)));
419wquo(wideval_t wx, wideval_t wy)
421#if WIDEVALUE_IS_WIDER
422 if (FIXWV_P(wx) && FIXWV_P(wy)) {
433 return v2w(quov(w2v(wx), w2v(wy)));
436#define wmulquo(x,y,z) ((WIDEVAL_GET(y) == WIDEVAL_GET(z)) ? (x) : wquo(wmul((x),(y)),(z)))
437#define wmulquoll(x,y,z) (((y) == (z)) ? (x) : wquo(wmul((x),WINT2WV(y)),WINT2WV(z)))
439#if WIDEVALUE_IS_WIDER
441wdivmod0(wideval_t wn, wideval_t wd, wideval_t *wq, wideval_t *wr)
443 if (FIXWV_P(wn) && FIXWV_P(wd)) {
444 wideint_t n, d, q, r;
453 wideint_t xneg = -FIXWV2WINT(wn);
466 if (d > 0 ? r < 0 : r > 0) {
479wdivmod(wideval_t wn, wideval_t wd, wideval_t *wq, wideval_t *wr)
482#if WIDEVALUE_IS_WIDER
483 if (wdivmod0(wn, wd, wq, wr))
return;
485 divmodv(w2v(wn), w2v(wd), &vq, &vr);
491wmuldivmod(wideval_t wx, wideval_t wy, wideval_t wz, wideval_t *wq, wideval_t *wr)
493 if (WIDEVAL_GET(wy) == WIDEVAL_GET(wz)) {
498 wdivmod(wmul(wx,wy), wz, wq, wr);
502wdiv(wideval_t wx, wideval_t wy)
504#if WIDEVALUE_IS_WIDER
506 if (wdivmod0(wx, wy, &q, &dmy))
return q;
508 return v2w(divv(w2v(wx), w2v(wy)));
512wmod(wideval_t wx, wideval_t wy)
514#if WIDEVALUE_IS_WIDER
516 if (wdivmod0(wx, wy, &dmy, &r))
return r;
518 return v2w(modv(w2v(wx), w2v(wy)));
522num_exact_check(
VALUE v)
533 tmp = rb_rational_canonicalize(v);
547 tmp = rb_rational_canonicalize(tmp);
563NORETURN(
static void num_exact_fail(
VALUE v));
565num_exact_fail(
VALUE v)
567 rb_raise(
rb_eTypeError,
"can't convert %"PRIsVALUE
" into an exact number",
574 VALUE num = num_exact_check(v);
575 if (
NIL_P(num)) num_exact_fail(v);
582static const int TIME_SCALE_NUMDIGITS =
rb_strlen_lit(STRINGIZE(TIME_SCALE)) - 1;
585rb_time_magnify(wideval_t w)
587 return wmul(w, WINT2FIXWV(TIME_SCALE));
591rb_time_unmagnify_to_rational(wideval_t w)
593 return quor(w2v(w),
INT2FIX(TIME_SCALE));
597rb_time_unmagnify(wideval_t w)
599 return v2w(rb_time_unmagnify_to_rational(w));
603rb_time_unmagnify_to_float(wideval_t w)
606#if WIDEVALUE_IS_WIDER
615 v =
DBL2NUM((
double)FIXWV2WINT(w));
616 return quov(v,
DBL2NUM(TIME_SCALE));
623 return quov(v,
DBL2NUM(TIME_SCALE));
627split_second(wideval_t timew, wideval_t *timew_p,
VALUE *subsecx_p)
630 wdivmod(timew, WINT2FIXWV(TIME_SCALE), &q, &r);
638#if WIDEVALUE_IS_WIDER
639 if (TIMET_MIN == 0) {
640 uwideint_t wi = (uwideint_t)t;
641 if (wi <= FIXWV_MAX) {
642 return WINT2FIXWV(wi);
646 wideint_t wi = (wideint_t)t;
647 if (FIXWV_MIN <= wi && wi <= FIXWV_MAX) {
648 return WINT2FIXWV(wi);
652 return v2w(TIMET2NUM(t));
654#define TIMET2WV(t) timet2wv(t)
659#if WIDEVALUE_IS_WIDER
661 wideint_t wi = FIXWV2WINT(w);
662 if (TIMET_MIN == 0) {
664 rb_raise(
rb_eRangeError,
"negative value to convert into 'time_t'");
665 if (TIMET_MAX < (uwideint_t)wi)
669 if (wi < TIMET_MIN || TIMET_MAX < wi)
675 return NUM2TIMET(w2v(w));
677#define WV2TIMET(t) wv2timet(t)
680static VALUE rb_cTimeTM;
682static int obj2int(
VALUE obj);
683static uint32_t obj2ubits(
VALUE obj,
unsigned int bits);
685static uint32_t month_arg(
VALUE arg);
686static VALUE validate_utc_offset(
VALUE utc_offset);
687static VALUE validate_zone_name(
VALUE zone_name);
688static void validate_vtm(
struct vtm *
vtm);
689static void vtm_add_day(
struct vtm *
vtm,
int day);
690static uint32_t obj2subsecx(
VALUE obj,
VALUE *subsecx);
697static time_t timegm_noleapsecond(
struct tm *tm);
698static int tmcmp(
struct tm *a,
struct tm *b);
699static int vtmcmp(
struct vtm *a,
struct vtm *b);
700static const char *find_time_t(
struct tm *tptr,
int utc_p, time_t *tp);
702static struct vtm *localtimew(wideval_t timew,
struct vtm *result);
704static int leap_year_p(
long y);
705#define leap_year_v_p(y) leap_year_p(NUM2LONG(modv((y), INT2FIX(400))))
709bool ruby_tz_uptodate_p;
712enum {tzkey_max = numberof(((DYNAMIC_TIME_ZONE_INFORMATION *)NULL)->TimeZoneKeyName)};
715 char name[tzkey_max * 4 + 1];
721 if (w32_tz.use_tzkey) {
722 if (w32_tz.name[0]) {
732 DYNAMIC_TIME_ZONE_INFORMATION tzi;
733 WCHAR *
const wtzkey = tzi.TimeZoneKeyName;
734 DWORD tzret = GetDynamicTimeZoneInformation(&tzi);
735 if (tzret != TIME_ZONE_ID_INVALID && *wtzkey) {
736 int wlen = (int)wcsnlen(wtzkey, tzkey_max);
737 int clen = WideCharToMultiByte(CP_UTF8, 0, wtzkey, wlen,
738 w32_tz.name,
sizeof(w32_tz.name) - 1,
740 w32_tz.name[clen] =
'\0';
745 return _tzname[_daylight && dst];
750ruby_reset_timezone(
const char *val)
752 ruby_tz_uptodate_p =
false;
754 w32_tz.use_tzkey = !val || !*val;
756 ruby_reset_leap_second_info();
762 if (ruby_tz_uptodate_p)
return;
763 ruby_tz_uptodate_p =
true;
768rb_localtime_r(
const time_t *t,
struct tm *result)
770#if defined __APPLE__ && defined __LP64__
771 if (*t != (time_t)(
int)*t)
return NULL;
775 result = localtime_r(t, result);
778 struct tm *tmp = localtime(t);
779 if (tmp) *result = *tmp;
782#if defined(HAVE_MKTIME) && defined(LOCALTIME_OVERFLOW_PROBLEM)
786 struct tm tmp = *result;
789# if defined(HAVE_STRUCT_TM_TM_GMTOFF)
790 gmtoff1 = result->tm_gmtoff;
791 gmtoff2 = tmp.tm_gmtoff;
793 if (*t + gmtoff1 != t2 + gmtoff2)
799#define LOCALTIME(tm, result) rb_localtime_r((tm), &(result))
801#ifndef HAVE_STRUCT_TM_TM_GMTOFF
803rb_gmtime_r(
const time_t *t,
struct tm *result)
806 result = gmtime_r(t, result);
808 struct tm *tmp = gmtime(t);
809 if (tmp) *result = *tmp;
811#if defined(HAVE_TIMEGM) && defined(LOCALTIME_OVERFLOW_PROBLEM)
812 if (result && *t != timegm(result)) {
818# define GMTIME(tm, result) rb_gmtime_r((tm), &(result))
821static const int16_t common_year_yday_offset[] = {
826 -1 + 31 + 28 + 31 + 30,
827 -1 + 31 + 28 + 31 + 30 + 31,
828 -1 + 31 + 28 + 31 + 30 + 31 + 30,
829 -1 + 31 + 28 + 31 + 30 + 31 + 30 + 31,
830 -1 + 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31,
831 -1 + 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30,
832 -1 + 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31,
833 -1 + 31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30
836static const int16_t leap_year_yday_offset[] = {
841 -1 + 31 + 29 + 31 + 30,
842 -1 + 31 + 29 + 31 + 30 + 31,
843 -1 + 31 + 29 + 31 + 30 + 31 + 30,
844 -1 + 31 + 29 + 31 + 30 + 31 + 30 + 31,
845 -1 + 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31,
846 -1 + 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30,
847 -1 + 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31,
848 -1 + 31 + 29 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30
852static const int8_t common_year_days_in_month[] = {
853 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
855static const int8_t leap_year_days_in_month[] = {
856 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
859#define days_in_month_of(leap) ((leap) ? leap_year_days_in_month : common_year_days_in_month)
860#define days_in_month_in(y) days_in_month_of(leap_year_p(y))
861#define days_in_month_in_v(y) days_in_month_of(leap_year_v_p(y))
864 (m),(m),(m),(m),(m),(m),(m),(m),(m),(m), \
865 (m),(m),(m),(m),(m),(m),(m),(m),(m),(m), \
866 (m),(m),(m),(m),(m),(m),(m),(m)
868 (m),(m),(m),(m),(m),(m),(m),(m),(m),(m), \
869 (m),(m),(m),(m),(m),(m),(m),(m),(m),(m), \
870 (m),(m),(m),(m),(m),(m),(m),(m),(m)
872 (m),(m),(m),(m),(m),(m),(m),(m),(m),(m), \
873 (m),(m),(m),(m),(m),(m),(m),(m),(m),(m), \
874 (m),(m),(m),(m),(m),(m),(m),(m),(m),(m)
876 (m),(m),(m),(m),(m),(m),(m),(m),(m),(m), \
877 (m),(m),(m),(m),(m),(m),(m),(m),(m),(m), \
878 (m),(m),(m),(m),(m),(m),(m),(m),(m),(m), (m)
880static const uint8_t common_year_mon_of_yday[] = {
881 M31(1), M28(2), M31(3), M30(4), M31(5), M30(6),
882 M31(7), M31(8), M30(9), M31(10), M30(11), M31(12)
884static const uint8_t leap_year_mon_of_yday[] = {
885 M31(1), M29(2), M31(3), M30(4), M31(5), M30(6),
886 M31(7), M31(8), M30(9), M31(10), M30(11), M31(12)
896 10,11,12,13,14,15,16,17,18,19, \
897 20,21,22,23,24,25,26,27,28
900 10,11,12,13,14,15,16,17,18,19, \
901 20,21,22,23,24,25,26,27,28,29
904 10,11,12,13,14,15,16,17,18,19, \
905 20,21,22,23,24,25,26,27,28,29,30
908 10,11,12,13,14,15,16,17,18,19, \
909 20,21,22,23,24,25,26,27,28,29,30,31
911static const uint8_t common_year_mday_of_yday[] = {
913 D31, D28, D31, D30, D31, D30, D31, D31, D30, D31, D30, D31
915static const uint8_t leap_year_mday_of_yday[] = {
916 D31, D29, D31, D30, D31, D30, D31, D31, D30, D31, D30, D31
925calc_tm_yday(
long tm_year,
int tm_mon,
int tm_mday)
927 int tm_year_mod400 = (int)MOD(tm_year, 400);
928 int tm_yday = tm_mday;
930 if (leap_year_p(tm_year_mod400 + 1900))
931 tm_yday += leap_year_yday_offset[tm_mon];
933 tm_yday += common_year_yday_offset[tm_mon];
939timegmw_noleapsecond(
struct vtm *
vtm)
951 divmodv(year1900,
INT2FIX(400), &q400, &r400);
954 yday = calc_tm_yday(year_mod400,
vtm->mon-1,
vtm->mday);
967 + DIV(year_mod400 - 69, 4)
968 - DIV(year_mod400 - 1, 100)
969 + (year_mod400 + 299) / 400;
971 vdays = addv(vdays, mulv(q400,
INT2FIX(97)));
972 vdays = addv(vdays, mulv(year1900,
INT2FIX(365)));
973 wret = wadd(rb_time_magnify(v2w(ret)), wmul(rb_time_magnify(v2w(vdays)), WINT2FIXWV(86400)));
974 wret = wadd(wret, v2w(
vtm->subsecx));
980zone_str(
const char *zone)
988 return rb_fstring_lit(
"(NO-TIMEZONE-ABBREVIATION)");
991 for (p = zone; *p; p++) {
1008 str = rb_enc_str_new(zone,
len, rb_locale_encoding());
1011 return rb_fstring(str);
1015gmtimew_noleapsecond(wideval_t timew,
struct vtm *
vtm)
1021 wideval_t timew2, w, w2;
1026 split_second(timew, &timew2, &subsecx);
1027 vtm->subsecx = subsecx;
1029 wdivmod(timew2, WINT2FIXWV(86400), &w2, &w);
1034 vtm->wday = (wday + 4) % 7;
1037 vtm->sec = n % 60; n = n / 60;
1038 vtm->min = n % 60; n = n / 60;
1042 divmodv(timev,
INT2FIX(400*365 + 97), &timev, &v);
1055 if (30*365+7+31+29-1 <= n) {
1069 x = n / (365*100 + 24);
1070 n = n % (365*100 + 24);
1072 if (30*365+7+31+29-1 <= n) {
1082 x = n / (365*4 + 1);
1083 n = n % (365*4 + 1);
1085 if (365*2+31+29-1 <= n) {
1086 if (n < 365*2+366) {
1103 if (leap_year_p(y)) {
1104 vtm->mon = leap_year_mon_of_yday[n];
1105 vtm->mday = leap_year_mday_of_yday[n];
1108 vtm->mon = common_year_mon_of_yday[n];
1109 vtm->mday = common_year_mday_of_yday[n];
1113 vtm->zone = str_utc;
1117gmtime_with_leapsecond(
const time_t *timep,
struct tm *result)
1119#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
1123 int gmtoff_sec, gmtoff_min, gmtoff_hour, gmtoff_day;
1125 t = LOCALTIME(timep, *result);
1130 if (t->tm_gmtoff < 0) {
1132 gmtoff = -t->tm_gmtoff;
1136 gmtoff = t->tm_gmtoff;
1138 gmtoff_sec = (int)(gmtoff % 60);
1139 gmtoff = gmtoff / 60;
1140 gmtoff_min = (int)(gmtoff % 60);
1141 gmtoff = gmtoff / 60;
1142 gmtoff_hour = (int)gmtoff;
1146 gmtoff_hour *= sign;
1153 result->tm_sec += gmtoff_sec;
1154 if (result->tm_sec < 0) {
1155 result->tm_sec += 60;
1158 if (60 <= result->tm_sec) {
1159 result->tm_sec -= 60;
1164 result->tm_min += gmtoff_min;
1165 if (result->tm_min < 0) {
1166 result->tm_min += 60;
1169 if (60 <= result->tm_min) {
1170 result->tm_min -= 60;
1175 result->tm_hour += gmtoff_hour;
1176 if (result->tm_hour < 0) {
1177 result->tm_hour += 24;
1180 if (24 <= result->tm_hour) {
1181 result->tm_hour -= 24;
1187 if (gmtoff_day < 0) {
1188 if (result->tm_yday == 0) {
1189 result->tm_mday = 31;
1190 result->tm_mon = 11;
1192 result->tm_yday = leap_year_p(result->tm_year + 1900) ? 365 : 364;
1194 else if (result->tm_mday == 1) {
1195 const int8_t *days_in_month = days_in_month_in(result->tm_year + 1900);
1197 result->tm_mday = days_in_month[result->tm_mon];
1204 result->tm_wday = (result->tm_wday + 6) % 7;
1207 int leap = leap_year_p(result->tm_year + 1900);
1208 if (result->tm_yday == (leap ? 365 : 364)) {
1211 result->tm_mday = 1;
1212 result->tm_yday = 0;
1214 else if (result->tm_mday == days_in_month_of(leap)[result->tm_mon]) {
1216 result->tm_mday = 1;
1223 result->tm_wday = (result->tm_wday + 1) % 7;
1226 result->tm_isdst = 0;
1227 result->tm_gmtoff = 0;
1228#if defined(HAVE_TM_ZONE)
1229 result->tm_zone = (
char *)
"UTC";
1233 return GMTIME(timep, *result);
1237static long this_year = 0;
1238static time_t known_leap_seconds_limit;
1239static int number_of_leap_seconds_known;
1242init_leap_second_info(
void)
1249 if (this_year == 0) {
1251 struct tm *tm, result;
1256 gmtime_r(&now, &result);
1260 tm = gmtime_with_leapsecond(&now, &result);
1262 this_year = tm->tm_year;
1264 if (TIMET_MAX - now < (time_t)(366*86400))
1265 known_leap_seconds_limit = TIMET_MAX;
1267 known_leap_seconds_limit = now + (time_t)(366*86400);
1269 if (!gmtime_with_leapsecond(&known_leap_seconds_limit, &result))
1273 vtm.mon = result.tm_mon + 1;
1274 vtm.mday = result.tm_mday;
1275 vtm.hour = result.tm_hour;
1276 vtm.min = result.tm_min;
1277 vtm.sec = result.tm_sec;
1281 timew = timegmw_noleapsecond(&
vtm);
1283 number_of_leap_seconds_known =
NUM2INT(w2v(wsub(TIMET2WV(known_leap_seconds_limit), rb_time_unmagnify(timew))));
1289ruby_reset_leap_second_info(
void)
1305 return timegmw_noleapsecond(
vtm);
1307 init_leap_second_info();
1309 timew = timegmw_noleapsecond(
vtm);
1312 if (number_of_leap_seconds_known == 0) {
1318 else if (wlt(rb_time_magnify(TIMET2WV(known_leap_seconds_limit)), timew)) {
1319 return wadd(timew, rb_time_magnify(WINT2WV(number_of_leap_seconds_known)));
1323 tm.tm_mon =
vtm->mon - 1;
1324 tm.tm_mday =
vtm->mday;
1325 tm.tm_hour =
vtm->hour;
1326 tm.tm_min =
vtm->min;
1327 tm.tm_sec =
vtm->sec;
1330 errmsg = find_time_t(&tm, 1, &t);
1332 rb_raise(rb_eArgError,
"%s", errmsg);
1333 return wadd(rb_time_magnify(TIMET2WV(t)), v2w(
vtm->subsecx));
1337gmtimew(wideval_t timew,
struct vtm *result)
1344 if (wlt(timew, WINT2FIXWV(0))) {
1345 gmtimew_noleapsecond(timew, result);
1349 init_leap_second_info();
1351 if (number_of_leap_seconds_known == 0) {
1355 gmtimew_noleapsecond(timew, result);
1358 else if (wlt(rb_time_magnify(TIMET2WV(known_leap_seconds_limit)), timew)) {
1359 timew = wsub(timew, rb_time_magnify(WINT2WV(number_of_leap_seconds_known)));
1360 gmtimew_noleapsecond(timew, result);
1364 split_second(timew, &timew2, &subsecx);
1366 t = WV2TIMET(timew2);
1367 if (!gmtime_with_leapsecond(&t, &tm))
1370 result->year =
LONG2NUM((
long)tm.tm_year + 1900);
1371 result->mon = tm.tm_mon + 1;
1372 result->mday = tm.tm_mday;
1373 result->hour = tm.tm_hour;
1374 result->min = tm.tm_min;
1375 result->sec = tm.tm_sec;
1376 result->subsecx = subsecx;
1377 result->utc_offset =
INT2FIX(0);
1378 result->wday = tm.tm_wday;
1379 result->yday = tm.tm_yday+1;
1380 result->isdst = tm.tm_isdst;
1385#define GMTIMEW(w, v) \
1386 (gmtimew(w, v) ? (void)0 : rb_raise(rb_eArgError, "gmtime error"))
1388static struct tm *localtime_with_gmtoff_zone(
const time_t *t,
struct tm *result,
long *gmtoff,
VALUE *zone);
1423static const int compat_common_month_table[12][7] = {
1425 { 2034, 2035, 2036, 2031, 2032, 2027, 2033 },
1426 { 2026, 2027, 2033, 2034, 2035, 2030, 2031 },
1427 { 2026, 2032, 2033, 2034, 2035, 2030, 2036 },
1428 { 2035, 2030, 2036, 2026, 2032, 2033, 2034 },
1429 { 2033, 2034, 2035, 2030, 2036, 2026, 2032 },
1430 { 2036, 2026, 2032, 2033, 2034, 2035, 2030 },
1431 { 2035, 2030, 2036, 2026, 2032, 2033, 2034 },
1432 { 2032, 2033, 2034, 2035, 2030, 2036, 2026 },
1433 { 2030, 2036, 2026, 2032, 2033, 2034, 2035 },
1434 { 2034, 2035, 2030, 2036, 2026, 2032, 2033 },
1435 { 2026, 2032, 2033, 2034, 2035, 2030, 2036 },
1436 { 2030, 2036, 2026, 2032, 2033, 2034, 2035 },
1464static const int compat_leap_month_table[7] = {
1466 2032, 2016, 2028, 2012, 2024, 2036, 2020,
1470calc_wday(
int year_mod400,
int month,
int day)
1475 a = (14 - month) / 12;
1476 y = year_mod400 + 4800 - a;
1477 m = month + 12 * a - 3;
1478 wday = day + (153*m+2)/5 + 365*y + y/4 - y/100 + y/400 + 2;
1484guess_local_offset(
struct vtm *vtm_utc,
int *isdst_ret,
VALUE *zone_ret)
1492 int year_mod400, wday;
1496 if (lt(vtm_utc->year,
INT2FIX(1916))) {
1501# if defined(NEGATIVE_TIME_T)
1502# if SIZEOF_TIME_T <= 4
1504# define THE_TIME_OLD_ENOUGH ((time_t)0x80000000)
1508# define THE_TIME_OLD_ENOUGH ((time_t)(1600-1970)*366*24*60*60)
1510 if (localtime_with_gmtoff_zone((t = THE_TIME_OLD_ENOUGH, &t), &tm, &gmtoff, &zone)) {
1512 isdst = tm.tm_isdst;
1517 if (localtime_with_gmtoff_zone((t = 0, &t), &tm, &gmtoff, &zone)) {
1519 isdst = tm.tm_isdst;
1535 wday = calc_wday(year_mod400, vtm_utc->mon, 1);
1536 if (vtm_utc->mon == 2 && leap_year_p(year_mod400))
1537 vtm2.year =
INT2FIX(compat_leap_month_table[wday]);
1539 vtm2.year =
INT2FIX(compat_common_month_table[vtm_utc->mon-1][wday]);
1541 timev = w2v(rb_time_unmagnify(timegmw(&vtm2)));
1542 t = NUM2TIMET(timev);
1544 if (localtime_with_gmtoff_zone(&t, &tm, &gmtoff, &zone)) {
1546 *isdst_ret = tm.tm_isdst;
1554 static time_t now = 0;
1555 static long now_gmtoff = 0;
1556 static int now_isdst = 0;
1557 static VALUE now_zone;
1561 localtime_with_gmtoff_zone(&now, &tm, &now_gmtoff, &zone);
1562 now_isdst = tm.tm_isdst;
1563 zone = rb_fstring(zone);
1564 rb_vm_register_global_object(zone);
1568 *isdst_ret = now_isdst;
1570 *zone_ret = now_zone;
1576small_vtm_sub(
struct vtm *vtm1,
struct vtm *vtm2)
1580 off = vtm1->sec - vtm2->sec;
1581 off += (vtm1->min - vtm2->min) * 60;
1582 off += (vtm1->hour - vtm2->hour) * 3600;
1583 if (ne(vtm1->year, vtm2->year))
1584 off += lt(vtm1->year, vtm2->year) ? -24*3600 : 24*3600;
1585 else if (vtm1->mon != vtm2->mon)
1586 off += vtm1->mon < vtm2->mon ? -24*3600 : 24*3600;
1587 else if (vtm1->mday != vtm2->mday)
1588 off += vtm1->mday < vtm2->mday ? -24*3600 : 24*3600;
1594timelocalw(
struct vtm *
vtm)
1599 wideval_t timew1, timew2;
1600 struct vtm vtm1, vtm2;
1605 if (l < INT_MIN || INT_MAX < l)
1607 tm.tm_year = (int)l;
1616 tm.tm_mon =
vtm->mon-1;
1617 tm.tm_mday =
vtm->mday;
1618 tm.tm_hour =
vtm->hour;
1619 tm.tm_min =
vtm->min;
1620 tm.tm_sec =
vtm->sec;
1621 tm.tm_isdst =
vtm->isdst == VTM_ISDST_INITVAL ? -1 :
vtm->isdst;
1623 if (find_time_t(&tm, 0, &t))
1625 return wadd(rb_time_magnify(TIMET2WV(t)), v2w(
vtm->subsecx));
1628 timew1 = timegmw(
vtm);
1630 if (!localtimew(timew1, &vtm1))
1631 rb_raise(rb_eArgError,
"localtimew error");
1633 n = vtmcmp(
vtm, &vtm1);
1635 timew1 = wsub(timew1, rb_time_magnify(WINT2FIXWV(12*3600)));
1636 if (!localtimew(timew1, &vtm1))
1637 rb_raise(rb_eArgError,
"localtimew error");
1644 timew1 = wsub(timew1, rb_time_magnify(WINT2FIXWV(24*3600)));
1645 if (!localtimew(timew1, &vtm1))
1646 rb_raise(rb_eArgError,
"localtimew error");
1649 timew2 = wadd(timew1, rb_time_magnify(WINT2FIXWV(24*3600)));
1650 if (!localtimew(timew2, &vtm2))
1651 rb_raise(rb_eArgError,
"localtimew error");
1653 timew1 = wadd(timew1, rb_time_magnify(v2w(small_vtm_sub(
vtm, &vtm1))));
1654 timew2 = wadd(timew2, rb_time_magnify(v2w(small_vtm_sub(
vtm, &vtm2))));
1656 if (weq(timew1, timew2))
1659 if (!localtimew(timew1, &vtm1))
1660 rb_raise(rb_eArgError,
"localtimew error");
1661 if (
vtm->hour != vtm1.hour ||
vtm->min != vtm1.min ||
vtm->sec != vtm1.sec)
1664 if (!localtimew(timew2, &vtm2))
1665 rb_raise(rb_eArgError,
"localtimew error");
1666 if (
vtm->hour != vtm2.hour ||
vtm->min != vtm2.min ||
vtm->sec != vtm2.sec)
1670 return lt(vtm1.utc_offset, vtm2.utc_offset) ? timew2 : timew1;
1672 return lt(vtm1.utc_offset, vtm2.utc_offset) ? timew1 : timew2;
1676localtime_with_gmtoff_zone(
const time_t *t,
struct tm *result,
long *gmtoff,
VALUE *zone)
1680 if (LOCALTIME(t, tm)) {
1681#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
1682 *gmtoff = tm.tm_gmtoff;
1688 u = GMTIME(t, tmbuf);
1691 if (l->tm_year != u->tm_year)
1692 off = l->tm_year < u->tm_year ? -1 : 1;
1693 else if (l->tm_mon != u->tm_mon)
1694 off = l->tm_mon < u->tm_mon ? -1 : 1;
1695 else if (l->tm_mday != u->tm_mday)
1696 off = l->tm_mday < u->tm_mday ? -1 : 1;
1699 off =
off * 24 + l->tm_hour - u->tm_hour;
1700 off =
off * 60 + l->tm_min - u->tm_min;
1701 off =
off * 60 + l->tm_sec - u->tm_sec;
1706#if defined(HAVE_TM_ZONE)
1707 *zone = zone_str(tm.tm_zone);
1708#elif defined(_WIN32)
1709 *zone = zone_str(get_tzname(tm.tm_isdst));
1710#elif defined(HAVE_TZNAME) && defined(HAVE_DAYLIGHT)
1712 *zone = zone_str(tzname[daylight && tm.tm_isdst]);
1716 strftime(buf,
sizeof(buf),
"%Z", &tm);
1717 *zone = zone_str(buf);
1729timew_out_of_timet_range(wideval_t timew)
1732#if WIDEVALUE_IS_WIDER && SIZEOF_TIME_T < SIZEOF_INT64_T
1733 if (FIXWV_P(timew)) {
1734 wideint_t t = FIXWV2WINT(timew);
1735 if (t < TIME_SCALE * (wideint_t)TIMET_MIN ||
1736 TIME_SCALE * (1 + (wideint_t)TIMET_MAX) <= t)
1741#if SIZEOF_TIME_T == SIZEOF_INT64_T
1742 if (FIXWV_P(timew)) {
1743 wideint_t t = FIXWV2WINT(timew);
1744 if (~(time_t)0 <= 0) {
1754 timexv = w2v(timew);
1755 if (lt(timexv, mulv(
INT2FIX(TIME_SCALE), TIMET2NUM(TIMET_MIN))) ||
1756 le(mulv(
INT2FIX(TIME_SCALE), addv(TIMET2NUM(TIMET_MAX),
INT2FIX(1))), timexv))
1762localtimew(wideval_t timew,
struct vtm *result)
1764 VALUE subsecx, offset;
1768 if (!timew_out_of_timet_range(timew)) {
1774 split_second(timew, &timew2, &subsecx);
1776 t = WV2TIMET(timew2);
1778 if (localtime_with_gmtoff_zone(&t, &tm, &gmtoff, &zone)) {
1779 result->year =
LONG2NUM((
long)tm.tm_year + 1900);
1780 result->mon = tm.tm_mon + 1;
1781 result->mday = tm.tm_mday;
1782 result->hour = tm.tm_hour;
1783 result->min = tm.tm_min;
1784 result->sec = tm.tm_sec;
1785 result->subsecx = subsecx;
1786 result->wday = tm.tm_wday;
1787 result->yday = tm.tm_yday+1;
1788 result->isdst = tm.tm_isdst;
1789 result->utc_offset =
LONG2NUM(gmtoff);
1790 result->zone = zone;
1795 if (!gmtimew(timew, result))
1798 offset = guess_local_offset(result, &isdst, &zone);
1800 if (!gmtimew(wadd(timew, rb_time_magnify(v2w(offset))), result))
1803 result->utc_offset = offset;
1804 result->isdst = isdst;
1805 result->zone = zone;
1810#define TIME_TZMODE_LOCALTIME 0
1811#define TIME_TZMODE_UTC 1
1812#define TIME_TZMODE_FIXOFF 2
1813#define TIME_TZMODE_UNINITIALIZED 3
1820#define GetTimeval(obj, tobj) ((tobj) = get_timeval(obj))
1821#define GetNewTimeval(obj, tobj) ((tobj) = get_new_timeval(obj))
1823#define IsTimeval(obj) rb_typeddata_is_kind_of((obj), &time_data_type)
1824#define TIME_INIT_P(tobj) ((tobj)->vtm.tzmode != TIME_TZMODE_UNINITIALIZED)
1826#define TZMODE_UTC_P(tobj) ((tobj)->vtm.tzmode == TIME_TZMODE_UTC)
1827#define TZMODE_SET_UTC(tobj) ((tobj)->vtm.tzmode = TIME_TZMODE_UTC)
1829#define TZMODE_LOCALTIME_P(tobj) ((tobj)->vtm.tzmode == TIME_TZMODE_LOCALTIME)
1830#define TZMODE_SET_LOCALTIME(tobj) ((tobj)->vtm.tzmode = TIME_TZMODE_LOCALTIME)
1832#define TZMODE_FIXOFF_P(tobj) ((tobj)->vtm.tzmode == TIME_TZMODE_FIXOFF)
1833#define TZMODE_SET_FIXOFF(time, tobj, off) do { \
1834 (tobj)->vtm.tzmode = TIME_TZMODE_FIXOFF; \
1835 RB_OBJ_WRITE_UNALIGNED(time, &(tobj)->vtm.utc_offset, off); \
1838#define TZMODE_COPY(tobj1, tobj2) \
1839 ((tobj1)->vtm.tzmode = (tobj2)->vtm.tzmode, \
1840 (tobj1)->vtm.utc_offset = (tobj2)->vtm.utc_offset, \
1841 (tobj1)->vtm.zone = (tobj2)->vtm.zone)
1843static int zone_localtime(
VALUE zone,
VALUE time);
1845#define MAKE_TM(time, tobj) \
1847 if ((tobj)->vtm.tm_got == 0) { \
1848 time_get_tm((time), (tobj)); \
1851#define MAKE_TM_ENSURE(time, tobj, cond) \
1853 MAKE_TM(time, tobj); \
1855 force_make_tm(time, tobj); \
1862 tobj->timew = timew;
1863 if (!FIXWV_P(timew)) {
1882 VALUE zone = tobj->vtm.zone;
1883 if (!
NIL_P(zone) && zone != str_empty && zone != str_utc) {
1884 if (zone_localtime(zone, time))
return;
1886 tobj->vtm.tm_got = 0;
1887 time_get_tm(time, tobj);
1894 if (!FIXWV_P(tobj->timew)) {
1895 rb_gc_mark_movable(w2v(tobj->timew));
1897 rb_gc_mark_movable(tobj->vtm.year);
1898 rb_gc_mark_movable(tobj->vtm.subsecx);
1899 rb_gc_mark_movable(tobj->vtm.utc_offset);
1900 rb_gc_mark_movable(tobj->vtm.zone);
1904time_compact(
void *ptr)
1907 if (!FIXWV_P(tobj->timew)) {
1908 WIDEVAL_GET(tobj->timew) = WIDEVAL_WRAP(rb_gc_location(w2v(tobj->timew)));
1911 tobj->vtm.year = rb_gc_location(tobj->vtm.year);
1912 tobj->vtm.subsecx = rb_gc_location(tobj->vtm.subsecx);
1913 tobj->vtm.utc_offset = rb_gc_location(tobj->vtm.utc_offset);
1914 tobj->vtm.zone = rb_gc_location(tobj->vtm.zone);
1923 .dcompact = time_compact,
1925 .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_FROZEN_SHAREABLE | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_EMBEDDABLE,
1929time_s_alloc(
VALUE klass)
1935 tobj->vtm.tzmode = TIME_TZMODE_UNINITIALIZED;
1936 tobj->vtm.tm_got = 0;
1937 time_set_timew(obj, tobj, WINT2FIXWV(0));
1938 tobj->vtm.zone =
Qnil;
1944get_timeval(
VALUE obj)
1948 if (!TIME_INIT_P(tobj)) {
1955get_new_timeval(
VALUE obj)
1959 if (TIME_INIT_P(tobj)) {
1966time_modify(
VALUE time)
1968 rb_check_frozen(time);
1972timenano2timew(wideint_t sec,
long nsec)
1976 timew = rb_time_magnify(WINT2WV(sec));
1978 timew = wadd(timew, wmulquoll(WINT2WV(nsec), TIME_SCALE, 1000000000));
1983timew2timespec(wideval_t timew)
1989 if (timew_out_of_timet_range(timew))
1990 rb_raise(rb_eArgError,
"time out of system range");
1991 split_second(timew, &timew2, &subsecx);
1992 ts.tv_sec = WV2TIMET(timew2);
1998timew2timespec_exact(wideval_t timew,
struct timespec *ts)
2004 if (timew_out_of_timet_range(timew))
2006 split_second(timew, &timew2, &subsecx);
2007 ts->tv_sec = WV2TIMET(timew2);
2008 nsecv = mulquov(subsecx,
INT2FIX(1000000000),
INT2FIX(TIME_SCALE));
2018#ifdef HAVE_CLOCK_GETTIME
2019 if (clock_gettime(CLOCK_REALTIME, ts) == -1) {
2020 rb_sys_fail(
"clock_gettime");
2025 if (gettimeofday(&tv, 0) < 0) {
2026 rb_sys_fail(
"gettimeofday");
2028 ts->tv_sec = tv.tv_sec;
2029 ts->tv_nsec = tv.tv_usec * 1000;
2045 GetNewTimeval(time, tobj);
2046 TZMODE_SET_LOCALTIME(tobj);
2049 time_set_timew(time, tobj, timenano2timew(ts.tv_sec, ts.tv_nsec));
2052 time_zonelocal(time, zone);
2060 VALUE t = time_s_alloc(klass);
2061 return time_init_now(ec, t, zone);
2071 GetTimeval(time, tobj);
2073 tobj->vtm.tm_got = 0;
2074 tobj->vtm.zone =
Qnil;
2075 TZMODE_SET_FIXOFF(time, tobj,
off);
2100 subsec = neg(subsec);
2109 vtm->subsecx = addv(
vtm->subsecx, w2v(rb_time_magnify(v2w(subsec))));
2158 vtm_add_day(
vtm, day);
2162vtm_add_day(
struct vtm *
vtm,
int day)
2166 if (
vtm->mon == 1 &&
vtm->mday == 1) {
2171 vtm->yday = leap_year_v_p(
vtm->year) ? 366 : 365;
2173 else if (
vtm->mday == 1) {
2174 const int8_t *days_in_month = days_in_month_in_v(
vtm->year);
2176 vtm->mday = days_in_month[
vtm->mon-1];
2177 if (
vtm->yday != 0)
vtm->yday--;
2181 if (
vtm->yday != 0)
vtm->yday--;
2183 if (
vtm->wday != VTM_WDAY_INITVAL)
vtm->wday = (
vtm->wday + 6) % 7;
2186 int leap = leap_year_v_p(
vtm->year);
2187 if (
vtm->mon == 12 &&
vtm->mday == 31) {
2193 else if (
vtm->mday == days_in_month_of(leap)[
vtm->mon-1]) {
2196 if (
vtm->yday != 0)
vtm->yday++;
2200 if (
vtm->yday != 0)
vtm->yday++;
2202 if (
vtm->wday != VTM_WDAY_INITVAL)
vtm->wday = (
vtm->wday + 1) % 7;
2208maybe_tzobj_p(
VALUE obj)
2210 if (
NIL_P(obj))
return FALSE;
2216NORETURN(
static void invalid_utc_offset(
VALUE));
2218invalid_utc_offset(
VALUE zone)
2220 rb_raise(rb_eArgError,
"\"+HH:MM\", \"-HH:MM\", \"UTC\" or "
2221 "\"A\"..\"I\",\"K\"..\"Z\" expected for utc_offset: %"PRIsVALUE,
2225#define have_2digits(ptr) (ISDIGIT((ptr)[0]) && ISDIGIT((ptr)[1]))
2226#define num_from_2digits(ptr) ((ptr)[0] * 10 + (ptr)[1] - '0' * 11)
2229utc_offset_arg(
VALUE arg)
2234 const char *s = RSTRING_PTR(tmp), *min = NULL, *sec = NULL;
2236 goto invalid_utc_offset;
2238 switch (RSTRING_LEN(tmp)) {
2244 if (s[0] >=
'A' && s[0] <=
'I') {
2245 n = (int)s[0] -
'A' + 1;
2248 else if (s[0] >=
'K' && s[0] <=
'M') {
2249 n = (int)s[0] -
'A';
2251 else if (s[0] >=
'N' && s[0] <=
'Y') {
2252 n =
'M' - (int)s[0];
2255 goto invalid_utc_offset;
2271 if (s[6] !=
':')
goto invalid_utc_offset;
2275 if (s[3] !=
':')
goto invalid_utc_offset;
2279 goto invalid_utc_offset;
2282 if (!have_2digits(sec))
goto invalid_utc_offset;
2283 if (sec[0] >
'5')
goto invalid_utc_offset;
2284 n += num_from_2digits(sec);
2288 if (!have_2digits(min))
goto invalid_utc_offset;
2289 if (min[0] >
'5')
goto invalid_utc_offset;
2290 n += num_from_2digits(min) * 60;
2292 if (s[0] !=
'+' && s[0] !=
'-')
goto invalid_utc_offset;
2293 if (!have_2digits(s+1))
goto invalid_utc_offset;
2294 n += num_from_2digits(s+1) * 3600;
2296 if (n == 0)
return UTC_ZONE;
2302 return num_exact(arg);
2310 wideval_t tlocal, wideval_t tutc,
VALUE time)
2313 wideval_t w = wsub(tlocal, tutc);
2315 validate_utc_offset(
off);
2318 TZMODE_SET_LOCALTIME(tobj);
2322extract_time(
VALUE time)
2325 const ID id_to_i = idTo_i;
2327#define EXTRACT_TIME() do { \
2328 t = NUM2WV(AREF(to_i)); \
2332 struct time_object *tobj = RTYPEDDATA_GET_DATA(time);
2335 t = rb_time_unmagnify(tobj->timew);
2340#define AREF(x) rb_struct_aref(time, ID2SYM(id_##x))
2345#define AREF(x) rb_funcallv(time, id_##x, 0, 0)
2358 const ID id_to_i = idTo_i;
2359 struct vtm *
vtm = &orig_tobj->vtm;
2361#define EXTRACT_VTM() do { \
2363 vtm->year = obj2vint(AREF(year)); \
2364 vtm->mon = month_arg(AREF(mon)); \
2365 vtm->mday = obj2ubits(AREF(mday), 5); \
2366 vtm->hour = obj2ubits(AREF(hour), 5); \
2367 vtm->min = obj2ubits(AREF(min), 6); \
2368 vtm->sec = obj2subsecx(AREF(sec), &subsecx); \
2369 vtm->isdst = RTEST(AREF(isdst)); \
2370 vtm->utc_offset = Qnil; \
2371 t = NUM2WV(AREF(to_i)); \
2375 struct time_object *tobj = RTYPEDDATA_GET_DATA(time);
2377 time_get_tm(time, tobj);
2378 time_set_vtm(orig_time, orig_tobj, tobj->vtm);
2379 t = rb_time_unmagnify(tobj->timew);
2380 if (TZMODE_FIXOFF_P(tobj) &&
vtm->utc_offset !=
INT2FIX(0))
2381 t = wadd(t, v2w(
vtm->utc_offset));
2386#define AREF(x) rb_struct_aref(time, ID2SYM(id_##x))
2392 struct vtm temp_vtm = *
vtm;
2393 GMTIMEW(rb_time_magnify(t), &temp_vtm);
2394 time_set_vtm(orig_time, orig_tobj, temp_vtm);
2397#define AREF(x) rb_funcallv(time, id_##x, 0, 0)
2403 RB_OBJ_WRITE_UNALIGNED(orig_time, &
vtm->subsecx, subsecx);
2416 tobj->vtm.isdst = (!UNDEF_P(dst) &&
RTEST(dst));
2423 struct time_object *tobj = RTYPEDDATA_GET_DATA(time);
2426 wdivmod(tobj->timew, WINT2FIXWV(TIME_SCALE), &t, &s);
2427 tm = tm_from_time(rb_cTimeTM, time);
2429 if (UNDEF_P(utc))
return 0;
2431 s = extract_time(utc);
2432 zone_set_offset(zone, tobj, t, s, time);
2433 s = rb_time_magnify(s);
2434 if (tobj->vtm.subsecx !=
INT2FIX(0)) {
2435 s = wadd(s, v2w(tobj->vtm.subsecx));
2437 time_set_timew(time, tobj, s);
2439 zone_set_dst(zone, tobj, tm);
2449 VALUE local, tm, subsecx;
2450 struct time_object *tobj = RTYPEDDATA_GET_DATA(time);
2453 split_second(tobj->timew, &t, &subsecx);
2454 tm = tm_from_time(rb_cTimeTM, time);
2457 if (UNDEF_P(local))
return 0;
2459 s = extract_vtm(local, time, tobj, subsecx);
2460 tobj->vtm.tm_got = 1;
2461 zone_set_offset(zone, tobj, s, t, time);
2462 zone_set_dst(zone, tobj, tm);
2474 return rb_check_funcall_default(klass, id_find_timezone, 1, &zone,
Qnil);
2480vtm_day_wraparound(
struct vtm *
vtm)
2482 if (
vtm->hour < 24)
return;
2487 vtm_add_day(
vtm, 1);
2502 vtm.wday = VTM_WDAY_INITVAL;
2504 vtm.zone = str_empty;
2506 vtm.year = obj2vint(year);
2508 vtm.mon =
NIL_P(mon) ? 1 : month_arg(mon);
2510 vtm.mday =
NIL_P(mday) ? 1 : obj2ubits(mday, 5);
2512 vtm.hour =
NIL_P(hour) ? 0 : obj2ubits(hour, 5);
2514 vtm.min =
NIL_P(min) ? 0 : obj2ubits(min, 6);
2522 vtm.sec = obj2subsecx(sec, &subsecx);
2523 vtm.subsecx = subsecx;
2526 return time_init_vtm(time,
vtm, zone);
2535 vtm.isdst = VTM_ISDST_INITVAL;
2537 const VALUE arg = zone;
2540 if (arg ==
ID2SYM(rb_intern(
"dst")))
2542 else if (arg ==
ID2SYM(rb_intern(
"std")))
2544 else if (maybe_tzobj_p(arg))
2546 else if (!
NIL_P(utc = utc_offset_arg(arg)))
2547 vtm.utc_offset = utc == UTC_ZONE ?
INT2FIX(0) : utc;
2548 else if (
NIL_P(zone = find_timezone(time, arg)))
2549 invalid_utc_offset(arg);
2555 GetNewTimeval(time, tobj);
2558 time_set_timew(time, tobj, timegmw(&
vtm));
2559 vtm_day_wraparound(&
vtm);
2560 time_set_vtm(time, tobj,
vtm);
2561 tobj->vtm.tm_got = 1;
2562 TZMODE_SET_LOCALTIME(tobj);
2563 if (zone_timelocal(zone, time)) {
2566 else if (
NIL_P(
vtm.utc_offset = utc_offset_arg(zone))) {
2567 if (
NIL_P(zone = find_timezone(time, zone)) || !zone_timelocal(zone, time))
2568 invalid_utc_offset(arg);
2572 if (utc == UTC_ZONE) {
2573 time_set_timew(time, tobj, timegmw(&
vtm));
2575 vtm_day_wraparound(&
vtm);
2576 time_set_vtm(time, tobj,
vtm);
2577 tobj->vtm.tm_got = 1;
2578 TZMODE_SET_UTC(tobj);
2582 TZMODE_SET_LOCALTIME(tobj);
2587 vtm_add_offset(&
vtm,
off, -1);
2589 time_set_timew(time, tobj, timegmw(&
vtm));
2591 return time_set_utc_offset(time,
off);
2594 time_set_timew(time, tobj, timelocalw(&
vtm));
2596 return time_localtime(time);
2601two_digits(
const char *ptr,
const char *end,
const char **endp,
const char *name)
2603 ssize_t
len = end - ptr;
2604 if (
len < 2 || !have_2digits(ptr) || ((
len > 2) &&
ISDIGIT(ptr[2]))) {
2605 VALUE mesg = rb_sprintf(
"two digits %s is expected", name);
2606 if (ptr[-1] ==
'-' || ptr[-1] ==
':') {
2607 rb_str_catf(mesg,
" after '%c'", ptr[-1]);
2609 rb_str_catf(mesg,
": %.*s", ((
len > 10) ? 10 : (int)(end - ptr)) + 1, ptr - 1);
2613 return num_from_2digits(ptr);
2617parse_int(
const char *ptr,
const char *end,
const char **endp,
size_t *ndigits,
bool sign)
2619 ssize_t
len = (end - ptr);
2620 int flags = sign ? RB_INT_PARSE_SIGN : 0;
2621 return rb_int_parse_cstr(ptr,
len, (
char **)endp, ndigits, 10, flags);
2633 rb_raise(rb_eArgError,
"time string should have ASCII compatible encoding");
2636 const char *
const begin = RSTRING_PTR(str);
2638 const char *ptr = begin;
2640 int mon = -1, mday = -1, hour = -1, min = -1, sec = -1;
2642 size_t prec =
NIL_P(precision) ? SIZE_MAX :
NUM2SIZET(precision);
2645 rb_raise(rb_eArgError,
"can't parse: %+"PRIsVALUE, str);
2647 year = parse_int(ptr, end, &ptr, &ndigits,
true);
2649 rb_raise(rb_eArgError,
"can't parse: %+"PRIsVALUE, str);
2651 else if (ndigits < 4) {
2652 rb_raise(rb_eArgError,
"year must be 4 or more digits: %.*s", (
int)ndigits, ptr - ndigits);
2654 else if (ptr == end) {
2658#define peekable_p(n) ((ptrdiff_t)(n) < (end - ptr))
2659#define peek_n(c, n) (peekable_p(n) && ((unsigned char)ptr[n] == (c)))
2660#define peek(c) peek_n(c, 0)
2661#define peekc_n(n) (peekable_p(n) ? (int)(unsigned char)ptr[n] : -1)
2662#define peekc() peekc_n(0)
2663#define expect_two_digits(x, bits) \
2664 (((unsigned int)(x = two_digits(ptr + 1, end, &ptr, #x)) > (1U << bits) - 1) ? \
2665 rb_raise(rb_eArgError, #x" out of range") : (void)0)
2666 if (!peek(
'-'))
break;
2667 expect_two_digits(mon, 4);
2668 if (!peek(
'-'))
break;
2669 expect_two_digits(mday, 5);
2670 if (!peek(
' ') && !peek(
'T'))
break;
2671 const char *
const time_part = ptr + 1;
2672 if (!
ISDIGIT(peekc_n(1)))
break;
2673#define nofraction(x) \
2675 rb_raise(rb_eArgError, "fraction " #x " is not supported: %.*s", \
2676 (int)(ptr + 1 - time_part), time_part); \
2678#define need_colon(x) \
2680 rb_raise(rb_eArgError, "missing " #x " part: %.*s", \
2681 (int)(ptr + 1 - time_part), time_part); \
2683 expect_two_digits(hour, 5);
2686 expect_two_digits(min, 6);
2689 expect_two_digits(sec, 6);
2692 for (ndigits = 0; ndigits < prec &&
ISDIGIT(peekc_n(ndigits)); ++ndigits);
2694 int clen = rb_enc_precise_mbclen(ptr, end, rb_enc_get(str));
2695 if (clen < 0) clen = 0;
2696 rb_raise(rb_eArgError,
"subsecond expected after dot: %.*s",
2697 (
int)(ptr - time_part) + clen, time_part);
2699 subsec = parse_int(ptr, ptr + ndigits, &ptr, &ndigits,
false);
2700 if (
NIL_P(subsec))
break;
2701 while (ptr < end &&
ISDIGIT(*ptr)) ptr++;
2704 while (ptr < end &&
ISSPACE(*ptr)) ptr++;
2705 const char *
const zstr = ptr;
2706 while (ptr < end && !
ISSPACE(*ptr)) ptr++;
2707 const char *
const zend = ptr;
2708 while (ptr < end &&
ISSPACE(*ptr)) ptr++;
2717 else if (hour == -1) {
2718 rb_raise(rb_eArgError,
"no time information");
2720 if (!
NIL_P(subsec)) {
2722 if (ndigits < (
size_t)TIME_SCALE_NUMDIGITS) {
2724 subsec = rb_int_mul(subsec, mul);
2726 else if (ndigits > (
size_t)TIME_SCALE_NUMDIGITS) {
2736 .wday = VTM_WDAY_INITVAL,
2740 .mon = (mon < 0) ? 1 : mon,
2741 .mday = (mday < 0) ? 1 : mday,
2742 .hour = (hour < 0) ? 0 : hour,
2743 .min = (min < 0) ? 0 : min,
2744 .sec = (sec < 0) ? 0 : sec,
2747 return time_init_vtm(time,
vtm, zone);
2751subsec_normalize(wideint_t *secp,
long *subsecp,
const long maxsubsec)
2753 wideint_t sec = *secp;
2754 long subsec = *subsecp;
2757 if (UNLIKELY(subsec >= maxsubsec)) {
2758 sec2 = subsec / maxsubsec;
2759 if (WIDEINT_MAX - sec2 < sec) {
2762 subsec -= sec2 * maxsubsec;
2765 else if (UNLIKELY(subsec < 0)) {
2766 sec2 = NDIV(subsec, maxsubsec);
2767 if (sec < WIDEINT_MIN - sec2) {
2770 subsec -= sec2 * maxsubsec;
2777#define time_usec_normalize(secp, usecp) subsec_normalize(secp, usecp, 1000000)
2778#define time_nsec_normalize(secp, nsecp) subsec_normalize(secp, nsecp, 1000000000)
2781time_new_timew(
VALUE klass, wideval_t timew)
2783 VALUE time = time_s_alloc(klass);
2786 tobj = RTYPEDDATA_GET_DATA(time);
2787 TZMODE_SET_LOCALTIME(tobj);
2788 time_set_timew(time, tobj, timew);
2794TIMETtoWIDEINT(time_t t)
2796#if SIZEOF_TIME_T * CHAR_BIT - (SIGNEDNESS_OF_TIME_T < 0) > \
2797 SIZEOF_WIDEINT * CHAR_BIT - 1
2799 if (t > WIDEINT_MAX) rb_raise(rb_eArgError,
"out of Time range");
2801 return (wideint_t)t;
2807 wideint_t isec = TIMETtoWIDEINT(sec);
2808 time_usec_normalize(&isec, &usec);
2809 return time_new_timew(
rb_cTime, timenano2timew(isec, usec * 1000));
2816 wideint_t isec = TIMETtoWIDEINT(sec);
2817 time_nsec_normalize(&isec, &nsec);
2818 return time_new_timew(
rb_cTime, timenano2timew(isec, nsec));
2827 if (-86400 < offset && offset < 86400) {
2828 GetTimeval(time, tobj);
2829 TZMODE_SET_FIXOFF(time, tobj,
INT2FIX(offset));
2831 else if (offset == INT_MAX) {
2833 else if (offset == INT_MAX-1) {
2834 GetTimeval(time, tobj);
2835 TZMODE_SET_UTC(tobj);
2838 rb_raise(rb_eArgError,
"utc_offset out of range");
2847 VALUE time = time_new_timew(
rb_cTime, rb_time_magnify(v2w(timev)));
2852 if (maybe_tzobj_p(zone)) {
2854 if (zone_timelocal(zone, time))
return time;
2858 if (
NIL_P(zone = find_timezone(time,
off))) invalid_utc_offset(
off);
2860 if (!zone_timelocal(zone, time)) invalid_utc_offset(
off);
2863 else if (
off == UTC_ZONE) {
2864 return time_gmtime(time);
2867 validate_utc_offset(
off);
2868 time_set_utc_offset(time,
off);
2876time_timespec(
VALUE num, int interval)
2879 const char *
const tstr = interval ?
"time interval" :
"time";
2882#ifndef NEGATIVE_TIME_T
2883# define arg_range_check(v) \
2885 rb_raise(rb_eArgError, "%s must not be negative", tstr) : \
2888# define arg_range_check(v) \
2889 ((interval && (v) < 0) ? \
2890 rb_raise(rb_eArgError, "time interval must not be negative") : \
2895 t.tv_sec = NUM2TIMET(num);
2896 arg_range_check(t.tv_sec);
2907 t.tv_nsec = (int)(d*1e9+0.5);
2908 if (t.tv_nsec >= 1000000000) {
2909 t.tv_nsec -= 1000000000;
2913 else if ((t.tv_nsec = (
int)(-d*1e9+0.5)) > 0) {
2914 t.tv_nsec = 1000000000 - t.tv_nsec;
2917 t.tv_sec = (time_t)f;
2918 if (f != t.tv_sec) {
2923 else if (RB_BIGNUM_TYPE_P(num)) {
2924 t.tv_sec = NUM2TIMET(num);
2925 arg_range_check(t.tv_sec);
2934 t.tv_sec = NUM2TIMET(i);
2935 arg_range_check(t.tv_sec);
2940 rb_raise(
rb_eTypeError,
"can't convert %"PRIsVALUE
" into %s",
2945#undef arg_range_check
2949time_timeval(
VALUE num, int interval)
2954 ts = time_timespec(num, interval);
2955 tv.tv_sec = (TYPEOF_TIMEVAL_TV_SEC)ts.tv_sec;
2956 tv.tv_usec = (TYPEOF_TIMEVAL_TV_USEC)(ts.tv_nsec / 1000);
2964 return time_timeval(num, TRUE);
2974 if (IsTimeval(time)) {
2975 GetTimeval(time, tobj);
2976 ts = timew2timespec(tobj->timew);
2977 t.tv_sec = (TYPEOF_TIMEVAL_TV_SEC)ts.tv_sec;
2978 t.tv_usec = (TYPEOF_TIMEVAL_TV_USEC)(ts.tv_nsec / 1000);
2981 return time_timeval(time, FALSE);
2990 if (IsTimeval(time)) {
2991 GetTimeval(time, tobj);
2992 t = timew2timespec(tobj->timew);
2995 return time_timespec(time, FALSE);
3001 return time_timespec(num, TRUE);
3005get_scale(
VALUE unit)
3007 if (unit ==
ID2SYM(id_nanosecond) || unit ==
ID2SYM(id_nsec)) {
3010 else if (unit ==
ID2SYM(id_microsecond) || unit ==
ID2SYM(id_usec)) {
3013 else if (unit ==
ID2SYM(id_millisecond)) {
3017 rb_raise(rb_eArgError,
"unexpected unit: %"PRIsVALUE, unit);
3028 int scale = get_scale(unit);
3029 time = num_exact(time);
3030 t = num_exact(subsec);
3031 timew = wadd(rb_time_magnify(v2w(time)), wmulquoll(v2w(t), TIME_SCALE, scale));
3032 t = time_new_timew(klass, timew);
3034 else if (IsTimeval(time)) {
3036 GetTimeval(time, tobj);
3037 t = time_new_timew(klass, tobj->timew);
3038 GetTimeval(t, tobj2);
3039 TZMODE_COPY(tobj2, tobj);
3042 timew = rb_time_magnify(v2w(num_exact(time)));
3043 t = time_new_timew(klass, timew);
3046 time_zonelocal(t, zone);
3058static const char months[][4] = {
3059 "jan",
"feb",
"mar",
"apr",
"may",
"jun",
3060 "jul",
"aug",
"sep",
"oct",
"nov",
"dec",
3067 obj = rb_str_to_inum(obj, 10, TRUE);
3075obj2ubits(
VALUE obj,
unsigned int bits)
3077 const unsigned int usable_mask = (1U << bits) - 1;
3078 unsigned int rv = (
unsigned int)obj2int(obj);
3080 if ((rv & usable_mask) != rv)
3081 rb_raise(rb_eArgError,
"argument out of range");
3082 return (uint32_t)rv;
3089 obj = rb_str_to_inum(obj, 10, TRUE);
3104 obj = rb_str_to_inum(obj, 10, TRUE);
3108 divmodv(num_exact(obj),
INT2FIX(1), &obj, &subsec);
3109 *subsecx = w2v(rb_time_magnify(v2w(subsec)));
3111 return obj2ubits(obj, 6);
3115usec2subsecx(
VALUE obj)
3118 obj = rb_str_to_inum(obj, 10, TRUE);
3121 return mulquov(num_exact(obj),
INT2FIX(TIME_SCALE),
INT2FIX(1000000));
3130 return obj2ubits(arg, 4);
3135 if (!
NIL_P(s) && RSTRING_LEN(s) > 0) {
3137 for (i=0; i<12; i++) {
3138 if (RSTRING_LEN(s) == 3 &&
3146 mon = obj2ubits(arg, 4);
3152validate_utc_offset(
VALUE utc_offset)
3154 if (le(utc_offset,
INT2FIX(-86400)) || ge(utc_offset,
INT2FIX(86400)))
3155 rb_raise(rb_eArgError,
"utc_offset out of range");
3160validate_zone_name(
VALUE zone_name)
3167validate_vtm(
struct vtm *
vtm)
3169#define validate_vtm_range(mem, b, e) \
3170 ((vtm->mem < b || vtm->mem > e) ? \
3171 rb_raise(rb_eArgError, #mem" out of range") : (void)0)
3172 validate_vtm_range(mon, 1, 12);
3173 validate_vtm_range(mday, 1, 31);
3174 validate_vtm_range(hour, 0, 24);
3175 validate_vtm_range(min, 0, (
vtm->hour == 24 ? 0 : 59));
3176 validate_vtm_range(sec, 0, (
vtm->hour == 24 ? 0 : 60));
3178 rb_raise(rb_eArgError,
"subsecx out of range");
3179 if (!
NIL_P(
vtm->utc_offset)) validate_utc_offset(
vtm->utc_offset);
3180#undef validate_vtm_range
3184time_arg(
int argc,
const VALUE *argv,
struct vtm *
vtm)
3200 vtm->zone = str_empty;
3210 vtm->isdst =
RTEST(argv[8]) ? 1 : 0;
3213 rb_scan_args(argc, argv,
"17", &v[0],&v[1],&v[2],&v[3],&v[4],&v[5],&v[6],&v[7]);
3216 vtm->wday = VTM_WDAY_INITVAL;
3217 vtm->isdst = VTM_ISDST_INITVAL;
3220 vtm->year = obj2vint(v[0]);
3226 vtm->mon = month_arg(v[1]);
3233 vtm->mday = obj2ubits(v[2], 5);
3241 unsigned int mday2 = leap_year_v_p(
vtm->year) ? 29 : 28;
3242 if (
vtm->mday > mday2) {
3252 if (
vtm->mday == 31) {
3259 vtm->hour =
NIL_P(v[3])?0:obj2ubits(v[3], 5);
3261 vtm->min =
NIL_P(v[4])?0:obj2ubits(v[4], 6);
3263 if (!
NIL_P(v[6]) && argc == 7) {
3264 vtm->sec =
NIL_P(v[5])?0:obj2ubits(v[5],6);
3265 subsecx = usec2subsecx(v[6]);
3273 vtm->sec = obj2subsecx(v[5], &subsecx);
3276 vtm->subsecx = subsecx;
3288 unsigned long uy = (
unsigned long)(LIKELY(y >= 0) ? y : -y);
3290 if (LIKELY(uy % 4 != 0))
return 0;
3292 unsigned long century = uy / 100;
3293 if (LIKELY(uy != century * 100))
return 1;
3294 return century % 4 == 0;
3298timegm_noleapsecond(
struct tm *tm)
3300 long tm_year = tm->tm_year;
3301 int tm_yday = calc_tm_yday(tm->tm_year, tm->tm_mon, tm->tm_mday);
3309 return tm->tm_sec + tm->tm_min*60 + tm->tm_hour*3600 +
3313 DIV(tm_year-1,100) +
3314 DIV(tm_year+299,400))*86400;
3318#define DEBUG_FIND_TIME_NUMGUESS
3319#define DEBUG_GUESSRANGE
3322static const bool debug_guessrange =
3323#ifdef DEBUG_GUESSRANGE
3329#define DEBUG_REPORT_GUESSRANGE \
3330 (debug_guessrange ? debug_report_guessrange(guess_lo, guess_hi) : (void)0)
3333debug_report_guessrange(time_t guess_lo, time_t guess_hi)
3335 time_t guess_diff = guess_hi - guess_lo;
3336 fprintf(stderr,
"find time guess range: %"PRI_TIMET_PREFIX
"d - "
3337 "%"PRI_TIMET_PREFIX
"d : %"PRI_TIMET_PREFIX
"u\n",
3338 guess_lo, guess_hi, guess_diff);
3341static const bool debug_find_time_numguess =
3342#ifdef DEBUG_FIND_TIME_NUMGUESS
3348#define DEBUG_FIND_TIME_NUMGUESS_INC \
3349 (void)(debug_find_time_numguess && find_time_numguess++),
3350static unsigned long long find_time_numguess;
3353find_time_numguess_getter(
ID name,
VALUE *data)
3355 unsigned long long *numguess = (
void *)data;
3360find_time_t(
struct tm *tptr,
int utc_p, time_t *tp)
3362 time_t guess, guess0, guess_lo, guess_hi;
3363 struct tm *tm, tm0, tm_lo, tm_hi;
3370#define GUESS(p) (DEBUG_FIND_TIME_NUMGUESS_INC (utc_p ? gmtime_with_leapsecond((p), &result) : LOCALTIME((p), result)))
3372 guess_lo = TIMET_MIN;
3373 guess_hi = TIMET_MAX;
3375 find_dst = 0 < tptr->tm_isdst;
3381 if (tm0.tm_mon < 0) {
3388 else if (11 < tm0.tm_mon) {
3395 else if (tm0.tm_mday < 1) {
3401 else if ((d = days_in_month_in(1900 + tm0.tm_year)[tm0.tm_mon]) < tm0.tm_mday) {
3407 else if (tm0.tm_hour < 0) {
3412 else if (23 < tm0.tm_hour) {
3417 else if (tm0.tm_min < 0) {
3421 else if (59 < tm0.tm_min) {
3425 else if (tm0.tm_sec < 0) {
3428 else if (60 < tm0.tm_sec) {
3432 DEBUG_REPORT_GUESSRANGE;
3433 guess0 = guess = timegm_noleapsecond(&tm0);
3436 d = tmcmp(tptr, tm);
3437 if (d == 0) {
goto found; }
3440 guess -= 24 * 60 * 60;
3444 guess += 24 * 60 * 60;
3446 DEBUG_REPORT_GUESSRANGE;
3447 if (guess_lo < guess && guess < guess_hi && (tm = GUESS(&guess)) != NULL) {
3448 d = tmcmp(tptr, tm);
3449 if (d == 0) {
goto found; }
3454 DEBUG_REPORT_GUESSRANGE;
3458 tm = GUESS(&guess_lo);
3459 if (!tm)
goto error;
3460 d = tmcmp(tptr, tm);
3461 if (d < 0)
goto out_of_range;
3462 if (d == 0) { guess = guess_lo;
goto found; }
3465 tm = GUESS(&guess_hi);
3466 if (!tm)
goto error;
3467 d = tmcmp(tptr, tm);
3468 if (d > 0)
goto out_of_range;
3469 if (d == 0) { guess = guess_hi;
goto found; }
3472 DEBUG_REPORT_GUESSRANGE;
3476 while (guess_lo + 1 < guess_hi) {
3479 guess = guess_lo / 2 + guess_hi / 2;
3480 if (guess <= guess_lo)
3481 guess = guess_lo + 1;
3482 else if (guess >= guess_hi)
3483 guess = guess_hi - 1;
3488 time_t guess0_hi = timegm_noleapsecond(&tm_hi);
3489 guess = guess_hi - (guess0_hi - guess0);
3490 if (guess == guess_hi)
3494 else if (status == 2) {
3495 time_t guess0_lo = timegm_noleapsecond(&tm_lo);
3496 guess = guess_lo + (guess0 - guess0_lo);
3497 if (guess == guess_lo)
3501 if (guess <= guess_lo || guess_hi <= guess) {
3503 if (debug_guessrange) {
3504 if (guess <= guess_lo) {
3505 fprintf(stderr,
"too small guess: %"PRI_TIMET_PREFIX
"d"\
3506 " <= %"PRI_TIMET_PREFIX
"d\n", guess, guess_lo);
3508 if (guess_hi <= guess) {
3509 fprintf(stderr,
"too big guess: %"PRI_TIMET_PREFIX
"d"\
3510 " <= %"PRI_TIMET_PREFIX
"d\n", guess_hi, guess);
3519 if (!tm)
goto error;
3521 d = tmcmp(tptr, tm);
3526 DEBUG_REPORT_GUESSRANGE;
3531 DEBUG_REPORT_GUESSRANGE;
3546 tptr_tm_yday = calc_tm_yday(tptr->tm_year, tptr->tm_mon, tptr->tm_mday);
3549 ((tptr->tm_year - tm_lo.tm_year) * 365 +
3550 DIV((tptr->tm_year-69), 4) -
3551 DIV((tptr->tm_year-1), 100) +
3552 DIV((tptr->tm_year+299), 400) -
3553 DIV((tm_lo.tm_year-69), 4) +
3554 DIV((tm_lo.tm_year-1), 100) -
3555 DIV((tm_lo.tm_year+299), 400) +
3557 tm_lo.tm_yday) * 86400 +
3558 (tptr->tm_hour - tm_lo.tm_hour) * 3600 +
3559 (tptr->tm_min - tm_lo.tm_min) * 60 +
3560 (tptr->tm_sec - (tm_lo.tm_sec == 60 ? 59 : tm_lo.tm_sec));
3569 guess2 = guess - 2 * 60 * 60;
3570 tm = LOCALTIME(&guess2, result);
3572 if (tptr->tm_hour != (tm->tm_hour + 2) % 24 ||
3573 tptr->tm_min != tm->tm_min ||
3574 tptr->tm_sec != tm->tm_sec) {
3575 guess2 -= (tm->tm_hour - tptr->tm_hour) * 60 * 60 +
3576 (tm->tm_min - tptr->tm_min) * 60 +
3577 (tm->tm_sec - tptr->tm_sec);
3578 if (tptr->tm_mday != tm->tm_mday)
3579 guess2 += 24 * 60 * 60;
3580 if (guess != guess2) {
3581 tm = LOCALTIME(&guess2, result);
3582 if (tm && tmcmp(tptr, tm) == 0) {
3594 guess2 = guess + 2 * 60 * 60;
3595 tm = LOCALTIME(&guess2, result);
3597 if ((tptr->tm_hour + 2) % 24 != tm->tm_hour ||
3598 tptr->tm_min != tm->tm_min ||
3599 tptr->tm_sec != tm->tm_sec) {
3600 guess2 -= (tm->tm_hour - tptr->tm_hour) * 60 * 60 +
3601 (tm->tm_min - tptr->tm_min) * 60 +
3602 (tm->tm_sec - tptr->tm_sec);
3603 if (tptr->tm_mday != tm->tm_mday)
3604 guess2 -= 24 * 60 * 60;
3605 if (guess != guess2) {
3606 tm = LOCALTIME(&guess2, result);
3607 if (tm && tmcmp(tptr, tm) == 0) {
3623 return "time out of range";
3626 return "gmtime/localtime error";
3630vtmcmp(
struct vtm *a,
struct vtm *b)
3632 if (ne(a->year, b->year))
3633 return lt(a->year, b->year) ? -1 : 1;
3634 else if (a->mon != b->mon)
3635 return a->mon < b->mon ? -1 : 1;
3636 else if (a->mday != b->mday)
3637 return a->mday < b->mday ? -1 : 1;
3638 else if (a->hour != b->hour)
3639 return a->hour < b->hour ? -1 : 1;
3640 else if (a->min != b->min)
3641 return a->min < b->min ? -1 : 1;
3642 else if (a->sec != b->sec)
3643 return a->sec < b->sec ? -1 : 1;
3644 else if (ne(a->subsecx, b->subsecx))
3645 return lt(a->subsecx, b->subsecx) ? -1 : 1;
3651tmcmp(
struct tm *a,
struct tm *b)
3653 if (a->tm_year != b->tm_year)
3654 return a->tm_year < b->tm_year ? -1 : 1;
3655 else if (a->tm_mon != b->tm_mon)
3656 return a->tm_mon < b->tm_mon ? -1 : 1;
3657 else if (a->tm_mday != b->tm_mday)
3658 return a->tm_mday < b->tm_mday ? -1 : 1;
3659 else if (a->tm_hour != b->tm_hour)
3660 return a->tm_hour < b->tm_hour ? -1 : 1;
3661 else if (a->tm_min != b->tm_min)
3662 return a->tm_min < b->tm_min ? -1 : 1;
3663 else if (a->tm_sec != b->tm_sec)
3664 return a->tm_sec < b->tm_sec ? -1 : 1;
3770time_s_mkutc(
int argc,
VALUE *argv,
VALUE klass)
3774 time_arg(argc, argv, &
vtm);
3775 return time_gmtime(time_new_timew(klass, timegmw(&
vtm)));
3796time_s_mktime(
int argc,
VALUE *argv,
VALUE klass)
3800 time_arg(argc, argv, &
vtm);
3801 return time_localtime(time_new_timew(klass, timelocalw(&
vtm)));
3821time_to_i(
VALUE time)
3825 GetTimeval(time, tobj);
3826 return w2v(wdiv(tobj->timew, WINT2FIXWV(TIME_SCALE)));
3850time_to_f(
VALUE time)
3854 GetTimeval(time, tobj);
3855 return rb_Float(rb_time_unmagnify_to_float(tobj->timew));
3871time_to_r(
VALUE time)
3876 GetTimeval(time, tobj);
3877 v = rb_time_unmagnify_to_rational(tobj->timew);
3899time_usec(
VALUE time)
3904 GetTimeval(time, tobj);
3906 w = wmod(tobj->timew, WINT2WV(TIME_SCALE));
3907 wmuldivmod(w, WINT2FIXWV(1000000), WINT2FIXWV(TIME_SCALE), &q, &r);
3926time_nsec(
VALUE time)
3930 GetTimeval(time, tobj);
3931 return rb_to_int(w2v(wmulquoll(wmod(tobj->timew, WINT2WV(TIME_SCALE)), 1000000000, TIME_SCALE)));
3952time_subsec(
VALUE time)
3956 GetTimeval(time, tobj);
3957 return quov(w2v(wmod(tobj->timew, WINT2FIXWV(TIME_SCALE))),
INT2FIX(TIME_SCALE));
3994 GetTimeval(time1, tobj1);
3995 if (IsTimeval(time2)) {
3996 GetTimeval(time2, tobj2);
3997 n = wcmp(tobj1->timew, tobj2->timew);
4000 return rb_invcmp(time1, time2);
4002 if (n == 0)
return INT2FIX(0);
4020 GetTimeval(time1, tobj1);
4021 if (IsTimeval(time2)) {
4022 GetTimeval(time2, tobj2);
4023 return rb_equal(w2v(tobj1->timew), w2v(tobj2->timew));
4056time_utc_p(
VALUE time)
4060 GetTimeval(time, tobj);
4061 return RBOOL(TZMODE_UTC_P(tobj));
4074time_hash(
VALUE time)
4078 GetTimeval(time, tobj);
4079 return rb_hash(w2v(tobj->timew));
4089 GetTimeval(time, tobj);
4090 GetNewTimeval(copy, tcopy);
4092 time_set_timew(copy, tcopy, tobj->timew);
4093 time_set_vtm(copy, tcopy, tobj->vtm);
4102 time_init_copy(dup, time);
4107time_localtime(
VALUE time)
4113 GetTimeval(time, tobj);
4114 if (TZMODE_LOCALTIME_P(tobj)) {
4115 if (tobj->vtm.tm_got)
4122 zone = tobj->vtm.zone;
4123 if (maybe_tzobj_p(zone) && zone_localtime(zone, time)) {
4127 if (!localtimew(tobj->timew, &
vtm))
4128 rb_raise(rb_eArgError,
"localtime error");
4129 time_set_vtm(time, tobj,
vtm);
4131 tobj->vtm.tm_got = 1;
4132 TZMODE_SET_LOCALTIME(tobj);
4140 if (zone_localtime(zone, time))
return time;
4144 if (
NIL_P(zone = find_timezone(time,
off))) invalid_utc_offset(
off);
4145 if (!zone_localtime(zone, time)) invalid_utc_offset(
off);
4148 else if (
off == UTC_ZONE) {
4149 return time_gmtime(time);
4151 validate_utc_offset(
off);
4153 time_set_utc_offset(time,
off);
4154 return time_fixoff(time);
4183time_localtime_m(
int argc,
VALUE *argv,
VALUE time)
4188 return time_zonelocal(time,
off);
4191 return time_localtime(time);
4209time_gmtime(
VALUE time)
4214 GetTimeval(time, tobj);
4215 if (TZMODE_UTC_P(tobj)) {
4216 if (tobj->vtm.tm_got)
4224 GMTIMEW(tobj->timew, &
vtm);
4225 time_set_vtm(time, tobj,
vtm);
4227 tobj->vtm.tm_got = 1;
4228 TZMODE_SET_UTC(tobj);
4233time_fixoff(
VALUE time)
4239 GetTimeval(time, tobj);
4240 if (TZMODE_FIXOFF_P(tobj)) {
4241 if (tobj->vtm.tm_got)
4248 if (TZMODE_FIXOFF_P(tobj))
4249 off = tobj->vtm.utc_offset;
4253 GMTIMEW(tobj->timew, &
vtm);
4255 zone = tobj->vtm.zone;
4256 vtm_add_offset(&
vtm,
off, +1);
4258 time_set_vtm(time, tobj,
vtm);
4259 RB_OBJ_WRITE_UNALIGNED(time, &tobj->vtm.zone, zone);
4261 tobj->vtm.tm_got = 1;
4262 TZMODE_SET_FIXOFF(time, tobj,
off);
4284time_getlocaltime(
int argc,
VALUE *argv,
VALUE time)
4290 if (maybe_tzobj_p(zone)) {
4291 VALUE t = time_dup(time);
4292 if (zone_localtime(
off, t))
return t;
4297 if (
NIL_P(zone = find_timezone(time,
off))) invalid_utc_offset(
off);
4298 time = time_dup(time);
4299 if (!zone_localtime(zone, time)) invalid_utc_offset(
off);
4302 else if (
off == UTC_ZONE) {
4303 return time_gmtime(time_dup(time));
4305 validate_utc_offset(
off);
4307 time = time_dup(time);
4308 time_set_utc_offset(time,
off);
4309 return time_fixoff(time);
4312 return time_localtime(time_dup(time));
4331time_getgmtime(
VALUE time)
4333 return time_gmtime(time_dup(time));
4339 if (TZMODE_UTC_P(tobj))
return time_gmtime(time);
4340 if (TZMODE_FIXOFF_P(tobj))
return time_fixoff(time);
4341 return time_localtime(time);
4345#define strftimev(fmt, time, enc) strftime_cstr((fmt), rb_strlen_lit(fmt), (time), (enc))
4369time_asctime(
VALUE time)
4371 return strftimev(
"%a %b %e %T %Y", time, rb_usascii_encoding());
4391time_to_s(
VALUE time)
4395 GetTimeval(time, tobj);
4396 if (TZMODE_UTC_P(tobj))
4397 return strftimev(
"%Y-%m-%d %H:%M:%S UTC", time, rb_usascii_encoding());
4399 return strftimev(
"%Y-%m-%d %H:%M:%S %z", time, rb_usascii_encoding());
4419time_inspect(
VALUE time)
4424 GetTimeval(time, tobj);
4425 str = strftimev(
"%Y-%m-%d %H:%M:%S", time, rb_usascii_encoding());
4426 subsec = w2v(wmod(tobj->timew, WINT2FIXWV(TIME_SCALE)));
4431 rb_str_catf(str,
".%09ld",
FIX2LONG(subsec));
4432 for (
len=RSTRING_LEN(str); RSTRING_PTR(str)[
len-1] ==
'0' &&
len > 0;
len--)
4434 rb_str_resize(str,
len);
4438 subsec = quov(subsec,
INT2FIX(TIME_SCALE));
4441 if (TZMODE_UTC_P(tobj)) {
4447 char sign = (
off < 0) ? (
off = -
off,
'-') :
'+';
4449 int min = (
off /= 60) % 60;
4451 rb_str_catf(str,
" %c%.2d%.2d", sign, (
int)
off, min);
4452 if (sec) rb_str_catf(str,
"%.2d", sec);
4463 offset = num_exact(offset);
4465 result = time_new_timew(klass, wsub(tobj->timew, rb_time_magnify(v2w(offset))));
4467 result = time_new_timew(klass, wadd(tobj->timew, rb_time_magnify(v2w(offset))));
4468 GetTimeval(result, result_tobj);
4469 TZMODE_COPY(result_tobj, tobj);
4477 return time_add0(
rb_cTime, tobj, torig, offset, sign);
4498 GetTimeval(time1, tobj);
4500 if (IsTimeval(time2)) {
4503 return time_add(tobj, time1, time2, 1);
4533 GetTimeval(time1, tobj);
4534 if (IsTimeval(time2)) {
4537 GetTimeval(time2, tobj2);
4538 return rb_Float(rb_time_unmagnify_to_float(wsub(tobj->timew, tobj2->timew)));
4540 return time_add(tobj, time1, time2, -1);
4544ndigits_denominator(
VALUE ndigits)
4549 rb_raise(rb_eArgError,
"negative ndigits given");
4589 VALUE ndigits, v, den;
4595 den = ndigits_denominator(ndigits);
4597 GetTimeval(time, tobj);
4598 v = w2v(rb_time_unmagnify(tobj->timew));
4601 if (lt(v, quov(den,
INT2FIX(2))))
4602 return time_add(tobj, time, v, -1);
4604 return time_add(tobj, time, subv(den, v), 1);
4637 VALUE ndigits, v, den;
4643 den = ndigits_denominator(ndigits);
4645 GetTimeval(time, tobj);
4646 v = w2v(rb_time_unmagnify(tobj->timew));
4649 return time_add(tobj, time, v, -1);
4682 VALUE ndigits, v, den;
4688 den = ndigits_denominator(ndigits);
4690 GetTimeval(time, tobj);
4691 v = w2v(rb_time_unmagnify(tobj->timew));
4697 return time_add(tobj, time, v, 1);
4722 GetTimeval(time, tobj);
4723 MAKE_TM(time, tobj);
4724 return INT2FIX(tobj->vtm.sec);
4746 GetTimeval(time, tobj);
4747 MAKE_TM(time, tobj);
4748 return INT2FIX(tobj->vtm.min);
4766time_hour(
VALUE time)
4770 GetTimeval(time, tobj);
4771 MAKE_TM(time, tobj);
4772 return INT2FIX(tobj->vtm.hour);
4790time_mday(
VALUE time)
4794 GetTimeval(time, tobj);
4795 MAKE_TM(time, tobj);
4796 return INT2FIX(tobj->vtm.mday);
4818 GetTimeval(time, tobj);
4819 MAKE_TM(time, tobj);
4820 return INT2FIX(tobj->vtm.mon);
4837time_year(
VALUE time)
4841 GetTimeval(time, tobj);
4842 MAKE_TM(time, tobj);
4843 return tobj->vtm.year;
4862time_wday(
VALUE time)
4866 GetTimeval(time, tobj);
4867 MAKE_TM_ENSURE(time, tobj, tobj->vtm.wday != VTM_WDAY_INITVAL);
4868 return INT2FIX((
int)tobj->vtm.wday);
4872 return RBOOL(time_wday(time) == INT2FIX(n)); \
4888time_sunday(
VALUE time)
4906time_monday(
VALUE time)
4924time_tuesday(
VALUE time)
4942time_wednesday(
VALUE time)
4960time_thursday(
VALUE time)
4978time_friday(
VALUE time)
4996time_saturday(
VALUE time)
5012time_yday(
VALUE time)
5016 GetTimeval(time, tobj);
5017 MAKE_TM_ENSURE(time, tobj, tobj->vtm.yday != 0);
5018 return INT2FIX(tobj->vtm.yday);
5037time_isdst(
VALUE time)
5041 GetTimeval(time, tobj);
5042 MAKE_TM(time, tobj);
5043 if (tobj->vtm.isdst == VTM_ISDST_INITVAL) {
5046 return RBOOL(tobj->vtm.isdst);
5060time_zone(
VALUE time)
5065 GetTimeval(time, tobj);
5066 MAKE_TM(time, tobj);
5068 if (TZMODE_UTC_P(tobj)) {
5071 zone = tobj->vtm.zone;
5096 GetTimeval(time, tobj);
5098 if (TZMODE_UTC_P(tobj)) {
5102 MAKE_TM(time, tobj);
5103 return tobj->vtm.utc_offset;
5123time_to_a(
VALUE time)
5127 GetTimeval(time, tobj);
5128 MAKE_TM_ENSURE(time, tobj, tobj->vtm.yday != 0);
5138 RBOOL(tobj->vtm.isdst),
5184 GetTimeval(time, tobj);
5185 MAKE_TM_ENSURE(time, tobj, tobj->vtm.yday != 0);
5188 h = rb_hash_new_with_size(11);
5190 rb_hash_aset(h, sym_year, tobj->vtm.year);
5191 rb_hash_aset(h, sym_month,
INT2FIX(tobj->vtm.mon));
5192 rb_hash_aset(h, sym_day,
INT2FIX(tobj->vtm.mday));
5193 rb_hash_aset(h, sym_yday,
INT2FIX(tobj->vtm.yday));
5194 rb_hash_aset(h, sym_wday,
INT2FIX(tobj->vtm.wday));
5195 rb_hash_aset(h, sym_hour,
INT2FIX(tobj->vtm.hour));
5196 rb_hash_aset(h, sym_min,
INT2FIX(tobj->vtm.min));
5197 rb_hash_aset(h, sym_sec,
INT2FIX(tobj->vtm.sec));
5198 rb_hash_aset(h, sym_subsec,
5199 quov(w2v(wmod(tobj->timew, WINT2FIXWV(TIME_SCALE))),
INT2FIX(TIME_SCALE)));
5200 rb_hash_aset(h, sym_dst, RBOOL(tobj->vtm.isdst));
5201 rb_hash_aset(h, sym_zone, time_zone(time));
5207 "wrong argument type %"PRIsVALUE
" (expected Array or nil)",
5217 if (sym_year == key) rb_hash_aset(h, key, tobj->vtm.year);
5218 if (sym_month == key) rb_hash_aset(h, key,
INT2FIX(tobj->vtm.mon));
5219 if (sym_day == key) rb_hash_aset(h, key,
INT2FIX(tobj->vtm.mday));
5220 if (sym_yday == key) rb_hash_aset(h, key,
INT2FIX(tobj->vtm.yday));
5221 if (sym_wday == key) rb_hash_aset(h, key,
INT2FIX(tobj->vtm.wday));
5222 if (sym_hour == key) rb_hash_aset(h, key,
INT2FIX(tobj->vtm.hour));
5223 if (sym_min == key) rb_hash_aset(h, key,
INT2FIX(tobj->vtm.min));
5224 if (sym_sec == key) rb_hash_aset(h, key,
INT2FIX(tobj->vtm.sec));
5225 if (sym_subsec == key) {
5226 rb_hash_aset(h, key, quov(w2v(wmod(tobj->timew, WINT2FIXWV(TIME_SCALE))),
INT2FIX(TIME_SCALE)));
5228 if (sym_dst == key) rb_hash_aset(h, key, RBOOL(tobj->vtm.isdst));
5229 if (sym_zone == key) rb_hash_aset(h, key, time_zone(time));
5235rb_strftime_alloc(
const char *format,
size_t format_len,
rb_encoding *enc,
5236 VALUE time,
struct vtm *
vtm, wideval_t timew,
int gmt)
5241 if (!timew2timespec_exact(timew, &ts))
5242 timev = w2v(rb_time_unmagnify(timew));
5245 return rb_strftime_timespec(format, format_len, enc, time,
vtm, &ts, gmt);
5248 return rb_strftime(format, format_len, enc, time,
vtm, timev, gmt);
5258 GetTimeval(time, tobj);
5259 MAKE_TM(time, tobj);
5260 str = rb_strftime_alloc(fmt,
len, enc, time, &tobj->vtm, tobj->timew, TZMODE_UTC_P(tobj));
5261 if (!str) rb_raise(rb_eArgError,
"invalid format: %s", fmt);
5283 GetTimeval(time, tobj);
5284 MAKE_TM_ENSURE(time, tobj, tobj->vtm.yday != 0);
5287 rb_raise(rb_eArgError,
"format should have ASCII compatible encoding");
5289 tmp = rb_str_tmp_frozen_acquire(format);
5290 fmt = RSTRING_PTR(tmp);
5291 len = RSTRING_LEN(tmp);
5292 enc = rb_enc_get(format);
5294 rb_warning(
"strftime called with empty format string");
5295 return rb_enc_str_new(0, 0, enc);
5298 VALUE str = rb_strftime_alloc(fmt,
len, enc, time, &tobj->vtm, tobj->timew,
5299 TZMODE_UTC_P(tobj));
5300 rb_str_tmp_frozen_release(format, tmp);
5301 if (!str) rb_raise(rb_eArgError,
"invalid format: %"PRIsVALUE, format);
5328time_xmlschema(
int argc,
VALUE *argv,
VALUE time)
5330 long fraction_digits = 0;
5333 fraction_digits =
NUM2LONG(argv[0]);
5334 if (fraction_digits < 0) {
5335 fraction_digits = 0;
5341 GetTimeval(time, tobj);
5342 MAKE_TM(time, tobj);
5344 const long size_after_year =
sizeof(
"-MM-DDTHH:MM:SS+ZH:ZM") + fraction_digits
5345 + (fraction_digits > 0);
5349# define fill_digits_long(len, prec, n) \
5350 for (int fill_it = 1, written = snprintf(ptr, len, "%0*ld", prec, n); \
5351 fill_it; ptr += written, fill_it = 0)
5354 long year =
FIX2LONG(tobj->vtm.year);
5356 int w = (year >= -9999 && year <= 9999 ? year_width : (year < 0) + (
int)
DECIMAL_SIZE_OF(year));
5358 ptr = RSTRING_PTR(str);
5359 fill_digits_long(w + 1, year_width, year) {
5360 if (year >= -9999 && year <= 9999) {
5370 str = rb_int2str(tobj->vtm.year, 10);
5375# define fill_2(c, n) (*ptr++ = c, *ptr++ = '0' + (n) / 10, *ptr++ = '0' + (n) % 10)
5376 fill_2(
'-', tobj->vtm.mon);
5377 fill_2(
'-', tobj->vtm.mday);
5378 fill_2(
'T', tobj->vtm.hour);
5379 fill_2(
':', tobj->vtm.min);
5380 fill_2(
':', tobj->vtm.sec);
5382 if (fraction_digits > 0) {
5383 VALUE subsecx = tobj->vtm.subsecx;
5387 if (fraction_digits <= TIME_SCALE_NUMDIGITS) {
5388 digits = TIME_SCALE_NUMDIGITS - (int)fraction_digits;
5391 long w = fraction_digits - TIME_SCALE_NUMDIGITS;
5398 if (digits >= 0 && fraction_digits < INT_MAX) {
5400 if (digits > 0) subsec /= (long)pow(10, digits);
5401 fill_digits_long(fraction_digits + 1, (
int)fraction_digits, subsec) {
5406 subsecx = rb_int2str(subsecx, 10);
5407 long len = RSTRING_LEN(subsecx);
5408 if (fraction_digits >
len) {
5409 memset(ptr,
'0', fraction_digits -
len);
5412 len = fraction_digits;
5414 ptr += fraction_digits;
5415 memcpy(ptr -
len, RSTRING_PTR(subsecx),
len);
5419 if (TZMODE_UTC_P(tobj)) {
5425 char sign = offset < 0 ?
'-' :
'+';
5426 if (offset < 0) offset = -offset;
5428 fill_2(sign, offset / 60);
5429 fill_2(
':', offset % 60);
5431 const char *
const start = RSTRING_PTR(str);
5436int ruby_marshal_write_long(
long x,
char *buf);
5438enum {base_dump_size = 8};
5442time_mdump(
VALUE time)
5446 char buf[base_dump_size +
sizeof(long) + 1];
5453 VALUE subsecx, nano, subnano, v, zone;
5456 const int max_year = 1900+0xffff;
5458 GetTimeval(time, tobj);
5460 gmtimew(tobj->timew, &
vtm);
5464 if (year > max_year) {
5465 year_extend =
INT2FIX(year - max_year);
5468 else if (year < 1900) {
5469 year_extend =
LONG2NUM(1900 - year);
5474 if (rb_int_positive_p(
vtm.year)) {
5475 year_extend = rb_int_minus(
vtm.year,
INT2FIX(max_year));
5479 year_extend = rb_int_minus(
INT2FIX(1900),
vtm.year);
5484 subsecx =
vtm.subsecx;
5486 nano = mulquov(subsecx,
INT2FIX(1000000000),
INT2FIX(TIME_SCALE));
5487 divmodv(nano,
INT2FIX(1), &v, &subnano);
5492 nano = addv(
LONG2FIX(nsec), subnano);
5495 TZMODE_UTC_P(tobj) << 30 |
5500 s = (
unsigned long)
vtm.min << 26 |
5504 for (i=0; i<4; i++) {
5505 buf[i] = (
unsigned char)p;
5508 for (i=4; i<8; i++) {
5509 buf[i] = (
unsigned char)s;
5513 if (!
NIL_P(year_extend)) {
5520 size_t ysize = rb_absint_size(year_extend, NULL);
5521 char *p, *
const buf_year_extend = buf + base_dump_size;
5522 if (ysize > LONG_MAX ||
5523 (i = ruby_marshal_write_long((
long)ysize, buf_year_extend)) < 0) {
5524 rb_raise(rb_eArgError,
"year too %s to marshal: %"PRIsVALUE
" UTC",
5525 (year == 1900 ?
"small" :
"big"),
vtm.year);
5527 i += base_dump_size;
5529 p = RSTRING_PTR(str);
5540 rb_ivar_set(str, id_nano_num, RRATIONAL(nano)->num);
5541 rb_ivar_set(str, id_nano_den, RRATIONAL(nano)->den);
5557 int len = (int)
sizeof(buf);
5558 buf[1] = (char)((nsec % 10) << 4);
5560 buf[0] = (char)(nsec % 10);
5562 buf[0] |= (char)((nsec % 10) << 4);
5567 if (!TZMODE_UTC_P(tobj)) {
5574 zone = tobj->vtm.zone;
5575 if (maybe_tzobj_p(zone)) {
5576 zone = rb_funcallv(zone, id_name, 0, 0);
5589 str = time_mdump(time);
5595mload_findzone(
VALUE arg)
5598 VALUE time = argp[0], zone = argp[1];
5599 return find_timezone(time, zone);
5609 if (
NIL_P(z))
return rb_fstring(zone);
5614long ruby_marshal_read_long(
const char **buf,
long len);
5628 VALUE submicro, nano_num, nano_den, offset, zone, year;
5633#define get_attr(attr, iffound) \
5634 attr = rb_attr_delete(str, id_##attr); \
5635 if (!NIL_P(attr)) { \
5639 get_attr(nano_num, {});
5640 get_attr(nano_den, {});
5641 get_attr(submicro, {});
5642 get_attr(offset, (offset =
rb_rescue(validate_utc_offset, offset, 0,
Qnil)));
5643 get_attr(zone, (zone =
rb_rescue(validate_zone_name, zone, 0,
Qnil)));
5651 buf = (
unsigned char *)RSTRING_PTR(str);
5652 if (RSTRING_LEN(str) < base_dump_size) {
5653 goto invalid_format;
5657 for (i=0; i<4; i++) {
5658 p |= (
unsigned long)buf[i]<<(8*i);
5660 for (i=4; i<8; i++) {
5661 s |= (
unsigned long)buf[i]<<(8*(i-4));
5664 if ((p & (1UL<<31)) == 0) {
5670 timew = wadd(rb_time_magnify(TIMET2WV(sec)), wmulquoll(WINT2FIXWV(usec), TIME_SCALE, 1000000));
5674 gmt = (int)((p >> 30) & 0x1);
5677 year =
INT2FIX(((
int)(p >> 14) & 0xffff) + 1900);
5679 if (RSTRING_LEN(str) > base_dump_size) {
5680 long len = RSTRING_LEN(str) - base_dump_size;
5683 const char *ybuf = (
const char *)(buf += base_dump_size);
5684 ysize = ruby_marshal_read_long(&ybuf,
len);
5685 len -= ybuf - (
const char *)buf;
5686 if (ysize < 0 || ysize >
len)
goto invalid_format;
5689 year = rb_int_minus(year, year_extend);
5692 year = rb_int_plus(year, year_extend);
5695 unsigned int mon = ((int)(p >> 10) & 0xf);
5702 vtm.mday = (int)(p >> 5) & 0x1f;
5703 vtm.hour = (int) p & 0x1f;
5704 vtm.min = (int)(s >> 26) & 0x3f;
5705 vtm.sec = (int)(s >> 20) & 0x3f;
5709 vtm.zone = str_empty;
5711 usec = (long)(s & 0xfffff);
5716 if (nano_num !=
Qnil) {
5717 VALUE nano = quov(num_exact(nano_num), num_exact(nano_den));
5720 else if (submicro !=
Qnil) {
5725 len = RSTRING_LEN(submicro);
5728 if (10 <= (digit = ptr[0] >> 4))
goto end_submicro;
5729 nsec += digit * 100;
5730 if (10 <= (digit = ptr[0] & 0xf))
goto end_submicro;
5734 if (10 <= (digit = ptr[1] >> 4))
goto end_submicro;
5740 timew = timegmw(&
vtm);
5743 GetNewTimeval(time, tobj);
5744 TZMODE_SET_LOCALTIME(tobj);
5745 tobj->vtm.tm_got = 0;
5746 time_set_timew(time, tobj, timew);
5749 TZMODE_SET_UTC(tobj);
5751 else if (!
NIL_P(offset)) {
5752 time_set_utc_offset(time, offset);
5756 zone = mload_zone(time, zone);
5758 zone_localtime(zone, time);
5772 VALUE time = time_s_alloc(klass);
5774 time_mload(time, str);
5799 GetTimeval(time, tobj);
5800 tm = time_s_alloc(klass);
5801 ttm = RTYPEDDATA_GET_DATA(tm);
5804 WIDEVALUE timew = tobj->timew;
5806 time_set_timew(tm, ttm, wsub(timew, v->subsecx));
5809 time_set_vtm(tm, ttm, *v);
5811 ttm->vtm.tm_got = 1;
5812 TZMODE_SET_UTC(ttm);
5824tm_initialize(
int argc,
VALUE *argv,
VALUE time)
5830 time_arg(argc, argv, &
vtm);
5832 struct time_object *tobj = RTYPEDDATA_GET_DATA(time);
5833 TZMODE_SET_UTC(tobj);
5834 time_set_timew(time, tobj, t);
5835 time_set_vtm(time, tobj,
vtm);
5851 struct time_object *tobj = RTYPEDDATA_GET_DATA(dup);
5859 return time_add0(
rb_obj_class(tm), get_timeval(tm), tm, offset, +1);
5865 return time_add0(
rb_obj_class(tm), get_timeval(tm), tm, offset, -1);
5869Init_tm(
VALUE outer,
const char *name)
5915rb_time_zone_abbreviation(
VALUE zone,
VALUE time)
5917 VALUE tm, abbr, strftime_args[2];
5920 if (!
NIL_P(abbr))
return abbr;
5922 tm = tm_from_time(rb_cTimeTM, time);
5924 if (!UNDEF_P(abbr)) {
5927#ifdef SUPPORT_TZINFO_ZONE_ABBREVIATION
5929 if (!UNDEF_P(abbr)) {
5930 abbr = rb_funcallv(abbr, rb_intern(
"abbreviation"), 0, 0);
5934 strftime_args[0] = rb_fstring_lit(
"%Z");
5935 strftime_args[1] = tm;
5937 if (!UNDEF_P(abbr)) {
5940 abbr = rb_check_funcall_default(zone, idName, 0, 0,
Qnil);
5950 ruby_reset_timezone(getenv(
"TZ"));
5986 str_utc = rb_fstring_lit(
"UTC");
5987 rb_vm_register_global_object(str_utc);
5988 str_empty = rb_fstring_lit(
"");
5989 rb_vm_register_global_object(str_empty);
6073 if (debug_find_time_numguess) {
6075 find_time_numguess_getter, 0);
6078 rb_cTimeTM = Init_tm(
rb_cTime,
"tm");
6081#include "timev.rbinc"
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_singleton_method(klass, mid, func, arity)
Defines klass.mid.
#define rb_define_private_method(klass, mid, func, arity)
Defines klass#mid and makes it private.
void rb_include_module(VALUE klass, VALUE module)
Includes a module to a class.
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
VALUE rb_singleton_class(VALUE obj)
Finds or creates the singleton class of the passed object.
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
void rb_define_alias(VALUE klass, const char *name1, const char *name2)
Defines an alias of a method.
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Retrieves argument from argc and argv to given VALUE references according to the format string.
#define TYPE(_)
Old name of rb_type.
#define RB_INTEGER_TYPE_P
Old name of rb_integer_type_p.
#define OBJ_INIT_COPY(obj, orig)
Old name of RB_OBJ_INIT_COPY.
#define ISSPACE
Old name of rb_isspace.
#define RFLOAT_VALUE
Old name of rb_float_value.
#define T_STRING
Old name of RUBY_T_STRING.
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
#define T_NIL
Old name of RUBY_T_NIL.
#define ID2SYM
Old name of RB_ID2SYM.
#define T_BIGNUM
Old name of RUBY_T_BIGNUM.
#define T_STRUCT
Old name of RUBY_T_STRUCT.
#define T_FIXNUM
Old name of RUBY_T_FIXNUM.
#define UNREACHABLE_RETURN
Old name of RBIMPL_UNREACHABLE_RETURN.
#define CLASS_OF
Old name of rb_class_of.
#define LONG2FIX
Old name of RB_INT2FIX.
#define FIX2INT
Old name of RB_FIX2INT.
#define ISDIGIT
Old name of rb_isdigit.
#define ASSUME
Old name of RBIMPL_ASSUME.
#define T_RATIONAL
Old name of RUBY_T_RATIONAL.
#define rb_ary_new3
Old name of rb_ary_new_from_args.
#define LONG2NUM
Old name of RB_LONG2NUM.
#define STRNCASECMP
Old name of st_locale_insensitive_strncasecmp.
#define ISASCII
Old name of rb_isascii.
#define ULL2NUM
Old name of RB_ULL2NUM.
#define FIXNUM_MIN
Old name of RUBY_FIXNUM_MIN.
#define NUM2INT
Old name of RB_NUM2INT.
#define INT2NUM
Old name of RB_INT2NUM.
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define FIX2LONG
Old name of RB_FIX2LONG.
#define T_ARRAY
Old name of RUBY_T_ARRAY.
#define NIL_P
Old name of RB_NIL_P.
#define DBL2NUM
Old name of rb_float_new.
#define NUM2LONG
Old name of RB_NUM2LONG.
#define FIXNUM_P
Old name of RB_FIXNUM_P.
#define CONST_ID
Old name of RUBY_CONST_ID.
#define NUM2SIZET
Old name of RB_NUM2SIZE.
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
int rb_typeddata_is_kind_of(VALUE obj, const rb_data_type_t *data_type)
Checks if the given object is of given kind.
VALUE rb_eRangeError
RangeError exception.
VALUE rb_eTypeError
TypeError exception.
VALUE rb_eRuntimeError
RuntimeError exception.
VALUE rb_exc_new_str(VALUE etype, VALUE str)
Identical to rb_exc_new_cstr(), except it takes a Ruby's string instead of C's.
void rb_warning(const char *fmt,...)
Issues a warning.
VALUE rb_cTime
Time class.
VALUE rb_Float(VALUE val)
This is the logic behind Kernel#Float.
VALUE rb_check_to_int(VALUE val)
Identical to rb_check_to_integer(), except it uses #to_int for conversion.
VALUE rb_Integer(VALUE val)
This is the logic behind Kernel#Integer.
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
VALUE rb_equal(VALUE lhs, VALUE rhs)
This function is an optimised version of calling #==.
VALUE rb_mComparable
Comparable module.
VALUE rb_to_int(VALUE val)
Identical to rb_check_to_int(), except it raises in case of conversion mismatch.
#define RB_OBJ_WRITTEN(old, oldv, young)
Identical to RB_OBJ_WRITE(), except it doesn't write any values, but only a WB declaration.
#define RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
static bool rb_enc_str_asciicompat_p(VALUE str)
Queries if the passed string is in an ASCII-compatible encoding.
VALUE rb_funcall(VALUE recv, ID mid, int n,...)
Calls a method.
Defines RBIMPL_HAS_BUILTIN.
VALUE rb_check_array_type(VALUE obj)
Try converting an object to its array representation using its to_ary method, if any.
VALUE rb_ary_entry(VALUE ary, long off)
Queries an element of an array.
#define INTEGER_PACK_NATIVE_BYTE_ORDER
Means either INTEGER_PACK_MSBYTE_FIRST or INTEGER_PACK_LSBYTE_FIRST, depending on the host processor'...
#define INTEGER_PACK_LITTLE_ENDIAN
Little endian combination.
static int rb_check_arity(int argc, int min, int max)
Ensures that the passed integer is in the passed range.
void rb_num_zerodiv(void)
Just always raises an exception.
VALUE rb_int_positive_pow(long x, unsigned long y)
Raises the passed x to the power of y.
VALUE rb_rational_new(VALUE num, VALUE den)
Constructs a Rational, with reduction.
#define rb_Rational1(x)
Shorthand of (x/1)r.
VALUE rb_str_subseq(VALUE str, long beg, long len)
Identical to rb_str_substr(), except the numbers are interpreted as byte offsets instead of character...
#define rb_str_new(str, len)
Allocates an instance of rb_cString.
#define rb_usascii_str_new(str, len)
Identical to rb_str_new, except it generates a string of "US ASCII" encoding.
VALUE rb_str_dup(VALUE str)
Duplicates a string.
VALUE rb_str_cat(VALUE dst, const char *src, long srclen)
Destructively appends the passed contents to the string.
#define rb_usascii_str_new_cstr(str)
Identical to rb_str_new_cstr, except it generates a string of "US ASCII" encoding.
void rb_str_set_len(VALUE str, long len)
Overwrites the length of the string.
VALUE rb_str_concat(VALUE dst, VALUE src)
Identical to rb_str_append(), except it also accepts an integer as a codepoint.
#define rb_strlen_lit(str)
Length of a string literal.
VALUE rb_check_string_type(VALUE obj)
Try converting an object to its stringised representation using its to_str method,...
#define rb_str_cat_cstr(buf, str)
Identical to rb_str_cat(), except it assumes the passed pointer is a pointer to a C string.
#define rb_utf8_str_new(str, len)
Identical to rb_str_new, except it generates a string of "UTF-8" encoding.
void rb_str_modify_expand(VALUE str, long capa)
Identical to rb_str_modify(), except it additionally expands the capacity of the receiver.
#define rb_str_new_cstr(str)
Identical to rb_str_new, except it assumes the passed pointer is a pointer to a C string.
VALUE rb_obj_as_string(VALUE obj)
Try converting an object to its stringised representation using its to_s method, if any.
VALUE rb_time_nano_new(time_t sec, long nsec)
Identical to rb_time_new(), except it accepts the time in nanoseconds resolution.
void rb_timespec_now(struct timespec *ts)
Fills the current time into the given struct.
VALUE rb_time_timespec_new(const struct timespec *ts, int offset)
Creates an instance of rb_cTime, with given time and offset.
struct timespec rb_time_timespec(VALUE time)
Identical to rb_time_timeval(), except for return type.
VALUE rb_time_new(time_t sec, long usec)
Creates an instance of rb_cTime with the given time and the local timezone.
struct timeval rb_time_timeval(VALUE time)
Converts an instance of rb_cTime to a struct timeval that represents the identical point of time.
struct timeval rb_time_interval(VALUE num)
Creates a "time interval".
VALUE rb_time_num_new(VALUE timev, VALUE off)
Identical to rb_time_timespec_new(), except it takes Ruby values instead of C structs.
VALUE rb_time_utc_offset(VALUE time)
Queries the offset, in seconds between the time zone of the time and the UTC.
struct timespec rb_time_timespec_interval(VALUE num)
Identical to rb_time_interval(), except for return type.
VALUE rb_ivar_set(VALUE obj, ID name, VALUE val)
Identical to rb_iv_set(), except it accepts the name as an ID instead of a C string.
int rb_respond_to(VALUE obj, ID mid)
Queries if the object responds to the method.
void rb_alias(VALUE klass, ID dst, ID src)
Resembles alias.
VALUE rb_check_funcall(VALUE recv, ID mid, int argc, const VALUE *argv)
Identical to rb_funcallv(), except it returns RUBY_Qundef instead of raising rb_eNoMethodError.
void rb_define_alloc_func(VALUE klass, rb_alloc_func_t func)
Sets the allocator function of a class.
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
int off
Offset inside of ptr.
int len
Length of the buffer.
#define DECIMAL_SIZE_OF(expr)
An approximation of decimal representation size.
#define rb_long2int
Just another name of rb_long2int_inline.
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
void rb_define_hooked_variable(const char *q, VALUE *w, type *e, void_type *r)
Define a function-backended global variable.
VALUE rb_rescue(type *q, VALUE w, type *e, VALUE r)
An equivalent of rescue clause.
void rb_copy_generic_ivar(VALUE clone, VALUE obj)
Copies the list of instance variables.
#define RARRAY_LEN
Just another name of rb_array_len.
#define RARRAY_AREF(a, i)
#define StringValue(v)
Ensures that the parameter object is a String.
#define StringValuePtr(v)
Identical to StringValue, except it returns a char*.
VALUE rb_str_export_locale(VALUE obj)
Identical to rb_str_export(), except it converts into the locale encoding instead.
static char * RSTRING_END(VALUE str)
Queries the end of the contents pointer of the string.
#define StringValueCStr(v)
Identical to StringValuePtr, except it additionally checks for the contents for viability as a C stri...
#define RUBY_TYPED_DEFAULT_FREE
This is a value you can set to rb_data_type_struct::dfree.
#define TypedData_Get_Struct(obj, type, data_type, sval)
Obtains a C struct from inside of a wrapper Ruby object.
#define TypedData_Make_Struct(klass, type, data_type, sval)
Identical to TypedData_Wrap_Struct, except it allocates a new data region internally instead of takin...
#define RTEST
This is an old name of RB_TEST.
This is the struct that holds necessary info for a struct.
const char * wrap_struct_name
Name of structs of this kind.
intptr_t SIGNED_VALUE
A signed integer type that has the same width with VALUE.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
uintptr_t VALUE
Type that represents a Ruby object.
static bool RB_FLOAT_TYPE_P(VALUE obj)
Queries if the object is an instance of rb_cFloat.
static bool rb_integer_type_p(VALUE obj)
Queries if the object is an instance of rb_cInteger.
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.