From 988f87a691af3c38ac6773b8c77b9a60d39f6aba Mon Sep 17 00:00:00 2001 From: Gabriel Dos Reis Date: Sat, 13 Aug 2022 13:40:27 -0700 Subject: Rename `Dynamic` to `Boxed` --- src/include/open-axiom/vm | 67 ++++++++++++++++++++++------------------------- src/rt/Lisp.cc | 22 ++++++++-------- src/rt/vm.cc | 13 ++++----- 3 files changed, 48 insertions(+), 54 deletions(-) diff --git a/src/include/open-axiom/vm b/src/include/open-axiom/vm index f7862249..301c6b2d 100644 --- a/src/include/open-axiom/vm +++ b/src/include/open-axiom/vm @@ -174,7 +174,8 @@ namespace OpenAxiom { constexpr bool to_bool(Value v) { return v != Value::nil; } // -- Convert a C++ Boolean value to VM view. - constexpr Value to_value(bool b) { + template T> + constexpr Value to_value(T b) { return b ? Value::t : Value::nil; } @@ -214,13 +215,13 @@ namespace OpenAxiom { three = 3, // Exactly three arguments. }; - // ------------- - // -- Dynamic -- - // ------------- + // ----------- + // -- Boxed -- + // ----------- // Any internal value is of a class derived from this. - internal_type Dynamic { + internal_type Boxed { struct Visitor; - virtual ~Dynamic(); + virtual ~Boxed() = default; virtual void accept(Visitor&) const = 0; }; @@ -230,26 +231,26 @@ namespace OpenAxiom { inline const S& as(const T& t) { return t; } template<> - struct ValueTrait { + struct ValueTrait { enum Tag : ValueBits { tag = 0x6 }; enum Mask : ValueBits { tag_mask = 0xF }; }; - inline Dynamic* to_dynamic(Value v) { - return reinterpret_cast(native(v)); + inline Boxed* to_boxed(Value v) { + return reinterpret_cast(native(v)); } - inline Dynamic* to_dynamic_if_can(Value v) { - return is(v) ? to_dynamic(v) : nullptr; + inline Boxed* if_boxed(Value v) { + return is(v) ? to_boxed(v) : nullptr; } - template T> + template T> inline Value to_value(const T* o) { - return Value(ValueBits(o) | ValueTrait::tag); + return Value(ValueBits(o) | ValueTrait::tag); } // -- Callable -- - struct Callable : Dynamic { + struct Callable : Boxed { }; // ------------- @@ -276,7 +277,7 @@ namespace OpenAxiom { return Fixnum(FixnumBits(v) >> 1); } - constexpr Value from_fixnum(Fixnum i) { + constexpr Value to_value(Fixnum i) { return Value((ValueBits(i) << 1 ) | ValueTrait::tag); } @@ -295,11 +296,11 @@ namespace OpenAxiom { return reinterpret_cast(native(v)); } - inline Value from_string(InternedString s) { + inline Value to_value(InternedString s) { return Value(ValueBits(s) | ValueTrait::tag); } - inline InternedString to_string_if_can(Value v) { + inline InternedString if_string(Value v) { return is(v) ? to_string(v) : nullptr; } @@ -319,7 +320,7 @@ namespace OpenAxiom { return Pointer(ValueBits(v)); } - inline Value from_pointer(Pointer p) { + inline Value to_value(Pointer p) { return Value(ValueBits(p) | ValueTrait::tag); } @@ -343,7 +344,7 @@ namespace OpenAxiom { return reinterpret_cast(native(v)); } - inline Value from_pair(Pair p) { + inline Value to_value(Pair p) { return Value(ValueBits(p) | ValueTrait::tag); } @@ -358,13 +359,13 @@ namespace OpenAxiom { // If `v' designates a pair, return a pointer to its // concrete representation. - inline Pair to_pair_if_can(Value v) { + inline Pair if_pair(Value v) { return consp(v) == Value::t ? to_pair(v) : nullptr; } Fixnum count_nodes(Pair); inline Fixnum count_nodes(Value v) { - if (auto p = to_pair_if_can(v)) + if (auto p = if_pair(v)) return count_nodes(p); return Fixnum::zero; } @@ -386,7 +387,7 @@ namespace OpenAxiom { return Character(ValueBits(v) >> 4); } - constexpr Value from_character(Character c) { + constexpr Value to_value(Character c) { return Value((ValueBits(c) << 4) | ValueTrait::tag); } @@ -416,7 +417,7 @@ namespace OpenAxiom { // ------------ // -- Symbol -- // ------------ - struct Symbol : Dynamic { + struct Symbol : Boxed { const InternedString name; Value value; const Callable* function; @@ -428,22 +429,18 @@ namespace OpenAxiom { bool has(SymbolAttribute x) const { return (attributes & x) == x; } }; - inline Symbol* to_symbol_if_can(Value v) { - return dynamic_cast(to_dynamic_if_can(v)); - } - - inline bool is_symbol(Value v) { - return to_symbol_if_can(v) != nullptr; + inline Symbol* if_symbol(Value v) { + return dynamic_cast(if_boxed(v)); } // -- Test if a value is a symbol. inline Value symbolp(Value v) { - return to_value(v == Value::nil or v == Value::t or is_symbol(v)); + return to_value(v == Value::nil or v == Value::t or if_symbol(v) != nullptr); } // -- Test if a value is a keyword symbol. inline Value keywordp(Value v) { - if (auto sym = to_symbol_if_can(v)) + if (auto sym = if_symbol(v)) return to_value(sym->has(SymbolAttribute::Keyword)); return Value::nil; } @@ -463,7 +460,7 @@ namespace OpenAxiom { // -- Argument binding as value. // Binding a parameter to a value in a call. - struct Binding : Dynamic { + struct Binding : Boxed { Symbol* symbol; Value value; void accept(Visitor&) const override; @@ -489,7 +486,7 @@ namespace OpenAxiom { // ------------- // -- Package -- // ------------- - struct Package : Dynamic { + struct Package : Boxed { const InternedString name; std::set symbols; @@ -554,8 +551,8 @@ namespace OpenAxiom { } }; - // -- Dynamic::Visitor -- - struct Dynamic::Visitor { + // -- Boxed::Visitor -- + struct Boxed::Visitor { virtual void visit(const Symbol&) = 0; virtual void visit(const Binding&) = 0; virtual void visit(const Package&) = 0; diff --git a/src/rt/Lisp.cc b/src/rt/Lisp.cc index 71b3c2b1..fae3e02f 100644 --- a/src/rt/Lisp.cc +++ b/src/rt/Lisp.cc @@ -68,8 +68,8 @@ namespace OpenAxiom { constexpr NamedConstant value_constants[] = { { "NIL", Value::nil }, { "T", Value::t }, - { "MOST-NEGATIVE-FIXNUM", from_fixnum(Fixnum::minimum) }, - { "MOST-POSITIVE-FIXNUM", from_fixnum(Fixnum::maximum) }, + { "MOST-NEGATIVE-FIXNUM", to_value(Fixnum::minimum) }, + { "MOST-POSITIVE-FIXNUM", to_value(Fixnum::maximum) }, }; static void define_special_constants(Evaluator* ctx) { @@ -151,7 +151,7 @@ namespace OpenAxiom { val = -val; } } - return VM::from_fixnum(Fixnum(val)); + return VM::to_value(Fixnum(val)); } static Value @@ -163,14 +163,14 @@ namespace OpenAxiom { if (x.dotted()) result = ctx->make_value(*p++); while (p != x.rend()) - result = from_pair(ctx->make_pair(ctx->make_value(*p++), result)); + result = to_value(ctx->make_pair(ctx->make_value(*p++), result)); return result; } static Value construct(Evaluator* ctx, const Sexpr::StringSyntax& x) { auto s = ctx->intern(x.lexeme().begin(), x.lexeme().size()); - return from_string(s); + return to_value(s); } static Value @@ -457,7 +457,7 @@ namespace OpenAxiom { if (v == Value::nil) break; os << ' '; - if (auto q = to_pair_if_can(v)) { + if (auto q = if_pair(v)) { p = q; continue; } @@ -478,7 +478,7 @@ namespace OpenAxiom { os << '"'; } - static void format(const Dynamic*, std::ostream&); + static void format(const Boxed*, std::ostream&); void format(Value v, std::ostream& os) { if (v == Value::nil) @@ -491,14 +491,14 @@ namespace OpenAxiom { format(to_pair(v), os); else if (is(v)) format(to_string(v), os); - else if (is(v)) - format(to_dynamic(v), os); + else if (is(v)) + format(to_boxed(v), os); else os << "#"; } - static void format(const Dynamic* x, std::ostream& os) { - struct V : Dynamic::Visitor { + static void format(const Boxed* x, std::ostream& os) { + struct V : Boxed::Visitor { std::ostream& os; V(std::ostream& s) : os(s) { } void visit(const Symbol& s) { diff --git a/src/rt/vm.cc b/src/rt/vm.cc index b099fa70..dbeb7fd0 100644 --- a/src/rt/vm.cc +++ b/src/rt/vm.cc @@ -1,4 +1,4 @@ -// Copyright (C) 2011-2014, Gabriel Dos Reis. +// Copyright (C) 2011-2022, Gabriel Dos Reis. // All rights reserved. // Written by Gabriel Dos Reis. // @@ -39,15 +39,15 @@ namespace OpenAxiom { namespace VM { - void Dynamic::Visitor::visit(const NullaryOperator& x) { + void Boxed::Visitor::visit(const NullaryOperator& x) { visit(as(x)); } - void Dynamic::Visitor::visit(const UnaryOperator& x) { + void Boxed::Visitor::visit(const UnaryOperator& x) { visit(as(x)); } - void Dynamic::Visitor::visit(const BinaryOperator& x) { + void Boxed::Visitor::visit(const BinaryOperator& x) { visit(as(x)); } @@ -72,9 +72,6 @@ namespace OpenAxiom { return nullptr; } - // -- Dynamic - Dynamic::~Dynamic() = default; - // -- Symbol Symbol::Symbol(InternedString s) : name(s), @@ -113,7 +110,7 @@ namespace OpenAxiom { Fixnum count_nodes(Pair p) { FixnumBits n = 1; - for (; auto q = to_pair_if_can(p->tail); p = q) + for (; auto q = if_pair(p->tail); p = q) ++n; return Fixnum(n); } -- cgit v1.2.3