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

Shorter AST names

Browse Source
This commit is contained in:
Nathan Braswell
2018-05-22 20:14:15 -04:00
parent eefa752d55
commit d85f388792
12 changed files with 217 additions and 217 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
stdlib/address_of_ensure_variable_lower.krak
View File

@@ -34,10 +34,10 @@ fun address_of_ensure_variable_lower(name_ast_map: *map<str, pair<*tree<symbol>,
var enclosing_block_idx = parent_chain->index_from_top_satisfying(is_code_block)
var enclosing_block = parent_chain->from_top(enclosing_block_idx)
var before_block_parent = parent_chain->from_top(enclosing_block_idx-1)
var ident = ast_identifier_ptr("for_address_of_temp",
var ident = _ident("for_address_of_temp",
backing.func->function.type->parameter_types[0],
enclosing_block)
var decl = ast_declaration_statement_ptr(ident, addresse)
var decl = _declaration(ident, addresse)
add_before_in(decl, before_block_parent, enclosing_block)
replace_with_in(addresse, ident, node)
}

68
stdlib/adt_lower.krak
View File

@@ -23,85 +23,85 @@ fun adt_lower(name_ast_map: *map<str, pair<*tree<symbol>,*ast_node>>, ast_to_syn
ast_node::adt_def(backing) {
/*println(backing.name + ": transforming!")*/
type_def_option_map[node] = vec<*ast_node>()
var replacement = ast_type_def_ptr(backing.name, false);
var replacement = _type_def(backing.name, false);
// we're going to be replacing adt_def in the same ptr, so this works
replacement->type_def.self_type = node->adt_def.self_type
var option_union = ast_type_def_ptr(backing.name + "_union", true);
var option_union = _type_def(backing.name + "_union", true);
node->adt_def.options.for_each(fun(opt: *ast_node) {
if (!opt->identifier.type->is_empty_adt_option())
option_union->type_def.variables.add(ast_declaration_statement_ptr(opt, null<ast_node>()))
option_union->type_def.variables.add(_declaration(opt, null<ast_node>()))
type_def_option_map[node].add(opt)
})
var option_union_type = type_ptr(option_union)
option_union->type_def.self_type = option_union_type
var option_union_ident = ast_identifier_ptr(str("data"), option_union_type, replacement)
replacement->type_def.variables.add(ast_declaration_statement_ptr(option_union_ident, null<ast_node>()))
var option_union_ident = _ident(str("data"), option_union_type, replacement)
replacement->type_def.variables.add(_declaration(option_union_ident, null<ast_node>()))
add_to_scope("data", option_union_ident, replacement)
var flag = ast_identifier_ptr(str("flag"), type_ptr(base_type::integer()), replacement)
replacement->type_def.variables.add(ast_declaration_statement_ptr(flag, null<ast_node>()))
var flag = _ident(str("flag"), type_ptr(base_type::integer()), replacement)
replacement->type_def.variables.add(_declaration(flag, null<ast_node>()))
add_to_scope("flag", flag, replacement)
add_before_in(option_union, node, parent_chain)
var enclosing_scope = node->adt_def.scope[str("~enclosing_scope")][0]
var idx = 0
node->adt_def.option_funcs.for_each(fun(func: *ast_node) {
var adt_type = replacement->type_def.self_type
var block = ast_code_block_ptr()
var block = _code_block()
add_to_scope("~enclosing_scope", func, block)
func->function.body_statement = block
var to_ret = ast_identifier_ptr(str("to_ret"), adt_type, block)
block->code_block.children.add(ast_declaration_statement_ptr(to_ret, null<ast_node>()))
var to_ret = _ident(str("to_ret"), adt_type, block)
block->code_block.children.add(_declaration(to_ret, null<ast_node>()))
var value = ast_value_ptr(to_string(idx), type_ptr(base_type::integer()))
block->code_block.children.add(ast_assignment_statement_ptr(make_operator_call(".", vec(to_ret, flag)), value))
var value = _value(to_string(idx), type_ptr(base_type::integer()))
block->code_block.children.add(_assign(make_operator_call(".", vec(to_ret, flag)), value))
var opt = type_def_option_map[node][idx]
var lvalue = make_operator_call(".", vec(make_operator_call(".", vec(to_ret, option_union_ident)), opt))
if (func->function.parameters.size) {
// do copy_construct if it should
block->code_block.children.add(assign_or_copy_construct_statement(lvalue, func->function.parameters[0]))
}
block->code_block.children.add(ast_return_statement_ptr(to_ret))
block->code_block.children.add(_return(to_ret))
add_before_in(func, node, parent_chain)
add_to_scope(func->function.name, func, enclosing_scope)
add_to_scope("~enclosing_scope", enclosing_scope, func)
idx++
})
node->adt_def.regular_funcs.for_each(fun(func: *ast_node) {
var block = ast_code_block_ptr()
var block = _code_block()
add_to_scope("~enclosing_scope", func, block)
func->function.body_statement = block
var func_this = func->function.this_param
if (func->function.name == "operator==") {
var other = func->function.parameters[0]
var if_stmt = ast_if_statement_ptr(make_operator_call("!=", vec(make_operator_call("->", vec(func_this, flag)), make_operator_call(".", vec(other, flag)))))
if_stmt->if_statement.then_part = ast_return_statement_ptr(ast_value_ptr(str("false"), type_ptr(base_type::boolean())))
var if_stmt = _if(make_operator_call("!=", vec(make_operator_call("->", vec(func_this, flag)), make_operator_call(".", vec(other, flag)))))
if_stmt->if_statement.then_part = _return(_value(str("false"), type_ptr(base_type::boolean())))
block->code_block.children.add(if_stmt)
for (var i = 0; i < type_def_option_map[node].size; i++;) {
if (get_ast_type(type_def_option_map[node][i])->is_empty_adt_option())
continue
var if_stmt_inner = ast_if_statement_ptr(make_operator_call("==", vec(make_operator_call("->", vec(func_this, flag)), ast_value_ptr(to_string(i), type_ptr(base_type::integer())))))
var if_stmt_inner = _if(make_operator_call("==", vec(make_operator_call("->", vec(func_this, flag)), _value(to_string(i), type_ptr(base_type::integer())))))
var option = type_def_option_map[node][i]
var our_option = make_operator_call(".", vec(make_operator_call("->", vec(func_this, option_union_ident)), option))
var their_option = make_operator_call(".", vec(make_operator_call(".", vec(other, option_union_ident)), option))
if_stmt_inner->if_statement.then_part = ast_return_statement_ptr(possible_object_equality(our_option, their_option))
if_stmt_inner->if_statement.then_part = _return(possible_object_equality(our_option, their_option))
block->code_block.children.add(if_stmt_inner)
}
block->code_block.children.add(ast_return_statement_ptr(ast_value_ptr(str("true"), type_ptr(base_type::boolean()))))
block->code_block.children.add(_return(_value(str("true"), type_ptr(base_type::boolean()))))
} else if (func->function.name == "operator!=") {
var other = func->function.parameters[0]
block->code_block.children.add(ast_return_statement_ptr(make_operator_call("!", vec(make_method_call(func_this, "operator==", vec(other))))))
block->code_block.children.add(_return(make_operator_call("!", vec(make_method_call(func_this, "operator==", vec(other))))))
} else if (func->function.name == "construct") {
var value = ast_value_ptr(str("-1"), type_ptr(base_type::integer()))
block->code_block.children.add(ast_assignment_statement_ptr(make_operator_call("->", vec(func_this, flag)), value))
block->code_block.children.add(ast_return_statement_ptr(func_this))
var value = _value(str("-1"), type_ptr(base_type::integer()))
block->code_block.children.add(_assign(make_operator_call("->", vec(func_this, flag)), value))
block->code_block.children.add(_return(func_this))
} else if (func->function.name == "copy_construct") {
var other = func->function.parameters[0]
block->code_block.children.add(ast_assignment_statement_ptr(make_operator_call("->", vec(func_this, flag)), make_operator_call("->", vec(other, flag))))
block->code_block.children.add(_assign(make_operator_call("->", vec(func_this, flag)), make_operator_call("->", vec(other, flag))))
for (var i = 0; i < type_def_option_map[node].size; i++;) {
if (get_ast_type(type_def_option_map[node][i])->is_empty_adt_option())
continue
var if_stmt_inner = ast_if_statement_ptr(make_operator_call("==", vec(make_operator_call("->", vec(func_this, flag)), ast_value_ptr(to_string(i), type_ptr(base_type::integer())))))
var if_stmt_inner = _if(make_operator_call("==", vec(make_operator_call("->", vec(func_this, flag)), _value(to_string(i), type_ptr(base_type::integer())))))
var option = type_def_option_map[node][i]
var our_option = make_operator_call(".", vec(make_operator_call("->", vec(func_this, option_union_ident)), option))
var their_option = make_operator_call(".", vec(make_operator_call("->", vec(other, option_union_ident)), option))
@@ -119,7 +119,7 @@ fun adt_lower(name_ast_map: *map<str, pair<*tree<symbol>,*ast_node>>, ast_to_syn
if (option_type->is_empty_adt_option())
continue
if (option_type->indirection == 0 && option_type->is_object() && has_method(option_type->type_def, "destruct", vec<*type>())) {
var if_stmt_inner = ast_if_statement_ptr(make_operator_call("==", vec(make_operator_call("->", vec(func_this, flag)), ast_value_ptr(to_string(i), type_ptr(base_type::integer())))))
var if_stmt_inner = _if(make_operator_call("==", vec(make_operator_call("->", vec(func_this, flag)), _value(to_string(i), type_ptr(base_type::integer())))))
var our_option = make_operator_call(".", vec(make_operator_call("->", vec(func_this, option_union_ident)), option))
if_stmt_inner->if_statement.then_part = make_method_call(our_option, "destruct", vec<*ast_node>())
block->code_block.children.add(if_stmt_inner)
@@ -142,12 +142,12 @@ fun adt_lower(name_ast_map: *map<str, pair<*tree<symbol>,*ast_node>>, ast_to_syn
var second_helper = fun(node: *ast_node, parent_chain: *stack<*ast_node>) {
match(*node) {
ast_node::match_statement(backing) {
var block = ast_code_block_ptr()
var block = _code_block()
add_to_scope("~enclosing_scope", parent_chain->item_from_top_satisfying(fun(i: *ast_node): bool return is_code_block(i) || is_function(i);), block)
var value = backing.value
var holder = ast_identifier_ptr(str("holder"), get_ast_type(value)->clone_with_increased_indirection(), block)
block->code_block.children.add(ast_declaration_statement_ptr(holder, null<ast_node>()))
block->code_block.children.add(ast_assignment_statement_ptr(holder, make_operator_call("&", vec(value))))
var holder = _ident(str("holder"), get_ast_type(value)->clone_with_increased_indirection(), block)
block->code_block.children.add(_declaration(holder, null<ast_node>()))
block->code_block.children.add(_assign(holder, make_operator_call("&", vec(value))))
backing.cases.for_each(fun(case_stmt: *ast_node) {
var option = case_stmt->case_statement.option
var flag = get_from_scope(get_ast_type(value)->type_def, "flag")
@@ -158,16 +158,16 @@ fun adt_lower(name_ast_map: *map<str, pair<*tree<symbol>,*ast_node>>, ast_to_syn
for (var i = 0; i < type_def_option_map[get_ast_type(value)->type_def].size; i++;)
if (type_def_option_map[get_ast_type(value)->type_def][i] == option)
option_num = i;
var condition = make_operator_call("==", vec(make_operator_call("->", vec(holder, flag)), ast_value_ptr(to_string(option_num), type_ptr(base_type::integer()))))
var if_stmt = ast_if_statement_ptr(condition)
var inner_block = ast_code_block_ptr()
var condition = make_operator_call("==", vec(make_operator_call("->", vec(holder, flag)), _value(to_string(option_num), type_ptr(base_type::integer()))))
var if_stmt = _if(condition)
var inner_block = _code_block()
add_to_scope("~enclosing_scope", block, inner_block)
var unpack_ident = case_stmt->case_statement.unpack_ident
if (unpack_ident) {
var get_option = make_operator_call(".", vec(make_operator_call("->", vec(holder, data)), option))
get_option = make_operator_call("&", vec(get_option))
unpack_ident->identifier.type = unpack_ident->identifier.type->clone_with_ref()
inner_block->code_block.children.add(ast_declaration_statement_ptr(unpack_ident, get_option))
inner_block->code_block.children.add(_declaration(unpack_ident, get_option))
}
inner_block->code_block.children.add(case_stmt->case_statement.statement)
if_stmt->if_statement.then_part = inner_block

70
stdlib/ast_nodes.krak
View File

@@ -42,7 +42,7 @@ fun ast_node_ptr(node: ast_node): *ast_node {
to_ret->copy_construct(&node)
return to_ret
}
fun ast_translation_unit_ptr(name: str): *ast_node {
fun _translation_unit(name: str): *ast_node {
var obj_var.construct(name): translation_unit
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::translation_unit(obj_var))
@@ -86,7 +86,7 @@ obj translation_unit (Object) {
return children == other.children && name == other.name && lambdas == other.lambdas
}
}
fun ast_import_ptr(name: str, containing_tu: *ast_node): *ast_node {
fun _import(name: str, containing_tu: *ast_node): *ast_node {
var to_ret.construct(name, containing_tu): import
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::import(to_ret))
@@ -135,13 +135,13 @@ obj import (Object) {
return imported == other.imported && name == other.name && containing_translation_unit == other.containing_translation_unit && translation_unit == other.translation_unit && starred == other.starred
}
}
fun ast_identifier_ptr(name: *char, type: *type, enclosing_scope: *ast_node): *ast_node {
return ast_identifier_ptr(str(name), type, enclosing_scope)
fun _ident(name: *char, type: *type, enclosing_scope: *ast_node): *ast_node {
return _ident(str(name), type, enclosing_scope)
}
fun ast_identifier_ptr(name: str, type: *type, enclosing_scope: *ast_node): *ast_node {
return ast_identifier_ptr(name, type, enclosing_scope, false)
fun _ident(name: str, type: *type, enclosing_scope: *ast_node): *ast_node {
return _ident(name, type, enclosing_scope, false)
}
fun ast_identifier_ptr(name: str, type: *type, enclosing_scope: *ast_node, is_extern: bool): *ast_node {
fun _ident(name: str, type: *type, enclosing_scope: *ast_node, is_extern: bool): *ast_node {
var to_ret.construct(name, type, enclosing_scope, is_extern): identifier
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::identifier(to_ret))
@@ -186,11 +186,11 @@ obj identifier (Object) {
return name == other.name && type == other.type && enclosing_scope == other.enclosing_scope && is_extern == other.is_extern
}
}
/*fun ast_type_def_ptr(name: str): *ast_node {*/
fun ast_type_def_ptr(name: ref str): *ast_node {
return ast_type_def_ptr(name, false)
/*fun _type_def(name: str): *ast_node {*/
fun _type_def(name: ref str): *ast_node {
return _type_def(name, false)
}
fun ast_type_def_ptr(name: ref str, is_union: bool): *ast_node {
fun _type_def(name: ref str, is_union: bool): *ast_node {
var to_ret.construct(name, is_union): type_def
/*var to_ret.construct(name): type_def*/
var ptr = new<ast_node>()
@@ -244,7 +244,7 @@ obj type_def (Object) {
/*return name == other.name && self_type == other.self_type && variables == other.variables && methods == other.methods*/
}
}
fun ast_adt_def_ptr(name: str): *ast_node {
fun _adt_def(name: str): *ast_node {
var to_ret.construct(name): adt_def
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::adt_def(to_ret))
@@ -295,9 +295,9 @@ obj adt_def (Object) {
return name == other.name && self_type == other.self_type && options == other.options && option_funcs == other.option_funcs && regular_funcs == other.regular_funcs
}
}
fun ast_function_ptr(name: str, type: *type, parameters: vec<*ast_node>, is_extern: bool): *ast_node
return ast_function_ptr(name, type, parameters, null<ast_node>(), is_extern, false)
fun ast_function_ptr(name: str, type: *type, parameters: vec<*ast_node>, this_param: *ast_node, is_extern: bool, is_variadic: bool): *ast_node {
fun _function(name: str, type: *type, parameters: vec<*ast_node>, is_extern: bool): *ast_node
return _function(name, type, parameters, null<ast_node>(), is_extern, false)
fun _function(name: str, type: *type, parameters: vec<*ast_node>, this_param: *ast_node, is_extern: bool, is_variadic: bool): *ast_node {
var to_ret.construct(name, type, parameters, this_param, is_extern, is_variadic): function
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::function(to_ret))
@@ -356,7 +356,7 @@ obj function (Object) {
return name == name && type == other.type && parameters == other.parameters && this_param == other.this_param && body_statement == other.body_statement && closed_variables == other.closed_variables && is_extern == other.is_extern && is_variadic == other.is_variadic
}
}
fun ast_template_ptr(name: str, syntax_node: *tree<symbol>, template_types: vec<str>, template_type_replacements: map<str, *type>, is_function: bool): *ast_node {
fun _template(name: str, syntax_node: *tree<symbol>, template_types: vec<str>, template_type_replacements: map<str, *type>, is_function: bool): *ast_node {
var to_ret.construct(name, syntax_node, template_types, template_type_replacements, is_function): template
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::template(to_ret))
@@ -416,12 +416,12 @@ obj template (Object) {
instantiated_map == other.instantiated_map && is_function == other.is_function
}
}
fun ast_code_block_ptr(stmt: *ast_node): *ast_node {
var to_ret = ast_code_block_ptr()
fun _code_block(stmt: *ast_node): *ast_node {
var to_ret = _code_block()
to_ret->code_block.children.add(stmt)
return to_ret
}
fun ast_code_block_ptr(): *ast_node {
fun _code_block(): *ast_node {
var to_ret.construct(): code_block
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::code_block(to_ret))
@@ -457,7 +457,7 @@ obj code_block (Object) {
return children == other.children && scope == other.scope
}
}
fun ast_if_statement_ptr(condition: *ast_node): *ast_node {
fun _if(condition: *ast_node): *ast_node {
var to_ret.construct(condition): if_statement
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::if_statement(to_ret))
@@ -499,7 +499,7 @@ obj if_statement (Object) {
return condition == other.condition && then_part == other.then_part && else_part == other.else_part
}
}
fun ast_match_statement_ptr(value: *ast_node): *ast_node {
fun _match(value: *ast_node): *ast_node {
var to_ret.construct(value): match_statement
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::match_statement(to_ret))
@@ -538,7 +538,7 @@ obj match_statement (Object) {
return value == other.value && cases == other.cases && scope == other.scope
}
}
fun ast_case_statement_ptr(): *ast_node {
fun _case(): *ast_node {
var to_ret.construct(): case_statement
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::case_statement(to_ret))
@@ -579,7 +579,7 @@ obj case_statement (Object) {
return option == other.option && unpack_ident == other.unpack_ident && statement == other.statement
}
}
fun ast_while_loop_ptr(condition: *ast_node): *ast_node {
fun _while(condition: *ast_node): *ast_node {
var to_ret.construct(condition): while_loop
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::while_loop(to_ret))
@@ -617,7 +617,7 @@ obj while_loop (Object) {
return condition == other.condition && statement == other.statement
}
}
fun ast_for_loop_ptr(): *ast_node {
fun _for(): *ast_node {
var to_ret.construct(): for_loop
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::for_loop(to_ret))
@@ -661,7 +661,7 @@ obj for_loop (Object) {
return init == other.init && condition == other.condition && update == other.update && body == other.body
}
}
fun ast_return_statement_ptr(return_value: *ast_node): *ast_node {
fun _return(return_value: *ast_node): *ast_node {
var to_ret.construct(return_value): return_statement
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::return_statement(to_ret))
@@ -700,7 +700,7 @@ adt branching_type {
break_stmt,
continue_stmt
}
fun ast_branching_statement_ptr(b_type: branching_type): *ast_node {
fun _branch(b_type: branching_type): *ast_node {
var to_ret.construct(b_type): branching_statement
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::branching_statement(to_ret))
@@ -732,7 +732,7 @@ obj branching_statement (Object) {
return true
}
}
fun ast_defer_statement_ptr(statement_in: *ast_node): *ast_node {
fun _defer(statement_in: *ast_node): *ast_node {
var to_ret.construct(statement_in): defer_statement
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::defer_statement(to_ret))
@@ -763,7 +763,7 @@ obj defer_statement (Object) {
return true
}
}
fun ast_assignment_statement_ptr(to: *ast_node, from: *ast_node): *ast_node {
fun _assign(to: *ast_node, from: *ast_node): *ast_node {
var to_ret.construct(to, from): assignment_statement
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::assignment_statement(to_ret))
@@ -797,7 +797,7 @@ obj assignment_statement (Object) {
return to == other.to && from == other.from
}
}
fun ast_declaration_statement_ptr(ident: *ast_node, expression: *ast_node): *ast_node {
fun _declaration(ident: *ast_node, expression: *ast_node): *ast_node {
var to_ret.construct(ident, expression): declaration_statement
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::declaration_statement(to_ret))
@@ -834,7 +834,7 @@ obj declaration_statement (Object) {
return identifier == other.identifier && expression == other.expression && init_method_call == other.init_method_call
}
}
fun ast_if_comp_ptr(): *ast_node {
fun _if_comp(): *ast_node {
var to_ret.construct(): if_comp
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::if_comp(to_ret))
@@ -868,7 +868,7 @@ obj if_comp (Object) {
return wanted_generator == other.wanted_generator && statement == other.statement
}
}
fun ast_simple_passthrough_ptr(): *ast_node {
fun _passthrough(): *ast_node {
var to_ret.construct(): simple_passthrough
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::simple_passthrough(to_ret))
@@ -917,7 +917,7 @@ obj simple_passthrough (Object) {
out_params == other.out_params && linker_str == other.linker_str
}
}
fun ast_function_call_ptr(func: *ast_node, parameters: vec<*ast_node>): *ast_node {
fun _func_call(func: *ast_node, parameters: vec<*ast_node>): *ast_node {
var to_ret.construct(func, parameters): function_call
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::function_call(to_ret))
@@ -952,7 +952,7 @@ obj function_call (Object) {
return func == func && parameters == other.parameters
}
}
fun ast_compiler_intrinsic_ptr(intrinsic: str, parameters: vec<*ast_node>, type_parameters: vec<*type>, return_type: *type): *ast_node {
fun _compiler_intrinsic(intrinsic: str, parameters: vec<*ast_node>, type_parameters: vec<*type>, return_type: *type): *ast_node {
var to_ret.construct(intrinsic, parameters, type_parameters, return_type): compiler_intrinsic
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::compiler_intrinsic(to_ret))
@@ -996,7 +996,7 @@ obj compiler_intrinsic (Object) {
return intrinsic == intrinsic && parameters == other.parameters && type_parameters == other.type_parameters && return_type == other.return_type
}
}
fun ast_cast_ptr(value: *ast_node, to_type: *type): *ast_node {
fun _cast(value: *ast_node, to_type: *type): *ast_node {
var to_ret.construct(value, to_type): cast
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::cast(to_ret))
@@ -1030,7 +1030,7 @@ obj cast (Object) {
return value == other.value && to_type == other.to_type
}
}
fun ast_value_ptr(string_value: str, value_type: *type): *ast_node {
fun _value(string_value: str, value_type: *type): *ast_node {
var to_ret.construct(string_value, value_type): value
var ptr = new<ast_node>()
ptr->copy_construct(&ast_node::value(to_ret))

110
stdlib/ast_transformation.krak
View File

@@ -45,13 +45,13 @@ obj ast_transformation (Object) {
}
// first pass defines all type_defs (objects and aliases), ADTs, and top-level if-comps/passthroughs
fun first_pass(file_name: str, parse_tree: *tree<symbol>): pair<*ast_node, vec<*ast_node>> {
var translation_unit = ast_translation_unit_ptr(file_name)
var translation_unit = _translation_unit(file_name)
parse_tree->children.for_each(fun(child: *tree<symbol>) {
if (child->data.name == "type_def") {
translation_unit->translation_unit.children.add(first_pass_type_def(child, translation_unit, false))
} else if (child->data.name == "adt_def") {
var name = concat_symbol_tree(get_node("identifier", child))
var adt_def_node = ast_adt_def_ptr(name)
var adt_def_node = _adt_def(name)
adt_def_node->adt_def.self_type = type_ptr(adt_def_node, set(str("Object")))
translation_unit->translation_unit.children.add(adt_def_node)
ast_to_syntax.set(adt_def_node, child)
@@ -72,7 +72,7 @@ obj ast_transformation (Object) {
if (child->data.name == "import") {
var import_identifier_children = get_nodes("identifier", child)
var name = concat_symbol_tree(import_identifier_children[0])
var import_node = ast_import_ptr(name, translation_unit)
var import_node = _import(name, translation_unit)
imports.add(import_node)
translation_unit->translation_unit.children.add(import_node)
ast_to_syntax.set(import_node, child)
@@ -100,15 +100,15 @@ obj ast_transformation (Object) {
template_types.add(concat_symbol_tree(get_node("identifier", template_param)))
template_type_replacements.set(template_types.last(), type_ptr(transform_traits(get_node("traits", template_param))))
})
var template = ast_template_ptr(name, child, template_types, template_type_replacements, false)
var template = _template(name, child, template_types, template_type_replacements, false)
add_to_scope("~enclosing_scope", scope, template)
add_to_scope(name, template, scope)
return template
} else {
// pass in whether or not this is a union
var type_def_node = ast_type_def_ptr(name, concat_symbol_tree(get_node("obj_nonterm", child)) == "uni")
/*var type_def_node = ast_type_def_ptr(name, false)*/
/*var type_def_node = ast_type_def_ptr(name)*/
var type_def_node = _type_def(name, concat_symbol_tree(get_node("obj_nonterm", child)) == "uni")
/*var type_def_node = _type_def(name, false)*/
/*var type_def_node = _type_def(name)*/
type_def_node->type_def.self_type = type_ptr(type_def_node, transform_traits(get_node("traits", child)))
ast_to_syntax.set(type_def_node, child)
add_to_scope("~enclosing_scope", scope, type_def_node)
@@ -161,7 +161,7 @@ obj ast_transformation (Object) {
else
ident_type = type_ptr(base_type::no_type_adt_option())
var option_name = concat_symbol_tree(get_node("identifier", adt_option))
var identifier = ast_identifier_ptr(option_name, ident_type, node)
var identifier = _ident(option_name, ident_type, node)
node->adt_def.options.add(identifier)
// we add the identifier first so that it's found before the function when doing option.thingy
add_to_scope(option_name, identifier, node)
@@ -170,10 +170,10 @@ obj ast_transformation (Object) {
var function_node = null<ast_node>()
if (type_syntax) {
var identifier_param = ast_identifier_ptr(option_name, ident_type, node)
function_node = ast_function_ptr(option_name, type_ptr(vec(get_ast_type(identifier_param)), node->adt_def.self_type, 0, false, false, true), vec(identifier_param), false)
var identifier_param = _ident(option_name, ident_type, node)
function_node = _function(option_name, type_ptr(vec(get_ast_type(identifier_param)), node->adt_def.self_type, 0, false, false, true), vec(identifier_param), false)
} else {
function_node = ast_function_ptr(option_name, type_ptr(vec<*type>(), node->adt_def.self_type, 0, false, false, true), vec<*ast_node>(), false)
function_node = _function(option_name, type_ptr(vec<*type>(), node->adt_def.self_type, 0, false, false, true), vec<*ast_node>(), false)
}
add_to_scope(option_name, function_node, node)
add_to_scope("~enclosing_scope", node, function_node)
@@ -183,29 +183,29 @@ obj ast_transformation (Object) {
// note they don't even have real parameters (but the type has them correctly) or bodies
// I'm not sure this is the correct enclosing scope, but I'm not sure how to do it with the function either
var equals_param = ast_identifier_ptr(str("in"), node->adt_def.self_type->clone_with_indirection(0,true), node)
var nequals_param = ast_identifier_ptr(str("in"), node->adt_def.self_type->clone_with_indirection(0,true), node)
var copy_construct_param = ast_identifier_ptr(str("in"), node->adt_def.self_type->clone_with_indirection(1,false), node)
var assign_param = ast_identifier_ptr(str("in"), node->adt_def.self_type->clone_with_indirection(0,true), node)
var equals_param = _ident(str("in"), node->adt_def.self_type->clone_with_indirection(0,true), node)
var nequals_param = _ident(str("in"), node->adt_def.self_type->clone_with_indirection(0,true), node)
var copy_construct_param = _ident(str("in"), node->adt_def.self_type->clone_with_indirection(1,false), node)
var assign_param = _ident(str("in"), node->adt_def.self_type->clone_with_indirection(0,true), node)
vec(
make_pair("operator==", ast_function_ptr(str("operator=="),
make_pair("operator==", _function(str("operator=="),
type_ptr(vec(equals_param->identifier.type), type_ptr(base_type::boolean()), 0, false, false, true),
vec(equals_param), ast_identifier_ptr("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false)),
make_pair("operator!=", ast_function_ptr(str("operator!="),
vec(equals_param), _ident("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false)),
make_pair("operator!=", _function(str("operator!="),
type_ptr(vec(nequals_param->identifier.type), type_ptr(base_type::boolean()), 0, false, false, true),
vec(nequals_param), ast_identifier_ptr("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false)),
make_pair("construct", ast_function_ptr(str("construct"),
vec(nequals_param), _ident("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false)),
make_pair("construct", _function(str("construct"),
type_ptr(vec<*type>(), node->adt_def.self_type->clone_with_increased_indirection(), 0, false, false, true),
vec<*ast_node>(), ast_identifier_ptr("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false)),
make_pair("copy_construct", ast_function_ptr(str("copy_construct"),
vec<*ast_node>(), _ident("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false)),
make_pair("copy_construct", _function(str("copy_construct"),
type_ptr(vec(copy_construct_param->identifier.type), type_ptr(base_type::void_return()), 0, false, false, true),
vec(copy_construct_param), ast_identifier_ptr("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false)),
make_pair("operator=", ast_function_ptr(str("operator="),
vec(copy_construct_param), _ident("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false)),
make_pair("operator=", _function(str("operator="),
type_ptr(vec(assign_param->identifier.type), type_ptr(base_type::void_return()), 0, false, false, true),
vec(assign_param), ast_identifier_ptr("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false)),
make_pair("destruct", ast_function_ptr(str("destruct"),
vec(assign_param), _ident("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false)),
make_pair("destruct", _function(str("destruct"),
type_ptr(vec<*type>(), type_ptr(base_type::void_return()), 0, false, false, true),
vec<*ast_node>(), ast_identifier_ptr("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false))
vec<*ast_node>(), _ident("this", node->adt_def.self_type->clone_with_indirection(1), node), false, false))
).for_each(fun(func_pair: pair<*char, *ast_node>) {
node->adt_def.regular_funcs.add(func_pair.second)
add_to_scope(str(func_pair.first), func_pair.second, node)
@@ -225,7 +225,7 @@ obj ast_transformation (Object) {
template_types.add(concat_symbol_tree(get_node("identifier", template_param)))
template_type_replacements.set(template_types.last(), type_ptr(transform_traits(get_node("traits", template_param))))
})
var template = ast_template_ptr(function_name, node, template_types, template_type_replacements, true)
var template = _template(function_name, node, template_types, template_type_replacements, true)
add_to_scope(function_name, template, scope)
add_to_scope("~enclosing_scope", scope, template)
return template
@@ -246,21 +246,21 @@ obj ast_transformation (Object) {
var param_type = transform_type(get_node("type", child), scope, template_replacements)
if (param_type->is_none())
error(child, "parameter type none")
parameters.add(ast_identifier_ptr(concat_symbol_tree(get_node("identifier", child)), param_type, null<ast_node>()))
parameters.add(_ident(concat_symbol_tree(get_node("identifier", child)), param_type, null<ast_node>()))
})
var is_variadic = get_node("\"...\"", node) != null<tree<symbol>>()
var is_raw = function_name != "__compiler_lambda__"
var this_param = null<ast_node>()
if (is_type_def(scope)) {
this_param = ast_identifier_ptr("this", scope->type_def.self_type->clone_with_indirection(1), scope)
this_param = _ident("this", scope->type_def.self_type->clone_with_indirection(1), scope)
} else if (is_template(scope)) {
var parent_scope = get_ast_scope(scope)->get(str("~enclosing_scope"))[0]
if (is_type_def(parent_scope)) {
this_param = ast_identifier_ptr("this", parent_scope->type_def.self_type->clone_with_indirection(1), parent_scope)
this_param = _ident("this", parent_scope->type_def.self_type->clone_with_indirection(1), parent_scope)
}
}
// figure out function type and make function_node
var function_node = ast_function_ptr(function_name,
var function_node = _function(function_name,
type_ptr(parameters.map(fun(parameter: *ast_node): *type return parameter->identifier.type;),
return_type, 0, false, is_variadic, is_raw), parameters, this_param, get_node("\"ext\"", node) != null<tree<symbol>>(), is_variadic)
// fix up the enclosing_scope's
@@ -586,22 +586,22 @@ obj ast_transformation (Object) {
value_str = value_str.slice(0, -1-chop)
}
}
return ast_value_ptr(value_str, value_type)
return _value(value_str, value_type)
}
fun transform_code_block(node: *tree<symbol>, scope: *ast_node, template_replacements: map<str, *type>): *ast_node {
var new_block = ast_code_block_ptr()
var new_block = _code_block()
add_to_scope("~enclosing_scope", scope, new_block)
new_block->code_block.children = transform_all(node->children, new_block, template_replacements)
return new_block
}
fun transform_if_comp(node: *tree<symbol>, scope: *ast_node): *ast_node {
var new_if_comp = ast_if_comp_ptr()
var new_if_comp = _if_comp()
new_if_comp->if_comp.wanted_generator = concat_symbol_tree(get_node("identifier", node))
new_if_comp->if_comp.statement = transform_statement(get_node("statement", node), scope, map<str, *type>())
return new_if_comp
}
fun transform_simple_passthrough(node: *tree<symbol>, scope: *ast_node): *ast_node {
var new_passthrough = ast_simple_passthrough_ptr()
var new_passthrough = _passthrough()
new_passthrough->simple_passthrough.passthrough_str = concat_symbol_tree(get_node("triple_quoted_string", node)).slice(3,-4)
// setup passthrough params and str
var passthrough_params = get_node("passthrough_params", node)
@@ -642,7 +642,7 @@ obj ast_transformation (Object) {
var expression_syntax_node = get_node("boolean_expression", node)
var expression = null<ast_node>()
// we do it early so that if there is a type_syntax_node we can add to scope so that the expression can find this for things like rec closures
var identifier = ast_identifier_ptr(name, null<type>(), scope, get_node("\"ext\"", node) != null<tree<symbol>>())
var identifier = _ident(name, null<type>(), scope, get_node("\"ext\"", node) != null<tree<symbol>>())
add_to_scope(name, identifier, scope)
if (type_syntax_node) identifier->identifier.type = transform_type(type_syntax_node, scope, template_replacements)
if (expression_syntax_node) {
@@ -652,7 +652,7 @@ obj ast_transformation (Object) {
}
if (!identifier->identifier.type) error(node, "declaration statement with no type or expression from which to inference type")
if (identifier->identifier.type->is_none() || (identifier->identifier.type->indirection == 0 && identifier->identifier.type->is_void())) error(node, "declaration statement with bad type")
var declaration = ast_declaration_statement_ptr(identifier, expression)
var declaration = _declaration(identifier, expression)
// ok, deal with the possible init position method call
if (identifiers.size == 2) {
var parameters = get_nodes("parameter", node).map(fun(child: *tree<symbol>): *ast_node return transform(get_node("boolean_expression", child), scope, template_replacements);)
@@ -717,13 +717,13 @@ obj ast_transformation (Object) {
}
to_assign = make_operator_call("^", vec(assign_to, to_assign))
}
var assignment = ast_assignment_statement_ptr(assign_to, to_assign)
var assignment = _assign(assign_to, to_assign)
return assignment
}
fun transform_if_statement(node: *tree<symbol>, scope: *ast_node, template_replacements: map<str, *type>): *ast_node {
if (get_node("AmbiguityInner", node))
error(node, "Ambigious two ifs with one else!")
var if_statement = ast_if_statement_ptr(transform_expression(get_node("boolean_expression", node), scope, template_replacements))
var if_statement = _if(transform_expression(get_node("boolean_expression", node), scope, template_replacements))
// one variable declarations might be in a code_block-less if statement
add_to_scope("~enclosing_scope", scope, if_statement)
var statements = transform_all(get_nodes("statement", node), if_statement, template_replacements)
@@ -734,13 +734,13 @@ obj ast_transformation (Object) {
return if_statement
}
fun transform_while_loop(node: *tree<symbol>, scope: *ast_node, template_replacements: map<str, *type>): *ast_node {
var while_loop = ast_while_loop_ptr(transform_expression(get_node("boolean_expression", node), scope, template_replacements))
var while_loop = _while(transform_expression(get_node("boolean_expression", node), scope, template_replacements))
add_to_scope("~enclosing_scope", scope, while_loop)
while_loop->while_loop.statement = transform(get_node("statement", node), while_loop, template_replacements)
return while_loop
}
fun transform_for_loop(node: *tree<symbol>, scope: *ast_node, template_replacements: map<str, *type>): *ast_node {
var for_loop = ast_for_loop_ptr()
var for_loop = _for()
add_to_scope("~enclosing_scope", scope, for_loop)
var statements = get_nodes("statement", node)
for_loop->for_loop.init = transform(statements[0], for_loop, template_replacements)
@@ -753,27 +753,27 @@ obj ast_transformation (Object) {
var return_value = get_node("boolean_expression", node)
var to_ret: *ast_node
if (return_value)
to_ret = ast_return_statement_ptr(transform(return_value, scope, template_replacements))
to_ret = _return(transform(return_value, scope, template_replacements))
else
to_ret = ast_return_statement_ptr(null<ast_node>())
to_ret = _return(null<ast_node>())
ast_to_syntax.set(to_ret, node)
return to_ret
}
fun transform_branching_statement(node: *tree<symbol>, scope: *ast_node): *ast_node {
if (node->data.name == "break_statement")
return ast_branching_statement_ptr(branching_type::break_stmt())
return ast_branching_statement_ptr(branching_type::continue_stmt())
return _branch(branching_type::break_stmt())
return _branch(branching_type::continue_stmt())
}
fun transform_defer_statement(node: *tree<symbol>, scope: *ast_node, template_replacements: map<str, *type>): *ast_node {
return ast_defer_statement_ptr(transform(node->children[0], scope, template_replacements))
return _defer(transform(node->children[0], scope, template_replacements))
}
fun transform_match_statement(node: *tree<symbol>, scope: *ast_node, template_replacements: map<str, *type>): *ast_node {
var to_ret = ast_match_statement_ptr(transform(get_node("boolean_expression", node), scope, template_replacements))
var to_ret = _match(transform(get_node("boolean_expression", node), scope, template_replacements))
get_nodes("case_statement", node).for_each(fun(syntax: *tree<symbol>) to_ret->match_statement.cases.add(transform_case_statement(syntax, scope, template_replacements));)
return to_ret
}
fun transform_case_statement(node: *tree<symbol>, scope: *ast_node, template_replacements: map<str, *type>): *ast_node {
var to_ret = ast_case_statement_ptr()
var to_ret = _case()
var the_adts = scope_lookup(concat_symbol_tree(get_node("scoped_identifier", get_node("scoped_identifier", node))), scope).filter(fun(i: *ast_node): bool return is_adt_def(i);)
if (the_adts.size != 1)
error(node, str("the number of adts found was not 1, it was ") + the_adts.size + " for " + concat_symbol_tree(get_node("scoped_identifier", node)))
@@ -784,7 +784,7 @@ obj ast_transformation (Object) {
to_ret->case_statement.option = the_option
var possible_ident = get_node("identifier", node)
if (possible_ident) {
var ident = ast_identifier_ptr(concat_symbol_tree(possible_ident), the_option->identifier.type, scope)
var ident = _ident(concat_symbol_tree(possible_ident), the_option->identifier.type, scope)
to_ret->case_statement.unpack_ident = ident
add_to_scope(ident->identifier.name, ident, to_ret)
}
@@ -807,7 +807,7 @@ obj ast_transformation (Object) {
}
if (!(func_type->is_function() && func_type->indirection == 0))
error(node, "trying to call not a function")
var f = ast_function_call_ptr(func, parameters)
var f = _func_call(func, parameters)
return f
}
fun transform_compiler_intrinsic(node: *tree<symbol>, scope: *ast_node, template_replacements: map<str, *type>): *ast_node {
@@ -819,7 +819,7 @@ obj ast_transformation (Object) {
intrinsic_return_type = get_ast_type(parameters[0])
else
intrinsic_return_type = type_ptr(base_type::ulong_int())
return ast_compiler_intrinsic_ptr(intrinsic_name, parameters, type_parameters, intrinsic_return_type)
return _compiler_intrinsic(intrinsic_name, parameters, type_parameters, intrinsic_return_type)
}
fun transform_lambda(node: *tree<symbol>, scope: *ast_node, template_replacements: map<str, *type>): *ast_node {
var function_node = second_pass_function(node, scope, template_replacements, false)
@@ -875,7 +875,7 @@ obj ast_transformation (Object) {
if (func_name == "[")
func_name += "]"
if (func_name == "cast")
return ast_cast_ptr(transform(get_node("boolean_expression", node), scope, template_replacements), transform_type(get_node("type", node), scope, template_replacements))
return _cast(transform(get_node("boolean_expression", node), scope, template_replacements), transform_type(get_node("type", node), scope, template_replacements))
var first_param = transform(node->children[0], scope, template_replacements)
var second_param = null<ast_node>()
if (func_name == "." || func_name == "->") {
@@ -920,7 +920,7 @@ obj ast_transformation (Object) {
var possible_overload_call = find_and_make_any_operator_overload_call(func_name, parameters, scope, template_replacements)
if (possible_overload_call)
return possible_overload_call
return ast_function_call_ptr(get_builtin_function(func_name, parameter_types, node), parameters)
return _func_call(get_builtin_function(func_name, parameter_types, node), parameters)
}
fun find_and_make_any_operator_overload_call(func_name: str, parameters: vec<*ast_node>, scope: *ast_node, template_replacements: map<str, *type>): *ast_node {
var parameter_types = parameters.map(fun(param: *ast_node): *type return get_ast_type(param);)
@@ -943,7 +943,7 @@ obj ast_transformation (Object) {
if (!possible_overload)
possible_overload = find_or_instantiate_template_function(str("operator")+func_name, null<tree<symbol>>(), scope, parameter_types, template_replacements, map<str, *type>())
if (possible_overload)
return ast_function_call_ptr(possible_overload, parameters)
return _func_call(possible_overload, parameters)
return null<ast_node>()
}
fun find_or_instantiate_template_function(name: str, template_inst: *tree<symbol>, scope: *ast_node, param_types: vec<*type>, template_replacements: map<str, *type>, replacements_base: map<str, *type>): *ast_node {

6
stdlib/bytecode_generator.krak
View File

@@ -428,7 +428,7 @@ obj bytecode_generator (Object) {
// we should save our return value as as the first parameter
if (return_type->is_object() && return_type->indirection == 0) {
var ptr_type = return_type->clone_with_increased_indirection()
functions.last().var_to_frame_offset[ast_identifier_ptr("bytecode_struct_return_temp_address", ptr_type, null<ast_node>())] = parameter_offset
functions.last().var_to_frame_offset[_ident("bytecode_struct_return_temp_address", ptr_type, null<ast_node>())] = parameter_offset
parameter_offset += type_size(ptr_type)
}
node->function.parameters.for_each(fun(p: *ast_node) {
@@ -445,7 +445,7 @@ obj bytecode_generator (Object) {
generate(node->function.body_statement)
// generate a return just in case the function itself doesn't have one
generate_return_statement(ast_return_statement_ptr(null<ast_node>()))
generate_return_statement(_return(null<ast_node>()))
instructions[push_frame_idx].addi.bi = -functions.last().frame_size
@@ -763,7 +763,7 @@ obj bytecode_generator (Object) {
var return_type = get_ast_type(func)->return_type
var struct_return_temp_ident = null<ast_node>()
if (return_type->is_object() && return_type->indirection == 0) {
struct_return_temp_ident = ast_identifier_ptr("bytecode_struct_return_temp", return_type, null<ast_node>())
struct_return_temp_ident = _ident("bytecode_struct_return_temp", return_type, null<ast_node>())
functions.last().frame_size += type_size(return_type)
functions.last().var_to_frame_offset[struct_return_temp_ident] = -functions.last().frame_size
}

2
stdlib/c_line_control.krak
View File

@@ -12,7 +12,7 @@ import ast_transformation:*
import pass_common:*
fun get_line(node: *tree<symbol>, name: str): *ast_node {
var to_ret = ast_simple_passthrough_ptr()
var to_ret = _passthrough()
to_ret->simple_passthrough.passthrough_str = str("\n#line ") + get_first_terminal(node)->data.position + " \"" + name + "\"\n"
return to_ret
}

2
stdlib/defer_lower.krak
View File

@@ -44,7 +44,7 @@ fun defer_lower(name_ast_map: *map<str, pair<*tree<symbol>,*ast_node>>, ast_to_s
var helper_after = fun(node: *ast_node, parent_chain: *stack<*ast_node>) {
match(*node) {
ast_node::branching_statement(backing) {
var block = ast_code_block_ptr()
var block = _code_block()
add_to_scope("~enclosing_scope", parent_chain->item_from_top_satisfying(fun(i: *ast_node): bool return is_code_block(i) || is_function(i);), block)
replace_with_in(node, block, parent_chain)
for (var i = 0; i < defer_triple_stack.top().size() - loop_stack.top(); i++;)

66
stdlib/function_value_lower.krak
View File

@@ -154,22 +154,22 @@ fun function_value_lower(name_ast_map: *map<str, pair<*tree<symbol>,*ast_node>>,
cleaned->is_raw = true
var new_type_def_name = t.to_string() + "_function_value_struct"
var new_type_def = ast_type_def_ptr(new_type_def_name)
var new_type_def = _type_def(new_type_def_name)
var func_ident = ast_identifier_ptr("func", cleaned, new_type_def)
var func_ident = _ident("func", cleaned, new_type_def)
add_to_scope("func", func_ident, new_type_def)
var func_closure_type = cleaned->clone()
func_closure_type->parameter_types.add(0, type_ptr(base_type::void_return(), 1))
var func_closure_ident = ast_identifier_ptr("func_closure", func_closure_type, new_type_def)
var func_closure_ident = _ident("func_closure", func_closure_type, new_type_def)
add_to_scope("func_closure", func_closure_ident, new_type_def)
var data_ident = ast_identifier_ptr("data", void_ptr, new_type_def)
var data_ident = _ident("data", void_ptr, new_type_def)
add_to_scope("data", data_ident, new_type_def)
new_type_def->type_def.variables.add(ast_declaration_statement_ptr(func_ident, null<ast_node>()))
new_type_def->type_def.variables.add(ast_declaration_statement_ptr(func_closure_ident, null<ast_node>()))
new_type_def->type_def.variables.add(ast_declaration_statement_ptr(data_ident, null<ast_node>()))
new_type_def->type_def.variables.add(_declaration(func_ident, null<ast_node>()))
new_type_def->type_def.variables.add(_declaration(func_closure_ident, null<ast_node>()))
new_type_def->type_def.variables.add(_declaration(data_ident, null<ast_node>()))
add_to_scope("~enclosing_scope", name_ast_map->values.first().second, new_type_def)
add_to_scope(new_type_def_name, new_type_def, name_ast_map->values.first().second)
@@ -179,17 +179,17 @@ fun function_value_lower(name_ast_map: *map<str, pair<*tree<symbol>,*ast_node>>,
var lambda_call_type = type_ptr(vec(lambda_struct_type) + t.parameter_types, t.return_type, 0, false, false, true)
// create parameters
var lambda_call_func_param = ast_identifier_ptr("func_struct", lambda_struct_type, null<ast_node>())
var lambda_call_func_param = _ident("func_struct", lambda_struct_type, null<ast_node>())
var lambda_call_parameters = vec(lambda_call_func_param) + cleaned->parameter_types.map(fun(t:*type): *ast_node {
return ast_identifier_ptr("pass_through_param", t, null<ast_node>())
return _ident("pass_through_param", t, null<ast_node>())
})
var lambda_call_function = ast_function_ptr(str("lambda_call"), lambda_call_type, lambda_call_parameters, false)
var lambda_call_function = _function(str("lambda_call"), lambda_call_type, lambda_call_parameters, false)
// create call body with if, etc
var if_statement = ast_if_statement_ptr(access_expression(lambda_call_func_param, "data"))
lambda_call_function->function.body_statement = ast_code_block_ptr(if_statement)
if_statement->if_statement.then_part = ast_code_block_ptr(ast_return_statement_ptr(ast_function_call_ptr(access_expression(lambda_call_func_param, "func_closure"),
var if_statement = _if(access_expression(lambda_call_func_param, "data"))
lambda_call_function->function.body_statement = _code_block(if_statement)
if_statement->if_statement.then_part = _code_block(_return(_func_call(access_expression(lambda_call_func_param, "func_closure"),
vec(access_expression(lambda_call_func_param, "data")) + lambda_call_parameters.slice(1,-1))))
if_statement->if_statement.else_part = ast_code_block_ptr(ast_return_statement_ptr(ast_function_call_ptr(access_expression(lambda_call_func_param, "func"),
if_statement->if_statement.else_part = _code_block(_return(_func_call(access_expression(lambda_call_func_param, "func"),
lambda_call_parameters.slice(1,-1))))
lambda_type_to_struct_type_and_call_func[t] = make_pair(lambda_struct_type, lambda_call_function)
@@ -210,13 +210,13 @@ fun function_value_lower(name_ast_map: *map<str, pair<*tree<symbol>,*ast_node>>,
var closure_struct_type: *type
if (l->function.closed_variables.size()) {
var new_type_def_name = str("closure_struct_") + closure_id++
var new_type_def = ast_type_def_ptr(new_type_def_name)
var new_type_def = _type_def(new_type_def_name)
l->function.closed_variables.for_each(fun(v: *ast_node) {
var closed_var_type = v->identifier.type
if (lambda_type_to_struct_type_and_call_func.contains_key(*closed_var_type))
closed_var_type = lambda_type_to_struct_type_and_call_func[*closed_var_type].first
var closed_ident = ast_identifier_ptr(v->identifier.name, closed_var_type->clone_with_increased_indirection(), new_type_def)
new_type_def->type_def.variables.add(ast_declaration_statement_ptr(closed_ident, null<ast_node>()))
var closed_ident = _ident(v->identifier.name, closed_var_type->clone_with_increased_indirection(), new_type_def)
new_type_def->type_def.variables.add(_declaration(closed_ident, null<ast_node>()))
add_to_scope(v->identifier.name, closed_ident, new_type_def)
})
add_to_scope("~enclosing_scope", name_ast_map->values.first().second, new_type_def)
@@ -227,31 +227,31 @@ fun function_value_lower(name_ast_map: *map<str, pair<*tree<symbol>,*ast_node>>,
var return_type = lambda_type_to_struct_type_and_call_func[*l->function.type].first
var creation_type = type_ptr(vec<*type>(), return_type, 0, false, false, true)
lambda_creation_funcs[l] = ast_function_ptr(l->function.name + "_creation", creation_type, vec<*ast_node>(), false);
var body = ast_code_block_ptr()
var ident = ast_identifier_ptr("to_ret", return_type, body)
body->code_block.children.add(ast_declaration_statement_ptr(ident, null<ast_node>()))
body->code_block.children.add(ast_assignment_statement_ptr(access_expression(ident, "func"), l))
body->code_block.children.add(ast_assignment_statement_ptr(access_expression(ident, "func_closure"), l))
lambda_creation_funcs[l] = _function(l->function.name + "_creation", creation_type, vec<*ast_node>(), false);
var body = _code_block()
var ident = _ident("to_ret", return_type, body)
body->code_block.children.add(_declaration(ident, null<ast_node>()))
body->code_block.children.add(_assign(access_expression(ident, "func"), l))
body->code_block.children.add(_assign(access_expression(ident, "func_closure"), l))
if (l->function.closed_variables.size()) {
var closure_lambda_param = ast_identifier_ptr("closure_data_pass", closure_struct_type, l)
var closure_lambda_param = _ident("closure_data_pass", closure_struct_type, l)
l->function.parameters.add(0, closure_lambda_param)
var closure_param = ast_identifier_ptr("closure", closure_struct_type, body)
var closure_param = _ident("closure", closure_struct_type, body)
lambda_creation_funcs[l]->function.parameters.add(closure_param)
body->code_block.children.add(ast_assignment_statement_ptr(access_expression(ident, "data"), closure_param))
body->code_block.children.add(_assign(access_expression(ident, "data"), closure_param))
l->function.closed_variables.for_each(fun(v: *ast_node) {
// have to make sure to clean here as well
var closed_param_type = v->identifier.type
if (lambda_type_to_struct_type_and_call_func.contains_key(*closed_param_type))
closed_param_type = lambda_type_to_struct_type_and_call_func[*closed_param_type].first
var closed_param = ast_identifier_ptr("closed_param", closed_param_type->clone_with_increased_indirection(), l)
var closed_param = _ident("closed_param", closed_param_type->clone_with_increased_indirection(), l)
lambda_creation_funcs[l]->function.parameters.add(closed_param)
body->code_block.children.add(ast_assignment_statement_ptr(access_expression(closure_param, v->identifier.name), closed_param))
body->code_block.children.add(_assign(access_expression(closure_param, v->identifier.name), closed_param))
})
} else {
body->code_block.children.add(ast_assignment_statement_ptr(access_expression(ident, "data"), ast_value_ptr(str("0"), type_ptr(base_type::void_return(), 1))))
body->code_block.children.add(_assign(access_expression(ident, "data"), _value(str("0"), type_ptr(base_type::void_return(), 1))))
}
body->code_block.children.add(ast_return_statement_ptr(ident))
body->code_block.children.add(_return(ident))
lambda_creation_funcs[l]->function.body_statement = body
name_ast_map->values.first().second->translation_unit.children.add(lambda_creation_funcs[l])
})
@@ -269,8 +269,8 @@ fun function_value_lower(name_ast_map: *map<str, pair<*tree<symbol>,*ast_node>>,
if (p.function->function.closed_variables.size()) {
// pull closure type off lambda creation func parameter
var closure_type = get_ast_type(lambda_creation_funcs[p.function]->function.parameters[0])->clone_with_decreased_indirection()
var closure_struct_ident = ast_identifier_ptr("closure_struct", closure_type, p.parent_block)
p.parent_block->code_block.children.add(0,ast_declaration_statement_ptr(closure_struct_ident, null<ast_node>()))
var closure_struct_ident = _ident("closure_struct", closure_type, p.parent_block)
p.parent_block->code_block.children.add(0,_declaration(closure_struct_ident, null<ast_node>()))
lambda_creation_params.add(make_operator_call("&", vec(closure_struct_ident)))
p.function->function.closed_variables.for_each(fun(v: *ast_node) {
var addr_of = make_operator_call("&", vec(v))
@@ -280,7 +280,7 @@ fun function_value_lower(name_ast_map: *map<str, pair<*tree<symbol>,*ast_node>>,
lambda_creation_params.add(addr_of)
})
}
var func_call = ast_function_call_ptr(lambda_creation_funcs[p.function], lambda_creation_params)
var func_call = _func_call(lambda_creation_funcs[p.function], lambda_creation_params)
replace_with_in(p.function, func_call, p.parent)
})
curr_time = split(curr_time, "\tfunction_value_creation_points.forEach")

10
stdlib/interpreter.krak
View File

@@ -145,17 +145,17 @@ fun unwrap_value(val: value): *ast_node {
value::ulong_int(data) value_string = to_string(data)
value::floating(data) value_string = to_string(data)
value::double_precision(data) value_string = to_string(data)
value::void_nothing() error("trying to unwrap a void into an ast_value_ptr")
value::void_nothing() error("trying to unwrap a void into an _value")
value::pointer(point) {
if (point.second->base == base_type::character() && point.second->indirection == 1)
value_string = str("\"") + str((point.first) cast *char) + "\""
else
error("trying to unwrap a pointer into an ast_value_ptr")
error("trying to unwrap a pointer into an _value")
}
value::object_like(ob) error("trying to unwrap an object_like into an ast_value_ptr")
value::function(fn) error("trying to unwrap a function into an ast_value_ptr")
value::object_like(ob) error("trying to unwrap an object_like into an _value")
value::function(fn) error("trying to unwrap a function into an _value")
}
return ast_value_ptr(value_string, get_type_from_primitive_value(get_real_value(val)))
return _value(value_string, get_type_from_primitive_value(get_real_value(val)))
}
fun is_boolean(it: value): bool { match(it) { value::boolean(var) return true; } return false; }

70
stdlib/obj_lower.krak
View File

@@ -42,7 +42,7 @@ fun obj_lower(name_ast_map: *map<str, pair<*tree<symbol>,*ast_node>>, ast_to_syn
match(*node) {
ast_node::type_def(backing) all_type_defs.add(node)
ast_node::function(backing) if (backing.body_statement && !is_code_block(backing.body_statement)) {
backing.body_statement = ast_code_block_ptr(backing.body_statement)
backing.body_statement = _code_block(backing.body_statement)
add_to_scope("~enclosing_scope", node, backing.body_statement)
if (!is_code_block(backing.body_statement))
error("BUT EXTRA WHY")
@@ -51,55 +51,55 @@ fun obj_lower(name_ast_map: *map<str, pair<*tree<symbol>,*ast_node>>, ast_to_syn
}
ast_node::if_statement(backing) {
if (!is_code_block(backing.then_part)) {
backing.then_part = ast_code_block_ptr(backing.then_part)
backing.then_part = _code_block(backing.then_part)
add_to_scope("~enclosing_scope", node, backing.then_part)
}
if (backing.else_part && !is_code_block(backing.else_part)) {
backing.else_part = ast_code_block_ptr(backing.else_part)
backing.else_part = _code_block(backing.else_part)
add_to_scope("~enclosing_scope", node, backing.else_part)
}
}
// no need for case because it's already been lowered
ast_node::while_loop(backing) {
if (!is_code_block(backing.statement)) {
backing.statement = ast_code_block_ptr(backing.statement)
backing.statement = _code_block(backing.statement)
add_to_scope("~enclosing_scope", node, backing.statement)
}
var condition = backing.condition
backing.condition = ast_value_ptr(str("true"), type_ptr(base_type::boolean()))
backing.condition = _value(str("true"), type_ptr(base_type::boolean()))
// objects do not coerce to booleans, so it should be ok for this not to be a ref
var condition_ident = ast_identifier_ptr("condition_temp", get_ast_type(condition), backing.statement)
backing.statement->code_block.children.add(0, ast_declaration_statement_ptr(condition_ident, condition))
var condition_if = ast_if_statement_ptr(make_operator_call("!", vec(condition_ident)))
condition_if->if_statement.then_part = ast_branching_statement_ptr(branching_type::break_stmt())
var condition_ident = _ident("condition_temp", get_ast_type(condition), backing.statement)
backing.statement->code_block.children.add(0, _declaration(condition_ident, condition))
var condition_if = _if(make_operator_call("!", vec(condition_ident)))
condition_if->if_statement.then_part = _branch(branching_type::break_stmt())
backing.statement->code_block.children.add(1, condition_if)
}
ast_node::for_loop(backing) {
if (!is_code_block(backing.body)) {
backing.body = ast_code_block_ptr(backing.body)
backing.body = _code_block(backing.body)
add_to_scope("~enclosing_scope", node, backing.body)
}
add_before_in(backing.init, node, parent_chain->top())
backing.init = null<ast_node>()
// the do_update goes in the block above the for
var update_ident = ast_identifier_ptr("do_update", type_ptr(base_type::boolean()), parent_chain->top())
add_before_in(ast_declaration_statement_ptr(update_ident, ast_value_ptr(str("false"), type_ptr(base_type::boolean()))),
var update_ident = _ident("do_update", type_ptr(base_type::boolean()), parent_chain->top())
add_before_in(_declaration(update_ident, _value(str("false"), type_ptr(base_type::boolean()))),
node, parent_chain->top())
var update_if = ast_if_statement_ptr(update_ident)
var update_if = _if(update_ident)
add_to_scope("~enclosing_scope", backing.body, update_if)
update_if->if_statement.then_part = ast_code_block_ptr(backing.update)
update_if->if_statement.then_part = _code_block(backing.update)
add_to_scope("~enclosing_scope", update_if, update_if->if_statement.then_part)
backing.update = null<ast_node>()
backing.body->code_block.children.add(0, update_if)
backing.body->code_block.children.add(1, ast_assignment_statement_ptr(update_ident, ast_value_ptr(str("true"), type_ptr(base_type::boolean()))))
backing.body->code_block.children.add(1, _assign(update_ident, _value(str("true"), type_ptr(base_type::boolean()))))
var condition = backing.condition
backing.condition = ast_value_ptr(str("true"), type_ptr(base_type::boolean()))
backing.condition = _value(str("true"), type_ptr(base_type::boolean()))
// objects do not coerce to booleans, so it should be ok for this not to be a ref
var condition_ident = ast_identifier_ptr("condition_temp", get_ast_type(condition), backing.body)
backing.body->code_block.children.add(2, ast_declaration_statement_ptr(condition_ident, condition))
var condition_if = ast_if_statement_ptr(make_operator_call("!", vec(condition_ident)))
condition_if->if_statement.then_part = ast_branching_statement_ptr(branching_type::break_stmt())
var condition_ident = _ident("condition_temp", get_ast_type(condition), backing.body)
backing.body->code_block.children.add(2, _declaration(condition_ident, condition))
var condition_if = _if(make_operator_call("!", vec(condition_ident)))
condition_if->if_statement.then_part = _branch(branching_type::break_stmt())
backing.body->code_block.children.add(3, condition_if)
}
}
@@ -144,15 +144,15 @@ fun obj_lower(name_ast_map: *map<str, pair<*tree<symbol>,*ast_node>>, ast_to_syn
}
if (func_name == "||" || func_name == "&&") {
var enclosing_block_idx = parent_chain->index_from_top_satisfying(fun(i: *ast_node): bool return is_code_block(i);)
var short_circuit_result = ast_identifier_ptr("short_circut_result", type_ptr(base_type::boolean()), parent_chain->from_top(enclosing_block_idx))
var short_circuit_declaration = ast_declaration_statement_ptr(short_circuit_result, backing.parameters[0])
var short_circuit_result = _ident("short_circut_result", type_ptr(base_type::boolean()), parent_chain->from_top(enclosing_block_idx))
var short_circuit_declaration = _declaration(short_circuit_result, backing.parameters[0])
var condition = short_circuit_result
if (func_name == "||")
condition = make_operator_call("!", vec(condition))
var short_circuit_if = ast_if_statement_ptr(condition)
var short_circuit_if = _if(condition)
add_to_scope("~enclosing_scope", parent_chain->from_top(enclosing_block_idx), short_circuit_if)
// how to get proper parent scoping working for this part
short_circuit_if->if_statement.then_part = ast_code_block_ptr(ast_assignment_statement_ptr(short_circuit_result, backing.parameters[1]))
short_circuit_if->if_statement.then_part = _code_block(_assign(short_circuit_result, backing.parameters[1]))
add_to_scope("~enclosing_scope", short_circuit_if, short_circuit_if->if_statement.then_part)
add_before_in(short_circuit_declaration, parent_chain->from_top(enclosing_block_idx-1), parent_chain->from_top(enclosing_block_idx))
add_before_in(short_circuit_if, parent_chain->from_top(enclosing_block_idx-1), parent_chain->from_top(enclosing_block_idx))
@@ -203,10 +203,10 @@ fun obj_lower(name_ast_map: *map<str, pair<*tree<symbol>,*ast_node>>, ast_to_syn
in_function_param_type = get_ast_type(param)->clone_without_ref()
var param_type = get_ast_type(param)
if (!in_function_param_type->is_ref && param_type->indirection == 0 && (param_type->is_object() && has_method(param_type->type_def, "copy_construct", vec(param_type->clone_with_indirection(1))))) {
var temp_ident = ast_identifier_ptr("temporary_param_boom", param_type->clone_without_ref(), replace_in)
var temp_ident = _ident("temporary_param_boom", param_type->clone_without_ref(), replace_in)
add_to_scope("temporary_param_boom", temp_ident, replace_in)
add_to_scope("~enclosing_scope", replace_in, temp_ident)
var declaration = ast_declaration_statement_ptr(temp_ident, null<ast_node>())
var declaration = _declaration(temp_ident, null<ast_node>())
var copy_in = make_method_call(temp_ident, "copy_construct", vec(make_operator_call("&", vec(param))))
add_before_in(declaration, replace_before, replace_in)
add_before_in(copy_in, replace_before, replace_in)
@@ -215,13 +215,13 @@ fun obj_lower(name_ast_map: *map<str, pair<*tree<symbol>,*ast_node>>, ast_to_syn
}
var func_return_type = func_type->return_type
if (!func_return_type->is_ref && func_return_type->indirection == 0 && func_return_type->is_object()) {
var temp_return = ast_identifier_ptr("temporary_return_boomchaka", func_return_type, replace_in)
var temp_return = _ident("temporary_return_boomchaka", func_return_type, replace_in)
add_to_scope("temporary_return_boomchaka", temp_return, replace_in)
add_to_scope("~enclosing_scope", replace_in, temp_return)
var declaration = ast_declaration_statement_ptr(temp_return, node)
var declaration = _declaration(temp_return, node)
add_before_in(declaration, replace_before, replace_in)
if (has_method(func_return_type->type_def, "destruct", vec<*type>())) {
add_before_in(ast_defer_statement_ptr(make_method_call(temp_return, "destruct", vec<*ast_node>())),
add_before_in(_defer(make_method_call(temp_return, "destruct", vec<*ast_node>())),
replace_before, replace_in)
}
replace_with_in(node, temp_return, parent_chain)
@@ -242,7 +242,7 @@ fun obj_lower(name_ast_map: *map<str, pair<*tree<symbol>,*ast_node>>, ast_to_syn
if (!is_code_block(backing.body_statement))
error("BUT WHY")
backing.body_statement->code_block.children.add(order++,
ast_defer_statement_ptr(make_method_call(param, "destruct", vec<*ast_node>())))
_defer(make_method_call(param, "destruct", vec<*ast_node>())))
}
})
}
@@ -252,10 +252,10 @@ fun obj_lower(name_ast_map: *map<str, pair<*tree<symbol>,*ast_node>>, ast_to_syn
return;
if (!ident_type->is_ref && ident_type->indirection == 0 && ident_type->is_object()) {
if (backing.expression && has_method(ident_type->type_def, "copy_construct", vec(get_ast_type(backing.expression)->clone_with_increased_indirection()))) {
var temp_cpy_ctst = ast_identifier_ptr("temp_declaration_copy_construct", get_ast_type(backing.expression)->clone_without_ref(), parent_chain->top())
var temp_cpy_ctst = _ident("temp_declaration_copy_construct", get_ast_type(backing.expression)->clone_without_ref(), parent_chain->top())
add_to_scope("temp_declaration_copy_construct", temp_cpy_ctst, parent_chain->top())
add_to_scope("~enclosing_scope", parent_chain->top(), temp_cpy_ctst)
var declaration = ast_declaration_statement_ptr(temp_cpy_ctst, backing.expression)
var declaration = _declaration(temp_cpy_ctst, backing.expression)
add_after_in(make_method_call(backing.identifier, "copy_construct", vec(make_operator_call("&", vec(temp_cpy_ctst)))),
node, parent_chain->top())
// do second so the order's right
@@ -264,7 +264,7 @@ fun obj_lower(name_ast_map: *map<str, pair<*tree<symbol>,*ast_node>>, ast_to_syn
backing.expression = null<ast_node>()
}
if (has_method(ident_type->type_def, "destruct", vec<*type>())) {
add_after_in(ast_defer_statement_ptr(make_method_call(backing.identifier, "destruct", vec<*ast_node>())),
add_after_in(_defer(make_method_call(backing.identifier, "destruct", vec<*ast_node>())),
node, parent_chain->top())
}
}
@@ -284,10 +284,10 @@ fun obj_lower(name_ast_map: *map<str, pair<*tree<symbol>,*ast_node>>, ast_to_syn
if (return_value) {
if (get_ast_type(enclosing_function)->return_type->is_ref)
return_value = make_operator_call("&", vec(return_value))
var temp_return = ast_identifier_ptr("temp_boom_return", get_ast_type(return_value)->clone_without_ref(), block)
var temp_return = _ident("temp_boom_return", get_ast_type(return_value)->clone_without_ref(), block)
add_to_scope("temp_boom_return", temp_return, block)
add_to_scope("~enclosing_scope", block, temp_return)
var declaration_statement = ast_declaration_statement_ptr(temp_return, null<ast_node>())
var declaration_statement = _declaration(temp_return, null<ast_node>())
var assign_statement = assign_or_copy_construct_statement(temp_return, return_value)
add_before_in(declaration_statement, node, block)
add_before_in(assign_statement, node, block)

24
stdlib/pass_common.krak
View File

@@ -174,12 +174,12 @@ fun make_method_call(object_ident: *ast_node, method: *ast_node, parameters: vec
var access_op = "."
if (get_ast_type(object_ident)->indirection)
access_op = "->"
var method_access = ast_function_call_ptr(get_builtin_function(str(access_op), vec(get_ast_type(object_ident), get_ast_type(method))), vec(object_ident, method))
return ast_function_call_ptr(method_access, parameters)
var method_access = _func_call(get_builtin_function(str(access_op), vec(get_ast_type(object_ident), get_ast_type(method))), vec(object_ident, method))
return _func_call(method_access, parameters)
}
fun make_operator_call(func: *char, params: vec<*ast_node>): *ast_node return make_operator_call(str(func), params);
fun make_operator_call(func: str, params: vec<*ast_node>): *ast_node {
return ast_function_call_ptr(get_builtin_function(func, params.map(fun(p:*ast_node): *type return get_ast_type(p);)), params)
return _func_call(get_builtin_function(func, params.map(fun(p:*ast_node): *type return get_ast_type(p);)), params)
}
fun get_builtin_function(name: *char, param_types: vec<*type>): *ast_node
return get_builtin_function(str(name), param_types, null<tree<symbol>>())
@@ -189,32 +189,32 @@ fun get_builtin_function(name: str, param_types: vec<*type>, syntax: *tree<symbo
// none of the builtin functions should take in references
param_types = param_types.map(fun(t: *type): *type return t->clone_without_ref();)
if (name == "==" || name == "!=" || name == ">" || name == "<" || name == "<=" || name == ">" || name == ">=" || name == "&&" || name == "||" || name == "!")
return ast_function_ptr(name, type_ptr(param_types, type_ptr(base_type::boolean()), 0, false, false, true), vec<*ast_node>(), false)
return _function(name, type_ptr(param_types, type_ptr(base_type::boolean()), 0, false, false, true), vec<*ast_node>(), false)
if (name == "." || name == "->") {
if (name == "->" && param_types[0]->indirection == 0)
error(syntax, str("drereferencing not a pointer: ") + name)
else if (name == "." && param_types[0]->indirection != 0)
error(syntax, str("dot operator on a pointer: ") + name)
else
return ast_function_ptr(name, type_ptr(param_types, param_types[1], 0, false, false, true), vec<*ast_node>(), false)
return _function(name, type_ptr(param_types, param_types[1], 0, false, false, true), vec<*ast_node>(), false)
}
if (name == "[]") {
if (param_types[0]->indirection == 0)
error(syntax, str("drereferencing not a pointer: ") + name)
else
return ast_function_ptr(name, type_ptr(param_types, param_types[0]->clone_with_decreased_indirection(), 0, false, false, true), vec<*ast_node>(), false)
return _function(name, type_ptr(param_types, param_types[0]->clone_with_decreased_indirection(), 0, false, false, true), vec<*ast_node>(), false)
}
if (name == "&" && param_types.size == 1)
return ast_function_ptr(name, type_ptr(param_types, param_types[0]->clone_with_increased_indirection(), 0, false, false, true), vec<*ast_node>(), false)
return _function(name, type_ptr(param_types, param_types[0]->clone_with_increased_indirection(), 0, false, false, true), vec<*ast_node>(), false)
if (name == "*" && param_types.size == 1) {
if (param_types[0]->indirection == 0)
error(syntax, str("drereferencing not a pointer: ") + name)
else
return ast_function_ptr(name, type_ptr(param_types, param_types[0]->clone_with_decreased_indirection(), 0, false, false, true), vec<*ast_node>(), false)
return _function(name, type_ptr(param_types, param_types[0]->clone_with_decreased_indirection(), 0, false, false, true), vec<*ast_node>(), false)
}
if (param_types.size > 1 && param_types[1]->rank() > param_types[0]->rank())
return ast_function_ptr(name, type_ptr(param_types, param_types[1], 0, false, false, true), vec<*ast_node>(), false)
return ast_function_ptr(name, type_ptr(param_types, param_types[0], 0, false, false, true), vec<*ast_node>(), false)
return _function(name, type_ptr(param_types, param_types[1], 0, false, false, true), vec<*ast_node>(), false)
return _function(name, type_ptr(param_types, param_types[0], 0, false, false, true), vec<*ast_node>(), false)
}
fun possible_object_equality(lvalue: *ast_node, rvalue: *ast_node): *ast_node {
var ltype = get_ast_type(lvalue)
@@ -223,7 +223,7 @@ fun possible_object_equality(lvalue: *ast_node, rvalue: *ast_node): *ast_node {
return make_method_call(lvalue, "operator==", vec(rvalue))
} else if (ltype->is_object())
// return false if object but no operator== (right now don't try for templated)
return ast_value_ptr(str("false"), type_ptr(base_type::boolean()))
return _value(str("false"), type_ptr(base_type::boolean()))
return make_operator_call("==", vec(lvalue, rvalue))
}
fun concat_symbol_tree(node: *tree<symbol>): str {
@@ -265,7 +265,7 @@ fun assign_or_copy_construct_statement(lvalue: *ast_node, rvalue: *ast_node): *a
var ltype = get_ast_type(lvalue)
if (ltype->indirection == 0 && (ltype->is_object() && has_method(ltype->type_def, "copy_construct", vec(ltype->clone_with_increased_indirection()))))
return make_method_call(lvalue, "copy_construct", vec(make_operator_call("&", vec(rvalue))))
return ast_assignment_statement_ptr(lvalue, rvalue)
return _assign(lvalue, rvalue)
}
fun get_children_pointer(node: *ast_node): *vec<*ast_node> {