shithub: mc

ref: 06e5f064ec985d4fd9e530e5a94cf4b1721d64f1
dir: /lib/date/date.myr/

use std
use "types.use"
use "zoneinfo.use"

pkg date =
	/* useful constructors */
	const utcnow	: (-> instant)
	const now	: (tz : byte[:] -> instant)
	const tozone	: (d : instant, zone : byte[:]	-> instant)
	const mkinstant	: (tm : std.time, zone : byte[:]	-> instant)

	const localoff	: (tm : std.time -> delta)
	const tzoff	: (tzname : byte[:], tm : std.time	-> delta)
	const isleap	: (d : instant	-> bool)

	/* date differences */
	const add	: (d : instant, dt : delta	-> instant)
	const sub	: (d : instant, dt : delta	-> instant)
	const delta	: (a : instant, b : instant	-> delta)
        /*
	const duradd	: (d : instant, dt : period	-> instant)
	const dursub	: (d : instant, dt : period	-> instant)
        */
;;

const Days400y	= 365*400 + 4*25 - 3
const Days4y	= 365*4 + 1
const DayUsec	= (24*60*60*1_000_000)

const utcnow = {
	-> mkinstant(std.now(), "")
}

const now = {tz : byte[:]
	var tm

	tm = std.now()
	-> mkinstant(tm, tz)
}

const tozone = {d, tz
	-> mkinstant(d.actual, tz)
}

const mkinstant = {tm, tz 
	var j, y, m, d
	var t, e
	var inst
	var off

	inst.actual = tm
	/* time zones */
	std.assert(tz.len <= inst._tzbuf.len, "time zone name too long\n")
	off =_zoneinfo.findtzoff(tz, tm) 
	inst.tzoff = off
	std.slcp(inst._tzbuf[:tz.len], tz)
	inst.tzname = inst._tzbuf[:tz.len]
	tm += off castto(std.time)

	/* break up time */
	t = tm % DayUsec	/* time */
	e = tm / DayUsec	/* epoch day */

	if t < 0
		t += DayUsec
		e -= 1
	;;

	/* microseconds, seconds, minutes, hours */
	inst.us  = (t % 1_000_000) castto(int)
	t /= 1_000_000
	inst.s = (t % 60) castto(int)
	t /= 60
	inst.m = (t % 60) castto(int)
	t /= 60
	inst.h = t castto(int)

	/* weekday */
	inst.wday = ((e + 4) % 7) castto(int)	/* the world started on Thursday */

	/*
	split up year, month, day.

	Implemented according to "Algorithm 199, conversions between calendar 
	date and Julian day number", Robert G. Tantzen, Air Force Missile Development
	Center, Holloman AFB, New Mex.

	Lots of magic. Yer a wizard, 'arry.
	*/
	j = (tm + 2440588 * DayUsec) / DayUsec 
	std.put("j = {}\n", j)
	j -= 1721119
	std.assert(j > 0, "date too negative")

	y = (4 * j - 1) / Days400y
	j = 4 * j - 1 - Days400y * y
	d = j / 4

	j = (4 * d + 3) / Days4y
	d = 4 * d + 3 - Days4y * j
	d = (d + 4) / 4 ;

	m = (5 * d - 3) / 153
	d = 5 * d - 3 - 153 * m
	d = (d + 5) / 5

	y = 100 * y + j
	if m < 10
		m += 3
	else
		m -= 9 
		y++
	;;

	/* there's no year 0 */
	if y <= 0
		y--
	;;

	inst.year = y castto(int)
	inst.mon = m castto(int)
	inst.day = d castto(int)
	-> inst
}

const localoff = {tm
	-> _zoneinfo.findtzoff("local", tm)
}

const tzoff = {tz, tm
	-> _zoneinfo.findtzoff(tz, tm)
}

const isleap = {d
	-> d.year % 4 == 0 && (d.year % 100 != 0 || d.year % 400 == 0)
}

const add  = {d, dt
	-> mkinstant(d.actual + (dt castto(std.time)), d.tzname)
}

const sub  = {d, dt
	-> mkinstant(d.actual - (dt castto(std.time)), d.tzname)
}

const delta = {a, b
	-> (b.actual - a.actual) castto(delta)
}