459 lines
17 KiB
C++
459 lines
17 KiB
C++
/* file parser.hpp
|
|
*
|
|
* author: Roland Conybeare, Jul 2024
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "xo/expression/Expression.hpp"
|
|
#include "xo/expression/DefineExpr.hpp"
|
|
#include "xo/expression/ConvertExpr.hpp"
|
|
#include "xo/tokenizer/token.hpp"
|
|
#include <stack>
|
|
#include <stdexcept>
|
|
|
|
namespace xo {
|
|
namespace scm {
|
|
enum class exprstatetype {
|
|
invalid = -1,
|
|
|
|
/** toplevel of some translation unit **/
|
|
expect_toplevel_expression_sequence,
|
|
|
|
def_0,
|
|
def_1,
|
|
def_2,
|
|
def_3,
|
|
def_4,
|
|
def_5,
|
|
|
|
/* lparen_0: look for expression; capture + advance to lparen_1 */
|
|
lparen_0,
|
|
/* lparen_1: expect rightparen */
|
|
lparen_1,
|
|
|
|
expect_rhs_expression,
|
|
expect_symbol,
|
|
expect_type,
|
|
|
|
expr_progress,
|
|
|
|
n_exprstatetype
|
|
};
|
|
|
|
extern const char *
|
|
exprstatetype_descr(exprstatetype x);
|
|
|
|
inline std::ostream &
|
|
operator<< (std::ostream & os, exprstatetype x) {
|
|
os << exprstatetype_descr(x);
|
|
return os;
|
|
}
|
|
|
|
class exprstatestack;
|
|
|
|
#ifdef NOT_YET
|
|
class exprstateaux {
|
|
public:
|
|
};
|
|
|
|
class lparen_xsa : public exprstateaux {
|
|
public:
|
|
private:
|
|
};
|
|
#endif
|
|
|
|
/** state associated with a partially-parsed expression.
|
|
**/
|
|
class exprstate {
|
|
public:
|
|
using Expression = xo::ast::Expression;
|
|
using DefineExprAccess = xo::ast::DefineExprAccess;
|
|
using ConvertExprAccess = xo::ast::ConvertExprAccess;
|
|
using exprtype = xo::ast::exprtype;
|
|
using token_type = token<char>;
|
|
using TypeDescr = xo::reflect::TypeDescr;
|
|
|
|
public:
|
|
exprstate() = default;
|
|
exprstate(exprstatetype exs_type,
|
|
rp<Expression> candidate_expr,
|
|
rp<DefineExprAccess> def_expr)
|
|
: exs_type_{exs_type},
|
|
gen_expr_{std::move(candidate_expr)},
|
|
def_expr_{std::move(def_expr)} {}
|
|
virtual ~exprstate() = default;
|
|
|
|
static std::unique_ptr<exprstate> expect_toplevel_expression_sequence() {
|
|
return std::make_unique<exprstate>(exprstate(exprstatetype::expect_toplevel_expression_sequence, nullptr, nullptr));
|
|
}
|
|
static std::unique_ptr<exprstate> expect_rhs_expression() {
|
|
return std::make_unique<exprstate>(exprstate(exprstatetype::expect_rhs_expression, nullptr, nullptr));
|
|
}
|
|
static std::unique_ptr<exprstate> expect_symbol() {
|
|
return std::make_unique<exprstate>(exprstate(exprstatetype::expect_symbol, nullptr, nullptr));
|
|
}
|
|
static std::unique_ptr<exprstate> expect_type() {
|
|
return std::make_unique<exprstate>(exprstate(exprstatetype::expect_type, nullptr, nullptr));
|
|
}
|
|
static std::unique_ptr<exprstate> make_expr_progress(rp<Expression> expr) {
|
|
return std::make_unique<exprstate>(exprstate(exprstatetype::expr_progress, expr, nullptr));
|
|
}
|
|
static std::unique_ptr<exprstate> def_0(rp<DefineExprAccess> def_expr) {
|
|
return std::make_unique<exprstate>(exprstate(exprstatetype::def_0, nullptr, def_expr));
|
|
}
|
|
static std::unique_ptr<exprstate> lparen_0() {
|
|
return std::make_unique<exprstate>(exprstate(exprstatetype::lparen_0, nullptr, nullptr));
|
|
}
|
|
|
|
exprstatetype exs_type() const { return exs_type_; }
|
|
|
|
/** true iff this parsing state admits a 'def' keyword
|
|
* as next token
|
|
**/
|
|
virtual bool admits_definition() const;
|
|
/** true iff this parsing state admits a symbol as next token **/
|
|
virtual bool admits_symbol() const;
|
|
/** true iff this parsing state admits a colon as next token **/
|
|
virtual bool admits_colon() const;
|
|
/** true iff this parsing state admits a semicolon as next token **/
|
|
virtual bool admits_semicolon() const;
|
|
/** true iff this parsing state admits a singleassign '=' as next token **/
|
|
virtual bool admits_singleassign() const;
|
|
/** true iff this parsing state admits a leftparen '(' as next token **/
|
|
virtual bool admits_leftparen() const;
|
|
/** truee iff this parsing state admits a rightparen ')' as next token **/
|
|
virtual bool admits_rightparen() const;
|
|
/** true iff this parsing state admits a 64-bit floating point literal token **/
|
|
virtual bool admits_f64() const;
|
|
|
|
/** update exprstate in response to incoming token @p tk,
|
|
* forward instructions to parent parser
|
|
**/
|
|
void on_input(const token_type & tk, exprstatestack * p_stack, rp<Expression> * p_emit_expr);
|
|
/** update exprstate in response to a successfully-parsed subexpression **/
|
|
virtual void on_expr(ref::brw<Expression> expr,
|
|
exprstatestack * p_stack,
|
|
rp<Expression> * p_emit_expr);
|
|
/** update exprstate when expecting a symbol **/
|
|
virtual void on_symbol(const std::string & symbol,
|
|
exprstatestack * p_stack,
|
|
rp<Expression> * p_emit_expr);
|
|
/** update exprstate when expeccting a typedescr **/
|
|
virtual void on_typedescr(TypeDescr td,
|
|
exprstatestack * p_stack,
|
|
rp<Expression> * p_emit_expr);
|
|
/** print human-readable representation on @p os **/
|
|
virtual void print(std::ostream & os) const;
|
|
|
|
protected:
|
|
virtual void on_def(exprstatestack * p_stack);
|
|
virtual void on_symbol(const token_type & tk,
|
|
exprstatestack * p_stack,
|
|
rp<Expression> * p_emit_expr);
|
|
virtual void on_colon(exprstatestack * p_stack);
|
|
virtual void on_semicolon(exprstatestack * p_stack,
|
|
rp<Expression> * p_emit_expr);
|
|
virtual void on_singleassign(exprstatestack * p_stack);
|
|
virtual void on_leftparen(exprstatestack * p_stack,
|
|
rp<Expression> * p_emit_expr);
|
|
virtual void on_rightparen(exprstatestack * p_stack,
|
|
rp<Expression> * p_emit_expr);
|
|
virtual void on_f64(const token_type & tk,
|
|
exprstatestack * p_stack,
|
|
rp<Expression> * p_emit_expr);
|
|
|
|
protected:
|
|
/**
|
|
* def foo : f64 = 1 ;
|
|
* ^ ^ ^ ^ ^ ^ ^ ^
|
|
* | | | | | | | (done)
|
|
* | | | | | | def_4:expect_rhs_expression:expr_progress
|
|
* | | | | | def_4:expect_rhs_expression
|
|
* | | | | def_3
|
|
* | | | def_2:expect_type
|
|
* | | def_1
|
|
* | def_0:expect_symbol
|
|
* expect_toplevel_expression_sequence
|
|
*
|
|
* def_0:expect_symbol: got 'def' keyword, symbol to follow
|
|
* def_1: got symbol name
|
|
* def_2:expect_symbol got (optional) colon, type name to follow
|
|
* def_3: got symbol type
|
|
* def_4:expect_rhs_expression got (optional) equal sign, value to follow
|
|
* (done): definition complete, pop exprstate from stack
|
|
*
|
|
**/
|
|
exprstatetype exs_type_;
|
|
|
|
/** generic expression **/
|
|
rp<Expression> gen_expr_;
|
|
/** scaffold a define-expression here **/
|
|
rp<DefineExprAccess> def_expr_;
|
|
/** scafford a convert-expression here.
|
|
* May be nested within a def_expr
|
|
**/
|
|
rp<ConvertExprAccess> cvt_expr_;
|
|
}; /*exprstate*/
|
|
|
|
inline std::ostream &
|
|
operator<< (std::ostream & os, const exprstate & x) {
|
|
x.print(os);
|
|
return os;
|
|
}
|
|
|
|
/** @class exprstatestack
|
|
* @brief A stack of exprstate objects
|
|
**/
|
|
class exprstatestack {
|
|
public:
|
|
exprstatestack() {}
|
|
|
|
bool empty() const { return stack_.empty(); }
|
|
std::size_t size() const { return stack_.size(); }
|
|
|
|
exprstate & top_exprstate();
|
|
void push_exprstate(std::unique_ptr<exprstate> exs);
|
|
std::unique_ptr<exprstate> pop_exprstate();
|
|
|
|
/** relative to top-of-stack.
|
|
* 0 -> top (last in), z-1 -> bottom (first in)
|
|
**/
|
|
std::unique_ptr<exprstate> & operator[](std::size_t i) {
|
|
std::size_t z = stack_.size();
|
|
|
|
assert(i < z);
|
|
|
|
return stack_[z - i - 1];
|
|
}
|
|
|
|
const std::unique_ptr<exprstate> & operator[](std::size_t i) const {
|
|
std::size_t z = stack_.size();
|
|
|
|
assert(i < z);
|
|
|
|
return stack_[z - i - 1];
|
|
}
|
|
|
|
void print (std::ostream & os) const;
|
|
|
|
private:
|
|
std::vector<std::unique_ptr<exprstate>> stack_;
|
|
};
|
|
|
|
inline std::ostream &
|
|
operator<< (std::ostream & os, const exprstatestack & x) {
|
|
x.print(os);
|
|
return os;
|
|
}
|
|
|
|
inline std::ostream &
|
|
operator<< (std::ostream & os, const exprstatestack * x) {
|
|
x->print(os);
|
|
return os;
|
|
}
|
|
|
|
/** schematica parser
|
|
*
|
|
* Examples:
|
|
*
|
|
* decltype point
|
|
*
|
|
* // forward declarations
|
|
* decl pi : f64;
|
|
* decl fib(n : i32) -> i32;
|
|
*
|
|
* def pi = 3.14159265; // constant. = is single assignment
|
|
*
|
|
* def fib(n : i32) -> i32 {
|
|
* // nested defs ok
|
|
* def aux(n : i32, s1 : i32, s2 : i32) -> i32 {
|
|
* // or:
|
|
* // (n == 0) ? s1 : aux(n - 1, s1 + s2, s1)
|
|
* //
|
|
* if (n == 0) {
|
|
* s1;
|
|
* } else {
|
|
* aux(n - 1, s1 + s2, s1);
|
|
* }
|
|
*
|
|
* // or:
|
|
* // if (n == 0) ? s1 : aux(n - 1, s1 + s2, s1)
|
|
* }
|
|
*
|
|
* aux(n=n, s1=1, s2=0);
|
|
* }
|
|
*
|
|
* def x := "fu"; // non-constant
|
|
* x += "bar";
|
|
*
|
|
* def anotherfib = lambda(n : i32) { fib(n) };
|
|
*
|
|
* def any : object;
|
|
* def l : list<object> = '();
|
|
*
|
|
* deftype point :: {x : f64, y : f64};
|
|
* deftype polar :: {arg : f64, mag : f64};
|
|
*
|
|
* def polar2rect(pt : polar) -> point {
|
|
* point(x = pt.mag * cos(arg),
|
|
* y = pt.mag * sin(arg));
|
|
* }
|
|
*
|
|
* Grammar:
|
|
* toplevel-program = $expression(1); ..; $expression(n)
|
|
*
|
|
* type-decl = decltype $typename [<$tp1 .. $tpn>]
|
|
* expression = define-expr
|
|
* | literal-expr
|
|
* | variable-expr
|
|
* | apply-expr
|
|
* | if-expr
|
|
* | lambda-expr
|
|
* | arithmetic-expr
|
|
* | block
|
|
*
|
|
* define-expr = type-decl
|
|
* | type-def
|
|
* | variable-def
|
|
* | function-decl
|
|
* | function-def
|
|
*
|
|
* type-def = deftype $typename [<$tp1 .. $tpn>] :: type-def-rhs
|
|
* type-def-rhs = object
|
|
* | bool
|
|
* | i128 | i64 | i32 | i16 | i8
|
|
* | f128 | f64 | f32 | f16
|
|
* | struct $typename { ($membername(i) : $typename(i))* }
|
|
* [end $typename]
|
|
* | tuple $typename { $typename(1), .., $typename(n) }
|
|
* [end $typename]
|
|
* | copytype $typename
|
|
* | subtype $typename { ($member(i) : $typename(i))* }
|
|
*
|
|
* variable-def = decl $varname [: $typename] [= expression]
|
|
* function-decl = decl $functionname($varname(1) : $typename(1),
|
|
* ..,
|
|
* $varname(n) : $typename(n)) -> $typename[ret]
|
|
* function-def = def $functionname($varname(1) : $typename(1),
|
|
* ..,
|
|
* $varname(n) : $typename(n)) [-> $typename[ret]]
|
|
* body-expr
|
|
* [ end $functionname ]
|
|
* literal-expr = integer-literal
|
|
* | fp-literal
|
|
* | string-literal
|
|
* | symbol-literal
|
|
* | struct-literal
|
|
*
|
|
* variable-expr = $varname
|
|
* apply-expr = fn-expr(arg-expr(1), .., arg-expr(n))
|
|
* fn-expr = expression
|
|
* arg-expr(i) = expression
|
|
*
|
|
* if-expr = if (test-expr) then-block else else-block
|
|
* | ((test-expr) ? then-expr : else-expr)
|
|
* test-expr = expression
|
|
* then-block = block
|
|
* else-block = block
|
|
*
|
|
* block = { (definition | expression)* }
|
|
*
|
|
* lambda-expr = lambda ($paramname(1) : $type(1),
|
|
* ..,
|
|
* $paramname(n) : $type(n)) body-expr
|
|
* body-expr = expression
|
|
*
|
|
* arithmetic-expr = expression binop expression
|
|
*
|
|
* binop = +
|
|
* | -
|
|
* | *
|
|
* | /
|
|
* | |
|
|
* | &
|
|
* | ^
|
|
* | ==
|
|
* | !=
|
|
* | <
|
|
* | <=
|
|
* | =>
|
|
* | >
|
|
*
|
|
**/
|
|
class parser {
|
|
public:
|
|
using Expression = xo::ast::Expression;
|
|
using token_type = exprstate::token_type; // token<char>;
|
|
|
|
public:
|
|
/** create parser in initial state;
|
|
* parser is ready to receive tokens via @ref include_token
|
|
**/
|
|
parser() = default;
|
|
|
|
/** for diagnostics: number of entries in parser stack **/
|
|
std::size_t stack_size() const { return xs_stack_.size(); }
|
|
/** for diagnostics: exprstatetype at level @p i
|
|
* (taken relative to top of stack)
|
|
*
|
|
* @pre 0 <= i < stack_size
|
|
**/
|
|
exprstatetype i_exstype(std::size_t i) const {
|
|
std::size_t z = xs_stack_.size();
|
|
|
|
if (i < z) {
|
|
return xs_stack_[i]->exs_type();
|
|
}
|
|
|
|
/* out of bounds */
|
|
return exprstatetype::invalid;
|
|
}
|
|
|
|
/** true iff parser contains state for an incomplete expression.
|
|
* For this to be true, parser must have consumed at least one token
|
|
* since end of last toplevel expression
|
|
**/
|
|
bool has_incomplete_expr() const;
|
|
|
|
/** put parser into state for beginning of a translation unit
|
|
* (i.e. input stream)
|
|
**/
|
|
void begin_translation_unit();
|
|
|
|
/** include next token @p tk and increment parser state.
|
|
*
|
|
* @param tk next input token
|
|
* @return parsed expression, if @p tk completes an expression.
|
|
* otherwise nullptr
|
|
**/
|
|
rp<Expression> include_token(const token_type & tk);
|
|
|
|
/** print human-readable representation on stream @p os **/
|
|
void print(std::ostream & os) const;
|
|
|
|
private:
|
|
/** state recording state associated with enclosing expressions.
|
|
*
|
|
* Note: at least asof c++23, the std::stack api doesn't support access
|
|
* to members other than the top.
|
|
*
|
|
* for stack with N elements (N = stack_.size()):
|
|
* - bottom of stack is stack_[0]
|
|
* - top of stack is stack_[N-1]
|
|
**/
|
|
exprstatestack xs_stack_;
|
|
|
|
}; /*parser*/
|
|
|
|
inline std::ostream &
|
|
operator<< (std::ostream & os,
|
|
const parser & x) {
|
|
x.print(os);
|
|
return os;
|
|
}
|
|
|
|
} /*namespace scm*/
|
|
} /*namespace xo*/
|
|
|
|
/* end parser.hpp */
|