Further work on AST transformation

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 : ""));
 }