Add static semantics to ensure proper variable declarations

Author: gbroques

.gitignore

@@ -1,6 +1,6 @@
 .vscode
 *.o
 *.gch
-P2_test*.txt
+test*.txt
 build
-frontEnd
+statSem

Makefile

@@ -7,7 +7,7 @@
 #
 #  Source: https://spin.atomicobject.com/2016/08/26/makefile-c-projects/
 
-TARGET_EXEC ?= frontEnd
+TARGET_EXEC ?= statSem
 
 BUILD_DIR ?= ./build
 

README.md

@@ -75,3 +75,11 @@ To edit import `assets/state-transition-table.csv` into your favorite spreadshee
 \<assign> -> **let** **Identifier** **=** \<expr>
 
 \<O> -> **<** | **>** | **:**
+
+## Static Semantics
+
+The only static semantics imposed by the compiler are proper use of variables. Before using a variable, you must first declare it using the **var** keyword.
+
+In our language scopes are imposed by blocks denoted by **start** and **end**, conditionals denoted by **if**, and loops denoted by **iter**.
+
+For our compiler, we implement **local scoping** in contrast to global scoping.

backend-specification.pdf

@@ -4,6 +4,7 @@
 #include <stdlib.h>
 #include "timer.h"
 #include "parser/parser.h"
+#include "semantic_analyzer/semantic_analyzer.h"
 
 std::string get_filename(int argc, char** argv);
 
@@ -15,11 +16,14 @@ int main(int argc, char** argv)
     std::string filename = get_filename(argc, argv);
 
     Parser parser(filename);
-    Node* parseTree = parser.parse();
+    Node* parse_tree = parser.parse();
 
-    Node::print(parseTree);
+    SemanticAnalyzer semantic_analyzer = SemanticAnalyzer();
+    Node::print(parse_tree);
+    semantic_analyzer.analyze(parse_tree);
 
-    Node::destroy(parseTree);
+
+    Node::destroy(parse_tree);
 
     timer_.stop("Timer stopped.");
 

src/main.cpp

@@ -30,23 +30,46 @@ void Node::destroy(Node* node)
     delete node;
 }
 
-std::ostream& operator<<(std::ostream &stream, const Node &node) {
-    return stream << node.label;
-}
-
 void Node::print(Node* node)
 {
     if (node == NULL) {
         return;
     }
 
+    print_node(node);
+
+    print_children(node);
+}
+
+void Node::print_node(Node* node)
+{
     printf("%*c%d:%-9s ", node->level, ' ', node->level, node->label.c_str());
     for (auto i = node->tokens.begin(); i != node->tokens.end(); ++i)
         std::cout << *i << ' ';
     printf("\n");
+}
 
+void Node::print_children(Node* node)
+{
     std::vector<Node*> children = node->children;
     for (unsigned int i = 0; i < children.size(); i++) {
         print(children.at(i));
     }
-}
+}
+
+std::vector<Token> Node::get_identifier_tokens()
+{
+    std::vector<Token> identifier_tokens;
+    for (auto token : tokens) {
+        if (token.is_identifier()) {
+            identifier_tokens.push_back(token);
+        }
+    }
+    return identifier_tokens;
+}
+
+
+std::ostream& operator<<(std::ostream &stream, const Node &node)
+{
+    return stream << node.label;
+}

src/parser/node/node.cpp

@@ -13,12 +13,15 @@ class Node
         void append_child(Node* child);
         void append_token(Token token);
         static void print(Node* node);
+        std::vector<Token> get_identifier_tokens();
         std::vector<Node*> children;
         std::string label;
         std::vector<Token> tokens;
         int level;
 
     private:
+        static void print_node(Node* node);
+        static void print_children(Node* node);
         friend std::ostream& operator<<(std::ostream&, const Node&);
 };
 

src/parser/node/node.h

@@ -21,7 +21,7 @@ Node* Parser::parse()
     if (token.is_eof()) {
         return root;
     }
-    error();
+    print_error_and_exit();
 }
 
 /**
@@ -37,7 +37,7 @@ Node* Parser::S()
         node->append_child(block(level));
         return node;
     }
-    error();
+    print_error_and_exit();
 }
 
 /**
@@ -47,7 +47,7 @@ Node* Parser::block(int level)
 {
     level++;
     if (KeywordToken::is_start_token(token)) {
-        Node* node = Node::of("block", level);
+        Node* node = Node::of(BLOCK, level);
         token = scanner->read();
         node->append_child(vars(level));
         node->append_child(stats(level));
@@ -56,7 +56,7 @@ Node* Parser::block(int level)
             return node;
         }
     }
-    error();
+    print_error_and_exit();
 }
 
 /**
@@ -66,15 +66,15 @@ Node* Parser::vars(int level)
 {
     if (KeywordToken::is_var_token(token)) {
         level++;
-        Node* node = Node::of("vars", level);
+        Node* node = Node::of(VARS, level);
         token = scanner->read();
         if (token.is_identifier()) {
             node->append_token(token);
             token = scanner->read();
             node->append_child(vars(level));
             return node;
         } else {
-            error();
+            print_error_and_exit();
         }
     } else {
         return NULL;
@@ -156,7 +156,7 @@ Node* Parser::R(int level)
         token = scanner->read();
         return node;
     }
-    error();
+    print_error_and_exit();
 }
 
 /**
@@ -186,7 +186,8 @@ Node* Parser::m_stat(int level)
     }
 }
 
-bool Parser::is_first_of_stats(Token token) {
+bool Parser::is_first_of_stats(Token token)
+{
     return KeywordToken::is_read_token(token) ||
            KeywordToken::is_print_token(token) ||
            KeywordToken::is_start_token(token) ||
@@ -227,14 +228,15 @@ Node* Parser::stat(int level)
         check_for_comma_token();
         return node;
     }
-    error();
+    print_error_and_exit();
 }
 
-void Parser::check_for_comma_token() {
+void Parser::check_for_comma_token()
+{
     if (DelimiterToken::is_comma_token(token)) {
         token = scanner->read();
     } else {
-        error();
+        print_error_and_exit();
     }
 }
 
@@ -253,7 +255,7 @@ Node* Parser::in(int level)
             return node;
         }
     }
-    error();
+    print_error_and_exit();
 }
 
 /**
@@ -268,7 +270,7 @@ Node* Parser::out(int level)
         node->append_child(expr(level));
         return node;
     }
-    error();
+    print_error_and_exit();
 }
 
 /**
@@ -278,7 +280,7 @@ Node* Parser::ifstat(int level)
 {
     level++;
     if (KeywordToken::is_if_token(token)) {
-        Node* node = Node::of("ifstat", level);
+        Node* node = Node::of(IFSTAT, level);
         token = scanner->read();
         if (DelimiterToken::is_left_parentheses_token(token)) {
             token = scanner->read();
@@ -292,7 +294,7 @@ Node* Parser::ifstat(int level)
             }
         }
     }
-    error();
+    print_error_and_exit();
 }
 
 /**
@@ -302,7 +304,7 @@ Node* Parser::loop(int level)
 {
     level++;
     if (KeywordToken::is_iter_token(token)) {
-        Node* node = Node::of("loop", level);
+        Node* node = Node::of(LOOP, level);
         token = scanner->read();
         if (DelimiterToken::is_left_parentheses_token(token)) {
             token = scanner->read();
@@ -316,7 +318,7 @@ Node* Parser::loop(int level)
             }
         }
     }
-    error();
+    print_error_and_exit();
 }
 
 /**
@@ -338,7 +340,7 @@ Node* Parser::assign(int level)
             }
         }
     }
-    error();
+    print_error_and_exit();
 }
 
 /**
@@ -353,17 +355,18 @@ Node* Parser::O(int level)
         token = scanner->read();
         return node;
     }
-    error();
+    print_error_and_exit();
 }
 
-bool Parser::is_O_token(Token token) {
+bool Parser::is_O_token(Token token)
+{
     return OperatorToken::is_less_than_token(token) ||
            OperatorToken::is_greater_than_token(token) ||
            DelimiterToken::is_colon_token(token);
 }
 
-void Parser::error()
+void Parser::print_error_and_exit()
 {
-    std::cerr << "Parser error: " << token << std::endl;
+    std::cerr << "Parser print_error_and_exit: " << token << std::endl;
     exit(1);
 }

src/parser/parser.cpp

@@ -6,6 +6,11 @@
 #include "../token/token.h"
 #include "node/node.h"
 
+const std::string BLOCK = "block";
+const std::string IFSTAT = "ifstat";
+const std::string LOOP = "loop";
+const std::string VARS = "vars";
+
 class Parser
 {
     public:
@@ -34,7 +39,7 @@ class Parser
         Node* assign(int level);
         Node* O(int level);
         bool is_O_token(Token token);
-        void error();
+        void print_error_and_exit();
         void check_for_comma_token();
 };
 

src/parser/parser.h

@@ -0,0 +1,69 @@
+#include "semantic_analyzer.h"
+#include <iostream>
+
+std::set<std::string> SemanticAnalyzer::new_scope_labels = {BLOCK, IFSTAT, LOOP};
+
+
+void SemanticAnalyzer::analyze(Node* parse_tree)
+{
+    traverse(parse_tree);
+}
+
+void SemanticAnalyzer::traverse(Node* node)
+{
+    if (node == NULL) {
+        return;
+    }
+
+    if (introduces_new_scope(node)) {
+        var_stack.push();
+    }
+
+    check_for_variables(node);
+    
+    if (introduces_new_scope(node)) {
+        var_stack.pop();
+    }
+
+    traverse_children(node);
+}
+
+void SemanticAnalyzer::check_for_variables(Node* node)
+{
+    std::vector<Token> id_tokens = node->get_identifier_tokens();
+
+    for (auto id_token : id_tokens) {
+        if (contains_variable_declarations(node)) {
+            var_stack.insert(id_token);
+        } else {
+            int location = var_stack.find(id_token);
+            if (location == -1) {
+                print_error_and_exit(id_token);
+            }
+        }
+    }
+}
+
+void SemanticAnalyzer::print_error_and_exit(Token token)
+{
+    std::cerr << token << " undeclared. First use in this scope.\n";
+    exit(EXIT_FAILURE);
+}
+
+void SemanticAnalyzer::traverse_children(Node* node)
+{
+    std::vector<Node*> children = node->children;
+    for (unsigned int i = 0; i < children.size(); i++) {
+        traverse(children.at(i));
+    }
+}
+
+bool SemanticAnalyzer::introduces_new_scope(Node* node)
+{
+    return new_scope_labels.count(node->label) == 1;
+}
+
+bool SemanticAnalyzer::contains_variable_declarations(Node* node)
+{
+    return node->label == VARS;
+}