Modules/Objects/private/parser/Bindings.cpp

#include "Private.hpp"

#include <parser/parser.h>

using namespace obj::BCgen;

typedef lalr::ParserNode<SymbolType> Node;

static UserData scope(const UserData* start, const Node* nodes, size_t length) { return start[1]; }

static UserData stm_list_append(const UserData* start, const Node* nodes, size_t length) {
	auto scope = (StatementScope*) start[0];
	auto stm = (Statement*) start[2];
	scope->mStatements.append(stm);
	return scope;
}

static UserData stm_list_create(const UserData* start, const Node* nodes, size_t length) {
	return new StatementScope({ (Statement*) start[0] }, true);
}

static UserData stm_log(const UserData* start, const Node* nodes, size_t length) {
	auto expr = (Expression*) (start[1]);
	return new StatementPrint(expr);
}

static UserData stm_assign(const UserData* start, const Node* nodes, size_t length) {
	return new StatementCopy((Expression*) start[0], (Expression*) start[2]);
}

static UserData stm_var_def_new_type(const UserData* start, const Node* nodes, size_t length) {
	return new StatementLocalDef((char*) nodes[1].lexeme().c_str(), new ExpressionNew((char*) nodes[3].lexeme().c_str()));
}

static UserData stm_var_def_assign(const UserData* start, const Node* nodes, size_t length) {
	return new StatementLocalDef((char*) nodes[1].lexeme().c_str(), (Expression*) start[3]);
}

static UserData expr_function(const UserData* start, const Node* nodes, size_t length) {
	auto expr = (Expression*) (start[0]);
	auto args = (ExpressionList*) (start[2]);
	return expr->ExprCall(args);
}

static UserData expr_method(const UserData* start, const Node* nodes, size_t length) {
	auto expr = (Expression*) (start[0]);
	auto args = (ExpressionList*) (start[4]);
	auto childId = nodes[1].lexeme();
	auto method = new ExpressionChild(expr, (char*) childId.c_str());
	return method->ExprCall(args);
}

static UserData expr_list_append(const UserData* start, const Node* nodes, size_t length) {
	auto list = (ExpressionList*) start[0];
	auto expr = (Expression*) start[2];
	list->mItems.append(expr);
	return list;
}

static UserData expr_list_create(const UserData* start, const Node* nodes, size_t length) {
	auto exprList = new ExpressionList();
	exprList->mItems.append((Expression*) start[0]);
	return exprList;
}

static UserData expr_child(const UserData* start, const Node* nodes, size_t length) {
	return new ExpressionChild((Expression*) start[0], (char*) nodes[2].lexeme().c_str());
}

static UserData expr_bool_eq(const UserData* start, const Node* nodes, size_t length) {
	return new ExpressionBoolean((Expression*) start[0], (Expression*) start[2], ExpressionBoolean::BoolType::EQUAL);
}

static UserData expr_bool_negate(const UserData* start, const Node* nodes, size_t length) {
	return new ExpressionBoolean((Expression*) start[1]);
}

static UserData expr_bool_neq(const UserData* start, const Node* nodes, size_t length) {
	return new ExpressionBoolean((Expression*) start[0], (Expression*) start[2], ExpressionBoolean::BoolType::NOT_EQUAL);
}

static UserData expr_bool_grater(const UserData* start, const Node* nodes, size_t length) {
	return new ExpressionBoolean((Expression*) start[0], (Expression*) start[2], ExpressionBoolean::BoolType::MORE);
}

static UserData expr_bool_lesser(const UserData* start, const Node* nodes, size_t length) {
	return new ExpressionBoolean((Expression*) start[0], (Expression*) start[2], ExpressionBoolean::BoolType::LESS);
}

static UserData expr_bool_grater_eq(const UserData* start, const Node* nodes, size_t length) {
	return new ExpressionBoolean(
		(Expression*) start[0], (Expression*) start[2], ExpressionBoolean::BoolType::EQUAL_OR_MORE
	);
}

static UserData expr_bool_lesser_eq(const UserData* start, const Node* nodes, size_t length) {
	return new ExpressionBoolean(
		(Expression*) start[0], (Expression*) start[2], ExpressionBoolean::BoolType::EQUAL_OR_LESS
	);
}

static UserData expr_add(const UserData* start, const Node* nodes, size_t length) {
	return new ExpressionAriphm((Expression*) start[0], (Expression*) start[2], obj::OpCode::OBJ_ADD);
}

static UserData expr_subtract(const UserData* start, const Node* nodes, size_t length) {
	return new ExpressionAriphm((Expression*) start[0], (Expression*) start[2], obj::OpCode::OBJ_SUB);
}

static UserData expr_multiply(const UserData* start, const Node* nodes, size_t length) {
	return new ExpressionAriphm((Expression*) start[0], (Expression*) start[2], obj::OpCode::OBJ_MUL);
}

static UserData expr_divide(const UserData* start, const Node* nodes, size_t length) {
	return new ExpressionAriphm((Expression*) start[0], (Expression*) start[2], obj::OpCode::OBJ_DIV);
}

static UserData expr_compound(const UserData* start, const Node* nodes, size_t length) { return start[1]; }

static UserData expr_bool(const UserData* start, const Node* nodes, size_t length) {
	return new ExpressionConst(nodes[0].lexeme() == "true");
}

static UserData expr_int(const UserData* start, const Node* nodes, size_t length) {
	return new ExpressionConst(stoi(nodes[0].lexeme()));
}

static UserData expr_float(const UserData* start, const Node* nodes, size_t length) {
	return new ExpressionConst(stof(nodes[0].lexeme()));
}

static UserData expr_string(const UserData* start, const Node* nodes, size_t length) {
	return new ExpressionConst((char*) nodes[0].lexeme().c_str());
}

static UserData expr_id(const UserData* start, const Node* nodes, size_t length) {
	return new ExpressionLocal((char*) nodes[0].lexeme().c_str());
}

static UserData tmp(const UserData* start, const Node* nodes, size_t length) {
	// a
	return *start;
}

#define BIND(name) parser.set_action_handler(#name, &(name));

void bind(LalrParser& parser) {
	BIND(scope);

	BIND(stm_list_append);
	BIND(stm_list_create);

	BIND(expr_list_append);
	BIND(expr_list_create);

	BIND(stm_var_def_new_type);
	BIND(stm_var_def_assign);
	BIND(stm_log);
	BIND(stm_assign);

	BIND(expr_function)
	BIND(expr_method)
	BIND(expr_child)
	BIND(expr_bool_eq)
	BIND(expr_bool_negate)
	BIND(expr_bool_neq)
	BIND(expr_bool_grater)
	BIND(expr_bool_lesser)
	BIND(expr_bool_grater_eq)
	BIND(expr_bool_lesser_eq)
	BIND(expr_add)
	BIND(expr_subtract)
	BIND(expr_multiply)
	BIND(expr_divide)
	BIND(expr_compound)
	BIND(expr_bool)
	BIND(expr_int)
	BIND(expr_float)
	BIND(expr_string)
	BIND(expr_id)

	BIND(tmp)

	parser.set_lexer_action_handler("string", &lalr::string_literal<IteratorType>);
}