removed implementations of symbol table related classes, need to fix the parser to use the new AST node classes then i can write the symbol table classes and refactor the lexer and parser to use the symbol table

1 files changed, 0 insertions, 241 deletions

diff --git a/src/semantic_analyzer.cpp b/src/semantic_analyzer.cpp
deleted file mode 100644
index 6df7011..0000000
--- a/src/semantic_analyzer.cpp
+++ /dev/null
@@ -1,241 +0,0 @@
-#include "semantic_analyzer.hpp"
-
-bool SemanticAnalyzer::analyze(ASTNode* ast) {
-    symbol_table.enterScope("global")
-    visit(ast);
-    validateMainFunction();
-
-    if (has_main_function == false) {
-        //error
-        return false;
-    }
-
-    symbol_table.exitScope();
-    return true;
-}
-
-std::vector<Error> SemanticAnalyzer::getErrors() {
-    return errors;
-}
-
-std::vector<Error> SemanticAnalyzer::getWarnings() {
-    return warnings;
-}
-
-bool SemanticAnalyzer::hasErrors() {
-    return !errors.empty();
-}
-
-std::string SemanticAnalyzer::visit(ASTNode* node) {
-    if (ProgramNode* prog = dynamic_cast<ProgramNode*>(node)) {
-        return visitProgram(prog);
-    }
-
-    else if (FunctionDeclNode* func = dynamic_cast<FunctionDeclNode*>(node)) {
-        return visitFunctionDecl(func);
-    }
-
-    else if (ParameterNode* param = dynamic_cast<ParameterNode*>(node)) {
-        return visitParameter(param);
-    }
-
-    else if (VarDeclNode* var = dynamic_cast<VarDeclNode*>(node)) {
-        return visitVarDeclaration(var);
-    }
-
-    else if (AssignmentNode as = dynamic_cast<AssignmentNode>(node)) {
-        return visitAssignment(as);
-    }
-
-    else if (IfStatementNode is = dynamic_cast<IfStatementNode>(node)) {
-        return visitIfStatement(is);
-    }
-
-    else if (WhileStatementNode ws = dynamic_cast<WhileStatementNode>(node)) {
-        return visitWhileStatement(ws);
-    }
-
-    else if (ForStatementNode fs = dynamic_cast<ForStatementNode>(node)) {
-        return visitForStatement(fs);
-    }
-
-    else if (ReturnStatementNode rs = dynamic_cast<ReturnStatementNode>(node)) {
-        return visitReturnStatement(rs);
-    }
-
-    else if (ExpressionStatementNode es = dynamic_cast<ExpressionStatementNode>(node)) {
-        return visitExpressionStatement(es);
-    }
-
-    else if (BinaryExprNode bin = dynamic_cast<BinaryExprNode>(node)) {
-        return visitBinaryExpression(bin);
-    }
-
-    else if (UnaryExprNode un = dynamic_cast<UnaryExprNode>(node)) {
-        return visitUnaryExpression(un);
-    }
-
-    else if (FunctionCallNode func_call = dynamic_cast<FunctionCallNode>(node)) {
-        return visitFunctionCall(func_call);
-    }
-
-    else if (IdentifierNode ident = dynamic_cast<IdentifierNode>(node)) {
-        return visitIdentifier(ident);
-    }
-
-    else if (LiteralNode lit = dynamic_cast<LiteralNode>(node)) {
-        return visitLiteral(lit);
-    }
-}
-
-std::string visitProgram(ProgramNode* node){
-    // get list of functions
-    // visit each function
-    // return
-
-    std::vector<FunctionDeclarationNode*> functions = node->function_declarations;
-    for (auto element : functions) {
-	visitFunctionDeclaration(element);
-    };
-
-    return;
-}
-
-std::string visitFunctionDeclaration(FunctionDeclarationNode* node){
-    // check for dupe name
-    // create function symbol and insert into global scope
-    // check if main function
-    // enter function scope
-    // process parameters
-    // process function body
-    // verify non-void functions have return statements
-    // exit function scope and clear context
-    // return
-    
-    current_function = node;
-
-}
-
-std::string visitParameter(ParameterNode*){
-    // get parameter info from node
-    // check for dupes
-    // create parameter symbol
-    // insert into current scope
-    // return parameter type
-
-}
-
-std::string visitVariableDeclaration(VariableDeclarationNode* node){
-    // get variable information
-    // check for dupes
-    // if initializer exists, check type
-    // create variable symbol
-    // insert into current scope
-    // return
-
-}
-
-std::string visitAssignment(AssignmentNode* node){
-    // get left side info
-    // look up target variable
-    // verify variable
-    // analyze right side info
-    // check type compatability
-    // make var as initialized
-    // return
-
-}
-
-std::string visitIfStatement(IfStatementNode* node){
-    // analyze condition
-    // verify condition is bool
-    // analyze then branch
-    // analyze else branch
-    // return
-
-}
-
-std::string visitWhileStatement(WhileStatementNode* node){
-    // analyze condition
-    // verify condition is bool
-    // analyze loop body
-    // return
-
-}
-
-std::string visitForStatement(ForStatementNode* node){
-    // enter new scope for loop
-    // analyze initialization
-    // analyze condition
-    // analyze update statement
-    // analyze loop body
-    // exit for loop scope
-    // return 
-
-}
-
-std::string visitReturnStatement(ReturnStatementNode* node){
-    // check if inside function
-    // get return expression
-    // analyze return expression
-    // validate return type matches function
-    // return
-    
-}
-
-std::string visitExpressionStatement(ExpressionStatementNode* node){
-    // get the expression
-    // analyze expression
-    // return
-
-}
-
-std::string visitBinaryExpression(BinaryExprNode* node){
-    // get operator and operands
-    // analyze operands
-    // infer result type based on operator
-    // return result type
-
-}
-
-std::string visitUnaryExpression(UnaryExprNode* node){
-    // get operator and operand
-    // analyze operand
-    // infer result type
-    // return result type
-
-}
-
-std::string visitFunctionCall(FunctionCallNode* node){
-    // get function name and args
-    // look up function
-    // verify its a function
-    // get expected parameter information
-    // check argument count
-    // check each argument type
-    // return functions return type
-
-}
-
-std::string visitIdentifier(IdentifierNode* node){
-    // get identifier name
-    // look up in symbol table
-    // check if initialized
-    // return symbol type
-    
-}
-
-std::string visitLiteral(LiteralNode* node){
-    // determine literal type
-    // return appropriate type
-
-}
-
-bool checkTypeCompatibility(std::string target, std::string source){
-    // determines if a value of source type can be used where target type is expected
-
-}
-
-std::string inferBinaryOpType(std::string op, std::string left, std::string right){
-
-}