use crate::host::with_host;
use crate::stdlib::common::*;
use chrono::{DateTime, Datelike, Duration, NaiveDate, TimeZone, Timelike, Utc};
use fusevm::Value;
use std::cell::RefCell;
thread_local! {
static TZ: RefCell<String> = RefCell::new("UTC".to_string());
}
pub fn dispatch(name: &str, args: &[Value]) -> Option<Result<Value, String>> {
let v = match name {
"time" => Value::int(Utc::now().timestamp()),
"mktime" | "gmmktime" => php_mktime(args),
"date" => php_date(args, false),
"gmdate" => php_date(args, true),
"checkdate" => php_checkdate(args),
"microtime" => php_microtime(args),
"strtotime" => php_strtotime(args),
"getdate" => php_getdate(args),
"date_default_timezone_set" => {
let tz = str_arg(args, 0);
TZ.with(|t| *t.borrow_mut() = tz);
Value::bool(true)
}
"date_default_timezone_get" => Value::str(TZ.with(|t| t.borrow().clone())),
_ => return None,
};
Some(Ok(v))
}
const DAYS: [&str; 7] = [
"Sunday",
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday",
];
const MONTHS: [&str; 13] = [
"",
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December",
];
fn from_ts(ts: i64) -> DateTime<Utc> {
DateTime::from_timestamp(ts, 0).unwrap_or_else(|| DateTime::from_timestamp(0, 0).unwrap())
}
fn now_ts() -> i64 {
Utc::now().timestamp()
}
fn php_date(args: &[Value], gm: bool) -> Value {
let fmt = str_arg(args, 0);
let ts = if args.len() >= 2 {
int_arg(args, 1)
} else {
now_ts()
};
Value::str(format_php(&fmt, from_ts(ts), gm))
}
fn format_php(fmt: &str, dt: DateTime<Utc>, gm: bool) -> String {
let mut out = String::with_capacity(fmt.len() * 2);
let mut chars = fmt.chars();
let dow_sun = dt.weekday().num_days_from_sunday() as usize; let dow_iso = dt.weekday().number_from_monday(); let day = dt.day();
let month = dt.month();
let hour24 = dt.hour();
let hour12 = match hour24 % 12 {
0 => 12,
h => h,
};
while let Some(c) = chars.next() {
match c {
'\\' => {
if let Some(n) = chars.next() {
out.push(n);
}
}
'd' => out.push_str(&format!("{day:02}")),
'j' => out.push_str(&day.to_string()),
'D' => out.push_str(&DAYS[dow_sun][..3]),
'l' => out.push_str(DAYS[dow_sun]),
'N' => out.push_str(&dow_iso.to_string()),
'w' => out.push_str(&dow_sun.to_string()),
'S' => out.push_str(ordinal_suffix(day)),
'z' => out.push_str(&dt.ordinal0().to_string()),
'W' => out.push_str(&format!("{:02}", dt.iso_week().week())),
'F' => out.push_str(MONTHS[month as usize]),
'M' => out.push_str(&MONTHS[month as usize][..3]),
'm' => out.push_str(&format!("{month:02}")),
'n' => out.push_str(&month.to_string()),
't' => out.push_str(&days_in_month(dt.year(), month).to_string()),
'L' => out.push_str(if is_leap(dt.year()) { "1" } else { "0" }),
'Y' => out.push_str(&dt.year().to_string()),
'y' => out.push_str(&format!("{:02}", dt.year().rem_euclid(100))),
'a' => out.push_str(if hour24 < 12 { "am" } else { "pm" }),
'A' => out.push_str(if hour24 < 12 { "AM" } else { "PM" }),
'g' => out.push_str(&hour12.to_string()),
'G' => out.push_str(&hour24.to_string()),
'h' => out.push_str(&format!("{hour12:02}")),
'H' => out.push_str(&format!("{hour24:02}")),
'i' => out.push_str(&format!("{:02}", dt.minute())),
's' => out.push_str(&format!("{:02}", dt.second())),
'U' => out.push_str(&dt.timestamp().to_string()),
'o' => out.push_str(&dt.iso_week().year().to_string()),
'u' => out.push_str(&format!("{:06}", dt.timestamp_subsec_micros())),
'v' => out.push_str(&format!("{:03}", dt.timestamp_subsec_millis())),
'c' => out.push_str(&format!(
"{:04}-{month:02}-{day:02}T{hour24:02}:{:02}:{:02}+00:00",
dt.year(),
dt.minute(),
dt.second()
)),
'r' => out.push_str(&format!(
"{}, {day:02} {} {} {hour24:02}:{:02}:{:02} +0000",
&DAYS[dow_sun][..3],
&MONTHS[month as usize][..3],
dt.year(),
dt.minute(),
dt.second()
)),
'e' => out.push_str("UTC"),
'T' => out.push_str(if gm { "GMT" } else { "UTC" }),
'I' => out.push('0'),
'Z' => out.push('0'),
'O' => out.push_str("+0000"),
'P' => out.push_str("+00:00"),
'p' => out.push('Z'),
'X' => out.push_str(&expanded_year(dt.year(), true)),
'x' => out.push_str(&expanded_year(dt.year(), false)),
'B' => {
let secs = (dt.timestamp() + 3600).rem_euclid(86_400);
out.push_str(&format!("{:03}", secs * 1000 / 86_400));
}
other => out.push(other),
}
}
out
}
fn expanded_year(year: i32, always_sign: bool) -> String {
let sign = if year < 0 {
"-"
} else if always_sign || year > 9999 {
"+"
} else {
""
};
format!("{sign}{:04}", year.abs())
}
fn ordinal_suffix(day: u32) -> &'static str {
match (day % 10, day % 100) {
(1, 11) | (2, 12) | (3, 13) => "th",
(1, _) => "st",
(2, _) => "nd",
(3, _) => "rd",
_ => "th",
}
}
fn is_leap(year: i32) -> bool {
(year % 4 == 0 && year % 100 != 0) || year % 400 == 0
}
fn days_in_month(year: i32, month: u32) -> u32 {
match month {
1 | 3 | 5 | 7 | 8 | 10 | 12 => 31,
4 | 6 | 9 | 11 => 30,
2 if is_leap(year) => 29,
2 => 28,
_ => 30,
}
}
fn php_mktime(args: &[Value]) -> Value {
let now = Utc::now();
let comp = |i: usize, default: i64| -> i64 {
if args.len() > i {
int_arg(args, i)
} else {
default
}
};
let hour = comp(0, now.hour() as i64);
let minute = comp(1, now.minute() as i64);
let second = comp(2, now.second() as i64);
let month = comp(3, now.month() as i64);
let day = comp(4, now.day() as i64);
let year = normalize_year(comp(5, now.year() as i64));
let Some(months_total) = year
.checked_mul(12)
.and_then(|x| month.checked_sub(1).and_then(|mm| x.checked_add(mm)))
else {
return Value::bool(false);
};
let y = months_total.div_euclid(12);
let m = (months_total.rem_euclid(12) + 1) as u32;
let Ok(y) = i32::try_from(y) else {
return Value::bool(false);
};
let Some(base) = NaiveDate::from_ymd_opt(y, m, 1).and_then(|d| d.and_hms_opt(0, 0, 0)) else {
return Value::bool(false);
};
let (Some(dd), Some(dh), Some(dmin), Some(ds)) = (
day.checked_sub(1).and_then(Duration::try_days),
Duration::try_hours(hour),
Duration::try_minutes(minute),
Duration::try_seconds(second),
) else {
return Value::bool(false);
};
let Some(delta) = dd
.checked_add(&dh)
.and_then(|x| x.checked_add(&dmin))
.and_then(|x| x.checked_add(&ds))
else {
return Value::bool(false);
};
let Some(dt) = base.checked_add_signed(delta) else {
return Value::bool(false);
};
Value::int(Utc.from_utc_datetime(&dt).timestamp())
}
fn normalize_year(year: i64) -> i64 {
match year {
0..=69 => year + 2000,
70..=100 => year + 1900,
_ => year,
}
}
fn php_checkdate(args: &[Value]) -> Value {
let month = int_arg(args, 0);
let day = int_arg(args, 1);
let year = int_arg(args, 2);
let ok = (1..=12).contains(&month)
&& (1..=32767).contains(&year)
&& day >= 1
&& day <= days_in_month(year as i32, month as u32) as i64;
Value::bool(ok)
}
fn php_microtime(args: &[Value]) -> Value {
let now = Utc::now();
let secs = now.timestamp();
let frac = now.timestamp_subsec_micros() as f64 / 1_000_000.0;
let as_float = with_host(|h| h.is_truthy(&arg(args, 0)));
if as_float {
Value::float(secs as f64 + frac)
} else {
Value::str(format!("{frac:.8} {secs}"))
}
}
fn php_strtotime(args: &[Value]) -> Value {
let input = str_arg(args, 0).trim().to_string();
let base = if args.len() >= 2 {
int_arg(args, 1)
} else {
now_ts()
};
match parse_strtotime(&input, base) {
Some(ts) => Value::int(ts),
None => Value::bool(false),
}
}
fn parse_strtotime(input: &str, base: i64) -> Option<i64> {
if input.is_empty() {
return None;
}
let low = input.to_ascii_lowercase();
match low.as_str() {
"now" => return Some(base),
"today" | "midnight" => return Some(start_of_day(base)),
"yesterday" => return Some(start_of_day(base) - 86_400),
"tomorrow" => return Some(start_of_day(base) + 86_400),
_ => {}
}
if let Some(rest) = input.strip_prefix('@') {
return rest.trim().parse::<i64>().ok();
}
let (input, offset) = match split_timezone(input) {
Some(split) => split,
None => (input, 0),
};
if let Ok(dt) = chrono::NaiveDateTime::parse_from_str(input, "%Y-%m-%d %H:%M:%S") {
return Some(Utc.from_utc_datetime(&dt).timestamp() - offset);
}
if let Some(dt) = NaiveDate::parse_from_str(input, "%Y-%m-%d")
.ok()
.and_then(|d| d.and_hms_opt(0, 0, 0))
{
return Some(Utc.from_utc_datetime(&dt).timestamp() - offset);
}
parse_relative(&low, base)
}
fn split_timezone(s: &str) -> Option<(&str, i64)> {
if let Some(head) = s.strip_suffix(['Z', 'z']) {
if !head.is_empty() {
return Some((head.trim_end(), 0));
}
}
let (head, tail) = s.rsplit_once(char::is_whitespace)?;
let head = head.trim_end();
if head.is_empty() {
return None;
}
if tail.eq_ignore_ascii_case("utc")
|| tail.eq_ignore_ascii_case("gmt")
|| tail.eq_ignore_ascii_case("ut")
|| tail.eq_ignore_ascii_case("z")
{
return Some((head, 0));
}
let sign = match tail.as_bytes().first()? {
b'+' => 1,
b'-' => -1,
_ => return None,
};
let digits: String = tail[1..].chars().filter(|c| *c != ':').collect();
if !digits.bytes().all(|b| b.is_ascii_digit()) {
return None;
}
let (h, m) = match digits.len() {
2 => (digits.parse::<i64>().ok()?, 0),
4 => (digits[..2].parse().ok()?, digits[2..].parse().ok()?),
_ => return None,
};
(h < 24 && m < 60).then_some((head, sign * (h * 3600 + m * 60)))
}
fn start_of_day(ts: i64) -> i64 {
let d = from_ts(ts).date_naive().and_hms_opt(0, 0, 0).unwrap();
Utc.from_utc_datetime(&d).timestamp()
}
fn parse_relative(low: &str, base: i64) -> Option<i64> {
let re = regex::Regex::new(
r"([+-]?\d+)\s*(sec(?:ond)?|min(?:ute)?|hour|day|week|month|year)s?(\s+ago)?",
)
.ok()?;
let mut dt = from_ts(base);
let mut matched_end = 0usize;
let mut any = false;
for cap in re.captures_iter(low) {
let whole = cap.get(0).unwrap();
let gap = low[matched_end..whole.start()].trim();
if !gap.is_empty() {
return None;
}
matched_end = whole.end();
any = true;
let mut n: i64 = cap[1].parse().ok()?;
if cap.get(3).is_some() {
n = -n; }
dt = apply_unit(dt, &cap[2], n)?;
}
if !any || !low[matched_end..].trim().is_empty() {
return None;
}
Some(dt.timestamp())
}
fn apply_unit(dt: DateTime<Utc>, unit: &str, n: i64) -> Option<DateTime<Utc>> {
let dur = match unit {
"sec" | "second" => Duration::try_seconds(n)?,
"min" | "minute" => Duration::try_minutes(n)?,
"hour" => Duration::try_hours(n)?,
"day" => Duration::try_days(n)?,
"week" => Duration::try_weeks(n)?,
"month" => return add_months_overflow(dt, n),
"year" => return add_months_overflow(dt, n.checked_mul(12)?),
_ => return None,
};
dt.checked_add_signed(dur)
}
fn add_months_overflow(dt: DateTime<Utc>, months: i64) -> Option<DateTime<Utc>> {
let total = (dt.year() as i64)
.checked_mul(12)?
.checked_add(dt.month0() as i64)?
.checked_add(months)?;
let ny = i32::try_from(total.div_euclid(12)).ok()?;
let nm = (total.rem_euclid(12) + 1) as u32;
let day_off = Duration::try_days(dt.day() as i64 - 1)?;
let first = NaiveDate::from_ymd_opt(ny, nm, 1)?.and_time(dt.time());
let shifted = first.checked_add_signed(day_off)?;
Some(Utc.from_utc_datetime(&shifted))
}
fn php_getdate(args: &[Value]) -> Value {
let ts = if args.is_empty() {
now_ts()
} else {
int_arg(args, 0)
};
let dt = from_ts(ts);
let dow_sun = dt.weekday().num_days_from_sunday() as usize;
make_map(vec![
(Value::str("seconds"), Value::int(dt.second() as i64)),
(Value::str("minutes"), Value::int(dt.minute() as i64)),
(Value::str("hours"), Value::int(dt.hour() as i64)),
(Value::str("mday"), Value::int(dt.day() as i64)),
(Value::str("wday"), Value::int(dow_sun as i64)),
(Value::str("mon"), Value::int(dt.month() as i64)),
(Value::str("year"), Value::int(dt.year() as i64)),
(Value::str("yday"), Value::int(dt.ordinal0() as i64)),
(Value::str("weekday"), Value::str(DAYS[dow_sun])),
(Value::str("month"), Value::str(MONTHS[dt.month() as usize])),
(Value::int(0), Value::int(ts)),
])
}