Merge remote-tracking branch 'upstream/master' into parser-fix

core/compress/common.odin

@@ -5,6 +5,9 @@
 	List of contributors:
 		Jeroen van Rijn: Initial implementation, optimization.
 */
+
+
+// package compress is a collection of utilities to aid with other compression packages
 package compress
 
 import "core:io"

core/encoding/hxa/doc.odin

@@ -27,7 +27,7 @@
 // 	Construction history, or BSP trees would make the format too large to serve its purpose.
 // 	The facilities of the formats to store meta data should make the format flexible enough
 // 	for most uses. Adding HxA support should be something anyone can do in a days work.
-
+//
 // Structure:
 // ----------
 // HxA is designed to be extremely simple to parse, and is therefore based around conventions. It has
@@ -45,17 +45,17 @@
 // of a number of named layers. All layers in the stack have the same number of elements. Each layer
 // describes one property of the primitive. Each layer can have multiple channels and each layer can
 // store data of a different type.
-
+//
 // HaX stores 3 kinds of nodes
 // 	- Pixel data.
 // 	- Polygon geometry data.
 // 	- Meta data only.
-
+//
 // Pixel Nodes stores pixels in a layer stack. A layer may store things like Albedo, Roughness,
 // Reflectance, Light maps, Masks, Normal maps, and Displacement. Layers use the channels of the
 // layers to store things like color. The length of the layer stack is determined by the type and
 // dimensions stored in the
-
+//
 // Geometry data is stored in 3 separate layer stacks for: vertex data, corner data and face data. The
 // vertex data stores things like verities, blend shapes, weight maps, and vertex colors. The first
 // layer in a vertex stack has to be a 3 channel layer named "position" describing the base position
@@ -63,7 +63,7 @@
 // for things like UV, normals, and adjacency. The first layer in a corner stack has to be a 1 channel
 // integer layer named "index" describing the vertices used to form polygons. The last value in each
 // polygon has a negative - 1 index to indicate the end of the polygon.
-
+//
 // Example:
 // 	A quad and a tri with the vertex index:
 // 		[0, 1, 2, 3] [1, 4, 2]
@@ -72,7 +72,7 @@
 // The face stack stores values per face. the length of the face stack has to match the number of
 // negative values in the index layer in the corner stack. The face stack can be used to store things
 // like material index.
-
+//
 // Storage
 // -------
 // All data is stored in little endian byte order with no padding. The layout mirrors the structs

core/fmt/doc.odin

@@ -64,6 +64,7 @@ If not present, the width is whatever is necessary to represent the value.
 Precision is specified after the (optional) width followed by a period followed by a decimal number.
 If no period is present, a default precision is used.
 A period with no following number specifies a precision of 0.
+
 Examples:
 	%f     default width, default precision
 	%8f    width 8, default precision
@@ -84,7 +85,6 @@ Other flags:
 	               add leading 0z for dozenal (%#z)
 	               add leading 0x or 0X for hexadecimal (%#x or %#X)
 	               remove leading 0x for %p (%#p)
-
 	' '    (space) leave a space for elided sign in numbers (% d)
 	0      pad with leading zeros rather than spaces
 

core/image/common.odin

@@ -6,6 +6,8 @@
 		Jeroen van Rijn: Initial implementation, optimization.
 		Ginger Bill:     Cosmetic changes.
 */
+
+// package image implements a general 2D image library to be used with other image related packages
 package image
 
 import "core:bytes"

core/image/png/png.odin

@@ -6,6 +6,11 @@
 		Jeroen van Rijn: Initial implementation.
 		Ginger Bill:     Cosmetic changes.
 */
+
+
+// package png implements a PNG image reader
+//
+// The PNG specification is at https://www.w3.org/TR/PNG/.
 package png
 
 import "core:compress"

core/math/big/api.odin

@@ -2,12 +2,10 @@
 	Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.
 	Made available under Odin's BSD-3 license.
 
-	An arbitrary precision mathematics implementation in Odin.
-	For the theoretical underpinnings, see Knuth's The Art of Computer Programming, Volume 2, section 4.3.
-	The code started out as an idiomatic source port of libTomMath, which is in the public domain, with thanks.
-
 	This file collects public proc maps and their aliases.
 */
+
+
 package math_big
 /*
 

core/math/big/common.odin

@@ -1,11 +1,9 @@
 /*
 	Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.
 	Made available under Odin's BSD-3 license.
-
-	An arbitrary precision mathematics implementation in Odin.
-	For the theoretical underpinnings, see Knuth's The Art of Computer Programming, Volume 2, section 4.3.
-	The code started out as an idiomatic source port of libTomMath, which is in the public domain, with thanks.
 */
+
+
 package math_big
 
 import "core:intrinsics"

core/math/big/doc.odin

@@ -0,0 +1,6 @@
+/*
+A BigInt implementation in Odin.
+For the theoretical underpinnings, see Knuth's The Art of Computer Programming, Volume 2, section 4.3.
+The code started out as an idiomatic source port of libTomMath, which is in the public domain, with thanks.
+*/
+package math_big

core/math/big/helpers.odin

@@ -1,11 +1,9 @@
 /*
 	Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.
 	Made available under Odin's BSD-3 license.
-
-	An arbitrary precision mathematics implementation in Odin.
-	For the theoretical underpinnings, see Knuth's The Art of Computer Programming, Volume 2, section 4.3.
-	The code started out as an idiomatic source port of libTomMath, which is in the public domain, with thanks.
 */
+
+
 package math_big
 
 import "core:intrinsics"

core/math/big/internal.odin

@@ -1,12 +1,7 @@
-//+ignore
 /*
 	Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.
 	Made available under Odin's BSD-3 license.
 
-	A BigInt implementation in Odin.
-	For the theoretical underpinnings, see Knuth's The Art of Computer Programming, Volume 2, section 4.3.
-	The code started out as an idiomatic source port of libTomMath, which is in the public domain, with thanks.
-
 	==========================    Low-level routines    ==========================
 
 	IMPORTANT: `internal_*` procedures make certain assumptions about their input.
@@ -29,6 +24,9 @@
 
 	TODO: Handle +/- Infinity and NaN.
 */
+
+
+//+ignore
 package math_big
 
 import "core:mem"

core/math/big/logical.odin

@@ -8,6 +8,8 @@
 
 	This file contains logical operations like `and`, `or` and `xor`.
 */
+
+
 package math_big
 
 /*

core/math/big/prime.odin

@@ -8,6 +8,8 @@
 
 	This file contains prime finding operations.
 */
+
+
 package math_big
 
 import rnd "core:math/rand"

core/math/big/private.odin

@@ -15,6 +15,8 @@
 
 	These aren't exported for the same reasons.
 */
+
+
 package math_big
 
 import "core:intrinsics"

core/math/big/public.odin

@@ -8,6 +8,8 @@
 
 	This file contains basic arithmetic operations like `add`, `sub`, `mul`, `div`, ...
 */
+
+
 package math_big
 
 import "core:intrinsics"

core/math/big/radix.odin

@@ -12,6 +12,8 @@
 		- Use Barrett reduction for non-powers-of-two.
 		- Also look at extracting and splatting several digits at once.
 */
+
+
 package math_big
 
 import "core:intrinsics"

core/math/big/tune.odin

@@ -1,4 +1,3 @@
-//+ignore
 /*
 	Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.
 	Made available under Odin's BSD-3 license.
@@ -7,6 +6,8 @@
 	For the theoretical underpinnings, see Knuth's The Art of Computer Programming, Volume 2, section 4.3.
 	The code started out as an idiomatic source port of libTomMath, which is in the public domain, with thanks.
 */
+
+//+ignore
 package math_big
 
 import "core:time"

core/odin/doc-format/doc_format.odin

@@ -11,7 +11,7 @@ String :: distinct Array(byte)
 
 Version_Type_Major :: 0
 Version_Type_Minor :: 2
-Version_Type_Patch :: 2
+Version_Type_Patch :: 3
 
 Version_Type :: struct {
 	major, minor, patch: u8,
@@ -107,6 +107,8 @@ Entity_Flag :: enum u32le {
 
 	Var_Thread_Local = 40,
 	Var_Static       = 41,
+
+	Private = 50,
 }
 
 Entity_Flags :: distinct bit_set[Entity_Flag; u64le]
@@ -122,6 +124,10 @@ Entity :: struct {
 	_:                u32le, // reserved for init
 	comment:          String,
 	docs:             String,
+	// May be used by (Struct fields and procedure fields):
+	// .Variable
+	// .Constant
+	field_group_index: i32le,
 
 	// May used by:
 	// .Variable

core/runtime/core_builtin_matrix.odin

@@ -146,14 +146,14 @@ matrix2x2_inverse_transpose :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y:
 	d := x[0, 0]*x[1, 1] - x[0, 1]*x[1, 0]
 	when intrinsics.type_is_integer(T) {
 		y[0, 0] = +x[1, 1] / d
-		y[1, 0] = -x[1, 0] / d
-		y[0, 1] = -x[0, 1] / d
+		y[1, 0] = -x[0, 1] / d
+		y[0, 1] = -x[1, 0] / d
 		y[1, 1] = +x[0, 0] / d
 	} else {
 		id := 1 / d
 		y[0, 0] = +x[1, 1] * id
-		y[1, 0] = -x[1, 0] * id
-		y[0, 1] = -x[0, 1] * id
+		y[1, 0] = -x[0, 1] * id
+		y[0, 1] = -x[1, 0] * id
 		y[1, 1] = +x[0, 0] * id
 	}
 	return
@@ -214,16 +214,16 @@ matrix1x1_inverse :: proc "contextless" (x: $M/matrix[1, 1]$T) -> (y: M) {
 matrix2x2_inverse :: proc "contextless" (x: $M/matrix[2, 2]$T) -> (y: M) {
 	d := x[0, 0]*x[1, 1] - x[0, 1]*x[1, 0]
 	when intrinsics.type_is_integer(T) {
-		y[0, 0] = x[1, 1] / d
-		y[0, 1] = x[1, 0] / d
-		y[1, 0] = x[0, 1] / d
-		y[1, 1] = x[0, 0] / d
+		y[0, 0] = +x[1, 1] / d
+		y[0, 1] = -x[0, 1] / d
+		y[1, 0] = -x[1, 0] / d
+		y[1, 1] = +x[0, 0] / d
 	} else {
 		id := 1 / d
-		y[0, 0] = x[1, 1] * id
-		y[0, 1] = x[1, 0] * id
-		y[1, 0] = x[0, 1] * id
-		y[1, 1] = x[0, 0] * id
+		y[0, 0] = +x[1, 1] * id
+		y[0, 1] = -x[0, 1] * id
+		y[1, 0] = -x[1, 0] * id
+		y[1, 1] = +x[0, 0] * id
 	}
 	return
 }

core/runtime/entry_unix.odin

@@ -5,13 +5,13 @@ package runtime
 import "core:intrinsics"
 
 when ODIN_BUILD_MODE == .Dynamic {
-	@(link_name="_odin_entry_point", linkage="strong", require, link_section=".init")
+	@(link_name="_odin_entry_point", linkage="strong", require/*, link_section=".init"*/)
 	_odin_entry_point :: proc "c" () {
 		context = default_context()
 		#force_no_inline _startup_runtime()
 		intrinsics.__entry_point()
 	}
-	@(link_name="_odin_exit_point", linkage="strong", require, link_section=".fini")
+	@(link_name="_odin_exit_point", linkage="strong", require/*, link_section=".fini"*/)
 	_odin_exit_point :: proc "c" () {
 		context = default_context()
 		#force_no_inline _cleanup_runtime()

core/sync/barrier.odin

@@ -1,44 +1,43 @@
 package sync
 
 
-// A barrier enabling multiple threads to synchronize the beginning of some computation
 /*
- * Example:
- *
- * 	package example
- *
- * 	import "core:fmt"
- * 	import "core:sync"
- * 	import "core:thread"
- *
- * 	barrier := &sync.Barrier{};
- *
- * 	main :: proc() {
- * 		fmt.println("Start");
- *
- * 		THREAD_COUNT :: 4;
- * 		threads: [THREAD_COUNT]^thread.Thread;
- *
- * 		sync.barrier_init(barrier, THREAD_COUNT);
- * 		defer sync.barrier_destroy(barrier);
- *
- *
- * 		for _, i in threads {
- * 			threads[i] = thread.create_and_start(proc(t: ^thread.Thread) {
- * 				// Same messages will be printed together but without any interleaving
- * 				fmt.println("Getting ready!");
- * 				sync.barrier_wait(barrier);
- * 				fmt.println("Off their marks they go!");
- * 			});
- * 		}
- *
- * 		for t in threads {
- * 			thread.destroy(t); // join and free thread
- * 		}
- * 		fmt.println("Finished");
- * 	}
- *
- */
+A barrier enabling multiple threads to synchronize the beginning of some computation
+Example:
+
+	package example
+
+	import "core:fmt"
+	import "core:sync"
+	import "core:thread"
+
+	barrier := &sync.Barrier{};
+
+	main :: proc() {
+		fmt.println("Start");
+
+		THREAD_COUNT :: 4;
+		threads: [THREAD_COUNT]^thread.Thread;
+
+		sync.barrier_init(barrier, THREAD_COUNT);
+		defer sync.barrier_destroy(barrier);
+
+
+		for _, i in threads {
+			threads[i] = thread.create_and_start(proc(t: ^thread.Thread) {
+				// Same messages will be printed together but without any interleaving
+				fmt.println("Getting ready!");
+				sync.barrier_wait(barrier);
+				fmt.println("Off their marks they go!");
+			});
+		}
+
+		for t in threads {
+			thread.destroy(t); // join and free thread
+		}
+		fmt.println("Finished");
+	}
+*/
 Barrier :: struct {
 	mutex: Blocking_Mutex,
 	cond:  Condition,

core/sync/sync2/extended.odin

@@ -67,44 +67,41 @@ wait_group_wait_with_timeout :: proc(wg: ^Wait_Group, duration: time.Duration) -
 
 
 
-// A barrier enabling multiple threads to synchronize the beginning of some computation
 /*
- * Example:
- *
- * 	package example
- *
- * 	import "core:fmt"
- * 	import "core:sync"
- * 	import "core:thread"
- *
- * 	barrier := &sync.Barrier{}
- *
- * 	main :: proc() {
- * 		fmt.println("Start")
- *
- * 		THREAD_COUNT :: 4
- * 		threads: [THREAD_COUNT]^thread.Thread
- *
- * 		sync.barrier_init(barrier, THREAD_COUNT)
- * 		defer sync.barrier_destroy(barrier)
- *
- *
- * 		for _, i in threads {
- * 			threads[i] = thread.create_and_start(proc(t: ^thread.Thread) {
- * 				// Same messages will be printed together but without any interleaving
- * 				fmt.println("Getting ready!")
- * 				sync.barrier_wait(barrier)
- * 				fmt.println("Off their marks they go!")
- * 			})
- * 		}
- *
- * 		for t in threads {
- * 			thread.destroy(t) // join and free thread
- * 		}
- * 		fmt.println("Finished")
- * 	}
- *
- */
+A barrier enabling multiple threads to synchronize the beginning of some computation
+
+Example:
+	package example
+
+	import "core:fmt"
+	import "core:sync"
+	import "core:thread"
+
+	barrier := &sync.Barrier{}
+
+	main :: proc() {
+		fmt.println("Start")
+
+		THREAD_COUNT :: 4
+		threads: [THREAD_COUNT]^thread.Thread
+
+		sync.barrier_init(barrier, THREAD_COUNT)
+
+		for _, i in threads {
+			threads[i] = thread.create_and_start(proc(t: ^thread.Thread) {
+				// Same messages will be printed together but without any interleaving
+				fmt.println("Getting ready!")
+				sync.barrier_wait(barrier)
+				fmt.println("Off their marks they go!")
+			})
+		}
+
+		for t in threads {
+			thread.destroy(t) // join and free thread
+		}
+		fmt.println("Finished")
+	}
+*/
 Barrier :: struct {
 	mutex: Mutex,
 	cond:  Cond,

core/sync/sync2/primitives.odin

@@ -29,12 +29,12 @@ mutex_try_lock :: proc(m: ^Mutex) -> bool {
 	return _mutex_try_lock(m)
 }
 
-// Example:
-//
-// if mutex_guard(&m) {
-//         ...
-// }
-//
+/*
+Example:
+	if mutex_guard(&m) {
+		...
+	}
+*/
 @(deferred_in=mutex_unlock)
 mutex_guard :: proc(m: ^Mutex) -> bool {
 	mutex_lock(m)
@@ -80,25 +80,24 @@ rw_mutex_shared_unlock :: proc(rw: ^RW_Mutex) {
 rw_mutex_try_shared_lock :: proc(rw: ^RW_Mutex) -> bool {
 	return _rw_mutex_try_shared_lock(rw)
 }
-
-// Example:
-//
-// if rw_mutex_guard(&m) {
-//         ...
-// }
-//
+/*
+Example:
+	if rw_mutex_guard(&m) {
+		...
+	}
+*/
 @(deferred_in=rw_mutex_unlock)
 rw_mutex_guard :: proc(m: ^RW_Mutex) -> bool {
 	rw_mutex_lock(m)
 	return true
 }
 
-// Example:
-//
-// if rw_mutex_shared_guard(&m) {
-//         ...
-// }
-//
+/*
+Example:
+	if rw_mutex_shared_guard(&m) {
+		...
+	}
+*/
 @(deferred_in=rw_mutex_shared_unlock)
 rw_mutex_shared_guard :: proc(m: ^RW_Mutex) -> bool {
 	rw_mutex_shared_lock(m)
@@ -127,13 +126,12 @@ recursive_mutex_try_lock :: proc(m: ^Recursive_Mutex) -> bool {
 	return _recursive_mutex_try_lock(m)
 }
 
-
-// Example:
-//
-// if recursive_mutex_guard(&m) {
-//         ...
-// }
-//
+/*
+Example:
+	if recursive_mutex_guard(&m) {
+		...
+	}
+*/
 @(deferred_in=recursive_mutex_unlock)
 recursive_mutex_guard :: proc(m: ^Recursive_Mutex) -> bool {
 	recursive_mutex_lock(m)

core/sync/sync2/primitives_atomic.odin

@@ -82,13 +82,12 @@ atomic_mutex_try_lock :: proc(m: ^Atomic_Mutex) -> bool {
 	return ok
 }
 
-
-// Example:
-//
-// if atomic_mutex_guard(&m) {
-//         ...
-// }
-//
+/*
+Example:
+	if atomic_mutex_guard(&m) {
+		...
+	}
+*/
 @(deferred_in=atomic_mutex_unlock)
 atomic_mutex_guard :: proc(m: ^Atomic_Mutex) -> bool {
 	atomic_mutex_lock(m)
@@ -193,25 +192,24 @@ atomic_rw_mutex_try_shared_lock :: proc(rw: ^Atomic_RW_Mutex) -> bool {
 	return false
 }
 
-
-// Example:
-//
-// if atomic_rw_mutex_guard(&m) {
-//         ...
-// }
-//
+/*
+Example:
+	if atomic_rw_mutex_guard(&m) {
+		...
+	}
+*/
 @(deferred_in=atomic_rw_mutex_unlock)
 atomic_rw_mutex_guard :: proc(m: ^Atomic_RW_Mutex) -> bool {
 	atomic_rw_mutex_lock(m)
 	return true
 }
 
-// Example:
-//
-// if atomic_rw_mutex_shared_guard(&m) {
-//         ...
-// }
-//
+/*
+Example:
+	if atomic_rw_mutex_shared_guard(&m) {
+		...
+	}
+*/
 @(deferred_in=atomic_rw_mutex_shared_unlock)
 atomic_rw_mutex_shared_guard :: proc(m: ^Atomic_RW_Mutex) -> bool {
 	atomic_rw_mutex_shared_lock(m)
@@ -270,13 +268,12 @@ atomic_recursive_mutex_try_lock :: proc(m: ^Atomic_Recursive_Mutex) -> bool {
 	return true
 }
 
-
-// Example:
-//
-// if atomic_recursive_mutex_guard(&m) {
-//         ...
-// }
-//
+/*
+Example:
+	if atomic_recursive_mutex_guard(&m) {
+		...
+	}
+*/
 @(deferred_in=atomic_recursive_mutex_unlock)
 atomic_recursive_mutex_guard :: proc(m: ^Atomic_Recursive_Mutex) -> bool {
 	atomic_recursive_mutex_lock(m)

core/sync/sync2/sema_internal.odin

@@ -1,3 +1,4 @@
+//+private
 package sync2
 
 import "core:time"

core/sync/sync2/sync_util.odin

@@ -1,12 +1,11 @@
 package sync2
 
-
-// Example:
-//
-// if guard(&m) {
-//         ...
-// }
-//
+/*
+Example:
+	if guard(&m) {
+		...
+	}
+*/
 guard :: proc{
 	mutex_guard,
 	rw_mutex_guard,
@@ -17,13 +16,12 @@ guard :: proc{
 	atomic_recursive_mutex_guard,
 	atomic_rw_mutex_guard,
 }
-
-// Example:
-//
-// if shared_guard(&m) {
-//         ...
-// }
-//
+/*
+Example:
+	if shared_guard(&m) {
+		...
+	}
+*/
 shared_guard :: proc{
 	rw_mutex_shared_guard,
 	atomic_rw_mutex_shared_guard,