current_block.add_statement (new CCodeExpressionStatement (expression));
}
+ public void add_assignment (CCodeExpression left, CCodeExpression right) {
+ add_expression (new CCodeAssignment (left, right));
+ }
+
public void add_return (CCodeExpression? expression = null) {
current_block.add_statement (new CCodeReturnStatement (expression));
}
if (rank > 1) {
append_initializer_list (name_cnode, (InitializerList) e, rank - 1, ref i);
} else {
- ccode.add_expression (new CCodeAssignment (new CCodeElementAccess (name_cnode, new CCodeConstant (i.to_string ())), get_cvalue (e)));
+ ccode.add_assignment (new CCodeElementAccess (name_cnode, new CCodeConstant (i.to_string ())), get_cvalue (e));
i++;
}
}
emit_temp_var (temp_var);
- ccode.add_expression (new CCodeAssignment (name_cnode, gnew));
+ ccode.add_assignment (name_cnode, gnew);
if (expr.initializer_list != null) {
append_initializer_list (name_cnode, expr.initializer_list, expr.rank, ref i);
gnew.add_argument (length_expr);
ccode.add_declaration (array_type.get_cname (), cvardecl);
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("result"), gnew));
+ ccode.add_assignment (new CCodeIdentifier ("result"), gnew);
ccode.add_declaration ("int", new CCodeVariableDeclarator ("i"));
new CCodeBinaryExpression (CCodeBinaryOperator.LESS_THAN, new CCodeIdentifier ("i"), new CCodeIdentifier ("length")),
new CCodeUnaryExpression (CCodeUnaryOperator.POSTFIX_INCREMENT, new CCodeIdentifier ("i")));
- ccode.add_expression (new CCodeAssignment (new CCodeElementAccess (new CCodeIdentifier ("result"), new CCodeIdentifier ("i")), get_ref_cexpression (array_type.element_type, new CCodeElementAccess (new CCodeIdentifier ("self"), new CCodeIdentifier ("i")), null, array_type)));
+ ccode.add_assignment (new CCodeElementAccess (new CCodeIdentifier ("result"), new CCodeIdentifier ("i")), get_ref_cexpression (array_type.element_type, new CCodeElementAccess (new CCodeIdentifier ("self"), new CCodeIdentifier ("i")), null, array_type));
ccode.close ();
ccode.add_return (new CCodeIdentifier ("result"));
new CCodeUnaryExpression (CCodeUnaryOperator.POSTFIX_INCREMENT, new CCodeIdentifier ("i")));
- ccode.add_expression (new CCodeAssignment (new CCodeElementAccess (new CCodeIdentifier ("dest"), new CCodeIdentifier ("i")), get_ref_cexpression (array_type.element_type, new CCodeElementAccess (new CCodeIdentifier ("self"), new CCodeIdentifier ("i")), null, array_type)));
+ ccode.add_assignment (new CCodeElementAccess (new CCodeIdentifier ("dest"), new CCodeIdentifier ("i")), get_ref_cexpression (array_type.element_type, new CCodeElementAccess (new CCodeIdentifier ("self"), new CCodeIdentifier ("i")), null, array_type));
} else {
cfile.add_include ("string.h");
var csizecheck = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, length, size);
ccode.open_if (csizecheck);
- ccode.add_expression (new CCodeAssignment (size, new CCodeConditionalExpression (size, new CCodeBinaryExpression (CCodeBinaryOperator.MUL, new CCodeConstant ("2"), size), new CCodeConstant ("4"))));
- ccode.add_expression (new CCodeAssignment (array, renew_call));
+ ccode.add_assignment (size, new CCodeConditionalExpression (size, new CCodeBinaryExpression (CCodeBinaryOperator.MUL, new CCodeConstant ("2"), size), new CCodeConstant ("4")));
+ ccode.add_assignment (array, renew_call);
ccode.close ();
- ccode.add_expression (new CCodeAssignment (new CCodeElementAccess (array, new CCodeUnaryExpression (CCodeUnaryOperator.POSTFIX_INCREMENT, length)), value));
+ ccode.add_assignment (new CCodeElementAccess (array, new CCodeUnaryExpression (CCodeUnaryOperator.POSTFIX_INCREMENT, length)), value);
if (array_type.element_type.is_reference_type_or_type_parameter ()) {
// NULL terminate array
- ccode.add_expression (new CCodeAssignment (new CCodeElementAccess (array, length), new CCodeConstant ("NULL")));
+ ccode.add_assignment (new CCodeElementAccess (array, length), new CCodeConstant ("NULL"));
}
pop_function ();
string lhs_temp_name = "_tmp%d_".printf (next_temp_var_id++);
var lhs_temp = new LocalVariable (lhs_value_type, "*" + lhs_temp_name);
emit_temp_var (lhs_temp);
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (lhs_temp_name), new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, lhs)));
+ ccode.add_assignment (get_variable_cexpression (lhs_temp_name), new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, lhs));
lhs = new CCodeParenthesizedExpression (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, get_variable_cexpression (lhs_temp_name)));
}
var temp_decl = get_temp_variable (assignment.left.value_type, true, null, false);
emit_temp_var (temp_decl);
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (temp_decl.name), rhs));
+ ccode.add_assignment (get_variable_cexpression (temp_decl.name), rhs);
if (unref_old) {
/* unref old value */
ccode.add_expression (get_unref_expression (lhs, assignment.left.value_type, assignment.left));
for (int dim = 1; dim <= array_type.rank; dim++) {
var lhs_array_len = get_array_length_cexpression (assignment.left, dim);
var rhs_array_len = get_array_length_cexpression (assignment.right, dim);
- ccode.add_expression (new CCodeAssignment (lhs_array_len, rhs_array_len));
+ ccode.add_assignment (lhs_array_len, rhs_array_len);
}
if (array_type.rank == 1) {
var array_var = assignment.left.symbol_reference;
&& ((array_var is LocalVariable && !array_local.captured) || array_var is Field)) {
var lhs_array_size = get_array_size_cvalue (assignment.left.target_value);
var rhs_array_len = get_array_length_cexpression (assignment.left, 1);
- ccode.add_expression (new CCodeAssignment (lhs_array_size, rhs_array_len));
+ ccode.add_assignment (lhs_array_size, rhs_array_len);
}
}
} else if (instance_delegate) {
CCodeExpression lhs_delegate_target_destroy_notify, rhs_delegate_target_destroy_notify;
var lhs_delegate_target = get_delegate_target_cexpression (assignment.left, out lhs_delegate_target_destroy_notify);
var rhs_delegate_target = get_delegate_target_cexpression (assignment.right, out rhs_delegate_target_destroy_notify);
- ccode.add_expression (new CCodeAssignment (lhs_delegate_target, rhs_delegate_target));
+ ccode.add_assignment (lhs_delegate_target, rhs_delegate_target);
if (assignment.right.target_type.value_owned) {
- ccode.add_expression (new CCodeAssignment (lhs_delegate_target_destroy_notify, rhs_delegate_target_destroy_notify));
+ ccode.add_assignment (lhs_delegate_target_destroy_notify, rhs_delegate_target_destroy_notify);
}
}
ccode.add_expression (destroy_value (lvalue));
}
- ccode.add_expression (new CCodeAssignment (get_cvalue_ (lvalue), get_cvalue_ (value)));
+ ccode.add_assignment (get_cvalue_ (lvalue), get_cvalue_ (value));
var array_type = variable.variable_type as ArrayType;
if (array_type != null) {
for (int dim = 1; dim <= array_type.rank; dim++) {
if (get_array_length_cvalue (lvalue, dim) != null) {
- ccode.add_expression (new CCodeAssignment (get_array_length_cvalue (lvalue, dim), get_array_length_cvalue (value, dim)));
+ ccode.add_assignment (get_array_length_cvalue (lvalue, dim), get_array_length_cvalue (value, dim));
}
}
if (array_type.rank == 1) {
if (get_array_size_cvalue (lvalue) != null) {
if (get_array_size_cvalue (value) != null) {
- ccode.add_expression (new CCodeAssignment (get_array_size_cvalue (lvalue), get_array_size_cvalue (value)));
+ ccode.add_assignment (get_array_size_cvalue (lvalue), get_array_size_cvalue (value));
} else {
- ccode.add_expression (new CCodeAssignment (get_array_size_cvalue (lvalue), get_array_length_cvalue (value, 1)));
+ ccode.add_assignment (get_array_size_cvalue (lvalue), get_array_length_cvalue (value, 1));
}
}
}
var delegate_type = variable.variable_type as DelegateType;
if (delegate_type != null && delegate_type.delegate_symbol.has_target) {
if (get_delegate_target_cvalue (lvalue) != null) {
- ccode.add_expression (new CCodeAssignment (get_delegate_target_cvalue (lvalue), get_delegate_target_cvalue (value)));
+ ccode.add_assignment (get_delegate_target_cvalue (lvalue), get_delegate_target_cvalue (value));
if (get_delegate_target_destroy_notify_cvalue (lvalue) != null) {
- ccode.add_expression (new CCodeAssignment (get_delegate_target_destroy_notify_cvalue (lvalue), get_delegate_target_destroy_notify_cvalue (value)));
+ ccode.add_assignment (get_delegate_target_destroy_notify_cvalue (lvalue), get_delegate_target_destroy_notify_cvalue (value));
}
}
}
var rhs = get_cvalue (f.initializer);
- ccode.add_expression (new CCodeAssignment (lhs, rhs));
+ ccode.add_assignment (lhs, rhs);
if (f.variable_type is ArrayType && !f.no_array_length &&
f.initializer is ArrayCreationExpression) {
for (int dim = 1; dim <= array_type.rank; dim++) {
var array_len_lhs = get_array_length_cexpression (ma, dim);
var size = sizes[dim - 1];
- ccode.add_expression (new CCodeAssignment (array_len_lhs, get_cvalue (size)));
+ ccode.add_assignment (array_len_lhs, get_cvalue (size));
}
if (array_type.rank == 1 && f.is_internal_symbol ()) {
var lhs_array_size = get_array_size_cvalue (ma.target_value);
var rhs_array_len = get_array_length_cexpression (ma, 1);
- ccode.add_expression (new CCodeAssignment (lhs_array_size, rhs_array_len));
+ ccode.add_assignment (lhs_array_size, rhs_array_len);
}
}
var rhs = get_cvalue (f.initializer);
- ccode.add_expression (new CCodeAssignment (lhs, rhs));
+ ccode.add_assignment (lhs, rhs);
foreach (LocalVariable local in temp_ref_vars) {
ccode.add_expression (get_unref_expression_ (local));
ccode.add_declaration (temp_decl.variable_type.get_cname (), vardecl);
var tmp = get_variable_cexpression (get_variable_cname (temp_decl.name));
- ccode.add_expression (new CCodeAssignment (lhs, tmp));
+ ccode.add_assignment (lhs, tmp);
ccode.close ();
} else {
- ccode.add_expression (new CCodeAssignment (lhs, rhs));
+ ccode.add_assignment (lhs, rhs);
}
if (f.variable_type is ArrayType && !f.no_array_length &&
for (int dim = 1; dim <= array_type.rank; dim++) {
var array_len_lhs = get_array_length_cexpression (ma, dim);
var size = sizes[dim - 1];
- ccode.add_expression (new CCodeAssignment (array_len_lhs, get_cvalue (size)));
+ ccode.add_assignment (array_len_lhs, get_cvalue (size));
}
}
} else {
if (is_virtual) {
ccode.add_declaration (this_type.get_cname (), new CCodeVariableDeclarator ("self"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("self"), transform_expression (new CCodeIdentifier ("base"), base_type, this_type)));
+ ccode.add_assignment (new CCodeIdentifier ("self"), transform_expression (new CCodeIdentifier ("base"), base_type, this_type));
}
acc.body.emit (this);
param.captured = true;
}
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), get_variable_cname (param.name)), cparam));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), get_variable_cname (param.name)), cparam);
if (param.variable_type is ArrayType) {
var array_type = (ArrayType) param.variable_type;
for (int dim = 1; dim <= array_type.rank; dim++) {
data.add_field ("gint", get_parameter_array_length_cname (param, dim));
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), get_array_length_cname (get_variable_cname (param.name), dim)), new CCodeIdentifier (get_array_length_cname (get_variable_cname (param.name), dim))));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), get_array_length_cname (get_variable_cname (param.name), dim)), new CCodeIdentifier (get_array_length_cname (get_variable_cname (param.name), dim)));
}
} else if (param.variable_type is DelegateType) {
CCodeExpression target_expr;
}
data.add_field ("gpointer", get_delegate_target_cname (get_variable_cname (param.name)));
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), get_delegate_target_cname (get_variable_cname (param.name))), target_expr));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), get_delegate_target_cname (get_variable_cname (param.name))), target_expr);
if (param.variable_type.value_owned) {
data.add_field ("GDestroyNotify", get_delegate_target_destroy_notify_cname (get_variable_cname (param.name)));
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), get_delegate_target_destroy_notify_cname (get_variable_cname (param.name))), delegate_target_destroy_notify));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), get_delegate_target_destroy_notify_cname (get_variable_cname (param.name))), delegate_target_destroy_notify);
}
}
} else {
ccode.add_declaration (struct_name + "*", new CCodeVariableDeclarator ("_data%d_".printf (block_id)));
}
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression ("_data%d_".printf (block_id)), data_alloc));
+ ccode.add_assignment (get_variable_cexpression ("_data%d_".printf (block_id)), data_alloc);
// initialize ref_count
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), "_ref_count_"), new CCodeIdentifier ("1")));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), "_ref_count_"), new CCodeIdentifier ("1"));
if (parent_block != null) {
int parent_block_id = get_block_id (parent_block);
var ref_call = new CCodeFunctionCall (new CCodeIdentifier ("block%d_data_ref".printf (parent_block_id)));
ref_call.add_argument (get_variable_cexpression ("_data%d_".printf (parent_block_id)));
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), "_data%d_".printf (parent_block_id)), ref_call));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), "_data%d_".printf (parent_block_id)), ref_call);
} else {
if (in_constructor || (current_method != null && current_method.binding == MemberBinding.INSTANCE &&
(!(current_method is CreationMethod) || current_method.body != b)) ||
var ref_call = new CCodeFunctionCall (get_dup_func_expression (new ObjectType (current_class), b.source_reference));
ref_call.add_argument (get_result_cexpression ("self"));
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), "self"), ref_call));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), "self"), ref_call);
}
if (current_method != null) {
string func_name;
func_name = "%s_type".printf (type_param.name.down ());
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), func_name), new CCodeIdentifier (func_name)));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), func_name), new CCodeIdentifier (func_name));
func_name = "%s_dup_func".printf (type_param.name.down ());
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), func_name), new CCodeIdentifier (func_name)));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), func_name), new CCodeIdentifier (func_name));
func_name = "%s_destroy_func".printf (type_param.name.down ());
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), func_name), new CCodeIdentifier (func_name)));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), func_name), new CCodeIdentifier (func_name));
}
}
}
// async method is suspended while waiting for callback,
// so we never need to care about memory management of async data
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), "_async_data_"), new CCodeIdentifier ("data")));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), "_async_data_"), new CCodeIdentifier ("data"));
}
} else if (b.parent_symbol is PropertyAccessor) {
var acc = (PropertyAccessor) b.parent_symbol;
} else {
var temp_var = get_temp_variable (local.variable_type, true, local, false);
emit_temp_var (temp_var);
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (temp_var.name), rhs));
+ ccode.add_assignment (get_variable_cexpression (temp_var.name), rhs);
for (int dim = 1; dim <= array_type.rank; dim++) {
var lhs_array_len = get_array_length_cvalue (target_value, dim);
var rhs_array_len = get_array_length_cexpression (local.initializer, dim);
- ccode.add_expression (new CCodeAssignment (lhs_array_len, rhs_array_len));
+ ccode.add_assignment (lhs_array_len, rhs_array_len);
}
if (array_type.rank == 1 && !local.captured) {
var lhs_array_size = get_array_size_cvalue (target_value);
var rhs_array_len = get_array_length_cvalue (target_value, 1);
- ccode.add_expression (new CCodeAssignment (lhs_array_size, rhs_array_len));
+ ccode.add_assignment (lhs_array_size, rhs_array_len);
}
rhs = get_variable_cexpression (temp_var.name);
if (d.has_target) {
var temp_var = get_temp_variable (local.variable_type, true, local, false);
emit_temp_var (temp_var);
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (temp_var.name), rhs));
+ ccode.add_assignment (get_variable_cexpression (temp_var.name), rhs);
var lhs_delegate_target = get_delegate_target_cvalue (target_value);
var lhs_delegate_target_destroy_notify = get_delegate_target_destroy_notify_cvalue (target_value);
CCodeExpression rhs_delegate_target_destroy_notify;
var rhs_delegate_target = get_delegate_target_cexpression (local.initializer, out rhs_delegate_target_destroy_notify);
- ccode.add_expression (new CCodeAssignment (lhs_delegate_target, rhs_delegate_target));
+ ccode.add_assignment (lhs_delegate_target, rhs_delegate_target);
if (deleg_type.value_owned) {
- ccode.add_expression (new CCodeAssignment (lhs_delegate_target_destroy_notify, rhs_delegate_target_destroy_notify));
+ ccode.add_assignment (lhs_delegate_target_destroy_notify, rhs_delegate_target_destroy_notify);
}
rhs = get_variable_cexpression (temp_var.name);
rhs = null;
} else {
for (int dim = 1; dim <= array_type.rank; dim++) {
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (get_array_length_cname (get_variable_cname (local.name), dim)), new CCodeConstant ("0")));
+ ccode.add_assignment (get_variable_cexpression (get_array_length_cname (get_variable_cname (local.name), dim)), new CCodeConstant ("0"));
}
}
}
if (has_simple_struct_initializer (local)) {
ccode.add_expression (rhs);
} else {
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (get_block_id ((Block) local.parent_symbol))), get_variable_cname (local.name)), rhs));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (get_block_id ((Block) local.parent_symbol))), get_variable_cname (local.name)), rhs);
}
}
} else if (current_method != null && current_method.coroutine) {
if (has_simple_struct_initializer (local)) {
ccode.add_expression (rhs);
} else {
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (new CCodeIdentifier ("data"), get_variable_cname (local.name)), rhs));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (new CCodeIdentifier ("data"), get_variable_cname (local.name)), rhs);
}
}
} else {
if (cvar.initializer != null && !cvar.init0) {
cvar.initializer = null;
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (local.name), rhs));
+ ccode.add_assignment (get_variable_cexpression (local.name), rhs);
}
if (post_rhs != null) {
var creation_call = new CCodeFunctionCall (new CCodeIdentifier ("g_new0"));
creation_call.add_argument (new CCodeConstant (value_type.data_type.get_cname ()));
creation_call.add_argument (new CCodeConstant ("1"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("dup"), creation_call));
+ ccode.add_assignment (new CCodeIdentifier ("dup"), creation_call);
var st = value_type.data_type as Struct;
if (st != null && st.is_disposable ()) {
memset_call.add_argument (new CCodeIdentifier ("sizeof (%s)".printf (local.variable_type.get_cname ())));
ccode.add_expression (memset_call);
} else if (vardecl.initializer != null) {
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (local.name), vardecl.initializer));
+ ccode.add_assignment (get_variable_cexpression (local.name), vardecl.initializer);
}
} else {
ccode.add_declaration (local.variable_type.get_cname (), vardecl);
var delegate_type = param.variable_type as DelegateType;
ccode.open_if (get_variable_cexpression (param.name));
- ccode.add_expression (new CCodeAssignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, get_variable_cexpression (param.name)), get_variable_cexpression ("_" + param.name)));
+ ccode.add_assignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, get_variable_cexpression (param.name)), get_variable_cexpression ("_" + param.name));
if (delegate_type != null && delegate_type.delegate_symbol.has_target) {
- ccode.add_expression (new CCodeAssignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, get_variable_cexpression (get_delegate_target_cname (param.name))), new CCodeIdentifier (get_delegate_target_cname (get_variable_cname ("_" + param.name)))));
+ ccode.add_assignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, get_variable_cexpression (get_delegate_target_cname (param.name))), new CCodeIdentifier (get_delegate_target_cname (get_variable_cname ("_" + param.name))));
if (delegate_type.value_owned) {
- ccode.add_expression (new CCodeAssignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, get_variable_cexpression (get_delegate_target_destroy_notify_cname (param.name))), new CCodeIdentifier (get_delegate_target_destroy_notify_cname (get_variable_cname ("_" + param.name)))));
+ ccode.add_assignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, get_variable_cexpression (get_delegate_target_destroy_notify_cname (param.name))), new CCodeIdentifier (get_delegate_target_destroy_notify_cname (get_variable_cname ("_" + param.name))));
}
}
if (array_type != null && !array_type.fixed_length && !param.no_array_length) {
for (int dim = 1; dim <= array_type.rank; dim++) {
ccode.open_if (get_variable_cexpression (get_parameter_array_length_cname (param, dim)));
- ccode.add_expression (new CCodeAssignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, get_variable_cexpression (get_parameter_array_length_cname (param, dim))), new CCodeIdentifier (get_array_length_cname (get_variable_cname ("_" + param.name), dim))));
+ ccode.add_assignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, get_variable_cexpression (get_parameter_array_length_cname (param, dim))), new CCodeIdentifier (get_array_length_cname (get_variable_cname ("_" + param.name), dim)));
ccode.close ();
}
}
if (((current_method != null && !current_method.no_array_length) || current_property_accessor != null) && current_return_type is ArrayType) {
var return_expr_decl = get_temp_variable (stmt.return_expression.value_type, true, stmt, false);
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (return_expr_decl.name), get_cvalue (stmt.return_expression)));
+ ccode.add_assignment (get_variable_cexpression (return_expr_decl.name), get_cvalue (stmt.return_expression));
var array_type = (ArrayType) current_return_type;
len_l = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, len_l);
}
var len_r = get_array_length_cexpression (stmt.return_expression, dim);
- ccode.add_expression (new CCodeAssignment (len_l, len_r));
+ ccode.add_assignment (len_l, len_r);
}
set_cvalue (stmt.return_expression, get_variable_cexpression (return_expr_decl.name));
if (delegate_type.delegate_symbol.has_target) {
var return_expr_decl = get_temp_variable (stmt.return_expression.value_type, true, stmt, false);
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (return_expr_decl.name), get_cvalue (stmt.return_expression)));
+ ccode.add_assignment (get_variable_cexpression (return_expr_decl.name), get_cvalue (stmt.return_expression));
var target_l = get_result_cexpression (get_delegate_target_cname ("result"));
if (current_method == null || !current_method.coroutine) {
}
CCodeExpression target_r_destroy_notify;
var target_r = get_delegate_target_cexpression (stmt.return_expression, out target_r_destroy_notify);
- ccode.add_expression (new CCodeAssignment (target_l, target_r));
+ ccode.add_assignment (target_l, target_r);
if (delegate_type.value_owned) {
var target_l_destroy_notify = get_result_cexpression (get_delegate_target_destroy_notify_cname ("result"));
if (current_method == null || !current_method.coroutine) {
target_l_destroy_notify = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, target_l_destroy_notify);
}
- ccode.add_expression (new CCodeAssignment (target_l_destroy_notify, target_r_destroy_notify));
+ ccode.add_assignment (target_l_destroy_notify, target_r_destroy_notify);
}
set_cvalue (stmt.return_expression, get_variable_cexpression (return_expr_decl.name));
if (current_return_type.is_real_non_null_struct_type () && (current_method == null || !current_method.coroutine)) {
result_lhs = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, result_lhs);
}
- ccode.add_expression (new CCodeAssignment (result_lhs, get_cvalue (stmt.return_expression)));
+ ccode.add_assignment (result_lhs, get_cvalue (stmt.return_expression));
}
// free local variables
regex_new_call.add_argument (new CCodeConstant ("match_options"));
regex_new_call.add_argument (new CCodeConstant ("0"));
regex_new_call.add_argument (new CCodeConstant ("NULL"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("GRegex* val"), regex_new_call));
+ ccode.add_assignment (new CCodeIdentifier ("GRegex* val"), regex_new_call);
var once_leave_call = new CCodeFunctionCall (new CCodeIdentifier ("g_once_init_leave"));
once_leave_call.add_argument (new CCodeConstant ("(volatile gsize*) re"));
// assign current value to temp variable
var temp_decl = get_temp_variable (prop.property_type, true, expr, false);
emit_temp_var (temp_decl);
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (temp_decl.name), get_cvalue (expr.inner)));
+ ccode.add_assignment (get_variable_cexpression (temp_decl.name), get_cvalue (expr.inner));
// increment/decrement property
var op = expr.increment ? CCodeBinaryOperator.PLUS : CCodeBinaryOperator.MINUS;
// assign current value to temp variable
var temp_decl = get_temp_variable (expr.inner.value_type, true, expr, false);
emit_temp_var (temp_decl);
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (temp_decl.name), get_cvalue (expr.inner)));
+ ccode.add_assignment (get_variable_cexpression (temp_decl.name), get_cvalue (expr.inner));
// increment/decrement variable
var op = expr.increment ? CCodeBinaryOperator.PLUS : CCodeBinaryOperator.MINUS;
var cexpr = new CCodeBinaryExpression (op, get_variable_cexpression (temp_decl.name), new CCodeConstant ("1"));
- ccode.add_expression (new CCodeAssignment (get_cvalue (expr.inner), cexpr));
+ ccode.add_assignment (get_cvalue (expr.inner), cexpr);
// return previous value
set_cvalue (expr, get_variable_cexpression (temp_decl.name));
if (expr.type_reference.data_type is Struct) {
ccode.add_expression (creation_expr);
} else {
- ccode.add_expression (new CCodeAssignment (instance, creation_expr));
+ ccode.add_assignment (instance, creation_expr);
}
foreach (MemberInitializer init in expr.get_object_initializer ()) {
} else {
lhs = new CCodeMemberAccess.pointer (typed_inst, f.get_cname ());
}
- ccode.add_expression (new CCodeAssignment (lhs, get_cvalue (init.initializer)));
+ ccode.add_assignment (lhs, get_cvalue (init.initializer));
if (f.variable_type is ArrayType && !f.no_array_length) {
var array_type = (ArrayType) f.variable_type;
lhs = new CCodeMemberAccess.pointer (typed_inst, get_array_length_cname (f.get_cname (), dim));
}
var rhs_array_len = get_array_length_cexpression (init.initializer, dim);
- ccode.add_expression (new CCodeAssignment (lhs, rhs_array_len));
+ ccode.add_assignment (lhs, rhs_array_len);
}
} else if (f.variable_type is DelegateType && (f.variable_type as DelegateType).delegate_symbol.has_target && !f.no_delegate_target) {
if (expr.type_reference.data_type is Struct) {
}
CCodeExpression rhs_delegate_target_destroy_notify;
var rhs_delegate_target = get_delegate_target_cexpression (init.initializer, out rhs_delegate_target_destroy_notify);
- ccode.add_expression (new CCodeAssignment (lhs, rhs_delegate_target));
+ ccode.add_assignment (lhs, rhs_delegate_target);
}
var cl = f.parent_symbol as Class;
emit_temp_var (temp_var);
- ccode.add_expression (new CCodeAssignment (temp_ref, creation_expr));
+ ccode.add_assignment (temp_ref, creation_expr);
set_cvalue (expr, temp_ref);
}
}
emit_temp_var (temp_decl);
var cvar = get_variable_cexpression (temp_decl.name);
- ccode.add_expression (new CCodeAssignment (cvar, get_cvalue (expr.inner)));
+ ccode.add_assignment (cvar, get_cvalue (expr.inner));
if (!(expr.value_type is DelegateType)) {
- ccode.add_expression (new CCodeAssignment (get_cvalue (expr.inner), new CCodeConstant ("NULL")));
+ ccode.add_assignment (get_cvalue (expr.inner), new CCodeConstant ("NULL"));
}
set_cvalue (expr, cvar);
var target_cvar = get_variable_cexpression (temp_target_decl.name);
CCodeExpression target_destroy_notify;
var target = get_delegate_target_cexpression (expr.inner, out target_destroy_notify);
- ccode.add_expression (new CCodeAssignment (target_cvar, target));
+ ccode.add_assignment (target_cvar, target);
set_delegate_target (expr, target_cvar);
if (target_destroy_notify != null) {
var temp_target_destroy_notify_decl = get_temp_variable (gdestroynotify_type, true, expr, false);
emit_temp_var (temp_target_destroy_notify_decl);
var target_destroy_notify_cvar = get_variable_cexpression (temp_target_destroy_notify_decl.name);
- ccode.add_expression (new CCodeAssignment (target_destroy_notify_cvar, target_destroy_notify));
- ccode.add_expression (new CCodeAssignment (target_destroy_notify, new CCodeConstant ("NULL")));
+ ccode.add_assignment (target_destroy_notify_cvar, target_destroy_notify);
+ ccode.add_assignment (target_destroy_notify, new CCodeConstant ("NULL"));
set_delegate_target_destroy_notify (expr, target_destroy_notify_cvar);
}
}
var decl = get_temp_variable (expression_type, true, expression_type, false);
emit_temp_var (decl);
temp_ref_vars.insert (0, decl);
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (decl.name), cexpr));
+ ccode.add_assignment (get_variable_cexpression (decl.name), cexpr);
cexpr = get_variable_cexpression (decl.name);
if (expression_type is ArrayType && expr != null) {
for (int dim = 1; dim <= array_type.rank; dim++) {
var len_decl = new LocalVariable (int_type.copy (), get_array_length_cname (decl.name, dim));
emit_temp_var (len_decl);
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (len_decl.name), get_array_length_cexpression (expr, dim)));
+ ccode.add_assignment (get_variable_cexpression (len_decl.name), get_array_length_cexpression (expr, dim));
}
} else if (expression_type is DelegateType && expr != null) {
var target_decl = new LocalVariable (new PointerType (new VoidType ()), get_delegate_target_cname (decl.name));
var target_destroy_notify_decl = new LocalVariable (gdestroynotify_type, get_delegate_target_destroy_notify_cname (decl.name));
emit_temp_var (target_destroy_notify_decl);
CCodeExpression target_destroy_notify;
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (target_decl.name), get_delegate_target_cexpression (expr, out target_destroy_notify)));
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (target_destroy_notify_decl.name), target_destroy_notify));
+ ccode.add_assignment (get_variable_cexpression (target_decl.name), get_delegate_target_cexpression (expr, out target_destroy_notify));
+ ccode.add_assignment (get_variable_cexpression (target_destroy_notify_decl.name), target_destroy_notify);
}
}
var decl = get_temp_variable (target_type, true, node, false);
emit_temp_var (decl);
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (decl.name), get_ref_cexpression (target_type, cexpr, expr, node)));
+ ccode.add_assignment (get_variable_cexpression (decl.name), get_ref_cexpression (target_type, cexpr, expr, node));
cexpr = get_variable_cexpression (decl.name);
}
}
var temp_var = get_temp_variable (instance.target_type, true, null, false);
emit_temp_var (temp_var);
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (temp_var.name), cinstance));
+ ccode.add_assignment (get_variable_cexpression (temp_var.name), cinstance);
cinstance = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_variable_cexpression (temp_var.name));
}
if (array_type != null && !prop.no_array_length) {
var temp_var = get_temp_variable (prop.property_type, true, null, false);
emit_temp_var (temp_var);
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (temp_var.name), cexpr));
+ ccode.add_assignment (get_variable_cexpression (temp_var.name), cexpr);
ccall.add_argument (get_variable_cexpression (temp_var.name));
} else {
ccall.add_argument (cexpr);
array_copy_call.add_argument (size);
ccode.add_expression (array_copy_call);
} else {
- ccode.add_expression (new CCodeAssignment (dest, copy));
+ ccode.add_assignment (dest, copy);
if (array_type != null && !f.no_array_length) {
for (int dim = 1; dim <= array_type.rank; dim++) {
var len_src = new CCodeMemberAccess.pointer (new CCodeIdentifier ("self"), get_array_length_cname (f.name, dim));
var len_dest = new CCodeMemberAccess.pointer (new CCodeIdentifier ("dest"), get_array_length_cname (f.name, dim));
- ccode.add_expression (new CCodeAssignment (len_dest, len_src));
+ ccode.add_assignment (len_dest, len_src);
}
}
}
var ccolvardecl = new CCodeVariableDeclarator (collection_backup.name);
ccode.add_declaration (collection_type.get_cname (), ccolvardecl);
}
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (collection_backup.name), get_cvalue (stmt.collection)));
+ ccode.add_assignment (get_variable_cexpression (collection_backup.name), get_cvalue (stmt.collection));
if (stmt.tree_can_fail && stmt.collection.tree_can_fail) {
// exception handling
} else {
ccode.add_declaration ("int", new CCodeVariableDeclarator (get_array_length_cname (collection_backup.name, 1)));
}
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (get_array_length_cname (collection_backup.name, 1)), array_len));
+ ccode.add_assignment (get_variable_cexpression (get_array_length_cname (collection_backup.name, 1)), array_len);
var it_name = (stmt.variable_name + "_it");
} else {
ccode.add_declaration (stmt.type_reference.get_cname (), new CCodeVariableDeclarator (stmt.variable_name));
}
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (stmt.variable_name), element_expr));
+ ccode.add_assignment (get_variable_cexpression (stmt.variable_name), element_expr);
// add array length variable for stacked arrays
if (stmt.type_reference is ArrayType) {
for (int dim = 1; dim <= inner_array_type.rank; dim++) {
if (current_method != null && current_method.coroutine) {
closure_struct.add_field ("int", get_array_length_cname (stmt.variable_name, dim));
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (get_array_length_cname (stmt.variable_name, dim)), new CCodeConstant ("-1")));
+ ccode.add_assignment (get_variable_cexpression (get_array_length_cname (stmt.variable_name, dim)), new CCodeConstant ("-1"));
} else {
ccode.add_declaration ("int", new CCodeVariableDeclarator (get_array_length_cname (stmt.variable_name, dim), new CCodeConstant ("-1")));
}
} else {
ccode.add_declaration (stmt.type_reference.get_cname (), new CCodeVariableDeclarator (stmt.variable_name));
}
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (stmt.variable_name), element_expr));
+ ccode.add_assignment (get_variable_cexpression (stmt.variable_name), element_expr);
stmt.body.emit (this);
} else {
ccode.add_declaration (stmt.type_reference.get_cname (), new CCodeVariableDeclarator (stmt.variable_name));
}
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (stmt.variable_name), element_expr));
+ ccode.add_assignment (get_variable_cexpression (stmt.variable_name), element_expr);
stmt.body.emit (this);
ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, ctemp));
ccode.add_expression (ccall);
} else {
- ccode.add_expression (new CCodeAssignment (ctemp, ccall));
+ ccode.add_assignment (ctemp, ccall);
array_type = base_property.property_type as ArrayType;
if (array_type != null && !base_property.no_array_length) {
// set state before calling async function to support immediate callbacks
int state = next_coroutine_state++;
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (new CCodeIdentifier ("data"), "_state_"), new CCodeConstant (state.to_string ())));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (new CCodeIdentifier ("data"), "_state_"), new CCodeConstant (state.to_string ()));
ccode.add_expression (async_call);
ccode.add_return (new CCodeConstant ("FALSE"));
ccode.add_label ("_state_%d".printf (state));
czero.add_argument (new CCodeConstant ("0"));
czero.add_argument (new CCodeBinaryExpression (CCodeBinaryOperator.MUL, csizeof, cdelta));
- ccode.add_expression (new CCodeAssignment (temp_ref, new_size));
+ ccode.add_assignment (temp_ref, new_size);
ccode.add_expression (ccall_expr);
ccode.add_expression (new CCodeConditionalExpression (ccheck, czero, new CCodeConstant ("NULL")));
- ccode.add_expression (new CCodeAssignment (get_array_length_cexpression (ma.inner, 1), temp_ref));
+ ccode.add_assignment (get_array_length_cexpression (ma.inner, 1), temp_ref);
var array_var = ma.inner.symbol_reference;
var array_local = array_var as LocalVariable;
if (array_var != null && array_var.is_internal_symbol ()
&& ((array_var is LocalVariable && !array_local.captured) || array_var is Field)) {
- ccode.add_expression (new CCodeAssignment (get_array_size_cvalue (ma.inner.target_value), temp_ref));
+ ccode.add_assignment (get_array_size_cvalue (ma.inner.target_value), temp_ref);
}
return;
emit_temp_var (temp_var);
- ccode.add_expression (new CCodeAssignment (temp_ref, ccall_expr));
+ ccode.add_assignment (temp_ref, ccall_expr);
set_cvalue (expr, temp_ref);
}
}
// assign new value
- ccode.add_expression (new CCodeAssignment (get_cvalue (unary.inner), transform_expression (get_cvalue (unary), unary.target_type, unary.inner.value_type, arg)));
+ ccode.add_assignment (get_cvalue (unary.inner), transform_expression (get_cvalue (unary), unary.target_type, unary.inner.value_type, arg));
var array_type = arg.value_type as ArrayType;
if (array_type != null) {
for (int dim = 1; dim <= array_type.rank; dim++) {
- ccode.add_expression (new CCodeAssignment (get_array_sizes (unary.inner).get (dim - 1), get_array_sizes (unary).get (dim - 1)));
+ ccode.add_assignment (get_array_sizes (unary.inner).get (dim - 1), get_array_sizes (unary).get (dim - 1));
}
}
var delegate_type = arg.value_type as DelegateType;
if (delegate_type != null) {
- ccode.add_expression (new CCodeAssignment (get_delegate_target (unary.inner), get_delegate_target (unary)));
+ ccode.add_assignment (get_delegate_target (unary.inner), get_delegate_target (unary));
}
}
}
var parent_data = new CCodeMemberAccess.pointer (new CCodeIdentifier ("_data%d_".printf (block_id)), "_data%d_".printf (parent_block_id));
ccode.add_declaration ("Block%dData*".printf (parent_block_id), new CCodeVariableDeclarator ("_data%d_".printf (parent_block_id)));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("_data%d_".printf (parent_block_id)), parent_data));
+ ccode.add_assignment (new CCodeIdentifier ("_data%d_".printf (parent_block_id)), parent_data);
closure_block = parent_closure_block;
block_id = parent_block_id;
if (m.binding == MemberBinding.INSTANCE) {
var cself = new CCodeMemberAccess.pointer (new CCodeIdentifier ("_data%d_".printf (block_id)), "self");
ccode.add_declaration ("%s *".printf (current_class.get_cname ()), new CCodeVariableDeclarator ("self"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("self"), cself));
+ ccode.add_assignment (new CCodeIdentifier ("self"), cself);
}
// allow capturing generic type parameters
func_name = "%s_type".printf (type_param.name.down ());
ccode.add_declaration ("GType", new CCodeVariableDeclarator (func_name));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier (func_name), new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), func_name)));
+ ccode.add_assignment (new CCodeIdentifier (func_name), new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), func_name));
func_name = "%s_dup_func".printf (type_param.name.down ());
ccode.add_declaration ("GBoxedCopyFunc", new CCodeVariableDeclarator (func_name));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier (func_name), new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), func_name)));
+ ccode.add_assignment (new CCodeIdentifier (func_name), new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), func_name));
func_name = "%s_destroy_func".printf (type_param.name.down ());
ccode.add_declaration ("GDestroyNotify", new CCodeVariableDeclarator (func_name));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier (func_name), new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), func_name)));
+ ccode.add_assignment (new CCodeIdentifier (func_name), new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), func_name));
}
} else if (m.parent_symbol is Class && !m.coroutine) {
var cl = (Class) m.parent_symbol;
CCodeExpression cself = transform_expression (new CCodeIdentifier ("base"), base_expression_type, self_target_type);
ccode.add_declaration ("%s *".printf (cl.get_cname ()), new CCodeVariableDeclarator ("self"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("self"), cself));
+ ccode.add_assignment (new CCodeIdentifier ("self"), cself);
} else if (m.binding == MemberBinding.INSTANCE
&& !(m is CreationMethod)) {
create_method_type_check_statement (m, creturn_type, cl, true, "self");
if (cl.is_fundamental ()) {
var ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_type_create_instance"));
ccall.add_argument (new CCodeIdentifier ("object_type"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("self"), new CCodeCastExpression (ccall, cl.get_cname () + "*")));
+ ccode.add_assignment (new CCodeIdentifier ("self"), new CCodeCastExpression (ccall, cl.get_cname () + "*"));
/* type, dup func, and destroy func fields for generic types */
foreach (TypeParameter type_param in current_class.get_type_parameters ()) {
// TODO implicitly chain up to base class as in add_object_creation
var ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_slice_new0"));
ccall.add_argument (new CCodeIdentifier (cl.get_cname ()));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("self"), ccall));
+ ccode.add_assignment (new CCodeIdentifier ("self"), ccall);
}
if (cl.base_class == null) {
} else {
/* store method return value for postconditions */
ccode.add_declaration (get_creturn_type (m, return_type.get_cname ()), new CCodeVariableDeclarator ("result"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("result"), vcall));
+ ccode.add_assignment (new CCodeIdentifier ("result"), vcall);
}
if (m.get_postconditions ().size > 0) {
array_copy_call.add_argument (size);
ccode.add_expression (array_copy_call);
} else {
- ccode.add_expression (new CCodeAssignment (dest, copy));
+ ccode.add_assignment (dest, copy);
if (array_type != null) {
for (int dim = 1; dim <= array_type.rank; dim++) {
var len_src = new CCodeMemberAccess.pointer (new CCodeIdentifier ("self"), get_array_length_cname (f.name, dim));
var len_dest = new CCodeMemberAccess.pointer (new CCodeIdentifier ("dest"), get_array_length_cname (f.name, dim));
- ccode.add_expression (new CCodeAssignment (len_dest, len_src));
+ ccode.add_assignment (len_dest, len_src);
}
}
}
public class Vala.DovaArrayModule : DovaMethodCallModule {
void append_initializer_list (CCodeExpression name_cnode, InitializerList initializer_list, ref int i) {
foreach (Expression e in initializer_list.get_initializers ()) {
- ccode.add_expression (new CCodeAssignment (new CCodeElementAccess (name_cnode, new CCodeConstant (i.to_string ())), get_cvalue (e)));
+ ccode.add_assignment (new CCodeElementAccess (name_cnode, new CCodeConstant (i.to_string ())), get_cvalue (e));
i++;
}
}
emit_temp_var (temp_var);
- ccode.add_expression (new CCodeAssignment (name_cnode, array_new));
+ ccode.add_assignment (name_cnode, array_new);
set_cvalue (expr, name_cnode);
}
string lhs_temp_name = "_tmp%d_".printf (next_temp_var_id++);
var lhs_temp = new LocalVariable (lhs_value_type, "*" + lhs_temp_name);
emit_temp_var (lhs_temp);
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (lhs_temp_name), new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, lhs)));
+ ccode.add_assignment (get_variable_cexpression (lhs_temp_name), new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, lhs));
lhs = new CCodeParenthesizedExpression (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, get_variable_cexpression (lhs_temp_name)));
}
var temp_decl = get_temp_variable (assignment.left.value_type);
emit_temp_var (temp_decl);
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (temp_decl.name), rhs));
+ ccode.add_assignment (get_variable_cexpression (temp_decl.name), rhs);
if (unref_old) {
/* unref old value */
ccode.add_expression (get_unref_expression (lhs, assignment.left.value_type, assignment.left));
ccode.add_expression (destroy_value (lvalue));
}
- ccode.add_expression (new CCodeAssignment (get_cvalue_ (lvalue), get_cvalue_ (value)));
+ ccode.add_assignment (get_cvalue_ (lvalue), get_cvalue_ (value));
}
public override void store_local (LocalVariable local, TargetValue value) {
param.captured = true;
}
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), get_variable_cname (param.name)), cparam));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), get_variable_cname (param.name)), cparam);
if (requires_destroy (param_type)) {
var ma = new MemberAccess.simple (param.name);
if (local.captured) {
if (local.initializer != null) {
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (get_block_id ((Block) local.parent_symbol))), get_variable_cname (local.name)), rhs));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (get_block_id ((Block) local.parent_symbol))), get_variable_cname (local.name)), rhs);
}
} else {
var cvar = new CCodeVariableDeclarator (get_variable_cname (local.name), rhs, local.variable_type.get_cdeclarator_suffix ());
// assign current value to temp variable
var temp_decl = get_temp_variable (prop.property_type, true, expr);
emit_temp_var (temp_decl);
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (temp_decl.name), get_cvalue (expr.inner)));
+ ccode.add_assignment (get_variable_cexpression (temp_decl.name), get_cvalue (expr.inner));
// increment/decrement property
var op = expr.increment ? CCodeBinaryOperator.PLUS : CCodeBinaryOperator.MINUS;
if (expr.type_reference.data_type is Struct) {
ccode.add_expression (creation_expr);
} else {
- ccode.add_expression (new CCodeAssignment (instance, creation_expr));
+ ccode.add_assignment (instance, creation_expr);
}
foreach (MemberInitializer init in expr.get_object_initializer ()) {
} else {
lhs = new CCodeMemberAccess.pointer (typed_inst, f.get_cname ());
}
- ccode.add_expression (new CCodeAssignment (lhs, get_cvalue (init.initializer)));
+ ccode.add_assignment (lhs, get_cvalue (init.initializer));
} else if (init.symbol_reference is Property) {
var inst_ma = new MemberAccess.simple ("new");
inst_ma.value_type = expr.type_reference;
emit_temp_var (temp_var);
- ccode.add_expression (new CCodeAssignment (temp_ref, creation_expr));
+ ccode.add_assignment (temp_ref, creation_expr);
set_cvalue (expr, temp_ref);
}
}
private bool is_in_catch = false;
public override void visit_throw_statement (ThrowStatement stmt) {
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("dova_error"), get_cvalue (stmt.error_expression)));
+ ccode.add_assignment (new CCodeIdentifier ("dova_error"), get_cvalue (stmt.error_expression));
add_simple_check (stmt, true);
}
emit_temp_var (temp_var);
- ccode.add_expression (new CCodeAssignment (temp_ref, ccall_expr));
+ ccode.add_assignment (temp_ref, ccall_expr);
set_cvalue (expr, temp_ref);
}
}
vcast = get_type_private_from_type ((ObjectTypeSymbol) prop.parent_symbol, new CCodeIdentifier ("type"));
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (vcast, "%s_%s".printf (acc.readable ? "get" : "set", prop.name)), new CCodeIdentifier ("function")));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (vcast, "%s_%s".printf (acc.readable ? "get" : "set", prop.name)), new CCodeIdentifier ("function"));
pop_function ();
var lhs = new CCodeIdentifier (field.get_cname ());
var rhs = get_cvalue (field.initializer);
- ccode.add_expression (new CCodeAssignment (lhs, rhs));
+ ccode.add_assignment (lhs, rhs);
}
}
}
var self_target_type = new ObjectType (type_symbol);
var cself = transform_expression (new CCodeIdentifier ("base"), base_expression_type, self_target_type);
ccode.add_declaration ("%s *".printf (type_symbol.get_cname ()), new CCodeVariableDeclarator ("self"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("self"), cself));
+ ccode.add_assignment (new CCodeIdentifier ("self"), cself);
}
var dataalloc = new CCodeFunctionCall (new CCodeIdentifier ("g_slice_new0"));
var data_var = new CCodeIdentifier ("_data_");
ccode.add_declaration (dataname + "*", new CCodeVariableDeclarator ("_data_"));
- ccode.add_expression (new CCodeAssignment (data_var, dataalloc));
+ ccode.add_assignment (data_var, dataalloc);
var create_result = new CCodeFunctionCall (new CCodeIdentifier ("g_simple_async_result_new"));
create_result.add_argument (new CCodeIdentifier ("_user_data_"));
create_result.add_argument (new CCodeIdentifier (m.get_real_cname ()));
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (data_var, "_async_result"), create_result));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (data_var, "_async_result"), create_result);
var set_op_res_call = new CCodeFunctionCall (new CCodeIdentifier ("g_simple_async_result_set_op_res_gpointer"));
set_op_res_call.add_argument (new CCodeMemberAccess.pointer (data_var, "_async_result"));
cself = get_ref_cexpression (m.this_parameter.variable_type, cself, ma, m.this_parameter);
}
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (data_var, "self"), cself));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (data_var, "self"), cself);
}
foreach (Parameter param in m.get_parameters ()) {
cparam = get_ref_cexpression (param.variable_type, cparam, ma, param);
}
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (data_var, get_variable_cname (param.name)), cparam));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (data_var, get_variable_cname (param.name)), cparam);
if (param.variable_type is ArrayType) {
var array_type = (ArrayType) param.variable_type;
if (!param.no_array_length) {
for (int dim = 1; dim <= array_type.rank; dim++) {
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (data_var, get_parameter_array_length_cname (param, dim)), new CCodeIdentifier (get_parameter_array_length_cname (param, dim))));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (data_var, get_parameter_array_length_cname (param, dim)), new CCodeIdentifier (get_parameter_array_length_cname (param, dim)));
}
}
} else if (param.variable_type is DelegateType) {
var deleg_type = (DelegateType) param.variable_type;
if (deleg_type.delegate_symbol.has_target) {
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (data_var, get_delegate_target_cname (get_variable_cname (param.name))), new CCodeIdentifier (get_delegate_target_cname (get_variable_cname (param.name)))));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (data_var, get_delegate_target_cname (get_variable_cname (param.name))), new CCodeIdentifier (get_delegate_target_cname (get_variable_cname (param.name))));
if (deleg_type.value_owned) {
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (data_var, get_delegate_target_destroy_notify_cname (get_variable_cname (param.name))), new CCodeIdentifier (get_delegate_target_destroy_notify_cname (get_variable_cname (param.name)))));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (data_var, get_delegate_target_destroy_notify_cname (get_variable_cname (param.name))), new CCodeIdentifier (get_delegate_target_destroy_notify_cname (get_variable_cname (param.name))));
}
}
}
var ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_simple_async_result_get_op_res_gpointer"));
ccall.add_argument (simple_async_result_cast);
- ccode.add_expression (new CCodeAssignment (data_var, ccall));
+ ccode.add_assignment (data_var, ccall);
foreach (Parameter param in m.get_parameters ()) {
if (param.direction != ParameterDirection.IN) {
- ccode.add_expression (new CCodeAssignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier (param.name)), new CCodeMemberAccess.pointer (data_var, get_variable_cname (param.name))));
+ ccode.add_assignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier (param.name)), new CCodeMemberAccess.pointer (data_var, get_variable_cname (param.name)));
if (!(param.variable_type is ValueType) || param.variable_type.nullable) {
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (data_var, get_variable_cname (param.name)), new CCodeConstant ("NULL")));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (data_var, get_variable_cname (param.name)), new CCodeConstant ("NULL"));
}
}
}
if (requires_copy (return_type)) {
cexpr = get_ref_cexpression (return_type, cexpr, null, return_type);
}
- ccode.add_expression (new CCodeAssignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("result")), cexpr));
+ ccode.add_assignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("result")), cexpr);
} else if (!(return_type is VoidType)) {
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("result"), new CCodeMemberAccess.pointer (data_var, "result")));
+ ccode.add_assignment (new CCodeIdentifier ("result"), new CCodeMemberAccess.pointer (data_var, "result"));
if (return_type is ArrayType) {
var array_type = (ArrayType) return_type;
if (!m.no_array_length) {
for (int dim = 1; dim <= array_type.rank; dim++) {
- ccode.add_expression (new CCodeAssignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier (get_array_length_cname ("result", dim))), new CCodeMemberAccess.pointer (data_var, get_array_length_cname ("result", dim))));
+ ccode.add_assignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier (get_array_length_cname ("result", dim))), new CCodeMemberAccess.pointer (data_var, get_array_length_cname ("result", dim)));
}
}
} else if (return_type is DelegateType && ((DelegateType) return_type).delegate_symbol.has_target) {
- ccode.add_expression (new CCodeAssignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier (get_delegate_target_cname ("result"))), new CCodeMemberAccess.pointer (data_var, get_delegate_target_cname ("result"))));
+ ccode.add_assignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier (get_delegate_target_cname ("result"))), new CCodeMemberAccess.pointer (data_var, get_delegate_target_cname ("result")));
}
if (!(return_type is ValueType) || return_type.nullable) {
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (data_var, "result"), new CCodeConstant ("NULL")));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (data_var, "result"), new CCodeConstant ("NULL"));
}
ccode.add_return (new CCodeIdentifier ("result"));
}
if (stmt.yield_expression == null) {
int state = next_coroutine_state++;
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (new CCodeIdentifier ("data"), "_state_"), new CCodeConstant (state.to_string ())));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (new CCodeIdentifier ("data"), "_state_"), new CCodeConstant (state.to_string ()));
ccode.add_return (new CCodeConstant ("FALSE"));
ccode.add_label ("_state_%d".printf (state));
ccode.add_statement (new CCodeEmptyStatement ());
if (expr.is_yield_expression) {
int state = next_coroutine_state++;
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (new CCodeIdentifier ("data"), "_state_"), new CCodeConstant (state.to_string ())));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (new CCodeIdentifier ("data"), "_state_"), new CCodeConstant (state.to_string ()));
ccode.add_expression (ccall);
ccode.add_return (new CCodeConstant ("FALSE"));
ccode.add_label ("_state_%d".printf (state));
emit_temp_var (temp_var);
- ccode.add_expression (new CCodeAssignment (temp_ref, ccall));
+ ccode.add_assignment (temp_ref, ccall);
set_cvalue (expr, temp_ref);
}
ccall.add_argument (interface_name);
}
ccall.add_argument (new CCodeConstant ("\"%s\"".printf (method_name)));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("_message"), ccall));
+ ccode.add_assignment (new CCodeIdentifier ("_message"), ccall);
ccode.add_declaration ("GVariant", new CCodeVariableDeclarator ("*_arguments"));
ccode.add_declaration ("GVariantBuilder", new CCodeVariableDeclarator ("_arguments_builder"));
if (uses_fd) {
ccode.add_declaration ("GUnixFDList", new CCodeVariableDeclarator ("*_fd_list"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("_fd_list"), new CCodeFunctionCall (new CCodeIdentifier ("g_unix_fd_list_new"))));
+ ccode.add_assignment (new CCodeIdentifier ("_fd_list"), new CCodeFunctionCall (new CCodeIdentifier ("g_unix_fd_list_new")));
}
CCodeExpression cancellable = new CCodeConstant ("NULL");
var builder_end = new CCodeFunctionCall (new CCodeIdentifier ("g_variant_builder_end"));
builder_end.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_arguments_builder")));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("_arguments"), builder_end));
+ ccode.add_assignment (new CCodeIdentifier ("_arguments"), builder_end);
var set_body = new CCodeFunctionCall (new CCodeIdentifier ("g_dbus_message_set_body"));
set_body.add_argument (new CCodeIdentifier ("_message"));
ccall.add_argument (new CCodeConstant ("NULL"));
ccall.add_argument (cancellable);
ccall.add_argument (new CCodeIdentifier ("error"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("_reply_message"), ccall));
+ ccode.add_assignment (new CCodeIdentifier ("_reply_message"), ccall);
} else if (call_type == CallType.NO_REPLY) {
var set_flags = new CCodeFunctionCall (new CCodeIdentifier ("g_dbus_message_set_flags"));
set_flags.add_argument (new CCodeIdentifier ("_message"));
ccall.add_argument (inner_res);
ccall.add_argument (new CCodeConstant ("error"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("_reply_message"), ccall));
+ ccode.add_assignment (new CCodeIdentifier ("_reply_message"), ccall);
}
if (call_type == CallType.SYNC || call_type == CallType.FINISH) {
ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_dbus_message_get_body"));
ccall.add_argument (new CCodeIdentifier ("_reply_message"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("_reply"), ccall));
+ ccode.add_assignment (new CCodeIdentifier ("_reply"), ccall);
var iter_init = new CCodeFunctionCall (new CCodeIdentifier ("g_variant_iter_init"));
iter_init.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_reply_iter")));
// TODO check that parameter is not NULL (out parameters are optional)
// free value if parameter is NULL
- ccode.add_expression (new CCodeAssignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier (param.name)), target));
+ ccode.add_assignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier (param.name)), target);
if (array_type != null) {
for (int dim = 1; dim <= array_type.rank; dim++) {
// TODO check that parameter is not NULL (out parameters are optional)
- ccode.add_expression (new CCodeAssignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("%s_length%d".printf (param.name, dim))), new CCodeIdentifier ("_%s_length%d".printf (param.name, dim))));
+ ccode.add_assignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("%s_length%d".printf (param.name, dim))), new CCodeIdentifier ("_%s_length%d".printf (param.name, dim)));
}
}
if (array_type != null) {
for (int dim = 1; dim <= array_type.rank; dim++) {
// TODO check that parameter is not NULL (out parameters are optional)
- ccode.add_expression (new CCodeAssignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("result_length%d".printf (dim))), new CCodeIdentifier ("_result_length%d".printf (dim))));
+ ccode.add_assignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("result_length%d".printf (dim))), new CCodeIdentifier ("_result_length%d".printf (dim)));
}
}
var ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_dbus_proxy_get_cached_property"));
ccall.add_argument (new CCodeCastExpression (new CCodeIdentifier ("self"), "GDBusProxy *"));
ccall.add_argument (new CCodeConstant ("\"%s\"".printf (get_dbus_name_for_member (prop))));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("_inner_reply"), ccall));
+ ccode.add_assignment (new CCodeIdentifier ("_inner_reply"), ccall);
// if not successful, retrieve value via D-Bus
ccode.open_if (new CCodeUnaryExpression (CCodeUnaryOperator.LOGICAL_NEGATION, new CCodeIdentifier ("_inner_reply")));
var builder_end = new CCodeFunctionCall (new CCodeIdentifier ("g_variant_builder_end"));
builder_end.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_arguments_builder")));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("_arguments"), builder_end));
+ ccode.add_assignment (new CCodeIdentifier ("_arguments"), builder_end);
ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_dbus_proxy_call_sync"));
ccall.add_argument (new CCodeCastExpression (new CCodeIdentifier ("self"), "GDBusProxy *"));
ccall.add_argument (new CCodeConstant ("NULL"));
ccall.add_argument (new CCodeConstant ("NULL"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("_reply"), ccall));
+ ccode.add_assignment (new CCodeIdentifier ("_reply"), ccall);
// return on error
ccode.open_if (new CCodeUnaryExpression (CCodeUnaryOperator.LOGICAL_NEGATION, new CCodeIdentifier ("_reply")));
if (prop.property_type.is_real_non_null_struct_type ()) {
var target = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("result"));
var result = deserialize_expression (prop.get_accessor.value_type, new CCodeIdentifier ("_inner_reply"), target);
- ccode.add_expression (new CCodeAssignment (target, result));
+ ccode.add_assignment (target, result);
} else {
ccode.add_declaration (prop.get_accessor.value_type.get_cname (), new CCodeVariableDeclarator ("_result"));
}
var result = deserialize_expression (prop.get_accessor.value_type, new CCodeIdentifier ("_inner_reply"), new CCodeIdentifier ("_result"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("_result"), result));
+ ccode.add_assignment (new CCodeIdentifier ("_result"), result);
if (array_type != null) {
for (int dim = 1; dim <= array_type.rank; dim++) {
// TODO check that parameter is not NULL (out parameters are optional)
- ccode.add_expression (new CCodeAssignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("result_length%d".printf (dim))), new CCodeIdentifier ("_result_length%d".printf (dim))));
+ ccode.add_assignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("result_length%d".printf (dim))), new CCodeIdentifier ("_result_length%d".printf (dim)));
}
}
}
var builder_end = new CCodeFunctionCall (new CCodeIdentifier ("g_variant_builder_end"));
builder_end.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_arguments_builder")));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("_arguments"), builder_end));
+ ccode.add_assignment (new CCodeIdentifier ("_arguments"), builder_end);
var ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_dbus_proxy_call_sync"));
ccall.add_argument (new CCodeCastExpression (new CCodeIdentifier ("self"), "GDBusProxy *"));
ccall.add_argument (new CCodeConstant ("NULL"));
ccall.add_argument (new CCodeConstant ("NULL"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("_reply"), ccall));
+ ccode.add_assignment (new CCodeIdentifier ("_reply"), ccall);
// return on error
ccode.open_if (new CCodeUnaryExpression (CCodeUnaryOperator.LOGICAL_NEGATION, new CCodeIdentifier ("_reply")));
get_fd.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_fd_index")));
ccode.add_expression (get_fd);
- ccode.add_expression (new CCodeAssignment (target_expr, stream));
+ ccode.add_assignment (target_expr, stream);
} else {
read_expression (type, iter_expr, target_expr, sym, error_expr, out may_fail);
}
if (m.return_type is VoidType || m.return_type.is_real_non_null_struct_type ()) {
ccode.add_expression (ccall);
} else {
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("result"), ccall));
+ ccode.add_assignment (new CCodeIdentifier ("result"), ccall);
}
if (m.get_error_types ().size > 0) {
ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_dbus_message_new_method_reply"));
ccall.add_argument (message_expr);
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("_reply_message"), ccall));
+ ccode.add_assignment (new CCodeIdentifier ("_reply_message"), ccall);
ccode.add_declaration ("GVariant*", new CCodeVariableDeclarator ("_reply"));
ccode.add_declaration ("GVariantBuilder", new CCodeVariableDeclarator ("_reply_builder"));
if (uses_fd) {
ccode.add_declaration ("GUnixFDList", new CCodeVariableDeclarator ("*_fd_list"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("_fd_list"), new CCodeFunctionCall (new CCodeIdentifier ("g_unix_fd_list_new"))));
+ ccode.add_assignment (new CCodeIdentifier ("_fd_list"), new CCodeFunctionCall (new CCodeIdentifier ("g_unix_fd_list_new")));
}
foreach (Parameter param in m.get_parameters ()) {
var builder_end = new CCodeFunctionCall (new CCodeIdentifier ("g_variant_builder_end"));
builder_end.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_reply_builder")));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("_reply"), builder_end));
+ ccode.add_assignment (new CCodeIdentifier ("_reply"), builder_end);
var set_body = new CCodeFunctionCall (new CCodeIdentifier ("g_dbus_message_set_body"));
set_body.add_argument (new CCodeIdentifier ("_reply_message"));
var builder_end = new CCodeFunctionCall (new CCodeIdentifier ("g_variant_builder_end"));
builder_end.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("_arguments_builder")));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("_arguments"), builder_end));
+ ccode.add_assignment (new CCodeIdentifier ("_arguments"), builder_end);
var ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_dbus_connection_emit_signal"));
ccall.add_argument (new CCodeIdentifier ("_connection"));
ccode.add_expression (ccall);
} else {
ccode.add_declaration (prop.get_accessor.value_type.get_cname (), new CCodeVariableDeclarator ("result"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("result"), ccall));
+ ccode.add_assignment (new CCodeIdentifier ("result"), ccall);
var array_type = prop.get_accessor.value_type as ArrayType;
if (array_type != null) {
var reply_expr = serialize_expression (prop.get_accessor.value_type, new CCodeIdentifier ("result"));
ccode.add_declaration ("GVariant*", new CCodeVariableDeclarator ("_reply"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("_reply"), reply_expr));
+ ccode.add_assignment (new CCodeIdentifier ("_reply"), reply_expr);
if (requires_destroy (prop.get_accessor.value_type)) {
// keep local alive (symbol_reference is weak)
var target = new CCodeIdentifier ("value");
var expr = deserialize_expression (prop.property_type, new CCodeIdentifier ("_value"), target);
- ccode.add_expression (new CCodeAssignment (target, expr));
+ ccode.add_assignment (target, expr);
ccode.add_expression (ccall);
get_qdata.add_argument (quark);
ccode.add_declaration ("void", new CCodeVariableDeclarator ("*func"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("func"), get_qdata));
+ ccode.add_assignment (new CCodeIdentifier ("func"), get_qdata);
ccode.open_if (new CCodeUnaryExpression (CCodeUnaryOperator.LOGICAL_NEGATION, new CCodeIdentifier ("func")));
// no D-Bus interface
emit_temp_var (temp_var);
- ccode.add_expression (new CCodeAssignment (temp_ref, cregister));
+ ccode.add_assignment (temp_ref, cregister);
set_cvalue (expr, temp_ref);
}
}
public override void visit_throw_statement (ThrowStatement stmt) {
// method will fail
current_method_inner_error = true;
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression ("_inner_error_"), get_cvalue (stmt.error_expression)));
+ ccode.add_assignment (get_variable_cexpression ("_inner_error_"), get_cvalue (stmt.error_expression));
add_simple_check (stmt, true);
}
} else {
ccode.add_declaration ("GError *", new CCodeVariableDeclarator (variable_name));
}
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression (variable_name), get_variable_cexpression ("_inner_error_")));
+ ccode.add_assignment (get_variable_cexpression (variable_name), get_variable_cexpression ("_inner_error_"));
} else {
// error object is not used within catch statement, clear it
var cclear = new CCodeFunctionCall (new CCodeIdentifier ("g_clear_error"));
cclear.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_variable_cexpression ("_inner_error_")));
ccode.add_expression (cclear);
}
- ccode.add_expression (new CCodeAssignment (get_variable_cexpression ("_inner_error_"), new CCodeConstant ("NULL")));
+ ccode.add_assignment (get_variable_cexpression ("_inner_error_"), new CCodeConstant ("NULL"));
clause.body.emit (this);
var ccall = new CCodeFunctionCall (new CCodeIdentifier ("G_OBJECT_CLASS"));
ccall.add_argument (new CCodeIdentifier ("klass"));
if (class_has_readable_properties (cl) || cl.get_type_parameters ().size > 0) {
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (ccall, "get_property"), new CCodeIdentifier ("_vala_%s_get_property".printf (cl.get_lower_case_cname (null)))));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (ccall, "get_property"), new CCodeIdentifier ("_vala_%s_get_property".printf (cl.get_lower_case_cname (null))));
}
if (class_has_writable_properties (cl) || cl.get_type_parameters ().size > 0) {
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (ccall, "set_property"), new CCodeIdentifier ("_vala_%s_set_property".printf (cl.get_lower_case_cname (null)))));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (ccall, "set_property"), new CCodeIdentifier ("_vala_%s_set_property".printf (cl.get_lower_case_cname (null))));
}
/* set constructor */
if (cl.constructor != null) {
var ccast = new CCodeFunctionCall (new CCodeIdentifier ("G_OBJECT_CLASS"));
ccast.add_argument (new CCodeIdentifier ("klass"));
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (ccast, "constructor"), new CCodeIdentifier ("%s_constructor".printf (cl.get_lower_case_cname (null)))));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (ccast, "constructor"), new CCodeIdentifier ("%s_constructor".printf (cl.get_lower_case_cname (null))));
}
/* set finalize function */
if (cl.get_fields ().size > 0 || cl.destructor != null) {
var ccast = new CCodeFunctionCall (new CCodeIdentifier ("G_OBJECT_CLASS"));
ccast.add_argument (new CCodeIdentifier ("klass"));
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (ccast, "finalize"), new CCodeIdentifier ("%s_finalize".printf (cl.get_lower_case_cname (null)))));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (ccast, "finalize"), new CCodeIdentifier ("%s_finalize".printf (cl.get_lower_case_cname (null))));
}
/* create type, dup_func, and destroy_func properties for generic types */
var ccast = new CCodeFunctionCall (new CCodeIdentifier ("G_OBJECT_CLASS"));
ccast.add_argument (new CCodeIdentifier ("%s_parent_class".printf (cl.get_lower_case_cname (null))));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("parent_class"), ccast));
+ ccode.add_assignment (new CCodeIdentifier ("parent_class"), ccast);
var ccall = new CCodeFunctionCall (new CCodeMemberAccess.pointer (new CCodeIdentifier ("parent_class"), "constructor"));
ccall.add_argument (new CCodeIdentifier ("type"));
ccall.add_argument (new CCodeIdentifier ("n_construct_properties"));
ccall.add_argument (new CCodeIdentifier ("construct_properties"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("obj"), ccall));
+ ccode.add_assignment (new CCodeIdentifier ("obj"), ccall);
ccall = generate_instance_cast (new CCodeIdentifier ("obj"), cl);
ccode.add_declaration ("%s *".printf (cl.get_cname ()), new CCodeVariableDeclarator ("self"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("self"), ccall));
+ ccode.add_assignment (new CCodeIdentifier ("self"), ccall);
c.body.emit (this);
emit_temp_var (temp_var);
- ccode.add_expression (new CCodeAssignment (temp_ref, ccall));
+ ccode.add_assignment (temp_ref, ccall);
return temp_ref;
}
var ccast = new CCodeFunctionCall (new CCodeIdentifier ("%s_CLASS".printf (((Class) base_type).get_upper_case_cname (null))));
ccast.add_argument (new CCodeIdentifier ("klass"));
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (ccast, m.base_method.vfunc_name), new CCodeIdentifier (m.get_real_cname ())));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (ccast, m.base_method.vfunc_name), new CCodeIdentifier (m.get_real_cname ()));
if (m.coroutine) {
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (ccast, m.base_method.get_finish_vfunc_name ()), new CCodeIdentifier (m.get_finish_real_cname ())));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (ccast, m.base_method.get_finish_vfunc_name ()), new CCodeIdentifier (m.get_finish_real_cname ()));
}
}
}
}
var ccast = new CCodeFunctionCall (new CCodeIdentifier ("%s_CLASS".printf (cl.get_upper_case_cname (null))));
ccast.add_argument (new CCodeIdentifier ("klass"));
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (ccast, sig.default_handler.vfunc_name), new CCodeIdentifier (sig.default_handler.get_real_cname ())));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (ccast, sig.default_handler.vfunc_name), new CCodeIdentifier (sig.default_handler.get_real_cname ()));
}
/* connect overridden properties */
if (prop.get_accessor != null) {
string cname = "%s_real_get_%s".printf (cl.get_lower_case_cname (null), prop.name);
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (ccast, "get_%s".printf (prop.name)), new CCodeIdentifier (cname)));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (ccast, "get_%s".printf (prop.name)), new CCodeIdentifier (cname));
}
if (prop.set_accessor != null) {
string cname = "%s_real_set_%s".printf (cl.get_lower_case_cname (null), prop.name);
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (ccast, "set_%s".printf (prop.name)), new CCodeIdentifier (cname)));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (ccast, "set_%s".printf (prop.name)), new CCodeIdentifier (cname));
}
}
if (!cl.is_compact && (cl.has_private_fields || cl.get_type_parameters ().size > 0)) {
var ccall = new CCodeFunctionCall (new CCodeIdentifier ("%s_GET_PRIVATE".printf (cl.get_upper_case_cname (null))));
ccall.add_argument (new CCodeIdentifier ("self"));
- func.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (new CCodeIdentifier ("self"), "priv"), ccall));
+ func.add_assignment (new CCodeMemberAccess.pointer (new CCodeIdentifier ("self"), "priv"), ccall);
}
pop_context ();
CCodeFunctionCall ccall = generate_instance_cast (new CCodeIdentifier ("obj"), cl);
ccode.add_declaration ("%s *".printf (cl.get_cname ()), new CCodeVariableDeclarator ("self"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("self"), ccall));
+ ccode.add_assignment (new CCodeIdentifier ("self"), ccall);
} else {
var function = new CCodeFunction (cl.get_lower_case_cprefix () + "free", "void");
if (cl.access == SymbolAccessibility.PRIVATE) {
ccode.add_declaration (bool_type.get_cname (), new CCodeVariableDeclarator ("initialized", new CCodeConstant ("FALSE")), CCodeModifiers.STATIC);
ccode.open_if (new CCodeUnaryExpression (CCodeUnaryOperator.LOGICAL_NEGATION, new CCodeIdentifier ("initialized")));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("initialized"), new CCodeConstant ("TRUE")));
+ ccode.add_assignment (new CCodeIdentifier ("initialized"), new CCodeConstant ("TRUE"));
if (iface.is_subtype_of (gobject_type)) {
/* create properties */
if (m.is_virtual) {
var ciface = new CCodeIdentifier ("iface");
var cname = m.get_real_cname ();
- ccode.add_expression (new CCodeAssignment (new CCodeMemberAccess.pointer (ciface, m.vfunc_name), new CCodeIdentifier (cname)));
+ ccode.add_assignment (new CCodeMemberAccess.pointer (ciface, m.vfunc_name), new CCodeIdentifier (cname));
}
}
// NULL terminate array
var length = new CCodeIdentifier (temp_name + "_length");
var element_access = new CCodeElementAccess (new CCodeIdentifier (temp_name), length);
- ccode.add_expression (new CCodeAssignment (element_access, new CCodeIdentifier ("NULL")));
+ ccode.add_assignment (element_access, new CCodeIdentifier ("NULL"));
}
return new CCodeIdentifier (temp_name);
// tmp_size = (2 * tmp_size);
var new_size = new CCodeBinaryExpression (CCodeBinaryOperator.MUL, new CCodeConstant ("2"), new CCodeIdentifier (temp_name + "_size"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier (temp_name + "_size"), new_size));
+ ccode.add_assignment (new CCodeIdentifier (temp_name + "_size"), new_size);
var renew_call = new CCodeFunctionCall (new CCodeIdentifier ("g_renew"));
renew_call.add_argument (new CCodeIdentifier (array_type.element_type.get_cname ()));
renew_call.add_argument (new CCodeIdentifier (temp_name));
// add one extra element for NULL-termination
renew_call.add_argument (new CCodeBinaryExpression (CCodeBinaryOperator.PLUS, new CCodeIdentifier (temp_name + "_size"), new CCodeConstant ("1")));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier (temp_name), renew_call));
+ ccode.add_assignment (new CCodeIdentifier (temp_name), renew_call);
ccode.close ();
var element_access = new CCodeElementAccess (new CCodeIdentifier (temp_name), new CCodeUnaryExpression (CCodeUnaryOperator.POSTFIX_INCREMENT, new CCodeIdentifier (temp_name + "_length")));
var element_expr = deserialize_expression (array_type.element_type, new CCodeIdentifier (element_name), null);
- ccode.add_expression (new CCodeAssignment (element_access, element_expr));
+ ccode.add_assignment (element_access, element_expr);
}
var unref = new CCodeFunctionCall (new CCodeIdentifier ("g_variant_unref"));
ccode.close ();
if (expr != null) {
- ccode.add_expression (new CCodeAssignment (get_array_length (expr, dim), new CCodeIdentifier ("%s_length%d".printf (temp_name, dim))));
+ ccode.add_assignment (get_array_length (expr, dim), new CCodeIdentifier ("%s_length%d".printf (temp_name, dim)));
}
}
} else {
hash_table_new.add_argument (new CCodeIdentifier ("NULL"));
}
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier (temp_name), hash_table_new));
+ ccode.add_assignment (new CCodeIdentifier (temp_name), hash_table_new);
var iter_call = new CCodeFunctionCall (new CCodeIdentifier ("g_variant_iter_init"));
iter_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (subiter_name)));
if (sym != null && get_dbus_signature (sym) != null) {
// raw GVariant
- ccode.add_expression (new CCodeAssignment (target_expr, iter_call));
+ ccode.add_assignment (target_expr, iter_call);
return;
}
var variant_expr = new CCodeIdentifier (temp_name);
- ccode.add_expression (new CCodeAssignment (variant_expr, iter_call));
+ ccode.add_assignment (variant_expr, iter_call);
var result = deserialize_expression (type, variant_expr, target_expr, error_expr, out may_fail);
if (result == null) {
return;
}
- ccode.add_expression (new CCodeAssignment (target_expr, result));
+ ccode.add_assignment (target_expr, result);
var unref = new CCodeFunctionCall (new CCodeIdentifier ("g_variant_unref"));
unref.add_argument (variant_expr);
string array_iter_name = "_tmp%d_".printf (next_temp_var_id++);
ccode.add_declaration (array_type.get_cname (), new CCodeVariableDeclarator (array_iter_name));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier (array_iter_name), array_expr));
+ ccode.add_assignment (new CCodeIdentifier (array_iter_name), array_expr);
return serialize_array_dim (array_type, 1, array_expr, new CCodeIdentifier (array_iter_name));
}
ccode.add_declaration (key_type.get_cname (), new CCodeVariableDeclarator ("_key"));
ccode.add_declaration (value_type.get_cname (), new CCodeVariableDeclarator ("_value"));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("_key"), convert_from_generic_pointer (new CCodeIdentifier (key_name), key_type)));
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("_value"), convert_from_generic_pointer (new CCodeIdentifier (value_name), value_type)));
+ ccode.add_assignment (new CCodeIdentifier ("_key"), convert_from_generic_pointer (new CCodeIdentifier (key_name), key_type));
+ ccode.add_assignment (new CCodeIdentifier ("_value"), convert_from_generic_pointer (new CCodeIdentifier (value_name), value_type));
var serialized_key = serialize_expression (key_type, new CCodeIdentifier ("_key"));
var serialized_value = serialize_expression (value_type, new CCodeIdentifier ("_value"));
projects / thirdparty / vala.git / commitdiff
