Disable `var` and `const` declarations

code/demo.odin

@@ -1,4 +1,22 @@
-import "fmt.odin";
+import (
+	"atomics.odin";
+	"bits.odin";
+	"decimal.odin";
+	"fmt.odin";
+	"hash.odin";
+	"math.odin";
+	"mem.odin";
+	"opengl.odin";
+	"os.odin";
+	"pool.odin";
+	"raw.odin";
+	"strconv.odin";
+	"strings.odin";
+	"sync.odin";
+	"types.odin";
+	"utf8.odin";
+	"utf16.odin";
+)
 
 proc general_stuff() {
 	// Complex numbers
@@ -20,13 +38,13 @@ proc general_stuff() {
 	}
 
 
-	type Foo struct {
+	Foo :: struct {
 		x: int,
 		y: f32,
 		z: string,
 	}
-	var foo = Foo{123, 0.513, "A string"};
-	var x, y, z = expand_to_tuple(foo);
+	foo := Foo{123, 0.513, "A string"};
+	x, y, z := expand_to_tuple(foo);
 	fmt.println(x, y, z);
 	compile_assert(type_of(x) == int);
 	compile_assert(type_of(y) == f32);
@@ -36,7 +54,7 @@ proc general_stuff() {
 	// By default, all variables are zeroed
 	// This can be overridden with the "uninitialized value"
 	// This is similar to `nil` but applied to everything
-	var undef_int: int = ---;
+	undef_int: int = ---;
 
 
 	// Context system is now implemented using Implicit Parameter Passing (IPP)
@@ -66,7 +84,7 @@ proc default_arguments() {
 }
 
 proc named_arguments() {
-	type Colour enum {
+	Colour :: enum {
 		Red,
 		Orange,
 		Yellow,
@@ -110,7 +128,7 @@ proc named_arguments() {
 	// Named arguments can also aid with default arguments
 	proc numerous_things(s: string, a = 1, b = 2, c = 3.14,
 	                     d = "The Best String!", e = false, f = 10.3/3.1, g = false) {
-		var g_str = g ? "true" : "false";
+		g_str := g ? "true" : "false";
 		fmt.printf("How many?! %s: %v\n", s, g_str);
 	}
 
@@ -150,13 +168,13 @@ proc default_return_values() {
 
 
 	// A more "real" example
-	type Error enum {
+	Error :: enum {
 		None,
 		WhyTheNumberThree,
 		TenIsTooBig,
 	};
 
-	type Entity struct {
+	Entity :: struct {
 		name: string,
 		id:   u32,
 	}
@@ -167,7 +185,7 @@ proc default_return_values() {
 		case input >= 10: return err = Error.TenIsTooBig;
 		}
 
-		var e = new(Entity);
+		e := new(Entity);
 		e.id = u32(input);
 
 		return result = e;
@@ -183,7 +201,7 @@ proc call_location() {
 		fmt.println();
 	}
 
-	var loc = #location(main);
+	loc := #location(main);
 	fmt.println("`main` is located at", loc);
 
 	fmt.println("This line is located at", #location());
@@ -203,18 +221,18 @@ proc explicit_parametric_polymorphic_procedures() {
 		return ^T(alloc(size_of(T), align_of(T)));
 	}
 
-	var int_ptr = alloc_type(int);
+	int_ptr := alloc_type(int);
 	defer free(int_ptr);
 	int_ptr^ = 137;
 	fmt.println(int_ptr, int_ptr^);
 
 	// Named arguments work too!
-	var another_ptr = alloc_type(T = f32);
+	another_ptr := alloc_type(T = f32);
 	defer free(another_ptr);
 
 
 	proc add(T: type, args: ..T) -> T {
-		var res: T;
+		res: T;
 		for arg in args {
 			res += arg;
 		}
@@ -224,12 +242,12 @@ proc explicit_parametric_polymorphic_procedures() {
 	fmt.println("add =", add(int, 1, 2, 3, 4, 5, 6));
 
 	proc swap(T: type, a, b: ^T) {
-		var tmp = a^;
+		tmp := a^;
 		a^ = b^;
 		b^ = tmp;
 	}
 
-	var a, b: int = 3, 4;
+	a, b: int = 3, 4;
 	fmt.println("Pre-swap:", a, b);
 	swap(int, &a, &b);
 	fmt.println("Post-swap:", a, b);
@@ -242,9 +260,9 @@ proc explicit_parametric_polymorphic_procedures() {
 
 	// A more complicated example using subtyping
 	// Something like this could be used in a game
-	type Vector2 struct {x, y: f32};
+	Vector2 :: struct {x, y: f32};
 
-	type Entity struct {
+	Entity :: struct {
 		using position: Vector2,
 		flags:          u64,
 		id:             u64,
@@ -254,27 +272,27 @@ proc explicit_parametric_polymorphic_procedures() {
 		derived:        any,
 	}
 
-	type Rock struct {
+	Rock :: struct {
 		using entity: ^Entity,
 		heavy: bool,
 	}
-	type Door struct {
+	Door :: struct {
 		using entity: ^Entity,
 		open:         bool,
 	}
-	type Monster struct {
+	Monster :: struct {
 		using entity: ^Entity,
 		is_robot:     bool,
 		is_zombie:    bool,
 	}
 
-	type EntityManager struct {
+	EntityManager :: struct {
 		batches: [dynamic]^EntityBatch,
 		next_portable_id: u32,
 	}
 
-	const ENTITIES_PER_BATCH = 16;
-	type EntityBatch struct {
+	ENTITIES_PER_BATCH :: 16;
+	EntityBatch :: struct {
 		data:        [ENTITIES_PER_BATCH]Entity,
 		occupied:    [ENTITIES_PER_BATCH]bool,
 		batch_index: u32,
@@ -285,7 +303,7 @@ proc explicit_parametric_polymorphic_procedures() {
 			if ok -> continue;
 			batch.occupied[i] = true;
 
-			var e = &batch.data[i];
+			e := &batch.data[i];
 			e.batch_index = u32(batch.batch_index);
 			e.slot_index  = u32(i);
 			e.portable_id = manager.next_portable_id;
@@ -297,11 +315,11 @@ proc explicit_parametric_polymorphic_procedures() {
 
 	proc gen_new_entity(manager: ^EntityManager) -> ^Entity {
 		for b in manager.batches {
-			var e = use_empty_slot(manager, b);
+			e := use_empty_slot(manager, b);
 			if e != nil -> return e;
 		}
 
-		var new_batch = new(EntityBatch);
+		new_batch := new(EntityBatch);
 		append(manager.batches, new_batch);
 		new_batch.batch_index = u32(len(manager.batches)-1);
 
@@ -311,7 +329,7 @@ proc explicit_parametric_polymorphic_procedures() {
 
 
 	proc new_entity(manager: ^EntityManager, Type: type, x, y: int) -> ^Type {
-		var result = new(Type);
+		result := new(Type);
 		result.entity = gen_new_entity(manager);
 		result.derived.data = result;
 		result.derived.type_info = type_info(Type);
@@ -322,16 +340,16 @@ proc explicit_parametric_polymorphic_procedures() {
 		return result;
 	}
 
-	var manager: EntityManager;
-	var entities: [dynamic]^Entity;
+	manager: EntityManager;
+	entities: [dynamic]^Entity;
 
-	var rock    = new_entity(&manager, Rock, 3, 5);
+	rock    := new_entity(&manager, Rock, 3, 5);
 
 	// Named arguments work too!
-	var door    = new_entity(manager = &manager, Type = Door, x = 3, y = 6);
+	door    := new_entity(manager = &manager, Type = Door, x = 3, y = 6);
 
 	// And named arguments can be any order
-	var monster = new_entity(
+	monster := new_entity(
 		y = 1,
 		x = 2,
 		manager = &manager,
@@ -417,8 +435,8 @@ proc main() {
 
 /*
 proc main() {
-	var program = "+ + * - /";
-	var accumulator = 0;
+	program := "+ + * - /";
+	accumulator := 0;
 
 	for token in program {
 		match token {

core/_preload.odin

@@ -113,17 +113,16 @@ type (
 
 // NOTE(bill): only the ones that are needed (not all types)
 // This will be set by the compiler
-var (
-	__type_table: []TypeInfo;
+__type_table: []TypeInfo;
+
+__argv__: ^^u8;
+__argc__: i32;
 
-	__argv__: ^^u8;
-	__argc__: i32;
-)
 
 proc type_info_base(info: ^TypeInfo) -> ^TypeInfo {
 	if info == nil -> return nil;
 
-	var base = info;
+	base := info;
 	match i in base {
 	case TypeInfo.Named:
 		base = i.base;
@@ -135,7 +134,7 @@ proc type_info_base(info: ^TypeInfo) -> ^TypeInfo {
 proc type_info_base_without_enum(info: ^TypeInfo) -> ^TypeInfo {
 	if info == nil -> return nil;
 
-	var base = info;
+	base := info;
 	match i in base {
 	case TypeInfo.Named:
 		base = i.base;
@@ -197,7 +196,7 @@ proc make_source_code_location(file: string, line, column: i64, procedure: strin
 
 
 
-const DEFAULT_ALIGNMENT = align_of([vector 4]f32);
+DEFAULT_ALIGNMENT :: align_of([vector 4]f32);
 
 proc __init_context_from_ptr(c: ^Context, other: ^Context) #cc_contextless {
 	if c == nil -> return;
@@ -231,7 +230,7 @@ proc __check_context() {
 
 proc alloc(size: int, alignment: int = DEFAULT_ALIGNMENT) -> rawptr #inline {
 	// __check_context();
-	var a = context.allocator;
+	a := context.allocator;
 	return a.procedure(a.data, AllocatorMode.Alloc, size, alignment, nil, 0, 0);
 }
 
@@ -252,14 +251,14 @@ proc free_ptr(ptr: rawptr) #inline {
 
 proc free_all() #inline {
 	// __check_context();
-	var a = context.allocator;
+	a := context.allocator;
 	a.procedure(a.data, AllocatorMode.FreeAll, 0, 0, nil, 0, 0);
 }
 
 
 proc resize(ptr: rawptr, old_size, new_size: int, alignment: int = DEFAULT_ALIGNMENT) -> rawptr #inline {
 	// __check_context();
-	var a = context.allocator;
+	a := context.allocator;
 	return a.procedure(a.data, AllocatorMode.Resize, new_size, alignment, ptr, old_size, 0);
 }
 
@@ -284,7 +283,7 @@ proc default_resize_align(old_memory: rawptr, old_size, new_size, alignment: int
 		return old_memory;
 	}
 
-	var new_memory = alloc(new_size, alignment);
+	new_memory := alloc(new_size, alignment);
 	if new_memory == nil {
 		return nil;
 	}
@@ -312,7 +311,7 @@ proc default_allocator_proc(allocator_data: rawptr, mode: AllocatorMode,
 		// NOTE(bill): Does nothing
 
 	case Resize:
-		var ptr = os.heap_resize(old_memory, size);
+		ptr := os.heap_resize(old_memory, size);
 		assert(ptr != nil);
 		return ptr;
 	}
@@ -478,11 +477,11 @@ foreign __llvm_core {
 	proc __sqrt_f64(x: f64) -> f64 #link_name "llvm.sqrt.f64";
 }
 proc __abs_complex64(x: complex64) -> f32 #inline #cc_contextless {
-	var r, i = real(x), imag(x);
+	r, i := real(x), imag(x);
 	return __sqrt_f32(r*r + i*i);
 }
 proc __abs_complex128(x: complex128) -> f64 #inline #cc_contextless {
-	var r, i = real(x), imag(x);
+	r, i := real(x), imag(x);
 	return __sqrt_f64(r*r + i*i);
 }
 
@@ -490,7 +489,7 @@ proc __abs_complex128(x: complex128) -> f64 #inline #cc_contextless {
 
 
 proc __dynamic_array_make(array_: rawptr, elem_size, elem_align: int, len, cap: int) {
-	var array = ^raw.DynamicArray(array_);
+	array := ^raw.DynamicArray(array_);
 	// __check_context();
 	array.allocator = context.allocator;
 	assert(array.allocator.procedure != nil);
@@ -502,7 +501,7 @@ proc __dynamic_array_make(array_: rawptr, elem_size, elem_align: int, len, cap:
 }
 
 proc __dynamic_array_reserve(array_: rawptr, elem_size, elem_align: int, cap: int) -> bool {
-	var array = ^raw.DynamicArray(array_);
+	array := ^raw.DynamicArray(array_);
 
 	if cap <= array.cap -> return true;
 
@@ -512,11 +511,11 @@ proc __dynamic_array_reserve(array_: rawptr, elem_size, elem_align: int, cap: in
 	}
 	assert(array.allocator.procedure != nil);
 
-	var old_size  = array.cap * elem_size;
-	var new_size  = cap * elem_size;
-	var allocator = array.allocator;
+	old_size  := array.cap * elem_size;
+	new_size  := cap * elem_size;
+	allocator := array.allocator;
 
-	var new_data = allocator.procedure(allocator.data, AllocatorMode.Resize, new_size, elem_align, array.data, old_size, 0);
+	new_data := allocator.procedure(allocator.data, AllocatorMode.Resize, new_size, elem_align, array.data, old_size, 0);
 	if new_data == nil -> return false;
 
 	array.data = new_data;
@@ -525,9 +524,9 @@ proc __dynamic_array_reserve(array_: rawptr, elem_size, elem_align: int, cap: in
 }
 
 proc __dynamic_array_resize(array_: rawptr, elem_size, elem_align: int, len: int) -> bool {
-	var array = ^raw.DynamicArray(array_);
+	array := ^raw.DynamicArray(array_);
 
-	var ok = __dynamic_array_reserve(array_, elem_size, elem_align, len);
+	ok := __dynamic_array_reserve(array_, elem_size, elem_align, len);
 	if ok -> array.len = len;
 	return ok;
 }
@@ -535,22 +534,22 @@ proc __dynamic_array_resize(array_: rawptr, elem_size, elem_align: int, len: int
 
 proc __dynamic_array_append(array_: rawptr, elem_size, elem_align: int,
                                items: rawptr, item_count: int) -> int {
-	var array = ^raw.DynamicArray(array_);
+	array := ^raw.DynamicArray(array_);
 
 	if item_count <= 0 || items == nil {
 		return array.len;
 	}
 
 
-	var ok = true;
+	ok := true;
 	if array.cap <= array.len+item_count {
-		var cap = 2 * array.cap + max(8, item_count);
+		cap := 2 * array.cap + max(8, item_count);
 		ok = __dynamic_array_reserve(array, elem_size, elem_align, cap);
 	}
 	// TODO(bill): Better error handling for failed reservation
 	if !ok -> return array.len;
 
-	var data = ^u8(array.data);
+	data := ^u8(array.data);
 	assert(data != nil);
 	__mem_copy(data + (elem_size*array.len), items, elem_size * item_count);
 	array.len += item_count;
@@ -558,17 +557,17 @@ proc __dynamic_array_append(array_: rawptr, elem_size, elem_align: int,
 }
 
 proc __dynamic_array_append_nothing(array_: rawptr, elem_size, elem_align: int) -> int {
-	var array = ^raw.DynamicArray(array_);
+	array := ^raw.DynamicArray(array_);
 
-	var ok = true;
+	ok := true;
 	if array.cap <= array.len+1 {
-		var cap = 2 * array.cap + max(8, 1);
+		cap := 2 * array.cap + max(8, 1);
 		ok = __dynamic_array_reserve(array, elem_size, elem_align, cap);
 	}
 	// TODO(bill): Better error handling for failed reservation
 	if !ok -> return array.len;
 
-	var data = ^u8(array.data);
+	data := ^u8(array.data);
 	assert(data != nil);
 	__mem_zero(data + (elem_size*array.len), elem_size);
 	array.len++;
@@ -577,7 +576,7 @@ proc __dynamic_array_append_nothing(array_: rawptr, elem_size, elem_align: int)
 
 proc __slice_append(slice_: rawptr, elem_size, elem_align: int,
                        items: rawptr, item_count: int) -> int {
-	var slice = ^raw.Slice(slice_);
+	slice := ^raw.Slice(slice_);
 
 	if item_count <= 0 || items == nil {
 		return slice.len;
@@ -585,7 +584,7 @@ proc __slice_append(slice_: rawptr, elem_size, elem_align: int,
 
 	item_count = min(slice.cap-slice.len, item_count);
 	if item_count > 0 {
-		var data = ^u8(slice.data);
+		data := ^u8(slice.data);
 		assert(data != nil);
 		__mem_copy(data + (elem_size*slice.len), items, elem_size * item_count);
 		slice.len += item_count;
@@ -598,7 +597,7 @@ proc __slice_append(slice_: rawptr, elem_size, elem_align: int,
 
 proc __default_hash(data: []u8) -> u128 {
 	proc fnv128a(data: []u8) -> u128 {
-		var h: u128 = 0x6c62272e07bb014262b821756295c58d;
+		h: u128 = 0x6c62272e07bb014262b821756295c58d;
 		for b in data {
 			h = (h ~ u128(b)) * 0x1000000000000000000013b;
 		}
@@ -610,37 +609,35 @@ proc __default_hash_string(s: string) -> u128 {
 	return __default_hash([]u8(s));
 }
 
-const __INITIAL_MAP_CAP = 16;
+__INITIAL_MAP_CAP :: 16;
 
-type (
-	__MapKey struct #ordered {
-		hash: u128,
-		str:  string,
-	}
+__MapKey :: struct #ordered {
+	hash: u128,
+	str:  string,
+}
 
-	__MapFindResult struct #ordered {
-		hash_index:  int,
-		entry_prev:  int,
-		entry_index: int,
-	}
+__MapFindResult :: struct #ordered {
+	hash_index:  int,
+	entry_prev:  int,
+	entry_index: int,
+}
 
-	__MapEntryHeader struct #ordered {
-		key:  __MapKey,
-		next: int,
-	/*
-		value: Value_Type,
-	*/
-	}
+__MapEntryHeader :: struct #ordered {
+	key:  __MapKey,
+	next: int,
+/*
+	value: Value_Type,
+*/
+}
 
-	__MapHeader struct #ordered {
-		m:             ^raw.DynamicMap,
-		is_key_string: bool,
-		entry_size:    int,
-		entry_align:   int,
-		value_offset:  int,
-		value_size:    int,
-	}
-)
+__MapHeader :: struct #ordered {
+	m:             ^raw.DynamicMap,
+	is_key_string: bool,
+	entry_size:    int,
+	entry_align:   int,
+	value_offset:  int,
+	value_size:    int,
+}
 
 proc __dynamic_map_reserve(using header: __MapHeader, cap: int)  {
 	__dynamic_array_reserve(&m.hashes, size_of(int), align_of(int), cap);
@@ -648,37 +645,37 @@ proc __dynamic_map_reserve(using header: __MapHeader, cap: int)  {
 }
 
 proc __dynamic_map_rehash(using header: __MapHeader, new_count: int) {
-	var new_header: __MapHeader = header;
-	var nm: raw.DynamicMap;
+	new_header: __MapHeader = header;
+	nm: raw.DynamicMap;
 	new_header.m = &nm;
 
-	var header_hashes = ^raw.DynamicArray(&header.m.hashes);
-	var nm_hashes = ^raw.DynamicArray(&nm.hashes);
+	header_hashes := ^raw.DynamicArray(&header.m.hashes);
+	nm_hashes     := ^raw.DynamicArray(&nm.hashes);
 
 	__dynamic_array_resize(nm_hashes, size_of(int), align_of(int), new_count);
 	__dynamic_array_reserve(&nm.entries, entry_size, entry_align, m.entries.len);
 	for i in 0..<new_count -> nm.hashes[i] = -1;
 
-	for var i = 0; i < m.entries.len; i++ {
+	for i := 0; i < m.entries.len; i++ {
 		if len(nm.hashes) == 0 {
 			__dynamic_map_grow(new_header);
 		}
 
-		var entry_header = __dynamic_map_get_entry(header, i);
-		var data = ^u8(entry_header);
+		entry_header := __dynamic_map_get_entry(header, i);
+		data := ^u8(entry_header);
 
-		var fr = __dynamic_map_find(new_header, entry_header.key);
-		var j = __dynamic_map_add_entry(new_header, entry_header.key);
+		fr := __dynamic_map_find(new_header, entry_header.key);
+		j := __dynamic_map_add_entry(new_header, entry_header.key);
 		if fr.entry_prev < 0 {
 			nm.hashes[fr.hash_index] = j;
 		} else {
-			var e = __dynamic_map_get_entry(new_header, fr.entry_prev);
+			e := __dynamic_map_get_entry(new_header, fr.entry_prev);
 			e.next = j;
 		}
 
-		var e = __dynamic_map_get_entry(new_header, j);
+		e := __dynamic_map_get_entry(new_header, j);
 		e.next = fr.entry_index;
-		var ndata = ^u8(e);
+		ndata := ^u8(e);
 		__mem_copy(ndata+value_offset, data+value_offset, value_size);
 
 		if __dynamic_map_full(new_header) {
@@ -691,17 +688,17 @@ proc __dynamic_map_rehash(using header: __MapHeader, new_count: int) {
 }
 
 proc __dynamic_map_get(h: __MapHeader, key: __MapKey) -> rawptr {
-	var index = __dynamic_map_find(h, key).entry_index;
+	index := __dynamic_map_find(h, key).entry_index;
 	if index >= 0 {
-		var data = ^u8(__dynamic_map_get_entry(h, index));
-		var val = data + h.value_offset;
+		data := ^u8(__dynamic_map_get_entry(h, index));
+		val := data + h.value_offset;
 		return val;
 	}
 	return nil;
 }
 
 proc __dynamic_map_set(using h: __MapHeader, key: __MapKey, value: rawptr) {
-	var index: int;
+	index: int;
 	assert(value != nil);
 
 
@@ -710,22 +707,22 @@ proc __dynamic_map_set(using h: __MapHeader, key: __MapKey, value: rawptr) {
 		__dynamic_map_grow(h);
 	}
 
-	var fr = __dynamic_map_find(h, key);
+	fr := __dynamic_map_find(h, key);
 	if fr.entry_index >= 0 {
 		index = fr.entry_index;
 	} else {
 		index = __dynamic_map_add_entry(h, key);
 		if fr.entry_prev >= 0 {
-			var entry = __dynamic_map_get_entry(h, fr.entry_prev);
+			entry := __dynamic_map_get_entry(h, fr.entry_prev);
 			entry.next = index;
 		} else {
 			m.hashes[fr.hash_index] = index;
 		}
 	}
 	{
-		var e = __dynamic_map_get_entry(h, index);
+		e := __dynamic_map_get_entry(h, index);
 		e.key = key;
-		var val = ^u8(e) + value_offset;
+		val := ^u8(e) + value_offset;
 		__mem_copy(val, value, value_size);
 	}
 
@@ -736,7 +733,7 @@ proc __dynamic_map_set(using h: __MapHeader, key: __MapKey, value: rawptr) {
 
 
 proc __dynamic_map_grow(using h: __MapHeader) {
-	var new_count = max(2*m.entries.cap + 8, __INITIAL_MAP_CAP);
+	new_count := max(2*m.entries.cap + 8, __INITIAL_MAP_CAP);
 	__dynamic_map_rehash(h, new_count);
 }
 
@@ -754,12 +751,12 @@ proc __dynamic_map_hash_equal(h: __MapHeader, a, b: __MapKey) -> bool {
 }
 
 proc __dynamic_map_find(using h: __MapHeader, key: __MapKey) -> __MapFindResult {
-	var fr = __MapFindResult{-1, -1, -1};
+	fr := __MapFindResult{-1, -1, -1};
 	if len(m.hashes) > 0 {
 		fr.hash_index = int(key.hash % u128(len(m.hashes)));
 		fr.entry_index = m.hashes[fr.hash_index];
 		for fr.entry_index >= 0 {
-			var entry = __dynamic_map_get_entry(h, fr.entry_index);
+			entry := __dynamic_map_get_entry(h, fr.entry_index);
 			if __dynamic_map_hash_equal(h, entry.key, key) {
 				return fr;
 			}
@@ -771,10 +768,10 @@ proc __dynamic_map_find(using h: __MapHeader, key: __MapKey) -> __MapFindResult
 }
 
 proc __dynamic_map_add_entry(using h: __MapHeader, key: __MapKey) -> int {
-	var prev = m.entries.len;
-	var c = __dynamic_array_append_nothing(&m.entries, entry_size, entry_align);
+	prev := m.entries.len;
+	c := __dynamic_array_append_nothing(&m.entries, entry_size, entry_align);
 	if c != prev {
-		var end = __dynamic_map_get_entry(h, c-1);
+		end := __dynamic_map_get_entry(h, c-1);
 		end.key = key;
 		end.next = -1;
 	}
@@ -783,14 +780,14 @@ proc __dynamic_map_add_entry(using h: __MapHeader, key: __MapKey) -> int {
 
 
 proc __dynamic_map_delete(using h: __MapHeader, key: __MapKey) {
-	var fr = __dynamic_map_find(h, key);
+	fr := __dynamic_map_find(h, key);
 	if fr.entry_index >= 0 {
 		__dynamic_map_erase(h, fr);
 	}
 }
 
 proc __dynamic_map_get_entry(using h: __MapHeader, index: int) -> ^__MapEntryHeader {
-	var data = ^u8(m.entries.data) + index*entry_size;
+	data := ^u8(m.entries.data) + index*entry_size;
 	return ^__MapEntryHeader(data);
 }
 
@@ -805,7 +802,7 @@ proc __dynamic_map_erase(using h: __MapHeader, fr: __MapFindResult) {
 		m.entries.len--;
 	}
 	__mem_copy(__dynamic_map_get_entry(h, fr.entry_index), __dynamic_map_get_entry(h, m.entries.len-1), entry_size);
-	var last = __dynamic_map_find(h, __dynamic_map_get_entry(h, fr.entry_index).key);
+	last := __dynamic_map_find(h, __dynamic_map_get_entry(h, fr.entry_index).key);
 	if last.entry_prev >= 0 {
 		__dynamic_map_get_entry(h, last.entry_prev).next = fr.entry_index;
 	} else {

core/_soft_numbers.odin

@@ -1,8 +1,8 @@
 #shared_global_scope;
 
 proc __multi3(a, b: u128) -> u128 #cc_c #link_name "__multi3" {
-	const bits_in_dword_2 = size_of(i64) * 4;
-	const lower_mask = u128(~u64(0) >> bits_in_dword_2);
+	bits_in_dword_2 :: size_of(i64) * 4;
+	lower_mask :: u128(~u64(0) >> bits_in_dword_2);
 
 
 	when ODIN_ENDIAN == "bit" {
@@ -17,18 +17,18 @@ proc __multi3(a, b: u128) -> u128 #cc_c #link_name "__multi3" {
 		};
 	}
 
-	var r: TWords;
-	var t: u64;
+	r: TWords;
+	t: u64;
 
-	r.lo = u64(a & lower_mask) * u64(b & lower_mask);
-	t = r.lo >> bits_in_dword_2;
+	r.lo =  u64(a & lower_mask) * u64(b & lower_mask);
+	t    =  r.lo >> bits_in_dword_2;
 	r.lo &= u64(lower_mask);
-	t += u64(a >> bits_in_dword_2) * u64(b & lower_mask);
+	t    += u64(a >> bits_in_dword_2) * u64(b & lower_mask);
 	r.lo += u64(t & u64(lower_mask)) << bits_in_dword_2;
-	r.hi = t >> bits_in_dword_2;
-	t = r.lo >> bits_in_dword_2;
+	r.hi =  t >> bits_in_dword_2;
+	t    =  r.lo >> bits_in_dword_2;
 	r.lo &= u64(lower_mask);
-	t += u64(b >> bits_in_dword_2) * u64(a & lower_mask);
+	t    += u64(b >> bits_in_dword_2) * u64(a & lower_mask);
 	r.lo += u64(t & u64(lower_mask)) << bits_in_dword_2;
 	r.hi += t >> bits_in_dword_2;
 	r.hi += u64(a >> bits_in_dword_2) * u64(b >> bits_in_dword_2);
@@ -36,7 +36,7 @@ proc __multi3(a, b: u128) -> u128 #cc_c #link_name "__multi3" {
 }
 
 proc __u128_mod(a, b: u128) -> u128 #cc_c #link_name "__umodti3" {
-	var r: u128;
+	r: u128;
 	__u128_quo_mod(a, b, &r);
 	return r;
 }
@@ -46,7 +46,7 @@ proc __u128_quo(a, b: u128) -> u128 #cc_c #link_name "__udivti3" {
 }
 
 proc __i128_mod(a, b: i128) -> i128 #cc_c #link_name "__modti3" {
-	var r: i128;
+	r: i128;
 	__i128_quo_mod(a, b, &r);
 	return r;
 }
@@ -56,16 +56,16 @@ proc __i128_quo(a, b: i128) -> i128 #cc_c #link_name "__divti3" {
 }
 
 proc __i128_quo_mod(a, b: i128, rem: ^i128) -> (quo: i128) #cc_c #link_name "__divmodti4" {
-	var s: i128;
+	s: i128;
 	s = b >> 127;
 	b = (b~s) - s;
 	s = a >> 127;
 	b = (a~s) - s;
 
-	var uquo: u128;
-	var urem = __u128_quo_mod(transmute(u128, a), transmute(u128, b), &uquo);
-	var iquo = transmute(i128, uquo);
-	var irem = transmute(i128, urem);
+	uquo: u128;
+	urem := __u128_quo_mod(transmute(u128, a), transmute(u128, b), &uquo);
+	iquo := transmute(i128, uquo);
+	irem := transmute(i128, urem);
 
 	iquo = (iquo~s) - s;
 	irem = (irem~s) - s;
@@ -75,14 +75,14 @@ proc __i128_quo_mod(a, b: i128, rem: ^i128) -> (quo: i128) #cc_c #link_name "__d
 
 
 proc __u128_quo_mod(a, b: u128, rem: ^u128) -> (quo: u128) #cc_c #link_name "__udivmodti4" {
-	var alo, ahi = u64(a), u64(a>>64);
-	var blo, bhi = u64(b), u64(b>>64);
+	alo, ahi := u64(a), u64(a>>64);
+	blo, bhi := u64(b), u64(b>>64);
 	if b == 0 {
 		if rem != nil { rem^ = 0; }
 		return u128(alo/blo);
 	}
 
-	var r, d, x, q: u128 = a, b, 1, 0;
+	r, d, x, q: u128 = a, b, 1, 0;
 
 	for r >= d && (d>>127)&1 == 0 {
 		x <<= 1;
@@ -106,7 +106,7 @@ proc __u128_quo_mod(a, b: u128, rem: ^u128) -> (quo: u128) #cc_c #link_name "__u
 proc __f16_to_f32(f: f16) -> f32 #cc_c #no_inline #link_name "__gnu_h2f_ieee" {
 	when true {
 		// Source: https://fgiesen.wordpress.com/2012/03/28/half-to-float-done-quic/
-		const FP32 = raw_union {u: u32, f: f32};
+		FP32 :: raw_union {u: u32, f: f32};
 
 		magic, was_infnan: FP32;
 		magic.u = (254-15) << 23;
@@ -130,16 +130,16 @@ proc __f16_to_f32(f: f16) -> f32 #cc_c #no_inline #link_name "__gnu_h2f_ieee" {
 proc __f32_to_f16(f_: f32) -> f16 #cc_c #no_inline #link_name "__gnu_f2h_ieee" {
 	when false {
 		// Source: https://gist.github.com/rygorous/2156668
-		const FP16 = raw_union {u: u16, f: f16};
-		const FP32 = raw_union {u: u32, f: f32};
+		FP16 :: raw_union {u: u16, f: f16};
+		FP32 :: raw_union {u: u32, f: f32};
 
 		f32infty, f16infty, magic: FP32;
 		f32infty.u = 255<<23;
 		f16infty.u =  31<<23;
 		magic.u    =  15<<23;
 
-		const sign_mask = u32(0x80000000);
-		const round_mask = ~u32(0x0fff);
+		sign_mask :: u32(0x80000000);
+		round_mask :: ~u32(0x0fff);
 
 		f := transmute(FP32, f_);
 

core/atomics.odin

@@ -2,7 +2,7 @@
 // Inline vs external file?
 
 import win32 "sys/windows.odin" when ODIN_OS == "windows";
-var _ = compile_assert(ODIN_ARCH == "amd64"); // TODO(bill): x86 version
+_ := compile_assert(ODIN_ARCH == "amd64"); // TODO(bill): x86 version
 
 
 proc yield_thread() { win32.mm_pause(); }
@@ -34,8 +34,8 @@ proc fetch_or(a: ^i32, operand: i32) -> i32 {
 	return win32.interlocked_or(a, operand);
 }
 proc spin_lock(a: ^i32, time_out: int) -> bool { // NOTE(bill) time_out = -1 as default
-	var old_value = compare_exchange(a, 1, 0);
-	var counter = 0;
+	old_value := compare_exchange(a, 1, 0);
+	counter := 0;
 	for old_value != 0 && (time_out < 0 || counter < time_out) {
 		counter++;
 		yield_thread();
@@ -50,7 +50,7 @@ proc spin_unlock(a: ^i32) {
 }
 proc try_acquire_lock(a: ^i32) -> bool {
 	yield_thread();
-	var old_value = compare_exchange(a, 1, 0);
+	old_value := compare_exchange(a, 1, 0);
 	mfence();
 	return old_value == 0;
 }
@@ -78,8 +78,8 @@ proc fetch_or(a: ^i64, operand: i64) -> i64 {
 	return win32.interlocked_or64(a, operand);
 }
 proc spin_lock(a: ^i64, time_out: int) -> bool { // NOTE(bill) time_out = -1 as default
-	var old_value = compare_exchange(a, 1, 0);
-	var counter = 0;
+	old_value := compare_exchange(a, 1, 0);
+	counter := 0;
 	for old_value != 0 && (time_out < 0 || counter < time_out) {
 		counter++;
 		yield_thread();
@@ -94,7 +94,7 @@ proc spin_unlock(a: ^i64) {
 }
 proc try_acquire_lock(a: ^i64) -> bool {
 	yield_thread();
-	var old_value = compare_exchange(a, 1, 0);
+	old_value := compare_exchange(a, 1, 0);
 	mfence();
 	return old_value == 0;
 }

core/bits.odin

@@ -1,28 +1,26 @@
-const (
-	U8_MIN   =   u8(0);
-	U16_MIN  =  u16(0);
-	U32_MIN  =  u32(0);
-	U64_MIN  =  u64(0);
-	U128_MIN = u128(0);
+U8_MIN   ::   u8(0);
+U16_MIN  ::  u16(0);
+U32_MIN  ::  u32(0);
+U64_MIN  ::  u64(0);
+U128_MIN :: u128(0);
 
-	I8_MIN   =   i8(-0x80);
-	I16_MIN  =  i16(-0x8000);
-	I32_MIN  =  i32(-0x8000_0000);
-	I64_MIN  =  i64(-0x8000_0000_0000_0000);
-	I128_MIN = i128(-0x8000_0000_0000_0000_0000_0000_0000_0000);
+I8_MIN   ::   i8(-0x80);
+I16_MIN  ::  i16(-0x8000);
+I32_MIN  ::  i32(-0x8000_0000);
+I64_MIN  ::  i64(-0x8000_0000_0000_0000);
+I128_MIN :: i128(-0x8000_0000_0000_0000_0000_0000_0000_0000);
 
-	U8_MAX   =   ~u8(0);
-	U16_MAX  =  ~u16(0);
-	U32_MAX  =  ~u32(0);
-	U64_MAX  =  ~u64(0);
-	U128_MAX = ~u128(0);
+U8_MAX   ::   ~u8(0);
+U16_MAX  ::  ~u16(0);
+U32_MAX  ::  ~u32(0);
+U64_MAX  ::  ~u64(0);
+U128_MAX :: ~u128(0);
 
-	I8_MAX   =   i8(0x7f);
-	I16_MAX  =  i16(0x7fff);
-	I32_MAX  =  i32(0x7fff_ffff);
-	I64_MAX  =  i64(0x7fff_ffff_ffff_ffff);
-	I128_MAX = i128(0x7fff_ffff_ffff_ffff_ffff_ffff_ffff_ffff);
-)
+I8_MAX   ::   i8(0x7f);
+I16_MAX  ::  i16(0x7fff);
+I32_MAX  ::  i32(0x7fff_ffff);
+I64_MAX  ::  i64(0x7fff_ffff_ffff_ffff);
+I128_MAX :: i128(0x7fff_ffff_ffff_ffff_ffff_ffff_ffff_ffff);
 
 proc count_ones(i:   u8) ->   u8 { foreign __llvm_core proc __llvm_ctpop(u8)   ->   u8 #link_name "llvm.ctpop.i8";  return __llvm_ctpop(i); }
 proc count_ones(i:   i8) ->   i8 { foreign __llvm_core proc __llvm_ctpop(i8)   ->   i8 #link_name "llvm.ctpop.i8";  return __llvm_ctpop(i); }
@@ -198,19 +196,19 @@ proc overflowing_add(lhs, rhs: u128) -> (u128, bool) { foreign __llvm_core proc
 proc overflowing_add(lhs, rhs: i128) -> (i128, bool) { foreign __llvm_core proc op(i128, i128) -> (i128, bool) #link_name "llvm.sadd.with.overflow.i128"; return op(lhs, rhs); }
 proc overflowing_add(lhs, rhs: uint) -> (uint, bool) {
 	when size_of(uint) == size_of(u32) {
-		var x, ok = overflowing_add(u32(lhs), u32(rhs));
+		x, ok := overflowing_add(u32(lhs), u32(rhs));
 		return uint(x), ok;
 	} else {
-		var x, ok = overflowing_add(u64(lhs), u64(rhs));
+		x, ok := overflowing_add(u64(lhs), u64(rhs));
 		return uint(x), ok;
 	}
 }
 proc overflowing_add(lhs, rhs: int) -> (int, bool) {
 	when size_of(int) == size_of(i32) {
-		var x, ok = overflowing_add(i32(lhs), i32(rhs));
+		x, ok := overflowing_add(i32(lhs), i32(rhs));
 		return int(x), ok;
 	} else {
-		var x, ok = overflowing_add(i64(lhs), i64(rhs));
+		x, ok := overflowing_add(i64(lhs), i64(rhs));
 		return int(x), ok;
 	}
 }
@@ -227,19 +225,19 @@ proc overflowing_sub(lhs, rhs: u128) -> (u128, bool) { foreign __llvm_core proc
 proc overflowing_sub(lhs, rhs: i128) -> (i128, bool) { foreign __llvm_core proc op(i128, i128) -> (i128, bool) #link_name "llvm.ssub.with.overflow.i128"; return op(lhs, rhs); }
 proc overflowing_sub(lhs, rhs: uint) -> (uint, bool) {
 	when size_of(uint) == size_of(u32) {
-		var x, ok = overflowing_sub(u32(lhs), u32(rhs));
+		x, ok := overflowing_sub(u32(lhs), u32(rhs));
 		return uint(x), ok;
 	} else {
-		var x, ok = overflowing_sub(u64(lhs), u64(rhs));
+		x, ok := overflowing_sub(u64(lhs), u64(rhs));
 		return uint(x), ok;
 	}
 }
 proc overflowing_sub(lhs, rhs: int) -> (int, bool) {
 	when size_of(int) == size_of(i32) {
-		var x, ok = overflowing_sub(i32(lhs), i32(rhs));
+		x, ok := overflowing_sub(i32(lhs), i32(rhs));
 		return int(x), ok;
 	} else {
-		var x, ok = overflowing_sub(i64(lhs), i64(rhs));
+		x, ok := overflowing_sub(i64(lhs), i64(rhs));
 		return int(x), ok;
 	}
 }
@@ -256,19 +254,19 @@ proc overflowing_mul(lhs, rhs: u128) -> (u128, bool) { foreign __llvm_core proc
 proc overflowing_mul(lhs, rhs: i128) -> (i128, bool) { foreign __llvm_core proc op(i128, i128) -> (i128, bool) #link_name "llvm.smul.with.overflow.i128"; return op(lhs, rhs); }
 proc overflowing_mul(lhs, rhs: uint) -> (uint, bool) {
 	when size_of(uint) == size_of(u32) {
-		var x, ok = overflowing_mul(u32(lhs), u32(rhs));
+		x, ok := overflowing_mul(u32(lhs), u32(rhs));
 		return uint(x), ok;
 	} else {
-		var x, ok = overflowing_mul(u64(lhs), u64(rhs));
+		x, ok := overflowing_mul(u64(lhs), u64(rhs));
 		return uint(x), ok;
 	}
 }
 proc overflowing_mul(lhs, rhs: int) -> (int, bool) {
 	when size_of(int) == size_of(i32) {
-		var x, ok = overflowing_mul(i32(lhs), i32(rhs));
+		x, ok := overflowing_mul(i32(lhs), i32(rhs));
 		return int(x), ok;
 	} else {
-		var x, ok = overflowing_mul(i64(lhs), i64(rhs));
+		x, ok := overflowing_mul(i64(lhs), i64(rhs));
 		return int(x), ok;
 	}
 }

core/decimal.odin

@@ -16,7 +16,7 @@ proc decimal_to_string(buf: []u8, a: ^Decimal) -> string {
 	}
 
 
-	var n = 10 + a.count + abs(a.decimal_point);
+	n := 10 + a.count + abs(a.decimal_point);
 
 	// TODO(bill): make this work with a buffer that's not big enough
 	assert(len(buf) >= n);
@@ -27,7 +27,7 @@ proc decimal_to_string(buf: []u8, a: ^Decimal) -> string {
 		return string(buf[0..<1]);
 	}
 
-	var w = 0;
+	w := 0;
 	if a.decimal_point <= 0 {
 		buf[w] = '0'; w++;
 		buf[w] = '.'; w++;
@@ -57,10 +57,10 @@ proc trim(a: ^Decimal) {
 
 
 proc assign(a: ^Decimal, i: u64) {
-	var buf: [32]u8;
-	var n = 0;
+	buf: [32]u8;
+	n := 0;
 	for i > 0 {
-		var j = i/10;
+		j := i/10;
 		i -= 10*j;
 		buf[n] = u8('0'+i);
 		n++;
@@ -79,10 +79,10 @@ proc assign(a: ^Decimal, i: u64) {
 
 
 proc shift_right(a: ^Decimal, k: uint) {
-	var r = 0; // read index
-	var w = 0; // write index
+	r := 0; // read index
+	w := 0; // write index
 
-	var n: uint;
+	n: uint;
 	for ; n>>k == 0; r++ {
 		if r >= a.count {
 			if n == 0 {
@@ -96,16 +96,16 @@ proc shift_right(a: ^Decimal, k: uint) {
 			}
 			break;
 		}
-		var c = uint(a.digits[r]);
+		c := uint(a.digits[r]);
 		n = n*10 + c - '0';
 	}
 	a.decimal_point -= r-1;
 
-	var mask: uint = (1<<k) - 1;
+	mask: uint = (1<<k) - 1;
 
 	for ; r < a.count; r++ {
-		var c = uint(a.digits[r]);
-		var dig = n>>k;
+		c := uint(a.digits[r]);
+		dig := n>>k;
 		n &= mask;
 		a.digits[w] = u8('0' + dig);
 		w++;
@@ -113,7 +113,7 @@ proc shift_right(a: ^Decimal, k: uint) {
 	}
 
 	for n > 0 {
-		var dig = n>>k;
+		dig := n>>k;
 		n &= mask;
 		if w < len(a.digits) {
 			a.digits[w] = u8('0' + dig);
@@ -130,16 +130,16 @@ proc shift_right(a: ^Decimal, k: uint) {
 }
 
 proc shift_left(a: ^Decimal, k: uint) {
-	var delta = int(k/4);
+	delta := int(k/4);
 
-	var r = a.count;       // read index
-	var w = a.count+delta; // write index
+	r := a.count;       // read index
+	w := a.count+delta; // write index
 
-	var n: uint;
+	n: uint;
 	for r--; r >= 0; r-- {
 		n += (uint(a.digits[r]) - '0') << k;
-		var quo = n/10;
-		var rem = n - 10*quo;
+		quo := n/10;
+		rem := n - 10*quo;
 		w--;
 		if w < len(a.digits) {
 			a.digits[w] = u8('0' + rem);
@@ -150,8 +150,8 @@ proc shift_left(a: ^Decimal, k: uint) {
 	}
 
 	for n > 0 {
-		var quo = n/10;
-		var rem = n - 10*quo;
+		quo := n/10;
+		rem := n - 10*quo;
 		w--;
 		if 0 <= w && w < len(a.digits) {
 			a.digits[w] = u8('0' + rem);
@@ -168,10 +168,8 @@ proc shift_left(a: ^Decimal, k: uint) {
 }
 
 proc shift(a: ^Decimal, k: int) {
-	const (
-		uint_size = 8*size_of(uint);
-		max_shift = uint_size-4;
-	)
+	uint_size :: 8*size_of(uint);
+	max_shift :: uint_size-4;
 
 	match {
 	case a.count == 0:
@@ -215,8 +213,8 @@ proc round(a: ^Decimal, nd: int) {
 proc round_up(a: ^Decimal, nd: int) {
 	if nd < 0 || nd >= a.count { return; }
 
-	for var i = nd-1; i >= 0; i-- {
-		if var c = a.digits[i]; c < '9' {
+	for i := nd-1; i >= 0; i-- {
+		if c := a.digits[i]; c < '9' {
 			a.digits[i]++;
 			a.count = i+1;
 			return;
@@ -241,9 +239,9 @@ proc rounded_integer(a: ^Decimal) -> u64 {
 	if a.decimal_point > 20 {
 		return 0xffff_ffff_ffff_ffff;
 	}
-	var i: int;
-	var n: u64 = 0;
-	var m = min(a.decimal_point, a.count);
+	i: int;
+	n: u64 = 0;
+	m := min(a.decimal_point, a.count);
 	for i = 0; i < m; i++ {
 		n = n*10 + u64(a.digits[i]-'0');
 	}

core/fmt.odin

@@ -7,7 +7,7 @@ import (
 	"raw.odin";
 )
 
-const _BUFFER_SIZE = 1<<12;
+_BUFFER_SIZE :: 1<<12;
 
 type StringBuffer union {
 	Static {buf: []u8},
@@ -89,45 +89,45 @@ proc write_rune(buf: ^StringBuffer, r: rune) {
 		return;
 	}
 
-	var b, n = utf8.encode_rune(r);
+	b, n := utf8.encode_rune(r);
 	write_bytes(buf, b[0..<n]);
 }
 
 proc write_int(buf: ^StringBuffer, i: i128, base: int) {
-	var b: [129]u8;
-	var s = strconv.append_bits(b[0..<0], u128(i), base, true, 128, strconv.digits, 0);
+	b: [129]u8;
+	s := strconv.append_bits(b[0..<0], u128(i), base, true, 128, strconv.digits, 0);
 	write_string(buf, s);
 }
 proc write_int(buf: ^StringBuffer, i: i64, base: int) {
-	var b: [129]u8;
-	var s = strconv.append_bits(b[0..<0], u128(i), base, true, 64, strconv.digits, 0);
+	b: [129]u8;
+	s := strconv.append_bits(b[0..<0], u128(i), base, true, 64, strconv.digits, 0);
 	write_string(buf, s);
 }
 
 
 
 proc fprint(fd: os.Handle, args: ..any) -> int {
-	var data: [_BUFFER_SIZE]u8;
-	var buf = make_string_buffer_from_slice(data[0..<0]);
+	data: [_BUFFER_SIZE]u8;
+	buf := make_string_buffer_from_slice(data[0..<0]);
 	sbprint(&buf, ..args);
-	var res = string_buffer_data(buf);
+	res := string_buffer_data(buf);
 	os.write(fd, res);
 	return len(res);
 }
 
 proc fprintln(fd: os.Handle, args: ..any) -> int {
-	var data: [_BUFFER_SIZE]u8;
-	var buf = make_string_buffer_from_slice(data[0..<0]);
+	data: [_BUFFER_SIZE]u8;
+	buf := make_string_buffer_from_slice(data[0..<0]);
 	sbprintln(&buf, ..args);
-	var res = string_buffer_data(buf);
+	res := string_buffer_data(buf);
 	os.write(fd, res);
 	return len(res);
 }
 proc fprintf(fd: os.Handle, fmt: string, args: ..any) -> int {
-	var data: [_BUFFER_SIZE]u8;
-	var buf = make_string_buffer_from_slice(data[0..<0]);
+	data: [_BUFFER_SIZE]u8;
+	buf := make_string_buffer_from_slice(data[0..<0]);
 	sbprintf(&buf, fmt, ..args);
-	var res = string_buffer_data(buf);
+	res := string_buffer_data(buf);
 	os.write(fd, res);
 	return len(res);
 }
@@ -145,17 +145,17 @@ proc printf_err  (fmt: string, args: ..any) -> int { return fprintf(os.stderr, f
 // aprint* procedures return a string that was allocated with the current context
 // They must be freed accordingly
 proc aprint(args: ..any) -> string {
-	var buf = make_string_dynamic_buffer();
+	buf := make_string_dynamic_buffer();
 	sbprint(&buf, ..args);
 	return to_string(buf);
 }
 proc aprintln(args: ..any) -> string {
-	var buf = make_string_dynamic_buffer();
+	buf := make_string_dynamic_buffer();
 	sbprintln(&buf, ..args);
 	return to_string(buf);
 }
 proc aprintf(fmt: string, args: ..any) -> string {
-	var buf = make_string_dynamic_buffer();
+	buf := make_string_dynamic_buffer();
 	sbprintf(&buf, fmt, ..args);
 	return to_string(buf);
 }
@@ -164,15 +164,15 @@ proc aprintf(fmt: string, args: ..any) -> string {
 // bprint* procedures return a string that was allocated with the current context
 // They must be freed accordingly
 proc bprint(buf: []u8, args: ..any) -> string {
-	var sb = make_string_buffer_from_slice(buf[0..<0..<len(buf)]);
+	sb := make_string_buffer_from_slice(buf[0..<0..<len(buf)]);
 	return sbprint(&sb, ..args);
 }
 proc bprintln(buf: []u8, args: ..any) -> string {
-	var sb = make_string_buffer_from_slice(buf[0..<0..<len(buf)]);
+	sb := make_string_buffer_from_slice(buf[0..<0..<len(buf)]);
 	return sbprintln(&sb, ..args);
 }
 proc bprintf(buf: []u8, fmt: string, args: ..any) -> string {
-	var sb = make_string_buffer_from_slice(buf[0..<0..<len(buf)]);
+	sb := make_string_buffer_from_slice(buf[0..<0..<len(buf)]);
 	return sbprintf(&sb, fmt, ..args);
 }
 
@@ -182,8 +182,8 @@ proc bprintf(buf: []u8, fmt: string, args: ..any) -> string {
 
 
 proc fprint_type(fd: os.Handle, info: ^TypeInfo) {
-	var data: [_BUFFER_SIZE]u8;
-	var buf = make_string_buffer_from_slice(data[0..<0]);
+	data: [_BUFFER_SIZE]u8;
+	buf := make_string_buffer_from_slice(data[0..<0]);
 	write_type(&buf, info);
 	os.write(fd, string_buffer_data(buf));
 }
@@ -237,7 +237,7 @@ proc write_type(buf: ^StringBuffer, ti: ^TypeInfo) {
 		if info.params == nil {
 			write_string(buf, "()");
 		} else {
-			var t = info.params.(^Tuple);
+			t := info.params.(^Tuple);
 			write_string(buf, "(");
 			for t, i in t.types {
 				if i > 0 -> write_string(buf, ", ");
@@ -250,12 +250,12 @@ proc write_type(buf: ^StringBuffer, ti: ^TypeInfo) {
 			write_type(buf, info.results);
 		}
 	case Tuple:
-		var count = len(info.names);
+		count := len(info.names);
 		if count != 1 -> write_string(buf, "(");
 		for name, i in info.names {
 			if i > 0 -> write_string(buf, ", ");
 
-			var t = info.types[i];
+			t := info.types[i];
 
 			if len(name) > 0 {
 				write_string(buf, name);
@@ -267,7 +267,7 @@ proc write_type(buf: ^StringBuffer, ti: ^TypeInfo) {
 
 	case Array:
 		write_string(buf, "[");
-		var fi = FmtInfo{buf = buf};
+		fi := FmtInfo{buf = buf};
 		write_int(buf, i64(info.count), 10);
 		write_string(buf, "]");
 		write_type(buf, info.elem);
@@ -309,8 +309,8 @@ proc write_type(buf: ^StringBuffer, ti: ^TypeInfo) {
 
 	case Union:
 		write_string(buf, "union {");
-		var cf = info.common_fields;
-		var total_count = 0;
+		cf := info.common_fields;
+		total_count := 0;
 		for name, i in cf.names {
 			if i > 0 -> write_string(buf, ", ");
 			write_string(buf, name);
@@ -324,13 +324,13 @@ proc write_type(buf: ^StringBuffer, ti: ^TypeInfo) {
 			write_byte(buf, '{');
 			defer write_byte(buf, '}');
 
-			var variant_type = type_info_base(info.variant_types[i]);
-			var variant = variant_type.(^Struct);
+			variant_type := type_info_base(info.variant_types[i]);
+			variant := variant_type.(^Struct);
 
-			var vc = len(variant.names)-len(cf.names);
-			for j in 0..vc {
+			vc := len(variant.names)-len(cf.names);
+			for j in 0..<vc {
 				if j > 0 -> write_string(buf, ", ");
-				var index = j + len(cf.names);
+				index := j + len(cf.names);
 				write_string(buf, variant.names[index]);
 				write_string(buf, ": ");
 				write_type(buf, variant.types[index]);
@@ -382,12 +382,12 @@ proc _parse_int(s: string, offset: int) -> (result: int, offset: int, ok: bool)
 		return '0' <= r && r <= '9';
 	}
 
-	var result = 0;
-	var ok = true;
+	result := 0;
+	ok := true;
 
-	var i = 0;
+	i := 0;
 	for i < len(s[offset..]) {
-		var c = rune(s[offset+i]);
+		c := rune(s[offset+i]);
 		if !is_digit(c) -> break;
 		i++;
 
@@ -406,7 +406,7 @@ proc _arg_number(fi: ^FmtInfo, arg_index: int, format: string, offset, arg_count
 
 		for i in 1..len(format) {
 			if format[i] == ']' {
-				var width, new_index, ok = _parse_int(format, 1);
+				width, new_index, ok := _parse_int(format, 1);
 				if !ok || new_index != i {
 					return 0, i+1, false;
 				}
@@ -422,7 +422,7 @@ proc _arg_number(fi: ^FmtInfo, arg_index: int, format: string, offset, arg_count
 		return arg_index, offset, false;
 	}
 	fi.reordered = true;
-	var index, width, ok = parse_arg_number(format[offset..]);
+	index, width, ok := parse_arg_number(format[offset..]);
 	if ok && 0 <= index && index < arg_count {
 		return index, offset+width, true;
 	}
@@ -431,11 +431,11 @@ proc _arg_number(fi: ^FmtInfo, arg_index: int, format: string, offset, arg_count
 }
 
 proc int_from_arg(args: []any, arg_index: int) -> (int, int, bool) {
-	var num = 0;
-	var new_arg_index = arg_index;
-	var ok = true;
+	num := 0;
+	new_arg_index := arg_index;
+	ok := true;
 	if arg_index < len(args) {
-		var arg = args[arg_index];
+		arg := args[arg_index];
 		arg.type_info = type_info_base(arg.type_info);
 		match i in arg {
 		case int:  num = i;
@@ -484,30 +484,30 @@ proc fmt_bool(using fi: ^FmtInfo, b: bool, verb: rune) {
 proc fmt_write_padding(fi: ^FmtInfo, width: int) {
 	if width <= 0 -> return;
 
-	var pad_byte: u8 = fi.space ? ' ' : '0';
+	pad_byte: u8 = fi.space ? ' ' : '0';
 
-	var data = string_buffer_data(fi.buf^);
-	var count = min(width, cap(data)-len(data));
+	data := string_buffer_data(fi.buf^);
+	count := min(width, cap(data)-len(data));
 	for _ in 0..<count -> write_byte(fi.buf, pad_byte);
 }
 
 proc _fmt_int(fi: ^FmtInfo, u: u128, base: int, is_signed: bool, bit_size: int, digits: string) {
-	var _, neg = strconv.is_integer_negative(u128(u), is_signed, bit_size);
+	_, neg := strconv.is_integer_negative(u128(u), is_signed, bit_size);
 
-	const BUF_SIZE = 256;
+	BUF_SIZE :: 256;
 	if fi.width_set || fi.prec_set {
-		var width = fi.width + fi.prec + 3; // 3 extra bytes for sign and prefix
+		width := fi.width + fi.prec + 3; // 3 extra bytes for sign and prefix
 		if width > BUF_SIZE {
 			// TODO(bill):????
 			panic("_fmt_int: buffer overrun. Width and precision too big");
 		}
 	}
 
-	var prec = 0;
+	prec := 0;
 	if fi.prec_set {
 		prec = fi.prec;
 		if prec == 0 && u == 0 {
-			var prev_zero = fi.zero;
+			prev_zero := fi.zero;
 			fi.zero = false;
 			fmt_write_padding(fi, fi.width);
 			fi.zero = prev_zero;
@@ -528,18 +528,18 @@ proc _fmt_int(fi: ^FmtInfo, u: u128, base: int, is_signed: bool, bit_size: int,
 		panic("_fmt_int: unknown base, whoops");
 	}
 
-	var buf: [256]u8;
-	var start = 0;
+	buf: [256]u8;
+	start := 0;
 
 
-	var flags: strconv.IntFlag;
+	flags: strconv.IntFlag;
 	if fi.hash && !fi.zero -> flags |= strconv.IntFlag.Prefix;
 	if fi.plus             -> flags |= strconv.IntFlag.Plus;
 	if fi.space            -> flags |= strconv.IntFlag.Space;
-	var s = strconv.append_bits(buf[start..<start], u128(u), base, is_signed, bit_size, digits, flags);
+	s := strconv.append_bits(buf[start..<start], u128(u), base, is_signed, bit_size, digits, flags);
 
 	if fi.hash && fi.zero {
-		var c: u8;
+		c: u8;
 		match base {
 		case 2:  c = 'b';
 		case 8:  c = 'o';
@@ -553,16 +553,15 @@ proc _fmt_int(fi: ^FmtInfo, u: u128, base: int, is_signed: bool, bit_size: int,
 		}
 	}
 
-	var prev_zero = fi.zero;
+	prev_zero := fi.zero;
 	defer fi.zero = prev_zero;
 	fi.zero = false;
 	_pad(fi, s);
 }
 
-var (
-	__DIGITS_LOWER = "0123456789abcdefx";
-	__DIGITS_UPPER = "0123456789ABCDEFX";
-)
+
+__DIGITS_LOWER := "0123456789abcdefx";
+__DIGITS_UPPER := "0123456789ABCDEFX";
 
 proc fmt_rune(fi: ^FmtInfo, r: rune, verb: rune) {
 	match verb {
@@ -584,7 +583,7 @@ proc fmt_int(fi: ^FmtInfo, u: u128, is_signed: bool, bit_size: int, verb: rune)
 	case 'c', 'r':
 		fmt_rune(fi, rune(u), verb);
 	case 'U':
-		var r = rune(u);
+		r := rune(u);
 		if r < 0 || r > utf8.MAX_RUNE {
 			fmt_bad_verb(fi, verb);
 		} else {
@@ -602,7 +601,7 @@ proc _pad(fi: ^FmtInfo, s: string) {
 		write_string(fi.buf, s);
 		return;
 	}
-	var width = fi.width - utf8.rune_count(s);
+	width := fi.width - utf8.rune_count(s);
 	if fi.minus { // right pad
 		write_string(fi.buf, s);
 		fmt_write_padding(fi, width);
@@ -618,10 +617,10 @@ proc fmt_float(fi: ^FmtInfo, v: f64, bit_size: int, verb: rune) {
 	// case 'f', 'F', 'v':
 
 	case 'f', 'F', 'v':
-		var prec: int = fi.prec_set ? fi.prec : 3;
-		var buf: [386]u8;
+		prec: int = fi.prec_set ? fi.prec : 3;
+		buf: [386]u8;
 
-		var str = strconv.append_float(buf[1..<1], v, 'f', prec, bit_size);
+		str := strconv.append_float(buf[1..<1], v, 'f', prec, bit_size);
 		str = string(buf[0..len(str)]);
 		if str[1] == '+' || str[1] == '-' {
 			str = str[1..];
@@ -660,7 +659,7 @@ proc fmt_string(fi: ^FmtInfo, s: string, verb: rune) {
 		write_string(fi.buf, s);
 
 	case 'x', 'X':
-		var space = fi.space;
+		space := fi.space;
 		fi.space = false;
 		defer fi.space = space;
 
@@ -682,7 +681,7 @@ proc fmt_pointer(fi: ^FmtInfo, p: rawptr, verb: rune) {
 		fmt_bad_verb(fi, verb);
 		return;
 	}
-	var u = u128(uint(p));
+	u := u128(uint(p));
 	if !fi.hash || verb == 'v' {
 		write_string(fi.buf, "0x");
 	}
@@ -705,13 +704,10 @@ proc fmt_enum(fi: ^FmtInfo, v: any, verb: rune) {
 		case 'd', 'f':
 			fmt_arg(fi, any{v.data, type_info_base(e.base)}, verb);
 		case 's', 'v':
-			var (
-				i:  i128;
-				f:  f64;
-				ok: bool;
-				a:  any;
-			)
-			a = any{v.data, type_info_base(e.base)};
+			i:  i128;
+			f:  f64;
+			ok: bool;
+			a := any{v.data, type_info_base(e.base)};
 			match v in a {
 			case rune:  i = i128(v);
 			case i8:   i = i128(v);
@@ -785,7 +781,7 @@ proc fmt_value(fi: ^FmtInfo, v: any, verb: rune) {
 				write_string(fi.buf, b.names[i]);
 				write_string(fi.buf, " = ");
 
-				var data = ^u8(v.data) + b.offsets[i];
+				data := ^u8(v.data) + b.offsets[i];
 				fmt_arg(fi, any{rawptr(data), b.types[i]}, 'v');
 			}
 			write_byte(fi.buf, '}');
@@ -817,29 +813,29 @@ proc fmt_value(fi: ^FmtInfo, v: any, verb: rune) {
 		for i in 0..<info.count {
 			if i > 0 -> write_string(fi.buf, ", ");
 
-			var data = ^u8(v.data) + i*info.elem_size;
+			data := ^u8(v.data) + i*info.elem_size;
 			fmt_arg(fi, any{rawptr(data), info.elem}, verb);
 		}
 
 	case DynamicArray:
 		write_byte(fi.buf, '[');
 		defer write_byte(fi.buf, ']');
-		var array = ^raw.DynamicArray(v.data);
+		array := ^raw.DynamicArray(v.data);
 		for i in 0..<array.len {
 			if i > 0 -> write_string(fi.buf, ", ");
 
-			var data = ^u8(array.data) + i*info.elem_size;
+			data := ^u8(array.data) + i*info.elem_size;
 			fmt_arg(fi, any{rawptr(data), info.elem}, verb);
 		}
 
 	case Slice:
 		write_byte(fi.buf, '[');
 		defer write_byte(fi.buf, ']');
-		var slice = ^[]u8(v.data);
+		slice := ^[]u8(v.data);
 		for _, i in slice {
 			if i > 0 -> write_string(fi.buf, ", ");
 
-			var data = &slice[0] + i*info.elem_size;
+			data := &slice[0] + i*info.elem_size;
 			fmt_arg(fi, any{rawptr(data), info.elem}, verb);
 		}
 
@@ -850,7 +846,7 @@ proc fmt_value(fi: ^FmtInfo, v: any, verb: rune) {
 		for i in 0..<info.count {
 			if i > 0 -> write_string(fi.buf, ", ");
 
-			var data = ^u8(v.data) + i*info.elem_size;
+			data := ^u8(v.data) + i*info.elem_size;
 			fmt_value(fi, any{rawptr(data), info.elem}, verb);
 		}
 
@@ -862,29 +858,29 @@ proc fmt_value(fi: ^FmtInfo, v: any, verb: rune) {
 
 		write_string(fi.buf, "map[");
 		defer write_byte(fi.buf, ']');
-		var (
-			entries    = &(^raw.DynamicMap(v.data).entries);
-			gs         = type_info_base(info.generated_struct).(^Struct);
-			ed         = type_info_base(gs.types[1]).(^DynamicArray);
-			entry_type = ed.elem.(^Struct);
-			entry_size = ed.elem_size;
-		)
+
+		entries    := &(^raw.DynamicMap(v.data).entries);
+		gs         := type_info_base(info.generated_struct).(^Struct);
+		ed         := type_info_base(gs.types[1]).(^DynamicArray);
+		entry_type := ed.elem.(^Struct);
+		entry_size := ed.elem_size;
+
 		for i in 0..<entries.len {
 			if i > 0 -> write_string(fi.buf, ", ");
 
-			var data = ^u8(entries.data) + i*entry_size;
-			var header = ^__MapEntryHeader(data);
+			data := ^u8(entries.data) + i*entry_size;
+			header := ^__MapEntryHeader(data);
 
 			if types.is_string(info.key) {
 				write_string(fi.buf, header.key.str);
 			} else {
-				var fi = FmtInfo{buf = fi.buf};
+				fi := FmtInfo{buf = fi.buf};
 				fmt_arg(&fi, any{rawptr(&header.key.hash), info.key}, 'v');
 			}
 
 			write_string(fi.buf, "=");
 
-			var value = data + entry_type.offsets[2];
+			value := data + entry_type.offsets[2];
 			fmt_arg(fi, any{rawptr(value), info.value}, 'v');
 		}
 
@@ -899,7 +895,7 @@ proc fmt_value(fi: ^FmtInfo, v: any, verb: rune) {
 
 			write_string(fi.buf, info.names[i]);
 			write_string(fi.buf, " = ");
-			var data = ^u8(v.data) + info.offsets[i];
+			data := ^u8(v.data) + info.offsets[i];
 			fmt_value(fi, any{rawptr(data), info.types[i]}, 'v');
 		}
 
@@ -907,13 +903,13 @@ proc fmt_value(fi: ^FmtInfo, v: any, verb: rune) {
 		write_byte(fi.buf, '{');
 		defer write_byte(fi.buf, '}');
 
-		var cf = info.common_fields;
+		cf := info.common_fields;
 		for _, i in cf.names {
 			if i > 0 -> write_string(fi.buf, ", ");
 
 			write_string(fi.buf, cf.names[i]);
 			write_string(fi.buf, " = ");
-			var data = ^u8(v.data) + cf.offsets[i];
+			data := ^u8(v.data) + cf.offsets[i];
 			fmt_value(fi, any{rawptr(data), cf.types[i]}, 'v');
 		}
 
@@ -933,7 +929,7 @@ proc fmt_value(fi: ^FmtInfo, v: any, verb: rune) {
 proc fmt_complex(fi: ^FmtInfo, c: complex128, bits: int, verb: rune) {
 	match verb {
 	case 'f', 'F', 'v':
-		var r, i = real(c), imag(c);
+		r, i := real(c), imag(c);
 		fmt_float(fi, r, bits/2, verb);
 		if !fi.plus && i >= 0 {
 			write_rune(fi.buf, '+');
@@ -963,7 +959,7 @@ proc fmt_arg(fi: ^FmtInfo, arg: any, verb: rune) {
 	fi.arg = arg;
 
 	if verb == 'T' {
-		var ti = arg.type_info;
+		ti := arg.type_info;
 		match a in arg {
 		case ^TypeInfo: ti = a;
 		}
@@ -972,7 +968,7 @@ proc fmt_arg(fi: ^FmtInfo, arg: any, verb: rune) {
 	}
 
 
-	var base_arg = arg;
+	base_arg := arg;
 	base_arg.type_info = type_info_base(base_arg.type_info);
 	match a in base_arg {
 	case any:           fmt_arg(fi,  a, verb);
@@ -1011,13 +1007,13 @@ proc fmt_arg(fi: ^FmtInfo, arg: any, verb: rune) {
 
 
 proc sbprint(buf: ^StringBuffer, args: ..any) -> string {
-	var fi: FmtInfo;
-	var prev_string = false;
+	fi: FmtInfo;
+	prev_string := false;
 
 	fi.buf = buf;
 
 	for arg, i in args {
-		var is_string = arg != nil && types.is_string(arg.type_info);
+		is_string := arg != nil && types.is_string(arg.type_info);
 		if i > 0 && !is_string && !prev_string {
 			write_byte(buf, ' ');
 		}
@@ -1028,7 +1024,7 @@ proc sbprint(buf: ^StringBuffer, args: ..any) -> string {
 }
 
 proc sbprintln(buf: ^StringBuffer, args: ..any) -> string {
-	var fi: FmtInfo;
+	fi: FmtInfo;
 	fi.buf = buf;
 
 	for arg, i in args {
@@ -1041,17 +1037,16 @@ proc sbprintln(buf: ^StringBuffer, args: ..any) -> string {
 }
 
 proc sbprintf(b: ^StringBuffer, fmt: string, args: ..any) -> string {
-	var (
-		end            = len(fmt);
-		arg_index: int = 0;
-		was_prev_index = false;
-		fi: FmtInfo;
-	)
-
-	for var i = 0; i < end; /**/ {
+	fi: FmtInfo;
+	arg_index: int = 0;
+	end := len(fmt);
+	was_prev_index := false;
+
+
+	for i := 0; i < end; /**/ {
 		fi = FmtInfo{buf = b, good_arg_index = true};
 
-		var prev_i = i;
+		prev_i := i;
 		for i < end && fmt[i] != '%' {
 			i++;
 		}
@@ -1142,7 +1137,7 @@ proc sbprintf(b: ^StringBuffer, fmt: string, args: ..any) -> string {
 			break;
 		}
 
-		var verb, w = utf8.decode_rune(fmt[i..]);
+		verb, w := utf8.decode_rune(fmt[i..]);
 		i += w;
 
 		if verb == '%' {

core/hash.odin

@@ -1,12 +1,12 @@
 proc crc32(data: []u8) -> u32 {
-	var result = ~u32(0);
+	result := ~u32(0);
 	for b in data {
 		result = result>>8 ~ _crc32_table[(result ~ u32(b)) & 0xff];
 	}
 	return ~result;
 }
 proc crc64(data: []u8) -> u64 {
-	var result = ~u64(0);
+	result := ~u64(0);
 	for b in data {
 		result = result>>8 ~ _crc64_table[(result ~ u64(b)) & 0xff];
 	}
@@ -14,7 +14,7 @@ proc crc64(data: []u8) -> u64 {
 }
 
 proc fnv32(data: []u8) -> u32 {
-	var h: u32 = 0x811c9dc5;
+	h: u32 = 0x811c9dc5;
 	for b in data {
 		h = (h * 0x01000193) ~ u32(b);
 	}
@@ -22,7 +22,7 @@ proc fnv32(data: []u8) -> u32 {
 }
 
 proc fnv64(data: []u8) -> u64 {
-	var h: u64 = 0xcbf29ce484222325;
+	h: u64 = 0xcbf29ce484222325;
 	for b in data {
 		h = (h * 0x100000001b3) ~ u64(b);
 	}
@@ -30,7 +30,7 @@ proc fnv64(data: []u8) -> u64 {
 }
 
 proc fnv32a(data: []u8) -> u32 {
-	var h: u32 = 0x811c9dc5;
+	h: u32 = 0x811c9dc5;
 	for b in data {
 		h = (h ~ u32(b)) * 0x01000193;
 	}
@@ -38,7 +38,7 @@ proc fnv32a(data: []u8) -> u32 {
 }
 
 proc fnv64a(data: []u8) -> u64 {
-	var h: u64 = 0xcbf29ce484222325;
+	h: u64 = 0xcbf29ce484222325;
 	for b in data {
 		h = (h ~ u64(b)) * 0x100000001b3;
 	}
@@ -46,20 +46,16 @@ proc fnv64a(data: []u8) -> u64 {
 }
 
 proc murmur32(data: []u8) -> u32 {
-	const (
-		c1_32: u32 = 0xcc9e2d51;
-		c2_32: u32 = 0x1b873593;
-	)
+	c1_32: u32 : 0xcc9e2d51;
+	c2_32: u32 : 0x1b873593;
 
-	var (
-		h1: u32 = 0;
-		nblocks = len(data)/4;
-		p = &data[0];
-		p1 = p + 4*nblocks;
-	)
+	h1: u32 = 0;
+	nblocks := len(data)/4;
+	p := &data[0];
+	p1 := p + 4*nblocks;
 
 	for ; p < p1; p += 4 {
-		var k1 = ^u32(p)^;
+		k1 := ^u32(p)^;
 
 		k1 *= c1_32;
 		k1 = (k1 << 15) | (k1 >> 17);
@@ -70,8 +66,8 @@ proc murmur32(data: []u8) -> u32 {
 		h1 = h1*5 + 0xe6546b64;
 	}
 
-	var tail = data[nblocks*4 ..];
-	var k1: u32;
+	tail := data[nblocks*4 ..];
+	k1: u32;
 	match len(tail)&3 {
 	case 3:
 		k1 ~= u32(tail[2]) << 16;
@@ -99,19 +95,17 @@ proc murmur32(data: []u8) -> u32 {
 }
 
 proc murmur64(data: []u8) -> u64 {
-	const SEED = 0x9747b28c;
+	SEED :: 0x9747b28c;
 
 	when size_of(int) == 8 {
-		const (
-			m = 0xc6a4a7935bd1e995;
-			r = 47;
-		)
+		m :: 0xc6a4a7935bd1e995;
+		r :: 47;
 
-		var h: u64 = SEED ~ (u64(len(data)) * m);
-		var data64 = slice_ptr(^u64(&data[0]), len(data)/size_of(u64));
+		h: u64 = SEED ~ (u64(len(data)) * m);
+		data64 := slice_ptr(^u64(&data[0]), len(data)/size_of(u64));
 
 		for _, i in data64 {
-			var k = data64[i];
+			k := data64[i];
 
 			k *= m;
 			k ~= k>>r;
@@ -139,21 +133,17 @@ proc murmur64(data: []u8) -> u64 {
 
 		return h;
 	} else {
-		const (
-			m = 0x5bd1e995;
-			r = 24;
-		)
+		m :: 0x5bd1e995;
+		r :: 24;
 
-		var (
-			h1 = u32(SEED) ~ u32(len(data));
-			h2 = u32(SEED) >> 32;
-			data32 = slice_ptr(^u32(&data[0]), len(data)/size_of(u32));
-			len = len(data);
-			i = 0;
-		)
+		h1 := u32(SEED) ~ u32(len(data));
+		h2 := u32(SEED) >> 32;
+		data32 := slice_ptr(^u32(&data[0]), len(data)/size_of(u32));
+		len := len(data);
+		i := 0;
 
 		for len >= 8 {
-			var k1, k2: u32;
+			k1, k2: u32;
 			k1 = data32[i]; i++;
 			k1 *= m;
 			k1 ~= k1>>r;
@@ -172,7 +162,7 @@ proc murmur64(data: []u8) -> u64 {
 		}
 
 		if len >= 4 {
-			var k1: u32;
+			k1: u32;
 			k1 = data32[i]; i++;
 			k1 *= m;
 			k1 ~= k1>>r;
@@ -183,7 +173,7 @@ proc murmur64(data: []u8) -> u64 {
 		}
 
 		// TODO(bill): Fix this
-		#no_bounds_check var data8 = slice_to_bytes(data32[i..])[0..<3];
+		#no_bounds_check data8 := slice_to_bytes(data32[i..])[0..<3];
 		match len {
 		case 3:
 			h2 ~= u32(data8[2]) << 16;
@@ -210,7 +200,7 @@ proc murmur64(data: []u8) -> u64 {
 }
 
 
-var _crc32_table = [256]u32{
+_crc32_table := [256]u32{
 	0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
 	0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
 	0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
@@ -276,7 +266,7 @@ var _crc32_table = [256]u32{
 	0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
 	0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
 };
-var _crc64_table = [256]u64{
+_crc64_table := [256]u64{
 	0x0000000000000000, 0x42f0e1eba9ea3693, 0x85e1c3d753d46d26, 0xc711223cfa3e5bb5,
 	0x493366450e42ecdf, 0x0bc387aea7a8da4c, 0xccd2a5925d9681f9, 0x8e224479f47cb76a,
 	0x9266cc8a1c85d9be, 0xd0962d61b56fef2d, 0x17870f5d4f51b498, 0x5577eeb6e6bb820b,

core/math.odin

@@ -1,22 +1,21 @@
-const (
-	TAU          = 6.28318530717958647692528676655900576;
-	PI           = 3.14159265358979323846264338327950288;
-	ONE_OVER_TAU = 0.636619772367581343075535053490057448;
-	ONE_OVER_PI  = 0.159154943091895335768883763372514362;
+TAU          :: 6.28318530717958647692528676655900576;
+PI           :: 3.14159265358979323846264338327950288;
+ONE_OVER_TAU :: 0.636619772367581343075535053490057448;
+ONE_OVER_PI  :: 0.159154943091895335768883763372514362;
 
-	E            = 2.71828182845904523536;
-	SQRT_TWO     = 1.41421356237309504880168872420969808;
-	SQRT_THREE   = 1.73205080756887729352744634150587236;
-	SQRT_FIVE    = 2.23606797749978969640917366873127623;
+E            :: 2.71828182845904523536;
+SQRT_TWO     :: 1.41421356237309504880168872420969808;
+SQRT_THREE   :: 1.73205080756887729352744634150587236;
+SQRT_FIVE    :: 2.23606797749978969640917366873127623;
 
-	LOG_TWO      = 0.693147180559945309417232121458176568;
-	LOG_TEN      = 2.30258509299404568401799145468436421;
+LOG_TWO      :: 0.693147180559945309417232121458176568;
+LOG_TEN      :: 2.30258509299404568401799145468436421;
 
-	EPSILON      = 1.19209290e-7;
+EPSILON      :: 1.19209290e-7;
+
+τ :: TAU;
+π :: PI;
 
-	τ = TAU;
-	π = PI;
-)
 type (
 	Vec2 [vector 2]f32;
 	Vec3 [vector 3]f32;
@@ -63,16 +62,16 @@ proc sign(x: f64) -> f64 { return x >= 0 ? +1 : -1; }
 
 
 proc copy_sign(x, y: f32) -> f32 {
-	var ix = transmute(u32, x);
-	var iy = transmute(u32, y);
+	ix := transmute(u32, x);
+	iy := transmute(u32, y);
 	ix &= 0x7fff_ffff;
 	ix |= iy & 0x8000_0000;
 	return transmute(f32, ix);
 }
 
 proc copy_sign(x, y: f64) -> f64 {
-	var ix = transmute(u64, x);
-	var iy = transmute(u64, y);
+	ix := transmute(u64, x);
+	iy := transmute(u64, y);
 	ix &= 0x7fff_ffff_ffff_ff;
 	ix |= iy & 0x8000_0000_0000_0000;
 	return transmute(f64, ix);
@@ -91,7 +90,7 @@ proc remainder(x, y: f32) -> f32 { return x - round(x/y) * y; }
 proc remainder(x, y: f64) -> f64 { return x - round(x/y) * y; }
 
 proc mod(x, y: f32) -> f32 {
-	var result: f32;
+	result: f32;
 	y = abs(y);
 	result = remainder(abs(x), y);
 	if sign(result) < 0 {
@@ -100,7 +99,7 @@ proc mod(x, y: f32) -> f32 {
 	return copy_sign(result, x);
 }
 proc mod(x, y: f64) -> f64 {
-	var result: f64;
+	result: f64;
 	y = abs(y);
 	result = remainder(abs(x), y);
 	if sign(result) < 0 {
@@ -115,13 +114,13 @@ proc to_degrees(radians: f32) -> f32 { return radians * 360 / TAU; }
 
 
 
-proc dot(a, b: Vec2) -> f32 { var c = a*b; return c.x + c.y; }
-proc dot(a, b: Vec3) -> f32 { var c = a*b; return c.x + c.y + c.z; }
-proc dot(a, b: Vec4) -> f32 { var c = a*b; return c.x + c.y + c.z + c.w; }
+proc dot(a, b: Vec2) -> f32 { c := a*b; return c.x + c.y; }
+proc dot(a, b: Vec3) -> f32 { c := a*b; return c.x + c.y + c.z; }
+proc dot(a, b: Vec4) -> f32 { c := a*b; return c.x + c.y + c.z + c.w; }
 
 proc cross(x, y: Vec3) -> Vec3 {
-	var a = swizzle(x, 1, 2, 0) * swizzle(y, 2, 0, 1);
-	var b = swizzle(x, 2, 0, 1) * swizzle(y, 1, 2, 0);
+	a := swizzle(x, 1, 2, 0) * swizzle(y, 2, 0, 1);
+	b := swizzle(x, 2, 0, 1) * swizzle(y, 1, 2, 0);
 	return a - b;
 }
 
@@ -135,7 +134,7 @@ proc norm(v: Vec3) -> Vec3 { return v / mag(v); }
 proc norm(v: Vec4) -> Vec4 { return v / mag(v); }
 
 proc norm0(v: Vec2) -> Vec2 {
-	var m = mag(v);
+	m := mag(v);
 	if m == 0 {
 		return 0;
 	}
@@ -143,7 +142,7 @@ proc norm0(v: Vec2) -> Vec2 {
 }
 
 proc norm0(v: Vec3) -> Vec3 {
-	var m = mag(v);
+	m := mag(v);
 	if m == 0 {
 		return 0;
 	}
@@ -151,7 +150,7 @@ proc norm0(v: Vec3) -> Vec3 {
 }
 
 proc norm0(v: Vec4) -> Vec4 {
-	var m = mag(v);
+	m := mag(v);
 	if m == 0 {
 		return 0;
 	}
@@ -179,7 +178,7 @@ proc mat4_transpose(m: Mat4) -> Mat4 {
 }
 
 proc mul(a, b: Mat4) -> Mat4 {
-	var c: Mat4;
+	c: Mat4;
 	for j in 0..<4 {
 		for i in 0..<4 {
 			c[j][i] = a[0][i]*b[j][0] +
@@ -201,29 +200,28 @@ proc mul(m: Mat4, v: Vec4) -> Vec4 {
 }
 
 proc inverse(m: Mat4) -> Mat4 {
-	var o: Mat4;
-
-	var (
-		sf00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-		sf01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-		sf02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-		sf03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-		sf04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-		sf05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-		sf06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
-		sf07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
-		sf08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
-		sf09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
-		sf10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
-		sf11 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
-		sf12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
-		sf13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
-		sf14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
-		sf15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
-		sf16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
-		sf17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
-		sf18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
-	)
+	o: Mat4;
+
+	sf00 := m[2][2] * m[3][3] - m[3][2] * m[2][3];
+	sf01 := m[2][1] * m[3][3] - m[3][1] * m[2][3];
+	sf02 := m[2][1] * m[3][2] - m[3][1] * m[2][2];
+	sf03 := m[2][0] * m[3][3] - m[3][0] * m[2][3];
+	sf04 := m[2][0] * m[3][2] - m[3][0] * m[2][2];
+	sf05 := m[2][0] * m[3][1] - m[3][0] * m[2][1];
+	sf06 := m[1][2] * m[3][3] - m[3][2] * m[1][3];
+	sf07 := m[1][1] * m[3][3] - m[3][1] * m[1][3];
+	sf08 := m[1][1] * m[3][2] - m[3][1] * m[1][2];
+	sf09 := m[1][0] * m[3][3] - m[3][0] * m[1][3];
+	sf10 := m[1][0] * m[3][2] - m[3][0] * m[1][2];
+	sf11 := m[1][1] * m[3][3] - m[3][1] * m[1][3];
+	sf12 := m[1][0] * m[3][1] - m[3][0] * m[1][1];
+	sf13 := m[1][2] * m[2][3] - m[2][2] * m[1][3];
+	sf14 := m[1][1] * m[2][3] - m[2][1] * m[1][3];
+	sf15 := m[1][1] * m[2][2] - m[2][1] * m[1][2];
+	sf16 := m[1][0] * m[2][3] - m[2][0] * m[1][3];
+	sf17 := m[1][0] * m[2][2] - m[2][0] * m[1][2];
+	sf18 := m[1][0] * m[2][1] - m[2][0] * m[1][1];
+
 
 	o[0][0] = +(m[1][1] * sf00 - m[1][2] * sf01 + m[1][3] * sf02);
 	o[0][1] = -(m[1][0] * sf00 - m[1][2] * sf03 + m[1][3] * sf04);
@@ -245,7 +243,7 @@ proc inverse(m: Mat4) -> Mat4 {
 	o[3][2] = -(m[0][0] * sf14 - m[0][1] * sf16 + m[0][3] * sf18);
 	o[3][3] = +(m[0][0] * sf15 - m[0][1] * sf17 + m[0][2] * sf18);
 
-	var ood = 1.0 / (m[0][0] * o[0][0] +
+	ood := 1.0 / (m[0][0] * o[0][0] +
 	              m[0][1] * o[0][1] +
 	              m[0][2] * o[0][2] +
 	              m[0][3] * o[0][3]);
@@ -272,7 +270,7 @@ proc inverse(m: Mat4) -> Mat4 {
 
 
 proc mat4_translate(v: Vec3) -> Mat4 {
-	var m = mat4_identity();
+	m := mat4_identity();
 	m[3][0] = v.x;
 	m[3][1] = v.y;
 	m[3][2] = v.z;
@@ -281,15 +279,13 @@ proc mat4_translate(v: Vec3) -> Mat4 {
 }
 
 proc mat4_rotate(v: Vec3, angle_radians: f32) -> Mat4 {
-	var (
-		c = cos(angle_radians);
-		s = sin(angle_radians);
+	c := cos(angle_radians);
+	s := sin(angle_radians);
 
-		a = norm(v);
-		t = a * (1-c);
+	a := norm(v);
+	t := a * (1-c);
 
-		rot = mat4_identity();
-	)
+	rot := mat4_identity();
 
 	rot[0][0] = c + t.x*a.x;
 	rot[0][1] = 0 + t.x*a.y + s*a.z;
@@ -325,11 +321,9 @@ proc scale(m: Mat4, s: f32) -> Mat4 {
 
 
 proc look_at(eye, centre, up: Vec3) -> Mat4 {
-	var (
-		f = norm(centre - eye);
-		s = norm(cross(f, up));
-		u = cross(s, f);
-	)
+	f := norm(centre - eye);
+	s := norm(cross(f, up));
+	u := cross(s, f);
 
 	return Mat4{
 		{+s.x, +u.x, -f.x, 0},
@@ -340,10 +334,9 @@ proc look_at(eye, centre, up: Vec3) -> Mat4 {
 }
 
 proc perspective(fovy, aspect, near, far: f32) -> Mat4 {
-	var (
-		m: Mat4;
-		tan_half_fovy = tan(0.5 * fovy);
-	)
+	m: Mat4;
+	tan_half_fovy := tan(0.5 * fovy);
+
 	m[0][0] = 1.0 / (aspect*tan_half_fovy);
 	m[1][1] = 1.0 / (tan_half_fovy);
 	m[2][2] = -(far + near) / (far - near);
@@ -354,7 +347,7 @@ proc perspective(fovy, aspect, near, far: f32) -> Mat4 {
 
 
 proc ortho3d(left, right, bottom, top, near, far: f32) -> Mat4 {
-	var m = mat4_identity();
+	m := mat4_identity();
 	m[0][0] = +2.0 / (right - left);
 	m[1][1] = +2.0 / (top - bottom);
 	m[2][2] = -2.0 / (far - near);
@@ -367,30 +360,28 @@ proc ortho3d(left, right, bottom, top, near, far: f32) -> Mat4 {
 
 
 
-const (
-	F32_DIG        = 6;
-	F32_EPSILON    = 1.192092896e-07;
-	F32_GUARD      = 0;
-	F32_MANT_DIG   = 24;
-	F32_MAX        = 3.402823466e+38;
-	F32_MAX_10_EXP = 38;
-	F32_MAX_EXP    = 128;
-	F32_MIN        = 1.175494351e-38;
-	F32_MIN_10_EXP = -37;
-	F32_MIN_EXP    = -125;
-	F32_NORMALIZE  = 0;
-	F32_RADIX      = 2;
-	F32_ROUNDS     = 1;
-
-	F64_DIG        = 15;                       // # of decimal digits of precision
-	F64_EPSILON    = 2.2204460492503131e-016;  // smallest such that 1.0+F64_EPSILON != 1.0
-	F64_MANT_DIG   = 53;                       // # of bits in mantissa
-	F64_MAX        = 1.7976931348623158e+308;  // max value
-	F64_MAX_10_EXP = 308;                      // max decimal exponent
-	F64_MAX_EXP    = 1024;                     // max binary exponent
-	F64_MIN        = 2.2250738585072014e-308;  // min positive value
-	F64_MIN_10_EXP = -307;                     // min decimal exponent
-	F64_MIN_EXP    = -1021;                    // min binary exponent
-	F64_RADIX      = 2;                        // exponent radix
-	F64_ROUNDS     = 1;                        // addition rounding: near
-)
+F32_DIG        :: 6;
+F32_EPSILON    :: 1.192092896e-07;
+F32_GUARD      :: 0;
+F32_MANT_DIG   :: 24;
+F32_MAX        :: 3.402823466e+38;
+F32_MAX_10_EXP :: 38;
+F32_MAX_EXP    :: 128;
+F32_MIN        :: 1.175494351e-38;
+F32_MIN_10_EXP :: -37;
+F32_MIN_EXP    :: -125;
+F32_NORMALIZE  :: 0;
+F32_RADIX      :: 2;
+F32_ROUNDS     :: 1;
+
+F64_DIG        :: 15;                       // # of decimal digits of precision
+F64_EPSILON    :: 2.2204460492503131e-016;  // smallest such that 1.0+F64_EPSILON != 1.0
+F64_MANT_DIG   :: 53;                       // # of bits in mantissa
+F64_MAX        :: 1.7976931348623158e+308;  // max value
+F64_MAX_10_EXP :: 308;                      // max decimal exponent
+F64_MAX_EXP    :: 1024;                     // max binary exponent
+F64_MIN        :: 2.2250738585072014e-308;  // min positive value
+F64_MIN_10_EXP :: -307;                     // min decimal exponent
+F64_MIN_EXP    :: -1021;                    // min binary exponent
+F64_RADIX      :: 2;                        // exponent radix
+F64_ROUNDS     :: 1;                        // addition rounding: near

core/mem.odin

@@ -41,9 +41,9 @@ proc is_power_of_two(x: int) -> bool {
 proc align_forward(ptr: rawptr, align: int) -> rawptr {
 	assert(is_power_of_two(align));
 
-	var a = uint(align);
-	var p = uint(ptr);
-	var modulo = p & (a-1);
+	a := uint(align);
+	p := uint(ptr);
+	modulo := p & (a-1);
 	if modulo != 0 {
 		p += a - modulo;
 	}
@@ -58,9 +58,9 @@ type AllocationHeader struct {
 
 proc allocation_header_fill(header: ^AllocationHeader, data: rawptr, size: int) {
 	header.size = size;
-	var ptr = ^int(header+1);
+	ptr := ^int(header+1);
 
-	for var i = 0; rawptr(ptr) < data; i++ {
+	for i := 0; rawptr(ptr) < data; i++ {
 		(ptr+i)^ = -1;
 	}
 }
@@ -68,7 +68,7 @@ proc allocation_header(data: rawptr) -> ^AllocationHeader {
 	if data == nil {
 		return nil;
 	}
-	var p = ^int(data);
+	p := ^int(data);
 	for (p-1)^ == -1 {
 		p = (p-1);
 	}
@@ -130,20 +130,20 @@ proc arena_allocator_proc(allocator_data: rawptr, mode: AllocatorMode,
                           size, alignment: int,
                           old_memory: rawptr, old_size: int, flags: u64) -> rawptr {
 	using AllocatorMode;
-	var arena = ^Arena(allocator_data);
+	arena := ^Arena(allocator_data);
 
 	match mode {
 	case Alloc:
-		var total_size = size + alignment;
+		total_size := size + alignment;
 
 		if arena.offset + total_size > len(arena.memory) {
 			fmt.fprintln(os.stderr, "Arena out of memory");
 			return nil;
 		}
 
-		#no_bounds_check var end = &arena.memory[arena.offset];
+		#no_bounds_check end := &arena.memory[arena.offset];
 
-		var ptr = align_forward(end, alignment);
+		ptr := align_forward(end, alignment);
 		arena.offset += total_size;
 		return zero(ptr, size);
 
@@ -162,7 +162,7 @@ proc arena_allocator_proc(allocator_data: rawptr, mode: AllocatorMode,
 }
 
 proc begin_arena_temp_memory(a: ^Arena) -> ArenaTempMemory {
-	var tmp: ArenaTempMemory;
+	tmp: ArenaTempMemory;
 	tmp.arena = a;
 	tmp.original_count = len(a.memory);
 	a.temp_count++;
@@ -196,8 +196,8 @@ proc align_of_type_info(type_info: ^TypeInfo) -> int {
 		return n - (n >> 1);
 	}
 
-	const WORD_SIZE = size_of(int);
-	const MAX_ALIGN = size_of([vector 64]f64); // TODO(bill): Should these constants be builtin constants?
+	WORD_SIZE :: size_of(int);
+	MAX_ALIGN :: size_of([vector 64]f64); // TODO(bill): Should these constants be builtin constants?
 	using TypeInfo;
 	match info in type_info {
 	case Named:
@@ -223,9 +223,9 @@ proc align_of_type_info(type_info: ^TypeInfo) -> int {
 	case Slice:
 		return WORD_SIZE;
 	case Vector:
-		var size = size_of_type_info(info.elem);
-		var count = int(max(prev_pow2(i64(info.count)), 1));
-		var total = size * count;
+		size  := size_of_type_info(info.elem);
+		count := int(max(prev_pow2(i64(info.count)), 1));
+		total := size * count;
 		return clamp(total, 1, MAX_ALIGN);
 	case Tuple:
 		return info.align;
@@ -245,12 +245,12 @@ proc align_of_type_info(type_info: ^TypeInfo) -> int {
 }
 
 proc align_formula(size, align: int) -> int {
-	var result = size + align-1;
+	result := size + align-1;
 	return result - result%align;
 }
 
 proc size_of_type_info(type_info: ^TypeInfo) -> int {
-	const WORD_SIZE = size_of(int);
+	WORD_SIZE :: size_of(int);
 	using TypeInfo;
 	match info in type_info {
 	case Named:
@@ -270,26 +270,26 @@ proc size_of_type_info(type_info: ^TypeInfo) -> int {
 	case Procedure:
 		return WORD_SIZE;
 	case Array:
-		var count = info.count;
+		count := info.count;
 		if count == 0 {
 			return 0;
 		}
-		var size      = size_of_type_info(info.elem);
-		var align     = align_of_type_info(info.elem);
-		var alignment = align_formula(size, align);
+		size      := size_of_type_info(info.elem);
+		align     := align_of_type_info(info.elem);
+		alignment := align_formula(size, align);
 		return alignment*(count-1) + size;
 	case DynamicArray:
 		return size_of(rawptr) + 2*size_of(int) + size_of(Allocator);
 	case Slice:
 		return 2*WORD_SIZE;
 	case Vector:
-		var count = info.count;
+		count := info.count;
 		if count == 0 {
 			return 0;
 		}
-		var size      = size_of_type_info(info.elem);
-		var align     = align_of_type_info(info.elem);
-		var alignment = align_formula(size, align);
+		size      := size_of_type_info(info.elem);
+		align     := align_of_type_info(info.elem);
+		alignment := align_formula(size, align);
 		return alignment*(count-1) + size;
 	case Struct:
 		return info.size;

core/opengl.odin

@@ -39,7 +39,7 @@ foreign lib {
 
 proc _string_data(s: string) -> ^u8 #inline { return &s[0]; }
 
-var _libgl = win32.load_library_a(_string_data("opengl32.dll\x00"));
+_libgl := win32.load_library_a(_string_data("opengl32.dll\x00"));
 
 proc get_proc_address(name: string) -> rawptr {
 	if name[len(name)-1] == 0 {
@@ -47,14 +47,14 @@ proc get_proc_address(name: string) -> rawptr {
 	}
 	// NOTE(bill): null terminated
 	assert((&name[0] + len(name))^ == 0);
-	var res = wgl.get_proc_address(&name[0]);
+	res := wgl.get_proc_address(&name[0]);
 	if res == nil {
 		res = win32.get_proc_address(_libgl, &name[0]);
 	}
 	return rawptr(res);
 }
 
-var (
+// Procedures
 	GenBuffers:               proc(count: i32, buffers: ^u32) #cc_c;
 	GenVertexArrays:          proc(count: i32, buffers: ^u32) #cc_c;
 	GenSamplers:              proc(count: i32, buffers: ^u32) #cc_c;
@@ -114,11 +114,11 @@ var (
 	UniformMatrix4fv:         proc(loc: i32, count: u32, transpose: i32, value: ^f32) #cc_c;
 
 	GetUniformLocation:       proc(program: u32, name: ^u8) -> i32 #cc_c;
-)
+
 
 proc init() {
 	proc set_proc_address(p: rawptr, name: string) #inline {
-		var x = ^rawptr(p);
+		x := ^rawptr(p);
 		x^ = get_proc_address(name);
 	}
 

core/opengl_constants.odin

@@ -1,1385 +1,1383 @@
-const (
-	FALSE                          = 0;
-	TRUE                           = 1;
+FALSE                          :: 0;
+TRUE                           :: 1;
 
-	DEPTH_BUFFER_BIT               = 0x00000100;
-	STENCIL_BUFFER_BIT             = 0x00000400;
-	COLOR_BUFFER_BIT               = 0x00004000;
-	POINTS                         = 0x0000;
-	LINES                          = 0x0001;
-	LINE_LOOP                      = 0x0002;
-	LINE_STRIP                     = 0x0003;
-	TRIANGLES                      = 0x0004;
-	TRIANGLE_STRIP                 = 0x0005;
-	TRIANGLE_FAN                   = 0x0006;
-	QUADS                          = 0x0007;
-	NEVER                          = 0x0200;
-	LESS                           = 0x0201;
-	EQUAL                          = 0x0202;
-	LEQUAL                         = 0x0203;
-	GREATER                        = 0x0204;
-	NOTEQUAL                       = 0x0205;
-	GEQUAL                         = 0x0206;
-	ALWAYS                         = 0x0207;
-	ZERO                           = 0;
-	ONE                            = 1;
-	SRC_COLOR                      = 0x0300;
-	ONE_MINUS_SRC_COLOR            = 0x0301;
-	SRC_ALPHA                      = 0x0302;
-	ONE_MINUS_SRC_ALPHA            = 0x0303;
-	DST_ALPHA                      = 0x0304;
-	ONE_MINUS_DST_ALPHA            = 0x0305;
-	DST_COLOR                      = 0x0306;
-	ONE_MINUS_DST_COLOR            = 0x0307;
-	SRC_ALPHA_SATURATE             = 0x0308;
-	NONE                           = 0;
-	FRONT_LEFT                     = 0x0400;
-	FRONT_RIGHT                    = 0x0401;
-	BACK_LEFT                      = 0x0402;
-	BACK_RIGHT                     = 0x0403;
-	FRONT                          = 0x0404;
-	BACK                           = 0x0405;
-	LEFT                           = 0x0406;
-	RIGHT                          = 0x0407;
-	FRONT_AND_BACK                 = 0x0408;
-	NO_ERROR                       = 0;
-	INVALID_ENUM                   = 0x0500;
-	INVALID_VALUE                  = 0x0501;
-	INVALID_OPERATION              = 0x0502;
-	OUT_OF_MEMORY                  = 0x0505;
-	CW                             = 0x0900;
-	CCW                            = 0x0901;
-	POINT_SIZE                     = 0x0B11;
-	POINT_SIZE_RANGE               = 0x0B12;
-	POINT_SIZE_GRANULARITY         = 0x0B13;
-	LINE_SMOOTH                    = 0x0B20;
-	LINE_WIDTH                     = 0x0B21;
-	LINE_WIDTH_RANGE               = 0x0B22;
-	LINE_WIDTH_GRANULARITY         = 0x0B23;
-	POLYGON_MODE                   = 0x0B40;
-	POLYGON_SMOOTH                 = 0x0B41;
-	CULL_FACE                      = 0x0B44;
-	CULL_FACE_MODE                 = 0x0B45;
-	FRONT_FACE                     = 0x0B46;
-	DEPTH_RANGE                    = 0x0B70;
-	DEPTH_TEST                     = 0x0B71;
-	DEPTH_WRITEMASK                = 0x0B72;
-	DEPTH_CLEAR_VALUE              = 0x0B73;
-	DEPTH_FUNC                     = 0x0B74;
-	STENCIL_TEST                   = 0x0B90;
-	STENCIL_CLEAR_VALUE            = 0x0B91;
-	STENCIL_FUNC                   = 0x0B92;
-	STENCIL_VALUE_MASK             = 0x0B93;
-	STENCIL_FAIL                   = 0x0B94;
-	STENCIL_PASS_DEPTH_FAIL        = 0x0B95;
-	STENCIL_PASS_DEPTH_PASS        = 0x0B96;
-	STENCIL_REF                    = 0x0B97;
-	STENCIL_WRITEMASK              = 0x0B98;
-	VIEWPORT                       = 0x0BA2;
-	DITHER                         = 0x0BD0;
-	BLEND_DST                      = 0x0BE0;
-	BLEND_SRC                      = 0x0BE1;
-	BLEND                          = 0x0BE2;
-	LOGIC_OP_MODE                  = 0x0BF0;
-	COLOR_LOGIC_OP                 = 0x0BF2;
-	DRAW_BUFFER                    = 0x0C01;
-	READ_BUFFER                    = 0x0C02;
-	SCISSOR_BOX                    = 0x0C10;
-	SCISSOR_TEST                   = 0x0C11;
-	COLOR_CLEAR_VALUE              = 0x0C22;
-	COLOR_WRITEMASK                = 0x0C23;
-	DOUBLEBUFFER                   = 0x0C32;
-	STEREO                         = 0x0C33;
-	LINE_SMOOTH_HINT               = 0x0C52;
-	POLYGON_SMOOTH_HINT            = 0x0C53;
-	UNPACK_SWAP_BYTES              = 0x0CF0;
-	UNPACK_LSB_FIRST               = 0x0CF1;
-	UNPACK_ROW_LENGTH              = 0x0CF2;
-	UNPACK_SKIP_ROWS               = 0x0CF3;
-	UNPACK_SKIP_PIXELS             = 0x0CF4;
-	UNPACK_ALIGNMENT               = 0x0CF5;
-	PACK_SWAP_BYTES                = 0x0D00;
-	PACK_LSB_FIRST                 = 0x0D01;
-	PACK_ROW_LENGTH                = 0x0D02;
-	PACK_SKIP_ROWS                 = 0x0D03;
-	PACK_SKIP_PIXELS               = 0x0D04;
-	PACK_ALIGNMENT                 = 0x0D05;
-	MAX_TEXTURE_SIZE               = 0x0D33;
-	MAX_VIEWPORT_DIMS              = 0x0D3A;
-	SUBPIXEL_BITS                  = 0x0D50;
-	TEXTURE_1D                     = 0x0DE0;
-	TEXTURE_2D                     = 0x0DE1;
-	POLYGON_OFFSET_UNITS           = 0x2A00;
-	POLYGON_OFFSET_POINT           = 0x2A01;
-	POLYGON_OFFSET_LINE            = 0x2A02;
-	POLYGON_OFFSET_FILL            = 0x8037;
-	POLYGON_OFFSET_FACTOR          = 0x8038;
-	TEXTURE_BINDING_1D             = 0x8068;
-	TEXTURE_BINDING_2D             = 0x8069;
-	TEXTURE_WIDTH                  = 0x1000;
-	TEXTURE_HEIGHT                 = 0x1001;
-	TEXTURE_INTERNAL_FORMAT        = 0x1003;
-	TEXTURE_BORDER_COLOR           = 0x1004;
-	TEXTURE_RED_SIZE               = 0x805C;
-	TEXTURE_GREEN_SIZE             = 0x805D;
-	TEXTURE_BLUE_SIZE              = 0x805E;
-	TEXTURE_ALPHA_SIZE             = 0x805F;
-	DONT_CARE                      = 0x1100;
-	FASTEST                        = 0x1101;
-	NICEST                         = 0x1102;
-	BYTE                           = 0x1400;
-	UNSIGNED_BYTE                  = 0x1401;
-	SHORT                          = 0x1402;
-	UNSIGNED_SHORT                 = 0x1403;
-	INT                            = 0x1404;
-	UNSIGNED_INT                   = 0x1405;
-	FLOAT                          = 0x1406;
-	DOUBLE                         = 0x140A;
-	STACK_OVERFLOW                 = 0x0503;
-	STACK_UNDERFLOW                = 0x0504;
-	CLEAR                          = 0x1500;
-	AND                            = 0x1501;
-	AND_REVERSE                    = 0x1502;
-	COPY                           = 0x1503;
-	AND_INVERTED                   = 0x1504;
-	NOOP                           = 0x1505;
-	XOR                            = 0x1506;
-	OR                             = 0x1507;
-	NOR                            = 0x1508;
-	EQUIV                          = 0x1509;
-	INVERT                         = 0x150A;
-	OR_REVERSE                     = 0x150B;
-	COPY_INVERTED                  = 0x150C;
-	OR_INVERTED                    = 0x150D;
-	NAND                           = 0x150E;
-	SET                            = 0x150F;
-	TEXTURE                        = 0x1702;
-	COLOR                          = 0x1800;
-	DEPTH                          = 0x1801;
-	STENCIL                        = 0x1802;
-	STENCIL_INDEX                  = 0x1901;
-	DEPTH_COMPONENT                = 0x1902;
-	RED                            = 0x1903;
-	GREEN                          = 0x1904;
-	BLUE                           = 0x1905;
-	ALPHA                          = 0x1906;
-	RGB                            = 0x1907;
-	RGBA                           = 0x1908;
-	POINT                          = 0x1B00;
-	LINE                           = 0x1B01;
-	FILL                           = 0x1B02;
-	KEEP                           = 0x1E00;
-	REPLACE                        = 0x1E01;
-	INCR                           = 0x1E02;
-	DECR                           = 0x1E03;
-	VENDOR                         = 0x1F00;
-	RENDERER                       = 0x1F01;
-	VERSION                        = 0x1F02;
-	EXTENSIONS                     = 0x1F03;
-	NEAREST                        = 0x2600;
-	LINEAR                         = 0x2601;
-	NEAREST_MIPMAP_NEAREST         = 0x2700;
-	LINEAR_MIPMAP_NEAREST          = 0x2701;
-	NEAREST_MIPMAP_LINEAR          = 0x2702;
-	LINEAR_MIPMAP_LINEAR           = 0x2703;
-	TEXTURE_MAG_FILTER             = 0x2800;
-	TEXTURE_MIN_FILTER             = 0x2801;
-	TEXTURE_WRAP_S                 = 0x2802;
-	TEXTURE_WRAP_T                 = 0x2803;
-	PROXY_TEXTURE_1D               = 0x8063;
-	PROXY_TEXTURE_2D               = 0x8064;
-	REPEAT                         = 0x2901;
-	R3_G3_B2                       = 0x2A10;
-	RGB4                           = 0x804F;
-	RGB5                           = 0x8050;
-	RGB8                           = 0x8051;
-	RGB10                          = 0x8052;
-	RGB12                          = 0x8053;
-	RGB16                          = 0x8054;
-	RGBA2                          = 0x8055;
-	RGBA4                          = 0x8056;
-	RGB5_A1                        = 0x8057;
-	RGBA8                          = 0x8058;
-	RGB10_A2                       = 0x8059;
-	RGBA12                         = 0x805A;
-	RGBA16                         = 0x805B;
-	VERTEX_ARRAY                   = 0x8074;
+DEPTH_BUFFER_BIT               :: 0x00000100;
+STENCIL_BUFFER_BIT             :: 0x00000400;
+COLOR_BUFFER_BIT               :: 0x00004000;
+POINTS                         :: 0x0000;
+LINES                          :: 0x0001;
+LINE_LOOP                      :: 0x0002;
+LINE_STRIP                     :: 0x0003;
+TRIANGLES                      :: 0x0004;
+TRIANGLE_STRIP                 :: 0x0005;
+TRIANGLE_FAN                   :: 0x0006;
+QUADS                          :: 0x0007;
+NEVER                          :: 0x0200;
+LESS                           :: 0x0201;
+EQUAL                          :: 0x0202;
+LEQUAL                         :: 0x0203;
+GREATER                        :: 0x0204;
+NOTEQUAL                       :: 0x0205;
+GEQUAL                         :: 0x0206;
+ALWAYS                         :: 0x0207;
+ZERO                           :: 0;
+ONE                            :: 1;
+SRC_COLOR                      :: 0x0300;
+ONE_MINUS_SRC_COLOR            :: 0x0301;
+SRC_ALPHA                      :: 0x0302;
+ONE_MINUS_SRC_ALPHA            :: 0x0303;
+DST_ALPHA                      :: 0x0304;
+ONE_MINUS_DST_ALPHA            :: 0x0305;
+DST_COLOR                      :: 0x0306;
+ONE_MINUS_DST_COLOR            :: 0x0307;
+SRC_ALPHA_SATURATE             :: 0x0308;
+NONE                           :: 0;
+FRONT_LEFT                     :: 0x0400;
+FRONT_RIGHT                    :: 0x0401;
+BACK_LEFT                      :: 0x0402;
+BACK_RIGHT                     :: 0x0403;
+FRONT                          :: 0x0404;
+BACK                           :: 0x0405;
+LEFT                           :: 0x0406;
+RIGHT                          :: 0x0407;
+FRONT_AND_BACK                 :: 0x0408;
+NO_ERROR                       :: 0;
+INVALID_ENUM                   :: 0x0500;
+INVALID_VALUE                  :: 0x0501;
+INVALID_OPERATION              :: 0x0502;
+OUT_OF_MEMORY                  :: 0x0505;
+CW                             :: 0x0900;
+CCW                            :: 0x0901;
+POINT_SIZE                     :: 0x0B11;
+POINT_SIZE_RANGE               :: 0x0B12;
+POINT_SIZE_GRANULARITY         :: 0x0B13;
+LINE_SMOOTH                    :: 0x0B20;
+LINE_WIDTH                     :: 0x0B21;
+LINE_WIDTH_RANGE               :: 0x0B22;
+LINE_WIDTH_GRANULARITY         :: 0x0B23;
+POLYGON_MODE                   :: 0x0B40;
+POLYGON_SMOOTH                 :: 0x0B41;
+CULL_FACE                      :: 0x0B44;
+CULL_FACE_MODE                 :: 0x0B45;
+FRONT_FACE                     :: 0x0B46;
+DEPTH_RANGE                    :: 0x0B70;
+DEPTH_TEST                     :: 0x0B71;
+DEPTH_WRITEMASK                :: 0x0B72;
+DEPTH_CLEAR_VALUE              :: 0x0B73;
+DEPTH_FUNC                     :: 0x0B74;
+STENCIL_TEST                   :: 0x0B90;
+STENCIL_CLEAR_VALUE            :: 0x0B91;
+STENCIL_FUNC                   :: 0x0B92;
+STENCIL_VALUE_MASK             :: 0x0B93;
+STENCIL_FAIL                   :: 0x0B94;
+STENCIL_PASS_DEPTH_FAIL        :: 0x0B95;
+STENCIL_PASS_DEPTH_PASS        :: 0x0B96;
+STENCIL_REF                    :: 0x0B97;
+STENCIL_WRITEMASK              :: 0x0B98;
+VIEWPORT                       :: 0x0BA2;
+DITHER                         :: 0x0BD0;
+BLEND_DST                      :: 0x0BE0;
+BLEND_SRC                      :: 0x0BE1;
+BLEND                          :: 0x0BE2;
+LOGIC_OP_MODE                  :: 0x0BF0;
+COLOR_LOGIC_OP                 :: 0x0BF2;
+DRAW_BUFFER                    :: 0x0C01;
+READ_BUFFER                    :: 0x0C02;
+SCISSOR_BOX                    :: 0x0C10;
+SCISSOR_TEST                   :: 0x0C11;
+COLOR_CLEAR_VALUE              :: 0x0C22;
+COLOR_WRITEMASK                :: 0x0C23;
+DOUBLEBUFFER                   :: 0x0C32;
+STEREO                         :: 0x0C33;
+LINE_SMOOTH_HINT               :: 0x0C52;
+POLYGON_SMOOTH_HINT            :: 0x0C53;
+UNPACK_SWAP_BYTES              :: 0x0CF0;
+UNPACK_LSB_FIRST               :: 0x0CF1;
+UNPACK_ROW_LENGTH              :: 0x0CF2;
+UNPACK_SKIP_ROWS               :: 0x0CF3;
+UNPACK_SKIP_PIXELS             :: 0x0CF4;
+UNPACK_ALIGNMENT               :: 0x0CF5;
+PACK_SWAP_BYTES                :: 0x0D00;
+PACK_LSB_FIRST                 :: 0x0D01;
+PACK_ROW_LENGTH                :: 0x0D02;
+PACK_SKIP_ROWS                 :: 0x0D03;
+PACK_SKIP_PIXELS               :: 0x0D04;
+PACK_ALIGNMENT                 :: 0x0D05;
+MAX_TEXTURE_SIZE               :: 0x0D33;
+MAX_VIEWPORT_DIMS              :: 0x0D3A;
+SUBPIXEL_BITS                  :: 0x0D50;
+TEXTURE_1D                     :: 0x0DE0;
+TEXTURE_2D                     :: 0x0DE1;
+POLYGON_OFFSET_UNITS           :: 0x2A00;
+POLYGON_OFFSET_POINT           :: 0x2A01;
+POLYGON_OFFSET_LINE            :: 0x2A02;
+POLYGON_OFFSET_FILL            :: 0x8037;
+POLYGON_OFFSET_FACTOR          :: 0x8038;
+TEXTURE_BINDING_1D             :: 0x8068;
+TEXTURE_BINDING_2D             :: 0x8069;
+TEXTURE_WIDTH                  :: 0x1000;
+TEXTURE_HEIGHT                 :: 0x1001;
+TEXTURE_INTERNAL_FORMAT        :: 0x1003;
+TEXTURE_BORDER_COLOR           :: 0x1004;
+TEXTURE_RED_SIZE               :: 0x805C;
+TEXTURE_GREEN_SIZE             :: 0x805D;
+TEXTURE_BLUE_SIZE              :: 0x805E;
+TEXTURE_ALPHA_SIZE             :: 0x805F;
+DONT_CARE                      :: 0x1100;
+FASTEST                        :: 0x1101;
+NICEST                         :: 0x1102;
+BYTE                           :: 0x1400;
+UNSIGNED_BYTE                  :: 0x1401;
+SHORT                          :: 0x1402;
+UNSIGNED_SHORT                 :: 0x1403;
+INT                            :: 0x1404;
+UNSIGNED_INT                   :: 0x1405;
+FLOAT                          :: 0x1406;
+DOUBLE                         :: 0x140A;
+STACK_OVERFLOW                 :: 0x0503;
+STACK_UNDERFLOW                :: 0x0504;
+CLEAR                          :: 0x1500;
+AND                            :: 0x1501;
+AND_REVERSE                    :: 0x1502;
+COPY                           :: 0x1503;
+AND_INVERTED                   :: 0x1504;
+NOOP                           :: 0x1505;
+XOR                            :: 0x1506;
+OR                             :: 0x1507;
+NOR                            :: 0x1508;
+EQUIV                          :: 0x1509;
+INVERT                         :: 0x150A;
+OR_REVERSE                     :: 0x150B;
+COPY_INVERTED                  :: 0x150C;
+OR_INVERTED                    :: 0x150D;
+NAND                           :: 0x150E;
+SET                            :: 0x150F;
+TEXTURE                        :: 0x1702;
+COLOR                          :: 0x1800;
+DEPTH                          :: 0x1801;
+STENCIL                        :: 0x1802;
+STENCIL_INDEX                  :: 0x1901;
+DEPTH_COMPONENT                :: 0x1902;
+RED                            :: 0x1903;
+GREEN                          :: 0x1904;
+BLUE                           :: 0x1905;
+ALPHA                          :: 0x1906;
+RGB                            :: 0x1907;
+RGBA                           :: 0x1908;
+POINT                          :: 0x1B00;
+LINE                           :: 0x1B01;
+FILL                           :: 0x1B02;
+KEEP                           :: 0x1E00;
+REPLACE                        :: 0x1E01;
+INCR                           :: 0x1E02;
+DECR                           :: 0x1E03;
+VENDOR                         :: 0x1F00;
+RENDERER                       :: 0x1F01;
+VERSION                        :: 0x1F02;
+EXTENSIONS                     :: 0x1F03;
+NEAREST                        :: 0x2600;
+LINEAR                         :: 0x2601;
+NEAREST_MIPMAP_NEAREST         :: 0x2700;
+LINEAR_MIPMAP_NEAREST          :: 0x2701;
+NEAREST_MIPMAP_LINEAR          :: 0x2702;
+LINEAR_MIPMAP_LINEAR           :: 0x2703;
+TEXTURE_MAG_FILTER             :: 0x2800;
+TEXTURE_MIN_FILTER             :: 0x2801;
+TEXTURE_WRAP_S                 :: 0x2802;
+TEXTURE_WRAP_T                 :: 0x2803;
+PROXY_TEXTURE_1D               :: 0x8063;
+PROXY_TEXTURE_2D               :: 0x8064;
+REPEAT                         :: 0x2901;
+R3_G3_B2                       :: 0x2A10;
+RGB4                           :: 0x804F;
+RGB5                           :: 0x8050;
+RGB8                           :: 0x8051;
+RGB10                          :: 0x8052;
+RGB12                          :: 0x8053;
+RGB16                          :: 0x8054;
+RGBA2                          :: 0x8055;
+RGBA4                          :: 0x8056;
+RGB5_A1                        :: 0x8057;
+RGBA8                          :: 0x8058;
+RGB10_A2                       :: 0x8059;
+RGBA12                         :: 0x805A;
+RGBA16                         :: 0x805B;
+VERTEX_ARRAY                   :: 0x8074;
 
-	UNSIGNED_BYTE_3_3_2            = 0x8032;
-	UNSIGNED_SHORT_4_4_4_4         = 0x8033;
-	UNSIGNED_SHORT_5_5_5_1         = 0x8034;
-	UNSIGNED_INT_8_8_8_8           = 0x8035;
-	UNSIGNED_INT_10_10_10_2        = 0x8036;
-	TEXTURE_BINDING_3D             = 0x806A;
-	PACK_SKIP_IMAGES               = 0x806B;
-	PACK_IMAGE_HEIGHT              = 0x806C;
-	UNPACK_SKIP_IMAGES             = 0x806D;
-	UNPACK_IMAGE_HEIGHT            = 0x806E;
-	TEXTURE_3D                     = 0x806F;
-	PROXY_TEXTURE_3D               = 0x8070;
-	TEXTURE_DEPTH                  = 0x8071;
-	TEXTURE_WRAP_R                 = 0x8072;
-	MAX_3D_TEXTURE_SIZE            = 0x8073;
-	UNSIGNED_BYTE_2_3_3_REV        = 0x8362;
-	UNSIGNED_SHORT_5_6_5           = 0x8363;
-	UNSIGNED_SHORT_5_6_5_REV       = 0x8364;
-	UNSIGNED_SHORT_4_4_4_4_REV     = 0x8365;
-	UNSIGNED_SHORT_1_5_5_5_REV     = 0x8366;
-	UNSIGNED_INT_8_8_8_8_REV       = 0x8367;
-	UNSIGNED_INT_2_10_10_10_REV    = 0x8368;
-	BGR                            = 0x80E0;
-	BGRA                           = 0x80E1;
-	MAX_ELEMENTS_VERTICES          = 0x80E8;
-	MAX_ELEMENTS_INDICES           = 0x80E9;
-	CLAMP_TO_EDGE                  = 0x812F;
-	TEXTURE_MIN_LOD                = 0x813A;
-	TEXTURE_MAX_LOD                = 0x813B;
-	TEXTURE_BASE_LEVEL             = 0x813C;
-	TEXTURE_MAX_LEVEL              = 0x813D;
-	SMOOTH_POINT_SIZE_RANGE        = 0x0B12;
-	SMOOTH_POINT_SIZE_GRANULARITY  = 0x0B13;
-	SMOOTH_LINE_WIDTH_RANGE        = 0x0B22;
-	SMOOTH_LINE_WIDTH_GRANULARITY  = 0x0B23;
-	ALIASED_LINE_WIDTH_RANGE       = 0x846E;
+UNSIGNED_BYTE_3_3_2            :: 0x8032;
+UNSIGNED_SHORT_4_4_4_4         :: 0x8033;
+UNSIGNED_SHORT_5_5_5_1         :: 0x8034;
+UNSIGNED_INT_8_8_8_8           :: 0x8035;
+UNSIGNED_INT_10_10_10_2        :: 0x8036;
+TEXTURE_BINDING_3D             :: 0x806A;
+PACK_SKIP_IMAGES               :: 0x806B;
+PACK_IMAGE_HEIGHT              :: 0x806C;
+UNPACK_SKIP_IMAGES             :: 0x806D;
+UNPACK_IMAGE_HEIGHT            :: 0x806E;
+TEXTURE_3D                     :: 0x806F;
+PROXY_TEXTURE_3D               :: 0x8070;
+TEXTURE_DEPTH                  :: 0x8071;
+TEXTURE_WRAP_R                 :: 0x8072;
+MAX_3D_TEXTURE_SIZE            :: 0x8073;
+UNSIGNED_BYTE_2_3_3_REV        :: 0x8362;
+UNSIGNED_SHORT_5_6_5           :: 0x8363;
+UNSIGNED_SHORT_5_6_5_REV       :: 0x8364;
+UNSIGNED_SHORT_4_4_4_4_REV     :: 0x8365;
+UNSIGNED_SHORT_1_5_5_5_REV     :: 0x8366;
+UNSIGNED_INT_8_8_8_8_REV       :: 0x8367;
+UNSIGNED_INT_2_10_10_10_REV    :: 0x8368;
+BGR                            :: 0x80E0;
+BGRA                           :: 0x80E1;
+MAX_ELEMENTS_VERTICES          :: 0x80E8;
+MAX_ELEMENTS_INDICES           :: 0x80E9;
+CLAMP_TO_EDGE                  :: 0x812F;
+TEXTURE_MIN_LOD                :: 0x813A;
+TEXTURE_MAX_LOD                :: 0x813B;
+TEXTURE_BASE_LEVEL             :: 0x813C;
+TEXTURE_MAX_LEVEL              :: 0x813D;
+SMOOTH_POINT_SIZE_RANGE        :: 0x0B12;
+SMOOTH_POINT_SIZE_GRANULARITY  :: 0x0B13;
+SMOOTH_LINE_WIDTH_RANGE        :: 0x0B22;
+SMOOTH_LINE_WIDTH_GRANULARITY  :: 0x0B23;
+ALIASED_LINE_WIDTH_RANGE       :: 0x846E;
 
-	TEXTURE0                       = 0x84C0;
-	TEXTURE1                       = 0x84C1;
-	TEXTURE2                       = 0x84C2;
-	TEXTURE3                       = 0x84C3;
-	TEXTURE4                       = 0x84C4;
-	TEXTURE5                       = 0x84C5;
-	TEXTURE6                       = 0x84C6;
-	TEXTURE7                       = 0x84C7;
-	TEXTURE8                       = 0x84C8;
-	TEXTURE9                       = 0x84C9;
-	TEXTURE10                      = 0x84CA;
-	TEXTURE11                      = 0x84CB;
-	TEXTURE12                      = 0x84CC;
-	TEXTURE13                      = 0x84CD;
-	TEXTURE14                      = 0x84CE;
-	TEXTURE15                      = 0x84CF;
-	TEXTURE16                      = 0x84D0;
-	TEXTURE17                      = 0x84D1;
-	TEXTURE18                      = 0x84D2;
-	TEXTURE19                      = 0x84D3;
-	TEXTURE20                      = 0x84D4;
-	TEXTURE21                      = 0x84D5;
-	TEXTURE22                      = 0x84D6;
-	TEXTURE23                      = 0x84D7;
-	TEXTURE24                      = 0x84D8;
-	TEXTURE25                      = 0x84D9;
-	TEXTURE26                      = 0x84DA;
-	TEXTURE27                      = 0x84DB;
-	TEXTURE28                      = 0x84DC;
-	TEXTURE29                      = 0x84DD;
-	TEXTURE30                      = 0x84DE;
-	TEXTURE31                      = 0x84DF;
-	ACTIVE_TEXTURE                 = 0x84E0;
-	MULTISAMPLE                    = 0x809D;
-	SAMPLE_ALPHA_TO_COVERAGE       = 0x809E;
-	SAMPLE_ALPHA_TO_ONE            = 0x809F;
-	SAMPLE_COVERAGE                = 0x80A0;
-	SAMPLE_BUFFERS                 = 0x80A8;
-	SAMPLES                        = 0x80A9;
-	SAMPLE_COVERAGE_VALUE          = 0x80AA;
-	SAMPLE_COVERAGE_INVERT         = 0x80AB;
-	TEXTURE_CUBE_MAP               = 0x8513;
-	TEXTURE_BINDING_CUBE_MAP       = 0x8514;
-	TEXTURE_CUBE_MAP_POSITIVE_X    = 0x8515;
-	TEXTURE_CUBE_MAP_NEGATIVE_X    = 0x8516;
-	TEXTURE_CUBE_MAP_POSITIVE_Y    = 0x8517;
-	TEXTURE_CUBE_MAP_NEGATIVE_Y    = 0x8518;
-	TEXTURE_CUBE_MAP_POSITIVE_Z    = 0x8519;
-	TEXTURE_CUBE_MAP_NEGATIVE_Z    = 0x851A;
-	PROXY_TEXTURE_CUBE_MAP         = 0x851B;
-	MAX_CUBE_MAP_TEXTURE_SIZE      = 0x851C;
-	COMPRESSED_RGB                 = 0x84ED;
-	COMPRESSED_RGBA                = 0x84EE;
-	TEXTURE_COMPRESSION_HINT       = 0x84EF;
-	TEXTURE_COMPRESSED_IMAGE_SIZE  = 0x86A0;
-	TEXTURE_COMPRESSED             = 0x86A1;
-	NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2;
-	COMPRESSED_TEXTURE_FORMATS     = 0x86A3;
-	CLAMP_TO_BORDER                = 0x812D;
+TEXTURE0                       :: 0x84C0;
+TEXTURE1                       :: 0x84C1;
+TEXTURE2                       :: 0x84C2;
+TEXTURE3                       :: 0x84C3;
+TEXTURE4                       :: 0x84C4;
+TEXTURE5                       :: 0x84C5;
+TEXTURE6                       :: 0x84C6;
+TEXTURE7                       :: 0x84C7;
+TEXTURE8                       :: 0x84C8;
+TEXTURE9                       :: 0x84C9;
+TEXTURE10                      :: 0x84CA;
+TEXTURE11                      :: 0x84CB;
+TEXTURE12                      :: 0x84CC;
+TEXTURE13                      :: 0x84CD;
+TEXTURE14                      :: 0x84CE;
+TEXTURE15                      :: 0x84CF;
+TEXTURE16                      :: 0x84D0;
+TEXTURE17                      :: 0x84D1;
+TEXTURE18                      :: 0x84D2;
+TEXTURE19                      :: 0x84D3;
+TEXTURE20                      :: 0x84D4;
+TEXTURE21                      :: 0x84D5;
+TEXTURE22                      :: 0x84D6;
+TEXTURE23                      :: 0x84D7;
+TEXTURE24                      :: 0x84D8;
+TEXTURE25                      :: 0x84D9;
+TEXTURE26                      :: 0x84DA;
+TEXTURE27                      :: 0x84DB;
+TEXTURE28                      :: 0x84DC;
+TEXTURE29                      :: 0x84DD;
+TEXTURE30                      :: 0x84DE;
+TEXTURE31                      :: 0x84DF;
+ACTIVE_TEXTURE                 :: 0x84E0;
+MULTISAMPLE                    :: 0x809D;
+SAMPLE_ALPHA_TO_COVERAGE       :: 0x809E;
+SAMPLE_ALPHA_TO_ONE            :: 0x809F;
+SAMPLE_COVERAGE                :: 0x80A0;
+SAMPLE_BUFFERS                 :: 0x80A8;
+SAMPLES                        :: 0x80A9;
+SAMPLE_COVERAGE_VALUE          :: 0x80AA;
+SAMPLE_COVERAGE_INVERT         :: 0x80AB;
+TEXTURE_CUBE_MAP               :: 0x8513;
+TEXTURE_BINDING_CUBE_MAP       :: 0x8514;
+TEXTURE_CUBE_MAP_POSITIVE_X    :: 0x8515;
+TEXTURE_CUBE_MAP_NEGATIVE_X    :: 0x8516;
+TEXTURE_CUBE_MAP_POSITIVE_Y    :: 0x8517;
+TEXTURE_CUBE_MAP_NEGATIVE_Y    :: 0x8518;
+TEXTURE_CUBE_MAP_POSITIVE_Z    :: 0x8519;
+TEXTURE_CUBE_MAP_NEGATIVE_Z    :: 0x851A;
+PROXY_TEXTURE_CUBE_MAP         :: 0x851B;
+MAX_CUBE_MAP_TEXTURE_SIZE      :: 0x851C;
+COMPRESSED_RGB                 :: 0x84ED;
+COMPRESSED_RGBA                :: 0x84EE;
+TEXTURE_COMPRESSION_HINT       :: 0x84EF;
+TEXTURE_COMPRESSED_IMAGE_SIZE  :: 0x86A0;
+TEXTURE_COMPRESSED             :: 0x86A1;
+NUM_COMPRESSED_TEXTURE_FORMATS :: 0x86A2;
+COMPRESSED_TEXTURE_FORMATS     :: 0x86A3;
+CLAMP_TO_BORDER                :: 0x812D;
 
-	BLEND_DST_RGB                  = 0x80C8;
-	BLEND_SRC_RGB                  = 0x80C9;
-	BLEND_DST_ALPHA                = 0x80CA;
-	BLEND_SRC_ALPHA                = 0x80CB;
-	POINT_FADE_THRESHOLD_SIZE      = 0x8128;
-	DEPTH_COMPONENT16              = 0x81A5;
-	DEPTH_COMPONENT24              = 0x81A6;
-	DEPTH_COMPONENT32              = 0x81A7;
-	MIRRORED_REPEAT                = 0x8370;
-	MAX_TEXTURE_LOD_BIAS           = 0x84FD;
-	TEXTURE_LOD_BIAS               = 0x8501;
-	INCR_WRAP                      = 0x8507;
-	DECR_WRAP                      = 0x8508;
-	TEXTURE_DEPTH_SIZE             = 0x884A;
-	TEXTURE_COMPARE_MODE           = 0x884C;
-	TEXTURE_COMPARE_FUNC           = 0x884D;
-	FUNC_ADD                       = 0x8006;
-	FUNC_SUBTRACT                  = 0x800A;
-	FUNC_REVERSE_SUBTRACT          = 0x800B;
-	MIN                            = 0x8007;
-	MAX                            = 0x8008;
-	CONSTANT_COLOR                 = 0x8001;
-	ONE_MINUS_CONSTANT_COLOR       = 0x8002;
-	CONSTANT_ALPHA                 = 0x8003;
-	ONE_MINUS_CONSTANT_ALPHA       = 0x8004;
+BLEND_DST_RGB                  :: 0x80C8;
+BLEND_SRC_RGB                  :: 0x80C9;
+BLEND_DST_ALPHA                :: 0x80CA;
+BLEND_SRC_ALPHA                :: 0x80CB;
+POINT_FADE_THRESHOLD_SIZE      :: 0x8128;
+DEPTH_COMPONENT16              :: 0x81A5;
+DEPTH_COMPONENT24              :: 0x81A6;
+DEPTH_COMPONENT32              :: 0x81A7;
+MIRRORED_REPEAT                :: 0x8370;
+MAX_TEXTURE_LOD_BIAS           :: 0x84FD;
+TEXTURE_LOD_BIAS               :: 0x8501;
+INCR_WRAP                      :: 0x8507;
+DECR_WRAP                      :: 0x8508;
+TEXTURE_DEPTH_SIZE             :: 0x884A;
+TEXTURE_COMPARE_MODE           :: 0x884C;
+TEXTURE_COMPARE_FUNC           :: 0x884D;
+FUNC_ADD                       :: 0x8006;
+FUNC_SUBTRACT                  :: 0x800A;
+FUNC_REVERSE_SUBTRACT          :: 0x800B;
+MIN                            :: 0x8007;
+MAX                            :: 0x8008;
+CONSTANT_COLOR                 :: 0x8001;
+ONE_MINUS_CONSTANT_COLOR       :: 0x8002;
+CONSTANT_ALPHA                 :: 0x8003;
+ONE_MINUS_CONSTANT_ALPHA       :: 0x8004;
 
-	BUFFER_SIZE                    = 0x8764;
-	BUFFER_USAGE                   = 0x8765;
-	QUERY_COUNTER_BITS             = 0x8864;
-	CURRENT_QUERY                  = 0x8865;
-	QUERY_RESULT                   = 0x8866;
-	QUERY_RESULT_AVAILABLE         = 0x8867;
-	ARRAY_BUFFER                   = 0x8892;
-	ELEMENT_ARRAY_BUFFER           = 0x8893;
-	ARRAY_BUFFER_BINDING           = 0x8894;
-	ELEMENT_ARRAY_BUFFER_BINDING   = 0x8895;
-	VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F;
-	READ_ONLY                      = 0x88B8;
-	WRITE_ONLY                     = 0x88B9;
-	READ_WRITE                     = 0x88BA;
-	BUFFER_ACCESS                  = 0x88BB;
-	BUFFER_MAPPED                  = 0x88BC;
-	BUFFER_MAP_POINTER             = 0x88BD;
-	STREAM_DRAW                    = 0x88E0;
-	STREAM_READ                    = 0x88E1;
-	STREAM_COPY                    = 0x88E2;
-	STATIC_DRAW                    = 0x88E4;
-	STATIC_READ                    = 0x88E5;
-	STATIC_COPY                    = 0x88E6;
-	DYNAMIC_DRAW                   = 0x88E8;
-	DYNAMIC_READ                   = 0x88E9;
-	DYNAMIC_COPY                   = 0x88EA;
-	SAMPLES_PASSED                 = 0x8914;
-	SRC1_ALPHA                     = 0x8589;
+BUFFER_SIZE                    :: 0x8764;
+BUFFER_USAGE                   :: 0x8765;
+QUERY_COUNTER_BITS             :: 0x8864;
+CURRENT_QUERY                  :: 0x8865;
+QUERY_RESULT                   :: 0x8866;
+QUERY_RESULT_AVAILABLE         :: 0x8867;
+ARRAY_BUFFER                   :: 0x8892;
+ELEMENT_ARRAY_BUFFER           :: 0x8893;
+ARRAY_BUFFER_BINDING           :: 0x8894;
+ELEMENT_ARRAY_BUFFER_BINDING   :: 0x8895;
+VERTEX_ATTRIB_ARRAY_BUFFER_BINDING :: 0x889F;
+READ_ONLY                      :: 0x88B8;
+WRITE_ONLY                     :: 0x88B9;
+READ_WRITE                     :: 0x88BA;
+BUFFER_ACCESS                  :: 0x88BB;
+BUFFER_MAPPED                  :: 0x88BC;
+BUFFER_MAP_POINTER             :: 0x88BD;
+STREAM_DRAW                    :: 0x88E0;
+STREAM_READ                    :: 0x88E1;
+STREAM_COPY                    :: 0x88E2;
+STATIC_DRAW                    :: 0x88E4;
+STATIC_READ                    :: 0x88E5;
+STATIC_COPY                    :: 0x88E6;
+DYNAMIC_DRAW                   :: 0x88E8;
+DYNAMIC_READ                   :: 0x88E9;
+DYNAMIC_COPY                   :: 0x88EA;
+SAMPLES_PASSED                 :: 0x8914;
+SRC1_ALPHA                     :: 0x8589;
 
-	BLEND_EQUATION_RGB             = 0x8009;
-	VERTEX_ATTRIB_ARRAY_ENABLED    = 0x8622;
-	VERTEX_ATTRIB_ARRAY_SIZE       = 0x8623;
-	VERTEX_ATTRIB_ARRAY_STRIDE     = 0x8624;
-	VERTEX_ATTRIB_ARRAY_TYPE       = 0x8625;
-	CURRENT_VERTEX_ATTRIB          = 0x8626;
-	VERTEX_PROGRAM_POINT_SIZE      = 0x8642;
-	VERTEX_ATTRIB_ARRAY_POINTER    = 0x8645;
-	STENCIL_BACK_FUNC              = 0x8800;
-	STENCIL_BACK_FAIL              = 0x8801;
-	STENCIL_BACK_PASS_DEPTH_FAIL   = 0x8802;
-	STENCIL_BACK_PASS_DEPTH_PASS   = 0x8803;
-	MAX_DRAW_BUFFERS               = 0x8824;
-	DRAW_BUFFER0                   = 0x8825;
-	DRAW_BUFFER1                   = 0x8826;
-	DRAW_BUFFER2                   = 0x8827;
-	DRAW_BUFFER3                   = 0x8828;
-	DRAW_BUFFER4                   = 0x8829;
-	DRAW_BUFFER5                   = 0x882A;
-	DRAW_BUFFER6                   = 0x882B;
-	DRAW_BUFFER7                   = 0x882C;
-	DRAW_BUFFER8                   = 0x882D;
-	DRAW_BUFFER9                   = 0x882E;
-	DRAW_BUFFER10                  = 0x882F;
-	DRAW_BUFFER11                  = 0x8830;
-	DRAW_BUFFER12                  = 0x8831;
-	DRAW_BUFFER13                  = 0x8832;
-	DRAW_BUFFER14                  = 0x8833;
-	DRAW_BUFFER15                  = 0x8834;
-	BLEND_EQUATION_ALPHA           = 0x883D;
-	MAX_VERTEX_ATTRIBS             = 0x8869;
-	VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A;
-	MAX_TEXTURE_IMAGE_UNITS        = 0x8872;
-	FRAGMENT_SHADER                = 0x8B30;
-	VERTEX_SHADER                  = 0x8B31;
-	MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49;
-	MAX_VERTEX_UNIFORM_COMPONENTS  = 0x8B4A;
-	MAX_VARYING_FLOATS             = 0x8B4B;
-	MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C;
-	MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D;
-	SHADER_TYPE                    = 0x8B4F;
-	FLOAT_VEC2                     = 0x8B50;
-	FLOAT_VEC3                     = 0x8B51;
-	FLOAT_VEC4                     = 0x8B52;
-	INT_VEC2                       = 0x8B53;
-	INT_VEC3                       = 0x8B54;
-	INT_VEC4                       = 0x8B55;
-	BOOL                           = 0x8B56;
-	BOOL_VEC2                      = 0x8B57;
-	BOOL_VEC3                      = 0x8B58;
-	BOOL_VEC4                      = 0x8B59;
-	FLOAT_MAT2                     = 0x8B5A;
-	FLOAT_MAT3                     = 0x8B5B;
-	FLOAT_MAT4                     = 0x8B5C;
-	SAMPLER_1D                     = 0x8B5D;
-	SAMPLER_2D                     = 0x8B5E;
-	SAMPLER_3D                     = 0x8B5F;
-	SAMPLER_CUBE                   = 0x8B60;
-	SAMPLER_1D_SHADOW              = 0x8B61;
-	SAMPLER_2D_SHADOW              = 0x8B62;
-	DELETE_STATUS                  = 0x8B80;
-	COMPILE_STATUS                 = 0x8B81;
-	LINK_STATUS                    = 0x8B82;
-	VALIDATE_STATUS                = 0x8B83;
-	INFO_LOG_LENGTH                = 0x8B84;
-	ATTACHED_SHADERS               = 0x8B85;
-	ACTIVE_UNIFORMS                = 0x8B86;
-	ACTIVE_UNIFORM_MAX_LENGTH      = 0x8B87;
-	SHADER_SOURCE_LENGTH           = 0x8B88;
-	ACTIVE_ATTRIBUTES              = 0x8B89;
-	ACTIVE_ATTRIBUTE_MAX_LENGTH    = 0x8B8A;
-	FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B;
-	SHADING_LANGUAGE_VERSION       = 0x8B8C;
-	CURRENT_PROGRAM                = 0x8B8D;
-	POINT_SPRITE_COORD_ORIGIN      = 0x8CA0;
-	LOWER_LEFT                     = 0x8CA1;
-	UPPER_LEFT                     = 0x8CA2;
-	STENCIL_BACK_REF               = 0x8CA3;
-	STENCIL_BACK_VALUE_MASK        = 0x8CA4;
-	STENCIL_BACK_WRITEMASK         = 0x8CA5;
+BLEND_EQUATION_RGB             :: 0x8009;
+VERTEX_ATTRIB_ARRAY_ENABLED    :: 0x8622;
+VERTEX_ATTRIB_ARRAY_SIZE       :: 0x8623;
+VERTEX_ATTRIB_ARRAY_STRIDE     :: 0x8624;
+VERTEX_ATTRIB_ARRAY_TYPE       :: 0x8625;
+CURRENT_VERTEX_ATTRIB          :: 0x8626;
+VERTEX_PROGRAM_POINT_SIZE      :: 0x8642;
+VERTEX_ATTRIB_ARRAY_POINTER    :: 0x8645;
+STENCIL_BACK_FUNC              :: 0x8800;
+STENCIL_BACK_FAIL              :: 0x8801;
+STENCIL_BACK_PASS_DEPTH_FAIL   :: 0x8802;
+STENCIL_BACK_PASS_DEPTH_PASS   :: 0x8803;
+MAX_DRAW_BUFFERS               :: 0x8824;
+DRAW_BUFFER0                   :: 0x8825;
+DRAW_BUFFER1                   :: 0x8826;
+DRAW_BUFFER2                   :: 0x8827;
+DRAW_BUFFER3                   :: 0x8828;
+DRAW_BUFFER4                   :: 0x8829;
+DRAW_BUFFER5                   :: 0x882A;
+DRAW_BUFFER6                   :: 0x882B;
+DRAW_BUFFER7                   :: 0x882C;
+DRAW_BUFFER8                   :: 0x882D;
+DRAW_BUFFER9                   :: 0x882E;
+DRAW_BUFFER10                  :: 0x882F;
+DRAW_BUFFER11                  :: 0x8830;
+DRAW_BUFFER12                  :: 0x8831;
+DRAW_BUFFER13                  :: 0x8832;
+DRAW_BUFFER14                  :: 0x8833;
+DRAW_BUFFER15                  :: 0x8834;
+BLEND_EQUATION_ALPHA           :: 0x883D;
+MAX_VERTEX_ATTRIBS             :: 0x8869;
+VERTEX_ATTRIB_ARRAY_NORMALIZED :: 0x886A;
+MAX_TEXTURE_IMAGE_UNITS        :: 0x8872;
+FRAGMENT_SHADER                :: 0x8B30;
+VERTEX_SHADER                  :: 0x8B31;
+MAX_FRAGMENT_UNIFORM_COMPONENTS :: 0x8B49;
+MAX_VERTEX_UNIFORM_COMPONENTS  :: 0x8B4A;
+MAX_VARYING_FLOATS             :: 0x8B4B;
+MAX_VERTEX_TEXTURE_IMAGE_UNITS :: 0x8B4C;
+MAX_COMBINED_TEXTURE_IMAGE_UNITS :: 0x8B4D;
+SHADER_TYPE                    :: 0x8B4F;
+FLOAT_VEC2                     :: 0x8B50;
+FLOAT_VEC3                     :: 0x8B51;
+FLOAT_VEC4                     :: 0x8B52;
+INT_VEC2                       :: 0x8B53;
+INT_VEC3                       :: 0x8B54;
+INT_VEC4                       :: 0x8B55;
+BOOL                           :: 0x8B56;
+BOOL_VEC2                      :: 0x8B57;
+BOOL_VEC3                      :: 0x8B58;
+BOOL_VEC4                      :: 0x8B59;
+FLOAT_MAT2                     :: 0x8B5A;
+FLOAT_MAT3                     :: 0x8B5B;
+FLOAT_MAT4                     :: 0x8B5C;
+SAMPLER_1D                     :: 0x8B5D;
+SAMPLER_2D                     :: 0x8B5E;
+SAMPLER_3D                     :: 0x8B5F;
+SAMPLER_CUBE                   :: 0x8B60;
+SAMPLER_1D_SHADOW              :: 0x8B61;
+SAMPLER_2D_SHADOW              :: 0x8B62;
+DELETE_STATUS                  :: 0x8B80;
+COMPILE_STATUS                 :: 0x8B81;
+LINK_STATUS                    :: 0x8B82;
+VALIDATE_STATUS                :: 0x8B83;
+INFO_LOG_LENGTH                :: 0x8B84;
+ATTACHED_SHADERS               :: 0x8B85;
+ACTIVE_UNIFORMS                :: 0x8B86;
+ACTIVE_UNIFORM_MAX_LENGTH      :: 0x8B87;
+SHADER_SOURCE_LENGTH           :: 0x8B88;
+ACTIVE_ATTRIBUTES              :: 0x8B89;
+ACTIVE_ATTRIBUTE_MAX_LENGTH    :: 0x8B8A;
+FRAGMENT_SHADER_DERIVATIVE_HINT :: 0x8B8B;
+SHADING_LANGUAGE_VERSION       :: 0x8B8C;
+CURRENT_PROGRAM                :: 0x8B8D;
+POINT_SPRITE_COORD_ORIGIN      :: 0x8CA0;
+LOWER_LEFT                     :: 0x8CA1;
+UPPER_LEFT                     :: 0x8CA2;
+STENCIL_BACK_REF               :: 0x8CA3;
+STENCIL_BACK_VALUE_MASK        :: 0x8CA4;
+STENCIL_BACK_WRITEMASK         :: 0x8CA5;
 
-	PIXEL_PACK_BUFFER              = 0x88EB;
-	PIXEL_UNPACK_BUFFER            = 0x88EC;
-	PIXEL_PACK_BUFFER_BINDING      = 0x88ED;
-	PIXEL_UNPACK_BUFFER_BINDING    = 0x88EF;
-	FLOAT_MAT2x3                   = 0x8B65;
-	FLOAT_MAT2x4                   = 0x8B66;
-	FLOAT_MAT3x2                   = 0x8B67;
-	FLOAT_MAT3x4                   = 0x8B68;
-	FLOAT_MAT4x2                   = 0x8B69;
-	FLOAT_MAT4x3                   = 0x8B6A;
-	SRGB                           = 0x8C40;
-	SRGB8                          = 0x8C41;
-	SRGB_ALPHA                     = 0x8C42;
-	SRGB8_ALPHA8                   = 0x8C43;
-	COMPRESSED_SRGB                = 0x8C48;
-	COMPRESSED_SRGB_ALPHA          = 0x8C49;
+PIXEL_PACK_BUFFER              :: 0x88EB;
+PIXEL_UNPACK_BUFFER            :: 0x88EC;
+PIXEL_PACK_BUFFER_BINDING      :: 0x88ED;
+PIXEL_UNPACK_BUFFER_BINDING    :: 0x88EF;
+FLOAT_MAT2x3                   :: 0x8B65;
+FLOAT_MAT2x4                   :: 0x8B66;
+FLOAT_MAT3x2                   :: 0x8B67;
+FLOAT_MAT3x4                   :: 0x8B68;
+FLOAT_MAT4x2                   :: 0x8B69;
+FLOAT_MAT4x3                   :: 0x8B6A;
+SRGB                           :: 0x8C40;
+SRGB8                          :: 0x8C41;
+SRGB_ALPHA                     :: 0x8C42;
+SRGB8_ALPHA8                   :: 0x8C43;
+COMPRESSED_SRGB                :: 0x8C48;
+COMPRESSED_SRGB_ALPHA          :: 0x8C49;
 
-	COMPARE_REF_TO_TEXTURE         = 0x884E;
-	CLIP_DISTANCE0                 = 0x3000;
-	CLIP_DISTANCE1                 = 0x3001;
-	CLIP_DISTANCE2                 = 0x3002;
-	CLIP_DISTANCE3                 = 0x3003;
-	CLIP_DISTANCE4                 = 0x3004;
-	CLIP_DISTANCE5                 = 0x3005;
-	CLIP_DISTANCE6                 = 0x3006;
-	CLIP_DISTANCE7                 = 0x3007;
-	MAX_CLIP_DISTANCES             = 0x0D32;
-	MAJOR_VERSION                  = 0x821B;
-	MINOR_VERSION                  = 0x821C;
-	NUM_EXTENSIONS                 = 0x821D;
-	CONTEXT_FLAGS                  = 0x821E;
-	COMPRESSED_RED                 = 0x8225;
-	COMPRESSED_RG                  = 0x8226;
-	CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001;
-	RGBA32F                        = 0x8814;
-	RGB32F                         = 0x8815;
-	RGBA16F                        = 0x881A;
-	RGB16F                         = 0x881B;
-	VERTEX_ATTRIB_ARRAY_INTEGER    = 0x88FD;
-	MAX_ARRAY_TEXTURE_LAYERS       = 0x88FF;
-	MIN_PROGRAM_TEXEL_OFFSET       = 0x8904;
-	MAX_PROGRAM_TEXEL_OFFSET       = 0x8905;
-	CLAMP_READ_COLOR               = 0x891C;
-	FIXED_ONLY                     = 0x891D;
-	MAX_VARYING_COMPONENTS         = 0x8B4B;
-	TEXTURE_1D_ARRAY               = 0x8C18;
-	PROXY_TEXTURE_1D_ARRAY         = 0x8C19;
-	TEXTURE_2D_ARRAY               = 0x8C1A;
-	PROXY_TEXTURE_2D_ARRAY         = 0x8C1B;
-	TEXTURE_BINDING_1D_ARRAY       = 0x8C1C;
-	TEXTURE_BINDING_2D_ARRAY       = 0x8C1D;
-	R11F_G11F_B10F                 = 0x8C3A;
-	UNSIGNED_INT_10F_11F_11F_REV   = 0x8C3B;
-	RGB9_E5                        = 0x8C3D;
-	UNSIGNED_INT_5_9_9_9_REV       = 0x8C3E;
-	TEXTURE_SHARED_SIZE            = 0x8C3F;
-	TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76;
-	TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F;
-	MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80;
-	TRANSFORM_FEEDBACK_VARYINGS    = 0x8C83;
-	TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84;
-	TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85;
-	PRIMITIVES_GENERATED           = 0x8C87;
-	TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88;
-	RASTERIZER_DISCARD             = 0x8C89;
-	MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A;
-	MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B;
-	INTERLEAVED_ATTRIBS            = 0x8C8C;
-	SEPARATE_ATTRIBS               = 0x8C8D;
-	TRANSFORM_FEEDBACK_BUFFER      = 0x8C8E;
-	TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F;
-	RGBA32UI                       = 0x8D70;
-	RGB32UI                        = 0x8D71;
-	RGBA16UI                       = 0x8D76;
-	RGB16UI                        = 0x8D77;
-	RGBA8UI                        = 0x8D7C;
-	RGB8UI                         = 0x8D7D;
-	RGBA32I                        = 0x8D82;
-	RGB32I                         = 0x8D83;
-	RGBA16I                        = 0x8D88;
-	RGB16I                         = 0x8D89;
-	RGBA8I                         = 0x8D8E;
-	RGB8I                          = 0x8D8F;
-	RED_INTEGER                    = 0x8D94;
-	GREEN_INTEGER                  = 0x8D95;
-	BLUE_INTEGER                   = 0x8D96;
-	RGB_INTEGER                    = 0x8D98;
-	RGBA_INTEGER                   = 0x8D99;
-	BGR_INTEGER                    = 0x8D9A;
-	BGRA_INTEGER                   = 0x8D9B;
-	SAMPLER_1D_ARRAY               = 0x8DC0;
-	SAMPLER_2D_ARRAY               = 0x8DC1;
-	SAMPLER_1D_ARRAY_SHADOW        = 0x8DC3;
-	SAMPLER_2D_ARRAY_SHADOW        = 0x8DC4;
-	SAMPLER_CUBE_SHADOW            = 0x8DC5;
-	UNSIGNED_INT_VEC2              = 0x8DC6;
-	UNSIGNED_INT_VEC3              = 0x8DC7;
-	UNSIGNED_INT_VEC4              = 0x8DC8;
-	INT_SAMPLER_1D                 = 0x8DC9;
-	INT_SAMPLER_2D                 = 0x8DCA;
-	INT_SAMPLER_3D                 = 0x8DCB;
-	INT_SAMPLER_CUBE               = 0x8DCC;
-	INT_SAMPLER_1D_ARRAY           = 0x8DCE;
-	INT_SAMPLER_2D_ARRAY           = 0x8DCF;
-	UNSIGNED_INT_SAMPLER_1D        = 0x8DD1;
-	UNSIGNED_INT_SAMPLER_2D        = 0x8DD2;
-	UNSIGNED_INT_SAMPLER_3D        = 0x8DD3;
-	UNSIGNED_INT_SAMPLER_CUBE      = 0x8DD4;
-	UNSIGNED_INT_SAMPLER_1D_ARRAY  = 0x8DD6;
-	UNSIGNED_INT_SAMPLER_2D_ARRAY  = 0x8DD7;
-	QUERY_WAIT                     = 0x8E13;
-	QUERY_NO_WAIT                  = 0x8E14;
-	QUERY_BY_REGION_WAIT           = 0x8E15;
-	QUERY_BY_REGION_NO_WAIT        = 0x8E16;
-	BUFFER_ACCESS_FLAGS            = 0x911F;
-	BUFFER_MAP_LENGTH              = 0x9120;
-	BUFFER_MAP_OFFSET              = 0x9121;
-	DEPTH_COMPONENT32F             = 0x8CAC;
-	DEPTH32F_STENCIL8              = 0x8CAD;
-	FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD;
-	INVALID_FRAMEBUFFER_OPERATION  = 0x0506;
-	FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210;
-	FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211;
-	FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212;
-	FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213;
-	FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214;
-	FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215;
-	FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216;
-	FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217;
-	FRAMEBUFFER_DEFAULT            = 0x8218;
-	FRAMEBUFFER_UNDEFINED          = 0x8219;
-	DEPTH_STENCIL_ATTACHMENT       = 0x821A;
-	MAX_RENDERBUFFER_SIZE          = 0x84E8;
-	DEPTH_STENCIL                  = 0x84F9;
-	UNSIGNED_INT_24_8              = 0x84FA;
-	DEPTH24_STENCIL8               = 0x88F0;
-	TEXTURE_STENCIL_SIZE           = 0x88F1;
-	TEXTURE_RED_TYPE               = 0x8C10;
-	TEXTURE_GREEN_TYPE             = 0x8C11;
-	TEXTURE_BLUE_TYPE              = 0x8C12;
-	TEXTURE_ALPHA_TYPE             = 0x8C13;
-	TEXTURE_DEPTH_TYPE             = 0x8C16;
-	UNSIGNED_NORMALIZED            = 0x8C17;
-	FRAMEBUFFER_BINDING            = 0x8CA6;
-	DRAW_FRAMEBUFFER_BINDING       = 0x8CA6;
-	RENDERBUFFER_BINDING           = 0x8CA7;
-	READ_FRAMEBUFFER               = 0x8CA8;
-	DRAW_FRAMEBUFFER               = 0x8CA9;
-	READ_FRAMEBUFFER_BINDING       = 0x8CAA;
-	RENDERBUFFER_SAMPLES           = 0x8CAB;
-	FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0;
-	FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1;
-	FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2;
-	FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3;
-	FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4;
-	FRAMEBUFFER_COMPLETE           = 0x8CD5;
-	FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6;
-	FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7;
-	FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB;
-	FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC;
-	FRAMEBUFFER_UNSUPPORTED        = 0x8CDD;
-	MAX_COLOR_ATTACHMENTS          = 0x8CDF;
-	COLOR_ATTACHMENT0              = 0x8CE0;
-	COLOR_ATTACHMENT1              = 0x8CE1;
-	COLOR_ATTACHMENT2              = 0x8CE2;
-	COLOR_ATTACHMENT3              = 0x8CE3;
-	COLOR_ATTACHMENT4              = 0x8CE4;
-	COLOR_ATTACHMENT5              = 0x8CE5;
-	COLOR_ATTACHMENT6              = 0x8CE6;
-	COLOR_ATTACHMENT7              = 0x8CE7;
-	COLOR_ATTACHMENT8              = 0x8CE8;
-	COLOR_ATTACHMENT9              = 0x8CE9;
-	COLOR_ATTACHMENT10             = 0x8CEA;
-	COLOR_ATTACHMENT11             = 0x8CEB;
-	COLOR_ATTACHMENT12             = 0x8CEC;
-	COLOR_ATTACHMENT13             = 0x8CED;
-	COLOR_ATTACHMENT14             = 0x8CEE;
-	COLOR_ATTACHMENT15             = 0x8CEF;
-	COLOR_ATTACHMENT16             = 0x8CF0;
-	COLOR_ATTACHMENT17             = 0x8CF1;
-	COLOR_ATTACHMENT18             = 0x8CF2;
-	COLOR_ATTACHMENT19             = 0x8CF3;
-	COLOR_ATTACHMENT20             = 0x8CF4;
-	COLOR_ATTACHMENT21             = 0x8CF5;
-	COLOR_ATTACHMENT22             = 0x8CF6;
-	COLOR_ATTACHMENT23             = 0x8CF7;
-	COLOR_ATTACHMENT24             = 0x8CF8;
-	COLOR_ATTACHMENT25             = 0x8CF9;
-	COLOR_ATTACHMENT26             = 0x8CFA;
-	COLOR_ATTACHMENT27             = 0x8CFB;
-	COLOR_ATTACHMENT28             = 0x8CFC;
-	COLOR_ATTACHMENT29             = 0x8CFD;
-	COLOR_ATTACHMENT30             = 0x8CFE;
-	COLOR_ATTACHMENT31             = 0x8CFF;
-	DEPTH_ATTACHMENT               = 0x8D00;
-	STENCIL_ATTACHMENT             = 0x8D20;
-	FRAMEBUFFER                    = 0x8D40;
-	RENDERBUFFER                   = 0x8D41;
-	RENDERBUFFER_WIDTH             = 0x8D42;
-	RENDERBUFFER_HEIGHT            = 0x8D43;
-	RENDERBUFFER_INTERNAL_FORMAT   = 0x8D44;
-	STENCIL_INDEX1                 = 0x8D46;
-	STENCIL_INDEX4                 = 0x8D47;
-	STENCIL_INDEX8                 = 0x8D48;
-	STENCIL_INDEX16                = 0x8D49;
-	RENDERBUFFER_RED_SIZE          = 0x8D50;
-	RENDERBUFFER_GREEN_SIZE        = 0x8D51;
-	RENDERBUFFER_BLUE_SIZE         = 0x8D52;
-	RENDERBUFFER_ALPHA_SIZE        = 0x8D53;
-	RENDERBUFFER_DEPTH_SIZE        = 0x8D54;
-	RENDERBUFFER_STENCIL_SIZE      = 0x8D55;
-	FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56;
-	MAX_SAMPLES                    = 0x8D57;
-	FRAMEBUFFER_SRGB               = 0x8DB9;
-	HALF_FLOAT                     = 0x140B;
-	MAP_READ_BIT                   = 0x0001;
-	MAP_WRITE_BIT                  = 0x0002;
-	MAP_INVALIDATE_RANGE_BIT       = 0x0004;
-	MAP_INVALIDATE_BUFFER_BIT      = 0x0008;
-	MAP_FLUSH_EXPLICIT_BIT         = 0x0010;
-	MAP_UNSYNCHRONIZED_BIT         = 0x0020;
-	COMPRESSED_RED_RGTC1           = 0x8DBB;
-	COMPRESSED_SIGNED_RED_RGTC1    = 0x8DBC;
-	COMPRESSED_RG_RGTC2            = 0x8DBD;
-	COMPRESSED_SIGNED_RG_RGTC2     = 0x8DBE;
-	RG                             = 0x8227;
-	RG_INTEGER                     = 0x8228;
-	R8                             = 0x8229;
-	R16                            = 0x822A;
-	RG8                            = 0x822B;
-	RG16                           = 0x822C;
-	R16F                           = 0x822D;
-	R32F                           = 0x822E;
-	RG16F                          = 0x822F;
-	RG32F                          = 0x8230;
-	R8I                            = 0x8231;
-	R8UI                           = 0x8232;
-	R16I                           = 0x8233;
-	R16UI                          = 0x8234;
-	R32I                           = 0x8235;
-	R32UI                          = 0x8236;
-	RG8I                           = 0x8237;
-	RG8UI                          = 0x8238;
-	RG16I                          = 0x8239;
-	RG16UI                         = 0x823A;
-	RG32I                          = 0x823B;
-	RG32UI                         = 0x823C;
-	VERTEX_ARRAY_BINDING           = 0x85B5;
+COMPARE_REF_TO_TEXTURE         :: 0x884E;
+CLIP_DISTANCE0                 :: 0x3000;
+CLIP_DISTANCE1                 :: 0x3001;
+CLIP_DISTANCE2                 :: 0x3002;
+CLIP_DISTANCE3                 :: 0x3003;
+CLIP_DISTANCE4                 :: 0x3004;
+CLIP_DISTANCE5                 :: 0x3005;
+CLIP_DISTANCE6                 :: 0x3006;
+CLIP_DISTANCE7                 :: 0x3007;
+MAX_CLIP_DISTANCES             :: 0x0D32;
+MAJOR_VERSION                  :: 0x821B;
+MINOR_VERSION                  :: 0x821C;
+NUM_EXTENSIONS                 :: 0x821D;
+CONTEXT_FLAGS                  :: 0x821E;
+COMPRESSED_RED                 :: 0x8225;
+COMPRESSED_RG                  :: 0x8226;
+CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT :: 0x00000001;
+RGBA32F                        :: 0x8814;
+RGB32F                         :: 0x8815;
+RGBA16F                        :: 0x881A;
+RGB16F                         :: 0x881B;
+VERTEX_ATTRIB_ARRAY_INTEGER    :: 0x88FD;
+MAX_ARRAY_TEXTURE_LAYERS       :: 0x88FF;
+MIN_PROGRAM_TEXEL_OFFSET       :: 0x8904;
+MAX_PROGRAM_TEXEL_OFFSET       :: 0x8905;
+CLAMP_READ_COLOR               :: 0x891C;
+FIXED_ONLY                     :: 0x891D;
+MAX_VARYING_COMPONENTS         :: 0x8B4B;
+TEXTURE_1D_ARRAY               :: 0x8C18;
+PROXY_TEXTURE_1D_ARRAY         :: 0x8C19;
+TEXTURE_2D_ARRAY               :: 0x8C1A;
+PROXY_TEXTURE_2D_ARRAY         :: 0x8C1B;
+TEXTURE_BINDING_1D_ARRAY       :: 0x8C1C;
+TEXTURE_BINDING_2D_ARRAY       :: 0x8C1D;
+R11F_G11F_B10F                 :: 0x8C3A;
+UNSIGNED_INT_10F_11F_11F_REV   :: 0x8C3B;
+RGB9_E5                        :: 0x8C3D;
+UNSIGNED_INT_5_9_9_9_REV       :: 0x8C3E;
+TEXTURE_SHARED_SIZE            :: 0x8C3F;
+TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH :: 0x8C76;
+TRANSFORM_FEEDBACK_BUFFER_MODE :: 0x8C7F;
+MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS :: 0x8C80;
+TRANSFORM_FEEDBACK_VARYINGS    :: 0x8C83;
+TRANSFORM_FEEDBACK_BUFFER_START :: 0x8C84;
+TRANSFORM_FEEDBACK_BUFFER_SIZE :: 0x8C85;
+PRIMITIVES_GENERATED           :: 0x8C87;
+TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN :: 0x8C88;
+RASTERIZER_DISCARD             :: 0x8C89;
+MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS :: 0x8C8A;
+MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS :: 0x8C8B;
+INTERLEAVED_ATTRIBS            :: 0x8C8C;
+SEPARATE_ATTRIBS               :: 0x8C8D;
+TRANSFORM_FEEDBACK_BUFFER      :: 0x8C8E;
+TRANSFORM_FEEDBACK_BUFFER_BINDING :: 0x8C8F;
+RGBA32UI                       :: 0x8D70;
+RGB32UI                        :: 0x8D71;
+RGBA16UI                       :: 0x8D76;
+RGB16UI                        :: 0x8D77;
+RGBA8UI                        :: 0x8D7C;
+RGB8UI                         :: 0x8D7D;
+RGBA32I                        :: 0x8D82;
+RGB32I                         :: 0x8D83;
+RGBA16I                        :: 0x8D88;
+RGB16I                         :: 0x8D89;
+RGBA8I                         :: 0x8D8E;
+RGB8I                          :: 0x8D8F;
+RED_INTEGER                    :: 0x8D94;
+GREEN_INTEGER                  :: 0x8D95;
+BLUE_INTEGER                   :: 0x8D96;
+RGB_INTEGER                    :: 0x8D98;
+RGBA_INTEGER                   :: 0x8D99;
+BGR_INTEGER                    :: 0x8D9A;
+BGRA_INTEGER                   :: 0x8D9B;
+SAMPLER_1D_ARRAY               :: 0x8DC0;
+SAMPLER_2D_ARRAY               :: 0x8DC1;
+SAMPLER_1D_ARRAY_SHADOW        :: 0x8DC3;
+SAMPLER_2D_ARRAY_SHADOW        :: 0x8DC4;
+SAMPLER_CUBE_SHADOW            :: 0x8DC5;
+UNSIGNED_INT_VEC2              :: 0x8DC6;
+UNSIGNED_INT_VEC3              :: 0x8DC7;
+UNSIGNED_INT_VEC4              :: 0x8DC8;
+INT_SAMPLER_1D                 :: 0x8DC9;
+INT_SAMPLER_2D                 :: 0x8DCA;
+INT_SAMPLER_3D                 :: 0x8DCB;
+INT_SAMPLER_CUBE               :: 0x8DCC;
+INT_SAMPLER_1D_ARRAY           :: 0x8DCE;
+INT_SAMPLER_2D_ARRAY           :: 0x8DCF;
+UNSIGNED_INT_SAMPLER_1D        :: 0x8DD1;
+UNSIGNED_INT_SAMPLER_2D        :: 0x8DD2;
+UNSIGNED_INT_SAMPLER_3D        :: 0x8DD3;
+UNSIGNED_INT_SAMPLER_CUBE      :: 0x8DD4;
+UNSIGNED_INT_SAMPLER_1D_ARRAY  :: 0x8DD6;
+UNSIGNED_INT_SAMPLER_2D_ARRAY  :: 0x8DD7;
+QUERY_WAIT                     :: 0x8E13;
+QUERY_NO_WAIT                  :: 0x8E14;
+QUERY_BY_REGION_WAIT           :: 0x8E15;
+QUERY_BY_REGION_NO_WAIT        :: 0x8E16;
+BUFFER_ACCESS_FLAGS            :: 0x911F;
+BUFFER_MAP_LENGTH              :: 0x9120;
+BUFFER_MAP_OFFSET              :: 0x9121;
+DEPTH_COMPONENT32F             :: 0x8CAC;
+DEPTH32F_STENCIL8              :: 0x8CAD;
+FLOAT_32_UNSIGNED_INT_24_8_REV :: 0x8DAD;
+INVALID_FRAMEBUFFER_OPERATION  :: 0x0506;
+FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING :: 0x8210;
+FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE :: 0x8211;
+FRAMEBUFFER_ATTACHMENT_RED_SIZE :: 0x8212;
+FRAMEBUFFER_ATTACHMENT_GREEN_SIZE :: 0x8213;
+FRAMEBUFFER_ATTACHMENT_BLUE_SIZE :: 0x8214;
+FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE :: 0x8215;
+FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE :: 0x8216;
+FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE :: 0x8217;
+FRAMEBUFFER_DEFAULT            :: 0x8218;
+FRAMEBUFFER_UNDEFINED          :: 0x8219;
+DEPTH_STENCIL_ATTACHMENT       :: 0x821A;
+MAX_RENDERBUFFER_SIZE          :: 0x84E8;
+DEPTH_STENCIL                  :: 0x84F9;
+UNSIGNED_INT_24_8              :: 0x84FA;
+DEPTH24_STENCIL8               :: 0x88F0;
+TEXTURE_STENCIL_SIZE           :: 0x88F1;
+TEXTURE_RED_TYPE               :: 0x8C10;
+TEXTURE_GREEN_TYPE             :: 0x8C11;
+TEXTURE_BLUE_TYPE              :: 0x8C12;
+TEXTURE_ALPHA_TYPE             :: 0x8C13;
+TEXTURE_DEPTH_TYPE             :: 0x8C16;
+UNSIGNED_NORMALIZED            :: 0x8C17;
+FRAMEBUFFER_BINDING            :: 0x8CA6;
+DRAW_FRAMEBUFFER_BINDING       :: 0x8CA6;
+RENDERBUFFER_BINDING           :: 0x8CA7;
+READ_FRAMEBUFFER               :: 0x8CA8;
+DRAW_FRAMEBUFFER               :: 0x8CA9;
+READ_FRAMEBUFFER_BINDING       :: 0x8CAA;
+RENDERBUFFER_SAMPLES           :: 0x8CAB;
+FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE :: 0x8CD0;
+FRAMEBUFFER_ATTACHMENT_OBJECT_NAME :: 0x8CD1;
+FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL :: 0x8CD2;
+FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE :: 0x8CD3;
+FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER :: 0x8CD4;
+FRAMEBUFFER_COMPLETE           :: 0x8CD5;
+FRAMEBUFFER_INCOMPLETE_ATTACHMENT :: 0x8CD6;
+FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT :: 0x8CD7;
+FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER :: 0x8CDB;
+FRAMEBUFFER_INCOMPLETE_READ_BUFFER :: 0x8CDC;
+FRAMEBUFFER_UNSUPPORTED        :: 0x8CDD;
+MAX_COLOR_ATTACHMENTS          :: 0x8CDF;
+COLOR_ATTACHMENT0              :: 0x8CE0;
+COLOR_ATTACHMENT1              :: 0x8CE1;
+COLOR_ATTACHMENT2              :: 0x8CE2;
+COLOR_ATTACHMENT3              :: 0x8CE3;
+COLOR_ATTACHMENT4              :: 0x8CE4;
+COLOR_ATTACHMENT5              :: 0x8CE5;
+COLOR_ATTACHMENT6              :: 0x8CE6;
+COLOR_ATTACHMENT7              :: 0x8CE7;
+COLOR_ATTACHMENT8              :: 0x8CE8;
+COLOR_ATTACHMENT9              :: 0x8CE9;
+COLOR_ATTACHMENT10             :: 0x8CEA;
+COLOR_ATTACHMENT11             :: 0x8CEB;
+COLOR_ATTACHMENT12             :: 0x8CEC;
+COLOR_ATTACHMENT13             :: 0x8CED;
+COLOR_ATTACHMENT14             :: 0x8CEE;
+COLOR_ATTACHMENT15             :: 0x8CEF;
+COLOR_ATTACHMENT16             :: 0x8CF0;
+COLOR_ATTACHMENT17             :: 0x8CF1;
+COLOR_ATTACHMENT18             :: 0x8CF2;
+COLOR_ATTACHMENT19             :: 0x8CF3;
+COLOR_ATTACHMENT20             :: 0x8CF4;
+COLOR_ATTACHMENT21             :: 0x8CF5;
+COLOR_ATTACHMENT22             :: 0x8CF6;
+COLOR_ATTACHMENT23             :: 0x8CF7;
+COLOR_ATTACHMENT24             :: 0x8CF8;
+COLOR_ATTACHMENT25             :: 0x8CF9;
+COLOR_ATTACHMENT26             :: 0x8CFA;
+COLOR_ATTACHMENT27             :: 0x8CFB;
+COLOR_ATTACHMENT28             :: 0x8CFC;
+COLOR_ATTACHMENT29             :: 0x8CFD;
+COLOR_ATTACHMENT30             :: 0x8CFE;
+COLOR_ATTACHMENT31             :: 0x8CFF;
+DEPTH_ATTACHMENT               :: 0x8D00;
+STENCIL_ATTACHMENT             :: 0x8D20;
+FRAMEBUFFER                    :: 0x8D40;
+RENDERBUFFER                   :: 0x8D41;
+RENDERBUFFER_WIDTH             :: 0x8D42;
+RENDERBUFFER_HEIGHT            :: 0x8D43;
+RENDERBUFFER_INTERNAL_FORMAT   :: 0x8D44;
+STENCIL_INDEX1                 :: 0x8D46;
+STENCIL_INDEX4                 :: 0x8D47;
+STENCIL_INDEX8                 :: 0x8D48;
+STENCIL_INDEX16                :: 0x8D49;
+RENDERBUFFER_RED_SIZE          :: 0x8D50;
+RENDERBUFFER_GREEN_SIZE        :: 0x8D51;
+RENDERBUFFER_BLUE_SIZE         :: 0x8D52;
+RENDERBUFFER_ALPHA_SIZE        :: 0x8D53;
+RENDERBUFFER_DEPTH_SIZE        :: 0x8D54;
+RENDERBUFFER_STENCIL_SIZE      :: 0x8D55;
+FRAMEBUFFER_INCOMPLETE_MULTISAMPLE :: 0x8D56;
+MAX_SAMPLES                    :: 0x8D57;
+FRAMEBUFFER_SRGB               :: 0x8DB9;
+HALF_FLOAT                     :: 0x140B;
+MAP_READ_BIT                   :: 0x0001;
+MAP_WRITE_BIT                  :: 0x0002;
+MAP_INVALIDATE_RANGE_BIT       :: 0x0004;
+MAP_INVALIDATE_BUFFER_BIT      :: 0x0008;
+MAP_FLUSH_EXPLICIT_BIT         :: 0x0010;
+MAP_UNSYNCHRONIZED_BIT         :: 0x0020;
+COMPRESSED_RED_RGTC1           :: 0x8DBB;
+COMPRESSED_SIGNED_RED_RGTC1    :: 0x8DBC;
+COMPRESSED_RG_RGTC2            :: 0x8DBD;
+COMPRESSED_SIGNED_RG_RGTC2     :: 0x8DBE;
+RG                             :: 0x8227;
+RG_INTEGER                     :: 0x8228;
+R8                             :: 0x8229;
+R16                            :: 0x822A;
+RG8                            :: 0x822B;
+RG16                           :: 0x822C;
+R16F                           :: 0x822D;
+R32F                           :: 0x822E;
+RG16F                          :: 0x822F;
+RG32F                          :: 0x8230;
+R8I                            :: 0x8231;
+R8UI                           :: 0x8232;
+R16I                           :: 0x8233;
+R16UI                          :: 0x8234;
+R32I                           :: 0x8235;
+R32UI                          :: 0x8236;
+RG8I                           :: 0x8237;
+RG8UI                          :: 0x8238;
+RG16I                          :: 0x8239;
+RG16UI                         :: 0x823A;
+RG32I                          :: 0x823B;
+RG32UI                         :: 0x823C;
+VERTEX_ARRAY_BINDING           :: 0x85B5;
 
-	SAMPLER_2D_RECT                = 0x8B63;
-	SAMPLER_2D_RECT_SHADOW         = 0x8B64;
-	SAMPLER_BUFFER                 = 0x8DC2;
-	INT_SAMPLER_2D_RECT            = 0x8DCD;
-	INT_SAMPLER_BUFFER             = 0x8DD0;
-	UNSIGNED_INT_SAMPLER_2D_RECT   = 0x8DD5;
-	UNSIGNED_INT_SAMPLER_BUFFER    = 0x8DD8;
-	TEXTURE_BUFFER                 = 0x8C2A;
-	MAX_TEXTURE_BUFFER_SIZE        = 0x8C2B;
-	TEXTURE_BINDING_BUFFER         = 0x8C2C;
-	TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D;
-	TEXTURE_RECTANGLE              = 0x84F5;
-	TEXTURE_BINDING_RECTANGLE      = 0x84F6;
-	PROXY_TEXTURE_RECTANGLE        = 0x84F7;
-	MAX_RECTANGLE_TEXTURE_SIZE     = 0x84F8;
-	R8_SNORM                       = 0x8F94;
-	RG8_SNORM                      = 0x8F95;
-	RGB8_SNORM                     = 0x8F96;
-	RGBA8_SNORM                    = 0x8F97;
-	R16_SNORM                      = 0x8F98;
-	RG16_SNORM                     = 0x8F99;
-	RGB16_SNORM                    = 0x8F9A;
-	RGBA16_SNORM                   = 0x8F9B;
-	SIGNED_NORMALIZED              = 0x8F9C;
-	PRIMITIVE_RESTART              = 0x8F9D;
-	PRIMITIVE_RESTART_INDEX        = 0x8F9E;
-	COPY_READ_BUFFER               = 0x8F36;
-	COPY_WRITE_BUFFER              = 0x8F37;
-	UNIFORM_BUFFER                 = 0x8A11;
-	UNIFORM_BUFFER_BINDING         = 0x8A28;
-	UNIFORM_BUFFER_START           = 0x8A29;
-	UNIFORM_BUFFER_SIZE            = 0x8A2A;
-	MAX_VERTEX_UNIFORM_BLOCKS      = 0x8A2B;
-	MAX_GEOMETRY_UNIFORM_BLOCKS    = 0x8A2C;
-	MAX_FRAGMENT_UNIFORM_BLOCKS    = 0x8A2D;
-	MAX_COMBINED_UNIFORM_BLOCKS    = 0x8A2E;
-	MAX_UNIFORM_BUFFER_BINDINGS    = 0x8A2F;
-	MAX_UNIFORM_BLOCK_SIZE         = 0x8A30;
-	MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31;
-	MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32;
-	MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33;
-	UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34;
-	ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35;
-	ACTIVE_UNIFORM_BLOCKS          = 0x8A36;
-	UNIFORM_TYPE                   = 0x8A37;
-	UNIFORM_SIZE                   = 0x8A38;
-	UNIFORM_NAME_LENGTH            = 0x8A39;
-	UNIFORM_BLOCK_INDEX            = 0x8A3A;
-	UNIFORM_OFFSET                 = 0x8A3B;
-	UNIFORM_ARRAY_STRIDE           = 0x8A3C;
-	UNIFORM_MATRIX_STRIDE          = 0x8A3D;
-	UNIFORM_IS_ROW_MAJOR           = 0x8A3E;
-	UNIFORM_BLOCK_BINDING          = 0x8A3F;
-	UNIFORM_BLOCK_DATA_SIZE        = 0x8A40;
-	UNIFORM_BLOCK_NAME_LENGTH      = 0x8A41;
-	UNIFORM_BLOCK_ACTIVE_UNIFORMS  = 0x8A42;
-	UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43;
-	UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44;
-	UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45;
-	UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46;
-	INVALID_INDEX                  = 0xFFFFFFFF;
+SAMPLER_2D_RECT                :: 0x8B63;
+SAMPLER_2D_RECT_SHADOW         :: 0x8B64;
+SAMPLER_BUFFER                 :: 0x8DC2;
+INT_SAMPLER_2D_RECT            :: 0x8DCD;
+INT_SAMPLER_BUFFER             :: 0x8DD0;
+UNSIGNED_INT_SAMPLER_2D_RECT   :: 0x8DD5;
+UNSIGNED_INT_SAMPLER_BUFFER    :: 0x8DD8;
+TEXTURE_BUFFER                 :: 0x8C2A;
+MAX_TEXTURE_BUFFER_SIZE        :: 0x8C2B;
+TEXTURE_BINDING_BUFFER         :: 0x8C2C;
+TEXTURE_BUFFER_DATA_STORE_BINDING :: 0x8C2D;
+TEXTURE_RECTANGLE              :: 0x84F5;
+TEXTURE_BINDING_RECTANGLE      :: 0x84F6;
+PROXY_TEXTURE_RECTANGLE        :: 0x84F7;
+MAX_RECTANGLE_TEXTURE_SIZE     :: 0x84F8;
+R8_SNORM                       :: 0x8F94;
+RG8_SNORM                      :: 0x8F95;
+RGB8_SNORM                     :: 0x8F96;
+RGBA8_SNORM                    :: 0x8F97;
+R16_SNORM                      :: 0x8F98;
+RG16_SNORM                     :: 0x8F99;
+RGB16_SNORM                    :: 0x8F9A;
+RGBA16_SNORM                   :: 0x8F9B;
+SIGNED_NORMALIZED              :: 0x8F9C;
+PRIMITIVE_RESTART              :: 0x8F9D;
+PRIMITIVE_RESTART_INDEX        :: 0x8F9E;
+COPY_READ_BUFFER               :: 0x8F36;
+COPY_WRITE_BUFFER              :: 0x8F37;
+UNIFORM_BUFFER                 :: 0x8A11;
+UNIFORM_BUFFER_BINDING         :: 0x8A28;
+UNIFORM_BUFFER_START           :: 0x8A29;
+UNIFORM_BUFFER_SIZE            :: 0x8A2A;
+MAX_VERTEX_UNIFORM_BLOCKS      :: 0x8A2B;
+MAX_GEOMETRY_UNIFORM_BLOCKS    :: 0x8A2C;
+MAX_FRAGMENT_UNIFORM_BLOCKS    :: 0x8A2D;
+MAX_COMBINED_UNIFORM_BLOCKS    :: 0x8A2E;
+MAX_UNIFORM_BUFFER_BINDINGS    :: 0x8A2F;
+MAX_UNIFORM_BLOCK_SIZE         :: 0x8A30;
+MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS :: 0x8A31;
+MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS :: 0x8A32;
+MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS :: 0x8A33;
+UNIFORM_BUFFER_OFFSET_ALIGNMENT :: 0x8A34;
+ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH :: 0x8A35;
+ACTIVE_UNIFORM_BLOCKS          :: 0x8A36;
+UNIFORM_TYPE                   :: 0x8A37;
+UNIFORM_SIZE                   :: 0x8A38;
+UNIFORM_NAME_LENGTH            :: 0x8A39;
+UNIFORM_BLOCK_INDEX            :: 0x8A3A;
+UNIFORM_OFFSET                 :: 0x8A3B;
+UNIFORM_ARRAY_STRIDE           :: 0x8A3C;
+UNIFORM_MATRIX_STRIDE          :: 0x8A3D;
+UNIFORM_IS_ROW_MAJOR           :: 0x8A3E;
+UNIFORM_BLOCK_BINDING          :: 0x8A3F;
+UNIFORM_BLOCK_DATA_SIZE        :: 0x8A40;
+UNIFORM_BLOCK_NAME_LENGTH      :: 0x8A41;
+UNIFORM_BLOCK_ACTIVE_UNIFORMS  :: 0x8A42;
+UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES :: 0x8A43;
+UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER :: 0x8A44;
+UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER :: 0x8A45;
+UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER :: 0x8A46;
+INVALID_INDEX                  :: 0xFFFFFFFF;
 
-	CONTEXT_CORE_PROFILE_BIT       = 0x00000001;
-	CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002;
-	LINES_ADJACENCY                = 0x000A;
-	LINE_STRIP_ADJACENCY           = 0x000B;
-	TRIANGLES_ADJACENCY            = 0x000C;
-	TRIANGLE_STRIP_ADJACENCY       = 0x000D;
-	PROGRAM_POINT_SIZE             = 0x8642;
-	MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29;
-	FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7;
-	FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8;
-	GEOMETRY_SHADER                = 0x8DD9;
-	GEOMETRY_VERTICES_OUT          = 0x8916;
-	GEOMETRY_INPUT_TYPE            = 0x8917;
-	GEOMETRY_OUTPUT_TYPE           = 0x8918;
-	MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF;
-	MAX_GEOMETRY_OUTPUT_VERTICES   = 0x8DE0;
-	MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1;
-	MAX_VERTEX_OUTPUT_COMPONENTS   = 0x9122;
-	MAX_GEOMETRY_INPUT_COMPONENTS  = 0x9123;
-	MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124;
-	MAX_FRAGMENT_INPUT_COMPONENTS  = 0x9125;
-	CONTEXT_PROFILE_MASK           = 0x9126;
-	DEPTH_CLAMP                    = 0x864F;
-	QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C;
-	FIRST_VERTEX_CONVENTION        = 0x8E4D;
-	LAST_VERTEX_CONVENTION         = 0x8E4E;
-	PROVOKING_VERTEX               = 0x8E4F;
-	TEXTURE_CUBE_MAP_SEAMLESS      = 0x884F;
-	MAX_SERVER_WAIT_TIMEOUT        = 0x9111;
-	OBJECT_TYPE                    = 0x9112;
-	SYNC_CONDITION                 = 0x9113;
-	SYNC_STATUS                    = 0x9114;
-	SYNC_FLAGS                     = 0x9115;
-	SYNC_FENCE                     = 0x9116;
-	SYNC_GPU_COMMANDS_COMPLETE     = 0x9117;
-	UNSIGNALED                     = 0x9118;
-	SIGNALED                       = 0x9119;
-	ALREADY_SIGNALED               = 0x911A;
-	TIMEOUT_EXPIRED                = 0x911B;
-	CONDITION_SATISFIED            = 0x911C;
-	WAIT_FAILED                    = 0x911D;
-	TIMEOUT_IGNORED                = 0xFFFFFFFFFFFFFFFF;
-	SYNC_FLUSH_COMMANDS_BIT        = 0x00000001;
-	SAMPLE_POSITION                = 0x8E50;
-	SAMPLE_MASK                    = 0x8E51;
-	SAMPLE_MASK_VALUE              = 0x8E52;
-	MAX_SAMPLE_MASK_WORDS          = 0x8E59;
-	TEXTURE_2D_MULTISAMPLE         = 0x9100;
-	PROXY_TEXTURE_2D_MULTISAMPLE   = 0x9101;
-	TEXTURE_2D_MULTISAMPLE_ARRAY   = 0x9102;
-	PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103;
-	TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104;
-	TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105;
-	TEXTURE_SAMPLES                = 0x9106;
-	TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107;
-	SAMPLER_2D_MULTISAMPLE         = 0x9108;
-	INT_SAMPLER_2D_MULTISAMPLE     = 0x9109;
-	UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A;
-	SAMPLER_2D_MULTISAMPLE_ARRAY   = 0x910B;
-	INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C;
-	UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D;
-	MAX_COLOR_TEXTURE_SAMPLES      = 0x910E;
-	MAX_DEPTH_TEXTURE_SAMPLES      = 0x910F;
-	MAX_INTEGER_SAMPLES            = 0x9110;
+CONTEXT_CORE_PROFILE_BIT       :: 0x00000001;
+CONTEXT_COMPATIBILITY_PROFILE_BIT :: 0x00000002;
+LINES_ADJACENCY                :: 0x000A;
+LINE_STRIP_ADJACENCY           :: 0x000B;
+TRIANGLES_ADJACENCY            :: 0x000C;
+TRIANGLE_STRIP_ADJACENCY       :: 0x000D;
+PROGRAM_POINT_SIZE             :: 0x8642;
+MAX_GEOMETRY_TEXTURE_IMAGE_UNITS :: 0x8C29;
+FRAMEBUFFER_ATTACHMENT_LAYERED :: 0x8DA7;
+FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS :: 0x8DA8;
+GEOMETRY_SHADER                :: 0x8DD9;
+GEOMETRY_VERTICES_OUT          :: 0x8916;
+GEOMETRY_INPUT_TYPE            :: 0x8917;
+GEOMETRY_OUTPUT_TYPE           :: 0x8918;
+MAX_GEOMETRY_UNIFORM_COMPONENTS :: 0x8DDF;
+MAX_GEOMETRY_OUTPUT_VERTICES   :: 0x8DE0;
+MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS :: 0x8DE1;
+MAX_VERTEX_OUTPUT_COMPONENTS   :: 0x9122;
+MAX_GEOMETRY_INPUT_COMPONENTS  :: 0x9123;
+MAX_GEOMETRY_OUTPUT_COMPONENTS :: 0x9124;
+MAX_FRAGMENT_INPUT_COMPONENTS  :: 0x9125;
+CONTEXT_PROFILE_MASK           :: 0x9126;
+DEPTH_CLAMP                    :: 0x864F;
+QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION :: 0x8E4C;
+FIRST_VERTEX_CONVENTION        :: 0x8E4D;
+LAST_VERTEX_CONVENTION         :: 0x8E4E;
+PROVOKING_VERTEX               :: 0x8E4F;
+TEXTURE_CUBE_MAP_SEAMLESS      :: 0x884F;
+MAX_SERVER_WAIT_TIMEOUT        :: 0x9111;
+OBJECT_TYPE                    :: 0x9112;
+SYNC_CONDITION                 :: 0x9113;
+SYNC_STATUS                    :: 0x9114;
+SYNC_FLAGS                     :: 0x9115;
+SYNC_FENCE                     :: 0x9116;
+SYNC_GPU_COMMANDS_COMPLETE     :: 0x9117;
+UNSIGNALED                     :: 0x9118;
+SIGNALED                       :: 0x9119;
+ALREADY_SIGNALED               :: 0x911A;
+TIMEOUT_EXPIRED                :: 0x911B;
+CONDITION_SATISFIED            :: 0x911C;
+WAIT_FAILED                    :: 0x911D;
+TIMEOUT_IGNORED                :: 0xFFFFFFFFFFFFFFFF;
+SYNC_FLUSH_COMMANDS_BIT        :: 0x00000001;
+SAMPLE_POSITION                :: 0x8E50;
+SAMPLE_MASK                    :: 0x8E51;
+SAMPLE_MASK_VALUE              :: 0x8E52;
+MAX_SAMPLE_MASK_WORDS          :: 0x8E59;
+TEXTURE_2D_MULTISAMPLE         :: 0x9100;
+PROXY_TEXTURE_2D_MULTISAMPLE   :: 0x9101;
+TEXTURE_2D_MULTISAMPLE_ARRAY   :: 0x9102;
+PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY :: 0x9103;
+TEXTURE_BINDING_2D_MULTISAMPLE :: 0x9104;
+TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY :: 0x9105;
+TEXTURE_SAMPLES                :: 0x9106;
+TEXTURE_FIXED_SAMPLE_LOCATIONS :: 0x9107;
+SAMPLER_2D_MULTISAMPLE         :: 0x9108;
+INT_SAMPLER_2D_MULTISAMPLE     :: 0x9109;
+UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE :: 0x910A;
+SAMPLER_2D_MULTISAMPLE_ARRAY   :: 0x910B;
+INT_SAMPLER_2D_MULTISAMPLE_ARRAY :: 0x910C;
+UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY :: 0x910D;
+MAX_COLOR_TEXTURE_SAMPLES      :: 0x910E;
+MAX_DEPTH_TEXTURE_SAMPLES      :: 0x910F;
+MAX_INTEGER_SAMPLES            :: 0x9110;
 
-	VERTEX_ATTRIB_ARRAY_DIVISOR    = 0x88FE;
-	SRC1_COLOR                     = 0x88F9;
-	ONE_MINUS_SRC1_COLOR           = 0x88FA;
-	ONE_MINUS_SRC1_ALPHA           = 0x88FB;
-	MAX_DUAL_SOURCE_DRAW_BUFFERS   = 0x88FC;
-	ANY_SAMPLES_PASSED             = 0x8C2F;
-	SAMPLER_BINDING                = 0x8919;
-	RGB10_A2UI                     = 0x906F;
-	TEXTURE_SWIZZLE_R              = 0x8E42;
-	TEXTURE_SWIZZLE_G              = 0x8E43;
-	TEXTURE_SWIZZLE_B              = 0x8E44;
-	TEXTURE_SWIZZLE_A              = 0x8E45;
-	TEXTURE_SWIZZLE_RGBA           = 0x8E46;
-	TIME_ELAPSED                   = 0x88BF;
-	TIMESTAMP                      = 0x8E28;
-	INT_2_10_10_10_REV             = 0x8D9F;
+VERTEX_ATTRIB_ARRAY_DIVISOR    :: 0x88FE;
+SRC1_COLOR                     :: 0x88F9;
+ONE_MINUS_SRC1_COLOR           :: 0x88FA;
+ONE_MINUS_SRC1_ALPHA           :: 0x88FB;
+MAX_DUAL_SOURCE_DRAW_BUFFERS   :: 0x88FC;
+ANY_SAMPLES_PASSED             :: 0x8C2F;
+SAMPLER_BINDING                :: 0x8919;
+RGB10_A2UI                     :: 0x906F;
+TEXTURE_SWIZZLE_R              :: 0x8E42;
+TEXTURE_SWIZZLE_G              :: 0x8E43;
+TEXTURE_SWIZZLE_B              :: 0x8E44;
+TEXTURE_SWIZZLE_A              :: 0x8E45;
+TEXTURE_SWIZZLE_RGBA           :: 0x8E46;
+TIME_ELAPSED                   :: 0x88BF;
+TIMESTAMP                      :: 0x8E28;
+INT_2_10_10_10_REV             :: 0x8D9F;
 
-	SAMPLE_SHADING                 = 0x8C36;
-	MIN_SAMPLE_SHADING_VALUE       = 0x8C37;
-	MIN_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5E;
-	MAX_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5F;
-	TEXTURE_CUBE_MAP_ARRAY         = 0x9009;
-	TEXTURE_BINDING_CUBE_MAP_ARRAY = 0x900A;
-	PROXY_TEXTURE_CUBE_MAP_ARRAY   = 0x900B;
-	SAMPLER_CUBE_MAP_ARRAY         = 0x900C;
-	SAMPLER_CUBE_MAP_ARRAY_SHADOW  = 0x900D;
-	INT_SAMPLER_CUBE_MAP_ARRAY     = 0x900E;
-	UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = 0x900F;
-	DRAW_INDIRECT_BUFFER           = 0x8F3F;
-	DRAW_INDIRECT_BUFFER_BINDING   = 0x8F43;
-	GEOMETRY_SHADER_INVOCATIONS    = 0x887F;
-	MAX_GEOMETRY_SHADER_INVOCATIONS = 0x8E5A;
-	MIN_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5B;
-	MAX_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5C;
-	FRAGMENT_INTERPOLATION_OFFSET_BITS = 0x8E5D;
-	MAX_VERTEX_STREAMS             = 0x8E71;
-	DOUBLE_VEC2                    = 0x8FFC;
-	DOUBLE_VEC3                    = 0x8FFD;
-	DOUBLE_VEC4                    = 0x8FFE;
-	DOUBLE_MAT2                    = 0x8F46;
-	DOUBLE_MAT3                    = 0x8F47;
-	DOUBLE_MAT4                    = 0x8F48;
-	DOUBLE_MAT2x3                  = 0x8F49;
-	DOUBLE_MAT2x4                  = 0x8F4A;
-	DOUBLE_MAT3x2                  = 0x8F4B;
-	DOUBLE_MAT3x4                  = 0x8F4C;
-	DOUBLE_MAT4x2                  = 0x8F4D;
-	DOUBLE_MAT4x3                  = 0x8F4E;
-	ACTIVE_SUBROUTINES             = 0x8DE5;
-	ACTIVE_SUBROUTINE_UNIFORMS     = 0x8DE6;
-	ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = 0x8E47;
-	ACTIVE_SUBROUTINE_MAX_LENGTH   = 0x8E48;
-	ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = 0x8E49;
-	MAX_SUBROUTINES                = 0x8DE7;
-	MAX_SUBROUTINE_UNIFORM_LOCATIONS = 0x8DE8;
-	NUM_COMPATIBLE_SUBROUTINES     = 0x8E4A;
-	COMPATIBLE_SUBROUTINES         = 0x8E4B;
-	PATCHES                        = 0x000E;
-	PATCH_VERTICES                 = 0x8E72;
-	PATCH_DEFAULT_INNER_LEVEL      = 0x8E73;
-	PATCH_DEFAULT_OUTER_LEVEL      = 0x8E74;
-	TESS_CONTROL_OUTPUT_VERTICES   = 0x8E75;
-	TESS_GEN_MODE                  = 0x8E76;
-	TESS_GEN_SPACING               = 0x8E77;
-	TESS_GEN_VERTEX_ORDER          = 0x8E78;
-	TESS_GEN_POINT_MODE            = 0x8E79;
-	ISOLINES                       = 0x8E7A;
-	FRACTIONAL_ODD                 = 0x8E7B;
-	FRACTIONAL_EVEN                = 0x8E7C;
-	MAX_PATCH_VERTICES             = 0x8E7D;
-	MAX_TESS_GEN_LEVEL             = 0x8E7E;
-	MAX_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E7F;
-	MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E80;
-	MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = 0x8E81;
-	MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = 0x8E82;
-	MAX_TESS_CONTROL_OUTPUT_COMPONENTS = 0x8E83;
-	MAX_TESS_PATCH_COMPONENTS      = 0x8E84;
-	MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = 0x8E85;
-	MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = 0x8E86;
-	MAX_TESS_CONTROL_UNIFORM_BLOCKS = 0x8E89;
-	MAX_TESS_EVALUATION_UNIFORM_BLOCKS = 0x8E8A;
-	MAX_TESS_CONTROL_INPUT_COMPONENTS = 0x886C;
-	MAX_TESS_EVALUATION_INPUT_COMPONENTS = 0x886D;
-	MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E1E;
-	MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E1F;
-	UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = 0x84F0;
-	UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x84F1;
-	TESS_EVALUATION_SHADER         = 0x8E87;
-	TESS_CONTROL_SHADER            = 0x8E88;
-	TRANSFORM_FEEDBACK             = 0x8E22;
-	TRANSFORM_FEEDBACK_BUFFER_PAUSED = 0x8E23;
-	TRANSFORM_FEEDBACK_BUFFER_ACTIVE = 0x8E24;
-	TRANSFORM_FEEDBACK_BINDING     = 0x8E25;
-	MAX_TRANSFORM_FEEDBACK_BUFFERS = 0x8E70;
+SAMPLE_SHADING                 :: 0x8C36;
+MIN_SAMPLE_SHADING_VALUE       :: 0x8C37;
+MIN_PROGRAM_TEXTURE_GATHER_OFFSET :: 0x8E5E;
+MAX_PROGRAM_TEXTURE_GATHER_OFFSET :: 0x8E5F;
+TEXTURE_CUBE_MAP_ARRAY         :: 0x9009;
+TEXTURE_BINDING_CUBE_MAP_ARRAY :: 0x900A;
+PROXY_TEXTURE_CUBE_MAP_ARRAY   :: 0x900B;
+SAMPLER_CUBE_MAP_ARRAY         :: 0x900C;
+SAMPLER_CUBE_MAP_ARRAY_SHADOW  :: 0x900D;
+INT_SAMPLER_CUBE_MAP_ARRAY     :: 0x900E;
+UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY :: 0x900F;
+DRAW_INDIRECT_BUFFER           :: 0x8F3F;
+DRAW_INDIRECT_BUFFER_BINDING   :: 0x8F43;
+GEOMETRY_SHADER_INVOCATIONS    :: 0x887F;
+MAX_GEOMETRY_SHADER_INVOCATIONS :: 0x8E5A;
+MIN_FRAGMENT_INTERPOLATION_OFFSET :: 0x8E5B;
+MAX_FRAGMENT_INTERPOLATION_OFFSET :: 0x8E5C;
+FRAGMENT_INTERPOLATION_OFFSET_BITS :: 0x8E5D;
+MAX_VERTEX_STREAMS             :: 0x8E71;
+DOUBLE_VEC2                    :: 0x8FFC;
+DOUBLE_VEC3                    :: 0x8FFD;
+DOUBLE_VEC4                    :: 0x8FFE;
+DOUBLE_MAT2                    :: 0x8F46;
+DOUBLE_MAT3                    :: 0x8F47;
+DOUBLE_MAT4                    :: 0x8F48;
+DOUBLE_MAT2x3                  :: 0x8F49;
+DOUBLE_MAT2x4                  :: 0x8F4A;
+DOUBLE_MAT3x2                  :: 0x8F4B;
+DOUBLE_MAT3x4                  :: 0x8F4C;
+DOUBLE_MAT4x2                  :: 0x8F4D;
+DOUBLE_MAT4x3                  :: 0x8F4E;
+ACTIVE_SUBROUTINES             :: 0x8DE5;
+ACTIVE_SUBROUTINE_UNIFORMS     :: 0x8DE6;
+ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS :: 0x8E47;
+ACTIVE_SUBROUTINE_MAX_LENGTH   :: 0x8E48;
+ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH :: 0x8E49;
+MAX_SUBROUTINES                :: 0x8DE7;
+MAX_SUBROUTINE_UNIFORM_LOCATIONS :: 0x8DE8;
+NUM_COMPATIBLE_SUBROUTINES     :: 0x8E4A;
+COMPATIBLE_SUBROUTINES         :: 0x8E4B;
+PATCHES                        :: 0x000E;
+PATCH_VERTICES                 :: 0x8E72;
+PATCH_DEFAULT_INNER_LEVEL      :: 0x8E73;
+PATCH_DEFAULT_OUTER_LEVEL      :: 0x8E74;
+TESS_CONTROL_OUTPUT_VERTICES   :: 0x8E75;
+TESS_GEN_MODE                  :: 0x8E76;
+TESS_GEN_SPACING               :: 0x8E77;
+TESS_GEN_VERTEX_ORDER          :: 0x8E78;
+TESS_GEN_POINT_MODE            :: 0x8E79;
+ISOLINES                       :: 0x8E7A;
+FRACTIONAL_ODD                 :: 0x8E7B;
+FRACTIONAL_EVEN                :: 0x8E7C;
+MAX_PATCH_VERTICES             :: 0x8E7D;
+MAX_TESS_GEN_LEVEL             :: 0x8E7E;
+MAX_TESS_CONTROL_UNIFORM_COMPONENTS :: 0x8E7F;
+MAX_TESS_EVALUATION_UNIFORM_COMPONENTS :: 0x8E80;
+MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS :: 0x8E81;
+MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS :: 0x8E82;
+MAX_TESS_CONTROL_OUTPUT_COMPONENTS :: 0x8E83;
+MAX_TESS_PATCH_COMPONENTS      :: 0x8E84;
+MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS :: 0x8E85;
+MAX_TESS_EVALUATION_OUTPUT_COMPONENTS :: 0x8E86;
+MAX_TESS_CONTROL_UNIFORM_BLOCKS :: 0x8E89;
+MAX_TESS_EVALUATION_UNIFORM_BLOCKS :: 0x8E8A;
+MAX_TESS_CONTROL_INPUT_COMPONENTS :: 0x886C;
+MAX_TESS_EVALUATION_INPUT_COMPONENTS :: 0x886D;
+MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS :: 0x8E1E;
+MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS :: 0x8E1F;
+UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER :: 0x84F0;
+UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER :: 0x84F1;
+TESS_EVALUATION_SHADER         :: 0x8E87;
+TESS_CONTROL_SHADER            :: 0x8E88;
+TRANSFORM_FEEDBACK             :: 0x8E22;
+TRANSFORM_FEEDBACK_BUFFER_PAUSED :: 0x8E23;
+TRANSFORM_FEEDBACK_BUFFER_ACTIVE :: 0x8E24;
+TRANSFORM_FEEDBACK_BINDING     :: 0x8E25;
+MAX_TRANSFORM_FEEDBACK_BUFFERS :: 0x8E70;
 
-	FIXED                          = 0x140C;
-	IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A;
-	IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B;
-	LOW_FLOAT                      = 0x8DF0;
-	MEDIUM_FLOAT                   = 0x8DF1;
-	HIGH_FLOAT                     = 0x8DF2;
-	LOW_INT                        = 0x8DF3;
-	MEDIUM_INT                     = 0x8DF4;
-	HIGH_INT                       = 0x8DF5;
-	SHADER_COMPILER                = 0x8DFA;
-	SHADER_BINARY_FORMATS          = 0x8DF8;
-	NUM_SHADER_BINARY_FORMATS      = 0x8DF9;
-	MAX_VERTEX_UNIFORM_VECTORS     = 0x8DFB;
-	MAX_VARYING_VECTORS            = 0x8DFC;
-	MAX_FRAGMENT_UNIFORM_VECTORS   = 0x8DFD;
-	RGB565                         = 0x8D62;
-	PROGRAM_BINARY_RETRIEVABLE_HINT = 0x8257;
-	PROGRAM_BINARY_LENGTH          = 0x8741;
-	NUM_PROGRAM_BINARY_FORMATS     = 0x87FE;
-	PROGRAM_BINARY_FORMATS         = 0x87FF;
-	VERTEX_SHADER_BIT              = 0x00000001;
-	FRAGMENT_SHADER_BIT            = 0x00000002;
-	GEOMETRY_SHADER_BIT            = 0x00000004;
-	TESS_CONTROL_SHADER_BIT        = 0x00000008;
-	TESS_EVALUATION_SHADER_BIT     = 0x00000010;
-	ALL_SHADER_BITS                = 0xFFFFFFFF;
-	PROGRAM_SEPARABLE              = 0x8258;
-	ACTIVE_PROGRAM                 = 0x8259;
-	PROGRAM_PIPELINE_BINDING       = 0x825A;
-	MAX_VIEWPORTS                  = 0x825B;
-	VIEWPORT_SUBPIXEL_BITS         = 0x825C;
-	VIEWPORT_BOUNDS_RANGE          = 0x825D;
-	LAYER_PROVOKING_VERTEX         = 0x825E;
-	VIEWPORT_INDEX_PROVOKING_VERTEX = 0x825F;
-	UNDEFINED_VERTEX               = 0x8260;
+FIXED                          :: 0x140C;
+IMPLEMENTATION_COLOR_READ_TYPE :: 0x8B9A;
+IMPLEMENTATION_COLOR_READ_FORMAT :: 0x8B9B;
+LOW_FLOAT                      :: 0x8DF0;
+MEDIUM_FLOAT                   :: 0x8DF1;
+HIGH_FLOAT                     :: 0x8DF2;
+LOW_INT                        :: 0x8DF3;
+MEDIUM_INT                     :: 0x8DF4;
+HIGH_INT                       :: 0x8DF5;
+SHADER_COMPILER                :: 0x8DFA;
+SHADER_BINARY_FORMATS          :: 0x8DF8;
+NUM_SHADER_BINARY_FORMATS      :: 0x8DF9;
+MAX_VERTEX_UNIFORM_VECTORS     :: 0x8DFB;
+MAX_VARYING_VECTORS            :: 0x8DFC;
+MAX_FRAGMENT_UNIFORM_VECTORS   :: 0x8DFD;
+RGB565                         :: 0x8D62;
+PROGRAM_BINARY_RETRIEVABLE_HINT :: 0x8257;
+PROGRAM_BINARY_LENGTH          :: 0x8741;
+NUM_PROGRAM_BINARY_FORMATS     :: 0x87FE;
+PROGRAM_BINARY_FORMATS         :: 0x87FF;
+VERTEX_SHADER_BIT              :: 0x00000001;
+FRAGMENT_SHADER_BIT            :: 0x00000002;
+GEOMETRY_SHADER_BIT            :: 0x00000004;
+TESS_CONTROL_SHADER_BIT        :: 0x00000008;
+TESS_EVALUATION_SHADER_BIT     :: 0x00000010;
+ALL_SHADER_BITS                :: 0xFFFFFFFF;
+PROGRAM_SEPARABLE              :: 0x8258;
+ACTIVE_PROGRAM                 :: 0x8259;
+PROGRAM_PIPELINE_BINDING       :: 0x825A;
+MAX_VIEWPORTS                  :: 0x825B;
+VIEWPORT_SUBPIXEL_BITS         :: 0x825C;
+VIEWPORT_BOUNDS_RANGE          :: 0x825D;
+LAYER_PROVOKING_VERTEX         :: 0x825E;
+VIEWPORT_INDEX_PROVOKING_VERTEX :: 0x825F;
+UNDEFINED_VERTEX               :: 0x8260;
 
-	COPY_READ_BUFFER_BINDING       = 0x8F36;
-	COPY_WRITE_BUFFER_BINDING      = 0x8F37;
-	TRANSFORM_FEEDBACK_ACTIVE      = 0x8E24;
-	TRANSFORM_FEEDBACK_PAUSED      = 0x8E23;
-	UNPACK_COMPRESSED_BLOCK_WIDTH  = 0x9127;
-	UNPACK_COMPRESSED_BLOCK_HEIGHT = 0x9128;
-	UNPACK_COMPRESSED_BLOCK_DEPTH  = 0x9129;
-	UNPACK_COMPRESSED_BLOCK_SIZE   = 0x912A;
-	PACK_COMPRESSED_BLOCK_WIDTH    = 0x912B;
-	PACK_COMPRESSED_BLOCK_HEIGHT   = 0x912C;
-	PACK_COMPRESSED_BLOCK_DEPTH    = 0x912D;
-	PACK_COMPRESSED_BLOCK_SIZE     = 0x912E;
-	NUM_SAMPLE_COUNTS              = 0x9380;
-	MIN_MAP_BUFFER_ALIGNMENT       = 0x90BC;
-	ATOMIC_COUNTER_BUFFER          = 0x92C0;
-	ATOMIC_COUNTER_BUFFER_BINDING  = 0x92C1;
-	ATOMIC_COUNTER_BUFFER_START    = 0x92C2;
-	ATOMIC_COUNTER_BUFFER_SIZE     = 0x92C3;
-	ATOMIC_COUNTER_BUFFER_DATA_SIZE = 0x92C4;
-	ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS = 0x92C5;
-	ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES = 0x92C6;
-	ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER = 0x92C7;
-	ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER = 0x92C8;
-	ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x92C9;
-	ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER = 0x92CA;
-	ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER = 0x92CB;
-	MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = 0x92CC;
-	MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = 0x92CD;
-	MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = 0x92CE;
-	MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = 0x92CF;
-	MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = 0x92D0;
-	MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = 0x92D1;
-	MAX_VERTEX_ATOMIC_COUNTERS     = 0x92D2;
-	MAX_TESS_CONTROL_ATOMIC_COUNTERS = 0x92D3;
-	MAX_TESS_EVALUATION_ATOMIC_COUNTERS = 0x92D4;
-	MAX_GEOMETRY_ATOMIC_COUNTERS   = 0x92D5;
-	MAX_FRAGMENT_ATOMIC_COUNTERS   = 0x92D6;
-	MAX_COMBINED_ATOMIC_COUNTERS   = 0x92D7;
-	MAX_ATOMIC_COUNTER_BUFFER_SIZE = 0x92D8;
-	MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = 0x92DC;
-	ACTIVE_ATOMIC_COUNTER_BUFFERS  = 0x92D9;
-	UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX = 0x92DA;
-	UNSIGNED_INT_ATOMIC_COUNTER    = 0x92DB;
-	VERTEX_ATTRIB_ARRAY_BARRIER_BIT = 0x00000001;
-	ELEMENT_ARRAY_BARRIER_BIT      = 0x00000002;
-	UNIFORM_BARRIER_BIT            = 0x00000004;
-	TEXTURE_FETCH_BARRIER_BIT      = 0x00000008;
-	SHADER_IMAGE_ACCESS_BARRIER_BIT = 0x00000020;
-	COMMAND_BARRIER_BIT            = 0x00000040;
-	PIXEL_BUFFER_BARRIER_BIT       = 0x00000080;
-	TEXTURE_UPDATE_BARRIER_BIT     = 0x00000100;
-	BUFFER_UPDATE_BARRIER_BIT      = 0x00000200;
-	FRAMEBUFFER_BARRIER_BIT        = 0x00000400;
-	TRANSFORM_FEEDBACK_BARRIER_BIT = 0x00000800;
-	ATOMIC_COUNTER_BARRIER_BIT     = 0x00001000;
-	ALL_BARRIER_BITS               = 0xFFFFFFFF;
-	MAX_IMAGE_UNITS                = 0x8F38;
-	MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS = 0x8F39;
-	IMAGE_BINDING_NAME             = 0x8F3A;
-	IMAGE_BINDING_LEVEL            = 0x8F3B;
-	IMAGE_BINDING_LAYERED          = 0x8F3C;
-	IMAGE_BINDING_LAYER            = 0x8F3D;
-	IMAGE_BINDING_ACCESS           = 0x8F3E;
-	IMAGE_1D                       = 0x904C;
-	IMAGE_2D                       = 0x904D;
-	IMAGE_3D                       = 0x904E;
-	IMAGE_2D_RECT                  = 0x904F;
-	IMAGE_CUBE                     = 0x9050;
-	IMAGE_BUFFER                   = 0x9051;
-	IMAGE_1D_ARRAY                 = 0x9052;
-	IMAGE_2D_ARRAY                 = 0x9053;
-	IMAGE_CUBE_MAP_ARRAY           = 0x9054;
-	IMAGE_2D_MULTISAMPLE           = 0x9055;
-	IMAGE_2D_MULTISAMPLE_ARRAY     = 0x9056;
-	INT_IMAGE_1D                   = 0x9057;
-	INT_IMAGE_2D                   = 0x9058;
-	INT_IMAGE_3D                   = 0x9059;
-	INT_IMAGE_2D_RECT              = 0x905A;
-	INT_IMAGE_CUBE                 = 0x905B;
-	INT_IMAGE_BUFFER               = 0x905C;
-	INT_IMAGE_1D_ARRAY             = 0x905D;
-	INT_IMAGE_2D_ARRAY             = 0x905E;
-	INT_IMAGE_CUBE_MAP_ARRAY       = 0x905F;
-	INT_IMAGE_2D_MULTISAMPLE       = 0x9060;
-	INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x9061;
-	UNSIGNED_INT_IMAGE_1D          = 0x9062;
-	UNSIGNED_INT_IMAGE_2D          = 0x9063;
-	UNSIGNED_INT_IMAGE_3D          = 0x9064;
-	UNSIGNED_INT_IMAGE_2D_RECT     = 0x9065;
-	UNSIGNED_INT_IMAGE_CUBE        = 0x9066;
-	UNSIGNED_INT_IMAGE_BUFFER      = 0x9067;
-	UNSIGNED_INT_IMAGE_1D_ARRAY    = 0x9068;
-	UNSIGNED_INT_IMAGE_2D_ARRAY    = 0x9069;
-	UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = 0x906A;
-	UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = 0x906B;
-	UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x906C;
-	MAX_IMAGE_SAMPLES              = 0x906D;
-	IMAGE_BINDING_FORMAT           = 0x906E;
-	IMAGE_FORMAT_COMPATIBILITY_TYPE = 0x90C7;
-	IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = 0x90C8;
-	IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = 0x90C9;
-	MAX_VERTEX_IMAGE_UNIFORMS      = 0x90CA;
-	MAX_TESS_CONTROL_IMAGE_UNIFORMS = 0x90CB;
-	MAX_TESS_EVALUATION_IMAGE_UNIFORMS = 0x90CC;
-	MAX_GEOMETRY_IMAGE_UNIFORMS    = 0x90CD;
-	MAX_FRAGMENT_IMAGE_UNIFORMS    = 0x90CE;
-	MAX_COMBINED_IMAGE_UNIFORMS    = 0x90CF;
-	COMPRESSED_RGBA_BPTC_UNORM     = 0x8E8C;
-	COMPRESSED_SRGB_ALPHA_BPTC_UNORM = 0x8E8D;
-	COMPRESSED_RGB_BPTC_SIGNED_FLOAT = 0x8E8E;
-	COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT = 0x8E8F;
-	TEXTURE_IMMUTABLE_FORMAT       = 0x912F;
+COPY_READ_BUFFER_BINDING       :: 0x8F36;
+COPY_WRITE_BUFFER_BINDING      :: 0x8F37;
+TRANSFORM_FEEDBACK_ACTIVE      :: 0x8E24;
+TRANSFORM_FEEDBACK_PAUSED      :: 0x8E23;
+UNPACK_COMPRESSED_BLOCK_WIDTH  :: 0x9127;
+UNPACK_COMPRESSED_BLOCK_HEIGHT :: 0x9128;
+UNPACK_COMPRESSED_BLOCK_DEPTH  :: 0x9129;
+UNPACK_COMPRESSED_BLOCK_SIZE   :: 0x912A;
+PACK_COMPRESSED_BLOCK_WIDTH    :: 0x912B;
+PACK_COMPRESSED_BLOCK_HEIGHT   :: 0x912C;
+PACK_COMPRESSED_BLOCK_DEPTH    :: 0x912D;
+PACK_COMPRESSED_BLOCK_SIZE     :: 0x912E;
+NUM_SAMPLE_COUNTS              :: 0x9380;
+MIN_MAP_BUFFER_ALIGNMENT       :: 0x90BC;
+ATOMIC_COUNTER_BUFFER          :: 0x92C0;
+ATOMIC_COUNTER_BUFFER_BINDING  :: 0x92C1;
+ATOMIC_COUNTER_BUFFER_START    :: 0x92C2;
+ATOMIC_COUNTER_BUFFER_SIZE     :: 0x92C3;
+ATOMIC_COUNTER_BUFFER_DATA_SIZE :: 0x92C4;
+ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS :: 0x92C5;
+ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES :: 0x92C6;
+ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER :: 0x92C7;
+ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER :: 0x92C8;
+ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER :: 0x92C9;
+ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER :: 0x92CA;
+ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER :: 0x92CB;
+MAX_VERTEX_ATOMIC_COUNTER_BUFFERS :: 0x92CC;
+MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS :: 0x92CD;
+MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS :: 0x92CE;
+MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS :: 0x92CF;
+MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS :: 0x92D0;
+MAX_COMBINED_ATOMIC_COUNTER_BUFFERS :: 0x92D1;
+MAX_VERTEX_ATOMIC_COUNTERS     :: 0x92D2;
+MAX_TESS_CONTROL_ATOMIC_COUNTERS :: 0x92D3;
+MAX_TESS_EVALUATION_ATOMIC_COUNTERS :: 0x92D4;
+MAX_GEOMETRY_ATOMIC_COUNTERS   :: 0x92D5;
+MAX_FRAGMENT_ATOMIC_COUNTERS   :: 0x92D6;
+MAX_COMBINED_ATOMIC_COUNTERS   :: 0x92D7;
+MAX_ATOMIC_COUNTER_BUFFER_SIZE :: 0x92D8;
+MAX_ATOMIC_COUNTER_BUFFER_BINDINGS :: 0x92DC;
+ACTIVE_ATOMIC_COUNTER_BUFFERS  :: 0x92D9;
+UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX :: 0x92DA;
+UNSIGNED_INT_ATOMIC_COUNTER    :: 0x92DB;
+VERTEX_ATTRIB_ARRAY_BARRIER_BIT :: 0x00000001;
+ELEMENT_ARRAY_BARRIER_BIT      :: 0x00000002;
+UNIFORM_BARRIER_BIT            :: 0x00000004;
+TEXTURE_FETCH_BARRIER_BIT      :: 0x00000008;
+SHADER_IMAGE_ACCESS_BARRIER_BIT :: 0x00000020;
+COMMAND_BARRIER_BIT            :: 0x00000040;
+PIXEL_BUFFER_BARRIER_BIT       :: 0x00000080;
+TEXTURE_UPDATE_BARRIER_BIT     :: 0x00000100;
+BUFFER_UPDATE_BARRIER_BIT      :: 0x00000200;
+FRAMEBUFFER_BARRIER_BIT        :: 0x00000400;
+TRANSFORM_FEEDBACK_BARRIER_BIT :: 0x00000800;
+ATOMIC_COUNTER_BARRIER_BIT     :: 0x00001000;
+ALL_BARRIER_BITS               :: 0xFFFFFFFF;
+MAX_IMAGE_UNITS                :: 0x8F38;
+MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS :: 0x8F39;
+IMAGE_BINDING_NAME             :: 0x8F3A;
+IMAGE_BINDING_LEVEL            :: 0x8F3B;
+IMAGE_BINDING_LAYERED          :: 0x8F3C;
+IMAGE_BINDING_LAYER            :: 0x8F3D;
+IMAGE_BINDING_ACCESS           :: 0x8F3E;
+IMAGE_1D                       :: 0x904C;
+IMAGE_2D                       :: 0x904D;
+IMAGE_3D                       :: 0x904E;
+IMAGE_2D_RECT                  :: 0x904F;
+IMAGE_CUBE                     :: 0x9050;
+IMAGE_BUFFER                   :: 0x9051;
+IMAGE_1D_ARRAY                 :: 0x9052;
+IMAGE_2D_ARRAY                 :: 0x9053;
+IMAGE_CUBE_MAP_ARRAY           :: 0x9054;
+IMAGE_2D_MULTISAMPLE           :: 0x9055;
+IMAGE_2D_MULTISAMPLE_ARRAY     :: 0x9056;
+INT_IMAGE_1D                   :: 0x9057;
+INT_IMAGE_2D                   :: 0x9058;
+INT_IMAGE_3D                   :: 0x9059;
+INT_IMAGE_2D_RECT              :: 0x905A;
+INT_IMAGE_CUBE                 :: 0x905B;
+INT_IMAGE_BUFFER               :: 0x905C;
+INT_IMAGE_1D_ARRAY             :: 0x905D;
+INT_IMAGE_2D_ARRAY             :: 0x905E;
+INT_IMAGE_CUBE_MAP_ARRAY       :: 0x905F;
+INT_IMAGE_2D_MULTISAMPLE       :: 0x9060;
+INT_IMAGE_2D_MULTISAMPLE_ARRAY :: 0x9061;
+UNSIGNED_INT_IMAGE_1D          :: 0x9062;
+UNSIGNED_INT_IMAGE_2D          :: 0x9063;
+UNSIGNED_INT_IMAGE_3D          :: 0x9064;
+UNSIGNED_INT_IMAGE_2D_RECT     :: 0x9065;
+UNSIGNED_INT_IMAGE_CUBE        :: 0x9066;
+UNSIGNED_INT_IMAGE_BUFFER      :: 0x9067;
+UNSIGNED_INT_IMAGE_1D_ARRAY    :: 0x9068;
+UNSIGNED_INT_IMAGE_2D_ARRAY    :: 0x9069;
+UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY :: 0x906A;
+UNSIGNED_INT_IMAGE_2D_MULTISAMPLE :: 0x906B;
+UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY :: 0x906C;
+MAX_IMAGE_SAMPLES              :: 0x906D;
+IMAGE_BINDING_FORMAT           :: 0x906E;
+IMAGE_FORMAT_COMPATIBILITY_TYPE :: 0x90C7;
+IMAGE_FORMAT_COMPATIBILITY_BY_SIZE :: 0x90C8;
+IMAGE_FORMAT_COMPATIBILITY_BY_CLASS :: 0x90C9;
+MAX_VERTEX_IMAGE_UNIFORMS      :: 0x90CA;
+MAX_TESS_CONTROL_IMAGE_UNIFORMS :: 0x90CB;
+MAX_TESS_EVALUATION_IMAGE_UNIFORMS :: 0x90CC;
+MAX_GEOMETRY_IMAGE_UNIFORMS    :: 0x90CD;
+MAX_FRAGMENT_IMAGE_UNIFORMS    :: 0x90CE;
+MAX_COMBINED_IMAGE_UNIFORMS    :: 0x90CF;
+COMPRESSED_RGBA_BPTC_UNORM     :: 0x8E8C;
+COMPRESSED_SRGB_ALPHA_BPTC_UNORM :: 0x8E8D;
+COMPRESSED_RGB_BPTC_SIGNED_FLOAT :: 0x8E8E;
+COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT :: 0x8E8F;
+TEXTURE_IMMUTABLE_FORMAT       :: 0x912F;
 
-	NUM_SHADING_LANGUAGE_VERSIONS  = 0x82E9;
-	VERTEX_ATTRIB_ARRAY_LONG       = 0x874E;
-	COMPRESSED_RGB8_ETC2           = 0x9274;
-	COMPRESSED_SRGB8_ETC2          = 0x9275;
-	COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276;
-	COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277;
-	COMPRESSED_RGBA8_ETC2_EAC      = 0x9278;
-	COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279;
-	COMPRESSED_R11_EAC             = 0x9270;
-	COMPRESSED_SIGNED_R11_EAC      = 0x9271;
-	COMPRESSED_RG11_EAC            = 0x9272;
-	COMPRESSED_SIGNED_RG11_EAC     = 0x9273;
-	PRIMITIVE_RESTART_FIXED_INDEX  = 0x8D69;
-	ANY_SAMPLES_PASSED_CONSERVATIVE = 0x8D6A;
-	MAX_ELEMENT_INDEX              = 0x8D6B;
-	COMPUTE_SHADER                 = 0x91B9;
-	MAX_COMPUTE_UNIFORM_BLOCKS     = 0x91BB;
-	MAX_COMPUTE_TEXTURE_IMAGE_UNITS = 0x91BC;
-	MAX_COMPUTE_IMAGE_UNIFORMS     = 0x91BD;
-	MAX_COMPUTE_SHARED_MEMORY_SIZE = 0x8262;
-	MAX_COMPUTE_UNIFORM_COMPONENTS = 0x8263;
-	MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS = 0x8264;
-	MAX_COMPUTE_ATOMIC_COUNTERS    = 0x8265;
-	MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS = 0x8266;
-	MAX_COMPUTE_WORK_GROUP_INVOCATIONS = 0x90EB;
-	MAX_COMPUTE_WORK_GROUP_COUNT   = 0x91BE;
-	MAX_COMPUTE_WORK_GROUP_SIZE    = 0x91BF;
-	COMPUTE_WORK_GROUP_SIZE        = 0x8267;
-	UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER = 0x90EC;
-	ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER = 0x90ED;
-	DISPATCH_INDIRECT_BUFFER       = 0x90EE;
-	DISPATCH_INDIRECT_BUFFER_BINDING = 0x90EF;
-	COMPUTE_SHADER_BIT             = 0x00000020;
-	DEBUG_OUTPUT_SYNCHRONOUS       = 0x8242;
-	DEBUG_NEXT_LOGGED_MESSAGE_LENGTH = 0x8243;
-	DEBUG_CALLBACK_FUNCTION        = 0x8244;
-	DEBUG_CALLBACK_USER_PARAM      = 0x8245;
-	DEBUG_SOURCE_API               = 0x8246;
-	DEBUG_SOURCE_WINDOW_SYSTEM     = 0x8247;
-	DEBUG_SOURCE_SHADER_COMPILER   = 0x8248;
-	DEBUG_SOURCE_THIRD_PARTY       = 0x8249;
-	DEBUG_SOURCE_APPLICATION       = 0x824A;
-	DEBUG_SOURCE_OTHER             = 0x824B;
-	DEBUG_TYPE_ERROR               = 0x824C;
-	DEBUG_TYPE_DEPRECATED_BEHAVIOR = 0x824D;
-	DEBUG_TYPE_UNDEFINED_BEHAVIOR  = 0x824E;
-	DEBUG_TYPE_PORTABILITY         = 0x824F;
-	DEBUG_TYPE_PERFORMANCE         = 0x8250;
-	DEBUG_TYPE_OTHER               = 0x8251;
-	MAX_DEBUG_MESSAGE_LENGTH       = 0x9143;
-	MAX_DEBUG_LOGGED_MESSAGES      = 0x9144;
-	DEBUG_LOGGED_MESSAGES          = 0x9145;
-	DEBUG_SEVERITY_HIGH            = 0x9146;
-	DEBUG_SEVERITY_MEDIUM          = 0x9147;
-	DEBUG_SEVERITY_LOW             = 0x9148;
-	DEBUG_TYPE_MARKER              = 0x8268;
-	DEBUG_TYPE_PUSH_GROUP          = 0x8269;
-	DEBUG_TYPE_POP_GROUP           = 0x826A;
-	DEBUG_SEVERITY_NOTIFICATION    = 0x826B;
-	MAX_DEBUG_GROUP_STACK_DEPTH    = 0x826C;
-	DEBUG_GROUP_STACK_DEPTH        = 0x826D;
-	BUFFER                         = 0x82E0;
-	SHADER                         = 0x82E1;
-	PROGRAM                        = 0x82E2;
-	QUERY                          = 0x82E3;
-	PROGRAM_PIPELINE               = 0x82E4;
-	SAMPLER                        = 0x82E6;
-	MAX_LABEL_LENGTH               = 0x82E8;
-	DEBUG_OUTPUT                   = 0x92E0;
-	CONTEXT_FLAG_DEBUG_BIT         = 0x00000002;
-	MAX_UNIFORM_LOCATIONS          = 0x826E;
-	FRAMEBUFFER_DEFAULT_WIDTH      = 0x9310;
-	FRAMEBUFFER_DEFAULT_HEIGHT     = 0x9311;
-	FRAMEBUFFER_DEFAULT_LAYERS     = 0x9312;
-	FRAMEBUFFER_DEFAULT_SAMPLES    = 0x9313;
-	FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS = 0x9314;
-	MAX_FRAMEBUFFER_WIDTH          = 0x9315;
-	MAX_FRAMEBUFFER_HEIGHT         = 0x9316;
-	MAX_FRAMEBUFFER_LAYERS         = 0x9317;
-	MAX_FRAMEBUFFER_SAMPLES        = 0x9318;
-	INTERNALFORMAT_SUPPORTED       = 0x826F;
-	INTERNALFORMAT_PREFERRED       = 0x8270;
-	INTERNALFORMAT_RED_SIZE        = 0x8271;
-	INTERNALFORMAT_GREEN_SIZE      = 0x8272;
-	INTERNALFORMAT_BLUE_SIZE       = 0x8273;
-	INTERNALFORMAT_ALPHA_SIZE      = 0x8274;
-	INTERNALFORMAT_DEPTH_SIZE      = 0x8275;
-	INTERNALFORMAT_STENCIL_SIZE    = 0x8276;
-	INTERNALFORMAT_SHARED_SIZE     = 0x8277;
-	INTERNALFORMAT_RED_TYPE        = 0x8278;
-	INTERNALFORMAT_GREEN_TYPE      = 0x8279;
-	INTERNALFORMAT_BLUE_TYPE       = 0x827A;
-	INTERNALFORMAT_ALPHA_TYPE      = 0x827B;
-	INTERNALFORMAT_DEPTH_TYPE      = 0x827C;
-	INTERNALFORMAT_STENCIL_TYPE    = 0x827D;
-	MAX_WIDTH                      = 0x827E;
-	MAX_HEIGHT                     = 0x827F;
-	MAX_DEPTH                      = 0x8280;
-	MAX_LAYERS                     = 0x8281;
-	MAX_COMBINED_DIMENSIONS        = 0x8282;
-	COLOR_COMPONENTS               = 0x8283;
-	DEPTH_COMPONENTS               = 0x8284;
-	STENCIL_COMPONENTS             = 0x8285;
-	COLOR_RENDERABLE               = 0x8286;
-	DEPTH_RENDERABLE               = 0x8287;
-	STENCIL_RENDERABLE             = 0x8288;
-	FRAMEBUFFER_RENDERABLE         = 0x8289;
-	FRAMEBUFFER_RENDERABLE_LAYERED = 0x828A;
-	FRAMEBUFFER_BLEND              = 0x828B;
-	READ_PIXELS                    = 0x828C;
-	READ_PIXELS_FORMAT             = 0x828D;
-	READ_PIXELS_TYPE               = 0x828E;
-	TEXTURE_IMAGE_FORMAT           = 0x828F;
-	TEXTURE_IMAGE_TYPE             = 0x8290;
-	GET_TEXTURE_IMAGE_FORMAT       = 0x8291;
-	GET_TEXTURE_IMAGE_TYPE         = 0x8292;
-	MIPMAP                         = 0x8293;
-	MANUAL_GENERATE_MIPMAP         = 0x8294;
-	AUTO_GENERATE_MIPMAP           = 0x8295;
-	COLOR_ENCODING                 = 0x8296;
-	SRGB_READ                      = 0x8297;
-	SRGB_WRITE                     = 0x8298;
-	FILTER                         = 0x829A;
-	VERTEX_TEXTURE                 = 0x829B;
-	TESS_CONTROL_TEXTURE           = 0x829C;
-	TESS_EVALUATION_TEXTURE        = 0x829D;
-	GEOMETRY_TEXTURE               = 0x829E;
-	FRAGMENT_TEXTURE               = 0x829F;
-	COMPUTE_TEXTURE                = 0x82A0;
-	TEXTURE_SHADOW                 = 0x82A1;
-	TEXTURE_GATHER                 = 0x82A2;
-	TEXTURE_GATHER_SHADOW          = 0x82A3;
-	SHADER_IMAGE_LOAD              = 0x82A4;
-	SHADER_IMAGE_STORE             = 0x82A5;
-	SHADER_IMAGE_ATOMIC            = 0x82A6;
-	IMAGE_TEXEL_SIZE               = 0x82A7;
-	IMAGE_COMPATIBILITY_CLASS      = 0x82A8;
-	IMAGE_PIXEL_FORMAT             = 0x82A9;
-	IMAGE_PIXEL_TYPE               = 0x82AA;
-	SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST = 0x82AC;
-	SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST = 0x82AD;
-	SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE = 0x82AE;
-	SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE = 0x82AF;
-	TEXTURE_COMPRESSED_BLOCK_WIDTH = 0x82B1;
-	TEXTURE_COMPRESSED_BLOCK_HEIGHT = 0x82B2;
-	TEXTURE_COMPRESSED_BLOCK_SIZE  = 0x82B3;
-	CLEAR_BUFFER                   = 0x82B4;
-	TEXTURE_VIEW                   = 0x82B5;
-	VIEW_COMPATIBILITY_CLASS       = 0x82B6;
-	FULL_SUPPORT                   = 0x82B7;
-	CAVEAT_SUPPORT                 = 0x82B8;
-	IMAGE_CLASS_4_X_32             = 0x82B9;
-	IMAGE_CLASS_2_X_32             = 0x82BA;
-	IMAGE_CLASS_1_X_32             = 0x82BB;
-	IMAGE_CLASS_4_X_16             = 0x82BC;
-	IMAGE_CLASS_2_X_16             = 0x82BD;
-	IMAGE_CLASS_1_X_16             = 0x82BE;
-	IMAGE_CLASS_4_X_8              = 0x82BF;
-	IMAGE_CLASS_2_X_8              = 0x82C0;
-	IMAGE_CLASS_1_X_8              = 0x82C1;
-	IMAGE_CLASS_11_11_10           = 0x82C2;
-	IMAGE_CLASS_10_10_10_2         = 0x82C3;
-	VIEW_CLASS_128_BITS            = 0x82C4;
-	VIEW_CLASS_96_BITS             = 0x82C5;
-	VIEW_CLASS_64_BITS             = 0x82C6;
-	VIEW_CLASS_48_BITS             = 0x82C7;
-	VIEW_CLASS_32_BITS             = 0x82C8;
-	VIEW_CLASS_24_BITS             = 0x82C9;
-	VIEW_CLASS_16_BITS             = 0x82CA;
-	VIEW_CLASS_8_BITS              = 0x82CB;
-	VIEW_CLASS_S3TC_DXT1_RGB       = 0x82CC;
-	VIEW_CLASS_S3TC_DXT1_RGBA      = 0x82CD;
-	VIEW_CLASS_S3TC_DXT3_RGBA      = 0x82CE;
-	VIEW_CLASS_S3TC_DXT5_RGBA      = 0x82CF;
-	VIEW_CLASS_RGTC1_RED           = 0x82D0;
-	VIEW_CLASS_RGTC2_RG            = 0x82D1;
-	VIEW_CLASS_BPTC_UNORM          = 0x82D2;
-	VIEW_CLASS_BPTC_FLOAT          = 0x82D3;
-	UNIFORM                        = 0x92E1;
-	UNIFORM_BLOCK                  = 0x92E2;
-	PROGRAM_INPUT                  = 0x92E3;
-	PROGRAM_OUTPUT                 = 0x92E4;
-	BUFFER_VARIABLE                = 0x92E5;
-	SHADER_STORAGE_BLOCK           = 0x92E6;
-	VERTEX_SUBROUTINE              = 0x92E8;
-	TESS_CONTROL_SUBROUTINE        = 0x92E9;
-	TESS_EVALUATION_SUBROUTINE     = 0x92EA;
-	GEOMETRY_SUBROUTINE            = 0x92EB;
-	FRAGMENT_SUBROUTINE            = 0x92EC;
-	COMPUTE_SUBROUTINE             = 0x92ED;
-	VERTEX_SUBROUTINE_UNIFORM      = 0x92EE;
-	TESS_CONTROL_SUBROUTINE_UNIFORM = 0x92EF;
-	TESS_EVALUATION_SUBROUTINE_UNIFORM = 0x92F0;
-	GEOMETRY_SUBROUTINE_UNIFORM    = 0x92F1;
-	FRAGMENT_SUBROUTINE_UNIFORM    = 0x92F2;
-	COMPUTE_SUBROUTINE_UNIFORM     = 0x92F3;
-	TRANSFORM_FEEDBACK_VARYING     = 0x92F4;
-	ACTIVE_RESOURCES               = 0x92F5;
-	MAX_NAME_LENGTH                = 0x92F6;
-	MAX_NUM_ACTIVE_VARIABLES       = 0x92F7;
-	MAX_NUM_COMPATIBLE_SUBROUTINES = 0x92F8;
-	NAME_LENGTH                    = 0x92F9;
-	TYPE                           = 0x92FA;
-	ARRAY_SIZE                     = 0x92FB;
-	OFFSET                         = 0x92FC;
-	BLOCK_INDEX                    = 0x92FD;
-	ARRAY_STRIDE                   = 0x92FE;
-	MATRIX_STRIDE                  = 0x92FF;
-	IS_ROW_MAJOR                   = 0x9300;
-	ATOMIC_COUNTER_BUFFER_INDEX    = 0x9301;
-	BUFFER_BINDING                 = 0x9302;
-	BUFFER_DATA_SIZE               = 0x9303;
-	NUM_ACTIVE_VARIABLES           = 0x9304;
-	ACTIVE_VARIABLES               = 0x9305;
-	REFERENCED_BY_VERTEX_SHADER    = 0x9306;
-	REFERENCED_BY_TESS_CONTROL_SHADER = 0x9307;
-	REFERENCED_BY_TESS_EVALUATION_SHADER = 0x9308;
-	REFERENCED_BY_GEOMETRY_SHADER  = 0x9309;
-	REFERENCED_BY_FRAGMENT_SHADER  = 0x930A;
-	REFERENCED_BY_COMPUTE_SHADER   = 0x930B;
-	TOP_LEVEL_ARRAY_SIZE           = 0x930C;
-	TOP_LEVEL_ARRAY_STRIDE         = 0x930D;
-	LOCATION                       = 0x930E;
-	LOCATION_INDEX                 = 0x930F;
-	IS_PER_PATCH                   = 0x92E7;
-	SHADER_STORAGE_BUFFER          = 0x90D2;
-	SHADER_STORAGE_BUFFER_BINDING  = 0x90D3;
-	SHADER_STORAGE_BUFFER_START    = 0x90D4;
-	SHADER_STORAGE_BUFFER_SIZE     = 0x90D5;
-	MAX_VERTEX_SHADER_STORAGE_BLOCKS = 0x90D6;
-	MAX_GEOMETRY_SHADER_STORAGE_BLOCKS = 0x90D7;
-	MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS = 0x90D8;
-	MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS = 0x90D9;
-	MAX_FRAGMENT_SHADER_STORAGE_BLOCKS = 0x90DA;
-	MAX_COMPUTE_SHADER_STORAGE_BLOCKS = 0x90DB;
-	MAX_COMBINED_SHADER_STORAGE_BLOCKS = 0x90DC;
-	MAX_SHADER_STORAGE_BUFFER_BINDINGS = 0x90DD;
-	MAX_SHADER_STORAGE_BLOCK_SIZE  = 0x90DE;
-	SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT = 0x90DF;
-	SHADER_STORAGE_BARRIER_BIT     = 0x00002000;
-	MAX_COMBINED_SHADER_OUTPUT_RESOURCES = 0x8F39;
-	DEPTH_STENCIL_TEXTURE_MODE     = 0x90EA;
-	TEXTURE_BUFFER_OFFSET          = 0x919D;
-	TEXTURE_BUFFER_SIZE            = 0x919E;
-	TEXTURE_BUFFER_OFFSET_ALIGNMENT = 0x919F;
-	TEXTURE_VIEW_MIN_LEVEL         = 0x82DB;
-	TEXTURE_VIEW_NUM_LEVELS        = 0x82DC;
-	TEXTURE_VIEW_MIN_LAYER         = 0x82DD;
-	TEXTURE_VIEW_NUM_LAYERS        = 0x82DE;
-	TEXTURE_IMMUTABLE_LEVELS       = 0x82DF;
-	VERTEX_ATTRIB_BINDING          = 0x82D4;
-	VERTEX_ATTRIB_RELATIVE_OFFSET  = 0x82D5;
-	VERTEX_BINDING_DIVISOR         = 0x82D6;
-	VERTEX_BINDING_OFFSET          = 0x82D7;
-	VERTEX_BINDING_STRIDE          = 0x82D8;
-	MAX_VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D9;
-	MAX_VERTEX_ATTRIB_BINDINGS     = 0x82DA;
-	VERTEX_BINDING_BUFFER          = 0x8F4F;
+NUM_SHADING_LANGUAGE_VERSIONS  :: 0x82E9;
+VERTEX_ATTRIB_ARRAY_LONG       :: 0x874E;
+COMPRESSED_RGB8_ETC2           :: 0x9274;
+COMPRESSED_SRGB8_ETC2          :: 0x9275;
+COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 :: 0x9276;
+COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 :: 0x9277;
+COMPRESSED_RGBA8_ETC2_EAC      :: 0x9278;
+COMPRESSED_SRGB8_ALPHA8_ETC2_EAC :: 0x9279;
+COMPRESSED_R11_EAC             :: 0x9270;
+COMPRESSED_SIGNED_R11_EAC      :: 0x9271;
+COMPRESSED_RG11_EAC            :: 0x9272;
+COMPRESSED_SIGNED_RG11_EAC     :: 0x9273;
+PRIMITIVE_RESTART_FIXED_INDEX  :: 0x8D69;
+ANY_SAMPLES_PASSED_CONSERVATIVE :: 0x8D6A;
+MAX_ELEMENT_INDEX              :: 0x8D6B;
+COMPUTE_SHADER                 :: 0x91B9;
+MAX_COMPUTE_UNIFORM_BLOCKS     :: 0x91BB;
+MAX_COMPUTE_TEXTURE_IMAGE_UNITS :: 0x91BC;
+MAX_COMPUTE_IMAGE_UNIFORMS     :: 0x91BD;
+MAX_COMPUTE_SHARED_MEMORY_SIZE :: 0x8262;
+MAX_COMPUTE_UNIFORM_COMPONENTS :: 0x8263;
+MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS :: 0x8264;
+MAX_COMPUTE_ATOMIC_COUNTERS    :: 0x8265;
+MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS :: 0x8266;
+MAX_COMPUTE_WORK_GROUP_INVOCATIONS :: 0x90EB;
+MAX_COMPUTE_WORK_GROUP_COUNT   :: 0x91BE;
+MAX_COMPUTE_WORK_GROUP_SIZE    :: 0x91BF;
+COMPUTE_WORK_GROUP_SIZE        :: 0x8267;
+UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER :: 0x90EC;
+ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER :: 0x90ED;
+DISPATCH_INDIRECT_BUFFER       :: 0x90EE;
+DISPATCH_INDIRECT_BUFFER_BINDING :: 0x90EF;
+COMPUTE_SHADER_BIT             :: 0x00000020;
+DEBUG_OUTPUT_SYNCHRONOUS       :: 0x8242;
+DEBUG_NEXT_LOGGED_MESSAGE_LENGTH :: 0x8243;
+DEBUG_CALLBACK_FUNCTION        :: 0x8244;
+DEBUG_CALLBACK_USER_PARAM      :: 0x8245;
+DEBUG_SOURCE_API               :: 0x8246;
+DEBUG_SOURCE_WINDOW_SYSTEM     :: 0x8247;
+DEBUG_SOURCE_SHADER_COMPILER   :: 0x8248;
+DEBUG_SOURCE_THIRD_PARTY       :: 0x8249;
+DEBUG_SOURCE_APPLICATION       :: 0x824A;
+DEBUG_SOURCE_OTHER             :: 0x824B;
+DEBUG_TYPE_ERROR               :: 0x824C;
+DEBUG_TYPE_DEPRECATED_BEHAVIOR :: 0x824D;
+DEBUG_TYPE_UNDEFINED_BEHAVIOR  :: 0x824E;
+DEBUG_TYPE_PORTABILITY         :: 0x824F;
+DEBUG_TYPE_PERFORMANCE         :: 0x8250;
+DEBUG_TYPE_OTHER               :: 0x8251;
+MAX_DEBUG_MESSAGE_LENGTH       :: 0x9143;
+MAX_DEBUG_LOGGED_MESSAGES      :: 0x9144;
+DEBUG_LOGGED_MESSAGES          :: 0x9145;
+DEBUG_SEVERITY_HIGH            :: 0x9146;
+DEBUG_SEVERITY_MEDIUM          :: 0x9147;
+DEBUG_SEVERITY_LOW             :: 0x9148;
+DEBUG_TYPE_MARKER              :: 0x8268;
+DEBUG_TYPE_PUSH_GROUP          :: 0x8269;
+DEBUG_TYPE_POP_GROUP           :: 0x826A;
+DEBUG_SEVERITY_NOTIFICATION    :: 0x826B;
+MAX_DEBUG_GROUP_STACK_DEPTH    :: 0x826C;
+DEBUG_GROUP_STACK_DEPTH        :: 0x826D;
+BUFFER                         :: 0x82E0;
+SHADER                         :: 0x82E1;
+PROGRAM                        :: 0x82E2;
+QUERY                          :: 0x82E3;
+PROGRAM_PIPELINE               :: 0x82E4;
+SAMPLER                        :: 0x82E6;
+MAX_LABEL_LENGTH               :: 0x82E8;
+DEBUG_OUTPUT                   :: 0x92E0;
+CONTEXT_FLAG_DEBUG_BIT         :: 0x00000002;
+MAX_UNIFORM_LOCATIONS          :: 0x826E;
+FRAMEBUFFER_DEFAULT_WIDTH      :: 0x9310;
+FRAMEBUFFER_DEFAULT_HEIGHT     :: 0x9311;
+FRAMEBUFFER_DEFAULT_LAYERS     :: 0x9312;
+FRAMEBUFFER_DEFAULT_SAMPLES    :: 0x9313;
+FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS :: 0x9314;
+MAX_FRAMEBUFFER_WIDTH          :: 0x9315;
+MAX_FRAMEBUFFER_HEIGHT         :: 0x9316;
+MAX_FRAMEBUFFER_LAYERS         :: 0x9317;
+MAX_FRAMEBUFFER_SAMPLES        :: 0x9318;
+INTERNALFORMAT_SUPPORTED       :: 0x826F;
+INTERNALFORMAT_PREFERRED       :: 0x8270;
+INTERNALFORMAT_RED_SIZE        :: 0x8271;
+INTERNALFORMAT_GREEN_SIZE      :: 0x8272;
+INTERNALFORMAT_BLUE_SIZE       :: 0x8273;
+INTERNALFORMAT_ALPHA_SIZE      :: 0x8274;
+INTERNALFORMAT_DEPTH_SIZE      :: 0x8275;
+INTERNALFORMAT_STENCIL_SIZE    :: 0x8276;
+INTERNALFORMAT_SHARED_SIZE     :: 0x8277;
+INTERNALFORMAT_RED_TYPE        :: 0x8278;
+INTERNALFORMAT_GREEN_TYPE      :: 0x8279;
+INTERNALFORMAT_BLUE_TYPE       :: 0x827A;
+INTERNALFORMAT_ALPHA_TYPE      :: 0x827B;
+INTERNALFORMAT_DEPTH_TYPE      :: 0x827C;
+INTERNALFORMAT_STENCIL_TYPE    :: 0x827D;
+MAX_WIDTH                      :: 0x827E;
+MAX_HEIGHT                     :: 0x827F;
+MAX_DEPTH                      :: 0x8280;
+MAX_LAYERS                     :: 0x8281;
+MAX_COMBINED_DIMENSIONS        :: 0x8282;
+COLOR_COMPONENTS               :: 0x8283;
+DEPTH_COMPONENTS               :: 0x8284;
+STENCIL_COMPONENTS             :: 0x8285;
+COLOR_RENDERABLE               :: 0x8286;
+DEPTH_RENDERABLE               :: 0x8287;
+STENCIL_RENDERABLE             :: 0x8288;
+FRAMEBUFFER_RENDERABLE         :: 0x8289;
+FRAMEBUFFER_RENDERABLE_LAYERED :: 0x828A;
+FRAMEBUFFER_BLEND              :: 0x828B;
+READ_PIXELS                    :: 0x828C;
+READ_PIXELS_FORMAT             :: 0x828D;
+READ_PIXELS_TYPE               :: 0x828E;
+TEXTURE_IMAGE_FORMAT           :: 0x828F;
+TEXTURE_IMAGE_TYPE             :: 0x8290;
+GET_TEXTURE_IMAGE_FORMAT       :: 0x8291;
+GET_TEXTURE_IMAGE_TYPE         :: 0x8292;
+MIPMAP                         :: 0x8293;
+MANUAL_GENERATE_MIPMAP         :: 0x8294;
+AUTO_GENERATE_MIPMAP           :: 0x8295;
+COLOR_ENCODING                 :: 0x8296;
+SRGB_READ                      :: 0x8297;
+SRGB_WRITE                     :: 0x8298;
+FILTER                         :: 0x829A;
+VERTEX_TEXTURE                 :: 0x829B;
+TESS_CONTROL_TEXTURE           :: 0x829C;
+TESS_EVALUATION_TEXTURE        :: 0x829D;
+GEOMETRY_TEXTURE               :: 0x829E;
+FRAGMENT_TEXTURE               :: 0x829F;
+COMPUTE_TEXTURE                :: 0x82A0;
+TEXTURE_SHADOW                 :: 0x82A1;
+TEXTURE_GATHER                 :: 0x82A2;
+TEXTURE_GATHER_SHADOW          :: 0x82A3;
+SHADER_IMAGE_LOAD              :: 0x82A4;
+SHADER_IMAGE_STORE             :: 0x82A5;
+SHADER_IMAGE_ATOMIC            :: 0x82A6;
+IMAGE_TEXEL_SIZE               :: 0x82A7;
+IMAGE_COMPATIBILITY_CLASS      :: 0x82A8;
+IMAGE_PIXEL_FORMAT             :: 0x82A9;
+IMAGE_PIXEL_TYPE               :: 0x82AA;
+SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST :: 0x82AC;
+SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST :: 0x82AD;
+SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE :: 0x82AE;
+SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE :: 0x82AF;
+TEXTURE_COMPRESSED_BLOCK_WIDTH :: 0x82B1;
+TEXTURE_COMPRESSED_BLOCK_HEIGHT :: 0x82B2;
+TEXTURE_COMPRESSED_BLOCK_SIZE  :: 0x82B3;
+CLEAR_BUFFER                   :: 0x82B4;
+TEXTURE_VIEW                   :: 0x82B5;
+VIEW_COMPATIBILITY_CLASS       :: 0x82B6;
+FULL_SUPPORT                   :: 0x82B7;
+CAVEAT_SUPPORT                 :: 0x82B8;
+IMAGE_CLASS_4_X_32             :: 0x82B9;
+IMAGE_CLASS_2_X_32             :: 0x82BA;
+IMAGE_CLASS_1_X_32             :: 0x82BB;
+IMAGE_CLASS_4_X_16             :: 0x82BC;
+IMAGE_CLASS_2_X_16             :: 0x82BD;
+IMAGE_CLASS_1_X_16             :: 0x82BE;
+IMAGE_CLASS_4_X_8              :: 0x82BF;
+IMAGE_CLASS_2_X_8              :: 0x82C0;
+IMAGE_CLASS_1_X_8              :: 0x82C1;
+IMAGE_CLASS_11_11_10           :: 0x82C2;
+IMAGE_CLASS_10_10_10_2         :: 0x82C3;
+VIEW_CLASS_128_BITS            :: 0x82C4;
+VIEW_CLASS_96_BITS             :: 0x82C5;
+VIEW_CLASS_64_BITS             :: 0x82C6;
+VIEW_CLASS_48_BITS             :: 0x82C7;
+VIEW_CLASS_32_BITS             :: 0x82C8;
+VIEW_CLASS_24_BITS             :: 0x82C9;
+VIEW_CLASS_16_BITS             :: 0x82CA;
+VIEW_CLASS_8_BITS              :: 0x82CB;
+VIEW_CLASS_S3TC_DXT1_RGB       :: 0x82CC;
+VIEW_CLASS_S3TC_DXT1_RGBA      :: 0x82CD;
+VIEW_CLASS_S3TC_DXT3_RGBA      :: 0x82CE;
+VIEW_CLASS_S3TC_DXT5_RGBA      :: 0x82CF;
+VIEW_CLASS_RGTC1_RED           :: 0x82D0;
+VIEW_CLASS_RGTC2_RG            :: 0x82D1;
+VIEW_CLASS_BPTC_UNORM          :: 0x82D2;
+VIEW_CLASS_BPTC_FLOAT          :: 0x82D3;
+UNIFORM                        :: 0x92E1;
+UNIFORM_BLOCK                  :: 0x92E2;
+PROGRAM_INPUT                  :: 0x92E3;
+PROGRAM_OUTPUT                 :: 0x92E4;
+BUFFER_VARIABLE                :: 0x92E5;
+SHADER_STORAGE_BLOCK           :: 0x92E6;
+VERTEX_SUBROUTINE              :: 0x92E8;
+TESS_CONTROL_SUBROUTINE        :: 0x92E9;
+TESS_EVALUATION_SUBROUTINE     :: 0x92EA;
+GEOMETRY_SUBROUTINE            :: 0x92EB;
+FRAGMENT_SUBROUTINE            :: 0x92EC;
+COMPUTE_SUBROUTINE             :: 0x92ED;
+VERTEX_SUBROUTINE_UNIFORM      :: 0x92EE;
+TESS_CONTROL_SUBROUTINE_UNIFORM :: 0x92EF;
+TESS_EVALUATION_SUBROUTINE_UNIFORM :: 0x92F0;
+GEOMETRY_SUBROUTINE_UNIFORM    :: 0x92F1;
+FRAGMENT_SUBROUTINE_UNIFORM    :: 0x92F2;
+COMPUTE_SUBROUTINE_UNIFORM     :: 0x92F3;
+TRANSFORM_FEEDBACK_VARYING     :: 0x92F4;
+ACTIVE_RESOURCES               :: 0x92F5;
+MAX_NAME_LENGTH                :: 0x92F6;
+MAX_NUM_ACTIVE_VARIABLES       :: 0x92F7;
+MAX_NUM_COMPATIBLE_SUBROUTINES :: 0x92F8;
+NAME_LENGTH                    :: 0x92F9;
+TYPE                           :: 0x92FA;
+ARRAY_SIZE                     :: 0x92FB;
+OFFSET                         :: 0x92FC;
+BLOCK_INDEX                    :: 0x92FD;
+ARRAY_STRIDE                   :: 0x92FE;
+MATRIX_STRIDE                  :: 0x92FF;
+IS_ROW_MAJOR                   :: 0x9300;
+ATOMIC_COUNTER_BUFFER_INDEX    :: 0x9301;
+BUFFER_BINDING                 :: 0x9302;
+BUFFER_DATA_SIZE               :: 0x9303;
+NUM_ACTIVE_VARIABLES           :: 0x9304;
+ACTIVE_VARIABLES               :: 0x9305;
+REFERENCED_BY_VERTEX_SHADER    :: 0x9306;
+REFERENCED_BY_TESS_CONTROL_SHADER :: 0x9307;
+REFERENCED_BY_TESS_EVALUATION_SHADER :: 0x9308;
+REFERENCED_BY_GEOMETRY_SHADER  :: 0x9309;
+REFERENCED_BY_FRAGMENT_SHADER  :: 0x930A;
+REFERENCED_BY_COMPUTE_SHADER   :: 0x930B;
+TOP_LEVEL_ARRAY_SIZE           :: 0x930C;
+TOP_LEVEL_ARRAY_STRIDE         :: 0x930D;
+LOCATION                       :: 0x930E;
+LOCATION_INDEX                 :: 0x930F;
+IS_PER_PATCH                   :: 0x92E7;
+SHADER_STORAGE_BUFFER          :: 0x90D2;
+SHADER_STORAGE_BUFFER_BINDING  :: 0x90D3;
+SHADER_STORAGE_BUFFER_START    :: 0x90D4;
+SHADER_STORAGE_BUFFER_SIZE     :: 0x90D5;
+MAX_VERTEX_SHADER_STORAGE_BLOCKS :: 0x90D6;
+MAX_GEOMETRY_SHADER_STORAGE_BLOCKS :: 0x90D7;
+MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS :: 0x90D8;
+MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS :: 0x90D9;
+MAX_FRAGMENT_SHADER_STORAGE_BLOCKS :: 0x90DA;
+MAX_COMPUTE_SHADER_STORAGE_BLOCKS :: 0x90DB;
+MAX_COMBINED_SHADER_STORAGE_BLOCKS :: 0x90DC;
+MAX_SHADER_STORAGE_BUFFER_BINDINGS :: 0x90DD;
+MAX_SHADER_STORAGE_BLOCK_SIZE  :: 0x90DE;
+SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT :: 0x90DF;
+SHADER_STORAGE_BARRIER_BIT     :: 0x00002000;
+MAX_COMBINED_SHADER_OUTPUT_RESOURCES :: 0x8F39;
+DEPTH_STENCIL_TEXTURE_MODE     :: 0x90EA;
+TEXTURE_BUFFER_OFFSET          :: 0x919D;
+TEXTURE_BUFFER_SIZE            :: 0x919E;
+TEXTURE_BUFFER_OFFSET_ALIGNMENT :: 0x919F;
+TEXTURE_VIEW_MIN_LEVEL         :: 0x82DB;
+TEXTURE_VIEW_NUM_LEVELS        :: 0x82DC;
+TEXTURE_VIEW_MIN_LAYER         :: 0x82DD;
+TEXTURE_VIEW_NUM_LAYERS        :: 0x82DE;
+TEXTURE_IMMUTABLE_LEVELS       :: 0x82DF;
+VERTEX_ATTRIB_BINDING          :: 0x82D4;
+VERTEX_ATTRIB_RELATIVE_OFFSET  :: 0x82D5;
+VERTEX_BINDING_DIVISOR         :: 0x82D6;
+VERTEX_BINDING_OFFSET          :: 0x82D7;
+VERTEX_BINDING_STRIDE          :: 0x82D8;
+MAX_VERTEX_ATTRIB_RELATIVE_OFFSET :: 0x82D9;
+MAX_VERTEX_ATTRIB_BINDINGS     :: 0x82DA;
+VERTEX_BINDING_BUFFER          :: 0x8F4F;
 
-	MAX_VERTEX_ATTRIB_STRIDE       = 0x82E5;
-	PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED = 0x8221;
-	TEXTURE_BUFFER_BINDING         = 0x8C2A;
-	MAP_PERSISTENT_BIT             = 0x0040;
-	MAP_COHERENT_BIT               = 0x0080;
-	DYNAMIC_STORAGE_BIT            = 0x0100;
-	CLIENT_STORAGE_BIT             = 0x0200;
-	CLIENT_MAPPED_BUFFER_BARRIER_BIT = 0x00004000;
-	BUFFER_IMMUTABLE_STORAGE       = 0x821F;
-	BUFFER_STORAGE_FLAGS           = 0x8220;
-	CLEAR_TEXTURE                  = 0x9365;
-	LOCATION_COMPONENT             = 0x934A;
-	TRANSFORM_FEEDBACK_BUFFER_INDEX = 0x934B;
-	TRANSFORM_FEEDBACK_BUFFER_STRIDE = 0x934C;
-	QUERY_BUFFER                   = 0x9192;
-	QUERY_BUFFER_BARRIER_BIT       = 0x00008000;
-	QUERY_BUFFER_BINDING           = 0x9193;
-	QUERY_RESULT_NO_WAIT           = 0x9194;
-	MIRROR_CLAMP_TO_EDGE           = 0x8743;
+MAX_VERTEX_ATTRIB_STRIDE       :: 0x82E5;
+PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED :: 0x8221;
+TEXTURE_BUFFER_BINDING         :: 0x8C2A;
+MAP_PERSISTENT_BIT             :: 0x0040;
+MAP_COHERENT_BIT               :: 0x0080;
+DYNAMIC_STORAGE_BIT            :: 0x0100;
+CLIENT_STORAGE_BIT             :: 0x0200;
+CLIENT_MAPPED_BUFFER_BARRIER_BIT :: 0x00004000;
+BUFFER_IMMUTABLE_STORAGE       :: 0x821F;
+BUFFER_STORAGE_FLAGS           :: 0x8220;
+CLEAR_TEXTURE                  :: 0x9365;
+LOCATION_COMPONENT             :: 0x934A;
+TRANSFORM_FEEDBACK_BUFFER_INDEX :: 0x934B;
+TRANSFORM_FEEDBACK_BUFFER_STRIDE :: 0x934C;
+QUERY_BUFFER                   :: 0x9192;
+QUERY_BUFFER_BARRIER_BIT       :: 0x00008000;
+QUERY_BUFFER_BINDING           :: 0x9193;
+QUERY_RESULT_NO_WAIT           :: 0x9194;
+MIRROR_CLAMP_TO_EDGE           :: 0x8743;
 
-	CONTEXT_LOST                   = 0x0507;
-	NEGATIVE_ONE_TO_ONE            = 0x935E;
-	ZERO_TO_ONE                    = 0x935F;
-	CLIP_ORIGIN                    = 0x935C;
-	CLIP_DEPTH_MODE                = 0x935D;
-	QUERY_WAIT_INVERTED            = 0x8E17;
-	QUERY_NO_WAIT_INVERTED         = 0x8E18;
-	QUERY_BY_REGION_WAIT_INVERTED  = 0x8E19;
-	QUERY_BY_REGION_NO_WAIT_INVERTED = 0x8E1A;
-	MAX_CULL_DISTANCES             = 0x82F9;
-	MAX_COMBINED_CLIP_AND_CULL_DISTANCES = 0x82FA;
-	TEXTURE_TARGET                 = 0x1006;
-	QUERY_TARGET                   = 0x82EA;
-	GUILTY_CONTEXT_RESET           = 0x8253;
-	INNOCENT_CONTEXT_RESET         = 0x8254;
-	UNKNOWN_CONTEXT_RESET          = 0x8255;
-	RESET_NOTIFICATION_STRATEGY    = 0x8256;
-	LOSE_CONTEXT_ON_RESET          = 0x8252;
-	NO_RESET_NOTIFICATION          = 0x8261;
-	CONTEXT_FLAG_ROBUST_ACCESS_BIT = 0x00000004;
-	CONTEXT_RELEASE_BEHAVIOR       = 0x82FB;
-	CONTEXT_RELEASE_BEHAVIOR_FLUSH = 0x82FC;
+CONTEXT_LOST                   :: 0x0507;
+NEGATIVE_ONE_TO_ONE            :: 0x935E;
+ZERO_TO_ONE                    :: 0x935F;
+CLIP_ORIGIN                    :: 0x935C;
+CLIP_DEPTH_MODE                :: 0x935D;
+QUERY_WAIT_INVERTED            :: 0x8E17;
+QUERY_NO_WAIT_INVERTED         :: 0x8E18;
+QUERY_BY_REGION_WAIT_INVERTED  :: 0x8E19;
+QUERY_BY_REGION_NO_WAIT_INVERTED :: 0x8E1A;
+MAX_CULL_DISTANCES             :: 0x82F9;
+MAX_COMBINED_CLIP_AND_CULL_DISTANCES :: 0x82FA;
+TEXTURE_TARGET                 :: 0x1006;
+QUERY_TARGET                   :: 0x82EA;
+GUILTY_CONTEXT_RESET           :: 0x8253;
+INNOCENT_CONTEXT_RESET         :: 0x8254;
+UNKNOWN_CONTEXT_RESET          :: 0x8255;
+RESET_NOTIFICATION_STRATEGY    :: 0x8256;
+LOSE_CONTEXT_ON_RESET          :: 0x8252;
+NO_RESET_NOTIFICATION          :: 0x8261;
+CONTEXT_FLAG_ROBUST_ACCESS_BIT :: 0x00000004;
+CONTEXT_RELEASE_BEHAVIOR       :: 0x82FB;
+CONTEXT_RELEASE_BEHAVIOR_FLUSH :: 0x82FC;
 
-	DEBUG_OUTPUT_SYNCHRONOUS_ARB   = 0x8242;
-	DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB = 0x8243;
-	DEBUG_CALLBACK_FUNCTION_ARB    = 0x8244;
-	DEBUG_CALLBACK_USER_PARAM_ARB  = 0x8245;
-	DEBUG_SOURCE_API_ARB           = 0x8246;
-	DEBUG_SOURCE_WINDOW_SYSTEM_ARB = 0x8247;
-	DEBUG_SOURCE_SHADER_COMPILER_ARB = 0x8248;
-	DEBUG_SOURCE_THIRD_PARTY_ARB   = 0x8249;
-	DEBUG_SOURCE_APPLICATION_ARB   = 0x824A;
-	DEBUG_SOURCE_OTHER_ARB         = 0x824B;
-	DEBUG_TYPE_ERROR_ARB           = 0x824C;
-	DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB = 0x824D;
-	DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB = 0x824E;
-	DEBUG_TYPE_PORTABILITY_ARB     = 0x824F;
-	DEBUG_TYPE_PERFORMANCE_ARB     = 0x8250;
-	DEBUG_TYPE_OTHER_ARB           = 0x8251;
-	MAX_DEBUG_MESSAGE_LENGTH_ARB   = 0x9143;
-	MAX_DEBUG_LOGGED_MESSAGES_ARB  = 0x9144;
-	DEBUG_LOGGED_MESSAGES_ARB      = 0x9145;
-	DEBUG_SEVERITY_HIGH_ARB        = 0x9146;
-	DEBUG_SEVERITY_MEDIUM_ARB      = 0x9147;
-	DEBUG_SEVERITY_LOW_ARB         = 0x9148;
-)
+DEBUG_OUTPUT_SYNCHRONOUS_ARB   :: 0x8242;
+DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB :: 0x8243;
+DEBUG_CALLBACK_FUNCTION_ARB    :: 0x8244;
+DEBUG_CALLBACK_USER_PARAM_ARB  :: 0x8245;
+DEBUG_SOURCE_API_ARB           :: 0x8246;
+DEBUG_SOURCE_WINDOW_SYSTEM_ARB :: 0x8247;
+DEBUG_SOURCE_SHADER_COMPILER_ARB :: 0x8248;
+DEBUG_SOURCE_THIRD_PARTY_ARB   :: 0x8249;
+DEBUG_SOURCE_APPLICATION_ARB   :: 0x824A;
+DEBUG_SOURCE_OTHER_ARB         :: 0x824B;
+DEBUG_TYPE_ERROR_ARB           :: 0x824C;
+DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB :: 0x824D;
+DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB :: 0x824E;
+DEBUG_TYPE_PORTABILITY_ARB     :: 0x824F;
+DEBUG_TYPE_PERFORMANCE_ARB     :: 0x8250;
+DEBUG_TYPE_OTHER_ARB           :: 0x8251;
+MAX_DEBUG_MESSAGE_LENGTH_ARB   :: 0x9143;
+MAX_DEBUG_LOGGED_MESSAGES_ARB  :: 0x9144;
+DEBUG_LOGGED_MESSAGES_ARB      :: 0x9145;
+DEBUG_SEVERITY_HIGH_ARB        :: 0x9146;
+DEBUG_SEVERITY_MEDIUM_ARB      :: 0x9147;
+DEBUG_SEVERITY_LOW_ARB         :: 0x9148;

core/os.odin

@@ -9,13 +9,13 @@ proc write_string(fd: Handle, str: string) -> (int, Errno) {
 }
 
 proc read_entire_file(name: string) -> ([]u8, bool) {
-	var fd, err = open(name, O_RDONLY, 0);
+	fd, err := open(name, O_RDONLY, 0);
 	if err != 0 {
 		return nil, false;
 	}
 	defer close(fd);
 
-	var length: i64;
+	length: i64;
 	if length, err = file_size(fd); err != 0 {
 		return nil, false;
 	}
@@ -24,12 +24,12 @@ proc read_entire_file(name: string) -> ([]u8, bool) {
 		return nil, true;
 	}
 
-	var data = make([]u8, length);
+	data := make([]u8, length);
 	if data == nil {
 		return nil, false;
 	}
 
-	var bytes_read, read_err = read(fd, data);
+	bytes_read, read_err := read(fd, data);
 	if read_err != 0 {
 		free(data);
 		return nil, false;
@@ -38,12 +38,12 @@ proc read_entire_file(name: string) -> ([]u8, bool) {
 }
 
 proc write_entire_file(name: string, data: []u8) -> bool {
-	var fd, err = open(name, O_WRONLY, 0);
+	fd, err := open(name, O_WRONLY, 0);
 	if err != 0 {
 		return false;
 	}
 	defer close(fd);
 
-	var bytes_written, write_err = write(fd, data);
+	bytes_written, write_err := write(fd, data);
 	return write_err != 0;
 }

core/os_linux.odin

@@ -10,40 +10,37 @@ type (
 	Errno    i32;
 )
 
-const (
-	O_RDONLY   = 0x00000;
-	O_WRONLY   = 0x00001;
-	O_RDWR     = 0x00002;
-	O_CREAT    = 0x00040;
-	O_EXCL     = 0x00080;
-	O_NOCTTY   = 0x00100;
-	O_TRUNC    = 0x00200;
-	O_NONBLOCK = 0x00800;
-	O_APPEND   = 0x00400;
-	O_SYNC     = 0x01000;
-	O_ASYNC    = 0x02000;
-	O_CLOEXEC  = 0x80000;
-)
 
-const (
-	SEEK_SET   = 0;
-	SEEK_CUR   = 1;
-	SEEK_END   = 2;
-	SEEK_DATA  = 3;
-	SEEK_HOLE  = 4;
-	SEEK_MAX   = SEEK_HOLE;
-)
-const (
-	// NOTE(zangent): These are OS specific!
-	// Do not mix these up!
-	RTLD_LAZY         = 0x001;
-	RTLD_NOW          = 0x002;
-	RTLD_BINDING_MASK = 0x3;
-	RTLD_GLOBAL       = 0x100;
-)
+O_RDONLY   :: 0x00000;
+O_WRONLY   :: 0x00001;
+O_RDWR     :: 0x00002;
+O_CREAT    :: 0x00040;
+O_EXCL     :: 0x00080;
+O_NOCTTY   :: 0x00100;
+O_TRUNC    :: 0x00200;
+O_NONBLOCK :: 0x00800;
+O_APPEND   :: 0x00400;
+O_SYNC     :: 0x01000;
+O_ASYNC    :: 0x02000;
+O_CLOEXEC  :: 0x80000;
+
+
+SEEK_SET   :: 0;
+SEEK_CUR   :: 1;
+SEEK_END   :: 2;
+SEEK_DATA  :: 3;
+SEEK_HOLE  :: 4;
+SEEK_MAX   :: SEEK_HOLE;
+
+// NOTE(zangent): These are OS specific!
+// Do not mix these up!
+RTLD_LAZY         :: 0x001;
+RTLD_NOW          :: 0x002;
+RTLD_BINDING_MASK :: 0x3;
+RTLD_GLOBAL       :: 0x100;
 
 // "Argv" arguments converted to Odin strings
-var args = _alloc_command_line_arguments();
+args := _alloc_command_line_arguments();
 
 type _FileTime struct #ordered {
 	seconds:     i64,
@@ -80,39 +77,38 @@ type Stat struct #ordered {
 };
 
 // File type
-const (
-	S_IFMT   = 0170000; // Type of file mask
-	S_IFIFO  = 0010000; // Named pipe (fifo)
-	S_IFCHR  = 0020000; // Character special
-	S_IFDIR  = 0040000; // Directory
-	S_IFBLK  = 0060000; // Block special
-	S_IFREG  = 0100000; // Regular
-	S_IFLNK  = 0120000; // Symbolic link
-	S_IFSOCK = 0140000; // Socket
-
-	// File mode
-	// Read, write, execute/search by owner
-	S_IRWXU = 0000700; // RWX mask for owner
-	S_IRUSR = 0000400; // R for owner
-	S_IWUSR = 0000200; // W for owner
-	S_IXUSR = 0000100; // X for owner
+S_IFMT   :: 0170000; // Type of file mask
+S_IFIFO  :: 0010000; // Named pipe (fifo)
+S_IFCHR  :: 0020000; // Character special
+S_IFDIR  :: 0040000; // Directory
+S_IFBLK  :: 0060000; // Block special
+S_IFREG  :: 0100000; // Regular
+S_IFLNK  :: 0120000; // Symbolic link
+S_IFSOCK :: 0140000; // Socket
+
+// File mode
+// Read, write, execute/search by owner
+S_IRWXU :: 0000700; // RWX mask for owner
+S_IRUSR :: 0000400; // R for owner
+S_IWUSR :: 0000200; // W for owner
+S_IXUSR :: 0000100; // X for owner
 
 	// Read, write, execute/search by group
-	S_IRWXG = 0000070; // RWX mask for group
-	S_IRGRP = 0000040; // R for group
-	S_IWGRP = 0000020; // W for group
-	S_IXGRP = 0000010; // X for group
+S_IRWXG :: 0000070; // RWX mask for group
+S_IRGRP :: 0000040; // R for group
+S_IWGRP :: 0000020; // W for group
+S_IXGRP :: 0000010; // X for group
 
 	// Read, write, execute/search by others
-	S_IRWXO = 0000007; // RWX mask for other
-	S_IROTH = 0000004; // R for other
-	S_IWOTH = 0000002; // W for other
-	S_IXOTH = 0000001; // X for other
-
-	S_ISUID = 0004000; // Set user id on execution
-	S_ISGID = 0002000; // Set group id on execution
-	S_ISVTX = 0001000; // Directory restrcted delete
-)
+S_IRWXO :: 0000007; // RWX mask for other
+S_IROTH :: 0000004; // R for other
+S_IWOTH :: 0000002; // W for other
+S_IXOTH :: 0000001; // X for other
+
+S_ISUID :: 0004000; // Set user id on execution
+S_ISGID :: 0002000; // Set group id on execution
+S_ISVTX :: 0001000; // Directory restrcted delete
+
 
 proc S_ISLNK (m: u32) -> bool #inline  {return (m & S_IFMT) == S_IFLNK; }
 proc S_ISREG (m: u32) -> bool #inline  {return (m & S_IFMT) == S_IFREG; }
@@ -122,12 +118,10 @@ proc S_ISBLK (m: u32) -> bool #inline  {return (m & S_IFMT) == S_IFBLK; }
 proc S_ISFIFO(m: u32) -> bool #inline  {return (m & S_IFMT) == S_IFIFO; }
 proc S_ISSOCK(m: u32) -> bool #inline  {return (m & S_IFMT) == S_IFSOCK;}
 
-const (
-	R_OK = 4; // Test for read permission
-	W_OK = 2; // Test for write permission
-	X_OK = 1; // Test for execute permission
-	F_OK = 0; // Test for file existance
-)
+F_OK :: 0; // Test for file existance
+X_OK :: 1; // Test for execute permission
+W_OK :: 2; // Test for write permission
+R_OK :: 4; // Test for read permission
 
 foreign libc {
 	proc _unix_open  (path: ^u8, mode: int) -> Handle                  #link_name "open";
@@ -156,8 +150,8 @@ foreign dl {
 // TODO(zangent): Change this to just `open` when Bill fixes overloading.
 proc open_simple(path: string, mode: int) -> (Handle, Errno) {
 
-	var cstr = strings.new_c_string(path);
-	var handle = _unix_open(cstr, mode);
+	cstr := strings.new_c_string(path);
+	handle := _unix_open(cstr, mode);
 	free(cstr);
 	if(handle == -1) {
 		return 0, 1;
@@ -174,49 +168,49 @@ proc close(fd: Handle) {
 }
 
 proc read(fd: Handle, data: []u8) -> (int, Errno) {
-	var sz = _unix_read(fd, &data[0], len(data));
+	sz := _unix_read(fd, &data[0], len(data));
 	return sz, 0;
 }
 
 proc write(fd: Handle, data: []u8) -> (int, Errno) {
-	var sz = _unix_write(fd, &data[0], len(data));
+	sz := _unix_write(fd, &data[0], len(data));
 	return sz, 0;
 }
 
 proc seek(fd: Handle, offset: i64, whence: int) -> (i64, Errno) {
-	var res = _unix_seek(fd, offset, i32(whence));
+	res := _unix_seek(fd, offset, i32(whence));
 	return res, 0;
 }
 
 proc file_size(fd: Handle) -> (i64, Errno) {
-	var prev, _ = seek(fd, 0, SEEK_CUR);
-	var size, err = seek(fd, 0, SEEK_END);
+	prev, _   := seek(fd, 0, SEEK_CUR);
+	size, err := seek(fd, 0, SEEK_END);
 	seek(fd, prev, SEEK_SET);
 	return size, err;
 }
 
 
 // NOTE(bill): Uses startup to initialize it
-var (
-	stdin:  Handle = 0;
-	stdout: Handle = 1;
-	stderr: Handle = 2;
-)
+
+stdin:  Handle = 0;
+stdout: Handle = 1;
+stderr: Handle = 2;
+
 /* TODO(zangent): Implement these!
 proc last_write_time(fd: Handle) -> FileTime {}
 proc last_write_time_by_name(name: string) -> FileTime {}
 */
 
 proc stat(path: string) -> (Stat, int) #inline {
-	var s: Stat;
-	var cstr = strings.new_c_string(path);
+	s: Stat;
+	cstr := strings.new_c_string(path);
 	defer free(cstr);
-	var ret_int = _unix_stat(cstr, &s);
+	ret_int := _unix_stat(cstr, &s);
 	return s, int(ret_int);
 }
 
 proc access(path: string, mask: int) -> bool #inline {
-	var cstr = strings.new_c_string(path);
+	cstr := strings.new_c_string(path);
 	defer free(cstr);
 	return _unix_access(cstr, mask) == 0;
 }
@@ -235,8 +229,8 @@ proc heap_free(ptr: rawptr) {
 }
 
 proc getenv(name: string) -> (string, bool) {
-	var path_str = strings.new_c_string(name);
-	var cstr: ^u8 = _unix_getenv(path_str);
+	path_str := strings.new_c_string(name);
+	cstr: ^u8 = _unix_getenv(path_str);
 	free(path_str);
 	if(cstr == nil) {
 		return "", false;
@@ -254,15 +248,15 @@ proc current_thread_id() -> int {
 }
 
 proc dlopen(filename: string, flags: int) -> rawptr #inline {
-	var cstr = strings.new_c_string(filename);
-	var handle = _unix_dlopen(cstr, flags);
+	cstr := strings.new_c_string(filename);
+	handle := _unix_dlopen(cstr, flags);
 	free(cstr);
 	return handle;
 }
 proc dlsym(handle: rawptr, symbol: string) -> (proc() #cc_c) #inline {
 	assert(handle != nil);
-	var cstr = strings.new_c_string(symbol);
-	var proc_handle = _unix_dlsym(handle, cstr);
+	cstr := strings.new_c_string(symbol);
+	proc_handle := _unix_dlsym(handle, cstr);
 	free(cstr);
 	return proc_handle;
 }

core/os_windows.odin

@@ -5,56 +5,55 @@ type (
 	FileTime u64;
 )
 
-const INVALID_HANDLE: Handle = -1;
-
-
-const (
-	O_RDONLY   = 0x00000;
-	O_WRONLY   = 0x00001;
-	O_RDWR     = 0x00002;
-	O_CREAT    = 0x00040;
-	O_EXCL     = 0x00080;
-	O_NOCTTY   = 0x00100;
-	O_TRUNC    = 0x00200;
-	O_NONBLOCK = 0x00800;
-	O_APPEND   = 0x00400;
-	O_SYNC     = 0x01000;
-	O_ASYNC    = 0x02000;
-	O_CLOEXEC  = 0x80000;
-)
+INVALID_HANDLE: Handle : -1;
+
+
+
+O_RDONLY   :: 0x00000;
+O_WRONLY   :: 0x00001;
+O_RDWR     :: 0x00002;
+O_CREAT    :: 0x00040;
+O_EXCL     :: 0x00080;
+O_NOCTTY   :: 0x00100;
+O_TRUNC    :: 0x00200;
+O_NONBLOCK :: 0x00800;
+O_APPEND   :: 0x00400;
+O_SYNC     :: 0x01000;
+O_ASYNC    :: 0x02000;
+O_CLOEXEC  :: 0x80000;
 
 type Errno int;
-const (
-	ERROR_NONE:               Errno = 0;
-	ERROR_FILE_NOT_FOUND            = 2;
-	ERROR_PATH_NOT_FOUND            = 3;
-	ERROR_ACCESS_DENIED             = 5;
-	ERROR_NO_MORE_FILES             = 18;
-	ERROR_HANDLE_EOF                = 38;
-	ERROR_NETNAME_DELETED           = 64;
-	ERROR_FILE_EXISTS               = 80;
-	ERROR_BROKEN_PIPE               = 109;
-	ERROR_BUFFER_OVERFLOW           = 111;
-	ERROR_INSUFFICIENT_BUFFER       = 122;
-	ERROR_MOD_NOT_FOUND             = 126;
-	ERROR_PROC_NOT_FOUND            = 127;
-	ERROR_DIR_NOT_EMPTY             = 145;
-	ERROR_ALREADY_EXISTS            = 183;
-	ERROR_ENVVAR_NOT_FOUND          = 203;
-	ERROR_MORE_DATA                 = 234;
-	ERROR_OPERATION_ABORTED         = 995;
-	ERROR_IO_PENDING                = 997;
-	ERROR_NOT_FOUND                 = 1168;
-	ERROR_PRIVILEGE_NOT_HELD        = 1314;
-	WSAEACCES                       = 10013;
-	WSAECONNRESET                   = 10054;
-
-	// Windows reserves errors >= 1<<29 for application use
-	ERROR_FILE_IS_PIPE              = 1<<29 + 0;
-)
+
+ERROR_NONE:                   Errno : 0;
+ERROR_FILE_NOT_FOUND:         Errno : 2;
+ERROR_PATH_NOT_FOUND:         Errno : 3;
+ERROR_ACCESS_DENIED:          Errno : 5;
+ERROR_NO_MORE_FILES:          Errno : 18;
+ERROR_HANDLE_EOF:             Errno : 38;
+ERROR_NETNAME_DELETED:        Errno : 64;
+ERROR_FILE_EXISTS:            Errno : 80;
+ERROR_BROKEN_PIPE:            Errno : 109;
+ERROR_BUFFER_OVERFLOW:        Errno : 111;
+ERROR_INSUFFICIENT_BUFFER:    Errno : 122;
+ERROR_MOD_NOT_FOUND:          Errno : 126;
+ERROR_PROC_NOT_FOUND:         Errno : 127;
+ERROR_DIR_NOT_EMPTY:          Errno : 145;
+ERROR_ALREADY_EXISTS:         Errno : 183;
+ERROR_ENVVAR_NOT_FOUND:       Errno : 203;
+ERROR_MORE_DATA:              Errno : 234;
+ERROR_OPERATION_ABORTED:      Errno : 995;
+ERROR_IO_PENDING:             Errno : 997;
+ERROR_NOT_FOUND:              Errno : 1168;
+ERROR_PRIVILEGE_NOT_HELD:     Errno : 1314;
+WSAEACCES:                    Errno : 10013;
+WSAECONNRESET:                Errno : 10054;
+
+// Windows reserves errors >= 1<<29 for application use
+ERROR_FILE_IS_PIPE:           Errno : 1<<29 + 0;
+
 
 // "Argv" arguments converted to Odin strings
-var args = _alloc_command_line_arguments();
+args := _alloc_command_line_arguments();
 
 
 proc open(path: string, mode: int = O_RDONLY, perm: u32 = 0) -> (Handle, Errno) {
@@ -62,7 +61,7 @@ proc open(path: string, mode: int = O_RDONLY, perm: u32 = 0) -> (Handle, Errno)
 		return INVALID_HANDLE, ERROR_FILE_NOT_FOUND;
 	}
 
-	var access: u32;
+	access: u32;
 	match mode & (O_RDONLY|O_WRONLY|O_RDWR) {
 	case O_RDONLY: access = win32.FILE_GENERIC_READ;
 	case O_WRONLY: access = win32.FILE_GENERIC_WRITE;
@@ -77,14 +76,14 @@ proc open(path: string, mode: int = O_RDONLY, perm: u32 = 0) -> (Handle, Errno)
 		access |=  win32.FILE_APPEND_DATA;
 	}
 
-	var share_mode = u32(win32.FILE_SHARE_READ|win32.FILE_SHARE_WRITE);
-	var sa: ^win32.Security_Attributes = nil;
-	var sa_inherit = win32.Security_Attributes{length = size_of(win32.Security_Attributes), inherit_handle = 1};
+	share_mode := u32(win32.FILE_SHARE_READ|win32.FILE_SHARE_WRITE);
+	sa: ^win32.Security_Attributes = nil;
+	sa_inherit := win32.Security_Attributes{length = size_of(win32.Security_Attributes), inherit_handle = 1};
 	if mode&O_CLOEXEC == 0 {
 		sa = &sa_inherit;
 	}
 
-	var create_mode: u32;
+	create_mode: u32;
 	match {
 	case mode&(O_CREAT|O_EXCL) == (O_CREAT | O_EXCL):
 		create_mode = win32.CREATE_NEW;
@@ -98,14 +97,14 @@ proc open(path: string, mode: int = O_RDONLY, perm: u32 = 0) -> (Handle, Errno)
 		create_mode = win32.OPEN_EXISTING;
 	}
 
-	var buf: [300]u8;
+	buf: [300]u8;
 	copy(buf[..], []u8(path));
 
-	var handle = Handle(win32.create_file_a(&buf[0], access, share_mode, sa, create_mode, win32.FILE_ATTRIBUTE_NORMAL, nil));
+	handle := Handle(win32.create_file_a(&buf[0], access, share_mode, sa, create_mode, win32.FILE_ATTRIBUTE_NORMAL, nil));
 	if handle != INVALID_HANDLE {
 		return handle, ERROR_NONE;
 	}
-	var err = win32.get_last_error();
+	err := win32.get_last_error();
 	return INVALID_HANDLE, Errno(err);
 }
 
@@ -118,22 +117,22 @@ proc write(fd: Handle, data: []u8) -> (int, Errno) {
 	if len(data) == 0 {
 		return 0, ERROR_NONE;
 	}
-	var single_write_length: i32;
-	var total_write: i64;
-	var length = i64(len(data));
+	single_write_length: i32;
+	total_write: i64;
+	length := i64(len(data));
 
 	for total_write < length {
-		var remaining = length - total_write;
-		var to_read: i32;
-		const MAX = 1<<31-1;
+		remaining := length - total_write;
+		to_read: i32;
+		MAX :: 1<<31-1;
 		if remaining <= MAX {
 			to_read = i32(remaining);
 		} else {
 			to_read = MAX;
 		}
-		var e = win32.write_file(win32.Handle(fd), &data[total_write], to_read, &single_write_length, nil);
+		e := win32.write_file(win32.Handle(fd), &data[total_write], to_read, &single_write_length, nil);
 		if single_write_length <= 0 || e == win32.FALSE {
-			var err = win32.get_last_error();
+			err := win32.get_last_error();
 			return int(total_write), Errno(e);
 		}
 		total_write += i64(single_write_length);
@@ -146,23 +145,23 @@ proc read(fd: Handle, data: []u8) -> (int, Errno) {
 		return 0, ERROR_NONE;
 	}
 
-	var single_read_length: i32;
-	var total_read: i64;
-	var length = i64(len(data));
+	single_read_length: i32;
+	total_read: i64;
+	length := i64(len(data));
 
 	for total_read < length {
-		var remaining = length - total_read;
-		var to_read: u32;
-		const MAX = 1<<32-1;
+		remaining := length - total_read;
+		to_read: u32;
+		MAX :: 1<<32-1;
 		if remaining <= MAX {
 			to_read = u32(remaining);
 		} else {
 			to_read = MAX;
 		}
 
-		var e = win32.read_file(win32.Handle(fd), &data[total_read], to_read, &single_read_length, nil);
+		e := win32.read_file(win32.Handle(fd), &data[total_read], to_read, &single_read_length, nil);
 		if single_read_length <= 0 || e == win32.FALSE {
-			var err = win32.get_last_error();
+			err := win32.get_last_error();
 			return int(total_read), Errno(e);
 		}
 		total_read += i64(single_read_length);
@@ -171,29 +170,29 @@ proc read(fd: Handle, data: []u8) -> (int, Errno) {
 }
 
 proc seek(fd: Handle, offset: i64, whence: int) -> (i64, Errno) {
-	var w: u32;
+	w: u32;
 	match whence {
 	case 0: w = win32.FILE_BEGIN;
 	case 1: w = win32.FILE_CURRENT;
 	case 2: w = win32.FILE_END;
 	}
-	var hi = i32(offset>>32);
-	var lo = i32(offset);
-	var ft = win32.get_file_type(win32.Handle(fd));
+	hi := i32(offset>>32);
+	lo := i32(offset);
+	ft := win32.get_file_type(win32.Handle(fd));
 	if ft == win32.FILE_TYPE_PIPE {
 		return 0, ERROR_FILE_IS_PIPE;
 	}
-	var dw_ptr = win32.set_file_pointer(win32.Handle(fd), lo, &hi, w);
+	dw_ptr := win32.set_file_pointer(win32.Handle(fd), lo, &hi, w);
 	if dw_ptr == win32.INVALID_SET_FILE_POINTER {
-		var err = win32.get_last_error();
+		err := win32.get_last_error();
 		return 0, Errno(err);
 	}
 	return i64(hi)<<32 + i64(dw_ptr), ERROR_NONE;
 }
 
 proc file_size(fd: Handle) -> (i64, Errno) {
-	var length: i64;
-	var err: Errno;
+	length: i64;
+	err: Errno;
 	if win32.get_file_size_ex(win32.Handle(fd), &length) == 0 {
 		err = Errno(win32.get_last_error());
 	}
@@ -203,13 +202,13 @@ proc file_size(fd: Handle) -> (i64, Errno) {
 
 
 // NOTE(bill): Uses startup to initialize it
-var stdin  = get_std_handle(win32.STD_INPUT_HANDLE);
-var stdout = get_std_handle(win32.STD_OUTPUT_HANDLE);
-var stderr = get_std_handle(win32.STD_ERROR_HANDLE);
+stdin  := get_std_handle(win32.STD_INPUT_HANDLE);
+stdout := get_std_handle(win32.STD_OUTPUT_HANDLE);
+stderr := get_std_handle(win32.STD_ERROR_HANDLE);
 
 
 proc get_std_handle(h: int) -> Handle {
-	var fd = win32.get_std_handle(i32(h));
+	fd := win32.get_std_handle(i32(h));
 	win32.set_handle_information(fd, win32.HANDLE_FLAG_INHERIT, 0);
 	return Handle(fd);
 }
@@ -220,17 +219,17 @@ proc get_std_handle(h: int) -> Handle {
 
 
 proc last_write_time(fd: Handle) -> FileTime {
-	var file_info: win32.ByHandleFileInformation;
+	file_info: win32.ByHandleFileInformation;
 	win32.get_file_information_by_handle(win32.Handle(fd), &file_info);
-	var lo = FileTime(file_info.last_write_time.lo);
-	var hi = FileTime(file_info.last_write_time.hi);
+	lo := FileTime(file_info.last_write_time.lo);
+	hi := FileTime(file_info.last_write_time.hi);
 	return lo | hi << 32;
 }
 
 proc last_write_time_by_name(name: string) -> FileTime {
-	var last_write_time: win32.Filetime;
-	var data: win32.FileAttributeData;
-	var buf: [1024]u8;
+	last_write_time: win32.Filetime;
+	data: win32.FileAttributeData;
+	buf: [1024]u8;
 
 	assert(len(buf) > len(name));
 
@@ -240,8 +239,8 @@ proc last_write_time_by_name(name: string) -> FileTime {
 		last_write_time = data.last_write_time;
 	}
 
-	var l = FileTime(last_write_time.lo);
-	var h = FileTime(last_write_time.hi);
+	l := FileTime(last_write_time.lo);
+	h := FileTime(last_write_time.hi);
 	return l | h << 32;
 }
 
@@ -283,15 +282,15 @@ proc current_thread_id() -> int {
 
 proc _alloc_command_line_arguments() -> []string {
 	proc alloc_ucs2_to_utf8(wstr: ^u16) -> string {
-		var wstr_len = 0;
+		wstr_len := 0;
 		for (wstr+wstr_len)^ != 0 {
 			wstr_len++;
 		}
-		var len = 2*wstr_len-1;
-		var buf = make([]u8, len+1);
-		var str = slice_ptr(wstr, wstr_len+1);
+		len := 2*wstr_len-1;
+		buf := make([]u8, len+1);
+		str := slice_ptr(wstr, wstr_len+1);
 
-		var i, j = 0, 0;
+		i, j := 0, 0;
 		for str[j] != 0 {
 			match {
 			case str[j] < 0x80:
@@ -311,7 +310,7 @@ proc _alloc_command_line_arguments() -> []string {
 				if i+4 > len {
 					return "";
 				}
-				var c = rune((str[j] - 0xd800) << 10) + rune((str[j+1]) - 0xdc00) + 0x10000;
+				c := rune((str[j] - 0xd800) << 10) + rune((str[j+1]) - 0xdc00) + 0x10000;
 				buf[i] = u8(0xf0 +  (c >> 18));         i++;
 				buf[i] = u8(0x80 + ((c >> 12) & 0x3f)); i++;
 				buf[i] = u8(0x80 + ((c >>  6) & 0x3f)); i++;
@@ -333,9 +332,9 @@ proc _alloc_command_line_arguments() -> []string {
 		return string(buf[0..<i]);
 	}
 
-	var arg_count: i32;
-	var arg_list_ptr = win32.command_line_to_argv_w(win32.get_command_line_w(), &arg_count);
-	var arg_list = make([]string, arg_count);
+	arg_count: i32;
+	arg_list_ptr := win32.command_line_to_argv_w(win32.get_command_line_w(), &arg_count);
+	arg_list := make([]string, arg_count);
 	for _, i in arg_list {
 		arg_list[i] = alloc_ucs2_to_utf8((arg_list_ptr+i)^);
 	}

core/os_x.odin

@@ -13,42 +13,42 @@ type (
 	AddressSize int;
 )
 
-const (
-	O_RDONLY   = 0x00000;
-	O_WRONLY   = 0x00001;
-	O_RDWR     = 0x00002;
-	O_CREAT    = 0x00040;
-	O_EXCL     = 0x00080;
-	O_NOCTTY   = 0x00100;
-	O_TRUNC    = 0x00200;
-	O_NONBLOCK = 0x00800;
-	O_APPEND   = 0x00400;
-	O_SYNC     = 0x01000;
-	O_ASYNC    = 0x02000;
-	O_CLOEXEC  = 0x80000;
-)
-const (
-	SEEK_SET   = 0;
-	SEEK_CUR   = 1;
-	SEEK_END   = 2;
-	SEEK_DATA  = 3;
-	SEEK_HOLE  = 4;
-	SEEK_MAX   = SEEK_HOLE;
-)
 
-const (
-	// NOTE(zangent): These are OS specific!
-	// Do not mix these up!
-	RTLD_LAZY     = 0x1;
-	RTLD_NOW      = 0x2;
-	RTLD_LOCAL    = 0x4;
-	RTLD_GLOBAL   = 0x8;
-	RTLD_NODELETE = 0x80;
-	RTLD_NOLOAD   = 0x10;
-	RTLD_FIRST    = 0x100;
-)
+O_RDONLY   :: 0x00000;
+O_WRONLY   :: 0x00001;
+O_RDWR     :: 0x00002;
+O_CREAT    :: 0x00040;
+O_EXCL     :: 0x00080;
+O_NOCTTY   :: 0x00100;
+O_TRUNC    :: 0x00200;
+O_NONBLOCK :: 0x00800;
+O_APPEND   :: 0x00400;
+O_SYNC     :: 0x01000;
+O_ASYNC    :: 0x02000;
+O_CLOEXEC  :: 0x80000;
+
+
+SEEK_SET   :: 0;
+SEEK_CUR   :: 1;
+SEEK_END   :: 2;
+SEEK_DATA  :: 3;
+SEEK_HOLE  :: 4;
+SEEK_MAX   :: SEEK_HOLE;
+
+
 
-var args: [dynamic]string;
+// NOTE(zangent): These are OS specific!
+// Do not mix these up!
+RTLD_LAZY     :: 0x1;
+RTLD_NOW      :: 0x2;
+RTLD_LOCAL    :: 0x4;
+RTLD_GLOBAL   :: 0x8;
+RTLD_NODELETE :: 0x80;
+RTLD_NOLOAD   :: 0x10;
+RTLD_FIRST    :: 0x100;
+
+
+args: [dynamic]string;
 
 type _FileTime struct #ordered {
 	seconds: i64,
@@ -80,39 +80,37 @@ type Stat struct #ordered {
 };
 
 // File type
-const (
-	S_IFMT   = 0170000; // Type of file mask
-	S_IFIFO  = 0010000; // Named pipe (fifo)
-	S_IFCHR  = 0020000; // Character special
-	S_IFDIR  = 0040000; // Directory
-	S_IFBLK  = 0060000; // Block special
-	S_IFREG  = 0100000; // Regular
-	S_IFLNK  = 0120000; // Symbolic link
-	S_IFSOCK = 0140000; // Socket
-
-	// File mode
-	// Read, write, execute/search by owner
-	S_IRWXU = 0000700; // RWX mask for owner
-	S_IRUSR = 0000400; // R for owner
-	S_IWUSR = 0000200; // W for owner
-	S_IXUSR = 0000100; // X for owner
-
-	// Read, write, execute/search by group
-	S_IRWXG = 0000070; // RWX mask for group
-	S_IRGRP = 0000040; // R for group
-	S_IWGRP = 0000020; // W for group
-	S_IXGRP = 0000010; // X for group
-
-	// Read, write, execute/search by others
-	S_IRWXO = 0000007; // RWX mask for other
-	S_IROTH = 0000004; // R for other
-	S_IWOTH = 0000002; // W for other
-	S_IXOTH = 0000001; // X for other
-
-	S_ISUID = 0004000; // Set user id on execution
-	S_ISGID = 0002000; // Set group id on execution
-	S_ISVTX = 0001000; // Directory restrcted delete
-)
+S_IFMT   :: 0170000; // Type of file mask
+S_IFIFO  :: 0010000; // Named pipe (fifo)
+S_IFCHR  :: 0020000; // Character special
+S_IFDIR  :: 0040000; // Directory
+S_IFBLK  :: 0060000; // Block special
+S_IFREG  :: 0100000; // Regular
+S_IFLNK  :: 0120000; // Symbolic link
+S_IFSOCK :: 0140000; // Socket
+
+// File mode
+// Read, write, execute/search by owner
+S_IRWXU :: 0000700; // RWX mask for owner
+S_IRUSR :: 0000400; // R for owner
+S_IWUSR :: 0000200; // W for owner
+S_IXUSR :: 0000100; // X for owner
+
+// Read, write, execute/search by group
+S_IRWXG :: 0000070; // RWX mask for group
+S_IRGRP :: 0000040; // R for group
+S_IWGRP :: 0000020; // W for group
+S_IXGRP :: 0000010; // X for group
+
+// Read, write, execute/search by others
+S_IRWXO :: 0000007; // RWX mask for other
+S_IROTH :: 0000004; // R for other
+S_IWOTH :: 0000002; // W for other
+S_IXOTH :: 0000001; // X for other
+
+S_ISUID :: 0004000; // Set user id on execution
+S_ISGID :: 0002000; // Set group id on execution
+S_ISVTX :: 0001000; // Directory restrcted delete
 
 proc S_ISLNK (m: u32) -> bool #inline  {return (m & S_IFMT) == S_IFLNK; }
 proc S_ISREG (m: u32) -> bool #inline  {return (m & S_IFMT) == S_IFREG; }
@@ -122,12 +120,10 @@ proc S_ISBLK (m: u32) -> bool #inline  {return (m & S_IFMT) == S_IFBLK; }
 proc S_ISFIFO(m: u32) -> bool #inline  {return (m & S_IFMT) == S_IFIFO; }
 proc S_ISSOCK(m: u32) -> bool #inline  {return (m & S_IFMT) == S_IFSOCK;}
 
-const (
-	R_OK = 4; // Test for read permission
-	W_OK = 2; // Test for write permission
-	X_OK = 1; // Test for execute permission
-	F_OK = 0; // Test for file existance
-)
+R_OK :: 4; // Test for read permission
+W_OK :: 2; // Test for write permission
+X_OK :: 1; // Test for execute permission
+F_OK :: 0; // Test for file existance
 
 foreign libc {
 	proc unix_open  (path: ^u8, mode: int) -> Handle                               #link_name "open";
@@ -157,8 +153,8 @@ foreign dl {
 // TODO(zangent): Change this to just `open` when Bill fixes overloading.
 proc open_simple(path: string, mode: int) -> (Handle, Errno) {
 
-	var cstr = strings.new_c_string(path);
-	var handle = unix_open(cstr, mode);
+	cstr := strings.new_c_string(path);
+	handle := unix_open(cstr, mode);
 	free(cstr);
 	if(handle == -1) {
 		return 0, 1;
@@ -178,7 +174,7 @@ proc close(fd: Handle) {
 proc write(fd: Handle, data: []u8) -> (AddressSize, Errno) {
 	assert(fd != -1);
 
-	var bytes_written = unix_write(fd, &data[0], len(data));
+	bytes_written := unix_write(fd, &data[0], len(data));
 	if(bytes_written == -1) {
 		return 0, 1;
 	}
@@ -188,7 +184,7 @@ proc write(fd: Handle, data: []u8) -> (AddressSize, Errno) {
 proc read(fd: Handle, data: []u8) -> (AddressSize, Errno) {
 	assert(fd != -1);
 
-	var bytes_read = unix_read(fd, &data[0], len(data));
+	bytes_read := unix_read(fd, &data[0], len(data));
 	if(bytes_read == -1) {
 		return 0, 1;
 	}
@@ -198,7 +194,7 @@ proc read(fd: Handle, data: []u8) -> (AddressSize, Errno) {
 proc seek(fd: Handle, offset: AddressSize, whence: int) -> (AddressSize, Errno) {
 	assert(fd != -1);
 
-	var final_offset = unix_lseek(fd, offset, whence);
+	final_offset := unix_lseek(fd, offset, whence);
 	if(final_offset == -1) {
 		return 0, 1;
 	}
@@ -206,8 +202,8 @@ proc seek(fd: Handle, offset: AddressSize, whence: int) -> (AddressSize, Errno)
 }
 
 proc file_size(fd: Handle) -> (i64, Errno) {
-	var prev, _ = seek(fd, 0, SEEK_CUR);
-	var size, err = seek(fd, 0, SEEK_END);
+	prev, _   := seek(fd, 0, SEEK_CUR);
+	size, err := seek(fd, 0, SEEK_END);
 	seek(fd, prev, SEEK_SET);
 	return size, err;
 }
@@ -215,26 +211,25 @@ proc file_size(fd: Handle) -> (i64, Errno) {
 
 
 // NOTE(bill): Uses startup to initialize it
-var (
-	stdin:  Handle = 0; // get_std_handle(win32.STD_INPUT_HANDLE);
-	stdout: Handle = 1; // get_std_handle(win32.STD_OUTPUT_HANDLE);
-	stderr: Handle = 2; // get_std_handle(win32.STD_ERROR_HANDLE);
-)
+stdin:  Handle = 0; // get_std_handle(win32.STD_INPUT_HANDLE);
+stdout: Handle = 1; // get_std_handle(win32.STD_OUTPUT_HANDLE);
+stderr: Handle = 2; // get_std_handle(win32.STD_ERROR_HANDLE);
+
 /* TODO(zangent): Implement these!
 proc last_write_time(fd: Handle) -> FileTime {}
 proc last_write_time_by_name(name: string) -> FileTime {}
 */
 
 proc stat(path: string) -> (Stat, bool) #inline {
-	var s: Stat;
-	var cstr = strings.new_c_string(path);
+	s: Stat;
+	cstr := strings.new_c_string(path);
 	defer free(cstr);
-	var ret_int = unix_stat(cstr, &s);
+	ret_int := unix_stat(cstr, &s);
 	return s, ret_int==0;
 }
 
 proc access(path: string, mask: int) -> bool #inline {
-	var cstr = strings.new_c_string(path);
+	cstr := strings.new_c_string(path);
 	defer free(cstr);
 	return unix_access(cstr, mask) == 0;
 }
@@ -251,8 +246,8 @@ proc heap_free(ptr: rawptr) #inline {
 }
 
 proc getenv(name: string) -> (string, bool) {
-	var path_str = strings.new_c_string(name);
-	var cstr: ^u8 = unix_getenv(path_str);
+	path_str := strings.new_c_string(name);
+	cstr: ^u8 = unix_getenv(path_str);
 	free(path_str);
 	if(cstr == nil) {
 		return "", false;
@@ -271,15 +266,15 @@ proc current_thread_id() -> int {
 }
 
 proc dlopen(filename: string, flags: int) -> rawptr #inline {
-	var cstr = strings.new_c_string(filename);
-	var handle = unix_dlopen(cstr, flags);
+	cstr := strings.new_c_string(filename);
+	handle := unix_dlopen(cstr, flags);
 	free(cstr);
 	return handle;
 }
 proc dlsym(handle: rawptr, symbol: string) -> (proc() #cc_c) #inline {
 	assert(handle != nil);
-	var cstr = strings.new_c_string(symbol);
-	var proc_handle = unix_dlsym(handle, cstr);
+	cstr := strings.new_c_string(symbol);
+	proc_handle := unix_dlsym(handle, cstr);
 	free(cstr);
 	return proc_handle;
 }

core/strconv.odin

@@ -18,8 +18,8 @@ proc parse_bool(s: string) -> (result: bool, ok: bool) {
 }
 
 proc _digit_value(r: rune) -> int {
-	var ri = int(r);
-	var v: int = 16;
+	ri := int(r);
+	v: int = 16;
 	match r {
 	case '0'..'9': v = ri-'0';
 	case 'a'..'z': v = ri-'a'+10;
@@ -29,7 +29,7 @@ proc _digit_value(r: rune) -> int {
 }
 
 proc parse_i128(s: string) -> i128 {
-	var neg = false;
+	neg := false;
 	if len(s) > 1 {
 		match s[0] {
 		case '-':
@@ -41,7 +41,7 @@ proc parse_i128(s: string) -> i128 {
 	}
 
 
-	var base: i128 = 10;
+	base: i128 = 10;
 	if len(s) > 2 && s[0] == '0' {
 		match s[1] {
 		case 'b': base =  2;  s = s[2..];
@@ -53,13 +53,13 @@ proc parse_i128(s: string) -> i128 {
 	}
 
 
-	var value: i128;
+	value: i128;
 	for r in s {
 		if r == '_' {
 			continue;
 		}
 
-		var v = i128(_digit_value(r));
+		v := i128(_digit_value(r));
 		if v >= base {
 			break;
 		}
@@ -71,13 +71,13 @@ proc parse_i128(s: string) -> i128 {
 }
 
 proc parse_u128(s: string) -> u128 {
-	var neg = false;
+	neg := false;
 	if len(s) > 1 && s[0] == '+' {
 		s = s[1..];
 	}
 
 
-	var base = u128(10);
+	base := u128(10);
 	if len(s) > 2 && s[0] == '0' {
 		match s[1] {
 		case 'b': base =  2;  s = s[2..];
@@ -89,13 +89,13 @@ proc parse_u128(s: string) -> u128 {
 	}
 
 
-	var value: u128;
+	value: u128;
 	for r in s {
 		if r == '_' {
 			continue;
 		}
 
-		var v = u128(_digit_value(r));
+		v := u128(_digit_value(r));
 		if v >= base {
 			break;
 		}
@@ -115,21 +115,21 @@ proc parse_uint(s: string, base: int) -> uint {
 }
 
 proc parse_f64(s: string) -> f64 {
-	var i = 0;
+	i := 0;
 
-	var sign: f64 = 1;
+	sign: f64 = 1;
 	match s[i] {
 	case '-': i++; sign = -1;
 	case '+': i++;
 	}
 
-	var value: f64 = 0;
+	value: f64 = 0;
 	for ; i < len(s); i++ {
-		var r = rune(s[i]);
+		r := rune(s[i]);
 		if r == '_' {
 			continue;
 		}
-		var v = _digit_value(r);
+		v := _digit_value(r);
 		if v >= 10 {
 			break;
 		}
@@ -138,15 +138,15 @@ proc parse_f64(s: string) -> f64 {
 	}
 
 	if s[i] == '.' {
-		var pow10: f64 = 10;
+		pow10: f64 = 10;
 		i++;
 
 		for ; i < len(s); i++ {
-			var r = rune(s[i]);
+			r := rune(s[i]);
 			if r == '_' {
 				continue;
 			}
-			var v = _digit_value(r);
+			v := _digit_value(r);
 			if v >= 10 {
 				break;
 			}
@@ -155,8 +155,8 @@ proc parse_f64(s: string) -> f64 {
 		}
 	}
 
-	var frac = false;
-	var scale: f64 = 1;
+	frac := false;
+	scale: f64 = 1;
 
 	if s[i] == 'e' || s[i] == 'E' {
 		i++;
@@ -166,13 +166,13 @@ proc parse_f64(s: string) -> f64 {
 		case '+': i++;
 		}
 
-		var exp: u32 = 0;
+		exp: u32 = 0;
 		for ; i < len(s); i++ {
-			var r = rune(s[i]);
+			r := rune(s[i]);
 			if r == '_' {
 				continue;
 			}
-			var d = u32(_digit_value(r));
+			d := u32(_digit_value(r));
 			if d >= 10 {
 				break;
 			}
@@ -190,7 +190,7 @@ proc parse_f64(s: string) -> f64 {
 
 
 proc append_bool(buf: []u8, b: bool) -> string {
-	var s = b ? "true" : "false";
+	s := b ? "true" : "false";
 	append(buf, ..[]u8(s));
 	return string(buf);
 }
@@ -210,28 +210,28 @@ proc append_float(buf: []u8, f: f64, fmt: u8, prec, bit_size: int) -> string {
 
 
 
-type DecimalSlice struct {
+DecimalSlice :: struct {
 	digits:        []u8,
 	count:         int,
 	decimal_point: int,
 	neg:           bool,
 }
 
-type Float_Info struct {
+Float_Info :: struct {
 	mantbits: uint,
 	expbits:  uint,
 	bias:     int,
 }
 
-var (
-	_f16_info = Float_Info{10, 5,   -15};
-	_f32_info = Float_Info{23, 8,  -127};
-	_f64_info = Float_Info{52, 11, -1023};
-)
+
+_f16_info := Float_Info{10, 5,   -15};
+_f32_info := Float_Info{23, 8,  -127};
+_f64_info := Float_Info{52, 11, -1023};
+
 
 proc generic_ftoa(buf: []u8, val: f64, fmt: u8, prec, bit_size: int) -> []u8 {
-	var bits: u64;
-	var flt: ^Float_Info;
+	bits: u64;
+	flt: ^Float_Info;
 	match bit_size {
 	case 32:
 		bits = u64(transmute(u32, f32(val)));
@@ -243,13 +243,13 @@ proc generic_ftoa(buf: []u8, val: f64, fmt: u8, prec, bit_size: int) -> []u8 {
 		panic("strconv: invalid bit_size");
 	}
 
-	var neg = bits>>(flt.expbits+flt.mantbits) != 0;
-	var exp = int(bits>>flt.mantbits) & (1<<flt.expbits - 1);
-	var mant = bits & (u64(1) << flt.mantbits - 1);
+	neg  := bits>>(flt.expbits+flt.mantbits) != 0;
+	exp  := int(bits>>flt.mantbits) & (1<<flt.expbits - 1);
+	mant := bits & (u64(1) << flt.mantbits - 1);
 
 	match exp {
 	case 1<<flt.expbits - 1:
-		var s: string;
+		s: string;
 		if mant != 0 {
 			s = "NaN";
 		} else if neg {
@@ -269,12 +269,12 @@ proc generic_ftoa(buf: []u8, val: f64, fmt: u8, prec, bit_size: int) -> []u8 {
 
 	exp += flt.bias;
 
-	var d_: Decimal;
-	var d = &d_;
+	d_: Decimal;
+	d := &d_;
 	assign(d, mant);
 	shift(d, exp - int(flt.mantbits));
-	var digs: DecimalSlice;
-	var shortest = prec < 0;
+	digs: DecimalSlice;
+	shortest := prec < 0;
 	if shortest {
 		round_shortest(d, mant, exp, flt);
 		digs = DecimalSlice{digits = d.digits[..], count = d.count, decimal_point = d.decimal_point};
@@ -308,7 +308,7 @@ proc format_digits(buf: []u8, shortest: bool, neg: bool, digs: DecimalSlice, pre
 
 		// integer, padded with zeros when needed
 		if digs.decimal_point > 0 {
-			var m = min(digs.count, digs.decimal_point);
+			m := min(digs.count, digs.decimal_point);
 			append(buf, ..digs.digits[0..<m]);
 			for ; m < digs.decimal_point; m++ {
 				append(buf, '0');
@@ -322,8 +322,8 @@ proc format_digits(buf: []u8, shortest: bool, neg: bool, digs: DecimalSlice, pre
 		if prec > 0 {
 			append(buf, '.');
 			for i in 0..<prec {
-				var c: u8 = '0';
-				if var j = digs.decimal_point + i; 0 <= j && j < digs.count {
+				c: u8 = '0';
+				if j := digs.decimal_point + i; 0 <= j && j < digs.count {
 					c = digs.digits[j];
 				}
 				append(buf, c);
@@ -341,9 +341,7 @@ proc format_digits(buf: []u8, shortest: bool, neg: bool, digs: DecimalSlice, pre
 		return buf; // TODO
 	}
 
-	var c: [2]u8;
-	c[0] = '%';
-	c[1] = fmt;
+	c := [2]u8{'%', fmt};
 	append(buf, ..c[..]);
 	return buf;
 }
@@ -360,18 +358,18 @@ proc round_shortest(d: ^Decimal, mant: u64, exp: int, flt: ^Float_Info) {
 		log(2) >~ 0.332
 		332*(dp-nd) >= 100*(exp-mantbits)
 	 */
-	var minexp = flt.bias+1;
+	minexp := flt.bias+1;
 	if exp > minexp && 332*(d.decimal_point-d.count) >= 100*(exp - int(flt.mantbits)) {
 		// Number is already its shortest
 		return;
 	}
 
-	var upper_: Decimal; var upper = &upper_;
+	upper_: Decimal; upper := &upper_;
 	assign(upper, 2*mant - 1);
 	shift(upper, exp - int(flt.mantbits) - 1);
 
-	var mantlo: u64;
-	var explo:  int;
+	mantlo: u64;
+	explo:  int;
 	if mant > 1<<flt.mantbits || exp == minexp {
 		mantlo = mant-1;
 		explo = exp;
@@ -379,25 +377,25 @@ proc round_shortest(d: ^Decimal, mant: u64, exp: int, flt: ^Float_Info) {
 		mantlo = 2*mant - 1;
 		explo = exp-1;
 	}
-	var lower_: Decimal; var lower = &lower_;
+	lower_: Decimal; lower := &lower_;
 	assign(lower, 2*mantlo + 1);
 	shift(lower, explo - int(flt.mantbits) - 1);
 
-	var inclusive = mant%2 == 0;
+	inclusive := mant%2 == 0;
 
 	for i in 0..<d.count {
-		var l: u8 = '0'; // lower digit
+		l: u8 = '0'; // lower digit
 		if i < lower.count {
 			l = lower.digits[i];
 		}
-		var m = d.digits[i];   // middle digit
-		var u: u8 = '0'; // upper digit
+		m := d.digits[i];   // middle digit
+		u: u8 = '0'; // upper digit
 		if i < upper.count {
 			u = upper.digits[i];
 		}
 
-		var ok_round_down = l != m || inclusive && i+1 == lower.count;
-		var ok_round_up   = m != u && (inclusive || m+1 < u || i+1 < upper.count);
+		ok_round_down := l != m || inclusive && i+1 == lower.count;
+		ok_round_up   := m != u && (inclusive || m+1 < u || i+1 < upper.count);
 
 		if (ok_round_down && ok_round_up) {
 			round(d, i+1);
@@ -415,36 +413,36 @@ proc round_shortest(d: ^Decimal, mant: u64, exp: int, flt: ^Float_Info) {
 
 }
 
-const MAX_BASE = 32;
-var digits = "0123456789abcdefghijklmnopqrstuvwxyz";
+MAX_BASE :: 32;
+digits := "0123456789abcdefghijklmnopqrstuvwxyz";
 
 
 proc is_integer_negative(u: u128, is_signed: bool, bit_size: int) -> (unsigned: u128, neg: bool) {
-	var neg = false;
+	neg := false;
 	if is_signed {
 		match bit_size {
 		case 8:
-			var i = i8(u);
+			i := i8(u);
 			neg = i < 0;
 			if neg { i = -i; }
 			u = u128(i);
 		case 16:
-			var i = i16(u);
+			i := i16(u);
 			neg = i < 0;
 			if neg { i = -i; }
 			u = u128(i);
 		case 32:
-			var i = i32(u);
+			i := i32(u);
 			neg = i < 0;
 			if neg { i = -i; }
 			u = u128(i);
 		case 64:
-			var i = i64(u);
+			i := i64(u);
 			neg = i < 0;
 			if neg { i = -i; }
 			u = u128(i);
 		case 128:
-			var i = i128(u);
+			i := i128(u);
 			neg = i < 0;
 			if neg { i = -i; }
 			u = u128(i);
@@ -460,11 +458,11 @@ proc append_bits(buf: []u8, u: u128, base: int, is_signed: bool, bit_size: int,
 		panic("strconv: illegal base passed to append_bits");
 	}
 
-	var neg: bool;
-	var a: [129]u8;
-	var i = len(a);
+	neg: bool;
+	a: [129]u8;
+	i := len(a);
 	u, neg = is_integer_negative(u, is_signed, bit_size);
-	var b = u128(base);
+	b := u128(base);
 	for u >= b {
 		i--; a[i] = digits[uint(u % b)];
 		u /= b;
@@ -472,7 +470,7 @@ proc append_bits(buf: []u8, u: u128, base: int, is_signed: bool, bit_size: int,
 	i--; a[i] = digits[uint(u % b)];
 
 	if flags&IntFlag.Prefix != 0 {
-		var ok = true;
+		ok := true;
 		match base {
 		case  2: i--; a[i] = 'b';
 		case  8: i--; a[i] = 'o';

core/strings.odin

@@ -1,19 +1,19 @@
 proc new_string(s: string) -> string {
-	var c = make([]u8, len(s)+1);
+	c := make([]u8, len(s)+1);
 	copy(c, []u8(s));
 	c[len(s)] = 0;
 	return string(c[0..<len(s)]);
 }
 
 proc new_c_string(s: string) -> ^u8 {
-	var c = make([]u8, len(s)+1);
+	c := make([]u8, len(s)+1);
 	copy(c, []u8(s));
 	c[len(s)] = 0;
 	return &c[0];
 }
 
 proc to_odin_string(c: ^u8) -> string {
-	var len = 0;
+	len := 0;
 	for (c+len)^ != 0 {
 		len++;
 	}

core/sync_linux.odin

@@ -49,7 +49,7 @@ proc mutex_destroy(m: ^Mutex) {
 	semaphore_destroy(&m._semaphore);
 }
 proc mutex_lock(m: ^Mutex) {
-	var thread_id = current_thread_id();
+	thread_id := current_thread_id();
 	if atomics.fetch_add(&m._counter, 1) > 0 {
 		if thread_id != atomics.load(&m._owner) {
 			semaphore_wait(&m._semaphore);
@@ -59,11 +59,11 @@ proc mutex_lock(m: ^Mutex) {
 	m._recursion++;
 }
 proc mutex_try_lock(m: ^Mutex) -> bool {
-	var thread_id = current_thread_id();
+	thread_id := current_thread_id();
 	if atomics.load(&m._owner) == thread_id {
 		atomics.fetch_add(&m._counter, 1);
 	} else {
-		var expected: i32 = 0;
+		expected: i32 = 0;
 		if atomics.load(&m._counter) != 0 {
 			return false;
 		}
@@ -76,8 +76,8 @@ proc mutex_try_lock(m: ^Mutex) -> bool {
 	return true;
 }
 proc mutex_unlock(m: ^Mutex) {
-	var recursion: i32;
-	var thread_id = current_thread_id();
+	recursion: i32;
+	thread_id := current_thread_id();
 	assert(thread_id == atomics.load(&m._owner));
 
 	m._recursion--;

core/sync_windows.odin

@@ -47,7 +47,7 @@ proc mutex_destroy(m: ^Mutex) {
 	semaphore_destroy(&m._semaphore);
 }
 proc mutex_lock(m: ^Mutex) {
-	var thread_id = current_thread_id();
+	thread_id := current_thread_id();
 	if atomics.fetch_add(&m._counter, 1) > 0 {
 		if thread_id != atomics.load(&m._owner) {
 			semaphore_wait(&m._semaphore);
@@ -57,11 +57,11 @@ proc mutex_lock(m: ^Mutex) {
 	m._recursion++;
 }
 proc mutex_try_lock(m: ^Mutex) -> bool {
-	var thread_id = current_thread_id();
+	thread_id := current_thread_id();
 	if atomics.load(&m._owner) == thread_id {
 		atomics.fetch_add(&m._counter, 1);
 	} else {
-		var expected: i32 = 0;
+		expected: i32 = 0;
 		if atomics.load(&m._counter) != 0 {
 			return false;
 		}
@@ -74,8 +74,8 @@ proc mutex_try_lock(m: ^Mutex) -> bool {
 	return true;
 }
 proc mutex_unlock(m: ^Mutex) {
-	var recursion: i32;
-	var thread_id = current_thread_id();
+	recursion: i32;
+	thread_id := current_thread_id();
 	assert(thread_id == atomics.load(&m._owner));
 
 	m._recursion--;

core/sys/wgl.odin

@@ -1,15 +1,14 @@
 foreign_system_library "opengl32.lib" when ODIN_OS == "windows";
 import . "windows.odin";
 
-const (
-	CONTEXT_MAJOR_VERSION_ARB          = 0x2091;
-	CONTEXT_MINOR_VERSION_ARB          = 0x2092;
-	CONTEXT_FLAGS_ARB                  = 0x2094;
-	CONTEXT_PROFILE_MASK_ARB           = 0x9126;
-	CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = 0x0002;
-	CONTEXT_CORE_PROFILE_BIT_ARB       = 0x00000001;
-	CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = 0x00000002;
-)
+
+CONTEXT_MAJOR_VERSION_ARB             :: 0x2091;
+CONTEXT_MINOR_VERSION_ARB             :: 0x2092;
+CONTEXT_FLAGS_ARB                     :: 0x2094;
+CONTEXT_PROFILE_MASK_ARB              :: 0x9126;
+CONTEXT_FORWARD_COMPATIBLE_BIT_ARB    :: 0x0002;
+CONTEXT_CORE_PROFILE_BIT_ARB          :: 0x00000001;
+CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB :: 0x00000002;
 
 type (
 	Hglrc    Handle;
@@ -62,12 +61,12 @@ type (
 	GetExtensionsStringARBType  proc(Hdc) -> ^u8 #cc_c;
 )
 
-var (
+// Procedures
 	create_context_attribs_arb: CreateContextAttribsARBType;
 	choose_pixel_format_arb:    ChoosePixelFormatARBType;
 	swap_interval_ext:          SwapIntervalEXTType;
 	get_extensions_string_arb:  GetExtensionsStringARBType;
-)
+
 
 
 foreign opengl32 {

core/sys/windows.odin

@@ -25,16 +25,14 @@ type (
 )
 
 type Bool i32;
-const (
-	FALSE: Bool = 0;
-	TRUE        = 1;
-)
+FALSE: Bool : 0;
+TRUE:  Bool : 1;
 
-type Point struct #ordered {
+Point :: struct #ordered {
 	x, y: i32,
 }
 
-type WndClassExA struct #ordered {
+WndClassExA :: struct #ordered {
 	size, style:           u32,
 	wnd_proc:              WndProc,
 	cls_extra, wnd_extra:  i32,
@@ -46,7 +44,7 @@ type WndClassExA struct #ordered {
 	sm:                    Hicon,
 }
 
-type Msg struct #ordered {
+Msg :: struct #ordered {
 	hwnd:    Hwnd,
 	message: u32,
 	wparam:  Wparam,
@@ -55,24 +53,24 @@ type Msg struct #ordered {
 	pt:      Point,
 }
 
-type Rect struct #ordered {
+Rect :: struct #ordered {
 	left:   i32,
 	top:    i32,
 	right:  i32,
 	bottom: i32,
 }
 
-type Filetime struct #ordered {
+Filetime :: struct #ordered {
 	lo, hi: u32,
 }
 
-type Systemtime struct #ordered {
+Systemtime :: struct #ordered {
 	year, month: u16,
 	day_of_week, day: u16,
 	hour, minute, second, millisecond: u16,
 }
 
-type ByHandleFileInformation struct #ordered {
+ByHandleFileInformation :: struct #ordered {
 	file_attributes:      u32,
 	creation_time,
 	last_access_time,
@@ -85,7 +83,7 @@ type ByHandleFileInformation struct #ordered {
 	file_index_low:       u32,
 }
 
-type FileAttributeData struct #ordered {
+FileAttributeData :: struct #ordered {
 	file_attributes:  u32,
 	creation_time,
 	last_access_time,
@@ -94,7 +92,7 @@ type FileAttributeData struct #ordered {
 	file_size_low:    u32,
 }
 
-type FindData struct #ordered {
+FindData :: struct #ordered {
     file_attributes:     u32,
     creation_time:       Filetime,
     last_access_time:    Filetime,
@@ -107,7 +105,7 @@ type FindData struct #ordered {
     alternate_file_name: [14]u8,
 }
 
-type Security_Attributes struct #ordered {
+Security_Attributes :: struct #ordered {
 	length:              u32,
 	security_descriptor: rawptr,
 	inherit_handle:      Bool,
@@ -115,7 +113,7 @@ type Security_Attributes struct #ordered {
 
 
 
-type PixelFormatDescriptor struct #ordered {
+PixelFormatDescriptor :: struct #ordered {
 	size,
 	version,
 	flags: u32,
@@ -151,138 +149,129 @@ type PixelFormatDescriptor struct #ordered {
 
 type Proc proc() #cc_c;
 
-const (
-	MAPVK_VK_TO_VSC    = 0;
-	MAPVK_VSC_TO_VK    = 1;
-	MAPVK_VK_TO_CHAR   = 2;
-	MAPVK_VSC_TO_VK_EX = 3;
-)
+MAPVK_VK_TO_VSC    :: 0;
+MAPVK_VSC_TO_VK    :: 1;
+MAPVK_VK_TO_CHAR   :: 2;
+MAPVK_VSC_TO_VK_EX :: 3;
 
 
 
-const INVALID_HANDLE = Handle(~int(0));
-
-
-const (
-	CS_VREDRAW    = 0x0001;
-	CS_HREDRAW    = 0x0002;
-	CS_OWNDC      = 0x0020;
-	CW_USEDEFAULT = -0x80000000;
-
-	WS_OVERLAPPED       = 0;
-	WS_MAXIMIZEBOX      = 0x00010000;
-	WS_MINIMIZEBOX      = 0x00020000;
-	WS_THICKFRAME       = 0x00040000;
-	WS_SYSMENU          = 0x00080000;
-	WS_BORDER           = 0x00800000;
-	WS_CAPTION          = 0x00C00000;
-	WS_VISIBLE          = 0x10000000;
-	WS_POPUP            = 0x80000000;
-	WS_OVERLAPPEDWINDOW = WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX;
-	WS_POPUPWINDOW      = WS_POPUP | WS_BORDER | WS_SYSMENU;
-
-	WM_DESTROY           = 0x0002;
-	WM_SIZE	             = 0x0005;
-	WM_CLOSE             = 0x0010;
-	WM_ACTIVATEAPP       = 0x001C;
-	WM_QUIT              = 0x0012;
-	WM_KEYDOWN           = 0x0100;
-	WM_KEYUP             = 0x0101;
-	WM_SIZING            = 0x0214;
-	WM_SYSKEYDOWN        = 0x0104;
-	WM_SYSKEYUP          = 0x0105;
-	WM_WINDOWPOSCHANGED  = 0x0047;
-	WM_SETCURSOR         = 0x0020;
-	WM_CHAR              = 0x0102;
-	WM_ACTIVATE          = 0x0006;
-	WM_SETFOCUS          = 0x0007;
-	WM_KILLFOCUS         = 0x0008;
-	WM_USER              = 0x0400;
-
-	WM_MOUSEWHEEL    = 0x020A;
-	WM_MOUSEMOVE     = 0x0200;
-	WM_LBUTTONDOWN   = 0x0201;
-	WM_LBUTTONUP     = 0x0202;
-	WM_LBUTTONDBLCLK = 0x0203;
-	WM_RBUTTONDOWN   = 0x0204;
-	WM_RBUTTONUP     = 0x0205;
-	WM_RBUTTONDBLCLK = 0x0206;
-	WM_MBUTTONDOWN   = 0x0207;
-	WM_MBUTTONUP     = 0x0208;
-	WM_MBUTTONDBLCLK = 0x0209;
-
-	PM_NOREMOVE = 0x0000;
-	PM_REMOVE   = 0x0001;
-	PM_NOYIELD  = 0x0002;
-
-	BLACK_BRUSH = 4;
-
-	SM_CXSCREEN = 0;
-	SM_CYSCREEN = 1;
-
-	SW_SHOW = 5;
-)
 
-const COLOR_BACKGROUND = Hbrush(int(1));
+INVALID_HANDLE :: Handle(~int(0));
 
-const INVALID_SET_FILE_POINTER = ~u32(0);
-const HEAP_ZERO_MEMORY = 0x00000008;
-const INFINITE = 0xffffffff;
-const GWL_STYLE = -16;
-const Hwnd_TOP = Hwnd(uint(0));
 
-const BI_RGB         = 0;
-const DIB_RGB_COLORS = 0x00;
-const SRCCOPY: u32   = 0x00cc0020;
+CS_VREDRAW    :: 0x0001;
+CS_HREDRAW    :: 0x0002;
+CS_OWNDC      :: 0x0020;
+CW_USEDEFAULT :: -0x80000000;
 
-const (
-	MONITOR_DEFAULTTONULL    = 0x00000000;
-	MONITOR_DEFAULTTOPRIMARY = 0x00000001;
-	MONITOR_DEFAULTTONEAREST = 0x00000002;
-)
-const (
-	SWP_FRAMECHANGED  = 0x0020;
-	SWP_NOOWNERZORDER = 0x0200;
-	SWP_NOZORDER      = 0x0004;
-	SWP_NOSIZE        = 0x0001;
-	SWP_NOMOVE        = 0x0002;
-)
+WS_OVERLAPPED       :: 0;
+WS_MAXIMIZEBOX      :: 0x00010000;
+WS_MINIMIZEBOX      :: 0x00020000;
+WS_THICKFRAME       :: 0x00040000;
+WS_SYSMENU          :: 0x00080000;
+WS_BORDER           :: 0x00800000;
+WS_CAPTION          :: 0x00C00000;
+WS_VISIBLE          :: 0x10000000;
+WS_POPUP            :: 0x80000000;
+WS_OVERLAPPEDWINDOW :: WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX;
+WS_POPUPWINDOW      :: WS_POPUP | WS_BORDER | WS_SYSMENU;
 
+WM_DESTROY           :: 0x0002;
+WM_SIZE	             :: 0x0005;
+WM_CLOSE             :: 0x0010;
+WM_ACTIVATEAPP       :: 0x001C;
+WM_QUIT              :: 0x0012;
+WM_KEYDOWN           :: 0x0100;
+WM_KEYUP             :: 0x0101;
+WM_SIZING            :: 0x0214;
+WM_SYSKEYDOWN        :: 0x0104;
+WM_SYSKEYUP          :: 0x0105;
+WM_WINDOWPOSCHANGED  :: 0x0047;
+WM_SETCURSOR         :: 0x0020;
+WM_CHAR              :: 0x0102;
+WM_ACTIVATE          :: 0x0006;
+WM_SETFOCUS          :: 0x0007;
+WM_KILLFOCUS         :: 0x0008;
+WM_USER              :: 0x0400;
 
+WM_MOUSEWHEEL    :: 0x020A;
+WM_MOUSEMOVE     :: 0x0200;
+WM_LBUTTONDOWN   :: 0x0201;
+WM_LBUTTONUP     :: 0x0202;
+WM_LBUTTONDBLCLK :: 0x0203;
+WM_RBUTTONDOWN   :: 0x0204;
+WM_RBUTTONUP     :: 0x0205;
+WM_RBUTTONDBLCLK :: 0x0206;
+WM_MBUTTONDOWN   :: 0x0207;
+WM_MBUTTONUP     :: 0x0208;
+WM_MBUTTONDBLCLK :: 0x0209;
 
+PM_NOREMOVE :: 0x0000;
+PM_REMOVE   :: 0x0001;
+PM_NOYIELD  :: 0x0002;
 
-// Windows OpenGL
-const (
-	PFD_TYPE_RGBA             = 0;
-	PFD_TYPE_COLORINDEX       = 1;
-	PFD_MAIN_PLANE            = 0;
-	PFD_OVERLAY_PLANE         = 1;
-	PFD_UNDERLAY_PLANE        = -1;
-	PFD_DOUBLEBUFFER          = 1;
-	PFD_STEREO                = 2;
-	PFD_DRAW_TO_WINDOW        = 4;
-	PFD_DRAW_TO_BITMAP        = 8;
-	PFD_SUPPORT_GDI           = 16;
-	PFD_SUPPORT_OPENGL        = 32;
-	PFD_GENERIC_FORMAT        = 64;
-	PFD_NEED_PALETTE          = 128;
-	PFD_NEED_SYSTEM_PALETTE   = 0x00000100;
-	PFD_SWAP_EXCHANGE         = 0x00000200;
-	PFD_SWAP_COPY             = 0x00000400;
-	PFD_SWAP_LAYER_BUFFERS    = 0x00000800;
-	PFD_GENERIC_ACCELERATED   = 0x00001000;
-	PFD_DEPTH_DONTCARE        = 0x20000000;
-	PFD_DOUBLEBUFFER_DONTCARE = 0x40000000;
-	PFD_STEREO_DONTCARE       = 0x80000000;
-)
+BLACK_BRUSH :: 4;
+
+SM_CXSCREEN :: 0;
+SM_CYSCREEN :: 1;
+
+SW_SHOW :: 5;
+
+COLOR_BACKGROUND :: Hbrush(int(1));
+
+INVALID_SET_FILE_POINTER :: ~u32(0);
+HEAP_ZERO_MEMORY         :: 0x00000008;
+INFINITE                 :: 0xffffffff;
+GWL_STYLE                :: -16;
+Hwnd_TOP                 :: Hwnd(uint(0));
+
+BI_RGB         :: 0;
+DIB_RGB_COLORS :: 0x00;
+SRCCOPY: u32    : 0x00cc0020;
 
 
+MONITOR_DEFAULTTONULL    :: 0x00000000;
+MONITOR_DEFAULTTOPRIMARY :: 0x00000001;
+MONITOR_DEFAULTTONEAREST :: 0x00000002;
+
+SWP_FRAMECHANGED  :: 0x0020;
+SWP_NOOWNERZORDER :: 0x0200;
+SWP_NOZORDER      :: 0x0004;
+SWP_NOSIZE        :: 0x0001;
+SWP_NOMOVE        :: 0x0002;
+
+
+
+
+// Windows OpenGL
+
+PFD_TYPE_RGBA             :: 0;
+PFD_TYPE_COLORINDEX       :: 1;
+PFD_MAIN_PLANE            :: 0;
+PFD_OVERLAY_PLANE         :: 1;
+PFD_UNDERLAY_PLANE        :: -1;
+PFD_DOUBLEBUFFER          :: 1;
+PFD_STEREO                :: 2;
+PFD_DRAW_TO_WINDOW        :: 4;
+PFD_DRAW_TO_BITMAP        :: 8;
+PFD_SUPPORT_GDI           :: 16;
+PFD_SUPPORT_OPENGL        :: 32;
+PFD_GENERIC_FORMAT        :: 64;
+PFD_NEED_PALETTE          :: 128;
+PFD_NEED_SYSTEM_PALETTE   :: 0x00000100;
+PFD_SWAP_EXCHANGE         :: 0x00000200;
+PFD_SWAP_COPY             :: 0x00000400;
+PFD_SWAP_LAYER_BUFFERS    :: 0x00000800;
+PFD_GENERIC_ACCELERATED   :: 0x00001000;
+PFD_DEPTH_DONTCARE        :: 0x20000000;
+PFD_DOUBLEBUFFER_DONTCARE :: 0x40000000;
+PFD_STEREO_DONTCARE       :: 0x80000000;
 
 type GET_FILEEX_INFO_LEVELS i32;
-const (
-	GetFileExInfoStandard: GET_FILEEX_INFO_LEVELS = 0;
-	GetFileExMaxInfoLevel                         = 1;
-)
+GetFileExInfoStandard: GET_FILEEX_INFO_LEVELS : 0;
+GetFileExMaxInfoLevel: GET_FILEEX_INFO_LEVELS : 1;
+
 
 foreign kernel32 {
 	proc get_last_error     () -> i32                                                                                       #cc_std #link_name "GetLastError";
@@ -448,7 +437,7 @@ foreign winmm {
 
 
 proc get_query_performance_frequency() -> i64 {
-	var r: i64;
+	r: i64;
 	query_performance_frequency(&r);
 	return r;
 }
@@ -463,67 +452,66 @@ proc is_key_down(key: KeyCode) -> bool #inline { return get_async_key_state(i32(
 
 
 
-const (
-	MAX_PATH = 0x00000104;
 
-	HANDLE_FLAG_INHERIT = 1;
-	HANDLE_FLAG_PROTECT_FROM_CLOSE = 2;
+MAX_PATH :: 0x00000104;
 
-	FILE_BEGIN   = 0;
-	FILE_CURRENT = 1;
-	FILE_END     = 2;
+HANDLE_FLAG_INHERIT :: 1;
+HANDLE_FLAG_PROTECT_FROM_CLOSE :: 2;
 
-	FILE_SHARE_READ      = 0x00000001;
-	FILE_SHARE_WRITE     = 0x00000002;
-	FILE_SHARE_DELETE    = 0x00000004;
-	FILE_GENERIC_ALL     = 0x10000000;
-	FILE_GENERIC_EXECUTE = 0x20000000;
-	FILE_GENERIC_WRITE   = 0x40000000;
-	FILE_GENERIC_READ    = 0x80000000;
+FILE_BEGIN   :: 0;
+FILE_CURRENT :: 1;
+FILE_END     :: 2;
 
-	FILE_APPEND_DATA = 0x0004;
+FILE_SHARE_READ      :: 0x00000001;
+FILE_SHARE_WRITE     :: 0x00000002;
+FILE_SHARE_DELETE    :: 0x00000004;
+FILE_GENERIC_ALL     :: 0x10000000;
+FILE_GENERIC_EXECUTE :: 0x20000000;
+FILE_GENERIC_WRITE   :: 0x40000000;
+FILE_GENERIC_READ    :: 0x80000000;
 
-	STD_INPUT_HANDLE  = -10;
-	STD_OUTPUT_HANDLE = -11;
-	STD_ERROR_HANDLE  = -12;
+FILE_APPEND_DATA :: 0x0004;
 
-	CREATE_NEW        = 1;
-	CREATE_ALWAYS     = 2;
-	OPEN_EXISTING     = 3;
-	OPEN_ALWAYS       = 4;
-	TRUNCATE_EXISTING = 5;
+STD_INPUT_HANDLE  :: -10;
+STD_OUTPUT_HANDLE :: -11;
+STD_ERROR_HANDLE  :: -12;
 
-	INVALID_FILE_ATTRIBUTES  = -1;
+CREATE_NEW        :: 1;
+CREATE_ALWAYS     :: 2;
+OPEN_EXISTING     :: 3;
+OPEN_ALWAYS       :: 4;
+TRUNCATE_EXISTING :: 5;
 
-	FILE_ATTRIBUTE_READONLY             = 0x00000001;
-	FILE_ATTRIBUTE_HIDDEN               = 0x00000002;
-	FILE_ATTRIBUTE_SYSTEM               = 0x00000004;
-	FILE_ATTRIBUTE_DIRECTORY            = 0x00000010;
-	FILE_ATTRIBUTE_ARCHIVE              = 0x00000020;
-	FILE_ATTRIBUTE_DEVICE               = 0x00000040;
-	FILE_ATTRIBUTE_NORMAL               = 0x00000080;
-	FILE_ATTRIBUTE_TEMPORARY            = 0x00000100;
-	FILE_ATTRIBUTE_SPARSE_FILE          = 0x00000200;
-	FILE_ATTRIBUTE_REPARSE_Point        = 0x00000400;
-	FILE_ATTRIBUTE_COMPRESSED           = 0x00000800;
-	FILE_ATTRIBUTE_OFFLINE              = 0x00001000;
-	FILE_ATTRIBUTE_NOT_CONTENT_INDEXED  = 0x00002000;
-	FILE_ATTRIBUTE_ENCRYPTED            = 0x00004000;
+INVALID_FILE_ATTRIBUTES  :: -1;
 
-	FILE_TYPE_DISK = 0x0001;
-	FILE_TYPE_CHAR = 0x0002;
-	FILE_TYPE_PIPE = 0x0003;
-)
+FILE_ATTRIBUTE_READONLY             :: 0x00000001;
+FILE_ATTRIBUTE_HIDDEN               :: 0x00000002;
+FILE_ATTRIBUTE_SYSTEM               :: 0x00000004;
+FILE_ATTRIBUTE_DIRECTORY            :: 0x00000010;
+FILE_ATTRIBUTE_ARCHIVE              :: 0x00000020;
+FILE_ATTRIBUTE_DEVICE               :: 0x00000040;
+FILE_ATTRIBUTE_NORMAL               :: 0x00000080;
+FILE_ATTRIBUTE_TEMPORARY            :: 0x00000100;
+FILE_ATTRIBUTE_SPARSE_FILE          :: 0x00000200;
+FILE_ATTRIBUTE_REPARSE_Point        :: 0x00000400;
+FILE_ATTRIBUTE_COMPRESSED           :: 0x00000800;
+FILE_ATTRIBUTE_OFFLINE              :: 0x00001000;
+FILE_ATTRIBUTE_NOT_CONTENT_INDEXED  :: 0x00002000;
+FILE_ATTRIBUTE_ENCRYPTED            :: 0x00004000;
+
+FILE_TYPE_DISK :: 0x0001;
+FILE_TYPE_CHAR :: 0x0002;
+FILE_TYPE_PIPE :: 0x0003;
 
 
-type MonitorInfo struct #ordered {
+MonitorInfo :: struct #ordered {
 	size:      u32,
 	monitor:   Rect,
 	work:      Rect,
 	flags:     u32,
 }
 
-type WindowPlacement struct #ordered {
+WindowPlacement :: struct #ordered {
 	length:     u32,
 	flags:      u32,
 	show_cmd:   u32,
@@ -532,7 +520,7 @@ type WindowPlacement struct #ordered {
 	normal_pos: Rect,
 }
 
-type BitmapInfoHeader struct #ordered {
+BitmapInfoHeader :: struct #ordered {
 	size:              u32,
 	width, height:     i32,
 	planes, bit_count: i16,
@@ -543,16 +531,16 @@ type BitmapInfoHeader struct #ordered {
 	clr_used:          u32,
 	clr_important:     u32,
 }
-type BitmapInfo struct #ordered {
+BitmapInfo :: struct #ordered {
 	using header: BitmapInfoHeader,
 	colors:       [1]RgbQuad,
 }
 
 
-type RgbQuad struct #ordered { blue, green, red, reserved: u8 }
+RgbQuad :: struct #ordered { blue, green, red, reserved: u8 }
 
 
-type KeyCode enum i32 {
+KeyCode :: enum i32 {
 	Lbutton    = 0x01,
 	Rbutton    = 0x02,
 	Cancel     = 0x03,

core/types.odin

@@ -8,91 +8,91 @@ proc is_signed(info: ^TypeInfo) -> bool {
 }
 proc is_integer(info: ^TypeInfo) -> bool {
 	if info == nil { return false; }
-	var _, ok = type_info_base(info).(^TypeInfo.Integer);
+	_, ok := type_info_base(info).(^TypeInfo.Integer);
 	return ok;
 }
 proc is_float(info: ^TypeInfo) -> bool {
 	if info == nil { return false; }
-	var _, ok = type_info_base(info).(^TypeInfo.Float);
+	_, ok := type_info_base(info).(^TypeInfo.Float);
 	return ok;
 }
 proc is_complex(info: ^TypeInfo) -> bool {
 	if info == nil { return false; }
-	var _, ok = type_info_base(info).(^TypeInfo.Complex);
+	_, ok := type_info_base(info).(^TypeInfo.Complex);
 	return ok;
 }
 proc is_any(info: ^TypeInfo) -> bool {
 	if info == nil { return false; }
-	var _, ok = type_info_base(info).(^TypeInfo.Any);
+	_, ok := type_info_base(info).(^TypeInfo.Any);
 	return ok;
 }
 proc is_string(info: ^TypeInfo) -> bool {
 	if info == nil { return false; }
-	var _, ok = type_info_base(info).(^TypeInfo.String);
+	_, ok := type_info_base(info).(^TypeInfo.String);
 	return ok;
 }
 proc is_boolean(info: ^TypeInfo) -> bool {
 	if info == nil { return false; }
-	var _, ok = type_info_base(info).(^TypeInfo.Boolean);
+	_, ok := type_info_base(info).(^TypeInfo.Boolean);
 	return ok;
 }
 proc is_pointer(info: ^TypeInfo) -> bool {
 	if info == nil { return false; }
-	var _, ok = type_info_base(info).(^TypeInfo.Pointer);
+	_, ok := type_info_base(info).(^TypeInfo.Pointer);
 	return ok;
 }
 proc is_procedure(info: ^TypeInfo) -> bool {
 	if info == nil { return false; }
-	var _, ok = type_info_base(info).(^TypeInfo.Procedure);
+	_, ok := type_info_base(info).(^TypeInfo.Procedure);
 	return ok;
 }
 proc is_array(info: ^TypeInfo) -> bool {
 	if info == nil { return false; }
-	var _, ok = type_info_base(info).(^TypeInfo.Array);
+	_, ok := type_info_base(info).(^TypeInfo.Array);
 	return ok;
 }
 proc is_dynamic_array(info: ^TypeInfo) -> bool {
 	if info == nil { return false; }
-	var _, ok = type_info_base(info).(^TypeInfo.DynamicArray);
+	_, ok := type_info_base(info).(^TypeInfo.DynamicArray);
 	return ok;
 }
 proc is_dynamic_map(info: ^TypeInfo) -> bool {
 	if info == nil { return false; }
-	var _, ok = type_info_base(info).(^TypeInfo.Map);
+	_, ok := type_info_base(info).(^TypeInfo.Map);
 	return ok;
 }
 proc is_slice(info: ^TypeInfo) -> bool {
 	if info == nil { return false; }
-	var _, ok = type_info_base(info).(^TypeInfo.Slice);
+	_, ok := type_info_base(info).(^TypeInfo.Slice);
 	return ok;
 }
 proc is_vector(info: ^TypeInfo) -> bool {
 	if info == nil { return false; }
-	var _, ok = type_info_base(info).(^TypeInfo.Vector);
+	_, ok := type_info_base(info).(^TypeInfo.Vector);
 	return ok;
 }
 proc is_tuple(info: ^TypeInfo) -> bool {
 	if info == nil { return false; }
-	var _, ok = type_info_base(info).(^TypeInfo.Tuple);
+	_, ok := type_info_base(info).(^TypeInfo.Tuple);
 	return ok;
 }
 proc is_struct(info: ^TypeInfo) -> bool {
 	if info == nil { return false; }
-	var _, ok = type_info_base(info).(^TypeInfo.Struct);
+	_, ok := type_info_base(info).(^TypeInfo.Struct);
 	return ok;
 }
 proc is_union(info: ^TypeInfo) -> bool {
 	if info == nil { return false; }
-	var _, ok = type_info_base(info).(^TypeInfo.Union);
+	_, ok := type_info_base(info).(^TypeInfo.Union);
 	return ok;
 }
 proc is_raw_union(info: ^TypeInfo) -> bool {
 	if info == nil { return false; }
-	var _, ok = type_info_base(info).(^TypeInfo.RawUnion);
+	_, ok := type_info_base(info).(^TypeInfo.RawUnion);
 	return ok;
 }
 proc is_enum(info: ^TypeInfo) -> bool {
 	if info == nil { return false; }
-	var _, ok = type_info_base(info).(^TypeInfo.Enum);
+	_, ok := type_info_base(info).(^TypeInfo.Enum);
 	return ok;
 }

core/utf16.odin

@@ -1,12 +1,11 @@
-const (
-	REPLACEMENT_CHAR = '\uFFFD';
-	MAX_RUNE         = '\U0010FFFF';
+REPLACEMENT_CHAR :: '\uFFFD';
+MAX_RUNE         :: '\U0010FFFF';
+
+_surr1           :: 0xd800;
+_surr2           :: 0xdc00;
+_surr3           :: 0xe000;
+_surr_self       :: 0x10000;
 
-	_surr1           = 0xd800;
-	_surr2           = 0xdc00;
-	_surr3           = 0xe000;
-	_surr_self       = 0x10000;
-)
 
 proc is_surrogate(r: rune) -> bool {
 	return _surr1 <= r && r < _surr3;
@@ -29,14 +28,14 @@ proc encode_surrogate_pair(r: rune) -> (r1, r2: rune) {
 }
 
 proc encode(d: []u16, s: []rune) {
-	var n = len(s);
+	n := len(s);
 	for r in s {
 		if r >= _surr_self {
 			n++;
 		}
 	}
 
-	var max_n = min(len(d), n);
+	max_n := min(len(d), n);
 	n = 0;
 
 	for r in s {
@@ -46,7 +45,7 @@ proc encode(d: []u16, s: []rune) {
 			n++;
 
 		case _surr_self..MAX_RUNE:
-			var r1, r2 = encode_surrogate_pair(r);
+			r1, r2 := encode_surrogate_pair(r);
 			d[n]    = u16(r1);
 			d[n+1]  = u16(r2);
 			n += 2;

core/utf8.odin

@@ -1,71 +1,67 @@
-const (
-	RUNE_ERROR = '\ufffd';
-	RUNE_SELF  = 0x80;
-	RUNE_BOM   = 0xfeff;
-	RUNE_EOF   = ~rune(0);
-	MAX_RUNE   = '\U0010ffff';
-	UTF_MAX    = 4;
-
-	SURROGATE_MIN = 0xd800;
-	SURROGATE_MAX = 0xdfff;
-
-	T1 = 0b0000_0000;
-	TX = 0b1000_0000;
-	T2 = 0b1100_0000;
-	T3 = 0b1110_0000;
-	T4 = 0b1111_0000;
-	T5 = 0b1111_1000;
-
-	MASKX = 0b0011_1111;
-	MASK2 = 0b0001_1111;
-	MASK3 = 0b0000_1111;
-	MASK4 = 0b0000_0111;
-
-	RUNE1_MAX = 1<<7 - 1;
-	RUNE2_MAX = 1<<11 - 1;
-	RUNE3_MAX = 1<<16 - 1;
+RUNE_ERROR :: '\ufffd';
+RUNE_SELF  :: 0x80;
+RUNE_BOM   :: 0xfeff;
+RUNE_EOF   :: ~rune(0);
+MAX_RUNE   :: '\U0010ffff';
+UTF_MAX    :: 4;
+
+SURROGATE_MIN :: 0xd800;
+SURROGATE_MAX :: 0xdfff;
+
+T1 :: 0b0000_0000;
+TX :: 0b1000_0000;
+T2 :: 0b1100_0000;
+T3 :: 0b1110_0000;
+T4 :: 0b1111_0000;
+T5 :: 0b1111_1000;
+
+MASKX :: 0b0011_1111;
+MASK2 :: 0b0001_1111;
+MASK3 :: 0b0000_1111;
+MASK4 :: 0b0000_0111;
+
+RUNE1_MAX :: 1<<7 - 1;
+RUNE2_MAX :: 1<<11 - 1;
+RUNE3_MAX :: 1<<16 - 1;
 
 	// The default lowest and highest continuation byte.
-	LOCB = 0b1000_0000;
-	HICB = 0b1011_1111;
-)
-
-type AcceptRange struct { lo, hi: u8 }
-
-var (
-	accept_ranges = [5]AcceptRange{
-		{0x80, 0xbf},
-		{0xa0, 0xbf},
-		{0x80, 0x9f},
-		{0x90, 0xbf},
-		{0x80, 0x8f},
-	};
-
-	accept_sizes = [256]u8{
-		0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x00-0x0f
-		0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x10-0x1f
-		0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x20-0x2f
-		0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x30-0x3f
-		0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x40-0x4f
-		0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x50-0x5f
-		0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x60-0x6f
-		0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x70-0x7f
-
-		0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0x80-0x8f
-		0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0x90-0x9f
-		0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xa0-0xaf
-		0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xb0-0xbf
-		0xf1, 0xf1, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, // 0xc0-0xcf
-		0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, // 0xd0-0xdf
-		0x13, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x23, 0x03, 0x03, // 0xe0-0xef
-		0x34, 0x04, 0x04, 0x04, 0x44, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xf0-0xff
-	};
-)
+LOCB :: 0b1000_0000;
+HICB :: 0b1011_1111;
+
+AcceptRange :: struct { lo, hi: u8 }
+
+accept_ranges := [5]AcceptRange{
+	{0x80, 0xbf},
+	{0xa0, 0xbf},
+	{0x80, 0x9f},
+	{0x90, 0xbf},
+	{0x80, 0x8f},
+};
+
+accept_sizes := [256]u8{
+	0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x00-0x0f
+	0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x10-0x1f
+	0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x20-0x2f
+	0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x30-0x3f
+	0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x40-0x4f
+	0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x50-0x5f
+	0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x60-0x6f
+	0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, // 0x70-0x7f
+
+	0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0x80-0x8f
+	0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0x90-0x9f
+	0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xa0-0xaf
+	0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xb0-0xbf
+	0xf1, 0xf1, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, // 0xc0-0xcf
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, // 0xd0-0xdf
+	0x13, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x23, 0x03, 0x03, // 0xe0-0xef
+	0x34, 0x04, 0x04, 0x04, 0x44, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xf0-0xff
+};
 
 proc encode_rune(r: rune) -> ([4]u8, int) {
-	var buf: [4]u8;
-	var i = u32(r);
-	const mask: u8 = 0x3f;
+	buf: [4]u8;
+	i := u32(r);
+	mask: u8 : 0x3f;
 	if i <= 1<<7-1 {
 		buf[0] = u8(r);
 		return buf, 1;
@@ -98,36 +94,36 @@ proc encode_rune(r: rune) -> ([4]u8, int) {
 
 proc decode_rune(s: string) -> (rune, int) #inline { return decode_rune([]u8(s)); }
 proc decode_rune(s: []u8) -> (rune, int) {
-	var n = len(s);
+	n := len(s);
 	if n < 1 {
 		return RUNE_ERROR, 0;
 	}
-	var s0 = s[0];
-	var x = accept_sizes[s0];
+	s0 := s[0];
+	x := accept_sizes[s0];
 	if x >= 0xF0 {
-		var mask = rune(x) << 31 >> 31; // NOTE(bill): Create 0x0000 or 0xffff.
+		mask := rune(x) << 31 >> 31; // NOTE(bill): Create 0x0000 or 0xffff.
 		return rune(s[0])&~mask | RUNE_ERROR&mask, 1;
 	}
-	var sz = x & 7;
-	var accept = accept_ranges[x>>4];
+	sz := x & 7;
+	accept := accept_ranges[x>>4];
 	if n < int(sz) {
 		return RUNE_ERROR, 1;
 	}
-	var b1 = s[1];
+	b1 := s[1];
 	if b1 < accept.lo || accept.hi < b1 {
 		return RUNE_ERROR, 1;
 	}
 	if sz == 2 {
 		return rune(s0&MASK2)<<6 | rune(b1&MASKX), 2;
 	}
-	var b2 = s[2];
+	b2 := s[2];
 	if b2 < LOCB || HICB < b2 {
 		return RUNE_ERROR, 1;
 	}
 	if sz == 3 {
 		return rune(s0&MASK3)<<12 | rune(b1&MASKX)<<6 | rune(b2&MASKX), 3;
 	}
-	var b3 = s[3];
+	b3 := s[3];
 	if b3 < LOCB || HICB < b3 {
 		return RUNE_ERROR, 1;
 	}
@@ -138,9 +134,9 @@ proc decode_rune(s: []u8) -> (rune, int) {
 
 proc decode_last_rune(s: string) -> (rune, int) #inline { return decode_last_rune([]u8(s)); }
 proc decode_last_rune(s: []u8) -> (rune, int) {
-	var r: rune;
-	var size: int;
-	var start, end, limit: int;
+	r: rune;
+	size: int;
+	start, end, limit: int;
 
 	end = len(s);
 	if end == 0 {
@@ -187,31 +183,31 @@ proc valid_rune(r: rune) -> bool {
 }
 
 proc valid_string(s: string) -> bool {
-	var n = len(s);
-	for var i = 0; i < n; {
-		var si = s[i];
+	n := len(s);
+	for i := 0; i < n; {
+		si := s[i];
 		if si < RUNE_SELF { // ascii
 			i++;
 			continue;
 		}
-		var x = accept_sizes[si];
+		x := accept_sizes[si];
 		if x == 0xf1 {
 			return false;
 		}
-		var size = int(x & 7);
+		size := int(x & 7);
 		if i+size > n {
 			return false;
 		}
-		var ar = accept_ranges[x>>4];
-		if var b = s[i+1]; b < ar.lo || ar.hi < b {
+		ar := accept_ranges[x>>4];
+		if b := s[i+1]; b < ar.lo || ar.hi < b {
 			return false;
 		} else if size == 2 {
 			// Okay
-		} else if var b = s[i+2]; b < 0x80 || 0xbf < b {
+		} else if b := s[i+2]; b < 0x80 || 0xbf < b {
 			return false;
 		} else if size == 3 {
 			// Okay
-		} else if var b = s[i+3]; b < 0x80 || 0xbf < b {
+		} else if b := s[i+3]; b < 0x80 || 0xbf < b {
 			return false;
 		}
 		i += size;
@@ -223,36 +219,36 @@ proc rune_start(b: u8) -> bool #inline { return b&0xc0 != 0x80; }
 
 proc rune_count(s: string) -> int #inline { return rune_count([]u8(s)); }
 proc rune_count(s: []u8) -> int {
-	var count = 0;
-	var n = len(s);
+	count := 0;
+	n := len(s);
 
-	for var i = 0; i < n; {
+	for i := 0; i < n; {
 		defer count++;
-		var si = s[i];
+		si := s[i];
 		if si < RUNE_SELF { // ascii
 			i++;
 			continue;
 		}
-		var x = accept_sizes[si];
+		x := accept_sizes[si];
 		if x == 0xf1 {
 			i++;
 			continue;
 		}
-		var size = int(x & 7);
+		size := int(x & 7);
 		if i+size > n {
 			i++;
 			continue;
 		}
-		var ar = accept_ranges[x>>4];
-		if var b = s[i+1]; b < ar.lo || ar.hi < b {
+		ar := accept_ranges[x>>4];
+		if b := s[i+1]; b < ar.lo || ar.hi < b {
 			size = 1;
 		} else if size == 2 {
 			// Okay
-		} else if var b = s[i+2]; b < 0x80 || 0xbf < b {
+		} else if b := s[i+2]; b < 0x80 || 0xbf < b {
 			size = 1;
 		} else if size == 3 {
 			// Okay
-		} else if var b = s[i+3]; b < 0x80 || 0xbf < b {
+		} else if b := s[i+3]; b < 0x80 || 0xbf < b {
 			size = 1;
 		}
 		i += size;

src/check_expr.cpp

@@ -2219,6 +2219,11 @@ Type *check_type(Checker *c, AstNode *e, Type *named_type) {
 		}
 	}
 
+	if (is_type_gen_proc(type)) {
+		error(e, "Invalid use of polymorphic procedure type");
+		type = t_invalid;
+	}
+
 	if (is_type_typed(type)) {
 		add_type_and_value(&c->info, e, Addressing_Type, type, empty_exact_value);
 	} else {

src/parser.cpp

@@ -1871,6 +1871,15 @@ bool is_semicolon_optional_for_node(AstFile *f, AstNode *s) {
 	case AstNode_ProcDecl:
 		return s->ProcDecl.body != NULL;
 
+	case AstNode_ValueDecl:
+		if (s->ValueDecl.is_mutable) {
+			return false;
+		}
+		if (s->ValueDecl.values.count > 0) {
+			return is_semicolon_optional_for_node(f, s->ValueDecl.values[s->ValueDecl.values.count-1]);
+		}
+		break;
+
 	case AstNode_GenDecl:
 		if (s->GenDecl.close.pos.line != 0) {
 			return true;
@@ -3149,7 +3158,11 @@ AstNode *parse_value_decl(AstFile *f, Array<AstNode *> names, CommentGroup docs)
 	}
 
 	if (f->expr_level >= 0) {
-		expect_semicolon(f, NULL);
+		AstNode *end = NULL;
+		if (!is_mutable && values.count > 0) {
+			end = values[values.count-1];
+		}
+		expect_semicolon(f, end);
 	}
 
 	return ast_value_decl(f, names, type, values, is_mutable, docs, f->line_comment);
@@ -4317,8 +4330,8 @@ AstNode *parse_stmt(AstFile *f) {
 		expect_semicolon(f, s);
 		return s;
 
-	case Token_var:
-	case Token_const:
+	// case Token_var:
+	// case Token_const:
 	case Token_proc:
 	case Token_type:
 	case Token_import: