time.rs

// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

use core::cmp::{Eq, Ord};
use core::int;
use core::i32;
use core::io::{Reader, ReaderUtil};
use core::io;
use core::prelude::*;
use core::result::{Result, Ok, Err};
use core::str;

static NSEC_PER_SEC: i32 = 1_000_000_000_i32;

pub mod rustrt {
    use super::Tm;

    #[abi = "cdecl"]
    pub extern {
        pub unsafe fn get_time(sec: &mut i64, nsec: &mut i32);

        pub unsafe fn precise_time_ns(ns: &mut u64);

        pub unsafe fn rust_tzset();
        // FIXME: The i64 values can be passed by-val when #2064 is fixed.
        pub unsafe fn rust_gmtime(sec: i64, nsec: i32, result: &mut Tm);
        pub unsafe fn rust_localtime(sec: i64, nsec: i32, result: &mut Tm);
        pub unsafe fn rust_timegm(tm: &Tm, sec: &mut i64);
        pub unsafe fn rust_mktime(tm: &Tm, sec: &mut i64);
    }
}

/// A record specifying a time value in seconds and nanoseconds.
#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct Timespec { sec: i64, nsec: i32 }

/*
 * Timespec assumes that pre-epoch Timespecs have negative sec and positive
 * nsec fields. Darwin's and Linux's struct timespec functions handle pre-
 * epoch timestamps using a "two steps back, one step forward" representation,
 * though the man pages do not actually document this. For example, the time
 * -1.2 seconds before the epoch is represented by `Timespec { sec: -2_i64,
 * nsec: 800_000_000_i32 }`.
 */
pub impl Timespec {
    fn new(sec: i64, nsec: i32) -> Timespec {
        fail_unless!(nsec >= 0 && nsec < NSEC_PER_SEC);
        Timespec { sec: sec, nsec: nsec }
    }
}

impl Ord for Timespec {
    fn lt(&self, other: &Timespec) -> bool {
        self.sec < other.sec ||
            (self.sec == other.sec && self.nsec < other.nsec)
    }
    fn le(&self, other: &Timespec) -> bool { !other.lt(self) }
    fn ge(&self, other: &Timespec) -> bool { !self.lt(other) }
    fn gt(&self, other: &Timespec) -> bool { !self.le(other) }
}

/**
 * Returns the current time as a `timespec` containing the seconds and
 * nanoseconds since 1970-01-01T00:00:00Z.
 */
pub fn get_time() -> Timespec {
    unsafe {
        let mut sec = 0i64;
        let mut nsec = 0i32;
        rustrt::get_time(&mut sec, &mut nsec);
        return Timespec::new(sec, nsec);
    }
}


/**
 * Returns the current value of a high-resolution performance counter
 * in nanoseconds since an unspecified epoch.
 */
pub fn precise_time_ns() -> u64 {
    unsafe {
        let mut ns = 0u64;
        rustrt::precise_time_ns(&mut ns);
        ns
    }
}


/**
 * Returns the current value of a high-resolution performance counter
 * in seconds since an unspecified epoch.
 */
pub fn precise_time_s() -> float {
    return (precise_time_ns() as float) / 1000000000.;
}

pub fn tzset() {
    unsafe {
        rustrt::rust_tzset();
    }
}

#[auto_encode]
#[auto_decode]
#[deriving(Eq)]
pub struct 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
}

pub fn empty_tm() -> 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,
    }
}

/// Returns the specified time in UTC
pub fn at_utc(clock: Timespec) -> Tm {
    unsafe {
        let mut Timespec { sec, nsec } = clock;
        let mut tm = empty_tm();
        rustrt::rust_gmtime(sec, nsec, &mut tm);
        tm
    }
}

/// Returns the current time in UTC
pub fn now_utc() -> Tm {
    at_utc(get_time())
}

/// Returns the specified time in the local timezone
pub fn at(clock: Timespec) -> Tm {
    unsafe {
        let mut Timespec { sec, nsec } = clock;
        let mut tm = empty_tm();
        rustrt::rust_localtime(sec, nsec, &mut tm);
        tm
    }
}

/// Returns the current time in the local timezone
pub fn now() -> Tm {
    at(get_time())
}

/// Parses the time from the string according to the format string.
pub fn strptime(s: &str, format: &str) -> Result<Tm, ~str> {
    // unsafe only because do_strptime is annoying to make pure
    // (it does IO with a str_reader)
    unsafe {do_strptime(s, format)}
}

/// Formats the time according to the format string.
pub fn strftime(format: &str, tm: &Tm) -> ~str {
    // unsafe only because do_strftime is annoying to make pure
    // (it does IO with a str_reader)
    unsafe { do_strftime(format, tm) }
}

pub impl Tm {
    /// Convert time to the seconds from January 1, 1970
    fn to_timespec(&self) -> Timespec {
        unsafe {
            let mut sec = 0i64;
            if self.tm_gmtoff == 0_i32 {
                rustrt::rust_timegm(self, &mut sec);
            } else {
                rustrt::rust_mktime(self, &mut sec);
            }
            Timespec::new(sec, self.tm_nsec)
        }
    }

    /// Convert time to the local timezone
    fn to_local(&self) -> Tm {
        at(self.to_timespec())
    }

    /// Convert time to the UTC
    fn to_utc(&self) -> Tm {
        at_utc(self.to_timespec())
    }

    /**
     * Return a string of the current time in the form
     * "Thu Jan  1 00:00:00 1970".
     */
    fn ctime(&self) -> ~str { self.strftime(~"%c") }

    /// Formats the time according to the format string.
    fn strftime(&self, format: &str) -> ~str {
        strftime(format, self)
    }

    /**
     * Returns a time string formatted according to RFC 822.
     *
     * local: "Thu, 22 Mar 2012 07:53:18 PST"
     * utc:   "Thu, 22 Mar 2012 14:53:18 UTC"
     */
    fn rfc822(&self) -> ~str {
        if self.tm_gmtoff == 0_i32 {
            self.strftime(~"%a, %d %b %Y %T GMT")
        } else {
            self.strftime(~"%a, %d %b %Y %T %Z")
        }
    }

    /**
     * Returns a time string formatted according to RFC 822 with Zulu time.
     *
     * local: "Thu, 22 Mar 2012 07:53:18 -0700"
     * utc:   "Thu, 22 Mar 2012 14:53:18 -0000"
     */
    fn rfc822z(&self) -> ~str {
        self.strftime(~"%a, %d %b %Y %T %z")
    }

    /**
     * Returns a time string formatted according to ISO 8601.
     *
     * local: "2012-02-22T07:53:18-07:00"
     * utc:   "2012-02-22T14:53:18Z"
     */
    fn rfc3339(&self) -> ~str {
        if self.tm_gmtoff == 0_i32 {
            self.strftime(~"%Y-%m-%dT%H:%M:%SZ")
        } else {
            let s = self.strftime(~"%Y-%m-%dT%H:%M:%S");
            let sign = if self.tm_gmtoff > 0_i32 { '+' } else { '-' };
            let mut m = i32::abs(self.tm_gmtoff) / 60_i32;
            let h = m / 60_i32;
            m -= h * 60_i32;
            s + fmt!("%c%02d:%02d", sign, h as int, m as int)
        }
    }
}

priv fn do_strptime(s: &str, format: &str) -> Result<Tm, ~str> {
    fn match_str(s: &str, pos: uint, needle: &str) -> bool {
        let mut i = pos;
        for str::each(needle) |ch| {
            if s[i] != ch {
                return false;
            }
            i += 1u;
        }
        return true;
    }

    fn match_strs(ss: &str, pos: uint, strs: &[(~str, i32)])
      -> Option<(i32, uint)> {
        let mut i = 0u;
        let len = strs.len();
        while i < len {
            let &(needle, value) = &strs[i];

            if match_str(ss, pos, needle) {
                return Some((value, pos + str::len(needle)));
            }
            i += 1u;
        }

        None
    }

    fn match_digits(ss: &str, pos: uint, digits: uint, ws: bool)
      -> Option<(i32, uint)> {
        let mut pos = pos;
        let mut value = 0_i32;

        let mut i = 0u;
        while i < digits {
            let range = str::char_range_at(str::from_slice(ss), pos);
            pos = range.next;

            match range.ch {
              '0' .. '9' => {
                value = value * 10_i32 + (range.ch as i32 - '0' as i32);
              }
              ' ' if ws => (),
              _ => return None
            }
            i += 1u;
        }

        Some((value, pos))
    }

    fn match_digits_in_range(ss: &str, pos: uint, digits: uint, ws: bool,
                             min: i32, max: i32) -> Option<(i32, uint)> {
        match match_digits(ss, pos, digits, ws) {
          Some((val, pos)) if val >= min && val <= max => {
            Some((val, pos))
          }
          _ => None
        }
    }

    fn parse_char(s: &str, pos: uint, c: char) -> Result<uint, ~str> {
        let range = str::char_range_at(s, pos);

        if c == range.ch {
            Ok(range.next)
        } else {
            Err(fmt!("Expected %?, found %?",
                str::from_char(c),
                str::from_char(range.ch)))
        }
    }

    fn parse_type(s: &str, pos: uint, ch: char, tm: &mut Tm)
      -> Result<uint, ~str> {
        match ch {
          'A' => match match_strs(s, pos, ~[
              (~"Sunday", 0_i32),
              (~"Monday", 1_i32),
              (~"Tuesday", 2_i32),
              (~"Wednesday", 3_i32),
              (~"Thursday", 4_i32),
              (~"Friday", 5_i32),
              (~"Saturday", 6_i32)
          ]) {
            Some(item) => { let (v, pos) = item; tm.tm_wday = v; Ok(pos) }
            None => Err(~"Invalid day")
          },
          'a' => match match_strs(s, pos, ~[
              (~"Sun", 0_i32),
              (~"Mon", 1_i32),
              (~"Tue", 2_i32),
              (~"Wed", 3_i32),
              (~"Thu", 4_i32),
              (~"Fri", 5_i32),
              (~"Sat", 6_i32)
          ]) {
            Some(item) => { let (v, pos) = item; tm.tm_wday = v; Ok(pos) }
            None => Err(~"Invalid day")
          },
          'B' => match match_strs(s, pos, ~[
              (~"January", 0_i32),
              (~"February", 1_i32),
              (~"March", 2_i32),
              (~"April", 3_i32),
              (~"May", 4_i32),
              (~"June", 5_i32),
              (~"July", 6_i32),
              (~"August", 7_i32),
              (~"September", 8_i32),
              (~"October", 9_i32),
              (~"November", 10_i32),
              (~"December", 11_i32)
          ]) {
            Some(item) => { let (v, pos) = item; tm.tm_mon = v; Ok(pos) }
            None => Err(~"Invalid month")
          },
          'b' | 'h' => match match_strs(s, pos, ~[
              (~"Jan", 0_i32),
              (~"Feb", 1_i32),
              (~"Mar", 2_i32),
              (~"Apr", 3_i32),
              (~"May", 4_i32),
              (~"Jun", 5_i32),
              (~"Jul", 6_i32),
              (~"Aug", 7_i32),
              (~"Sep", 8_i32),
              (~"Oct", 9_i32),
              (~"Nov", 10_i32),
              (~"Dec", 11_i32)
          ]) {
            Some(item) => { let (v, pos) = item; tm.tm_mon = v; Ok(pos) }
            None => Err(~"Invalid month")
          },
          'C' => match match_digits_in_range(s, pos, 2u, false, 0_i32,
                                             99_i32) {
            Some(item) => {
                let (v, pos) = item;
                  tm.tm_year += (v * 100_i32) - 1900_i32;
                  Ok(pos)
              }
            None => Err(~"Invalid year")
          },
          'c' => {
            parse_type(s, pos, 'a', &mut *tm)
                .chain(|pos| parse_char(s, pos, ' '))
                .chain(|pos| parse_type(s, pos, 'b', &mut *tm))
                .chain(|pos| parse_char(s, pos, ' '))
                .chain(|pos| parse_type(s, pos, 'e', &mut *tm))
                .chain(|pos| parse_char(s, pos, ' '))
                .chain(|pos| parse_type(s, pos, 'T', &mut *tm))
                .chain(|pos| parse_char(s, pos, ' '))
                .chain(|pos| parse_type(s, pos, 'Y', &mut *tm))
          }
          'D' | 'x' => {
            parse_type(s, pos, 'm', &mut *tm)
                .chain(|pos| parse_char(s, pos, '/'))
                .chain(|pos| parse_type(s, pos, 'd', &mut *tm))
                .chain(|pos| parse_char(s, pos, '/'))
                .chain(|pos| parse_type(s, pos, 'y', &mut *tm))
          }
          'd' => match match_digits_in_range(s, pos, 2u, false, 1_i32,
                                             31_i32) {
            Some(item) => { let (v, pos) = item; tm.tm_mday = v; Ok(pos) }
            None => Err(~"Invalid day of the month")
          },
          'e' => match match_digits_in_range(s, pos, 2u, true, 1_i32,
                                             31_i32) {
            Some(item) => { let (v, pos) = item; tm.tm_mday = v; Ok(pos) }
            None => Err(~"Invalid day of the month")
          },
          'F' => {
            parse_type(s, pos, 'Y', &mut *tm)
                .chain(|pos| parse_char(s, pos, '-'))
                .chain(|pos| parse_type(s, pos, 'm', &mut *tm))
                .chain(|pos| parse_char(s, pos, '-'))
                .chain(|pos| parse_type(s, pos, 'd', &mut *tm))
          }
          'H' => {
            match match_digits_in_range(s, pos, 2u, false, 0_i32, 23_i32) {
              Some(item) => { let (v, pos) = item; tm.tm_hour = v; Ok(pos) }
              None => Err(~"Invalid hour")
            }
          }
          'I' => {
            match match_digits_in_range(s, pos, 2u, false, 1_i32, 12_i32) {
              Some(item) => {
                  let (v, pos) = item;
                  tm.tm_hour = if v == 12_i32 { 0_i32 } else { v };
                  Ok(pos)
              }
              None => Err(~"Invalid hour")
            }
          }
          'j' => {
            match match_digits_in_range(s, pos, 3u, false, 1_i32, 366_i32) {
              Some(item) => {
                let (v, pos) = item;
                tm.tm_yday = v - 1_i32;
                Ok(pos)
              }
              None => Err(~"Invalid day of year")
            }
          }
          'k' => {
            match match_digits_in_range(s, pos, 2u, true, 0_i32, 23_i32) {
              Some(item) => { let (v, pos) = item; tm.tm_hour = v; Ok(pos) }
              None => Err(~"Invalid hour")
            }
          }
          'l' => {
            match match_digits_in_range(s, pos, 2u, true, 1_i32, 12_i32) {
              Some(item) => {
                  let (v, pos) = item;
                  tm.tm_hour = if v == 12_i32 { 0_i32 } else { v };
                  Ok(pos)
              }
              None => Err(~"Invalid hour")
            }
          }
          'M' => {
            match match_digits_in_range(s, pos, 2u, false, 0_i32, 59_i32) {
              Some(item) => { let (v, pos) = item; tm.tm_min = v; Ok(pos) }
              None => Err(~"Invalid minute")
            }
          }
          'm' => {
            match match_digits_in_range(s, pos, 2u, false, 1_i32, 12_i32) {
              Some(item) => {
                let (v, pos) = item;
                tm.tm_mon = v - 1_i32;
                Ok(pos)
              }
              None => Err(~"Invalid month")
            }
          }
          'n' => parse_char(s, pos, '\n'),
          'P' => match match_strs(s, pos,
                                  ~[(~"am", 0_i32), (~"pm", 12_i32)]) {

            Some(item) => { let (v, pos) = item; tm.tm_hour += v; Ok(pos) }
            None => Err(~"Invalid hour")
          },
          'p' => match match_strs(s, pos,
                                  ~[(~"AM", 0_i32), (~"PM", 12_i32)]) {

            Some(item) => { let (v, pos) = item; tm.tm_hour += v; Ok(pos) }
            None => Err(~"Invalid hour")
          },
          'R' => {
            parse_type(s, pos, 'H', &mut *tm)
                .chain(|pos| parse_char(s, pos, ':'))
                .chain(|pos| parse_type(s, pos, 'M', &mut *tm))
          }
          'r' => {
            parse_type(s, pos, 'I', &mut *tm)
                .chain(|pos| parse_char(s, pos, ':'))
                .chain(|pos| parse_type(s, pos, 'M', &mut *tm))
                .chain(|pos| parse_char(s, pos, ':'))
                .chain(|pos| parse_type(s, pos, 'S', &mut *tm))
                .chain(|pos| parse_char(s, pos, ' '))
                .chain(|pos| parse_type(s, pos, 'p', &mut *tm))
          }
          'S' => {
            match match_digits_in_range(s, pos, 2u, false, 0_i32, 60_i32) {
              Some(item) => {
                let (v, pos) = item;
                tm.tm_sec = v;
                Ok(pos)
              }
              None => Err(~"Invalid second")
            }
          }
          //'s' {}
          'T' | 'X' => {
            parse_type(s, pos, 'H', &mut *tm)
                .chain(|pos| parse_char(s, pos, ':'))
                .chain(|pos| parse_type(s, pos, 'M', &mut *tm))
                .chain(|pos| parse_char(s, pos, ':'))
                .chain(|pos| parse_type(s, pos, 'S', &mut *tm))
          }
          't' => parse_char(s, pos, '\t'),
          'u' => {
            match match_digits_in_range(s, pos, 1u, false, 1_i32, 7_i32) {
              Some(item) => {
                let (v, pos) = item;
                tm.tm_wday = if v == 7 { 0 } else { v };
                Ok(pos)
              }
              None => Err(~"Invalid day of week")
            }
          }
          'v' => {
            parse_type(s, pos, 'e', &mut *tm)
                .chain(|pos|  parse_char(s, pos, '-'))
                .chain(|pos| parse_type(s, pos, 'b', &mut *tm))
                .chain(|pos| parse_char(s, pos, '-'))
                .chain(|pos| parse_type(s, pos, 'Y', &mut *tm))
          }
          //'W' {}
          'w' => {
            match match_digits_in_range(s, pos, 1u, false, 0_i32, 6_i32) {
              Some(item) => { let (v, pos) = item; tm.tm_wday = v; Ok(pos) }
              None => Err(~"Invalid day of week")
            }
          }
          //'X' {}
          //'x' {}
          'Y' => {
            match match_digits(s, pos, 4u, false) {
              Some(item) => {
                let (v, pos) = item;
                tm.tm_year = v - 1900_i32;
                Ok(pos)
              }
              None => Err(~"Invalid year")
            }
          }
          'y' => {
            match match_digits_in_range(s, pos, 2u, false, 0_i32, 99_i32) {
              Some(item) => {
                let (v, pos) = item;
                tm.tm_year = v;
                Ok(pos)
              }
              None => Err(~"Invalid year")
            }
          }
          'Z' => {
            if match_str(s, pos, ~"UTC") || match_str(s, pos, ~"GMT") {
                tm.tm_gmtoff = 0_i32;
                tm.tm_zone = ~"UTC";
                Ok(pos + 3u)
            } else {
                // It's odd, but to maintain compatibility with c's
                // strptime we ignore the timezone.
                let mut pos = pos;
                let len = str::len(s);
                while pos < len {
                    let range = str::char_range_at(s, pos);
                    pos = range.next;
                    if range.ch == ' ' { break; }
                }

                Ok(pos)
            }
          }
          'z' => {
            let range = str::char_range_at(s, pos);

            if range.ch == '+' || range.ch == '-' {
                match match_digits(s, range.next, 4u, false) {
                  Some(item) => {
                    let (v, pos) = item;
                    if v == 0_i32 {
                        tm.tm_gmtoff = 0_i32;
                        tm.tm_zone = ~"UTC";
                    }

                    Ok(pos)
                  }
                  None => Err(~"Invalid zone offset")
                }
            } else {
                Err(~"Invalid zone offset")
            }
          }
          '%' => parse_char(s, pos, '%'),
          ch => {
            Err(fmt!("unknown formatting type: %?", str::from_char(ch)))
          }
        }
    }

    do io::with_str_reader(str::from_slice(format)) |rdr| {
        let mut 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,
        };
        let mut pos = 0u;
        let len = str::len(s);
        let mut result = Err(~"Invalid time");

        while !rdr.eof() && pos < len {
            let range = str::char_range_at(s, pos);
            let ch = range.ch;
            let next = range.next;

            match rdr.read_char() {
                '%' => {
                    match parse_type(s, pos, rdr.read_char(), &mut tm) {
                        Ok(next) => pos = next,
                        Err(e) => { result = Err(e); break; }
                    }
                },
                c => {
                    if c != ch { break }
                    pos = next;
                }
            }
        }

        if pos == len && rdr.eof() {
            Ok(Tm {
                tm_sec: tm.tm_sec,
                tm_min: tm.tm_min,
                tm_hour: tm.tm_hour,
                tm_mday: tm.tm_mday,
                tm_mon: tm.tm_mon,
                tm_year: tm.tm_year,
                tm_wday: tm.tm_wday,
                tm_yday: tm.tm_yday,
                tm_isdst: tm.tm_isdst,
                tm_gmtoff: tm.tm_gmtoff,
                tm_zone: copy tm.tm_zone,
                tm_nsec: tm.tm_nsec,
            })
        } else { result }
    }
}

priv fn do_strftime(format: &str, tm: &Tm) -> ~str {
    fn parse_type(ch: char, tm: &Tm) -> ~str {
        //FIXME (#2350): Implement missing types.
      let die = || fmt!("strftime: can't understand this format %c ", ch);
        match ch {
          'A' => match tm.tm_wday as int {
            0 => ~"Sunday",
            1 => ~"Monday",
            2 => ~"Tuesday",
            3 => ~"Wednesday",
            4 => ~"Thursday",
            5 => ~"Friday",
            6 => ~"Saturday",
            _ => die()
          },
         'a' => match tm.tm_wday as int {
            0 => ~"Sun",
            1 => ~"Mon",
            2 => ~"Tue",
            3 => ~"Wed",
            4 => ~"Thu",
            5 => ~"Fri",
            6 => ~"Sat",
            _ => die()
          },
          'B' => match tm.tm_mon as int {
            0 => ~"January",
            1 => ~"February",
            2 => ~"March",
            3 => ~"April",
            4 => ~"May",
            5 => ~"June",
            6 => ~"July",
            7 => ~"August",
            8 => ~"September",
            9 => ~"October",
            10 => ~"November",
            11 => ~"December",
            _ => die()
          },
          'b' | 'h' => match tm.tm_mon as int {
            0 => ~"Jan",
            1 => ~"Feb",
            2 => ~"Mar",
            3 => ~"Apr",
            4 => ~"May",
            5 => ~"Jun",
            6 => ~"Jul",
            7 => ~"Aug",
            8 => ~"Sep",
            9 => ~"Oct",
            10 => ~"Nov",
            11 => ~"Dec",
            _  => die()
          },
          'C' => fmt!("%02d", (tm.tm_year as int + 1900) / 100),
          'c' => {
            fmt!("%s %s %s %s %s",
                parse_type('a', tm),
                parse_type('b', tm),
                parse_type('e', tm),
                parse_type('T', tm),
                parse_type('Y', tm))
          }
          'D' | 'x' => {
            fmt!("%s/%s/%s",
                parse_type('m', tm),
                parse_type('d', tm),
                parse_type('y', tm))
          }
          'd' => fmt!("%02d", tm.tm_mday as int),
          'e' => fmt!("%2d", tm.tm_mday as int),
          'F' => {
            fmt!("%s-%s-%s",
                parse_type('Y', tm),
                parse_type('m', tm),
                parse_type('d', tm))
          }
          //'G' {}
          //'g' {}
          'H' => fmt!("%02d", tm.tm_hour as int),
          'I' => {
            let mut h = tm.tm_hour as int;
            if h == 0 { h = 12 }
            if h > 12 { h -= 12 }
            fmt!("%02d", h)
          }
          'j' => fmt!("%03d", tm.tm_yday as int + 1),
          'k' => fmt!("%2d", tm.tm_hour as int),
          'l' => {
            let mut h = tm.tm_hour as int;
            if h == 0 { h = 12 }
            if h > 12 { h -= 12 }
            fmt!("%2d", h)
          }
          'M' => fmt!("%02d", tm.tm_min as int),
          'm' => fmt!("%02d", tm.tm_mon as int + 1),
          'n' => ~"\n",
          'P' => if (tm.tm_hour as int) < 12 { ~"am" } else { ~"pm" },
          'p' => if (tm.tm_hour as int) < 12 { ~"AM" } else { ~"PM" },
          'R' => {
            fmt!("%s:%s",
                parse_type('H', tm),
                parse_type('M', tm))
          }
          'r' => {
            fmt!("%s:%s:%s %s",
                parse_type('I', tm),
                parse_type('M', tm),
                parse_type('S', tm),
                parse_type('p', tm))
          }
          'S' => fmt!("%02d", tm.tm_sec as int),
          's' => fmt!("%d", tm.to_timespec().sec as int),
          'T' | 'X' => {
            fmt!("%s:%s:%s",
                parse_type('H', tm),
                parse_type('M', tm),
                parse_type('S', tm))
          }
          't' => ~"\t",
          //'U' {}
          'u' => {
            let i = tm.tm_wday as int;
            int::to_str(if i == 0 { 7 } else { i })
          }
          //'V' {}
          'v' => {
            fmt!("%s-%s-%s",
                parse_type('e', tm),
                parse_type('b', tm),
                parse_type('Y', tm))
          }
          //'W' {}
          'w' => int::to_str(tm.tm_wday as int),
          //'X' {}
          //'x' {}
          'Y' => int::to_str(tm.tm_year as int + 1900),
          'y' => fmt!("%02d", (tm.tm_year as int + 1900) % 100),
          'Z' => copy tm.tm_zone,
          'z' => {
            let sign = if tm.tm_gmtoff > 0_i32 { '+' } else { '-' };
            let mut m = i32::abs(tm.tm_gmtoff) / 60_i32;
            let h = m / 60_i32;
            m -= h * 60_i32;
            fmt!("%c%02d%02d", sign, h as int, m as int)
          }
          //'+' {}
          '%' => ~"%",
          _   => die()
        }
    }

    let mut buf = ~"";

    do io::with_str_reader(str::from_slice(format)) |rdr| {
        while !rdr.eof() {
            match rdr.read_char() {
                '%' => buf += parse_type(rdr.read_char(), tm),
                ch => str::push_char(&mut buf, ch)
            }
        }
    }

    buf
}

#[cfg(test)]
mod tests {
    use time::*;

    use core::float;
    use core::os;
    use core::result;
    use core::result::{Err, Ok};
    use core::str;
    use core::vec;

    pub fn test_get_time() {
        static some_recent_date: i64 = 1325376000i64; // 2012-01-01T00:00:00Z
        static some_future_date: i64 = 1577836800i64; // 2020-01-01T00:00:00Z

        let tv1 = get_time();
        debug!("tv1=%? sec + %? nsec", tv1.sec as uint, tv1.nsec as uint);

        fail_unless!(tv1.sec > some_recent_date);
        fail_unless!(tv1.nsec < 1000000000i32);

        let tv2 = get_time();
        debug!("tv2=%? sec + %? nsec", tv2.sec as uint, tv2.nsec as uint);

        fail_unless!(tv2.sec >= tv1.sec);
        fail_unless!(tv2.sec < some_future_date);
        fail_unless!(tv2.nsec < 1000000000i32);
        if tv2.sec == tv1.sec {
            fail_unless!(tv2.nsec >= tv1.nsec);
        }
    }

    pub fn test_precise_time() {
        let s0 = precise_time_s();
        let ns1 = precise_time_ns();

        debug!("s0=%s sec", float::to_str_digits(s0, 9u));
        fail_unless!(s0 > 0.);
        let ns0 = (s0 * 1000000000.) as u64;
        debug!("ns0=%? ns", ns0);

        debug!("ns1=%? ns", ns0);
        fail_unless!(ns1 >= ns0);

        let ns2 = precise_time_ns();
        debug!("ns2=%? ns", ns0);
        fail_unless!(ns2 >= ns1);
    }

    pub fn test_at_utc() {
        os::setenv(~"TZ", ~"America/Los_Angeles");
        tzset();

        let time = ::time::Timespec::new(1234567890, 54321);
        let utc = at_utc(time);

        fail_unless!(utc.tm_sec == 30_i32);
        fail_unless!(utc.tm_min == 31_i32);
        fail_unless!(utc.tm_hour == 23_i32);
        fail_unless!(utc.tm_mday == 13_i32);
        fail_unless!(utc.tm_mon == 1_i32);
        fail_unless!(utc.tm_year == 109_i32);
        fail_unless!(utc.tm_wday == 5_i32);
        fail_unless!(utc.tm_yday == 43_i32);
        fail_unless!(utc.tm_isdst == 0_i32);
        fail_unless!(utc.tm_gmtoff == 0_i32);
        fail_unless!(utc.tm_zone == ~"UTC");
        fail_unless!(utc.tm_nsec == 54321_i32);
    }

    pub fn test_at() {
        os::setenv(~"TZ", ~"America/Los_Angeles");
        tzset();

        let time = ::time::Timespec::new(1234567890, 54321);
        let local = at(time);

        error!("time_at: %?", local);

        fail_unless!(local.tm_sec == 30_i32);
        fail_unless!(local.tm_min == 31_i32);
        fail_unless!(local.tm_hour == 15_i32);
        fail_unless!(local.tm_mday == 13_i32);
        fail_unless!(local.tm_mon == 1_i32);
        fail_unless!(local.tm_year == 109_i32);
        fail_unless!(local.tm_wday == 5_i32);
        fail_unless!(local.tm_yday == 43_i32);
        fail_unless!(local.tm_isdst == 0_i32);
        fail_unless!(local.tm_gmtoff == -28800_i32);

        // FIXME (#2350): We should probably standardize on the timezone
        // abbreviation.
        let zone = &local.tm_zone;
        fail_unless!(*zone == ~"PST" || *zone == ~"Pacific Standard Time");

        fail_unless!(local.tm_nsec == 54321_i32);
    }

    pub fn test_to_timespec() {
        os::setenv(~"TZ", ~"America/Los_Angeles");
        tzset();

        let time = ::time::Timespec::new(1234567890, 54321);
        let utc = at_utc(time);

        fail_unless!(utc.to_timespec() == time);
        fail_unless!(utc.to_local().to_timespec() == time);
    }

    pub fn test_conversions() {
        os::setenv(~"TZ", ~"America/Los_Angeles");
        tzset();

        let time = ::time::Timespec::new(1234567890, 54321);
        let utc = at_utc(time);
        let local = at(time);

        fail_unless!(local.to_local() == local);
        fail_unless!(local.to_utc() == utc);
        fail_unless!(local.to_utc().to_local() == local);
        fail_unless!(utc.to_utc() == utc);
        fail_unless!(utc.to_local() == local);
        fail_unless!(utc.to_local().to_utc() == utc);
    }

    pub fn test_strptime() {
        os::setenv(~"TZ", ~"America/Los_Angeles");
        tzset();

        match strptime(~"", ~"") {
          Ok(ref tm) => {
            fail_unless!(tm.tm_sec == 0_i32);
            fail_unless!(tm.tm_min == 0_i32);
            fail_unless!(tm.tm_hour == 0_i32);
            fail_unless!(tm.tm_mday == 0_i32);
            fail_unless!(tm.tm_mon == 0_i32);
            fail_unless!(tm.tm_year == 0_i32);
            fail_unless!(tm.tm_wday == 0_i32);
            fail_unless!(tm.tm_isdst== 0_i32);
            fail_unless!(tm.tm_gmtoff == 0_i32);
            fail_unless!(tm.tm_zone == ~"");
            fail_unless!(tm.tm_nsec == 0_i32);
          }
          Err(_) => ()
        }

        let format = ~"%a %b %e %T %Y";
        fail_unless!(strptime(~"", format) == Err(~"Invalid time"));
        fail_unless!(strptime(~"Fri Feb 13 15:31:30", format)
            == Err(~"Invalid time"));

        match strptime(~"Fri Feb 13 15:31:30 2009", format) {
          Err(copy e) => fail!(e),
          Ok(ref tm) => {
            fail_unless!(tm.tm_sec == 30_i32);
            fail_unless!(tm.tm_min == 31_i32);
            fail_unless!(tm.tm_hour == 15_i32);
            fail_unless!(tm.tm_mday == 13_i32);
            fail_unless!(tm.tm_mon == 1_i32);
            fail_unless!(tm.tm_year == 109_i32);
            fail_unless!(tm.tm_wday == 5_i32);
            fail_unless!(tm.tm_yday == 0_i32);
            fail_unless!(tm.tm_isdst == 0_i32);
            fail_unless!(tm.tm_gmtoff == 0_i32);
            fail_unless!(tm.tm_zone == ~"");
            fail_unless!(tm.tm_nsec == 0_i32);
          }
        }

        fn test(s: &str, format: &str) -> bool {
            match strptime(s, format) {
              Ok(ref tm) => tm.strftime(format) == str::from_slice(s),
              Err(copy e) => fail!(e)
            }
        }

        for vec::each([
            ~"Sunday",
            ~"Monday",
            ~"Tuesday",
            ~"Wednesday",
            ~"Thursday",
            ~"Friday",
            ~"Saturday"
        ]) |day| {
            fail_unless!(test(*day, ~"%A"));
        }

        for vec::each([
            ~"Sun",
            ~"Mon",
            ~"Tue",
            ~"Wed",
            ~"Thu",
            ~"Fri",
            ~"Sat"
        ]) |day| {
            fail_unless!(test(*day, ~"%a"));
        }

        for vec::each([
            ~"January",
            ~"February",
            ~"March",
            ~"April",
            ~"May",
            ~"June",
            ~"July",
            ~"August",
            ~"September",
            ~"October",
            ~"November",
            ~"December"
        ]) |day| {
            fail_unless!(test(*day, ~"%B"));
        }

        for vec::each([
            ~"Jan",
            ~"Feb",
            ~"Mar",
            ~"Apr",
            ~"May",
            ~"Jun",
            ~"Jul",
            ~"Aug",
            ~"Sep",
            ~"Oct",
            ~"Nov",
            ~"Dec"
        ]) |day| {
            fail_unless!(test(*day, ~"%b"));
        }

        fail_unless!(test(~"19", ~"%C"));
        fail_unless!(test(~"Fri Feb 13 23:31:30 2009", ~"%c"));
        fail_unless!(test(~"02/13/09", ~"%D"));
        fail_unless!(test(~"03", ~"%d"));
        fail_unless!(test(~"13", ~"%d"));
        fail_unless!(test(~" 3", ~"%e"));
        fail_unless!(test(~"13", ~"%e"));
        fail_unless!(test(~"2009-02-13", ~"%F"));
        fail_unless!(test(~"03", ~"%H"));
        fail_unless!(test(~"13", ~"%H"));
        fail_unless!(test(~"03", ~"%I")); // FIXME (#2350): flesh out
        fail_unless!(test(~"11", ~"%I")); // FIXME (#2350): flesh out
        fail_unless!(test(~"044", ~"%j"));
        fail_unless!(test(~" 3", ~"%k"));
        fail_unless!(test(~"13", ~"%k"));
        fail_unless!(test(~" 1", ~"%l"));
        fail_unless!(test(~"11", ~"%l"));
        fail_unless!(test(~"03", ~"%M"));
        fail_unless!(test(~"13", ~"%M"));
        fail_unless!(test(~"\n", ~"%n"));
        fail_unless!(test(~"am", ~"%P"));
        fail_unless!(test(~"pm", ~"%P"));
        fail_unless!(test(~"AM", ~"%p"));
        fail_unless!(test(~"PM", ~"%p"));
        fail_unless!(test(~"23:31", ~"%R"));
        fail_unless!(test(~"11:31:30 AM", ~"%r"));
        fail_unless!(test(~"11:31:30 PM", ~"%r"));
        fail_unless!(test(~"03", ~"%S"));
        fail_unless!(test(~"13", ~"%S"));
        fail_unless!(test(~"15:31:30", ~"%T"));
        fail_unless!(test(~"\t", ~"%t"));
        fail_unless!(test(~"1", ~"%u"));
        fail_unless!(test(~"7", ~"%u"));
        fail_unless!(test(~"13-Feb-2009", ~"%v"));
        fail_unless!(test(~"0", ~"%w"));
        fail_unless!(test(~"6", ~"%w"));
        fail_unless!(test(~"2009", ~"%Y"));
        fail_unless!(test(~"09", ~"%y"));
        fail_unless!(result::unwrap(strptime(~"UTC", ~"%Z")).tm_zone ==
            ~"UTC");
        fail_unless!(result::unwrap(strptime(~"PST", ~"%Z")).tm_zone ==
            ~"");
        fail_unless!(result::unwrap(strptime(~"-0000", ~"%z")).tm_gmtoff ==
            0);
        fail_unless!(result::unwrap(strptime(~"-0800", ~"%z")).tm_gmtoff ==
            0);
        fail_unless!(test(~"%", ~"%%"));
    }

    pub fn test_ctime() {
        os::setenv(~"TZ", ~"America/Los_Angeles");
        tzset();

        let time = ::time::Timespec::new(1234567890, 54321);
        let utc   = at_utc(time);
        let local = at(time);

        error!("test_ctime: %? %?", utc.ctime(), local.ctime());

        fail_unless!(utc.ctime()   == ~"Fri Feb 13 23:31:30 2009");
        fail_unless!(local.ctime() == ~"Fri Feb 13 15:31:30 2009");
    }

    pub fn test_strftime() {
        os::setenv(~"TZ", ~"America/Los_Angeles");
        tzset();

        let time = ::time::Timespec::new(1234567890, 54321);
        let utc = at_utc(time);
        let local = at(time);

        fail_unless!(local.strftime(~"") == ~"");
        fail_unless!(local.strftime(~"%A") == ~"Friday");
        fail_unless!(local.strftime(~"%a") == ~"Fri");
        fail_unless!(local.strftime(~"%B") == ~"February");
        fail_unless!(local.strftime(~"%b") == ~"Feb");
        fail_unless!(local.strftime(~"%C") == ~"20");
        fail_unless!(local.strftime(~"%c") == ~"Fri Feb 13 15:31:30 2009");
        fail_unless!(local.strftime(~"%D") == ~"02/13/09");
        fail_unless!(local.strftime(~"%d") == ~"13");
        fail_unless!(local.strftime(~"%e") == ~"13");
        fail_unless!(local.strftime(~"%F") == ~"2009-02-13");
        // fail_unless!(local.strftime("%G") == "2009");
        // fail_unless!(local.strftime("%g") == "09");
        fail_unless!(local.strftime(~"%H") == ~"15");
        fail_unless!(local.strftime(~"%I") == ~"03");
        fail_unless!(local.strftime(~"%j") == ~"044");
        fail_unless!(local.strftime(~"%k") == ~"15");
        fail_unless!(local.strftime(~"%l") == ~" 3");
        fail_unless!(local.strftime(~"%M") == ~"31");
        fail_unless!(local.strftime(~"%m") == ~"02");
        fail_unless!(local.strftime(~"%n") == ~"\n");
        fail_unless!(local.strftime(~"%P") == ~"pm");
        fail_unless!(local.strftime(~"%p") == ~"PM");
        fail_unless!(local.strftime(~"%R") == ~"15:31");
        fail_unless!(local.strftime(~"%r") == ~"03:31:30 PM");
        fail_unless!(local.strftime(~"%S") == ~"30");
        fail_unless!(local.strftime(~"%s") == ~"1234567890");
        fail_unless!(local.strftime(~"%T") == ~"15:31:30");
        fail_unless!(local.strftime(~"%t") == ~"\t");
        // fail_unless!(local.strftime("%U") == "06");
        fail_unless!(local.strftime(~"%u") == ~"5");
        // fail_unless!(local.strftime("%V") == "07");
        fail_unless!(local.strftime(~"%v") == ~"13-Feb-2009");
        // fail_unless!(local.strftime("%W") == "06");
        fail_unless!(local.strftime(~"%w") == ~"5");
        // handle "%X"
        // handle "%x"
        fail_unless!(local.strftime(~"%Y") == ~"2009");
        fail_unless!(local.strftime(~"%y") == ~"09");

        // FIXME (#2350): We should probably standardize on the timezone
        // abbreviation.
        let zone = local.strftime(~"%Z");
        fail_unless!(zone == ~"PST" || zone == ~"Pacific Standard Time");

        fail_unless!(local.strftime(~"%z") == ~"-0800");
        fail_unless!(local.strftime(~"%%") == ~"%");

        // FIXME (#2350): We should probably standardize on the timezone
        // abbreviation.
        let rfc822 = local.rfc822();
        let prefix = ~"Fri, 13 Feb 2009 15:31:30 ";
        fail_unless!(rfc822 == prefix + ~"PST" ||
                     rfc822 == prefix + ~"Pacific Standard Time");

        fail_unless!(local.ctime() == ~"Fri Feb 13 15:31:30 2009");
        fail_unless!(local.rfc822z() == ~"Fri, 13 Feb 2009 15:31:30 -0800");
        fail_unless!(local.rfc3339() == ~"2009-02-13T15:31:30-08:00");

        fail_unless!(utc.ctime() == ~"Fri Feb 13 23:31:30 2009");
        fail_unless!(utc.rfc822() == ~"Fri, 13 Feb 2009 23:31:30 GMT");
        fail_unless!(utc.rfc822z() == ~"Fri, 13 Feb 2009 23:31:30 -0000");
        fail_unless!(utc.rfc3339() == ~"2009-02-13T23:31:30Z");
    }

    pub fn test_timespec_eq_ord() {
        use core::cmp::{eq, ge, gt, le, lt, ne};

        let a = &Timespec::new(-2, 1);
        let b = &Timespec::new(-1, 2);
        let c = &Timespec::new(1, 2);
        let d = &Timespec::new(2, 1);
        let e = &Timespec::new(2, 1);

        fail_unless!(eq(d, e));
        fail_unless!(ne(c, e));

        fail_unless!(lt(a, b));
        fail_unless!(lt(b, c));
        fail_unless!(lt(c, d));

        fail_unless!(le(a, b));
        fail_unless!(le(b, c));
        fail_unless!(le(c, d));
        fail_unless!(le(d, e));
        fail_unless!(le(e, d));

        fail_unless!(ge(b, a));
        fail_unless!(ge(c, b));
        fail_unless!(ge(d, c));
        fail_unless!(ge(e, d));
        fail_unless!(ge(d, e));

        fail_unless!(gt(b, a));
        fail_unless!(gt(c, b));
        fail_unless!(gt(d, c));
    }

    #[test]
    pub fn run_tests() {
        // The tests race on tzset. So instead of having many independent
        // tests, we will just call the functions now.
        test_get_time();
        test_precise_time();
        test_at_utc();
        test_at();
        test_to_timespec();
        test_conversions();
        test_strptime();
        test_ctime();
        test_strftime();
        test_timespec_eq_ord();
    }
}