Push all code
This commit is contained in:
MaxanRus
parent
347987bb66
commit
ba2bf4b404
10 changed files with 1671 additions and 0 deletions
680
src/syntax_tree.cpp
Normal file
680
src/syntax_tree.cpp
Normal file
|
|
@ -0,0 +1,680 @@
|
|||
#include <unordered_set>
|
||||
#include <stdexcept>
|
||||
#include <limits>
|
||||
#include <iostream>
|
||||
#include "syntax_tree.hpp"
|
||||
|
||||
using Type = Lexer::LexerToken::Type;
|
||||
|
||||
std::unordered_set<std::string> special_words = {"def"};
|
||||
|
||||
bool IsOperation(Type type) {
|
||||
switch (type) {
|
||||
case Type::Equal:
|
||||
case Type::Plus:
|
||||
case Type::Minus:
|
||||
case Type::Star:
|
||||
case Type::Slash:
|
||||
case Type::ExclamationMark:
|
||||
case Type::PlusEqual:
|
||||
case Type::MinusEqual:
|
||||
case Type::StarEqual:
|
||||
case Type::SlashEqual:
|
||||
case Type::EqualEqual:
|
||||
case Type::ExclamationMarkEqual:
|
||||
// case Type::PlusPlus:
|
||||
// case Type::MinusMinus:
|
||||
case Type::LAngle:
|
||||
case Type::RAngle:
|
||||
case Type::LAngleEqual:
|
||||
case Type::RAngleEqual:return true;
|
||||
default:return false;
|
||||
}
|
||||
}
|
||||
|
||||
void Node::Insert(Node* node) {
|
||||
node->previous = this;
|
||||
node->parent = parent;
|
||||
if (next) {
|
||||
next->previous = node;
|
||||
node->next = next;
|
||||
} else {
|
||||
if (parent) {
|
||||
dynamic_cast<Container*>(parent)->children_end = node;
|
||||
}
|
||||
}
|
||||
next = node;
|
||||
}
|
||||
|
||||
void Node::InsertBefore(Node* node) {
|
||||
node->next = this;
|
||||
node->parent = parent;
|
||||
if (previous) {
|
||||
previous->next = node;
|
||||
node->previous = previous;
|
||||
} else {
|
||||
if (parent) {
|
||||
dynamic_cast<Container*>(parent)->children_begin = node;
|
||||
}
|
||||
}
|
||||
previous = node;
|
||||
}
|
||||
|
||||
void Container::AddChildren(Node* node) {
|
||||
if (children_end) {
|
||||
children_end->next = node;
|
||||
node->previous = children_end;
|
||||
children_end = node;
|
||||
node->parent = this;
|
||||
} else {
|
||||
children_begin = children_end = node;
|
||||
node->parent = this;
|
||||
}
|
||||
}
|
||||
|
||||
size_t Expression::GetPriority(Operation op) {
|
||||
switch (op) {
|
||||
case Operation::Equal:
|
||||
case Operation::StarEqual:
|
||||
case Operation::SlashEqual:
|
||||
case Operation::PlusEqual:
|
||||
case Operation::MinusEqual:
|
||||
return 0;
|
||||
case Operation::EqualEqual:
|
||||
case Operation::ExclamationMarkEqual:
|
||||
return 6;
|
||||
case Operation::LAngle:
|
||||
case Operation::LAngleEqual:
|
||||
case Operation::RAngle:
|
||||
case Operation::RAngleEqual:
|
||||
return 7;
|
||||
case Operation::Plus:
|
||||
case Operation::Minus:
|
||||
return 9;
|
||||
case Operation::Star:
|
||||
case Operation::Slash:
|
||||
return 10;
|
||||
}
|
||||
throw std::logic_error("unsupported operator");
|
||||
}
|
||||
|
||||
Operation Expression::Convert(Lexer::LexerToken::Type type) {
|
||||
switch (type) {
|
||||
case Type::Equal:return Operation::Equal;
|
||||
case Type::LAngle:return Operation::LAngle;
|
||||
case Type::Plus:return Operation::Plus;
|
||||
case Type::Minus:return Operation::Minus;
|
||||
case Type::Star:return Operation::Star;
|
||||
case Type::Slash:return Operation::Slash;
|
||||
case Type::ExclamationMark:return Operation::ExclamationMark;
|
||||
case Type::PlusEqual:return Operation::PlusEqual;
|
||||
case Type::MinusEqual:return Operation::MinusEqual;
|
||||
case Type::StarEqual:return Operation::StarEqual;
|
||||
case Type::SlashEqual:return Operation::SlashEqual;
|
||||
case Type::EqualEqual:return Operation::EqualEqual;
|
||||
case Type::ExclamationMarkEqual:return Operation::ExclamationMarkEqual;
|
||||
// case Type::PlusPlus:
|
||||
// case Type::MinusMinus:
|
||||
case Type::RAngle:return Operation::RAngle;
|
||||
case Type::LAngleEqual:return Operation::LAngleEqual;
|
||||
case Type::RAngleEqual:return Operation::RAngleEqual;
|
||||
}
|
||||
std::cerr << std::to_string(type) << std::endl;
|
||||
throw std::logic_error("unsupported operator");
|
||||
}
|
||||
|
||||
PriorityType Expression::GetPriorityType(Operation op) {
|
||||
switch (op) {
|
||||
case Operation::Equal:
|
||||
case Operation::StarEqual:
|
||||
case Operation::SlashEqual:
|
||||
case Operation::PlusEqual:
|
||||
case Operation::MinusEqual:
|
||||
return PriorityType::R;
|
||||
case Operation::EqualEqual:
|
||||
case Operation::ExclamationMarkEqual:
|
||||
case Operation::LAngle:
|
||||
case Operation::LAngleEqual:
|
||||
case Operation::RAngle:
|
||||
case Operation::RAngleEqual:
|
||||
case Operation::Plus:
|
||||
case Operation::Minus:
|
||||
case Operation::Star:
|
||||
case Operation::Slash:
|
||||
return PriorityType::L;
|
||||
}
|
||||
|
||||
throw std::logic_error("unsupported operator");
|
||||
}
|
||||
|
||||
bool SyntaxTree::IsTypeName(Node* node, const std::string& str) {
|
||||
return str == "int" || str == "string";
|
||||
}
|
||||
|
||||
bool SyntaxTree::IsVariableName(Node* node, const std::string& name) {
|
||||
while (node) {
|
||||
if (auto var = dynamic_cast<Variable*>(node)) {
|
||||
if (var->name == name) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
if (node->previous) {
|
||||
node = node->previous;
|
||||
} else {
|
||||
node = node->parent;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool SyntaxTree::IsFunctionName(Node*, const std::string& str) {
|
||||
return str == "print";
|
||||
}
|
||||
|
||||
void SyntaxTree::PushLexerTokenList(const LexerTokenList& list) {
|
||||
if (!tree_) {
|
||||
tree_ = new CodeBlock();
|
||||
}
|
||||
for (auto it = list.begin(); it != list.end(); ++it) {
|
||||
PushLine(tree_, list, it);
|
||||
}
|
||||
}
|
||||
|
||||
CodeBlock* SyntaxTree::ParseCurlyBrackets(Container* container,
|
||||
const LexerTokenList& list,
|
||||
LexerTokenList::const_iterator& it) {
|
||||
auto* current = new CodeBlock();
|
||||
current->previous = container->children_end;
|
||||
current->parent = container;
|
||||
|
||||
for (; it->type != Type::CurlyCloseBracket; ++it) {
|
||||
PushLine(current, list, it);
|
||||
}
|
||||
return current;
|
||||
}
|
||||
|
||||
void SyntaxTree::PushCurlyBrackets(Container* container, const LexerTokenList& list,
|
||||
LexerTokenList::const_iterator& it) {
|
||||
container->AddChildren(ParseCurlyBrackets(container, list, it));
|
||||
}
|
||||
|
||||
/*
|
||||
void SyntaxTree::PushRoundBrackets(Container* container, const LexerTokenList& list,
|
||||
LexerTokenList::const_iterator& it) {
|
||||
RoundBrackets* current = new RoundBrackets();
|
||||
container->AddChildren(current);
|
||||
|
||||
for (; it->type != Type::RoundCloseBracket; ++it) {
|
||||
if (it->type == Type::Word) {
|
||||
if (IsTypeName(container->children_end, it->info)) {
|
||||
std::string type = it->info;
|
||||
++it;
|
||||
if (it->type == Type::Word) {
|
||||
container->AddChildren(new Variable(std::move(type), it->info));
|
||||
}
|
||||
} else if (IsVariableName(container->children_end, it->info)) {
|
||||
++it;
|
||||
// TODO
|
||||
}
|
||||
} else {
|
||||
throw std::logic_error("I expected type or name");
|
||||
}
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
/*
|
||||
void SyntaxTree::PushFunction(Container* container, const LexerTokenList& list,
|
||||
LexerTokenList::const_iterator& it) {
|
||||
if (it->type == Type::Word && !IsSpecialWord(it->info)) {
|
||||
auto func = new Function(it->info);
|
||||
++it;
|
||||
if (it->type == Type::RoundOpenBracket) {
|
||||
PushRoundBrackets(func->parameters, list, ++it);
|
||||
++it;
|
||||
if (it->type == Type::RArrow) {
|
||||
++it;
|
||||
if (it->type == Type::Word && IsTypeName(container->children_end, it->info)) {
|
||||
++it;
|
||||
if (it->type == Type::CurlyOpenBracket) {
|
||||
PushCurlyBrackets(func->code, list, ++it);
|
||||
container->AddChildren(func);
|
||||
} else {
|
||||
throw std::logic_error("Invalid function body");
|
||||
}
|
||||
} else {
|
||||
throw std::logic_error("Invalit return type");
|
||||
}
|
||||
} else {
|
||||
throw std::logic_error("Missing -> in function");
|
||||
}
|
||||
} else {
|
||||
throw std::logic_error("Invalid function parameters");
|
||||
}
|
||||
} else {
|
||||
throw std::logic_error("Invalid function name");
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
void SyntaxTree::PushLine(Container* container, const LexerTokenList& list,
|
||||
LexerTokenList::const_iterator& it) {
|
||||
if (it->type == Type::CurlyOpenBracket) {
|
||||
PushCurlyBrackets(container, list, ++it);
|
||||
} else if (it->type == Type::RoundOpenBracket) {
|
||||
PushExpression(container, list, it);
|
||||
// PushRoundBrackets(container, list, ++it);
|
||||
} else if (it->type == Type::IF) {
|
||||
PushIF(container, list, it);
|
||||
} else if (it->type == Type::FOR) {
|
||||
PushFOR(container, list, it);
|
||||
} else if (it->type == Type::WHILE) {
|
||||
PushWHILE(container, list, it);
|
||||
} else if (it->type == Type::Word) {
|
||||
auto place = container->children_end;
|
||||
if (!place)
|
||||
place = container;
|
||||
if (it->info == "def") {
|
||||
// PushFunction(container, list, ++it);
|
||||
} else if (IsTypeName(place, it->info)) {
|
||||
PushNewVariable(container, list, it);
|
||||
} else if (IsVariableName(place, it->info)) {
|
||||
PushExpression(container, list, it);
|
||||
} else if (IsFunctionName(place, it->info)) {
|
||||
PushCallFunction(container, list, it);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Variable* SyntaxTree::ParseNewVariable(const LexerTokenList& list, LexerTokenList::const_iterator& it) {
|
||||
std::string type = it->info;
|
||||
++it;
|
||||
if (it->type == Type::Word) {
|
||||
auto var = new Variable(std::move(type), it->info);
|
||||
++it;
|
||||
if (it->type == Type::Semicolon)
|
||||
return var;
|
||||
if (it->type == Type::Equal) {
|
||||
--it;
|
||||
var->default_value = ParseExpression(list, it);
|
||||
if (it->type == Type::Semicolon) {
|
||||
return var;
|
||||
} else {
|
||||
throw std::logic_error("Expected ;");
|
||||
}
|
||||
} else {
|
||||
throw std::logic_error("Expected =");
|
||||
}
|
||||
} else {
|
||||
throw std::logic_error("Expected variable name");
|
||||
}
|
||||
}
|
||||
|
||||
void SyntaxTree::PushNewVariable(Container* container, const LexerTokenList& list, LexerTokenList::const_iterator& it) {
|
||||
container->AddChildren(ParseNewVariable(list, it));
|
||||
}
|
||||
|
||||
void SyntaxTree::PushExpression(Container* container, const LexerTokenList& list, LexerTokenList::const_iterator& it) {
|
||||
container->AddChildren(ParseExpression(list, it));
|
||||
}
|
||||
|
||||
void SyntaxTree::PushParametersFunction(CallFunction* call_function,
|
||||
const LexerTokenList& list,
|
||||
LexerTokenList::const_iterator& it) {
|
||||
if (it->type != Type::RoundOpenBracket) {
|
||||
throw std::logic_error("expected ( after function name");
|
||||
}
|
||||
while (it->type != Type::RoundCloseBracket) {
|
||||
auto expr = ParseExpression(list, ++it);
|
||||
call_function->parameters.push_back(new Expression(new Expression((size_t) 0, nullptr, Operation::Value),
|
||||
expr,
|
||||
Operation::Equal));
|
||||
auto& t = call_function->parameters.back();
|
||||
t->parent = call_function;
|
||||
std::get<Expression*>(t->type1)->parent = t;
|
||||
std::get<Expression*>(t->type2)->parent = t;
|
||||
}
|
||||
for (size_t i = 0; i < call_function->parameters.size(); ++i) {
|
||||
std::get<Expression*>(call_function->parameters[i]->type1)->type1 = call_function->parameters.size() - i;
|
||||
}
|
||||
++it;
|
||||
}
|
||||
|
||||
void SyntaxTree::PushCallFunction(Container* container,
|
||||
const LexerTokenList& list,
|
||||
LexerTokenList::const_iterator& it) {
|
||||
auto function = new CallFunction(it->info);
|
||||
PushParametersFunction(function, list, ++it);
|
||||
container->AddChildren(new CreateVariables(function->parameters.size()));
|
||||
container->AddChildren(function);
|
||||
container->AddChildren(new HiddenDeallocateStack(function->parameters.size()));
|
||||
}
|
||||
|
||||
void SyntaxTree::PushFOR(Container* container,
|
||||
const LexerTokenList& list,
|
||||
std::list<Lexer::LexerToken>::const_iterator& it) {
|
||||
auto c = new Container;
|
||||
auto f = new FOR();
|
||||
container->AddChildren(c);
|
||||
PushSignatureFOR(f, list, ++it);
|
||||
c->AddChildren(f->var);
|
||||
c->AddChildren(f);
|
||||
if (it->type != Type::CurlyOpenBracket) {
|
||||
throw std::logic_error("expected { after for (...)");
|
||||
}
|
||||
f->code = ParseCurlyBrackets(c, list, ++it);
|
||||
f->code->parent = f;
|
||||
f->code->previous = nullptr;
|
||||
}
|
||||
|
||||
void SyntaxTree::PushSignatureFOR(FOR* node_for,
|
||||
const LexerTokenList& list,
|
||||
std::list<Lexer::LexerToken>::const_iterator& it) {
|
||||
if (it->type != Type::RoundOpenBracket)
|
||||
throw std::logic_error("expected ( after for");
|
||||
++it;
|
||||
if (it->type == Type::Semicolon) {
|
||||
++it;
|
||||
} else {
|
||||
if (it->type != Type::Word || !IsTypeName(node_for, it->info)) {
|
||||
throw std::logic_error("expected type after for (");
|
||||
}
|
||||
node_for->var = ParseNewVariable(list, it);
|
||||
node_for->var->parent = node_for;
|
||||
|
||||
if (it->type != Type::Semicolon) {
|
||||
throw std::logic_error("expected ; after for ( type name");
|
||||
}
|
||||
++it;
|
||||
}
|
||||
if (it->type == Type::Semicolon) {
|
||||
++it;
|
||||
} else {
|
||||
node_for->check = ParseExpression(list, it);
|
||||
node_for->check->parent = node_for;
|
||||
if (it->type != Type::Semicolon) {
|
||||
throw std::logic_error("expected ; after for ( type name; expr");
|
||||
}
|
||||
++it;
|
||||
}
|
||||
if (it->type == Type::RoundCloseBracket) {
|
||||
} else {
|
||||
node_for->tick = ParseExpression(list, it);
|
||||
node_for->tick->parent = node_for;
|
||||
if (it->type != Type::RoundCloseBracket) {
|
||||
throw std::logic_error("expected ) after for ( type name; expr; expr");
|
||||
}
|
||||
++it;
|
||||
}
|
||||
}
|
||||
|
||||
void SyntaxTree::PushIF(Container* container,
|
||||
const LexerTokenList& list,
|
||||
std::list<Lexer::LexerToken>::const_iterator& it) {
|
||||
auto f = new IF();
|
||||
container->AddChildren(f);
|
||||
PushSignatureIF(f, list, ++it);
|
||||
f->check->parent = f;
|
||||
if (it->type != Type::CurlyOpenBracket) {
|
||||
throw std::logic_error("expected { after if (...)");
|
||||
}
|
||||
f->code = ParseCurlyBrackets(container, list, ++it);
|
||||
f->code->parent = f;
|
||||
}
|
||||
|
||||
void SyntaxTree::PushSignatureIF(IF* node_if,
|
||||
const LexerTokenList& list,
|
||||
std::list<Lexer::LexerToken>::const_iterator& it) {
|
||||
if (it->type != Type::RoundOpenBracket)
|
||||
throw std::logic_error("expected ( after if");
|
||||
++it;
|
||||
node_if->check = ParseExpression(list, it);
|
||||
node_if->check->parent = node_if;
|
||||
if (it->type != Type::RoundCloseBracket) {
|
||||
throw std::logic_error("expected ) after if(...");
|
||||
}
|
||||
++it;
|
||||
}
|
||||
|
||||
void SyntaxTree::PushWHILE(Container* container,
|
||||
const LexerTokenList& list,
|
||||
std::list<Lexer::LexerToken>::const_iterator& it) {
|
||||
auto f = new WHILE();
|
||||
container->AddChildren(f);
|
||||
PushSignatureWHILE(f, list, ++it);
|
||||
if (it->type != Type::CurlyOpenBracket) {
|
||||
throw std::logic_error("expected { after while (...)");
|
||||
}
|
||||
f->code = ParseCurlyBrackets(container, list, ++it);
|
||||
}
|
||||
|
||||
void SyntaxTree::PushSignatureWHILE(WHILE* node_if,
|
||||
const LexerTokenList& list,
|
||||
std::list<Lexer::LexerToken>::const_iterator& it) {
|
||||
if (it->type != Type::RoundOpenBracket)
|
||||
throw std::logic_error("expected ( after while");
|
||||
++it;
|
||||
node_if->check = ParseExpression(list, it);
|
||||
node_if->check->parent = node_if;
|
||||
if (it->type != Type::RoundCloseBracket) {
|
||||
throw std::logic_error("expected ) after while(...");
|
||||
}
|
||||
++it;
|
||||
}
|
||||
|
||||
Expression* SyntaxTree::ParseExpression(LexerTokenList::const_iterator l, LexerTokenList::const_iterator r) {
|
||||
if (std::next(l) == r) {
|
||||
return new Expression(l->info, nullptr, Operation::Value);
|
||||
}
|
||||
{
|
||||
auto it = l;
|
||||
if (it->type == Type::RoundOpenBracket) {
|
||||
int balance = 1;
|
||||
do {
|
||||
++it;
|
||||
if (it->type == Type::RoundOpenBracket) {
|
||||
++balance;
|
||||
} else if (it->type == Type::RoundCloseBracket) {
|
||||
--balance;
|
||||
}
|
||||
} while (balance != 0);
|
||||
}
|
||||
++it;
|
||||
if (it == r) {
|
||||
return ParseExpression(std::next(l), std::prev(r));
|
||||
}
|
||||
}
|
||||
auto mid = l;
|
||||
size_t current_priority = std::numeric_limits<size_t>::max();
|
||||
for (auto it = l; std::next(it) != r; ++it) {
|
||||
if (it->type == Type::RoundOpenBracket) {
|
||||
int balance = 1;
|
||||
do {
|
||||
++it;
|
||||
if (it->type == Type::RoundOpenBracket) {
|
||||
++balance;
|
||||
} else if (it->type == Type::RoundCloseBracket) {
|
||||
--balance;
|
||||
}
|
||||
} while (balance != 0);
|
||||
}
|
||||
++it;
|
||||
|
||||
size_t tmp = Expression::GetPriority(Expression::Convert(it->type));
|
||||
if (tmp < current_priority) {
|
||||
mid = it;
|
||||
current_priority = tmp;
|
||||
} else if (tmp == current_priority) {
|
||||
if (Expression::GetPriorityType(Expression::Convert(it->type)) == PriorityType::R) {
|
||||
mid = it;
|
||||
}
|
||||
}
|
||||
}
|
||||
return new Expression(ParseExpression(l, mid), ParseExpression(std::next(mid), r), Expression::Convert(mid->type));
|
||||
}
|
||||
|
||||
Expression* SyntaxTree::ParseExpression(const LexerTokenList& list,
|
||||
std::list<Lexer::LexerToken>::const_iterator& it) {
|
||||
auto l = it;
|
||||
int balance = 0;
|
||||
while (it->type == Type::Word || IsOperation(it->type) || it->type == Type::StringLiteral
|
||||
|| it->type == Type::RoundOpenBracket || it->type == Type::RoundCloseBracket) {
|
||||
if (it->type == Type::RoundOpenBracket) {
|
||||
++balance;
|
||||
} else if (it->type == Type::RoundCloseBracket) {
|
||||
if (balance == 0) {
|
||||
break;
|
||||
} else {
|
||||
--balance;
|
||||
}
|
||||
}
|
||||
++it;
|
||||
}
|
||||
return ParseExpression(l, it);
|
||||
}
|
||||
|
||||
void SyntaxTree::PushDeallocateStack(Node* node, size_t count_variables = 0) {
|
||||
if (auto code_block = dynamic_cast<Container*>(node)) {
|
||||
if (code_block->children_begin) {
|
||||
PushDeallocateStack(code_block->children_begin);
|
||||
}
|
||||
}
|
||||
if (auto if_ = dynamic_cast<IF*>(node)) {
|
||||
PushDeallocateStack(if_->code);
|
||||
}
|
||||
if (auto for_ = dynamic_cast<FOR*>(node)) {
|
||||
PushDeallocateStack(for_->code);
|
||||
}
|
||||
if (dynamic_cast<Variable*>(node)) {
|
||||
++count_variables;
|
||||
}
|
||||
if (auto expr = dynamic_cast<Expression*>(node)) {
|
||||
node->Insert(new DeallocateStack(1));
|
||||
}
|
||||
if (node->next) {
|
||||
PushDeallocateStack(node->next, count_variables);
|
||||
} else {
|
||||
if (count_variables) {
|
||||
node->Insert(new DeallocateStack(count_variables));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void SyntaxTree::Compile() {
|
||||
PushDeallocateStack(tree_);
|
||||
LinkVariables(tree_);
|
||||
}
|
||||
|
||||
void SyntaxTree::Run() {
|
||||
std::vector<std::shared_ptr<VariableInStack>> stack;
|
||||
tree_->Run(stack);
|
||||
}
|
||||
|
||||
void SyntaxTree::LinkVariables(Node* node) {
|
||||
while (node) {
|
||||
if (auto expr = dynamic_cast<Expression*>(node)) {
|
||||
LinkVariablesInExpression(expr, node);
|
||||
}
|
||||
if (auto var = dynamic_cast<Variable*>(node)) {
|
||||
if (var->default_value) {
|
||||
LinkVariablesInExpression(var->default_value, node);
|
||||
}
|
||||
}
|
||||
if (auto if_ = dynamic_cast<IF*>(node)) {
|
||||
LinkVariablesInExpression(if_->check, node);
|
||||
LinkVariables(if_->code->children_begin);
|
||||
}
|
||||
if (auto while_ = dynamic_cast<WHILE*>(node)) {
|
||||
LinkVariablesInExpression(while_->check, node);
|
||||
LinkVariables(while_->code->children_begin);
|
||||
}
|
||||
if (auto for_ = dynamic_cast<FOR*>(node)) {
|
||||
LinkVariablesInExpression(for_->check, node);
|
||||
LinkVariablesInExpression(for_->tick, node);
|
||||
LinkVariables(for_->code->children_begin);
|
||||
}
|
||||
if (auto call_function = dynamic_cast<CallFunction*>(node)) {
|
||||
for (auto i: call_function->parameters) {
|
||||
LinkVariablesInExpression(i, node);
|
||||
}
|
||||
}
|
||||
if (auto container = dynamic_cast<Container*>(node)) {
|
||||
LinkVariables(container->children_begin);
|
||||
}
|
||||
node = node->next;
|
||||
}
|
||||
}
|
||||
|
||||
stack_pointer SyntaxTree::GetCountStackOffsetForVariable(Node* node, std::string name) {
|
||||
stack_pointer result = 0;
|
||||
while (node) {
|
||||
if (auto var = dynamic_cast<Variable*>(node)) {
|
||||
result += 1;
|
||||
if (var->name == name) {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
if (auto vars = dynamic_cast<CreateVariables*>(node)) {
|
||||
result += vars->count;
|
||||
}
|
||||
if (auto vars = dynamic_cast<HiddenDeallocateStack*>(node)) {
|
||||
result -= vars->count;
|
||||
}
|
||||
if (node->previous) {
|
||||
node = node->previous;
|
||||
} else {
|
||||
node = node->parent;
|
||||
}
|
||||
}
|
||||
return std::numeric_limits<stack_pointer>::max();
|
||||
}
|
||||
|
||||
void SyntaxTree::LinkVariablesInExpression(Expression* expression, Node* node) {
|
||||
if (expression->op == Operation::Value) {
|
||||
if (std::holds_alternative<std::string>(expression->type1)) {
|
||||
auto& var = std::get<std::string>(expression->type1);
|
||||
stack_pointer offset = GetCountStackOffsetForVariable(node, var);
|
||||
if (offset != std::numeric_limits<stack_pointer>::max()) {
|
||||
expression->type1 = offset;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
LinkVariablesInExpression(std::get<Expression*>(expression->type1), node);
|
||||
LinkVariablesInExpression(std::get<Expression*>(expression->type2), node);
|
||||
}
|
||||
}
|
||||
|
||||
void CallFunction::Run(std::vector<std::shared_ptr<VariableInStack>>& stack) {
|
||||
for (size_t i = 0; i < parameters.size(); ++i) {
|
||||
stack.push_back(std::make_shared<VariableInStack>(TypeVariable()));
|
||||
// stack.back().Allocate();
|
||||
}
|
||||
for (auto i: parameters) {
|
||||
i->Run(stack);
|
||||
stack.pop_back();
|
||||
}
|
||||
if (name_function == "print") {
|
||||
for (size_t i = 0; i < parameters.size(); ++i) {
|
||||
std::shared_ptr<VariableInStack>& t = *(stack.end() - parameters.size() + i);
|
||||
if (t->type_variable.id == TypeVariable::ID::type_int) {
|
||||
std::cout << *((int*) t->memory) << " ";
|
||||
} else if (t->type_variable.id == TypeVariable::ID::type_string) {
|
||||
std::cout << *((std::string*) t->memory) << " ";
|
||||
}
|
||||
}
|
||||
std::cout << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
void Variable::Run(std::vector<std::shared_ptr<VariableInStack>>& stack) {
|
||||
if (type == "int") {
|
||||
stack.push_back(std::make_shared<VariableInStack>(TypeVariable(TypeVariable::ID::type_int)));
|
||||
} else if (type == "string") {
|
||||
stack.push_back(std::make_shared<VariableInStack>(TypeVariable(TypeVariable::ID::type_string)));
|
||||
}
|
||||
stack.back()->Allocate();
|
||||
if (default_value) {
|
||||
default_value->Run(stack);
|
||||
stack.pop_back();
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue