std: add localtime/gmtime support.

Author: erickt

Diff for: src/libstd/time.rs

@@ -1,7 +1,29 @@
+import libc::{c_char, c_int, c_long, size_t, time_t};
+import io::{reader, reader_util};
+import result::{result, ok, err, extensions};
+
+export
+    timespec,
+    get_time,
+    precise_time_ns,
+    precise_time_s,
+    tm,
+    empty_tm,
+    now,
+    at,
+    now_utc,
+    at_utc;
+
 #[abi = "cdecl"]
 native mod rustrt {
     fn get_time(&sec: i64, &nsec: i32);
     fn precise_time_ns(&ns: u64);
+
+    // FIXME: The i64 values can be passed by-val when #2064 is fixed.
+    fn rust_gmtime(&&sec: i64, &&nsec: i32, &&result: tm);
+    fn rust_localtime(&&sec: i64, &&nsec: i32, &result: tm);
+    fn rust_timegm(&&tm: tm, &sec: i64);
+    fn rust_mktime(&&tm: tm, &sec: i64);
 }
 
 #[doc = "A record specifying a time value in seconds and microseconds."]
@@ -36,6 +58,87 @@ fn precise_time_s() -> float {
     ret (precise_time_ns() as float) / 1000000000.;
 }
 
+type tm = {
+    tm_sec: i32, // seconds after the minute [0-60]
+    tm_min: i32, // minutes after the hour [0-59]
+    tm_hour: i32, // hours after midnight [0-23]
+    tm_mday: i32, // days of the month [1-31]
+    tm_mon: i32, // months since January [0-11]
+    tm_year: i32, // years since 1900
+    tm_wday: i32, // days since Sunday [0-6]
+    tm_yday: i32, // days since January 1 [0-365]
+    tm_isdst: i32, // Daylight Savings Time flag
+    tm_gmtoff: i32, // offset from UTC in seconds
+    tm_zone: str, // timezone abbreviation
+    tm_nsec: i32, // nanoseconds
+};
+
+fn empty_tm() -> tm {
+    {
+        tm_sec: 0_i32,
+        tm_min: 0_i32,
+        tm_hour: 0_i32,
+        tm_mday: 0_i32,
+        tm_mon: 0_i32,
+        tm_year: 0_i32,
+        tm_wday: 0_i32,
+        tm_yday: 0_i32,
+        tm_isdst: 0_i32,
+        tm_gmtoff: 0_i32,
+        tm_zone: "",
+        tm_nsec: 0_i32,
+    }
+}
+
+#[doc = "Returns the specified time in UTC"]
+fn at_utc(clock: timespec) -> tm {
+    let mut {sec, nsec} = clock;
+    let mut tm = empty_tm();
+    rustrt::rust_gmtime(sec, nsec, tm);
+    tm
+}
+
+#[doc = "Returns the current time in UTC"]
+fn now_utc() -> tm {
+    at_utc(get_time())
+}
+
+#[doc = "Returns the specified time in the local timezone"]
+fn at(clock: timespec) -> tm {
+    let mut {sec, nsec} = clock;
+    let mut tm = empty_tm();
+    rustrt::rust_localtime(sec, nsec, tm);
+    tm
+}
+
+#[doc = "Returns the current time in the local timezone"]
+fn now() -> tm {
+    at(get_time())
+}
+
+impl tm for tm {
+    #[doc = "Convert time to the seconds from January 1, 1970"]
+    fn to_timespec() -> timespec {
+        let mut sec = 0i64;
+        if self.tm_gmtoff == 0_i32 {
+            rustrt::rust_timegm(self, sec);
+        } else {
+            rustrt::rust_mktime(self, sec);
+        }
+        { sec: sec, nsec: self.tm_nsec }
+    }
+
+    #[doc = "Convert time to the local timezone"]
+    fn to_local() -> tm {
+        at(self.to_timespec())
+    }
+
+    #[doc = "Convert time to the UTC"]
+    fn to_utc() -> tm {
+        at_utc(self.to_timespec())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     import task;
@@ -81,4 +184,78 @@ mod tests {
         log(debug, "ns2=" + u64::str(ns2) + " ns");
         assert ns2 >= ns1;
     }
+
+    #[test]
+    fn test_at_utc() {
+        os::setenv("TZ", "America/Los_Angeles");
+
+        let time = { sec: 1234567890_i64, nsec: 54321_i32 };
+        let utc = at_utc(time);
+
+        assert utc.tm_sec == 30_i32;
+        assert utc.tm_min == 31_i32;
+        assert utc.tm_hour == 23_i32;
+        assert utc.tm_mday == 13_i32;
+        assert utc.tm_mon == 1_i32;
+        assert utc.tm_year == 109_i32;
+        assert utc.tm_wday == 5_i32;
+        assert utc.tm_yday == 43_i32;
+        assert utc.tm_isdst == 0_i32;
+        assert utc.tm_gmtoff == 0_i32;
+        assert utc.tm_zone == "UTC";
+        assert utc.tm_nsec == 54321_i32;
+    }
+
+    #[test]
+    fn test_at() {
+        os::setenv("TZ", "America/Los_Angeles");
+
+        let time = { sec: 1234567890_i64, nsec: 54321_i32 };
+        let local = at(time);
+
+        assert local.tm_sec == 30_i32;
+        assert local.tm_min == 31_i32;
+        assert local.tm_hour == 15_i32;
+        assert local.tm_mday == 13_i32;
+        assert local.tm_mon == 1_i32;
+        assert local.tm_year == 109_i32;
+        assert local.tm_wday == 5_i32;
+        assert local.tm_yday == 43_i32;
+        assert local.tm_isdst == 0_i32;
+        assert local.tm_gmtoff == -28800_i32;
+
+        // FIXME: We should probably standardize on the timezone
+        // abbreviation.
+        let zone = local.tm_zone;
+        assert zone == "PST" || zone == "Pacific Standard Time";
+
+        assert local.tm_nsec == 54321_i32;
+    }
+
+    #[test]
+    fn test_to_timespec() {
+        os::setenv("TZ", "America/Los_Angeles");
+
+        let time = { sec: 1234567890_i64, nsec: 54321_i32 };
+        let utc = at_utc(time);
+
+        assert utc.to_timespec() == time;
+        assert utc.to_local().to_timespec() == time;
+    }
+
+    #[test]
+    fn test_conversions() {
+        os::setenv("TZ", "America/Los_Angeles");
+
+        let time = { sec: 1234567890_i64, nsec: 54321_i32 };
+        let utc = at_utc(time);
+        let local = at(time);
+
+        assert local.to_local() == local;
+        assert local.to_utc() == utc;
+        assert local.to_utc().to_local() == local;
+        assert utc.to_utc() == utc;
+        assert utc.to_local() == local;
+        assert utc.to_local().to_utc() == utc;
+    }
 }

Diff for: src/rt/rust_builtin.cpp

@@ -8,6 +8,8 @@
 #include "rust_abi.h"
 #include "rust_port.h"
 
+#include <time.h>
+
 #ifdef __APPLE__
 #include <crt_externs.h>
 #endif
@@ -448,6 +450,127 @@ precise_time_ns(uint64_t *ns) {
     *ns = t.time_ns();
 }
 
+struct rust_tm {
+    int32_t tm_sec;
+    int32_t tm_min;
+    int32_t tm_hour;
+    int32_t tm_mday;
+    int32_t tm_mon;
+    int32_t tm_year;
+    int32_t tm_wday;
+    int32_t tm_yday;
+    int32_t tm_isdst;
+    int32_t tm_gmtoff;
+    rust_str *tm_zone;
+    int32_t tm_nsec;
+};
+
+void rust_tm_to_tm(rust_tm* in_tm, tm* out_tm) {
+    memset(out_tm, 0, sizeof(tm));
+    out_tm->tm_sec = in_tm->tm_sec;
+    out_tm->tm_min = in_tm->tm_min;
+    out_tm->tm_hour = in_tm->tm_hour;
+    out_tm->tm_mday = in_tm->tm_mday;
+    out_tm->tm_mon = in_tm->tm_mon;
+    out_tm->tm_year = in_tm->tm_year;
+    out_tm->tm_wday = in_tm->tm_wday;
+    out_tm->tm_yday = in_tm->tm_yday;
+    out_tm->tm_isdst = in_tm->tm_isdst;
+}
+
+void tm_to_rust_tm(tm* in_tm, rust_tm* out_tm, int32_t gmtoff,
+                   const char *zone, int32_t nsec) {
+    out_tm->tm_sec = in_tm->tm_sec;
+    out_tm->tm_min = in_tm->tm_min;
+    out_tm->tm_hour = in_tm->tm_hour;
+    out_tm->tm_mday = in_tm->tm_mday;
+    out_tm->tm_mon = in_tm->tm_mon;
+    out_tm->tm_year = in_tm->tm_year;
+    out_tm->tm_wday = in_tm->tm_wday;
+    out_tm->tm_yday = in_tm->tm_yday;
+    out_tm->tm_isdst = in_tm->tm_isdst;
+    out_tm->tm_gmtoff = gmtoff;
+    out_tm->tm_nsec = nsec;
+
+    if (zone != NULL) {
+        size_t size = strlen(zone);
+        str_reserve_shared(&out_tm->tm_zone, size);
+        memcpy(out_tm->tm_zone->data, zone, size);
+        out_tm->tm_zone->fill = size + 1;
+        out_tm->tm_zone->data[size] = '\0';
+    }
+}
+
+#if defined(__WIN32__)
+#define TZSET() _tzset()
+#if defined(_MSC_VER) && (_MSC_VER >= 1400)
+#define GMTIME(clock, result) gmtime_s((result), (clock))
+#define LOCALTIME(clock, result) localtime_s((result), (clock))
+#define TIMEGM(result) _mkgmtime64(result)
+#else
+struct tm* GMTIME(const time_t *clock, tm *result) {
+    struct tm* t = gmtime(clock);
+    if (t == NULL || result == NULL) { return NULL; }
+    *result = *t;
+    return result;
+}
+struct tm* LOCALTIME(const time_t *clock, tm *result) {
+    struct tm* t = localtime(clock);
+    if (t == NULL || result == NULL) { return NULL; }
+    *result = *t;
+    return result;
+}
+#define TIMEGM(result) mktime((result)) - _timezone
+#endif
+#else
+#define TZSET() tzset()
+#define GMTIME(clock, result) gmtime_r((clock), (result))
+#define LOCALTIME(clock, result) localtime_r((clock), (result))
+#define TIMEGM(result) timegm(result)
+#endif
+
+extern "C" CDECL void
+rust_gmtime(int64_t *sec, int32_t *nsec, rust_tm *timeptr) {
+    tm tm;
+    time_t s = *sec;
+    GMTIME(&s, &tm);
+
+    tm_to_rust_tm(&tm, timeptr, 0, "UTC", *nsec);
+}
+
+extern "C" CDECL void
+rust_localtime(int64_t *sec, int32_t *nsec, rust_tm *timeptr) {
+    tm tm;
+    TZSET();
+    time_t s = *sec;
+    LOCALTIME(&s, &tm);
+
+#if defined(__WIN32__)
+    int32_t gmtoff = -timezone;
+    char zone[64];
+    strftime(zone, sizeof(zone), "%Z", &tm);
+#else
+    int32_t gmtoff = tm.tm_gmtoff;
+    const char *zone = tm.tm_zone;
+#endif
+
+    tm_to_rust_tm(&tm, timeptr, gmtoff, zone, *nsec);
+}
+
+extern "C" CDECL void
+rust_timegm(rust_tm* timeptr, int64_t *out) {
+    tm t;
+    rust_tm_to_tm(timeptr, &t);
+    *out = TIMEGM(&t);
+}
+
+extern "C" CDECL void
+rust_mktime(rust_tm* timeptr, int64_t *out) {
+    tm t;
+    rust_tm_to_tm(timeptr, &t);
+    *out = mktime(&t);
+}
+
 extern "C" CDECL rust_sched_id
 rust_get_sched_id() {
     rust_task *task = rust_get_current_task();

Diff for: src/rt/rustrt.def.in

@@ -12,6 +12,10 @@ debug_abi_2
 get_port_id
 get_task_id
 get_time
+rust_gmtime
+rust_localtime
+rust_timegm
+rust_mktime
 last_os_error
 new_port
 new_task