More closure fixes

2008-12-20  Jürg Billeter  <j@bitron.ch>

	* gobject/valaccodeassignmentmodule.vala:
	* gobject/valaccodebasemodule.vala:
	* gobject/valaccodecontrolflowmodule.vala:
	* gobject/valaccodemethodcallmodule.vala:
	* gobject/valagasyncmodule.vala:
	* gobject/valagerrormodule.vala:

	More closure fixes

svn path=/trunk/; revision=2232

diff --git a/ChangeLog b/ChangeLog
index 8857483ed1f6a7ef6f81f899079c3bd71619df14..07618f5fab9f6078b6cae089484eaa2ffdbec70e 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,14 @@
+2008-12-20  Jürg Billeter  <j@bitron.ch>
+
+       * gobject/valaccodeassignmentmodule.vala:
+       * gobject/valaccodebasemodule.vala:
+       * gobject/valaccodecontrolflowmodule.vala:
+       * gobject/valaccodemethodcallmodule.vala:
+       * gobject/valagasyncmodule.vala:
+       * gobject/valagerrormodule.vala:
+
+       More closure fixes
+
 2008-12-19  Jürg Billeter  <j@bitron.ch>
 
        * vapi/atk.vapi:

diff --git a/gobject/valaccodeassignmentmodule.vala b/gobject/valaccodeassignmentmodule.vala
index 2e6d947ba6d972a97813e69b8c2c0575f3f5908e..e33cf7cbc7eca14aa583a2c2e62f1214aacef144 100644 (file)
--- a/gobject/valaccodeassignmentmodule.vala
+++ b/gobject/valaccodeassignmentmodule.vala
@@ -155,7 +155,7 @@ public class Vala.CCodeAssignmentModule : CCodeMemberAccessModule {
                        
                        var temp_decl = get_temp_variable (assignment.left.value_type);
                        temp_vars.insert (0, temp_decl);
-                       ccomma.append_expression (new CCodeAssignment (new CCodeIdentifier (temp_decl.name), rhs));
+                       ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (temp_decl.name), rhs));
                        if (unref_old) {
                                /* unref old value */
                                ccomma.append_expression (get_unref_expression ((CCodeExpression) get_ccodenode (assignment.left), assignment.left.value_type, assignment.left));
@@ -174,7 +174,7 @@ public class Vala.CCodeAssignmentModule : CCodeMemberAccessModule {
                                ccomma.append_expression (new CCodeAssignment (lhs_delegate_target, rhs_delegate_target));
                        }
                        
-                       ccomma.append_expression (new CCodeIdentifier (temp_decl.name));
+                       ccomma.append_expression (get_variable_cexpression (temp_decl.name));
                        
                        rhs = ccomma;
                }
@@ -213,10 +213,10 @@ public class Vala.CCodeAssignmentModule : CCodeMemberAccessModule {
                                temp_vars.insert (0, index_temp_decl);
                                
                                var ccomma = new CCodeCommaExpression ();
-                               ccomma.append_expression (new CCodeAssignment (new CCodeIdentifier (index_temp_decl.name), cea.index));
+                               ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (index_temp_decl.name), cea.index));
                                ccomma.append_expression (codenode);
 
-                               cea.index = new CCodeIdentifier (index_temp_decl.name);
+                               cea.index = get_variable_cexpression (index_temp_decl.name);
                                
                                codenode = ccomma;
                        }

diff --git a/gobject/valaccodebasemodule.vala b/gobject/valaccodebasemodule.vala
index 195f477ad485f9bbbbda7cf0a2d8a95dae100de8..f11f722fbd266d2f42a35a195b423ced392342b7 100644 (file)
--- a/gobject/valaccodebasemodule.vala
+++ b/gobject/valaccodebasemodule.vala
@@ -1440,7 +1440,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
 
                                var temp_var = get_temp_variable (local.variable_type, true, local);
                                temp_vars.insert (0, temp_var);
-                               ccomma.append_expression (new CCodeAssignment (new CCodeIdentifier (temp_var.name), rhs));
+                               ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (temp_var.name), rhs));
 
                                for (int dim = 1; dim <= array_type.rank; dim++) {
                                        var lhs_array_len = get_variable_cexpression (head.get_array_length_cname (get_variable_cname (local.name), dim));
@@ -1459,7 +1459,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
 
                                        var temp_var = get_temp_variable (local.variable_type, true, local);
                                        temp_vars.insert (0, temp_var);
-                                       ccomma.append_expression (new CCodeAssignment (new CCodeIdentifier (temp_var.name), rhs));
+                                       ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (temp_var.name), rhs));
 
                                        var lhs_delegate_target = get_variable_cexpression (get_delegate_target_cname (get_variable_cname (local.name)));
                                        var rhs_delegate_target = get_delegate_target_cexpression (local.initializer);
@@ -2112,14 +2112,14 @@ public class Vala.CCodeBaseModule : CCodeModule {
                var return_expr_decl = get_temp_variable (expr_type, true, expr);
                
                var ccomma = new CCodeCommaExpression ();
-               ccomma.append_expression (new CCodeAssignment (new CCodeIdentifier (return_expr_decl.name), (CCodeExpression) expr.ccodenode));
+               ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (return_expr_decl.name), (CCodeExpression) expr.ccodenode));
 
                if (!append_local_free_expr (current_symbol, ccomma, false)) {
                        /* no local variables need to be freed */
                        return;
                }
 
-               ccomma.append_expression (new CCodeIdentifier (return_expr_decl.name));
+               ccomma.append_expression (get_variable_cexpression (return_expr_decl.name));
                
                expr.ccodenode = ccomma;
                expr.temp_vars.add (return_expr_decl);
@@ -2165,7 +2165,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
                                var return_expr_decl = get_temp_variable (stmt.return_expression.value_type, true, stmt);
 
                                var ccomma = new CCodeCommaExpression ();
-                               ccomma.append_expression (new CCodeAssignment (new CCodeIdentifier (return_expr_decl.name), (CCodeExpression) stmt.return_expression.ccodenode));
+                               ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (return_expr_decl.name), (CCodeExpression) stmt.return_expression.ccodenode));
 
                                var array_type = (ArrayType) current_return_type;
 
@@ -2175,7 +2175,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
                                        ccomma.append_expression (new CCodeAssignment (len_l, len_r));
                                }
 
-                               ccomma.append_expression (new CCodeIdentifier (return_expr_decl.name));
+                               ccomma.append_expression (get_variable_cexpression (return_expr_decl.name));
                                
                                stmt.return_expression.ccodenode = ccomma;
                                stmt.return_expression.temp_vars.add (return_expr_decl);
@@ -2334,11 +2334,11 @@ public class Vala.CCodeBaseModule : CCodeModule {
                        // assign current value to temp variable
                        var temp_decl = get_temp_variable (prop.property_type, true, expr);
                        temp_vars.insert (0, temp_decl);
-                       ccomma.append_expression (new CCodeAssignment (new CCodeIdentifier (temp_decl.name), (CCodeExpression) expr.inner.ccodenode));
+                       ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (temp_decl.name), (CCodeExpression) expr.inner.ccodenode));
                        
                        // increment/decrement property
                        var op = expr.increment ? CCodeBinaryOperator.PLUS : CCodeBinaryOperator.MINUS;
-                       var cexpr = new CCodeBinaryExpression (op, new CCodeIdentifier (temp_decl.name), new CCodeConstant ("1"));
+                       var cexpr = new CCodeBinaryExpression (op, get_variable_cexpression (temp_decl.name), new CCodeConstant ("1"));
                        var ccall = get_property_set_call (prop, ma, cexpr);
                        ccomma.append_expression (ccall);
                        
@@ -2422,7 +2422,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
                        var decl = get_temp_variable (expression_type, false, node);
                        temp_vars.insert (0, decl);
 
-                       var ctemp = new CCodeIdentifier (decl.name);
+                       var ctemp = get_variable_cexpression (decl.name);
                        
                        var vt = (ValueType) expression_type;
                        var st = (Struct) vt.type_symbol;
@@ -2484,7 +2484,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
                        var decl = get_temp_variable (expression_type, false, node);
                        temp_vars.insert (0, decl);
 
-                       var ctemp = new CCodeIdentifier (decl.name);
+                       var ctemp = get_variable_cexpression (decl.name);
                        
                        var cisnull = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, ctemp, new CCodeConstant ("NULL"));
                        if (expression_type.type_parameter != null) {
@@ -2905,7 +2905,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
 
                                        var temp_var = get_temp_variable (arg.value_type);
                                        temp_vars.insert (0, temp_var);
-                                       ccomma.append_expression (new CCodeAssignment (new CCodeIdentifier (temp_var.name), cexpr));
+                                       ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (temp_var.name), cexpr));
                                        ccomma.append_expression (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (temp_var.name)));
 
                                        return ccomma;
@@ -2963,7 +2963,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
 
                                temp_vars.add (temp_decl);
 
-                               var ctemp = new CCodeIdentifier (temp_decl.name);
+                               var ctemp = get_variable_cexpression (temp_decl.name);
                                var cinit = new CCodeAssignment (ctemp, (CCodeExpression) expr.inner.ccodenode);
                                var ccheck = create_type_check (ctemp, expr.type_reference);
                                var ccast = new CCodeCastExpression (ctemp, expr.type_reference.get_cname ());
@@ -3001,7 +3001,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
                var ccomma = new CCodeCommaExpression ();
                var temp_decl = get_temp_variable (expr.value_type, true, expr);
                temp_vars.insert (0, temp_decl);
-               var cvar = new CCodeIdentifier (temp_decl.name);
+               var cvar = get_variable_cexpression (temp_decl.name);
 
                ccomma.append_expression (new CCodeAssignment (cvar, (CCodeExpression) expr.inner.ccodenode));
                ccomma.append_expression (new CCodeAssignment ((CCodeExpression) expr.inner.ccodenode, new CCodeConstant ("NULL")));
@@ -3444,7 +3444,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
 
                var ccomma = new CCodeCommaExpression ();
                var temp_decl = get_temp_variable (e.value_type);
-               var ctemp = new CCodeIdentifier (temp_decl.name);
+               var ctemp = get_variable_cexpression (temp_decl.name);
                temp_vars.add (temp_decl);
                ccomma.append_expression (new CCodeAssignment (ctemp, ce));
                ccomma.append_expression (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, ctemp));

diff --git a/gobject/valaccodecontrolflowmodule.vala b/gobject/valaccodecontrolflowmodule.vala
index c88d9bbe2ea8f5bf3a41a292a7e4951873bbf479..679b1e6291824ed4f2e29593ec05445d77ca1f07 100644 (file)
--- a/gobject/valaccodecontrolflowmodule.vala
+++ b/gobject/valaccodecontrolflowmodule.vala
@@ -281,11 +281,17 @@ public class Vala.CCodeControlFlowModule : CCodeMethodModule {
                
                var collection_backup = stmt.collection_variable;
                var collection_type = collection_backup.variable_type.copy ();
-               var ccoldecl = new CCodeDeclaration (collection_type.get_cname ());
-               var ccolvardecl = new CCodeVariableDeclarator.with_initializer (collection_backup.name, (CCodeExpression) stmt.collection.ccodenode);
-               ccolvardecl.line = cblock.line;
-               ccoldecl.add_declarator (ccolvardecl);
-               cblock.add_statement (ccoldecl);
+
+               if (current_method != null && current_method.coroutine) {
+                       closure_struct.add_field (collection_type.get_cname (), collection_backup.name);
+                       cblock.add_statement (new CCodeExpressionStatement (new CCodeAssignment (get_variable_cexpression (collection_backup.name), (CCodeExpression) stmt.collection.ccodenode)));
+               } else {
+                       var ccoldecl = new CCodeDeclaration (collection_type.get_cname ());
+                       var ccolvardecl = new CCodeVariableDeclarator.with_initializer (collection_backup.name, (CCodeExpression) stmt.collection.ccodenode);
+                       ccolvardecl.line = cblock.line;
+                       ccoldecl.add_declarator (ccolvardecl);
+                       cblock.add_statement (ccoldecl);
+               }
                
                if (stmt.tree_can_fail && stmt.collection.tree_can_fail) {
                        // exception handling
@@ -300,22 +306,31 @@ public class Vala.CCodeControlFlowModule : CCodeMethodModule {
                        var array_len = head.get_array_length_cexpression (stmt.collection);
 
                        // store array length for use by _vala_array_free
-                       var clendecl = new CCodeDeclaration ("int");
-                       clendecl.add_declarator (new CCodeVariableDeclarator.with_initializer (head.get_array_length_cname (collection_backup.name, 1), array_len));
-                       cblock.add_statement (clendecl);
+                       if (current_method != null && current_method.coroutine) {
+                               closure_struct.add_field ("int", head.get_array_length_cname (collection_backup.name, 1));
+                               cblock.add_statement (new CCodeExpressionStatement (new CCodeAssignment (get_variable_cexpression (head.get_array_length_cname (collection_backup.name, 1)), array_len)));
+                       } else {
+                               var clendecl = new CCodeDeclaration ("int");
+                               clendecl.add_declarator (new CCodeVariableDeclarator.with_initializer (head.get_array_length_cname (collection_backup.name, 1), array_len));
+                               cblock.add_statement (clendecl);
+                       }
 
                        if (array_len is CCodeConstant) {
                                // the array has no length parameter i.e. it is NULL-terminated array
 
                                var it_name = "%s_it".printf (stmt.variable_name);
                        
-                               var citdecl = new CCodeDeclaration (collection_type.get_cname ());
-                               citdecl.add_declarator (new CCodeVariableDeclarator (it_name));
-                               cblock.add_statement (citdecl);
+                               if (current_method != null && current_method.coroutine) {
+                                       closure_struct.add_field (collection_type.get_cname (), it_name);
+                               } else {
+                                       var citdecl = new CCodeDeclaration (collection_type.get_cname ());
+                                       citdecl.add_declarator (new CCodeVariableDeclarator (it_name));
+                                       cblock.add_statement (citdecl);
+                               }
                                
                                var cbody = new CCodeBlock ();
 
-                               CCodeExpression element_expr = new CCodeIdentifier ("*%s".printf (it_name));
+                               CCodeExpression element_expr = get_variable_cexpression ("*%s".printf (it_name));
 
                                var element_type = array_type.element_type.copy ();
                                element_type.value_owned = false;
@@ -326,17 +341,27 @@ public class Vala.CCodeControlFlowModule : CCodeMethodModule {
                                cbody.add_statement (cfrag);
                                temp_vars.clear ();
 
-                               var cdecl = new CCodeDeclaration (stmt.type_reference.get_cname ());
-                               cdecl.add_declarator (new CCodeVariableDeclarator.with_initializer (stmt.variable_name, element_expr));
-                               cbody.add_statement (cdecl);
+                               if (current_method != null && current_method.coroutine) {
+                                       closure_struct.add_field (stmt.type_reference.get_cname (), stmt.variable_name);
+                                       cbody.add_statement (new CCodeExpressionStatement (new CCodeAssignment (get_variable_cexpression (stmt.variable_name), element_expr)));
+                               } else {
+                                       var cdecl = new CCodeDeclaration (stmt.type_reference.get_cname ());
+                                       cdecl.add_declarator (new CCodeVariableDeclarator.with_initializer (stmt.variable_name, element_expr));
+                                       cbody.add_statement (cdecl);
+                               }
 
                                // add array length variable for stacked arrays
                                if (stmt.type_reference is ArrayType) {
                                        var inner_array_type = (ArrayType) stmt.type_reference;
                                        for (int dim = 1; dim <= inner_array_type.rank; dim++) {
-                                               cdecl = new CCodeDeclaration ("int");
-                                               cdecl.add_declarator (new CCodeVariableDeclarator.with_initializer (head.get_array_length_cname (stmt.variable_name, dim), new CCodeConstant ("-1")));
-                                               cbody.add_statement (cdecl);
+                                               if (current_method != null && current_method.coroutine) {
+                                                       closure_struct.add_field ("int", head.get_array_length_cname (stmt.variable_name, dim));
+                                                       cbody.add_statement (new CCodeExpressionStatement (new CCodeAssignment (get_variable_cexpression (head.get_array_length_cname (stmt.variable_name, dim)), new CCodeConstant ("-1"))));
+                                               } else {
+                                                       var cdecl = new CCodeDeclaration ("int");
+                                                       cdecl.add_declarator (new CCodeVariableDeclarator.with_initializer (head.get_array_length_cname (stmt.variable_name, dim), new CCodeConstant ("-1")));
+                                                       cbody.add_statement (cdecl);
+                                               }
                                        }
                                }
 
@@ -355,13 +380,17 @@ public class Vala.CCodeControlFlowModule : CCodeMethodModule {
 
                                var it_name = (stmt.variable_name + "_it");
                        
-                               var citdecl = new CCodeDeclaration ("int");
-                               citdecl.add_declarator (new CCodeVariableDeclarator (it_name));
-                               cblock.add_statement (citdecl);
+                               if (current_method != null && current_method.coroutine) {
+                                       closure_struct.add_field ("int", it_name);
+                               } else {
+                                       var citdecl = new CCodeDeclaration ("int");
+                                       citdecl.add_declarator (new CCodeVariableDeclarator (it_name));
+                                       cblock.add_statement (citdecl);
+                               }
                                
                                var cbody = new CCodeBlock ();
 
-                               CCodeExpression element_expr = new CCodeElementAccess (new CCodeIdentifier (collection_backup.name), new CCodeIdentifier (it_name));
+                               CCodeExpression element_expr = new CCodeElementAccess (get_variable_cexpression (collection_backup.name), get_variable_cexpression (it_name));
 
                                var element_type = array_type.element_type.copy ();
                                element_type.value_owned = false;
@@ -372,31 +401,41 @@ public class Vala.CCodeControlFlowModule : CCodeMethodModule {
                                cbody.add_statement (cfrag);
                                temp_vars.clear ();
 
-                               var cdecl = new CCodeDeclaration (stmt.type_reference.get_cname ());
-                               cdecl.add_declarator (new CCodeVariableDeclarator.with_initializer (stmt.variable_name, element_expr));
-                               cbody.add_statement (cdecl);
+                               if (current_method != null && current_method.coroutine) {
+                                       closure_struct.add_field (stmt.type_reference.get_cname (), stmt.variable_name);
+                                       cbody.add_statement (new CCodeExpressionStatement (new CCodeAssignment (get_variable_cexpression (stmt.variable_name), element_expr)));
+                               } else {
+                                       var cdecl = new CCodeDeclaration (stmt.type_reference.get_cname ());
+                                       cdecl.add_declarator (new CCodeVariableDeclarator.with_initializer (stmt.variable_name, element_expr));
+                                       cbody.add_statement (cdecl);
+                               }
 
                                // add array length variable for stacked arrays
                                if (stmt.type_reference is ArrayType) {
                                        var inner_array_type = (ArrayType) stmt.type_reference;
                                        for (int dim = 1; dim <= inner_array_type.rank; dim++) {
-                                               cdecl = new CCodeDeclaration ("int");
-                                               cdecl.add_declarator (new CCodeVariableDeclarator.with_initializer (head.get_array_length_cname (stmt.variable_name, dim), new CCodeConstant ("-1")));
-                                               cbody.add_statement (cdecl);
+                                               if (current_method != null && current_method.coroutine) {
+                                                       closure_struct.add_field ("int", head.get_array_length_cname (stmt.variable_name, dim));
+                                                       cbody.add_statement (new CCodeExpressionStatement (new CCodeAssignment (get_variable_cexpression (head.get_array_length_cname (stmt.variable_name, dim)), new CCodeConstant ("-1"))));
+                                               } else {
+                                                       var cdecl = new CCodeDeclaration ("int");
+                                                       cdecl.add_declarator (new CCodeVariableDeclarator.with_initializer (head.get_array_length_cname (stmt.variable_name, dim), new CCodeConstant ("-1")));
+                                                       cbody.add_statement (cdecl);
+                                               }
                                        }
                                }
 
                                cbody.add_statement (stmt.body.ccodenode);
                                
                                var ccond_ind1 = new CCodeBinaryExpression (CCodeBinaryOperator.INEQUALITY, array_len, new CCodeConstant ("-1"));
-                               var ccond_ind2 = new CCodeBinaryExpression (CCodeBinaryOperator.LESS_THAN, new CCodeIdentifier (it_name), array_len);
+                               var ccond_ind2 = new CCodeBinaryExpression (CCodeBinaryOperator.LESS_THAN, get_variable_cexpression (it_name), array_len);
                                var ccond_ind = new CCodeBinaryExpression (CCodeBinaryOperator.AND, ccond_ind1, ccond_ind2);
                                
                                /* only check for null if the containers elements are of reference-type */
                                CCodeBinaryExpression ccond;
                                if (array_type.element_type.is_reference_type_or_type_parameter ()) {
                                        var ccond_term1 = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, array_len, new CCodeConstant ("-1"));
-                                       var ccond_term2 = new CCodeBinaryExpression (CCodeBinaryOperator.INEQUALITY, new CCodeElementAccess (new CCodeIdentifier (collection_backup.name), new CCodeIdentifier (it_name)), new CCodeConstant ("NULL"));
+                                       var ccond_term2 = new CCodeBinaryExpression (CCodeBinaryOperator.INEQUALITY, new CCodeElementAccess (new CCodeIdentifier (collection_backup.name), get_variable_cexpression (it_name)), new CCodeConstant ("NULL"));
                                        var ccond_term = new CCodeBinaryExpression (CCodeBinaryOperator.AND, ccond_term1, ccond_term2);
 
                                        ccond = new CCodeBinaryExpression (CCodeBinaryOperator.OR, ccond_ind, ccond_term);
@@ -410,8 +449,8 @@ public class Vala.CCodeControlFlowModule : CCodeMethodModule {
                                }
                                
                                var cfor = new CCodeForStatement (ccond, cbody);
-                               cfor.add_initializer (new CCodeAssignment (new CCodeIdentifier (it_name), new CCodeConstant ("0")));
-                               cfor.add_iterator (new CCodeAssignment (new CCodeIdentifier (it_name), new CCodeBinaryExpression (CCodeBinaryOperator.PLUS, new CCodeIdentifier (it_name), new CCodeConstant ("1"))));
+                               cfor.add_initializer (new CCodeAssignment (get_variable_cexpression (it_name), new CCodeConstant ("0")));
+                               cfor.add_iterator (new CCodeAssignment (get_variable_cexpression (it_name), new CCodeBinaryExpression (CCodeBinaryOperator.PLUS, get_variable_cexpression (it_name), new CCodeConstant ("1"))));
                                cblock.add_statement (cfor);
                        }
                } else if (stmt.collection.value_type.compatible (new ObjectType (glist_type)) || stmt.collection.value_type.compatible (new ObjectType (gslist_type))) {
@@ -419,15 +458,19 @@ public class Vala.CCodeControlFlowModule : CCodeMethodModule {
 
                        var it_name = "%s_it".printf (stmt.variable_name);
                
-                       var citdecl = new CCodeDeclaration (collection_type.get_cname ());
-                       var citvardecl = new CCodeVariableDeclarator (it_name);
-                       citvardecl.line = cblock.line;
-                       citdecl.add_declarator (citvardecl);
-                       cblock.add_statement (citdecl);
+                       if (current_method != null && current_method.coroutine) {
+                               closure_struct.add_field (collection_type.get_cname (), it_name);
+                       } else {
+                               var citdecl = new CCodeDeclaration (collection_type.get_cname ());
+                               var citvardecl = new CCodeVariableDeclarator (it_name);
+                               citvardecl.line = cblock.line;
+                               citdecl.add_declarator (citvardecl);
+                               cblock.add_statement (citdecl);
+                       }
                        
                        var cbody = new CCodeBlock ();
 
-                       CCodeExpression element_expr = new CCodeMemberAccess.pointer (new CCodeIdentifier (it_name), "data");
+                       CCodeExpression element_expr = new CCodeMemberAccess.pointer (get_variable_cexpression (it_name), "data");
 
                        if (collection_type.get_type_arguments ().size != 1) {
                                Report.error (stmt.source_reference, "internal error: missing generic type argument");
@@ -445,21 +488,26 @@ public class Vala.CCodeControlFlowModule : CCodeMethodModule {
                        cbody.add_statement (cfrag);
                        temp_vars.clear ();
 
-                       var cdecl = new CCodeDeclaration (stmt.type_reference.get_cname ());
-                       var cvardecl = new CCodeVariableDeclarator.with_initializer (stmt.variable_name, element_expr);
-                       cvardecl.line = cblock.line;
-                       cdecl.add_declarator (cvardecl);
-                       cbody.add_statement (cdecl);
+                       if (current_method != null && current_method.coroutine) {
+                               closure_struct.add_field (stmt.type_reference.get_cname (), stmt.variable_name);
+                               cbody.add_statement (new CCodeExpressionStatement (new CCodeAssignment (get_variable_cexpression (stmt.variable_name), element_expr)));
+                       } else {
+                               var cdecl = new CCodeDeclaration (stmt.type_reference.get_cname ());
+                               var cvardecl = new CCodeVariableDeclarator.with_initializer (stmt.variable_name, element_expr);
+                               cvardecl.line = cblock.line;
+                               cdecl.add_declarator (cvardecl);
+                               cbody.add_statement (cdecl);
+                       }
                        
                        cbody.add_statement (stmt.body.ccodenode);
                        
-                       var ccond = new CCodeBinaryExpression (CCodeBinaryOperator.INEQUALITY, new CCodeIdentifier (it_name), new CCodeConstant ("NULL"));
+                       var ccond = new CCodeBinaryExpression (CCodeBinaryOperator.INEQUALITY, get_variable_cexpression (it_name), new CCodeConstant ("NULL"));
                        
                        var cfor = new CCodeForStatement (ccond, cbody);
                        
-                       cfor.add_initializer (new CCodeAssignment (new CCodeIdentifier (it_name), new CCodeIdentifier (collection_backup.name)));
+                       cfor.add_initializer (new CCodeAssignment (get_variable_cexpression (it_name), get_variable_cexpression (collection_backup.name)));
 
-                       cfor.add_iterator (new CCodeAssignment (new CCodeIdentifier (it_name), new CCodeMemberAccess.pointer (new CCodeIdentifier (it_name), "next")));
+                       cfor.add_iterator (new CCodeAssignment (get_variable_cexpression (it_name), new CCodeMemberAccess.pointer (get_variable_cexpression (it_name), "next")));
                        cblock.add_statement (cfor);
                }
 
@@ -467,7 +515,7 @@ public class Vala.CCodeControlFlowModule : CCodeMethodModule {
                        if (requires_destroy (local.variable_type)) {
                                var ma = new MemberAccess.simple (local.name);
                                ma.symbol_reference = local;
-                               var cunref = new CCodeExpressionStatement (get_unref_expression (new CCodeIdentifier (get_variable_cname (local.name)), local.variable_type, ma));
+                               var cunref = new CCodeExpressionStatement (get_unref_expression (get_variable_cexpression (local.name), local.variable_type, ma));
                                cunref.line = cblock.line;
                                cblock.add_statement (cunref);
                        }

diff --git a/gobject/valaccodemethodcallmodule.vala b/gobject/valaccodemethodcallmodule.vala
index 0bd176e6596afed458059f1d63eebd0e74adb5df..4bb7a989205462b8b81a252af782f4bf2426d49b 100644 (file)
--- a/gobject/valaccodemethodcallmodule.vala
+++ b/gobject/valaccodemethodcallmodule.vala
@@ -106,6 +106,11 @@ public class Vala.CCodeMethodCallModule : CCodeAssignmentModule {
                if (m != null && m.binding == MemberBinding.INSTANCE && !(m is CreationMethod)) {
                        instance = (CCodeExpression) ma.inner.ccodenode;
 
+                       if (ma.member_name == "begin" && ma.inner.symbol_reference == ma.symbol_reference) {
+                               var inner_ma = (MemberAccess) ma.inner;
+                               instance = (CCodeExpression) inner_ma.inner.ccodenode;
+                       }
+
                        var st = m.parent_symbol as Struct;
                        if (st != null && !st.is_simple_type ()) {
                                // we need to pass struct instance by reference
@@ -445,20 +450,26 @@ public class Vala.CCodeMethodCallModule : CCodeAssignmentModule {
                }
 
                // append C arguments in the right order
-               int last_pos = -1;
+               
+               int last_pos;
                int min_pos;
-               while (true) {
-                       min_pos = -1;
-                       foreach (int pos in out_arg_map.get_keys ()) {
-                               if (pos > last_pos && (min_pos == -1 || pos < min_pos)) {
-                                       min_pos = pos;
+
+               if (async_call != ccall) {
+                       // don't append out arguments for .begin() calls
+                       last_pos = -1;
+                       while (true) {
+                               min_pos = -1;
+                               foreach (int pos in out_arg_map.get_keys ()) {
+                                       if (pos > last_pos && (min_pos == -1 || pos < min_pos)) {
+                                               min_pos = pos;
+                                       }
                                }
+                               if (min_pos == -1) {
+                                       break;
+                               }
+                               ccall.add_argument (out_arg_map.get (min_pos));
+                               last_pos = min_pos;
                        }
-                       if (min_pos == -1) {
-                               break;
-                       }
-                       ccall.add_argument (out_arg_map.get (min_pos));
-                       last_pos = min_pos;
                }
 
                if (async_call != null) {

diff --git a/gobject/valagasyncmodule.vala b/gobject/valagasyncmodule.vala
index ab1ba3ca41a4d788d13deca80ed79f2e474ce2b6..9504d61582677612601d75fc88b1989031776d9d 100644 (file)
--- a/gobject/valagasyncmodule.vala
+++ b/gobject/valagasyncmodule.vala
@@ -48,6 +48,11 @@ public class Vala.GAsyncModule : GSignalModule {
                closure_struct.add_field ("gpointer", "user_data");
                closure_struct.add_field ("GAsyncResult*", "res");
 
+               if (m.binding == MemberBinding.INSTANCE) {
+                       var type_sym = (TypeSymbol) m.parent_symbol;
+                       closure_struct.add_field (type_sym.get_cname () + "*", "self");
+               }
+
                foreach (FormalParameter param in m.get_parameters ()) {
                        closure_struct.add_field (param.parameter_type.get_cname (), param.name);
                }
@@ -80,6 +85,10 @@ public class Vala.GAsyncModule : GSignalModule {
                asyncblock.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeMemberAccess.pointer (new CCodeIdentifier ("data"), "callback"), new CCodeIdentifier ("callback"))));
                asyncblock.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeMemberAccess.pointer (new CCodeIdentifier ("data"), "user_data"), new CCodeIdentifier ("user_data"))));
 
+               if (m.binding == MemberBinding.INSTANCE) {
+                       asyncblock.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeMemberAccess.pointer (new CCodeIdentifier ("data"), "self"), new CCodeIdentifier ("self"))));
+               }
+
                foreach (FormalParameter param in m.get_parameters ()) {
                        if (param.direction != ParameterDirection.OUT) {
                                asyncblock.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeMemberAccess.pointer (new CCodeIdentifier ("data"), param.name), new CCodeIdentifier (param.name))));

diff --git a/gobject/valagerrormodule.vala b/gobject/valagerrormodule.vala
index 68b148af1da1e7d3a9947f08ecda2e61deb4a205..c69b2da558ae2d80062b6405009baf8d62861e88 100644 (file)
--- a/gobject/valagerrormodule.vala
+++ b/gobject/valagerrormodule.vala
@@ -235,9 +235,14 @@ public class Vala.GErrorModule : CCodeDelegateModule {
                        variable_name = "__err";
                }
 
-               var cdecl = new CCodeDeclaration ("GError *");
-               cdecl.add_declarator (new CCodeVariableDeclarator.with_initializer (variable_name, get_variable_cexpression ("inner_error")));
-               cblock.add_statement (cdecl);
+               if (current_method != null && current_method.coroutine) {
+                       closure_struct.add_field ("GError *", variable_name);
+                       cblock.add_statement (new CCodeExpressionStatement (new CCodeAssignment (get_variable_cexpression (variable_name), get_variable_cexpression ("inner_error"))));
+               } else {
+                       var cdecl = new CCodeDeclaration ("GError *");
+                       cdecl.add_declarator (new CCodeVariableDeclarator.with_initializer (variable_name, get_variable_cexpression ("inner_error")));
+                       cblock.add_statement (cdecl);
+               }
                cblock.add_statement (new CCodeExpressionStatement (new CCodeAssignment (get_variable_cexpression ("inner_error"), new CCodeConstant ("NULL"))));
 
                cblock.add_statement (clause.body.ccodenode);