public override void generate_cparameters(Method m, CCodeFile decl_space, Dictionary <int, CCodeParameter> cparam_map, CCodeFunction func, CCodeFunctionDeclarator vdeclarator = null, Dictionary <int, CCodeExpression> carg_map = null, CCodeFunctionCall vcall = null, int direction = 3)
{
if (m.coroutine)
{
decl_space.add_include("gio/gio.h");
if (direction == 1)
{
cparam_map[get_param_pos(-1)] = new CCodeParameter("_callback_", "GAsyncReadyCallback");
cparam_map[get_param_pos(-0.9)] = new CCodeParameter("_user_data_", "gpointer");
if (carg_map != null)
{
carg_map[get_param_pos(-1)] = new CCodeIdentifier("_callback_");
carg_map[get_param_pos(-0.9)] = new CCodeIdentifier("_user_data_");
}
}
else if (direction == 2)
{
cparam_map[get_param_pos(0.1)] = new CCodeParameter("_res_", "GAsyncResult*");
if (carg_map != null)
{
carg_map[get_param_pos(0.1)] = new CCodeIdentifier("_res_");
}
}
}
base.generate_cparameters(m, decl_space, cparam_map, func, vdeclarator, carg_map, vcall, direction);
}
public override void generate_error_domain_declaration(ErrorDomain edomain, CCodeFile decl_space)
{
if (add_symbol_declaration(decl_space, edomain, get_ccode_name(edomain)))
{
return;
}
var cenum = new CCodeEnum(get_ccode_name(edomain));
foreach (ErrorCode ecode in edomain.get_codes())
{
if (ecode.value == null)
{
cenum.add_value(new CCodeEnumValue(get_ccode_name(ecode)));
}
else
{
ecode.value.emit(this);
cenum.add_value(new CCodeEnumValue(get_ccode_name(ecode), get_cvalue(ecode.value)));
}
}
decl_space.add_type_definition(cenum);
string quark_fun_name = get_ccode_lower_case_prefix(edomain) + "quark";
var error_domain_define = new CCodeMacroReplacement(get_ccode_upper_case_name(edomain), quark_fun_name + " ()");
decl_space.add_type_definition(error_domain_define);
var cquark_fun = new CCodeFunction(quark_fun_name, get_ccode_name(gquark_type.data_type));
decl_space.add_function_declaration(cquark_fun);
}
public override bool generate_enum_declaration(ValaEnum en, CCodeFile decl_space)
{
if (base.generate_enum_declaration(en, decl_space))
{
if (is_string_marshalled_enum(en))
{
decl_space.add_function_declaration(generate_enum_from_string_function_declaration(en));
decl_space.add_function_declaration(generate_enum_to_string_function_declaration(en));
}
return(true);
}
return(false);
}
public override CCodeParameter generate_parameter(Parameter param, CCodeFile decl_space, Dictionary <int, CCodeParameter> cparam_map, Dictionary <int, CCodeExpression> carg_map)
{
if (!(param.variable_type is ArrayType))
{
return(base.generate_parameter(param, decl_space, cparam_map, carg_map));
}
string ctypename = get_ccode_name(param.variable_type);
if (param.direction != ParameterDirection.IN)
{
ctypename += "*";
}
var main_cparam = new CCodeParameter(get_variable_cname(param.name), ctypename);
var array_type = (ArrayType)param.variable_type;
generate_type_declaration(array_type.element_type, decl_space);
cparam_map[get_param_pos(get_ccode_pos(param))] = main_cparam;
if (carg_map != null)
{
carg_map[get_param_pos(get_ccode_pos(param))] = get_variable_cexpression(param.name);
}
if (get_ccode_array_length(param))
{
string length_ctype = "int";
if (get_ccode_array_length_type(param) != null)
{
length_ctype = get_ccode_array_length_type(param);
}
if (param.direction != ParameterDirection.IN)
{
length_ctype = "%s*".printf(length_ctype);
}
for (int dim = 1; dim <= array_type.rank; dim++)
{
var cparam = new CCodeParameter(get_parameter_array_length_cname(param, dim), length_ctype);
cparam_map[get_param_pos(get_ccode_array_length_pos(param) + 0.01 * dim)] = cparam;
if (carg_map != null)
{
carg_map[get_param_pos(get_ccode_array_length_pos(param) + 0.01 * dim)] = get_variable_cexpression(cparam.name);
}
}
}
return(main_cparam);
}
public override void generate_virtual_method_declaration(Method m, CCodeFile decl_space, CCodeStruct type_struct)
{
if (!m.coroutine)
{
base.generate_virtual_method_declaration(m, decl_space, type_struct);
return;
}
if (!m.is_abstract && !m.is_virtual)
{
return;
}
var creturn_type = m.return_type;
if (m.return_type.is_real_non_null_struct_type())
{
// structs are returned via out parameter
creturn_type = new VoidType();
}
// add vfunc field to the type struct
var vdeclarator = new CCodeFunctionDeclarator(get_ccode_vfunc_name(m));
var cparam_map = new Dictionary <int, CCodeParameter>();
generate_cparameters(m, decl_space, cparam_map, new CCodeFunction("fake"), vdeclarator, null, null, 1);
var vdecl = new CCodeDeclaration("void");
vdecl.add_declarator(vdeclarator);
type_struct.add_declaration(vdecl);
// add vfunc field to the type struct
vdeclarator = new CCodeFunctionDeclarator(get_ccode_finish_vfunc_name(m));
cparam_map = new Dictionary <int, CCodeParameter>();
generate_cparameters(m, decl_space, cparam_map, new CCodeFunction("fake"), vdeclarator, null, null, 2);
vdecl = new CCodeDeclaration(get_ccode_name(creturn_type));
vdecl.add_declarator(vdeclarator);
type_struct.add_declaration(vdecl);
}
public override void generate_struct_declaration(Struct st, CCodeFile decl_space)
{
if (add_symbol_declaration(decl_space, st, get_ccode_name(st)))
{
return;
}
if (st.is_boolean_type() || st.is_integer_type() || st.is_floating_type())
{
if (st.base_struct != null)
{
generate_struct_declaration(st.base_struct, decl_space);
decl_space.add_type_declaration(new CCodeTypeDefinition(get_ccode_name(st.base_struct), new CCodeVariableDeclarator(get_ccode_name(st))));
}
else
{
string typename = null;
if (st.is_boolean_type())
{
// typedef for boolean types
decl_space.add_include("stdbool.h");
typename = "bool";
}
else if (st.is_integer_type())
{
// typedef for integral types
decl_space.add_include("stdint.h");
typename = "%sint%d_t".printf(st.signed ? "" : "u", st.width);
}
else if (st.is_floating_type())
{
// typedef for floating types
typename = (st.width == 64 ? "double" : "float");
}
decl_space.add_type_declaration(new CCodeTypeDefinition(typename, new CCodeVariableDeclarator(get_ccode_name(st))));
}
return;
}
if (get_ccode_has_type_id(st))
{
decl_space.add_include("glib-object.h");
decl_space.add_type_declaration(new CCodeNewline());
var macro = "(%s_get_type ())".printf(get_ccode_lower_case_name(st, null));
decl_space.add_type_declaration(new CCodeMacroReplacement(get_ccode_type_id(st), macro));
var type_fun = new StructRegisterFunction(st, context);
type_fun.init_from_type(false, true);
decl_space.add_type_member_declaration(type_fun.get_declaration());
}
var instance_struct = new CCodeStruct("_%s".printf(get_ccode_name(st)));
instance_struct.modifiers |= (st.version.deprecated ? CCodeModifiers.DEPRECATED : 0);
foreach (Field f in st.get_fields())
{
if (f.binding == MemberBinding.INSTANCE)
{
generate_type_declaration(f.variable_type, decl_space);
CCodeModifiers modifiers = (f.is_volatile ? CCodeModifiers.VOLATILE : 0) | (f.version.deprecated ? CCodeModifiers.DEPRECATED : 0);
instance_struct.add_field(get_ccode_name(f.variable_type), get_ccode_name(f), modifiers, get_ccode_declarator_suffix(f.variable_type));
if (f.variable_type is ArrayType && get_ccode_array_length(f))
{
// create fields to store array dimensions
var array_type = (ArrayType)f.variable_type;
if (!array_type.fixed_length)
{
var len_type = int_type.copy();
for (int dim = 1; dim <= array_type.rank; dim++)
{
string length_cname;
if (get_ccode_array_length_name(f) != null)
{
length_cname = get_ccode_array_length_name(f);
}
else
{
length_cname = get_array_length_cname(get_ccode_name(f), dim);
}
instance_struct.add_field(get_ccode_name(len_type), length_cname);
}
if (array_type.rank == 1 && f.is_internal_symbol())
{
instance_struct.add_field(get_ccode_name(len_type), get_array_size_cname(get_ccode_name(f)));
}
}
}
else if (f.variable_type is DelegateType)
{
var delegate_type = (DelegateType)f.variable_type;
if (delegate_type.delegate_symbol.has_target)
{
// create field to store delegate target
instance_struct.add_field("gpointer", get_ccode_delegate_target_name(f));
if (delegate_type.is_disposable())
{
instance_struct.add_field("GDestroyNotify", get_delegate_target_destroy_notify_cname(get_ccode_name(f)));
}
}
}
}
}
if (st.base_struct == null)
{
decl_space.add_type_declaration(new CCodeTypeDefinition("struct _%s".printf(get_ccode_name(st)), new CCodeVariableDeclarator(get_ccode_name(st))));
decl_space.add_type_definition(instance_struct);
}
else
{
decl_space.add_type_declaration(new CCodeTypeDefinition(get_ccode_name(st.base_struct), new CCodeVariableDeclarator(get_ccode_name(st))));
}
var function = new CCodeFunction(get_ccode_dup_function(st), get_ccode_name(st) + "*");
if (st.is_private_symbol())
{
function.modifiers = CCodeModifiers.STATIC;
}
else if (context.hide_internal && st.is_internal_symbol())
{
function.modifiers = CCodeModifiers.INTERNAL;
}
function.add_parameter(new CCodeParameter("self", "const " + get_ccode_name(st) + "*"));
decl_space.add_function_declaration(function);
function = new CCodeFunction(get_ccode_free_function(st), "void");
if (st.is_private_symbol())
{
function.modifiers = CCodeModifiers.STATIC;
}
else if (context.hide_internal && st.is_internal_symbol())
{
function.modifiers = CCodeModifiers.INTERNAL;
}
function.add_parameter(new CCodeParameter("self", get_ccode_name(st) + "*"));
decl_space.add_function_declaration(function);
if (st.is_disposable())
{
function = new CCodeFunction(get_ccode_copy_function(st), "void");
if (st.is_private_symbol())
{
function.modifiers = CCodeModifiers.STATIC;
}
else if (context.hide_internal && st.is_internal_symbol())
{
function.modifiers = CCodeModifiers.INTERNAL;
}
function.add_parameter(new CCodeParameter("self", "const " + get_ccode_name(st) + "*"));
function.add_parameter(new CCodeParameter("dest", get_ccode_name(st) + "*"));
decl_space.add_function_declaration(function);
function = new CCodeFunction(get_ccode_destroy_function(st), "void");
if (st.is_private_symbol())
{
function.modifiers = CCodeModifiers.STATIC;
}
else if (context.hide_internal && st.is_internal_symbol())
{
function.modifiers = CCodeModifiers.INTERNAL;
}
function.add_parameter(new CCodeParameter("self", get_ccode_name(st) + "*"));
decl_space.add_function_declaration(function);
}
}
public override CCodeParameter generate_parameter(Parameter param, CCodeFile decl_space, Dictionary <int, CCodeParameter> cparam_map, Dictionary <int, CCodeExpression> carg_map)
{
if (!(param.variable_type is DelegateType || param.variable_type is MethodType))
{
return(base.generate_parameter(param, decl_space, cparam_map, carg_map));
}
string ctypename = get_ccode_name(param.variable_type);
string target_ctypename = "void*";
string target_destroy_notify_ctypename = "GDestroyNotify";
if (param.parent_symbol is ValaDelegate &&
get_ccode_name(param.variable_type) == get_ccode_name(param.parent_symbol))
{
// recursive delegate
ctypename = "GCallback";
}
if (param.direction != ParameterDirection.IN)
{
ctypename += "*";
target_ctypename += "*";
target_destroy_notify_ctypename += "*";
}
var main_cparam = new CCodeParameter(get_variable_cname(param.name), ctypename);
cparam_map[get_param_pos(get_ccode_pos(param))] = main_cparam;
if (carg_map != null)
{
carg_map[get_param_pos(get_ccode_pos(param))] = get_variable_cexpression(param.name);
}
if (param.variable_type is DelegateType)
{
var deleg_type = (DelegateType)param.variable_type;
var d = deleg_type.delegate_symbol;
generate_delegate_declaration(d, decl_space);
if (d.has_target)
{
var cparam = new CCodeParameter(get_ccode_delegate_target_name(param), target_ctypename);
cparam_map[get_param_pos(get_ccode_delegate_target_pos(param))] = cparam;
if (carg_map != null)
{
carg_map[get_param_pos(get_ccode_delegate_target_pos(param))] = get_variable_cexpression(cparam.name);
}
if (deleg_type.is_disposable())
{
cparam = new CCodeParameter(get_delegate_target_destroy_notify_cname(get_variable_cname(param.name)), target_destroy_notify_ctypename);
cparam_map[get_param_pos(get_ccode_delegate_target_pos(param) + 0.01)] = cparam;
if (carg_map != null)
{
carg_map[get_param_pos(get_ccode_delegate_target_pos(param) + 0.01)] = get_variable_cexpression(cparam.name);
}
}
}
}
else if (param.variable_type is MethodType)
{
var cparam = new CCodeParameter(get_ccode_delegate_target_name(param), target_ctypename);
cparam_map[get_param_pos(get_ccode_delegate_target_pos(param))] = cparam;
if (carg_map != null)
{
carg_map[get_param_pos(get_ccode_delegate_target_pos(param))] = get_variable_cexpression(cparam.name);
}
}
return(main_cparam);
}
public override void generate_delegate_declaration(ValaDelegate d, CCodeFile decl_space)
{
if (add_symbol_declaration(decl_space, d, get_ccode_name(d)))
{
return;
}
string return_type_cname = get_ccode_name(d.return_type);
if (d.return_type.is_real_non_null_struct_type())
{
// structs are returned via out parameter
return_type_cname = "void";
}
if (return_type_cname == get_ccode_name(d))
{
// recursive delegate
return_type_cname = "GCallback";
}
else
{
generate_type_declaration(d.return_type, decl_space);
}
var cfundecl = new CCodeFunctionDeclarator(get_ccode_name(d));
foreach (Parameter param in d.get_parameters())
{
var cparam = generate_parameter(param, decl_space, new Dictionary <int, CCodeParameter>(), null);
cfundecl.add_parameter(cparam);
// handle array parameters
if (get_ccode_array_length(param) && param.variable_type is ArrayType)
{
var array_type = (ArrayType)param.variable_type;
var length_ctype = "int";
if (param.direction != ParameterDirection.IN)
{
length_ctype = "int*";
}
for (int dim = 1; dim <= array_type.rank; dim++)
{
cparam = new CCodeParameter(get_parameter_array_length_cname(param, dim), length_ctype);
cfundecl.add_parameter(cparam);
}
}
// handle delegate parameters
if (param.variable_type is DelegateType)
{
var deleg_type = (DelegateType)param.variable_type;
var param_d = deleg_type.delegate_symbol;
if (param_d.has_target)
{
cparam = new CCodeParameter(get_delegate_target_cname(get_variable_cname(param.name)), "void*");
cfundecl.add_parameter(cparam);
if (deleg_type.is_disposable())
{
cparam = new CCodeParameter(get_delegate_target_destroy_notify_cname(get_variable_cname(param.name)), "GDestroyNotify*");
cfundecl.add_parameter(cparam);
}
}
}
}
if (get_ccode_array_length(d) && d.return_type is ArrayType)
{
// return array length if appropriate
var array_type = (ArrayType)d.return_type;
var array_length_type = get_ccode_array_length_type(d) != null?get_ccode_array_length_type(d) : "int";
array_length_type += "*";
for (int dim = 1; dim <= array_type.rank; dim++)
{
var cparam = new CCodeParameter(get_array_length_cname("result", dim), array_length_type);
cfundecl.add_parameter(cparam);
}
}
else if (d.return_type is DelegateType)
{
// return delegate target if appropriate
var deleg_type = (DelegateType)d.return_type;
var result_d = deleg_type.delegate_symbol;
if (result_d.has_target)
{
var cparam = new CCodeParameter(get_delegate_target_cname("result"), "void**");
cfundecl.add_parameter(cparam);
if (deleg_type.is_disposable())
{
cparam = new CCodeParameter(get_delegate_target_destroy_notify_cname("result"), "GDestroyNotify*");
cfundecl.add_parameter(cparam);
}
}
}
else if (d.return_type.is_real_non_null_struct_type())
{
var cparam = new CCodeParameter("result", "%s*".printf(get_ccode_name(d.return_type)));
cfundecl.add_parameter(cparam);
}
if (d.has_target)
{
var cparam = new CCodeParameter("user_data", "void*");
cfundecl.add_parameter(cparam);
}
if (d.get_error_types().Count > 0)
{
var cparam = new CCodeParameter("error", "GError**");
cfundecl.add_parameter(cparam);
}
var ctypedef = new CCodeTypeDefinition(return_type_cname, cfundecl);
ctypedef.modifiers |= (d.version.deprecated ? CCodeModifiers.DEPRECATED : 0);
decl_space.add_type_definition(ctypedef);
}
public override void generate_method_declaration(Method m, CCodeFile decl_space)
{
if (m.coroutine)
{
if (add_symbol_declaration(decl_space, m, get_ccode_name(m)))
{
return;
}
var cl = m.parent_symbol as Class;
var asyncfunc = new CCodeFunction(get_ccode_name(m), "void");
var cparam_map = new Dictionary <int, CCodeParameter>();
var carg_map = new Dictionary <int, CCodeExpression>();
if (m.is_private_symbol())
{
asyncfunc.modifiers |= CCodeModifiers.STATIC;
}
else if (context.hide_internal && m.is_internal_symbol())
{
asyncfunc.modifiers |= CCodeModifiers.INTERNAL;
}
// do not generate _new functions for creation methods of abstract classes
if (!(m is CreationMethod && cl != null && cl.is_abstract))
{
generate_cparameters(m, decl_space, cparam_map, asyncfunc, null, carg_map, new CCodeFunctionCall(new CCodeIdentifier("fake")), 1);
decl_space.add_function_declaration(asyncfunc);
}
var finishfunc = new CCodeFunction(get_ccode_finish_name(m));
cparam_map = new Dictionary <int, CCodeParameter>();
carg_map = new Dictionary <int, CCodeExpression>();
if (m.is_private_symbol())
{
finishfunc.modifiers |= CCodeModifiers.STATIC;
}
else if (context.hide_internal && m.is_internal_symbol())
{
finishfunc.modifiers |= CCodeModifiers.INTERNAL;
}
// do not generate _new functions for creation methods of abstract classes
if (!(m is CreationMethod && cl != null && cl.is_abstract))
{
generate_cparameters(m, decl_space, cparam_map, finishfunc, null, carg_map, new CCodeFunctionCall(new CCodeIdentifier("fake")), 2);
decl_space.add_function_declaration(finishfunc);
}
if (m is CreationMethod && cl != null)
{
// _construct function
var function = new CCodeFunction(get_ccode_real_name(m));
if (m.is_private_symbol())
{
function.modifiers |= CCodeModifiers.STATIC;
}
else if (context.hide_internal && m.is_internal_symbol())
{
function.modifiers |= CCodeModifiers.INTERNAL;
}
cparam_map = new Dictionary <int, CCodeParameter>();
generate_cparameters(m, decl_space, cparam_map, function, null, null, null, 1);
decl_space.add_function_declaration(function);
function = new CCodeFunction(get_ccode_finish_real_name(m));
if (m.is_private_symbol())
{
function.modifiers |= CCodeModifiers.STATIC;
}
else if (context.hide_internal && m.is_internal_symbol())
{
function.modifiers |= CCodeModifiers.INTERNAL;
}
cparam_map = new Dictionary <int, CCodeParameter>();
generate_cparameters(m, decl_space, cparam_map, function, null, null, null, 2);
decl_space.add_function_declaration(function);
}
}
else
{
base.generate_method_declaration(m, decl_space);
}
}
