From 4c7b44ff01a0664d12ba111c355f6dfef0bd5188 Mon Sep 17 00:00:00 2001 From: Konstantin Nazarov Date: Fri, 9 Aug 2024 23:45:06 +0100 Subject: [PATCH] Stop passing arena explicitly --- src/arena.cpp | 11 ++ src/arena.hpp | 28 ++-- src/common.cpp | 186 ++++++++++------------- src/common.hpp | 386 +++++++++++++++++++++-------------------------- src/compiler.cpp | 10 +- src/compiler.hpp | 5 +- src/reader.cpp | 64 ++++---- src/reader.hpp | 9 +- src/vli.cpp | 12 +- src/writer.cpp | 68 ++++----- src/writer.hpp | 12 +- test/array.cpp | 16 +- test/dict.cpp | 30 ++-- test/symbol.cpp | 8 +- test/test.hpp | 28 ++-- 15 files changed, 409 insertions(+), 464 deletions(-) diff --git a/src/arena.cpp b/src/arena.cpp index 01cd5c7..b3b7075 100644 --- a/src/arena.cpp +++ b/src/arena.cpp @@ -1,7 +1,10 @@ #include "arena.hpp" +#include "die.hpp" #include "error.hpp" +static Arena* current_arena = 0; + GcRootBase::GcRootBase(PodObject* ptr, GcRootList* node) : _ptr(ptr), _node(node) {} @@ -175,3 +178,11 @@ Result Arena::gc_dict(PodDict* obj) { return nobj; // return ErrorCode::NotImplemented; } + +Arena& get_arena() { + if (current_arena == 0) die("Arena not set\n"); + return *current_arena; +} +void set_arena(Arena& arena) { current_arena = &arena; } + +Result arena_gc() { return get_arena().gc(); } diff --git a/src/arena.hpp b/src/arena.hpp index db057f0..b954bd3 100644 --- a/src/arena.hpp +++ b/src/arena.hpp @@ -13,6 +13,9 @@ class Arena; class GcRootList; +Arena& get_arena(); +void set_arena(Arena& arena); + class GcRootBase { public: friend class Arena; @@ -38,10 +41,8 @@ class GcRoot : public GcRootBase { GcRoot(GcRoot&& rhs); GcRoot& operator=(GcRoot&& rhs); - static Result> create(T* ptr, Arena& arena); - Result> copy(Arena& arena) const { - return GcRoot::create((T*)_ptr, arena); - } + static Result> create(T* ptr); + Result> copy() const { return GcRoot::create((T*)_ptr); } T* get() { return (T*)_ptr; } T& operator*() { return *(T*)_ptr; } @@ -50,8 +51,8 @@ class GcRoot : public GcRootBase { template requires std::derived_from -Result> MkGcRoot(T* ptr, Arena& arena) { - return GcRoot::create(ptr, arena); +Result> MkGcRoot(T* ptr) { + return GcRoot::create(ptr); } class GcRootList { @@ -184,17 +185,24 @@ class StaticArenaHeap : public ArenaHeap { template class StaticArena : public Arena { public: - StaticArena() : Arena(&_heaps[0], &_heaps[1]) {} + StaticArena() : Arena(&_heaps[0], &_heaps[1]) { set_arena(*this); } private: StaticArenaHeap<(size - sizeof(Arena)) / 2> _heaps[2]; }; +template +Result arena_alloc(uint64_t extra = 0) { + return get_arena().alloc(extra); +} + +Result arena_gc(); + template requires std::derived_from -Result> GcRoot::create(T* ptr, Arena& arena) { - auto lst = TRY(arena.alloc()); - arena.add_root(lst); +Result> GcRoot::create(T* ptr) { + auto lst = TRY(arena_alloc()); + get_arena().add_root(lst); return std::move(GcRoot(ptr, lst)); } diff --git a/src/common.cpp b/src/common.cpp index 46346c2..3fa2268 100644 --- a/src/common.cpp +++ b/src/common.cpp @@ -8,56 +8,56 @@ Syntax::Syntax(String filename, String modulename, Value expression) {} -Result Syntax::get_value(Arena& arena) { - return Value::create(arena, _value->expression.get()); +Result Syntax::get_value() { + return Value::create(_value->expression.get()); } -Result Value::create(Arena& arena, PodObject* obj) { +Result Value::create(PodObject* obj) { switch (obj->header.tag) { case Tag::Nil: - return Value(TRY(Nil::create(arena, (PodNil*)obj))); + return Value(TRY(Nil::create((PodNil*)obj))); case Tag::Int64: - return Value(TRY(Int64::create(arena, (PodInt64*)obj))); + return Value(TRY(Int64::create((PodInt64*)obj))); case Tag::Float: - return Value(TRY(Float::create(arena, (PodFloat*)obj))); + return Value(TRY(Float::create((PodFloat*)obj))); case Tag::Bool: - return Value(TRY(Bool::create(arena, (PodBool*)obj))); + return Value(TRY(Bool::create((PodBool*)obj))); case Tag::Array: - return Value(TRY(Array::create(arena, (PodArray*)obj))); + return Value(TRY(Array::create((PodArray*)obj))); case Tag::ByteArray: - return Value(TRY(ByteArray::create(arena, (PodByteArray*)obj))); + return Value(TRY(ByteArray::create((PodByteArray*)obj))); case Tag::Dict: - return Value(TRY(Dict::create(arena, (PodDict*)obj))); + return Value(TRY(Dict::create((PodDict*)obj))); case Tag::String: - return Value(TRY(String::create(arena, (PodString*)obj))); + return Value(TRY(String::create((PodString*)obj))); case Tag::Symbol: - return Value(TRY(Symbol::create(arena, (PodSymbol*)obj))); + return Value(TRY(Symbol::create((PodSymbol*)obj))); case Tag::Syntax: - return Value(TRY(Syntax::create(arena, (PodSyntax*)obj))); + return Value(TRY(Syntax::create((PodSyntax*)obj))); case Tag::Pair: - return Value(TRY(Pair::create(arena, (PodPair*)obj))); + return Value(TRY(Pair::create((PodPair*)obj))); }; return Value(); } -Result Symbol::create(Arena& arena, String& rhs) { +Result Symbol::create(String& rhs) { uint64_t rhs_size = rhs.size(); uint64_t res_size = rhs_size; - auto pod = TRY(arena.alloc(res_size * sizeof(char32_t))); + auto pod = TRY(arena_alloc(res_size * sizeof(char32_t))); pod->header.tag = Tag::Symbol; pod->size = res_size; memcpy(pod->data, rhs._value->data, sizeof(char32_t) * rhs_size); - return Symbol(TRY(MkGcRoot(pod, arena))); + return Symbol(TRY(MkGcRoot(pod))); } -Result ByteArray::create(Arena& arena, String& str) { +Result ByteArray::create(String& str) { uint64_t size = 0; for (uint64_t i = 0; i < str.size(); i++) { size += utf8_codepoint_size(TRY(str[i])); } - auto pod = TRY(arena.alloc(size * sizeof(char))); + auto pod = TRY(arena_alloc(size * sizeof(char))); pod->header.tag = Tag::ByteArray; pod->size = size; @@ -68,94 +68,76 @@ Result ByteArray::create(Arena& arena, String& str) { res = utf8_write_codepoint(res, codepoint); } - return ByteArray(TRY(MkGcRoot(pod, arena))); + return ByteArray(TRY(MkGcRoot(pod))); } -Result syntax_unwrap(Arena& arena, Value& val) { +Result syntax_unwrap(Value& val) { Syntax* syntax = val.to(); - if (syntax == 0) return val.copy(arena); + if (syntax == 0) return val.copy(); - return syntax->get_value(arena); + return syntax->get_value(); } -Result Nil::copy(Arena& arena) const { return Value(Nil()); } +Result Nil::copy() const { return Value(Nil()); } -Result Int64::copy(Arena& arena) const { - return Value(Int64(TRY(_value.copy(arena)))); -} -Result Float::copy(Arena& arena) const { - return Value(Float(TRY(_value.copy(arena)))); +Result Int64::copy() const { return Value(Int64(TRY(_value.copy()))); } +Result Float::copy() const { return Value(Float(TRY(_value.copy()))); } + +Result Array::copy() const { return Value(Array(TRY(_value.copy()))); } + +Result ByteArray::copy() const { + return Value(ByteArray(TRY(_value.copy()))); } -Result Array::copy(Arena& arena) const { - return Value(Array(TRY(_value.copy(arena)))); -} +Result Dict::copy() const { return Value(Dict(TRY(_value.copy()))); } -Result ByteArray::copy(Arena& arena) const { - return Value(ByteArray(TRY(_value.copy(arena)))); -} +Result String::copy() const { return Value(String(TRY(_value.copy()))); } -Result Dict::copy(Arena& arena) const { - return Value(Dict(TRY(_value.copy(arena)))); -} +Result Symbol::copy() const { return Value(Symbol(TRY(_value.copy()))); } -Result String::copy(Arena& arena) const { - return Value(String(TRY(_value.copy(arena)))); -} +Result Syntax::copy() const { return Value(Syntax(TRY(_value.copy()))); } -Result Symbol::copy(Arena& arena) const { - return Value(Symbol(TRY(_value.copy(arena)))); -} +Result Pair::copy() const { return Value(Pair(TRY(_value.copy()))); } -Result Syntax::copy(Arena& arena) const { - return Value(Syntax(TRY(_value.copy(arena)))); -} +Result Bool::copy() const { return Value(Bool(TRY(_value.copy()))); } -Result Pair::copy(Arena& arena) const { - return Value(Pair(TRY(_value.copy(arena)))); -} - -Result Bool::copy(Arena& arena) const { - return Value(Bool(TRY(_value.copy(arena)))); -} - -Result Pair::create(Arena& arena, Value& first, Value& rest) { - auto pod = TRY(arena.alloc()); +Result Pair::create(Value& first, Value& rest) { + auto pod = TRY(arena_alloc()); pod->header.tag = Tag::Pair; pod->first = first.pod(); pod->rest = rest.pod(); - return Pair(TRY(MkGcRoot(pod, arena))); + return Pair(TRY(MkGcRoot(pod))); } -Result Pair::first(Arena& arena) { +Result Pair::first() { auto val = _value->first.get(); - return Value::create(arena, val); + return Value::create(val); } -Result Pair::rest(Arena& arena) { +Result Pair::rest() { auto val = _value->rest.get(); - return Value::create(arena, val); + return Value::create(val); } -Result reverse(Arena& arena, Value& val) { +Result reverse(Value& val) { if (!val.is()) return ErrorCode::TypeMismatch; - auto res = Value(TRY(Nil::create(arena))); - auto cur = TRY(val.copy(arena)); + auto res = Value(TRY(Nil::create())); + auto cur = TRY(val.copy()); while (!cur.is()) { if (!cur.is()) return ErrorCode::TypeMismatch; Pair& pair = *cur.to(); - Value first = TRY(pair.first(arena)); - cur = TRY(pair.rest(arena)); - res = TRY(Pair::create(arena, first, res)); + Value first = TRY(pair.first()); + cur = TRY(pair.rest()); + res = TRY(Pair::create(first, res)); } return res; } -Result debug_print(Arena& arena, String& val) { - auto ba = TRY(ByteArray::create(arena, val)); +Result debug_print(String& val) { + auto ba = TRY(ByteArray::create(val)); for (uint64_t i = 0; i < ba.size(); i++) { std::cout << TRY(ba[i]); @@ -164,27 +146,27 @@ Result debug_print(Arena& arena, String& val) { return Result(); } -Result debug_print(Arena& arena, Value& val) { - auto w = Writer(arena); +Result debug_print(Value& val) { + auto w = Writer(); auto s = TRY(w.write_one(val)); - return debug_print(arena, s); + return debug_print(s); } -Result Array::get(Arena& arena, uint64_t idx) { +Result Array::get(uint64_t idx) { if (idx >= _value->size) return ErrorCode::IndexOutOfRange; auto val = _value->data[idx].get(); - return Value::create(arena, val); + return Value::create(val); } -Result Array::get(Arena& arena, Value& key) { +Result Array::get(Value& key) { if (!key.is()) return ErrorCode::TypeMismatch; - return get(arena, key.to()->value()); + return get(key.to()->value()); } -Result Array::append(Arena& arena, Value& rhs) { +Result Array::append(Value& rhs) { uint64_t res_size = size() + 1; - auto pod = TRY(arena.alloc(res_size * sizeof(OffPtr))); + auto pod = TRY(arena_alloc(res_size * sizeof(OffPtr))); pod->header.tag = Tag::Array; pod->size = res_size; for (uint64_t i = 0; i < size(); i++) { @@ -192,7 +174,7 @@ Result Array::append(Arena& arena, Value& rhs) { } pod->data[size()] = rhs.pod(); - return Array(TRY(MkGcRoot(pod, arena))); + return Array(TRY(MkGcRoot(pod))); } short cmp_tag(Tag lhs, Tag rhs) { @@ -201,29 +183,29 @@ short cmp_tag(Tag lhs, Tag rhs) { return 0; } -Result Dict::get(Arena& arena, Value& key) { - auto pos = TRY(find(arena, key)); +Result Dict::get(Value& key) { + auto pos = TRY(find(key)); if (pos > size()) return ErrorCode::KeyError; - auto k = TRY(Value::create(arena, _value->data[pos * 2].get())); + auto k = TRY(Value::create(_value->data[pos * 2].get())); - if (TRY(k.cmp(arena, key)) != 0) { + if (TRY(k.cmp(key)) != 0) { return ErrorCode::KeyError; } - return TRY(Value::create(arena, _value->data[pos * 2 + 1].get())); + return TRY(Value::create(_value->data[pos * 2 + 1].get())); } -Result Dict::insert(Arena& arena, Value& key, Value& value) { - auto pos = TRY(find(arena, key)); +Result Dict::insert(Value& key, Value& value) { + auto pos = TRY(find(key)); auto s = size(); if (pos >= s) { s += 1; } else { - auto k = TRY(Value::create(arena, _value->data[pos * 2].get())); - if (TRY(k.cmp(arena, key)) != 0) s += 1; + auto k = TRY(Value::create(_value->data[pos * 2].get())); + if (TRY(k.cmp(key)) != 0) s += 1; } - auto pod = TRY(arena.alloc(2 * s * sizeof(OffPtr))); + auto pod = TRY(arena_alloc(2 * s * sizeof(OffPtr))); pod->header.tag = Tag::Dict; pod->size = s; @@ -243,16 +225,16 @@ Result Dict::insert(Arena& arena, Value& key, Value& value) { } } - return Dict(TRY(MkGcRoot(pod, arena))); + return Dict(TRY(MkGcRoot(pod))); } -Result Dict::find(Arena& arena, Value& key) { +Result Dict::find(Value& key) { uint64_t left = 0; uint64_t right = size(); uint64_t pos = (left + right) / 2; while (left < right) { - auto v = TRY(Value::create(arena, _value->data[pos * 2].get())); - auto c = TRY(v.cmp(arena, key)); + auto v = TRY(Value::create(_value->data[pos * 2].get())); + auto c = TRY(v.cmp(key)); if (c == 0) { return pos; } @@ -267,17 +249,17 @@ Result Dict::find(Arena& arena, Value& key) { return left; } -Result Int64::cmp(Arena&, Float& rhs) { +Result Int64::cmp(Float& rhs) { return (_value->value > rhs._value->value) - (_value->value < rhs._value->value); } -Result Float::cmp(Arena&, Int64& rhs) { +Result Float::cmp(Int64& rhs) { return (_value->value > rhs._value->value) - (_value->value < rhs._value->value); } -Result Dict::cmp(Arena& arena, Dict& rhs) { +Result Dict::cmp(Dict& rhs) { auto lsize = size() * 2; auto rsize = rhs.size() * 2; uint64_t i = 0; @@ -288,9 +270,9 @@ Result Dict::cmp(Arena& arena, Dict& rhs) { short cmp = short(i == lsize) - short(j == rsize); if (cmp != 0) return cmp; - Value lc = TRY(Value::create(arena, _value->data[i].get())); - Value rc = TRY(Value::create(arena, rhs._value->data[j].get())); - cmp = TRY(lc.cmp(arena, rc)); + Value lc = TRY(Value::create(_value->data[i].get())); + Value rc = TRY(Value::create(rhs._value->data[j].get())); + cmp = TRY(lc.cmp(rc)); if (cmp != 0) return cmp; i++; j++; @@ -298,6 +280,4 @@ Result Dict::cmp(Arena& arena, Dict& rhs) { return 0; } -Result Object::get(Arena& arena, Value& key) { - return ErrorCode::TypeMismatch; -} +Result Object::get(Value& key) { return ErrorCode::TypeMismatch; } diff --git a/src/common.hpp b/src/common.hpp index b255e05..3d3c498 100644 --- a/src/common.hpp +++ b/src/common.hpp @@ -31,37 +31,25 @@ short cmp_tag(Tag lhs, Tag rhs); class Object { public: virtual Tag tag() = 0; - virtual Result copy(Arena& arena) const = 0; + virtual Result copy() const = 0; virtual PodObject* pod() = 0; virtual void move(Object*) = 0; virtual ~Object() = default; - virtual Result cmp(Arena&, Object&) = 0; - virtual Result cmp(Arena&, Nil&) { return cmp_tag(tag(), Tag::Nil); } - virtual Result cmp(Arena&, Int64&) { - return cmp_tag(tag(), Tag::Int64); - } - virtual Result cmp(Arena&, Float&) { - return cmp_tag(tag(), Tag::Float); - } - virtual Result cmp(Arena&, Bool&) { return cmp_tag(tag(), Tag::Bool); } - virtual Result cmp(Arena&, String&) { - return cmp_tag(tag(), Tag::String); - } - virtual Result cmp(Arena&, Symbol&) { - return cmp_tag(tag(), Tag::Symbol); - } - virtual Result cmp(Arena&, Syntax&) { - return cmp_tag(tag(), Tag::Syntax); - } - virtual Result cmp(Arena&, Pair&) { return cmp_tag(tag(), Tag::Pair); } - virtual Result cmp(Arena&, Array&) { - return cmp_tag(tag(), Tag::Array); - } - virtual Result cmp(Arena&, ByteArray&) { + virtual Result cmp(Object&) = 0; + virtual Result cmp(Nil&) { return cmp_tag(tag(), Tag::Nil); } + virtual Result cmp(Int64&) { return cmp_tag(tag(), Tag::Int64); } + virtual Result cmp(Float&) { return cmp_tag(tag(), Tag::Float); } + virtual Result cmp(Bool&) { return cmp_tag(tag(), Tag::Bool); } + virtual Result cmp(String&) { return cmp_tag(tag(), Tag::String); } + virtual Result cmp(Symbol&) { return cmp_tag(tag(), Tag::Symbol); } + virtual Result cmp(Syntax&) { return cmp_tag(tag(), Tag::Syntax); } + virtual Result cmp(Pair&) { return cmp_tag(tag(), Tag::Pair); } + virtual Result cmp(Array&) { return cmp_tag(tag(), Tag::Array); } + virtual Result cmp(ByteArray&) { return cmp_tag(tag(), Tag::ByteArray); } - virtual Result get(Arena& arena, Value& key); + virtual Result get(Value& key); Object() = default; Object(const Object&) = delete; @@ -76,23 +64,19 @@ class Nil : public Object { virtual Tag tag() final { return Tag::Nil; } virtual PodObject* pod() final { return _value.get(); } - virtual Result cmp(Arena& arena, Object& rhs) final { - return -TRY(rhs.cmp(arena, *this)); - } - virtual Result cmp(Arena&, Nil& rhs) final { return 0; } + virtual Result cmp(Object& rhs) final { return -TRY(rhs.cmp(*this)); } + virtual Result cmp(Nil& rhs) final { return 0; } - static Result create(Arena& arena, PodNil* obj) { - return Nil(TRY(MkGcRoot(obj, arena))); - } + static Result create(PodNil* obj) { return Nil(TRY(MkGcRoot(obj))); } - static Result create(Arena& arena) { - auto pod = TRY(arena.alloc()); + static Result create() { + auto pod = TRY(arena_alloc()); pod->header.tag = Tag::Nil; - return Nil(TRY(MkGcRoot(pod, arena))); + return Nil(TRY(MkGcRoot(pod))); } - virtual Result copy(Arena& arena) const final; + virtual Result copy() const final; virtual void move(Object* obj) final { new (obj) Nil(std::move(_value)); } @@ -113,42 +97,40 @@ class Array : public Object { virtual Tag tag() final { return Tag::Array; } virtual PodObject* pod() final { return _value.get(); } - virtual Result cmp(Arena& arena, Object& rhs) final { - return -TRY(rhs.cmp(arena, *this)); - } - virtual Result cmp(Arena&, Array& rhs) final { return 0; } + virtual Result cmp(Object& rhs) final { return -TRY(rhs.cmp(*this)); } + virtual Result cmp(Array& rhs) final { return 0; } virtual void move(Object* obj) final { new (obj) Array(std::move(_value)); } - static Result create(Arena& arena, PodArray* obj) { - return Array(TRY(MkGcRoot(obj, arena))); + static Result create(PodArray* obj) { + return Array(TRY(MkGcRoot(obj))); } - static Result create(Arena& arena) { - auto pod = TRY(arena.alloc()); + static Result create() { + auto pod = TRY(arena_alloc()); pod->header.tag = Tag::Array; pod->size = 0; - return Array(TRY(MkGcRoot(pod, arena))); + return Array(TRY(MkGcRoot(pod))); } uint64_t size() { return _value->size; } - virtual Result copy(Arena& arena) const final; + virtual Result copy() const final; - Result get(Arena& arena, uint64_t idx); - virtual Result get(Arena& arena, Value& key) final; + Result get(uint64_t idx); + virtual Result get(Value& key) final; - Result append(Arena& arena, Value& rhs); + Result append(Value& rhs); template - Result append(Arena& arena, const V& value); + Result append(const V& value); - Result concat(Arena& arena, Array& rhs) { + Result concat(Array& rhs) { uint64_t rhs_size = rhs.size(); uint64_t lhs_size = size(); uint64_t res_size = lhs_size + rhs_size; - auto pod = TRY(arena.alloc(res_size * sizeof(PodObject*))); + auto pod = TRY(arena_alloc(res_size * sizeof(PodObject*))); pod->size = res_size; for (uint64_t i = 0; i < size(); i++) { pod->data[i] = _value->data[i]; @@ -157,19 +139,19 @@ class Array : public Object { pod->data[i] = rhs._value->data[i]; } - return Array(TRY(MkGcRoot(pod, arena))); + return Array(TRY(MkGcRoot(pod))); } - Result sub(Arena& arena, uint64_t start, uint64_t end) { + Result sub(uint64_t start, uint64_t end) { if (start > end) return ErrorCode::IndexOutOfRange; uint64_t res_size = end - start; - auto pod = TRY(arena.alloc(res_size * sizeof(PodObject*))); + auto pod = TRY(arena_alloc(res_size * sizeof(PodObject*))); pod->size = res_size; for (uint64_t i = 0; i < end - start; i++) { pod->data[i] = _value->data[start + i]; } - return Array(TRY(MkGcRoot(pod, arena))); + return Array(TRY(MkGcRoot(pod))); } private: @@ -189,95 +171,93 @@ class ByteArray : public Object { virtual Tag tag() final { return Tag::ByteArray; } virtual PodObject* pod() final { return _value.get(); } - virtual Result cmp(Arena& arena, Object& rhs) final { - return -TRY(rhs.cmp(arena, *this)); - } - virtual Result cmp(Arena&, ByteArray& rhs) final { return 0; } + virtual Result cmp(Object& rhs) final { return -TRY(rhs.cmp(*this)); } + virtual Result cmp(ByteArray& rhs) final { return 0; } virtual void move(Object* obj) final { new (obj) ByteArray(std::move(_value)); } - static Result create(Arena& arena, PodByteArray* obj) { - return ByteArray(TRY(MkGcRoot(obj, arena))); + static Result create(PodByteArray* obj) { + return ByteArray(TRY(MkGcRoot(obj))); } - static Result create(Arena& arena, char* chars, int64_t size) { - auto pod = TRY(arena.alloc(size * sizeof(char))); + static Result create(char* chars, int64_t size) { + auto pod = TRY(arena_alloc(size * sizeof(char))); pod->header.tag = Tag::ByteArray; memcpy(pod->data, chars, size * sizeof(char32_t)); pod->size = size; - return ByteArray(TRY(MkGcRoot(pod, arena))); + return ByteArray(TRY(MkGcRoot(pod))); } - static Result create(Arena& arena, const char* str) { + static Result create(const char* str) { uint64_t size = strlen(str); - auto pod = TRY(arena.alloc(size * sizeof(char32_t))); + auto pod = TRY(arena_alloc(size * sizeof(char32_t))); pod->header.tag = Tag::ByteArray; memcpy(pod->data, str, size); pod->size = size; - return ByteArray(TRY(MkGcRoot(pod, arena))); + return ByteArray(TRY(MkGcRoot(pod))); } - static Result create(Arena& arena, String& str); + static Result create(String& str); uint64_t size() { return _value->size; } - virtual Result copy(Arena& arena) const final; + virtual Result copy() const final; Result operator[](uint64_t idx) { if (idx >= _value->size) return ErrorCode::IndexOutOfRange; return _value->data[idx]; } - Result concat(Arena& arena, const char* rhs) { + Result concat(const char* rhs) { uint64_t rhs_size = strlen(rhs); uint64_t lhs_size = size(); uint64_t res_size = lhs_size + rhs_size; - auto pod = TRY(arena.alloc(res_size * sizeof(char))); + auto pod = TRY(arena_alloc(res_size * sizeof(char))); pod->size = res_size; memcpy(pod->data, _value->data, sizeof(char) * lhs_size); memcpy(pod->data, rhs + lhs_size, sizeof(char) * rhs_size); - return ByteArray(TRY(MkGcRoot(pod, arena))); + return ByteArray(TRY(MkGcRoot(pod))); } - Result concat(Arena& arena, const char* rhs, uint64_t rhs_size) { + Result concat(const char* rhs, uint64_t rhs_size) { uint64_t lhs_size = size(); uint64_t res_size = lhs_size + rhs_size; - auto pod = TRY(arena.alloc(res_size * sizeof(char))); + auto pod = TRY(arena_alloc(res_size * sizeof(char))); pod->size = res_size; memcpy(pod->data, _value->data, sizeof(char) * lhs_size); memcpy(pod->data, rhs + lhs_size, sizeof(char) * rhs_size); - return ByteArray(TRY(MkGcRoot(pod, arena))); + return ByteArray(TRY(MkGcRoot(pod))); } - Result concat(Arena& arena, ByteArray& rhs) { + Result concat(ByteArray& rhs) { uint64_t rhs_size = rhs.size(); uint64_t lhs_size = size(); uint64_t res_size = lhs_size + rhs_size; - auto pod = TRY(arena.alloc(res_size * sizeof(char))); + auto pod = TRY(arena_alloc(res_size * sizeof(char))); pod->size = res_size; memcpy(pod->data, _value->data, sizeof(char) * lhs_size); memcpy(pod->data + lhs_size, rhs._value->data, sizeof(char) * rhs_size); - return ByteArray(TRY(MkGcRoot(pod, arena))); + return ByteArray(TRY(MkGcRoot(pod))); } - Result sub(Arena& arena, uint64_t start, uint64_t end) { + Result sub(uint64_t start, uint64_t end) { if (start > end) return ErrorCode::IndexOutOfRange; uint64_t res_size = end - start; - auto pod = TRY(arena.alloc(res_size * sizeof(char))); + auto pod = TRY(arena_alloc(res_size * sizeof(char))); pod->size = res_size; memcpy(pod->data, _value->data + start, sizeof(char) * res_size); - return ByteArray(TRY(MkGcRoot(pod, arena))); + return ByteArray(TRY(MkGcRoot(pod))); } private: @@ -298,41 +278,37 @@ class Dict : public Object { virtual Tag tag() final { return Tag::Dict; } virtual PodObject* pod() final { return _value.get(); } - virtual Result cmp(Arena& arena, Object& rhs) final { - return -TRY(rhs.cmp(arena, *this)); - } - virtual Result cmp(Arena&, Dict& rhs) final; + virtual Result cmp(Object& rhs) final { return -TRY(rhs.cmp(*this)); } + virtual Result cmp(Dict& rhs) final; virtual void move(Object* obj) final { new (obj) Dict(std::move(_value)); } - static Result create(Arena& arena, PodDict* obj) { - return Dict(TRY(MkGcRoot(obj, arena))); - } + static Result create(PodDict* obj) { return Dict(TRY(MkGcRoot(obj))); } - static Result create(Arena& arena) { - auto pod = TRY(arena.alloc()); + static Result create() { + auto pod = TRY(arena_alloc()); pod->header.tag = Tag::Dict; pod->size = 0; - return Dict(TRY(MkGcRoot(pod, arena))); + return Dict(TRY(MkGcRoot(pod))); } - virtual Result copy(Arena& arena) const final; + virtual Result copy() const final; - virtual Result get(Arena& arena, Value& key) final; + virtual Result get(Value& key) final; - Result insert(Arena& arena, Value& key, Value& value); + Result insert(Value& key, Value& value); template - Result insert(Arena& arena, const K& key, const V& value); + Result insert(const K& key, const V& value); - Result concat(Arena& arena, Dict& rhs) { + Result concat(Dict& rhs) { uint64_t rhs_size = rhs.size(); uint64_t lhs_size = size(); uint64_t res_size = lhs_size + rhs_size; - auto pod = TRY(arena.alloc(2 * res_size * sizeof(PodObject*))); + auto pod = TRY(arena_alloc(2 * res_size * sizeof(PodObject*))); pod->size = res_size; for (uint64_t i = 0; i < 2 * size(); i++) { @@ -342,11 +318,11 @@ class Dict : public Object { pod->data[i] = rhs._value->data[i]; } - return Dict(TRY(MkGcRoot(pod, arena))); + return Dict(TRY(MkGcRoot(pod))); } private: - Result find(Arena& arena, Value& key); + Result find(Value& key); uint64_t size() { return _value->size; } GcRoot _value; @@ -365,10 +341,8 @@ class String : public Object { virtual Tag tag() final { return Tag::String; } virtual PodObject* pod() final { return _value.get(); } - virtual Result cmp(Arena& arena, Object& rhs) final { - return -TRY(rhs.cmp(arena, *this)); - } - virtual Result cmp(Arena&, String& rhs) final { + virtual Result cmp(Object& rhs) final { return -TRY(rhs.cmp(*this)); } + virtual Result cmp(String& rhs) final { auto lsize = size(); auto rsize = rhs.size(); uint64_t i = 0; @@ -391,88 +365,88 @@ class String : public Object { virtual void move(Object* obj) final { new (obj) String(std::move(_value)); } - static Result create(Arena& arena, PodString* obj) { - return String(TRY(MkGcRoot(obj, arena))); + static Result create(PodString* obj) { + return String(TRY(MkGcRoot(obj))); } - static Result create(Arena& arena, char32_t* chars, int64_t size) { - auto pod = TRY(arena.alloc(size * sizeof(char32_t))); + static Result create(char32_t* chars, int64_t size) { + auto pod = TRY(arena_alloc(size * sizeof(char32_t))); pod->header.tag = Tag::String; memcpy(pod->data, chars, size * sizeof(char32_t)); pod->size = size; - return String(TRY(MkGcRoot(pod, arena))); + return String(TRY(MkGcRoot(pod))); } - static Result create(Arena& arena, const char* str) { + static Result create(const char* str) { uint64_t size = strlen(str); - auto pod = TRY(arena.alloc(size * sizeof(char32_t))); + auto pod = TRY(arena_alloc(size * sizeof(char32_t))); pod->header.tag = Tag::String; for (uint64_t i = 0; i < size; i++) pod->data[i] = str[i]; pod->size = size; - return String(TRY(MkGcRoot(pod, arena))); + return String(TRY(MkGcRoot(pod))); } uint64_t size() { return _value->size; } - virtual Result copy(Arena& arena) const final; + virtual Result copy() const final; Result operator[](uint64_t idx) { if (idx >= _value->size) return ErrorCode::IndexOutOfRange; return _value->data[idx]; } - Result concat(Arena& arena, const char* rhs) { + Result concat(const char* rhs) { uint64_t rhs_size = strlen(rhs); uint64_t lhs_size = size(); uint64_t res_size = lhs_size + rhs_size; - auto pod = TRY(arena.alloc(res_size * sizeof(char32_t))); + auto pod = TRY(arena_alloc(res_size * sizeof(char32_t))); pod->header.tag = Tag::String; pod->size = res_size; memcpy(pod->data, _value->data, sizeof(char32_t) * lhs_size); for (uint64_t i = 0; i < rhs_size; i++) pod->data[lhs_size + i] = rhs[i]; - return String(TRY(MkGcRoot(pod, arena))); + return String(TRY(MkGcRoot(pod))); } - Result concat(Arena& arena, const char32_t* rhs, uint64_t rhs_size) { + Result concat(const char32_t* rhs, uint64_t rhs_size) { uint64_t lhs_size = size(); uint64_t res_size = lhs_size + rhs_size; - auto pod = TRY(arena.alloc(res_size * sizeof(char32_t))); + auto pod = TRY(arena_alloc(res_size * sizeof(char32_t))); pod->header.tag = Tag::String; pod->size = res_size; memcpy(pod->data, _value->data, sizeof(char32_t) * lhs_size); for (uint64_t i = 0; i < rhs_size; i++) pod->data[lhs_size + i] = rhs[i]; - return String(TRY(MkGcRoot(pod, arena))); + return String(TRY(MkGcRoot(pod))); } - Result concat(Arena& arena, String& rhs) { + Result concat(String& rhs) { uint64_t rhs_size = rhs.size(); uint64_t lhs_size = size(); uint64_t res_size = lhs_size + rhs_size; - auto pod = TRY(arena.alloc(res_size * sizeof(char32_t))); + auto pod = TRY(arena_alloc(res_size * sizeof(char32_t))); pod->header.tag = Tag::String; pod->size = res_size; memcpy(pod->data, _value->data, sizeof(char32_t) * lhs_size); memcpy(pod->data + lhs_size, rhs._value->data, sizeof(char32_t) * rhs_size); - return String(TRY(MkGcRoot(pod, arena))); + return String(TRY(MkGcRoot(pod))); } - Result sub(Arena& arena, uint64_t start, uint64_t end) { + Result sub(uint64_t start, uint64_t end) { if (start > end) return ErrorCode::IndexOutOfRange; uint64_t res_size = end - start; - auto pod = TRY(arena.alloc(res_size * sizeof(char32_t))); + auto pod = TRY(arena_alloc(res_size * sizeof(char32_t))); pod->header.tag = Tag::String; pod->size = res_size; memcpy(pod->data, _value->data + start, sizeof(char32_t) * res_size); - return String(TRY(MkGcRoot(pod, arena))); + return String(TRY(MkGcRoot(pod))); } friend class Symbol; @@ -488,10 +462,8 @@ class Symbol : public Object { Symbol(GcRoot&& val) : _value(std::move(val)) {} virtual Tag tag() final { return Tag::Symbol; } virtual PodObject* pod() final { return _value.get(); } - virtual Result cmp(Arena& arena, Object& rhs) final { - return -TRY(rhs.cmp(arena, *this)); - } - virtual Result cmp(Arena&, Symbol& rhs) final { + virtual Result cmp(Object& rhs) final { return -TRY(rhs.cmp(*this)); } + virtual Result cmp(Symbol& rhs) final { auto lsize = size(); auto rsize = rhs.size(); uint64_t i = 0; @@ -513,32 +485,32 @@ class Symbol : public Object { } virtual void move(Object* obj) final { new (obj) Symbol(std::move(_value)); } - static Result create(Arena& arena, PodSymbol* obj) { - return Symbol(TRY(MkGcRoot(obj, arena))); + static Result create(PodSymbol* obj) { + return Symbol(TRY(MkGcRoot(obj))); } - static Result create(Arena& arena, char32_t* chars, int64_t size) { - auto pod = TRY(arena.alloc(size * sizeof(char32_t))); + static Result create(char32_t* chars, int64_t size) { + auto pod = TRY(arena_alloc(size * sizeof(char32_t))); pod->header.tag = Tag::Symbol; memcpy(pod->data, chars, size * sizeof(char32_t)); - return Symbol(TRY(MkGcRoot(pod, arena))); + return Symbol(TRY(MkGcRoot(pod))); } - static Result create(Arena& arena, const char* str) { + static Result create(const char* str) { uint64_t size = strlen(str); - auto pod = TRY(arena.alloc(size * sizeof(char32_t))); + auto pod = TRY(arena_alloc(size * sizeof(char32_t))); pod->header.tag = Tag::Symbol; for (uint64_t i = 0; i < size; i++) pod->data[i] = str[i]; pod->size = size; - return Symbol(TRY(MkGcRoot(pod, arena))); + return Symbol(TRY(MkGcRoot(pod))); } - static Result create(Arena& arena, String& rhs); - virtual Result copy(Arena& arena) const final; + static Result create(String& rhs); + virtual Result copy() const final; uint64_t size() { return _value->size; } @@ -559,20 +531,18 @@ class Syntax : public Object { Syntax(String filename, String modulename, Value expression); virtual Tag tag() final { return Tag::Syntax; } virtual PodObject* pod() final { return _value.get(); } - virtual Result cmp(Arena& arena, Object& rhs) final { - return -TRY(rhs.cmp(arena, *this)); - } - virtual Result cmp(Arena&, Syntax& rhs) final { return 0; } + virtual Result cmp(Object& rhs) final { return -TRY(rhs.cmp(*this)); } + virtual Result cmp(Syntax& rhs) final { return 0; } virtual void move(Object* obj) final { new (obj) Syntax(std::move(_value)); } - static Result create(Arena& arena, PodSyntax* obj) { - return Syntax(TRY(MkGcRoot(obj, arena))); + static Result create(PodSyntax* obj) { + return Syntax(TRY(MkGcRoot(obj))); } - Result get_value(Arena& arena); + Result get_value(); - virtual Result copy(Arena& arena) const final; + virtual Result copy() const final; private: GcRoot _value; @@ -585,22 +555,18 @@ class Pair : public Object { Pair(GcRoot&& val) : _value(std::move(val)) {} virtual Tag tag() final { return Tag::Pair; } virtual PodObject* pod() final { return _value.get(); } - virtual Result cmp(Arena& arena, Object& rhs) final { - return -TRY(rhs.cmp(arena, *this)); - } - virtual Result cmp(Arena&, Pair& rhs) final { return 0; } + virtual Result cmp(Object& rhs) final { return -TRY(rhs.cmp(*this)); } + virtual Result cmp(Pair& rhs) final { return 0; } virtual void move(Object* obj) final { new (obj) Pair(std::move(_value)); } - static Result create(Arena& arena, PodPair* obj) { - return Pair(TRY(MkGcRoot(obj, arena))); - } - static Result create(Arena& arena, Value& first, Value& rest); + static Result create(PodPair* obj) { return Pair(TRY(MkGcRoot(obj))); } + static Result create(Value& first, Value& rest); - Result first(Arena& arena); - Result rest(Arena& arena); + Result first(); + Result rest(); - virtual Result copy(Arena& arena) const final; + virtual Result copy() const final; private: GcRoot _value; @@ -615,32 +581,30 @@ class Int64 : public Object { Int64(GcRoot&& val) : _value(std::move(val)) {} virtual Tag tag() final { return Tag::Int64; } virtual PodObject* pod() final { return _value.get(); } - virtual Result cmp(Arena& arena, Object& rhs) final { - return -TRY(rhs.cmp(arena, *this)); - } - virtual Result cmp(Arena&, Int64& rhs) final { + virtual Result cmp(Object& rhs) final { return -TRY(rhs.cmp(*this)); } + virtual Result cmp(Int64& rhs) final { return (_value->value > rhs._value->value) - (_value->value < rhs._value->value); } - virtual Result cmp(Arena&, Float& rhs) final; + virtual Result cmp(Float& rhs) final; virtual void move(Object* obj) final { new (obj) Int64(std::move(_value)); } - static Result create(Arena& arena, PodInt64* obj) { - return Int64(TRY(MkGcRoot(obj, arena))); + static Result create(PodInt64* obj) { + return Int64(TRY(MkGcRoot(obj))); } - static Result create(Arena& arena, double val) { - auto pod = TRY(arena.alloc()); + static Result create(double val) { + auto pod = TRY(arena_alloc()); pod->header.tag = Tag::Int64; pod->value = val; - return Int64(TRY(MkGcRoot(pod, arena))); + return Int64(TRY(MkGcRoot(pod))); } int64_t value() { return _value->value; } - virtual Result copy(Arena& arena) const final; + virtual Result copy() const final; private: GcRoot _value; @@ -655,32 +619,30 @@ class Float : public Object { Float(GcRoot&& val) : _value(std::move(val)) {} virtual Tag tag() final { return Tag::Float; } virtual PodObject* pod() final { return _value.get(); } - virtual Result cmp(Arena& arena, Object& rhs) final { - return -TRY(rhs.cmp(arena, *this)); - } - virtual Result cmp(Arena&, Float& rhs) final { + virtual Result cmp(Object& rhs) final { return -TRY(rhs.cmp(*this)); } + virtual Result cmp(Float& rhs) final { return (_value->value > rhs._value->value) - (_value->value < rhs._value->value); } - virtual Result cmp(Arena&, Int64& rhs) final; + virtual Result cmp(Int64& rhs) final; virtual void move(Object* obj) final { new (obj) Float(std::move(_value)); } - static Result create(Arena& arena, PodFloat* obj) { - return Float(TRY(MkGcRoot(obj, arena))); + static Result create(PodFloat* obj) { + return Float(TRY(MkGcRoot(obj))); } - static Result create(Arena& arena, double val) { - auto pod = TRY(arena.alloc()); + static Result create(double val) { + auto pod = TRY(arena_alloc()); pod->header.tag = Tag::Float; pod->value = val; - return Float(TRY(MkGcRoot(pod, arena))); + return Float(TRY(MkGcRoot(pod))); } double value() { return _value->value; } - virtual Result copy(Arena& arena) const final; + virtual Result copy() const final; private: GcRoot _value; @@ -694,28 +656,24 @@ class Bool : public Object { virtual Tag tag() final { return Tag::Bool; } virtual PodObject* pod() final { return _value.get(); } - virtual Result cmp(Arena& arena, Object& rhs) final { - return -TRY(rhs.cmp(arena, *this)); - } - virtual Result cmp(Arena&, Bool& rhs) final { return 0; } + virtual Result cmp(Object& rhs) final { return -TRY(rhs.cmp(*this)); } + virtual Result cmp(Bool& rhs) final { return 0; } virtual void move(Object* obj) final { new (obj) Bool(std::move(_value)); } - static Result create(Arena& arena, PodBool* obj) { - return Bool(TRY(MkGcRoot(obj, arena))); - } + static Result create(PodBool* obj) { return Bool(TRY(MkGcRoot(obj))); } - static Result create(Arena& arena, bool val) { - auto pod = TRY(arena.alloc()); + static Result create(bool val) { + auto pod = TRY(arena_alloc()); pod->header.tag = Tag::Bool; pod->value = val; - return Bool(TRY(MkGcRoot(pod, arena))); + return Bool(TRY(MkGcRoot(pod))); } bool value() { return _value->value; } - virtual Result copy(Arena& arena) const final; + virtual Result copy() const final; private: GcRoot _value; @@ -746,14 +704,14 @@ class Value { return *this; } - static Result create(Arena& arena, PodObject* obj); + static Result create(PodObject* obj); - static Result create(Arena& arena, const int64_t& value) { - return Value(TRY(Int64::create(arena, value))); + static Result create(const int64_t& value) { + return Value(TRY(Int64::create(value))); } - static Result create(Arena& arena, const char* value) { - return Value(TRY(String::create(arena, value))); + static Result create(const char* value) { + return Value(TRY(String::create(value))); } template @@ -772,23 +730,21 @@ class Value { Object& operator*() { return *(Object*)(buf); } Object* operator->() { return (Object*)(buf); } - Result cmp(Arena& arena, Value& rhs) { - return ((Object*)buf)->cmp(arena, *(Object*)rhs.buf); + Result cmp(Value& rhs) { + return ((Object*)buf)->cmp(*(Object*)rhs.buf); } - Result get(Arena& arena, Value& key) { - return ((Object*)buf)->get(arena, key); - } - Result get(Arena& arena, int64_t key) { - Value k = TRY(Int64::create(arena, key)); - return ((Object*)buf)->get(arena, k); + Result get(Value& key) { return ((Object*)buf)->get(key); } + Result get(int64_t key) { + Value k = TRY(Int64::create(key)); + return ((Object*)buf)->get(k); } // TODO: cmp() probably doesn't need arena parameter // Result operator==(Value& rhs) { return TRY(cmp(rhs)) == 0; } // Result operator!=(Value& rhs) { return TRY(cmp(rhs)) != 0; } - Result copy(Arena& arena) const { return ((Object*)buf)->copy(arena); } + Result copy() const { return ((Object*)buf)->copy(); } private: uint8_t buf[24]; @@ -796,21 +752,21 @@ class Value { Result syntax_unwrap(Value& val); -Result reverse(Arena& arena, Value& val); +Result reverse(Value& val); -Result debug_print(Arena& arena, String& val); -Result debug_print(Arena& arena, Value& val); +Result debug_print(String& val); +Result debug_print(Value& val); template -Result Dict::insert(Arena& arena, const K& key, const V& value) { - Value k = TRY(Value::create(arena, key)); - Value v = TRY(Value::create(arena, value)); +Result Dict::insert(const K& key, const V& value) { + Value k = TRY(Value::create(key)); + Value v = TRY(Value::create(value)); - return insert(arena, k, v); + return insert(k, v); } template -Result Array::append(Arena& arena, const V& value) { - Value v = TRY(Value::create(arena, value)); - return append(arena, v); +Result Array::append(const V& value) { + Value v = TRY(Value::create(value)); + return append(v); } diff --git a/src/compiler.cpp b/src/compiler.cpp index dbe01e6..3d42fa1 100644 --- a/src/compiler.cpp +++ b/src/compiler.cpp @@ -8,9 +8,9 @@ struct Context { maxreg(0), maxconst(0) {} - static Result create(Arena& arena) { - auto env = TRY(Nil::create(arena)); - auto constants = TRY(Array::create(arena)); + static Result create() { + auto env = TRY(Nil::create()); + auto constants = TRY(Array::create()); return Context(std::move(env), std::move(constants)); } @@ -27,7 +27,7 @@ bool is_primitive_op(Symbol& sym) { } Result Compiler::compile(Value& expr) { - auto context = TRY(Context::create(_arena)); + auto context = TRY(Context::create()); TRY(compile_expr(context, expr)); return ErrorCode::NotImplemented; @@ -52,7 +52,7 @@ Result Compiler::compile_expr(Context& context, Value& expr) { } Result Compiler::compile_list(Context& context, Pair& expr) { - auto first = TRY(expr.first(_arena)); + auto first = TRY(expr.first()); if (first.is()) { Symbol& sym = *first.to(); diff --git a/src/compiler.hpp b/src/compiler.hpp index 10c0e94..2bc4181 100644 --- a/src/compiler.hpp +++ b/src/compiler.hpp @@ -13,12 +13,9 @@ struct Expression { class Compiler { public: - Compiler(Arena& arena) : _arena(arena) {} + Compiler() {} Result compile(Value& expr); Result compile_expr(Context& context, Value& expr); Result compile_list(Context& context, Pair& expr); - - private: - Arena& _arena; }; diff --git a/src/reader.cpp b/src/reader.cpp index f157207..f4a1fc6 100644 --- a/src/reader.cpp +++ b/src/reader.cpp @@ -73,16 +73,16 @@ Result Reader::read_one() { } Result Reader::read_multiple() { - Value res = TRY(Nil::create(_arena)); + Value res = TRY(Nil::create()); while (1) { forward_whitespace(); if (is_eof()) { - return reverse(_arena, res); + return reverse(res); } auto val = TRY(read_one()); - res = Value(TRY(Pair::create(_arena, val, res))); + res = Value(TRY(Pair::create(val, res))); } return ErrorCode::ReadError; @@ -93,7 +93,7 @@ Result Reader::read_list() { forward(); - Value res = TRY(Nil::create(_arena)); + Value res = TRY(Nil::create()); while (1) { forward_whitespace(); @@ -104,12 +104,12 @@ Result Reader::read_list() { if (match(')')) { forward(); - return reverse(_arena, res); + return reverse(res); } auto val = TRY(read_one()); - res = Value(TRY(Pair::create(_arena, val, res))); + res = Value(TRY(Pair::create(val, res))); } return ErrorCode::ReadError; @@ -120,7 +120,7 @@ Result Reader::read_dict() { forward(); - auto res = TRY(Dict::create(_arena)); + auto res = TRY(Dict::create()); while (1) { forward_whitespace(); @@ -137,7 +137,7 @@ Result Reader::read_dict() { auto val1 = TRY(read_one()); auto val2 = TRY(read_one()); - res = TRY(res.insert(_arena, val1, val2)); + res = TRY(res.insert(val1, val2)); } return ErrorCode::ReadError; @@ -146,12 +146,12 @@ Result Reader::read_bool() { if (match("true")) { forward(4); if (!is_separator(get()) && !is_eof()) return ErrorCode::ReadError; - return Value(TRY(Bool::create(_arena, true))); + return Value(TRY(Bool::create(true))); } if (match("false")) { forward(5); if (!is_separator(get()) && !is_eof()) return ErrorCode::ReadError; - return Value(TRY(Bool::create(_arena, false))); + return Value(TRY(Bool::create(false))); } return ErrorCode::ReadError; @@ -175,13 +175,13 @@ Result Reader::read_string() { forward(); - String result = TRY(String::create(_arena, "")); + String result = TRY(String::create("")); for (size_t i = 0; i < position_.offset - start - 1; i++) { char32_t cur = TRY(_str[start + i]); if (cur != '\\') { // TODO: optimize this - result = TRY(result.concat(_arena, &cur, 1)); + result = TRY(result.concat(&cur, 1)); continue; } ++i; @@ -189,32 +189,32 @@ Result Reader::read_string() { char32_t next = TRY(_str[start + i]); if (next == '\0') { - result = TRY(result.concat(_arena, "\0")); + result = TRY(result.concat("\0")); continue; } switch (next) { case 'b': - result = TRY(result.concat(_arena, "\b")); + result = TRY(result.concat("\b")); continue; case 'f': - result = TRY(result.concat(_arena, "\f")); + result = TRY(result.concat("\f")); continue; case 'n': - result = TRY(result.concat(_arena, "\n")); + result = TRY(result.concat("\n")); continue; case 'r': - result = TRY(result.concat(_arena, "\r")); + result = TRY(result.concat("\r")); continue; case 't': - result = TRY(result.concat(_arena, "\t")); + result = TRY(result.concat("\t")); continue; case 'v': - result = TRY(result.concat(_arena, "\v")); + result = TRY(result.concat("\v")); continue; } - result = TRY(result.concat(_arena, "\\")); - result = TRY(result.concat(_arena, &next, 1)); + result = TRY(result.concat("\\")); + result = TRY(result.concat(&next, 1)); } if (!is_separator(get()) && !is_eof()) return ErrorCode::ReadError; @@ -274,12 +274,12 @@ Result Reader::read_number() { buf[position_.offset - start] = '\0'; if (is_float) { - res = Value(TRY(Float::create(_arena, strtod(buf, 0)))); + res = Value(TRY(Float::create(strtod(buf, 0)))); if (match("f64")) { forward(3); } } else { - res = Value(TRY(Int64::create(_arena, strtoll(buf, 0, 10)))); + res = Value(TRY(Int64::create(strtoll(buf, 0, 10)))); } if (!is_separator(get()) && !is_eof()) return ErrorCode::ReadError; @@ -296,11 +296,11 @@ Result Reader::read_symbol() { size_t end = position_.offset; - String str = TRY(_str.sub(_arena, start, end)); + String str = TRY(_str.sub(start, end)); if (!is_separator(get()) && !is_eof()) return ErrorCode::ReadError; - return Value(TRY(Symbol::create(_arena, str))); + return Value(TRY(Symbol::create(str))); } char32_t Reader::get(size_t offset) { @@ -409,17 +409,17 @@ bool Reader::forward_exponent() { return forward_decimal_number(); } -Result read_one(Arena& arena, Value& value) { +Result read_one(Value& value) { if (!value.is()) return ErrorCode::TypeMismatch; - auto r = Reader(arena, *value.to()); + auto r = Reader(*value.to()); return r.read_one(); } -Result read_one(Arena& arena, String& value) { - auto r = Reader(arena, value); +Result read_one(String& value) { + auto r = Reader(value); return r.read_one(); } -Result read_one(Arena& arena, const char* value) { - auto s = TRY(String::create(arena, value)); - auto r = Reader(arena, s); +Result read_one(const char* value) { + auto s = TRY(String::create(value)); + auto r = Reader(s); return r.read_one(); } diff --git a/src/reader.hpp b/src/reader.hpp index d4231a1..e3b2871 100644 --- a/src/reader.hpp +++ b/src/reader.hpp @@ -5,7 +5,7 @@ class Reader { public: - Reader(Arena& arena, String& str) : _arena(arena), _str(str) {} + Reader(String& str) : _str(str) {} Result read_one(); Result read_multiple(); @@ -38,11 +38,10 @@ class Reader { bool match(const char* str); bool match(char c); - Arena& _arena; String& _str; SourcePosition position_{1, 1, 0}; }; -Result read_one(Arena& arena, Value& value); -Result read_one(Arena& arena, String& value); -Result read_one(Arena& arena, const char* value); +Result read_one(Value& value); +Result read_one(String& value); +Result read_one(const char* value); diff --git a/src/vli.cpp b/src/vli.cpp index 08a6779..ec9c06d 100644 --- a/src/vli.cpp +++ b/src/vli.cpp @@ -9,19 +9,19 @@ StaticArena<64 * 1024 * 1024> arena; int main() { - auto s = DIEX(String::create(arena, "(+ 1 2 3)")); - auto reader = Reader(arena, s); + auto s = DIEX(String::create("(+ 1 2 3)")); + auto reader = Reader(s); auto r = DIEX(reader.read_one()); - auto writer = Writer(arena); + auto writer = Writer(); auto s2 = DIEX(writer.write_one(r)); - DIEX(arena.gc()); + DIEX(arena_gc()); - DIEX(debug_print(arena, s2)); + DIEX(debug_print(s2)); - Compiler c = Compiler(arena); + Compiler c = Compiler(); auto compiled = DIEX(c.compile(r)); return 0; diff --git a/src/writer.cpp b/src/writer.cpp index 5ac6d91..f6e9973 100644 --- a/src/writer.cpp +++ b/src/writer.cpp @@ -33,7 +33,7 @@ Result Writer::write_int64(Int64& val) { sprintf(tmp, "%lu", val.value()); size_t len = strlen(tmp); - return String::create(_arena, tmp); + return String::create(tmp); } bool needs_dot(char* str) { @@ -58,17 +58,15 @@ Result Writer::write_float(Float& val) { len += 2; } - return String::create(_arena, tmp); + return String::create(tmp); } -Result Writer::write_nil(Nil& val) { - return String::create(_arena, "nil"); -} +Result Writer::write_nil(Nil& val) { return String::create("nil"); } Result Writer::write_bool(Bool& val) { - if (val.value()) return String::create(_arena, "true"); + if (val.value()) return String::create("true"); - return String::create(_arena, "false"); + return String::create("false"); } Result Writer::write_bytearray(ByteArray& val) { @@ -76,7 +74,7 @@ Result Writer::write_bytearray(ByteArray& val) { } Result Writer::write_string(String& val) { - String res = TRY(String::create(_arena, "\"")); + String res = TRY(String::create("\"")); // TODO: optimize this for (uint64_t i = 0; i < val.size(); i++) { @@ -103,13 +101,13 @@ Result Writer::write_string(String& val) { }; if (replace != 0) { - res = TRY(res.concat(_arena, replace)); + res = TRY(res.concat(replace)); } else { - res = TRY(res.concat(_arena, &c, 1)); + res = TRY(res.concat(&c, 1)); } } - res = TRY(res.concat(_arena, "\"")); + res = TRY(res.concat("\"")); return res; } @@ -127,7 +125,7 @@ int is_valid_symbol_char(char32_t codepoint) { } Result Writer::write_symbol(Symbol& val) { - String res = TRY(String::create(_arena, "")); + String res = TRY(String::create("")); // TODO: optimize this for (uint64_t i = 0; i < val.size(); i++) { @@ -135,7 +133,7 @@ Result Writer::write_symbol(Symbol& val) { if (!is_valid_symbol_char(c)) return ErrorCode::InvalidSymbol; - res = TRY(res.concat(_arena, &c, 1)); + res = TRY(res.concat(&c, 1)); } return res; @@ -146,9 +144,9 @@ Result Writer::write_syntax(Syntax& val) { } Result Writer::write_pair(Pair& val) { - String res = TRY(String::create(_arena, "(")); + String res = TRY(String::create("(")); - Value cur = TRY(val.copy(_arena)); + Value cur = TRY(val.copy()); bool is_first = true; while (!cur.is()) { @@ -156,65 +154,65 @@ Result Writer::write_pair(Pair& val) { Pair& pair = *cur.to(); - Value first = TRY(pair.first(_arena)); - if (!is_first) res = TRY(res.concat(_arena, " ")); + Value first = TRY(pair.first()); + if (!is_first) res = TRY(res.concat(" ")); String first_str = TRY(write_one(first)); - res = TRY(res.concat(_arena, first_str)); + res = TRY(res.concat(first_str)); - cur = TRY(pair.rest(_arena)); + cur = TRY(pair.rest()); is_first = false; } - res = TRY(res.concat(_arena, ")")); + res = TRY(res.concat(")")); return res; } Result Writer::write_array(Array& val) { - String res = TRY(String::create(_arena, "[")); + String res = TRY(String::create("[")); bool is_first = true; for (uint64_t i = 0; i < val.size(); i++) { - Value cur = TRY(val.get(_arena, i)); + Value cur = TRY(val.get(i)); - if (!is_first) res = TRY(res.concat(_arena, " ")); + if (!is_first) res = TRY(res.concat(" ")); String first_str = TRY(write_one(cur)); - res = TRY(res.concat(_arena, first_str)); + res = TRY(res.concat(first_str)); is_first = false; } - res = TRY(res.concat(_arena, "]")); + res = TRY(res.concat("]")); return res; } Result Writer::write_dict(Dict& val) { - String res = TRY(String::create(_arena, "{")); + String res = TRY(String::create("{")); bool is_first = true; for (uint64_t i = 0; i < val.size(); i++) { - Value k = TRY(Value::create(_arena, val._value->data[i * 2].get())); - Value v = TRY(Value::create(_arena, val._value->data[i * 2 + 1].get())); + Value k = TRY(Value::create(val._value->data[i * 2].get())); + Value v = TRY(Value::create(val._value->data[i * 2 + 1].get())); - if (!is_first) res = TRY(res.concat(_arena, " ")); + if (!is_first) res = TRY(res.concat(" ")); String first_str = TRY(write_one(k)); - res = TRY(res.concat(_arena, first_str)); + res = TRY(res.concat(first_str)); - res = TRY(res.concat(_arena, " ")); + res = TRY(res.concat(" ")); String second_str = TRY(write_one(v)); - res = TRY(res.concat(_arena, second_str)); + res = TRY(res.concat(second_str)); is_first = false; } - res = TRY(res.concat(_arena, "}")); + res = TRY(res.concat("}")); return res; } -Result write_one(Arena& arena, Value& value) { - auto w = Writer(arena); +Result write_one(Value& value) { + auto w = Writer(); return w.write_one(value); } diff --git a/src/writer.hpp b/src/writer.hpp index c2a49be..e857723 100644 --- a/src/writer.hpp +++ b/src/writer.hpp @@ -5,7 +5,7 @@ class Writer { public: - Writer(Arena& arena) : _arena(arena){}; + Writer(){}; Result write_one(Value& obj); Result write_multiple(Value& obj); @@ -22,17 +22,15 @@ class Writer { Result write_dict(Dict& val); Result write_symbol(Symbol& val); Result write_syntax(Syntax& val); - - Arena& _arena; }; -Result write_one(Arena& arena, Value& value); +Result write_one(Value& value); template -Result write_one(Arena& arena, T& value) +Result write_one(T& value) requires std::derived_from { - auto w = Writer(arena); - auto v = DIEX(value.copy(arena)); + auto w = Writer(); + auto v = DIEX(value.copy()); return w.write_one(v); } diff --git a/test/array.cpp b/test/array.cpp index 994a96b..6a90aae 100644 --- a/test/array.cpp +++ b/test/array.cpp @@ -7,20 +7,20 @@ StaticArena<64 * 1024 * 1024> arena; TEST_CASE(array_append) { - auto a = DIEX(Array::create(arena)); + auto a = DIEX(Array::create()); - a = DIEX(a.append(arena, 1)); - a = DIEX(a.append(arena, 2)); - a = DIEX(a.append(arena, 3)); + a = DIEX(a.append(1)); + a = DIEX(a.append(2)); + a = DIEX(a.append(3)); - DIEX(arena.gc()); + DIEX(arena_gc()); - auto s = DIEX(write_one(arena, a)); + auto s = DIEX(write_one(a)); - DIEX(arena.gc()); + DIEX(arena_gc()); ASSERT_EQUALS(s, "[1 2 3]"); - auto v = DIEX(a.get(arena, 1)); + auto v = DIEX(a.get(1)); ASSERT_EQUALS(v, 2); } diff --git a/test/dict.cpp b/test/dict.cpp index 48b6e17..9cc5306 100644 --- a/test/dict.cpp +++ b/test/dict.cpp @@ -7,33 +7,33 @@ StaticArena<64 * 1024 * 1024> arena; TEST_CASE(dict_insert) { - auto d = DIEX(Dict::create(arena)); + auto d = DIEX(Dict::create()); - d = DIEX(d.insert(arena, 1, 2)); - d = DIEX(d.insert(arena, 1, 3)); - d = DIEX(d.insert(arena, 3, 3)); - d = DIEX(d.insert(arena, 0, 4)); - d = DIEX(d.insert(arena, 0, 5)); - d = DIEX(d.insert(arena, 2, 6)); + d = DIEX(d.insert(1, 2)); + d = DIEX(d.insert(1, 3)); + d = DIEX(d.insert(3, 3)); + d = DIEX(d.insert(0, 4)); + d = DIEX(d.insert(0, 5)); + d = DIEX(d.insert(2, 6)); - DIEX(arena.gc()); + DIEX(arena_gc()); - auto s = DIEX(write_one(arena, d)); + auto s = DIEX(write_one(d)); - DIEX(arena.gc()); + DIEX(arena_gc()); ASSERT_EQUALS(s, "{0 5 1 3 2 6 3 3}"); } TEST_CASE(dict_read) { - auto v = DIEX(read_one(arena, "{}")); - auto s = DIEX(write_one(arena, v)); + auto v = DIEX(read_one("{}")); + auto s = DIEX(write_one(v)); ASSERT_EQUALS(s, "{}"); - v = DIEX(read_one(arena, "{1 2 3 4}")); - s = DIEX(write_one(arena, v)); + v = DIEX(read_one("{1 2 3 4}")); + s = DIEX(write_one(v)); ASSERT_EQUALS(s, "{1 2 3 4}"); - auto vv = DIEX(v.get(arena, 1)); + auto vv = DIEX(v.get(1)); ASSERT_EQUALS(vv, 2); } diff --git a/test/symbol.cpp b/test/symbol.cpp index 2f01ca4..78159b1 100644 --- a/test/symbol.cpp +++ b/test/symbol.cpp @@ -7,14 +7,14 @@ StaticArena<64 * 1024 * 1024> arena; TEST_CASE(symbol_basic) { - auto a = DIEX(Symbol::create(arena, "foo")); - auto b = DIEX(Symbol::create(arena, "foo")); + auto a = DIEX(Symbol::create("foo")); + auto b = DIEX(Symbol::create("foo")); ASSERT_EQUALS(a, b); - auto s = DIEX(write_one(arena, a)); + auto s = DIEX(write_one(a)); - DIEX(arena.gc()); + DIEX(arena_gc()); ASSERT_EQUALS(s, "foo"); } diff --git a/test/test.hpp b/test/test.hpp index 4c0d9f2..95fea0a 100644 --- a/test/test.hpp +++ b/test/test.hpp @@ -43,38 +43,36 @@ bool run_tests() { #define TEST_CASE(fun_) TEST_CASE_IMPL(MACRO_CONCAT(fun_, _COUNTER_)) -Result to_value(Arena& arena, Value& val) { return val.copy(arena); } -Result to_value(Arena& arena, const Value& val) { - return val.copy(arena); -} +Result to_value(Value& val) { return val.copy(); } +Result to_value(const Value& val) { return val.copy(); } template requires std::derived_from -Result to_value(Arena& arena, T& val) { - return val.copy(arena); +Result to_value(T& val) { + return val.copy(); } template requires(!std::derived_from && !std::is_fundamental::value) -Result to_value(Arena& arena, T& val) { - return Value::create(arena, val); +Result to_value(T& val) { + return Value::create(val); } template requires(!std::derived_from && std::is_fundamental::value) -Result to_value(Arena& arena, T val) { - return Value::create(arena, val); +Result to_value(T val) { + return Value::create(val); } #define ASSERT_EQUALS(lhs, rhs) \ do { \ - auto lv = DIEX(to_value(arena, lhs)); \ - auto rv = DIEX(to_value(arena, rhs)); \ - short c = DIEX(lv.cmp(arena, rv)); \ + auto lv = DIEX(to_value(lhs)); \ + auto rv = DIEX(to_value(rhs)); \ + short c = DIEX(lv.cmp(rv)); \ if (c != 0) { \ fprintf(stderr, "Values not equal at %s:%d\n", __FILE__, __LINE__); \ - debug_print(arena, lv); \ - debug_print(arena, rv); \ + debug_print(lv); \ + debug_print(rv); \ exit(EXIT_FAILURE); \ } \ } while (0)