third-party/mruby/mrbgems/mruby-time/src/time.c

   1 /*
   2 ** time.c - Time class
   3 **
   4 ** See Copyright Notice in mruby.h
   5 */
   6
   7 #include <math.h>
   8 #include <time.h>
   9 #include <mruby.h>
  10 #include <mruby/class.h>
  11 #include <mruby/data.h>
  12 #include <mruby/time.h>
  13
  14 #ifndef MRB_DISABLE_STDIO
  15 #include <stdio.h>
  16 #else
  17 #include <string.h>
  18 #endif
  19
  20 #define NDIV(x,y) (-(-((x)+1)/(y))-1)
  21
  22 #if defined(_MSC_VER) && _MSC_VER < 1800
  23 double round(double x) {
  24   return floor(x + 0.5);
  25 }
  26 #endif
  27
  28 #if !defined(__MINGW64__) && defined(_WIN32)
  29 # define llround(x) round(x)
  30 #endif
  31
  32 #if defined(__MINGW64__) || defined(__MINGW32__)
  33 # include <sys/time.h>
  34 #endif
  35
  36 /** Time class configuration */
  37
  38 /* gettimeofday(2) */
  39 /* C99 does not have gettimeofday that is required to retrieve microseconds */
  40 /* uncomment following macro on platforms without gettimeofday(2) */
  41 /* #define NO_GETTIMEOFDAY */
  42
  43 /* gmtime(3) */
  44 /* C99 does not have reentrant gmtime_r() so it might cause troubles under */
  45 /* multi-threading environment.  undef following macro on platforms that */
  46 /* does not have gmtime_r() and localtime_r(). */
  47 /* #define NO_GMTIME_R */
  48
  49 #ifdef _WIN32
  50 #ifdef _MSC_VER
  51 /* Win32 platform do not provide gmtime_r/localtime_r; emulate them using gmtime_s/localtime_s */
  52 #define gmtime_r(tp, tm)    ((gmtime_s((tm), (tp)) == 0) ? (tm) : NULL)
  53 #define localtime_r(tp, tm)    ((localtime_s((tm), (tp)) == 0) ? (tm) : NULL)
  54 #else
  55 #define NO_GMTIME_R
  56 #endif
  57 #endif
  58
  59 /* asctime(3) */
  60 /* mruby usually use its own implementation of struct tm to string conversion */
  61 /* except when DISABLE_STDIO is set. In that case, it uses asctime() or asctime_r(). */
  62 /* By default mruby tries to use asctime_r() which is reentrant. */
  63 /* Undef following macro on platforms that does not have asctime_r(). */
  64 /* #define NO_ASCTIME_R */
  65
  66 /* timegm(3) */
  67 /* mktime() creates tm structure for localtime; timegm() is for UTC time */
  68 /* define following macro to use probably faster timegm() on the platform */
  69 /* #define USE_SYSTEM_TIMEGM */
  70
  71 /* time_t */
  72 /* If your platform supports time_t as uint (e.g. uint32_t, uint64_t), */
  73 /* uncomment following macro. */
  74 /* #define MRB_TIME_T_UINT */
  75
  76 /** end of Time class configuration */
  77
  78 #ifndef NO_GETTIMEOFDAY
  79 # ifdef _WIN32
  80 #  define WIN32_LEAN_AND_MEAN  /* don't include winsock.h */
  81 #  include <windows.h>
  82 #  define gettimeofday my_gettimeofday
  83
  84 #  ifdef _MSC_VER
  85 #    define UI64(x) x##ui64
  86 #  else
  87 #    define UI64(x) x##ull
  88 #  endif
  89
  90 typedef long suseconds_t;
  91
  92 # if (!defined __MINGW64__) && (!defined __MINGW32__)
  93 struct timeval {
  94   time_t tv_sec;
  95   suseconds_t tv_usec;
  96 };
  97 # endif
  98
  99 static int
 100 gettimeofday(struct timeval *tv, void *tz)
 101 {
 102   if (tz) {
 103     mrb_assert(0);  /* timezone is not supported */
 104   }
 105   if (tv) {
 106     union {
 107       FILETIME ft;
 108       unsigned __int64 u64;
 109     } t;
 110     GetSystemTimeAsFileTime(&t.ft);   /* 100 ns intervals since Windows epoch */
 111     t.u64 -= UI64(116444736000000000);  /* Unix epoch bias */
 112     t.u64 /= 10;                      /* to microseconds */
 113     tv->tv_sec = (time_t)(t.u64 / (1000 * 1000));
 114     tv->tv_usec = t.u64 % (1000 * 1000);
 115   }
 116   return 0;
 117 }
 118 # else
 119 #  include <sys/time.h>
 120 # endif
 121 #endif
 122 #ifdef NO_GMTIME_R
 123 #define gmtime_r(t,r) gmtime(t)
 124 #define localtime_r(t,r) localtime(t)
 125 #endif
 126
 127 #ifndef USE_SYSTEM_TIMEGM
 128 #define timegm my_timgm
 129
 130 static unsigned int
 131 is_leapyear(unsigned int y)
 132 {
 133   return (y % 4) == 0 && ((y % 100) != 0 || (y % 400) == 0);
 134 }
 135
 136 static time_t
 137 timegm(struct tm *tm)
 138 {
 139   static const unsigned int ndays[2][12] = {
 140     {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
 141     {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
 142   };
 143   time_t r = 0;
 144   int i;
 145   unsigned int *nday = (unsigned int*) ndays[is_leapyear(tm->tm_year+1900)];
 146
 147   static const int epoch_year = 70;
 148   if(tm->tm_year >= epoch_year) {
 149     for (i = epoch_year; i < tm->tm_year; ++i)
 150       r += is_leapyear(i+1900) ? 366*24*60*60 : 365*24*60*60;
 151   } else {
 152     for (i = tm->tm_year; i < epoch_year; ++i)
 153       r -= is_leapyear(i+1900) ? 366*24*60*60 : 365*24*60*60;
 154   }
 155   for (i = 0; i < tm->tm_mon; ++i)
 156     r += nday[i] * 24 * 60 * 60;
 157   r += (tm->tm_mday - 1) * 24 * 60 * 60;
 158   r += tm->tm_hour * 60 * 60;
 159   r += tm->tm_min * 60;
 160   r += tm->tm_sec;
 161   return r;
 162 }
 163 #endif
 164
 165 /* Since we are limited to using ISO C99, this implementation is based
 166 * on time_t. That means the resolution of time is only precise to the
 167 * second level. Also, there are only 2 timezones, namely UTC and LOCAL.
 168 */
 169
 170 typedef struct mrb_timezone_name {
 171   const char name[8];
 172   size_t len;
 173 } mrb_timezone_name;
 174
 175 static const mrb_timezone_name timezone_names[] = {
 176   { "none", sizeof("none") - 1 },
 177   { "UTC", sizeof("UTC") - 1 },
 178   { "LOCAL", sizeof("LOCAL") - 1 },
 179 };
 180
 181 #ifndef MRB_DISABLE_STDIO
 182 static const char mon_names[12][4] = {
 183   "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
 184 };
 185
 186 static const char wday_names[7][4] = {
 187   "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat",
 188 };
 189 #endif
 190
 191 struct mrb_time {
 192   time_t              sec;
 193   time_t              usec;
 194   enum mrb_timezone   timezone;
 195   struct tm           datetime;
 196 };
 197
 198 static const struct mrb_data_type mrb_time_type = { "Time", mrb_free };
 199
 200 /** Updates the datetime of a mrb_time based on it's timezone and
 201     seconds setting. Returns self on success, NULL of failure.
 202     if `dealloc` is set `true`, it frees `self` on error. */
 203 static struct mrb_time*
 204 time_update_datetime(mrb_state *mrb, struct mrb_time *self, int dealloc)
 205 {
 206   struct tm *aid;
 207
 208   if (self->timezone == MRB_TIMEZONE_UTC) {
 209     aid = gmtime_r(&self->sec, &self->datetime);
 210   }
 211   else {
 212     aid = localtime_r(&self->sec, &self->datetime);
 213   }
 214   if (!aid) {
 215     mrb_float sec = (mrb_float)self->sec;
 216
 217     mrb_free(mrb, self);
 218     mrb_raisef(mrb, E_ARGUMENT_ERROR, "%S out of Time range", mrb_float_value(mrb, sec));
 219     /* not reached */
 220     return NULL;
 221   }
 222 #ifdef NO_GMTIME_R
 223   self->datetime = *aid; /* copy data */
 224 #endif
 225
 226   return self;
 227 }
 228
 229 static mrb_value
 230 mrb_time_wrap(mrb_state *mrb, struct RClass *tc, struct mrb_time *tm)
 231 {
 232   return mrb_obj_value(Data_Wrap_Struct(mrb, tc, &mrb_time_type, tm));
 233 }
 234
 235 void mrb_check_num_exact(mrb_state *mrb, mrb_float num);
 236
 237 /* Allocates a mrb_time object and initializes it. */
 238 static struct mrb_time*
 239 time_alloc(mrb_state *mrb, double sec, double usec, enum mrb_timezone timezone)
 240 {
 241   struct mrb_time *tm;
 242   time_t tsec = 0;
 243
 244   mrb_check_num_exact(mrb, (mrb_float)sec);
 245   mrb_check_num_exact(mrb, (mrb_float)usec);
 246 #ifndef MRB_TIME_T_UINT
 247   if (sizeof(time_t) == 4 && (sec > (double)INT32_MAX || (double)INT32_MIN > sec)) {
 248     goto out_of_range;
 249   }
 250   if (sizeof(time_t) == 8 && (sec > (double)INT64_MAX || (double)INT64_MIN > sec)) {
 251     goto out_of_range;
 252   }
 253 #else
 254   if (sizeof(time_t) == 4 && (sec > (double)UINT32_MAX || (double)0 > sec)) {
 255     goto out_of_range;
 256   }
 257   if (sizeof(time_t) == 8 && (sec > (double)UINT64_MAX || (double)0 > sec)) {
 258     goto out_of_range;
 259   }
 260 #endif
 261   tsec  = (time_t)sec;
 262   if ((sec > 0 && tsec < 0) || (sec < 0 && (double)tsec > sec)) {
 263   out_of_range:
 264     mrb_raisef(mrb, E_ARGUMENT_ERROR, "%S out of Time range", mrb_float_value(mrb, sec));
 265   }
 266   tm = (struct mrb_time *)mrb_malloc(mrb, sizeof(struct mrb_time));
 267   tm->sec  = tsec;
 268   tm->usec = (time_t)llround((sec - tm->sec) * 1.0e6 + usec);
 269   if (tm->usec < 0) {
 270     long sec2 = (long)NDIV(tm->usec,1000000); /* negative div */
 271     tm->usec -= sec2 * 1000000;
 272     tm->sec += sec2;
 273   }
 274   else if (tm->usec >= 1000000) {
 275     long sec2 = (long)(tm->usec / 1000000);
 276     tm->usec -= sec2 * 1000000;
 277     tm->sec += sec2;
 278   }
 279   tm->timezone = timezone;
 280   time_update_datetime(mrb, tm, TRUE);
 281
 282   return tm;
 283 }
 284
 285 static mrb_value
 286 mrb_time_make(mrb_state *mrb, struct RClass *c, double sec, double usec, enum mrb_timezone timezone)
 287 {
 288   return mrb_time_wrap(mrb, c, time_alloc(mrb, sec, usec, timezone));
 289 }
 290
 291 static struct mrb_time*
 292 current_mrb_time(mrb_state *mrb)
 293 {
 294   struct mrb_time *tm;
 295
 296   tm = (struct mrb_time *)mrb_malloc(mrb, sizeof(*tm));
 297 #if defined(TIME_UTC) && !defined(__ANDROID__)
 298   {
 299     struct timespec ts;
 300     if (timespec_get(&ts, TIME_UTC) == 0) {
 301       mrb_free(mrb, tm);
 302       mrb_raise(mrb, E_RUNTIME_ERROR, "timespec_get() failed for unknown reasons");
 303     }
 304     tm->sec = ts.tv_sec;
 305     tm->usec = ts.tv_nsec / 1000;
 306   }
 307 #elif defined(NO_GETTIMEOFDAY)
 308   {
 309     static time_t last_sec = 0, last_usec = 0;
 310
 311     tm->sec  = time(NULL);
 312     if (tm->sec != last_sec) {
 313       last_sec = tm->sec;
 314       last_usec = 0;
 315     }
 316     else {
 317       /* add 1 usec to differentiate two times */
 318       last_usec += 1;
 319     }
 320     tm->usec = last_usec;
 321   }
 322 #else
 323   {
 324     struct timeval tv;
 325
 326     gettimeofday(&tv, NULL);
 327     tm->sec = tv.tv_sec;
 328     tm->usec = tv.tv_usec;
 329   }
 330 #endif
 331   tm->timezone = MRB_TIMEZONE_LOCAL;
 332   time_update_datetime(mrb, tm, TRUE);
 333
 334   return tm;
 335 }
 336
 337 /* Allocates a new Time object with given millis value. */
 338 static mrb_value
 339 mrb_time_now(mrb_state *mrb, mrb_value self)
 340 {
 341   return mrb_time_wrap(mrb, mrb_class_ptr(self), current_mrb_time(mrb));
 342 }
 343
 344 MRB_API mrb_value
 345 mrb_time_at(mrb_state *mrb, double sec, double usec, enum mrb_timezone zone)
 346 {
 347   return mrb_time_make(mrb, mrb_class_get(mrb, "Time"), sec, usec, zone);
 348 }
 349
 350 /* 15.2.19.6.1 */
 351 /* Creates an instance of time at the given time in seconds, etc. */
 352 static mrb_value
 353 mrb_time_at_m(mrb_state *mrb, mrb_value self)
 354 {
 355   mrb_float f, f2 = 0;
 356
 357   mrb_get_args(mrb, "f|f", &f, &f2);
 358   return mrb_time_make(mrb, mrb_class_ptr(self), f, f2, MRB_TIMEZONE_LOCAL);
 359 }
 360
 361 static struct mrb_time*
 362 time_mktime(mrb_state *mrb, mrb_int ayear, mrb_int amonth, mrb_int aday,
 363   mrb_int ahour, mrb_int amin, mrb_int asec, mrb_int ausec,
 364   enum mrb_timezone timezone)
 365 {
 366   time_t nowsecs;
 367   struct tm nowtime = { 0 };
 368
 369   nowtime.tm_year  = (int)ayear  - 1900;
 370   nowtime.tm_mon   = (int)amonth - 1;
 371   nowtime.tm_mday  = (int)aday;
 372   nowtime.tm_hour  = (int)ahour;
 373   nowtime.tm_min   = (int)amin;
 374   nowtime.tm_sec   = (int)asec;
 375   nowtime.tm_isdst = -1;
 376
 377   if (nowtime.tm_mon  < 0 || nowtime.tm_mon  > 11
 378       || nowtime.tm_mday < 1 || nowtime.tm_mday > 31
 379       || nowtime.tm_hour < 0 || nowtime.tm_hour > 24
 380       || (nowtime.tm_hour == 24 && (nowtime.tm_min > 0 || nowtime.tm_sec > 0))
 381       || nowtime.tm_min  < 0 || nowtime.tm_min  > 59
 382       || nowtime.tm_sec  < 0 || nowtime.tm_sec  > 60)
 383     mrb_raise(mrb, E_RUNTIME_ERROR, "argument out of range");
 384
 385   if (timezone == MRB_TIMEZONE_UTC) {
 386     nowsecs = timegm(&nowtime);
 387   }
 388   else {
 389     nowsecs = mktime(&nowtime);
 390   }
 391   if (nowsecs == (time_t)-1) {
 392     mrb_raise(mrb, E_ARGUMENT_ERROR, "Not a valid time.");
 393   }
 394
 395   return time_alloc(mrb, (double)nowsecs, (double)ausec, timezone);
 396 }
 397
 398 /* 15.2.19.6.2 */
 399 /* Creates an instance of time at the given time in UTC. */
 400 static mrb_value
 401 mrb_time_gm(mrb_state *mrb, mrb_value self)
 402 {
 403   mrb_int ayear = 0, amonth = 1, aday = 1, ahour = 0, amin = 0, asec = 0, ausec = 0;
 404
 405   mrb_get_args(mrb, "i|iiiiii",
 406                 &ayear, &amonth, &aday, &ahour, &amin, &asec, &ausec);
 407   return mrb_time_wrap(mrb, mrb_class_ptr(self),
 408           time_mktime(mrb, ayear, amonth, aday, ahour, amin, asec, ausec, MRB_TIMEZONE_UTC));
 409 }
 410
 411
 412 /* 15.2.19.6.3 */
 413 /* Creates an instance of time at the given time in local time zone. */
 414 static mrb_value
 415 mrb_time_local(mrb_state *mrb, mrb_value self)
 416 {
 417   mrb_int ayear = 0, amonth = 1, aday = 1, ahour = 0, amin = 0, asec = 0, ausec = 0;
 418
 419   mrb_get_args(mrb, "i|iiiiii",
 420                 &ayear, &amonth, &aday, &ahour, &amin, &asec, &ausec);
 421   return mrb_time_wrap(mrb, mrb_class_ptr(self),
 422           time_mktime(mrb, ayear, amonth, aday, ahour, amin, asec, ausec, MRB_TIMEZONE_LOCAL));
 423 }
 424
 425 static struct mrb_time*
 426 time_get_ptr(mrb_state *mrb, mrb_value time)
 427 {
 428   struct mrb_time *tm;
 429
 430   tm = DATA_GET_PTR(mrb, time, &mrb_time_type, struct mrb_time);
 431   if (!tm) {
 432     mrb_raise(mrb, E_ARGUMENT_ERROR, "uninitialized time");
 433   }
 434   return tm;
 435 }
 436
 437 static mrb_value
 438 mrb_time_eq(mrb_state *mrb, mrb_value self)
 439 {
 440   mrb_value other;
 441   struct mrb_time *tm1, *tm2;
 442   mrb_bool eq_p;
 443
 444   mrb_get_args(mrb, "o", &other);
 445   tm1 = DATA_GET_PTR(mrb, self, &mrb_time_type, struct mrb_time);
 446   tm2 = DATA_CHECK_GET_PTR(mrb, other, &mrb_time_type, struct mrb_time);
 447   eq_p = tm1 && tm2 && tm1->sec == tm2->sec && tm1->usec == tm2->usec;
 448
 449   return mrb_bool_value(eq_p);
 450 }
 451
 452 static mrb_value
 453 mrb_time_cmp(mrb_state *mrb, mrb_value self)
 454 {
 455   mrb_value other;
 456   struct mrb_time *tm1, *tm2;
 457
 458   mrb_get_args(mrb, "o", &other);
 459   tm1 = DATA_GET_PTR(mrb, self, &mrb_time_type, struct mrb_time);
 460   tm2 = DATA_CHECK_GET_PTR(mrb, other, &mrb_time_type, struct mrb_time);
 461   if (!tm1 || !tm2) return mrb_nil_value();
 462   if (tm1->sec > tm2->sec) {
 463     return mrb_fixnum_value(1);
 464   }
 465   else if (tm1->sec < tm2->sec) {
 466     return mrb_fixnum_value(-1);
 467   }
 468   /* tm1->sec == tm2->sec */
 469   if (tm1->usec > tm2->usec) {
 470     return mrb_fixnum_value(1);
 471   }
 472   else if (tm1->usec < tm2->usec) {
 473     return mrb_fixnum_value(-1);
 474   }
 475   return mrb_fixnum_value(0);
 476 }
 477
 478 static mrb_value
 479 mrb_time_plus(mrb_state *mrb, mrb_value self)
 480 {
 481   mrb_float f;
 482   struct mrb_time *tm;
 483
 484   mrb_get_args(mrb, "f", &f);
 485   tm = time_get_ptr(mrb, self);
 486   return mrb_time_make(mrb, mrb_obj_class(mrb, self), (double)tm->sec+f, (double)tm->usec, tm->timezone);
 487 }
 488
 489 static mrb_value
 490 mrb_time_minus(mrb_state *mrb, mrb_value self)
 491 {
 492   mrb_float f;
 493   mrb_value other;
 494   struct mrb_time *tm, *tm2;
 495
 496   mrb_get_args(mrb, "o", &other);
 497   tm = time_get_ptr(mrb, self);
 498   tm2 = DATA_CHECK_GET_PTR(mrb, other, &mrb_time_type, struct mrb_time);
 499   if (tm2) {
 500     f = (mrb_float)(tm->sec - tm2->sec)
 501       + (mrb_float)(tm->usec - tm2->usec) / 1.0e6;
 502     return mrb_float_value(mrb, f);
 503   }
 504   else {
 505     mrb_get_args(mrb, "f", &f);
 506     return mrb_time_make(mrb, mrb_obj_class(mrb, self), (double)tm->sec-f, (double)tm->usec, tm->timezone);
 507   }
 508 }
 509
 510 /* 15.2.19.7.30 */
 511 /* Returns week day number of time. */
 512 static mrb_value
 513 mrb_time_wday(mrb_state *mrb, mrb_value self)
 514 {
 515   struct mrb_time *tm;
 516
 517   tm = time_get_ptr(mrb, self);
 518   return mrb_fixnum_value(tm->datetime.tm_wday);
 519 }
 520
 521 /* 15.2.19.7.31 */
 522 /* Returns year day number of time. */
 523 static mrb_value
 524 mrb_time_yday(mrb_state *mrb, mrb_value self)
 525 {
 526   struct mrb_time *tm;
 527
 528   tm = time_get_ptr(mrb, self);
 529   return mrb_fixnum_value(tm->datetime.tm_yday + 1);
 530 }
 531
 532 /* 15.2.19.7.32 */
 533 /* Returns year of time. */
 534 static mrb_value
 535 mrb_time_year(mrb_state *mrb, mrb_value self)
 536 {
 537   struct mrb_time *tm;
 538
 539   tm = time_get_ptr(mrb, self);
 540   return mrb_fixnum_value(tm->datetime.tm_year + 1900);
 541 }
 542
 543 /* 15.2.19.7.33 */
 544 /* Returns name of time's timezone. */
 545 static mrb_value
 546 mrb_time_zone(mrb_state *mrb, mrb_value self)
 547 {
 548   struct mrb_time *tm;
 549
 550   tm = time_get_ptr(mrb, self);
 551   if (tm->timezone <= MRB_TIMEZONE_NONE) return mrb_nil_value();
 552   if (tm->timezone >= MRB_TIMEZONE_LAST) return mrb_nil_value();
 553   return mrb_str_new_static(mrb,
 554                             timezone_names[tm->timezone].name,
 555                             timezone_names[tm->timezone].len);
 556 }
 557
 558 /* 15.2.19.7.4 */
 559 /* Returns a string that describes the time. */
 560 static mrb_value
 561 mrb_time_asctime(mrb_state *mrb, mrb_value self)
 562 {
 563   struct mrb_time *tm = time_get_ptr(mrb, self);
 564   struct tm *d = &tm->datetime;
 565   int len;
 566
 567 #if defined(MRB_DISABLE_STDIO)
 568   char *s;
 569 # ifdef NO_ASCTIME_R
 570   s = asctime(d);
 571 # else
 572   char buf[32];
 573   s = asctime_r(d, buf);
 574 # endif
 575   len = strlen(s)-1;            /* truncate the last newline */
 576 #else
 577   char buf[256];
 578
 579   len = snprintf(buf, sizeof(buf), "%s %s %02d %02d:%02d:%02d %s%d",
 580     wday_names[d->tm_wday], mon_names[d->tm_mon], d->tm_mday,
 581     d->tm_hour, d->tm_min, d->tm_sec,
 582     tm->timezone == MRB_TIMEZONE_UTC ? "UTC " : "",
 583     d->tm_year + 1900);
 584 #endif
 585   return mrb_str_new(mrb, buf, len);
 586 }
 587
 588 /* 15.2.19.7.6 */
 589 /* Returns the day in the month of the time. */
 590 static mrb_value
 591 mrb_time_day(mrb_state *mrb, mrb_value self)
 592 {
 593   struct mrb_time *tm;
 594
 595   tm = time_get_ptr(mrb, self);
 596   return mrb_fixnum_value(tm->datetime.tm_mday);
 597 }
 598
 599
 600 /* 15.2.19.7.7 */
 601 /* Returns true if daylight saving was applied for this time. */
 602 static mrb_value
 603 mrb_time_dst_p(mrb_state *mrb, mrb_value self)
 604 {
 605   struct mrb_time *tm;
 606
 607   tm = time_get_ptr(mrb, self);
 608   return mrb_bool_value(tm->datetime.tm_isdst);
 609 }
 610
 611 /* 15.2.19.7.8 */
 612 /* 15.2.19.7.10 */
 613 /* Returns the Time object of the UTC(GMT) timezone. */
 614 static mrb_value
 615 mrb_time_getutc(mrb_state *mrb, mrb_value self)
 616 {
 617   struct mrb_time *tm, *tm2;
 618
 619   tm = time_get_ptr(mrb, self);
 620   tm2 = (struct mrb_time *)mrb_malloc(mrb, sizeof(*tm));
 621   *tm2 = *tm;
 622   tm2->timezone = MRB_TIMEZONE_UTC;
 623   time_update_datetime(mrb, tm2, TRUE);
 624   return mrb_time_wrap(mrb, mrb_obj_class(mrb, self), tm2);
 625 }
 626
 627 /* 15.2.19.7.9 */
 628 /* Returns the Time object of the LOCAL timezone. */
 629 static mrb_value
 630 mrb_time_getlocal(mrb_state *mrb, mrb_value self)
 631 {
 632   struct mrb_time *tm, *tm2;
 633
 634   tm = time_get_ptr(mrb, self);
 635   tm2 = (struct mrb_time *)mrb_malloc(mrb, sizeof(*tm));
 636   *tm2 = *tm;
 637   tm2->timezone = MRB_TIMEZONE_LOCAL;
 638   time_update_datetime(mrb, tm2, TRUE);
 639   return mrb_time_wrap(mrb, mrb_obj_class(mrb, self), tm2);
 640 }
 641
 642 /* 15.2.19.7.15 */
 643 /* Returns hour of time. */
 644 static mrb_value
 645 mrb_time_hour(mrb_state *mrb, mrb_value self)
 646 {
 647   struct mrb_time *tm;
 648
 649   tm = time_get_ptr(mrb, self);
 650   return mrb_fixnum_value(tm->datetime.tm_hour);
 651 }
 652
 653 /* 15.2.19.7.16 */
 654 /* Initializes a time by setting the amount of milliseconds since the epoch.*/
 655 static mrb_value
 656 mrb_time_initialize(mrb_state *mrb, mrb_value self)
 657 {
 658   mrb_int ayear = 0, amonth = 1, aday = 1, ahour = 0,
 659   amin = 0, asec = 0, ausec = 0;
 660   mrb_int n;
 661   struct mrb_time *tm;
 662
 663   n = mrb_get_args(mrb, "|iiiiiii",
 664        &ayear, &amonth, &aday, &ahour, &amin, &asec, &ausec);
 665   tm = (struct mrb_time*)DATA_PTR(self);
 666   if (tm) {
 667     mrb_free(mrb, tm);
 668   }
 669   mrb_data_init(self, NULL, &mrb_time_type);
 670
 671   if (n == 0) {
 672     tm = current_mrb_time(mrb);
 673   }
 674   else {
 675     tm = time_mktime(mrb, ayear, amonth, aday, ahour, amin, asec, ausec, MRB_TIMEZONE_LOCAL);
 676   }
 677   mrb_data_init(self, tm, &mrb_time_type);
 678   return self;
 679 }
 680
 681 /* 15.2.19.7.17(x) */
 682 /* Initializes a copy of this time object. */
 683 static mrb_value
 684 mrb_time_initialize_copy(mrb_state *mrb, mrb_value copy)
 685 {
 686   mrb_value src;
 687   struct mrb_time *t1, *t2;
 688
 689   mrb_get_args(mrb, "o", &src);
 690   if (mrb_obj_equal(mrb, copy, src)) return copy;
 691   if (!mrb_obj_is_instance_of(mrb, src, mrb_obj_class(mrb, copy))) {
 692     mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class");
 693   }
 694   t1 = (struct mrb_time *)DATA_PTR(copy);
 695   t2 = (struct mrb_time *)DATA_PTR(src);
 696   if (!t2) {
 697     mrb_raise(mrb, E_ARGUMENT_ERROR, "uninitialized time");
 698   }
 699   if (!t1) {
 700     t1 = (struct mrb_time *)mrb_malloc(mrb, sizeof(struct mrb_time));
 701     mrb_data_init(copy, t1, &mrb_time_type);
 702   }
 703   *t1 = *t2;
 704   return copy;
 705 }
 706
 707 /* 15.2.19.7.18 */
 708 /* Sets the timezone attribute of the Time object to LOCAL. */
 709 static mrb_value
 710 mrb_time_localtime(mrb_state *mrb, mrb_value self)
 711 {
 712   struct mrb_time *tm;
 713
 714   tm = time_get_ptr(mrb, self);
 715   tm->timezone = MRB_TIMEZONE_LOCAL;
 716   time_update_datetime(mrb, tm, FALSE);
 717   return self;
 718 }
 719
 720 /* 15.2.19.7.19 */
 721 /* Returns day of month of time. */
 722 static mrb_value
 723 mrb_time_mday(mrb_state *mrb, mrb_value self)
 724 {
 725   struct mrb_time *tm;
 726
 727   tm = time_get_ptr(mrb, self);
 728   return mrb_fixnum_value(tm->datetime.tm_mday);
 729 }
 730
 731 /* 15.2.19.7.20 */
 732 /* Returns minutes of time. */
 733 static mrb_value
 734 mrb_time_min(mrb_state *mrb, mrb_value self)
 735 {
 736   struct mrb_time *tm;
 737
 738   tm = time_get_ptr(mrb, self);
 739   return mrb_fixnum_value(tm->datetime.tm_min);
 740 }
 741
 742 /* 15.2.19.7.21 and 15.2.19.7.22 */
 743 /* Returns month of time. */
 744 static mrb_value
 745 mrb_time_mon(mrb_state *mrb, mrb_value self)
 746 {
 747   struct mrb_time *tm;
 748
 749   tm = time_get_ptr(mrb, self);
 750   return mrb_fixnum_value(tm->datetime.tm_mon + 1);
 751 }
 752
 753 /* 15.2.19.7.23 */
 754 /* Returns seconds in minute of time. */
 755 static mrb_value
 756 mrb_time_sec(mrb_state *mrb, mrb_value self)
 757 {
 758   struct mrb_time *tm;
 759
 760   tm = time_get_ptr(mrb, self);
 761   return mrb_fixnum_value(tm->datetime.tm_sec);
 762 }
 763
 764
 765 /* 15.2.19.7.24 */
 766 /* Returns a Float with the time since the epoch in seconds. */
 767 static mrb_value
 768 mrb_time_to_f(mrb_state *mrb, mrb_value self)
 769 {
 770   struct mrb_time *tm;
 771
 772   tm = time_get_ptr(mrb, self);
 773   return mrb_float_value(mrb, (mrb_float)tm->sec + (mrb_float)tm->usec/1.0e6);
 774 }
 775
 776 /* 15.2.19.7.25 */
 777 /* Returns a Fixnum with the time since the epoch in seconds. */
 778 static mrb_value
 779 mrb_time_to_i(mrb_state *mrb, mrb_value self)
 780 {
 781   struct mrb_time *tm;
 782
 783   tm = time_get_ptr(mrb, self);
 784   if (tm->sec > MRB_INT_MAX || tm->sec < MRB_INT_MIN) {
 785     return mrb_float_value(mrb, (mrb_float)tm->sec);
 786   }
 787   return mrb_fixnum_value((mrb_int)tm->sec);
 788 }
 789
 790 /* 15.2.19.7.26 */
 791 /* Returns a Float with the time since the epoch in microseconds. */
 792 static mrb_value
 793 mrb_time_usec(mrb_state *mrb, mrb_value self)
 794 {
 795   struct mrb_time *tm;
 796
 797   tm = time_get_ptr(mrb, self);
 798   if (tm->usec > MRB_INT_MAX || tm->usec < MRB_INT_MIN) {
 799     return mrb_float_value(mrb, (mrb_float)tm->usec);
 800   }
 801   return mrb_fixnum_value((mrb_int)tm->usec);
 802 }
 803
 804 /* 15.2.19.7.27 */
 805 /* Sets the timezone attribute of the Time object to UTC. */
 806 static mrb_value
 807 mrb_time_utc(mrb_state *mrb, mrb_value self)
 808 {
 809   struct mrb_time *tm;
 810
 811   tm = time_get_ptr(mrb, self);
 812   tm->timezone = MRB_TIMEZONE_UTC;
 813   time_update_datetime(mrb, tm, FALSE);
 814   return self;
 815 }
 816
 817 /* 15.2.19.7.28 */
 818 /* Returns true if this time is in the UTC timezone false if not. */
 819 static mrb_value
 820 mrb_time_utc_p(mrb_state *mrb, mrb_value self)
 821 {
 822   struct mrb_time *tm;
 823
 824   tm = time_get_ptr(mrb, self);
 825   return mrb_bool_value(tm->timezone == MRB_TIMEZONE_UTC);
 826 }
 827
 828
 829 void
 830 mrb_mruby_time_gem_init(mrb_state* mrb)
 831 {
 832   struct RClass *tc;
 833   /* ISO 15.2.19.2 */
 834   tc = mrb_define_class(mrb, "Time", mrb->object_class);
 835   MRB_SET_INSTANCE_TT(tc, MRB_TT_DATA);
 836   mrb_include_module(mrb, tc, mrb_module_get(mrb, "Comparable"));
 837   mrb_define_class_method(mrb, tc, "at", mrb_time_at_m, MRB_ARGS_ARG(1, 1));      /* 15.2.19.6.1 */
 838   mrb_define_class_method(mrb, tc, "gm", mrb_time_gm, MRB_ARGS_ARG(1,6));       /* 15.2.19.6.2 */
 839   mrb_define_class_method(mrb, tc, "local", mrb_time_local, MRB_ARGS_ARG(1,6)); /* 15.2.19.6.3 */
 840   mrb_define_class_method(mrb, tc, "mktime", mrb_time_local, MRB_ARGS_ARG(1,6));/* 15.2.19.6.4 */
 841   mrb_define_class_method(mrb, tc, "now", mrb_time_now, MRB_ARGS_NONE());       /* 15.2.19.6.5 */
 842   mrb_define_class_method(mrb, tc, "utc", mrb_time_gm, MRB_ARGS_ARG(1,6));      /* 15.2.19.6.6 */
 843
 844   mrb_define_method(mrb, tc, "=="     , mrb_time_eq     , MRB_ARGS_REQ(1));
 845   mrb_define_method(mrb, tc, "<=>"    , mrb_time_cmp    , MRB_ARGS_REQ(1)); /* 15.2.19.7.1 */
 846   mrb_define_method(mrb, tc, "+"      , mrb_time_plus   , MRB_ARGS_REQ(1)); /* 15.2.19.7.2 */
 847   mrb_define_method(mrb, tc, "-"      , mrb_time_minus  , MRB_ARGS_REQ(1)); /* 15.2.19.7.3 */
 848   mrb_define_method(mrb, tc, "to_s"   , mrb_time_asctime, MRB_ARGS_NONE());
 849   mrb_define_method(mrb, tc, "inspect", mrb_time_asctime, MRB_ARGS_NONE());
 850   mrb_define_method(mrb, tc, "asctime", mrb_time_asctime, MRB_ARGS_NONE()); /* 15.2.19.7.4 */
 851   mrb_define_method(mrb, tc, "ctime"  , mrb_time_asctime, MRB_ARGS_NONE()); /* 15.2.19.7.5 */
 852   mrb_define_method(mrb, tc, "day"    , mrb_time_day    , MRB_ARGS_NONE()); /* 15.2.19.7.6 */
 853   mrb_define_method(mrb, tc, "dst?"   , mrb_time_dst_p  , MRB_ARGS_NONE()); /* 15.2.19.7.7 */
 854   mrb_define_method(mrb, tc, "getgm"  , mrb_time_getutc , MRB_ARGS_NONE()); /* 15.2.19.7.8 */
 855   mrb_define_method(mrb, tc, "getlocal",mrb_time_getlocal,MRB_ARGS_NONE()); /* 15.2.19.7.9 */
 856   mrb_define_method(mrb, tc, "getutc" , mrb_time_getutc , MRB_ARGS_NONE()); /* 15.2.19.7.10 */
 857   mrb_define_method(mrb, tc, "gmt?"   , mrb_time_utc_p  , MRB_ARGS_NONE()); /* 15.2.19.7.11 */
 858   mrb_define_method(mrb, tc, "gmtime" , mrb_time_utc    , MRB_ARGS_NONE()); /* 15.2.19.7.13 */
 859   mrb_define_method(mrb, tc, "hour"   , mrb_time_hour, MRB_ARGS_NONE());    /* 15.2.19.7.15 */
 860   mrb_define_method(mrb, tc, "localtime", mrb_time_localtime, MRB_ARGS_NONE()); /* 15.2.19.7.18 */
 861   mrb_define_method(mrb, tc, "mday"   , mrb_time_mday, MRB_ARGS_NONE());    /* 15.2.19.7.19 */
 862   mrb_define_method(mrb, tc, "min"    , mrb_time_min, MRB_ARGS_NONE());     /* 15.2.19.7.20 */
 863
 864   mrb_define_method(mrb, tc, "mon"  , mrb_time_mon, MRB_ARGS_NONE());       /* 15.2.19.7.21 */
 865   mrb_define_method(mrb, tc, "month", mrb_time_mon, MRB_ARGS_NONE());       /* 15.2.19.7.22 */
 866
 867   mrb_define_method(mrb, tc, "sec" , mrb_time_sec, MRB_ARGS_NONE());        /* 15.2.19.7.23 */
 868   mrb_define_method(mrb, tc, "to_i", mrb_time_to_i, MRB_ARGS_NONE());       /* 15.2.19.7.25 */
 869   mrb_define_method(mrb, tc, "to_f", mrb_time_to_f, MRB_ARGS_NONE());       /* 15.2.19.7.24 */
 870   mrb_define_method(mrb, tc, "usec", mrb_time_usec, MRB_ARGS_NONE());       /* 15.2.19.7.26 */
 871   mrb_define_method(mrb, tc, "utc" , mrb_time_utc, MRB_ARGS_NONE());        /* 15.2.19.7.27 */
 872   mrb_define_method(mrb, tc, "utc?", mrb_time_utc_p,MRB_ARGS_NONE());       /* 15.2.19.7.28 */
 873   mrb_define_method(mrb, tc, "wday", mrb_time_wday, MRB_ARGS_NONE());       /* 15.2.19.7.30 */
 874   mrb_define_method(mrb, tc, "yday", mrb_time_yday, MRB_ARGS_NONE());       /* 15.2.19.7.31 */
 875   mrb_define_method(mrb, tc, "year", mrb_time_year, MRB_ARGS_NONE());       /* 15.2.19.7.32 */
 876   mrb_define_method(mrb, tc, "zone", mrb_time_zone, MRB_ARGS_NONE());       /* 15.2.19.7.33 */
 877
 878   mrb_define_method(mrb, tc, "initialize", mrb_time_initialize, MRB_ARGS_REQ(1)); /* 15.2.19.7.16 */
 879   mrb_define_method(mrb, tc, "initialize_copy", mrb_time_initialize_copy, MRB_ARGS_REQ(1)); /* 15.2.19.7.17 */
 880
 881   /*
 882     methods not available:
 883       gmt_offset(15.2.19.7.12)
 884       gmtoff(15.2.19.7.14)
 885       utc_offset(15.2.19.7.29)
 886   */
 887 }
 888
 889 void
 890 mrb_mruby_time_gem_final(mrb_state* mrb)
 891 {
 892 }