Merge branch 'odin-lang:master' into master

Author: as2te

.gitignore

@@ -277,6 +277,7 @@ odin
 *.bin
 demo.bin
 libLLVM*.so*
+*.a
 
 # shared collection
 shared/

check_all.bat

@@ -1,9 +1,9 @@
 @echo off
 
 if "%1" == "" (
-	echo Checking darwin_amd64 - expect vendor:cgtlf panic
+	echo Checking darwin_amd64 - expect vendor:cgltf panic
 	odin check examples\all -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do -target:darwin_amd64
-	echo Checking darwin_arm64 - expect vendor:cgtlf panic
+	echo Checking darwin_arm64 - expect vendor:cgltf panic
 	odin check examples\all -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do -target:darwin_arm64
 	echo Checking linux_i386
 	odin check examples\all -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do -target:linux_i386

check_all.sh

@@ -45,9 +45,9 @@ wasm)
 	;;
 
 *)
-	echo Checking darwin_amd64 - expect vendor:cgtlf panic
+	echo Checking darwin_amd64 - expect vendor:cgltf panic
 	odin check examples/all -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do -target:darwin_amd64
-	echo Checking darwin_arm64 - expect vendor:cgtlf panic
+	echo Checking darwin_arm64 - expect vendor:cgltf panic
 	odin check examples/all -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do -target:darwin_arm64
 	echo Checking linux_i386
 	odin check examples/all -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do -target:linux_i386

core/mem/allocators.odin

@@ -2196,7 +2196,7 @@ The buddy allocator data.
 */
 Buddy_Allocator :: struct {
 	head:      ^Buddy_Block,
-	tail:      ^Buddy_Block,
+	tail:      ^Buddy_Block `fmt:"-"`,
 	alignment: uint,
 }
 
@@ -2239,6 +2239,7 @@ buddy_allocator_init :: proc(b: ^Buddy_Allocator, data: []byte, alignment: uint,
 	b.head.is_free = true
 	b.tail = buddy_block_next(b.head)
 	b.alignment = alignment
+	assert(uint(len(data)) >= 2 * buddy_block_size_required(b, 1), "The size of the backing buffer must be large enough to hold at least two 1-byte allocations given the alignment requirements, otherwise it cannot split.", loc)
 	// sanitizer.address_poison(data)
 }
 
@@ -2247,12 +2248,14 @@ Get required block size to fit in the allocation as well as the alignment paddin
 */
 @(require_results)
 buddy_block_size_required :: proc(b: ^Buddy_Allocator, size: uint) -> uint {
-	size := size
-	actual_size := b.alignment
-	size += size_of(Buddy_Block)
-	size = align_forward_uint(size, b.alignment)
-	for size > actual_size {
-		actual_size <<= 1
+	assert(size > 0)
+	// NOTE: `size_of(Buddy_Block)` will be accounted for in `b.alignment`.
+	// This calculation is also previously guarded against being given a `size`
+	// 0 by `buddy_allocator_alloc_bytes_non_zeroed` checking for that.
+	actual_size := b.alignment + size
+	if intrinsics.count_ones(actual_size) != 1 {
+		// We're not a power of two. Let's fix that.
+		actual_size = 1 << (size_of(uint) * 8 - intrinsics.count_leading_zeros(actual_size))
 	}
 	return actual_size
 }
@@ -2315,7 +2318,7 @@ buddy_allocator_alloc_bytes_non_zeroed :: proc(b: ^Buddy_Allocator, size: uint)
 	if size != 0 {
 		actual_size := buddy_block_size_required(b, size)
 		found := buddy_block_find_best(b.head, b.tail, actual_size)
-		if found != nil {
+		if found == nil {
 			// Try to coalesce all the free buddy blocks and then search again
 			buddy_block_coalescence(b.head, b.tail)
 			found = buddy_block_find_best(b.head, b.tail, actual_size)
@@ -2325,6 +2328,7 @@ buddy_allocator_alloc_bytes_non_zeroed :: proc(b: ^Buddy_Allocator, size: uint)
 		}
 		found.is_free = false
 		data := ([^]byte)(found)[b.alignment:][:size]
+		assert(cast(uintptr)raw_data(data)+cast(uintptr)size < cast(uintptr)buddy_block_next(found), "Buddy_Allocator has made an allocation which overlaps a block header.")
 		// ensure_poisoned(data)
 		// sanitizer.address_unpoison(data)
 		return data, nil

examples/all/all_vendor.odin

@@ -45,4 +45,7 @@ package all
 @(require) import stbi "vendor:stb/image"
 @(require) import "vendor:stb/rect_pack"
 @(require) import "vendor:stb/truetype"
-@(require) import "vendor:stb/vorbis"
+@(require) import "vendor:stb/vorbis"
+
+
+@(require) import "vendor:kb_text_shape"

tests/issues/run.bat

@@ -17,6 +17,7 @@ set COMMON=-define:ODIN_TEST_FANCY=false -file -vet -strict-style
 ..\..\..\odin test ..\test_issue_2637.odin %COMMON%  || exit /b
 ..\..\..\odin test ..\test_issue_2666.odin %COMMON%  || exit /b
 ..\..\..\odin test ..\test_issue_2694.odin %COMMON%  || exit /b
+..\..\..\odin test ..\test_issue_3435.odin %COMMON%  || exit /b
 ..\..\..\odin test ..\test_issue_4210.odin %COMMON%  || exit /b
 ..\..\..\odin test ..\test_issue_4364.odin %COMMON%  || exit /b
 ..\..\..\odin test ..\test_issue_4584.odin %COMMON%  || exit /b

tests/issues/run.sh

@@ -18,6 +18,7 @@ $ODIN test ../test_issue_2615.odin $COMMON
 $ODIN test ../test_issue_2637.odin $COMMON
 $ODIN test ../test_issue_2666.odin $COMMON
 $ODIN test ../test_issue_2694.odin $COMMON
+$ODIN test ../test_issue_3435.odin $COMMON
 $ODIN test ../test_issue_4210.odin $COMMON
 $ODIN test ../test_issue_4364.odin $COMMON
 $ODIN test ../test_issue_4584.odin $COMMON

tests/issues/test_issue_3435.odin

@@ -0,0 +1,38 @@
+package main
+
+import "base:runtime"
+import "core:mem"
+import "core:testing"
+import "core:time"
+
+@test
+test_issue_3435 :: proc(t: ^testing.T) {
+	testing.set_fail_timeout(t, time.Second)
+	allocator: mem.Buddy_Allocator
+	data := runtime.make_aligned([]byte, 64, 32)
+	defer delete(data)
+
+	// mem.buddy_allocator_init(&allocator, data, 32)
+
+	// Bypass the assertion that would normally keep this from happening by
+	// manually putting the allocator together.
+	allocator.head = cast(^mem.Buddy_Block)raw_data(data)
+	allocator.head.size = len(data)
+	allocator.head.is_free = true
+	allocator.tail = mem.buddy_block_next(allocator.head)
+	allocator.alignment = 32
+
+	context.allocator = mem.buddy_allocator(&allocator)
+
+	// Three allocations in the space above is all that's needed to reproduce
+	// the bug seen in #3435; this is the most minimal reproduction possible.
+	a := make([]u8, 1)
+	testing.expect(t, len(a) == 1)
+	b := make([]u8, 1)
+	testing.expect(t, len(b) == 0)
+	c := make([]u8, 1)
+	testing.expect(t, len(c) == 0)
+
+	// With the bugfix in place, the allocator should be sensible enough to not
+	// fall into an infinite loop anymore, even if the assertion is disabled.
+}

vendor/README.md

@@ -158,3 +158,9 @@ Se also LICENCE in `cgltf` directory itself.
 ## fontstash (Port)
 
 [Font stash](https://github.com/memononen/fontstash) is a light-weight online font texture atlas builder. It uses stb_truetype to render fonts on demand to a texture atlas.
+
+## kb
+
+[kb](https://github.com/JimmyLefevre/kb) provides ICU-like text segmentation (i.e. breaking Unicode text by direction, line, word and grapheme). It also provides Harfbuzz-like text shaping for OpenType fonts, which means it is capable of handling complex script layout and ligatures, among other things.
+
+It does not handle rasterization. It will only help you know which glyphs to display where!

vendor/kb_text_shape/kb_text_shape_procs.odin

@@ -0,0 +1,158 @@
+package vendor_kb_text_shape
+
+when ODIN_OS == .Windows {
+	foreign import lib {
+		"lib/kb_text_shape.lib",
+	}
+} else {
+	foreign import lib {
+		"kb_text_shape.a",
+	}
+}
+
+import "core:mem"
+
+@(default_calling_convention="c", link_prefix="kbts_", require_results)
+foreign lib {
+	FontIsValid       :: proc(Font: ^font) -> b32 ---
+	SizeOfShapeState  :: proc(Font: ^font) -> un ---
+
+	ResetShapeState   :: proc(State: ^shape_state) ---
+
+	ShapeConfig       :: proc(Font: ^font, Script: script, Language: language) -> shape_config ---
+	ShaperIsComplex   :: proc(Shaper: shaper) -> b32 ---
+	ScriptIsComplex   :: proc(Script: script) -> b32 ---
+
+	Shape             :: proc(State: ^shape_state, Config: ^shape_config,
+	                          MainDirection, RunDirection: direction,
+	                          Glyphs: [^]glyph, GlyphCount: ^u32, GlyphCapacity: u32) -> b32 ---
+
+	Cursor            :: proc(Direction: direction) -> cursor  ---
+	BeginBreak        :: proc(State: ^break_state, MainDirection: direction, JapaneseLineBreakStyle: japanese_line_break_style) ---
+	BreakStateIsValid :: proc(State: ^break_state) -> b32 ---
+	BreakAddCodepoint :: proc(State: ^break_state, Codepoint: rune, PositionIncrement: u32, EndOfText: b32) ---
+	BreakFlush        :: proc(State: ^break_state) ---
+	Break             :: proc(State: ^break_state, Break: ^break_type) -> b32 ---
+	CodepointToGlyph  :: proc(Font: ^font, Codepoint: rune) -> glyph ---
+	InferScript       :: proc(Direction: ^direction, Script: ^script, GlyphScript: script) ---
+}
+
+@(require_results)
+PlaceShapeState :: proc "c" (Memory: []byte) -> ^shape_state {
+	@(default_calling_convention="c", require_results)
+	foreign lib {
+		kbts_PlaceShapeState :: proc(Address: rawptr, Size: un) -> ^shape_state ---
+	}
+
+	return kbts_PlaceShapeState(raw_data(Memory), un(len(Memory)))
+}
+
+@(require_results)
+DecodeUtf8 :: proc "contextless" (String: string) -> (Codepoint: rune, SourceCharactersConsumed: u32, Valid: bool) {
+	decode :: struct {
+		Codepoint: rune,
+
+		SourceCharactersConsumed: u32,
+		Valid:                    b32,
+	}
+
+	@(default_calling_convention="c", require_results)
+	foreign lib {
+		kbts_DecodeUtf8 :: proc(Utf8: [^]byte, Length: uint) -> decode ---
+	}
+
+	Decode := kbts_DecodeUtf8(raw_data(String), len(String))
+	return Decode.Codepoint, Decode.SourceCharactersConsumed, bool(Decode.Valid)
+}
+
+
+@(require_results)
+ReadFontHeader :: proc "c" (Font: ^font, Data: []byte) -> un {
+	@(default_calling_convention="c", require_results)
+	foreign lib {
+		kbts_ReadFontHeader :: proc(Font: ^font, Data: rawptr, Size: un) -> un ---
+	}
+
+	return kbts_ReadFontHeader(Font, raw_data(Data), un(len(Data)))
+}
+@(require_results)
+ReadFontData :: proc "c" (Font: ^font, Scratch: []byte) -> un {
+	@(default_calling_convention="c", require_results)
+	foreign lib {
+		kbts_ReadFontData :: proc(Font: ^font, Scratch: rawptr, ScratchSize: un) -> un ---
+	}
+
+	return kbts_ReadFontData(Font, raw_data(Scratch), un(len(Scratch)))
+}
+@(require_results)
+PostReadFontInitialize :: proc "c" (Font: ^font, Memory: []byte) -> b32 {
+	@(default_calling_convention="c", require_results)
+	foreign lib {
+		kbts_PostReadFontInitialize :: proc(Font: ^font, Memory: rawptr, MemorySize: un) -> b32 ---
+	}
+
+	return kbts_PostReadFontInitialize(Font, raw_data(Memory), un(len(Memory)))
+}
+
+@(require_results)
+FontFromMemory :: proc(Data: []byte, allocator: mem.Allocator) -> (Result: font, Err: mem.Allocator_Error) {
+	ClonedData := mem.make_aligned([]byte, len(Data), 16, allocator) or_return
+	defer if Err != nil {
+		delete(ClonedData, allocator)
+	}
+	copy(ClonedData, Data)
+
+	ScratchSize := ReadFontHeader(&Result, ClonedData)
+	Scratch := mem.make_aligned([]byte, ScratchSize, 16, allocator) or_return
+	MemorySize := ReadFontData(&Result, Scratch)
+
+	Memory := Scratch
+	if MemorySize > ScratchSize {
+		delete(Scratch, allocator)
+		Memory = mem.make_aligned([]byte, MemorySize, 16, allocator) or_return
+	}
+	defer if Err != nil {
+		delete(Memory, allocator)
+	}
+
+	_ = PostReadFontInitialize(&Result, Memory)
+	return
+
+}
+FreeFont :: proc(Font: ^font, allocator: mem.Allocator) {
+	free(Font.FileBase, allocator)
+	free(Font.GlyphLookupMatrix, allocator)
+	Font^ = {}
+}
+
+@(require_results)
+CreateShapeState :: proc(Font: ^font, allocator: mem.Allocator) -> (Result: ^shape_state, Err: mem.Allocator_Error) {
+	Size := SizeOfShapeState(Font)
+	Memory := mem.make_aligned([]byte, Size, 16, allocator) or_return
+	Result = PlaceShapeState(Memory)
+	return
+}
+FreeShapeState :: proc(State: ^shape_state, allocator: mem.Allocator) {
+	free(State, allocator)
+}
+
+@(require_results)
+PositionGlyph :: proc(Cursor: ^cursor, Glyph: ^glyph) -> (X, Y: i32) {
+	@(default_calling_convention="c", require_results)
+	foreign lib {
+		kbts_PositionGlyph :: proc(Cursor: ^cursor, Glyph: ^glyph, X, Y: ^i32) ---
+	}
+	kbts_PositionGlyph(Cursor, Glyph, &X, &Y)
+	return
+}
+
+@(require_results)
+ShapeDynamic :: proc(State: ^shape_state, Config: ^shape_config,
+                     MainDirection, RunDirection: direction,
+                     Glyphs: ^[dynamic]glyph) -> b32 {
+	GlyphCount    := u32(len(Glyphs^))
+	GlyphCapacity := u32(cap(Glyphs^))
+	Res := Shape(State, Config, MainDirection, RunDirection, raw_data(Glyphs^), &GlyphCount, GlyphCapacity)
+	resize(Glyphs, int(GlyphCount))
+	return Res
+}