roland/xo-reader2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

xo-interpreter2 stack: refactor + bugfix operator expr

Browse source
This commit is contained in:
Roland Conybeare 2026-03-12 20:26:08 -05:00
commit 3dc6268dfe
20 changed files with 614 additions and 230 deletions
Download patch file Download diff file Expand all files Collapse all files

16
CMakeLists.txt
View file

@ -337,6 +337,22 @@ xo_add_genfacetimpl(
# ----------------------------------------------------------------
# note: manual target; generated code committed to git
xo_add_genfacetimpl(
TARGET xo-reader2-facetimpl-gcobject-globalenv
FACET_PKG xo_alloc2
INPUT idl/IGCObject_DGlobalEnv.json5
)
# note: manual target; generated code committed to git
xo_add_genfacetimpl(
TARGET xo-reader2-facetimpl-printable-globalenv
FACET_PKG xo_printable2
INPUT idl/IPrintable_DGlobalEnv.json5
)
# ----------------------------------------------------------------
xo_add_genfacet_all(xo-reader2-genfacet-all)
# ----------------------------------------------------------------

18
idl/IGCObject_DGlobalEnv.json5 Normal file
View file

@ -0,0 +1,18 @@
{
mode: "implementation",
output_cpp_dir: "src/reader2/facet",
output_hpp_dir: "include/xo/interpreter2",
output_impl_subdir: "env",
includes: [
"<xo/alloc2/GCObject.hpp>",
"<xo/alloc2/Allocator.hpp>"
],
local_types: [ ],
namespace1: "xo",
namespace2: "scm",
facet_idl: "idl/GCObject.json5",
brief: "provide AGCObject interface for GlobalEnv",
using_doxygen: true,
repr: "DGlobalEnv",
doc: [ "implement AGCObject for DGlobalEnv" ],
}

16
idl/IPrintable_DGlobalEnv.json5 Normal file
View file

@ -0,0 +1,16 @@
{
mode: "implementation",
output_cpp_dir: "src/interpreter2/facet",
output_hpp_dir: "include/xo/interpreter2",
output_impl_subdir: "env",
includes: [ "<xo/printable2/Printable.hpp>",
"<xo/printable2/detail/IPrintable_Xfer.hpp>" ],
local_types: [ ],
namespace1: "xo",
namespace2: "scm",
facet_idl: "idl/Printable.json5",
brief: "provide APrintable interface for DGlobalEnv",
using_doxygen: true,
repr: "DGlobalEnv",
doc: [ "implement APrintable for DGlobalEnv" ],
}

94
include/xo/reader2/DGlobalEnv.hpp Normal file
View file

@ -0,0 +1,94 @@
/** @file DGlobalEnv.hpp
*
* @author Roland Conybeare, Feb 2026
**/
#pragma once
#include <xo/expression2/DGlobalSymtab.hpp>
#include <xo/object2/DArray.hpp>
namespace xo {
namespace scm {
/** @brief runtime bindings for global variabels
*
* Implementation here uses a DArenaHashMap to hold <key,value> pairs.
* The hash map has its own memory outside GC space.
* Keys are DUniqueStrings, also outside GC space.
* Values are regular gc-aware objects, generally will be in GC space.
*
* We need collector to traverse all the values in a global env
* on each cycle. Arrange that by having DGlobalEnv itself
* in GC space.
*
**/
class DGlobalEnv {
public:
using TypeDescr = xo::reflect::TypeDescr;
using ACollector = xo::mm::ACollector;
using AAllocator = xo::mm::AAllocator;
using AGCObject = xo::mm::AGCObject;
using MemorySizeVisitor = xo::mm::MemorySizeVisitor;
using ppindentinfo = xo::print::ppindentinfo;
using size_type = std::uint32_t;
public:
/** @defgroup scm-globalenv-ctors constructors **/
///@{
DGlobalEnv(DGlobalSymtab * symtab, DArray * values);
static DGlobalEnv * _make(obj<AAllocator> mm,
DGlobalSymtab * symtab);
///@}
/** @defgroup scm-globalenv-methods methods **/
///@{
/** symbol-table size. Is the number of distinct global variables **/
size_type n_vars() const noexcept { return symtab_->n_vars(); }
/** lookup current value associated with binding @p ix **/
obj<AGCObject> lookup_value(Binding ix) const noexcept;
/** assign value associated with binding @p to @p x.
* If need to expand size of this env, use memory from @p mm
**/
void assign_value(obj<AAllocator> mm, Binding ix, obj<AGCObject> x);
/** create/establish global for symbol @p sym with resolved type @p td
* and associate with @p value.
**/
DVariable * _upsert_value(obj<AAllocator> mm,
const DUniqueString * sym,
TypeDescr td,
obj<AGCObject> value);
///@}
/** @defgroup scm-globalenv-gcobject-facet **/
///@{
std::size_t shallow_size() const noexcept;
DGlobalEnv * shallow_copy(obj<AAllocator> mm) const noexcept;
std::size_t forward_children(obj<ACollector> gc) noexcept;
///@}
/** @defgroup scm-globalenv-printable-facet **/
///@{
bool pretty(const ppindentinfo & ppii) const;
///@}
private:
/** symbol table assigns a unique index for each symbol **/
DGlobalSymtab * symtab_;
/** value for a symbol S will be in values_[symtab->lookup_binding(S)] **/
DArray * values_ = nullptr;
};
}
}

12
include/xo/reader2/GlobalEnv.hpp Normal file
View file

@ -0,0 +1,12 @@
/** @file GlobalEnv.hpp
*
* @author Roland Conybeare, Feb 2026
**/
#pragma once
#include "DGlobalEnv.hpp"
#include "env/IGCObject_DGlobalEnv.hpp"
#include "env/IPrintable_DGlobalEnv.hpp"
/* end GlobalEnv.hpp */

4
include/xo/reader2/ParserConfig.hpp
View file

@ -5,6 +5,7 @@
#pragma once
#include <xo/procedure2/PrimitiveRegistry.hpp>
#include <xo/arena/ArenaHashMapConfig.hpp>
#include <xo/arena/ArenaConfig.hpp>
@ -55,6 +56,9 @@ namespace xo {
/** max capacity for unique string table **/
size_t max_stringtable_capacity_ = 4096;
/** flags controlling which primitives to install **/
InstallFlags pm_install_flags_ = InstallFlags::f_all;
/** control SchematikaParser debug logging **/
bool debug_flag_ = false;
};

45
include/xo/reader2/ParserStateMachine.hpp
View file

@ -6,11 +6,13 @@
#pragma once
#include "ParserResult.hpp"
#include "GlobalEnv.hpp"
#include <xo/expression2/DGlobalSymtab.hpp>
#include <xo/expression2/DLocalSymtab.hpp>
#include <xo/expression2/DVariable.hpp>
#include <xo/expression2/VarRef.hpp>
#include <xo/tokenizer2/Token.hpp>
#include <xo/procedure2/PrimitiveRegistry.hpp>
#include <xo/type/Type.hpp>
#include <xo/object2/DArray.hpp>
#include <xo/stringtable2/StringTable.hpp>
@ -45,6 +47,9 @@ namespace xo {
using size_type = std::size_t;
public:
/** @defgroup scm-parserstatemachine-ctors constructors **/
///@{
/**
* @p config arena configuration for parser state
* @p symtab_var_config configuration for global symtab variables
@ -53,6 +58,8 @@ namespace xo {
* (maps to separate dedicated memory)
* @p max_stringtable_capacity
* hard max size for unique stringtable
* @p pm_install_flags
* flags controlling primitives to install
* @p expr_alloc allocator for schematika expressions.
* Probably shared with execution.
* @p aux_alloc auxiliary allocator for non-copyable memory
@ -64,12 +71,17 @@ namespace xo {
const ArenaHashMapConfig & symtab_var_config,
const ArenaHashMapConfig & symtab_type_config,
size_type max_stringtable_capacity,
InstallFlags pm_install_flags,
obj<AAllocator> expr_alloc,
obj<AAllocator> aux_alloc);
/** non-trivial dtor for @ref global_symtab_ **/
~ParserStateMachine() = default;
/** not copyable (need to put global_env into gc **/
ParserStateMachine(const ParserStateMachine & other) = delete;
/** non-trivial dtor for @ref global_symtab_ **/
~ParserStateMachine();
///@}
/** @defgroup scm-parserstatemachine-accessors accessor methods **/
///@{
@ -80,6 +92,21 @@ namespace xo {
DLocalSymtab * local_symtab() const noexcept { return local_symtab_; }
const ParserResult & result() const noexcept { return result_; }
/** polymoprhihc multiply primitive. Use to implement infix op* **/
obj<AGCObject> multiply_pm() const;
/** polymorphic divide primitive. Use to implement infix op/ **/
obj<AGCObject> divide_pm() const;
/** polymorphic add primitive. Use to implement infix op+ **/
obj<AGCObject> add_pm() const;
/** polymorphic subtract primitive. Use to implement infix op- **/
obj<AGCObject> subtract_pm() const;
/** polymorphic equality comparison. Use to implement infix op== **/
obj<AGCObject> cmpeq_pm() const;
/** polymorphic inequality comparison. Use to implement infix op!= **/
obj<AGCObject> cmpne_pm() const;
/** polymorphich less-than comparison. Use to implement infix op< **/
obj<AGCObject> cmplt_pm() const;
/** true iff state machine is currently idle (at top-level) **/
bool is_at_toplevel() const noexcept;
@ -378,6 +405,20 @@ namespace xo {
**/
DLocalSymtab * local_symtab_ = nullptr;
/** global variable bindings (builtin primitives) **/
obj<AGCObject,DGlobalEnv> global_env_;
/** bindings for special builtin primitives
* (asociated with hardwired operator syntax)
**/
Binding multiply_binding_;
Binding divide_binding_;
Binding add_binding_;
Binding subtract_binding_;
Binding cmpeq_binding_;
Binding cmpne_binding_;
Binding cmplt_binding_;
/** current output from parser **/
ParserResult result_;

4
include/xo/reader2/ReaderConfig.hpp
View file

@ -5,6 +5,7 @@
#pragma once
#include <xo/procedure2/PrimitiveRegistry.hpp>
#include <xo/arena/CircularBufferConfig.hpp>
#include <xo/arena/ArenaHashMapConfig.hpp>
#include <xo/arena/ArenaConfig.hpp>
@ -71,6 +72,9 @@ namespace xo {
/** max size (in bytes) of stringtable **/
size_t max_stringtable_cap_ = 64*1024;
/** flags controlling which primitives to install **/
InstallFlags pm_install_flags_ = InstallFlags::f_all;
/** debug flag for schematika_reader **/
bool reader_debug_flag_ = false;
};

67
include/xo/reader2/env/IGCObject_DGlobalEnv.hpp vendored Normal file
View file

@ -0,0 +1,67 @@
/** @file IGCObject_DGlobalEnv.hpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/IGCObject_DGlobalEnv.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_repr.hpp.j2]
* 3. idl for facet methods
* [idl/IGCObject_DGlobalEnv.json5]
**/
#pragma once
#include "GCObject.hpp"
#include <xo/alloc2/GCObject.hpp>
#include <xo/alloc2/Allocator.hpp>
#include "DGlobalEnv.hpp"
namespace xo { namespace scm { class IGCObject_DGlobalEnv; } }
namespace xo {
namespace facet {
template <>
struct FacetImplementation<xo::mm::AGCObject,
xo::scm::DGlobalEnv>
{
using ImplType = xo::mm::IGCObject_Xfer
<xo::scm::DGlobalEnv,
xo::scm::IGCObject_DGlobalEnv>;
};
}
}
namespace xo {
namespace scm {
/** @class IGCObject_DGlobalEnv
**/
class IGCObject_DGlobalEnv {
public:
/** @defgroup scm-gcobject-dglobalenv-type-traits **/
///@{
using size_type = xo::mm::AGCObject::size_type;
using AAllocator = xo::mm::AGCObject::AAllocator;
using ACollector = xo::mm::AGCObject::ACollector;
using Copaque = xo::mm::AGCObject::Copaque;
using Opaque = xo::mm::AGCObject::Opaque;
///@}
/** @defgroup scm-gcobject-dglobalenv-methods **/
///@{
// const methods
/** memory consumption for this instance **/
static size_type shallow_size(const DGlobalEnv & self) noexcept;
/** copy instance using allocator **/
static Opaque shallow_copy(const DGlobalEnv & self, obj<AAllocator> mm) noexcept;
// non-const methods
/** during GC: forward immdiate children **/
static size_type forward_children(DGlobalEnv & self, obj<ACollector> gc) noexcept;
///@}
};
} /*namespace scm*/
} /*namespace xo*/
/* end */

62
include/xo/reader2/env/IPrintable_DGlobalEnv.hpp vendored Normal file
View file

@ -0,0 +1,62 @@
/** @file IPrintable_DGlobalEnv.hpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/IPrintable_DGlobalEnv.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_repr.hpp.j2]
* 3. idl for facet methods
* [idl/IPrintable_DGlobalEnv.json5]
**/
#pragma once
#include "Printable.hpp"
#include <xo/printable2/Printable.hpp>
#include <xo/printable2/detail/IPrintable_Xfer.hpp>
#include "DGlobalEnv.hpp"
namespace xo { namespace scm { class IPrintable_DGlobalEnv; } }
namespace xo {
namespace facet {
template <>
struct FacetImplementation<xo::print::APrintable,
xo::scm::DGlobalEnv>
{
using ImplType = xo::print::IPrintable_Xfer
<xo::scm::DGlobalEnv,
xo::scm::IPrintable_DGlobalEnv>;
};
}
}
namespace xo {
namespace scm {
/** @class IPrintable_DGlobalEnv
**/
class IPrintable_DGlobalEnv {
public:
/** @defgroup scm-printable-dglobalenv-type-traits **/
///@{
using ppindentinfo = xo::print::APrintable::ppindentinfo;
using Copaque = xo::print::APrintable::Copaque;
using Opaque = xo::print::APrintable::Opaque;
///@}
/** @defgroup scm-printable-dglobalenv-methods **/
///@{
// const methods
/** Pretty-printing support for this object.
See [xo-indentlog/xo/indentlog/pretty.hpp] **/
static bool pretty(const DGlobalEnv & self, const ppindentinfo & ppii);
// non-const methods
///@}
};
} /*namespace scm*/
} /*namespace xo*/
/* end */

4
src/reader2/CMakeLists.txt
View file

@ -14,6 +14,10 @@ set(SELF_SRCS
ParserStack.cpp
ParserResult.cpp
DGlobalEnv.cpp
facet/IGCObject_DGlobalEnv.cpp
facet/IPrintable_DGlobalEnv.cpp
syntaxstatetype.cpp
ISyntaxStateMachine_Any.cpp

145
src/reader2/DGlobalEnv.cpp Normal file
View file

@ -0,0 +1,145 @@
/** @file DGlobalEnv.cpp
*
* @author Roland Conybeare, Feb 2026
**/
#include "GlobalEnv.hpp"
#include <xo/expression2/GlobalSymtab.hpp>
#include <xo/object2/Array.hpp>
namespace xo {
using xo::mm::AAllocator;
using xo::mm::AGCObject;
namespace scm {
DGlobalEnv::DGlobalEnv(DGlobalSymtab * symtab, DArray * values)
: symtab_{symtab}, values_{values}
{}
DGlobalEnv *
DGlobalEnv::_make(obj<AAllocator> mm,
DGlobalSymtab * symtab)
{
DArray * values = DArray::empty(mm, symtab->var_capacity());
void * mem = mm.alloc_for<DGlobalSymtab>();
return new (mem) DGlobalEnv(symtab, values);
}
obj<AGCObject>
DGlobalEnv::lookup_value(Binding ix) const noexcept
{
if (!ix.is_global()) {
assert(false);
return obj<AGCObject>();
}
if (ix.j_slot() >= static_cast<int32_t>(values_->size())) {
assert(false);
return obj<AGCObject>();
}
return (*values_)[ix.j_slot()];
}
void
DGlobalEnv::assign_value(obj<AAllocator> mm, Binding ix, obj<AGCObject> x)
{
scope log(XO_DEBUG(true),
xtag("ix.j_slot", ix.j_slot()),
xtag("values.cap", values_->capacity()));
assert(ix.is_global());
if (ix.j_slot() >= static_cast<int32_t>(values_->size())) {
// Control will come here in interpreter as new definitions are introduced.
// After seeing
// def foo = 1.2345;
// introducing new symbol foo:
// GlobalSymtab extends to include foo without this GlobalEnv
// knowing about it.
if (ix.j_slot() + 1 > static_cast<int32_t>(values_->capacity())) {
// realloc global array for more size
size_t cap_2x = 2 * values_->capacity();
while (cap_2x < static_cast<size_t>(ix.j_slot() + 1))
cap_2x = 2 * cap_2x;
DArray * values_2x = DArray::copy(mm, values_, cap_2x);
assert(values_2x);
if (values_2x) {
log && log("STUB: need write barrier for GC (also in GlobalSymtab!)");
this->values_ = values_2x;
} else {
return;
}
}
/** expand size sot that j_slot is valid **/
values_->resize(ix.j_slot() + 1);
}
log && log("STUB: need write barrier for GC here");
(*values_)[ix.j_slot()] = x;
}
DVariable *
DGlobalEnv::_upsert_value(obj<AAllocator> mm,
const DUniqueString * sym,
TypeDescr td,
obj<AGCObject> value)
{
DVariable * var
= DVariable::make(mm, sym, TypeRef::resolved(td));
assert(var);
symtab_->upsert_variable(mm, var);
this->assign_value(mm, var->path(), value);
return var;
}
// ----- AGCObject facet -----
std::size_t
DGlobalEnv::shallow_size() const noexcept
{
return sizeof(*this);
}
DGlobalEnv *
DGlobalEnv::shallow_copy(obj<AAllocator> mm) const noexcept
{
return mm.std_copy_for<DGlobalEnv>(this);
}
std::size_t
DGlobalEnv::forward_children(obj<ACollector> gc) noexcept
{
gc.forward_inplace(&symtab_);
gc.forward_inplace(&values_);
return this->shallow_size();
}
// ----- APrintable facet -----
bool
DGlobalEnv::pretty(const ppindentinfo & ppii) const
{
return ppii.pps()->pretty_struct
(ppii,
"DGlobalEnv",
refrtag("n_vars", symtab_->n_vars()));
}
} /*namespace scm*/
} /*namespace xo*/
/* end DGlobalEnv.cpp */

272
src/reader2/DProgressSsm.cpp
View file

@ -603,173 +603,6 @@ namespace xo {
p_psm->on_error(self_name, std::move(errmsg));
}
rp<Expression>
progress_xs::assemble_expr(parserstatemachine * p_psm) {
/* need to defer building Apply incase expr followed by higher-precedence operator:
* consider input like
* 3.14 + 2.0 * ...
*/
constexpr const char * c_self_name = "progress_xs::assemble_expr";
if ((op_type_ != optype::invalid) && (rhs_.get() == nullptr)) {
std::string errmsg = tostr("expected expression on rhs of operator op",
xtag("lhs", lhs_),
xtag("op", op_type_));
p_psm->on_error(c_self_name, errmsg);
}
/* consecutive expressions not legal, e.g:
* 3.14 6.28
* but expressions surrounding an infix operators is:
* 3.14 / 6.28
*/
switch (op_type_) {
case optype::invalid:
return this->lhs_;
case optype::op_assign:
{
bp<Variable> lhs = Variable::from(this->lhs_);
if (!lhs) {
throw std::runtime_error
(tostr("progress_xs::assemble_expr",
" expect variable on lhs of assignment operator :=",
xtag("lhs", lhs_),
xtag("rhs", rhs_)));
}
return AssignExpr::make(lhs.promote(),
this->rhs_);
}
case optype::op_equal:
if (lhs_->valuetype()->is_i64() && rhs_->valuetype()->is_i64()) {
return Apply::make_cmp_eq_i64(lhs_, rhs_);
} else {
this->apply_type_error(c_self_name,
op_type_, lhs_, rhs_, p_psm);
return nullptr;
}
break;
case optype::op_not_equal:
if (lhs_->valuetype()->is_i64() && rhs_->valuetype()->is_i64()) {
return Apply::make_cmp_ne_i64(lhs_, rhs_);
} else {
this->apply_type_error(c_self_name,
op_type_, lhs_, rhs_, p_psm);
return nullptr;
}
break;
case optype::op_less:
// TODO: floating-point less-than
if (lhs_->valuetype()->is_i64() && rhs_->valuetype()->is_i64()) {
return Apply::make_cmp_lt_i64(lhs_, rhs_);
} else {
this->apply_type_error(c_self_name,
op_type_, lhs_, rhs_, p_psm);
return nullptr;
}
break;
case optype::op_less_equal:
if (lhs_->valuetype()->is_i64() && rhs_->valuetype()->is_i64()) {
return Apply::make_cmp_le_i64(lhs_, rhs_);
} else {
this->apply_type_error(c_self_name,
op_type_, lhs_, rhs_, p_psm);
return nullptr;
}
break;
case optype::op_great:
if (lhs_->valuetype()->is_i64() && rhs_->valuetype()->is_i64()) {
return Apply::make_cmp_gt_i64(lhs_, rhs_);
} else {
this->apply_type_error(c_self_name,
op_type_, lhs_, rhs_, p_psm);
return nullptr;
}
break;
case optype::op_great_equal:
// TODO: upconvert integer->double
if (lhs_->valuetype()->is_i64() && rhs_->valuetype()->is_i64()) {
return Apply::make_cmp_ge_i64(lhs_, rhs_);
} else {
this->apply_type_error(c_self_name,
op_type_, lhs_, rhs_, p_psm);
return nullptr;
}
assert(false);
case optype::op_add:
// TODO: upconvert integer->double
if (lhs_->valuetype()->is_i64() && rhs_->valuetype()->is_i64()) {
return Apply::make_add2_i64(lhs_, rhs_);
} else if (lhs_->valuetype()->is_f64() && rhs_->valuetype()->is_f64()) {
return Apply::make_add2_f64(lhs_, rhs_);
} else {
this->apply_type_error(c_self_name,
op_type_, lhs_, rhs_, p_psm);
return nullptr;
}
break;
case optype::op_subtract:
// TODO: upconvert integer->double
if (lhs_->valuetype()->is_i64() && rhs_->valuetype()->is_i64()) {
return Apply::make_sub2_i64(lhs_, rhs_);
} else if (lhs_->valuetype()->is_f64() && rhs_->valuetype()->is_f64()) {
return Apply::make_sub2_f64(lhs_, rhs_);
} else {
this->apply_type_error(c_self_name,
op_type_, lhs_, rhs_, p_psm);
return nullptr;
}
break;
case optype::op_multiply:
// TODO: upconvert integer->double
if (lhs_->valuetype()->is_i64() && rhs_->valuetype()->is_i64()) {
return Apply::make_mul2_i64(lhs_, rhs_);
} else if (lhs_->valuetype()->is_f64() && rhs_->valuetype()->is_f64()) {
return Apply::make_mul2_f64(lhs_, rhs_);
} else {
this->apply_type_error(c_self_name,
op_type_, lhs_, rhs_, p_psm);
return nullptr;
}
break;
case optype::op_divide:
// TODO: upconvert integer->double
if (lhs_->valuetype()->is_i64() && rhs_->valuetype()->is_i64()) {
return Apply::make_div2_i64(lhs_, rhs_);
} else if (lhs_->valuetype()->is_f64() && rhs_->valuetype()->is_f64()) {
return Apply::make_div2_f64(lhs_, rhs_);
} else {
this->apply_type_error(c_self_name,
op_type_, lhs_, rhs_, p_psm);
return nullptr;
}
break;
case optype::n_optype:
/* unreachable */
assert(false);
return nullptr;
}
return nullptr;
}
void
progress_xs::on_expr(bp<Expression> expr,
parserstatemachine * p_psm)
@ -1216,11 +1049,10 @@ namespace xo {
obj<AExpression>
assemble_numeric_expr_aux(obj<AAllocator> expr_alloc,
const TypeRef::prefix_type & prefix,
DPrimitive_gco_2_gco_gco * p_gco_pm,
obj<AGCObject> pm_obj,
obj<AExpression> lhs,
obj<AExpression> rhs)
{
auto pm_obj = with_facet<AGCObject>::mkobj(p_gco_pm);
auto fn_expr = DConstant::make(expr_alloc, pm_obj);
/* note:
@ -1247,6 +1079,23 @@ namespace xo {
tref, fn_expr, lhs, rhs);
}
#ifdef OBSOLETE
obj<AExpression>
assemble_numeric_expr_aux(obj<AAllocator> expr_alloc,
const TypeRef::prefix_type & prefix,
DPrimitive_gco_2_gco_gco * p_gco_pm,
obj<AExpression> lhs,
obj<AExpression> rhs)
{
auto pm_obj = with_facet<AGCObject>::mkobj(p_gco_pm);
return assemble_numeric_expr_aux(expr_alloc,
prefix,
pm_obj,
lhs, rhs);
}
#endif
}
obj<AExpression>
@ -1288,41 +1137,21 @@ namespace xo {
return assemble_numeric_expr_aux
(p_psm->expr_alloc(),
TypeRef::prefix_type::from_chars("_cmpeq_gco"),
&NumericPrimitives::s_cmpeq_gco_gco_pm,
p_psm->cmpeq_pm(),
lhs_, rhs_);
#ifdef OBSOLETE
{
auto pm_obj = (with_facet<AGCObject>::mkobj
(&NumericPrimitives::s_cmpeq_gco_gco_pm));
auto fn_expr = (DConstant::make
(p_psm->expr_alloc(), pm_obj));
// see note on op_multiply
TypeRef tref = TypeRef::dwim
(TypeRef::prefix_type::from_chars("_equal_gco"),
nullptr);
return DApplyExpr::make2(p_psm->expr_alloc(),
tref,
fn_expr, lhs_, rhs_);
}
break;
#endif
case optype::op_not_equal:
return assemble_numeric_expr_aux
(p_psm->expr_alloc(),
TypeRef::prefix_type::from_chars("_cmpne_gco"),
&NumericPrimitives::s_cmpne_gco_gco_pm,
p_psm->cmpne_pm(),
lhs_, rhs_);
case optype::op_less:
return assemble_numeric_expr_aux
(p_psm->expr_alloc(),
TypeRef::prefix_type::from_chars("_cmplt_gco"),
&NumericPrimitives::s_cmplt_gco_gco_pm,
p_psm->cmplt_pm(),
lhs_, rhs_);
case optype::op_less_equal:
@ -1335,45 +1164,18 @@ namespace xo {
return assemble_numeric_expr_aux
(p_psm->expr_alloc(),
TypeRef::prefix_type::from_chars("_mul_gco"),
&NumericPrimitives::s_mul_gco_gco_pm,
p_psm->multiply_pm(), //&NumericPrimitives::s_mul_gco_gco_pm
lhs_, rhs_);
#ifdef OBSOLETE
{
auto pm_obj = (with_facet<AGCObject>::mkobj
(&NumericPrimitives::s_mul_gco_gco_pm));
auto fn_expr = (DConstant::make
(p_psm->expr_alloc(), pm_obj));
/* note:
* 1. don't assume we know lhs_ / rhs_ value types yet.
* perhaps have expression like
* f(..) * g(..)
* where f is the function that contains current ssm.
*
* 2. consequence: we need representation for
* polymorphic multiply on unknown numeric arguments.
*
* 3. TypeRef::dwim(..) is a placeholder.
* Plan to later provide abstract interpreter
* (ie compiler pass :) to drive type inference/unification
*
* 4. Alternatively could supply type-annotation syntax
* so human can assist inference; context here is we want
* to automate the boring stuff
*/
TypeRef tref = TypeRef::dwim
(TypeRef::prefix_type::from_chars("_mul_gco"),
nullptr);
return DApplyExpr::make2(p_psm->expr_alloc(),
tref, fn_expr, lhs_, rhs_);
}
#endif
break;
case optype::op_divide:
return assemble_numeric_expr_aux
(p_psm->expr_alloc(),
TypeRef::prefix_type::from_chars("_div_gco"),
p_psm->divide_pm(), // &NumericPrimitives::s_div_gco_gco_pm
lhs_, rhs_);
#ifdef OBSOLETE
{
auto pm_obj = (with_facet<AGCObject>::mkobj
(&NumericPrimitives::s_div_gco_gco_pm));
@ -1405,10 +1207,17 @@ namespace xo {
return DApplyExpr::make2(p_psm->expr_alloc(),
tref, fn_expr, lhs_, rhs_);
}
#endif
break;
case optype::op_add:
return assemble_numeric_expr_aux
(p_psm->expr_alloc(),
TypeRef::prefix_type::from_chars("_add_gco"),
p_psm->add_pm(),
lhs_, rhs_);
#ifdef OBSOLETE
{
auto pm_obj = (with_facet<AGCObject>::mkobj
(&NumericPrimitives::s_add_gco_gco_pm));
@ -1440,10 +1249,18 @@ namespace xo {
return DApplyExpr::make2(p_psm->expr_alloc(),
tref, fn_expr, lhs_, rhs_);
}
#endif
break;
case optype::op_subtract: /* editor bait: op_minus */
return assemble_numeric_expr_aux
(p_psm->expr_alloc(),
TypeRef::prefix_type::from_chars("_sub_gco"),
p_psm->subtract_pm(),
lhs_, rhs_);
#ifdef OBSOLETE
{
auto pm_obj = (with_facet<AGCObject>::mkobj
(&NumericPrimitives::s_sub_gco_gco_pm));
@ -1459,6 +1276,7 @@ namespace xo {
return DApplyExpr::make2(p_psm->expr_alloc(),
tref, fn_expr, lhs_, rhs_);
}
#endif
break;

2
src/reader2/ParserStateMachine.cpp
View file

@ -8,8 +8,10 @@
#include "SyntaxStateMachine.hpp"
#include "ToplevelSeqSsm.hpp"
#include "DefineSsm.hpp"
#include <xo/procedure2/PrimitiveRegistry.hpp>
#include <xo/object2/array/IPrintable_DArray.hpp>
#include <xo/printable2/Printable.hpp>
#include <xo/alloc2/Collector.hpp>
#include <xo/alloc2/arena/IAllocator_DArena.hpp>
#include <xo/facet/FacetRegistry.hpp>
#include <xo/indentlog/scope.hpp>

1
src/reader2/SchematikaParser.cpp
View file

@ -28,6 +28,7 @@ namespace xo {
cfg.symtab_var_config_,
cfg.symtab_types_config_,
cfg.max_stringtable_capacity_,
cfg.pm_install_flags_,
expr_alloc,
aux_alloc
},

1
src/reader2/SchematikaReader.cpp
View file

@ -18,6 +18,7 @@ namespace xo {
config.symtab_var_config_,
config.symtab_types_config_,
config.max_stringtable_cap_,
config.pm_install_flags_,
config.parser_debug_flag_),
expr_alloc,
aux_alloc},

39
src/reader2/facet/IGCObject_DGlobalEnv.cpp Normal file
View file

@ -0,0 +1,39 @@
/** @file IGCObject_DGlobalEnv.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/IGCObject_DGlobalEnv.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/IGCObject_DGlobalEnv.json5]
**/
#include "env/IGCObject_DGlobalEnv.hpp"
namespace xo {
namespace scm {
auto
IGCObject_DGlobalEnv::shallow_size(const DGlobalEnv & self) noexcept -> size_type
{
return self.shallow_size();
}
auto
IGCObject_DGlobalEnv::shallow_copy(const DGlobalEnv & self, obj<AAllocator> mm) noexcept -> Opaque
{
return self.shallow_copy(mm);
}
auto
IGCObject_DGlobalEnv::forward_children(DGlobalEnv & self, obj<ACollector> gc) noexcept -> size_type
{
return self.forward_children(gc);
}
} /*namespace scm*/
} /*namespace xo*/
/* end IGCObject_DGlobalEnv.cpp */

28
src/reader2/facet/IPrintable_DGlobalEnv.cpp Normal file
View file

@ -0,0 +1,28 @@
/** @file IPrintable_DGlobalEnv.cpp
*
* Generated automagically from ingredients:
* 1. code generator:
* [xo-facet/codegen/genfacet]
* arguments:
* --input [idl/IPrintable_DGlobalEnv.json5]
* 2. jinja2 template for abstract facet .hpp file:
* [iface_facet_any.hpp.j2]
* 3. idl for facet methods
* [idl/IPrintable_DGlobalEnv.json5]
**/
#include "env/IPrintable_DGlobalEnv.hpp"
namespace xo {
namespace scm {
auto
IPrintable_DGlobalEnv::pretty(const DGlobalEnv & self, const ppindentinfo & ppii) -> bool
{
return self.pretty(ppii);
}
} /*namespace scm*/
} /*namespace xo*/
/* end IPrintable_DGlobalEnv.cpp */

9
src/reader2/reader2_register_facets.cpp
View file

@ -33,6 +33,7 @@
namespace xo {
using xo::print::APrintable;
using xo::mm::AGCObject;
using xo::facet::FacetRegistry;
using xo::facet::TypeRegistry;
using xo::facet::typeseq;
@ -43,6 +44,13 @@ namespace xo {
{
scope log(XO_DEBUG(true));
// GlobalEnv
FacetRegistry::register_impl<AGCObject, DGlobalEnv>();
FacetRegistry::register_impl<APrintable, DGlobalEnv>();
// SyntaxStateMachine
FacetRegistry::register_impl<ASyntaxStateMachine, DToplevelSeqSsm>();
FacetRegistry::register_impl<APrintable, DToplevelSeqSsm>();
@ -105,6 +113,7 @@ namespace xo {
// misc types showing up in parser stack arena
TypeRegistry::register_type<ParserStack>();
log && log(xtag("DGlobalEnv.tseq", typeseq::id<DGlobalEnv>()));
log && log(xtag("DToplevelSeqSsm.tseq", typeseq::id<DToplevelSeqSsm>()));
log && log(xtag("DDefineSsm.tseq", typeseq::id<DDefineSsm>()));
log && log(xtag("DDeftypeSsm.tseq", typeseq::id<DDeftypeSsm>()));

7
src/reader2/reader2_register_types.cpp
View file

@ -4,22 +4,25 @@
**/
#include "reader2_register_types.hpp"
#include "GlobalEnv.hpp"
#include <xo/indentlog/scope.hpp>
namespace xo {
using xo::mm::ACollector;
using xo::mm::AGCObject;
using xo::facet::impl_for;
using xo::scope;
namespace scm {
bool
reader2_register_types(obj<ACollector> /*gc*/)
reader2_register_types(obj<ACollector> gc)
{
scope log(XO_DEBUG(true));
bool ok = true;
/* no gc-aware types yet; scaffold for future use */
ok &= gc.install_type(impl_for<AGCObject, DGlobalEnv>());
return ok;
}