Initial commit

Author: jackweatherford

.gitignore

@@ -0,0 +1 @@
+inputs/

ArithExpr.cpp

@@ -0,0 +1,166 @@
+#ifndef EXPRINTER_ARITHEXPR_HPP
+#define EXPRINTER_ARITHEXPR_HPP
+
+#include "Token.hpp"
+#include "SymTab.hpp"
+
+
+class Functions;
+
+// Classes in this file define the internal representation of expressions.
+
+
+// An ExprNode serves as the base class (super class) for an expression.
+// It forces the derived classes (subclasses) to implement two functions, print and
+// evaluate.
+class ExprNode {
+public:
+    ExprNode(Token token);
+    Token token() const;
+    Token &token() { return _token; }
+    virtual void print() = 0;
+    virtual TypeDescriptor* evaluate(SymTab &symTab) = 0;
+
+private:
+    Token _token;
+};
+
+
+// An InfixExprNode is useful to represent binary arithmetic operators.
+class InfixExprNode: public ExprNode {  // An expression tree node.
+
+public:
+    InfixExprNode(Token tk);
+
+    ExprNode *&left();
+    ExprNode *&right();
+    virtual void print();
+    virtual TypeDescriptor* evaluate(SymTab &symTab);
+
+private:
+    ExprNode *_left, *_right;
+};
+
+
+// A RelExprNode is useful to represent binary relational operators.
+class RelExprNode: public ExprNode {  // An expression tree node.
+
+public:
+    RelExprNode(Token tk);
+
+    ExprNode *&left();
+    ExprNode *&right();
+    virtual void print();
+    virtual TypeDescriptor* evaluate(SymTab &symTab);
+
+private:
+    ExprNode *_left, *_right;
+};
+
+// A BoolExprNode is useful to represent binary boolean operators.
+class BoolExprNode: public ExprNode {  // An expression tree node.
+
+public:
+    BoolExprNode(Token tk);
+
+    ExprNode *&left();
+    ExprNode *&right();
+    virtual void print();
+    virtual TypeDescriptor* evaluate(SymTab &symTab);
+
+private:
+    ExprNode *_left, *_right;
+};
+
+// A NotExprNode is useful to represent the unary 'not' operator.
+class NotExprNode: public ExprNode {  // An expression tree node.
+
+public:
+    NotExprNode(Token tk);
+
+    ExprNode *&right();
+    virtual void print();
+    virtual TypeDescriptor* evaluate(SymTab &symTab);
+
+private:
+    ExprNode *_right;
+};
+
+// A Subscription is useful to represent a subscription into an array
+class Subscription: public ExprNode {
+public:
+    Subscription(Token varName, ExprNode* subscript);
+
+    ExprNode *&subscript();
+    virtual void print();
+    virtual TypeDescriptor* evaluate(SymTab &symTab);
+
+private:
+    ExprNode *_subscript;
+};
+
+// A Len is useful to represent a length call on an array
+class Len: public ExprNode {
+public:
+    Len(Token varName);
+    virtual void print();
+    virtual TypeDescriptor* evaluate(SymTab &symTab);
+};
+
+class Call: public ExprNode {
+public:
+    Call(Token funcName, Functions* funcList, std::vector<ExprNode*> args);
+
+    std::vector<ExprNode*> &args();
+    virtual void print();
+    virtual TypeDescriptor* evaluate(SymTab &symTab);
+private:
+    std::vector<ExprNode*> _args;
+    Functions* _funcList;
+};
+
+// WholeNumber is a leaf-node in an expression tree. It corresponds to
+// a terminal in the production rules of the grammar that describes the
+// syntax of expressions.
+
+class WholeNumber: public ExprNode {
+public:
+    WholeNumber(Token token);
+    virtual void print();
+    virtual TypeDescriptor* evaluate(SymTab &symTab);
+};
+
+// Variable is a leaf-node in an expression tree. It corresponds to
+// a terminal in the production rules of the grammar that describes the
+// syntax of expressions.
+
+class Variable: public ExprNode {
+public:
+    Variable(Token token);
+    virtual void print();
+    virtual TypeDescriptor* evaluate(SymTab &symTab);
+};
+
+// Double is a leaf-node in an expression tree. It corresponds to
+// a terminal in the production rules of the grammar that describes the
+// syntax of expressions.
+
+class Double: public ExprNode {
+public:
+    Double(Token token);
+    virtual void print();
+    virtual TypeDescriptor* evaluate(SymTab &symTab);
+};
+
+// String is a leaf-node in an expression tree. It corresponds to
+// a terminal in the production rules of the grammar that describes the
+// syntax of expressions.
+
+class String: public ExprNode {
+public:
+    String(Token token);
+    virtual void print();
+    virtual TypeDescriptor* evaluate(SymTab &symTab);
+};
+
+#endif //EXPRINTER_ARITHEXPR_HPP

ArithExpr.hpp

@@ -0,0 +1,13 @@
+#include "Functions.hpp"
+
+void Functions::addFunction(Function *func) {
+    functions().push_back(func);
+}
+
+Function* Functions::findFunction(std::string name) {
+    for (int i = 0; i < _functions.size(); i++) {
+        if (_functions[i]->name() == name)
+            return _functions[i];
+    }
+    return nullptr;
+}

Functions.cpp

@@ -0,0 +1,41 @@
+#ifndef EXPRINTER_FUNCTIONS_HPP
+#define EXPRINTER_FUNCTIONS_HPP
+
+#include <vector>
+#include "SymTab.hpp"
+#include "Statements.hpp"
+
+class Function {
+public:
+    Function();
+    Function(std::string name, std::vector<std::string> args, Statements *body)
+            : _name{name}, _args{args}, _body{body} {}
+
+    std::string &name() { return _name; }
+    std::vector<std::string> &args() { return _args; }
+    Statements *&body() {return _body; }
+
+private:
+    std::string _name;
+    std::vector<std::string> _args;
+    Statements *_body;
+};
+
+
+// Functions is a collection of Function.
+
+class Functions {
+public:
+    Functions() : _functions{std::vector<Function *>()} {}
+
+    std::vector<Function*> &functions() {return _functions; }
+
+    void addFunction(Function *func);
+    Function *findFunction(std::string name);
+
+private:
+    std::vector<Function *> _functions;
+};
+
+
+#endif //EXPRINTER_FUNCTIONS_HPP

Functions.hpp

@@ -0,0 +1,25 @@
+.SUFFIXES: .o .cpp .exe
+
+CFLAGS = -ggdb -std=c++17
+objects =  Token.o Tokenizer.o Parser.o ArithExpr.o SymTab.o Statements.o TypeDescriptor.o Range.o Functions.o main.o
+
+python.exe: $(objects)
+	g++ $(CFLAGS) -o python.exe $(objects)
+
+.cpp.o:
+	g++ $(CFLAGS) -c $< -o $@
+
+
+Token.o:  Token.cpp Token.hpp
+Tokenizer.o: Tokenizer.cpp Tokenizer.hpp
+ArithExpr.o: ArithExpr.cpp ArithExpr.hpp Token.hpp SymTab.hpp Functions.hpp TypeDescriptor.hpp
+SymTab.o: SymTab.cpp SymTab.hpp TypeDescriptor.hpp
+Parser.o: Parser.cpp Token.hpp Parser.hpp Tokenizer.hpp SymTab.hpp ArithExpr.hpp Statements.hpp Range.hpp Functions.hpp
+Statements.o: Statements.cpp Statements.hpp ArithExpr.hpp SymTab.hpp Range.hpp TypeDescriptor.hpp
+TypeDescriptor.o: TypeDescriptor.cpp TypeDescriptor.hpp
+Range.o: Range.cpp Range.hpp ArithExpr.hpp
+Functions.o: Functions.cpp Functions.hpp SymTab.hpp Statements.hpp
+main.o: main.cpp Token.hpp Tokenizer.hpp Parser.hpp
+
+clean:
+	rm -fr *.o *~ *.exe