Browse Source

Update default field value syntax; Use more declaration groupings

Ginger Bill 8 years ago
parent
commit
83bad13e9e
9 changed files with 273 additions and 236 deletions
  1. 1 4
      code/demo.odin
  2. 6 2
      core/decimal.odin
  3. 29 21
      core/fmt.odin
  4. 28 21
      core/hash.odin
  5. 69 58
      core/math.odin
  6. 12 11
      core/mem.odin
  7. 61 59
      core/opengl.odin
  8. 63 57
      core/sys/wgl.odin
  9. 4 3
      src/parser.cpp

+ 1 - 4
code/demo.odin

@@ -14,9 +14,6 @@ import (
 	"utf16.odin";
 )
 
-
 proc main() {
-	proc(s: string){
-		fmt.println(s, "world!");
-	}("Hellope");
+	fmt.println("Hellope!");
 }

+ 6 - 2
core/decimal.odin

@@ -78,8 +78,7 @@ proc assign(a: ^Decimal, i: u64) {
 	trim(a);
 }
 
-const uint_size = 8*size_of(uint);
-const max_shift = uint_size-4;
+
 
 proc shift_right(a: ^Decimal, k: uint) {
 	var r = 0; // read index
@@ -171,6 +170,11 @@ proc shift_left(a: ^Decimal, k: uint) {
 }
 
 proc shift(a: ^Decimal, k: int) {
+	const (
+		uint_size = 8*size_of(uint);
+		max_shift = uint_size-4;
+	)
+
 	match {
 	case a.count == 0:
 		// no need to update

+ 29 - 21
core/fmt.odin

@@ -583,8 +583,10 @@ proc _fmt_int(fi: ^FmtInfo, u: u128, base: int, is_signed: bool, bit_size: int,
 	_pad(fi, s);
 }
 
-let __DIGITS_LOWER = "0123456789abcdefx";
-let __DIGITS_UPPER = "0123456789ABCDEFX";
+let (
+	__DIGITS_LOWER = "0123456789abcdefx";
+	__DIGITS_UPPER = "0123456789ABCDEFX";
+)
 
 proc fmt_rune(fi: ^FmtInfo, r: rune, verb: rune) {
 	match verb {
@@ -732,10 +734,13 @@ proc fmt_enum(fi: ^FmtInfo, v: any, verb: rune) {
 		case 'd', 'f':
 			fmt_arg(fi, any{v.data, type_info_base(e.base)}, verb);
 		case 's', 'v':
-			var i: i128;
-			var f: f64;
-			var ok = false;
-			var a = any{v.data, type_info_base(e.base)};
+			var (
+				i:  i128;
+				f:  f64;
+				ok: bool;
+				a:  any;
+			)
+			a = any{v.data, type_info_base(e.base)};
 			match v in a {
 			case rune:  i = i128(v);
 			case i8:   i = i128(v);
@@ -810,6 +815,7 @@ proc fmt_value(fi: ^FmtInfo, v: any, verb: rune) {
 				}
 				write_string(fi.buf, b.names[i]);
 				write_string(fi.buf, " = ");
+
 				var data = ^u8(v.data) + b.offsets[i];
 				fmt_arg(fi, any{rawptr(data), b.types[i]}, 'v');
 			}
@@ -892,19 +898,20 @@ proc fmt_value(fi: ^FmtInfo, v: any, verb: rune) {
 
 		write_string(fi.buf, "map[");
 		defer write_byte(fi.buf, ']');
-		var entries = &(^raw.DynamicMap(v.data).entries);
-		var gs = type_info_base(info.generated_struct).(^Struct);
-		var ed = type_info_base(gs.types[1]).(^DynamicArray);
-
-		var entry_type = ed.elem.(^Struct);
-		var entry_size = ed.elem_size;
+		var (
+			entries    = &(^raw.DynamicMap(v.data).entries);
+			gs         = type_info_base(info.generated_struct).(^Struct);
+			ed         = type_info_base(gs.types[1]).(^DynamicArray);
+			entry_type = ed.elem.(^Struct);
+			entry_size = ed.elem_size;
+		)
 		for i in 0..<entries.len {
 			if i > 0 {
 				write_string(fi.buf, ", ");
 			}
 			var data = ^u8(entries.data) + i*entry_size;
-
 			var header = ^__MapEntryHeader(data);
+
 			if types.is_string(info.key) {
 				write_string(fi.buf, header.key.str);
 			} else {
@@ -939,7 +946,6 @@ proc fmt_value(fi: ^FmtInfo, v: any, verb: rune) {
 		defer write_byte(fi.buf, '}');
 
 		var cf = info.common_fields;
-
 		for _, i in cf.names {
 			if i > 0 {
 				write_string(fi.buf, ", ");
@@ -966,8 +972,7 @@ proc fmt_value(fi: ^FmtInfo, v: any, verb: rune) {
 proc fmt_complex(fi: ^FmtInfo, c: complex128, bits: int, verb: rune) {
 	match verb {
 	case 'f', 'F', 'v':
-		var r = real(c);
-		var i = imag(c);
+		var r, i = real(c), imag(c);
 		fmt_float(fi, r, bits/2, verb);
 		if !fi.plus && i >= 0 {
 			write_rune(fi.buf, '+');
@@ -1046,9 +1051,10 @@ proc fmt_arg(fi: ^FmtInfo, arg: any, verb: rune) {
 
 proc sbprint(buf: ^StringBuffer, args: ..any) -> string {
 	var fi: FmtInfo;
+	var prev_string = false;
+
 	fi.buf = buf;
 
-	var prev_string = false;
 	for arg, i in args {
 		var is_string = arg != nil && types.is_string(arg.type_info);
 		if i > 0 && !is_string && !prev_string {
@@ -1075,10 +1081,12 @@ proc sbprintln(buf: ^StringBuffer, args: ..any) -> string {
 }
 
 proc sbprintf(b: ^StringBuffer, fmt: string, args: ..any) -> string {
-	var fi = FmtInfo{};
-	var end = len(fmt);
-	var arg_index = 0;
-	var was_prev_index = false;
+	var (
+		end            = len(fmt);
+		arg_index: int = 0;
+		was_prev_index = false;
+		fi: FmtInfo;
+	)
 	for var i = 0; i < end; /**/ {
 		fi = FmtInfo{buf = b, good_arg_index = true};
 

+ 28 - 21
core/hash.odin

@@ -46,13 +46,17 @@ proc fnv64a(data: []u8) -> u64 {
 }
 
 proc murmur32(data: []u8) -> u32 {
-	const c1_32: u32 = 0xcc9e2d51;
-	const c2_32: u32 = 0x1b873593;
-
-	var h1: u32 = 0;
-	var nblocks = len(data)/4;
-	var p = &data[0];
-	var p1 = p + 4*nblocks;
+	const (
+		c1_32: u32 = 0xcc9e2d51;
+		c2_32: u32 = 0x1b873593;
+	)
+
+	var (
+		h1: u32 = 0;
+		nblocks = len(data)/4;
+		p = &data[0];
+		p1 = p + 4*nblocks;
+	)
 
 	for ; p < p1; p += 4 {
 		var k1 = ^u32(p)^;
@@ -67,7 +71,6 @@ proc murmur32(data: []u8) -> u32 {
 	}
 
 	var tail = data[nblocks*4 ..];
-
 	var k1: u32;
 	match len(tail)&3 {
 	case 3:
@@ -99,8 +102,10 @@ proc murmur64(data: []u8) -> u64 {
 	const SEED = 0x9747b28c;
 
 	when size_of(int) == 8 {
-		const m = 0xc6a4a7935bd1e995;
-		const r = 47;
+		const (
+			m = 0xc6a4a7935bd1e995;
+			r = 47;
+		)
 
 		var h: u64 = SEED ~ (u64(len(data)) * m);
 		var data64 = slice_ptr(^u64(&data[0]), len(data)/size_of(u64));
@@ -134,16 +139,19 @@ proc murmur64(data: []u8) -> u64 {
 
 		return h;
 	} else {
-		const m = 0x5bd1e995;
-		const r = 24;
-
-		var h1 = u32(SEED) ~ u32(len(data));
-		var h2 = u32(SEED) >> 32;
+		const (
+			m = 0x5bd1e995;
+			r = 24;
+		)
+
+		var (
+			h1 = u32(SEED) ~ u32(len(data));
+			h2 = u32(SEED) >> 32;
+			data32 = slice_ptr(^u32(&data[0]), len(data)/size_of(u32));
+			len = len(data);
+			i = 0;
+		)
 
-		var data32 = slice_ptr(cast(^u32)&data[0], len(data)/size_of(u32));
-		var len = len(data);
-
-		var i = 0;
 		for len >= 8 {
 			var k1, k2: u32;
 			k1 = data32[i]; i++;
@@ -197,8 +205,7 @@ proc murmur64(data: []u8) -> u64 {
 		h2 ~= h1>>19;
 		h2 *= m;
 
-		var h = cast(u64)(h1)<<32 | cast(u64)(h2);
-		return h;
+		return u64(h1)<<32 | u64(h2);
 	}
 }
 

+ 69 - 58
core/math.odin

@@ -22,7 +22,7 @@ type (
 	Vec3 [vector 3]f32;
 	Vec4 [vector 4]f32;
 
-// Column major
+	// Column major
 	Mat2 [2][2]f32;
 	Mat3 [3][3]f32;
 	Mat4 [4][4]f32;
@@ -88,16 +88,18 @@ proc remainder(x, y: f32) -> f32 { return x - round(x/y) * y; }
 proc remainder(x, y: f64) -> f64 { return x - round(x/y) * y; }
 
 proc mod(x, y: f32) -> f32 {
+	var result: f32;
 	y = abs(y);
-	var result = remainder(abs(x), y);
+	result = remainder(abs(x), y);
 	if sign(result) < 0 {
 		result += y;
 	}
 	return copy_sign(result, x);
 }
 proc mod(x, y: f64) -> f64 {
+	var result: f64;
 	y = abs(y);
-	var result = remainder(abs(x), y);
+	result = remainder(abs(x), y);
 	if sign(result) < 0 {
 		result += y;
 	}
@@ -198,25 +200,27 @@ proc mul(m: Mat4, v: Vec4) -> Vec4 {
 proc inverse(m: Mat4) -> Mat4 {
 	var o: Mat4;
 
-	var sf00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
-	var sf01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
-	var sf02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
-	var sf03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
-	var sf04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
-	var sf05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
-	var sf06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
-	var sf07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
-	var sf08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
-	var sf09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
-	var sf10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
-	var sf11 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
-	var sf12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
-	var sf13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
-	var sf14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
-	var sf15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
-	var sf16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
-	var sf17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
-	var sf18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
+	var (
+		sf00 = m[2][2] * m[3][3] - m[3][2] * m[2][3];
+		sf01 = m[2][1] * m[3][3] - m[3][1] * m[2][3];
+		sf02 = m[2][1] * m[3][2] - m[3][1] * m[2][2];
+		sf03 = m[2][0] * m[3][3] - m[3][0] * m[2][3];
+		sf04 = m[2][0] * m[3][2] - m[3][0] * m[2][2];
+		sf05 = m[2][0] * m[3][1] - m[3][0] * m[2][1];
+		sf06 = m[1][2] * m[3][3] - m[3][2] * m[1][3];
+		sf07 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+		sf08 = m[1][1] * m[3][2] - m[3][1] * m[1][2];
+		sf09 = m[1][0] * m[3][3] - m[3][0] * m[1][3];
+		sf10 = m[1][0] * m[3][2] - m[3][0] * m[1][2];
+		sf11 = m[1][1] * m[3][3] - m[3][1] * m[1][3];
+		sf12 = m[1][0] * m[3][1] - m[3][0] * m[1][1];
+		sf13 = m[1][2] * m[2][3] - m[2][2] * m[1][3];
+		sf14 = m[1][1] * m[2][3] - m[2][1] * m[1][3];
+		sf15 = m[1][1] * m[2][2] - m[2][1] * m[1][2];
+		sf16 = m[1][0] * m[2][3] - m[2][0] * m[1][3];
+		sf17 = m[1][0] * m[2][2] - m[2][0] * m[1][2];
+		sf18 = m[1][0] * m[2][1] - m[2][0] * m[1][1];
+	)
 
 	o[0][0] = +(m[1][1] * sf00 - m[1][2] * sf01 + m[1][3] * sf02);
 	o[0][1] = -(m[1][0] * sf00 - m[1][2] * sf03 + m[1][3] * sf04);
@@ -274,13 +278,15 @@ proc mat4_translate(v: Vec3) -> Mat4 {
 }
 
 proc mat4_rotate(v: Vec3, angle_radians: f32) -> Mat4 {
-	var c = cos(angle_radians);
-	var s = sin(angle_radians);
+	var (
+		c = cos(angle_radians);
+		s = sin(angle_radians);
 
-	var a = norm(v);
-	var t = a * (1-c);
+		a = norm(v);
+		t = a * (1-c);
 
-	var rot = mat4_identity();
+		rot = mat4_identity();
+	)
 
 	rot[0][0] = c + t.x*a.x;
 	rot[0][1] = 0 + t.x*a.y + s*a.z;
@@ -316,9 +322,11 @@ proc scale(m: Mat4, s: f32) -> Mat4 {
 
 
 proc look_at(eye, centre, up: Vec3) -> Mat4 {
-	var f = norm(centre - eye);
-	var s = norm(cross(f, up));
-	var u = cross(s, f);
+	var (
+		f = norm(centre - eye);
+		s = norm(cross(f, up));
+		u = cross(s, f);
+	)
 
 	return Mat4{
 		{+s.x, +u.x, -f.x, 0},
@@ -329,8 +337,10 @@ proc look_at(eye, centre, up: Vec3) -> Mat4 {
 }
 
 proc perspective(fovy, aspect, near, far: f32) -> Mat4 {
-	var m: Mat4;
-	var tan_half_fovy = tan(0.5 * fovy);
+	var (
+		m: Mat4;
+		tan_half_fovy = tan(0.5 * fovy);
+	)
 	m[0][0] = 1.0 / (aspect*tan_half_fovy);
 	m[1][1] = 1.0 / (tan_half_fovy);
 	m[2][2] = -(far + near) / (far - near);
@@ -354,29 +364,30 @@ proc ortho3d(left, right, bottom, top, near, far: f32) -> Mat4 {
 
 
 
-
-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
+const (
+	F32_DIG        = 6;
+	F32_EPSILON    = 1.192092896e-07;
+	F32_GUARD      = 0;
+	F32_MANT_DIG   = 24;
+	F32_MAX        = 3.402823466e+38;
+	F32_MAX_10_EXP = 38;
+	F32_MAX_EXP    = 128;
+	F32_MIN        = 1.175494351e-38;
+	F32_MIN_10_EXP = -37;
+	F32_MIN_EXP    = -125;
+	F32_NORMALIZE  = 0;
+	F32_RADIX      = 2;
+	F32_ROUNDS     = 1;
+
+	F64_DIG        = 15;                       // # of decimal digits of precision
+	F64_EPSILON    = 2.2204460492503131e-016;  // smallest such that 1.0+F64_EPSILON != 1.0
+	F64_MANT_DIG   = 53;                       // # of bits in mantissa
+	F64_MAX        = 1.7976931348623158e+308;  // max value
+	F64_MAX_10_EXP = 308;                      // max decimal exponent
+	F64_MAX_EXP    = 1024;                     // max binary exponent
+	F64_MIN        = 2.2250738585072014e-308;  // min positive value
+	F64_MIN_10_EXP = -307;                     // min decimal exponent
+	F64_MIN_EXP    = -1021;                    // min binary exponent
+	F64_RADIX      = 2;                        // exponent radix
+	F64_ROUNDS     = 1;                        // addition rounding: near
+)

+ 12 - 11
core/mem.odin

@@ -80,18 +80,19 @@ proc allocation_header(data: rawptr) -> ^AllocationHeader {
 
 
 // Custom allocators
-type Arena struct {
-	backing:    Allocator,
-	offset:     int,
-	memory:     []u8,
-	temp_count: int,
-}
-
-type ArenaTempMemory struct {
-	arena:          ^Arena,
-	original_count: int,
-}
+type (
+	Arena struct {
+		backing:    Allocator,
+		offset:     int,
+		memory:     []u8,
+		temp_count: int,
+	}
 
+	ArenaTempMemory struct {
+		arena:          ^Arena,
+		original_count: int,
+	}
+)
 
 
 

+ 61 - 59
core/opengl.odin

@@ -52,65 +52,67 @@ proc get_proc_address(name: string) -> proc() #cc_c {
 	return res;
 }
 
-var GenBuffers:               proc(count: i32, buffers: ^u32) #cc_c;
-var GenVertexArrays:          proc(count: i32, buffers: ^u32) #cc_c;
-var GenSamplers:              proc(count: i32, buffers: ^u32) #cc_c;
-var DeleteBuffers:            proc(count: i32, buffers: ^u32) #cc_c;
-var BindBuffer:               proc(target: i32, buffer: u32) #cc_c;
-var BindVertexArray:          proc(buffer: u32) #cc_c;
-var DeleteVertexArrays:       proc(count: i32, arrays: ^u32) #cc_c;
-var BindSampler:              proc(position: i32, sampler: u32) #cc_c;
-var BufferData:               proc(target: i32, size: int, data: rawptr, usage: i32) #cc_c;
-var BufferSubData:            proc(target: i32, offset, size: int, data: rawptr) #cc_c;
-
-var DrawArrays:               proc(mode, first: i32, count: u32) #cc_c;
-var DrawElements:             proc(mode: i32, count: u32, type_: i32, indices: rawptr) #cc_c;
-
-var MapBuffer:                proc(target, access: i32) -> rawptr #cc_c;
-var UnmapBuffer:              proc(target: i32) #cc_c;
-
-var VertexAttribPointer:      proc(index: u32, size, type_: i32, normalized: i32, stride: u32, pointer: rawptr) #cc_c;
-var EnableVertexAttribArray:  proc(index: u32) #cc_c;
-
-var CreateShader:             proc(shader_type: i32) -> u32 #cc_c;
-var ShaderSource:             proc(shader: u32, count: u32, str: ^^u8, length: ^i32) #cc_c;
-var CompileShader:            proc(shader: u32) #cc_c;
-var CreateProgram:            proc() -> u32 #cc_c;
-var AttachShader:             proc(program, shader: u32) #cc_c;
-var DetachShader:             proc(program, shader: u32) #cc_c;
-var DeleteShader:             proc(shader:  u32) #cc_c;
-var LinkProgram:              proc(program: u32) #cc_c;
-var UseProgram:               proc(program: u32) #cc_c;
-var DeleteProgram:            proc(program: u32) #cc_c;
-
-
-var GetShaderiv:              proc(shader:  u32, pname: i32, params: ^i32) #cc_c;
-var GetProgramiv:             proc(program: u32, pname: i32, params: ^i32) #cc_c;
-var GetShaderInfoLog:         proc(shader:  u32, max_length: u32, length: ^u32, info_long: ^u8) #cc_c;
-var GetProgramInfoLog:        proc(program: u32, max_length: u32, length: ^u32, info_long: ^u8) #cc_c;
-
-var ActiveTexture:            proc(texture: i32) #cc_c;
-var GenerateMipmap:           proc(target:  i32) #cc_c;
-
-var SamplerParameteri:        proc(sampler: u32, pname: i32, param: i32) #cc_c;
-var SamplerParameterf:        proc(sampler: u32, pname: i32, param: f32) #cc_c;
-var SamplerParameteriv:       proc(sampler: u32, pname: i32, params: ^i32) #cc_c;
-var SamplerParameterfv:       proc(sampler: u32, pname: i32, params: ^f32) #cc_c;
-var SamplerParameterIiv:      proc(sampler: u32, pname: i32, params: ^i32) #cc_c;
-var SamplerParameterIuiv:     proc(sampler: u32, pname: i32, params: ^u32) #cc_c;
-
-
-var Uniform1i:                proc(loc: i32, v0: i32) #cc_c;
-var Uniform2i:                proc(loc: i32, v0, v1: i32) #cc_c;
-var Uniform3i:                proc(loc: i32, v0, v1, v2: i32) #cc_c;
-var Uniform4i:                proc(loc: i32, v0, v1, v2, v3: i32) #cc_c;
-var Uniform1f:                proc(loc: i32, v0: f32) #cc_c;
-var Uniform2f:                proc(loc: i32, v0, v1: f32) #cc_c;
-var Uniform3f:                proc(loc: i32, v0, v1, v2: f32) #cc_c;
-var Uniform4f:                proc(loc: i32, v0, v1, v2, v3: f32) #cc_c;
-var UniformMatrix4fv:         proc(loc: i32, count: u32, transpose: i32, value: ^f32) #cc_c;
-
-var GetUniformLocation:       proc(program: u32, name: ^u8) -> i32 #cc_c;
+var (
+	GenBuffers:               proc(count: i32, buffers: ^u32) #cc_c;
+	GenVertexArrays:          proc(count: i32, buffers: ^u32) #cc_c;
+	GenSamplers:              proc(count: i32, buffers: ^u32) #cc_c;
+	DeleteBuffers:            proc(count: i32, buffers: ^u32) #cc_c;
+	BindBuffer:               proc(target: i32, buffer: u32) #cc_c;
+	BindVertexArray:          proc(buffer: u32) #cc_c;
+	DeleteVertexArrays:       proc(count: i32, arrays: ^u32) #cc_c;
+	BindSampler:              proc(position: i32, sampler: u32) #cc_c;
+	BufferData:               proc(target: i32, size: int, data: rawptr, usage: i32) #cc_c;
+	BufferSubData:            proc(target: i32, offset, size: int, data: rawptr) #cc_c;
+
+	DrawArrays:               proc(mode, first: i32, count: u32) #cc_c;
+	DrawElements:             proc(mode: i32, count: u32, type_: i32, indices: rawptr) #cc_c;
+
+	MapBuffer:                proc(target, access: i32) -> rawptr #cc_c;
+	UnmapBuffer:              proc(target: i32) #cc_c;
+
+	VertexAttribPointer:      proc(index: u32, size, type_: i32, normalized: i32, stride: u32, pointer: rawptr) #cc_c;
+	EnableVertexAttribArray:  proc(index: u32) #cc_c;
+
+	CreateShader:             proc(shader_type: i32) -> u32 #cc_c;
+	ShaderSource:             proc(shader: u32, count: u32, str: ^^u8, length: ^i32) #cc_c;
+	CompileShader:            proc(shader: u32) #cc_c;
+	CreateProgram:            proc() -> u32 #cc_c;
+	AttachShader:             proc(program, shader: u32) #cc_c;
+	DetachShader:             proc(program, shader: u32) #cc_c;
+	DeleteShader:             proc(shader:  u32) #cc_c;
+	LinkProgram:              proc(program: u32) #cc_c;
+	UseProgram:               proc(program: u32) #cc_c;
+	DeleteProgram:            proc(program: u32) #cc_c;
+
+
+	GetShaderiv:              proc(shader:  u32, pname: i32, params: ^i32) #cc_c;
+	GetProgramiv:             proc(program: u32, pname: i32, params: ^i32) #cc_c;
+	GetShaderInfoLog:         proc(shader:  u32, max_length: u32, length: ^u32, info_long: ^u8) #cc_c;
+	GetProgramInfoLog:        proc(program: u32, max_length: u32, length: ^u32, info_long: ^u8) #cc_c;
+
+	ActiveTexture:            proc(texture: i32) #cc_c;
+	GenerateMipmap:           proc(target:  i32) #cc_c;
+
+	SamplerParameteri:        proc(sampler: u32, pname: i32, param: i32) #cc_c;
+	SamplerParameterf:        proc(sampler: u32, pname: i32, param: f32) #cc_c;
+	SamplerParameteriv:       proc(sampler: u32, pname: i32, params: ^i32) #cc_c;
+	SamplerParameterfv:       proc(sampler: u32, pname: i32, params: ^f32) #cc_c;
+	SamplerParameterIiv:      proc(sampler: u32, pname: i32, params: ^i32) #cc_c;
+	SamplerParameterIuiv:     proc(sampler: u32, pname: i32, params: ^u32) #cc_c;
+
+
+	Uniform1i:                proc(loc: i32, v0: i32) #cc_c;
+	Uniform2i:                proc(loc: i32, v0, v1: i32) #cc_c;
+	Uniform3i:                proc(loc: i32, v0, v1, v2: i32) #cc_c;
+	Uniform4i:                proc(loc: i32, v0, v1, v2, v3: i32) #cc_c;
+	Uniform1f:                proc(loc: i32, v0: f32) #cc_c;
+	Uniform2f:                proc(loc: i32, v0, v1: f32) #cc_c;
+	Uniform3f:                proc(loc: i32, v0, v1, v2: f32) #cc_c;
+	Uniform4f:                proc(loc: i32, v0, v1, v2, v3: f32) #cc_c;
+	UniformMatrix4fv:         proc(loc: i32, count: u32, transpose: i32, value: ^f32) #cc_c;
+
+	GetUniformLocation:       proc(program: u32, name: ^u8) -> i32 #cc_c;
+)
 
 proc init() {
 	proc set_proc_address(p: rawptr, name: string) #inline {

+ 63 - 57
core/sys/wgl.odin

@@ -1,67 +1,73 @@
 foreign_system_library "opengl32.lib" when ODIN_OS == "windows";
 import . "windows.odin";
 
-const CONTEXT_MAJOR_VERSION_ARB          = 0x2091;
-const CONTEXT_MINOR_VERSION_ARB          = 0x2092;
-const CONTEXT_FLAGS_ARB                  = 0x2094;
-const CONTEXT_PROFILE_MASK_ARB           = 0x9126;
-const CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = 0x0002;
-const CONTEXT_CORE_PROFILE_BIT_ARB       = 0x00000001;
-const CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = 0x00000002;
+const (
+	CONTEXT_MAJOR_VERSION_ARB          = 0x2091;
+	CONTEXT_MINOR_VERSION_ARB          = 0x2092;
+	CONTEXT_FLAGS_ARB                  = 0x2094;
+	CONTEXT_PROFILE_MASK_ARB           = 0x9126;
+	CONTEXT_FORWARD_COMPATIBLE_BIT_ARB = 0x0002;
+	CONTEXT_CORE_PROFILE_BIT_ARB       = 0x00000001;
+	CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB = 0x00000002;
+)
 
-type Hglrc    Handle;
-type ColorRef u32;
+type (
+	Hglrc    Handle;
+	ColorRef u32;
 
-type LayerPlaneDescriptor struct {
-	size:             u16,
-	version:          u16,
-	flags:            u32,
-	pixel_type:       u8,
-	color_bits:       u8,
-	red_bits:         u8,
-	red_shift:        u8,
-	green_bits:       u8,
-	green_shift:      u8,
-	blue_bits:        u8,
-	blue_shift:       u8,
-	alpha_bits:       u8,
-	alpha_shift:      u8,
-	accum_bits:       u8,
-	accum_red_bits:   u8,
-	accum_green_bits: u8,
-	accum_blue_bits:  u8,
-	accum_alpha_bits: u8,
-	depth_bits:       u8,
-	stencil_bits:     u8,
-	aux_buffers:      u8,
-	layer_type:       u8,
-	reserved:         u8,
-	transparent:      ColorRef,
-}
+	LayerPlaneDescriptor struct {
+		size:             u16,
+		version:          u16,
+		flags:            u32,
+		pixel_type:       u8,
+		color_bits:       u8,
+		red_bits:         u8,
+		red_shift:        u8,
+		green_bits:       u8,
+		green_shift:      u8,
+		blue_bits:        u8,
+		blue_shift:       u8,
+		alpha_bits:       u8,
+		alpha_shift:      u8,
+		accum_bits:       u8,
+		accum_red_bits:   u8,
+		accum_green_bits: u8,
+		accum_blue_bits:  u8,
+		accum_alpha_bits: u8,
+		depth_bits:       u8,
+		stencil_bits:     u8,
+		aux_buffers:      u8,
+		layer_type:       u8,
+		reserved:         u8,
+		transparent:      ColorRef,
+	}
 
-type PointFloat struct {
-	x, y: f32,
-}
+	PointFloat struct {
+		x, y: f32,
+	}
 
-type Glyph_MetricsFloat struct {
-	black_box_x:  f32,
-	black_box_y:  f32,
-	glyph_origin: PointFloat,
-	cell_inc_x:   f32,
-	cell_inc_y:   f32,
-}
+	Glyph_MetricsFloat struct {
+		black_box_x:  f32,
+		black_box_y:  f32,
+		glyph_origin: PointFloat,
+		cell_inc_x:   f32,
+		cell_inc_y:   f32,
+	}
+)
 
-type CreateContextAttribsARBType proc(hdc: Hdc, h_share_context: rawptr, attribList: ^i32) -> Hglrc;
-type ChoosePixelFormatARBType    proc(hdc: Hdc, attrib_i_list: ^i32, attrib_f_list: ^f32, max_formats: u32, formats: ^i32, num_formats : ^u32) -> Bool #cc_c;
-type SwapIntervalEXTType         proc(interval: i32) -> bool #cc_c;
-type GetExtensionsStringARBType  proc(Hdc) -> ^u8 #cc_c;
-
-
-var create_context_attribs_arb: CreateContextAttribsARBType;
-var choose_pixel_format_arb:    ChoosePixelFormatARBType;
-var swap_interval_ext:          SwapIntervalEXTType;
-var get_extensions_string_arb:  GetExtensionsStringARBType;
+type (
+	CreateContextAttribsARBType proc(hdc: Hdc, h_share_context: rawptr, attribList: ^i32) -> Hglrc;
+	ChoosePixelFormatARBType    proc(hdc: Hdc, attrib_i_list: ^i32, attrib_f_list: ^f32, max_formats: u32, formats: ^i32, num_formats : ^u32) -> Bool #cc_c;
+	SwapIntervalEXTType         proc(interval: i32) -> bool #cc_c;
+	GetExtensionsStringARBType  proc(Hdc) -> ^u8 #cc_c;
+)
 
+var (
+	create_context_attribs_arb: CreateContextAttribsARBType;
+	choose_pixel_format_arb:    ChoosePixelFormatARBType;
+	swap_interval_ext:          SwapIntervalEXTType;
+	get_extensions_string_arb:  GetExtensionsStringARBType;
+)
 
 
 proc create_context           (hdc: Hdc) -> Hglrc                                                                                                 #foreign opengl32 "wglCreateContext";
@@ -73,9 +79,9 @@ proc create_layer_context     (hdc: Hdc, layer_plane: i32) -> Hglrc
 proc describe_layer_plane     (hdc: Hdc, pixel_format, layer_plane: i32, bytes: u32, pd: ^LayerPlaneDescriptor) -> Bool                           #foreign opengl32 "wglDescribeLayerPlane";
 proc get_current_context      () -> Hglrc                                                                                                         #foreign opengl32 "wglGetCurrentContext";
 proc get_current_dc           () -> Hdc                                                                                                           #foreign opengl32 "wglGetCurrentDC";
-proc get_layer_palette_entries(hdc: Hdc, layer_plane, start, entries: i32, cr: ^ColorRef) -> i32                                                 #foreign opengl32 "wglGetLayerPaletteEntries";
+proc get_layer_palette_entries(hdc: Hdc, layer_plane, start, entries: i32, cr: ^ColorRef) -> i32                                                  #foreign opengl32 "wglGetLayerPaletteEntries";
 proc realize_layer_palette    (hdc: Hdc, layer_plane: i32, realize: Bool) -> Bool                                                                 #foreign opengl32 "wglRealizeLayerPalette";
-proc set_layer_palette_entries(hdc: Hdc, layer_plane, start, entries: i32, cr: ^ColorRef) -> i32                                                 #foreign opengl32 "wglSetLayerPaletteEntries";
+proc set_layer_palette_entries(hdc: Hdc, layer_plane, start, entries: i32, cr: ^ColorRef) -> i32                                                  #foreign opengl32 "wglSetLayerPaletteEntries";
 proc share_lists              (hglrc1, hglrc2: Hglrc) -> Bool                                                                                     #foreign opengl32 "wglShareLists";
 proc swap_layer_buffers       (hdc: Hdc, planes: u32) -> Bool                                                                                     #foreign opengl32 "wglSwapLayerBuffers";
 proc use_font_bitmaps         (hdc: Hdc, first, count, list_base: u32) -> Bool                                                                    #foreign opengl32 "wglUseFontBitmaps";

+ 4 - 3
src/parser.cpp

@@ -3125,7 +3125,8 @@ AstNode *parse_field_list(AstFile *f, isize *name_count_, u32 allowed_flags, Tok
 		next_token(f);
 	}
 
-	if (f->curr_token.kind == Token_Colon) {
+	if (f->curr_token.kind == Token_Colon ||
+	    f->curr_token.kind == Token_Eq) {
 		Array<AstNode *> names = convert_to_ident_list(f, list, true); // Copy for semantic reasons
 		if (names.count == 0) {
 			syntax_error(f->curr_token, "Empty field declaration");
@@ -3137,11 +3138,11 @@ AstNode *parse_field_list(AstFile *f, isize *name_count_, u32 allowed_flags, Tok
 		set_flags = check_field_prefixes(f, names.count, allowed_flags, set_flags);
 		total_name_count += names.count;
 
-		expect_token_after(f, Token_Colon, "field list");
 		AstNode *type = NULL;
 		AstNode *default_value = NULL;
 
 		if (f->curr_token.kind != Token_Eq) {
+			expect_token_after(f, Token_Colon, "field list");
 			type = parse_var_type(f, allow_ellipsis);
 		}
 		if (allow_token(f, Token_Eq)) {
@@ -3172,10 +3173,10 @@ AstNode *parse_field_list(AstFile *f, isize *name_count_, u32 allowed_flags, Tok
 			set_flags = check_field_prefixes(f, names.count, allowed_flags, set_flags);
 			total_name_count += names.count;
 
-			expect_token_after(f, Token_Colon, "field list");
 			AstNode *type = NULL;
 			AstNode *default_value = NULL;
 			if (f->curr_token.kind != Token_Eq) {
+				expect_token_after(f, Token_Colon, "field list");
 				type = parse_var_type(f, allow_ellipsis);
 			}
 			if (allow_token(f, Token_Eq)) {