shithub: mc

ref: 3ee9ef9b185e6f7b7af5d5c6fc3d330cb4a51cd8
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 UnixJulianDiff	= 719468
const Days400y	= 365*400 + 4*25 - 3
const Days4y	= 365*4 + 1

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 % (24*60*60*1_000_000)	/* time */
	e = tm / (24*60*60*1_000_000)	/* epoch days */


	/* 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 = e + UnixJulianDiff
	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++
	;;
	inst.year = y castto(int)
	inst.mon = m castto(int)
	inst.day = (d + 1) 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)
}