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

Basic math expressions will passthrough now

Browse Source
This commit is contained in:
Nathan Braswell
2016-01-18 18:04:34 -05:00
parent bffedcf2fd
commit ac34a550d5
5 changed files with 47 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
stdlib/ast_nodes.krak
View File

@@ -952,7 +952,7 @@ fun get_ast_type(node: *ast_node): *type {
match (*node) {
ast_node::identifier() return node->identifier.type
ast_node::function() return node->function.type
ast_node::function_call() return get_ast_type(node->function_call.func)
ast_node::function_call() return get_ast_type(node->function_call.func)->return_type
ast_node::value() return node->value.value_type
}
}

33
stdlib/ast_transformation.krak
View File

@@ -241,12 +241,6 @@ obj ast_transformation (Object) {
}
return ast_value_ptr(value_str, value_type)
}
fun transform_expression(node: *tree<symbol>, scope: *ast_node): *ast_node {
// figure out what the expression is, handle overloads, or you know
// ignore everything and do a passthrough
/*println(string("passing through: ") + node->data.name)*/
return transform(node->children[0], scope)
}
fun transform_code_block(node: *tree<symbol>, scope: *ast_node): *ast_node {
var new_block = ast_code_block_ptr()
add_to_scope("~enclosing_scope", scope, new_block)
@@ -308,15 +302,33 @@ obj ast_transformation (Object) {
f->function_call.parameters.for_each(fun(param: *ast_node) print(param);)
return f
}
fun transform_expression(node: *tree<symbol>, scope: *ast_node): *ast_node {
// figure out what the expression is, handle overloads, or you know
// ignore everything and do a passthrough
if (node->children.size == 1)
return transform(node->children[0], scope)
else if (node->children.size == 2) {
return transform(node->children[0], scope)
}
var parameters = vector(transform(node->children[0], scope), transform(node->children[2], scope))
var parameter_types = parameters.map(fun(param: *ast_node): *type return get_ast_type(param);)
return ast_function_call_ptr(get_builtin_function(concat_symbol_tree(node->children[1]), parameter_types), parameters)
}
fun get_builtin_function(name: string, param_types: vector<*type>): *ast_node {
return ast_function_ptr(name, type_ptr(param_types, param_types[0]), vector<*ast_node>())
}
fun function_lookup(name: string, scope: *ast_node, param_types: vector<*type>): *ast_node {
var param_string = string()
param_types.for_each(fun(t: *type) param_string += t->to_string() + ", ";)
var results = scope_lookup(name, scope)
for (var i = 0; i < results.size; i++;)
print(results.size); println(" number of results")
for (var i = 0; i < results.size; i++;) {
if (is_function(results[i])) {
var func_param_types = get_ast_type(results[i])->parameter_types
if (func_param_types.size != param_types.size)
if (func_param_types.size != param_types.size) {
println(string("type sizes don't match") + get_ast_type(results[i])->to_string() + " with needed " + param_string)
continue
}
var param_types_match = true
for (var j = 0; j < param_types.size; j++;) {
if (*func_param_types[j] != *param_types[j]) {
@@ -326,8 +338,9 @@ obj ast_transformation (Object) {
}
if (param_types_match)
return results[i]
} else
println(string("either isn't function or types don't match ") + get_ast_type(results[i])->to_string() + " with needed " + param_string)
}
println(string("either isn't function or types don't match ") + get_ast_type(results[i])->to_string() + " with needed " + param_string)
}
println(string("function lookup failed for ") + name)
return null<ast_node>()
}

8
stdlib/c_generator.krak
View File

@@ -111,13 +111,17 @@ obj c_generator (Object) {
}
fun generate_function_call(node: *ast_node): string {
var func_name = generate(node->function_call.func)
var parameters = node->function_call.parameters
if (func_name == "+" || func_name == "-" || func_name == "*" || func_name == "/" || func_name == "||" || func_name == "&&")
return generate(parameters[0]) + func_name + generate(parameters[1])
var call_string = string()
node->function_call.parameters.for_each(fun(param: *ast_node) {
parameters.for_each(fun(param: *ast_node) {
if (call_string != "")
call_string += ", "
call_string += generate(param)
})
return generate(node->function_call.func) + "(" + call_string + ")"
return func_name + "(" + call_string + ")"
}
// for now, anyway

26
stdlib/type.krak
View File

@@ -76,20 +76,22 @@ obj type (Object) {
return base == other.base && parameter_types == other.parameter_types && indirection == other.indirection
}
fun to_string(): string {
var indirection_str = string()
for (var i = 0; i < indirection; i++;) indirection_str += "*"
match (base) {
base_type::none() return string("none, indirection: ") + indirection
base_type::template() return string("template, indirection:") + indirection
base_type::template_type() return string("template_type, indirection:") + indirection
base_type::void_return() return string("void_return, indirection:") + indirection
base_type::boolean() return string("boolean, indirection:") + indirection
base_type::character() return string("character, indirection:") + indirection
base_type::integer() return string("integer, indirection:") + indirection
base_type::floating() return string("floating, indirection:") + indirection
base_type::double_precision() return string("double_precision, indirection:") + indirection
base_type::none() return indirection_str + string("none")
base_type::template() return indirection_str + string("template")
base_type::template_type() return indirection_str + string("template_type")
base_type::void_return() return indirection_str + string("void_return")
base_type::boolean() return indirection_str + string("boolean")
base_type::character() return indirection_str + string("character")
base_type::integer() return indirection_str + string("integer")
base_type::floating() return indirection_str + string("floating")
base_type::double_precision() return indirection_str + string("double_precision")
base_type::function() {
var temp = string("function: (")
parameter_types.for_each(fun(parameter_type: *type) temp += parameter_type->to_string() + " ";)
return temp + ")" + return_type->to_string() + "indirection: " + indirection
var temp = indirection_str + string("fun(")
parameter_types.for_each(fun(parameter_type: *type) temp += parameter_type->to_string() + ", ";)
return temp + ")" + return_type->to_string()
}
}
return string("impossible type, indirection:") + indirection