GNOME.org
 

vala r2228 - in trunk: . gobject

Author: juergbi
Date: Fri Dec 19 18:40:45 2008
New Revision: 2228
URL: http://svn.gnome.org/viewvc/vala?rev=2228&view=rev

Log:
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


Modified:
   trunk/ChangeLog
   trunk/gobject/valaccodebasemodule.vala
   trunk/gobject/valaccodemethodcallmodule.vala
   trunk/gobject/valaccodemethodmodule.vala
   trunk/gobject/valagerrormodule.vala

Modified: trunk/gobject/valaccodebasemodule.vala
==============================================================================
--- trunk/gobject/valaccodebasemodule.vala	(original)
+++ trunk/gobject/valaccodebasemodule.vala	Fri Dec 19 18:40:45 2008
@@ -1443,12 +1443,12 @@
 				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 @@
 					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 @@
 				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 @@
 		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 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 ());
+			if (current_method != null && current_method.coroutine) {
+				closure_struct.add_field (local.variable_type.get_cname (), local.name);
+
+				// 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"));
+				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;
-			}
+					vardecl.initializer = clist;
+				}
 			
-			cfrag.append (cdecl);
+				cfrag.append (cdecl);
+			}
 		}
 	}
 
@@ -2639,7 +2645,7 @@
 			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 @@
 				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 @@
 					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 @@
 				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) {

Modified: trunk/gobject/valaccodemethodcallmodule.vala
==============================================================================
--- trunk/gobject/valaccodemethodcallmodule.vala	(original)
+++ trunk/gobject/valaccodemethodcallmodule.vala	Fri Dec 19 18:40:45 2008
@@ -122,8 +122,8 @@
 
 					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 @@
 
 						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 @@
 
 						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 @@
 						} 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 @@
 						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 @@
 			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 @@
 			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 @@
 			// 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 @@
 				// 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 @@
 			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);
 

Modified: trunk/gobject/valaccodemethodmodule.vala
==============================================================================
--- trunk/gobject/valaccodemethodmodule.vala	(original)
+++ trunk/gobject/valaccodemethodmodule.vala	Fri Dec 19 18:40:45 2008
@@ -302,9 +302,15 @@
 					/* 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) {

Modified: trunk/gobject/valagerrormodule.vala
==============================================================================
--- trunk/gobject/valagerrormodule.vala	(original)
+++ trunk/gobject/valagerrormodule.vala	Fri Dec 19 18:40:45 2008
@@ -76,7 +76,7 @@
 
 		// 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 @@
 		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 @@
 					// 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 @@
 			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 @@
 			// 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 @@
 				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 @@
 			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 @@
 		}
 
 		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);
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]