Will Anderson
426 lines
14 KiB
EmacsLisp
426 lines
14 KiB
EmacsLisp
// runtime/time.el — Time operations, sleep, and formatting.
|
||
//
|
||
// Implements the time surface from el-compiler/runtime/legacy/el_runtime.c
|
||
// (lines 3334–3440, 3471–3656) in pure El, using seed primitives.
|
||
//
|
||
// Seed primitives consumed:
|
||
// __time_now_ns() -> Int (nanoseconds since Unix epoch)
|
||
// __sleep_ms(n: Int)
|
||
// __int_to_str(n: Int) -> String
|
||
// __str_to_int(s: String) -> Int
|
||
// __float_to_str(f: Float) -> String
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Core — now / sleep
|
||
// ---------------------------------------------------------------------------
|
||
|
||
// time_now — milliseconds since Unix epoch (UTC). Matches legacy time_now().
|
||
fn time_now() -> Int {
|
||
return __time_now_ns() / 1000000
|
||
}
|
||
|
||
// time_now_utc — same as time_now; UTC alias kept for compatibility.
|
||
fn time_now_utc() -> Int {
|
||
return __time_now_ns() / 1000000
|
||
}
|
||
|
||
// now_ns — nanoseconds since Unix epoch. Matches el_now_instant().
|
||
fn now_ns() -> Int {
|
||
return __time_now_ns()
|
||
}
|
||
|
||
// unix_timestamp — whole seconds since Unix epoch. Matches unix_timestamp().
|
||
fn unix_timestamp() -> Int {
|
||
return __time_now_ns() / 1000000000
|
||
}
|
||
|
||
// sleep_secs — block for n seconds. Clamps negatives to 0.
|
||
fn sleep_secs(n: Int) {
|
||
if n < 0 {
|
||
__sleep_ms(0)
|
||
} else {
|
||
__sleep_ms(n * 1000)
|
||
}
|
||
}
|
||
|
||
// sleep_ms — block for n milliseconds. Clamps negatives to 0.
|
||
fn sleep_ms(n: Int) {
|
||
if n < 0 {
|
||
__sleep_ms(0)
|
||
} else {
|
||
__sleep_ms(n)
|
||
}
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Gregorian decomposition helpers — pure integer arithmetic.
|
||
//
|
||
// Algorithm: civil date from days since Unix epoch (1970-01-01).
|
||
// Based on Howard Hinnant's public-domain civil_from_days formula
|
||
// (http://howardhinnant.github.io/date_algorithms.html), which the legacy
|
||
// gmtime_r call performs under the hood.
|
||
//
|
||
// We expose the pieces as private helpers (leading underscore convention).
|
||
// ---------------------------------------------------------------------------
|
||
|
||
// _is_leap — 1 if year y is a Gregorian leap year, 0 otherwise.
|
||
fn _is_leap(y: Int) -> Int {
|
||
if y % 400 == 0 { return 1 }
|
||
if y % 100 == 0 { return 0 }
|
||
if y % 4 == 0 { return 1 }
|
||
return 0
|
||
}
|
||
|
||
// _days_in_month — number of days in month m of year y (m: 1..12).
|
||
fn _days_in_month(y: Int, m: Int) -> Int {
|
||
if m == 1 { return 31 }
|
||
if m == 2 {
|
||
if _is_leap(y) == 1 { return 29 }
|
||
return 28
|
||
}
|
||
if m == 3 { return 31 }
|
||
if m == 4 { return 30 }
|
||
if m == 5 { return 31 }
|
||
if m == 6 { return 30 }
|
||
if m == 7 { return 31 }
|
||
if m == 8 { return 31 }
|
||
if m == 9 { return 30 }
|
||
if m == 10 { return 31 }
|
||
if m == 11 { return 30 }
|
||
return 31
|
||
}
|
||
|
||
// _pad2 — zero-pad an integer to at least 2 digits.
|
||
fn _pad2(n: Int) -> String {
|
||
if n < 10 { return "0" + __int_to_str(n) }
|
||
return __int_to_str(n)
|
||
}
|
||
|
||
// _pad4 — zero-pad an integer to at least 4 digits.
|
||
fn _pad4(n: Int) -> String {
|
||
if n < 10 { return "000" + __int_to_str(n) }
|
||
if n < 100 { return "00" + __int_to_str(n) }
|
||
if n < 1000 { return "0" + __int_to_str(n) }
|
||
return __int_to_str(n)
|
||
}
|
||
|
||
// _pad3 — zero-pad an integer to at least 3 digits (milliseconds).
|
||
fn _pad3(n: Int) -> String {
|
||
if n < 10 { return "00" + __int_to_str(n) }
|
||
if n < 100 { return "0" + __int_to_str(n) }
|
||
return __int_to_str(n)
|
||
}
|
||
|
||
// _civil_year_month_day — decompose days-since-epoch (z, may be negative)
|
||
// into year/month/day using the civil_from_days algorithm.
|
||
// Returns a JSON object: {"year":Y,"month":M,"day":D}
|
||
fn _civil_ymd(z: Int) -> String {
|
||
// shift epoch to 0000-03-01 (makes leap-day math clean)
|
||
let zz: Int = z + 719468
|
||
// era: 400-year block
|
||
let era: Int = zz / 146097
|
||
if zz < 0 {
|
||
era = (zz - 146096) / 146097
|
||
}
|
||
let doe: Int = zz - era * 146097 // day-of-era [0, 146096]
|
||
let yoe: Int = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365 // year-of-era [0, 399]
|
||
let y: Int = yoe + era * 400
|
||
let doy: Int = doe - (365 * yoe + yoe / 4 - yoe / 100) // day-of-year [0, 365]
|
||
let mp: Int = (5 * doy + 2) / 153 // month in [0, 11] from March
|
||
let d: Int = doy - (153 * mp + 2) / 5 + 1 // day [1, 31]
|
||
let m: Int = mp + 3
|
||
if mp >= 10 { m = mp - 9 }
|
||
if mp >= 10 { y = y + 1 }
|
||
return "{\"year\":" + __int_to_str(y) + ",\"month\":" + __int_to_str(m) + ",\"day\":" + __int_to_str(d) + "}"
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// time_to_parts — decompose a millisecond timestamp into UTC components.
|
||
//
|
||
// Returns a JSON string:
|
||
// {"year":Y,"month":M,"day":D,"hour":H,"minute":M,"second":S,"ms":MS}
|
||
//
|
||
// Matches legacy time_to_parts() which returns an ElMap with the same keys.
|
||
// ---------------------------------------------------------------------------
|
||
|
||
fn time_to_parts(ts: Int) -> String {
|
||
let ms_raw: Int = ts % 1000
|
||
let ms: Int = ms_raw
|
||
if ms_raw < 0 { ms = ms_raw + 1000 }
|
||
|
||
let s_raw: Int = ts / 1000
|
||
let s: Int = s_raw
|
||
if ms_raw < 0 { s = s_raw - 1 }
|
||
|
||
// seconds within the day and days since epoch
|
||
let sec_of_day: Int = s % 86400
|
||
let day_z: Int = s / 86400
|
||
// handle negative: floor division
|
||
if sec_of_day < 0 {
|
||
sec_of_day = sec_of_day + 86400
|
||
day_z = day_z - 1
|
||
}
|
||
|
||
let hour: Int = sec_of_day / 3600
|
||
let rem: Int = sec_of_day % 3600
|
||
let minute: Int = rem / 60
|
||
let second: Int = rem % 60
|
||
|
||
// date components via civil decomposition
|
||
let ymd: String = _civil_ymd(day_z)
|
||
let year: Int = __str_to_int(json_get(ymd, "year"))
|
||
let month: Int = __str_to_int(json_get(ymd, "month"))
|
||
let day: Int = __str_to_int(json_get(ymd, "day"))
|
||
|
||
return "{\"year\":" + __int_to_str(year) +
|
||
",\"month\":" + __int_to_str(month) +
|
||
",\"day\":" + __int_to_str(day) +
|
||
",\"hour\":" + __int_to_str(hour) +
|
||
",\"minute\":" + __int_to_str(minute) +
|
||
",\"second\":" + __int_to_str(second) +
|
||
",\"ms\":" + __int_to_str(ms) + "}"
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// time_format — format a millisecond timestamp as a string.
|
||
//
|
||
// fmt "ISO" (or empty) → "YYYY-MM-DDTHH:MM:SS.mmmZ" (ISO 8601 UTC)
|
||
// Other fmt values are passed as a strftime-style hint; the El runtime
|
||
// implements the most common tokens. Unsupported tokens are passed through.
|
||
//
|
||
// Matches legacy time_format().
|
||
// ---------------------------------------------------------------------------
|
||
|
||
fn time_format(ts: Int, fmt: String) -> String {
|
||
let parts: String = time_to_parts(ts)
|
||
let y: Int = __str_to_int(json_get(parts, "year"))
|
||
let mo: Int = __str_to_int(json_get(parts, "month"))
|
||
let d: Int = __str_to_int(json_get(parts, "day"))
|
||
let h: Int = __str_to_int(json_get(parts, "hour"))
|
||
let mi: Int = __str_to_int(json_get(parts, "minute"))
|
||
let s: Int = __str_to_int(json_get(parts, "second"))
|
||
let ms: Int = __str_to_int(json_get(parts, "ms"))
|
||
|
||
// ISO 8601 UTC: YYYY-MM-DDTHH:MM:SS.mmmZ
|
||
if str_eq(fmt, "ISO") {
|
||
return _pad4(y) + "-" + _pad2(mo) + "-" + _pad2(d) +
|
||
"T" + _pad2(h) + ":" + _pad2(mi) + ":" + _pad2(s) +
|
||
"." + _pad3(ms) + "Z"
|
||
}
|
||
if str_eq(fmt, "") {
|
||
return _pad4(y) + "-" + _pad2(mo) + "-" + _pad2(d) +
|
||
"T" + _pad2(h) + ":" + _pad2(mi) + ":" + _pad2(s) +
|
||
"." + _pad3(ms) + "Z"
|
||
}
|
||
|
||
// strftime-subset: replace common tokens
|
||
let out: String = fmt
|
||
let out = str_replace(out, "%Y", _pad4(y))
|
||
let out = str_replace(out, "%m", _pad2(mo))
|
||
let out = str_replace(out, "%d", _pad2(d))
|
||
let out = str_replace(out, "%H", _pad2(h))
|
||
let out = str_replace(out, "%M", _pad2(mi))
|
||
let out = str_replace(out, "%S", _pad2(s))
|
||
let out = str_replace(out, "%3N", _pad3(ms))
|
||
return out
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// time_from_parts — construct a ms timestamp from seconds + nanosecond offset.
|
||
//
|
||
// Matches legacy time_from_parts(secs, ns, tz) — tz is ignored (UTC assumed).
|
||
// ---------------------------------------------------------------------------
|
||
|
||
fn time_from_parts(secs: Int, ns: Int, tz: String) -> Int {
|
||
return secs * 1000 + ns / 1000000
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// time_add — add a duration to a millisecond timestamp.
|
||
//
|
||
// unit: "ms" | "sec" | "min" | "hour" | "day"
|
||
// Matches legacy time_add().
|
||
// ---------------------------------------------------------------------------
|
||
|
||
fn time_add(ts: Int, n: Int, unit: String) -> Int {
|
||
if str_eq(unit, "ms") { return ts + n }
|
||
if str_eq(unit, "sec") { return ts + n * 1000 }
|
||
if str_eq(unit, "min") { return ts + n * 60000 }
|
||
if str_eq(unit, "hour") { return ts + n * 3600000 }
|
||
if str_eq(unit, "day") { return ts + n * 86400000 }
|
||
// default: treat as ms
|
||
return ts + n
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// time_diff — compute the difference between two millisecond timestamps.
|
||
//
|
||
// Returns ts2 - ts1 in the given unit.
|
||
// unit: "ms" | "sec" | "min" | "hour" | "day"
|
||
// Matches legacy time_diff().
|
||
// ---------------------------------------------------------------------------
|
||
|
||
fn time_diff(ts1: Int, ts2: Int, unit: String) -> Int {
|
||
let d: Int = ts2 - ts1
|
||
if str_eq(unit, "ms") { return d }
|
||
if str_eq(unit, "sec") { return d / 1000 }
|
||
if str_eq(unit, "min") { return d / 60000 }
|
||
if str_eq(unit, "hour") { return d / 3600000 }
|
||
if str_eq(unit, "day") { return d / 86400000 }
|
||
return d
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Instant / Duration — nanosecond-precision temporal types.
|
||
//
|
||
// These match the el_now_instant, duration_seconds, duration_millis, etc.
|
||
// family from legacy lines 3471–3656. Both Instant and Duration are Int
|
||
// (nanoseconds); the type distinction is at the call-site convention level.
|
||
// ---------------------------------------------------------------------------
|
||
|
||
// now — current Instant in nanoseconds. Alias for __time_now_ns().
|
||
fn now() -> Int {
|
||
return __time_now_ns()
|
||
}
|
||
|
||
// unix_seconds — Instant from whole seconds since epoch.
|
||
fn unix_seconds(n: Int) -> Int {
|
||
return n * 1000000000
|
||
}
|
||
|
||
// unix_millis — Instant from milliseconds since epoch.
|
||
fn unix_millis(n: Int) -> Int {
|
||
return n * 1000000
|
||
}
|
||
|
||
// instant_to_unix_seconds — convert Instant nanoseconds to whole seconds.
|
||
fn instant_to_unix_seconds(i: Int) -> Int {
|
||
return i / 1000000000
|
||
}
|
||
|
||
// instant_to_unix_millis — convert Instant nanoseconds to milliseconds.
|
||
fn instant_to_unix_millis(i: Int) -> Int {
|
||
return i / 1000000
|
||
}
|
||
|
||
// instant_to_iso8601 — format an Instant (nanoseconds) as ISO 8601 UTC.
|
||
fn instant_to_iso8601(i: Int) -> String {
|
||
let ms: Int = i / 1000000
|
||
return time_format(ms, "ISO")
|
||
}
|
||
|
||
// duration_seconds — Duration from n whole seconds.
|
||
fn duration_seconds(n: Int) -> Int {
|
||
return n * 1000000000
|
||
}
|
||
|
||
// duration_millis — Duration from n milliseconds.
|
||
fn duration_millis(n: Int) -> Int {
|
||
return n * 1000000
|
||
}
|
||
|
||
// duration_nanos — Duration from n nanoseconds (identity).
|
||
fn duration_nanos(n: Int) -> Int {
|
||
return n
|
||
}
|
||
|
||
// duration_to_seconds — convert a Duration (nanoseconds) to whole seconds.
|
||
fn duration_to_seconds(d: Int) -> Int {
|
||
return d / 1000000000
|
||
}
|
||
|
||
// duration_to_millis — convert a Duration (nanoseconds) to milliseconds.
|
||
fn duration_to_millis(d: Int) -> Int {
|
||
return d / 1000000
|
||
}
|
||
|
||
// duration_to_nanos — return the Duration as nanoseconds (identity).
|
||
fn duration_to_nanos(d: Int) -> Int {
|
||
return d
|
||
}
|
||
|
||
// sleep_duration — sleep for a Duration (nanoseconds). Clamps negatives to 0.
|
||
fn sleep_duration(dur: Int) {
|
||
let ms: Int = dur / 1000000
|
||
if ms < 0 {
|
||
__sleep_ms(0)
|
||
} else {
|
||
__sleep_ms(ms)
|
||
}
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// TTL cache — time-bounded key/value backed by state.
|
||
//
|
||
// Matches legacy ttl_cache_set / ttl_cache_get / ttl_cache_age (lines 3663–3717).
|
||
// max_age is a Duration (nanoseconds).
|
||
// ---------------------------------------------------------------------------
|
||
|
||
// ttl_cache_set — store a value and record the current Instant for TTL checks.
|
||
fn ttl_cache_set(key: String, value: String) {
|
||
state_set(key, value)
|
||
let stamp_key: String = "__ttl_at:" + key
|
||
let now_str: String = __int_to_str(__time_now_ns())
|
||
state_set(stamp_key, now_str)
|
||
}
|
||
|
||
// ttl_cache_get — return value if age < max_age (nanoseconds), else "".
|
||
fn ttl_cache_get(key: String, max_age: Int) -> String {
|
||
let stamp_key: String = "__ttl_at:" + key
|
||
let sv: String = state_get(stamp_key)
|
||
if str_eq(sv, "") { return "" }
|
||
let set_at: Int = __str_to_int(sv)
|
||
let now_ns: Int = __time_now_ns()
|
||
let age: Int = now_ns - set_at
|
||
if age < 0 { return "" }
|
||
if age > max_age { return "" }
|
||
return state_get(key)
|
||
}
|
||
|
||
// ttl_cache_age — nanoseconds since a key was last set (INT_MAX sentinel if missing).
|
||
fn ttl_cache_age(key: String) -> Int {
|
||
let stamp_key: String = "__ttl_at:" + key
|
||
let sv: String = state_get(stamp_key)
|
||
if str_eq(sv, "") { return 9223372036854775807 }
|
||
let set_at: Int = __str_to_int(sv)
|
||
return __time_now_ns() - set_at
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// uuid_new / uuid_v4 — generate a UUID v4 string.
|
||
//
|
||
// Delegates to the __uuid_v4() seed primitive.
|
||
// Matches legacy uuid_new() / uuid_v4() (lines 4602–4621).
|
||
// ---------------------------------------------------------------------------
|
||
|
||
fn uuid_new() -> String {
|
||
return __uuid_v4()
|
||
}
|
||
|
||
fn uuid_v4() -> String {
|
||
return __uuid_v4()
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// DHARMA-compatible aliases — millisecond-precision timestamps.
|
||
//
|
||
// now_millis, unix_timestamp_ms, and time_now_ms all return the same value:
|
||
// milliseconds since the Unix epoch. They exist because different parts of
|
||
// the dharma codebase use different names for the same concept.
|
||
// ---------------------------------------------------------------------------
|
||
|
||
// now_millis — milliseconds since Unix epoch. Alias for time_now().
|
||
fn now_millis() -> Int {
|
||
return __time_now_ns() / 1000000
|
||
}
|
||
|
||
// unix_timestamp_ms — same as now_millis.
|
||
fn unix_timestamp_ms() -> Int {
|
||
return __time_now_ns() / 1000000
|
||
}
|
||
|
||
// time_now_ms — same as now_millis.
|
||
fn time_now_ms() -> Int {
|
||
return __time_now_ns() / 1000000
|
||
}
|