爱特每羊队
519 lines
19 KiB
Rust
519 lines
19 KiB
Rust
use chrono::{DateTime, Datelike, NaiveDate, NaiveDateTime, Timelike, Utc};
|
|
|
|
use oxide_kernel::shape_forge::EMPTY_SHAPE_ID;
|
|
use oxide_types::object::JsObject;
|
|
use oxide_types::value::JsValue;
|
|
|
|
use crate::coercion;
|
|
use crate::native::NativeResult;
|
|
use crate::vm::Vm;
|
|
|
|
fn get_timestamp(obj: &JsObject) -> f64 {
|
|
let v = obj.get_prop_at(0);
|
|
if v.is_double() { v.as_double() } else { f64::NAN }
|
|
}
|
|
|
|
fn set_timestamp(obj: &mut JsObject, ms: f64) {
|
|
obj.set_prop_at(0, JsValue::float(ms));
|
|
}
|
|
|
|
fn ensure_date(vm: &mut Vm, obj: &JsObject) -> Result<(), JsValue> {
|
|
if !obj.is_date_obj() {
|
|
return Err(crate::builtins::error::create_type_error(vm, "called on incompatible receiver"));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
macro_rules! native_try {
|
|
($expr:expr) => {
|
|
match $expr {
|
|
Ok(value) => value,
|
|
Err(err) => return NativeResult::Err(err),
|
|
}
|
|
};
|
|
}
|
|
|
|
fn date_this_mut(vm: &mut Vm, args: &[u8]) -> Result<*mut JsObject, JsValue> {
|
|
let raw = vm.reg(if args.is_empty() { 0 } else { args[0] });
|
|
if !raw.is_object() {
|
|
return Err(crate::builtins::error::create_type_error(vm, "called on incompatible receiver"));
|
|
}
|
|
let obj_ptr = raw.as_js_object_ptr();
|
|
if obj_ptr.is_null() {
|
|
return Err(crate::builtins::error::create_type_error(vm, "called on incompatible receiver"));
|
|
}
|
|
let obj = unsafe { &*obj_ptr };
|
|
ensure_date(vm, obj)?;
|
|
Ok(obj_ptr)
|
|
}
|
|
|
|
fn date_this(vm: &mut Vm, args: &[u8]) -> Result<*const JsObject, JsValue> {
|
|
let raw = vm.reg(if args.is_empty() { 0 } else { args[0] });
|
|
if !raw.is_object() {
|
|
return Err(crate::builtins::error::create_type_error(vm, "called on incompatible receiver"));
|
|
}
|
|
let obj_ptr = raw.as_js_object_ptr();
|
|
if obj_ptr.is_null() {
|
|
return Err(crate::builtins::error::create_type_error(vm, "called on incompatible receiver"));
|
|
}
|
|
let obj = unsafe { &*obj_ptr };
|
|
ensure_date(vm, obj)?;
|
|
Ok(obj_ptr)
|
|
}
|
|
|
|
fn dt_from_ms(ms: f64) -> Option<DateTime<Utc>> {
|
|
if !ms.is_finite() {
|
|
return None;
|
|
}
|
|
DateTime::from_timestamp_millis(ms as i64)
|
|
}
|
|
|
|
fn naive_from_ms(ms: f64) -> Option<NaiveDateTime> {
|
|
if !ms.is_finite() {
|
|
return None;
|
|
}
|
|
dt_from_ms(ms).map(|dt| dt.naive_utc())
|
|
}
|
|
|
|
pub fn date_constructor(vm: &mut Vm, args: &[u8]) -> NativeResult {
|
|
let this_val = vm.reg(if args.is_empty() { 0 } else { args[0] });
|
|
let is_ctor_call = this_val.is_object() && {
|
|
let ptr = this_val.as_js_object_ptr();
|
|
if ptr.is_null() {
|
|
false
|
|
} else {
|
|
let date_proto = vm.kernel().builtin_world().date_proto.as_ptr() as *mut JsObject;
|
|
if date_proto.is_null() {
|
|
false
|
|
} else {
|
|
let obj = unsafe { &*ptr };
|
|
let proto_ptr = obj.proto().as_js_object_ptr();
|
|
if proto_ptr.is_null() {
|
|
false
|
|
} else {
|
|
std::ptr::eq(proto_ptr, date_proto)
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
let timestamp = if args.len() < 2 {
|
|
Utc::now().timestamp_millis() as f64
|
|
} else if args.len() > 2 {
|
|
let y = coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref()) as i32;
|
|
let m = coercion::to_number(vm.reg(args[2]), vm.kernel().string_forge().as_ref()) as u32;
|
|
let d = if args.len() > 3 {
|
|
coercion::to_number(vm.reg(args[3]), vm.kernel().string_forge().as_ref()) as u32
|
|
} else {
|
|
1
|
|
};
|
|
let h = if args.len() > 4 {
|
|
coercion::to_number(vm.reg(args[4]), vm.kernel().string_forge().as_ref()) as u32
|
|
} else {
|
|
0
|
|
};
|
|
let min = if args.len() > 5 {
|
|
coercion::to_number(vm.reg(args[5]), vm.kernel().string_forge().as_ref()) as u32
|
|
} else {
|
|
0
|
|
};
|
|
let sec = if args.len() > 6 {
|
|
coercion::to_number(vm.reg(args[6]), vm.kernel().string_forge().as_ref()) as u32
|
|
} else {
|
|
0
|
|
};
|
|
let ms = if args.len() > 7 {
|
|
coercion::to_number(vm.reg(args[7]), vm.kernel().string_forge().as_ref()) as u32
|
|
} else {
|
|
0
|
|
};
|
|
NaiveDate::from_ymd_opt(y, m + 1, d)
|
|
.and_then(|nd| {
|
|
nd.and_hms_milli_opt(h, min, sec, ms)
|
|
.and_then(|ndt| ndt.and_local_timezone(Utc).earliest())
|
|
})
|
|
.map(|dt| dt.timestamp_millis() as f64)
|
|
.unwrap_or(f64::NAN)
|
|
} else {
|
|
let val = vm.reg(args[1]);
|
|
if val.is_string() {
|
|
let s = vm.kernel().string_forge().lookup(val.as_string_index()).unwrap_or_default();
|
|
let formats = ["%Y-%m-%dT%H:%M:%S%.fZ", "%Y-%m-%dT%H:%M:%S%.f"];
|
|
let mut ts = f64::NAN;
|
|
for fmt in &formats {
|
|
if let Ok(ndt) = NaiveDateTime::parse_from_str(&s, fmt) {
|
|
ts = ndt.and_utc().timestamp_millis() as f64;
|
|
break;
|
|
}
|
|
}
|
|
if ts.is_nan() {
|
|
if let Ok(nd) = NaiveDate::parse_from_str(&s, "%Y-%m-%d") {
|
|
if let Some(ndt) = nd.and_hms_opt(0, 0, 0).and_then(|n| n.and_local_timezone(Utc).earliest()) {
|
|
ts = ndt.timestamp_millis() as f64;
|
|
}
|
|
}
|
|
}
|
|
ts
|
|
} else if val.is_int() || val.is_double() {
|
|
if val.is_int() {
|
|
val.as_int() as f64
|
|
} else {
|
|
val.as_double()
|
|
}
|
|
} else if val.is_object() && {
|
|
let ptr = val.as_js_object_ptr();
|
|
if ptr.is_null() {
|
|
false
|
|
} else {
|
|
unsafe { &*ptr }.is_date_obj()
|
|
}
|
|
} {
|
|
let obj = unsafe { &*val.as_js_object_ptr() };
|
|
get_timestamp(obj)
|
|
} else {
|
|
f64::NAN
|
|
}
|
|
};
|
|
|
|
if !is_ctor_call {
|
|
let s = if timestamp.is_finite() {
|
|
dt_from_ms(timestamp)
|
|
.map(|dt| dt.to_rfc2822())
|
|
.unwrap_or_else(|| "Invalid Date".to_string())
|
|
} else {
|
|
"Invalid Date".to_string()
|
|
};
|
|
return NativeResult::Ok(vm.intern(&s));
|
|
}
|
|
|
|
let mut obj = JsObject::new_empty(
|
|
EMPTY_SHAPE_ID,
|
|
JsValue::from_js_object(vm.kernel().builtin_world().date_proto.as_ptr() as *mut JsObject),
|
|
);
|
|
obj.type_tag = JsObject::OBJ_TYPE_DATE;
|
|
obj.set_prop_at(0, JsValue::float(timestamp));
|
|
|
|
let ptr = vm.epoch().alloc(obj);
|
|
NativeResult::Ok(JsValue::from_js_object(ptr))
|
|
}
|
|
|
|
pub fn date_now(_vm: &mut Vm, _args: &[u8]) -> NativeResult {
|
|
NativeResult::Ok(JsValue::float(Utc::now().timestamp_millis() as f64))
|
|
}
|
|
|
|
pub fn date_parse(vm: &mut Vm, args: &[u8]) -> NativeResult {
|
|
if args.len() < 2 {
|
|
return NativeResult::Ok(JsValue::float(f64::NAN));
|
|
}
|
|
let val = vm.reg(args[1]);
|
|
if !val.is_string() {
|
|
return NativeResult::Ok(JsValue::float(f64::NAN));
|
|
}
|
|
let s = vm.kernel().string_forge().lookup(val.as_string_index()).unwrap_or_default();
|
|
let formats = ["%Y-%m-%dT%H:%M:%S%.fZ", "%Y-%m-%dT%H:%M:%S%.f"];
|
|
let mut ts = f64::NAN;
|
|
for fmt in &formats {
|
|
if let Ok(ndt) = NaiveDateTime::parse_from_str(&s, fmt) {
|
|
ts = ndt.and_utc().timestamp_millis() as f64;
|
|
break;
|
|
}
|
|
}
|
|
if ts.is_nan() {
|
|
if let Ok(nd) = NaiveDate::parse_from_str(&s, "%Y-%m-%d") {
|
|
if let Some(ndt) = nd.and_hms_opt(0, 0, 0).and_then(|n| n.and_local_timezone(Utc).earliest()) {
|
|
ts = ndt.timestamp_millis() as f64;
|
|
}
|
|
}
|
|
}
|
|
NativeResult::Ok(JsValue::float(ts))
|
|
}
|
|
|
|
pub fn date_utc(_vm: &mut Vm, _args: &[u8]) -> NativeResult {
|
|
NativeResult::Ok(JsValue::float(f64::NAN))
|
|
}
|
|
|
|
macro_rules! make_getter {
|
|
($name:ident, $f:expr, $df:expr) => {
|
|
pub fn $name(vm: &mut Vm, args: &[u8]) -> NativeResult {
|
|
let obj = unsafe { &*native_try!(date_this(vm, args)) };
|
|
let ms = get_timestamp(obj);
|
|
if !ms.is_finite() {
|
|
return NativeResult::Ok(JsValue::float($df));
|
|
}
|
|
match dt_from_ms(ms) {
|
|
Some(dt) => NativeResult::Ok(JsValue::float(($f)(dt))),
|
|
None => NativeResult::Ok(JsValue::float($df)),
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
macro_rules! make_utc_getter {
|
|
($name:ident, $f:expr, $df:expr) => {
|
|
pub fn $name(vm: &mut Vm, args: &[u8]) -> NativeResult {
|
|
let obj = unsafe { &*native_try!(date_this(vm, args)) };
|
|
let ms = get_timestamp(obj);
|
|
if !ms.is_finite() {
|
|
return NativeResult::Ok(JsValue::float($df));
|
|
}
|
|
match naive_from_ms(ms) {
|
|
Some(ndt) => NativeResult::Ok(JsValue::float(($f)(ndt))),
|
|
None => NativeResult::Ok(JsValue::float($df)),
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
make_getter!(date_get_time, |dt: DateTime<Utc>| dt.timestamp_millis() as f64, f64::NAN);
|
|
make_getter!(date_get_full_year, |dt: DateTime<Utc>| dt.year() as f64, f64::NAN);
|
|
make_getter!(date_get_month, |dt: DateTime<Utc>| dt.month0() as f64, f64::NAN);
|
|
make_getter!(date_get_date, |dt: DateTime<Utc>| dt.day() as f64, f64::NAN);
|
|
make_getter!(date_get_day, |dt: DateTime<Utc>| dt.weekday().num_days_from_sunday() as f64, f64::NAN);
|
|
make_getter!(date_get_hours, |dt: DateTime<Utc>| dt.hour() as f64, f64::NAN);
|
|
make_getter!(date_get_minutes, |dt: DateTime<Utc>| dt.minute() as f64, f64::NAN);
|
|
make_getter!(date_get_seconds, |dt: DateTime<Utc>| dt.second() as f64, f64::NAN);
|
|
make_getter!(date_get_milliseconds, |dt: DateTime<Utc>| dt.timestamp_subsec_millis() as f64, f64::NAN);
|
|
|
|
make_utc_getter!(date_get_utc_full_year, |ndt: NaiveDateTime| ndt.date().year() as f64, f64::NAN);
|
|
make_utc_getter!(date_get_utc_month, |ndt: NaiveDateTime| ndt.date().month0() as f64, f64::NAN);
|
|
make_utc_getter!(date_get_utc_date, |ndt: NaiveDateTime| ndt.date().day() as f64, f64::NAN);
|
|
make_utc_getter!(
|
|
date_get_utc_day,
|
|
|ndt: NaiveDateTime| ndt.date().weekday().num_days_from_sunday() as f64,
|
|
f64::NAN
|
|
);
|
|
make_utc_getter!(date_get_utc_hours, |ndt: NaiveDateTime| ndt.time().hour() as f64, f64::NAN);
|
|
make_utc_getter!(date_get_utc_minutes, |ndt: NaiveDateTime| ndt.time().minute() as f64, f64::NAN);
|
|
make_utc_getter!(date_get_utc_seconds, |ndt: NaiveDateTime| ndt.time().second() as f64, f64::NAN);
|
|
make_utc_getter!(
|
|
date_get_utc_milliseconds,
|
|
|ndt: NaiveDateTime| ndt.time().nanosecond() as f64 / 1_000_000.0,
|
|
f64::NAN
|
|
);
|
|
|
|
pub fn date_get_timezone_offset(vm: &mut Vm, args: &[u8]) -> NativeResult {
|
|
let _obj = unsafe { &*native_try!(date_this(vm, args)) };
|
|
let offset_min = local_offset_minutes();
|
|
NativeResult::Ok(JsValue::float(offset_min as f64))
|
|
}
|
|
|
|
fn local_offset_minutes() -> i32 {
|
|
chrono::Local::now().offset().local_minus_utc() / 60
|
|
}
|
|
|
|
fn get_opt_arg(vm: &Vm, args: &[u8], idx: usize, default: u32) -> u32 {
|
|
if args.len() > idx {
|
|
coercion::to_number(vm.reg(args[idx]), vm.kernel().string_forge().as_ref()) as u32
|
|
} else {
|
|
default
|
|
}
|
|
}
|
|
|
|
pub fn date_set_time(vm: &mut Vm, args: &[u8]) -> NativeResult {
|
|
let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) };
|
|
let val = if args.len() > 1 {
|
|
coercion::to_number(vm.reg(args[1]), vm.kernel().string_forge().as_ref())
|
|
} else {
|
|
f64::NAN
|
|
};
|
|
set_timestamp(obj, val);
|
|
NativeResult::Ok(JsValue::float(val))
|
|
}
|
|
|
|
pub fn date_set_full_year(vm: &mut Vm, args: &[u8]) -> NativeResult {
|
|
let val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
|
|
let v = coercion::to_number(val, vm.kernel().string_forge().as_ref());
|
|
let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) };
|
|
let ms = get_timestamp(obj);
|
|
if !ms.is_finite() {
|
|
return NativeResult::Ok(JsValue::float(f64::NAN));
|
|
}
|
|
let dt = match dt_from_ms(ms) {
|
|
Some(d) => d,
|
|
None => return NativeResult::Ok(JsValue::float(f64::NAN)),
|
|
};
|
|
let m = get_opt_arg(vm, args, 2, dt.month0());
|
|
let d = get_opt_arg(vm, args, 3, dt.day0());
|
|
let nd = dt
|
|
.with_year(v as i32)
|
|
.and_then(|x| x.with_month0(m))
|
|
.and_then(|x| x.with_day0(d))
|
|
.unwrap_or(dt);
|
|
let ts = nd.timestamp_millis() as f64;
|
|
set_timestamp(obj, ts);
|
|
NativeResult::Ok(JsValue::float(ts))
|
|
}
|
|
pub fn date_set_month(vm: &mut Vm, args: &[u8]) -> NativeResult {
|
|
let val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
|
|
let v = coercion::to_number(val, vm.kernel().string_forge().as_ref());
|
|
let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) };
|
|
let ms = get_timestamp(obj);
|
|
if !ms.is_finite() {
|
|
return NativeResult::Ok(JsValue::float(f64::NAN));
|
|
}
|
|
let dt = match dt_from_ms(ms) {
|
|
Some(d) => d,
|
|
None => return NativeResult::Ok(JsValue::float(f64::NAN)),
|
|
};
|
|
let d = get_opt_arg(vm, args, 2, dt.day0());
|
|
let nd = dt.with_month0(v as u32).and_then(|x| x.with_day0(d)).unwrap_or(dt);
|
|
let ts = nd.timestamp_millis() as f64;
|
|
set_timestamp(obj, ts);
|
|
NativeResult::Ok(JsValue::float(ts))
|
|
}
|
|
pub fn date_set_date(vm: &mut Vm, args: &[u8]) -> NativeResult {
|
|
let val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
|
|
let v = coercion::to_number(val, vm.kernel().string_forge().as_ref());
|
|
let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) };
|
|
let ms = get_timestamp(obj);
|
|
if !ms.is_finite() {
|
|
return NativeResult::Ok(JsValue::float(f64::NAN));
|
|
}
|
|
let dt = match dt_from_ms(ms) {
|
|
Some(d) => d,
|
|
None => return NativeResult::Ok(JsValue::float(f64::NAN)),
|
|
};
|
|
let nd = dt.with_day0(v as u32).unwrap_or(dt);
|
|
let ts = nd.timestamp_millis() as f64;
|
|
set_timestamp(obj, ts);
|
|
NativeResult::Ok(JsValue::float(ts))
|
|
}
|
|
pub fn date_set_hours(vm: &mut Vm, args: &[u8]) -> NativeResult {
|
|
let val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
|
|
let v = coercion::to_number(val, vm.kernel().string_forge().as_ref());
|
|
let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) };
|
|
let ms = get_timestamp(obj);
|
|
if !ms.is_finite() {
|
|
return NativeResult::Ok(JsValue::float(f64::NAN));
|
|
}
|
|
let dt = match dt_from_ms(ms) {
|
|
Some(d) => d,
|
|
None => return NativeResult::Ok(JsValue::float(f64::NAN)),
|
|
};
|
|
let min = get_opt_arg(vm, args, 2, dt.minute());
|
|
let sec = get_opt_arg(vm, args, 3, dt.second());
|
|
let ms_arg = get_opt_arg(vm, args, 4, dt.timestamp_subsec_millis());
|
|
let nd = dt
|
|
.with_hour(v as u32)
|
|
.and_then(|x| x.with_minute(min))
|
|
.and_then(|x| x.with_second(sec))
|
|
.and_then(|x| x.with_nanosecond(ms_arg * 1_000_000))
|
|
.unwrap_or(dt);
|
|
let ts = nd.timestamp_millis() as f64;
|
|
set_timestamp(obj, ts);
|
|
NativeResult::Ok(JsValue::float(ts))
|
|
}
|
|
pub fn date_set_minutes(vm: &mut Vm, args: &[u8]) -> NativeResult {
|
|
let val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
|
|
let v = coercion::to_number(val, vm.kernel().string_forge().as_ref());
|
|
let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) };
|
|
let ms = get_timestamp(obj);
|
|
if !ms.is_finite() {
|
|
return NativeResult::Ok(JsValue::float(f64::NAN));
|
|
}
|
|
let dt = match dt_from_ms(ms) {
|
|
Some(d) => d,
|
|
None => return NativeResult::Ok(JsValue::float(f64::NAN)),
|
|
};
|
|
let sec = get_opt_arg(vm, args, 2, dt.second());
|
|
let ms_arg = get_opt_arg(vm, args, 3, dt.timestamp_subsec_millis());
|
|
let nd = dt
|
|
.with_minute(v as u32)
|
|
.and_then(|x| x.with_second(sec))
|
|
.and_then(|x| x.with_nanosecond(ms_arg * 1_000_000))
|
|
.unwrap_or(dt);
|
|
let ts = nd.timestamp_millis() as f64;
|
|
set_timestamp(obj, ts);
|
|
NativeResult::Ok(JsValue::float(ts))
|
|
}
|
|
pub fn date_set_seconds(vm: &mut Vm, args: &[u8]) -> NativeResult {
|
|
let val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
|
|
let v = coercion::to_number(val, vm.kernel().string_forge().as_ref());
|
|
let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) };
|
|
let ms = get_timestamp(obj);
|
|
if !ms.is_finite() {
|
|
return NativeResult::Ok(JsValue::float(f64::NAN));
|
|
}
|
|
let dt = match dt_from_ms(ms) {
|
|
Some(d) => d,
|
|
None => return NativeResult::Ok(JsValue::float(f64::NAN)),
|
|
};
|
|
let ms_arg = get_opt_arg(vm, args, 2, dt.timestamp_subsec_millis());
|
|
let nd = dt
|
|
.with_second(v as u32)
|
|
.and_then(|x| x.with_nanosecond(ms_arg * 1_000_000))
|
|
.unwrap_or(dt);
|
|
let ts = nd.timestamp_millis() as f64;
|
|
set_timestamp(obj, ts);
|
|
NativeResult::Ok(JsValue::float(ts))
|
|
}
|
|
pub fn date_set_milliseconds(vm: &mut Vm, args: &[u8]) -> NativeResult {
|
|
let val = if args.len() > 1 { vm.reg(args[1]) } else { JsValue::undefined() };
|
|
let v = coercion::to_number(val, vm.kernel().string_forge().as_ref());
|
|
let obj = unsafe { &mut *native_try!(date_this_mut(vm, args)) };
|
|
let ms = get_timestamp(obj);
|
|
if !ms.is_finite() {
|
|
return NativeResult::Ok(JsValue::float(f64::NAN));
|
|
}
|
|
let dt = match dt_from_ms(ms) {
|
|
Some(d) => d,
|
|
None => return NativeResult::Ok(JsValue::float(f64::NAN)),
|
|
};
|
|
let nd = dt.with_nanosecond(v as u32 * 1_000_000).unwrap_or(dt);
|
|
let ts = nd.timestamp_millis() as f64;
|
|
set_timestamp(obj, ts);
|
|
NativeResult::Ok(JsValue::float(ts))
|
|
}
|
|
|
|
fn date_to_string_inner(vm: &mut Vm, args: &[u8], format_str: &str, invalid: &str) -> NativeResult {
|
|
let obj = unsafe { &*native_try!(date_this(vm, args)) };
|
|
let ms = get_timestamp(obj);
|
|
if !ms.is_finite() {
|
|
return NativeResult::Ok(vm.intern(invalid));
|
|
}
|
|
let s = match dt_from_ms(ms) {
|
|
Some(dt) => dt.format(format_str).to_string(),
|
|
None => invalid.to_string(),
|
|
};
|
|
NativeResult::Ok(vm.intern(&s))
|
|
}
|
|
|
|
pub fn date_to_iso_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
|
|
date_to_string_inner(vm, args, "%Y-%m-%dT%H:%M:%S%.3fZ", "Invalid Date")
|
|
}
|
|
|
|
pub fn date_to_json(vm: &mut Vm, args: &[u8]) -> NativeResult {
|
|
let obj = unsafe { &*native_try!(date_this(vm, args)) };
|
|
let ms = get_timestamp(obj);
|
|
if !ms.is_finite() {
|
|
return NativeResult::Ok(JsValue::null());
|
|
}
|
|
let s = match dt_from_ms(ms) {
|
|
Some(dt) => dt.format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string(),
|
|
None => return NativeResult::Ok(JsValue::null()),
|
|
};
|
|
NativeResult::Ok(vm.intern(&s))
|
|
}
|
|
|
|
pub fn date_to_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
|
|
date_to_string_inner(vm, args, "%a %b %d %Y %H:%M:%S %Z %z", "Invalid Date")
|
|
}
|
|
|
|
pub fn date_to_date_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
|
|
date_to_string_inner(vm, args, "%a %b %d %Y", "Invalid Date")
|
|
}
|
|
|
|
pub fn date_to_time_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
|
|
date_to_string_inner(vm, args, "%H:%M:%S %Z", "Invalid Date")
|
|
}
|
|
|
|
pub fn date_to_utc_string(vm: &mut Vm, args: &[u8]) -> NativeResult {
|
|
date_to_string_inner(vm, args, "%a, %d %b %Y %H:%M:%S GMT", "Invalid Date")
|
|
}
|
|
|
|
pub fn date_value_of(vm: &mut Vm, args: &[u8]) -> NativeResult {
|
|
let obj = unsafe { &*native_try!(date_this(vm, args)) };
|
|
let ms = get_timestamp(obj);
|
|
NativeResult::Ok(JsValue::float(ms))
|
|
}
|