diff --git a/include/ASTTransformation.h b/include/ASTTransformation.h index 36e4819..4fb8d09 100644 --- a/include/ASTTransformation.h +++ b/include/ASTTransformation.h @@ -22,7 +22,7 @@ class ASTTransformation: public NodeTransformation { std::string concatSymbolTree(NodeTree* root); NodeTree* doFunction(NodeTree* scope, std::string lookup, std::vector*> nodes); NodeTree* scopeLookup(NodeTree* scope, std::string lookup, std::vector types = std::vector()); - Type* typeFromString(std::string type, NodeTree* scope); + Type* typeFromTypeNode(NodeTree* typeNode, NodeTree* scope); private: Importer * importer; std::map*>> languageLevelScope; diff --git a/krakenGrammer.kgm b/krakenGrammer.kgm index 352eb4d..66bc097 100644 --- a/krakenGrammer.kgm +++ b/krakenGrammer.kgm @@ -2,7 +2,8 @@ Goal = translation_unit ; translation_unit = interpreter_directive WS unorderd_list_part WS ; unorderd_list_part = import WS unorderd_list_part | function WS unorderd_list_part | type_def WS ";" WS unorderd_list_part | if_comp WS unorderd_list_part | simple_passthrough WS unorderd_list_part | declaration_statement WS ";" WS unorderd_list_part | import | function | type_def WS ";" | if_comp | simple_passthrough | declaration_statement WS ";" ; -type = type WS "\*" | "void" | "int" | "float" | "double" | "char" | identifier ; +type = type WS "\*" | "void" | "int" | "float" | "double" | "char" | identifier | identifier WS template_inst ; +template_inst = "<" WS type WS ">" ; import = "import" WS identifier WS ";" ; @@ -41,7 +42,8 @@ opt_parameter_list = parameter_list | ; parameter_list = parameter_list WS "," WS parameter | parameter ; parameter = boolean_expression ; -type_def = "typedef" WS identifier WS type | "typedef" WS identifier WS "{" WS class_innerds WS "}" | "typedef" WS identifier WS "{" WS declaration_block WS "}" ; +type_def = "typedef" WS identifier WS type | "typedef" WS template_dec WS identifier WS "{" WS class_innerds WS "}" | "typedef" WS template_dec WS identifier WS "{" WS declaration_block WS "}" ; +template_dec = "template" WS "<" WS identifier WS ">" | ; class_innerds = visibility_block WS class_innerds | visibility_block ; visibility_block = "public:" WS declaration_block | "protected:" WS declaration_block | "private:" WS declaration_block ; declaration_block = declaration_statement WS ";" WS declaration_block | function WS declaration_block | declaration_statement WS ";" | function ; diff --git a/src/ASTTransformation.cpp b/src/ASTTransformation.cpp index 97b7c15..751b64c 100644 --- a/src/ASTTransformation.cpp +++ b/src/ASTTransformation.cpp @@ -72,23 +72,34 @@ NodeTree* ASTTransformation::transform(NodeTree* from, NodeTree } //newNode = new NodeTree(name, ASTData(identifier, Symbol(concatSymbolTree(children[0]), true))); } else if (name == "type_def") { - std::string typeAlias = concatSymbolTree(children[0]); //If it is an alisis of a type + std::string typeAlias; if (children[1]->getData().getName() == "type") { - newNode = new NodeTree(name, ASTData(type_def, Symbol(typeAlias, true, typeAlias), typeFromString(concatSymbolTree(children[1]), scope))); + typeAlias = concatSymbolTree(children[0]); + newNode = new NodeTree(name, ASTData(type_def, Symbol(typeAlias, true, typeAlias), typeFromTypeNode(children[1], scope))); skipChildren.insert(1); //Don't want any children, it's unnecessary for ailising } else { //Is a struct or class + Type* objectType = NULL; + if (children[0]->getData().getName() == "template_dec") { + typeAlias = concatSymbolTree(children[1]); + objectType = new Type(newNode), std::cout << "Template Type!"<(name, ASTData(type_def, Symbol(typeAlias, true, typeAlias))); - newNode->getDataRef()->valueType = new Type(newNode); //Type is self-referential since this is the definition + newNode->getDataRef()->valueType = objectType; //Type is self-referential since this is the definition } scope->getDataRef()->scope[typeAlias].push_back(newNode); newNode->getDataRef()->scope["~enclosing_scope"].push_back(scope); scope = newNode; - skipChildren.insert(0); //Identifier lookup will be ourselves, as we just added ourselves to the scope //return newNode; } else if (name == "function") { std::string functionName = concatSymbolTree(children[1]); - newNode = new NodeTree(name, ASTData(function, Symbol(functionName, true), typeFromString(concatSymbolTree(children[0]), scope))); + newNode = new NodeTree(name, ASTData(function, Symbol(functionName, true), typeFromTypeNode(children[0], scope))); skipChildren.insert(0); skipChildren.insert(1); scope->getDataRef()->scope[functionName].push_back(newNode); @@ -111,8 +122,8 @@ NodeTree* ASTTransformation::transform(NodeTree* from, NodeTree } else if (name == "typed_parameter") { //newNode = transform(children[1]); //Transform to get the identifier std::string parameterName = concatSymbolTree(children[1]); - std::string typeString = concatSymbolTree(children[0]);//Get the type (left child) and set our new identifer to be that type - newNode = new NodeTree("identifier", ASTData(identifier, Symbol(parameterName, true), typeFromString(typeString, scope))); + //std::string typeString = concatSymbolTree(children[0]);//Get the type (left child) and set our new identifer to be that type + newNode = new NodeTree("identifier", ASTData(identifier, Symbol(parameterName, true), typeFromTypeNode(children[0], scope))); scope->getDataRef()->scope[parameterName].push_back(newNode); newNode->getDataRef()->scope["~enclosing_scope"].push_back(scope); return newNode; @@ -252,21 +263,12 @@ NodeTree* ASTTransformation::transform(NodeTree* from, NodeTree // newIdentifier->getDataRef()->valueType = Type(concatSymbolTree(children[0]));//set the type of the identifier std::string newIdentifierStr = concatSymbolTree(children[1]); std::string typeString = concatSymbolTree(children[0]);//Get the type (left child) and set our new identifer to be that type - Type* identifierType = typeFromString(typeString, scope); + Type* identifierType = typeFromTypeNode(children[0], scope); NodeTree* newIdentifier = new NodeTree("identifier", ASTData(identifier, Symbol(newIdentifierStr, true), identifierType)); scope->getDataRef()->scope[newIdentifierStr].push_back(newIdentifier); newNode->getDataRef()->scope["~enclosing_scope"].push_back(scope); - //Now we don't do this thing - // if (identifierType->typeDefinition) { - // //Is a custom type. Populate this declaration's scope with it's inner declarations - // std::vector*> definitions = identifierType->typeDefinition->getChildren(); - // for (auto i : definitions) { - // //Point to the identifier. May need to change so it points to the declaration or something, with new declarations..... - // newIdentifier->getDataRef()->scope[i->get(0)->getDataRef()->symbol.getName()] = i->get(0); //make each declaration's name point to it's definition, like above - // } - // } - newNode->addChild(newIdentifier); + skipChildren.insert(0); //These, the type and the identifier, have been taken care of. skipChildren.insert(1); } else if (name == "if_comp") { @@ -301,7 +303,7 @@ NodeTree* ASTTransformation::transform(NodeTree* from, NodeTree return transform(children[0], scope, types); //Don't need a parameter node, just the value } else if (name == "type") { std::string theConcat = concatSymbolTree(from); //We have no symbol, so this will concat our children - newNode = new NodeTree(name, ASTData(value, Symbol(theConcat, true), typeFromString(theConcat, scope))); + newNode = new NodeTree(name, ASTData(value, Symbol(theConcat, true), typeFromTypeNode(from, scope))); } else if (name == "number") { return transform(children[0], scope, types); } else if (name == "integer") { @@ -486,7 +488,13 @@ NodeTree* ASTTransformation::scopeLookup(NodeTree* scope, std: return NULL; } -Type* ASTTransformation::typeFromString(std::string typeIn, NodeTree* scope) { +Type* ASTTransformation::typeFromTypeNode(NodeTree* typeNode, NodeTree* scope) { + std::string typeIn; + if (typeNode->getChildren().size() > 1 && typeNode->getChildren()[1]->getData().getName() == "template_inst") + typeIn = concatSymbolTree(typeNode->getChildren()[0]); //Not including the possible template for now + else + typeIn = concatSymbolTree(typeNode); + int indirection = 0; ValueType baseType; NodeTree* typeDefinition = NULL; @@ -499,8 +507,8 @@ Type* ASTTransformation::typeFromString(std::string typeIn, NodeTree* s else if (edited == "int") baseType = integer; else if (edited == "float") - baseType = floating -; else if (edited == "double") + baseType = floating; + else if (edited == "double") baseType = double_percision; else if (edited == "char") baseType = character; diff --git a/src/Importer.cpp b/src/Importer.cpp index eaf8838..db04e72 100644 --- a/src/Importer.cpp +++ b/src/Importer.cpp @@ -14,13 +14,14 @@ Importer::Importer(Parser* parserIn, std::vector includePaths) { removeSymbols.push_back(Symbol("}", true)); removeSymbols.push_back(Symbol("(", true)); removeSymbols.push_back(Symbol(")", true)); - removeSymbols.push_back(Symbol("import", true)); //Don't need the actual text of the symbol + removeSymbols.push_back(Symbol("import", true)); removeSymbols.push_back(Symbol("interpreter_directive", false)); removeSymbols.push_back(Symbol("if", true)); removeSymbols.push_back(Symbol("while", true)); removeSymbols.push_back(Symbol("__if_comp__", true)); removeSymbols.push_back(Symbol("comp_simple_passthrough", true)); removeSymbols.push_back(Symbol("typedef", true)); + removeSymbols.push_back(Symbol("template", true)); collapseSymbols.push_back(Symbol("opt_typed_parameter_list", false)); collapseSymbols.push_back(Symbol("opt_parameter_list", false));