initial commit

test/test_bitsruct.c3

@@ -0,0 +1,14 @@
+bitstruct Bits : uint {
+	bool a : 0;
+	bool b : 1;
+	bool c : 2;
+}
+
+fn int main()
+{
+	Bits a = {false, true, false};
+	Bits b = {true, true, false};
+	Bits c = a | b;
+
+	return 0;
+}

test/test_bittype.c3

@@ -0,0 +1,10 @@
+import std::io;
+import std::collections::bitset;
+
+def Bits = bitset::BitSet(<128>);
+
+fn void main()
+{
+    Bits b;
+	io::printn($typeof(b.data[0]).sizeof);
+}

test/test_color.c3

@@ -0,0 +1,19 @@
+import std::io;
+
+struct Color { short r,g,b,a; }
+
+macro Color uint.to_rgba(uint u)
+{
+	return Color{
+		.r = (char)((u >> 24) & 0xff),
+		.g = (char)((u >> 16) & 0xff),
+		.b = (char)((u >> 8) & 0xff),
+		.a = (char)((u >> 0) & 0xff)
+	};
+}
+
+fn void main(String[] args)
+{
+	uint col = args[1].to_uint()!!;
+	io::printn(col.to_rgba());
+}

test/test_custom_hash.c3

@@ -0,0 +1,14 @@
+import std::collections::map;
+
+def Codepoint = uint;
+fn uint Codepoint.hash(Codepoint code) => code < 128 ? code : ((uint)code).hash();
+def CodeMap = map::HashMap(<Codepoint, Codepoint>);
+
+
+fn int main()
+{
+    CodeMap m;
+    m.new_init();
+    m.free();
+    return 0;
+}

test/test_error.c3

@@ -0,0 +1,72 @@
+import std::io;
+
+struct FaultStack {
+	usz elem;
+	anyfault[16] v;
+}
+
+fn void FaultStack.push(&fs, anyfault f)
+{
+	if (fs.elem < fs.v.len) {
+		fs.v[fs.elem++] = f;
+	}
+}
+
+fn anyfault FaultStack.pop(&fs)
+{
+	return fs.elem > 0 ? fs.v[fs.elem-- - 1] : anyfault{};
+}
+
+FaultStack fs;
+
+fn int! err1()
+{
+	return IoError.OUT_OF_SPACE?;
+}
+
+fn void! err2()
+{
+	return IoError.EOF?;
+}
+
+/*
+macro @unwrap(#f)
+{
+	$if ($typeof(#f).typeid == void!.typeid) {
+		if (catch err = #f) { fs.push(err); }
+		return;
+	} $else {
+		$typeof(#f) x = #f;
+		if (catch err = x) {
+			fs.push(err);
+			return $typeof(#f!!){};
+		} else {return x;}
+	}
+}
+*/
+
+<*
+@require @typekind(#func) == OPTIONAL : `@unwrap requires an optional value`
+*>
+macro @unwrap(#func)
+{
+	anyfault exc = @catch(#func);
+	if (exc != anyfault{}) {
+		fs.push(exc);
+		$if $typeof(#func!!).typeid != void.typeid:
+			return $typeof(#func!!){};
+		$else
+			return;
+		$endif
+	} else {
+		return #func!!;
+	}
+}
+
+fn void main()
+{
+	@unwrap(err1());
+	@unwrap(err2());
+
+	io::printfn("%s", fs.v);
+}

test/test_font.c3

@@ -0,0 +1,6 @@
+import rl;
+
+fn int main(void)
+{
+	return 0;
+}

test/test_idgen.c3

@@ -0,0 +1,30 @@
+import std::io;
+
+alias Id = uint;
+
+fn void foo_ex(Id id)
+{
+	io::printfn("id = %d", id);
+}
+
+
+macro Id @compute_id(...)
+{
+	Id id = (Id)$$LINE.hash() ^ (Id)@str_hash($$FILE);
+	$for var $i = 0; $i < $vacount; $i++:
+		id ^= (Id)$vaconst[$i].hash();
+	$endfor
+	return id;
+}
+
+macro foo(...) => foo_ex(@compute_id($vasplat));
+
+fn int main()
+{
+	foo_ex(1234);
+	foo();
+	foo();
+	foo();
+
+	return 0;
+}

test/test_keyboard.c3

@@ -0,0 +1,26 @@
+import rl;
+import std::io;
+
+fn int main(String[] args)
+{
+	short width = 800;
+	short height = 450;
+	rl::set_config_flags(rl::FLAG_WINDOW_RESIZABLE);
+	rl::init_window(width, height, "Ugui Test");
+	rl::set_target_fps(60);
+	rl::enable_event_waiting();
+
+	// Main loop
+	KeyboardKey k;
+	while (!rl::window_should_close()) {
+		do {
+			k = rl::get_char_pressed();
+			io::printfn("%s", k);
+		} while (k != 0);
+	}
+
+	rl::close_window();
+
+	return 0;
+}
+

test/test_mtree.c3

@@ -0,0 +1,342 @@
+module mtree{Type};
+
+import std::core::mem;
+import std::core::mem::allocator;
+import std::io;
+import std::bits;
+import std::collections::list;
+
+
+alias Bitmap = ulong;
+const BITS = Bitmap.sizeof*8;
+
+alias IdxList = list::List{int};
+
+// more: if positive it contains the index of the next node that contains the children information
+struct Node {
+	int more;
+	int parent;
+	Bitmap children;
+}
+
+struct MTree {
+	usz elements;
+	Allocator allocator;
+	IdxList  queue;
+	Bitmap[] used;
+	Type[]   elem_mat; // element matrix
+	Node[]   refs_mat;  // relationship matrix
+}
+
+
+fn void MTree.init(&tree, usz size, Allocator allocator = mem)
+{
+	// round size to the nearest multiple of BITS
+	size = size + size%BITS;
+
+	tree.elements = 0;
+	tree.allocator = allocator;
+	tree.queue.init(allocator, size);
+	tree.used     = allocator::new_array(tree.allocator, Bitmap, size/BITS);
+	tree.elem_mat = allocator::new_array(tree.allocator, Type, size);
+	tree.refs_mat = allocator::new_array(tree.allocator, Node, size);
+	
+	foreach (&r: tree.refs_mat) {
+		r.more = -1;
+	}
+}
+
+
+fn void MTree.free(&tree)
+{
+	tree.elements = 0;
+	tree.queue.free();
+	(void)allocator::free(tree.allocator, tree.used);
+	(void)allocator::free(tree.allocator, tree.elem_mat);
+	(void)allocator::free(tree.allocator, tree.refs_mat);
+}
+
+
+fn int MTree.get_free_spot(&tree)
+{
+	foreach (idx, d: tree.used) {
+		if (d != $typeof(d).max) {
+			int spot = (int)idx*BITS + BITS-(int)d.clz();
+			return spot;
+		}
+	}
+	unreachable("no free spots left");
+}
+
+<* @require idx >= 0 *>
+fn void MTree.set_used(&tree, int idx)
+{
+	int r = idx % BITS;
+	int q = idx / BITS;
+	tree.used[q] |= (1l << r);
+}
+
+<* @require idx >= 0 *>
+fn void MTree.unset_used(&tree, int idx)
+{
+	int r = idx % BITS;
+	int q = idx / BITS;
+	tree.used[q] &= ~(1l << r);
+}
+
+<* @require idx >= 0 *>
+fn bool MTree.is_used(&tree, int idx)
+{
+	int r = idx % BITS;
+	int q = idx / BITS;
+	return !!(tree.used[q] & (1l << r));
+}
+
+
+// get the last node in the "more" chain
+<* @require tree.is_used(parent) == true *>
+fn int MTree.last_node(&tree, int parent)
+{
+	while(tree.refs_mat[parent].more >= 0) {
+		parent = tree.refs_mat[parent].more;
+	}
+	return parent;
+}
+
+
+<* @require tree.elements == 0 || tree.is_used(parent) == true *>
+fn int MTree.add(&tree, int parent, Type t)
+{
+	int idx = tree.get_free_spot();
+	int subtree = idx / BITS;
+
+	tree.set_used(idx);
+	tree.elem_mat[idx] = t;
+	tree.refs_mat[idx] = (Node){
+		.parent = parent,
+		.more = -1,
+	};
+	
+	tree.elements++;
+	// root element, has no parent
+	if (tree.elements == 1) {
+		tree.refs_mat[idx].parent = -1;
+		return idx;
+	}
+	
+
+	// if the parent already has a node in the same subtree as the child then update that node's
+	// children bitmap
+	bool done;
+	for (int p = parent; p >= 0; p = tree.refs_mat[p].more) {
+		int ps = p/BITS;
+		if (ps == subtree) {
+			tree.refs_mat[p].children |= (1l << (idx%BITS));
+			done = true;
+			break;
+		}
+	}
+	// on fail we need to create another parent node
+	if (!done) {
+		int new_more = tree.get_free_spot();
+		// if the new node does not land in the same subtree as the child we cannot do
+		// anything since the references are immutable
+		if (new_more/BITS != subtree) {
+			unreachable("cannot allocate new child for parent");
+		}
+		tree.set_used(new_more);
+		tree.elements++;
+		// update the "more" chain
+		int last_link = tree.last_node(parent);
+		tree.refs_mat[last_link].more = new_more;
+		tree.refs_mat[new_more].more = -1;
+		tree.refs_mat[new_more].children |= (long)(1 << (idx%BITS));
+		tree.refs_mat[new_more].parent = last_link;
+		// FIXME: the elem_mat is not updated, do we need to?
+	}
+
+	return idx;
+}
+
+
+// get the index of the n-th children of parent, -1 otherwise
+// usage: for (int i, c; (c = tree.children_it(parent, i)) >= 0; i++) { ... }
+fn int MTree.children_it(&tree, int parent, int n)
+{
+	int tot_children;
+	int child;
+	for (int p = parent; p >= 0; p = tree.refs_mat[p].more) {
+		int cn = (int)tree.refs_mat[p].children.popcount();
+		tot_children += cn;
+
+		// we are in the right subtree
+		if (tot_children > n) {
+			child = (p/BITS) * BITS; // start at the parent's subtree index
+			int j = cn - (tot_children - n); // we need the j-th children of this node
+			Bitmap u = tree.refs_mat[p].children;
+
+			child += j; // add the children number
+			do {
+				child += (int)u.ctz(); // increment by the skipped zeroes
+				u >>= u.ctz() + 1;
+				j--;
+			} while (j >= 0);
+
+			return child;
+		}
+	}
+	return -1;
+}
+
+fn int MTree.children_num(&tree, int parent)
+{
+	int n;
+	for (int p = parent; p >= 0; p = tree.refs_mat[p].more) {
+		n += (int)tree.refs_mat[p].children.popcount();
+	}
+	return n;
+}
+
+fn int MTree.subtree_size(&tree, int parent)
+{
+	int x = tree.children_num(parent);
+	int c;
+	for (int n; (c = tree.children_it(parent, n)) >= 0; n++) {
+		x += tree.subtree_size(c);
+	}
+	return x;
+}
+
+
+fn int MTree.level_order_it(&tree, int parent, int i)
+{
+	if (i == 0) {
+		tree.queue.clear();
+		tree.queue.push(parent);
+	}
+	
+	if (tree.queue.len() == 0) return -1;
+
+	int p = tree.queue.pop_first()!!;
+	int c;
+	for (int n; (c = tree.children_it(p, n)) >= 0; n++) {
+		tree.queue.push(c);
+	}
+	return p;
+}
+
+fn void MTree.prune(&tree, int parent)
+{
+	int c;
+	for (int i = 0; (c = tree.children_it(parent, i)) >= 0; i++) {
+		tree.prune(c); // prune the subtree
+
+		// delete all children including their more chain
+		for (int p = c; p >= 0;) {
+			int next = tree.refs_mat[p].more;
+			tree.unset_used(p);
+			tree.refs_mat[p] = {.more = -1};
+			p = next;
+		}
+
+	}
+
+	// finally delete the parent
+	for (int p = parent; p >= 0;) {
+		int next = tree.refs_mat[p].more;
+		tree.unset_used(p);
+		tree.elements--;
+		tree.refs_mat[p] = {.more = -1};
+		p = next;
+	}
+
+}
+
+
+macro bool MTree.is_root(&t, int i) => t.refs_mat[i].parent == -1;
+
+fn void MTree.print(&tree)
+{
+	foreach (idx, c: tree.elem_mat) {
+		if (tree.is_used((int)idx)) {
+			io::printfn("[%d](%s) parent:%d more:%d children:%b",
+			             idx, c, tree.refs_mat[idx].parent, tree.refs_mat[idx].more,
+			             tree.refs_mat[idx].children
+			           );
+		}
+	}
+}
+
+
+module foo;
+
+import std::io;
+import mtree;
+
+alias Tree = mtree::MTree{int};
+
+fn int main()
+{
+	Tree t;
+	t.init(256);
+	defer t.free();
+/*
+	int root = t.add(0, 0);
+	int c1 = t.add(root, 1);
+	int c2 = t.add(root, 2);
+	
+	int c11 = t.add(c1, 11);
+	int c12 = t.add(c1, 12);
+	
+	int c3 = t.add(root, 3);
+
+	for (int x = 0;  x < 70; x++) {
+		t.add(c2, x);
+	}
+	
+	int c31 = t.add(c3, 31);
+	int c32 = t.add(c3, 32);
+
+	int c4 = t.add(root, 4);
+	
+	int c13 = t.add(c1, 13);
+	int c14 = t.add(c1, 14);
+	int c15 = t.add(c1, 15);
+
+	t.prune(c2);
+
+	io::printn("printing tree");
+	t.print();
+	
+	usz x;
+	foreach_r (u: t.used) {
+		x += u.popcount();
+		io::printf("%b ", u);
+	}
+	io::printfn("TOT:%d/%d",x,t.elements);
+
+	io::printn(t.subtree_size(root));
+
+	io::printn();
+*/
+
+	int root = t.add(0, 0);
+	int c1 = t.add(root, 1);
+	int c2 = t.add(root, 2);
+	int c3 = t.add(root, 3);
+	
+	int c11 = t.add(c1, 11);
+	int c12 = t.add(c1, 12);
+	
+	int c111 = t.add(c11, 111);
+	int c121 = t.add(c12, 121);
+	
+	int c31 = t.add(c3, 31);
+
+	int c;
+	for (int i; (c = t.level_order_it(root, i)) >= 0; i++) {
+		io::printfn("%d-th: [%d](%d)", i, c, t.elem_mat[c]);
+	}
+
+	return 0;
+}

test/test_renderer.c3

@@ -0,0 +1,94 @@
+import sdlrenderer::ren;
+import std::io;
+import std::thread;
+import sdl3::sdl;
+import std::compression::qoi;
+import std::core::mem::allocator;
+
+char[*] shader_rect_vert = $embed("resources/shaders/compiled/rect.vert.spv");
+char[*] shader_rect_frag = $embed("resources/shaders/compiled/rect.frag.spv");
+
+char[*] shader_sprite_vert = $embed("resources/shaders/compiled/sprite.vert.spv");
+char[*] shader_sprite_frag = $embed("resources/shaders/compiled/sprite.frag.spv");
+
+const uint WINDOW_WIDTH  = 640;
+const uint WINDOW_HEIGHT = 480;
+
+
+fn int main()
+{
+	ren::Renderer ren;
+	ren.init("test window", WINDOW_WIDTH, WINDOW_HEIGHT);
+
+	// TODO: these could be the same function
+	ren.load_spirv_shader_from_mem("rect shader", &shader_rect_vert, &shader_rect_frag, 0, 0);
+	ren.create_pipeline("rect shader", RECT);
+
+	// load the tux qoi image
+	QOIDesc img_desc;
+	char[] img_pixels = qoi::read(allocator::temp(), "resources/tux.qoi", &img_desc)!!;
+	// and put it in a texture
+	ren.new_texture("tux", FULL_COLOR, img_pixels, img_desc.width, img_desc.height);
+	// create a new pipeline to use the texture
+	ren.load_spirv_shader_from_mem("sprite shader", &shader_sprite_vert, &shader_sprite_frag, 1, 0);
+	ren.create_pipeline("sprite shader", SPRITE);
+
+
+	sdl::Event e;
+	bool quit = false;
+	for (usz i = 0; !quit; i++) {
+
+		if (sdl::poll_event(&e)) {
+			if (e.type == EVENT_QUIT) {
+				quit = true;
+			}
+		}
+
+		if (i == 300) {
+			io::printn("ciao!");
+			img_pixels = qoi::read(allocator::temp(), "resources/tux_inv.qoi", &img_desc)!!;
+			ren.update_texture("tux", img_pixels, img_desc.width, img_desc.height);
+		}
+
+		ren.begin_render(true);
+
+		// Colored Rectangles Render Pass
+		ren.start_render_pass("rect shader");
+
+		// rect 1
+		ren.push_quad(100,100,100,100,0xff00ff00, 20);
+		// rect 2
+		ren.push_quad(0,0,20,20,0xff0000ff);
+		// rect 3
+		ren.push_quad(200,300,50,50,0xffff0000);
+
+		//ren.set_scissor(0,50,200,300);
+
+		ren.draw_quads();
+
+		ren.end_render_pass();
+		// End Rectangle Render Pass
+
+
+		// Textured Rectangles Render Pass
+		ren.start_render_pass("sprite shader");
+		
+		// bind the pipeline's sampler
+		ren.bind_texture("tux");
+
+		// tux
+		ren.push_sprite(300, 0, 54, 64, 0, 0);
+
+		ren.reset_scissor();
+
+		ren.draw_quads();
+
+		ren.end_render_pass();
+		// End Textured Rectangle Render Pass
+
+		ren.end_render();
+	}
+
+	ren.free();
+	return 0;
+}

test/test_tree_layout.c3

@@ -0,0 +1,436 @@
+import vtree;
+import std::io;
+import std::math;
+import std::thread;
+
+const short WIDTH = 128;
+const short HEIGHT = 64;
+
+struct Size {
+	short min, max;
+}
+macro Size @grow() => {.min = 0, .max = 0};
+macro Size @exact(short s) => {.min = s, .max = s};
+macro Size @fit(short min = 0, short max = short.max) => {.min = min, .max = max};
+macro bool Size.@is_grow(s) => (s.min == 0 && s.max == 0);
+macro bool Size.@is_exact(s) => (s.min == s.max && s.min != 0);
+macro bool Size.@is_fit(s) => (s.min != s.max);
+
+
+
+struct Rect {
+	short x, y, w, h;
+}
+
+enum LayoutDirection {
+	ROW,
+	COLUMN
+}
+
+enum ElemType {
+	DIV,
+	ELEM
+}
+
+enum Anchor {
+	TOP_LEFT,
+	LEFT,
+	BOTTOM_LEFT,
+	BOTTOM,
+	BOTTOM_RIGHT,
+	RIGHT,
+	TOP_RIGHT,
+	TOP,
+	CENTER
+}
+
+struct Elem {
+	ElemType type;
+	Size w, h;
+	Rect bounds;
+	Size ch_w, ch_h; // children width / height
+	uint grow_children; // how many children want to grow, decreased once a child has grown
+	short orig_x, orig_y;
+	short occupied; // occupied space in the layout direction
+	LayoutDirection layout_dir;
+	Anchor anchor;
+}
+
+alias ElemTree = vtree::VTree{Elem*};
+
+
+char[HEIGHT][WIDTH] screen;
+fn void paint(Rect bounds, char c)
+{
+	for (short x = bounds.x; x < WIDTH && x < bounds.x + bounds.w; x++) {
+		for (short y = bounds.y; y < HEIGHT && y < bounds.y + bounds.h; y++) {
+			screen[x][y] = c;
+		}
+	}
+}
+
+fn isz Elem.div_start(&e, ElemTree* tree, isz parent, Size w, Size h, LayoutDirection dir = ROW, Anchor anchor = TOP_LEFT, char c = ' ')
+{
+	e.type = DIV;
+	e.w = w;
+	e.h = h;
+	e.layout_dir = dir;
+	e.anchor = anchor;
+
+	e.grow_children = 0;
+	e.occupied = 0;
+	e.ch_w = e.ch_h = {};
+	e.orig_x = e.orig_y = 0;
+
+	// update grow children if necessary
+	Elem* p = tree.get(parent) ?? &&{};
+	if ((p.layout_dir == ROW && e.w.@is_grow()) || ((p.layout_dir == COLUMN && e.h.@is_grow()))) {
+		p.grow_children++;
+	}
+
+	paint(e.bounds, c);
+	return tree.add(e, parent)!!;
+}
+
+fn void update_parent_size(Elem* parent, Elem* child)
+{
+	// update the parent children size
+	switch (parent.layout_dir) {
+	case ROW: // on rows grow the ch width by the child width and only grow ch height if it exceeds
+		parent.ch_w.min += child.w.min;
+		parent.ch_w.max += child.w.max;
+		parent.ch_h.min = math::max(child.h.min, parent.ch_h.min);
+		parent.ch_h.max = math::max(child.h.max, parent.ch_h.max);
+	case COLUMN: // do the opposite on column
+		parent.ch_w.min = math::max(child.w.min, parent.ch_w.min);
+		parent.ch_w.max = math::max(child.w.max, parent.ch_w.max);
+		parent.ch_h.min += child.h.min;
+		parent.ch_h.max += child.h.max;
+	}
+}
+
+fn isz Elem.div_end(&e, ElemTree* tree, isz node)
+{
+	isz parent = tree.parentof(node) ?? -1;
+	if (parent > 0) {
+		Elem* p = tree.get(parent)!!;
+		update_parent_size(p, e);
+	}
+	return parent;
+}
+
+fn void resolve_dimensions(Elem* e, Elem* p)
+{
+	// ASSIGN WIDTH
+	switch {
+	case e.w.@is_exact():
+		e.bounds.w = e.w.min;
+	case e.w.@is_grow():
+		break;
+		// done in another pass
+	case e.w.@is_fit(): // fit the element's children
+		short min = math::max(e.ch_w.min, e.w.min);
+		short max = math::min(e.ch_w.max, e.w.max);
+		if (max >= min) { // OK!
+			e.bounds.w = max;
+		} else {
+			unreachable("cannot fit children");
+		}
+	default: unreachable("width is not exact, grow or fit");
+	}
+
+	// ASSIGN HEIGHT
+	switch {
+	case e.h.@is_exact():
+		e.bounds.h = e.h.min;
+	case e.h.@is_grow():
+		break;
+		// done in another pass
+	case e.h.@is_fit(): // fit the element's children
+		short min = math::max(e.ch_h.min, e.h.min);
+		short max = math::min(e.ch_h.max, e.h.max);
+		if (max >= min) { // OK!
+			e.bounds.h = max;
+		} else {
+			unreachable("cannot fit children");
+		}
+	default: unreachable("width is not exact, grow or fit");
+	}
+	
+	switch (p.layout_dir) {
+	case ROW:
+		if (!e.w.@is_grow()) p.occupied += e.bounds.w;
+	case COLUMN:
+		if (!e.h.@is_grow()) p.occupied += e.bounds.h;
+	}
+}
+
+fn void resolve_grow_elements(Elem* e, Elem* p)
+{
+	// WIDTH
+	if (e.w.@is_grow()) {
+		if (p.layout_dir == ROW) { // grow along the axis, divide the parent size
+			e.bounds.w = (short)((int)(p.bounds.w - p.occupied) / (int)p.grow_children);
+			p.grow_children--;
+			p.occupied += e.bounds.w;
+		} else if (p.layout_dir == COLUMN) { // grow across the layout axis, inherit width of the parent
+			e.bounds.w = p.bounds.w;
+		}
+	}
+	
+	// HEIGHT
+	if (e.h.@is_grow()) {
+		if (p.layout_dir == COLUMN) { // grow along the axis, divide the parent size
+			e.bounds.h = (short)((int)(p.bounds.h - p.occupied) / (int)p.grow_children);
+			p.grow_children--;
+			p.occupied += e.bounds.h;
+		} else if (p.layout_dir == ROW) { // grow across the layout axis, inherit width of the parent
+			e.bounds.h = p.bounds.h;
+		}
+	}
+}
+
+fn void resolve_placement(Elem* e, Elem* p)
+{
+	switch (p.anchor) {
+	case TOP_LEFT:
+		e.bounds.x = p.bounds.x + p.orig_x;
+		e.bounds.y = p.bounds.y + p.orig_y;
+	case LEFT:
+		e.bounds.x = p.bounds.x + p.orig_x;
+		e.bounds.y = p.bounds.y + p.orig_y + p.bounds.h/2;
+		if (p.layout_dir == COLUMN) {
+			e.bounds.y -= p.occupied/2;
+		} else if (p.layout_dir == ROW) {
+			e.bounds.y -= e.bounds.h/2;
+		}
+	case BOTTOM_LEFT:
+		e.bounds.x = p.bounds.x + p.orig_x;
+		e.bounds.y = p.bounds.y + p.bounds.h + p.orig_y;
+		if (p.layout_dir == COLUMN) {
+			e.bounds.y -= p.occupied;
+		} else if (p.layout_dir == ROW) {
+			e.bounds.y -= e.bounds.h;
+		}
+	case BOTTOM:
+		e.bounds.x = p.bounds.x + p.orig_x + p.bounds.w/2;
+		e.bounds.y = p.bounds.y + p.bounds.h + p.orig_y;
+		if (p.layout_dir == COLUMN) {
+			e.bounds.y -= p.occupied;
+			e.bounds.x -= e.bounds.w/2;
+		} else if (p.layout_dir == ROW) {
+			e.bounds.y -= e.bounds.h;
+			e.bounds.x -= p.occupied/2;
+		}
+	case BOTTOM_RIGHT:
+		e.bounds.x = p.bounds.x + p.orig_x + p.bounds.w;
+		e.bounds.y = p.bounds.y + p.bounds.h + p.orig_y;
+		if (p.layout_dir == COLUMN) {
+			e.bounds.y -= p.occupied;
+			e.bounds.x -= e.bounds.w;
+		} else if (p.layout_dir == ROW) {
+			e.bounds.y -= e.bounds.h;
+			e.bounds.x -= p.occupied;
+		}
+	case RIGHT:
+		e.bounds.x = p.bounds.x + p.orig_x + p.bounds.w;
+		e.bounds.y = p.bounds.y + p.orig_y + p.bounds.h/2;
+		if (p.layout_dir == COLUMN) {
+			e.bounds.y -= p.occupied/2;
+			e.bounds.x -= e.bounds.w;
+		} else if (p.layout_dir == ROW) {
+			e.bounds.y -= e.bounds.h/2;
+			e.bounds.x -= p.occupied;
+		}
+	case TOP_RIGHT:
+		e.bounds.x = p.bounds.x + p.orig_x + p.bounds.w;
+		e.bounds.y = p.bounds.y + p.orig_y;
+		if (p.layout_dir == COLUMN) {
+			e.bounds.x -= e.bounds.w;
+		} else if (p.layout_dir == ROW) {
+			e.bounds.x -= p.occupied;
+		}
+	case TOP:
+		e.bounds.x = p.bounds.x + p.orig_x + p.bounds.w/2;
+		e.bounds.y = p.bounds.y + p.orig_y;
+		if (p.layout_dir == COLUMN) {
+			e.bounds.x -= e.bounds.w/2;
+		} else if (p.layout_dir == ROW) {
+			e.bounds.x -= p.occupied/2;
+		}
+	case CENTER:
+		e.bounds.x = p.bounds.x + p.orig_x + p.bounds.w/2;
+		e.bounds.y = p.bounds.y + p.orig_y + p.bounds.h/2;
+		if (p.layout_dir == COLUMN) {
+			e.bounds.x -= e.bounds.w/2;
+			e.bounds.y -= p.occupied/2;
+		} else if (p.layout_dir == ROW) {
+			e.bounds.x -= p.occupied/2;
+			e.bounds.y -= e.bounds.h/2;
+		}
+		break;
+	}
+
+/*
+	e.bounds.x = p.bounds.x + p.orig_x;
+	e.bounds.y = p.bounds.y + p.orig_y;
+*/
+
+	switch (p.layout_dir) {
+	case ROW:
+		p.orig_x += e.bounds.w;
+	case COLUMN:
+		p.orig_y += e.bounds.h;
+	default: unreachable("unknown layout direction");
+	}
+}
+
+fn void frame_end(ElemTree* tree, isz root)
+{
+	// assign the element bounds
+	isz cursor = -1;
+
+	/*
+	// RESOLVE DIMENSIONS
+	isz current = tree.level_order_it(root, &cursor)!!;
+	for (; current >= 0; current = tree.level_order_it(root, &cursor)!!) {
+		Elem* e = tree.get(current)!!;
+		isz pi = tree.parentof(current)!!;
+		Elem* p = (pi != current) ? tree.get(pi) ?? &&{} : &&{};
+		resolve_dimensions(e, p);
+	}
+	
+	// RESOLVE GROW ELEMENTS
+	cursor = -1;
+	current = tree.level_order_it(root, &cursor)!!;
+	for (; current >= 0; current = tree.level_order_it(root, &cursor)!!) {
+		Elem* e = tree.get(current)!!;
+		isz pi = tree.parentof(current)!!;			if (ch == current) continue;
+		Elem* p = (pi != current) ? tree.get(pi) ?? &&{} : &&{};
+
+		resolve_grow_elements(e, p);
+	}
+
+
+	// RESOLVE PLACEMENT
+	cursor = -1;
+	current = tree.level_order_it(root, &cursor)!!;
+	for (; current >= 0; current = tree.level_order_it(root, &cursor)!!) {
+		Elem* e = tree.get(current)!!;
+		isz pi = tree.parentof(current)!!;
+		Elem* p = (pi != current) ? tree.get(pi) ?? &&{} : &&{};
+
+		resolve_placement(e, p);
+	}
+	*/
+
+	cursor = -1;
+	isz current = tree.level_order_it(root, &cursor)!!;
+	for (; current >= 0; current = tree.level_order_it(root, &cursor)!!) {
+		Elem* p = tree.get(current)!!;
+
+		// RESOLVE KNOWN DIMENSIONS
+		isz ch_cur = 0;
+		isz ch = tree.children_it(current, &ch_cur)!!;
+		for (; ch >= 0; ch = tree.children_it(current, &ch_cur)!!) {
+			Elem* c = tree.get(ch)!!;
+			if (tree.is_root(ch)!!) {
+				resolve_dimensions(p, &&{});
+			} else {
+				resolve_dimensions(c, p);
+			}
+		}
+
+		// RESOLVE GROW CHILDREN
+		ch_cur = 0;
+		ch = tree.children_it(current, &ch_cur)!!;
+		for (; ch >= 0; ch = tree.children_it(current, &ch_cur)!!) {
+			Elem* c = tree.get(ch)!!;
+			if (tree.is_root(ch)!!) {
+				resolve_grow_elements(p, &&{});
+			} else {
+				resolve_grow_elements(c, p);
+			}
+		}
+		
+		// RESOLVE CHILDREN PLACEMENT
+		ch_cur = 0;
+		ch = tree.children_it(current, &ch_cur)!!;
+		for (; ch >= 0; ch = tree.children_it(current, &ch_cur)!!) {
+			Elem* c = tree.get(ch)!!;
+			if (tree.is_root(ch)!!) {
+				resolve_placement(p, &&{});
+			} else {
+				resolve_placement(c, p);
+			}
+		}
+	}
+}
+
+fn void main()
+{
+	ElemTree tree;
+	tree.init(64, mem)!!;
+	isz parent;
+	defer (void)tree.free();
+
+	Elem root; // root div
+	Elem div1, div2, div3, div4;
+	usz frame;
+	while (true) {
+		parent = root.div_start(&tree, parent, @exact(WIDTH), @exact(HEIGHT), ROW, anchor: RIGHT);
+		/*
+		{
+			parent = div1.div_start(&tree, parent, @grow(), @grow(), dir: ROW, c: '1');
+			{
+				parent = div4.div_start(&tree, parent, @exact(30), @exact(30), dir: ROW, c: '4');
+				parent = div4.div_end(&tree, parent);
+			}
+			parent = div1.div_end(&tree, parent);
+
+			if (frame < 200) {
+				parent = div2.div_start(&tree, parent, @exact(20), @fit(), dir: COLUMN, c: '2');
+				{
+					parent = div3.div_start(&tree, parent, @exact(10), @exact(10), dir: ROW, c: '3');
+					parent = div3.div_end(&tree, parent);
+				}
+				parent = div2.div_end(&tree, parent);
+			}
+		}
+		*/
+		parent = div3.div_start(&tree, parent, @fit(), @fit(), COLUMN, anchor: CENTER);
+		{
+			parent = div1.div_start(&tree, parent, @exact(20), @exact(20), dir: ROW, c: '1');
+			parent = div1.div_end(&tree, parent);
+	
+			parent = div2.div_start(&tree, parent, @exact(10), @exact(10), dir: ROW, c: '2');
+			parent = div2.div_end(&tree, parent);
+		}
+		parent = div3.div_end(&tree, parent);
+
+		parent = root.div_end(&tree, parent);
+		
+		frame_end(&tree, parent);
+		tree.nuke();
+		
+
+		// draw the screen
+		//io::print("\e[1;1H\e[2J");
+		for (short x = 0; x < WIDTH+2; x++) io::printf("%c", x == 0 || x == WIDTH+1 ? '+' : '-');
+		io::printn();
+		for (short y = 0; y < HEIGHT; y++) {
+			io::print("|");
+			for (short x = 0; x < WIDTH; x++) {
+				char c = screen[x][y] == 0 ? 'x' : screen[x][y];
+				io::printf("%c", c);
+			}
+			io::print("|");
+			io::printn();
+		}
+		for (short x = 0; x < WIDTH+2; x++) io::printf("%c", x == 0 || x == WIDTH+1 ? '+' : '-');
+		io::printn("\n\n");
+
+		thread::sleep_ms(10);
+		frame++;
+	}
+}

test/test_union.c3

@@ -0,0 +1,26 @@
+
+struct CmdA {
+	int a, b;
+}
+
+struct CmdB {
+	float a, b;
+}
+
+union AnyCmd {
+	CmdA a;
+	CmdB b;
+}
+
+struct Cmd {
+	int type;
+	AnyCmd cmd;
+}
+
+fn int main()
+{
+	Cmd c;
+	c.type = 1;
+	c.cmd.a = {.a = 1, .b = 2};
+	return 0;
+}

test/test_vtree.c3

@@ -0,0 +1,7 @@
+import std::io;
+import vtree;
+
+fn int main()
+{
+    return 0;
+}

test/ugui_font.c3

@@ -0,0 +1,226 @@
+module ugui;
+
+import cache;
+//#include <grapheme.h>
+//#include <assert.h>
+
+//#include "stb_truetype.h"
+//#include "stbimage_write.h"
+
+// unicode code point, different type for a different hash
+def Codepoint = uint;
+
+/* width and height of a glyph contain the kering advance
+ * (u,v)
+ *   +-------------*---+ -
+ *   |       ^     |   | ^
+ *   |       |oy   |   | |
+ *   |       v     |   | |
+ *   |      .ii.   |   | |
+ *   |     @@@@@@. |<->| |
+ *   |    V@Mio@@o |adv| |h
+ *   |    :i.  V@V |   | |
+ *   |      :oM@@M |   | |
+ *   |    :@@@MM@M |   | |
+ *   |    @@o  o@M |   | |
+ *   |<->:@@.  M@M |   | |
+ *   |ox  @@@o@@@@ |   | |
+ *   |    :M@@V:@@.|   | v
+ *   +-------------*---+ -
+ *   |<------------->|
+ *           w
+ */
+struct Glyph {
+    Codepoint code;
+	uint u, v;
+	ushort w, h, a, x, y;
+}
+
+def GlyphCache = cache::Cache(<Codepoint, Glyph, 1024>);
+
+// identity map the ASCII range
+fn uint Codepoint.hash(Codepoint code) => code < 128 ? code : ((uint)code).hash();
+
+struct FontAtlas {
+	uint width, height;
+	char* atlas;
+	uint glyph_max_w, glyph_max_h;
+	int size;
+	int file_size;
+	char *file;
+	void *priv;
+}
+
+
+macro is_utf8(char c) => c & 0x80;
+const uint BDEPTH = 1;
+const uint BORDER = 4;
+
+// FIXME: as of now only monospaced fonts look decent since no
+//        kerning information is stored
+
+struct Priv @private {
+	stbtt_fontinfo stb;
+	float scale;
+	int baseline;
+	unsigned char *bitmap;
+	struct cache c;
+}
+//#define PRIV(x) ((struct priv *)x->priv)
+
+
+struct font_atlas * font_init(void)
+{
+	struct font_atlas *p = emalloc(sizeof(struct font_atlas));
+	memset(p, 0, sizeof(struct font_atlas));
+	p->priv = emalloc(sizeof(struct priv));
+	memset(p->priv, 0, sizeof(struct priv));
+	PRIV(p)->c = cache_init();
+	return p;
+}
+
+
+// loads a font into memory, storing all the ASCII characters in the atlas, each font
+// atlas structure holds glyphs of a specific size in pixels
+// NOTE: size includes ascend and descend (so 12 does not mean that 'A' is 12px tall)
+int font_load(struct font_atlas *atlas, const char *path, int size)
+{
+	if (!atlas || !path)
+		return -1;
+
+	int err;
+
+	dump_file(path, &(atlas->file), &(atlas->file_size));
+
+	err = stbtt_InitFont(&(PRIV(atlas)->stb), (unsigned char *)atlas->file, 0);
+	if (err == 0) return -1;
+
+	int ascent, descent, linegap, baseline;
+	int x0,y0,x1,y1;
+	float scale;
+	stbtt_GetFontVMetrics(&(PRIV(atlas)->stb), &ascent, &descent, &linegap);
+	stbtt_GetFontBoundingBox(&(PRIV(atlas)->stb), &x0, &y0, &x1, &y1);
+	scale = stbtt_ScaleForPixelHeight(&(PRIV(atlas)->stb), size);
+	baseline = scale * -y0;
+	atlas->glyph_max_w = (scale*x1) - (scale*x0);
+	atlas->glyph_max_h = (baseline+scale*y1) - (baseline+scale*y0);
+	atlas->atlas = emalloc(CACHE_SIZE*BDEPTH*atlas->glyph_max_w*atlas->glyph_max_h);
+	memset(atlas->atlas, 0, CACHE_SIZE*BDEPTH*atlas->glyph_max_w*atlas->glyph_max_h);
+	PRIV(atlas)->baseline = atlas->glyph_max_h - baseline;
+	PRIV(atlas)->scale = scale;
+	PRIV(atlas)->bitmap = emalloc(BDEPTH*atlas->glyph_max_w*atlas->glyph_max_h);
+	// FIXME: make this a square atlas
+	atlas->width  = atlas->glyph_max_w*CACHE_SIZE/4;
+	atlas->height = atlas->glyph_max_h*4;
+	atlas->size = size;
+
+	// preallocate all ascii characters
+	for (char c = ' '; c <= '~'; c++) {
+		if (!font_get_glyph_texture(atlas, c, NULL))
+			return -1;
+	}
+
+	return 0;
+}
+
+
+int font_free(struct font_atlas *atlas)
+{
+	efree(atlas->atlas);
+	efree(atlas->file);
+	efree(PRIV(atlas)->bitmap);
+	cache_free(&PRIV(atlas)->c);
+	efree(atlas->priv);
+	efree(atlas);
+	return 0;
+}
+
+
+// TODO: time and take the median of the time it takes to generate the cache and
+//       the time it takes to draw the glyph
+const struct font_glyph * font_get_glyph_texture(struct font_atlas *atlas, unsigned int code, int *updated)
+{
+	int _u = 0;
+	if (!updated) updated = &_u;
+
+	const struct font_glyph *r;
+	if ((r = cache_search(&PRIV(atlas)->c, code)) != NULL) {
+		*updated = 0;
+		return r;
+	}
+
+	*updated = 1;
+	// generate the sdf and put it into the cache
+	// TODO: generate the whole block at once
+	int idx = stbtt_FindGlyphIndex(&PRIV(atlas)->stb, code);
+	int x0,y0,x1,y1,gw,gh,l,off_x,off_y,adv,base;
+	base = atlas->glyph_max_h - PRIV(atlas)->baseline;
+	stbtt_GetGlyphBitmapBoxSubpixel(
+		&PRIV(atlas)->stb,
+		idx,
+		PRIV(atlas)->scale,
+		PRIV(atlas)->scale,
+		0,0,
+		&x0,&y0,
+		&x1, &y1);
+	gw = x1 - x0;
+	gh = y1 - y0;
+	stbtt_GetGlyphHMetrics(&PRIV(atlas)->stb, idx, &adv, &l);
+	adv *= PRIV(atlas)->scale;
+	off_x = PRIV(atlas)->scale*l;
+	off_y = atlas->glyph_max_h+y0;
+	stbtt_MakeGlyphBitmapSubpixel(
+		&PRIV(atlas)->stb,
+		PRIV(atlas)->bitmap,
+		atlas->glyph_max_w,
+		atlas->glyph_max_h,
+		atlas->glyph_max_w,
+		PRIV(atlas)->scale,
+		PRIV(atlas)->scale,
+		0, 0,
+		idx);
+
+	// TODO: bounds check usign atlas height
+	// TODO: clear spot area in the atlas before writing on it
+	unsigned int spot = cache_get_free_spot(&PRIV(atlas)->c);
+	unsigned int ty   = ((atlas->glyph_max_w * spot) / atlas->width) * atlas->glyph_max_h;
+	unsigned int tx   = (atlas->glyph_max_w * spot) % atlas->width;
+	unsigned int w    = atlas->width;
+
+	unsigned char *a = (void *)atlas->atlas;
+
+	//printf("max:%d %d spot:%d : %d %d %d %d\n", atlas->glyph_max_w, atlas->glyph_max_h, spot, tx, ty, off_x, off_y);
+
+	for (int y = 0; y < gh; y++) {
+		for (int x = 0; x < gw; x++) {
+			int c, r;
+			r = (ty+y)*w;
+			c = tx+x;
+			a[r+c] = PRIV(atlas)->bitmap[y*atlas->glyph_max_w+x];
+		}
+	}
+
+	struct font_glyph g = {
+		.codepoint = code,
+		.u = tx,
+		.v = ty,
+		.w = gw,
+		.h = gh,
+		.x = off_x,
+		.y = off_y-base,
+		.a = adv,
+	};
+	return cache_insert_at(&PRIV(atlas)->c, &g, g.codepoint, spot);
+}
+
+
+void font_dump(const struct font_atlas *atlas, const char *path)
+{
+	stbi_write_png(
+		path,
+		atlas->width,
+		atlas->height,
+		BDEPTH,
+		atlas->atlas,
+		BDEPTH*atlas->width);
+}