diff --git a/include/xo/reader2/SchematikaReader.hpp b/include/xo/reader2/SchematikaReader.hpp index 8b24f775..58c77ec8 100644 --- a/include/xo/reader2/SchematikaReader.hpp +++ b/include/xo/reader2/SchematikaReader.hpp @@ -110,7 +110,7 @@ namespace xo { /** parser converts a stream of tokens * to a stream of expressions **/ - SchematikaParser parser_; + DSchematikaParser parser_; /** current output from reader **/ ReaderResult result_; diff --git a/src/reader2/CMakeLists.txt b/src/reader2/CMakeLists.txt index 73e9ea37..30f11169 100644 --- a/src/reader2/CMakeLists.txt +++ b/src/reader2/CMakeLists.txt @@ -8,7 +8,9 @@ set(SELF_SRCS SchematikaReader.cpp ReaderConfig.cpp - SchematikaParser.cpp + DSchematikaParser.cpp + facet/IGCObject_DSchematikaParser.cpp + ParserStateMachine.cpp ParserStack.cpp ParserResult.cpp diff --git a/src/reader2/DSchematikaParser.cpp b/src/reader2/DSchematikaParser.cpp index 7d27e41c..a18d9735 100644 --- a/src/reader2/DSchematikaParser.cpp +++ b/src/reader2/DSchematikaParser.cpp @@ -1,4 +1,4 @@ -/** @file SchematikaParser.cpp +/** @file DSchematikaParser.cpp * * @author Roland Conybeare, Jan 2026 **/ @@ -12,7 +12,9 @@ #include namespace xo { + using xo::mm::ACollector; using xo::mm::AAllocator; + using xo::mm::AGCObject; using xo::mm::MemorySizeInfo; using xo::tostr; using xo::xtag; @@ -20,9 +22,9 @@ namespace xo { namespace scm { // ----- SchematikaParser ----- - SchematikaParser::SchematikaParser(const ParserConfig & cfg, - obj expr_alloc, - obj aux_alloc) + DSchematikaParser::DSchematikaParser(const ParserConfig & cfg, + obj expr_alloc, + obj aux_alloc) : psm_{ cfg.parser_arena_config_, cfg.symtab_var_config_, @@ -36,74 +38,94 @@ namespace xo { { } + DSchematikaParser * + DSchematikaParser::_make(obj mm, + const ParserConfig & cfg, + obj expr_alloc, + obj aux_alloc) + { + void * mem = mm.alloc_for(); + + return new (mem) DSchematikaParser(cfg, expr_alloc, aux_alloc); + } + + obj + DSchematikaParser::make(obj mm, + const ParserConfig & cfg, + obj expr_alloc, + obj aux_alloc) + { + return obj(_make(mm, cfg, expr_alloc, aux_alloc)); + } + DGlobalSymtab * - SchematikaParser::global_symtab() const noexcept + DSchematikaParser::global_symtab() const noexcept { return psm_.global_symtab(); } DGlobalEnv * - SchematikaParser::global_env() const noexcept + DSchematikaParser::global_env() const noexcept { return psm_.global_env(); } bool - SchematikaParser::is_at_toplevel() const + DSchematikaParser::is_at_toplevel() const { return psm_.is_at_toplevel(); } bool - SchematikaParser::has_incomplete_expr() const + DSchematikaParser::has_incomplete_expr() const { return psm_.has_incomplete_expr(); } obj - SchematikaParser::top_ssm() const + DSchematikaParser::top_ssm() const { return psm_.top_ssm(); } const ParserResult & - SchematikaParser::result() const + DSchematikaParser::result() const { return psm_.result(); } void - SchematikaParser::visit_pools(const MemorySizeVisitor & visitor) const + DSchematikaParser::visit_pools(const MemorySizeVisitor & visitor) const { return psm_.visit_pools(visitor); } void - SchematikaParser::begin_interactive_session() + DSchematikaParser::begin_interactive_session() { DToplevelSeqSsm::establish_interactive(psm_.parser_alloc(), &psm_); } void - SchematikaParser::begin_batch_session() + DSchematikaParser::begin_batch_session() { DToplevelSeqSsm::establish_batch(psm_.parser_alloc(), &psm_); } const DUniqueString * - SchematikaParser::intern_string(std::string_view str) + DSchematikaParser::intern_string(std::string_view str) { return psm_.intern_string(str); } const ParserResult & - SchematikaParser::on_token(const token_type & tk) + DSchematikaParser::on_token(const token_type & tk) { scope log(XO_DEBUG(debug_flag_), xtag("tk", tk)); if (psm_.stack() == nullptr) { - throw std::runtime_error(tostr("SchematikaParser::include_token", + throw std::runtime_error(tostr("DSchematikaParser::include_token", ": parser not expecting input" "(call parser.begin_translation_unit()..?)", xtag("token", tk))); @@ -120,19 +142,19 @@ namespace xo { } /*include_token*/ void - SchematikaParser::reset_result() + DSchematikaParser::reset_result() { psm_.reset_result(); } void - SchematikaParser::reset_to_idle_toplevel() + DSchematikaParser::reset_to_idle_toplevel() { psm_.clear_error_reset(); } /*reset_to_idle_toplevel*/ void - SchematikaParser::print(std::ostream & os) const { + DSchematikaParser::print(std::ostream & os) const { os << " mm) const noexcept + { + (void)mm; + + assert(false); + return nullptr; + } + + std::size_t + DSchematikaParser::forward_children(obj gc) noexcept + { + psm_.forward_children(gc); + + return this->shallow_size(); + } + } /*namespace scm*/ } /*namespace xo*/ diff --git a/src/reader2/ParserResult.cpp b/src/reader2/ParserResult.cpp index 974724d9..fa9c9591 100644 --- a/src/reader2/ParserResult.cpp +++ b/src/reader2/ParserResult.cpp @@ -4,7 +4,9 @@ **/ #include "ParserResult.hpp" +#include #include +#include #include namespace xo { @@ -102,6 +104,15 @@ namespace xo { return false; } + + void + ParserResult::forward_children(obj gc) noexcept + { + // {result_type_, error_src_fn_}: pod, ignore + + gc.forward_pivot_inplace(&result_expr_); + gc.forward_inplace(const_cast(&error_description_)); + } } /*namespace scm*/ } /*namespace xo*/ diff --git a/src/reader2/ParserStack.cpp b/src/reader2/ParserStack.cpp index 9ab919b2..f40696b2 100644 --- a/src/reader2/ParserStack.cpp +++ b/src/reader2/ParserStack.cpp @@ -89,6 +89,18 @@ namespace xo { return false; } + void + ParserStack::forward_children(obj gc) noexcept + { + + for (ParserStack * target = this; target; target = target->parent_) { + // ParserStack::ckp: skip, POD + + if (target->ssm_) + target->ssm_.forward_children(gc); + } + } + } /*namespace scm*/ } /*namespace xo*/ diff --git a/src/reader2/ParserStateMachine.cpp b/src/reader2/ParserStateMachine.cpp index 16871d22..63c333e1 100644 --- a/src/reader2/ParserStateMachine.cpp +++ b/src/reader2/ParserStateMachine.cpp @@ -43,7 +43,7 @@ namespace xo { DGlobalSymtab * global_symtab, InstallFlags pm_install_flags) { - scope log(XO_DEBUG(true)); + scope log(XO_DEBUG(false)); DGlobalEnv * env = DGlobalEnv::_make(mm, global_symtab); @@ -102,10 +102,9 @@ namespace xo { pm_install_flags)}, debug_flag_{config.debug_flag_} { - obj gc = expr_alloc_.try_to_facet(); - if (gc) { - gc.add_gc_root(&global_env_); - } + // see xo-numeric/ {SetupNumeric.cpp, NumericPrimitives.cpp} + // for setup of {_mul, _div, _sub, ...} + // { const DUniqueString * name = stringtable_.lookup("_mul"); @@ -175,6 +174,8 @@ namespace xo { if (gc) { scope log(XO_DEBUG(true), "remove_gc_root not implemented"); + gc.remove_gc_root(&global_symtab_); + gc.remove_gc_root(&local_symtab_); gc.remove_gc_root(&global_env_); } } @@ -404,7 +405,7 @@ namespace xo { // if (local_symtab_) { - DLocalSymtab * symtab = local_symtab_; + DLocalSymtab * symtab = local_symtab_.data(); // count #of nested scopes to cross, to reach symbol // @@ -450,7 +451,7 @@ namespace xo { void ParserStateMachine::push_local_symtab(DLocalSymtab * symtab) { - this->local_symtab_ = symtab; + this->local_symtab_ = obj(symtab); } void @@ -458,7 +459,7 @@ namespace xo { { assert(local_symtab_); - this->local_symtab_ = local_symtab_->parent(); + this->local_symtab_ = obj(local_symtab_->parent()); } void @@ -879,6 +880,45 @@ namespace xo { this->capture_error(ssm_name, errmsg); } + // ----- gc support ----- + +#ifdef OBSOLETE + std::size_t + ParserStateMachine::shallow_size() const noexcept + { + return sizeof(ParserStateMachine); + } + + ParserStateMachine * + ParserStateMachine::shallow_copy(obj mm) const noexcept + { + (void)mm; + + assert(false); + return nullptr; + } +#endif + + void + ParserStateMachine::forward_children(obj gc) noexcept + { + static_assert(!stringtable_.is_gc_eligible()); + static_assert(!parser_alloc_.is_gc_eligible()); + + if (stack_) { + stack_->forward_children(gc); + } + + // static_assert(!expr_alloc_.is_gc_eligible()); + // static_assert(!aux_alloc_.is_gc_eligible()); + + gc.forward_inplace(&global_symtab_); + gc.forward_inplace(&local_symtab_); + gc.forward_inplace(&global_env_); + + result_.forward_children(gc); + } + } /*namespace scm*/ } /*namespace xo*/ diff --git a/src/reader2/SchematikaReader.cpp b/src/reader2/SchematikaReader.cpp index 388c5266..0db3f337 100644 --- a/src/reader2/SchematikaReader.cpp +++ b/src/reader2/SchematikaReader.cpp @@ -1,5 +1,5 @@ /** @file SchematikaReader.cpp -* + * * @author Roland Conybeare, Jan 2026 **/ diff --git a/src/reader2/SetupReader2.cpp b/src/reader2/SetupReader2.cpp index 62536329..3dca4ac8 100644 --- a/src/reader2/SetupReader2.cpp +++ b/src/reader2/SetupReader2.cpp @@ -47,6 +47,10 @@ namespace xo { { scope log(XO_DEBUG(true)); + // SchematikParser + + FacetRegistry::register_impl(); + // GlobalEnv FacetRegistry::register_impl(); @@ -114,11 +118,11 @@ namespace xo { FacetRegistry::register_impl(); FacetRegistry::register_impl(); - // misc types showing up in aux arena - TypeRegistry::register_type(); // misc types showing up in parser stack arena TypeRegistry::register_type(); + log && log(xtag("DSchematikaParser.tseq", typeseq::id())); + log && log(xtag("DGlobalEnv.tseq", typeseq::id())); log && log(xtag("DToplevelSeqSsm.tseq", typeseq::id())); log && log(xtag("DDefineSsm.tseq", typeseq::id())); diff --git a/utest/SchematikaParser.test.cpp b/utest/SchematikaParser.test.cpp index 23821872..7b9a2a26 100644 --- a/utest/SchematikaParser.test.cpp +++ b/utest/SchematikaParser.test.cpp @@ -19,17 +19,16 @@ #include #include #include -#include +#include +#include +#include +#include #include #include namespace xo { using xo::scm::ParserConfig; - using xo::scm::SchematikaParser; -// using xo::scm::ASyntaxStateMachine; -// using xo::scm::syntaxstatetype; -// using xo::scm::DDefineSsm; -// using xo::scm::DExpectExprSsm; + using xo::scm::DSchematikaParser; using xo::scm::AExpression; using xo::scm::DDefineExpr; @@ -38,9 +37,7 @@ namespace xo { using xo::scm::DVarRef; using xo::scm::DConstant; - //using xo::scm::ParserResult; using xo::scm::Token; - using xo::mm::AGCObject; using xo::scm::DPrimitive_gco_2_gco_gco; using xo::scm::DList; using xo::scm::DString; @@ -51,67 +48,129 @@ namespace xo { using xo::mm::ArenaConfig; using xo::mm::AAllocator; + using xo::mm::ACollector; + using xo::mm::AGCObject; using xo::mm::DArena; + using xo::mm::DX1Collector; + using xo::mm::generation; + using xo::mm::X1CollectorConfig; + using xo::mm::CollectorTypeRegistry; using xo::mm::MemorySizeInfo; -// using xo::facet::with_facet; - static InitEvidence s_init = (InitSubsys::require()); + static InitEvidence s_init = (InitSubsys::require() + ^ InitSubsys::require()); namespace ut { struct ParserFixture { - ParserFixture(const std::string & testname, bool debug_flag) + ParserFixture(const std::string & testname, + bool gc_flag, + bool debug_flag) { this->aux_arena_ = std::move(DArena(ArenaConfig() .with_name(testname) - .with_size(4 * 1024) + .with_size(64 * 1024) .with_store_header_flag(true))); obj aux_mm(&aux_arena_); - this->expr_arena_ - = dp::make(aux_mm, - (ArenaConfig() - .with_name("expr") - .with_size(16 * 1024) - .with_store_header_flag(true))); - obj expr_mm(expr_arena_.data()); + if (gc_flag) { + X1CollectorConfig x1_config + = (X1CollectorConfig() + .with_name("gc") + .with_size(32 * 1024) + .with_debug_flag(true) + .with_sanitize_flag(true)); + + dp expr_x1_dp + = dp::make(aux_mm, x1_config); + + this->expr_mm_ + = obj(expr_x1_dp.release()); + + obj gc = expr_mm_.to_facet(); + + CollectorTypeRegistry::instance().install_types(gc); + } else { + ArenaConfig arena_config + = (ArenaConfig().with_name("expr") + .with_size(16 * 1024) + .with_store_header_flag(true)); + + dp expr_arena_dp + = dp::make(aux_mm, arena_config); + + this->expr_mm_ + = obj(expr_arena_dp.release()); + + } ParserConfig cfg; - cfg.parser_arena_config_.size_ = 16 * 1024; - /* editor bait: symbol table */ - cfg.symtab_var_config_.hint_max_capacity_ = 128; - cfg.symtab_types_config_.hint_max_capacity_ = 64; - cfg.max_stringtable_capacity_ = 512; - cfg.debug_flag_ = false; + { + cfg.parser_arena_config_.size_ = 16 * 1024; + /* editor bait: symbol table */ + cfg.symtab_var_config_.hint_max_capacity_ = 128; + cfg.symtab_types_config_.hint_max_capacity_ = 64; + cfg.max_stringtable_capacity_ = 512; + cfg.debug_flag_ = false; + } this->parser_ - = dp::make(aux_mm, cfg, expr_mm, aux_mm); + = DSchematikaParser::make(aux_mm, cfg, expr_mm_, aux_mm); + this->parser_gco_ = parser_; + + if (gc_flag) { + obj gc = expr_mm_.to_facet(); + + if (gc) { + gc.add_gc_root_poly(&parser_gco_); + } + + // Also add parser itself as a global. + // SchematikaParser is a snowflake GCObject: + // it only supports the AGCObject forward_children() method + // + } + + this->gc_flag_ = gc_flag; + this->debug_flag_ = debug_flag; } ParserFixture(const ParserFixture & other) = delete; ParserFixture(const ParserFixture && other) = delete; + ~ParserFixture() { + // destroy allocator + expr_mm_._drop(); + // destroy parser (reminder: was allocated from aux_arena_) + parser_._drop(); + } + bool log_memory_layout(scope * p_log) { using xo::facet::TypeRegistry; using xo::mm::MemorySizeDetail; - auto visitor = [p_log](const MemorySizeInfo & info) { + auto visitor = [this, p_log](const MemorySizeInfo & info) { *p_log && (*p_log)(xtag("name", info.resource_name_), xtag("used", info.used_), xtag("alloc", info.allocated_), xtag("commit", info.committed_), xtag("resv", info.reserved_)); - if (*p_log && info.detail_) { + + if (*p_log && debug_mm_detail_ && info.detail_) { (*p_log)("detail", xtag("n", (*info.detail_)[0].n_alloc_), xtag("z", (*info.detail_)[0].z_alloc_)); + for (size_t i = 1; i < info.detail_->size(); ++i) { const MemorySizeDetail & d = (*info.detail_)[i]; if (d.tseq_.is_sentinel()) break; - (*p_log)("[",i,"]", + char buf[40]; + snprintf(buf, sizeof(buf), "[%lu]", i); + + (*p_log)(buf, xtag("tseq",d.tseq_), xtag("type", TypeRegistry::id2name(d.tseq_)), xtag("n", d.n_alloc_), @@ -123,47 +182,68 @@ namespace xo { aux_arena_.visit_pools(visitor); FacetRegistry::instance().visit_pools(visitor); TypeRegistry::instance().visit_pools(visitor); - expr_arena_->visit_pools(visitor); + expr_mm_.visit_pools(visitor); parser_->visit_pools(visitor); return true; } DArena aux_arena_; - dp expr_arena_; - dp parser_; + /** allocator for parsed schematika expressions **/ + obj expr_mm_; + obj parser_; + /** parser_ as variant gco, to sastify Collector.add_gc_root_poly() **/ + obj parser_gco_; + bool gc_flag_ = false; + bool debug_flag_ = false; + bool debug_mm_detail_ = false; }; void - utest_tokenizer_loop(SchematikaParser * parser, std::vector & tk_v, bool debug_flag) + utest_tokenizer_loop(ParserFixture * fixture, + std::vector & tk_v, + bool debug_flag) { scope log(XO_DEBUG(debug_flag)); + obj expr_gc + = fixture->expr_mm_.try_to_facet(); + size_t i_tk = 0; size_t n_tk = tk_v.size(); + for (const auto & tk : tk_v) { - INFO(tostr(xtag("i_tk", i_tk), xtag("tk", tk))); + INFO(tostr(xtag("i_tk", i_tk), + xtag("tk", tk))); - auto & result = parser->on_token(tk); + auto & result = fixture->parser_->on_token(tk); - log && log("after token", xtag("i_tk", i_tk), xtag("tk", tk)); - log && log(xtag("parser", parser)); + log && log("after token", + xtag("i_tk", i_tk), xtag("tk", tk)); + log && log(xtag("parser", fixture->parser_.data())); log && log(xtag("result", result)); if (i_tk + 1 < n_tk) { - REQUIRE(parser->has_incomplete_expr() == true); + REQUIRE(fixture->parser_->has_incomplete_expr() == true); REQUIRE(!result.is_error()); REQUIRE(result.is_incomplete()); } else { /* last token in tk_v[] */ - REQUIRE(parser->has_incomplete_expr() == false); + REQUIRE(fixture->parser_->has_incomplete_expr() == false); REQUIRE(!result.is_error()); REQUIRE(result.is_expression()); REQUIRE(result.result_expr()); } ++i_tk; + + // for this test: invoke full collection after each token + if (fixture->gc_flag_) { + REQUIRE(expr_gc); + + expr_gc.request_gc(generation(2)); + } } } @@ -174,11 +254,11 @@ namespace xo { constexpr bool c_debug_flag = true; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - REQUIRE(parser.debug_flag() == false); - REQUIRE(parser.is_at_toplevel() == true); + REQUIRE(parser->debug_flag() == false); + REQUIRE(parser->is_at_toplevel() == true); // baseline: // SchematikaParser-ctor :used 1408 @@ -205,14 +285,14 @@ namespace xo { constexpr bool c_debug_flag = false; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); // after begin_interactive_session, parser has toplevel exprseq // but is still "at toplevel" in the sense of ready for input - REQUIRE(parser.has_incomplete_expr() == false); + REQUIRE(parser->has_incomplete_expr() == false); log && fixture.log_memory_layout(&log); } @@ -224,94 +304,138 @@ namespace xo { constexpr bool c_debug_flag = false; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_batch_session(); + parser->begin_batch_session(); // after begin_translation_unit, parser has toplevel exprseq // but is still "at toplevel" in the sense of ready for input - REQUIRE(parser.has_incomplete_expr() == false); + REQUIRE(parser->has_incomplete_expr() == false); log && fixture.log_memory_layout(&log); } + namespace { + void + test_batch_def(ParserFixture * fixture) + { + scope log(XO_DEBUG(fixture->debug_flag_)); + + auto parser = fixture->parser_; + + parser->begin_batch_session(); + + /** Walkthrough parsing input equivalent to: + * + * def foo : f64 = 3.141593 ; + * + **/ + + std::vector tk_v{ + Token::def_token(), + Token::symbol_token("foo"), + Token::colon_token(), + Token::symbol_token("f64"), + Token::singleassign_token(), + Token::f64_token("3.141593"), + Token::semicolon_token(), + }; + + utest_tokenizer_loop(fixture, tk_v, fixture->debug_flag_); + + const auto & result = parser->result(); + { + auto expr = obj::from(result.result_expr()); + REQUIRE(expr); + } + + log && fixture->log_memory_layout(&log); + } + + void + test_driver(const std::string & testname, + std::function test_subject, + std::array debug_flag_v) + { + scope log(XO_DEBUG(debug_flag_v[0] || debug_flag_v[1]), + xtag("test", testname)); + + /* phase=0 arena, no gc + * phase=1 x1 collector + */ + for (int phase = 0; phase < 2; ++phase) + { + log && log(xtag("phase", phase)); + + ParserFixture fixture(testname, phase == 1 /*gc*/, debug_flag_v[phase]); + + test_subject(&fixture); + } + + } + } + TEST_CASE("SchematikaParser-batch-def", "[reader2][SchematikaParser]") { const auto & testname = Catch::getResultCapture().getCurrentTestName(); - constexpr bool c_debug_flag = false; - scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); + // [0] arena; [1] gc + constexpr std::array c_debug_flag_v = {{false, true}}; - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + test_driver(testname, + &test_batch_def, + c_debug_flag_v); + } - parser.begin_batch_session(); - - /** Walkthrough parsing input equivalent to: - * - * def foo : f64 = 3.141593 ; - * - **/ - - std::vector tk_v{ - Token::def_token(), - Token::symbol_token("foo"), - Token::colon_token(), - Token::symbol_token("f64"), - Token::singleassign_token(), - Token::f64_token("3.141593"), - Token::semicolon_token(), - }; - - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); - - const auto & result = parser.result(); + namespace { + void + test_batch_deftype(ParserFixture * fixture) { - auto expr = obj::from(result.result_expr()); - REQUIRE(expr); - } + scope log(XO_DEBUG(fixture->debug_flag_)); - log && fixture.log_memory_layout(&log); + auto parser = fixture->parser_; + + parser->begin_batch_session(); + + /** Walkthrough parsing input equivalent to: + * + * deftype foo :: f64; + **/ + + std::vector tk_v{ + Token::deftype_token(), + Token::symbol_token("foo"), + Token::doublecolon_token(), + Token::symbol_token("f64"), + Token::semicolon_token(), + }; + + utest_tokenizer_loop(fixture, tk_v, fixture->debug_flag_); + + const auto & result = parser->result(); + { + // placeholder for form's sake. + // deftype doesn't actuallly produce any executable content + + auto expr = obj::from(result.result_expr()); + REQUIRE(expr); + } + + log && fixture->log_memory_layout(&log); + } } TEST_CASE("SchematikaParser-batch-deftype", "[reader2][SchematikaParser]") { const auto & testname = Catch::getResultCapture().getCurrentTestName(); - constexpr bool c_debug_flag = false; - scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); + // [0] arena; [1] gc + constexpr std::array c_debug_flag_v = {{false, true}}; - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); - - parser.begin_batch_session(); - - /** Walkthrough parsing input equivalent to: - * - * deftype foo :: f64; - **/ - - std::vector tk_v{ - Token::deftype_token(), - Token::symbol_token("foo"), - Token::doublecolon_token(), - Token::symbol_token("f64"), - Token::semicolon_token(), - }; - - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); - - const auto & result = parser.result(); - { - // placeholder for form's sake. - // deftype doesn't actuallly produce any executable content - - auto expr = obj::from(result.result_expr()); - REQUIRE(expr); - } - - log && fixture.log_memory_layout(&log); + test_driver(testname, + &test_batch_deftype, + c_debug_flag_v); } TEST_CASE("SchematikaParser-batch-deftype-2", "[reader2][SchematikaParser]") @@ -321,10 +445,10 @@ namespace xo { constexpr bool c_debug_flag = false; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_batch_session(); + parser->begin_batch_session(); /** Walkthrough parsing input equivalent to: * @@ -342,9 +466,9 @@ namespace xo { Token::semicolon_token(), }; - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); - const auto & result = parser.result(); + const auto & result = parser->result(); { // placeholder for form's sake. // deftype doesn't actuallly produce any executable content @@ -363,10 +487,10 @@ namespace xo { constexpr bool c_debug_flag = false; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); { /** Walkthrough parsing input equivalent to: @@ -385,15 +509,15 @@ namespace xo { Token::semicolon_token(), }; - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); - const auto & result = parser.result(); + const auto & result = parser->result(); { auto expr = obj::from(result.result_expr()); REQUIRE(expr); } - parser.reset_result(); + parser->reset_result(); } { @@ -410,9 +534,9 @@ namespace xo { Token::semicolon_token(), }; - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); - const auto & result = parser.result(); + const auto & result = parser->result(); { auto expr = obj::from(result.result_expr()); REQUIRE(expr); @@ -429,10 +553,10 @@ namespace xo { constexpr bool c_debug_flag = false; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); /** Walkthrough parsing input equivalent to: * @@ -441,25 +565,25 @@ namespace xo { **/ { - auto & result = parser.on_token(Token::i64_token("1011")); + auto & result = parser->on_token(Token::i64_token("1011")); log && log("after integer token:"); log && log(xtag("parser", &parser)); log && log(xtag("result", result)); - REQUIRE(parser.has_incomplete_expr() == true); + REQUIRE(parser->has_incomplete_expr() == true); REQUIRE(!result.is_error()); REQUIRE(result.is_incomplete()); } { - auto & result = parser.on_token(Token::semicolon_token()); + auto & result = parser->on_token(Token::semicolon_token()); log && log("after semicolon token:"); log && log(xtag("parser", &parser)); log && log(xtag("result", result)); - REQUIRE(parser.has_incomplete_expr() == false); + REQUIRE(parser->has_incomplete_expr() == false); REQUIRE(!result.is_error()); REQUIRE(result.is_expression()); REQUIRE(result.result_expr()); @@ -490,10 +614,10 @@ namespace xo { constexpr bool c_debug_flag = false; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); /** Walkthrough parsing input equivalent to: * @@ -502,25 +626,25 @@ namespace xo { **/ { - auto & result = parser.on_token(Token::f64_token("3.14159265")); + auto & result = parser->on_token(Token::f64_token("3.14159265")); log && log("after float token:"); log && log(xtag("parser", &parser)); log && log(xtag("result", result)); - REQUIRE(parser.has_incomplete_expr() == true); + REQUIRE(parser->has_incomplete_expr() == true); REQUIRE(!result.is_error()); REQUIRE(result.is_incomplete()); } { - auto & result = parser.on_token(Token::semicolon_token()); + auto & result = parser->on_token(Token::semicolon_token()); log && log("after semicolon token:"); log && log(xtag("parser", &parser)); log && log(xtag("result", result)); - REQUIRE(parser.has_incomplete_expr() == false); + REQUIRE(parser->has_incomplete_expr() == false); REQUIRE(!result.is_error()); REQUIRE(result.is_expression()); REQUIRE(result.result_expr()); @@ -551,10 +675,10 @@ namespace xo { constexpr bool c_debug_flag = false; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); /** Walkthrough parsing input equivalent to: * @@ -563,25 +687,25 @@ namespace xo { **/ { - auto & result = parser.on_token(Token::string_token("hello world")); + auto & result = parser->on_token(Token::string_token("hello world")); log && log("after string token:"); log && log(xtag("parser", &parser)); log && log(xtag("result", result)); - REQUIRE(parser.has_incomplete_expr() == true); + REQUIRE(parser->has_incomplete_expr() == true); REQUIRE(!result.is_error()); REQUIRE(result.is_incomplete()); } { - auto & result = parser.on_token(Token::semicolon_token()); + auto & result = parser->on_token(Token::semicolon_token()); log && log("after semicolon token:"); log && log(xtag("parser", &parser)); log && log(xtag("result", result)); - REQUIRE(parser.has_incomplete_expr() == false); + REQUIRE(parser->has_incomplete_expr() == false); REQUIRE(!result.is_error()); REQUIRE(result.is_expression()); REQUIRE(result.result_expr()); @@ -612,10 +736,10 @@ namespace xo { constexpr bool c_debug_flag = false; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); /** Walkthrough parsing input equivalent to: * @@ -624,25 +748,25 @@ namespace xo { **/ { - auto & result = parser.on_token(Token::nil_token()); + auto & result = parser->on_token(Token::nil_token()); log && log("after nil token:"); log && log(xtag("parser", &parser)); log && log(xtag("result", result)); - REQUIRE(parser.has_incomplete_expr() == true); + REQUIRE(parser->has_incomplete_expr() == true); REQUIRE(!result.is_error()); REQUIRE(result.is_incomplete()); } { - auto & result = parser.on_token(Token::semicolon_token()); + auto & result = parser->on_token(Token::semicolon_token()); log && log("after semicolon token:"); log && log(xtag("parser", &parser)); log && log(xtag("result", result)); - REQUIRE(parser.has_incomplete_expr() == false); + REQUIRE(parser->has_incomplete_expr() == false); REQUIRE(!result.is_error()); REQUIRE(result.is_expression()); REQUIRE(result.result_expr()); @@ -673,10 +797,10 @@ namespace xo { constexpr bool c_debug_flag = false; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); /** Walkthrough parsing input equivalent to: * @@ -691,9 +815,9 @@ namespace xo { Token::semicolon_token(), }; - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); - const auto & result = parser.result(); + const auto & result = parser->result(); { auto expr = obj::from(result.result_expr()); REQUIRE(expr); @@ -732,10 +856,10 @@ namespace xo { constexpr bool c_debug_flag = false; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); /** Walkthrough parsing input equivalent to: * @@ -752,9 +876,9 @@ namespace xo { INFO(testname); - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); - const auto & result = parser.result(); + const auto & result = parser->result(); { auto expr = obj::from(result.result_expr()); REQUIRE(expr); @@ -793,10 +917,10 @@ namespace xo { constexpr bool c_debug_flag = false; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); /** Walkthrough parsing input equivalent to: * @@ -815,9 +939,9 @@ namespace xo { INFO(testname); - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); - const auto & result = parser.result(); + const auto & result = parser->result(); { auto expr = obj::from(result.result_expr()); REQUIRE(expr); @@ -863,10 +987,10 @@ namespace xo { constexpr bool c_debug_flag = true; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); /** Walkthrough parsing input equivalent to: * @@ -885,9 +1009,9 @@ namespace xo { INFO(testname); - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); - const auto & result = parser.result(); + const auto & result = parser->result(); { auto expr = obj::from(result.result_expr()); REQUIRE(expr); @@ -933,10 +1057,10 @@ namespace xo { constexpr bool c_debug_flag = true; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); /** Walkthrough parsing input equivalent to: * @@ -958,7 +1082,7 @@ namespace xo { utest_tokenizer_loop(&parser, tk_v, c_debug_flag); - const auto & result = parser.result(); + const auto & result = parser->result(); { auto expr = obj::from(result.result_expr()); REQUIRE(expr); @@ -998,7 +1122,8 @@ namespace xo { } #endif - TEST_CASE("SchematikaParser-interactive-cmp", "[reader2][SchematikaParser]") +#ifdef NOT_YET + TEST_CASE("SchematikaParser-interactive-cmpne", "[reader2][SchematikaParser]") { const auto & testname = Catch::getResultCapture().getCurrentTestName(); @@ -1006,10 +1131,72 @@ namespace xo { scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); + + /** Walkthrough parsing input equivalent to: + * + * 312 != 312 ; + * ^ ^ ^ ^ + * 0 1 2 3 + **/ + + std::vector tk_v{ + /* [0] */ Token::i64_token("312"), + /* [1] */ Token::cmpne_token(), + /* [2] */ Token::i64_token("312"), + /* [3] */ Token::semicolon_token(), + }; + + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); + + const auto & result = parser->result(); + { + auto expr = obj::from(result.result_expr()); + REQUIRE(expr); + + REQUIRE(expr->n_args() == 2); + + auto fn = obj::from(expr->fn()); + REQUIRE(fn); + + auto pm = obj::from(fn->value()); + REQUIRE(pm); + REQUIRE(pm->name() == "_cmpne"); + + auto lhs = obj::from(expr->arg(0)); + REQUIRE(lhs); + + auto lhs_i64 = obj::from(lhs->value()); + REQUIRE(lhs_i64); + REQUIRE(lhs_i64->value() == 312); + + auto rhs = obj::from(expr->arg(1)); + REQUIRE(rhs); + + auto rhs_i64 = obj::from(rhs->value()); + REQUIRE(rhs_i64); + REQUIRE(rhs_i64->value() == 312); + } + + log && fixture.log_memory_layout(&log); + } +#endif + + TEST_CASE("SchematikaParser-interactive-cmpeq", "[reader2][SchematikaParser]") + { + const auto & testname = Catch::getResultCapture().getCurrentTestName(); + + constexpr bool c_debug_flag = false; + scope log(XO_DEBUG(c_debug_flag), + xtag("test", testname)); + + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; + + parser->begin_interactive_session(); /** Walkthrough parsing input equivalent to: * @@ -1025,9 +1212,9 @@ namespace xo { /* [3] */ Token::semicolon_token(), }; - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); - const auto & result = parser.result(); + const auto & result = parser->result(); { auto expr = obj::from(result.result_expr()); REQUIRE(expr); @@ -1067,10 +1254,10 @@ namespace xo { scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); { /** Walkthrough parsing input equivalent to: @@ -1088,18 +1275,18 @@ namespace xo { /* [4] */ Token::semicolon_token() }; - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); } { - const auto & result = parser.result(); + const auto & result = parser->result(); auto expr = obj::from(result.result_expr()); REQUIRE(expr); } { - parser.reset_result(); + parser->reset_result(); /** Walkthrough parsing input equivalent to: * @@ -1125,10 +1312,10 @@ namespace xo { /* [c] */ Token::semicolon_token() }; - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); } - const auto & result = parser.result(); + const auto & result = parser->result(); { auto expr = obj::from(result.result_expr()); REQUIRE(expr); @@ -1144,10 +1331,10 @@ namespace xo { constexpr bool c_debug_flag = false; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); /** Walkthrough parsing input equivalent to: * @@ -1175,7 +1362,7 @@ namespace xo { /* [ e] */ Token::rightbrace_token(), }; - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); log && fixture.log_memory_layout(&log); } @@ -1187,10 +1374,10 @@ namespace xo { constexpr bool c_debug_flag = false; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); /** Walkthrough parsing input equivalent to: * @@ -1209,7 +1396,7 @@ namespace xo { /* [6] */ Token::semicolon_token(), }; - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); log && fixture.log_memory_layout(&log); } @@ -1221,10 +1408,10 @@ namespace xo { constexpr bool c_debug_flag = false; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); /** Walkthrough parsing input equivalent to: * @@ -1250,7 +1437,7 @@ namespace xo { /* [ c] */ Token::rightbrace_token(), }; - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); log && fixture.log_memory_layout(&log); } @@ -1262,10 +1449,10 @@ namespace xo { constexpr bool c_debug_flag = false; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); /** Walkthrough parsing input equivalent to: * @@ -1296,7 +1483,7 @@ namespace xo { /* [ g] */ Token::semicolon_token(), }; - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); log && fixture.log_memory_layout(&log); } @@ -1310,10 +1497,10 @@ namespace xo { constexpr bool c_debug_flag = false; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); /** Walkthrough parsing input equivalent to: * @@ -1354,7 +1541,7 @@ namespace xo { /* [ m] */ Token::semicolon_token(), }; - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); log && fixture.log_memory_layout(&log); } @@ -1368,10 +1555,10 @@ namespace xo { constexpr bool c_debug_flag = false; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); /** Walkthrough parsing input equivalent to: * @@ -1412,7 +1599,7 @@ namespace xo { /* [ q] */ Token::semicolon_token(), }; - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); log && fixture.log_memory_layout(&log); } @@ -1426,10 +1613,10 @@ namespace xo { constexpr bool c_debug_flag = false; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); /** Walkthrough parsing input equivalent to: * @@ -1447,7 +1634,7 @@ namespace xo { /* [ 4] */ Token::semicolon_token(), }; - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); log && fixture.log_memory_layout(&log); } @@ -1461,10 +1648,10 @@ namespace xo { constexpr bool c_debug_flag = false; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); /** Walkthrough parsing input equivalent to: * @@ -1490,7 +1677,7 @@ namespace xo { /* [ 9] */ Token::semicolon_token(), }; - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); log && fixture.log_memory_layout(&log); } @@ -1504,10 +1691,10 @@ namespace xo { constexpr bool c_debug_flag = false; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); /** Walkthrough parsing input equivalent to: * @@ -1528,7 +1715,7 @@ namespace xo { /* [ 7] */ Token::semicolon_token(), }; - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); log && fixture.log_memory_layout(&log); } @@ -1542,10 +1729,10 @@ namespace xo { constexpr bool c_debug_flag = false; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); /** Walkthrough parsing input equivalent to: * @@ -1566,7 +1753,7 @@ namespace xo { /* [ 7] */ Token::semicolon_token(), }; - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); log && fixture.log_memory_layout(&log); } @@ -1580,10 +1767,10 @@ namespace xo { constexpr bool c_debug_flag = false; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); /** Walkthrough parsing input equivalent to: * @@ -1604,7 +1791,7 @@ namespace xo { /* [ 7] */ Token::semicolon_token(), }; - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); log && fixture.log_memory_layout(&log); } @@ -1618,10 +1805,10 @@ namespace xo { constexpr bool c_debug_flag = true; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); /** Walkthrough parsing input equivalent to: * @@ -1642,7 +1829,7 @@ namespace xo { /* [ 5] */ Token::semicolon_token(), }; - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); log && fixture.log_memory_layout(&log); } @@ -1656,10 +1843,10 @@ namespace xo { constexpr bool c_debug_flag = false; scope log(XO_DEBUG(c_debug_flag), xtag("test", testname)); - ParserFixture fixture(testname, c_debug_flag); - auto & parser = *(fixture.parser_); + ParserFixture fixture(testname, false /*!gc*/, c_debug_flag); + auto parser = fixture.parser_; - parser.begin_interactive_session(); + parser->begin_interactive_session(); /** Walkthrough parsing input equivalent to: * @@ -1694,7 +1881,7 @@ namespace xo { /* [ g] */ Token::semicolon_token(), }; - utest_tokenizer_loop(&parser, tk_v, c_debug_flag); + utest_tokenizer_loop(&fixture, tk_v, c_debug_flag); log && fixture.log_memory_layout(&log); }