var/const decl; remove `:` from parameter lists

core/_preload.odin

@@ -77,7 +77,7 @@ type Type_Info union {
 	};
 };
 
-proc type_info_base(info: ^Type_Info) -> ^Type_Info {
+proc type_info_base(info ^Type_Info) -> ^Type_Info {
 	if info == nil {
 		return nil;
 	}
@@ -91,22 +91,22 @@ proc type_info_base(info: ^Type_Info) -> ^Type_Info {
 
 
 
-proc assume(cond: bool) #foreign "llvm.assume"
+proc assume(cond bool) #foreign "llvm.assume"
 
 proc __debug_trap      ()        #foreign "llvm.debugtrap"
 proc __trap            ()        #foreign "llvm.trap"
 proc read_cycle_counter() -> u64 #foreign "llvm.readcyclecounter"
 
-proc bit_reverse16(b: u16) -> u16 #foreign "llvm.bitreverse.i16"
-proc bit_reverse32(b: u32) -> u32 #foreign "llvm.bitreverse.i32"
-proc bit_reverse64(b: u64) -> u64 #foreign "llvm.bitreverse.i64"
+proc bit_reverse16(b u16) -> u16 #foreign "llvm.bitreverse.i16"
+proc bit_reverse32(b u32) -> u32 #foreign "llvm.bitreverse.i32"
+proc bit_reverse64(b u64) -> u64 #foreign "llvm.bitreverse.i64"
 
-proc byte_swap16(b: u16) -> u16 #foreign "llvm.bswap.i16"
-proc byte_swap32(b: u32) -> u32 #foreign "llvm.bswap.i32"
-proc byte_swap64(b: u64) -> u64 #foreign "llvm.bswap.i64"
+proc byte_swap16(b u16) -> u16 #foreign "llvm.bswap.i16"
+proc byte_swap32(b u32) -> u32 #foreign "llvm.bswap.i32"
+proc byte_swap64(b u64) -> u64 #foreign "llvm.bswap.i64"
 
-proc fmuladd32(a, b, c: f32) -> f32 #foreign "llvm.fmuladd.f32"
-proc fmuladd64(a, b, c: f64) -> f64 #foreign "llvm.fmuladd.f64"
+proc fmuladd32(a, b, c f32) -> f32 #foreign "llvm.fmuladd.f32"
+proc fmuladd64(a, b, c f64) -> f64 #foreign "llvm.fmuladd.f64"
 
 
 
@@ -119,9 +119,9 @@ type Allocator_Mode enum {
 	FREE_ALL,
 	RESIZE,
 }
-type Allocator_Proc proc(allocator_data: rawptr, mode: Allocator_Mode,
-                         size, alignment: int,
-                         old_memory: rawptr, old_size: int, flags: u64) -> rawptr;
+type Allocator_Proc proc(allocator_data rawptr, mode Allocator_Mode,
+                         size, alignment int,
+                         old_memory rawptr, old_size int, flags u64) -> rawptr;
 
 
 
@@ -140,10 +140,10 @@ type Context struct #ordered {
 	user_index: int;
 }
 
-#thread_local __context: Context;
+#thread_local var __context Context;
 
 
-DEFAULT_ALIGNMENT :: align_of([vector 4]f32);
+const DEFAULT_ALIGNMENT = align_of([vector 4]f32);
 
 
 proc __check_context() {
@@ -157,15 +157,15 @@ proc __check_context() {
 	}
 }
 
-proc alloc(size: int) -> rawptr #inline { return alloc_align(size, DEFAULT_ALIGNMENT); }
+proc alloc(size int) -> rawptr #inline { return alloc_align(size, DEFAULT_ALIGNMENT); }
 
-proc alloc_align(size, alignment: int) -> rawptr #inline {
+proc alloc_align(size, alignment int) -> rawptr #inline {
 	__check_context();
 	a := context.allocator;
 	return a.procedure(a.data, Allocator_Mode.ALLOC, size, alignment, nil, 0, 0);
 }
 
-proc free(ptr: rawptr) #inline {
+proc free(ptr rawptr) #inline {
 	__check_context();
 	a := context.allocator;
 	if ptr != nil {
@@ -179,8 +179,8 @@ proc free_all() #inline {
 }
 
 
-proc resize      (ptr: rawptr, old_size, new_size: int) -> rawptr #inline { return resize_align(ptr, old_size, new_size, DEFAULT_ALIGNMENT); }
-proc resize_align(ptr: rawptr, old_size, new_size, alignment: int) -> rawptr #inline {
+proc resize      (ptr rawptr, old_size, new_size int) -> rawptr #inline { return resize_align(ptr, old_size, new_size, DEFAULT_ALIGNMENT); }
+proc resize_align(ptr rawptr, old_size, new_size, alignment int) -> rawptr #inline {
 	__check_context();
 	a := context.allocator;
 	return a.procedure(a.data, Allocator_Mode.RESIZE, new_size, alignment, ptr, old_size, 0);
@@ -188,7 +188,7 @@ proc resize_align(ptr: rawptr, old_size, new_size, alignment: int) -> rawptr #in
 
 
 
-proc default_resize_align(old_memory: rawptr, old_size, new_size, alignment: int) -> rawptr {
+proc default_resize_align(old_memory rawptr, old_size, new_size, alignment int) -> rawptr {
 	if old_memory == nil {
 		return alloc_align(new_size, alignment);
 	}
@@ -213,9 +213,9 @@ proc default_resize_align(old_memory: rawptr, old_size, new_size, alignment: int
 }
 
 
-proc default_allocator_proc(allocator_data: rawptr, mode: Allocator_Mode,
-                               size, alignment: int,
-                               old_memory: rawptr, old_size: int, flags: u64) -> rawptr {
+proc default_allocator_proc(allocator_data rawptr, mode Allocator_Mode,
+                            size, alignment int,
+                            old_memory rawptr, old_size int, flags u64) -> rawptr {
 	using Allocator_Mode;
 	when false {
 		match mode {
@@ -279,7 +279,7 @@ proc default_allocator() -> Allocator {
 
 
 
-proc __string_eq(a, b: string) -> bool {
+proc __string_eq(a, b string) -> bool {
 	if a.count != b.count {
 		return false;
 	}
@@ -289,25 +289,24 @@ proc __string_eq(a, b: string) -> bool {
 	return mem.compare(a.data, b.data, a.count) == 0;
 }
 
-proc __string_cmp(a, b : string) -> int {
+proc __string_cmp(a, b string) -> int {
 	return mem.compare(a.data, b.data, min(a.count, b.count));
 }
 
-proc __string_ne(a, b: string) -> bool #inline { return !__string_eq(a, b); }
-proc __string_lt(a, b: string) -> bool #inline { return __string_cmp(a, b) < 0; }
-proc __string_gt(a, b: string) -> bool #inline { return __string_cmp(a, b) > 0; }
-proc __string_le(a, b: string) -> bool #inline { return __string_cmp(a, b) <= 0; }
-proc __string_ge(a, b: string) -> bool #inline { return __string_cmp(a, b) >= 0; }
+proc __string_ne(a, b string) -> bool #inline { return !__string_eq(a, b); }
+proc __string_lt(a, b string) -> bool #inline { return __string_cmp(a, b) < 0; }
+proc __string_gt(a, b string) -> bool #inline { return __string_cmp(a, b) > 0; }
+proc __string_le(a, b string) -> bool #inline { return __string_cmp(a, b) <= 0; }
+proc __string_ge(a, b string) -> bool #inline { return __string_cmp(a, b) >= 0; }
 
 
-proc __assert(file: string, line, column: int, msg: string) #inline {
+proc __assert(file string, line, column int, msg string) #inline {
 	fmt.fprintf(os.stderr, "%(%:%) Runtime assertion: %\n",
 	            file, line, column, msg);
 	__debug_trap();
 }
 
-proc __bounds_check_error(file: string, line, column: int,
-                             index, count: int) {
+proc __bounds_check_error(file string, line, column int, index, count int) {
 	if 0 <= index && index < count {
 		return;
 	}
@@ -316,8 +315,7 @@ proc __bounds_check_error(file: string, line, column: int,
 	__debug_trap();
 }
 
-proc __slice_expr_error(file: string, line, column: int,
-                           low, high, max: int) {
+proc __slice_expr_error(file string, line, column int, low, high, max int) {
 	if 0 <= low && low <= high && high <= max {
 		return;
 	}
@@ -325,8 +323,7 @@ proc __slice_expr_error(file: string, line, column: int,
 	            file, line, column, low, high, max);
 	__debug_trap();
 }
-proc __substring_expr_error(file: string, line, column: int,
-                               low, high: int) {
+proc __substring_expr_error(file string, line, column int, low, high int) {
 	if 0 <= low && low <= high {
 		return;
 	}
@@ -335,7 +332,7 @@ proc __substring_expr_error(file: string, line, column: int,
 	__debug_trap();
 }
 
-proc __enum_to_string(info: ^Type_Info, value: i64) -> string {
+proc __enum_to_string(info ^Type_Info, value i64) -> string {
 	match type ti : type_info_base(info) {
 	case Type_Info.Enum:
 		// TODO(bill): Search faster than linearly

core/atomic.odin

@@ -11,30 +11,30 @@ proc sfence      () { win32.WriteBarrier(); }
 proc lfence      () { win32.ReadBarrier(); }
 
 
-proc load32(a: ^i32) -> i32 {
+proc load32(a ^i32) -> i32 {
 	return a^;
 }
-proc store32(a: ^i32, value: i32) {
+proc store32(a ^i32, value i32) {
 	a^ = value;
 }
-proc compare_exchange32(a: ^i32, expected, desired: i32) -> i32 {
+proc compare_exchange32(a ^i32, expected, desired i32) -> i32 {
 	return win32.InterlockedCompareExchange(a, desired, expected);
 }
-proc exchanged32(a: ^i32, desired: i32) -> i32 {
+proc exchanged32(a ^i32, desired i32) -> i32 {
 	return win32.InterlockedExchange(a, desired);
 }
-proc fetch_add32(a: ^i32, operand: i32) -> i32 {
+proc fetch_add32(a ^i32, operand i32) -> i32 {
 	return win32.InterlockedExchangeAdd(a, operand);
 
 }
-proc fetch_and32(a: ^i32, operand: i32) -> i32 {
+proc fetch_and32(a ^i32, operand i32) -> i32 {
 	return win32.InterlockedAnd(a, operand);
 
 }
-proc fetch_or32(a: ^i32, operand: i32) -> i32 {
+proc fetch_or32(a ^i32, operand i32) -> i32 {
 	return win32.InterlockedOr(a, operand);
 }
-proc spin_lock32(a: ^i32, time_out: int) -> bool { // NOTE(bill): time_out = -1 as default
+proc spin_lock32(a ^i32, time_out int) -> bool { // NOTE(bill) time_out = -1 as default
 	old_value := compare_exchange32(a, 1, 0);
 	counter := 0;
 	for old_value != 0 && (time_out < 0 || counter < time_out) {
@@ -45,11 +45,11 @@ proc spin_lock32(a: ^i32, time_out: int) -> bool { // NOTE(bill): time_out = -1
 	}
 	return old_value == 0;
 }
-proc spin_unlock32(a: ^i32) {
+proc spin_unlock32(a ^i32) {
 	store32(a, 0);
 	mfence();
 }
-proc try_acquire_lock32(a: ^i32) -> bool {
+proc try_acquire_lock32(a ^i32) -> bool {
 	yield_thread();
 	old_value := compare_exchange32(a, 1, 0);
 	mfence();
@@ -57,28 +57,28 @@ proc try_acquire_lock32(a: ^i32) -> bool {
 }
 
 
-proc load64(a: ^i64) -> i64 {
+proc load64(a ^i64) -> i64 {
 	return a^;
 }
-proc store64(a: ^i64, value: i64) {
+proc store64(a ^i64, value i64) {
 	a^ = value;
 }
-proc compare_exchange64(a: ^i64, expected, desired: i64) -> i64 {
+proc compare_exchange64(a ^i64, expected, desired i64) -> i64 {
 	return win32.InterlockedCompareExchange64(a, desired, expected);
 }
-proc exchanged64(a: ^i64, desired: i64) -> i64 {
+proc exchanged64(a ^i64, desired i64) -> i64 {
 	return win32.InterlockedExchange64(a, desired);
 }
-proc fetch_add64(a: ^i64, operand: i64) -> i64 {
+proc fetch_add64(a ^i64, operand i64) -> i64 {
 	return win32.InterlockedExchangeAdd64(a, operand);
 }
-proc fetch_and64(a: ^i64, operand: i64) -> i64 {
+proc fetch_and64(a ^i64, operand i64) -> i64 {
 	return win32.InterlockedAnd64(a, operand);
 }
-proc fetch_or64(a: ^i64, operand: i64) -> i64 {
+proc fetch_or64(a ^i64, operand i64) -> i64 {
 	return win32.InterlockedOr64(a, operand);
 }
-proc spin_lock64(a: ^i64, time_out: int) -> bool { // NOTE(bill): time_out = -1 as default
+proc spin_lock64(a ^i64, time_out int) -> bool { // NOTE(bill) time_out = -1 as default
 	old_value := compare_exchange64(a, 1, 0);
 	counter := 0;
 	for old_value != 0 && (time_out < 0 || counter < time_out) {
@@ -89,11 +89,11 @@ proc spin_lock64(a: ^i64, time_out: int) -> bool { // NOTE(bill): time_out = -1
 	}
 	return old_value == 0;
 }
-proc spin_unlock64(a: ^i64) {
+proc spin_unlock64(a ^i64) {
 	store64(a, 0);
 	mfence();
 }
-proc try_acquire_lock64(a: ^i64) -> bool {
+proc try_acquire_lock64(a ^i64) -> bool {
 	yield_thread();
 	old_value := compare_exchange64(a, 1, 0);
 	mfence();

core/fmt.odin

@@ -2,9 +2,9 @@
 #import "mem.odin";
 #import "utf8.odin";
 
-PRINT_BUF_SIZE :: 1<<12;
+const PRINT_BUF_SIZE = 1<<12;
 
-proc fprint(f: ^os.File, args: ..any) -> int {
+proc fprint(f ^os.File, args ..any) -> int {
 	data: [PRINT_BUF_SIZE]byte;
 	buf := data[:0];
 	bprint(^buf, ..args);
@@ -12,14 +12,14 @@ proc fprint(f: ^os.File, args: ..any) -> int {
 	return buf.count;
 }
 
-proc fprintln(f: ^os.File, args: ..any) -> int {
+proc fprintln(f ^os.File, args ..any) -> int {
 	data: [PRINT_BUF_SIZE]byte;
 	buf := data[:0];
 	bprintln(^buf, ..args);
 	os.write(f, buf);
 	return buf.count;
 }
-proc fprintf(f: ^os.File, fmt: string, args: ..any) -> int {
+proc fprintf(f ^os.File, fmt string, args ..any) -> int {
 	data: [PRINT_BUF_SIZE]byte;
 	buf := data[:0];
 	bprintf(^buf, fmt, ..args);
@@ -28,19 +28,19 @@ proc fprintf(f: ^os.File, fmt: string, args: ..any) -> int {
 }
 
 
-proc print(args: ..any) -> int {
+proc print(args ..any) -> int {
 	return fprint(os.stdout, ..args);
 }
-proc println(args: ..any) -> int {
+proc println(args ..any) -> int {
 	return fprintln(os.stdout, ..args);
 }
-proc printf(fmt: string, args: ..any) -> int {
+proc printf(fmt string, args ..any) -> int {
 	return fprintf(os.stdout, fmt, ..args);
 }
 
 
 
-proc fprint_type(f: ^os.File, info: ^Type_Info) {
+proc fprint_type(f ^os.File, info ^Type_Info) {
 	data: [PRINT_BUF_SIZE]byte;
 	buf := data[:0];
 	bprint_type(^buf, info);
@@ -49,7 +49,7 @@ proc fprint_type(f: ^os.File, info: ^Type_Info) {
 
 
 
-proc print_byte_buffer(buf: ^[]byte, b: []byte) {
+proc print_byte_buffer(buf ^[]byte, b []byte) {
 	if buf.count < buf.capacity {
 		n := min(buf.capacity-buf.count, b.count);
 		if n > 0 {
@@ -59,29 +59,29 @@ proc print_byte_buffer(buf: ^[]byte, b: []byte) {
 	}
 }
 
-proc bprint_string(buf: ^[]byte, s: string) {
+proc bprint_string(buf ^[]byte, s string) {
 	print_byte_buffer(buf, s as []byte);
 }
 
 
-proc byte_reverse(b: []byte) {
+proc byte_reverse(b []byte) {
 	n := b.count;
 	for i := 0; i < n/2; i++ {
 		b[i], b[n-1-i] = b[n-1-i], b[i];
 	}
 }
 
-proc bprint_rune(buf: ^[]byte, r: rune) {
+proc bprint_rune(buf ^[]byte, r rune) {
 	b, n := utf8.encode_rune(r);
 	bprint_string(buf, b[:n] as string);
 }
 
-proc bprint_space(buf: ^[]byte) { bprint_rune(buf, ' '); }
-proc bprint_nl   (buf: ^[]byte) { bprint_rune(buf, '\n'); }
+proc bprint_space(buf ^[]byte) { bprint_rune(buf, ' '); }
+proc bprint_nl   (buf ^[]byte) { bprint_rune(buf, '\n'); }
 
 __NUM_TO_CHAR_TABLE := "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz@$";
 
-proc bprint_bool(buffer: ^[]byte, b : bool) {
+proc bprint_bool(buffer ^[]byte, b bool) {
 	if b {
 		bprint_string(buffer, "true");
 	} else {
@@ -89,15 +89,15 @@ proc bprint_bool(buffer: ^[]byte, b : bool) {
 	}
 }
 
-proc bprint_pointer(buffer: ^[]byte, p: rawptr) #inline {
+proc bprint_pointer(buffer ^[]byte, p rawptr) #inline {
 	bprint_string(buffer, "0x");
 	bprint_u64(buffer, p as uint as u64);
 }
 
-proc bprint_f16 (buffer: ^[]byte, f: f32)  #inline { print__f64(buffer, f as f64, 4); }
-proc bprint_f32 (buffer: ^[]byte, f: f32)  #inline { print__f64(buffer, f as f64, 7); }
-proc bprint_f64 (buffer: ^[]byte, f: f64)  #inline { print__f64(buffer, f as f64, 16); }
-proc bprint_u64(buffer: ^[]byte, value: u64) {
+proc bprint_f16 (buffer ^[]byte, f f32)  #inline { print__f64(buffer, f as f64, 4); }
+proc bprint_f32 (buffer ^[]byte, f f32)  #inline { print__f64(buffer, f as f64, 7); }
+proc bprint_f64 (buffer ^[]byte, f f64)  #inline { print__f64(buffer, f as f64, 16); }
+proc bprint_u64(buffer ^[]byte, value u64) {
 	i := value;
 	buf: [20]byte;
 	len := 0;
@@ -113,7 +113,7 @@ proc bprint_u64(buffer: ^[]byte, value: u64) {
 	byte_reverse(buf[:len]);
 	bprint_string(buffer, buf[:len] as string);
 }
-proc bprint_i64(buffer: ^[]byte, value: i64) {
+proc bprint_i64(buffer ^[]byte, value i64) {
 	// TODO(bill): Cleanup printing
 	i := value;
 	if i < 0 {
@@ -124,14 +124,14 @@ proc bprint_i64(buffer: ^[]byte, value: i64) {
 }
 
 /*
-proc bprint_u128(buffer: ^[]byte, value: u128) {
+proc bprint_u128(buffer ^[]byte, value u128) {
 	a := value transmute [2]u64;
 	if a[1] != 0 {
 		bprint_u64(buffer, a[1]);
 	}
 	bprint_u64(buffer, a[0]);
 }
-proc bprint_i128(buffer: ^[]byte, value: i128) {
+proc bprint_i128(buffer ^[]byte, value i128) {
 	i := value;
 	if i < 0 {
 		i = -i;
@@ -142,7 +142,7 @@ proc bprint_i128(buffer: ^[]byte, value: i128) {
 */
 
 
-proc print__f64(buffer: ^[]byte, value: f64, decimal_places: int) {
+proc print__f64(buffer ^[]byte, value f64, decimal_places int) {
 	f := value;
 	if f == 0 {
 		bprint_rune(buffer, '0');
@@ -168,7 +168,7 @@ proc print__f64(buffer: ^[]byte, value: f64, decimal_places: int) {
 	}
 }
 
-proc bprint_type(buf: ^[]byte, ti: ^Type_Info) {
+proc bprint_type(buf ^[]byte, ti ^Type_Info) {
 	if ti == nil {
 		return;
 	}
@@ -299,14 +299,14 @@ proc bprint_type(buf: ^[]byte, ti: ^Type_Info) {
 }
 
 
-proc make_any(type_info: ^Type_Info, data: rawptr) -> any {
+proc make_any(type_info ^Type_Info, data rawptr) -> any {
 	a: any;
 	a.type_info = type_info;
 	a.data = data;
 	return a;
 }
 
-proc bprint_any(buf: ^[]byte, arg: any) {
+proc bprint_any(buf ^[]byte, arg any) {
 	if arg.type_info == nil {
 		bprint_string(buf, "<nil>");
 		return;
@@ -435,7 +435,7 @@ proc bprint_any(buf: ^[]byte, arg: any) {
 		}
 
 	case Vector:
-		proc is_bool(type_info: ^Type_Info) -> bool {
+		proc is_bool(type_info ^Type_Info) -> bool {
 			match type info : type_info {
 			case Named:
 				return is_bool(info.base);
@@ -489,12 +489,12 @@ proc bprint_any(buf: ^[]byte, arg: any) {
 }
 
 
-proc bprintf(buf: ^[]byte, fmt: string, args: ..any) -> int {
-	proc is_digit(r: rune) -> bool #inline {
+proc bprintf(buf ^[]byte, fmt string, args ..any) -> int {
+	proc is_digit(r rune) -> bool #inline {
 		return '0' <= r && r <= '9';
 	}
 
-	proc parse_int(s: string, offset: int) -> (int, int) {
+	proc parse_int(s string, offset int) -> (int, int) {
 		result := 0;
 
 		for ; offset < s.count; offset++ {
@@ -554,8 +554,8 @@ proc bprintf(buf: ^[]byte, fmt: string, args: ..any) -> int {
 }
 
 
-proc bprint(buf: ^[]byte, args: ..any) -> int {
-	proc is_type_string(info: ^Type_Info) -> bool {
+proc bprint(buf ^[]byte, args ..any) -> int {
+	proc is_type_string(info ^Type_Info) -> bool {
 		using Type_Info;
 		if info == nil {
 			return false;
@@ -582,7 +582,7 @@ proc bprint(buf: ^[]byte, args: ..any) -> int {
 	return buf.count;
 }
 
-proc bprintln(buf: ^[]byte, args: ..any) -> int {
+proc bprintln(buf ^[]byte, args ..any) -> int {
 	for i := 0; i < args.count; i++ {
 		if i > 0 {
 			append(buf, ' ');

core/hash.odin

@@ -1,4 +1,4 @@
-proc crc32(data: rawptr, len: int) -> u32 {
+proc crc32(data rawptr, len int) -> u32 {
 	result := ~(0 as u32);
 	s := slice_ptr(data as ^u8, len);
 	for i := 0; i < len; i++ {
@@ -7,7 +7,7 @@ proc crc32(data: rawptr, len: int) -> u32 {
 	}
 	return ~result;
 }
-proc crc64(data: rawptr, len: int) -> u64 {
+proc crc64(data rawptr, len int) -> u64 {
 	result := ~(0 as u64);
 	s := slice_ptr(data as ^u8, len);
 	for i := 0; i < len; i++ {
@@ -17,7 +17,7 @@ proc crc64(data: rawptr, len: int) -> u64 {
 	return ~result;
 }
 
-proc fnv32(data: rawptr, len: int) -> u32 {
+proc fnv32(data rawptr, len int) -> u32 {
 	s := slice_ptr(data as ^u8, len);
 
 	h: u32 = 0x811c9dc5;
@@ -27,7 +27,7 @@ proc fnv32(data: rawptr, len: int) -> u32 {
 	return h;
 }
 
-proc fnv64(data: rawptr, len: int) -> u64 {
+proc fnv64(data rawptr, len int) -> u64 {
 	s := slice_ptr(data as ^u8, len);
 
 	h: u64 = 0xcbf29ce484222325;
@@ -37,7 +37,7 @@ proc fnv64(data: rawptr, len: int) -> u64 {
 	return h;
 }
 
-proc fnv32a(data: rawptr, len: int) -> u32 {
+proc fnv32a(data rawptr, len int) -> u32 {
 	s := slice_ptr(data as ^u8, len);
 
 	h: u32 = 0x811c9dc5;
@@ -47,7 +47,7 @@ proc fnv32a(data: rawptr, len: int) -> u32 {
 	return h;
 }
 
-proc fnv64a(data: rawptr, len: int) -> u64 {
+proc fnv64a(data rawptr, len int) -> u64 {
 	s := slice_ptr(data as ^u8, len);
 
 	h: u64 = 0xcbf29ce484222325;
@@ -58,12 +58,12 @@ proc fnv64a(data: rawptr, len: int) -> u64 {
 }
 
 
-proc murmur64(data_: rawptr, len: int) -> u64 {
-	SEED :: 0x9747b28c;
+proc murmur64(data_ rawptr, len int) -> u64 {
+	const SEED = 0x9747b28c;
 
 	when size_of(int) == 8 {
-		m :: 0xc6a4a7935bd1e995;
-		r :: 47;
+		const m = 0xc6a4a7935bd1e995;
+		const r = 47;
 
 		h: u64 = SEED ~ (len as u64 * m);
 
@@ -99,8 +99,8 @@ proc murmur64(data_: rawptr, len: int) -> u64 {
 
 		return h;
 	} else {
-		m :: 0x5bd1e995;
-		r :: 24;
+		const m = 0x5bd1e995;
+		const r = 24;
 
 		h1: u32 = SEED as u32 ~ len as u32;
 		h2: u32 = SEED >> 32;

core/math.odin

@@ -1,20 +1,20 @@
-TAU          :: 6.28318530717958647692528676655900576;
-PI           :: 3.14159265358979323846264338327950288;
-ONE_OVER_TAU :: 0.636619772367581343075535053490057448;
-ONE_OVER_PI  :: 0.159154943091895335768883763372514362;
+const TAU          = 6.28318530717958647692528676655900576;
+const PI           = 3.14159265358979323846264338327950288;
+const ONE_OVER_TAU = 0.636619772367581343075535053490057448;
+const ONE_OVER_PI  = 0.159154943091895335768883763372514362;
 
-E            :: 2.71828182845904523536;
-SQRT_TWO     :: 1.41421356237309504880168872420969808;
-SQRT_THREE   :: 1.73205080756887729352744634150587236;
-SQRT_FIVE    :: 2.23606797749978969640917366873127623;
+const E            = 2.71828182845904523536;
+const SQRT_TWO     = 1.41421356237309504880168872420969808;
+const SQRT_THREE   = 1.73205080756887729352744634150587236;
+const SQRT_FIVE    = 2.23606797749978969640917366873127623;
 
-LOG_TWO      :: 0.693147180559945309417232121458176568;
-LOG_TEN      :: 2.30258509299404568401799145468436421;
+const LOG_TWO      = 0.693147180559945309417232121458176568;
+const LOG_TEN      = 2.30258509299404568401799145468436421;
 
-EPSILON      :: 1.19209290e-7;
+const EPSILON      = 1.19209290e-7;
 
-τ :: TAU;
-π :: PI;
+const τ = TAU;
+const π = PI;
 
 
 type Vec2 [vector 2]f32;
@@ -26,57 +26,57 @@ type Mat3 [3]Vec3;
 type Mat4 [4]Vec4;
 
 
-proc sqrt32(x: f32) -> f32 #foreign "llvm.sqrt.f32"
-proc sqrt64(x: f64) -> f64 #foreign "llvm.sqrt.f64"
+proc sqrt32(x f32) -> f32 #foreign "llvm.sqrt.f32"
+proc sqrt64(x f64) -> f64 #foreign "llvm.sqrt.f64"
 
-proc sin32(x: f32) -> f32 #foreign "llvm.sin.f32"
-proc sin64(x: f64) -> f64 #foreign "llvm.sin.f64"
+proc sin32(x f32) -> f32 #foreign "llvm.sin.f32"
+proc sin64(x f64) -> f64 #foreign "llvm.sin.f64"
 
-proc cos32(x: f32) -> f32 #foreign "llvm.cos.f32"
-proc cos64(x: f64) -> f64 #foreign "llvm.cos.f64"
+proc cos32(x f32) -> f32 #foreign "llvm.cos.f32"
+proc cos64(x f64) -> f64 #foreign "llvm.cos.f64"
 
-proc tan32(x: f32) -> f32 #inline { return sin32(x)/cos32(x); }
-proc tan64(x: f64) -> f64 #inline { return sin64(x)/cos64(x); }
+proc tan32(x f32) -> f32 #inline { return sin32(x)/cos32(x); }
+proc tan64(x f64) -> f64 #inline { return sin64(x)/cos64(x); }
 
-proc lerp32(a, b, t: f32) -> f32 { return a*(1-t) + b*t; }
-proc lerp64(a, b, t: f64) -> f64 { return a*(1-t) + b*t; }
+proc lerp32(a, b, t f32) -> f32 { return a*(1-t) + b*t; }
+proc lerp64(a, b, t f64) -> f64 { return a*(1-t) + b*t; }
 
-proc sign32(x: f32) -> f32 { if x >= 0 { return +1; } return -1; }
-proc sign64(x: f64) -> f64 { if x >= 0 { return +1; } return -1; }
+proc sign32(x f32) -> f32 { if x >= 0 { return +1; } return -1; }
+proc sign64(x f64) -> f64 { if x >= 0 { return +1; } return -1; }
 
 
 
-proc copy_sign32(x, y: f32) -> f32 {
+proc copy_sign32(x, y f32) -> f32 {
 	ix := x transmute u32;
 	iy := y transmute u32;
 	ix &= 0x7fffffff;
 	ix |= iy & 0x80000000;
 	return ix transmute f32;
 }
-proc round32(x: f32) -> f32 {
+proc round32(x f32) -> f32 {
 	if x >= 0 {
 		return floor32(x + 0.5);
 	}
 	return ceil32(x - 0.5);
 }
-proc floor32(x: f32) -> f32 {
+proc floor32(x f32) -> f32 {
 	if x >= 0 {
 		return x as int as f32;
 	}
 	return (x-0.5) as int as f32;
 }
-proc ceil32(x: f32) -> f32 {
+proc ceil32(x f32) -> f32 {
 	if x < 0 {
 		return x as int as f32;
 	}
 	return ((x as int)+1) as f32;
 }
 
-proc remainder32(x, y: f32) -> f32 {
+proc remainder32(x, y f32) -> f32 {
 	return x - round32(x/y) * y;
 }
 
-proc fmod32(x, y: f32) -> f32 {
+proc fmod32(x, y f32) -> f32 {
 	y = abs(y);
 	result := remainder32(abs(x), y);
 	if sign32(result) < 0 {
@@ -86,32 +86,32 @@ proc fmod32(x, y: f32) -> f32 {
 }
 
 
-proc to_radians(degrees: f32) -> f32 { return degrees * TAU / 360; }
-proc to_degrees(radians: f32) -> f32 { return radians * 360 / TAU; }
+proc to_radians(degrees f32) -> f32 { return degrees * TAU / 360; }
+proc to_degrees(radians f32) -> f32 { return radians * 360 / TAU; }
 
 
 
 
-proc dot2(a, b: Vec2) -> f32 { c := a*b; return c.x + c.y; }
-proc dot3(a, b: Vec3) -> f32 { c := a*b; return c.x + c.y + c.z; }
-proc dot4(a, b: Vec4) -> f32 { c := a*b; return c.x + c.y + c.z + c.w; }
+proc dot2(a, b Vec2) -> f32 { c := a*b; return c.x + c.y; }
+proc dot3(a, b Vec3) -> f32 { c := a*b; return c.x + c.y + c.z; }
+proc dot4(a, b Vec4) -> f32 { c := a*b; return c.x + c.y + c.z + c.w; }
 
-proc cross3(x, y: Vec3) -> Vec3 {
+proc cross3(x, y Vec3) -> Vec3 {
 	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;
 }
 
 
-proc vec2_mag(v: Vec2) -> f32 { return sqrt32(dot2(v, v)); }
-proc vec3_mag(v: Vec3) -> f32 { return sqrt32(dot3(v, v)); }
-proc vec4_mag(v: Vec4) -> f32 { return sqrt32(dot4(v, v)); }
+proc vec2_mag(v Vec2) -> f32 { return sqrt32(dot2(v, v)); }
+proc vec3_mag(v Vec3) -> f32 { return sqrt32(dot3(v, v)); }
+proc vec4_mag(v Vec4) -> f32 { return sqrt32(dot4(v, v)); }
 
-proc vec2_norm(v: Vec2) -> Vec2 { return v / Vec2{vec2_mag(v)}; }
-proc vec3_norm(v: Vec3) -> Vec3 { return v / Vec3{vec3_mag(v)}; }
-proc vec4_norm(v: Vec4) -> Vec4 { return v / Vec4{vec4_mag(v)}; }
+proc vec2_norm(v Vec2) -> Vec2 { return v / Vec2{vec2_mag(v)}; }
+proc vec3_norm(v Vec3) -> Vec3 { return v / Vec3{vec3_mag(v)}; }
+proc vec4_norm(v Vec4) -> Vec4 { return v / Vec4{vec4_mag(v)}; }
 
-proc vec2_norm0(v: Vec2) -> Vec2 {
+proc vec2_norm0(v Vec2) -> Vec2 {
 	m := vec2_mag(v);
 	if m == 0 {
 		return Vec2{0};
@@ -119,7 +119,7 @@ proc vec2_norm0(v: Vec2) -> Vec2 {
 	return v / Vec2{m};
 }
 
-proc vec3_norm0(v: Vec3) -> Vec3 {
+proc vec3_norm0(v Vec3) -> Vec3 {
 	m := vec3_mag(v);
 	if m == 0 {
 		return Vec3{0};
@@ -127,7 +127,7 @@ proc vec3_norm0(v: Vec3) -> Vec3 {
 	return v / Vec3{m};
 }
 
-proc vec4_norm0(v: Vec4) -> Vec4 {
+proc vec4_norm0(v Vec4) -> Vec4 {
 	m := vec4_mag(v);
 	if m == 0 {
 		return Vec4{0};
@@ -146,7 +146,7 @@ proc mat4_identity() -> Mat4 {
 	};
 }
 
-proc mat4_transpose(m: Mat4) -> Mat4 {
+proc mat4_transpose(m Mat4) -> Mat4 {
 	for j := 0; j < 4; j++ {
 		for i := 0; i < 4; i++ {
 			m[i][j], m[j][i] = m[j][i], m[i][j];
@@ -155,7 +155,7 @@ proc mat4_transpose(m: Mat4) -> Mat4 {
 	return m;
 }
 
-proc mat4_mul(a, b: Mat4) -> Mat4 {
+proc mat4_mul(a, b Mat4) -> Mat4 {
 	c: Mat4;
 	for j := 0; j < 4; j++ {
 		for i := 0; i < 4; i++ {
@@ -168,7 +168,7 @@ proc mat4_mul(a, b: Mat4) -> Mat4 {
 	return c;
 }
 
-proc mat4_mul_vec4(m: Mat4, v: Vec4) -> Vec4 {
+proc mat4_mul_vec4(m Mat4, v Vec4) -> Vec4 {
 	return Vec4{
 		m[0][0]*v.x + m[1][0]*v.y + m[2][0]*v.z + m[3][0]*v.w,
 		m[0][1]*v.x + m[1][1]*v.y + m[2][1]*v.z + m[3][1]*v.w,
@@ -177,7 +177,7 @@ proc mat4_mul_vec4(m: Mat4, v: Vec4) -> Vec4 {
 	};
 }
 
-proc mat4_inverse(m: Mat4) -> Mat4 {
+proc mat4_inverse(m Mat4) -> Mat4 {
 	o: Mat4;
 
 	sf00 := m[2][2] * m[3][3] - m[3][2] * m[2][3];
@@ -246,7 +246,7 @@ proc mat4_inverse(m: Mat4) -> Mat4 {
 }
 
 
-proc mat4_translate(v: Vec3) -> Mat4 {
+proc mat4_translate(v Vec3) -> Mat4 {
 	m := mat4_identity();
 	m[3][0] = v.x;
 	m[3][1] = v.y;
@@ -255,7 +255,7 @@ proc mat4_translate(v: Vec3) -> Mat4 {
 	return m;
 }
 
-proc mat4_rotate(v: Vec3, angle_radians: f32) -> Mat4 {
+proc mat4_rotate(v Vec3, angle_radians f32) -> Mat4 {
 	c := cos32(angle_radians);
 	s := sin32(angle_radians);
 
@@ -282,14 +282,14 @@ proc mat4_rotate(v: Vec3, angle_radians: f32) -> Mat4 {
 	return rot;
 }
 
-proc mat4_scale(m: Mat4, v: Vec3) -> Mat4 {
+proc mat4_scale(m Mat4, v Vec3) -> Mat4 {
 	m[0][0] *= v.x;
 	m[1][1] *= v.y;
 	m[2][2] *= v.z;
 	return m;
 }
 
-proc mat4_scalef(m: Mat4, s: f32) -> Mat4 {
+proc mat4_scalef(m Mat4, s f32) -> Mat4 {
 	m[0][0] *= s;
 	m[1][1] *= s;
 	m[2][2] *= s;
@@ -297,7 +297,7 @@ proc mat4_scalef(m: Mat4, s: f32) -> Mat4 {
 }
 
 
-proc mat4_look_at(eye, centre, up: Vec3) -> Mat4 {
+proc mat4_look_at(eye, centre, up Vec3) -> Mat4 {
 	f := vec3_norm(centre - eye);
 	s := vec3_norm(cross3(f, up));
 	u := cross3(s, f);
@@ -311,7 +311,7 @@ proc mat4_look_at(eye, centre, up: Vec3) -> Mat4 {
 
 	return m;
 }
-proc mat4_perspective(fovy, aspect, near, far: f32) -> Mat4 {
+proc mat4_perspective(fovy, aspect, near, far f32) -> Mat4 {
 	m: Mat4;
 	tan_half_fovy := tan32(0.5 * fovy);
 	m[0][0] = 1.0 / (aspect*tan_half_fovy);
@@ -323,7 +323,7 @@ proc mat4_perspective(fovy, aspect, near, far: f32) -> Mat4 {
 }
 
 
-proc mat4_ortho3d(left, right, bottom, top, near, far: f32) -> Mat4 {
+proc mat4_ortho3d(left, right, bottom, top, near, far f32) -> Mat4 {
 	m := mat4_identity();
 	m[0][0] = +2.0 / (right - left);
 	m[1][1] = +2.0 / (top - bottom);
@@ -338,31 +338,31 @@ proc mat4_ortho3d(left, right, bottom, top, near, far: f32) -> Mat4 {
 
 
 
-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
+const F32_DIG        = 6;
+const F32_EPSILON    = 1.192092896e-07;
+const F32_GUARD      = 0;
+const F32_MANT_DIG   = 24;
+const F32_MAX        = 3.402823466e+38;
+const F32_MAX_10_EXP = 38;
+const F32_MAX_EXP    = 128;
+const F32_MIN        = 1.175494351e-38;
+const F32_MIN_10_EXP = -37;
+const F32_MIN_EXP    = -125;
+const F32_NORMALIZE  = 0;
+const F32_RADIX      = 2;
+const F32_ROUNDS     = 1;
+
+const F64_DIG        = 15;                       // # of decimal digits of precision
+const F64_EPSILON    = 2.2204460492503131e-016;  // smallest such that 1.0+F64_EPSILON != 1.0
+const F64_MANT_DIG   = 53;                       // # of bits in mantissa
+const F64_MAX        = 1.7976931348623158e+308;  // max value
+const F64_MAX_10_EXP = 308;                      // max decimal exponent
+const F64_MAX_EXP    = 1024;                     // max binary exponent
+const F64_MIN        = 2.2250738585072014e-308;  // min positive value
+const F64_MIN_10_EXP = -307;                     // min decimal exponent
+const F64_MIN_EXP    = -1021;                    // min binary exponent
+const F64_RADIX      = 2;                        // exponent radix
+const F64_ROUNDS     = 1;                        // addition rounding: near
 
 
 

core/mem.odin

@@ -1,32 +1,32 @@
 #import "fmt.odin";
 #import "os.odin";
 
-proc set(data: rawptr, value: i32, len: int) -> rawptr #link_name "__mem_set" {
-	proc llvm_memset_64bit(dst: rawptr, val: byte, len: int, align: i32, is_volatile: bool) #foreign "llvm.memset.p0i8.i64"
+proc set(data rawptr, value i32, len int) -> rawptr #link_name "__mem_set" {
+	proc llvm_memset_64bit(dst rawptr, val byte, len int, align i32, is_volatile bool) #foreign "llvm.memset.p0i8.i64"
 	llvm_memset_64bit(data, value as byte, len, 1, false);
 	return data;
 }
 
-proc zero(data: rawptr, len: int) -> rawptr #link_name "__mem_zero" {
+proc zero(data rawptr, len int) -> rawptr #link_name "__mem_zero" {
 	return set(data, 0, len);
 }
 
-proc copy(dst, src: rawptr, len: int) -> rawptr #link_name "__mem_copy" {
+proc copy(dst, src rawptr, len int) -> rawptr #link_name "__mem_copy" {
 	// NOTE(bill): This _must_ implemented like C's memmove
-	proc llvm_memmove_64bit(dst, src: rawptr, len: int, align: i32, is_volatile: bool) #foreign "llvm.memmove.p0i8.p0i8.i64"
+	proc llvm_memmove_64bit(dst, src rawptr, len int, align i32, is_volatile bool) #foreign "llvm.memmove.p0i8.p0i8.i64"
 	llvm_memmove_64bit(dst, src, len, 1, false);
 	return dst;
 }
 
-proc copy_non_overlapping(dst, src: rawptr, len: int) -> rawptr #link_name "__mem_copy_non_overlapping" {
+proc copy_non_overlapping(dst, src rawptr, len int) -> rawptr #link_name "__mem_copy_non_overlapping" {
 	// NOTE(bill): This _must_ implemented like C's memcpy
-	proc llvm_memcpy_64bit(dst, src: rawptr, len: int, align: i32, is_volatile: bool) #foreign "llvm.memcpy.p0i8.p0i8.i64"
+	proc llvm_memcpy_64bit(dst, src rawptr, len int, align i32, is_volatile bool) #foreign "llvm.memcpy.p0i8.p0i8.i64"
 	llvm_memcpy_64bit(dst, src, len, 1, false);
 	return dst;
 }
 
 
-proc compare(dst, src: rawptr, n: int) -> int #link_name "__mem_compare" {
+proc compare(dst, src rawptr, n int) -> int #link_name "__mem_compare" {
 	// Translation of http://mgronhol.github.io/fast-strcmp/
 	a := slice_ptr(dst as ^byte, n);
 	b := slice_ptr(src as ^byte, n);
@@ -63,19 +63,19 @@ proc compare(dst, src: rawptr, n: int) -> int #link_name "__mem_compare" {
 
 
 
-proc kilobytes(x: int) -> int #inline { return          (x) * 1024; }
-proc megabytes(x: int) -> int #inline { return kilobytes(x) * 1024; }
-proc gigabytes(x: int) -> int #inline { return gigabytes(x) * 1024; }
-proc terabytes(x: int) -> int #inline { return terabytes(x) * 1024; }
+proc kilobytes(x int) -> int #inline { return          (x) * 1024; }
+proc megabytes(x int) -> int #inline { return kilobytes(x) * 1024; }
+proc gigabytes(x int) -> int #inline { return gigabytes(x) * 1024; }
+proc terabytes(x int) -> int #inline { return terabytes(x) * 1024; }
 
-proc is_power_of_two(x: int) -> bool {
+proc is_power_of_two(x int) -> bool {
 	if x <= 0 {
 		return false;
 	}
 	return (x & (x-1)) == 0;
 }
 
-proc align_forward(ptr: rawptr, align: int) -> rawptr {
+proc align_forward(ptr rawptr, align int) -> rawptr {
 	assert(is_power_of_two(align));
 
 	a := align as uint;
@@ -92,7 +92,7 @@ proc align_forward(ptr: rawptr, align: int) -> rawptr {
 type Allocation_Header struct {
 	size: int;
 }
-proc allocation_header_fill(header: ^Allocation_Header, data: rawptr, size: int) {
+proc allocation_header_fill(header ^Allocation_Header, data rawptr, size int) {
 	header.size = size;
 	ptr := (header+1) as ^int;
 
@@ -100,7 +100,7 @@ proc allocation_header_fill(header: ^Allocation_Header, data: rawptr, size: int)
 		(ptr+i)^ = -1;
 	}
 }
-proc allocation_header(data: rawptr) -> ^Allocation_Header {
+proc allocation_header(data rawptr) -> ^Allocation_Header {
 	p := data as ^int;
 	for (p-1)^ == -1 {
 		p = (p-1);
@@ -129,19 +129,19 @@ type Arena_Temp_Memory struct {
 
 
 
-proc init_arena_from_memory(using a: ^Arena, data: []byte) {
+proc init_arena_from_memory(using a ^Arena, data []byte) {
 	backing    = Allocator{};
 	memory     = data[:0];
 	temp_count = 0;
 }
 
-proc init_arena_from_context(using a: ^Arena, size: int) {
+proc init_arena_from_context(using a ^Arena, size int) {
 	backing = context.allocator;
 	memory = new_slice(byte, 0, size);
 	temp_count = 0;
 }
 
-proc free_arena(using a: ^Arena) {
+proc free_arena(using a ^Arena) {
 	if backing.procedure != nil {
 		push_allocator backing {
 			free(memory.data);
@@ -150,16 +150,16 @@ proc free_arena(using a: ^Arena) {
 	}
 }
 
-proc arena_allocator(arena: ^Arena) -> Allocator {
+proc arena_allocator(arena ^Arena) -> Allocator {
 	return Allocator{
 		procedure = arena_allocator_proc,
 		data = arena,
 	};
 }
 
-proc arena_allocator_proc(allocator_data: rawptr, mode: Allocator_Mode,
-                             size, alignment: int,
-                             old_memory: rawptr, old_size: int, flags: u64) -> rawptr {
+proc arena_allocator_proc(allocator_data rawptr, mode Allocator_Mode,
+                          size, alignment int,
+                          old_memory rawptr, old_size int, flags u64) -> rawptr {
 	arena := allocator_data as ^Arena;
 
 	using Allocator_Mode;
@@ -192,7 +192,7 @@ proc arena_allocator_proc(allocator_data: rawptr, mode: Allocator_Mode,
 	return nil;
 }
 
-proc begin_arena_temp_memory(a: ^Arena) -> Arena_Temp_Memory {
+proc begin_arena_temp_memory(a ^Arena) -> Arena_Temp_Memory {
 	tmp: Arena_Temp_Memory;
 	tmp.arena = a;
 	tmp.original_count = a.memory.count;
@@ -200,7 +200,7 @@ proc begin_arena_temp_memory(a: ^Arena) -> Arena_Temp_Memory {
 	return tmp;
 }
 
-proc end_arena_temp_memory(using tmp: Arena_Temp_Memory) {
+proc end_arena_temp_memory(using tmp Arena_Temp_Memory) {
 	assert(arena.memory.count >= original_count);
 	assert(arena.temp_count > 0);
 	arena.memory.count = original_count;
@@ -213,8 +213,8 @@ proc end_arena_temp_memory(using tmp: Arena_Temp_Memory) {
 
 
 
-proc align_of_type_info(type_info: ^Type_Info) -> int {
-	proc prev_pow2(n: i64) -> i64 {
+proc align_of_type_info(type_info ^Type_Info) -> int {
+	proc prev_pow2(n i64) -> i64 {
 		if n <= 0 {
 			return 0;
 		}
@@ -227,8 +227,8 @@ proc align_of_type_info(type_info: ^Type_Info) -> int {
 		return n - (n >> 1);
 	}
 
-	WORD_SIZE :: size_of(int);
-	MAX_ALIGN :: size_of([vector 64]f64); // TODO(bill): Should these constants be builtin constants?
+	const WORD_SIZE = size_of(int);
+	const MAX_ALIGN = size_of([vector 64]f64); // TODO(bill): Should these constants be builtin constants?
 	using Type_Info;
 
 	match type info : type_info {
@@ -270,13 +270,13 @@ proc align_of_type_info(type_info: ^Type_Info) -> int {
 	return 0;
 }
 
-proc align_formula(size, align: int) -> int {
+proc align_formula(size, align int) -> int {
 	result := size + align-1;
 	return result - result%align;
 };
 
-proc size_of_type_info(type_info: ^Type_Info) -> int {
-	WORD_SIZE :: size_of(int);
+proc size_of_type_info(type_info ^Type_Info) -> int {
+	const WORD_SIZE = size_of(int);
 	using Type_Info;
 	match type info : type_info {
 	case Named:
@@ -309,7 +309,7 @@ proc size_of_type_info(type_info: ^Type_Info) -> int {
 	case Slice:
 		return 3*WORD_SIZE;
 	case Vector:
-		proc is_bool(type_info: ^Type_Info) -> bool {
+		proc is_bool(type_info ^Type_Info) -> bool {
 			match type info : type_info {
 			case Named:
 				return is_bool(info.base);

core/opengl.odin

@@ -2,37 +2,37 @@
 #import win32 "sys/windows.odin" when ODIN_OS == "windows";
 #include "opengl_constants.odin";
 
-proc Clear         (mask: u32)                                #foreign "glClear"
-proc ClearColor    (r, g, b, a: f32)                          #foreign "glClearColor"
-proc Begin         (mode: i32)                                #foreign "glBegin"
-proc End           ()                                         #foreign "glEnd"
-proc Finish        ()                                         #foreign "glFinish"
-proc BlendFunc     (sfactor, dfactor: i32)                    #foreign "glBlendFunc"
-proc Enable        (cap: i32)                                 #foreign "glEnable"
-proc Disable       (cap: i32)                                 #foreign "glDisable"
-proc GenTextures   (count: i32, result: ^u32)                 #foreign "glGenTextures"
-proc DeleteTextures(count: i32, result: ^u32)                 #foreign "glDeleteTextures"
-proc TexParameteri (target, pname, param: i32)                #foreign "glTexParameteri"
-proc TexParameterf (target: i32, pname: i32, param: f32)      #foreign "glTexParameterf"
-proc BindTexture   (target: i32, texture: u32)                #foreign "glBindTexture"
-proc LoadIdentity  ()                                         #foreign "glLoadIdentity"
-proc Viewport      (x, y, width, height: i32)                 #foreign "glViewport"
-proc Ortho         (left, right, bottom, top, near, far: f64) #foreign "glOrtho"
-proc Color3f       (r, g, b: f32)                             #foreign "glColor3f"
-proc Vertex3f      (x, y, z: f32)                             #foreign "glVertex3f"
+proc Clear         (mask u32)                                #foreign "glClear"
+proc ClearColor    (r, g, b, a f32)                          #foreign "glClearColor"
+proc Begin         (mode i32)                                #foreign "glBegin"
+proc End           ()                                        #foreign "glEnd"
+proc Finish        ()                                        #foreign "glFinish"
+proc BlendFunc     (sfactor, dfactor i32)                    #foreign "glBlendFunc"
+proc Enable        (cap i32)                                 #foreign "glEnable"
+proc Disable       (cap i32)                                 #foreign "glDisable"
+proc GenTextures   (count i32, result ^u32)                  #foreign "glGenTextures"
+proc DeleteTextures(count i32, result ^u32)                  #foreign "glDeleteTextures"
+proc TexParameteri (target, pname, param i32)                #foreign "glTexParameteri"
+proc TexParameterf (target i32, pname i32, param f32)        #foreign "glTexParameterf"
+proc BindTexture   (target i32, texture u32)                 #foreign "glBindTexture"
+proc LoadIdentity  ()                                        #foreign "glLoadIdentity"
+proc Viewport      (x, y, width, height i32)                 #foreign "glViewport"
+proc Ortho         (left, right, bottom, top, near, far f64) #foreign "glOrtho"
+proc Color3f       (r, g, b f32)                             #foreign "glColor3f"
+proc Vertex3f      (x, y, z f32)                             #foreign "glVertex3f"
 proc TexImage2D    (target, level, internal_format,
                     width, height, border,
-                    format, _type: i32, pixels: rawptr) #foreign "glTexImage2D"
+                    format, _type i32, pixels rawptr) #foreign "glTexImage2D"
 
 proc GetError   () -> i32            #foreign "glGetError"
-proc GetString  (name: i32) -> ^byte #foreign "glGetString"
-proc GetIntegerv(name: i32, v: ^i32) #foreign "glGetIntegerv"
+proc GetString  (name i32) -> ^byte #foreign "glGetString"
+proc GetIntegerv(name i32, v ^i32) #foreign "glGetIntegerv"
 
 
 
 _libgl := win32.LoadLibraryA(("opengl32.dll\x00" as string).data);
 
-proc GetProcAddress(name: string) -> proc() {
+proc GetProcAddress(name string) -> proc() {
 	assert(name[name.count-1] == 0);
 	res := win32.wglGetProcAddress(name.data);
 	if res == nil {
@@ -42,66 +42,66 @@ proc GetProcAddress(name: string) -> proc() {
 }
 
 
-GenBuffers:      proc(count: i32, buffers: ^u32);
-GenVertexArrays: proc(count: i32, buffers: ^u32);
-GenSamplers:     proc(count: i32, buffers: ^u32);
-BindBuffer:      proc(target: i32, buffer: u32);
-BindVertexArray: proc(buffer: u32);
-BindSampler:     proc(position: i32, sampler: u32);
-BufferData:      proc(target: i32, size: int, data: rawptr, usage: i32);
-BufferSubData:   proc(target: i32, offset, size: int, data: rawptr);
+GenBuffers:      proc(count i32, buffers ^u32);
+GenVertexArrays: proc(count i32, buffers ^u32);
+GenSamplers:     proc(count i32, buffers ^u32);
+BindBuffer:      proc(target i32, buffer u32);
+BindVertexArray: proc(buffer u32);
+BindSampler:     proc(position i32, sampler u32);
+BufferData:      proc(target i32, size int, data rawptr, usage i32);
+BufferSubData:   proc(target i32, offset, size int, data rawptr);
 
-DrawArrays:      proc(mode, first: i32, count: u32);
-DrawElements:    proc(mode: i32, count: u32, type_: i32, indices: rawptr);
+DrawArrays:      proc(mode, first i32, count u32);
+DrawElements:    proc(mode i32, count u32, type_ i32, indices rawptr);
 
-MapBuffer:       proc(target, access: i32) -> rawptr;
-UnmapBuffer:     proc(target: i32);
+MapBuffer:       proc(target, access i32) -> rawptr;
+UnmapBuffer:     proc(target i32);
 
-VertexAttribPointer: proc(index: u32, size, type_: i32, normalized: i32, stride: u32, pointer: rawptr);
-EnableVertexAttribArray: proc(index: u32);
+VertexAttribPointer: proc(index u32, size, type_ i32, normalized i32, stride u32, pointer rawptr);
+EnableVertexAttribArray: proc(index u32);
 
-CreateShader:  proc(shader_type: i32) -> u32;
-ShaderSource:  proc(shader: u32, count: u32, string: ^^byte, length: ^i32);
-CompileShader: proc(shader: u32);
+CreateShader:  proc(shader_type i32) -> u32;
+ShaderSource:  proc(shader u32, count u32, str ^^byte, length ^i32);
+CompileShader: proc(shader u32);
 CreateProgram: proc() -> u32;
-AttachShader:  proc(program, shader: u32);
-DetachShader:  proc(program, shader: u32);
-DeleteShader:  proc(shader: u32);
-LinkProgram:   proc(program: u32);
-UseProgram:    proc(program: u32);
-DeleteProgram: proc(program: u32);
-
-
-GetShaderiv:       proc(shader:  u32, pname: i32, params: ^i32);
-GetProgramiv:      proc(program: u32, pname: i32, params: ^i32);
-GetShaderInfoLog:  proc(shader:  u32, max_length: u32, length: ^u32, info_long: ^byte);
-GetProgramInfoLog: proc(program: u32, max_length: u32, length: ^u32, info_long: ^byte);
-
-ActiveTexture:  proc(texture: i32);
-GenerateMipmap: proc(target: i32);
-
-SamplerParameteri:    proc(sampler: u32, pname: i32, param: i32);
-SamplerParameterf:    proc(sampler: u32, pname: i32, param: f32);
-SamplerParameteriv:   proc(sampler: u32, pname: i32, params: ^i32);
-SamplerParameterfv:   proc(sampler: u32, pname: i32, params: ^f32);
-SamplerParameterIiv:  proc(sampler: u32, pname: i32, params: ^i32);
-SamplerParameterIuiv: proc(sampler: u32, pname: i32, params: ^u32);
-
-
-Uniform1i:        proc(loc: i32, v0: i32);
-Uniform2i:        proc(loc: i32, v0, v1: i32);
-Uniform3i:        proc(loc: i32, v0, v1, v2: i32);
-Uniform4i:        proc(loc: i32, v0, v1, v2, v3: i32);
-Uniform1f:        proc(loc: i32, v0: f32);
-Uniform2f:        proc(loc: i32, v0, v1: f32);
-Uniform3f:        proc(loc: i32, v0, v1, v2: f32);
-Uniform4f:        proc(loc: i32, v0, v1, v2, v3: f32);
-UniformMatrix4fv: proc(loc: i32, count: u32, transpose: i32, value: ^f32);
-
-GetUniformLocation: proc(program: u32, name: ^byte) -> i32;
+AttachShader:  proc(program, shader u32);
+DetachShader:  proc(program, shader u32);
+DeleteShader:  proc(shader u32);
+LinkProgram:   proc(program u32);
+UseProgram:    proc(program u32);
+DeleteProgram: proc(program u32);
+
+
+GetShaderiv:       proc(shader  u32, pname i32, params ^i32);
+GetProgramiv:      proc(program u32, pname i32, params ^i32);
+GetShaderInfoLog:  proc(shader  u32, max_length u32, length ^u32, info_long ^byte);
+GetProgramInfoLog: proc(program u32, max_length u32, length ^u32, info_long ^byte);
+
+ActiveTexture:  proc(texture i32);
+GenerateMipmap: proc(target i32);
+
+SamplerParameteri:    proc(sampler u32, pname i32, param i32);
+SamplerParameterf:    proc(sampler u32, pname i32, param f32);
+SamplerParameteriv:   proc(sampler u32, pname i32, params ^i32);
+SamplerParameterfv:   proc(sampler u32, pname i32, params ^f32);
+SamplerParameterIiv:  proc(sampler u32, pname i32, params ^i32);
+SamplerParameterIuiv: proc(sampler u32, pname i32, params ^u32);
+
+
+Uniform1i:        proc(loc i32, v0 i32);
+Uniform2i:        proc(loc i32, v0, v1 i32);
+Uniform3i:        proc(loc i32, v0, v1, v2 i32);
+Uniform4i:        proc(loc i32, v0, v1, v2, v3 i32);
+Uniform1f:        proc(loc i32, v0 f32);
+Uniform2f:        proc(loc i32, v0, v1 f32);
+Uniform3f:        proc(loc i32, v0, v1, v2 f32);
+Uniform4f:        proc(loc i32, v0, v1, v2, v3 f32);
+UniformMatrix4fv: proc(loc i32, count u32, transpose i32, value ^f32);
+
+GetUniformLocation: proc(program u32, name ^byte) -> i32;
 
 proc init() {
-	proc set_proc_address(p: rawptr, name: string) #inline { (p as ^proc())^ = GetProcAddress(name); }
+	proc set_proc_address(p rawptr, name string) #inline { (p as ^proc())^ = GetProcAddress(name); }
 
 	set_proc_address(^GenBuffers,      "glGenBuffers\x00");
 	set_proc_address(^GenVertexArrays, "glGenVertexArrays\x00");

core/opengl_constants.odin

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

core/os_windows.odin

@@ -13,7 +13,7 @@ type File struct {
 	last_write_time: File_Time;
 }
 
-proc open(name: string) -> (File, bool) {
+proc open(name string) -> (File, bool) {
 	using win32;
 	buf: [300]byte;
 	copy(buf[:], name as []byte);
@@ -24,7 +24,7 @@ proc open(name: string) -> (File, bool) {
 	return f, success;
 }
 
-proc create(name: string) -> (File, bool) {
+proc create(name string) -> (File, bool) {
 	using win32;
 	buf: [300]byte;
 	copy(buf[:], name as []byte);
@@ -35,16 +35,16 @@ proc create(name: string) -> (File, bool) {
 	return f, success;
 }
 
-proc close(using f: ^File) {
+proc close(using f ^File) {
 	win32.CloseHandle(handle.p as win32.HANDLE);
 }
 
-proc write(using f: ^File, buf: []byte) -> bool {
+proc write(using f ^File, buf []byte) -> bool {
 	bytes_written: i32;
 	return win32.WriteFile(handle.p as win32.HANDLE, buf.data, buf.count as i32, ^bytes_written, nil) != 0;
 }
 
-proc file_has_changed(f: ^File) -> bool {
+proc file_has_changed(f ^File) -> bool {
 	last_write_time := last_write_time(f);
 	if f.last_write_time != last_write_time {
 		f.last_write_time = last_write_time;
@@ -55,7 +55,7 @@ proc file_has_changed(f: ^File) -> bool {
 
 
 
-proc last_write_time(f: ^File) -> File_Time {
+proc last_write_time(f ^File) -> File_Time {
 	file_info: win32.BY_HANDLE_FILE_INFORMATION;
 	win32.GetFileInformationByHandle(f.handle.p as win32.HANDLE, ^file_info);
 	l := file_info.last_write_time.low_date_time as File_Time;
@@ -63,7 +63,7 @@ proc last_write_time(f: ^File) -> File_Time {
 	return l | h << 32;
 }
 
-proc last_write_time_by_name(name: string) -> File_Time {
+proc last_write_time_by_name(name string) -> File_Time {
 	last_write_time: win32.FILETIME;
 	data: win32.WIN32_FILE_ATTRIBUTE_DATA;
 	buf: [1024]byte;
@@ -103,7 +103,7 @@ stderr := ^__std_files[File_Standard.ERROR];
 
 
 
-proc read_entire_file(name: string) -> ([]byte, bool) {
+proc read_entire_file(name string) -> ([]byte, bool) {
 	buf: [300]byte;
 	copy(buf[:], name as []byte);
 
@@ -130,7 +130,7 @@ proc read_entire_file(name: string) -> ([]byte, bool) {
 	for total_read < length {
 		remaining := length - total_read;
 		to_read: u32;
-		MAX :: 1<<32-1;
+		const MAX = 1<<32-1;
 		if remaining <= MAX {
 			to_read = remaining as u32;
 		} else {
@@ -151,18 +151,18 @@ proc read_entire_file(name: string) -> ([]byte, bool) {
 
 
 
-proc heap_alloc(size: int) -> rawptr {
+proc heap_alloc(size int) -> rawptr {
 	return win32.HeapAlloc(win32.GetProcessHeap(), win32.HEAP_ZERO_MEMORY, size);
 }
-proc heap_resize(ptr: rawptr, new_size: int) -> rawptr {
+proc heap_resize(ptr rawptr, new_size int) -> rawptr {
 	return win32.HeapReAlloc(win32.GetProcessHeap(), win32.HEAP_ZERO_MEMORY, ptr, new_size);
 }
-proc heap_free(ptr: rawptr) {
+proc heap_free(ptr rawptr) {
 	win32.HeapFree(win32.GetProcessHeap(), 0, ptr);
 }
 
 
-proc exit(code: int) {
+proc exit(code int) {
 	win32.ExitProcess(code as u32);
 }
 

core/sync.odin

@@ -17,35 +17,35 @@ proc current_thread_id() -> i32 {
 	return win32.GetCurrentThreadId() as i32;
 }
 
-proc semaphore_init(s: ^Semaphore) {
+proc semaphore_init(s ^Semaphore) {
 	s.handle = win32.CreateSemaphoreA(nil, 0, 1<<31-1, nil);
 }
 
-proc semaphore_destroy(s: ^Semaphore) {
+proc semaphore_destroy(s ^Semaphore) {
 	win32.CloseHandle(s.handle);
 }
 
-proc semaphore_post(s: ^Semaphore, count: int) {
+proc semaphore_post(s ^Semaphore, count int) {
 	win32.ReleaseSemaphore(s.handle, count as i32, nil);
 }
 
-proc semaphore_release(s: ^Semaphore) #inline { semaphore_post(s, 1); }
+proc semaphore_release(s ^Semaphore) #inline { semaphore_post(s, 1); }
 
-proc semaphore_wait(s: ^Semaphore) {
+proc semaphore_wait(s ^Semaphore) {
 	win32.WaitForSingleObject(s.handle, win32.INFINITE);
 }
 
 
-proc mutex_init(m: ^Mutex) {
+proc mutex_init(m ^Mutex) {
 	atomic.store32(^m.counter, 0);
 	atomic.store32(^m.owner, current_thread_id());
 	semaphore_init(^m.semaphore);
 	m.recursion = 0;
 }
-proc mutex_destroy(m: ^Mutex) {
+proc mutex_destroy(m ^Mutex) {
 	semaphore_destroy(^m.semaphore);
 }
-proc mutex_lock(m: ^Mutex) {
+proc mutex_lock(m ^Mutex) {
 	thread_id := current_thread_id();
 	if atomic.fetch_add32(^m.counter, 1) > 0 {
 		if thread_id != atomic.load32(^m.owner) {
@@ -55,7 +55,7 @@ proc mutex_lock(m: ^Mutex) {
 	atomic.store32(^m.owner, thread_id);
 	m.recursion++;
 }
-proc mutex_try_lock(m: ^Mutex) -> bool {
+proc mutex_try_lock(m ^Mutex) -> bool {
 	thread_id := current_thread_id();
 	if atomic.load32(^m.owner) == thread_id {
 		atomic.fetch_add32(^m.counter, 1);
@@ -72,7 +72,7 @@ proc mutex_try_lock(m: ^Mutex) -> bool {
 	m.recursion++;
 	return true;
 }
-proc mutex_unlock(m: ^Mutex) {
+proc mutex_unlock(m ^Mutex) {
 	recursion: i32;
 	thread_id := current_thread_id();
 	assert(thread_id == atomic.load32(^m.owner));

core/sys/windows.odin

@@ -16,39 +16,39 @@ type LPARAM    int;
 type LRESULT   int;
 type ATOM      i16;
 type BOOL      i32;
-type WNDPROC   proc(hwnd: HWND, msg: u32, wparam: WPARAM, lparam: LPARAM) -> LRESULT;
+type WNDPROC   proc(hwnd HWND, msg u32, wparam WPARAM, lparam LPARAM) -> LRESULT;
 
-INVALID_HANDLE_VALUE :: (-1 as int) as HANDLE;
+const INVALID_HANDLE_VALUE = (-1 as int) as HANDLE;
 
-CS_VREDRAW    :: 0x0001;
-CS_HREDRAW    :: 0x0002;
-CS_OWNDC      :: 0x0020;
-CW_USEDEFAULT :: -0x80000000;
+const CS_VREDRAW    = 0x0001;
+const CS_HREDRAW    = 0x0002;
+const CS_OWNDC      = 0x0020;
+const CW_USEDEFAULT = -0x80000000;
 
-WS_OVERLAPPED       :: 0;
-WS_MAXIMIZEBOX      :: 0x00010000;
-WS_MINIMIZEBOX      :: 0x00020000;
-WS_THICKFRAME       :: 0x00040000;
-WS_SYSMENU          :: 0x00080000;
-WS_CAPTION          :: 0x00C00000;
-WS_VISIBLE          :: 0x10000000;
-WS_OVERLAPPEDWINDOW :: WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX;
+const WS_OVERLAPPED       = 0;
+const WS_MAXIMIZEBOX      = 0x00010000;
+const WS_MINIMIZEBOX      = 0x00020000;
+const WS_THICKFRAME       = 0x00040000;
+const WS_SYSMENU          = 0x00080000;
+const WS_CAPTION          = 0x00C00000;
+const WS_VISIBLE          = 0x10000000;
+const WS_OVERLAPPEDWINDOW = WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX;
 
-WM_DESTROY :: 0x0002;
-WM_CLOSE   :: 0x0010;
-WM_QUIT    :: 0x0012;
-WM_KEYDOWN :: 0x0100;
-WM_KEYUP   :: 0x0101;
+const WM_DESTROY = 0x0002;
+const WM_CLOSE   = 0x0010;
+const WM_QUIT    = 0x0012;
+const WM_KEYDOWN = 0x0100;
+const WM_KEYUP   = 0x0101;
 
-PM_REMOVE :: 1;
+const PM_REMOVE = 1;
 
-COLOR_BACKGROUND :: 1 as HBRUSH;
-BLACK_BRUSH :: 4;
+const COLOR_BACKGROUND = 1 as HBRUSH;
+const BLACK_BRUSH = 4;
 
-SM_CXSCREEN :: 0;
-SM_CYSCREEN :: 1;
+const SM_CXSCREEN = 0;
+const SM_CYSCREEN = 1;
 
-SW_SHOW :: 5;
+const SW_SHOW = 5;
 
 type POINT struct #ordered {
 	x, y: i32;
@@ -110,101 +110,101 @@ type WIN32_FILE_ATTRIBUTE_DATA struct #ordered {
 }
 
 type GET_FILEEX_INFO_LEVELS i32;
-GetFileExInfoStandard :: 0 as GET_FILEEX_INFO_LEVELS;
-GetFileExMaxInfoLevel :: 1 as GET_FILEEX_INFO_LEVELS;
+const GetFileExInfoStandard = 0 as GET_FILEEX_INFO_LEVELS;
+const GetFileExMaxInfoLevel = 1 as GET_FILEEX_INFO_LEVELS;
 
 proc GetLastError    () -> i32                           #foreign #dll_import
-proc ExitProcess     (exit_code: u32)                    #foreign #dll_import
+proc ExitProcess     (exit_code u32)                    #foreign #dll_import
 proc GetDesktopWindow() -> HWND                          #foreign #dll_import
-proc GetCursorPos    (p: ^POINT) -> i32                  #foreign #dll_import
-proc ScreenToClient  (h: HWND, p: ^POINT) -> i32         #foreign #dll_import
-proc GetModuleHandleA(module_name: ^u8) -> HINSTANCE     #foreign #dll_import
-proc GetStockObject  (fn_object: i32) -> HGDIOBJ         #foreign #dll_import
-proc PostQuitMessage (exit_code: i32)                    #foreign #dll_import
-proc SetWindowTextA  (hwnd: HWND, c_string: ^u8) -> BOOL #foreign #dll_import
+proc GetCursorPos    (p ^POINT) -> i32                  #foreign #dll_import
+proc ScreenToClient  (h HWND, p ^POINT) -> i32         #foreign #dll_import
+proc GetModuleHandleA(module_name ^u8) -> HINSTANCE     #foreign #dll_import
+proc GetStockObject  (fn_object i32) -> HGDIOBJ         #foreign #dll_import
+proc PostQuitMessage (exit_code i32)                    #foreign #dll_import
+proc SetWindowTextA  (hwnd HWND, c_string ^u8) -> BOOL #foreign #dll_import
 
-proc QueryPerformanceFrequency(result: ^i64) -> i32 #foreign #dll_import
-proc QueryPerformanceCounter  (result: ^i64) -> i32 #foreign #dll_import
+proc QueryPerformanceFrequency(result ^i64) -> i32 #foreign #dll_import
+proc QueryPerformanceCounter  (result ^i64) -> i32 #foreign #dll_import
 
-proc Sleep(ms: i32) -> i32 #foreign #dll_import
+proc Sleep(ms i32) -> i32 #foreign #dll_import
 
-proc OutputDebugStringA(c_str: ^u8) #foreign #dll_import
+proc OutputDebugStringA(c_str ^u8) #foreign #dll_import
 
 
-proc RegisterClassExA(wc: ^WNDCLASSEXA) -> ATOM #foreign #dll_import
-proc CreateWindowExA (ex_style: u32,
-                         class_name, title: ^u8,
-                         style: u32,
-                         x, y, w, h: i32,
-                         parent: HWND, menu: HMENU, instance: HINSTANCE,
-                         param: rawptr) -> HWND #foreign #dll_import
+proc RegisterClassExA(wc ^WNDCLASSEXA) -> ATOM #foreign #dll_import
+proc CreateWindowExA (ex_style u32,
+                      class_name, title ^u8,
+                      style u32,
+                      x, y, w, h i32,
+                      parent HWND, menu HMENU, instance HINSTANCE,
+                      param rawptr) -> HWND #foreign #dll_import
 
-proc ShowWindow      (hwnd: HWND, cmd_show: i32) -> BOOL #foreign #dll_import
-proc TranslateMessage(msg: ^MSG) -> BOOL                 #foreign #dll_import
-proc DispatchMessageA(msg: ^MSG) -> LRESULT              #foreign #dll_import
-proc UpdateWindow    (hwnd: HWND) -> BOOL                #foreign #dll_import
-proc PeekMessageA    (msg: ^MSG, hwnd: HWND,
-                         msg_filter_min, msg_filter_max, remove_msg: u32) -> BOOL #foreign #dll_import
+proc ShowWindow      (hwnd HWND, cmd_show i32) -> BOOL #foreign #dll_import
+proc TranslateMessage(msg ^MSG) -> BOOL                 #foreign #dll_import
+proc DispatchMessageA(msg ^MSG) -> LRESULT              #foreign #dll_import
+proc UpdateWindow    (hwnd HWND) -> BOOL                #foreign #dll_import
+proc PeekMessageA    (msg ^MSG, hwnd HWND,
+                         msg_filter_min, msg_filter_max, remove_msg u32) -> BOOL #foreign #dll_import
 
-proc DefWindowProcA  (hwnd: HWND, msg: u32, wparam: WPARAM, lparam: LPARAM) -> LRESULT #foreign #dll_import
+proc DefWindowProcA  (hwnd HWND, msg u32, wparam WPARAM, lparam LPARAM) -> LRESULT #foreign #dll_import
 
-proc AdjustWindowRect(rect: ^RECT, style: u32, menu: BOOL) -> BOOL #foreign #dll_import
+proc AdjustWindowRect(rect ^RECT, style u32, menu BOOL) -> BOOL #foreign #dll_import
 proc GetActiveWindow () -> HWND #foreign #dll_import
 
 
 proc GetQueryPerformanceFrequency() -> i64 {
-	r: i64;
+	var r i64;
 	QueryPerformanceFrequency(^r);
 	return r;
 }
 
 proc GetCommandLineA() -> ^u8 #foreign #dll_import
-proc GetSystemMetrics(index: i32) -> i32 #foreign #dll_import
+proc GetSystemMetrics(index i32) -> i32 #foreign #dll_import
 proc GetCurrentThreadId() -> u32 #foreign #dll_import
 
 // File Stuff
 
-proc CloseHandle (h: HANDLE) -> i32 #foreign #dll_import
-proc GetStdHandle(h: i32) -> HANDLE #foreign #dll_import
-proc CreateFileA (filename: ^u8, desired_access, share_mode: u32,
-                     security: rawptr,
-                     creation, flags_and_attribs: u32, template_file: HANDLE) -> HANDLE #foreign #dll_import
-proc ReadFile    (h: HANDLE, buf: rawptr, to_read: u32, bytes_read: ^i32, overlapped: rawptr) -> BOOL #foreign #dll_import
-proc WriteFile   (h: HANDLE, buf: rawptr, len: i32, written_result: ^i32, overlapped: rawptr) -> i32 #foreign #dll_import
+proc CloseHandle (h HANDLE) -> i32 #foreign #dll_import
+proc GetStdHandle(h i32) -> HANDLE #foreign #dll_import
+proc CreateFileA (filename ^u8, desired_access, share_mode u32,
+                     security rawptr,
+                     creation, flags_and_attribs u32, template_file HANDLE) -> HANDLE #foreign #dll_import
+proc ReadFile    (h HANDLE, buf rawptr, to_read u32, bytes_read ^i32, overlapped rawptr) -> BOOL #foreign #dll_import
+proc WriteFile   (h HANDLE, buf rawptr, len i32, written_result ^i32, overlapped rawptr) -> i32 #foreign #dll_import
 
-proc GetFileSizeEx             (file_handle: HANDLE, file_size: ^i64) -> BOOL #foreign #dll_import
-proc GetFileAttributesExA      (filename: ^u8, info_level_id: GET_FILEEX_INFO_LEVELS, file_info: rawptr) -> BOOL #foreign #dll_import
-proc GetFileInformationByHandle(file_handle: HANDLE, file_info: ^BY_HANDLE_FILE_INFORMATION) -> BOOL #foreign #dll_import
+proc GetFileSizeEx             (file_handle HANDLE, file_size ^i64) -> BOOL #foreign #dll_import
+proc GetFileAttributesExA      (filename ^u8, info_level_id GET_FILEEX_INFO_LEVELS, file_info rawptr) -> BOOL #foreign #dll_import
+proc GetFileInformationByHandle(file_handle HANDLE, file_info ^BY_HANDLE_FILE_INFORMATION) -> BOOL #foreign #dll_import
 
-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;
+const FILE_SHARE_READ      = 0x00000001;
+const FILE_SHARE_WRITE     = 0x00000002;
+const FILE_SHARE_DELETE    = 0x00000004;
+const FILE_GENERIC_ALL     = 0x10000000;
+const FILE_GENERIC_EXECUTE = 0x20000000;
+const FILE_GENERIC_WRITE   = 0x40000000;
+const FILE_GENERIC_READ    = 0x80000000;
 
-STD_INPUT_HANDLE  :: -10;
-STD_OUTPUT_HANDLE :: -11;
-STD_ERROR_HANDLE  :: -12;
+const STD_INPUT_HANDLE  = -10;
+const STD_OUTPUT_HANDLE = -11;
+const STD_ERROR_HANDLE  = -12;
 
-CREATE_NEW        :: 1;
-CREATE_ALWAYS     :: 2;
-OPEN_EXISTING     :: 3;
-OPEN_ALWAYS       :: 4;
-TRUNCATE_EXISTING :: 5;
+const CREATE_NEW        = 1;
+const CREATE_ALWAYS     = 2;
+const OPEN_EXISTING     = 3;
+const OPEN_ALWAYS       = 4;
+const TRUNCATE_EXISTING = 5;
 
 
 
 
 
-proc HeapAlloc     (h: HANDLE, flags: u32, bytes: int) -> rawptr                 #foreign #dll_import
-proc HeapReAlloc   (h: HANDLE, flags: u32, memory: rawptr, bytes: int) -> rawptr #foreign #dll_import
-proc HeapFree      (h: HANDLE, flags: u32, memory: rawptr) -> BOOL               #foreign #dll_import
+proc HeapAlloc     (h HANDLE, flags u32, bytes int) -> rawptr                 #foreign #dll_import
+proc HeapReAlloc   (h HANDLE, flags u32, memory rawptr, bytes int) -> rawptr #foreign #dll_import
+proc HeapFree      (h HANDLE, flags u32, memory rawptr) -> BOOL               #foreign #dll_import
 proc GetProcessHeap() -> HANDLE #foreign #dll_import
 
 
-HEAP_ZERO_MEMORY :: 0x00000008;
+const HEAP_ZERO_MEMORY = 0x00000008;
 
 // Synchronization
 
@@ -214,24 +214,24 @@ type SECURITY_ATTRIBUTES struct #ordered {
 	inherit_handle:      BOOL;
 }
 
-INFINITE :: 0xffffffff;
+const INFINITE = 0xffffffff;
 
-proc CreateSemaphoreA   (attributes: ^SECURITY_ATTRIBUTES, initial_count, maximum_count: i32, name: ^byte) -> HANDLE #foreign #dll_import
-proc ReleaseSemaphore   (semaphore: HANDLE, release_count: i32, previous_count: ^i32) -> BOOL #foreign #dll_import
-proc WaitForSingleObject(handle: HANDLE, milliseconds: u32) -> u32 #foreign #dll_import
+proc CreateSemaphoreA   (attributes ^SECURITY_ATTRIBUTES, initial_count, maximum_count i32, name ^byte) -> HANDLE #foreign #dll_import
+proc ReleaseSemaphore   (semaphore HANDLE, release_count i32, previous_count ^i32) -> BOOL #foreign #dll_import
+proc WaitForSingleObject(handle HANDLE, milliseconds u32) -> u32 #foreign #dll_import
 
 
-proc InterlockedCompareExchange(dst: ^i32, exchange, comparand: i32) -> i32 #foreign
-proc InterlockedExchange       (dst: ^i32, desired: i32) -> i32 #foreign
-proc InterlockedExchangeAdd    (dst: ^i32, desired: i32) -> i32 #foreign
-proc InterlockedAnd            (dst: ^i32, desired: i32) -> i32 #foreign
-proc InterlockedOr             (dst: ^i32, desired: i32) -> i32 #foreign
+proc InterlockedCompareExchange(dst ^i32, exchange, comparand i32) -> i32 #foreign
+proc InterlockedExchange       (dst ^i32, desired i32) -> i32 #foreign
+proc InterlockedExchangeAdd    (dst ^i32, desired i32) -> i32 #foreign
+proc InterlockedAnd            (dst ^i32, desired i32) -> i32 #foreign
+proc InterlockedOr             (dst ^i32, desired i32) -> i32 #foreign
 
-proc InterlockedCompareExchange64(dst: ^i64, exchange, comparand: i64) -> i64 #foreign
-proc InterlockedExchange64       (dst: ^i64, desired: i64) -> i64 #foreign
-proc InterlockedExchangeAdd64    (dst: ^i64, desired: i64) -> i64 #foreign
-proc InterlockedAnd64            (dst: ^i64, desired: i64) -> i64 #foreign
-proc InterlockedOr64             (dst: ^i64, desired: i64) -> i64 #foreign
+proc InterlockedCompareExchange64(dst ^i64, exchange, comparand i64) -> i64 #foreign
+proc InterlockedExchange64       (dst ^i64, desired i64) -> i64 #foreign
+proc InterlockedExchangeAdd64    (dst ^i64, desired i64) -> i64 #foreign
+proc InterlockedAnd64            (dst ^i64, desired i64) -> i64 #foreign
+proc InterlockedOr64             (dst ^i64, desired i64) -> i64 #foreign
 
 proc _mm_pause       () #foreign
 proc ReadWriteBarrier() #foreign
@@ -262,54 +262,54 @@ type RGBQUAD struct #ordered {
 	blue, green, red, reserved: byte;
 }
 
-BI_RGB         :: 0;
-DIB_RGB_COLORS :: 0x00;
-SRCCOPY        :: 0x00cc0020 as u32;
+const BI_RGB         = 0;
+const DIB_RGB_COLORS = 0x00;
+const SRCCOPY        = 0x00cc0020 as u32;
 
-proc StretchDIBits(hdc: HDC,
-                      x_dst, y_dst, width_dst, height_dst: i32,
-                      x_src, y_src, width_src, header_src: i32,
-                      bits: rawptr, bits_info: ^BITMAPINFO,
-                      usage: u32,
-                      rop: u32) -> i32 #foreign #dll_import
+proc StretchDIBits(hdc HDC,
+                   x_dst, y_dst, width_dst, height_dst i32,
+                   x_src, y_src, width_src, header_src i32,
+                   bits rawptr, bits_info ^BITMAPINFO,
+                   usage u32,
+                   rop u32) -> i32 #foreign #dll_import
 
 
 
-proc LoadLibraryA  (c_str: ^u8) -> HMODULE #foreign
-proc FreeLibrary   (h: HMODULE) #foreign
-proc GetProcAddress(h: HMODULE, c_str: ^u8) -> PROC #foreign
+proc LoadLibraryA  (c_str ^u8) -> HMODULE #foreign
+proc FreeLibrary   (h HMODULE) #foreign
+proc GetProcAddress(h HMODULE, c_str ^u8) -> PROC #foreign
 
-proc GetClientRect(hwnd: HWND, rect: ^RECT) -> BOOL #foreign
+proc GetClientRect(hwnd HWND, rect ^RECT) -> BOOL #foreign
 
 
 
 // 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;
+const PFD_TYPE_RGBA             = 0;
+const PFD_TYPE_COLORINDEX       = 1;
+const PFD_MAIN_PLANE            = 0;
+const PFD_OVERLAY_PLANE         = 1;
+const PFD_UNDERLAY_PLANE        = -1;
+const PFD_DOUBLEBUFFER          = 1;
+const PFD_STEREO                = 2;
+const PFD_DRAW_TO_WINDOW        = 4;
+const PFD_DRAW_TO_BITMAP        = 8;
+const PFD_SUPPORT_GDI           = 16;
+const PFD_SUPPORT_OPENGL        = 32;
+const PFD_GENERIC_FORMAT        = 64;
+const PFD_NEED_PALETTE          = 128;
+const PFD_NEED_SYSTEM_PALETTE   = 0x00000100;
+const PFD_SWAP_EXCHANGE         = 0x00000200;
+const PFD_SWAP_COPY             = 0x00000400;
+const PFD_SWAP_LAYER_BUFFERS    = 0x00000800;
+const PFD_GENERIC_ACCELERATED   = 0x00001000;
+const PFD_DEPTH_DONTCARE        = 0x20000000;
+const PFD_DOUBLEBUFFER_DONTCARE = 0x40000000;
+const PFD_STEREO_DONTCARE       = 0x80000000;
 
 type HGLRC HANDLE;
 type PROC  proc();
-type wglCreateContextAttribsARBType proc(hdc: HDC, hshareContext: rawptr, attribList: ^i32) -> HGLRC;
+type wglCreateContextAttribsARBType proc(hdc HDC, hshareContext rawptr, attribList ^i32) -> HGLRC;
 
 
 type PIXELFORMATDESCRIPTOR struct #ordered {
@@ -343,29 +343,29 @@ type PIXELFORMATDESCRIPTOR struct #ordered {
 	damage_mask: u32;
 }
 
-proc GetDC            (h: HANDLE) -> HDC #foreign
-proc SetPixelFormat   (hdc: HDC, pixel_format: i32, pfd: ^PIXELFORMATDESCRIPTOR ) -> BOOL #foreign #dll_import
-proc ChoosePixelFormat(hdc: HDC, pfd: ^PIXELFORMATDESCRIPTOR) -> i32 #foreign #dll_import
-proc SwapBuffers      (hdc: HDC) -> BOOL #foreign #dll_import
-proc ReleaseDC        (wnd: HWND, hdc: HDC) -> i32 #foreign #dll_import
+proc GetDC            (h HANDLE) -> HDC #foreign
+proc SetPixelFormat   (hdc HDC, pixel_format i32, pfd ^PIXELFORMATDESCRIPTOR ) -> BOOL #foreign #dll_import
+proc ChoosePixelFormat(hdc HDC, pfd ^PIXELFORMATDESCRIPTOR) -> i32 #foreign #dll_import
+proc SwapBuffers      (hdc HDC) -> BOOL #foreign #dll_import
+proc ReleaseDC        (wnd HWND, hdc HDC) -> i32 #foreign #dll_import
 
-WGL_CONTEXT_MAJOR_VERSION_ARB             :: 0x2091;
-WGL_CONTEXT_MINOR_VERSION_ARB             :: 0x2092;
-WGL_CONTEXT_PROFILE_MASK_ARB              :: 0x9126;
-WGL_CONTEXT_CORE_PROFILE_BIT_ARB          :: 0x0001;
-WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB :: 0x0002;
+const WGL_CONTEXT_MAJOR_VERSION_ARB             = 0x2091;
+const WGL_CONTEXT_MINOR_VERSION_ARB             = 0x2092;
+const WGL_CONTEXT_PROFILE_MASK_ARB              = 0x9126;
+const WGL_CONTEXT_CORE_PROFILE_BIT_ARB          = 0x0001;
+const WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = 0x0002;
 
-proc wglCreateContext (hdc: HDC) -> HGLRC #foreign #dll_import
-proc wglMakeCurrent   (hdc: HDC, hglrc: HGLRC) -> BOOL #foreign #dll_import
-proc wglGetProcAddress(c_str: ^u8) -> PROC #foreign #dll_import
-proc wglDeleteContext (hglrc: HGLRC) -> BOOL #foreign #dll_import
+proc wglCreateContext (hdc HDC) -> HGLRC #foreign #dll_import
+proc wglMakeCurrent   (hdc HDC, hglrc HGLRC) -> BOOL #foreign #dll_import
+proc wglGetProcAddress(c_str ^u8) -> PROC #foreign #dll_import
+proc wglDeleteContext (hglrc HGLRC) -> BOOL #foreign #dll_import
 
 
 
-proc GetKeyState     (v_key: i32) -> i16 #foreign #dll_import
-proc GetAsyncKeyState(v_key: i32) -> i16 #foreign #dll_import
+proc GetKeyState     (v_key i32) -> i16 #foreign #dll_import
+proc GetAsyncKeyState(v_key i32) -> i16 #foreign #dll_import
 
-proc is_key_down(key: Key_Code) -> bool {
+proc is_key_down(key Key_Code) -> bool {
 	return GetAsyncKeyState(key as i32) < 0;
 }
 

core/utf8.odin

@@ -1,13 +1,13 @@
-RUNE_ERROR :: '\ufffd';
-RUNE_SELF  :: 0x80;
-RUNE_BOM   :: 0xfeff;
-RUNE_EOF   :: ~(0 as rune);
-MAX_RUNE   :: '\U0010ffff';
-UTF_MAX    :: 4;
+const RUNE_ERROR = '\ufffd';
+const RUNE_SELF  = 0x80;
+const RUNE_BOM   = 0xfeff;
+const RUNE_EOF   = ~(0 as rune);
+const MAX_RUNE   = '\U0010ffff';
+const UTF_MAX    = 4;
 
 
-SURROGATE_MIN :: 0xd800;
-SURROGATE_MAX :: 0xdfff;
+const SURROGATE_MIN = 0xd800;
+const SURROGATE_MAX = 0xdfff;
 
 
 type Accept_Range struct {
@@ -42,11 +42,10 @@ accept_sizes := [256]byte{
 	0x34, 0x04, 0x04, 0x04, 0x44, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, // 0xf0-0xff
 };
 
-proc encode_rune(r_: rune) -> ([4]byte, int) {
-	r := r_;
+proc encode_rune(r rune) -> ([4]byte, int) {
 	buf: [4]byte;
 	i := r as u32;
-	mask :: 0x3f as byte;
+	const mask = 0x3f as byte;
 	if i <= 1<<7-1 {
 		buf[0] = r as byte;
 		return buf, 1;
@@ -77,7 +76,7 @@ proc encode_rune(r_: rune) -> ([4]byte, int) {
 	return buf, 4;
 }
 
-proc decode_rune(s: string) -> (rune, int) {
+proc decode_rune(s string) -> (rune, int) {
 	n := s.count;
 	if n < 1 {
 		return RUNE_ERROR, 0;
@@ -98,10 +97,10 @@ proc decode_rune(s: string) -> (rune, int) {
 		return RUNE_ERROR, 1;
 	}
 
-	MASK_X :: 0b00111111;
-	MASK_2 :: 0b00011111;
-	MASK_3 :: 0b00001111;
-	MASK_4 :: 0b00000111;
+	const MASK_X = 0b00111111;
+	const MASK_2 = 0b00011111;
+	const MASK_3 = 0b00001111;
+	const MASK_4 = 0b00000111;
 
 	if size == 2 {
 		return (b0&MASK_2) as rune <<6 | (b1&MASK_X) as rune, 2;
@@ -122,7 +121,7 @@ proc decode_rune(s: string) -> (rune, int) {
 }
 
 
-proc valid_rune(r: rune) -> bool {
+proc valid_rune(r rune) -> bool {
 	if r < 0 {
 		return false;
 	} else if SURROGATE_MIN <= r && r <= SURROGATE_MAX {
@@ -133,7 +132,7 @@ proc valid_rune(r: rune) -> bool {
 	return true;
 }
 
-proc valid_string(s: string) -> bool {
+proc valid_string(s string) -> bool {
 	n := s.count;
 	for i := 0; i < n; {
 		si := s[i];
@@ -166,7 +165,7 @@ proc valid_string(s: string) -> bool {
 	return true;
 }
 
-proc rune_count(s: string) -> int {
+proc rune_count(s string) -> int {
 	count := 0;
 	n := s.count;
 	for i := 0; i < n; count++ {
@@ -203,7 +202,7 @@ proc rune_count(s: string) -> int {
 }
 
 
-proc rune_size(r: rune) -> int {
+proc rune_size(r rune) -> int {
 	match {
 	case r < 0:          return -1;
 	case r <= 1<<7  - 1: return 1;

src/checker/expr.c

@@ -644,18 +644,18 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node) {
 
 	isize field_count = 0;
 	isize other_field_count = 0;
-	for_array(decl_index, st->decls) {
-		AstNode *decl = st->decls.e[decl_index];
-		switch (decl->kind) {
-		case_ast_node(vd, VarDecl, decl);
+	for_array(field_index, st->fields) {
+		AstNode *field = st->fields.e[field_index];
+		switch (field->kind) {
+		case_ast_node(vd, VarDecl, field);
 			field_count += vd->names.count;
 		case_end;
 
-		case_ast_node(cd, ConstDecl, decl);
+		case_ast_node(cd, ConstDecl, field);
 			other_field_count += cd->names.count;
 		case_end;
 
-		case_ast_node(td, TypeDecl, decl);
+		case_ast_node(td, TypeDecl, field);
 			other_field_count += 1;
 		case_end;
 		}
@@ -664,7 +664,7 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node) {
 	Entity **fields = gb_alloc_array(c->allocator, Entity *, field_count);
 	Entity **other_fields = gb_alloc_array(c->allocator, Entity *, other_field_count);
 
-	check_fields(c, node, st->decls, fields, field_count, other_fields, other_field_count, str_lit("struct"));
+	check_fields(c, node, st->fields, fields, field_count, other_fields, other_field_count, str_lit("struct"));
 
 	struct_type->Record.struct_is_packed    = st->is_packed;
 	struct_type->Record.struct_is_ordered   = st->is_ordered;
@@ -705,18 +705,18 @@ void check_union_type(Checker *c, Type *union_type, AstNode *node) {
 
 	isize field_count = 1;
 	isize other_field_count = 0;
-	for_array(decl_index, ut->decls) {
-		AstNode *decl = ut->decls.e[decl_index];
-		switch (decl->kind) {
-		case_ast_node(vd, VarDecl, decl);
+	for_array(field_index, ut->fields) {
+		AstNode *field = ut->fields.e[field_index];
+		switch (field->kind) {
+		case_ast_node(vd, VarDecl, field);
 			field_count += vd->names.count;
 		case_end;
 
-		case_ast_node(cd, ConstDecl, decl);
+		case_ast_node(cd, ConstDecl, field);
 			other_field_count += cd->names.count;
 		case_end;
 
-		case_ast_node(td, TypeDecl, decl);
+		case_ast_node(td, TypeDecl, field);
 			other_field_count += 1;
 		case_end;
 		}
@@ -725,7 +725,7 @@ void check_union_type(Checker *c, Type *union_type, AstNode *node) {
 	Entity **fields = gb_alloc_array(c->allocator, Entity *, field_count);
 	Entity **other_fields = gb_alloc_array(c->allocator, Entity *, other_field_count);
 
-	check_fields(c, node, ut->decls, fields, field_count, other_fields, other_field_count, str_lit("union"));
+	check_fields(c, node, ut->fields, fields, field_count, other_fields, other_field_count, str_lit("union"));
 
 	union_type->Record.fields            = fields;
 	union_type->Record.field_count       = field_count;
@@ -740,18 +740,18 @@ void check_raw_union_type(Checker *c, Type *union_type, AstNode *node) {
 
 	isize field_count = 0;
 	isize other_field_count = 0;
-	for_array(decl_index, ut->decls) {
-		AstNode *decl = ut->decls.e[decl_index];
-		switch (decl->kind) {
-		case_ast_node(vd, VarDecl, decl);
+	for_array(field_index, ut->fields) {
+		AstNode *field = ut->fields.e[field_index];
+		switch (field->kind) {
+		case_ast_node(vd, VarDecl, field);
 			field_count += vd->names.count;
 		case_end;
 
-		case_ast_node(cd, ConstDecl, decl);
+		case_ast_node(cd, ConstDecl, field);
 			other_field_count += cd->names.count;
 		case_end;
 
-		case_ast_node(td, TypeDecl, decl);
+		case_ast_node(td, TypeDecl, field);
 			other_field_count += 1;
 		case_end;
 		}
@@ -760,7 +760,7 @@ void check_raw_union_type(Checker *c, Type *union_type, AstNode *node) {
 	Entity **fields = gb_alloc_array(c->allocator, Entity *, field_count);
 	Entity **other_fields = gb_alloc_array(c->allocator, Entity *, other_field_count);
 
-	check_fields(c, node, ut->decls, fields, field_count, other_fields, other_field_count, str_lit("raw union"));
+	check_fields(c, node, ut->fields, fields, field_count, other_fields, other_field_count, str_lit("raw union"));
 
 	union_type->Record.fields = fields;
 	union_type->Record.field_count = field_count;
@@ -4655,11 +4655,11 @@ gbString write_expr_to_string(gbString str, AstNode *node) {
 		str = gb_string_appendc(str, "struct ");
 		if (st->is_packed)  str = gb_string_appendc(str, "#packed ");
 		if (st->is_ordered) str = gb_string_appendc(str, "#ordered ");
-		for_array(i, st->decls) {
+		for_array(i, st->fields) {
 			if (i > 0) {
 				str = gb_string_appendc(str, "; ");
 			}
-			str = write_expr_to_string(str, st->decls.e[i]);
+			str = write_expr_to_string(str, st->fields.e[i]);
 		}
 		// str = write_params_to_string(str, st->decl_list, ", ");
 		str = gb_string_appendc(str, "}");
@@ -4667,11 +4667,11 @@ gbString write_expr_to_string(gbString str, AstNode *node) {
 
 	case_ast_node(st, RawUnionType, node);
 		str = gb_string_appendc(str, "raw_union {");
-		for_array(i, st->decls) {
+		for_array(i, st->fields) {
 			if (i > 0) {
 				str = gb_string_appendc(str, "; ");
 			}
-			str = write_expr_to_string(str, st->decls.e[i]);
+			str = write_expr_to_string(str, st->fields.e[i]);
 		}
 		// str = write_params_to_string(str, st->decl_list, ", ");
 		str = gb_string_appendc(str, "}");
@@ -4679,11 +4679,11 @@ gbString write_expr_to_string(gbString str, AstNode *node) {
 
 	case_ast_node(st, UnionType, node);
 		str = gb_string_appendc(str, "union {");
-		for_array(i, st->decls) {
+		for_array(i, st->fields) {
 			if (i > 0) {
 				str = gb_string_appendc(str, "; ");
 			}
-			str = write_expr_to_string(str, st->decls.e[i]);
+			str = write_expr_to_string(str, st->fields.e[i]);
 		}
 		// str = write_params_to_string(str, st->decl_list, ", ");
 		str = gb_string_appendc(str, "}");

src/parser.c

@@ -302,20 +302,20 @@ AST_NODE_KIND(_TypeBegin, "", i32) \
 	}) \
 	AST_NODE_KIND(StructType, "struct type", struct { \
 		Token token; \
-		AstNodeArray decls; \
-		isize decl_count; \
+		AstNodeArray fields; \
+		isize field_count; \
 		bool is_packed; \
 		bool is_ordered; \
 	}) \
 	AST_NODE_KIND(UnionType, "union type", struct { \
 		Token token; \
-		AstNodeArray decls; \
-		isize decl_count; \
+		AstNodeArray fields; \
+		isize field_count; \
 	}) \
 	AST_NODE_KIND(RawUnionType, "raw union type", struct { \
 		Token token; \
-		AstNodeArray decls; \
-		isize decl_count; \
+		AstNodeArray fields; \
+		isize field_count; \
 	}) \
 	AST_NODE_KIND(EnumType, "enum type", struct { \
 		Token token; \
@@ -968,30 +968,30 @@ AstNode *make_vector_type(AstFile *f, Token token, AstNode *count, AstNode *elem
 	return result;
 }
 
-AstNode *make_struct_type(AstFile *f, Token token, AstNodeArray decls, isize decl_count, bool is_packed, bool is_ordered) {
+AstNode *make_struct_type(AstFile *f, Token token, AstNodeArray fields, isize field_count, bool is_packed, bool is_ordered) {
 	AstNode *result = make_node(f, AstNode_StructType);
 	result->StructType.token = token;
-	result->StructType.decls = decls;
-	result->StructType.decl_count = decl_count;
+	result->StructType.fields = fields;
+	result->StructType.field_count = field_count;
 	result->StructType.is_packed = is_packed;
 	result->StructType.is_ordered = is_ordered;
 	return result;
 }
 
 
-AstNode *make_union_type(AstFile *f, Token token, AstNodeArray decls, isize decl_count) {
+AstNode *make_union_type(AstFile *f, Token token, AstNodeArray fields, isize field_count) {
 	AstNode *result = make_node(f, AstNode_UnionType);
 	result->UnionType.token = token;
-	result->UnionType.decls = decls;
-	result->UnionType.decl_count = decl_count;
+	result->UnionType.fields = fields;
+	result->UnionType.field_count = field_count;
 	return result;
 }
 
-AstNode *make_raw_union_type(AstFile *f, Token token, AstNodeArray decls, isize decl_count) {
+AstNode *make_raw_union_type(AstFile *f, Token token, AstNodeArray fields, isize field_count) {
 	AstNode *result = make_node(f, AstNode_RawUnionType);
 	result->RawUnionType.token = token;
-	result->RawUnionType.decls = decls;
-	result->RawUnionType.decl_count = decl_count;
+	result->RawUnionType.fields = fields;
+	result->RawUnionType.field_count = field_count;
 	return result;
 }
 
@@ -1212,22 +1212,6 @@ void expect_semicolon(AstFile *f, AstNode *s) {
 	fix_advance_to_next_stmt(f);
 }
 
-bool parse_at_comma(AstFile *f, String context, TokenKind follow) {
-	if (f->curr_token.kind == Token_Comma) {
-		return true;
-	}
-	if (f->curr_token.kind != follow) {
-		if (f->curr_token.kind == Token_Semicolon &&
-		    str_eq(f->curr_token.string, str_lit("\n"))) {
-			error(f->curr_token, "Missing `,` before new line in %.*s", LIT(context));
-		}
-		error(f->curr_token, "Missing `,` in %.*s", LIT(context));
-		return true;
-	}
-	return false;
-}
-
-
 
 AstNode *    parse_expr(AstFile *f, bool lhs);
 AstNode *    parse_proc_type(AstFile *f);
@@ -1276,10 +1260,9 @@ AstNodeArray parse_element_list(AstFile *f) {
 
 		array_add(&elems, elem);
 
-		if (!parse_at_comma(f, str_lit("compound literal"), Token_CloseBrace)) {
+		if (!allow_token(f, Token_Comma)) {
 			break;
 		}
-		next_token(f);
 	}
 
 	return elems;
@@ -1617,10 +1600,9 @@ AstNode *parse_call_expr(AstFile *f, AstNode *operand) {
 		AstNode *arg = parse_expr(f, false);
 		array_add(&args, arg);
 
-		if (!parse_at_comma(f, str_lit("argument list"), Token_CloseParen)) {
+		if (!allow_token(f, Token_Comma)) {
 			break;
 		}
-		next_token(f);
 	}
 
 	f->expr_level--;
@@ -1862,7 +1844,15 @@ void parse_check_name_list_for_reserves(AstFile *f, AstNodeArray names) {
 	}
 }
 
+AstNode *parse_value_decl(AstFile *f);
+
 AstNode *parse_simple_stmt(AstFile *f) {
+	switch (f->curr_token.kind) {
+	case Token_var:
+	case Token_const:
+		return parse_value_decl(f);
+	}
+
 	isize lhs_count = 0, rhs_count = 0;
 	AstNodeArray lhs = parse_lhs_expr_list(f);
 
@@ -1926,56 +1916,56 @@ AstNode *parse_simple_stmt(AstFile *f) {
 		return make_var_decl(f, names, type, values);
 	} break;
 
-	case Token_ColonColon: {
-		AstNodeArray names = lhs;
-		parse_check_name_list_for_reserves(f, names);
-
-		Token colon_colon = expect_token(f, Token_ColonColon);
-
-		// if (f->curr_token.kind == Token_type ||
-		//     f->curr_token.kind == Token_struct ||
-		//     f->curr_token.kind == Token_enum ||
-		//     f->curr_token.kind == Token_union ||
-		//     f->curr_token.kind == Token_raw_union) {
-		// // if (f->curr_token.kind == Token_type) {
-		// 	Token token = f->curr_token;
-		// 	if (token.kind == Token_type) {
-		// 		next_token(f);
-		// 	}
-		// 	if (names.count != 1) {
-		// 		syntax_error_node(names.e[0], "You can only declare one type at a time");
-		// 		return make_bad_decl(f, names.e[0]->Ident, token);
-		// 	}
-
-		// 	return make_type_decl(f, token, names.e[0], parse_type(f));
-		// } else if (f->curr_token.kind == Token_proc) {
-		//     // NOTE(bill): Procedure declarations
-		// 	Token proc_token = f->curr_token;
-		// 	AstNode *name = names.e[0];
-		// 	if (names.count != 1) {
-		// 		syntax_error(proc_token, "You can only declare one procedure at a time");
-		// 		return make_bad_decl(f, name->Ident, proc_token);
-		// 	}
-
-		// 	return parse_proc_decl(f, proc_token, name);
-		// }
-
-		AstNodeArray values = parse_rhs_expr_list(f);
-		if (values.count > names.count) {
-			syntax_error(f->curr_token, "Too many values on the right hand side of the declaration");
-		} else if (values.count < names.count) {
-			syntax_error(f->curr_token, "All constant declarations must be defined");
-		} else if (values.count == 0) {
-			syntax_error(f->curr_token, "Expected an expression for this declaration");
-		}
-
-		if (values.count == 0 && names.count > 0) {
-			syntax_error(f->curr_token, "Missing constant value");
-			return make_bad_decl(f, f->curr_token, f->curr_token);
-		}
-
-		return make_const_decl(f, names, NULL, values);
-	} break;
+	// case Token_ColonColon: {
+	// 	AstNodeArray names = lhs;
+	// 	parse_check_name_list_for_reserves(f, names);
+
+	// 	Token colon_colon = expect_token(f, Token_ColonColon);
+
+	// 	// if (f->curr_token.kind == Token_type ||
+	// 	//     f->curr_token.kind == Token_struct ||
+	// 	//     f->curr_token.kind == Token_enum ||
+	// 	//     f->curr_token.kind == Token_union ||
+	// 	//     f->curr_token.kind == Token_raw_union) {
+	// 	// // if (f->curr_token.kind == Token_type) {
+	// 	// 	Token token = f->curr_token;
+	// 	// 	if (token.kind == Token_type) {
+	// 	// 		next_token(f);
+	// 	// 	}
+	// 	// 	if (names.count != 1) {
+	// 	// 		syntax_error_node(names.e[0], "You can only declare one type at a time");
+	// 	// 		return make_bad_decl(f, names.e[0]->Ident, token);
+	// 	// 	}
+
+	// 	// 	return make_type_decl(f, token, names.e[0], parse_type(f));
+	// 	// } else if (f->curr_token.kind == Token_proc) {
+	// 	//     // NOTE(bill): Procedure declarations
+	// 	// 	Token proc_token = f->curr_token;
+	// 	// 	AstNode *name = names.e[0];
+	// 	// 	if (names.count != 1) {
+	// 	// 		syntax_error(proc_token, "You can only declare one procedure at a time");
+	// 	// 		return make_bad_decl(f, name->Ident, proc_token);
+	// 	// 	}
+
+	// 	// 	return parse_proc_decl(f, proc_token, name);
+	// 	// }
+
+	// 	AstNodeArray values = parse_rhs_expr_list(f);
+	// 	if (values.count > names.count) {
+	// 		syntax_error(f->curr_token, "Too many values on the right hand side of the declaration");
+	// 	} else if (values.count < names.count) {
+	// 		syntax_error(f->curr_token, "All constant declarations must be defined");
+	// 	} else if (values.count == 0) {
+	// 		syntax_error(f->curr_token, "Expected an expression for this declaration");
+	// 	}
+
+	// 	if (values.count == 0 && names.count > 0) {
+	// 		syntax_error(f->curr_token, "Missing constant value");
+	// 		return make_bad_decl(f, f->curr_token, f->curr_token);
+	// 	}
+
+	// 	return make_const_decl(f, names, NULL, values);
+	// } break;
 	}
 
 	if (lhs_count > 1) {
@@ -2072,19 +2062,20 @@ AstNode *parse_proc_type(AstFile *f) {
 }
 
 
-AstNodeArray parse_parameter_list(AstFile *f, bool allow_using) {
+AstNodeArray parse_parameter_list(AstFile *f, bool allow_using, TokenKind follow) {
 	AstNodeArray params = make_ast_node_array(f);
 
-	while (f->curr_token.kind == Token_Ident ||
-	       f->curr_token.kind == Token_using) {
+	while (f->curr_token.kind != follow &&
+	       f->curr_token.kind != Token_EOF) {
 		bool is_using = false;
 		if (allow_token(f, Token_using)) {
 			is_using = true;
 		}
 
-		AstNodeArray names = parse_lhs_expr_list(f);
+		AstNodeArray names = parse_identfier_list(f);
 		if (names.count == 0) {
 			syntax_error(f->curr_token, "Empty parameter declaration");
+			break;
 		}
 
 		if (names.count > 1 && is_using) {
@@ -2097,7 +2088,7 @@ AstNodeArray parse_parameter_list(AstFile *f, bool allow_using) {
 			is_using = false;
 		}
 
-		expect_token_after(f, Token_Colon, "parameter list");
+		// expect_token_after(f, Token_Colon, "parameter list");
 
 		AstNode *type = NULL;
 		if (f->curr_token.kind == Token_Ellipsis) {
@@ -2124,17 +2115,16 @@ AstNodeArray parse_parameter_list(AstFile *f, bool allow_using) {
 		}
 
 		array_add(&params, make_parameter(f, names, type, is_using));
-		if (!parse_at_comma(f, str_lit("parameter list"), Token_CloseParen)) {
+		if (!allow_token(f, Token_Comma)) {
 			break;
 		}
-		next_token(f);
 	}
 
 	return params;
 }
 
 
-AstNodeArray parse_record_params(AstFile *f, isize *decl_count_, bool using_allowed, String context) {
+AstNodeArray parse_record_params(AstFile *f, isize *decl_count_, bool allow_using, String context) {
 	AstNodeArray decls = make_ast_node_array(f);
 	isize decl_count = 0;
 
@@ -2154,13 +2144,13 @@ AstNodeArray parse_record_params(AstFile *f, isize *decl_count_, bool using_allo
 
 			case AstNode_UsingStmt: {
 				bool is_using = true;
-				if (!using_allowed) {
+				if (!allow_using) {
 					syntax_error(f->curr_token, "Cannot apply `using` to members of a %.*s", LIT(context));
 					is_using = false;
 				}
 				if (decl->UsingStmt.node->kind == AstNode_VarDecl) {
 					AstNode *vd = decl->UsingStmt.node;
-					vd->VarDecl.is_using = is_using && using_allowed;
+					vd->VarDecl.is_using = is_using && allow_using;
 					if (vd->VarDecl.values.count > 0) {
 						syntax_error(f->curr_token, "Default variable assignments within a %.*s will be ignored", LIT(context));
 					}
@@ -2214,10 +2204,6 @@ AstNode *parse_identifier_or_type(AstFile *f) {
 		return e;
 	}
 
-	case Token_type:
-		expect_token(f, Token_type);
-		return parse_identifier_or_type(f);
-
 	case Token_Pointer: {
 		Token token = expect_token(f, Token_Pointer);
 		AstNode *elem = parse_type(f);
@@ -2358,27 +2344,10 @@ AstNode *parse_identifier_or_type(AstFile *f) {
 		close = expect_token(f, Token_CloseParen);
 		return type;
 		// return make_paren_expr(f, type, open, close);
-	}
-
-	// TODO(bill): Why is this even allowed? Is this a parsing error?
-	case Token_Colon:
-		break;
-
-	case Token_Eq:
-		if (f->prev_token.kind == Token_Colon) {
-			break;
-		}
-		// fallthrough
-	default: {
-		String prev = str_lit("newline");
-		if (str_ne(f->prev_token.string, str_lit("\n"))) {
-			prev = f->prev_token.string;
-		}
-		syntax_error(f->curr_token,
-		             "Expected a type or identifier after %.*s, got %.*s", LIT(prev), LIT(f->curr_token.string));
 	} break;
 	}
 
+	// No type found
 	return NULL;
 }
 
@@ -2411,7 +2380,7 @@ void parse_proc_signature(AstFile *f,
                           AstNodeArray *params,
                           AstNodeArray *results) {
 	expect_token(f, Token_OpenParen);
-	*params = parse_parameter_list(f, true);
+	*params = parse_parameter_list(f, true, Token_CloseParen);
 	expect_token_after(f, Token_CloseParen, "parameter list");
 	*results = parse_results(f);
 }
@@ -2777,6 +2746,64 @@ AstNode *parse_type_decl(AstFile *f) {
 	return decl;
 }
 
+AstNode *parse_value_decl(AstFile *f) {
+	Token token = f->curr_token;
+	switch (token.kind) {
+	case Token_var:
+	case Token_const:
+		next_token(f);
+		break;
+	default:
+		next_token(f);
+		syntax_error(token, "Expected a variable or constant declaration");
+		fix_advance_to_next_stmt(f);
+		return make_bad_decl(f, token, f->curr_token);
+	}
+
+	AstNodeArray names = parse_lhs_expr_list(f);
+	parse_check_name_list_for_reserves(f, names);
+	AstNode *type = parse_type_attempt(f);
+	AstNodeArray values = {0};
+
+	if (allow_token(f, Token_Eq)) {
+		values = parse_rhs_expr_list(f);
+	}
+
+	if (values.count > names.count) {
+		syntax_error(f->curr_token, "Too many values on the right hand side of the declaration");
+	} else if (token.kind == Token_const) {
+		if (values.count < names.count) {
+			syntax_error(f->curr_token, "All constant declarations must be defined");
+		} else if (values.count == 0) {
+			syntax_error(f->curr_token, "Expected an expression for this declaration");
+		}
+	}
+
+	if (type == NULL && values.count == 0 && names.count > 0) {
+		syntax_error(f->curr_token, "Missing type or initialization");
+		return make_bad_decl(f, f->curr_token, f->curr_token);
+	}
+
+	// TODO(bill): Fix this so it does not require it
+	if (values.e == NULL) {
+		values = make_ast_node_array(f);
+	}
+
+
+	AstNode *decl = NULL;
+
+	switch (token.kind) {
+	case Token_var:
+		decl = make_var_decl(f, names, type, values);
+		break;
+	case Token_const:
+		decl = make_const_decl(f, names, type, values);
+		break;
+	}
+	expect_semicolon(f, decl);
+	return decl;
+}
+
 AstNode *parse_stmt(AstFile *f) {
 	AstNode *s = NULL;
 	Token token = f->curr_token;
@@ -2816,9 +2843,11 @@ AstNode *parse_stmt(AstFile *f) {
 
 	case Token_proc:
 		return parse_proc_decl(f);
-
 	case Token_type:
 		return parse_type_decl(f);
+	case Token_var:
+	case Token_const:
+		return parse_value_decl(f);
 
 
 	case Token_using: {

src/tokenizer.c

@@ -74,7 +74,6 @@ TOKEN_KIND(Token__ComparisonEnd, "_ComparisonEnd"), \
 	TOKEN_KIND(Token_OpenBrace, "{"), \
 	TOKEN_KIND(Token_CloseBrace, "}"), \
 	TOKEN_KIND(Token_Colon, ":"), \
-	TOKEN_KIND(Token_ColonColon, "::"), \
 	TOKEN_KIND(Token_Semicolon, ";"), \
 	TOKEN_KIND(Token_Period, "."), \
 	TOKEN_KIND(Token_Comma, ","), \
@@ -835,10 +834,6 @@ Token tokenizer_get_token(Tokenizer *t) {
 			break;
 		case ':':
 			token.kind = Token_Colon;
-			if (t->curr_rune == ':') {
-				advance_to_next_rune(t);
-				token.kind = Token_ColonColon;
-			}
 			break;
 		case '(':
 			token.kind = Token_OpenParen;