From e818236e909b90cc321f6f5985c45c7983d22959 Mon Sep 17 00:00:00 2001 From: Nathan Braswell Date: Sat, 26 Oct 2013 11:47:34 -0400 Subject: [PATCH] Some more AST work. Functions no longer retain an identifer for their name. --- include/ASTData.h | 5 ++-- include/CollapseTransformation.h | 5 ++-- main.cpp | 3 +++ src/ASTData.cpp | 1 + src/ASTTransformation.cpp | 44 +++++++++++++++++++++++++++++++- 5 files changed, 53 insertions(+), 5 deletions(-) diff --git a/include/ASTData.h b/include/ASTData.h index 96cc6c1..b603224 100644 --- a/include/ASTData.h +++ b/include/ASTData.h @@ -2,14 +2,15 @@ #define ASTDATA_H #include +#include #include "Symbol.h" #ifndef NULL #define NULL 0 #endif -enum ASTType {translation_unit, interpreter_directive, identifier, - import, function, code_block, +enum ASTType {undef, translation_unit, interpreter_directive, import, identifier, + function, code_block, typed_parameter, expression, boolean_expression, statement, if_statement, return_statement, assignment_statement, function_call, value}; diff --git a/include/CollapseTransformation.h b/include/CollapseTransformation.h index 7863a79..a9b3226 100644 --- a/include/CollapseTransformation.h +++ b/include/CollapseTransformation.h @@ -42,8 +42,9 @@ NodeTree* CollapseTransformation::transform(NodeTree* from) { node->removeChild(children[i]); std::vector*> newChildren = children[i]->getChildren(); node->addChildren(newChildren); - for (int j = 0; j < newChildren.size(); j++) - toProcess.push(newChildren[j]); + toProcess.push(node); //Do this node again + // for (int j = 0; j < newChildren.size(); j++) + // toProcess.push(newChildren[j]); } else toProcess.push(children[i]); diff --git a/main.cpp b/main.cpp index 275c452..6281f91 100644 --- a/main.cpp +++ b/main.cpp @@ -108,12 +108,15 @@ int main(int argc, char* argv[]) { preASTTransforms.push_back(new RemovalTransformation(Symbol("}", true))); preASTTransforms.push_back(new RemovalTransformation(Symbol("import", true))); //Don't need the actual text of the symbol preASTTransforms.push_back(new RemovalTransformation(Symbol("interpreter_directive", false))); + preASTTransforms.push_back(new RemovalTransformation(Symbol("if", true))); + preASTTransforms.push_back(new RemovalTransformation(Symbol("while", true))); //Collapse Transformations preASTTransforms.push_back(new CollapseTransformation(Symbol("opt_typed_parameter_list", false))); preASTTransforms.push_back(new CollapseTransformation(Symbol("opt_parameter_list", false))); preASTTransforms.push_back(new CollapseTransformation(Symbol("opt_import_list", false))); preASTTransforms.push_back(new CollapseTransformation(Symbol("import_list", false))); preASTTransforms.push_back(new CollapseTransformation(Symbol("function_list", false))); + preASTTransforms.push_back(new CollapseTransformation(Symbol("statement_list", false))); for (int i = 0; i < preASTTransforms.size(); i++) { parseTree = preASTTransforms[i]->transform(parseTree); diff --git a/src/ASTData.cpp b/src/ASTData.cpp index f2f32fd..51c5ad6 100644 --- a/src/ASTData.cpp +++ b/src/ASTData.cpp @@ -1,6 +1,7 @@ #include "ASTData.h" ASTData::ASTData() { + this->type = undef; } ASTData::ASTData(ASTType type, ValueType valueType) { diff --git a/src/ASTTransformation.cpp b/src/ASTTransformation.cpp index d04ab97..364c303 100644 --- a/src/ASTTransformation.cpp +++ b/src/ASTTransformation.cpp @@ -13,21 +13,63 @@ NodeTree* ASTTransformation::transform(NodeTree* from) { std::string name = current.getName(); NodeTree* newNode; std::vector*> children = from->getChildren(); + std::set skipChildren; if (name == "translation_unit") { newNode = new NodeTree(name, ASTData(translation_unit)); + } else if (name == "interpreter_directive") { + newNode = new NodeTree(name, ASTData(interpreter_directive)); } else if (name == "import" && !current.isTerminal()) { newNode = new NodeTree(name, ASTData(import, Symbol(concatSymbolTree(children[0]), true))); return newNode; // Don't need children of import + } else if (name == "identifier") { + newNode = new NodeTree(name, ASTData(identifier)); } else if (name == "function") { newNode = new NodeTree(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(name, ASTData(code_block)); + } else if (name == "typed_parameter") { + newNode = new NodeTree(name, ASTData(typed_parameter)); + } else if (name == "expression") { + newNode = new NodeTree(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(functionCallName, ASTData(function_call, Symbol(functionCallName, true))); + skipChildren.insert(1); + } else { + newNode = new NodeTree(); + } + } else if (name == "boolean_expression") { + newNode = new NodeTree(name, ASTData(boolean_expression)); + } else if (name == "statement") { + newNode = new NodeTree(name, ASTData(statement)); + } else if (name == "if_statement") { + newNode = new NodeTree(name, ASTData(if_statement)); + } else if (name == "return_statement") { + newNode = new NodeTree(name, ASTData(return_statement)); + } else if (name == "assignment_statement") { + newNode = new NodeTree(name, ASTData(assignment_statement)); + } else if (name == "function_call") { + newNode = new NodeTree(name, ASTData(function_call)); + } else if (name == "value") { + newNode = new NodeTree(name, ASTData(value)); } else { return new NodeTree(); } // 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* transChild = transform(children[i]); + if (transChild->getData().type) + newNode->addChild(transChild); + else + delete transChild; + } } return newNode;