miloignis/kraken
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

WOOO compiles all in one file! Dependencies resolved! Next up, C name mangeling for scoping

Browse Source
This commit is contained in:
Nathan Braswell
2015-03-11 01:58:10 -04:00
parent 9e9b4371da
commit 6a311fb237
14 changed files with 230 additions and 133 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -1,5 +1,6 @@
_site
build
build-ninja
*.comp
stats
*.swp

1
include/ASTTransformation.h
View File

@@ -49,6 +49,7 @@ class ASTTransformation: public NodeTransformation<Symbol,ASTData> {
std::vector<NodeTree<ASTData>*> scopeLookup(NodeTree<ASTData>* scope, std::string lookup, bool includeModules = false);
std::vector<NodeTree<ASTData>*> scopeLookup(NodeTree<ASTData>* scope, std::string lookup, bool includeModules, std::vector<NodeTree<ASTData>*> visited);
NodeTree<ASTData>* getUpperTranslationUnit(NodeTree<ASTData>* node);
Type* typeFromTypeNode(NodeTree<Symbol>* typeNode, NodeTree<ASTData>* scope, std::map<std::string, Type*> templateTypeReplacements);
NodeTree<ASTData>* templateClassLookup(NodeTree<ASTData>* scope, std::string name, std::vector<Type*> templateInstantiationTypes);
NodeTree<ASTData>* findOrInstantiateFunctionTemplate(std::vector<NodeTree<Symbol>*> children, NodeTree<ASTData>* scope, std::vector<Type> types, std::map<std::string, Type*> templateTypeReplacements);

4
include/CGenerator.h
View File

@@ -24,9 +24,9 @@ class CGenerator {
std::string generateClassStruct(NodeTree<ASTData>* from);
bool isUnderTranslationUnit(NodeTree<ASTData>* from, NodeTree<ASTData>* typeDefinition);
NodeTree<ASTData>* highestScope(NodeTree<ASTData>* node);
std::pair<std::string, std::string> generateTranslationUnit(NodeTree<ASTData>* from);
std::pair<std::string, std::string> generateTranslationUnit(std::string name, std::map<std::string, NodeTree<ASTData>*> ASTs);
std::string generate(NodeTree<ASTData>* from, NodeTree<ASTData>* enclosingObject = NULL);
std::string generateAliasChains(NodeTree<ASTData>* scopeNode, NodeTree<ASTData>* definition);
std::string generateAliasChains(std::map<std::string, NodeTree<ASTData>*> ASTs, NodeTree<ASTData>* definition);
static std::string ValueTypeToCType(Type *type);
static std::string ValueTypeToCTypeDecoration(Type *type);
static std::string ValueTypeToCTypeThingHelper(Type *type, std::string ptrStr);

45
src/ASTTransformation.cpp
View File

@@ -1112,6 +1112,18 @@ std::vector<NodeTree<ASTData>*> ASTTransformation::scopeLookup(NodeTree<ASTData>
return matches;
}
// Find the translation unit that is the top of the passed in node
NodeTree<ASTData>* ASTTransformation::getUpperTranslationUnit(NodeTree<ASTData>* node) {
auto scope = node->getDataRef()->scope;
auto iter = scope.find("~enclosing_scope");
while(iter != scope.end()) {
node = iter->second[0];
scope = node->getDataRef()->scope;
iter = scope.find("~enclosing_scope");
}
return node;
}
//Create a type from a syntax tree. This can get complicated with templates
Type* ASTTransformation::typeFromTypeNode(NodeTree<Symbol>* typeNode, NodeTree<ASTData>* scope, std::map<std::string, Type*> templateTypeReplacements) {
std::string typeIn = concatSymbolTree(typeNode);
@@ -1180,16 +1192,16 @@ Type* ASTTransformation::typeFromTypeNode(NodeTree<Symbol>* typeNode, NodeTree<A
//Finish creating the new name for this instantiation
std::string classNameWithoutTemplate = concatSymbolTree(typeNode->getChildren()[0]);
std::string fullyInstantiatedName = classNameWithoutTemplate + "<" + instTypeString + ">";
std::string templateLookupName = classNameWithoutTemplate + "<" + instTypeString + ">";
// Recheck for prior definition here, now that we have the true name.
possibleMatches = scopeLookup(scope, fullyInstantiatedName);
possibleMatches = scopeLookup(scope, templateLookupName);
if (possibleMatches.size()) {
typeDefinition = possibleMatches[0];
traits = typeDefinition->getDataRef()->valueType->traits;
std::cout << "Found already instantiated template of " << fullyInstantiatedName << " at second check" << std::endl;
std::cout << "Found already instantiated template of " << templateLookupName << " at second check" << std::endl;
} else {
std::cout << "Did not find already instantiated template of " << fullyInstantiatedName << " at second check" << std::endl;
std::cout << "Did not find already instantiated template of " << templateLookupName << " at second check" << std::endl;
//Look up this template's plain definition. It's type has the syntax tree that we need to parse
NodeTree<ASTData>* templateDefinition = templateClassLookup(scope, concatSymbolTree(typeNode->getChildren()[0]), templateParamInstantiationTypes);
if (templateDefinition == NULL)
@@ -1197,6 +1209,8 @@ Type* ASTTransformation::typeFromTypeNode(NodeTree<Symbol>* typeNode, NodeTree<A
else
std::cout << "Template definition is not null!" << std::endl;
std::string fullyInstantiatedName = templateDefinition->getDataRef()->symbol.getName() + "<" + instTypeString + ">";
NodeTree<Symbol>* templateSyntaxTree = templateDefinition->getDataRef()->valueType->templateDefinition;
//Create a new map of template type names to actual types.
std::vector<NodeTree<Symbol>*> templateParamPlaceholderNodes = slice(templateSyntaxTree->getChildren()[0]->getChildren(), 1, -2, 2); //Don't get beginning or end for < or >, skip commas in the middle
@@ -1211,9 +1225,17 @@ Type* ASTTransformation::typeFromTypeNode(NodeTree<Symbol>* typeNode, NodeTree<A
//Note that we're adding to the current top scope. This makes it more efficient by preventing multiple instantiation and should not cause any problems
//It also makes sure it gets generated in the right place
std::cout << "Adding to top scope and template's origional scope with fullyInstantiatedName " << fullyInstantiatedName << std::endl;
topScope->getDataRef()->scope[fullyInstantiatedName].push_back(typeDefinition);
topScope->addChild(typeDefinition); //Add this object the the highest scope's
//std::cout << "Adding to top scope and template's origional scope with fullyInstantiatedName " << fullyInstantiatedName << std::endl;
//topScope->getDataRef()->scope[fullyInstantiatedName].push_back(typeDefinition);
//topScope->addChild(typeDefinition); Add this object the the highest scope's
// Actually, let's just put it in the scope of the origional template, which should work just fine under the new scoping rules and will ACTUALLY prevent multiple instantiation.
// At least, hopefully it will if we also check it's scope for it. Which I think it should be anyway. Yeah, I think it should work.
std::cout << "Adding to template top scope and template's origional scope with fullyInstantiatedName " << fullyInstantiatedName << std::endl;
auto templateTopScope = getUpperTranslationUnit(templateDefinition);
templateTopScope->getDataRef()->scope[fullyInstantiatedName].push_back(typeDefinition);
templateTopScope->addChild(typeDefinition); // Add this object the the highest scope's
//NodeTree<ASTData>* templateHighScope = templateDefinition->getDataRef()->scope["~enclosing_scope"][0];
//if (topScope != templateHighScope)
//templateHighScope->getDataRef()->scope[fullyInstantiatedName].push_back(typeDefinition);
@@ -1304,8 +1326,13 @@ NodeTree<ASTData>* ASTTransformation::findOrInstantiateFunctionTemplate(std::vec
skipChildren.insert(2);
//scope->getDataRef()->scope[fullyInstantiatedName].push_back(instantiatedFunction);
instantiatedFunction->getDataRef()->scope["~enclosing_scope"].push_back(templateDefinition->getDataRef()->scope["~enclosing_scope"][0]); //Instantiated Template Function's scope is it's template's definition's scope
topScope->getDataRef()->scope[fullyInstantiatedName].push_back(instantiatedFunction);
topScope->addChild(instantiatedFunction); //Add this object the the highest scope's
// Arrrrrgh this has a hard time working because the functions will need to see their parameter once they are emitted as C.
// HAHAHAHAHA DOESN'T MATTER ALL ONE C FILE NOW, swap back to old way
auto templateTopScope = getUpperTranslationUnit(templateDefinition);
templateTopScope->getDataRef()->scope[fullyInstantiatedName].push_back(instantiatedFunction);
templateTopScope->addChild(instantiatedFunction); // Add this object the the highest scope's
//topScope->getDataRef()->scope[fullyInstantiatedName].push_back(instantiatedFunction);
//topScope->addChild(instantiatedFunction); //Add this object the the highest scope's
std::cout << "About to do children of " << functionName << " to " << fullyInstantiatedName << std::endl;
instantiatedFunction->addChildren(transformChildren(templateSyntaxTree->getChildren(), skipChildren, instantiatedFunction, std::vector<Type>(), newTemplateTypeReplacement));

65
src/CGenerator.cpp
View File

@@ -4,7 +4,6 @@ CGenerator::CGenerator() : generatorString("__C__") {
tabLevel = 0;
}
CGenerator::~CGenerator() {
}
// Note the use of std::pair to hold two strings - the running string for the header file and the running string for the c file.
@@ -16,23 +15,23 @@ void CGenerator::generateCompSet(std::map<std::string, NodeTree<ASTData>*> ASTs,
std::cout << "Could not make directory " << outputName << std::endl;
//throw "could not make directory ";
}
for (auto i = ASTs.begin(); i != ASTs.end(); i++) {
std::cout << "\n\nGenerate pass for: " << i->first << std::endl;
buildString += i->first + ".c ";
std::cout << "\n\nGenerate pass for: " << outputName << std::endl;
buildString += outputName + ".c ";
std::ofstream outputCFile, outputHFile;
outputCFile.open(outputName + "/" + i->first + ".c");
outputHFile.open(outputName + "/" + i->first + ".h");
outputCFile.open(outputName + "/" + outputName + ".c");
outputHFile.open(outputName + "/" + outputName + ".h");
if (outputCFile.is_open() || outputHFile.is_open()) {
// Prequel common to all files
auto chPair = generateTranslationUnit(i->second);
auto chPair = generateTranslationUnit(outputName, ASTs);
outputHFile << "#include <stdbool.h>\n#include <stdlib.h>\n#include <stdio.h>\n" << chPair.first;
outputCFile << "#include \"" + i->first + ".h\"\n\n" << chPair.second;
outputCFile << "#include \"" + outputName + ".h\"\n\n" << chPair.second;
} else {
std::cout << "Cannot open file " << i->first << ".c/h" << std::endl;
std::cout << "Cannot open file " << outputName << ".c/h" << std::endl;
}
outputCFile.close();
outputHFile.close();
}
buildString += "-o " + outputName;
std::ofstream outputBuild;
outputBuild.open(outputName + "/" + split(outputName, '/').back() + ".sh");
@@ -63,10 +62,10 @@ std::string CGenerator::generateClassStruct(NodeTree<ASTData>* from) {
}
// This method recurseivly generates all aliases of some definition
std::string CGenerator::generateAliasChains(NodeTree<ASTData>* scopeNode, NodeTree<ASTData>* definition) {
auto scope = scopeNode->getDataRef()->scope;
std::string CGenerator::generateAliasChains(std::map<std::string, NodeTree<ASTData>*> ASTs, NodeTree<ASTData>* definition) {
std::string output;
for (auto i = scope.begin(); i != scope.end(); i++) {
for (auto trans : ASTs) {
for (auto i = trans.second->getDataRef()->scope.begin(); i != trans.second->getDataRef()->scope.end(); i++) {
for (auto declaration : i->second) {
auto declarationData = declaration->getDataRef();
if (declarationData->type == type_def
@@ -74,7 +73,8 @@ std::string CGenerator::generateAliasChains(NodeTree<ASTData>* scopeNode, NodeTr
&& declarationData->valueType->typeDefinition == definition) {
output += "typedef " + CifyName(definition->getDataRef()->symbol.getName()) + " " + CifyName(declarationData->symbol.getName()) + ";\n";
// Recursively add the ones that depend on this one
output += generateAliasChains(scopeNode, declaration);
output += generateAliasChains(ASTs, declaration);
}
}
}
}
@@ -104,9 +104,8 @@ NodeTree<ASTData>* CGenerator::highestScope(NodeTree<ASTData>* node) {
}
// We do translation units in their own function so they can do the pariwise h/c stuff and regualr in function body generation does not
std::pair<std::string, std::string> CGenerator::generateTranslationUnit(NodeTree<ASTData>* from) {
ASTData data = from->getData();
std::vector<NodeTree<ASTData>*> children = from->getChildren();
std::pair<std::string, std::string> CGenerator::generateTranslationUnit(std::string name, std::map<std::string, NodeTree<ASTData>*> ASTs) {
// We now pass in the entire map of ASTs and loop through them so that we generate out into a single file
std::string cOutput, hOutput;
// Ok, so we've got to do this in passes to preserve mututally recursive definitions.
//
@@ -129,14 +128,12 @@ std::pair<std::string, std::string> CGenerator::generateTranslationUnit(NodeTree
std::string functionPrototypes = "/**\n * Function Prototypes\n */\n\n";
std::string functionDefinitions = "/**\n * Function Definitions\n */\n\n";
// Ok, let's handle the included files
for (auto i : from->getChildren())
if (i->getDataRef()->type == import)
importIncludes += "#include \"" + i->getDataRef()->symbol.getName() + ".krak.h\" //woo importing!\n";
// And get the correct order for emiting classes, but not if they're not in our file, then they will get included
// Note that this is not sufsticated enough for some multiple file mutually recursive types, but I want to get this simple version working first
Poset<NodeTree<ASTData>*> typedefPoset;
for (auto trans : ASTs) {
auto children = trans.second->getChildren();
for (int i = 0; i < children.size(); i++) {
if (children[i]->getDataRef()->type == type_def) {
// If we're an alias type, continue. We handle those differently
@@ -151,21 +148,21 @@ std::pair<std::string, std::string> CGenerator::generateTranslationUnit(NodeTree
for (auto j : classChildren) {
if (j->getDataRef()->type == declaration_statement) {
Type* decType = j->getChildren()[0]->getDataRef()->valueType; // Type of the declaration
if (decType->typeDefinition && decType->getIndirection() == 0 && isUnderTranslationUnit(from, decType->typeDefinition)) // If this is a custom type and not a pointer and actually should be defined in this file
if (decType->typeDefinition && decType->getIndirection() == 0) // If this is a custom type and not a pointer
typedefPoset.addRelationship(children[i], decType->typeDefinition); // Add a dependency
}
}
}
}
}
//Now generate the typedef's in the correct, topological order
for (NodeTree<ASTData>* i : typedefPoset.getTopoSort())
classStructs += generateClassStruct(i) + "\n";
// Declare everything in translation unit scope here. (allows stuff from other files, automatic forward declarations)
// Declare everything in translation unit scope here (now for ALL translation units). (allows stuff from other files, automatic forward declarations)
// Also, everything in all of the import's scopes
std::map<std::string, std::vector<NodeTree<ASTData>*>> combinedMap;
combinedMap = from->getDataRef()->scope; // Actually, just do this file. We're moving back to using include files
for (auto i = combinedMap.begin(); i != combinedMap.end(); i++) {
for (auto trans : ASTs) {
for (auto i = trans.second->getDataRef()->scope.begin(); i != trans.second->getDataRef()->scope.end(); i++) {
for (auto declaration : i->second) {
std::vector<NodeTree<ASTData>*> decChildren = declaration->getChildren();
ASTData declarationData = declaration->getData();
@@ -190,9 +187,8 @@ std::pair<std::string, std::string> CGenerator::generateTranslationUnit(NodeTree
nameDecoration += "_" + ValueTypeToCTypeDecoration(decChildren[j]->getData().valueType);
}
functionPrototypes += CifyName(declarationData.symbol.getName() + nameDecoration) + "(" + parameters + "); /*func*/\n";
// Only generate function if this is the unit it was defined in
// generate function
std::cout << "Generating " << CifyName(declarationData.symbol.getName()) << std::endl;
if (contains(children, declaration))
functionDefinitions += generate(declaration, nullptr);
}
}
@@ -208,7 +204,7 @@ std::pair<std::string, std::string> CGenerator::generateTranslationUnit(NodeTree
continue; // Aliases of objects are done with the thing it alises
// Otherwise, we're actually a renaming of a primitive, can generate here
plainTypedefs += "typedef " + ValueTypeToCType(declarationData.valueType) + " " + CifyName(declarationData.symbol.getName()) + ";\n";
plainTypedefs += generateAliasChains(from, declaration);
plainTypedefs += generateAliasChains(ASTs, declaration);
} else {
plainTypedefs += "typedef struct __struct_dummy_" + CifyName(declarationData.symbol.getName()) + "__ " + CifyName(declarationData.symbol.getName()) + ";\n";
functionPrototypes += "/* Method Prototypes for " + declarationData.symbol.getName() + " */\n";
@@ -220,10 +216,9 @@ std::pair<std::string, std::string> CGenerator::generateTranslationUnit(NodeTree
objectFunctionDefinitions += generateObjectMethod(declaration, decChildren[j], &functionPrototypes) + "\n";
}
// Add all aliases to the plain typedefs. This will add any alias that aliases to this object, and any alias that aliases to that, and so on
plainTypedefs += generateAliasChains(from, declaration);
plainTypedefs += generateAliasChains(ASTs, declaration);
functionPrototypes += "/* Done with " + declarationData.symbol.getName() + " */\n";
// If this is the file the object is defined in, include methods
if (contains(children, declaration))
// include methods
functionDefinitions += objectFunctionDefinitions + "/* Done with " + declarationData.symbol.getName() + " */\n";
}
break;
@@ -234,6 +229,7 @@ std::pair<std::string, std::string> CGenerator::generateTranslationUnit(NodeTree
}
}
}
}
hOutput += plainTypedefs + importIncludes + variableExternDeclarations + classStructs + functionPrototypes;
cOutput += variableDeclarations + functionDefinitions;
return std::make_pair(hOutput, cOutput);
@@ -262,11 +258,12 @@ std::string CGenerator::generate(NodeTree<ASTData>* from, NodeTree<ASTData>* enc
case identifier:
{
//but first, if we're this, we should just emit. (assuming enclosing object) (note that technically this would fall through, but for errors)
if (data.symbol.getName() == "this")
if (data.symbol.getName() == "this") {
if (enclosingObject)
return "this";
else
std::cout << "Error: this used in non-object scope" << std::endl;
}
//If we're in an object method, and our enclosing scope is that object, we're a member of the object and should use the this reference.
std::string preName;
if (enclosingObject && enclosingObject->getDataRef()->scope.find(data.symbol.getName()) != enclosingObject->getDataRef()->scope.end())
@@ -480,6 +477,7 @@ std::string CGenerator::generateObjectMethod(NodeTree<ASTData>* enclosingObject,
return functionSignature + "\n" + generate(children[children.size()-1], enclosingObject); //Pass in the object so we can properly handle access to member stuff
}
std::string CGenerator::ValueTypeToCType(Type *type) { return ValueTypeToCTypeThingHelper(type, "*"); }
std::string CGenerator::ValueTypeToCTypeDecoration(Type *type) { return ValueTypeToCTypeThingHelper(type, "_P__"); }
std::string CGenerator::ValueTypeToCTypeThingHelper(Type *type, std::string ptrStr) {
@@ -557,6 +555,7 @@ std::string CGenerator::CifyName(std::string name) {
"[", "openbracket",
"]", "closebracket",
" ", "space",
".", "dot",
"->", "arrow" };
int length = sizeof(operatorsToReplace)/sizeof(std::string);
//std::cout << "Length is " << length << std::endl;

1
src/Importer.cpp
View File

@@ -167,6 +167,7 @@ NodeTree<Symbol>* Importer::parseAndTrim(std::string fileName) {
} else {
std::cout << "ParseTree returned from parser for " << fileName << " is NULL!" << std::endl;
outFile.close(); outFileTransformed.close();
throw "unexceptablblllll";
return NULL;
}
outFile.close();

10
stdlib/io.krak
View File

@@ -1,3 +1,5 @@
import string:*;
__if_comp__ __C__ __simple_passthrough__ """
#include <stdio.h>
"""
@@ -20,6 +22,14 @@ __if_comp__ __C__ __simple_passthrough__ """
println();
}
|void| print(|string| toPrint) {
print(toPrint.toCharArray());
}
|void| println(|string| toPrint) {
println(toPrint.toCharArray());
}
|void| print(|int| toPrint) {
__if_comp__ __C__ {
__simple_passthrough__ """

27
stdlib/string.krak Normal file
View File

@@ -0,0 +1,27 @@
import vector;
import mem;
typedef string (Destructable) {
|vector::vector<char>| data;
|string*| construct() {
data.construct();
return this;
}
|string*| construct(|char*| str) {
data.construct();
while(*str) {
data.addEnd(*str);
str += 1;
}
return this;
}
|char*| toCharArray() {
|char*| out = mem::new<char>(data.size);
for (|int| i = 0; i < data.size; i++;)
out[i] = data.get(i);
return out;
}
};

11
stdlib/vector.krak
View File

@@ -1,6 +1,6 @@
import mem:*;
import util:*;
import io:*;
//import io:*;
typedef template<T> vector (Destructable) {
|T*| data;
@@ -25,6 +25,8 @@ typedef template<T> vector (Destructable) {
for (|int| i = 0; i < lesser<int>(size, newSize); i++;)
newData[i] = data[i];
delete<T>(data, 0);
data = newData;
available = newSize;
return true;
}
@@ -34,21 +36,22 @@ typedef template<T> vector (Destructable) {
|T| get(|int| index) {
if (index < 0 || index >= size) {
println("Vector access out of bounds! Retuning 0th element as sanest option");
// println("Vector access out of bounds! Retuning 0th element as sanest option");
return data[0];
}
return data[index];
}
|T*| getBackingMemory() { return data; }
|void| set(|int| index, |T| dataIn) {
if (index < 0 || index >= size)
return;
data[index] = dataIn;
}
|void| addEnd(|T| dataIn) {
if (size < available)
size++;
else
if (size >= available)
resize(size*2);
data[size-1] = dataIn;
}

15
tests/runTests-ninja.sh Normal file
View File

@@ -0,0 +1,15 @@
#!/bin/bash
krakenPath="../build-ninja/kraken"
#testDir=${1:-"../tests"}
testDir="."
ext=${2:-"krak"}
fileList=""
for dir in `find ${testDir} -type f -name "test_*.${ext}"`; do
filename=$(basename ${dir})
filename="${filename%.*}"
fileList+=\ $testDir\/$filename
done
${krakenPath} "--test" ${fileList}

1
tests/test_string.expected_results Normal file
View File

@@ -0,0 +1 @@
hello strings

10
tests/test_string.krak Normal file
View File

@@ -0,0 +1,10 @@
import io;
import string;
|int| main() {
|string::string| str.construct("hello strings");
io::println(str);
return 0;
}

1
tests/test_vectorTest.expected_results
View File

@@ -1,2 +1,3 @@
4
1337
Destroyed!

1
tests/test_vectorTest.krak
View File

@@ -14,6 +14,7 @@ typedef AbleToBeDestroyed (Destructable) {
intVec.addEnd(3);
intVec.addEnd(3);
intVec.addEnd(7);
println(intVec.size);
for (|int| i = 0; i < intVec.size; i++;)
print(intVec.at(i));