Redirect more variable access to closure struct

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

	* gobject/valaccodebasemodule.vala:
	* gobject/valaccodemethodcallmodule.vala:
	* gobject/valaccodemethodmodule.vala:
	* gobject/valagerrormodule.vala:

	Redirect more variable access to closure struct

svn path=/trunk/; revision=2228

diff --git a/ChangeLog b/ChangeLog
index 1790c27dc14f8e4dbcbc1618233791585f86b292..ac26fba43411de46c3358ca36a470bba8326a45c 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,12 @@
+2008-12-19  Jürg Billeter  <j@bitron.ch>
+
+       * gobject/valaccodebasemodule.vala:
+       * gobject/valaccodemethodcallmodule.vala:
+       * gobject/valaccodemethodmodule.vala:
+       * gobject/valagerrormodule.vala:
+
+       Redirect more variable access to closure struct
+
 2008-12-19  Jürg Billeter  <j@bitron.ch>
 
        * gobject/valadbusclientmodule.vala:

diff --git a/gobject/valaccodebasemodule.vala b/gobject/valaccodebasemodule.vala
index 02abeda89edb4e27395969ee1282b73f0b237a7a..1d1249bc75c395edd4142b1189880fa649deffc1 100644 (file)
--- a/gobject/valaccodebasemodule.vala
+++ b/gobject/valaccodebasemodule.vala
@@ -1443,12 +1443,12 @@ public class Vala.CCodeBaseModule : CCodeModule {
                                ccomma.append_expression (new CCodeAssignment (new CCodeIdentifier (temp_var.name), rhs));
 
                                for (int dim = 1; dim <= array_type.rank; dim++) {
-                                       var lhs_array_len = new CCodeIdentifier (head.get_array_length_cname (get_variable_cname (local.name), dim));
+                                       var lhs_array_len = get_variable_cexpression (head.get_array_length_cname (get_variable_cname (local.name), dim));
                                        var rhs_array_len = head.get_array_length_cexpression (local.initializer, dim);
                                        ccomma.append_expression (new CCodeAssignment (lhs_array_len, rhs_array_len));
                                }
                                
-                               ccomma.append_expression (new CCodeIdentifier (temp_var.name));
+                               ccomma.append_expression (get_variable_cexpression (temp_var.name));
                                
                                rhs = ccomma;
                        } else if (local.variable_type is DelegateType) {
@@ -1461,11 +1461,11 @@ public class Vala.CCodeBaseModule : CCodeModule {
                                        temp_vars.insert (0, temp_var);
                                        ccomma.append_expression (new CCodeAssignment (new CCodeIdentifier (temp_var.name), rhs));
 
-                                       var lhs_delegate_target = new CCodeIdentifier (get_delegate_target_cname (get_variable_cname (local.name)));
+                                       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);
                                        ccomma.append_expression (new CCodeAssignment (lhs_delegate_target, rhs_delegate_target));
                                
-                                       ccomma.append_expression (new CCodeIdentifier (temp_var.name));
+                                       ccomma.append_expression (get_variable_cexpression (temp_var.name));
                                
                                        rhs = ccomma;
                                }
@@ -1480,7 +1480,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
                                var ccomma = new CCodeCommaExpression ();
 
                                for (int dim = 1; dim <= array_type.rank; dim++) {
-                                       ccomma.append_expression (new CCodeAssignment (new CCodeIdentifier (head.get_array_length_cname (get_variable_cname (local.name), dim)), new CCodeConstant ("0")));
+                                       ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (head.get_array_length_cname (get_variable_cname (local.name), dim)), new CCodeConstant ("0")));
                                }
 
                                ccomma.append_expression (rhs);
@@ -1903,15 +1903,15 @@ public class Vala.CCodeBaseModule : CCodeModule {
                expr.temp_vars.add (full_expr_var);
                
                var expr_list = new CCodeCommaExpression ();
-               expr_list.append_expression (new CCodeAssignment (new CCodeIdentifier (full_expr_var.name), (CCodeExpression) expr.ccodenode));
+               expr_list.append_expression (new CCodeAssignment (get_variable_cexpression (full_expr_var.name), (CCodeExpression) expr.ccodenode));
                
                foreach (LocalVariable local in temp_ref_vars) {
                        var ma = new MemberAccess.simple (local.name);
                        ma.symbol_reference = local;
-                       expr_list.append_expression (get_unref_expression (new CCodeIdentifier (local.name), local.variable_type, ma));
+                       expr_list.append_expression (get_unref_expression (get_variable_cexpression (local.name), local.variable_type, ma));
                }
                
-               expr_list.append_expression (new CCodeIdentifier (full_expr_var.name));
+               expr_list.append_expression (get_variable_cexpression (full_expr_var.name));
                
                expr.ccodenode = expr_list;
                
@@ -1920,27 +1920,33 @@ public class Vala.CCodeBaseModule : CCodeModule {
        
        public void append_temp_decl (CCodeFragment cfrag, Gee.List<LocalVariable> temp_vars) {
                foreach (LocalVariable local in temp_vars) {
-                       var cdecl = new CCodeDeclaration (local.variable_type.get_cname ());
-               
-                       var vardecl = new CCodeVariableDeclarator (local.name);
-                       // sets #line
-                       local.ccodenode = vardecl;
-                       cdecl.add_declarator (vardecl);
-
-                       var st = local.variable_type.data_type as Struct;
+                       if (current_method != null && current_method.coroutine) {
+                               closure_struct.add_field (local.variable_type.get_cname (), local.name);
 
-                       if (local.variable_type.is_reference_type_or_type_parameter ()) {
-                               vardecl.initializer = new CCodeConstant ("NULL");
-                       } else if (st != null && !st.is_simple_type ()) {
-                               // 0-initialize struct with struct initializer { 0 }
-                               // necessary as they will be passed by reference
-                               var clist = new CCodeInitializerList ();
-                               clist.append (new CCodeConstant ("0"));
-
-                               vardecl.initializer = clist;
-                       }
+                               // no initialization necessary, closure struct is zeroed
+                       } else {
+                               var cdecl = new CCodeDeclaration (local.variable_type.get_cname ());
+               
+                               var vardecl = new CCodeVariableDeclarator (local.name);
+                               // sets #line
+                               local.ccodenode = vardecl;
+                               cdecl.add_declarator (vardecl);
+
+                               var st = local.variable_type.data_type as Struct;
+
+                               if (local.variable_type.is_reference_type_or_type_parameter ()) {
+                                       vardecl.initializer = new CCodeConstant ("NULL");
+                               } else if (st != null && !st.is_simple_type ()) {
+                                       // 0-initialize struct with struct initializer { 0 }
+                                       // necessary as they will be passed by reference
+                                       var clist = new CCodeInitializerList ();
+                                       clist.append (new CCodeConstant ("0"));
+
+                                       vardecl.initializer = clist;
+                               }
                        
-                       cfrag.append (cdecl);
+                               cfrag.append (cdecl);
+                       }
                }
        }
 
@@ -2639,7 +2645,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
                        var temp_decl = get_temp_variable (expr.type_reference, false, expr);
                        temp_vars.add (temp_decl);
 
-                       instance = new CCodeIdentifier (get_variable_cname (temp_decl.name));
+                       instance = get_variable_cexpression (get_variable_cname (temp_decl.name));
                }
 
                if (expr.symbol_reference == null) {
@@ -3251,7 +3257,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
                                var decl = get_temp_variable (expression_type, true, expression_type);
                                temp_vars.insert (0, decl);
                                temp_ref_vars.insert (0, decl);
-                               cexpr = new CCodeAssignment (new CCodeIdentifier (get_variable_cname (decl.name)), cexpr);
+                               cexpr = new CCodeAssignment (get_variable_cexpression (decl.name), cexpr);
 
                                if (expression_type is ArrayType && expr != null) {
                                        var array_type = (ArrayType) expression_type;
@@ -3260,9 +3266,9 @@ public class Vala.CCodeBaseModule : CCodeModule {
                                        for (int dim = 1; dim <= array_type.rank; dim++) {
                                                var len_decl = new LocalVariable (int_type.copy (), head.get_array_length_cname (decl.name, dim));
                                                temp_vars.insert (0, len_decl);
-                                               ccomma.append_expression (new CCodeAssignment (new CCodeIdentifier (get_variable_cname (len_decl.name)), head.get_array_length_cexpression (expr, dim)));
+                                               ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (len_decl.name), head.get_array_length_cexpression (expr, dim)));
                                        }
-                                       ccomma.append_expression (new CCodeIdentifier (get_variable_cname (decl.name)));
+                                       ccomma.append_expression (get_variable_cexpression (decl.name));
                                        cexpr = ccomma;
                                }
                        }
@@ -3287,8 +3293,8 @@ public class Vala.CCodeBaseModule : CCodeModule {
                                temp_vars.insert (0, decl);
 
                                var ccomma = new CCodeCommaExpression ();
-                               ccomma.append_expression (new CCodeAssignment (new CCodeIdentifier (get_variable_cname (decl.name)), cexpr));
-                               ccomma.append_expression (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (get_variable_cname (decl.name))));
+                               ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (decl.name), cexpr));
+                               ccomma.append_expression (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_variable_cexpression (decl.name)));
                                cexpr = ccomma;
                        }
                } else if (unboxing) {

diff --git a/gobject/valaccodemethodcallmodule.vala b/gobject/valaccodemethodcallmodule.vala
index 0954ca04f58e2ca6ba18f2b1110333aa10ada83d..0bd176e6596afed458059f1d63eebd0e74adb5df 100644 (file)
--- a/gobject/valaccodemethodcallmodule.vala
+++ b/gobject/valaccodemethodcallmodule.vala
@@ -122,8 +122,8 @@ public class Vala.CCodeMethodCallModule : CCodeAssignmentModule {
 
                                        var temp_var = get_temp_variable (ma.inner.target_type);
                                        temp_vars.insert (0, temp_var);
-                                       ccomma.append_expression (new CCodeAssignment (new CCodeIdentifier (temp_var.name), instance));
-                                       ccomma.append_expression (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (temp_var.name)));
+                                       ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (temp_var.name), instance));
+                                       ccomma.append_expression (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_variable_cexpression (temp_var.name)));
 
                                        instance = ccomma;
                                }
@@ -264,7 +264,7 @@ public class Vala.CCodeMethodCallModule : CCodeAssignmentModule {
 
                                                var temp_decl = get_temp_variable (arg.value_type);
                                                temp_vars.insert (0, temp_decl);
-                                               ccomma.append_expression (new CCodeAssignment (new CCodeIdentifier (temp_decl.name), cexpr));
+                                               ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (temp_decl.name), cexpr));
 
                                                cexpr = new CCodeIdentifier (temp_decl.name);
 
@@ -285,11 +285,11 @@ public class Vala.CCodeMethodCallModule : CCodeAssignmentModule {
 
                                                var temp_var = get_temp_variable (param.parameter_type, param.parameter_type.value_owned);
                                                temp_vars.insert (0, temp_var);
-                                               cexpr = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (temp_var.name));
+                                               cexpr = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_variable_cexpression (temp_var.name));
 
                                                if (param.direction == ParameterDirection.REF) {
                                                        var crefcomma = new CCodeCommaExpression ();
-                                                       crefcomma.append_expression (new CCodeAssignment (new CCodeIdentifier (temp_var.name), (CCodeExpression) unary.inner.ccodenode));
+                                                       crefcomma.append_expression (new CCodeAssignment (get_variable_cexpression (temp_var.name), (CCodeExpression) unary.inner.ccodenode));
                                                        crefcomma.append_expression (cexpr);
                                                        cexpr = crefcomma;
                                                }
@@ -301,7 +301,7 @@ public class Vala.CCodeMethodCallModule : CCodeAssignmentModule {
                                                } else {
                                                        ret_temp_var = get_temp_variable (itype.get_return_type ());
                                                        temp_vars.insert (0, ret_temp_var);
-                                                       ccomma.append_expression (new CCodeAssignment (new CCodeIdentifier (ret_temp_var.name), ccall_expr));
+                                                       ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (ret_temp_var.name), ccall_expr));
                                                }
 
                                                var cassign_comma = new CCodeCommaExpression ();
@@ -309,19 +309,19 @@ public class Vala.CCodeMethodCallModule : CCodeAssignmentModule {
                                                var assign_temp_var = get_temp_variable (unary.inner.value_type, unary.inner.value_type.value_owned);
                                                temp_vars.insert (0, assign_temp_var);
 
-                                               cassign_comma.append_expression (new CCodeAssignment (new CCodeIdentifier (assign_temp_var.name), transform_expression (new CCodeIdentifier (temp_var.name), param.parameter_type, unary.inner.value_type, arg)));
+                                               cassign_comma.append_expression (new CCodeAssignment (get_variable_cexpression (assign_temp_var.name), transform_expression (get_variable_cexpression (temp_var.name), param.parameter_type, unary.inner.value_type, arg)));
 
                                                // unref old value
                                                cassign_comma.append_expression (get_unref_expression ((CCodeExpression) unary.inner.ccodenode, arg.value_type, arg));
 
-                                               cassign_comma.append_expression (new CCodeIdentifier (assign_temp_var.name));
+                                               cassign_comma.append_expression (get_variable_cexpression (assign_temp_var.name));
 
                                                // assign new value
                                                ccomma.append_expression (new CCodeAssignment ((CCodeExpression) unary.inner.ccodenode, cassign_comma));
 
                                                // return value
                                                if (!(itype.get_return_type () is VoidType)) {
-                                                       ccomma.append_expression (new CCodeIdentifier (ret_temp_var.name));
+                                                       ccomma.append_expression (get_variable_cexpression (ret_temp_var.name));
                                                }
 
                                                ccall_expr = ccomma;
@@ -358,7 +358,7 @@ public class Vala.CCodeMethodCallModule : CCodeAssignmentModule {
                        for (int dim = 1; dim <= array_type.rank; dim++) {
                                if (!m.no_array_length) {
                                        var temp_var = get_temp_variable (int_type);
-                                       var temp_ref = new CCodeIdentifier (temp_var.name);
+                                       var temp_ref = get_variable_cexpression (temp_var.name);
 
                                        temp_vars.insert (0, temp_var);
 
@@ -374,7 +374,7 @@ public class Vala.CCodeMethodCallModule : CCodeAssignmentModule {
                        var d = deleg_type.delegate_symbol;
                        if (d.has_target) {
                                var temp_var = get_temp_variable (new PointerType (new VoidType ()));
-                               var temp_ref = new CCodeIdentifier (temp_var.name);
+                               var temp_ref = get_variable_cexpression (temp_var.name);
 
                                temp_vars.insert (0, temp_var);
 
@@ -404,7 +404,7 @@ public class Vala.CCodeMethodCallModule : CCodeAssignmentModule {
                        // method can fail
                        current_method_inner_error = true;
                        // add &inner_error before the ellipsis arguments
-                       out_arg_map.set (get_param_pos (-1), new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("inner_error")));
+                       out_arg_map.set (get_param_pos (-1), new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_variable_cexpression ("inner_error")));
                }
 
                if (ellipsis) {
@@ -430,7 +430,7 @@ public class Vala.CCodeMethodCallModule : CCodeAssignmentModule {
                                // normal return value for base access
                        } else if (!sig.has_emitter) {
                                var temp_var = get_temp_variable (itype.get_return_type ());
-                               var temp_ref = new CCodeIdentifier (temp_var.name);
+                               var temp_ref = get_variable_cexpression (temp_var.name);
 
                                temp_vars.insert (0, temp_var);
 
@@ -505,7 +505,7 @@ public class Vala.CCodeMethodCallModule : CCodeAssignmentModule {
                        var new_size = (CCodeExpression) arg_it.get ().ccodenode;
 
                        var temp_decl = get_temp_variable (int_type);
-                       var temp_ref = new CCodeIdentifier (temp_decl.name);
+                       var temp_ref = get_variable_cexpression (temp_decl.name);
 
                        temp_vars.insert (0, temp_decl);
 

diff --git a/gobject/valaccodemethodmodule.vala b/gobject/valaccodemethodmodule.vala
index 5b5c048e7a514d95e6000d72e38989a59f50bdbe..fc7b082c5f94116310a744577d4708d04f202c1e 100644 (file)
--- a/gobject/valaccodemethodmodule.vala
+++ b/gobject/valaccodemethodmodule.vala
@@ -302,9 +302,15 @@ public class Vala.CCodeMethodModule : CCodeStructModule {
                                        /* always separate error parameter and inner_error local variable
                                         * as error may be set to NULL but we're always interested in inner errors
                                         */
-                                       var cdecl = new CCodeDeclaration ("GError *");
-                                       cdecl.add_declarator (new CCodeVariableDeclarator.with_initializer ("inner_error", new CCodeConstant ("NULL")));
-                                       cinit.append (cdecl);
+                                       if (m.coroutine) {
+                                               closure_struct.add_field ("GError *", "inner_error");
+
+                                               // no initialization necessary, closure struct is zeroed
+                                       } else {
+                                               var cdecl = new CCodeDeclaration ("GError *");
+                                               cdecl.add_declarator (new CCodeVariableDeclarator.with_initializer ("inner_error", new CCodeConstant ("NULL")));
+                                               cinit.append (cdecl);
+                                       }
                                }
 
                                if (!m.coroutine) {

diff --git a/gobject/valagerrormodule.vala b/gobject/valagerrormodule.vala
index f9ad002ef4c1f9e5ebb553fce4b256c3f8defb13..68b148af1da1e7d3a9947f08ecda2e61deb4a205 100644 (file)
--- a/gobject/valagerrormodule.vala
+++ b/gobject/valagerrormodule.vala
@@ -76,7 +76,7 @@ public class Vala.GErrorModule : CCodeDelegateModule {
 
                // method will fail
                current_method_inner_error = true;
-               var cassign = new CCodeAssignment (new CCodeIdentifier ("inner_error"), (CCodeExpression) stmt.error_expression.ccodenode);
+               var cassign = new CCodeAssignment (get_variable_cexpression ("inner_error"), (CCodeExpression) stmt.error_expression.ccodenode);
                cfrag.append (new CCodeExpressionStatement (cassign));
 
                head.add_simple_check (stmt, cfrag);
@@ -94,10 +94,10 @@ public class Vala.GErrorModule : CCodeDelegateModule {
                ccritical.add_argument (new CCodeConstant ("\"file %s: line %d: uncaught error: %s\""));
                ccritical.add_argument (new CCodeConstant ("__FILE__"));
                ccritical.add_argument (new CCodeConstant ("__LINE__"));
-               ccritical.add_argument (new CCodeMemberAccess.pointer (new CCodeIdentifier ("inner_error"), "message"));
+               ccritical.add_argument (new CCodeMemberAccess.pointer (get_variable_cexpression ("inner_error"), "message"));
                cprint_frag.append (new CCodeExpressionStatement (ccritical));
                var cclear = new CCodeFunctionCall (new CCodeIdentifier ("g_clear_error"));
-               cclear.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("inner_error")));
+               cclear.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_variable_cexpression ("inner_error")));
                cprint_frag.append (new CCodeExpressionStatement (cclear));
 
                if (current_try != null) {
@@ -113,7 +113,7 @@ public class Vala.GErrorModule : CCodeDelegateModule {
                                        // general catch clause
                                        cerror_block.add_statement (cgoto_stmt);
                                } else {
-                                       var ccond = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, new CCodeMemberAccess.pointer (new CCodeIdentifier ("inner_error"), "domain"), new CCodeIdentifier (clause.error_type.data_type.get_upper_case_cname ()));
+                                       var ccond = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, new CCodeMemberAccess.pointer (get_variable_cexpression ("inner_error"), "domain"), new CCodeIdentifier (clause.error_type.data_type.get_upper_case_cname ()));
 
                                        var cgoto_block = new CCodeBlock ();
                                        cgoto_block.add_statement (cgoto_stmt);
@@ -125,7 +125,7 @@ public class Vala.GErrorModule : CCodeDelegateModule {
                        cerror_block.add_statement (cprint_frag);
 
                        // check error domain if expression failed
-                       var ccond = new CCodeBinaryExpression (CCodeBinaryOperator.INEQUALITY, new CCodeIdentifier ("inner_error"), new CCodeConstant ("NULL"));
+                       var ccond = new CCodeBinaryExpression (CCodeBinaryOperator.INEQUALITY, get_variable_cexpression ("inner_error"), new CCodeConstant ("NULL"));
 
                        cfrag.append (new CCodeIfStatement (ccond, cerror_block));
                } else if (current_method != null && current_method.get_error_types ().size > 0) {
@@ -133,8 +133,8 @@ public class Vala.GErrorModule : CCodeDelegateModule {
                        // TODO ensure one of the error domains matches
 
                        var cpropagate = new CCodeFunctionCall (new CCodeIdentifier ("g_propagate_error"));
-                       cpropagate.add_argument (new CCodeIdentifier ("error"));
-                       cpropagate.add_argument (new CCodeIdentifier ("inner_error"));
+                       cpropagate.add_argument (get_variable_cexpression ("error"));
+                       cpropagate.add_argument (get_variable_cexpression ("inner_error"));
 
                        var cerror_block = new CCodeBlock ();
                        cerror_block.add_statement (new CCodeExpressionStatement (cpropagate));
@@ -150,7 +150,7 @@ public class Vala.GErrorModule : CCodeDelegateModule {
                                cerror_block.add_statement (new CCodeReturnStatement (default_value_for_type (current_return_type, false)));
                        }
 
-                       var ccond = new CCodeBinaryExpression (CCodeBinaryOperator.INEQUALITY, new CCodeIdentifier ("inner_error"), new CCodeConstant ("NULL"));
+                       var ccond = new CCodeBinaryExpression (CCodeBinaryOperator.INEQUALITY, get_variable_cexpression ("inner_error"), new CCodeConstant ("NULL"));
 
                        cfrag.append (new CCodeIfStatement (ccond, cerror_block));
                } else {
@@ -161,7 +161,7 @@ public class Vala.GErrorModule : CCodeDelegateModule {
                        cerror_block.add_statement (cprint_frag);
 
                        // check error domain if expression failed
-                       var ccond = new CCodeBinaryExpression (CCodeBinaryOperator.INEQUALITY, new CCodeIdentifier ("inner_error"), new CCodeConstant ("NULL"));
+                       var ccond = new CCodeBinaryExpression (CCodeBinaryOperator.INEQUALITY, get_variable_cexpression ("inner_error"), new CCodeConstant ("NULL"));
 
                        cfrag.append (new CCodeIfStatement (ccond, cerror_block));
                }
@@ -236,9 +236,9 @@ public class Vala.GErrorModule : CCodeDelegateModule {
                }
 
                var cdecl = new CCodeDeclaration ("GError *");
-               cdecl.add_declarator (new CCodeVariableDeclarator.with_initializer (variable_name, new CCodeIdentifier ("inner_error")));
+               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 (new CCodeIdentifier ("inner_error"), new CCodeConstant ("NULL"))));
+               cblock.add_statement (new CCodeExpressionStatement (new CCodeAssignment (get_variable_cexpression ("inner_error"), new CCodeConstant ("NULL"))));
 
                cblock.add_statement (clause.body.ccodenode);