LLVMValueRef gen_tuple(compile_t* c, ast_t* ast)
{
ast_t* child = ast_child(ast);
if(ast_sibling(child) == NULL)
return gen_expr(c, child);
deferred_reification_t* reify = c->frame->reify;
ast_t* type = deferred_reify(reify, ast_type(ast), c->opt);
// If we contain '_', we have no usable value.
if(contains_dontcare(type))
{
ast_free_unattached(type);
return GEN_NOTNEEDED;
}
reach_type_t* t = reach_type(c->reach, type);
compile_type_t* c_t = (compile_type_t*)t->c_type;
int count = LLVMCountStructElementTypes(c_t->primitive);
size_t buf_size = count * sizeof(LLVMTypeRef);
LLVMTypeRef* elements = (LLVMTypeRef*)ponyint_pool_alloc_size(buf_size);
LLVMGetStructElementTypes(c_t->primitive, elements);
LLVMValueRef tuple = LLVMGetUndef(c_t->primitive);
int i = 0;
while(child != NULL)
{
LLVMValueRef value = gen_expr(c, child);
if(value == NULL)
{
ponyint_pool_free_size(buf_size, elements);
return NULL;
}
// We'll have an undefined element if one of our source elements is a
// variable declaration. This is ok, since the tuple value will never be
// used.
if(value == GEN_NOVALUE || value == GEN_NOTNEEDED)
{
ponyint_pool_free_size(buf_size, elements);
return value;
}
ast_t* child_type = deferred_reify(reify, ast_type(child), c->opt);
value = gen_assign_cast(c, elements[i], value, child_type);
ast_free_unattached(child_type);
tuple = LLVMBuildInsertValue(c->builder, tuple, value, i++, "");
child = ast_sibling(child);
}
ponyint_pool_free_size(buf_size, elements);
return tuple;
}
LLVMValueRef gen_tuple(compile_t* c, ast_t* ast)
{
ast_t* child = ast_child(ast);
if(ast_sibling(child) == NULL)
return gen_expr(c, child);
ast_t* type = ast_type(ast);
gentype_t g;
if(!gentype(c, type, &g))
return NULL;
// If we contain TK_DONTCARE, we have no usable value.
if(g.primitive == NULL)
return GEN_NOVALUE;
LLVMValueRef tuple = LLVMGetUndef(g.primitive);
int i = 0;
while(child != NULL)
{
LLVMValueRef value = gen_expr(c, child);
if(value == NULL)
return NULL;
// We'll have an undefined element if one of our source elements is a
// variable declaration. This is ok, since the tuple value will never be
// used.
if(value != GEN_NOVALUE)
tuple = LLVMBuildInsertValue(c->builder, tuple, value, i++, "");
child = ast_sibling(child);
}
return tuple;
}
static LLVMValueRef assign_to_tuple(compile_t* c, LLVMTypeRef l_type,
LLVMValueRef r_value, ast_t* type)
{
// Cast each component.
assert(ast_id(type) == TK_TUPLETYPE);
int count = LLVMCountStructElementTypes(l_type);
size_t buf_size = count * sizeof(LLVMTypeRef);
LLVMTypeRef* elements = (LLVMTypeRef*)pool_alloc_size(buf_size);
LLVMGetStructElementTypes(l_type, elements);
LLVMValueRef result = LLVMGetUndef(l_type);
ast_t* type_child = ast_child(type);
int i = 0;
while(type_child != NULL)
{
LLVMValueRef r_child = LLVMBuildExtractValue(c->builder, r_value, i, "");
LLVMValueRef cast_value = gen_assign_cast(c, elements[i], r_child,
type_child);
if(cast_value == NULL)
{
pool_free_size(buf_size, elements);
return NULL;
}
result = LLVMBuildInsertValue(c->builder, result, cast_value, i, "");
type_child = ast_sibling(type_child);
i++;
}
pool_free_size(buf_size, elements);
return result;
}