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); } }