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

Working on objects and scoping. To finish, need to actually implement decent propogation of types

Browse Source
This commit is contained in:
Nathan Braswell
2014-02-03 11:41:25 -05:00
parent 62933af8f8
commit 1791738cd9
3 changed files with 161 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files

136
src/CGenerator.cpp
View File

@@ -35,16 +35,17 @@ std::string CGenerator::tabs() {
return returnTabs;
}
std::string CGenerator::generate(NodeTree<ASTData>* from) {
//The enclosing object is for when we're generating the inside of object methods. They allow us to check scope lookups against the object we're in
std::string CGenerator::generate(NodeTree<ASTData>* from, NodeTree<ASTData>* enclosingObject) {
ASTData data = from->getData();
std::vector<NodeTree<ASTData>*> children = from->getChildren();
std::string output = "";
std::string output = "";
switch (data.type) {
case translation_unit:
//Do here because we may need the typedefs before the declarations of variables
for (int i = 0; i < children.size(); i++)
if (children[i]->getDataRef()->type == type_def)
output += generate(children[i]) + "\n";
output += generate(children[i], enclosingObject) + "\n";
//Declare everything in translation unit scope here. (allows stuff from other files, automatic forward declarations)
for (auto i = data.scope.begin(); i != data.scope.end(); i++) {
NodeTree<ASTData>* declaration = i->second;
@@ -55,11 +56,15 @@ std::string CGenerator::generate(NodeTree<ASTData>* from) {
output += ValueTypeToCType(declarationData.valueType) + " " + declarationData.symbol.getName() + "; /*identifier*/\n";
break;
case function:
if (decChildren.size() == 0) { //Not a real function, must be a built in passthrough {
output += "/* built in function: " + declarationData.toString() + " */\n";
break;
}
output += "\n" + ValueTypeToCType(declarationData.valueType) + " " + declarationData.symbol.getName() + "(";
for (int j = 0; j < decChildren.size()-1; j++) {
if (j > 0)
output += ", ";
output += ValueTypeToCType(decChildren[j]->getData().valueType) + " " + generate(decChildren[j]);
output += ValueTypeToCType(decChildren[j]->getData().valueType) + " " + generate(decChildren[j], enclosingObject);
}
output += "); /*func*/\n";
break;
@@ -75,7 +80,7 @@ std::string CGenerator::generate(NodeTree<ASTData>* from) {
//Do here because we need the newlines
for (int i = 0; i < children.size(); i++)
if (children[i]->getDataRef()->type != type_def)
output += generate(children[i]) + "\n";
output += generate(children[i], enclosingObject) + "\n";
return output;
break;
case interpreter_directive:
@@ -85,31 +90,47 @@ std::string CGenerator::generate(NodeTree<ASTData>* from) {
return "/* would import \"" + data.symbol.getName() + "\" but....*/\n";
//return "#include <" + data.symbol.getName() + ">\n";
case identifier:
{
//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 self reference.
if (enclosingObject && enclosingObject->getDataRef()->scope.find(data.symbol.getName()) != enclosingObject->getDataRef()->scope.end()) {
return "self->" + data.symbol.getName();
}
return data.symbol.getName();
}
case type_def:
if (children.size() == 0) {
return "typedef " + ValueTypeToCType(data.valueType) + " " + data.symbol.getName() + ";";
} else {
std::string objectString = "typedef struct __struct_dummy_" + data.symbol.getName() + "__ {\n";
for (int i = 0; i < children.size(); i++)
objectString += generate(children[i]) + "\n";
std::string postString; //The functions have to be outside the struct definition
for (int i = 0; i < children.size(); i++) {
std::cout << children[i]->getName() << std::endl;
if (children[i]->getName() == "function") //If object method
postString += generateObjectMethod(from, children[i]) + "\n";
else
objectString += generate(children[i], enclosingObject) + "\n";
}
objectString += "} " + data.symbol.getName() + ";";
return objectString;
return objectString + postString; //Functions come after the declaration of the struct
}
case function:
output += "\n" + ValueTypeToCType(data.valueType) + " " + data.symbol.getName() + "(";
for (int i = 0; i < children.size()-1; i++) {
if (i > 0)
output += ", ";
output += ValueTypeToCType(children[i]->getData().valueType) + " " + generate(children[i]);
output += ValueTypeToCType(children[i]->getData().valueType) + " " + generate(children[i], enclosingObject);
}
output+= ")\n" + generate(children[children.size()-1]);
output+= ")\n" + generate(children[children.size()-1], enclosingObject);
return output;
case code_block:
output += "{\n";
tabLevel++;
for (int i = 0; i < children.size(); i++)
output += generate(children[i]);
for (int i = 0; i < children.size(); i++) {
std::cout << "Line " << i << std::endl;
std::string line = generate(children[i], enclosingObject);
std::cout << line << std::endl;
output += line;
}
tabLevel--;
output += tabs() + "}";
return output;
@@ -118,60 +139,82 @@ std::string CGenerator::generate(NodeTree<ASTData>* from) {
case boolean_expression:
output += " " + data.symbol.getName() + " ";
case statement:
return tabs() + generate(children[0]) + ";\n";
return tabs() + generate(children[0], enclosingObject) + ";\n";
case if_statement:
output += "if (" + generate(children[0]) + ")\n\t" + generate(children[1]);
output += "if (" + generate(children[0], enclosingObject) + ")\n\t" + generate(children[1], enclosingObject);
if (children.size() > 2)
output += " else " + generate(children[2]);
output += " else " + generate(children[2], enclosingObject);
return output;
case while_loop:
output += "while (" + generate(children[0]) + ")\n\t" + generate(children[1]);
output += "while (" + generate(children[0], enclosingObject) + ")\n\t" + generate(children[1], enclosingObject);
return output;
case for_loop:
//The strSlice's are there to get ride of an unwanted return and an unwanted semicolon(s)
output += "for (" + strSlice(generate(children[0]),0,-3) + generate(children[1]) + ";" + strSlice(generate(children[2]),0,-3) + ")\n\t" + generate(children[3]);
output += "for (" + strSlice(generate(children[0], enclosingObject),0,-3) + generate(children[1], enclosingObject) + ";" + strSlice(generate(children[2], enclosingObject),0,-3) + ")\n\t" + generate(children[3], enclosingObject);
return output;
case return_statement:
if (children.size())
return "return " + generate(children[0]);
return "return " + generate(children[0], enclosingObject);
else
return "return";
case assignment_statement:
return generate(children[0]) + " = " + generate(children[1]);
return generate(children[0], enclosingObject) + " = " + generate(children[1], enclosingObject);
case declaration_statement:
if (children.size() == 1)
return ValueTypeToCType(children[0]->getData().valueType) + " " + generate(children[0]) + ";";
return ValueTypeToCType(children[0]->getData().valueType) + " " + generate(children[0], enclosingObject) + ";";
else
return ValueTypeToCType(children[0]->getData().valueType) + " " + generate(children[0]) + " = " + generate(children[1]) + ";";
return ValueTypeToCType(children[0]->getData().valueType) + " " + generate(children[0], enclosingObject) + " = " + generate(children[1], enclosingObject) + ";";
case if_comp:
if (generate(children[0]) == generatorString)
return generate(children[1]);
if (generate(children[0], enclosingObject) == generatorString)
return generate(children[1], enclosingObject);
return "";
case simple_passthrough:
return strSlice(generate(children[0]), 3, -4);
return strSlice(generate(children[0], enclosingObject), 3, -4);
case function_call:
{
//NOTE: The first (0th) child of a function call node is the declaration of the function
//Handle operators specially for now. Will later replace with
//Inlined functions in the standard library
std::string name = data.symbol.getName();
//std::cout << name << " == " << children[0]->getData().symbol.getName() << std::endl;
if (name == "++" || name == "--")
return generate(children[1]) + name;
if (name == "*" && children.size() == 2) //Is dereference, not multiplication
return "*(" + generate(children[1]) + ")";
if (name == "+" || name == "-" || name == "*" || name == "/" || name == "==" || name == ">=" || name == "<=" || name == "!="
|| name == "<" || name == ">" || name == "%" || name == "+=" || name == "-=" || name == "*=" || name == "/=" || name == "||"
|| name == "&&" || name == "!" )
return "((" + generate(children[1]) + ")" + name + "(" + generate(children[2]) + "))";
else if (name == "." || name == "->")
return "((" + generate(children[1]) + ")" + name + generate(children[2]) + ")";
output += data.symbol.getName() + "(";
// std::string name = data.symbol.getName();
// std::cout << name << " == " << children[0]->getData().symbol.getName() << std::endl;
std::string name = children[0]->getDataRef()->symbol.getName();
ASTType funcType = children[0]->getDataRef()->type;
std::cout << "Doing function: " << name << std::endl;
//Test for specail functions only if what we're testing is, indeed, the definition, not a function call that returns a callable function pointer
if (funcType == function) {
if (name == "++" || name == "--")
return generate(children[1], enclosingObject) + name;
if (name == "*" && children.size() == 2) //Is dereference, not multiplication
return "*(" + generate(children[1], enclosingObject) + ")";
if (name == "+" || name == "-" || name == "*" || name == "/" || name == "==" || name == ">=" || name == "<=" || name == "!="
|| name == "<" || name == ">" || name == "%" || name == "+=" || name == "-=" || name == "*=" || name == "/=" || name == "||"
|| name == "&&" || name == "!" )
return "((" + generate(children[1], enclosingObject) + ")" + name + "(" + generate(children[2], enclosingObject) + "))";
else if (name == "." || name == "->") {
if (children.size() == 1)
return "/*dot operation with one child*/" + generate(children[0], enclosingObject) + "/*end one child*/";
//If this is accessing an actual function, just output the name. No actual function definition should be in an access operation
if (children[2]->getDataRef()->type == function)
return "((" + generate(children[1], enclosingObject) + ")" + name + children[2]->getDataRef()->symbol.getName() + ")";
return "((" + generate(children[1], enclosingObject) + ")" + name + generate(children[2], enclosingObject) + ")";
}
}
//output += data.symbol.getName() + "(";
if (funcType == function) {
output += name + "(";
std::cout << "Is a function, outputting name!" << std::cout;
if (enclosingObject && enclosingObject->getDataRef()->scope.find(name) != enclosingObject->getDataRef()->scope.end()) {
//So, it is part of the enclosing object's namespace, so it's (for now) a member function and we need to pass in an implicit self reference
output += ValueTypeToCType(enclosingObject->getDataRef()->valueType) + "* self, ";
}
} else {
output += generate(children[0], enclosingObject) + "(";
}
for (int i = 1; i < children.size(); i++) //children[0] is the declaration
if (i < children.size()-1)
output += generate(children[i]) + ", ";
else output += generate(children[i]);
output += generate(children[i], enclosingObject) + ", ";
else output += generate(children[i], enclosingObject);
output += ") ";
return output;
}
@@ -182,11 +225,24 @@ std::string CGenerator::generate(NodeTree<ASTData>* from) {
std::cout << "Nothing!" << std::endl;
}
for (int i = 0; i < children.size(); i++)
output += generate(children[i]);
output += generate(children[i], enclosingObject);
return output;
}
std::string CGenerator::generateObjectMethod(NodeTree<ASTData>* enclosingObject, NodeTree<ASTData>* from) {
std::string output;
ASTData data = from->getData();
Type enclosingObjectType = *(enclosingObject->getDataRef()->valueType); //Copy a new type so we can turn it into a pointer
enclosingObjectType.indirection++;
std::vector<NodeTree<ASTData>*> children = from->getChildren();
output += "\n" + ValueTypeToCType(data.valueType) + " " + enclosingObject->getDataRef()->symbol.getName() +"__" + data.symbol.getName() + "(" + ValueTypeToCType(&enclosingObjectType) + " self";
for (int i = 0; i < children.size()-1; i++)
output += ", " + ValueTypeToCType(children[i]->getData().valueType) + " " + generate(children[i]);
output+= ")\n" + generate(children[children.size()-1], enclosingObject); //Pass in the object so we can
return output;
}
std::string CGenerator::ValueTypeToCType(Type *type) {
std::string return_type;
switch (type->baseType) {