renamed 'ArenaState' to 'Arena'; added 'string.read_alphanum'

diff --git a/compiler/src/utils.c b/compiler/src/utils.c
index 7c83b89023e5e338292abc2ac81a5d1a65aabd11..d73ab5c81f32b9f4ba28cf2c049318405de89dd4 100644 (file)
--- a/compiler/src/utils.c
+++ b/compiler/src/utils.c
@@ -1223,7 +1223,7 @@ char *find_closest_symbol_in_scope_and_parents(Scope *scope, char *sym) {
 char *find_closest_symbol_in_node(AstNode* node, char *sym) {
     Scope *scope = get_scope_from_node(node);
     if (!scope) {
-        if (node->kind == Ast_Kind_Poly_Call_Type) {
+        if (node && node->kind == Ast_Kind_Poly_Call_Type) {
             AstPolyCallType* pcall = (AstPolyCallType *) node;
             return find_closest_symbol_in_node((AstNode *) pcall->callee, sym);
         }

diff --git a/core/alloc/arena.onyx b/core/alloc/arena.onyx
index 673145109b1dc329bff635173f5b582e69bcb519..80aa852ed19f616f28ef7fb3f3dcba154a2386cb 100644 (file)
--- a/core/alloc/arena.onyx
+++ b/core/alloc/arena.onyx
@@ -13,21 +13,24 @@ package core.alloc.arena
 // while guaranteeing that the memory inside of it will
 // never move.
 
-ArenaState :: struct {
+// Deprecated struct 'ArenaState'. Use 'Arena' instead.
+ArenaState :: Arena
+
+Arena :: struct {
     backing_allocator : Allocator;
 
-    first_arena   : ^Arena;
-    current_arena : ^Arena;
+    first_arena   : ^ArenaBlock;
+    current_arena : ^ArenaBlock;
     
     size       : u32;
     arena_size : u32;
 }
 
-Arena :: struct { next : ^Arena; }
+ArenaBlock :: struct { next : ^ArenaBlock; }
 
 #local
 arena_alloc_proc :: (data: rawptr, aa: AllocationAction, size: u32, align: u32, oldptr: rawptr) -> rawptr {
-    alloc_arena := cast(^ArenaState) data;
+    alloc_arena := cast(^Arena) data;
 
     if aa == .Alloc {
         // An allocation of this size does not fit into a single arena.
@@ -40,7 +43,7 @@ arena_alloc_proc :: (data: rawptr, aa: AllocationAction, size: u32, align: u32,
         }
 
         if alloc_arena.size + size >= alloc_arena.arena_size {
-            new_arena := cast(^Arena) raw_alloc(alloc_arena.backing_allocator, alloc_arena.arena_size);
+            new_arena := cast(^ArenaBlock) raw_alloc(alloc_arena.backing_allocator, alloc_arena.arena_size);
             if new_arena == null do return null;
 
             alloc_arena.size = sizeof rawptr;
@@ -75,13 +78,13 @@ arena_alloc_proc :: (data: rawptr, aa: AllocationAction, size: u32, align: u32,
 }
 
 // @Note // `arena_size` must be at least 4
-make :: (backing: Allocator, arena_size: u32) -> ArenaState {
+make :: (backing: Allocator, arena_size: u32) -> Arena {
     assert(arena_size >= 4, "Arena size was expected to be at least 4 bytes.");
     
-    initial_arena := cast(^Arena) raw_alloc(backing, arena_size);
+    initial_arena := cast(^ArenaBlock) raw_alloc(backing, arena_size);
     initial_arena.next = null;
 
-    return ArenaState.{
+    return Arena.{
         backing_allocator = backing,
         first_arena       = initial_arena,
         current_arena     = initial_arena,
@@ -92,14 +95,14 @@ make :: (backing: Allocator, arena_size: u32) -> ArenaState {
 }
 
 #match core.alloc.as_allocator make_allocator
-make_allocator :: (rs: ^ArenaState) -> Allocator {
+make_allocator :: (rs: ^Arena) -> Allocator {
     return Allocator.{
         func = arena_alloc_proc,
         data = rs,
     };
 }
 
-free :: (arena: ^ArenaState) {
+free :: (arena: ^Arena) {
     walker := arena.first_arena;
     trailer := walker;
     while walker != null {
@@ -114,7 +117,7 @@ free :: (arena: ^ArenaState) {
 }
 
 // Clears and frees every page, except for first page.
-clear :: (arena: ^ArenaState) {
+clear :: (arena: ^Arena) {
     walker := arena.first_arena.next;
     while walker != null {
         next := walker.next;
@@ -125,7 +128,7 @@ clear :: (arena: ^ArenaState) {
     arena.size = sizeof rawptr;
 }
 
-get_allocated_arenas :: (arena: ^ArenaState) -> u32 {
+get_allocated_arenas :: (arena: ^Arena) -> u32 {
     arenas := 0;
     walker := arena.first_arena;
     while walker != null {
@@ -136,7 +139,7 @@ get_allocated_arenas :: (arena: ^ArenaState) -> u32 {
     return arenas;
 }
 
-get_allocated_bytes :: (arena: ^ArenaState) -> u32 {
+get_allocated_bytes :: (arena: ^Arena) -> u32 {
     return get_allocated_arenas(arena) * (arena.arena_size - 1) + arena.size;
 }
 
@@ -144,11 +147,11 @@ auto :: #match {
     macro (size := 32 * 1024, $dest: Code = #(context.allocator)) {
         use core.alloc {arena, heap_allocator}
 
-        arena := arena.make(heap_allocator, size);
+        a := arena.make(heap_allocator, size);
         old_allocator := #unquote dest;
-        (#unquote dest) = arena.make_allocator(^arena);
+        (#unquote dest) = arena.make_allocator(^a);
         defer {
-            arena.free(^arena);
+            arena.free(^a);
             (#unquote dest) = old_allocator;
         }
     },

diff --git a/core/io/reader.onyx b/core/io/reader.onyx
index 8f50d745e3599af101e226ec8c80332f9803d8e6..58f9986b336574190fe81263037877cd70f6560e 100644 (file)
--- a/core/io/reader.onyx
+++ b/core/io/reader.onyx
@@ -467,7 +467,7 @@ read_until :: (use reader: ^Reader, until: u8, skip: u32 = 0, allocator := conte
     return out;
 }
 
-peek_byte :: (use reader: ^Reader) -> (u8, Error) {
+peek_byte :: (use reader: ^Reader, advance := 0) -> (u8, Error) {
     if reader_empty(reader) do return 0, .EOF;
 
     if start == end {
@@ -476,7 +476,11 @@ peek_byte :: (use reader: ^Reader) -> (u8, Error) {
         }
     }
 
-    return buffer[start], .None;
+    if start + advance >= end {
+        return 0, .EOF;
+    }
+
+    return buffer[start + advance], .None;
 }
 
 advance_line :: (use reader: ^Reader) {

diff --git a/core/string.onyx b/core/string.onyx
index e840d3add174c89670cd9fab5c8cb873dc393a56..1b9d9cf736c3adfccab80cfcaf9e3aed0a0bfd87 100644 (file)
--- a/core/string.onyx
+++ b/core/string.onyx
@@ -425,6 +425,33 @@ read_until :: (s: ^str, upto: str, skip := 0) -> str {
     return out;
 }
 
+read_alphanum :: (s: ^str) -> str {
+    if s.count == 0 do return "";
+
+    out : str;
+    out.data = s.data;
+    out.count = 0;
+
+    for ch: *s {
+        switch ch {
+            case #char "a" .. #char "z",
+                 #char "A" .. #char "Z",
+                 #char "0" .. #char "9" {
+                out.count += 1;
+            }
+
+            case #default {
+                break break;
+            }
+        }
+    }
+
+    s.data += out.count;
+    s.count -= out.count;
+
+    return out;
+}
+
 read_until_any :: (s: ^str, skip: u32, uptos: ..u8) -> str {
     if s.count == 0 do return "";