fix assigning to delegate fields and variables

2008-02-26  Juerg Billeter  <j@bitron.ch>

	* vala/valadatatype.vala, vala/valanulltype.vala,
	  vala/valasemanticanalyzer.vala,
	  gobject/valaccodegeneratorinvocationexpression.vala: fix
	  assigning to delegate fields and variables

svn path=/trunk/; revision=1058

diff --git a/ChangeLog b/ChangeLog
index ca6c73b..a5f81cc 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,12 @@
 2008-02-26  Jürg Billeter  <j@bitron.ch>
 
+       * vala/valadatatype.vala, vala/valanulltype.vala,
+         vala/valasemanticanalyzer.vala,
+         gobject/valaccodegeneratorinvocationexpression.vala: fix
+         assigning to delegate fields and variables
+
+2008-02-26  Jürg Billeter  <j@bitron.ch>
+
        * gobject/valaccodecompiler.vala, compiler/valacompiler.vala:
          remove non-portable -O commandline option, fixes bug 518660
 

diff --git a/gobject/valaccodegeneratorinvocationexpression.vala b/gobject/valaccodegeneratorinvocationexpression.vala
index ad7669f..e7fce2f 100644 (file)
--- a/gobject/valaccodegeneratorinvocationexpression.vala
+++ b/gobject/valaccodegeneratorinvocationexpression.vala
@@ -227,65 +227,61 @@ public class Vala.CCodeGenerator {
                                var param = params_it.get ();
                                ellipsis = param.ellipsis;
                                if (!ellipsis) {
-                                       if (param.type_reference.data_type is Delegate) {
-                                               cexpr = new CCodeCastExpression (cexpr, param.type_reference.data_type.get_cname ());
-                                       } else {
-                                               if (!param.no_array_length && param.type_reference is ArrayType) {
-                                                       var array_type = (ArrayType) param.type_reference;
-                                                       for (int dim = 1; dim <= array_type.rank; dim++) {
-                                                               carg_map.set (get_param_pos (param.carray_length_parameter_position + 0.01 * dim), get_array_length_cexpression (arg, dim));
-                                                       }
-                                               } else if (param.type_reference is DelegateType) {
-                                                       var deleg_type = (DelegateType) param.type_reference;
-                                                       var d = deleg_type.delegate_symbol;
-                                                       if (d.instance) {
-                                                               carg_map.set (get_param_pos (param.cdelegate_target_parameter_position), get_delegate_target_cexpression (arg));
-                                                       }
+                                       if (!param.no_array_length && param.type_reference is ArrayType) {
+                                               var array_type = (ArrayType) param.type_reference;
+                                               for (int dim = 1; dim <= array_type.rank; dim++) {
+                                                       carg_map.set (get_param_pos (param.carray_length_parameter_position + 0.01 * dim), get_array_length_cexpression (arg, dim));
                                                }
-                                               cexpr = get_implicit_cast_expression (cexpr, arg.static_type, param.type_reference);
-
-                                               // pass non-simple struct instances always by reference
-                                               if (!(arg.static_type is NullType) && param.type_reference.data_type is Struct && !((Struct) param.type_reference.data_type).is_simple_type ()) {
-                                                       // we already use a reference for arguments of ref and out parameters
-                                                       if (!param.type_reference.is_ref && !param.type_reference.is_out) {
-                                                               cexpr = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, cexpr);
-                                                       }
+                                       } else if (param.type_reference is DelegateType) {
+                                               var deleg_type = (DelegateType) param.type_reference;
+                                               var d = deleg_type.delegate_symbol;
+                                               if (d.instance) {
+                                                       carg_map.set (get_param_pos (param.cdelegate_target_parameter_position), get_delegate_target_cexpression (arg));
                                                }
+                                       }
+                                       cexpr = get_implicit_cast_expression (cexpr, arg.static_type, param.type_reference);
 
-                                               // unref old value for non-null non-weak out arguments
-                                               if (param.type_reference.is_out && param.type_reference.takes_ownership && !(arg.static_type is NullType)) {
-                                                       var unary = (UnaryExpression) arg;
-
-                                                       // (ret_tmp = call (&tmp), free (var1), var1 = tmp, ret_tmp)
-                                                       var ccomma = new CCodeCommaExpression ();
-
-                                                       var temp_decl = get_temp_variable_declarator (unary.inner.static_type);
-                                                       temp_vars.insert (0, temp_decl);
-                                                       cexpr = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (temp_decl.name));
-
-                                                       // call function
-                                                       VariableDeclarator ret_temp_decl;
-                                                       if (m.return_type is VoidType) {
-                                                               ccomma.append_expression (ccall_expr);
-                                                       } else {
-                                                               ret_temp_decl = get_temp_variable_declarator (m.return_type);
-                                                               temp_vars.insert (0, ret_temp_decl);
-                                                               ccomma.append_expression (new CCodeAssignment (new CCodeIdentifier (ret_temp_decl.name), ccall_expr));
-                                                       }
+                                       // pass non-simple struct instances always by reference
+                                       if (!(arg.static_type is NullType) && param.type_reference.data_type is Struct && !((Struct) param.type_reference.data_type).is_simple_type ()) {
+                                               // we already use a reference for arguments of ref and out parameters
+                                               if (!param.type_reference.is_ref && !param.type_reference.is_out) {
+                                                       cexpr = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, cexpr);
+                                               }
+                                       }
 
-                                                       // unref old value
-                                                       ccomma.append_expression (get_unref_expression ((CCodeExpression) unary.inner.ccodenode, arg.static_type, arg));
+                                       // unref old value for non-null non-weak out arguments
+                                       if (param.type_reference.is_out && param.type_reference.takes_ownership && !(arg.static_type is NullType)) {
+                                               var unary = (UnaryExpression) arg;
+
+                                               // (ret_tmp = call (&tmp), free (var1), var1 = tmp, ret_tmp)
+                                               var ccomma = new CCodeCommaExpression ();
+
+                                               var temp_decl = get_temp_variable_declarator (unary.inner.static_type);
+                                               temp_vars.insert (0, temp_decl);
+                                               cexpr = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (temp_decl.name));
+
+                                               // call function
+                                               VariableDeclarator ret_temp_decl;
+                                               if (m.return_type is VoidType) {
+                                                       ccomma.append_expression (ccall_expr);
+                                               } else {
+                                                       ret_temp_decl = get_temp_variable_declarator (m.return_type);
+                                                       temp_vars.insert (0, ret_temp_decl);
+                                                       ccomma.append_expression (new CCodeAssignment (new CCodeIdentifier (ret_temp_decl.name), ccall_expr));
+                                               }
 
-                                                       // assign new value
-                                                       ccomma.append_expression (new CCodeAssignment ((CCodeExpression) unary.inner.ccodenode, new CCodeIdentifier (temp_decl.name)));
+                                               // unref old value
+                                               ccomma.append_expression (get_unref_expression ((CCodeExpression) unary.inner.ccodenode, arg.static_type, arg));
 
-                                                       // return value
-                                                       if (!(m.return_type is VoidType)) {
-                                                               ccomma.append_expression (new CCodeIdentifier (ret_temp_decl.name));
-                                                       }
+                                               // assign new value
+                                               ccomma.append_expression (new CCodeAssignment ((CCodeExpression) unary.inner.ccodenode, new CCodeIdentifier (temp_decl.name)));
 
-                                                       ccall_expr = ccomma;
+                                               // return value
+                                               if (!(m.return_type is VoidType)) {
+                                                       ccomma.append_expression (new CCodeIdentifier (ret_temp_decl.name));
                                                }
+
+                                               ccall_expr = ccomma;
                                        }
                                }
                                arg_pos = get_param_pos (param.cparameter_position, ellipsis);

diff --git a/vala/valadatatype.vala b/vala/valadatatype.vala
index db3551b..bca5164 100644 (file)
--- a/vala/valadatatype.vala
+++ b/vala/valadatatype.vala
@@ -361,7 +361,7 @@ public class Vala.DataType : CodeNode {
                                (data_type != null && (
                                        data_type.is_reference_type () ||
                                        this is ArrayType ||
-                                       data_type is Delegate ||
+                                       this is DelegateType ||
                                        data_type.get_attribute ("PointerType") != null))) {
                                return true;
                        }

diff --git a/vala/valanulltype.vala b/vala/valanulltype.vala
index a2d2977..744a959 100644 (file)
--- a/vala/valanulltype.vala
+++ b/vala/valanulltype.vala
@@ -46,7 +46,7 @@ public class Vala.NullType : ReferenceType {
 
                if (target_type.data_type.is_reference_type () ||
                    target_type is ArrayType ||
-                   target_type.data_type is Delegate) {
+                   target_type is DelegateType) {
                        // incompatibility between null and non-null types
                        return !enable_non_null;
                }

diff --git a/vala/valasemanticanalyzer.vala b/vala/valasemanticanalyzer.vala
index 6f97204..8f9c931 100644 (file)
--- a/vala/valasemanticanalyzer.vala
+++ b/vala/valasemanticanalyzer.vala
@@ -746,9 +746,10 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
                                }
 
                                if (decl.initializer.symbol_reference is Method &&
-                                   decl.type_reference.data_type is Delegate) {
+                                   decl.type_reference is DelegateType) {
                                        var m = (Method) decl.initializer.symbol_reference;
-                                       var cb = (Delegate) decl.type_reference.data_type;
+                                       var dt = (DelegateType) decl.type_reference;
+                                       var cb = dt.delegate_symbol;
 
                                        /* check whether method matches callback type */
                                        if (!cb.matches_method (m)) {
@@ -2841,9 +2842,10 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
                                var decl = (VariableDeclarator) ma.symbol_reference;
 
                                if (a.right.symbol_reference is Method &&
-                                   decl.type_reference.data_type is Delegate) {
+                                   decl.type_reference is DelegateType) {
                                        var m = (Method) a.right.symbol_reference;
-                                       var cb = (Delegate) decl.type_reference.data_type;
+                                       var dt = (DelegateType) decl.type_reference;
+                                       var cb = dt.delegate_symbol;
 
                                        /* check whether method matches callback type */
                                        if (!cb.matches_method (m)) {
@@ -2862,9 +2864,10 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
                                var f = (Field) ma.symbol_reference;
 
                                if (a.right.symbol_reference is Method &&
-                                   f.type_reference.data_type is Delegate) {
+                                   f.type_reference is DelegateType) {
                                        var m = (Method) a.right.symbol_reference;
-                                       var cb = (Delegate) f.type_reference.data_type;
+                                       var dt = (DelegateType) f.type_reference;
+                                       var cb = dt.delegate_symbol;
 
                                        /* check whether method matches callback type */
                                        if (!cb.matches_method (m)) {