public override void visit_delegate(ValaDelegate cb)
{
current_scope = cb.scope;
cb.accept_children(this);
current_scope = current_scope.parent_scope;
}
/// <summary>
/// Returns generated delegate to be used for signal handlers.
///
/// <returns>delegate</returns>
/// </summary>
public ValaDelegate get_delegate(DataType sender_type, CodeNode node_reference)
{
var actual_return_type = return_type.get_actual_type(sender_type, null, node_reference);
var generated_delegate = new ValaDelegate(null, actual_return_type);
generated_delegate.access = SymbolAccessibility.PUBLIC;
generated_delegate.owner = scope;
// sender parameter is never null and doesn't own its value
var sender_param_type = sender_type.copy();
sender_param_type.value_owned = false;
sender_param_type.nullable = false;
generated_delegate.sender_type = sender_param_type;
bool is_generic = false;
foreach (Parameter param in parameters)
{
var actual_param = param.copy();
actual_param.variable_type = actual_param.variable_type.get_actual_type(sender_type, null, node_reference);
generated_delegate.add_parameter(actual_param);
if (actual_param.variable_type is GenericType)
{
is_generic = true;
}
}
if (is_generic)
{
var cl = (ObjectTypeSymbol)parent_symbol;
foreach (var type_param in cl.get_type_parameters())
{
generated_delegate.add_type_parameter(new TypeParameter(type_param.name, type_param.source_reference));
}
// parameter types must refer to the delegate type parameters
// instead of to the class type parameters
foreach (var param in generated_delegate.get_parameters())
{
if (param.variable_type is GenericType)
{
param.variable_type.type_parameter = generated_delegate.get_type_parameters()[generated_delegate.get_type_parameter_index(param.variable_type.type_parameter.name)];
}
}
}
scope.add(null, generated_delegate);
return(generated_delegate);
}
public override void visit_delegate(ValaDelegate d)
{
d.accept_children(this);
generate_delegate_declaration(d, cfile);
if (!d.is_internal_symbol())
{
generate_delegate_declaration(d, header_file);
}
if (!d.is_private_symbol())
{
generate_delegate_declaration(d, internal_header_file);
}
}
/// <summary>
/// Adds the specified delegate to this namespace.
///
/// <param name="d">a delegate</param>
/// </summary>
public override void add_delegate(ValaDelegate d)
{
// namespaces do not support private memebers
if (d.access == SymbolAccessibility.PRIVATE)
{
d.access = SymbolAccessibility.INTERNAL;
}
if (d.owner == null)
{
d.source_reference.file.add_node(d);
}
delegates.Add(d);
scope.add(d.name, d);
}
public DelegateType(ValaDelegate delegate_symbol)
{
this.delegate_symbol = delegate_symbol;
this.is_called_once = (delegate_symbol.get_attribute_string("CCode", "scope") == "async");
}
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 visit_delegate(ValaDelegate d)
{
d.accept_children(this);
}
public virtual void add_delegate(ValaDelegate d)
{
Report.error(d.source_reference, "unexpected declaration");
}
public override void visit_delegate(ValaDelegate cb)
{
check_unused_attr(cb);
cb.accept_children(this);
}
/// <summary>
/// Visit operation called for delegates.
///
/// <param name="d">a delegate</param>
/// </summary>
public virtual void visit_delegate(ValaDelegate d)
{
}
