Replace object parser with lalr library
This commit is contained in:
Ilusha
Ilya Shurupov
parent
8f87c3bc33
commit
1293136343
13 changed files with 499 additions and 995 deletions
|
|
@ -1,840 +1,105 @@
|
|||
|
||||
#include "List.hpp"
|
||||
#include "Logging.hpp"
|
||||
|
||||
#include "compiler/function.h"
|
||||
#include "parser/parser.h"
|
||||
#include <parser/parser.h>
|
||||
|
||||
#include <cstdlib>
|
||||
// #include "compiler/function.h"
|
||||
|
||||
#define MAX_STREAM_LENGTH 1024 * 8 * 200
|
||||
#include <lalr/Parser.hpp>
|
||||
#include <lalr/string_literal.hpp>
|
||||
|
||||
#define REQUIRE(expr, desc, on_catch) \
|
||||
DEBUG_BREAK(mRes.err); \
|
||||
if (!(expr)) { \
|
||||
mRes.err = new Error(desc, mTok.getCursorPrev().mAdvancedOffset); \
|
||||
on_catch; \
|
||||
return NULL; \
|
||||
}
|
||||
#define CHECK(expr, on_catch) \
|
||||
if (!(expr)) { \
|
||||
on_catch; \
|
||||
return NULL; \
|
||||
}
|
||||
#define CHECK_ERROR(value, on_catch) \
|
||||
if (mRes.err || !value) { \
|
||||
on_catch; \
|
||||
return NULL; \
|
||||
}
|
||||
|
||||
using namespace tp;
|
||||
using namespace obj;
|
||||
using namespace BCgen;
|
||||
|
||||
bool Parser::Token::isAriphm() {
|
||||
switch (type) {
|
||||
case Token::ADD:
|
||||
case Token::SUB:
|
||||
case Token::DIV:
|
||||
case Token::MUL: return true;
|
||||
default: return false;
|
||||
struct ASTNode {
|
||||
BCgen::Expression* expression = nullptr;
|
||||
BCgen::Statement* statement = nullptr;
|
||||
};
|
||||
|
||||
extern const lalr::ParserStateMachine* oscript_parser_state_machine;
|
||||
typedef void* UserData;
|
||||
typedef char SymbolType;
|
||||
|
||||
typedef std::basic_string<SymbolType>::iterator IteratorType;
|
||||
|
||||
namespace action {
|
||||
static UserData expr_bool(const UserData* start, const lalr::ParserNode<SymbolType>* nodes, size_t length) {
|
||||
return new BCgen::ExpressionConst(nodes[0].lexeme() == "true");
|
||||
}
|
||||
|
||||
static UserData expr_int(const UserData* start, const lalr::ParserNode<SymbolType>* nodes, size_t length) {
|
||||
return {};
|
||||
}
|
||||
|
||||
static UserData expr_float(const UserData* start, const lalr::ParserNode<SymbolType>* nodes, size_t length) {
|
||||
return {};
|
||||
}
|
||||
|
||||
static UserData expr_string(const UserData* start, const lalr::ParserNode<SymbolType>* nodes, size_t length) {
|
||||
return {};
|
||||
}
|
||||
|
||||
static UserData stm_log(const UserData* start, const lalr::ParserNode<SymbolType>* nodes, size_t length) {
|
||||
auto expr = (BCgen::Expression*) (start[1]);
|
||||
return new BCgen::StatementPrint(expr);
|
||||
}
|
||||
|
||||
static UserData stm_defVar(const UserData* start, const lalr::ParserNode<SymbolType>* nodes, size_t length) {
|
||||
return new BCgen::StatementLocalDef(nodes[1].lexeme().c_str(), new BCgen::ExpressionConst(false));
|
||||
}
|
||||
|
||||
static UserData stm_scope_append(const UserData* start, const lalr::ParserNode<SymbolType>* nodes, size_t length) {
|
||||
auto scope = (BCgen::StatementScope*) start[0];
|
||||
auto stm = (BCgen::Statement*) start[2];
|
||||
scope->mStatements.append(stm);
|
||||
return scope;
|
||||
}
|
||||
|
||||
static UserData stm_scope_create(const UserData* start, const lalr::ParserNode<SymbolType>* nodes, size_t length) {
|
||||
auto stm = (BCgen::Statement*) start[0];
|
||||
return new BCgen::StatementScope({ stm }, true);
|
||||
}
|
||||
|
||||
static UserData scope(const UserData* start, const lalr::ParserNode<SymbolType>* nodes, size_t length) {
|
||||
return start[1];
|
||||
}
|
||||
|
||||
static UserData tmp(const UserData* start, const lalr::ParserNode<SymbolType>* nodes, size_t length) {
|
||||
return *start;
|
||||
}
|
||||
}
|
||||
|
||||
bool Parser::Token::isBoolean() {
|
||||
switch (type) {
|
||||
case Token::EQUAL:
|
||||
case Token::NOT_EQUAL:
|
||||
case Token::BOOL_AND:
|
||||
case Token::BOOL_OR:
|
||||
case Token::MORE:
|
||||
case Token::LESS:
|
||||
case Token::QE_OR_MORE:
|
||||
case Token::QE_OR_LESS: return true;
|
||||
default: return false;
|
||||
}
|
||||
}
|
||||
Parser::Result Parser::parse(const tp::String& stream) {
|
||||
|
||||
Parser::Parser() {
|
||||
mTok.build({
|
||||
{ "\n|\t| |\r", Token::SPACE },
|
||||
{ "var", Token::VAR },
|
||||
{ "class", Token::CLASS_DEF },
|
||||
{ "self", Token::SELF },
|
||||
{ "\\{", Token::SCOPE_IN },
|
||||
{ "\\}", Token::SCOPE_OUT },
|
||||
{ "=", Token::ASSIGN },
|
||||
{ "def", Token::DEF_FUNC },
|
||||
{ "<<", Token::PRINT },
|
||||
{ "if", Token::IF },
|
||||
{ "else", Token::ELSE },
|
||||
{ "while", Token::WHILE },
|
||||
{ "\\(", Token::BRACKET_IN },
|
||||
{ "\\)", Token::BRACKET_OUT },
|
||||
{ ",", Token::COMMA },
|
||||
{ "new", Token::NEW },
|
||||
{ "\\.", Token::CHILD },
|
||||
{ "return", Token::RETURN },
|
||||
{ "==", Token::EQUAL },
|
||||
{ "!=", Token::NOT_EQUAL },
|
||||
{ ">", Token::MORE },
|
||||
{ "<", Token::LESS },
|
||||
{ ">=", Token::QE_OR_MORE },
|
||||
{ "<=", Token::QE_OR_LESS },
|
||||
{ "!", Token::BOOL_NOT },
|
||||
{ "&&", Token::BOOL_AND },
|
||||
{ "\\|\\|", Token::BOOL_OR },
|
||||
{ "\\+", Token::ADD },
|
||||
{ "\\*", Token::MUL },
|
||||
{ "\\-", Token::SUB },
|
||||
{ "/", Token::DIV },
|
||||
{ ";", Token::STM_END },
|
||||
{ "true", Token::CONST_TRUE },
|
||||
{ "false", Token::CONST_FALSE },
|
||||
{ "((\\-)|(\\+))?[0-9]+i?", Token::CONST_INT },
|
||||
{ R"(((\-)|(\+))?([0-9]+)(\.)([0-9]*)?f?)", Token::CONST_FLOAT },
|
||||
{ R"((/\*){\*-\*}*(\*/))", Token::COMMENT_BLOCK },
|
||||
{ R"("{"-"}*")", Token::CONST_STRING },
|
||||
lalr::ErrorPolicy errorPolicy;
|
||||
|
||||
{ "([a-z]|[A-Z]|_)+([a-z]|[A-Z]|[0-9]|_)*", Token::ID },
|
||||
});
|
||||
}
|
||||
lalr::Parser<IteratorType, UserData> parser(oscript_parser_state_machine, &errorPolicy);
|
||||
|
||||
tp::String to_string(const char* stream, tp::alni len) {
|
||||
tp::String out;
|
||||
out.resize(len);
|
||||
tp::memCopy(out.write(), stream, len);
|
||||
return out;
|
||||
}
|
||||
parser.set_lexer_action_handler("string", &lalr::string_literal<IteratorType>);
|
||||
|
||||
Parser::Token Parser::tokRead() {
|
||||
Token out;
|
||||
parser.set_action_handler("expr_bool", &action::expr_bool);
|
||||
parser.set_action_handler("expr_int", &action::expr_int);
|
||||
parser.set_action_handler("expr_float", &action::expr_float);
|
||||
parser.set_action_handler("expr_string", &action::expr_string);
|
||||
|
||||
if (!tokInputLeft()) {
|
||||
Token out;
|
||||
out.type = Token::NO_TOKEN;
|
||||
return out;
|
||||
}
|
||||
parser.set_action_handler("stm_defVar", &action::stm_defVar);
|
||||
parser.set_action_handler("stm_log", &action::stm_log);
|
||||
|
||||
auto crs_start = mTok.getCursor();
|
||||
out.type = mTok.readTok();
|
||||
out.token = to_string(crs_start.str(), mTok.lastTokLEn());
|
||||
parser.set_action_handler("stm_scope_create", &action::stm_scope_create);
|
||||
parser.set_action_handler("stm_scope_append", &action::stm_scope_append);
|
||||
|
||||
switch (out.type) {
|
||||
case Token::CONST_FALSE: out.boolean = false; break;
|
||||
case Token::CONST_TRUE: out.boolean = true; break;
|
||||
case Token::CONST_INT:
|
||||
{
|
||||
char* p_end;
|
||||
out.integer = std::strtol(out.token.read(), &p_end, 10);
|
||||
DEBUG_ASSERT(out.token.read() != p_end);
|
||||
break;
|
||||
}
|
||||
case Token::CONST_FLOAT:
|
||||
{
|
||||
char* p_end;
|
||||
out.floating = std::strtod(out.token.read(), &p_end);
|
||||
DEBUG_ASSERT(out.token.read() != p_end);
|
||||
break;
|
||||
}
|
||||
case Token::CONST_STRING:
|
||||
{
|
||||
out.str = to_string(crs_start.str() + 1, mTok.lastTokLEn() - 2);
|
||||
break;
|
||||
}
|
||||
}
|
||||
parser.set_action_handler("scope", &action::scope);
|
||||
|
||||
return out;
|
||||
}
|
||||
parser.set_action_handler("tmp", &action::tmp);
|
||||
|
||||
Parser::Token Parser::tokLookup() {
|
||||
auto crs = mTok.getCursor();
|
||||
auto out = tokRead();
|
||||
mTok.setCursor(crs);
|
||||
return out;
|
||||
}
|
||||
std::string streamStd(stream.read());
|
||||
|
||||
bool Parser::tokInputLeft() {
|
||||
auto type = mTok.lookupTok();
|
||||
LALR_ASSERT(parser.valid());
|
||||
|
||||
while (mTok.isInputLeft() && type == Token::SPACE || (type >= Token::__END__ && type <= Token::__START__)) {
|
||||
mTok.skipTok();
|
||||
type = mTok.lookupTok();
|
||||
}
|
||||
parser.parse(streamStd.begin(), streamStd.end());
|
||||
|
||||
return type != Token::SOURCE_END_TOKEN;
|
||||
}
|
||||
parser.accepted();
|
||||
parser.full();
|
||||
|
||||
void Parser::tokSkip() {
|
||||
if (!tokInputLeft()) {
|
||||
return;
|
||||
}
|
||||
mTok.skipTok();
|
||||
}
|
||||
auto scope = (BCgen::StatementScope*) parser.user_data();
|
||||
|
||||
Parser::Tokenizer::Cursor Parser::tokGetCursor() { return mTok.getCursor(); }
|
||||
void Parser::tokSetCursor(Tokenizer::Cursor crs) { mTok.setCursor(crs); }
|
||||
|
||||
Expression* Parser::parseExprCompound() {
|
||||
CHECK(tokRead() == Token::BRACKET_IN, {});
|
||||
auto ret = parseExpr();
|
||||
CHECK_ERROR(ret, {});
|
||||
REQUIRE(tokRead() == Token::BRACKET_OUT, "Expected Closing Bracket", {});
|
||||
return ret;
|
||||
}
|
||||
|
||||
Expression* Parser::parseExprNEW() {
|
||||
CHECK(tokRead() == Token::NEW, {});
|
||||
auto name = tokRead();
|
||||
REQUIRE(name == Token::ID, "Expected Identifier", {});
|
||||
|
||||
REQUIRE(tokRead() == Token::BRACKET_IN, "Expected opening brackets", {});
|
||||
REQUIRE(tokRead() == Token::BRACKET_OUT, "Expected closing brackets", {});
|
||||
|
||||
return ExprNew(name.token);
|
||||
}
|
||||
|
||||
Expression* Parser::parseExprLOCAL() {
|
||||
auto local_id_tok = tokRead();
|
||||
if (local_id_tok == Token::ID) {
|
||||
return ExprLocal(local_id_tok.token);
|
||||
} else if (local_id_tok == Token::SELF) {
|
||||
return ExprSelf();
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
Expression* Parser::parseExprCONST() {
|
||||
auto tok = tokRead();
|
||||
switch (tok) {
|
||||
case Token::CONST_FALSE: return ExprConst(false);
|
||||
case Token::CONST_TRUE: return ExprConst(true);
|
||||
case Token::CONST_INT: return ExprConst(tok.integer);
|
||||
case Token::CONST_FLOAT: return ExprConst(tok.floating);
|
||||
case Token::CONST_STRING: return ExprConst(tok.str);
|
||||
default: REQUIRE(0, "not a const Expr", {});
|
||||
}
|
||||
}
|
||||
|
||||
Expression* Parser::parseExprCHILD(Expression* prnt) {
|
||||
CHECK(tokRead() == Token::CHILD, {});
|
||||
auto id = tokRead();
|
||||
REQUIRE(id == Token::ID, "Exprected Identifier", {});
|
||||
return prnt->ExprChild(id.str);
|
||||
}
|
||||
|
||||
Expression* Parser::parseExprCALL(Expression* prnt) {
|
||||
CHECK(tokRead() == Token::BRACKET_IN, {});
|
||||
|
||||
List<Expression*> args;
|
||||
|
||||
READ_ARG:
|
||||
Expression* expr = NULL;
|
||||
auto tok = tokLookup();
|
||||
REQUIRE(tok != Token::NO_TOKEN, "Missing Closing Bracket", {});
|
||||
|
||||
if (tok != Token::BRACKET_OUT) {
|
||||
|
||||
expr = parseExpr();
|
||||
CHECK_ERROR(expr, {
|
||||
for (auto arg : args) {
|
||||
delete arg.data();
|
||||
}
|
||||
});
|
||||
|
||||
args.pushBack(expr);
|
||||
|
||||
tok = tokLookup();
|
||||
if (tok == Token::COMMA) {
|
||||
tokSkip();
|
||||
goto READ_ARG;
|
||||
} else if (tok != Token::BRACKET_OUT) {
|
||||
for (auto arg : args) {
|
||||
delete arg.data();
|
||||
}
|
||||
REQUIRE(0, "Expected A Closing Bracket", {});
|
||||
}
|
||||
}
|
||||
tokSkip();
|
||||
|
||||
auto out = prnt->ExprCall({});
|
||||
out->mArgs.reserve(args.length());
|
||||
|
||||
ualni idx = 0;
|
||||
for (auto arg : args) {
|
||||
out->mArgs[idx] = arg.data();
|
||||
idx++;
|
||||
}
|
||||
|
||||
return out;
|
||||
}
|
||||
|
||||
Expression* Parser::parseExprAriphm() {
|
||||
|
||||
tp::InitialierList<ExprType> expessions = {
|
||||
ExprType::Compound,
|
||||
ExprType::NEW,
|
||||
ExprType::LOCAL,
|
||||
ExprType::CONST,
|
||||
};
|
||||
|
||||
Expression* left = parseExpr(expessions);
|
||||
CHECK_ERROR(left, {});
|
||||
|
||||
Expression* ret = NULL;
|
||||
|
||||
PARSE:
|
||||
|
||||
Expression* right = NULL;
|
||||
|
||||
auto tok = tokLookup();
|
||||
if (tok.isAriphm()) {
|
||||
tokSkip();
|
||||
|
||||
right = parseExpr(expessions);
|
||||
|
||||
if (mRes.err) {
|
||||
if (ret) {
|
||||
goto PRECEDENCE;
|
||||
}
|
||||
|
||||
delete left;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
} else {
|
||||
CHECK(ret, { delete left; });
|
||||
goto PRECEDENCE;
|
||||
}
|
||||
|
||||
switch (tok) {
|
||||
case Token::ADD: ret = ExprAriphm(left, right, OpCode::OBJ_ADD); break;
|
||||
case Token::SUB: ret = ExprAriphm(left, right, OpCode::OBJ_SUB); break;
|
||||
case Token::DIV: ret = ExprAriphm(left, right, OpCode::OBJ_DIV); break;
|
||||
case Token::MUL: ret = ExprAriphm(left, right, OpCode::OBJ_MUL);
|
||||
}
|
||||
|
||||
left = ret;
|
||||
goto PARSE;
|
||||
|
||||
PRECEDENCE:
|
||||
// FIXME: Not Implemented
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
Expression* Parser::parseExprBOOLEAN() {
|
||||
|
||||
tp::InitialierList<ExprType> expessions = {
|
||||
ExprType::Compound, ExprType::NEW, ExprType::LOCAL, ExprType::CONST, ExprType::BOOLEAN_NOT,
|
||||
};
|
||||
|
||||
Expression* left = parseExpr(expessions);
|
||||
CHECK_ERROR(left, {});
|
||||
|
||||
Expression* ret = NULL;
|
||||
|
||||
PARSE:
|
||||
|
||||
Expression* right = NULL;
|
||||
|
||||
auto tok = tokLookup();
|
||||
if (tok.isBoolean()) {
|
||||
tokSkip();
|
||||
|
||||
right = parseExpr(expessions);
|
||||
|
||||
if (mRes.err) {
|
||||
if (ret) {
|
||||
goto PRECEDENCE;
|
||||
}
|
||||
|
||||
delete left;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
} else {
|
||||
CHECK(ret, { delete left; });
|
||||
goto PRECEDENCE;
|
||||
}
|
||||
|
||||
switch (tok) {
|
||||
case Token::EQUAL: ret = ExprBool(left, right, OpCode::EQUAL); break;
|
||||
case Token::NOT_EQUAL: ret = ExprBool(left, right, OpCode::NOT_EQUAL); break;
|
||||
case Token::BOOL_AND: ret = ExprBool(left, right, OpCode::AND); break;
|
||||
case Token::BOOL_OR: ret = ExprBool(left, right, OpCode::OR); break;
|
||||
case Token::MORE: ret = ExprBool(left, right, OpCode::MORE); break;
|
||||
case Token::LESS: ret = ExprBool(left, right, OpCode::LESS); break;
|
||||
case Token::QE_OR_MORE: ret = ExprBool(left, right, OpCode::EQUAL_OR_MORE); break;
|
||||
case Token::QE_OR_LESS: ret = ExprBool(left, right, OpCode::EQUAL_OR_LESS);
|
||||
}
|
||||
|
||||
left = ret;
|
||||
goto PARSE;
|
||||
|
||||
PRECEDENCE:
|
||||
// FIXME: Not Implemented
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
Expression* Parser::parseExprBOOLEAN_NOT() {
|
||||
CHECK(tokRead() == Token::BOOL_NOT, {});
|
||||
|
||||
tp::InitialierList<ExprType> exprs = {
|
||||
ExprType::Compound, ExprType::BOOLEAN, ExprType::Ariphm, ExprType::NEW, ExprType::LOCAL, ExprType::CONST,
|
||||
};
|
||||
|
||||
auto out = parseExpr(exprs);
|
||||
CHECK_ERROR(out, {});
|
||||
|
||||
return ExprBoolNot(out);
|
||||
}
|
||||
|
||||
Expression* Parser::parseExprFUNC() {
|
||||
auto op_tok = tokRead();
|
||||
CHECK(op_tok == Token::ID, {});
|
||||
return ExprFunc(op_tok.token);
|
||||
}
|
||||
|
||||
// passed prnt isno longer responsability of callee
|
||||
// suc : returns top level parent
|
||||
// err : returns NULL
|
||||
Expression* Parser::parseExprChain(Expression* prnt) {
|
||||
|
||||
PARSE_CHAIN:
|
||||
auto tok = tokLookup();
|
||||
|
||||
switch (tok) {
|
||||
case Token::CHILD:
|
||||
{
|
||||
tokRead();
|
||||
|
||||
auto child_id = tokRead();
|
||||
REQUIRE(child_id == Token::ID, "expected an id", { delete prnt; });
|
||||
|
||||
prnt = prnt->ExprChild(child_id.token);
|
||||
goto PARSE_CHAIN;
|
||||
}
|
||||
|
||||
case Token::BRACKET_IN:
|
||||
{
|
||||
|
||||
auto new_prnt = parseExprCALL(prnt);
|
||||
CHECK_ERROR(new_prnt, { delete prnt; });
|
||||
|
||||
if (prnt->mType == Expression::Type::CHILD) {
|
||||
((ExpressionChild*) prnt)->mMethod = true;
|
||||
}
|
||||
|
||||
prnt = new_prnt;
|
||||
goto PARSE_CHAIN;
|
||||
}
|
||||
}
|
||||
|
||||
return prnt;
|
||||
}
|
||||
|
||||
Expression* Parser::parseExpr(tp::InitialierList<ExprType> expressions) {
|
||||
|
||||
Expression* out = NULL;
|
||||
|
||||
List<Error*> errors;
|
||||
|
||||
for (auto expr_type : expressions) {
|
||||
auto crs = tokGetCursor();
|
||||
switch (expr_type) {
|
||||
case Parser::ExprType::BOOLEAN_NOT: out = parseExprBOOLEAN_NOT(); break;
|
||||
case Parser::ExprType::BOOLEAN: out = parseExprBOOLEAN(); break;
|
||||
case Parser::ExprType::Ariphm: out = parseExprAriphm(); break;
|
||||
case Parser::ExprType::NEW: out = parseExprNEW(); break;
|
||||
case Parser::ExprType::LOCAL: out = parseExprLOCAL(); break;
|
||||
case Parser::ExprType::CONST: out = parseExprCONST(); break;
|
||||
case Parser::ExprType::Compound: out = parseExprCompound(); break;
|
||||
}
|
||||
|
||||
if (out) {
|
||||
break;
|
||||
}
|
||||
|
||||
tokSetCursor(crs);
|
||||
if (mRes.err) {
|
||||
errors.pushBack(mRes.err);
|
||||
mRes.err = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
if (out) {
|
||||
// check for child expression and calls
|
||||
out = parseExprChain(out);
|
||||
|
||||
// check errors
|
||||
if (mRes.err) {
|
||||
errors.pushBack(mRes.err);
|
||||
mRes.err = NULL;
|
||||
goto ERRORS;
|
||||
}
|
||||
|
||||
for (auto err : errors) {
|
||||
delete err.data();
|
||||
}
|
||||
|
||||
return out;
|
||||
}
|
||||
|
||||
ERRORS:
|
||||
Error* error = NULL;
|
||||
tp::alni max_advanced = 0;
|
||||
for (auto err : errors) {
|
||||
if (err.data()->mAdvanecedIdx && err.data()->mAdvanecedIdx > max_advanced) {
|
||||
max_advanced = err.data()->mAdvanecedIdx;
|
||||
error = err.data();
|
||||
}
|
||||
}
|
||||
|
||||
if (error) {
|
||||
mRes.err = new Error(*error);
|
||||
|
||||
for (auto err : errors) {
|
||||
delete err.data();
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
REQUIRE(0, "Expected and expression", {});
|
||||
}
|
||||
|
||||
Statement* Parser::parseStmCall() {
|
||||
|
||||
Expression* expr = parseExpr();
|
||||
CHECK_ERROR(expr, {});
|
||||
|
||||
REQUIRE(expr->mType == Expression::Type::CALL, "expression statement can only be function call", { delete expr; });
|
||||
|
||||
if (tokRead() != Token::STM_END) {
|
||||
delete expr;
|
||||
REQUIRE(0, "Expected End Of Statement", {});
|
||||
}
|
||||
|
||||
return StmIgnore(expr);
|
||||
}
|
||||
|
||||
Statement* Parser::parseStmDefFunc() {
|
||||
CHECK(tokRead() == Token::DEF_FUNC, {});
|
||||
List<tp::String> args;
|
||||
auto name = tokRead();
|
||||
REQUIRE(name == Token::ID, "Expected an Identifier", {});
|
||||
|
||||
REQUIRE(tokRead() == Token::BRACKET_IN, "Expected Opening Bracket", {});
|
||||
|
||||
READ_ARG:
|
||||
auto tok = tokLookup();
|
||||
|
||||
REQUIRE(tok != Token::NO_TOKEN, "Missing Closing Bracket", {});
|
||||
|
||||
if (tok == Token::ID) {
|
||||
args.pushBack(tok.token);
|
||||
tokSkip();
|
||||
tok = tokLookup();
|
||||
}
|
||||
|
||||
if (tok == Token::COMMA) {
|
||||
tokSkip();
|
||||
goto READ_ARG;
|
||||
}
|
||||
|
||||
REQUIRE(tok == Token::BRACKET_OUT, "Expected Closing Bracket", {});
|
||||
tokSkip();
|
||||
|
||||
auto func_def = StmDefFunc(name.token, {}, {});
|
||||
|
||||
func_def->mArgs.reserve(args.length());
|
||||
|
||||
ualni idx = 0;
|
||||
for (auto iter : args) {
|
||||
func_def->mArgs[idx] = iter.data();
|
||||
idx++;
|
||||
}
|
||||
|
||||
StatementScope* scope = parseScope(true);
|
||||
CHECK_ERROR(scope, { delete func_def; });
|
||||
|
||||
func_def->mStatements.reserve(scope->mStatements.size());
|
||||
|
||||
idx = 0;
|
||||
for (auto stm : scope->mStatements) {
|
||||
func_def->mStatements[idx] = stm.data();
|
||||
idx++;
|
||||
}
|
||||
|
||||
delete scope;
|
||||
return func_def;
|
||||
}
|
||||
|
||||
Statement* Parser::parseStmDefLocal() {
|
||||
CHECK(tokRead() == Token::VAR, {});
|
||||
|
||||
auto tok = tokRead();
|
||||
REQUIRE(tok == Token::ID, "Expected an Identifier", {});
|
||||
REQUIRE(tokRead() == Token::ASSIGN, "Expected an assigment", {});
|
||||
|
||||
auto expr = parseExpr();
|
||||
CHECK_ERROR(expr, {});
|
||||
|
||||
if (tokRead() != Token::STM_END) {
|
||||
delete expr;
|
||||
REQUIRE(0, "Expected End Of Statement", {});
|
||||
}
|
||||
|
||||
return StmDefLocal(tok.token, expr);
|
||||
}
|
||||
|
||||
Statement* Parser::parseStmReturn() {
|
||||
CHECK(tokRead() == Token::RETURN, {});
|
||||
auto crs = tokGetCursor();
|
||||
|
||||
auto expr = parseExpr();
|
||||
if (mRes.err) {
|
||||
tokSetCursor(crs);
|
||||
delete mRes.err;
|
||||
mRes.err = NULL;
|
||||
}
|
||||
|
||||
if (tokRead() != Token::STM_END) {
|
||||
if (expr) delete expr;
|
||||
REQUIRE(0, "Expected End Of Statement", {});
|
||||
}
|
||||
|
||||
return expr ? StmReturn(expr) : StmReturn();
|
||||
}
|
||||
|
||||
Statement* Parser::parseStmPrint() {
|
||||
CHECK(tokRead() == Token::PRINT, {});
|
||||
auto expr = parseExpr();
|
||||
CHECK_ERROR(expr, {});
|
||||
|
||||
if (tokRead() != Token::STM_END) {
|
||||
delete expr;
|
||||
REQUIRE(0, "Expected End Of Statement", {});
|
||||
}
|
||||
return StmPrint(expr);
|
||||
}
|
||||
|
||||
Statement* Parser::parseStmIf() {
|
||||
CHECK(tokRead() == Token::IF, {});
|
||||
|
||||
// single if
|
||||
REQUIRE(tokRead() == Token::BRACKET_IN, "Expected Opening Bracket", {});
|
||||
auto expr = parseExpr();
|
||||
CHECK_ERROR(expr, {});
|
||||
|
||||
if (tokRead() != Token::BRACKET_OUT) {
|
||||
delete expr;
|
||||
REQUIRE(0, "Expected Closing Bracket", {});
|
||||
}
|
||||
|
||||
auto ontrue = parseScope(false);
|
||||
CHECK_ERROR(ontrue, {});
|
||||
|
||||
// if-else
|
||||
auto crs = tokGetCursor();
|
||||
if (tokRead() == Token::ELSE) {
|
||||
StatementScope* onfalse = parseScope(false);
|
||||
CHECK_ERROR(onfalse, {
|
||||
delete ontrue;
|
||||
delete expr;
|
||||
});
|
||||
|
||||
return StmIf(expr, ontrue, onfalse);
|
||||
}
|
||||
tokSetCursor(crs);
|
||||
|
||||
return StmIf(expr, ontrue, NULL);
|
||||
}
|
||||
|
||||
Statement* Parser::parseStmWhile() {
|
||||
CHECK(tokRead() == Token::WHILE, {});
|
||||
|
||||
REQUIRE(tokRead() == Token::BRACKET_IN, "Expected Opening Bracket", {});
|
||||
auto expr = parseExpr();
|
||||
CHECK_ERROR(expr, {});
|
||||
|
||||
if (tokRead() != Token::BRACKET_OUT) {
|
||||
delete expr;
|
||||
REQUIRE(0, "Expected Closing Bracket", {});
|
||||
}
|
||||
|
||||
auto scope = parseScope(false);
|
||||
CHECK_ERROR(scope, {});
|
||||
|
||||
return StmWhile(expr, scope);
|
||||
}
|
||||
|
||||
Statement* Parser::parseStmCopy() {
|
||||
auto left = parseExpr();
|
||||
CHECK_ERROR(left, {});
|
||||
|
||||
CHECK(tokRead() == Token::ASSIGN, {});
|
||||
|
||||
auto right = parseExpr();
|
||||
CHECK_ERROR(right, { delete left; });
|
||||
|
||||
if (tokRead() != Token::STM_END) {
|
||||
delete left;
|
||||
delete right;
|
||||
REQUIRE(0, "Expected End Of Statement", {});
|
||||
}
|
||||
|
||||
return StmCopy(left, right);
|
||||
}
|
||||
|
||||
Statement* Parser::parseStmClassDef() {
|
||||
CHECK(tokRead() == Token::CLASS_DEF, {});
|
||||
|
||||
auto id = tokRead();
|
||||
REQUIRE(id == Token::ID, "Expected an Identifier", {});
|
||||
|
||||
auto scope = parseScope(true);
|
||||
CHECK_ERROR(scope, {});
|
||||
|
||||
return StmClassDef(id.token, scope);
|
||||
}
|
||||
|
||||
Statement* Parser::parseStm(tp::InitialierList<StmType> stm_types) {
|
||||
Statement* out = NULL;
|
||||
|
||||
List<Error*> errors;
|
||||
|
||||
for (auto stm_type : stm_types) {
|
||||
auto crs = tokGetCursor();
|
||||
switch (stm_type) {
|
||||
case StmType::DefFunc: out = parseStmDefFunc(); break;
|
||||
case StmType::DefLocal: out = parseStmDefLocal(); break;
|
||||
case StmType::Return: out = parseStmReturn(); break;
|
||||
case StmType::Print: out = parseStmPrint(); break;
|
||||
case StmType::If: out = parseStmIf(); break;
|
||||
case StmType::While: out = parseStmWhile(); break;
|
||||
case StmType::Copy: out = parseStmCopy(); break;
|
||||
case StmType::Call: out = parseStmCall(); break;
|
||||
case StmType::CLASS_DEF: out = parseStmClassDef(); break;
|
||||
}
|
||||
|
||||
if (out) {
|
||||
break;
|
||||
}
|
||||
|
||||
tokSetCursor(crs);
|
||||
if (mRes.err) {
|
||||
errors.pushBack(mRes.err);
|
||||
mRes.err = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
if (out) {
|
||||
for (auto err : errors) {
|
||||
delete err.data();
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
Error* error = NULL;
|
||||
tp::alni max_advanced = 0;
|
||||
for (auto err : errors) {
|
||||
if (err.data()->mAdvanecedIdx && max_advanced < err.data()->mAdvanecedIdx) {
|
||||
max_advanced = err.data()->mAdvanecedIdx;
|
||||
error = err.data();
|
||||
}
|
||||
}
|
||||
|
||||
if (error) {
|
||||
mRes.err = new Error(*error);
|
||||
|
||||
for (auto err : errors) {
|
||||
delete err.data();
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
REQUIRE(0, "Exprected A Statement", {});
|
||||
}
|
||||
|
||||
StatementScope* Parser::parseScope(bool aPushToScopeStack) {
|
||||
CHECK(tokRead() == Token::SCOPE_IN, {});
|
||||
|
||||
auto out = new StatementScope({}, aPushToScopeStack);
|
||||
List<Statement*> stms;
|
||||
|
||||
READ_STM:
|
||||
auto crs = tokGetCursor();
|
||||
auto tok = tokRead();
|
||||
|
||||
if (tok == Token::NO_TOKEN) {
|
||||
delete out;
|
||||
for (auto stm : stms) {
|
||||
delete stm.data();
|
||||
}
|
||||
REQUIRE(0, "Missing Scope Closing Bracket", {});
|
||||
}
|
||||
|
||||
if (tok != Token::SCOPE_OUT) {
|
||||
tokSetCursor(crs);
|
||||
|
||||
auto stm = parseStm();
|
||||
CHECK_ERROR(stm, {
|
||||
delete out;
|
||||
for (auto stm : stms) {
|
||||
delete stm.data();
|
||||
}
|
||||
});
|
||||
|
||||
stms.pushBack(stm);
|
||||
|
||||
goto READ_STM;
|
||||
}
|
||||
|
||||
out->mStatements.reserve(stms.length());
|
||||
|
||||
ualni idx = 0;
|
||||
for (auto stm : stms) {
|
||||
out->mStatements[idx] = stm.data();
|
||||
idx++;
|
||||
}
|
||||
|
||||
return out;
|
||||
}
|
||||
|
||||
Parser::Resault Parser::parse(const tp::String& oscript) {
|
||||
mTok.bindSource(oscript.read());
|
||||
mTok.reset();
|
||||
|
||||
mRes.scope = new StatementScope({}, true);
|
||||
|
||||
List<Statement*> stms;
|
||||
do {
|
||||
auto stm = parseStm();
|
||||
|
||||
if (mRes.err || !stm) { // catch
|
||||
delete mRes.scope;
|
||||
mRes.scope = NULL;
|
||||
for (auto stm : stms) {
|
||||
delete stm.data();
|
||||
}
|
||||
|
||||
return mRes;
|
||||
}
|
||||
|
||||
stms.pushBack(stm);
|
||||
|
||||
} while (tokInputLeft());
|
||||
|
||||
mRes.scope->mStatements.reserve(stms.length());
|
||||
|
||||
ualni idx = 0;
|
||||
for (auto stm : stms) {
|
||||
mRes.scope->mStatements[idx] = stm.data();
|
||||
idx++;
|
||||
}
|
||||
|
||||
return mRes;
|
||||
}
|
||||
return { nullptr, scope };
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue