From c32e876813e09387dc7c25c6f4b3a73f5273d0bb Mon Sep 17 00:00:00 2001 From: Brendan Hansen Date: Mon, 10 Oct 2022 22:38:26 -0500 Subject: [PATCH] renamed 'ArenaState' to 'Arena'; added 'string.read_alphanum' --- compiler/src/utils.c | 2 +- core/alloc/arena.onyx | 37 ++++++++++++++++++++----------------- core/io/reader.onyx | 8 ++++++-- core/string.onyx | 27 +++++++++++++++++++++++++++ 4 files changed, 54 insertions(+), 20 deletions(-) diff --git a/compiler/src/utils.c b/compiler/src/utils.c index 7c83b890..d73ab5c8 100644 --- 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 67314510..80aa852e 100644 --- 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 8f50d745..58f9986b 100644 --- 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 e840d3ad..1b9d9cf7 100644 --- 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 ""; -- 2.25.1