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

xo-reader2: + on_parsed_expression_with_semicolon + DefineSsm works

Browse source
This commit is contained in:
Roland Conybeare 2026-01-22 17:15:05 -05:00
commit 56aceac9e8
36 changed files with 426 additions and 19 deletions
Download patch file Download diff file Expand all files Collapse all files

1
xo-expression2/include/xo/expression2/DDefineExpr.hpp
View file

@ -56,6 +56,7 @@ namespace xo {
///@{
void assign_lhs_name(const DUniqueString * name);
void assign_rhs(obj<AExpression> rhs);
///@}
/** @defgroup scm-defineexpr-expression-facet **/

5
xo-expression2/src/expression2/DDefineExpr.cpp
View file

@ -67,6 +67,11 @@ namespace xo {
lhs_var_->assign_valuetype(td);
}
void
DDefineExpr::assign_rhs(obj<AExpression> x) {
this->rhs_ = x;
}
bool
DDefineExpr::pretty(const ppindentinfo & ppii) const
{

9
xo-reader2/idl/SyntaxStateMachine.json5
View file

@ -135,5 +135,14 @@
{type: "ParserStateMachine *", name: "p_psm"},
],
},
{
name: "on_parsed_expression_with_semicolon",
doc: ["update state machine for incoming parsed expression @p expr followed by semicolon"],
return_type: "void",
args: [
{type: "obj<AExpression>", name: "expr"},
{type: "ParserStateMachine *", name: "p_psm"},
],
},
],
}

7
xo-reader2/include/xo/reader2/DDefineSsm.hpp
View file

@ -177,6 +177,13 @@ namespace xo {
void on_parsed_expression(obj<AExpression> expr,
ParserStateMachine * p_psm);
/** update state for this syntax after parsing an expression @p expr
* followed by semicolon,
* overall parser state in @p p_psm
**/
void on_parsed_expression_with_semicolon(obj<AExpression> expr,
ParserStateMachine * p_psm);
///@}
/** @defgroup scm-define-printable-facet printable facet methods **/
///@{

7
xo-reader2/include/xo/reader2/DExpectExprSsm.hpp
View file

@ -113,6 +113,13 @@ namespace xo {
void on_parsed_expression(obj<AExpression> expr,
ParserStateMachine * p_psm);
/** update state for this syntax after parsing an expression @p expr
* followed by semicolon,
* overall parser state in @p p_psm
**/
void on_parsed_expression_with_semicolon(obj<AExpression> expr,
ParserStateMachine * p_psm);
///@}
/** @defgroup scm-define-printable-facet printable facet methods **/
///@{

7
xo-reader2/include/xo/reader2/DExpectSymbolSsm.hpp
View file

@ -86,6 +86,13 @@ namespace xo {
void on_parsed_expression(obj<AExpression> expr,
ParserStateMachine * p_psm);
/** update state for this syntax after parsing an expression @p expr
* followed by semicolon in nested state machine.
* (provided to satisfy ASyntaxStateMachine api. not reachable)
**/
void on_parsed_expression_with_semicolon(obj<AExpression> expr,
ParserStateMachine * p_psm);
/** update state for this syntax on incoming token @p tk,
* overall parser state in @p p_psm.
**/

7
xo-reader2/include/xo/reader2/DExpectTypeSsm.hpp
View file

@ -114,6 +114,13 @@ namespace xo {
void on_parsed_expression(obj<AExpression> expr,
ParserStateMachine * p_psm);
/** operate state machine for this syntax on receiving expression
* followed by semicolon from nested parser.
* (provided to satisfy ASyntaxStateMachine api. not reachable)
**/
void on_parsed_expression_with_semicolon(obj<AExpression> expr,
ParserStateMachine * p_psm);
///@}
/** @defgroup scm-expecttype-printable-facet printable facet methods **/
///@{

6
xo-reader2/include/xo/reader2/DExprSeqState.hpp
View file

@ -118,6 +118,12 @@ namespace xo {
**/
void on_parsed_expression(obj<AExpression> expr, ParserStateMachine * p_psm);
/** update state for this syntax on parsed expression @p expr
* followed by semicolon from nested ssm.
* overall parser state in @p p_psm
**/
void on_parsed_expression_with_semicolon(obj<AExpression> expr, ParserStateMachine * p_psm);
///@}
/** @defgroup scm-exprseq-printable-facet printable facet methods **/
///@{

21
xo-reader2/include/xo/reader2/DProgressSsm.hpp
View file

@ -123,12 +123,14 @@ namespace xo {
std::string_view get_expect_str() const noexcept;
#ifdef NOT_YET
void on_expr(bp<Expression> expr,
parserstatemachine * p_psm) override;
void on_expr_with_semicolon(bp<Expression> expr,
parserstatemachine * p_psm) override;
#endif
/** assemble expression from collected inputs.
* Usually triggered by syntax like ';' or ')'
**/
obj<AExpression> assemble_expr(ParserStateMachine * p_psm);
/** @defgroup scm-progressssm-ssm-facet syntaxstatemachine facet methods **/
/// @{
void on_symbol_token(const Token & tk,
ParserStateMachine * p_psm);
void on_def_token(const Token & tk,
@ -149,12 +151,17 @@ namespace xo {
ParserStateMachine * p_psm);
void on_parsed_expression(obj<AExpression>,
ParserStateMachine * p_psm);
void on_parsed_expression_with_semicolon(obj<AExpression> expr,
ParserStateMachine * p_psm);
///@}
/** @defgroup scm-progressssm-printable-facet printable facet methods **/
///@{
/** @defgroup scm-progressssm-printable-facet printable facet methods **/
bool pretty(const ppindentinfo & ppii) const;
///@}
#ifdef NOT_YET
void on_comma_token(const token_type & tk,
parserstatemachine * p_psm) final override;

16
xo-reader2/include/xo/reader2/ParserStateMachine.hpp
View file

@ -102,6 +102,22 @@ namespace xo {
**/
void on_parsed_typedescr(TypeDescr td);
/** update state to respond to parsed expression @p expr
* (from nested parsing state)
**/
void on_parsed_expression(obj<AExpression> expr);
/** update state to respond to parsed expression @p expr
* (from nested parsing state), with trailing semicolon.
*
* Need to distinguish cases like:
* 6 // ; allowed
* f(6 // ) allowed ; forbidden
* 6 + // ) forbidden ; forbidden
*
**/
void on_parsed_expression_with_semicolon(obj<AExpression> expr);
/** update state to respond to input token @p tk.
* record output (if any) in @ref result_
**/

2
xo-reader2/include/xo/reader2/ssm/ASyntaxStateMachine.hpp
View file

@ -77,6 +77,8 @@ public:
virtual void on_parsed_typedescr(Opaque data, TypeDescr td, ParserStateMachine * p_psm) = 0;
/** update state machine for incoming parsed expression @p expr **/
virtual void on_parsed_expression(Opaque data, obj<AExpression> expr, ParserStateMachine * p_psm) = 0;
/** update state machine for incoming parsed expression @p expr followed by semicolon **/
virtual void on_parsed_expression_with_semicolon(Opaque data, obj<AExpression> expr, ParserStateMachine * p_psm) = 0;
///@}
}; /*ASyntaxStateMachine*/

1
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_Any.hpp
View file

@ -70,6 +70,7 @@ namespace scm {
[[noreturn]] void on_parsed_symbol(Opaque, std::string_view, ParserStateMachine *) override;
[[noreturn]] void on_parsed_typedescr(Opaque, TypeDescr, ParserStateMachine *) override;
[[noreturn]] void on_parsed_expression(Opaque, obj<AExpression>, ParserStateMachine *) override;
[[noreturn]] void on_parsed_expression_with_semicolon(Opaque, obj<AExpression>, ParserStateMachine *) override;
///@}

2
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DDefineSsm.hpp
View file

@ -74,6 +74,8 @@ namespace xo {
static void on_parsed_typedescr(DDefineSsm & self, TypeDescr td, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr **/
static void on_parsed_expression(DDefineSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr followed by semicolon **/
static void on_parsed_expression_with_semicolon(DDefineSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm);
///@}
};

2
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DExpectExprSsm.hpp
View file

@ -74,6 +74,8 @@ namespace xo {
static void on_parsed_typedescr(DExpectExprSsm & self, TypeDescr td, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr **/
static void on_parsed_expression(DExpectExprSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr followed by semicolon **/
static void on_parsed_expression_with_semicolon(DExpectExprSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm);
///@}
};

2
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DExpectSymbolSsm.hpp
View file

@ -74,6 +74,8 @@ namespace xo {
static void on_parsed_typedescr(DExpectSymbolSsm & self, TypeDescr td, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr **/
static void on_parsed_expression(DExpectSymbolSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr followed by semicolon **/
static void on_parsed_expression_with_semicolon(DExpectSymbolSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm);
///@}
};

2
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DExpectTypeSsm.hpp
View file

@ -74,6 +74,8 @@ namespace xo {
static void on_parsed_typedescr(DExpectTypeSsm & self, TypeDescr td, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr **/
static void on_parsed_expression(DExpectTypeSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr followed by semicolon **/
static void on_parsed_expression_with_semicolon(DExpectTypeSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm);
///@}
};

2
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DExprSeqState.hpp
View file

@ -74,6 +74,8 @@ namespace xo {
static void on_parsed_typedescr(DExprSeqState & self, TypeDescr td, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr **/
static void on_parsed_expression(DExprSeqState & self, obj<AExpression> expr, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr followed by semicolon **/
static void on_parsed_expression_with_semicolon(DExprSeqState & self, obj<AExpression> expr, ParserStateMachine * p_psm);
///@}
};

2
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DProgressSsm.hpp
View file

@ -74,6 +74,8 @@ namespace xo {
static void on_parsed_typedescr(DProgressSsm & self, TypeDescr td, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr **/
static void on_parsed_expression(DProgressSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm);
/** update state machine for incoming parsed expression @p expr followed by semicolon **/
static void on_parsed_expression_with_semicolon(DProgressSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm);
///@}
};

3
xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_Xfer.hpp
View file

@ -82,6 +82,9 @@ namespace scm {
void on_parsed_expression(Opaque data, obj<AExpression> expr, ParserStateMachine * p_psm) override {
return I::on_parsed_expression(_dcast(data), expr, p_psm);
}
void on_parsed_expression_with_semicolon(Opaque data, obj<AExpression> expr, ParserStateMachine * p_psm) override {
return I::on_parsed_expression_with_semicolon(_dcast(data), expr, p_psm);
}
///@}

3
xo-reader2/include/xo/reader2/ssm/RSyntaxStateMachine.hpp
View file

@ -86,6 +86,9 @@ public:
void on_parsed_expression(obj<AExpression> expr, ParserStateMachine * p_psm) {
return O::iface()->on_parsed_expression(O::data(), expr, p_psm);
}
void on_parsed_expression_with_semicolon(obj<AExpression> expr, ParserStateMachine * p_psm) {
return O::iface()->on_parsed_expression_with_semicolon(O::data(), expr, p_psm);
}
///@}
/** @defgroup scm-syntaxstatemachine-member-vars **/

22
xo-reader2/src/reader2/DDefineSsm.cpp
View file

@ -578,6 +578,12 @@ namespace xo {
DDefineSsm::on_semicolon_token(const Token & tk,
ParserStateMachine * p_psm)
{
if (defstate_ == defexprstatetype::def_6) {
p_psm->pop_ssm();
p_psm->on_parsed_expression_with_semicolon(def_expr_);
return;
}
p_psm->illegal_input_on_token("DDefineSsm::on_semicolon_token",
tk,
this->get_expect_str());
@ -587,11 +593,27 @@ namespace xo {
DDefineSsm::on_parsed_expression(obj<AExpression> expr,
ParserStateMachine * p_psm)
{
if (defstate_ == defexprstatetype::def_5)
{
this->defstate_ = defexprstatetype::def_6;
def_expr_.data()->assign_rhs(expr);
return;
}
p_psm->illegal_parsed_expression("DDefineSsm::on_parsed_expression",
expr,
this->get_expect_str());
}
void
DDefineSsm::on_parsed_expression_with_semicolon(obj<AExpression> expr,
ParserStateMachine * p_psm)
{
this->on_parsed_expression(expr, p_psm);
this->on_semicolon_token(Token::semicolon_token(), p_psm);
}
bool
DDefineSsm::pretty(const ppindentinfo & ppii) const
{

11
xo-reader2/src/reader2/DExpectExprSsm.cpp
View file

@ -206,6 +206,17 @@ namespace xo {
this->get_expect_str());
}
void
DExpectExprSsm::on_parsed_expression_with_semicolon(obj<AExpression> expr,
ParserStateMachine * p_psm)
{
// expression (reported by nested ProgressSsm)
// completes this DExpectExprSsm's assignment
p_psm->pop_ssm();
p_psm->on_parsed_expression_with_semicolon(expr);
}
bool
DExpectExprSsm::pretty(const ppindentinfo & ppii) const
{

9
xo-reader2/src/reader2/DExpectSymbolSsm.cpp
View file

@ -83,6 +83,15 @@ namespace xo {
this->get_expect_str());
}
void
DExpectSymbolSsm::on_parsed_expression_with_semicolon(obj<AExpression> expr,
ParserStateMachine * p_psm)
{
p_psm->illegal_parsed_expression("DExpectSymbolSsm::on_parsed_expression_with_semicolon",
expr,
this->get_expect_str());
}
void
DExpectSymbolSsm::on_symbol_token(const Token & tk,
ParserStateMachine * p_psm)

9
xo-reader2/src/reader2/DExpectTypeSsm.cpp
View file

@ -172,6 +172,15 @@ namespace xo {
this->get_expect_str());
}
void
DExpectTypeSsm::on_parsed_expression_with_semicolon(obj<AExpression> expr,
ParserStateMachine * p_psm)
{
p_psm->illegal_parsed_expression("DExpectTypeSsm::on_parsed_expression_with_semicolon",
expr,
this->get_expect_str());
}
bool
DExpectTypeSsm::pretty(const ppindentinfo & ppii) const
{

9
xo-reader2/src/reader2/DExprSeqState.cpp
View file

@ -223,6 +223,15 @@ namespace xo {
this->get_expect_str());
}
void
DExprSeqState::on_parsed_expression_with_semicolon(obj<AExpression> expr,
ParserStateMachine * p_psm)
{
p_psm->illegal_parsed_expression("DExprSeqState::on_parsed_expression_with_semicolon",
expr,
this->get_expect_str());
}
bool
DExprSeqState::pretty(const ppindentinfo & ppii) const
{

205
xo-reader2/src/reader2/DProgressSsm.cpp
View file

@ -213,11 +213,12 @@ namespace xo {
{
/* note: implementation should parallel .on_rightparen_token() */
#ifdef NOT_YET
(void)tk;
obj<AExpression> expr = this->assemble_expr(p_psm);
p_psm->pop_ssm();
p_psm->on_expr_with_semicolon(expr);
p_psm->on_parsed_expression_with_semicolon(expr);
/* control here on input like:
* (1.234;
@ -232,11 +233,12 @@ namespace xo {
* d. expr_rhs_expression forwards expression to [lparen_0]
* e. lparen_0 would advance to [lparen_1], but rejects semicolon
*/
#endif
#ifdef OBSOLETE
p_psm->illegal_input_on_token("DProgressSsm::on_semicolon_token",
tk,
this->get_expect_str());
#endif
}
void
@ -266,6 +268,15 @@ namespace xo {
this->get_expect_str());
}
void
DProgressSsm::on_parsed_expression_with_semicolon(obj<AExpression> expr,
ParserStateMachine * p_psm)
{
p_psm->illegal_parsed_expression("DProgressSsm::on_parsed_expression_with_semicolon",
expr,
this->get_expect_str());
}
#ifdef NOT_YET
void
progress_xs::apply_type_error(const char * self_name,
@ -967,6 +978,194 @@ namespace xo {
}
#endif
}
obj<AExpression>
DProgressSsm::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 = "DProgressSsm::assemble_expr";
if ((op_type_ != optype::invalid) && rhs_) {
std::string errmsg_string = tostr("expected expression on rhs of operator op",
xtag("lhs", lhs_),
xtag("op", op_type_));
auto errmsg = DString::from_view(p_psm->expr_alloc(),
std::string_view(errmsg_string));
p_psm->capture_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:
case optype::op_equal:
case optype::op_not_equal:
case optype::op_less:
case optype::op_less_equal:
case optype::op_great:
case optype::op_great_equal:
case optype::op_add:
case optype::op_subtract:
case optype::op_multiply:
case optype::op_divide:
// TODO: implement binary operator expression assembly
break;
#ifdef NOT_YET
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;
#endif
case optype::n_optype:
/* unreachable */
assert(false);
break;
}
return obj<AExpression>();
}
} /*namespace scm*/
} /*namespace xo*/

6
xo-reader2/src/reader2/ISyntaxStateMachine_Any.cpp
View file

@ -94,6 +94,12 @@ ISyntaxStateMachine_Any::on_parsed_expression(Opaque, obj<AExpression>, ParserSt
_fatal();
}
auto
ISyntaxStateMachine_Any::on_parsed_expression_with_semicolon(Opaque, obj<AExpression>, ParserStateMachine *) -> void
{
_fatal();
}
} /*namespace scm*/
} /*namespace xo*/

5
xo-reader2/src/reader2/ISyntaxStateMachine_DDefineSsm.cpp
View file

@ -77,6 +77,11 @@ namespace xo {
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DDefineSsm::on_parsed_expression_with_semicolon(DDefineSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_semicolon(expr, p_psm);
}
} /*namespace scm*/
} /*namespace xo*/

5
xo-reader2/src/reader2/ISyntaxStateMachine_DExpectExprSsm.cpp
View file

@ -77,6 +77,11 @@ namespace xo {
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DExpectExprSsm::on_parsed_expression_with_semicolon(DExpectExprSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_semicolon(expr, p_psm);
}
} /*namespace scm*/
} /*namespace xo*/

5
xo-reader2/src/reader2/ISyntaxStateMachine_DExpectSymbolSsm.cpp
View file

@ -77,6 +77,11 @@ namespace xo {
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DExpectSymbolSsm::on_parsed_expression_with_semicolon(DExpectSymbolSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_semicolon(expr, p_psm);
}
} /*namespace scm*/
} /*namespace xo*/

5
xo-reader2/src/reader2/ISyntaxStateMachine_DExpectTypeSsm.cpp
View file

@ -77,6 +77,11 @@ namespace xo {
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DExpectTypeSsm::on_parsed_expression_with_semicolon(DExpectTypeSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_semicolon(expr, p_psm);
}
} /*namespace scm*/
} /*namespace xo*/

5
xo-reader2/src/reader2/ISyntaxStateMachine_DExprSeqState.cpp
View file

@ -77,6 +77,11 @@ namespace xo {
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DExprSeqState::on_parsed_expression_with_semicolon(DExprSeqState & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_semicolon(expr, p_psm);
}
} /*namespace scm*/
} /*namespace xo*/

5
xo-reader2/src/reader2/ISyntaxStateMachine_DProgressSsm.cpp
View file

@ -77,6 +77,11 @@ namespace xo {
{
self.on_parsed_expression(expr, p_psm);
}
auto
ISyntaxStateMachine_DProgressSsm::on_parsed_expression_with_semicolon(DProgressSsm & self, obj<AExpression> expr, ParserStateMachine * p_psm) -> void
{
self.on_parsed_expression_with_semicolon(expr, p_psm);
}
} /*namespace scm*/
} /*namespace xo*/

20
xo-reader2/src/reader2/ParserStateMachine.cpp
View file

@ -129,6 +129,26 @@ namespace xo {
this->stack_->top().on_parsed_typedescr(td, this);
}
void
ParserStateMachine::on_parsed_expression(obj<AExpression> expr)
{
scope log(XO_DEBUG(debug_flag_), xtag("expr", expr));
assert(stack_);
this->top_ssm().on_parsed_expression(expr, this);
}
void
ParserStateMachine::on_parsed_expression_with_semicolon(obj<AExpression> expr)
{
scope log(XO_DEBUG(debug_flag_), xtag("expr", expr));
assert(stack_);
this->top_ssm().on_parsed_expression_with_semicolon(expr, this);
}
void
ParserStateMachine::on_token(const Token & tk)
{

13
xo-reader2/utest/SchematikaParser.test.cpp
View file

@ -177,14 +177,13 @@ namespace xo {
}
{
#ifdef NOT_YET
auto def_ssm
= obj<ASyntaxStateMachine,DDefineSsm>::from(parser.top_ssm());
auto & result = parser.on_token(Token::semicolon_token());
REQUIRE(def_ssm);
REQUIRE(def_ssm.data()->ssm_type() == syntaxstatetype::defexpr);
REQUIRE(def_ssm.data()->defstate() == defexprstatetype::def_5);
#endif
log && log("after semicolon token:");
log && log(xtag("parser", &parser));
log && log(xtag("result", result));
REQUIRE(parser.has_incomplete_expr() == false);
}
// define-expressions not properly implemented

2
xo-tokenizer2/include/xo/tokenizer2/Token.hpp
View file

@ -112,7 +112,7 @@ namespace xo {
/** token representing double-colo @c "::" **/
static Token doublecolon() { return Token(tokentype::tk_doublecolon); }
/** token representing semicolon @c ";" **/
static Token semicolon() { return Token(tokentype::tk_semicolon); }
static Token semicolon_token() { return Token(tokentype::tk_semicolon); }
/** token representing single-assignment @c "=" (editor bait: equal_token) **/
static Token singleassign_token() { return Token(tokentype::tk_singleassign); }
/** token representing unrestricted assignment @c ":=" **/