Further work on AST transformation

include/ASTData.h

@@ -18,10 +18,14 @@ enum ValueType {none, boolean, integer, floating, double_percision, char_string
 
 class ASTData {
 	public:
+		ASTData();
 		ASTData(ASTType type, ValueType valueType = none);
 		ASTData(ASTType type, Symbol symbol, ValueType valueType = none);
 		~ASTData();
 		std::string toString();
+		static std::string ASTTypeToString(ASTType type);
+		static std::string ValueTypeToString(ValueType type);
+		static ValueType strToType(std::string type);
 		ASTType type;
 		ValueType valueType;
 		Symbol symbol;

include/ASTTransformation.h

@@ -9,6 +9,7 @@ class ASTTransformation: public NodeTransformation<Symbol,ASTData> {
 		ASTTransformation();
 		~ASTTransformation();
 		virtual NodeTree<ASTData>* transform(NodeTree<Symbol>* from);
+		std::string concatSymbolTree(NodeTree<Symbol>* root);
 
 	private:
 		//Nothing

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;
+}

include/Symbol.h

@@ -22,6 +22,7 @@ class Symbol {
 		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);

main.cpp

@@ -102,14 +102,19 @@ int main(int argc, char* argv[]) {
 	preASTTransforms.push_back(new RemovalTransformation<Symbol>(Symbol("WS", false)));
 	preASTTransforms.push_back(new RemovalTransformation<Symbol>(Symbol("\\(", true)));
 	preASTTransforms.push_back(new RemovalTransformation<Symbol>(Symbol("\\)", true)));
-	//preASTTransforms.push_back(new RemovalTransformation<Symbol>(Symbol("/", true)));
 	preASTTransforms.push_back(new RemovalTransformation<Symbol>(Symbol("::", true)));
 	preASTTransforms.push_back(new RemovalTransformation<Symbol>(Symbol(";", true)));
 	preASTTransforms.push_back(new RemovalTransformation<Symbol>(Symbol("{", true)));
 	preASTTransforms.push_back(new RemovalTransformation<Symbol>(Symbol("}", true)));
+	preASTTransforms.push_back(new RemovalTransformation<Symbol>(Symbol("import", true))); //Don't need the actual text of the symbol
+	preASTTransforms.push_back(new RemovalTransformation<Symbol>(Symbol("interpreter_directive", false)));
 	//Collapse Transformations
 	preASTTransforms.push_back(new CollapseTransformation<Symbol>(Symbol("opt_typed_parameter_list", false)));
 	preASTTransforms.push_back(new CollapseTransformation<Symbol>(Symbol("opt_parameter_list", false)));
+	preASTTransforms.push_back(new CollapseTransformation<Symbol>(Symbol("opt_import_list", false)));
+	preASTTransforms.push_back(new CollapseTransformation<Symbol>(Symbol("import_list", false)));
+	preASTTransforms.push_back(new CollapseTransformation<Symbol>(Symbol("function_list", false)));
+
 	for (int i = 0; i < preASTTransforms.size(); i++) {
 		parseTree = preASTTransforms[i]->transform(parseTree);
 	}
@@ -126,7 +131,7 @@ int main(int argc, char* argv[]) {
 
 
 	if (AST) {
-		outFileTransformed << AST->DOTGraphString() << std::endl;
+		outFileAST << AST->DOTGraphString() << std::endl;
 	} else {
 		std::cout << "Tree returned from ASTTransformation is NULL!" << std::endl;
 	}

src/ASTData.cpp

@@ -1,5 +1,8 @@
 #include "ASTData.h"
 
+ASTData::ASTData() {
+}
+
 ASTData::ASTData(ASTType type, ValueType valueType) {
 	this->type = type;
 	this->valueType = valueType;
@@ -16,5 +19,96 @@ ASTData::~ASTData() {
 }
 
 std::string ASTData::toString() {
-	return "ASTData!";
+	return ASTTypeToString(type) + (symbol.isTerminal() ? " " + symbol.toString() : "") + (valueType ? " " + ValueTypeToString(valueType) : "");
+}
+
+ValueType ASTData::strToType(std::string type) {
+	if (type == "bool") 
+		return boolean;
+	else if (type == "int")
+		return integer;
+	else if (type == "float")
+		return floating;
+	else if (type == "double")
+		return double_percision;
+	else if (type == "string")
+		return char_string;
+	else return none;
+}
+
+std::string ASTData::ValueTypeToString(ValueType type) {
+	switch (type) {
+		case none:
+			return "none";
+			break;
+		case boolean:
+			return "boolean";
+			break;
+		case integer:
+			return "integer";
+			break;
+		case floating:
+			return "floating";
+			break;
+		case double_percision:
+			return "double_percision";
+			break;
+		case char_string:
+			return "char_string";
+			break;
+		default:
+			return "unknown_ValueType";
+	}
+}
+
+std::string ASTData::ASTTypeToString(ASTType type) {
+	switch (type) {
+		case translation_unit:
+			return "translation_unit";
+			break;
+		case interpreter_directive:
+			return "interpreter_directive";
+			break;
+		case identifier:
+			return "identifier";
+			break;
+		case import:
+			return "import";
+			break;
+		case function:
+			return "function";
+			break;
+		case code_block:
+			return "code_block";
+			break;
+		case typed_parameter:
+			return "typed_parameter";
+			break;
+		case expression:
+			return "expression";
+			break;
+		case boolean_expression:
+			return "boolean_expression";
+			break;
+		case statement:
+			return "statement";
+			break;
+		case if_statement:
+			return "if_statement";
+			break;
+		case return_statement:
+			return "return_statement";
+			break;
+		case assignment_statement:
+			return "assignment_statement";
+			break;
+		case function_call:
+			return "function_call";
+			break;
+		case value:
+			return "value";
+			break;
+		default:
+			return "unknown_ASTType";
+	}
 }

src/ASTTransformation.cpp

@@ -9,5 +9,38 @@ ASTTransformation::~ASTTransformation() {
 }
 
 NodeTree<ASTData>* ASTTransformation::transform(NodeTree<Symbol>* from) {
-	return NULL;
+	Symbol current = from->getData();
+	std::string name = current.getName();
+	NodeTree<ASTData>* newNode;
+	std::vector<NodeTree<Symbol>*> children = from->getChildren();
+
+	if (name == "translation_unit") {
+		newNode = new NodeTree<ASTData>(name, ASTData(translation_unit));
+	} else if (name == "import" && !current.isTerminal()) {
+		newNode = new NodeTree<ASTData>(name, ASTData(import, Symbol(concatSymbolTree(children[0]), true)));
+		return newNode; // Don't need children of import
+	} else if (name == "function") {
+		newNode = new NodeTree<ASTData>(name, ASTData(function, Symbol(concatSymbolTree(children[1]), true), ASTData::strToType(concatSymbolTree(children[0]))));
+	} else {
+		return new NodeTree<ASTData>();
+	}
+
+	// In general, iterate through children and do them. Might not do this for all children.
+	for (int i = 0; i < children.size(); i++) {
+		newNode->addChild(transform(children[i]));
+	}
+
+	return newNode;
+}
+
+std::string ASTTransformation::concatSymbolTree(NodeTree<Symbol>* root) {
+	std::string concatString;
+	std::string ourValue = root->getData().getValue();
+	if (ourValue != "NoValue")
+		concatString += ourValue;
+	std::vector<NodeTree<Symbol>*> children = root->getChildren();
+	for (int i = 0; i < children.size(); i++) {
+		concatString = concatSymbolTree(children[i]);	
+	}
+	return concatString;
 }

src/Symbol.cpp

@@ -47,6 +47,10 @@ std::string Symbol::getName() const {
 	return(name);
 }
 
+std::string Symbol::getValue() const {
+	return(value);
+}
+
 std::string Symbol::toString() const {
 	return(name + (terminal ? " " + value : ""));
 }