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

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;
}