xo-reader2: + on_parsed_expression_with_semicolon + DefineSsm works

xo-expression2/include/xo/expression2/DDefineExpr.hpp

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

xo-expression2/src/expression2/DDefineExpr.cpp

@@ -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
         {

xo-reader2/idl/SyntaxStateMachine.json5

@@ -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"},
+            ],
+        },
     ],
 }

xo-reader2/include/xo/reader2/DDefineSsm.hpp

@@ -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 **/
             ///@{

xo-reader2/include/xo/reader2/DExpectExprSsm.hpp

@@ -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 **/
             ///@{

xo-reader2/include/xo/reader2/DExpectSymbolSsm.hpp

@@ -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.
              **/

xo-reader2/include/xo/reader2/DExpectTypeSsm.hpp

@@ -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 **/
             ///@{

xo-reader2/include/xo/reader2/DExprSeqState.hpp

@@ -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 **/
             ///@{

xo-reader2/include/xo/reader2/DProgressSsm.hpp

@@ -123,12 +123,14 @@ namespace xo {
 
             std::string_view get_expect_str() const noexcept;
 
-#ifdef NOT_YET
+            /** assemble expression from collected inputs.
-            void on_expr(bp<Expression> expr,
+             *  Usually triggered by syntax like ';' or ')'
-                                 parserstatemachine * p_psm) override;
+             **/
-            void on_expr_with_semicolon(bp<Expression> expr,
+            obj<AExpression> assemble_expr(ParserStateMachine * p_psm);
-                                                parserstatemachine * p_psm) override;
+
-#endif
+            /** @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;

xo-reader2/include/xo/reader2/ParserStateMachine.hpp

@@ -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_
              **/

xo-reader2/include/xo/reader2/ssm/ASyntaxStateMachine.hpp

@@ -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*/
 

xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_Any.hpp

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

xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DDefineSsm.hpp

@@ -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);
             ///@}
         };
 

xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DExpectExprSsm.hpp

@@ -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);
             ///@}
         };
 

xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DExpectSymbolSsm.hpp

@@ -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);
             ///@}
         };
 

xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DExpectTypeSsm.hpp

@@ -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);
             ///@}
         };
 

xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DExprSeqState.hpp

@@ -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);
             ///@}
         };
 

xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_DProgressSsm.hpp

@@ -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);
             ///@}
         };
 

xo-reader2/include/xo/reader2/ssm/ISyntaxStateMachine_Xfer.hpp

@@ -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);
+        }
 
         ///@}
 

xo-reader2/include/xo/reader2/ssm/RSyntaxStateMachine.hpp

@@ -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 **/

xo-reader2/src/reader2/DDefineSsm.cpp

@@ -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
         {

xo-reader2/src/reader2/DExpectExprSsm.cpp

@@ -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
         {

xo-reader2/src/reader2/DExpectSymbolSsm.cpp

@@ -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)

xo-reader2/src/reader2/DExpectTypeSsm.cpp

@@ -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
         {

xo-reader2/src/reader2/DExprSeqState.cpp

@@ -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
         {

xo-reader2/src/reader2/DProgressSsm.cpp

@@ -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*/
 

xo-reader2/src/reader2/ISyntaxStateMachine_Any.cpp

@@ -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*/

xo-reader2/src/reader2/ISyntaxStateMachine_DDefineSsm.cpp

@@ -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*/

xo-reader2/src/reader2/ISyntaxStateMachine_DExpectExprSsm.cpp

@@ -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*/

xo-reader2/src/reader2/ISyntaxStateMachine_DExpectSymbolSsm.cpp

@@ -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*/

xo-reader2/src/reader2/ISyntaxStateMachine_DExpectTypeSsm.cpp

@@ -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*/

xo-reader2/src/reader2/ISyntaxStateMachine_DExprSeqState.cpp

@@ -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*/

xo-reader2/src/reader2/ISyntaxStateMachine_DProgressSsm.cpp

@@ -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*/

xo-reader2/src/reader2/ParserStateMachine.cpp

@@ -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)
         {

xo-reader2/utest/SchematikaParser.test.cpp

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

xo-tokenizer2/include/xo/tokenizer2/Token.hpp

@@ -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 ":=" **/