Skip to content

Commit d7c8f88

Browse files
wiktorkub1wiktorkub1
committed
Debug fixes with symbol table
1 parent 39b0db9 commit d7c8f88

File tree

6 files changed

+159
-25
lines changed

6 files changed

+159
-25
lines changed

‎interpreter/main.cpp‎

Lines changed: 1 addition & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -58,17 +58,7 @@ int main(int argc, char* argv[])
5858

5959
std::shared_ptr<AstNode> result = interpreter.interpret(tree);
6060

61-
// std::cout << "Variables:" << std::endl;
62-
63-
// for (const auto& [name, value] : GLOBAL_SCOPE) {
64-
// if (std::holds_alternative<int>(value)) {
65-
// std::cout << "[" << name << " = " << std::get<int>(value) << "]" << std::endl;
66-
// } else {
67-
// std::cout << "[" << name << " = " << std::get<float>(value) << "]" << std::endl;
68-
// }
69-
// }
70-
71-
std::cout << "Result node type: " << getTypeString(result->nodeType()) << std::endl;
61+
stRef.debugPrint();
7262

7363
return 0;
7464
}

‎interpreter/src/Ast.cpp‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -129,6 +129,8 @@ std::string getTypeString(NodeType nt)
129129
return "UNARY_OPERATOR";
130130
case NodeType::VARIABLE:
131131
return "VARIABLE";
132+
case NodeType::VARIABLE_DECLARATION:
133+
return "VARIABLE_DECLARATION";
132134
case NodeType::FUN_DECLARATION:
133135
return "FUN_DECLARATION";
134136
case NodeType::FUN_CALL:

‎interpreter/src/Ast.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -69,7 +69,7 @@ class AstNode
6969
virtual NodeType nodeType() const = 0;
7070
};
7171

72-
class Number : public AstNode // Can be bool
72+
class Number : public AstNode
7373
{
7474
public:
7575
Number(const Token& token) :

‎interpreter/src/Interpreter.cpp‎

Lines changed: 145 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -46,6 +46,59 @@ void st::SymbolTable::init()
4646
create(std::make_shared<BuiltInTypeSymbol>("BOOL_VALUE", SymbolVariableType::BOOL_VALUE));
4747
}
4848

49+
void st::SymbolTable::debugPrint()
50+
{
51+
for (const auto& [symbolName, symbolPtr] : _symbols) {
52+
if (!symbolPtr)
53+
continue;
54+
55+
std::cout << "Symbol Name: " << symbolName << "\n";
56+
std::cout << "Symbol Type: ";
57+
58+
switch (symbolPtr->symbolType()) {
59+
case SymbolType::SYMBOL:
60+
std::cout << "General Symbol\n";
61+
break;
62+
63+
case SymbolType::BUILT_IN_TYPE_SYMBOL: {
64+
std::cout << "Built-in Type Symbol\n";
65+
auto builtInTypeSymbol = std::dynamic_pointer_cast<BuiltInTypeSymbol>(symbolPtr);
66+
if (builtInTypeSymbol) {
67+
std::cout << "Type: " << static_cast<int>(builtInTypeSymbol->_type) << "\n";
68+
}
69+
break;
70+
}
71+
72+
case SymbolType::VARIABLE_SYMBOL: {
73+
std::cout << "Variable Symbol\n";
74+
auto variableSymbol = std::dynamic_pointer_cast<VariableSymbol>(symbolPtr);
75+
if (variableSymbol) {
76+
std::cout << "Type: " << variableSymbol->variableType->name() << "\n";
77+
std::cout << "Value: ";
78+
std::visit([](const auto& val) { std::cout << val; }, variableSymbol->variableValue);
79+
std::cout << "\n";
80+
}
81+
break;
82+
}
83+
84+
case SymbolType::FUNCTION_SYMBOL: {
85+
std::cout << "Function Symbol\n";
86+
auto functionSymbol = std::dynamic_pointer_cast<FunctionSymbol>(symbolPtr);
87+
if (functionSymbol) {
88+
std::cout << "Function Body Nodes: " << functionSymbol->body().size() << "\n";
89+
}
90+
break;
91+
}
92+
93+
default:
94+
std::cout << "Unknown Type\n";
95+
break;
96+
}
97+
98+
std::cout << "--------------------------\n";
99+
}
100+
}
101+
49102
void stNodeVisitor::operator()(BinaryOperation& node)
50103
{
51104
visit(getVariant(node.left()));
@@ -82,19 +135,37 @@ void stNodeVisitor::operator()(Assign& node)
82135

83136
void stNodeVisitor::operator()(VariableDeclaration& node)
84137
{
85-
std::shared_ptr<Variable> variable = std::dynamic_pointer_cast<Variable>(node.variable().value());
138+
if (node.variable().has_value()) {
139+
std::shared_ptr<Variable> variable = std::dynamic_pointer_cast<Variable>(node.variable().value());
86140

87-
const std::string variableName = variable->name();
141+
const std::string variableName = variable->name();
88142

89-
if (st.find(variableName)) {
90-
const std::string errorMessage = "Variable '" + variableName + "' already exists";
91-
throw std::runtime_error(errorMessage);
92-
}
143+
if (st.find(variableName)) {
144+
const std::string errorMessage = "Variable '" + variableName + "' already exists";
145+
throw std::runtime_error(errorMessage);
146+
}
147+
148+
const std::variant<int, float, bool> variableValue = variable->token().getFlexNumber();
149+
std::shared_ptr<st::Symbol> variableType = st.find(Token::typeToString(variable->token().getType()));
93150

94-
const std::variant<int, float, bool> variableValue = variable->token().getFlexNumber();
95-
std::shared_ptr<st::Symbol> variableType = st.find(Token::typeToString(variable->token().getType()));
151+
st.create(std::make_shared<st::VariableSymbol>(variableName, variableValue, variableType));
152+
} else {
153+
std::shared_ptr<Assign> assignment = std::dynamic_pointer_cast<Assign>(node.assignment().value());
154+
std::shared_ptr<Variable> variable = std::dynamic_pointer_cast<Variable>(assignment->left());
96155

97-
st.create(std::make_shared<st::VariableSymbol>(variableName, variableValue, variableType));
156+
const std::string variableName = variable->name();
157+
158+
if (st.find(variableName)) {
159+
const std::string errorMessage = "Variable '" + variableName + "' already exists";
160+
throw std::runtime_error(errorMessage);
161+
}
162+
163+
const std::variant<int, float, bool> variableValue = evaluateExpression(assignment->right());
164+
const std::string tokenType = getTokenTypeFromVariant(variableValue);
165+
std::shared_ptr<st::Symbol> variableType = st.find(tokenType);
166+
167+
st.create(std::make_shared<st::VariableSymbol>(variableName, variableValue, variableType));
168+
}
98169
}
99170

100171
void stNodeVisitor::operator()(Variable& variable)
@@ -170,6 +241,69 @@ void SymbolTableVisitNode::visit(NodeVariant astNode)
170241
return std::visit(SymbolTableVisitNode(st), astNode);
171242
}
172243

244+
std::variant<int, float, bool> stNodeVisitor::evaluateExpression(const std::shared_ptr<AstNode> node)
245+
{
246+
switch (node->nodeType()) {
247+
case NodeType::BINARY_OPERATION: {
248+
auto binaryOpNode = std::dynamic_pointer_cast<BinaryOperation>(node);
249+
250+
NodeVariant left = getVariant(binaryOpNode->left());
251+
NodeVariant right = getVariant(binaryOpNode->right());
252+
253+
TokenType tokenType = binaryOpNode->binaryOperator().getType();
254+
255+
return Interpreter::calculateBinaryResult(st, Interpreter::visitInterpret(left, st), Interpreter::visitInterpret(right, st), tokenType);
256+
}
257+
case NodeType::UNARY_OPERATOR: {
258+
auto unaryOpNode = std::dynamic_pointer_cast<UnaryOp>(node);
259+
260+
if (unaryOpNode->token().getType() == TokenType::PLUS) {
261+
return evaluateExpression(unaryOpNode->expr());
262+
} else if (unaryOpNode->token().getType() == TokenType::MINUS) {
263+
const std::variant<int, float, bool> variant = evaluateExpression(unaryOpNode->expr());
264+
if (std::holds_alternative<int>(variant)) {
265+
const int value = std::get<int>(variant);
266+
return -value;
267+
} else if (std::holds_alternative<float>(variant)) {
268+
const float value = std::get<float>(variant);
269+
return -value;
270+
} else if (std::holds_alternative<bool>(variant)) {
271+
throw std::runtime_error("Cannot add '-' sign to bool value");
272+
} else {
273+
throw std::runtime_error("Variant does not hold integer, float or bool inside, cannot return value of it");
274+
}
275+
} else {
276+
throw std::runtime_error("Token type in UnaryOp is netiher PLUS or MINUS");
277+
}
278+
}
279+
case NodeType::NUMBER: {
280+
auto numberNode = std::dynamic_pointer_cast<Number>(node);
281+
return numberNode->value();
282+
}
283+
case NodeType::VARIABLE: {
284+
auto variableNode = std::dynamic_pointer_cast<Variable>(node);
285+
return variableNode->token().getFlexNumber();
286+
}
287+
default: {
288+
const std::string msg = "Evaluating expression for type '" + std::to_string(static_cast<uint8_t>(node->nodeType())) + "' is not implemented";
289+
throw std::runtime_error(msg);
290+
}
291+
}
292+
}
293+
294+
std::string stNodeVisitor::getTokenTypeFromVariant(std::variant<int, float, bool> variant)
295+
{
296+
if (std::holds_alternative<int>(variant)) {
297+
return "INTEGER";
298+
} else if (std::holds_alternative<float>(variant)) {
299+
return "FLOATING_NUMBER";
300+
} else if (std::holds_alternative<bool>(variant)) {
301+
return "BOOL_VALUE";
302+
} else {
303+
throw std::runtime_error("Unknown variant in getTokenTypeFromVariant");
304+
}
305+
}
306+
173307
std::shared_ptr<AstNode> NodeVisitor::operator()(BinaryOperation& node)
174308
{
175309

@@ -449,6 +583,8 @@ std::shared_ptr<AstNode> Interpreter::buildTree(const std::string& text)
449583
{
450584
reset();
451585

586+
_symbolTable.init();
587+
452588
_parser = Parser(Lexer(text));
453589

454590
return _parser.parse();

‎interpreter/src/Interpreter.h‎

Lines changed: 9 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -36,7 +36,7 @@ class Symbol
3636

3737
virtual SymbolType symbolType() { return SymbolType::SYMBOL; }
3838

39-
protected:
39+
// protected:
4040
std::string _name;
4141
};
4242

@@ -51,7 +51,7 @@ class BuiltInTypeSymbol : public Symbol
5151

5252
SymbolType symbolType() override { return SymbolType::BUILT_IN_TYPE_SYMBOL; }
5353

54-
protected:
54+
// protected:
5555
SymbolVariableType _type;
5656
};
5757

@@ -86,7 +86,7 @@ class FunctionSymbol : public Symbol
8686

8787
std::vector<std::shared_ptr<AstNode>>& body() { return _function; }
8888

89-
protected:
89+
// protected:
9090
// std::string _functionName;
9191
std::vector<std::shared_ptr<AstNode>> _function;
9292
};
@@ -108,9 +108,12 @@ class SymbolTable
108108

109109
void init();
110110

111+
void debugPrint();
112+
111113
private:
112114
std::map<std::string, std::shared_ptr<Symbol>> _symbols;
113115
};
116+
114117
} // namespace st
115118

116119
// class InterpreterNodeVisitor
@@ -245,5 +248,8 @@ class SymbolTableVisitNode
245248

246249
void visit(NodeVariant astNode /*, st::SymbolTable& st*/);
247250

251+
std::variant<int, float, bool> evaluateExpression(const std::shared_ptr<AstNode> node);
252+
std::string getTokenTypeFromVariant(std::variant<int, float, bool> variant);
253+
248254
st::SymbolTable& st;
249255
};

‎interpreter/src/Parser.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -235,7 +235,7 @@ variableDeclaration : auto ID | auto assignmentStatement
235235
std::shared_ptr<AstNode> Parser::variableDeclaration()
236236
{
237237
eat(TokenType::VARIABLE_DECLARATION);
238-
if (_currentToken.getType() == TokenType::ASSIGN) {
238+
if (_currentToken.getType() == TokenType::ID) {
239239
auto assign = assignmentStatement();
240240
return std::make_shared<VariableDeclaration>(assign, true);
241241
} else {

0 commit comments

Comments
 (0)