diff --git a/include/ASTData.h b/include/ASTData.h index 9bf1c25..96cc6c1 100644 --- a/include/ASTData.h +++ b/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; diff --git a/include/ASTTransformation.h b/include/ASTTransformation.h index e41483a..4ecd57f 100644 --- a/include/ASTTransformation.h +++ b/include/ASTTransformation.h @@ -9,6 +9,7 @@ class ASTTransformation: public NodeTransformation { ASTTransformation(); ~ASTTransformation(); virtual NodeTree* transform(NodeTree* from); + std::string concatSymbolTree(NodeTree* root); private: //Nothing diff --git a/include/DeleteTransformation.h b/include/DeleteTransformation.h new file mode 100644 index 0000000..f5434b5 --- /dev/null +++ b/include/DeleteTransformation.h @@ -0,0 +1,48 @@ +#ifndef DELETETRANSFORMATION_H +#define DELETETRANSFORMATION_H + +#include +#include + +#include "NodeTransformation.h" + +template +class DeleteTransformation: public NodeTransformation { + public: + DeleteTransformation(T toDelete); + ~DeleteTransformation(); + virtual NodeTree* transform(NodeTree* from); + + private: + T toRemove; +}; + +#endif + +template +DeleteTransformation::DeleteTransformation(T toRemove) { + this->toRemove = toRemove; +} + +template +DeleteTransformation::~DeleteTransformation() { + // +} + +template +NodeTree* DeleteTransformation::transform(NodeTree* from) { + std::queue*> toProcess; + toProcess.push(from); + while(!toProcess.empty()) { + NodeTree* node = toProcess.front(); + toProcess.pop(); + std::vector*> 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; +} diff --git a/include/Symbol.h b/include/Symbol.h index 3aa491f..1d306b1 100644 --- a/include/Symbol.h +++ b/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* tree); diff --git a/krakenGrammer.kgm b/krakenGrammer.kgm index 0b14dfc..1b275f1 100644 --- a/krakenGrammer.kgm +++ b/krakenGrammer.kgm @@ -60,4 +60,4 @@ double = sign numeric "." numeric | sign numeric "." numeric "d" ; bool = "true" | "false" | "True" | "False" ; alpha = "(a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z|A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z|.|_)+" ; numeric = "(0|1|2|3|4|5|6|7|8|9)+" ; -string = "\"(a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z|A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z|.|!|_|-| | |\\|/|\||0|1|2|3|4|5|6|7|8|9)+\"" ; +string = "\"(a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z|A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z|.|!|_|-| | |\\|/|\||0|1|2|3|4|5|6|7|8|9)+\"" ; \ No newline at end of file diff --git a/main.cpp b/main.cpp index 639dac0..275c452 100644 --- a/main.cpp +++ b/main.cpp @@ -102,14 +102,19 @@ int main(int argc, char* argv[]) { preASTTransforms.push_back(new RemovalTransformation(Symbol("WS", false))); preASTTransforms.push_back(new RemovalTransformation(Symbol("\\(", true))); preASTTransforms.push_back(new RemovalTransformation(Symbol("\\)", true))); - //preASTTransforms.push_back(new RemovalTransformation(Symbol("/", true))); preASTTransforms.push_back(new RemovalTransformation(Symbol("::", true))); preASTTransforms.push_back(new RemovalTransformation(Symbol(";", true))); preASTTransforms.push_back(new RemovalTransformation(Symbol("{", true))); 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))); //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))); + 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; } diff --git a/src/ASTData.cpp b/src/ASTData.cpp index bee0a24..f2f32fd 100644 --- a/src/ASTData.cpp +++ b/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"; + } } diff --git a/src/ASTTransformation.cpp b/src/ASTTransformation.cpp index 564d28b..d04ab97 100644 --- a/src/ASTTransformation.cpp +++ b/src/ASTTransformation.cpp @@ -9,5 +9,38 @@ ASTTransformation::~ASTTransformation() { } NodeTree* ASTTransformation::transform(NodeTree* from) { - return NULL; + Symbol current = from->getData(); + std::string name = current.getName(); + NodeTree* newNode; + std::vector*> children = from->getChildren(); + + if (name == "translation_unit") { + newNode = new NodeTree(name, ASTData(translation_unit)); + } 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 == "function") { + newNode = new NodeTree(name, ASTData(function, Symbol(concatSymbolTree(children[1]), true), ASTData::strToType(concatSymbolTree(children[0])))); + } 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])); + } + + return newNode; +} + +std::string ASTTransformation::concatSymbolTree(NodeTree* root) { + std::string concatString; + std::string ourValue = root->getData().getValue(); + if (ourValue != "NoValue") + concatString += ourValue; + std::vector*> children = root->getChildren(); + for (int i = 0; i < children.size(); i++) { + concatString = concatSymbolTree(children[i]); + } + return concatString; } diff --git a/src/Symbol.cpp b/src/Symbol.cpp index 5acdb2c..4ccb772 100644 --- a/src/Symbol.cpp +++ b/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 : "")); }