Merge pull request #2 from Pip-Install-Party/officialblake-develop

continue logic

Author: officialblake

Makefile

@@ -1,5 +1,5 @@
-table.x: main.o commentDFA.o tokenizer.o parser.o table.o
-	g++ -std=c++17 -g main.o commentDFA.o tokenizer.o parser.o table.o -o table.x
+tree.x: main.o commentDFA.o tokenizer.o parser.o table.o tree.o
+	g++ -std=c++17 -g main.o commentDFA.o tokenizer.o parser.o table.o tree.o -o tree.x
 
 main.o: main.cpp commentDFA.h tokenizer.h parser.h testFiles.h
 	g++ -std=c++17 -g main.cpp -o main.o -c
@@ -16,5 +16,8 @@ parser.o: parser.cpp parser.h
 table.o: table.cpp table.h
 	g++ -std=c++17 -g table.cpp -o table.o -c
 
+tree.o: tree.cpp tree.h
+	g++ -std=c++17 -g tree.cpp -o tree.o -c
+
 clean:
-	rm -f table.x *.o *.txt
+	rm -f tree.x *.o *.txt

main.cpp

@@ -8,6 +8,7 @@
 #include "tokenizer.h"
 #include "parser.h"
 #include "table.h"
+#include "tree.h"
 
 #include "testFiles.h"
 
@@ -86,11 +87,29 @@ void symbolTable(std::ifstream& testFile, std::ostringstream& outputFile, int) {
     table->printParameters();
 }
 
+void abstractSyntaxTree(std::ifstream& testFile, std::ostringstream& outputFile, int filenum) {
+    CommentDFA *removeComments = new CommentDFA();
+    std::ostringstream tempBuffer;
+    removeComments->begin(testFile, tempBuffer);
+
+    Tokenizer *tokenizer = new Tokenizer();
+    std::istringstream tokenStream(tempBuffer.str());
+    tokenizer->begin(tokenStream);
+    std::vector<Token> tokenList = tokenizer->getTokens();
+
+    Parser *parser = new Parser(tokenList);
+    parser->begin();
+
+    Tree* tree = new Tree(parser->getHead());
+
+}
+
 const assignmentElements assignments[] = {
     {1, a1Tests, std::size(a1Tests), removeComments},
     {2, a2Tests, std::size(a2Tests), tokenize},
     {3, a3Tests, std::size(a3Tests), parse},
-    {4, a4Tests, std::size(a4Tests), symbolTable}
+    {4, a4Tests, std::size(a4Tests), symbolTable},
+    {5, a5Tests, std::size(a5Tests), abstractSyntaxTree}
 };
 
 // chooses test file based on user selection and includes error messages
@@ -113,10 +132,11 @@ int main() {
               << "2 - Tokenize\n"
               << "3 - Parse\n"
               << "4 - Symbol Table\n"
+              << "5 - Abstract Syntax Tree\n"
               << "Selection: ";
     std::cin >> assignmentNum;
 
-    if (assignmentNum < 1 || assignmentNum > 4) {
+    if (assignmentNum < 1 || assignmentNum > 5) {
         std::cerr << "Invalid assignment choice. Exiting.\n";
         return 1;
     }

testFiles.h

@@ -48,4 +48,13 @@ const std::filesystem::path a4Tests[] = {
     "Tests/Program4/programming_assignment_4-test_file_7.c"
 }; 
 
+// Assignment 5
+const std::filesystem::path a5Tests[] = {
+    "Tests/Program5/programming_assignment_5-test_file_1.c",
+    "Tests/Program5/programming_assignment_5-test_file_2.c",
+    "Tests/Program5/programming_assignment_5-test_file_3.c",
+    "Tests/Program5/programming_assignment_5-test_file_4.c",
+    "Tests/Program5/programming_assignment_5-test_file_5.c",
+}; 
+
 #endif // TESTFILES_H

tree.cpp

@@ -1,40 +1,146 @@
 #include "tree.h"
 
 // Prints the abstract syntax tree to the provided output stream
-void Tree::printTree(Token* head){
+void Tree::printTree(Token* head, Token* prevToken){
+    bool ignore = true;
     if (head == nullptr){
         return;
     }
     if (head->getValue() == "{") {
+        ignore = false;
         std::cout << "BEGIN BLOCK";
     } else if (head->getValue() == "}") {
+        ignore = false;
         std::cout << "END BLOCK";
     } else if (head->getValue() == "procedure" || head->getValue() == "function") {
+        std::cout << "DECLARATION\n|\n|\n|\n|\nv\n";
+        while(head->getSibling() != nullptr) {
+            head = head->getSibling();
+        }
+    } else if (head->getValue() == "if"){
+         ignore = false;
+        std::cout << "IF ----> ";
+        // This needs to break out to handleAssignment();
+        head = head->getSibling();
+        head = handleAssignment(head); 
+        prevToken = nullptr;
+        
+    }else if (contains(varTypes, prevToken->getValue())) {
+        ignore = false;
         std::cout << "DECLARATION";
-    } else if (contains(head->getValue())) {
-        std::cout << "DECLARATION";
+        if (head->getSibling() != nullptr && head->getSibling()->getValue() == ",") {
+            while(head->getSibling() != nullptr) {
+                head = head->getSibling();
+                if (head->getType() == "IDENTIFIER") {
+                    std::cout << "\n|\n|\n|\n|\nv\nDECLARATION";
+                }
+            }
+        }
     } else if (head->getType() == "IDENTIFIER") {
         if (head->getSibling() != nullptr && head->getSibling()->getValue() == "=") {
-            std::cout << "ASSIGNMENT" << " ----> " << head->getValue();
+            ignore = false;
+            std::cout << "ASSIGNMENT" << " ----> ";
             // This needs to break out to handleAssignment();
-            // head = handleAssignment(); 
-        }
-    }
+             head = handleAssignment(head); 
+             prevToken = nullptr;
+        } 
+    } 
     if (head->getSibling() != nullptr) {
-        head = head->getSibling();
-        std::cout << " ----> ";
+        if (!ignore){
+            std::cout << " ----> ";
+            std::cout << head->getValue();
+        }
+        return printTree(head->getSibling(), head);
     } else if (head->getChild() != nullptr) {
-        head = head->getChild();
-        std::cout << "\n|\n|\n|\n|\nv ";
-    }
-    return printTree(head);
+        if (!ignore) {
+            std::cout << "\n|\n|\n|\n|\nv\n ";
+        }
+        return printTree(head->getChild(), head);
+    } 
+    return;
 }
 
-bool contains(std::string type){
-    for (const auto& reserved : varTypes) {
-        if (type == reserved) {
+bool Tree::contains(const std::vector<std::string> reserved, std::string type){
+    for (const auto& word : reserved) {
+        if (type == word) {
             return true;
         }
     }
     return false;
+}
+
+Token* Tree::handleAssignment(Token* head) {
+    std::string equationAsString;
+    equationAsString += head->getValue();
+    head = head->getSibling();
+
+    while(contains(equationOperators, head->getValue()) || head->getType() == "IDENTIFIER" || head->getType() == "INTEGER" || head->getType() == "CHARACTER") {
+        equationAsString += head->getValue();
+        if (head ->getSibling() != nullptr) {
+            head = head->getSibling();
+        } else {
+            break;
+        }
+    } 
+        //head = head->getSibling(); // Remove ?
+
+    for (char ch : infixToPostfix(equationAsString)) {
+     //   std::cout << ch << " ----> ";
+    }
+    std::cout << "Postfix Expression";
+    return head;
+}
+
+
+// Function to get precedence of operators
+int Tree::getPrecedence(char op) {
+    if (op == '+' || op == '-') return 1;
+    if (op == '*' || op == '/') return 2;
+    return 0;
+}
+
+// Function to check if a character is an operator
+bool Tree::isOperator(char c) {
+    return c == '+' || c == '-' || c == '*' || c == '/';
+}
+
+// Function to convert infix expression to postfix
+std::string Tree::infixToPostfix(const std::string& infix) {
+    std::stack<char> operators;
+    std::string postfix;
+
+    for (char c : infix) {
+        // If the character is an operand, add it to postfix output
+        if (std::isdigit(c) || std::isalpha(c)) {
+            postfix += c;
+        }
+        // If the character is '(', push it onto the stack
+        else if (c == '(') {
+            operators.push(c);
+        }
+        // If the character is ')', pop and add operators until '(' is found
+        else if (c == ')') {
+            while (!operators.empty() && operators.top() != '(') {
+                postfix += operators.top();
+                operators.pop();
+            }
+            operators.pop(); // Pop '(' from the stack
+        }
+        // If the character is an operator
+        else if (isOperator(c)) {
+            while (!operators.empty() && getPrecedence(operators.top()) >= getPrecedence(c)) {
+                postfix += operators.top();
+                operators.pop();
+            }
+            operators.push(c);
+        }
+    }
+
+    // Pop all remaining operators in the stack
+    while (!operators.empty()) {
+        postfix += operators.top();
+        operators.pop();
+    }
+
+    return postfix;
 }

tree.h

@@ -4,13 +4,20 @@
 #include "token.h"
 
 const std::vector<std::string> varTypes = {"int", "void", "char", "bool", "string", "short", "long"};
+const std::vector<std::string> equationOperators = {"+", "-", "/", "%", "*", "(", ")", "=", "'", "<", ">", "<=", ">=", "&&"};
 
 class Tree {
     private:
-        void printTree(Token*);
-        bool contains(std::string);
+        void printTree(Token*, Token*);
+        bool contains(const std::vector<std::string>, std::string);
+        Token* handleAssignment(Token*);
+        int getPrecedence(char op);
+        bool isOperator(char c);
+        std::string infixToPostfix(const std::string& infix);
+
+
     public: 
-        Tree(Token* head) { printTree(head); }
+        Tree(Token* head) { printTree(head, nullptr); }
         ~Tree();
 };