Move Cephelepod into deprecated_compiler, create captian.sh to handle bootstrapping kraken from backup or from Cephelepod

deprecated_compiler/include/ASTData.h

@@ -0,0 +1,41 @@
+#ifndef ASTDATA_H
+#define ASTDATA_H
+
+#include <vector>
+#include <map>
+#include <set>
+
+#include "Symbol.h"
+//Circular dependency
+class Type;
+#include "Type.h"
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+enum ASTType {undef, translation_unit, import, identifier, type_def, adt_def,
+	function, code_block, typed_parameter, expression, boolean_expression, statement,
+	if_statement, match_statement, case_statement, while_loop, for_loop, return_statement, break_statement,
+    continue_statement, defer_statement, assignment_statement, declaration_statement, if_comp, simple_passthrough,
+    passthrough_params, in_passthrough_params, out_passthrough_params, opt_string, param_assign, function_call, value};
+
+class ASTData {
+	public:
+		ASTData();
+		ASTData(ASTType type, Type *valueType = NULL);
+		ASTData(ASTType type, Symbol symbol, Type *valueType = NULL);
+		~ASTData();
+		std::string toString();
+		static std::string ASTTypeToString(ASTType type);
+
+		ASTType type;
+		Type* valueType;
+		Symbol symbol;
+		std::map<std::string, std::vector<NodeTree<ASTData>*>> scope;
+        std::set<NodeTree<ASTData>*> closedVariables;
+	private:
+
+};
+
+#endif

deprecated_compiler/include/ASTTransformation.h

@@ -0,0 +1,87 @@
+#ifndef ASTTRANSFORMATION_H
+#define ASTTRANSFORMATION_H
+
+#include <set>
+#include <map>
+
+#include <iterator>
+#include <algorithm>
+
+#include "Type.h"
+#include "ASTData.h"
+#include "NodeTransformation.h"
+#include "Importer.h"
+
+class Importer;
+
+class ASTTransformation: public NodeTransformation<Symbol,ASTData> {
+	public:
+		ASTTransformation(Importer* importerIn);
+		~ASTTransformation();
+
+        NodeTree<Symbol>* getNode(std::string lookup, std::vector<NodeTree<Symbol>*> nodes);
+        NodeTree<Symbol>* getNode(std::string lookup, NodeTree<Symbol>* parent);
+        std::vector<NodeTree<Symbol>*> getNodes(std::string lookup, std::vector<NodeTree<Symbol>*> nodes);
+        std::vector<NodeTree<Symbol>*> getNodes(std::string lookup, NodeTree<Symbol>* parent);
+
+		//First pass defines all type_defs (objects and ailises)
+		NodeTree<ASTData>* firstPass(std::string fileName, NodeTree<Symbol>* parseTree);
+        std::set<std::string> parseTraits(NodeTree<Symbol>* traitsNode);
+
+		//Second pass defines data inside objects, outside declaration statements, and function prototpyes (since we have type_defs now)
+		void secondPass(NodeTree<ASTData>* ast, NodeTree<Symbol>* parseTree);
+        void secondPassDoClassInsides(NodeTree<ASTData>* typeDef, std::vector<NodeTree<Symbol>*> typedefChildren, std::map<std::string, Type*> templateTypeReplacements);
+		NodeTree<ASTData>* secondPassDeclaration(NodeTree<Symbol>* from, NodeTree<ASTData>* scope, std::map<std::string, Type*> templateTypeReplacements);
+		NodeTree<ASTData>* secondPassFunction(NodeTree<Symbol>* from, NodeTree<ASTData>* scope, std::map<std::string, Type*> templateTypeReplacements);
+
+		//The third pass does all the function bodies
+		void thirdPass(NodeTree<ASTData>* ast, NodeTree<Symbol>* parseTree);
+		NodeTree<ASTData>* searchScopeForFunctionDef(NodeTree<ASTData>* scope, NodeTree<Symbol>* parseTree, std::map<std::string, Type*> templateTypeReplacements);
+		void thirdPassFunction(NodeTree<Symbol>* from, NodeTree<ASTData>* functionDef, std::map<std::string, Type*> templateTypeReplacements);
+
+		//The fourth pass finishes instantiation of templated objects
+        //it used to be a part of the third pass, but it was split out because it has to be done in a loop
+        //with all the other asts until none change anymore (it returns a bool if it instantiated a new one)
+        bool fourthPass(NodeTree<ASTData>* ast, NodeTree<Symbol>* parseTree);
+
+		virtual NodeTree<ASTData>* transform(NodeTree<Symbol>* from);
+		NodeTree<ASTData>* transform(NodeTree<Symbol>* from, NodeTree<ASTData>* scope, std::vector<Type> types, bool limitToFunction, std::map<std::string, Type*> templateTypeReplacements);
+		std::vector<NodeTree<ASTData>*> transformChildren(std::vector<NodeTree<Symbol>*> children, std::set<int> skipChildren, NodeTree<ASTData>* scope, std::vector<Type> types, bool limitToFunction, std::map<std::string, Type*> templateTypeReplacements);
+		std::string concatSymbolTree(NodeTree<Symbol>* root);
+		NodeTree<ASTData>* doFunction(NodeTree<ASTData>* scope, std::string lookup, std::vector<NodeTree<ASTData>*> nodes, std::map<std::string, Type*> templateTypeReplacements);
+
+        NodeTree<ASTData>* generateThis(NodeTree<ASTData>* scope);
+        std::set<NodeTree<ASTData>*> findVariablesToClose(NodeTree<ASTData>* func, NodeTree<ASTData>* stat, NodeTree<ASTData>* scope);
+        bool inScopeChain(NodeTree<ASTData>* node, NodeTree<ASTData>* scope);
+        NodeTree<ASTData>* functionLookup(NodeTree<ASTData>* scope, std::string lookup, std::vector<Type> types);
+        NodeTree<ASTData>* templateFunctionLookup(NodeTree<ASTData>* scope, std::string lookup, std::vector<Type*>* templateInstantiationTypes, std::vector<Type> types, std::map<std::string, Type*> scopeTypeMap);
+        std::vector<NodeTree<ASTData>*> scopeLookup(NodeTree<ASTData>* scope, std::string lookup, bool includeModules = false);
+        std::vector<NodeTree<ASTData>*> scopeLookup(NodeTree<ASTData>* scope, std::string lookup, bool includeModules, std::set<NodeTree<ASTData>*> visited);
+
+        NodeTree<ASTData>* getUpperTranslationUnit(NodeTree<ASTData>* node);
+        NodeTree<ASTData>* addToScope(std::string name, NodeTree<ASTData>* toAdd, NodeTree<ASTData>* addTo);
+        Type* typeFromTypeNode(NodeTree<Symbol>* typeNode, NodeTree<ASTData>* scope, std::map<std::string, Type*> templateTypeReplacements);
+        NodeTree<ASTData>* templateClassLookup(NodeTree<ASTData>* scope, std::string name, std::vector<Type*> templateInstantiationTypes);
+        void unifyType(NodeTree<Symbol> *syntaxType, Type type, std::map<std::string, Type>* templateTypeMap, std::map<std::string, Type*> typeMap);
+        void unifyTemplateFunction(NodeTree<ASTData>* templateFunction, std::vector<Type> types, std::vector<Type*>* templateInstantiationTypes, std::map<std::string, Type*> typeMap);
+		NodeTree<ASTData>* tryToFindOrInstantiateFunctionTemplate(std::string functionName, NodeTree<ASTData>* scope, std::vector<Type> types, std::map<std::string, Type*> templateTypeReplacements);
+		NodeTree<ASTData>* findOrInstantiateFunctionTemplate(std::string functionName, NodeTree<ASTData>* scope, std::vector<Type> types, std::map<std::string, Type*> templateTypeReplacements);
+		NodeTree<ASTData>* findOrInstantiateFunctionTemplate(std::vector<NodeTree<Symbol>*> children, NodeTree<ASTData>* scope, std::vector<Type> types, std::map<std::string, Type*> templateTypeReplacements);
+		NodeTree<ASTData>* findOrInstantiateFunctionTemplate(std::string functionName, std::vector<NodeTree<Symbol>*> children, NodeTree<ASTData>* scope, std::vector<Type> types, std::map<std::string, Type*> templateTypeReplacements);
+        std::map<std::string, Type*> makeTemplateFunctionTypeMap(NodeTree<Symbol>* templateNode, std::vector<Type*> types, std::map<std::string, Type*> scopeTypeMap);
+        std::vector<std::pair<std::string, std::set<std::string>>> makeTemplateNameTraitPairs(NodeTree<Symbol>* templateNode);
+
+	private:
+		Importer * importer;
+		NodeTree<ASTData>* builtin_trans_unit; // the top scope for language level stuff
+		std::map<std::string, std::vector<NodeTree<ASTData>*>> languageLevelReservedWords;
+		std::map<std::string, std::vector<NodeTree<ASTData>*>> languageLevelOperators;
+		std::map<NodeTree<ASTData>*, NodeTree<ASTData>*> this_map; // used to map implicit "this" variables to their type
+		NodeTree<ASTData>* topScope; //maintained for templates that need to add themselves to the top scope no matter where they are instantiated
+        int lambdaID = 0;
+};
+
+std::vector<Type> mapNodesToTypes(std::vector<NodeTree<ASTData>*> nodes);
+std::vector<Type*> mapNodesToTypePointers(std::vector<NodeTree<ASTData>*> nodes);
+
+#endif

deprecated_compiler/include/CCodeTriple.h

@@ -0,0 +1,25 @@
+#ifndef CCODETRIPLE_H
+#define CCODETRIPLE_H
+
+#include <string>
+#include <iostream>
+#include "util.h"
+
+class CCodeTriple {
+	public:
+        CCodeTriple(std::string pre, std::string val, std::string post);
+        CCodeTriple(std::string val);
+        CCodeTriple(const char* val);
+		CCodeTriple();
+		~CCodeTriple();
+        std::string oneString(bool endValue = false);
+        CCodeTriple & operator=(const CCodeTriple &rhs);
+        CCodeTriple & operator+=(const CCodeTriple &rhs);
+
+		std::string preValue;
+        std::string value;
+        std::string postValue;
+	private:
+};
+CCodeTriple operator+(const CCodeTriple &a, const CCodeTriple &b);
+#endif //CCODETRIPLE_H

deprecated_compiler/include/CGenerator.h

@@ -0,0 +1,72 @@
+#ifndef CGENERATOR_H
+#define CGENERATOR_H
+
+#include <string>
+#include <iostream>
+#include <fstream>
+#include <utility>
+#include <stack>
+#include <sys/stat.h>
+
+#include "CCodeTriple.h"
+#include "NodeTree.h"
+#include "ASTData.h"
+#include "Type.h"
+// for mapNodesToTypes
+#include "ASTTransformation.h"
+
+#include "util.h"
+#include "Poset.h"
+
+// Note the use of std::pair to hold two strings - the running string for the header file and the running string for  the c file.
+
+enum ClosureTypeSpecialType { ClosureTypeRegularNone, ClosureFunctionPointerTypeWithoutClosedParam, ClosureFunctionPointerTypeWithClosedParam };
+
+class CGenerator {
+	public:
+		CGenerator();
+		~CGenerator();
+		int generateCompSet(std::map<std::string, NodeTree<ASTData>*> ASTs, std::string outputName);
+        std::string generateTypeStruct(NodeTree<ASTData>* from);
+        bool isUnderNodeWithType(NodeTree<ASTData>* from, ASTType type);
+        bool isUnderTranslationUnit(NodeTree<ASTData>* from, NodeTree<ASTData>* typeDefinition);
+        NodeTree<ASTData>* highestScope(NodeTree<ASTData>* node);
+        std::pair<std::string, std::string> generateTranslationUnit(std::string name, std::map<std::string, NodeTree<ASTData>*> ASTs);
+		CCodeTriple generate(NodeTree<ASTData>* from, NodeTree<ASTData>* enclosingObject = NULL, bool justFuncName = false, NodeTree<ASTData>* enclosingFunction = NULL);
+        std::string generateAliasChains(std::map<std::string, NodeTree<ASTData>*> ASTs, NodeTree<ASTData>* definition);
+
+        std::string closureStructType(std::set<NodeTree<ASTData>*> closedVariables);
+		std::string ValueTypeToCType(Type *type, std::string, ClosureTypeSpecialType closureSpecial = ClosureTypeRegularNone);
+		std::string ValueTypeToCTypeDecoration(Type *type, ClosureTypeSpecialType closureSpecial = ClosureTypeRegularNone);
+        std::string ValueTypeToCTypeThingHelper(Type *type, std::string ptrStr, ClosureTypeSpecialType closureSpecial);
+		static std::string CifyName(std::string name);
+		static std::string scopePrefix(NodeTree<ASTData>* from);
+        std::string simpleComplexName(std::string simpleName, std::string complexName);
+        std::string prefixIfNeeded(std::string prefix, std::string name);
+        std::string generateObjectMethod(NodeTree<ASTData>* enclosingObject, NodeTree<ASTData>* from, std::string *functionPrototype);
+        NodeTree<ASTData>* getMethodsObjectType(NodeTree<ASTData>* scope, std::string functionName);
+        NodeTree<ASTData>* getMethod(Type* type, std::string method, std::vector<Type> types);
+        bool methodExists(Type* type, std::string method, std::vector<Type> types);
+        std::string generateMethodIfExists(Type* type, std::string method, std::string parameter, std::vector<Type> methodTypes);
+        std::string emitDestructors(std::vector<NodeTree<ASTData>*> possibleDeclarations, NodeTree<ASTData>* enclosingObject);
+		std::string tabs();
+		std::string getID();
+
+		int tabLevel;
+		int id;
+        std::string function_header;
+		std::string generatorString;
+        std::string linkerString;
+        std::string functionTypedefString;
+        std::string functionTypedefStringPre;
+        std::set<std::string> usedNameSet;
+        std::map<std::string, std::string> simpleComplexNameMap;
+        std::map<Type, triple<std::string, std::string, std::string>> functionTypedefMap;
+        std::map<std::set<NodeTree<ASTData>*>, std::string> closureStructMap;
+        std::vector<std::vector<NodeTree<ASTData>*>> distructDoubleStack;
+        std::stack<int> loopDistructStackDepth;
+        std::vector<std::vector<NodeTree<ASTData>*>> deferDoubleStack;
+        std::stack<int> loopDeferStackDepth;
+	private:
+};
+#endif

deprecated_compiler/include/CollapseTransformation.h

@@ -0,0 +1,52 @@
+#ifndef COLLAPSETRANSFORMATION_H
+#define COLLAPSETRANSFORMATION_H
+
+#include <queue>
+#include <vector>
+
+#include "NodeTransformation.h"
+
+template<class T>
+class CollapseTransformation: public NodeTransformation<T,T> {
+	public:
+		CollapseTransformation(T toCollapse);
+		~CollapseTransformation();
+		virtual NodeTree<T>* transform(NodeTree<T>* from);
+
+	private:
+		T toCollapse;
+};
+
+#endif
+
+template<class T>
+CollapseTransformation<T>::CollapseTransformation(T toCollapse) {
+	this->toCollapse = toCollapse;
+}
+
+template<class T>
+CollapseTransformation<T>::~CollapseTransformation() {
+	//
+}
+
+template<class T>
+NodeTree<T>* CollapseTransformation<T>::transform(NodeTree<T>* from) {
+	std::queue<NodeTree<T>*> toProcess;
+	toProcess.push(from);
+	while(!toProcess.empty()) {
+		NodeTree<T>* node = toProcess.front();
+		toProcess.pop();
+		std::vector<NodeTree<T>*> children = node->getChildren();
+		for (int i = 0; i < children.size(); i++) {
+			if (children[i]->getData() == toCollapse) {
+				node->removeChild(children[i]);
+				std::vector<NodeTree<T>*> newChildren = children[i]->getChildren();
+				node->insertChildren(i,newChildren);
+				toProcess.push(node); //Do this node again
+			}
+			else
+				toProcess.push(children[i]);
+		}
+	}
+	return from;
+}

deprecated_compiler/include/DeleteTransformation.h

@@ -0,0 +1,48 @@
+#ifndef DELETETRANSFORMATION_H
+#define DELETETRANSFORMATION_H
+
+#include <queue>
+#include <vector>
+
+#include "NodeTransformation.h"
+
+template<class T>
+class DeleteTransformation: public NodeTransformation<T,T> {
+	public:
+		DeleteTransformation(T toDelete);
+		~DeleteTransformation();
+		virtual NodeTree<T>* transform(NodeTree<T>* from);
+
+	private:
+		T toRemove;
+};
+
+#endif
+
+template<class T>
+DeleteTransformation<T>::DeleteTransformation(T toRemove) {
+	this->toRemove = toRemove;
+}
+
+template<class T>
+DeleteTransformation<T>::~DeleteTransformation() {
+	//
+}
+
+template<class T>
+NodeTree<T>* DeleteTransformation<T>::transform(NodeTree<T>* from) {
+	std::queue<NodeTree<T>*> toProcess;
+	toProcess.push(from);
+	while(!toProcess.empty()) {
+		NodeTree<T>* node = toProcess.front();
+		toProcess.pop();
+		std::vector<NodeTree<T>*> children = node->getChildren();
+		for (int i = 0; i < children.size(); i++) {
+			if (children[i]->getData() == toRemove)
+				node->removeChild(children[i]);
+			else
+				toProcess.push(children[i]);
+		}
+	}
+	return from;
+}

deprecated_compiler/include/GraphStructuredStack.h

@@ -0,0 +1,38 @@
+#include <iostream>
+#include <vector>
+#include <queue>
+#include <map>
+#include "NodeTree.h"
+#include "Symbol.h"
+#include "util.h"
+
+#ifndef GRAPH_STRUCTURED_STACK
+#define GRAPH_STRUCTURED_STACK
+
+class GraphStructuredStack {
+	public:
+		GraphStructuredStack();
+		~GraphStructuredStack();
+		NodeTree<int>* newNode(int stateNum);
+		void addToFrontier(int frontier, NodeTree<int>* node);
+		NodeTree<int>* inFrontier(int frontier, int state);
+		int getContainingFrontier(NodeTree<int>* node);
+		bool frontierIsEmpty(int frontier);
+		NodeTree<int>* frontierGetAccState(int frontier);
+		std::vector<NodeTree<int>*>* getReachable(NodeTree<int>* start, int lenght);
+		std::vector<std::vector<NodeTree<int>*> >* getReachablePaths(NodeTree<int>* start, int lenght);
+		void recursivePathFind(NodeTree<int>* start, int length, std::vector<NodeTree<int>*> currentPath, std::vector<std::vector<NodeTree<int>*> >* paths);
+		bool hasEdge(NodeTree<int>* start, NodeTree<int>* end);
+		NodeTree<Symbol>* getEdge(NodeTree<int>* start, NodeTree<int>* end);
+		void addEdge(NodeTree<int>* start, NodeTree<int>* end, NodeTree<Symbol>* edge);
+		void clear();
+
+        std::vector<int> getFrontier(int frontier);
+		std::string toString();
+	private:
+		std::vector<std::vector<NodeTree<int>*>*> gss;
+		std::map< std::pair< NodeTree<int>*, NodeTree<int>* >, NodeTree<Symbol>* > edges;
+        std::map< NodeTree<int>*, int > containing_frontier_map;
+};
+
+#endif

deprecated_compiler/include/Importer.h

@@ -0,0 +1,48 @@
+#ifndef __IMPORTER__H_
+#define __IMPORTER__H_
+
+#include <string>
+#include <vector>
+#include <iostream>
+#include <fstream>
+
+#include <sys/stat.h>
+
+#include "Parser.h"
+#include "NodeTree.h"
+#include "ASTData.h"
+#include "Symbol.h"
+#include "RemovalTransformation.h"
+#include "CollapseTransformation.h"
+#include "ASTTransformation.h"
+
+class ASTTransformation;
+
+class Importer {
+	public:
+		Importer(Parser* parserIn, std::vector<std::string> includePaths, std::string outputName, bool only_parseIn = false);
+		~Importer();
+		void import(std::string fileName);
+		NodeTree<ASTData>* getUnit(std::string fileName);
+		NodeTree<ASTData>* importFirstPass(std::string fileName);
+		NodeTree<Symbol>* parseAndTrim(std::string fileName);
+		void registerAST(std::string name, NodeTree<ASTData>* ast, NodeTree<Symbol>* syntaxTree);
+		std::map<std::string, NodeTree<ASTData>*> getASTMap();
+	private:
+        std::string outputName;
+		ASTTransformation *ASTTransformer;
+		struct importTriplet {
+			std::string name;
+			NodeTree<ASTData>* ast;
+			NodeTree<Symbol>* syntaxTree;
+		};
+        bool only_parse;
+		std::vector<importTriplet> importedTrips;
+		std::vector<std::string> includePaths;
+		Parser* parser;
+		std::vector<Symbol> removeSymbols;
+		std::vector<Symbol> collapseSymbols;
+		std::map<std::string, NodeTree<ASTData>*> imported;
+};
+
+#endif

deprecated_compiler/include/Lexer.h

@@ -0,0 +1,26 @@
+#ifndef LEXER_H
+#define LEXER_H
+
+#include "util.h"
+#include "StringReader.h"
+#include "RegEx.h"
+#include "Symbol.h"
+
+#include <string>
+
+class Lexer {
+	public:
+		Lexer();
+		Lexer(std::string inputString);
+		~Lexer();
+		void addRegEx(std::string regExString);
+		void setInput(std::string inputString);
+		Symbol next();
+		void reset();
+		static void test();
+	private:
+		std::vector<RegEx*> regExs;
+		std::string input;
+		int currentPosition;
+};
+#endif

deprecated_compiler/include/NodeTransformation.h

@@ -0,0 +1,35 @@
+#ifndef NODETRANSFORMATION_H
+#define NODETRANSFORMATION_H
+
+#include "NodeTree.h"
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+template <class FROM, class TO>
+class NodeTransformation {
+	public:
+		NodeTransformation();
+		virtual ~NodeTransformation();
+		virtual NodeTree<TO>* transform(NodeTree<FROM>* from)=0;
+	private:
+
+};
+
+template <class FROM, class TO>
+NodeTransformation<FROM,TO>::NodeTransformation() {
+	//Nothing
+}
+
+template <class FROM, class TO>
+NodeTransformation<FROM,TO>::~NodeTransformation() {
+	//Nothing
+}
+
+// template <class FROM, class TO>
+// NodeTree<TO>* NodeTransformation<FROM,TO>::transform(NodeTree<FROM>* from) {
+// 	return (NodeTree<TO>*)0x1234;
+// }
+
+#endif

deprecated_compiler/include/NodeTree.h

@@ -0,0 +1,277 @@
+#ifndef NODETREE_H
+#define NODETREE_H
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+#include <vector>
+#include <string>
+#include <iostream>
+
+#include "util.h"
+
+template<class T>
+class NodeTree {
+	public:
+		NodeTree();
+		NodeTree(std::string name, T inData);
+		~NodeTree();
+
+		bool const operator==(NodeTree &other);
+		bool const operator<(const NodeTree &other) const;
+
+		void setParent(NodeTree<T>* parent);
+		void addParent(NodeTree<T>* parent);
+		NodeTree<T>* getParent();
+		std::vector<NodeTree<T>*> getParents();
+
+		void addChild(NodeTree<T>* child);
+		void insertChild(int i, NodeTree<T>* child);
+		void addChildren(std::vector<NodeTree<T>*>* children);
+		void addChildren(std::vector<NodeTree<T>*> children);
+		void insertChildren(int index, std::vector<NodeTree<T>*>* children);
+		void insertChildren(int index, std::vector<NodeTree<T>*> children);
+		int findChild(NodeTree<T>* child);
+		void removeChild(NodeTree<T>* child);
+		void removeChild(int index);
+		void clearChildren();
+		std::vector<NodeTree<T>*> getChildren();
+
+		NodeTree<T>* get(int index);
+		std::string getName();
+		void setName(std::string);
+
+		T getData() const;
+		T* getDataRef();
+		void setData(T data);
+
+		int size();
+		std::string DOTGraphString();
+
+	private:
+		std::string DOTGraphStringHelper(std::vector<NodeTree<T>*> avoidList);
+		std::string getDOTName();
+		std::string name;
+		T data;
+		std::vector<NodeTree<T>*> parents;
+		std::vector<NodeTree<T>*> children;
+
+		static int idCounter;
+		int id;
+};
+
+template<class T>
+
+int NodeTree<T>::idCounter;
+
+template<class T>
+NodeTree<T>::NodeTree() {
+	name = "UnnamedNode";
+	id = idCounter++;
+}
+
+template<class T>
+NodeTree<T>::NodeTree(std::string name, T inData) {
+	this->name = name;
+	this->data = inData;
+	id = idCounter++;
+}
+
+template<class T>
+NodeTree<T>::~NodeTree() {
+	children.clear();
+	parents.clear(); //? Will this segfault?
+}
+
+template<class T>
+const bool NodeTree<T>::operator==(NodeTree &other) {
+	if (!(data == other.data))
+		return false;
+	if (children.size() != other.getChildren().size())
+		return false;
+	for (typename std::vector<NodeTree<T>*>::size_type i = 0; i < children.size(); i++)
+		if (! (*(children[i]) == *(other.getChildren()[i])))
+			return false;
+	return true;
+}
+
+//Used when making a map of NodeTrees
+template<class T>
+const bool NodeTree<T>::operator<(const NodeTree &other) const {
+	return data < other.getData();
+}
+
+template<class T>
+void NodeTree<T>::setParent(NodeTree<T>* parent) {
+	parents.clear();
+	parents.push_back(parent);
+}
+
+template<class T>
+void NodeTree<T>::addParent(NodeTree<T>* parent) {
+	parents.push_back(parent);
+}
+
+template<class T>
+NodeTree<T>* NodeTree<T>::getParent() {
+	if (parents.size() > 0)
+		return parents[0];
+	return NULL;
+}
+
+template<class T>
+std::vector<NodeTree<T>*> NodeTree<T>::getParents() {
+	return parents;
+}
+
+
+template<class T>
+void NodeTree<T>::addChild(NodeTree<T>* child) {
+	if (!child)
+		throw "Help, NULL child";
+	//if (findChild(child) == -1)
+		children.push_back(child);
+}
+
+template<class T>
+void NodeTree<T>::insertChild(int i, NodeTree<T>* child) {
+	if (!child)
+		throw "Help, NULL child";
+	//if (findChild(child) == -1)
+		children.insert(children.begin()+i,child);
+}
+
+template<class T>
+void NodeTree<T>::addChildren(std::vector<NodeTree<T>*>* children) {
+	for (typename std::vector<NodeTree<T>*>::size_type i = 0; i < children->size(); i++)
+		addChild((*children)[i]);
+}
+
+template<class T>
+void NodeTree<T>::addChildren(std::vector<NodeTree<T>*> children) {
+	for (typename std::vector<NodeTree<T>*>::size_type i = 0; i < children.size(); i++)
+		addChild(children[i]);
+}
+
+template<class T>
+void NodeTree<T>::insertChildren(int index, std::vector<NodeTree<T>*>* children) {
+	for (typename std::vector<NodeTree<T>*>::size_type i = 0; i < children->size(); i++)
+		insertChild(index+i,(*children)[i]);
+}
+
+template<class T>
+void NodeTree<T>::insertChildren(int index, std::vector<NodeTree<T>*> children) {
+	for (typename std::vector<NodeTree<T>*>::size_type i = 0; i < children.size(); i++)
+		insertChild(index+i, children[i]);
+}
+
+template<class T>
+int NodeTree<T>::findChild(NodeTree<T>* child) {
+	for (int i = 0; i < children.size(); i++) {
+		if (children[i] == child) {
+			return i;
+		}
+	}
+	return -1;
+}
+
+template<class T>
+void NodeTree<T>::removeChild(int index) {
+	children[index] = NULL;
+	children.erase(children.begin()+index);
+}
+
+template<class T>
+void NodeTree<T>::removeChild(NodeTree<T>* child) {
+	int index = findChild(child);
+	if (index != -1) {
+		removeChild(index);
+	}
+}
+
+template<class T>
+void NodeTree<T>::clearChildren() {
+	for (typename std::vector<T>::size_type i = 0; i < children.size(); i++)
+		children[i] = NULL;
+	children.clear();
+}
+
+template<class T>
+std::vector<NodeTree<T>*> NodeTree<T>::getChildren() {
+	return children;
+}
+
+template<class T>
+int NodeTree<T>::size() {
+	int count = 0;
+	for (int i = 0; i < children.size(); i++) {
+		count += children[i]->size();
+	}
+	return 1+count;
+}
+
+template<class T>
+NodeTree<T>* NodeTree<T>::get(int index) {
+	return children[index];
+}
+
+template<class T>
+std::string NodeTree<T>::getName() {
+	return name;
+}
+
+template<class T>
+void NodeTree<T>::setName(std::string name) {
+	this->name = name;
+}
+
+template<class T>
+T NodeTree<T>::getData() const {
+	return data;
+}
+
+template<class T>
+T* NodeTree<T>::getDataRef() {
+	return &data;
+}
+
+template<class T>
+void NodeTree<T>::setData(T data) {
+	this->data = data;
+}
+
+template<class T>
+std::string NodeTree<T>::DOTGraphString() {
+	return( "digraph Kraken { \n" + DOTGraphStringHelper(std::vector<NodeTree<T>*>()) + "}");
+}
+
+template<class T>
+std::string NodeTree<T>::DOTGraphStringHelper(std::vector<NodeTree<T>*> avoidList) {
+	for (typename std::vector<NodeTree<T>*>::size_type i = 0; i < avoidList.size(); i++)
+		if (this == avoidList[i])
+			return "";
+	avoidList.push_back(this);
+
+	std::string ourDOTRelation = "";
+	for (int i = 0; i < children.size(); i++) {
+		if (children[i] != NULL)
+			ourDOTRelation += getDOTName() + " -> " + children[i]->getDOTName() + ";\n" + children[i]->DOTGraphStringHelper(avoidList);
+		else
+			ourDOTRelation += getDOTName() + " -> BAD_NULL_" + getDOTName() + "\n";
+	}
+	return(ourDOTRelation);
+}
+
+template<class T>
+std::string NodeTree<T>::getDOTName() {
+	std::string DOTName = "";
+	DOTName = "\"" + replaceExEscape(name + "-" + data.toString(), "\"", "\\\"") + "_" + intToString(id) + "\""; //Note that terminals already have a quote in the front of their name, so we don't need to add one
+	// if (data != NULL)
+	// 	DOTName = "\"" + replaceExEscape(name + "-" + data->toString(), "\"", "\\\"") + "_" + intToString(id) + "\""; //Note that terminals already have a quote in the front of their name, so we don't need to add one
+	// else
+	// 	DOTName = "\"" + replaceExEscape(name, "\"", " \\\"") + "_" + intToString(id) + "\"";
+	return(replaceExEscape(DOTName, "\n", "\\n"));
+}
+
+#endif

deprecated_compiler/include/ParseAction.h

@@ -0,0 +1,36 @@
+#ifndef PARSE_ACTION_H
+#define PARSE_ACTION_H
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+#include "util.h"
+#include "ParseRule.h"
+
+#include <vector>
+#include <string>
+
+
+class ParseAction {
+	public:
+		enum ActionType { INVALID, REDUCE, SHIFT, ACCEPT, REJECT };
+		ParseAction(ActionType action);
+		ParseAction(ActionType action, ParseRule* reduceRule);
+		ParseAction(ActionType action, int shiftState);
+		~ParseAction();
+		bool const equalsExceptLookahead(const ParseAction &other) const;
+		bool const operator==(const ParseAction &other) const;
+		bool const operator!=(const ParseAction &other) const;
+        bool const operator<(const ParseAction &other) const;
+        std::string toString(bool printRuleLookahead = true);
+		static std::string actionToString(ActionType action);
+
+		ActionType action;
+		ParseRule* reduceRule;
+		int shiftState;
+
+
+};
+
+#endif

deprecated_compiler/include/ParseRule.h

@@ -0,0 +1,53 @@
+#ifndef PARSERULE_H
+#define PARSERULE_H
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+#include "Symbol.h"
+
+#include <vector>
+#include <string>
+#include <iostream>
+
+class ParseRule {
+	private:
+		int pointerIndex;
+		Symbol leftHandle;
+		std::vector<Symbol> lookahead;
+		std::vector<Symbol> rightSide;
+
+	public:
+		ParseRule();
+		ParseRule(Symbol leftHandle, int pointerIndex, std::vector<Symbol> &rightSide, std::vector<Symbol> lookahead);
+		~ParseRule();
+		const bool equalsExceptLookahead(const ParseRule &other) const;
+		bool const operator==(const ParseRule &other) const;
+		bool const operator!=(const ParseRule &other) const;
+        bool const operator<(const ParseRule &other) const; //Used for ordering so we can put ParseRule's in sets, and also so that ParseActions will have an ordering
+		ParseRule* clone();
+
+		void setLeftHandle(Symbol leftHandle);
+		void appendToRight(Symbol appendee);
+
+		Symbol getLeftSide();
+		void setRightSide(std::vector<Symbol> rightSide);
+		std::vector<Symbol> getRightSide();
+		Symbol getAtNextIndex();
+		Symbol getAtIndex();
+		int getRightSize();
+		int getIndex();
+
+		bool advancePointer();
+		bool isAtEnd();
+
+		void setLookahead(std::vector<Symbol> lookahead);
+		void addLookahead(std::vector<Symbol> lookahead);
+		std::vector<Symbol> getLookahead();
+
+		std::string toString(bool printLookahead = true);
+		std::string toDOT();
+};
+
+#endif

deprecated_compiler/include/Parser.h

@@ -0,0 +1,73 @@
+#ifndef PARSER_H
+#define PARSER_H
+
+#include "util.h"
+#include "ParseRule.h"
+#include "ParseAction.h"
+#include "Symbol.h"
+#include "State.h"
+#include "StringReader.h"
+#include "Lexer.h"
+#include "NodeTree.h"
+#include "Table.h"
+
+#include <queue>
+#include <set>
+#include <map>
+#include <vector>
+#include <algorithm>
+#include <stack>
+#include <string>
+#include <iostream>
+
+class Parser {
+	public:
+		Parser();
+		~Parser();
+
+		virtual void loadGrammer(std::string grammerInputString);
+		virtual void createStateSet();
+		virtual std::string stateSetToString();
+		virtual NodeTree<Symbol>* parseInput(std::string inputString, std::string filename, bool highlight_errors) = 0; // filename for error reporting
+		virtual std::string grammerToString();
+		virtual std::string grammerToDOT();
+
+		std::string tableToString();
+		void exportTable(std::ofstream &file);
+		void importTable(char* tableData);
+
+	protected:
+		std::vector<Symbol> firstSet(Symbol token, std::vector<Symbol> avoidList = std::vector<Symbol>(), bool addNewTokens = true);
+        bool isNullable(Symbol token);
+        bool isNullableHelper(Symbol token, std::set<Symbol> done);
+
+        std::map<Symbol, std::vector<Symbol>> tokenFirstSet;
+        std::map<Symbol, bool> tokenNullable;
+
+		std::vector<Symbol> incrementiveFollowSet(ParseRule* rule);
+		virtual void closure(State* state);
+		virtual void addStates(std::vector< State* >* stateSets, State* state, std::queue<State*>* toDo);
+		int stateNum(State* state);
+
+
+		StringReader reader;
+		Lexer lexer;
+		std::map<std::pair<std::string, bool>, Symbol> symbols;
+		std::vector<ParseRule*> loadedGrammer;
+
+		std::vector< State* > stateSets;
+
+		Symbol EOFSymbol;
+		Symbol nullSymbol;
+		Symbol invalidSymbol;
+
+		Table table;
+
+
+		std::stack<int> stateStack;
+		std::stack<Symbol> symbolStack;
+
+		Symbol getOrAddSymbol(std::string symbolString, bool isTerminal);
+};
+
+#endif

deprecated_compiler/include/Poset.h

@@ -0,0 +1,126 @@
+
+#ifndef POSET_H
+#define POSET_H
+
+#include <vector>
+#include <set>
+#include <map>
+#include <queue>
+
+#include <cassert>
+
+#include "util.h"
+
+template <class T>
+class Poset {
+	public:
+		Poset();
+		~Poset();
+		void addRelationship(T first, T second);
+		void addVertex(T vertex);
+		bool zeroDependencies(T vertex);
+		std::set<T> getDependsOn(T dependency);
+		std::vector<T> getTopoSort();
+		static void test();
+	private:
+		//backing data structures
+		std::map<T, std::map<T,bool>> adjMatrix;
+		std::set<T> verticies;
+};
+
+template <class T>
+Poset<T>::Poset() {
+	//Nothing needed
+}
+
+template <class T>
+Poset<T>::~Poset() {
+	//Ditto
+}
+
+
+template <class T>
+void Poset<T>::addRelationship(T first, T second) {
+	verticies.insert(first);
+	verticies.insert(second);
+	adjMatrix[first][second] = true;
+}
+
+template <class T>
+void Poset<T>::addVertex(T vertex) {
+	verticies.insert(vertex);
+}
+
+template <class T>
+bool Poset<T>::zeroDependencies(T vertex) {
+	auto depMapItr = adjMatrix.find(vertex);
+	if (depMapItr == adjMatrix.end())
+		return true;
+	for (auto i : depMapItr->second)
+		if (i.second == true)
+			return false;
+	return true;
+}
+
+template <class T>
+std::set<T> Poset<T>::getDependsOn(T dependency) {
+	std::set<T> vertsThatDependOn;
+	for (auto i : adjMatrix) {
+		auto depItr = i.second.find(dependency);
+		if (depItr != i.second.end() && depItr->second)
+			vertsThatDependOn.insert(i.first);
+	}
+	return vertsThatDependOn;
+}
+
+template <class T>
+std::vector<T> Poset<T>::getTopoSort() {
+	std::vector<T> sorted;
+	std::queue<T> toDo;
+	for (auto i : verticies)
+		if (zeroDependencies(i))
+			toDo.push(i);
+	while(!toDo.empty()) {
+		T current = toDo.front(); toDo.pop();
+		sorted.push_back(current);
+		for (T depOnCurrent : getDependsOn(current)) {
+			adjMatrix[depOnCurrent][current] = false; //Remove the edge to current, since current's now been taken care of
+			if (zeroDependencies(depOnCurrent))
+				toDo.push(depOnCurrent);
+		}
+	}
+	return sorted;
+}
+
+
+//would make it just an int specilization, but then we get multiple definition complaints....
+template<class T>
+void Poset<T>::test() {
+	std::string result;
+	{
+		Poset<int> poset;
+		poset.addVertex(1000);
+		for (int i = 0; i < 20; i++)
+			poset.addRelationship(i,i+1);
+		result = "";
+		for (int i : poset.getTopoSort())
+			result += intToString(i) + " ";
+		//std::cout << result << std::endl;
+		assert(result == "20 1000 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 "); //Note that sets do not have a set order, so this could change
+																						//This is why the 1000 is in an odd, yet valid, position
+	}
+	{
+		Poset<int> poset;
+		for (int i = 0; i < 20; i+=2)
+			poset.addRelationship(i,i+1);
+		result = "";
+		for (int i : poset.getTopoSort())
+			result += intToString(i) + " ";
+		//std::cout << result << std::endl;
+		assert(result == "1 3 5 7 9 11 13 15 17 19 0 2 4 6 8 10 12 14 16 18 ");
+	}
+
+	std::cout << "Poset tests passed" << std::endl;
+} 
+
+#endif

deprecated_compiler/include/RNGLRParser.h

@@ -0,0 +1,68 @@
+#ifndef RNGLRPARSER_H
+#define RNGLRPARSER_H
+
+#include <iostream>
+#include <queue>
+#include <map>
+#include <vector>
+#include <set>
+#include <utility>
+#include <algorithm>
+#include "Parser.h"
+#include "Symbol.h"
+#include "GraphStructuredStack.h"
+#include "util.h"
+
+class RNGLRParser: public Parser {
+	public:
+		RNGLRParser();
+		~RNGLRParser();
+		NodeTree<Symbol>* parseInput(std::string inputString, std::string filename, bool highlight_errors); // filename for error reporting
+        void printReconstructedFrontier(int frontier);
+
+	private:
+		void reducer(int i);
+		void shifter(int i);
+		void addChildren(NodeTree<Symbol>* parent, std::vector<NodeTree<Symbol>*>* children, NodeTree<Symbol>* nullableParts);
+
+		void addStates(std::vector< State* >* stateSets, State* state, std::queue<State*>* toDo);
+		void addStateReductionsToTable(State* state);
+		bool fullyReducesToNull(ParseRule* rule);
+		bool reducesToNull(ParseRule* rule);
+		bool reducesToNull(ParseRule* rule, std::vector<Symbol> avoidList);
+
+		bool belongsToFamily(NodeTree<Symbol>* node, std::vector<NodeTree<Symbol>*>* nodes);
+		bool arePacked(std::vector<NodeTree<Symbol>*> nodes);
+		bool isPacked(NodeTree<Symbol>* node);
+		void setPacked(NodeTree<Symbol>* node, bool isPacked);
+
+		NodeTree<Symbol>* getNullableParts(ParseRule* rule);
+		NodeTree<Symbol>* getNullableParts(ParseRule* rule, std::vector<NodeTree<Symbol>*> avoidList);
+		NodeTree<Symbol>* getNullableParts(Symbol symbol);
+
+		std::vector<NodeTree<Symbol>*> getPathEdges(std::vector<NodeTree<int>*> path);
+
+		int findLine(int tokenNum); //Get the line number for a token, used for error reporting
+
+		std::vector<Symbol> input;
+		GraphStructuredStack gss;
+		//start node, lefthand side of the reduction, reduction length
+		struct Reduction {
+			NodeTree<int>* from;
+			Symbol symbol;
+			int length;
+			NodeTree<Symbol>* nullableParts;
+			NodeTree<Symbol>* label;
+		} ;
+		std::queue<Reduction> toReduce;
+		//Node coming from, state going to
+		std::queue< std::pair<NodeTree<int>*, int> > toShift;
+		std::vector<std::pair<NodeTree<Symbol>*, int> > SPPFStepNodes;
+
+		std::vector<NodeTree<Symbol>*> nullableParts;
+		std::map<NodeTree<Symbol>, bool> packedMap;
+
+        std::map<ParseRule*, bool> reduceToNullMap;
+};
+
+#endif

deprecated_compiler/include/RegEx.h

@@ -0,0 +1,29 @@
+#ifndef REGEX_H
+#define REGEX_H
+
+#include "util.h"
+#include "RegExState.h"
+#include "Symbol.h"
+
+#include <string>
+#include <utility>
+#include <stack>
+#include <vector>
+
+class RegEx {
+	public:
+		RegEx();
+		RegEx(std::string inPattern);
+		~RegEx();
+
+		RegExState* construct(std::vector<RegExState*>* ending, std::string pattern);
+		int longMatch(std::string stringToMatch);
+		std::string getPattern();
+		std::string toString();
+		static void test();
+	private:
+		std::string pattern;
+		RegExState* begin;
+		std::vector<RegExState*> currentStates;
+};
+#endif

deprecated_compiler/include/RegExState.h

@@ -0,0 +1,32 @@
+#ifndef REGEXSTATE_H
+#define REGEXSTATE_H
+
+#include "util.h"
+#include "Symbol.h"
+
+#include <string>
+#include <vector>
+
+class RegExState {
+	public:
+		RegExState(char inCharacter);
+		RegExState();
+		~RegExState();
+
+		void addNext(RegExState* nextState);
+		bool characterIs(char inCharacter);
+		std::vector<RegExState*> advance(char advanceCharacter);
+		std::vector<RegExState*> getNextStates();
+
+		bool isGoal();
+		std::string toString();
+		std::string toString(RegExState* avoid);
+		std::string toString(std::vector<RegExState*>* avoid);
+
+		char getCharacter();
+
+	private:
+		std::vector<RegExState*> nextStates;
+		char character;
+};
+#endif

deprecated_compiler/include/RemovalTransformation.h

@@ -0,0 +1,50 @@
+#ifndef REMOVALTRANSFORMATION_H
+#define REMOVALTRANSFORMATION_H
+
+#include <queue>
+#include <vector>
+
+#include "NodeTransformation.h"
+
+template<class T>
+class RemovalTransformation: public NodeTransformation<T,T> {
+	public:
+		RemovalTransformation(T toRemove);
+		~RemovalTransformation();
+		virtual NodeTree<T>* transform(NodeTree<T>* from);
+
+	private:
+		T toRemove;
+};
+
+#endif
+
+template<class T>
+RemovalTransformation<T>::RemovalTransformation(T toRemove) {
+	this->toRemove = toRemove;
+}
+
+template<class T>
+RemovalTransformation<T>::~RemovalTransformation() {
+	//
+}
+
+template<class T>
+NodeTree<T>* RemovalTransformation<T>::transform(NodeTree<T>* from) {
+	std::queue<NodeTree<T>*> toProcess;
+	toProcess.push(from);
+	while(!toProcess.empty()) {
+		NodeTree<T>* node = toProcess.front();
+		toProcess.pop();
+        if (!node)
+            continue;
+		std::vector<NodeTree<T>*> children = node->getChildren();
+		for (int i = 0; i < children.size(); i++) {
+			if (children[i]->getData() == toRemove)
+				node->removeChild(children[i]);
+			else if (children[i])
+				toProcess.push(children[i]);
+		}
+	}
+	return from;
+}

deprecated_compiler/include/State.h

@@ -0,0 +1,46 @@
+#ifndef STATE_H
+#define STATE_H
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+#include "util.h"
+#include "ParseRule.h"
+
+#include <vector>
+#include <string>
+#include <string>
+#include <sstream>
+
+class State {
+	public:
+		State(int number, ParseRule* basis);
+		State(int number, ParseRule* basis, State* parent);
+		~State();
+		bool const operator==(const State &other);
+		bool const basisEquals(const State &other);
+		bool const basisEqualsExceptLookahead(const State &other);
+		bool const operator!=(const State &other);
+		std::vector<ParseRule*>* getBasis();
+		std::vector<ParseRule*>* getRemaining();
+		std::vector<ParseRule*> getTotal();
+		bool containsRule(ParseRule* rule);
+		void addRuleCombineLookahead(ParseRule* rule);
+		std::string toString();
+
+		void combineStates(State &other);
+		void addParents(std::vector<State*>* parents);
+		std::vector<State*>* getParents();
+		std::vector<State*>* getDeepParents(int depth);
+		int getNumber();
+
+
+		std::vector<ParseRule*> basis;
+		std::vector<ParseRule*> remaining;
+	private:
+		std::vector<State*> parents;
+		int number;
+};
+
+#endif

deprecated_compiler/include/StringReader.h

@@ -0,0 +1,28 @@
+#ifndef StringReader_H
+#define StringReader_H
+
+#include <vector>
+#include <string>
+#include <iostream>
+
+class StringReader
+{
+    public:
+        StringReader();
+        StringReader(std::string inputString);
+        virtual ~StringReader();
+        void setString(std::string inputString);
+        std::string word(bool truncateEnd = true);
+        std::string line(bool truncateEnd = true);
+        std::string getTokens(const char *get_chars, bool truncateEnd = true);
+        std::string truncateEnd(std::string to_truncate);
+
+        static void test();
+    protected:
+    private:
+        std::string rd_string;
+        int str_pos;
+        bool end_reached;
+};
+
+#endif

deprecated_compiler/include/Symbol.h

@@ -0,0 +1,37 @@
+#ifndef SYMBOL_H
+#define SYMBOL_H
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+#include "NodeTree.h"
+
+#include <vector>
+#include <string>
+
+class Symbol {
+	public:
+		Symbol();
+		Symbol(std::string name, bool isTerminal);
+		Symbol(std::string name, bool isTerminal, std::string value);
+		Symbol(std::string name, bool isTerminal, NodeTree<Symbol>* tree);
+		~Symbol();
+		bool const operator==(const Symbol &other)const;
+		bool const operator!=(const Symbol &other)const;
+		bool const operator<(const Symbol &other)const;
+
+		std::string getName() const;
+		std::string getValue() const;
+		std::string toString() const;
+		Symbol clone();
+		void setSubTree(NodeTree<Symbol>* tree);
+		NodeTree<Symbol>* getSubTree();
+		bool isTerminal();
+	private:
+		std::string name;
+		std::string value;
+		bool terminal;
+};
+
+#endif

deprecated_compiler/include/Table.h

@@ -0,0 +1,37 @@
+#include <fstream>
+
+#include <string>
+#include <utility>
+
+#include "util.h"
+#include "ParseRule.h"
+#include "ParseAction.h"
+#include "Symbol.h"
+#include "State.h"
+
+#ifndef TABLE_H
+#define TABLE_H
+
+class Table {
+	public:
+		Table();
+		~Table();
+		void exportTable(std::ofstream &file);
+		void importTable(char* tableData);
+		void setSymbols(Symbol EOFSymbol, Symbol nullSymbol);
+		void add(int stateNum, Symbol tranSymbol, ParseAction* action);
+		void remove(int stateNum, Symbol tranSymbol);
+		std::vector<ParseAction*>* get(int state, Symbol token);
+		ParseAction* getShift(int state, Symbol token);
+	    std::vector<std::pair<std::string, ParseAction>> stateAsParseActionVector(int state);
+        std::string toString();
+	private:
+		std::vector< std::vector< std::vector<ParseAction*>* >* >  table;
+		std::vector<Symbol> symbolIndexVec;
+		//The EOFSymbol, a pointer because of use in table, etc
+		Symbol EOFSymbol;
+		//The nullSymbol, ditto with above. Also used in comparisons
+		Symbol nullSymbol;
+};
+
+#endif

deprecated_compiler/include/Tester.h

@@ -0,0 +1,32 @@
+#include <iostream>
+#include <string>
+
+#include <stdlib.h>
+
+#include "util.h"
+
+#ifndef TESTER_H
+#define TESTER_H
+
+class Tester {
+	public:
+		Tester(std::string krakenInvocation, std::string krakenGrammerLocation);
+		~Tester();
+		bool run(std::string fileName);
+		bool compareFiles(std::string file1Path, std::string file2Path);
+		void cleanExtras(std::string path);
+
+	private:
+		std::string krakenInvocation;
+		std::string krakenGrammerLocation;
+		std::string removeCmd;
+		std::string resultsExtention;
+		std::string expectedExtention;
+		std::string krakenExtention;
+		std::string shell;
+		std::string changePermissions;
+		std::string redirect;
+		std::string sep;
+		std::string cd;
+};
+#endif

deprecated_compiler/include/Type.h

@@ -0,0 +1,64 @@
+#ifndef TYPE_H
+#define TYPE_H
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+#include <string>
+#include <iostream>
+#include <set>
+
+//Circular dependency
+class ASTData;
+#include "ASTData.h"
+#include "util.h"
+
+enum ValueType {none, template_type, template_type_type, void_type, boolean, character, integer, floating, double_percision, function_type };
+
+
+class Type {
+	public:
+		Type();
+		Type(ValueType typeIn, int indirectionIn = 0);
+        Type(ValueType typeIn, std::set<std::string> traitsIn); //Mostly for template type type's
+		Type(NodeTree<ASTData>* typeDefinitionIn, int indirectionIn = 0);
+		Type(NodeTree<ASTData>* typeDefinitionIn, std::set<std::string> traitsIn);
+		Type(ValueType typeIn, NodeTree<ASTData>* typeDefinitionIn, int indirectionIn, bool referenceIn, std::set<std::string> traitsIn);
+		Type(ValueType typeIn, NodeTree<ASTData>* typeDefinitionIn, int indirectionIn, bool referenceIn, std::set<std::string> traitsIn, std::vector<Type*> parameterTypesIn, Type* returnTypeIn);
+		Type(std::vector<Type*> parameterTypesIn, Type* returnTypeIn, bool referenceIn = false);
+		Type(ValueType typeIn, NodeTree<Symbol>* templateDefinitionIn, std::set<std::string> traitsIn = std::set<std::string>());
+		~Type();
+        const bool test_equality(const Type &other, bool care_about_references) const;
+		bool const operator==(const Type &other)const;
+		bool const operator!=(const Type &other)const;
+		bool const operator<(const Type &other)const;
+		Type* clone();
+		std::string toString(bool showTraits = true);
+		int getIndirection();
+		void setIndirection(int indirectionIn);
+		void increaseIndirection();
+		void decreaseIndirection();
+		void modifyIndirection(int mod);
+		Type withIncreasedIndirection();
+		Type withReference();
+		Type *withReferencePtr();
+        Type *withIncreasedIndirectionPtr();
+		Type withDecreasedIndirection();
+
+		Type* withoutReference();
+
+        ValueType baseType;
+		NodeTree<ASTData>* typeDefinition;
+		NodeTree<Symbol>* templateDefinition;
+        std::map<std::string, Type*> templateTypeReplacement;
+        bool templateInstantiated;
+        std::set<std::string> traits;
+        std::vector<Type*> parameterTypes;
+        Type *returnType;
+		bool is_reference;
+    private:
+		int indirection;
+};
+
+#endif

deprecated_compiler/include/util.h

@@ -0,0 +1,92 @@
+#ifndef UTIL_H
+#define UTIL_H
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+#include <iostream>
+#include <string>
+#include <sstream>
+#include <vector>
+#include <set>
+#include <fstream>
+#include <cstring>
+
+int ssystem(std::string command);
+std::string intToString(int theInt);
+std::string replaceExEscape(std::string first, std::string search, std::string replace);
+std::string strSlice(std::string str, int begin, int end);
+int findPerenEnd(std::string str, int i);
+std::vector<std::string> split(const std::string &str, char delim);
+std::string join(const std::vector<std::string> &strVec, std::string joinStr);
+std::string readFile(std::istream &file);
+std::string padWithSpaces(std::string str, int padTo);
+
+template <typename T, typename U, typename V>
+class triple {
+    public:
+        T first;
+        U second;
+        V third;
+};
+template <typename T, typename U, typename V>
+triple<T,U,V> make_triple(T f, U s, V t) {
+    triple<T,U,V> out;
+    out.first = f;
+    out.second = s;
+    out.third = t;
+    return out;
+}
+
+template <typename T>
+bool contains(std::vector<T> vec, T item) {
+    for (auto i : vec)
+        if (i == item)
+            return true;
+    return false;
+}
+
+template <typename T>
+std::vector<T> flatten(std::vector<std::vector<T>> vec) {
+    std::vector<T> flat;
+    for (auto i : vec)
+        flat.insert(flat.end(), i.begin(), i.end());
+    return flat;
+}
+
+template <typename T>
+std::vector<T> reverse(std::vector<T> vec) {
+    std::vector<T> flat;
+    flat.insert(flat.end(), vec.rbegin(), vec.rend());
+    return flat;
+}
+
+template <typename T>
+std::vector<T> dereferenced(std::vector<T*> vec) {
+    std::vector<T> de;
+    for (T* i:vec)
+        de.push_back(*i);
+    return de;
+}
+
+template <typename T>
+std::vector<T> slice(std::vector<T> vec, int begin, int end, int step = 1) {
+    std::vector<T> toReturn;
+    if (begin < 0)
+        begin += vec.size()+1;
+    if (end < 0)
+        end += vec.size()+1;
+    for (int i = begin; i < end; i += step)
+    	toReturn.push_back(vec[i]);
+    return toReturn;
+}
+
+template <typename T>
+bool subset(std::set<T> a, std::set<T> b) {
+    for (auto i : a)
+        if (b.find(i) == b.end())
+            return false;
+    return true;
+}
+#endif