Some more AST work. Functions no longer retain an identifer for their name.

include/ASTData.h

@@ -2,14 +2,15 @@
 #define ASTDATA_H
 
 #include <vector>
+#include <set>
 #include "Symbol.h"
 
 #ifndef NULL
 #define NULL 0
 #endif
 
-enum ASTType {translation_unit, interpreter_directive, identifier,
+enum ASTType {undef, translation_unit, interpreter_directive, import, identifier,
-	import, function, code_block,
+	function, code_block,
 	typed_parameter, expression, boolean_expression, statement,
 	if_statement, return_statement, assignment_statement, function_call,
 	value};

include/CollapseTransformation.h

@@ -42,8 +42,9 @@ NodeTree<T>* CollapseTransformation<T>::transform(NodeTree<T>* from) {
 				node->removeChild(children[i]);
 				std::vector<NodeTree<T>*> newChildren = children[i]->getChildren();
 				node->addChildren(newChildren);
-				for (int j = 0; j < newChildren.size(); j++)
+				toProcess.push(node); //Do this node again
-					toProcess.push(newChildren[j]);
+				// for (int j = 0; j < newChildren.size(); j++)
+				// 	toProcess.push(newChildren[j]);
 			}
 			else
 				toProcess.push(children[i]);

main.cpp

@@ -108,12 +108,15 @@ int main(int argc, char* argv[]) {
 	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)));
+	preASTTransforms.push_back(new RemovalTransformation<Symbol>(Symbol("if", true)));
+	preASTTransforms.push_back(new RemovalTransformation<Symbol>(Symbol("while", true)));
 	//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)));
+	preASTTransforms.push_back(new CollapseTransformation<Symbol>(Symbol("statement_list", false)));
 
 	for (int i = 0; i < preASTTransforms.size(); i++) {
 		parseTree = preASTTransforms[i]->transform(parseTree);

src/ASTData.cpp

@@ -1,6 +1,7 @@
 #include "ASTData.h"
 
 ASTData::ASTData() {
+	this->type = undef;
 }
 
 ASTData::ASTData(ASTType type, ValueType valueType) {

src/ASTTransformation.cpp

@@ -13,21 +13,63 @@ NodeTree<ASTData>* ASTTransformation::transform(NodeTree<Symbol>* from) {
 	std::string name = current.getName();
 	NodeTree<ASTData>* newNode;
 	std::vector<NodeTree<Symbol>*> children = from->getChildren();
+	std::set<int> skipChildren;
 
 	if (name == "translation_unit") {
 		newNode = new NodeTree<ASTData>(name, ASTData(translation_unit));
+	} else if (name == "interpreter_directive") {
+		newNode = new NodeTree<ASTData>(name, ASTData(interpreter_directive));
 	} 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 == "identifier") {
+		newNode = new NodeTree<ASTData>(name, ASTData(identifier));
 	} else if (name == "function") {
 		newNode = new NodeTree<ASTData>(name, ASTData(function, Symbol(concatSymbolTree(children[1]), true), ASTData::strToType(concatSymbolTree(children[0]))));
+		skipChildren.insert(0);
+		skipChildren.insert(1);
+	} else if (name == "code_block") {
+		newNode = new NodeTree<ASTData>(name, ASTData(code_block));
+	} else if (name == "typed_parameter") {
+		newNode = new NodeTree<ASTData>(name, ASTData(typed_parameter));
+	} else if (name == "expression") {
+		newNode = new NodeTree<ASTData>(name, ASTData(expression));
+	}else if (name == "term") {
+		//If this is an actual part of an expression, not just a premoted factor
+		if (children.size() > 1) {
+			std::string functionCallName = concatSymbolTree(children[1]);
+			newNode = new NodeTree<ASTData>(functionCallName, ASTData(function_call, Symbol(functionCallName, true)));
+			skipChildren.insert(1);
+		} else {
+			newNode = new NodeTree<ASTData>();
+		}
+	} else if (name == "boolean_expression") {
+		newNode = new NodeTree<ASTData>(name, ASTData(boolean_expression));
+	} else if (name == "statement") {
+		newNode = new NodeTree<ASTData>(name, ASTData(statement));
+	} else if (name == "if_statement") {
+		newNode = new NodeTree<ASTData>(name, ASTData(if_statement));
+	} else if (name == "return_statement") {
+		newNode = new NodeTree<ASTData>(name, ASTData(return_statement));
+	} else if (name == "assignment_statement") {
+		newNode = new NodeTree<ASTData>(name, ASTData(assignment_statement));
+	} else if (name == "function_call") {
+		newNode = new NodeTree<ASTData>(name, ASTData(function_call));
+	} else if (name == "value") {
+		newNode = new NodeTree<ASTData>(name, ASTData(value));
 	} 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]));
+		if (skipChildren.find(i) == skipChildren.end()) {
+			NodeTree<ASTData>* transChild = transform(children[i]);
+			if (transChild->getData().type)
+				newNode->addChild(transChild);
+			else
+				delete transChild;
+		}
 	}
 
 	return newNode;