if (rank > 1) {
append_initializer_list (ce, name_cnode, (InitializerList) e, rank - 1, ref i);
} else {
- ce.append_expression (new CCodeAssignment (new CCodeElementAccess (name_cnode, new CCodeConstant (i.to_string ())), (CCodeExpression) e.ccodenode));
+ ce.append_expression (new CCodeAssignment (new CCodeElementAccess (name_cnode, new CCodeConstant (i.to_string ())), get_cvalue (e)));
i++;
}
}
ce.append_expression (name_cnode);
- expr.ccodenode = ce;
+ set_cvalue (expr, ce);
return;
}
// iterate over each dimension
foreach (Expression size in expr.get_sizes ()) {
- CCodeExpression csize = (CCodeExpression) size.ccodenode;
+ CCodeExpression csize = get_cvalue (size);
if (!is_pure_ccode_expression (csize)) {
var temp_var = get_temp_variable (int_type, false, expr);
var name_cnode = get_variable_cexpression (temp_var.name);
- size.ccodenode = name_cnode;
+ set_cvalue (size, name_cnode);
emit_temp_var (temp_var);
ce.append_expression (name_cnode);
- expr.ccodenode = ce;
+ set_cvalue (expr, ce);
} else {
- expr.ccodenode = gnew;
+ set_cvalue (expr, gnew);
}
}
List<Expression> indices = expr.get_indices ();
int rank = indices.size;
- var ccontainer = (CCodeExpression) expr.container.ccodenode;
- var cindex = (CCodeExpression) indices[0].ccodenode;
+ var ccontainer = get_cvalue (expr.container);
+ var cindex = get_cvalue (indices[0]);
if (expr.container.symbol_reference is ArrayLengthField) {
/* Figure if cindex is a constant expression and calculate dim...*/
var lit = indices[0] as IntegerLiteral;
var memberaccess = expr.container as MemberAccess;
if (lit != null && memberaccess != null) {
int dim = lit.value.to_int ();
- expr.ccodenode = get_array_length_cexpression (memberaccess.inner, dim + 1);
+ set_cvalue (expr, get_array_length_cexpression (memberaccess.inner, dim + 1));
} else {
Report.error (expr.source_reference, "only integer literals supported as index");
}
// access to element in an array
for (int i = 1; i < rank; i++) {
var cmul = new CCodeBinaryExpression (CCodeBinaryOperator.MUL, cindex, get_array_length_cexpression (expr.container, i + 1));
- cindex = new CCodeBinaryExpression (CCodeBinaryOperator.PLUS, cmul, (CCodeExpression) indices[i].ccodenode);
+ cindex = new CCodeBinaryExpression (CCodeBinaryOperator.PLUS, cmul, get_cvalue (indices[i]));
}
- expr.ccodenode = new CCodeElementAccess (ccontainer, cindex);
+ set_cvalue (expr, new CCodeElementAccess (ccontainer, cindex));
}
}
public override void visit_slice_expression (SliceExpression expr) {
- var ccontainer = (CCodeExpression) expr.container.ccodenode;
- var cstart = (CCodeExpression) expr.start.ccodenode;
- var cstop = (CCodeExpression) expr.stop.ccodenode;
+ var ccontainer = get_cvalue (expr.container);
+ var cstart = get_cvalue (expr.start);
+ var cstop = get_cvalue (expr.stop);
var ccomma = new CCodeCommaExpression ();
ccomma.append_expression (get_variable_cexpression (slice_var.name));
- expr.ccodenode = ccomma;
+ set_cvalue (expr, ccomma);
expr.append_array_size (get_variable_cexpression (len_var.name));
}
var value_param = new FormalParameter ("value", element.target_type);
var ccall = new CCodeFunctionCall (new CCodeIdentifier (generate_array_add_wrapper (array_type)));
- ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, (CCodeExpression) array.ccodenode));
+ ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_cvalue (array)));
ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_array_length_cexpression (array)));
ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_array_size_cexpression (array)));
- ccall.add_argument (handle_struct_argument (value_param, element, (CCodeExpression) element.ccodenode));
+ ccall.add_argument (handle_struct_argument (value_param, element, get_cvalue (element)));
- assignment.ccodenode = ccall;
+ set_cvalue (assignment, ccall);
var array_var = assignment.left.symbol_reference;
var array_local = array_var as LocalVariable;
}
}
- CCodeExpression cexpr = (CCodeExpression) assignment.right.ccodenode;
+ CCodeExpression cexpr = get_cvalue (assignment.right);
if (!prop.no_accessor_method) {
if (prop.property_type.is_real_non_null_struct_type ()) {
}
CCodeExpression emit_simple_assignment (Assignment assignment) {
- CCodeExpression rhs = (CCodeExpression) assignment.right.ccodenode;
+ CCodeExpression rhs = get_cvalue (assignment.right);
CCodeExpression lhs = (CCodeExpression) get_ccodenode (assignment.left);
CCodeCommaExpression outer_ccomma = null;
}
CCodeExpression emit_fixed_length_array_assignment (Assignment assignment, ArrayType array_type) {
- CCodeExpression rhs = (CCodeExpression) assignment.right.ccodenode;
+ CCodeExpression rhs = get_cvalue (assignment.right);
CCodeExpression lhs = (CCodeExpression) get_ccodenode (assignment.left);
cfile.add_include ("string.h");
}
if (assignment.left.symbol_reference is Property) {
- assignment.ccodenode = emit_property_assignment (assignment);
+ set_cvalue (assignment, emit_property_assignment (assignment));
} else {
var array_type = assignment.left.value_type as ArrayType;
if (array_type != null && array_type.fixed_length) {
- assignment.ccodenode = emit_fixed_length_array_assignment (assignment, array_type);
+ set_cvalue (assignment, emit_fixed_length_array_assignment (assignment, array_type));
} else {
- assignment.ccodenode = emit_simple_assignment (assignment);
+ set_cvalue (assignment, emit_simple_assignment (assignment));
}
}
}
}
} else {
ev.value.emit (this);
- c_ev = new CCodeEnumValue (ev.get_cname (), (CCodeExpression) ev.value.ccodenode);
+ c_ev = new CCodeEnumValue (ev.get_cname (), get_cvalue (ev.value));
}
c_ev.deprecated = ev.deprecated;
cenum.add_value (c_ev);
arr = "[%d]".printf (initializer_list.size);
}
- var cinitializer = (CCodeExpression) c.value.ccodenode;
+ var cinitializer = get_cvalue (c.value);
if (!definition) {
// never output value in header
// special case needed as this method combines declaration and definition
decl_space.add_constant_declaration (cdecl);
} else {
- var cdefine = new CCodeMacroReplacement.with_expression (c.get_cname (), (CCodeExpression) c.value.ccodenode);
+ var cdefine = new CCodeMacroReplacement.with_expression (c.get_cname (), get_cvalue (c.value));
decl_space.add_type_member_declaration (cdefine);
}
}
f.initializer.emit (this);
- var rhs = (CCodeExpression) f.initializer.ccodenode;
+ var rhs = get_cvalue (f.initializer);
ccode.add_expression (new CCodeAssignment (lhs, rhs));
var array_type = (ArrayType) f.variable_type;
var this_access = new MemberAccess.simple ("this");
this_access.value_type = get_data_type_for_symbol ((TypeSymbol) f.parent_symbol);
- this_access.ccodenode = new CCodeIdentifier ("self");
+ set_cvalue (this_access, new CCodeIdentifier ("self"));
var ma = new MemberAccess (this_access, f.name);
ma.symbol_reference = f;
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, (CCodeExpression) size.ccodenode));
+ ccode.add_expression (new CCodeAssignment (array_len_lhs, get_cvalue (size)));
}
if (array_type.rank == 1 && f.is_internal_symbol ()) {
var field_st = f.parent_symbol as Struct;
if (field_st != null && !field_st.is_simple_type ()) {
- this_access.ccodenode = new CCodeIdentifier ("(*self)");
+ set_cvalue (this_access, new CCodeIdentifier ("(*self)"));
} else {
- this_access.ccodenode = new CCodeIdentifier ("self");
+ set_cvalue (this_access, new CCodeIdentifier ("self"));
}
var ma = new MemberAccess (this_access, f.name);
f.initializer.emit (this);
- var rhs = (CCodeExpression) f.initializer.ccodenode;
+ var rhs = get_cvalue (f.initializer);
ccode.add_expression (new CCodeAssignment (lhs, rhs));
if (f.initializer != null) {
f.initializer.emit (this);
- var init = (CCodeExpression) f.initializer.ccodenode;
+ var init = get_cvalue (f.initializer);
if (is_constant_ccode_expression (init)) {
var_decl.initializer = init;
}
}
if (f.initializer != null) {
- var rhs = (CCodeExpression) f.initializer.ccodenode;
+ var rhs = get_cvalue (f.initializer);
if (!is_constant_ccode_expression (rhs)) {
if (f.parent_symbol is Class) {
if (f.initializer is InitializerList) {
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, (CCodeExpression) size.ccodenode));
+ ccode.add_expression (new CCodeAssignment (array_len_lhs, get_cvalue (size)));
}
}
} else {
}
CCodeExpression rhs = null;
- if (local.initializer != null && local.initializer.ccodenode != null) {
+ if (local.initializer != null && get_cvalue (local.initializer) != null) {
var ma = new MemberAccess.simple (local.name);
ma.symbol_reference = local;
ma.value_type = local.variable_type.copy ();
- rhs = (CCodeExpression) local.initializer.ccodenode;
+ rhs = get_cvalue (local.initializer);
if (local.variable_type is ArrayType) {
var array_type = (ArrayType) local.variable_type;
var ccopy = new CCodeFunctionCall (new CCodeIdentifier ("memcpy"));
ccopy.add_argument (get_variable_cexpression (local.name));
- ccopy.add_argument ((CCodeExpression) local.initializer.ccodenode);
+ ccopy.add_argument (get_cvalue (local.initializer));
ccopy.add_argument (size);
ccode.add_expression (ccopy);
}
}
}
- var cexpr = (CCodeExpression) expr.ccodenode;
+ var cexpr = get_cvalue (expr);
string ctype = field.get_ctype ();
if (ctype != null) {
clist.append (cexpr);
}
- list.ccodenode = clist;
+ set_cvalue (list, clist);
} else {
// used as expression
var temp_decl = get_temp_variable (list.target_type, false, list);
}
}
- var cexpr = (CCodeExpression) expr.ccodenode;
+ var cexpr = get_cvalue (expr);
string ctype = field.get_ctype ();
if (ctype != null) {
}
ccomma.append_expression (instance);
- list.ccodenode = ccomma;
+ set_cvalue (list, ccomma);
}
} else {
var clist = new CCodeInitializerList ();
foreach (Expression expr in list.get_initializers ()) {
- clist.append ((CCodeExpression) expr.ccodenode);
+ clist.append (get_cvalue (expr));
}
- list.ccodenode = clist;
+ set_cvalue (list, clist);
}
}
var local_decl = expr.parent_node as LocalVariable;
if (local_decl != null && has_simple_struct_initializer (local_decl)) {
- expr_list.append_expression ((CCodeExpression) expr.ccodenode);
+ expr_list.append_expression (get_cvalue (expr));
} else {
var expr_type = expr.value_type;
if (expr.target_type != null) {
full_expr_var = get_temp_variable (expr_type, true, expr, false);
emit_temp_var (full_expr_var);
- expr_list.append_expression (new CCodeAssignment (get_variable_cexpression (full_expr_var.name), (CCodeExpression) expr.ccodenode));
+ expr_list.append_expression (new CCodeAssignment (get_variable_cexpression (full_expr_var.name), get_cvalue (expr)));
}
foreach (LocalVariable local in temp_ref_vars) {
expr_list.append_expression (get_variable_cexpression (full_expr_var.name));
}
- expr.ccodenode = expr_list;
+ set_cvalue (expr, expr_list);
temp_ref_vars.clear ();
}
return;
}
- ccode.add_expression ((CCodeExpression) stmt.expression.ccodenode);
+ ccode.add_expression (get_cvalue (stmt.expression));
/* free temporary objects and handle errors */
var return_expr_decl = get_temp_variable (stmt.return_expression.value_type, true, stmt, false);
var ccomma = new CCodeCommaExpression ();
- ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (return_expr_decl.name), (CCodeExpression) stmt.return_expression.ccodenode));
+ ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (return_expr_decl.name), get_cvalue (stmt.return_expression)));
var array_type = (ArrayType) current_return_type;
ccomma.append_expression (get_variable_cexpression (return_expr_decl.name));
- stmt.return_expression.ccodenode = ccomma;
+ set_cvalue (stmt.return_expression, ccomma);
emit_temp_var (return_expr_decl);
} else if ((current_method != null || current_property_accessor != null) && current_return_type is DelegateType) {
var delegate_type = (DelegateType) current_return_type;
var return_expr_decl = get_temp_variable (stmt.return_expression.value_type, true, stmt, false);
var ccomma = new CCodeCommaExpression ();
- ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (return_expr_decl.name), (CCodeExpression) stmt.return_expression.ccodenode));
+ ccomma.append_expression (new CCodeAssignment (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) {
ccomma.append_expression (get_variable_cexpression (return_expr_decl.name));
- stmt.return_expression.ccodenode = ccomma;
+ set_cvalue (stmt.return_expression, ccomma);
emit_temp_var (return_expr_decl);
}
}
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, (CCodeExpression) stmt.return_expression.ccodenode));
+ ccode.add_expression (new CCodeAssignment (result_lhs, get_cvalue (stmt.return_expression)));
}
// free local variables
if (inner_node == null) {
l = new CCodeIdentifier ("self");
} else if (resource.symbol_reference.parent_symbol != current_type_symbol) {
- l = generate_instance_cast ((CCodeExpression) inner_node.ccodenode, parent);
+ l = generate_instance_cast (get_cvalue (inner_node), parent);
} else {
- l = (CCodeExpression) inner_node.ccodenode;
+ l = get_cvalue (inner_node);
}
l = new CCodeMemberAccess.pointer (new CCodeMemberAccess.pointer (l, "priv"), get_symbol_lock_name (resource.symbol_reference.name));
}
var ccall = new CCodeFunctionCall (get_destroy_func_expression (type));
- ccall.add_argument ((CCodeExpression) stmt.expression.ccodenode);
+ ccall.add_argument (get_cvalue (stmt.expression));
ccode.add_expression (ccall);
}
public override void visit_expression (Expression expr) {
- if (expr.ccodenode != null && !expr.lvalue) {
+ if (get_cvalue (expr) != null && !expr.lvalue) {
if (expr.formal_value_type is GenericType && !(expr.value_type is GenericType)) {
var st = expr.formal_value_type.type_parameter.parent_symbol.parent_symbol as Struct;
if (expr.formal_value_type.type_parameter.parent_symbol != garray_type &&
(st == null || st.get_cname () != "va_list")) {
// GArray and va_list don't use pointer-based generics
- expr.ccodenode = convert_from_generic_pointer ((CCodeExpression) expr.ccodenode, expr.value_type);
+ set_cvalue (expr, convert_from_generic_pointer (get_cvalue (expr), expr.value_type));
}
}
// memory management, implicit casts, and boxing/unboxing
- expr.ccodenode = transform_expression ((CCodeExpression) expr.ccodenode, expr.value_type, expr.target_type, expr);
+ set_cvalue (expr, transform_expression (get_cvalue (expr), expr.value_type, expr.target_type, expr));
if (expr.formal_target_type is GenericType && !(expr.target_type is GenericType)) {
if (expr.formal_target_type.type_parameter.parent_symbol != garray_type) {
// GArray doesn't use pointer-based generics
- expr.ccodenode = convert_to_generic_pointer ((CCodeExpression) expr.ccodenode, expr.target_type);
+ set_cvalue (expr, convert_to_generic_pointer (get_cvalue (expr), expr.target_type));
}
}
}
public override void visit_boolean_literal (BooleanLiteral expr) {
if (context.profile == Profile.GOBJECT) {
- expr.ccodenode = new CCodeConstant (expr.value ? "TRUE" : "FALSE");
+ set_cvalue (expr, new CCodeConstant (expr.value ? "TRUE" : "FALSE"));
} else {
cfile.add_include ("stdbool.h");
- expr.ccodenode = new CCodeConstant (expr.value ? "true" : "false");
+ set_cvalue (expr, new CCodeConstant (expr.value ? "true" : "false"));
}
}
public override void visit_character_literal (CharacterLiteral expr) {
if (expr.get_char () >= 0x20 && expr.get_char () < 0x80) {
- expr.ccodenode = new CCodeConstant (expr.value);
+ set_cvalue (expr, new CCodeConstant (expr.value));
} else {
- expr.ccodenode = new CCodeConstant ("%uU".printf (expr.get_char ()));
+ set_cvalue (expr, new CCodeConstant ("%uU".printf (expr.get_char ())));
}
}
public override void visit_integer_literal (IntegerLiteral expr) {
- expr.ccodenode = new CCodeConstant (expr.value + expr.type_suffix);
+ set_cvalue (expr, new CCodeConstant (expr.value + expr.type_suffix));
}
public override void visit_real_literal (RealLiteral expr) {
c_literal += ".";
}
}
- expr.ccodenode = new CCodeConstant (c_literal);
+ set_cvalue (expr, new CCodeConstant (c_literal));
}
public override void visit_string_literal (StringLiteral expr) {
- expr.ccodenode = new CCodeConstant.string (expr.value.replace ("\n", "\\n"));
+ set_cvalue (expr, new CCodeConstant.string (expr.value.replace ("\n", "\\n")));
}
public override void visit_regex_literal (RegexLiteral expr) {
var regex_const = new CCodeConstant ("_thread_safe_regex_init (&%s, \"%s\", %s)".printf (cname, re, flags));
cfile.add_constant_declaration (cdecl);
- expr.ccodenode = regex_const;
+ set_cvalue (expr, regex_const);
}
public override void visit_null_literal (NullLiteral expr) {
if (context.profile != Profile.GOBJECT) {
cfile.add_include ("stddef.h");
}
- expr.ccodenode = new CCodeConstant ("NULL");
+ set_cvalue (expr, new CCodeConstant ("NULL"));
}
public virtual string get_delegate_target_cname (string delegate_cname) {
this_access = new CCodeIdentifier ("self");
}
- expr.ccodenode = generate_instance_cast (this_access, expr.value_type.data_type);
+ set_cvalue (expr, generate_instance_cast (this_access, expr.value_type.data_type));
}
public override void visit_postfix_expression (PostfixExpression expr) {
// assign current value to temp variable
var temp_decl = get_temp_variable (prop.property_type, true, expr, false);
emit_temp_var (temp_decl);
- ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (temp_decl.name), (CCodeExpression) expr.inner.ccodenode));
+ ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (temp_decl.name), get_cvalue (expr.inner)));
// increment/decrement property
var op = expr.increment ? CCodeBinaryOperator.PLUS : CCodeBinaryOperator.MINUS;
// return previous value
ccomma.append_expression (get_variable_cexpression (temp_decl.name));
- expr.ccodenode = ccomma;
+ set_cvalue (expr, ccomma);
return;
}
var op = expr.increment ? CCodeUnaryOperator.POSTFIX_INCREMENT : CCodeUnaryOperator.POSTFIX_DECREMENT;
- expr.ccodenode = new CCodeUnaryExpression (op, (CCodeExpression) expr.inner.ccodenode);
+ set_cvalue (expr, new CCodeUnaryExpression (op, get_cvalue (expr.inner)));
}
private MemberAccess? find_property_access (Expression expr) {
if (!(expression_type is ArrayType) && expr != null && expr.is_non_null ()
&& !is_ref_function_void (expression_type)) {
// expression is non-null
- ccall.add_argument ((CCodeExpression) expr.ccodenode);
+ ccall.add_argument (get_cvalue (expr));
return ccall;
} else {
} else if (expr.type_reference.data_type == glist_type ||
expr.type_reference.data_type == gslist_type) {
// NULL is an empty list
- expr.ccodenode = new CCodeConstant ("NULL");
+ set_cvalue (expr, new CCodeConstant ("NULL"));
} else if (expr.symbol_reference is Method) {
// use creation method
var m = (Method) expr.symbol_reference;
int arg_pos;
Iterator<FormalParameter> params_it = params.iterator ();
foreach (Expression arg in expr.get_argument_list ()) {
- CCodeExpression cexpr = (CCodeExpression) arg.ccodenode;
+ CCodeExpression cexpr = get_cvalue (arg);
FormalParameter param = null;
if (params_it.next ()) {
param = params_it.get ();
* parameter yet */
param.initializer.emit (this);
- carg_map.set (get_param_pos (param.cparameter_position), (CCodeExpression) param.initializer.ccodenode);
+ carg_map.set (get_param_pos (param.cparameter_position), get_cvalue (param.initializer));
i++;
}
creation_call.add_argument (new CCodeIdentifier (ecode.get_cname ()));
foreach (Expression arg in expr.get_argument_list ()) {
- creation_call.add_argument ((CCodeExpression) arg.ccodenode);
+ creation_call.add_argument (get_cvalue (arg));
}
creation_expr = creation_call;
var local = expr.parent_node as LocalVariable;
if (local != null && has_simple_struct_initializer (local)) {
// no comma expression necessary
- expr.ccodenode = creation_expr;
+ set_cvalue (expr, creation_expr);
} else if (instance != null) {
var ccomma = new CCodeCommaExpression ();
} else {
lhs = new CCodeMemberAccess.pointer (typed_inst, f.get_cname ());
}
- ccomma.append_expression (new CCodeAssignment (lhs, (CCodeExpression) init.initializer.ccodenode));
+ ccomma.append_expression (new CCodeAssignment (lhs, get_cvalue (init.initializer)));
if (f.variable_type is ArrayType && !f.no_array_length) {
var array_type = (ArrayType) f.variable_type;
} else if (init.symbol_reference is Property) {
var inst_ma = new MemberAccess.simple ("new");
inst_ma.value_type = expr.type_reference;
- inst_ma.ccodenode = instance;
+ set_cvalue (inst_ma, instance);
var ma = new MemberAccess (inst_ma, init.name);
- ccomma.append_expression (get_property_set_call ((Property) init.symbol_reference, ma, (CCodeExpression) init.initializer.ccodenode));
+ ccomma.append_expression (get_property_set_call ((Property) init.symbol_reference, ma, get_cvalue (init.initializer)));
}
}
ccomma.append_expression (instance);
- expr.ccodenode = ccomma;
+ set_cvalue (expr, ccomma);
} else if (creation_expr != null) {
- expr.ccodenode = creation_expr;
+ set_cvalue (expr, creation_expr);
}
}
var csizeof = new CCodeFunctionCall (new CCodeIdentifier ("sizeof"));
csizeof.add_argument (new CCodeIdentifier (expr.type_reference.get_cname ()));
- expr.ccodenode = csizeof;
+ set_cvalue (expr, csizeof);
}
public override void visit_typeof_expression (TypeofExpression expr) {
- expr.ccodenode = get_type_id_expression (expr.type_reference);
+ set_cvalue (expr, get_type_id_expression (expr.type_reference));
}
public override void visit_unary_expression (UnaryExpression expr) {
} else {
assert_not_reached ();
}
- expr.ccodenode = new CCodeUnaryExpression (op, (CCodeExpression) expr.inner.ccodenode);
+ set_cvalue (expr, new CCodeUnaryExpression (op, get_cvalue (expr.inner)));
}
public CCodeExpression? try_cast_value_to_type (CCodeExpression ccodeexpr, DataType from, DataType to, Expression? expr = null) {
}
public override void visit_cast_expression (CastExpression expr) {
- var valuecast = try_cast_value_to_type ((CCodeExpression) expr.inner.ccodenode, expr.inner.value_type, expr.type_reference, expr);
+ var valuecast = try_cast_value_to_type (get_cvalue (expr.inner), expr.inner.value_type, expr.type_reference, expr);
if (valuecast != null) {
- expr.ccodenode = valuecast;
+ set_cvalue (expr, valuecast);
return;
}
- var variantcast = try_cast_variant_to_type ((CCodeExpression) expr.inner.ccodenode, expr.inner.value_type, expr.type_reference, expr);
+ var variantcast = try_cast_variant_to_type (get_cvalue (expr.inner), expr.inner.value_type, expr.type_reference, expr);
if (variantcast != null) {
- expr.ccodenode = variantcast;
+ set_cvalue (expr, variantcast);
return;
}
emit_temp_var (temp_decl);
var ctemp = get_variable_cexpression (temp_decl.name);
- var cinit = new CCodeAssignment (ctemp, (CCodeExpression) expr.inner.ccodenode);
+ var cinit = new CCodeAssignment (ctemp, get_cvalue (expr.inner));
var ccheck = create_type_check (ctemp, expr.type_reference);
var ccast = new CCodeCastExpression (ctemp, expr.type_reference.get_cname ());
var cnull = new CCodeConstant ("NULL");
ccomma.append_expression (cinit);
ccomma.append_expression (new CCodeConditionalExpression (ccheck, ccast, cnull));
- expr.ccodenode = ccomma;
+ set_cvalue (expr, ccomma);
} else {
- expr.ccodenode = generate_instance_cast ((CCodeExpression) expr.inner.ccodenode, expr.type_reference.data_type);
+ set_cvalue (expr, generate_instance_cast (get_cvalue (expr.inner), expr.type_reference.data_type));
}
} else {
if (expr.is_silent_cast) {
}
}
- var innercexpr = (CCodeExpression) expr.inner.ccodenode;
+ var innercexpr = get_cvalue (expr.inner);
if (expr.type_reference.data_type is Struct && !expr.type_reference.nullable &&
expr.inner.value_type.data_type is Struct && expr.inner.value_type.nullable) {
// nullable integer or float or boolean or struct cast to non-nullable
innercexpr = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, innercexpr);
}
- expr.ccodenode = new CCodeCastExpression (innercexpr, expr.type_reference.get_cname ());
+ set_cvalue (expr, new CCodeCastExpression (innercexpr, expr.type_reference.get_cname ()));
}
}
public override void visit_named_argument (NamedArgument expr) {
- expr.ccodenode = expr.inner.ccodenode;
+ set_cvalue (expr, get_cvalue (expr.inner));
}
public override void visit_pointer_indirection (PointerIndirection expr) {
- expr.ccodenode = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, (CCodeExpression) expr.inner.ccodenode);
+ set_cvalue (expr, new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, get_cvalue (expr.inner)));
}
public override void visit_addressof_expression (AddressofExpression expr) {
- if (expr.inner.ccodenode is CCodeCommaExpression) {
- var ccomma = expr.inner.ccodenode as CCodeCommaExpression;
+ if (get_cvalue (expr.inner) is CCodeCommaExpression) {
+ var ccomma = get_cvalue (expr.inner) as CCodeCommaExpression;
var inner = ccomma.get_inner ();
var last = inner.get (inner.size - 1);
ccomma.set_expression (inner.size - 1, new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, (CCodeExpression) last));
- expr.ccodenode = ccomma;
+ set_cvalue (expr, ccomma);
} else {
- expr.ccodenode = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, (CCodeExpression) expr.inner.ccodenode);
+ set_cvalue (expr, new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_cvalue (expr.inner)));
}
}
emit_temp_var (temp_decl);
var cvar = get_variable_cexpression (temp_decl.name);
- ccomma.append_expression (new CCodeAssignment (cvar, (CCodeExpression) expr.inner.ccodenode));
- ccomma.append_expression (new CCodeAssignment ((CCodeExpression) expr.inner.ccodenode, new CCodeConstant ("NULL")));
+ ccomma.append_expression (new CCodeAssignment (cvar, get_cvalue (expr.inner)));
+ ccomma.append_expression (new CCodeAssignment (get_cvalue (expr.inner), new CCodeConstant ("NULL")));
ccomma.append_expression (cvar);
- expr.ccodenode = ccomma;
+ set_cvalue (expr, ccomma);
}
public override void visit_binary_expression (BinaryExpression expr) {
- var cleft = (CCodeExpression) expr.left.ccodenode;
- var cright = (CCodeExpression) expr.right.ccodenode;
+ var cleft = get_cvalue (expr.left);
+ var cright = get_cvalue (expr.right);
CCodeExpression? left_chain = null;
if (expr.chained) {
emit_temp_var (temp_decl);
var cvar = get_variable_cexpression (temp_decl.name);
var ccomma = new CCodeCommaExpression ();
- var clbe = (CCodeBinaryExpression) lbe.ccodenode;
+ var clbe = (CCodeBinaryExpression) get_cvalue (lbe);
if (lbe.chained) {
clbe = (CCodeBinaryExpression) clbe.right;
}
- ccomma.append_expression (new CCodeAssignment (cvar, (CCodeExpression)lbe.right.ccodenode));
+ ccomma.append_expression (new CCodeAssignment (cvar, get_cvalue (lbe.right)));
clbe.right = get_variable_cexpression (temp_decl.name);
ccomma.append_expression (cleft);
cleft = cvar;
var ccall = new CCodeFunctionCall (new CCodeIdentifier ("fmod"));
ccall.add_argument (cleft);
ccall.add_argument (cright);
- expr.ccodenode = ccall;
+ set_cvalue (expr, ccall);
return;
} else if (expr.value_type.equals (float_type)) {
cfile.add_include ("math.h");
var ccall = new CCodeFunctionCall (new CCodeIdentifier ("fmodf"));
ccall.add_argument (cleft);
ccall.add_argument (cright);
- expr.ccodenode = ccall;
+ set_cvalue (expr, ccall);
return;
} else {
op = CCodeBinaryOperator.MOD;
} else {
node.add_argument (cleft);
}
- expr.ccodenode = node;
+ set_cvalue (expr, node);
} else {
- expr.ccodenode = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, new CCodeBinaryExpression (CCodeBinaryOperator.BITWISE_AND, cright, cleft), cleft);
+ set_cvalue (expr, new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, new CCodeBinaryExpression (CCodeBinaryOperator.BITWISE_AND, cright, cleft), cleft));
}
return;
} else {
assert_not_reached ();
}
- expr.ccodenode = new CCodeConstant ("%s %s".printf (left, right));
+ set_cvalue (expr, new CCodeConstant ("%s %s".printf (left, right)));
return;
} else {
if (context.profile == Profile.POSIX) {
strcat.add_argument(strcpy);
strcat.add_argument(cright);
- expr.ccodenode = strcat;
+ set_cvalue (expr, strcat);
} else {
// convert to g_strconcat (a, b, NULL)
var ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_strconcat"));
ccall.add_argument (cleft);
ccall.add_argument (cright);
ccall.add_argument (new CCodeConstant("NULL"));
- expr.ccodenode = ccall;
+ set_cvalue (expr, ccall);
}
return;
}
}
}
- expr.ccodenode = new CCodeBinaryExpression (op, cleft, cright);
+ set_cvalue (expr, new CCodeBinaryExpression (op, cleft, cright));
if (left_chain != null) {
- expr.ccodenode = new CCodeBinaryExpression (CCodeBinaryOperator.AND, left_chain, (CCodeExpression) expr.ccodenode);
+ set_cvalue (expr, new CCodeBinaryExpression (CCodeBinaryOperator.AND, left_chain, get_cvalue (expr)));
}
}
public override void visit_type_check (TypeCheck expr) {
generate_type_declaration (expr.type_reference, cfile);
- expr.ccodenode = create_type_check (expr.expression.ccodenode, expr.type_reference);
- if (expr.ccodenode is CCodeInvalidExpression) {
+ set_cvalue (expr, create_type_check (get_cvalue (expr.expression), expr.type_reference));
+ if (get_cvalue (expr) is CCodeInvalidExpression) {
Report.error (expr.source_reference, "type check expressions not supported for compact classes, structs, and enums");
}
}
l.accept_children (this);
- l.ccodenode = new CCodeIdentifier (l.method.get_cname ());
+ set_cvalue (l, new CCodeIdentifier (l.method.get_cname ()));
}
public CCodeExpression convert_from_generic_pointer (CCodeExpression cexpr, DataType actual_type) {
}
}
+ public CCodeExpression? get_cvalue (Expression expr) {
+ return (CCodeExpression) expr.ccodenode;
+ }
+
+ public void set_cvalue (Expression expr, CCodeExpression? cvalue) {
+ expr.ccodenode = cvalue;
+ }
+
public CCodeNode? get_ccodenode (CodeNode node) {
if (node.ccodenode == null) {
node.emit (this);
public void create_postcondition_statement (Expression postcondition) {
var cassert = new CCodeFunctionCall (new CCodeIdentifier ("g_warn_if_fail"));
- cassert.add_argument ((CCodeExpression) postcondition.ccodenode);
+ cassert.add_argument (get_cvalue (postcondition));
ccode.add_expression (cassert);
}
var this_access = new MemberAccess.simple ("this");
this_access.value_type = get_data_type_for_symbol ((TypeSymbol) f.parent_symbol);
- this_access.ccodenode = new CCodeIdentifier ("(*self)");
+ set_cvalue (this_access, new CCodeIdentifier ("(*self)"));
var ma = new MemberAccess (this_access, f.name);
ma.symbol_reference = f;
if (requires_copy (f.variable_type)) {
var this_access = new MemberAccess.simple ("this");
this_access.value_type = get_data_type_for_symbol ((TypeSymbol) f.parent_symbol);
- this_access.ccodenode = new CCodeIdentifier ("(*self)");
+ set_cvalue (this_access, new CCodeIdentifier ("(*self)"));
var ma = new MemberAccess (this_access, f.name);
ma.symbol_reference = f;
copy = get_ref_cexpression (f.variable_type, copy, ma, f);
public class Vala.CCodeControlFlowModule : CCodeMethodModule {
public override void visit_if_statement (IfStatement stmt) {
- ccode.open_if ((CCodeExpression) stmt.condition.ccodenode);
+ ccode.open_if (get_cvalue (stmt.condition));
stmt.true_statement.emit (this);
emit_temp_var (temp_var);
var ctemp = get_variable_cexpression (temp_var.name);
- var cinit = new CCodeAssignment (ctemp, (CCodeExpression) stmt.expression.ccodenode);
+ var cinit = new CCodeAssignment (ctemp, get_cvalue (stmt.expression));
var czero = new CCodeConstant ("0");
var free_call = new CCodeFunctionCall (new CCodeIdentifier ("g_free"));
foreach (SwitchLabel label in section.get_labels ()) {
label.expression.emit (this);
- var cexpr = (CCodeExpression) label.expression.ccodenode;
+ var cexpr = get_cvalue (label.expression);
if (is_constant_ccode_expression (cexpr)) {
var cname = "%s_label%d".printf (temp_var.name, label_count++);
CCodeBinaryExpression cor = null;
foreach (SwitchLabel label in section.get_labels ()) {
label.expression.emit (this);
- var cexpr = (CCodeExpression) label.expression.ccodenode;
+ var cexpr = get_cvalue (label.expression);
if (is_constant_ccode_expression (cexpr)) {
var cname = new CCodeIdentifier ("%s_label%d".printf (temp_var.name, label_count++));
return;
}
- ccode.open_switch ((CCodeExpression) stmt.expression.ccodenode);
+ ccode.open_switch (get_cvalue (stmt.expression));
foreach (SwitchSection section in stmt.get_sections ()) {
if (section.has_default_label ()) {
visit_end_full_expression (label.expression);
- ccode.add_case ((CCodeExpression) label.expression.ccodenode);
+ ccode.add_case (get_cvalue (label.expression));
}
}
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), (CCodeExpression) stmt.collection.ccodenode));
+ ccode.add_expression (new CCodeAssignment (get_variable_cexpression (collection_backup.name), get_cvalue (stmt.collection)));
if (stmt.tree_can_fail && stmt.collection.tree_can_fail) {
// exception handling
CCodeExpression pub_inst = null;
if (expr.inner != null) {
- pub_inst = (CCodeExpression) expr.inner.ccodenode;
+ pub_inst = get_cvalue (expr.inner);
}
if (expr.symbol_reference is Method) {
var vcast = new CCodeFunctionCall (new CCodeIdentifier ("%s_CLASS".printf (base_class.get_upper_case_cname (null))));
vcast.add_argument (new CCodeIdentifier ("%s_parent_class".printf (current_class.get_lower_case_cname (null))));
- expr.ccodenode = new CCodeMemberAccess.pointer (vcast, m.vfunc_name);
+ set_cvalue (expr, new CCodeMemberAccess.pointer (vcast, m.vfunc_name));
return;
} else if (m.base_interface_method != null) {
var base_iface = (Interface) m.base_interface_method.parent_symbol;
string parent_iface_var = "%s_%s_parent_iface".printf (current_class.get_lower_case_cname (null), base_iface.get_lower_case_cname (null));
- expr.ccodenode = new CCodeMemberAccess.pointer (new CCodeIdentifier (parent_iface_var), m.vfunc_name);
+ set_cvalue (expr, new CCodeMemberAccess.pointer (new CCodeIdentifier (parent_iface_var), m.vfunc_name));
return;
}
}
emit_temp_var (temp_var);
var ctemp = get_variable_cexpression (temp_var.name);
inst = new CCodeAssignment (ctemp, pub_inst);
- expr.inner.ccodenode = ctemp;
+ set_cvalue (expr.inner, ctemp);
}
var base_class = (Class) m.base_method.parent_symbol;
var vclass = new CCodeFunctionCall (new CCodeIdentifier ("%s_GET_CLASS".printf (base_class.get_upper_case_cname (null))));
vclass.add_argument (inst);
- expr.ccodenode = new CCodeMemberAccess.pointer (vclass, m.name);
+ set_cvalue (expr, new CCodeMemberAccess.pointer (vclass, m.name));
} else {
- expr.ccodenode = new CCodeIdentifier (m.base_method.get_cname ());
+ set_cvalue (expr, new CCodeIdentifier (m.base_method.get_cname ()));
}
} else if (m.base_interface_method != null) {
- expr.ccodenode = new CCodeIdentifier (m.base_interface_method.get_cname ());
+ set_cvalue (expr, new CCodeIdentifier (m.base_interface_method.get_cname ()));
} else if (m is CreationMethod) {
- expr.ccodenode = new CCodeIdentifier (m.get_real_cname ());
+ set_cvalue (expr, new CCodeIdentifier (m.get_real_cname ()));
} else {
- expr.ccodenode = new CCodeIdentifier (m.get_cname ());
+ set_cvalue (expr, new CCodeIdentifier (m.get_cname ()));
}
} else if (expr.symbol_reference is ArrayLengthField) {
if (expr.value_type is ArrayType && !(expr.parent_node is ElementAccess)) {
Report.error (expr.source_reference, "unsupported use of length field of multi-dimensional array");
}
- expr.ccodenode = get_array_length_cexpression (expr.inner, 1);
+ set_cvalue (expr, get_array_length_cexpression (expr.inner, 1));
} else if (expr.symbol_reference is Field) {
var f = (Field) expr.symbol_reference;
if (f.binding == MemberBinding.INSTANCE) {
inst = pub_inst;
}
if (instance_target_type.data_type.is_reference_type () || (expr.inner != null && expr.inner.value_type is PointerType)) {
- expr.ccodenode = new CCodeMemberAccess.pointer (inst, f.get_cname ());
+ set_cvalue (expr, new CCodeMemberAccess.pointer (inst, f.get_cname ()));
} else {
if (inst is CCodeCommaExpression) {
var ccomma = inst as CCodeCommaExpression;
var inner = ccomma.get_inner ();
var last = inner.get (inner.size - 1);
ccomma.set_expression (inner.size - 1, new CCodeMemberAccess (last, f.get_cname ()));
- expr.ccodenode = ccomma;
+ set_cvalue (expr, ccomma);
} else {
- expr.ccodenode = new CCodeMemberAccess (inst, f.get_cname ());
+ set_cvalue (expr, new CCodeMemberAccess (inst, f.get_cname ()));
}
}
} else if (f.binding == MemberBinding.CLASS) {
} else {
// Accessing the field of an instance
var k = new CCodeFunctionCall (new CCodeIdentifier ("G_OBJECT_GET_CLASS"));
- k.add_argument ((CCodeExpression) expr.inner.ccodenode);
+ k.add_argument (get_cvalue (expr.inner));
klass = k;
}
cast.add_argument (klass);
if (f.access == SymbolAccessibility.PRIVATE) {
var ccall = new CCodeFunctionCall (new CCodeIdentifier ("%s_GET_CLASS_PRIVATE".printf (cl.get_upper_case_cname ())));
ccall.add_argument (klass);
- expr.ccodenode = new CCodeMemberAccess.pointer (ccall, f.get_cname ());
+ set_cvalue (expr, new CCodeMemberAccess.pointer (ccall, f.get_cname ()));
} else {
- expr.ccodenode = new CCodeMemberAccess.pointer (cast, f.get_cname ());
+ set_cvalue (expr, new CCodeMemberAccess.pointer (cast, f.get_cname ()));
}
} else {
generate_field_declaration (f, cfile);
- expr.ccodenode = new CCodeIdentifier (f.get_cname ());
+ set_cvalue (expr, new CCodeIdentifier (f.get_cname ()));
}
} else if (expr.symbol_reference is EnumValue) {
var ev = (EnumValue) expr.symbol_reference;
generate_enum_declaration ((Enum) ev.parent_symbol, cfile);
- expr.ccodenode = new CCodeConstant (ev.get_cname ());
+ set_cvalue (expr, new CCodeConstant (ev.get_cname ()));
} else if (expr.symbol_reference is Constant) {
var c = (Constant) expr.symbol_reference;
string fn = c.get_full_name ();
if (fn == "GLib.Log.FILE") {
string s = Path.get_basename (expr.source_reference.file.filename);
- expr.ccodenode = new CCodeConstant ("\"%s\"".printf (s));
+ set_cvalue (expr, new CCodeConstant ("\"%s\"".printf (s)));
} else if (fn == "GLib.Log.LINE") {
int i = expr.source_reference.first_line;
- expr.ccodenode = new CCodeConstant ("%d".printf (i));
+ set_cvalue (expr, new CCodeConstant ("%d".printf (i)));
} else if (fn == "GLib.Log.METHOD") {
string s = "";
if (current_method != null) {
s = current_method.get_full_name ();
}
- expr.ccodenode = new CCodeConstant ("\"%s\"".printf (s));
+ set_cvalue (expr, new CCodeConstant ("\"%s\"".printf (s)));
} else {
- expr.ccodenode = new CCodeIdentifier (c.get_cname ());
+ set_cvalue (expr, new CCodeIdentifier (c.get_cname ()));
}
} else if (expr.symbol_reference is Property) {
var prop = (Property) expr.symbol_reference;
vcast.add_argument (new CCodeIdentifier ("%s_parent_class".printf (current_class.get_lower_case_cname (null))));
var ccall = new CCodeFunctionCall (new CCodeMemberAccess.pointer (vcast, "get_%s".printf (prop.name)));
- ccall.add_argument ((CCodeExpression) expr.inner.ccodenode);
- expr.ccodenode = ccall;
+ ccall.add_argument (get_cvalue (expr.inner));
+ set_cvalue (expr, ccall);
return;
} else if (prop.base_interface_property != null) {
var base_iface = (Interface) prop.base_interface_property.parent_symbol;
string parent_iface_var = "%s_%s_parent_iface".printf (current_class.get_lower_case_cname (null), base_iface.get_lower_case_cname (null));
var ccall = new CCodeFunctionCall (new CCodeMemberAccess.pointer (new CCodeIdentifier (parent_iface_var), "get_%s".printf (prop.name)));
- ccall.add_argument ((CCodeExpression) expr.inner.ccodenode);
- expr.ccodenode = ccall;
+ ccall.add_argument (get_cvalue (expr.inner));
+ set_cvalue (expr, ccall);
return;
}
}
!(prop.property_type is ArrayType || prop.property_type is DelegateType)) {
CCodeExpression inst;
inst = new CCodeMemberAccess.pointer (pub_inst, "priv");
- expr.ccodenode = new CCodeMemberAccess.pointer (inst, prop.field.get_cname());
+ set_cvalue (expr, new CCodeMemberAccess.pointer (inst, prop.field.get_cname()));
} else if (!prop.no_accessor_method) {
var base_property = prop;
if (prop.base_property != null) {
ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, ctemp));
ccomma.append_expression (ccall);
ccomma.append_expression (ctemp);
- expr.ccodenode = ccomma;
+ set_cvalue (expr, ccomma);
} else {
var array_type = base_property.property_type as ArrayType;
if (array_type != null && !base_property.no_array_length) {
}
}
- expr.ccodenode = ccall;
+ set_cvalue (expr, ccall);
}
} else {
var ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_object_get"));
ccall.add_argument (new CCodeConstant ("NULL"));
ccomma.append_expression (ccall);
ccomma.append_expression (ctemp);
- expr.ccodenode = ccomma;
+ set_cvalue (expr, ccomma);
}
} else if (expr.symbol_reference is LocalVariable) {
var local = (LocalVariable) expr.symbol_reference;
// used in postconditions
// structs are returned as out parameter
if (local.variable_type != null && local.variable_type.is_real_non_null_struct_type ()) {
- expr.ccodenode = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("result"));
+ set_cvalue (expr, new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("result")));
} else {
- expr.ccodenode = new CCodeIdentifier ("result");
+ set_cvalue (expr, new CCodeIdentifier ("result"));
}
} else if (local.captured) {
// captured variables are stored on the heap
var block = (Block) local.parent_symbol;
- expr.ccodenode = new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (get_block_id (block))), get_variable_cname (local.name));
+ set_cvalue (expr, new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (get_block_id (block))), get_variable_cname (local.name)));
} else {
- expr.ccodenode = get_variable_cexpression (local.name);
+ set_cvalue (expr, get_variable_cexpression (local.name));
if (expr.parent_node is ReturnStatement &&
current_return_type.value_owned &&
if (p.name == "this") {
if (current_method != null && current_method.coroutine) {
// use closure
- expr.ccodenode = new CCodeMemberAccess.pointer (new CCodeIdentifier ("data"), "self");
+ set_cvalue (expr, new CCodeMemberAccess.pointer (new CCodeIdentifier ("data"), "self"));
} else {
var st = current_type_symbol as Struct;
if (st != null && !st.is_simple_type ()) {
- expr.ccodenode = new CCodeIdentifier ("(*self)");
+ set_cvalue (expr, new CCodeIdentifier ("(*self)"));
} else {
- expr.ccodenode = new CCodeIdentifier ("self");
+ set_cvalue (expr, new CCodeIdentifier ("self"));
}
}
} else {
if (block == null) {
block = ((Method) p.parent_symbol).body;
}
- expr.ccodenode = new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (get_block_id (block))), get_variable_cname (p.name));
+ set_cvalue (expr, new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (get_block_id (block))), get_variable_cname (p.name)));
} else if (current_method != null && current_method.coroutine) {
// use closure
- expr.ccodenode = get_variable_cexpression (p.name);
+ set_cvalue (expr, get_variable_cexpression (p.name));
} else {
var type_as_struct = p.variable_type.data_type as Struct;
if (p.direction != ParameterDirection.IN
|| (type_as_struct != null && !type_as_struct.is_simple_type () && !p.variable_type.nullable)) {
- expr.ccodenode = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier (get_variable_cname (p.name)));
+ set_cvalue (expr, new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier (get_variable_cname (p.name))));
} else {
// Property setters of non simple structs shall replace all occurences
// of the "value" formal parameter with a dereferencing version of that
current_property_accessor.value_parameter == p &&
current_property_accessor.prop.property_type.is_real_struct_type () &&
!current_property_accessor.prop.property_type.nullable) {
- expr.ccodenode = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("value"));
+ set_cvalue (expr, new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("value")));
} else {
- expr.ccodenode = get_variable_cexpression (p.name);
+ set_cvalue (expr, get_variable_cexpression (p.name));
}
}
}
public class Vala.CCodeMethodCallModule : CCodeAssignmentModule {
public override void visit_method_call (MethodCall expr) {
// the bare function call
- var ccall = new CCodeFunctionCall ((CCodeExpression) expr.call.ccodenode);
+ var ccall = new CCodeFunctionCall (get_cvalue (expr.call));
CCodeFunctionCall async_call = null;
if (ma != null && ma.inner is BaseAccess && sig_type.signal_symbol.is_virtual) {
m = sig_type.signal_symbol.default_handler;
} else {
- ccall = (CCodeFunctionCall) expr.call.ccodenode;
+ ccall = (CCodeFunctionCall) get_cvalue (expr.call);
}
} else if (itype is ObjectType) {
// constructor
in_arg_map.set (get_param_pos (m.cinstance_parameter_position), instance);
out_arg_map.set (get_param_pos (m.cinstance_parameter_position), instance);
} else if (m != null && m.binding == MemberBinding.INSTANCE && !(m is CreationMethod)) {
- instance = (CCodeExpression) ma.inner.ccodenode;
+ instance = get_cvalue (ma.inner);
if ((ma.member_name == "begin" || ma.member_name == "end") && ma.inner.symbol_reference == ma.symbol_reference) {
var inner_ma = (MemberAccess) ma.inner;
- instance = (CCodeExpression) inner_ma.inner.ccodenode;
+ instance = get_cvalue (inner_ma.inner);
}
var st = m.parent_symbol as Struct;
} else {
// Accessing the method of an instance
var k = new CCodeFunctionCall (new CCodeIdentifier ("G_OBJECT_GET_CLASS"));
- k.add_argument ((CCodeExpression) ma.inner.ccodenode);
+ k.add_argument (get_cvalue (ma.inner));
klass = k;
}
int arg_pos;
Iterator<FormalParameter> params_it = params.iterator ();
foreach (Expression arg in expr.get_argument_list ()) {
- CCodeExpression cexpr = (CCodeExpression) arg.ccodenode;
+ CCodeExpression cexpr = get_cvalue (arg);
var carg_map = in_arg_map;
if (param.direction == ParameterDirection.REF) {
var crefcomma = new CCodeCommaExpression ();
- crefcomma.append_expression (new CCodeAssignment (get_variable_cexpression (temp_var.name), (CCodeExpression) unary.inner.ccodenode));
+ crefcomma.append_expression (new CCodeAssignment (get_variable_cexpression (temp_var.name), get_cvalue (unary.inner)));
crefcomma.append_expression (cexpr);
cexpr = crefcomma;
}
cassign_comma.append_expression (new CCodeAssignment (get_variable_cexpression (assign_temp_var.name), transform_expression (get_variable_cexpression (temp_var.name), param.variable_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 (get_unref_expression (get_cvalue (unary.inner), arg.value_type, arg));
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));
+ ccomma.append_expression (new CCodeAssignment (get_cvalue (unary.inner), cassign_comma));
// return value
if (ret_temp_var != null) {
}
if (m != null && m.binding == MemberBinding.INSTANCE && m.returns_modified_pointer) {
- expr.ccodenode = new CCodeAssignment (instance, ccall_expr);
+ set_cvalue (expr, new CCodeAssignment (instance, ccall_expr));
} else {
- expr.ccodenode = ccall_expr;
+ set_cvalue (expr, ccall_expr);
}
if (expr.is_yield_expression) {
// FIXME: size expression must not be evaluated twice at runtime (potential side effects)
Iterator<Expression> arg_it = expr.get_argument_list ().iterator ();
arg_it.next ();
- var new_size = (CCodeExpression) arg_it.get ().ccodenode;
+ var new_size = get_cvalue (arg_it.get ());
var temp_decl = get_temp_variable (int_type);
var temp_ref = get_variable_cexpression (temp_decl.name);
cfile.add_include ("string.h");
var clen = get_array_length_cexpression (ma.inner, 1);
- var celems = (CCodeExpression) ma.inner.ccodenode;
+ var celems = get_cvalue (ma.inner);
var array_type = (ArrayType) ma.inner.value_type;
var csizeof = new CCodeIdentifier ("sizeof (%s)".printf (array_type.element_type.get_cname ()));
var cdelta = new CCodeBinaryExpression (CCodeBinaryOperator.MINUS, temp_ref, clen);
var ccomma = new CCodeCommaExpression ();
ccomma.append_expression (new CCodeAssignment (temp_ref, new_size));
- ccomma.append_expression ((CCodeExpression) expr.ccodenode);
+ ccomma.append_expression (get_cvalue (expr));
ccomma.append_expression (new CCodeConditionalExpression (ccheck, czero, new CCodeConstant ("NULL")));
ccomma.append_expression (new CCodeAssignment (get_array_length_cexpression (ma.inner, 1), temp_ref));
- expr.ccodenode = ccomma;
+ set_cvalue (expr, ccomma);
}
}
private void create_precondition_statement (CodeNode method_node, DataType ret_type, Expression precondition) {
var ccheck = new CCodeFunctionCall ();
- ccheck.add_argument ((CCodeExpression) precondition.ccodenode);
+ ccheck.add_argument (get_cvalue (precondition));
if (method_node is CreationMethod) {
ccheck.call = new CCodeIdentifier ("g_return_val_if_fail");
if (requires_copy (f.variable_type)) {
var this_access = new MemberAccess.simple ("this");
this_access.value_type = get_data_type_for_symbol ((TypeSymbol) f.parent_symbol);
- this_access.ccodenode = new CCodeIdentifier ("(*self)");
+ set_cvalue (this_access, new CCodeIdentifier ("(*self)"));
var ma = new MemberAccess (this_access, f.name);
ma.symbol_reference = f;
copy = get_ref_cexpression (f.variable_type, copy, ma, f);
cend_call.add_argument (new CCodeIdentifier ("proxy"));
cend_call.add_argument (new CCodeIdentifier ("call"));
cend_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("error")));
- var creply_call = new CCodeFunctionCall ((CCodeExpression) callback.ccodenode);
+ var creply_call = new CCodeFunctionCall (get_cvalue (callback));
if (reply_method.binding != MemberBinding.STATIC) {
creply_call.add_argument (new CCodeIdentifier ("user_data"));
}
var ccall = new CCodeFunctionCall (new CCodeIdentifier (type.type_symbol.get_lower_case_cprefix () + "dbus_proxy_new"));
connection.emit (this);
- ccall.add_argument ((CCodeExpression) connection.ccodenode);
+ ccall.add_argument (get_cvalue (connection));
bus_name.emit (this);
- ccall.add_argument ((CCodeExpression) bus_name.ccodenode);
+ ccall.add_argument (get_cvalue (bus_name));
object_path.emit (this);
- ccall.add_argument ((CCodeExpression) object_path.ccodenode);
- expr.ccodenode = ccall;
+ ccall.add_argument (get_cvalue (object_path));
+ set_cvalue (expr, ccall);
}
void generate_proxy_interface_init (Interface main_iface, Interface iface) {
interface_name.emit (this);
var ccall = new CCodeFunctionCall (new CCodeIdentifier (generate_get_all_function (mtype.method_symbol)));
- ccall.add_argument ((CCodeExpression) instance.ccodenode);
- ccall.add_argument ((CCodeExpression) interface_name.ccodenode);
+ ccall.add_argument (get_cvalue (instance));
+ ccall.add_argument (get_cvalue (interface_name));
current_method_inner_error = true;
ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_variable_cexpression ("_inner_error_")));
- expr.ccodenode = ccall;
+ set_cvalue (expr, ccall);
return;
}
var qdata_call = new CCodeFunctionCall (new CCodeIdentifier ("g_type_get_qdata"));
type.emit (this);
- qdata_call.add_argument ((CCodeExpression) type.ccodenode);
+ qdata_call.add_argument (get_cvalue (type));
qdata_call.add_argument (quark_call);
var get_type_call = new CCodeFunctionCall (new CCodeCastExpression (qdata_call, "GType (*)(void)"));
ccall.add_argument (get_type_call);
ccall.add_argument (new CCodeConstant ("\"connection\""));
connection.emit (this);
- ccall.add_argument ((CCodeExpression) connection.ccodenode);
+ ccall.add_argument (get_cvalue (connection));
ccall.add_argument (new CCodeConstant ("\"name\""));
bus_name.emit (this);
- ccall.add_argument ((CCodeExpression) bus_name.ccodenode);
+ ccall.add_argument (get_cvalue (bus_name));
ccall.add_argument (new CCodeConstant ("\"path\""));
object_path.emit (this);
- ccall.add_argument ((CCodeExpression) object_path.ccodenode);
+ ccall.add_argument (get_cvalue (object_path));
ccall.add_argument (new CCodeConstant ("\"interface\""));
interface_name.emit (this);
- ccall.add_argument ((CCodeExpression) interface_name.ccodenode);
+ ccall.add_argument (get_cvalue (interface_name));
ccall.add_argument (new CCodeConstant ("NULL"));
- expr.ccodenode = ccall;
+ set_cvalue (expr, ccall);
}
void generate_proxy_filter_function (Interface iface) {
var ma = (MemberAccess) expr.call;
var raw_conn = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_connection_get_connection"));
- raw_conn.add_argument ((CCodeExpression) ma.inner.ccodenode);
+ raw_conn.add_argument (get_cvalue (ma.inner));
var args_it = expr.get_argument_list ().iterator ();
args_it.next ();
if (mtype.method_symbol.get_cname () == "dbus_g_connection_register_g_object") {
cregister.add_argument (raw_conn);
} else {
- cregister.add_argument ((CCodeExpression) ma.inner.ccodenode);
+ cregister.add_argument (get_cvalue (ma.inner));
}
- cregister.add_argument ((CCodeExpression) path_arg.ccodenode);
- cregister.add_argument ((CCodeExpression) obj_arg.ccodenode);
- expr.ccodenode = cregister;
+ cregister.add_argument (get_cvalue (path_arg));
+ cregister.add_argument (get_cvalue (obj_arg));
+ set_cvalue (expr, cregister);
}
bool type_implements_dbus_interface (ObjectTypeSymbol sym) {
public class Vala.DovaArrayModule : DovaMethodCallModule {
void append_initializer_list (CCodeCommaExpression ce, CCodeExpression name_cnode, InitializerList initializer_list, ref int i) {
foreach (Expression e in initializer_list.get_initializers ()) {
- ce.append_expression (new CCodeAssignment (new CCodeElementAccess (name_cnode, new CCodeConstant (i.to_string ())), (CCodeExpression) e.ccodenode));
+ ce.append_expression (new CCodeAssignment (new CCodeElementAccess (name_cnode, new CCodeConstant (i.to_string ())), get_cvalue (e)));
i++;
}
}
ce.append_expression (name_cnode);
- expr.ccodenode = ce;
+ set_cvalue (expr, ce);
return;
}
array_new.add_argument (get_type_id_expression (expr.element_type));
// length of new array
- array_new.add_argument ((CCodeExpression) expr.get_sizes ().get (0).ccodenode);
+ array_new.add_argument (get_cvalue (expr.get_sizes ().get (0)));
- expr.ccodenode = array_new;
+ set_cvalue (expr, array_new);
}
public override void visit_element_access (ElementAccess expr) {
List<Expression> indices = expr.get_indices ();
- var ccontainer = (CCodeExpression) expr.container.ccodenode;
- var cindex = (CCodeExpression) indices[0].ccodenode;
+ var ccontainer = get_cvalue (expr.container);
+ var cindex = get_cvalue (indices[0]);
// access to element in an array
- expr.ccodenode = new CCodeElementAccess (ccontainer, cindex);
+ set_cvalue (expr, new CCodeElementAccess (ccontainer, cindex));
}
}
}
}
- CCodeExpression cexpr = (CCodeExpression) assignment.right.ccodenode;
+ CCodeExpression cexpr = get_cvalue (assignment.right);
if (assignment.operator != AssignmentOperator.SIMPLE) {
CCodeBinaryOperator cop;
}
CCodeExpression emit_simple_assignment (Assignment assignment) {
- CCodeExpression rhs = (CCodeExpression) assignment.right.ccodenode;
+ CCodeExpression rhs = get_cvalue (assignment.right);
CCodeExpression lhs = (CCodeExpression) get_ccodenode (assignment.left);
CCodeCommaExpression outer_ccomma = null;
}
CCodeExpression emit_fixed_length_array_assignment (Assignment assignment, ArrayType array_type) {
- CCodeExpression rhs = (CCodeExpression) assignment.right.ccodenode;
+ CCodeExpression rhs = get_cvalue (assignment.right);
CCodeExpression lhs = (CCodeExpression) get_ccodenode (assignment.left);
// it is necessary to use memcpy for fixed-length (stack-allocated) arrays
}
if (assignment.left.symbol_reference is Property) {
- assignment.ccodenode = emit_property_assignment (assignment);
+ set_cvalue (assignment, emit_property_assignment (assignment));
} else {
var array_type = assignment.left.value_type as ArrayType;
if (array_type != null && array_type.fixed_length) {
- assignment.ccodenode = emit_fixed_length_array_assignment (assignment, array_type);
+ set_cvalue (assignment, emit_fixed_length_array_assignment (assignment, array_type));
} else {
- assignment.ccodenode = emit_simple_assignment (assignment);
+ set_cvalue (assignment, emit_simple_assignment (assignment));
}
}
}
cenum.add_value (new CCodeEnumValue (ev.get_cname ()));
} else {
ev.value.emit (this);
- cenum.add_value (new CCodeEnumValue (ev.get_cname (), (CCodeExpression) ev.value.ccodenode));
+ cenum.add_value (new CCodeEnumValue (ev.get_cname (), get_cvalue (ev.value)));
}
}
if (c.type_reference is ArrayType) {
arr = "[]";
}
- cdecl.add_declarator (new CCodeVariableDeclarator ("%s%s".printf (c.get_cname (), arr), (CCodeExpression) c.value.ccodenode));
+ cdecl.add_declarator (new CCodeVariableDeclarator ("%s%s".printf (c.get_cname (), arr), get_cvalue (c.value)));
cdecl.modifiers = CCodeModifiers.STATIC;
decl_space.add_constant_declaration (cdecl);
} else {
- var cdefine = new CCodeMacroReplacement.with_expression (c.get_cname (), (CCodeExpression) c.value.ccodenode);
+ var cdefine = new CCodeMacroReplacement.with_expression (c.get_cname (), get_cvalue (c.value));
decl_space.add_type_member_declaration (cdefine);
}
}
generate_type_declaration (local.variable_type, cfile);
CCodeExpression rhs = null;
- if (local.initializer != null && local.initializer.ccodenode != null) {
- rhs = (CCodeExpression) local.initializer.ccodenode;
+ if (local.initializer != null && get_cvalue (local.initializer) != null) {
+ rhs = get_cvalue (local.initializer);
}
if (local.captured) {
}
}
- var cexpr = (CCodeExpression) expr.ccodenode;
+ var cexpr = get_cvalue (expr);
string ctype = field.get_ctype ();
if (ctype != null) {
clist.append (cexpr);
}
- list.ccodenode = clist;
+ set_cvalue (list, clist);
} else {
var clist = new CCodeInitializerList ();
foreach (Expression expr in list.get_initializers ()) {
- clist.append ((CCodeExpression) expr.ccodenode);
+ clist.append (get_cvalue (expr));
}
- list.ccodenode = clist;
+ set_cvalue (list, clist);
}
}
emit_temp_var (full_expr_var);
var expr_list = new CCodeCommaExpression ();
- expr_list.append_expression (new CCodeAssignment (get_variable_cexpression (full_expr_var.name), (CCodeExpression) expr.ccodenode));
+ expr_list.append_expression (new CCodeAssignment (get_variable_cexpression (full_expr_var.name), get_cvalue (expr)));
foreach (LocalVariable local in temp_ref_vars) {
var ma = new MemberAccess.simple (local.name);
expr_list.append_expression (get_variable_cexpression (full_expr_var.name));
- expr.ccodenode = expr_list;
+ set_cvalue (expr, expr_list);
temp_ref_vars.clear ();
}
return;
}
- ccode.add_expression ((CCodeExpression) stmt.expression.ccodenode);
+ ccode.add_expression (get_cvalue (stmt.expression));
/* free temporary objects and handle errors */
foreach (LocalVariable local in temp_ref_vars) {
}
var ccall = new CCodeFunctionCall (get_destroy_func_expression (type));
- ccall.add_argument ((CCodeExpression) stmt.expression.ccodenode);
+ ccall.add_argument (get_cvalue (stmt.expression));
ccode.add_expression (ccall);
}
public override void visit_expression (Expression expr) {
- if (expr.ccodenode != null && !expr.lvalue) {
+ if (get_cvalue (expr) != null && !expr.lvalue) {
// memory management, implicit casts, and boxing/unboxing
- expr.ccodenode = transform_expression ((CCodeExpression) expr.ccodenode, expr.value_type, expr.target_type, expr);
+ set_cvalue (expr, transform_expression (get_cvalue (expr), expr.value_type, expr.target_type, expr));
}
}
public override void visit_boolean_literal (BooleanLiteral expr) {
- expr.ccodenode = new CCodeConstant (expr.value ? "true" : "false");
+ set_cvalue (expr, new CCodeConstant (expr.value ? "true" : "false"));
}
public override void visit_character_literal (CharacterLiteral expr) {
if (expr.get_char () >= 0x20 && expr.get_char () < 0x80) {
- expr.ccodenode = new CCodeConstant (expr.value);
+ set_cvalue (expr, new CCodeConstant (expr.value));
} else {
- expr.ccodenode = new CCodeConstant ("%uU".printf (expr.get_char ()));
+ set_cvalue (expr, new CCodeConstant ("%uU".printf (expr.get_char ())));
}
}
public override void visit_integer_literal (IntegerLiteral expr) {
- expr.ccodenode = new CCodeConstant (expr.value);
+ set_cvalue (expr, new CCodeConstant (expr.value));
}
public override void visit_real_literal (RealLiteral expr) {
c_literal += ".";
}
}
- expr.ccodenode = new CCodeConstant (c_literal);
+ set_cvalue (expr, new CCodeConstant (c_literal));
}
public override void visit_string_literal (StringLiteral expr) {
var cliteral = new CCodeConstant ("\"\\0\" " + expr.value);
var cbinary = new CCodeBinaryExpression (CCodeBinaryOperator.PLUS, cliteral, new CCodeConstant ("1"));
- expr.ccodenode = new CCodeCastExpression (cbinary, "string_t");
+ set_cvalue (expr, new CCodeCastExpression (cbinary, "string_t"));
}
public override void visit_null_literal (NullLiteral expr) {
- expr.ccodenode = new CCodeConstant ("NULL");
+ set_cvalue (expr, new CCodeConstant ("NULL"));
}
public override void visit_base_access (BaseAccess expr) {
generate_type_declaration (expr.value_type, cfile);
- expr.ccodenode = new CCodeCastExpression (new CCodeIdentifier ("this"), expr.value_type.get_cname ());
+ set_cvalue (expr, new CCodeCastExpression (new CCodeIdentifier ("this"), expr.value_type.get_cname ()));
}
public override void visit_postfix_expression (PostfixExpression expr) {
// assign current value to temp variable
var temp_decl = get_temp_variable (prop.property_type, true, expr);
emit_temp_var (temp_decl);
- ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (temp_decl.name), (CCodeExpression) expr.inner.ccodenode));
+ ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (temp_decl.name), get_cvalue (expr.inner)));
// increment/decrement property
var op = expr.increment ? CCodeBinaryOperator.PLUS : CCodeBinaryOperator.MINUS;
// return previous value
ccomma.append_expression (new CCodeIdentifier (temp_decl.name));
- expr.ccodenode = ccomma;
+ set_cvalue (expr, ccomma);
return;
}
var op = expr.increment ? CCodeUnaryOperator.POSTFIX_INCREMENT : CCodeUnaryOperator.POSTFIX_DECREMENT;
- expr.ccodenode = new CCodeUnaryExpression (op, (CCodeExpression) expr.inner.ccodenode);
+ set_cvalue (expr, new CCodeUnaryExpression (op, get_cvalue (expr.inner)));
}
private MemberAccess? find_property_access (Expression expr) {
if (expr != null && expr.is_non_null ()
&& !is_ref_function_void (expression_type)) {
// expression is non-null
- ccall.add_argument ((CCodeExpression) expr.ccodenode);
+ ccall.add_argument (get_cvalue (expr));
return ccall;
} else {
int i = 1;
Iterator<FormalParameter> params_it = params.iterator ();
foreach (Expression arg in expr.get_argument_list ()) {
- CCodeExpression cexpr = (CCodeExpression) arg.ccodenode;
+ CCodeExpression cexpr = get_cvalue (arg);
FormalParameter param = null;
if (params_it.next ()) {
param = params_it.get ();
* parameter yet */
param.initializer.emit (this);
- creation_call.add_argument ((CCodeExpression) param.initializer.ccodenode);
+ creation_call.add_argument (get_cvalue (param.initializer));
i++;
}
} else {
lhs = new CCodeMemberAccess.pointer (typed_inst, f.get_cname ());
}
- ccomma.append_expression (new CCodeAssignment (lhs, (CCodeExpression) init.initializer.ccodenode));
+ ccomma.append_expression (new CCodeAssignment (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;
- inst_ma.ccodenode = instance;
+ set_cvalue (inst_ma, instance);
var ma = new MemberAccess (inst_ma, init.name);
- ccomma.append_expression (get_property_set_call ((Property) init.symbol_reference, ma, (CCodeExpression) init.initializer.ccodenode));
+ ccomma.append_expression (get_property_set_call ((Property) init.symbol_reference, ma, get_cvalue (init.initializer)));
}
}
ccomma.append_expression (instance);
- expr.ccodenode = ccomma;
+ set_cvalue (expr, ccomma);
} else if (creation_expr != null) {
- expr.ccodenode = creation_expr;
+ set_cvalue (expr, creation_expr);
}
}
public override void visit_sizeof_expression (SizeofExpression expr) {
var csizeof = new CCodeFunctionCall (new CCodeIdentifier ("sizeof"));
csizeof.add_argument (new CCodeIdentifier (expr.type_reference.get_cname ()));
- expr.ccodenode = csizeof;
+ set_cvalue (expr, csizeof);
}
public override void visit_typeof_expression (TypeofExpression expr) {
- expr.ccodenode = get_type_id_expression (expr.type_reference);
+ set_cvalue (expr, get_type_id_expression (expr.type_reference));
}
public override void visit_unary_expression (UnaryExpression expr) {
} else {
assert_not_reached ();
}
- expr.ccodenode = new CCodeUnaryExpression (op, (CCodeExpression) expr.inner.ccodenode);
+ set_cvalue (expr, new CCodeUnaryExpression (op, get_cvalue (expr.inner)));
}
public override void visit_cast_expression (CastExpression expr) {
emit_temp_var (temp_decl);
var ctemp = get_variable_cexpression (temp_decl.name);
- var cinit = new CCodeAssignment (ctemp, (CCodeExpression) expr.inner.ccodenode);
+ var cinit = new CCodeAssignment (ctemp, get_cvalue (expr.inner));
var ccheck = create_type_check (ctemp, expr.type_reference);
var ccast = new CCodeCastExpression (ctemp, expr.type_reference.get_cname ());
var cnull = new CCodeConstant ("NULL");
ccomma.append_expression (cinit);
ccomma.append_expression (new CCodeConditionalExpression (ccheck, ccast, cnull));
- expr.ccodenode = ccomma;
+ set_cvalue (expr, ccomma);
} else {
expr.error = true;
Report.error (expr.source_reference, "Operation not supported for this type");
var cvar = get_variable_cexpression (temp_decl.name);
var ccomma = new CCodeCommaExpression ();
- ccomma.append_expression (new CCodeAssignment (cvar, (CCodeExpression) expr.inner.ccodenode));
+ ccomma.append_expression (new CCodeAssignment (cvar, get_cvalue (expr.inner)));
var to_any = new CCodeFunctionCall (new CCodeIdentifier ("dova_type_value_to_any"));
to_any.add_argument (get_type_id_expression (expr.inner.value_type));
to_any.add_argument (new CCodeConstant ("0"));
ccomma.append_expression (to_any);
- expr.ccodenode = ccomma;
+ set_cvalue (expr, ccomma);
return;
} else if (expr.inner.value_type.data_type != null && expr.inner.value_type.data_type.get_full_name () == "Dova.Value") {
// unbox value
var to_any = new CCodeFunctionCall (new CCodeIdentifier ("dova_type_value_from_any"));
to_any.add_argument (get_type_id_expression (expr.type_reference));
- to_any.add_argument ((CCodeExpression) expr.inner.ccodenode);
+ to_any.add_argument (get_cvalue (expr.inner));
to_any.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, cvar));
to_any.add_argument (new CCodeConstant ("0"));
ccomma.append_expression (to_any);
ccomma.append_expression (cvar);
- expr.ccodenode = ccomma;
+ set_cvalue (expr, ccomma);
return;
}
if (expr.inner.value_type is GenericType && !(expr.type_reference is GenericType)) {
// generic types use an extra pointer, dereference that pointer
- expr.ccodenode = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeCastExpression ((CCodeExpression) expr.inner.ccodenode, expr.type_reference.get_cname () + "*"));
+ set_cvalue (expr, new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeCastExpression (get_cvalue (expr.inner), expr.type_reference.get_cname () + "*")));
} else {
- expr.ccodenode = new CCodeCastExpression ((CCodeExpression) expr.inner.ccodenode, expr.type_reference.get_cname ());
+ set_cvalue (expr, new CCodeCastExpression (get_cvalue (expr.inner), expr.type_reference.get_cname ()));
}
}
public override void visit_pointer_indirection (PointerIndirection expr) {
- expr.ccodenode = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, (CCodeExpression) expr.inner.ccodenode);
+ set_cvalue (expr, new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, get_cvalue (expr.inner)));
}
public override void visit_addressof_expression (AddressofExpression expr) {
- expr.ccodenode = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, (CCodeExpression) expr.inner.ccodenode);
+ set_cvalue (expr, new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_cvalue (expr.inner)));
}
public override void visit_reference_transfer_expression (ReferenceTransferExpression expr) {
emit_temp_var (temp_decl);
var cvar = get_variable_cexpression (temp_decl.name);
- ccomma.append_expression (new CCodeAssignment (cvar, (CCodeExpression) expr.inner.ccodenode));
- ccomma.append_expression (new CCodeAssignment ((CCodeExpression) expr.inner.ccodenode, new CCodeConstant ("NULL")));
+ ccomma.append_expression (new CCodeAssignment (cvar, get_cvalue (expr.inner)));
+ ccomma.append_expression (new CCodeAssignment (get_cvalue (expr.inner), new CCodeConstant ("NULL")));
ccomma.append_expression (cvar);
- expr.ccodenode = ccomma;
+ set_cvalue (expr, ccomma);
}
public override void visit_binary_expression (BinaryExpression expr) {
- var cleft = (CCodeExpression) expr.left.ccodenode;
- var cright = (CCodeExpression) expr.right.ccodenode;
+ var cleft = get_cvalue (expr.left);
+ var cright = get_cvalue (expr.right);
CCodeBinaryOperator op;
if (expr.operator == BinaryOperator.PLUS) {
} else if (expr.operator == BinaryOperator.OR) {
op = CCodeBinaryOperator.OR;
} else if (expr.operator == BinaryOperator.IN) {
- expr.ccodenode = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, new CCodeBinaryExpression (CCodeBinaryOperator.BITWISE_AND, cright, cleft), cleft);
+ set_cvalue (expr, new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, new CCodeBinaryExpression (CCodeBinaryOperator.BITWISE_AND, cright, cleft), cleft));
return;
} else {
assert_not_reached ();
}
}
- expr.ccodenode = new CCodeBinaryExpression (op, cleft, cright);
+ set_cvalue (expr, new CCodeBinaryExpression (op, cleft, cright));
}
CCodeExpression? create_type_check (CCodeNode ccodenode, DataType type) {
public override void visit_type_check (TypeCheck expr) {
generate_type_declaration (expr.type_reference, cfile);
- expr.ccodenode = create_type_check (expr.expression.ccodenode, expr.type_reference);
- if (expr.ccodenode is CCodeInvalidExpression) {
+ set_cvalue (expr, create_type_check (get_cvalue (expr.expression), expr.type_reference));
+ if (get_cvalue (expr) is CCodeInvalidExpression) {
Report.error (expr.source_reference, "type check expressions not supported for compact classes, structs, and enums");
}
}
l.accept_children (this);
- l.ccodenode = new CCodeIdentifier (l.method.get_cname ());
+ set_cvalue (l, new CCodeIdentifier (l.method.get_cname ()));
}
// manage memory and implicit casts
return null;
}
+ public CCodeExpression? get_cvalue (Expression expr) {
+ return (CCodeExpression) expr.ccodenode;
+ }
+
+ public void set_cvalue (Expression expr, CCodeExpression? cvalue) {
+ expr.ccodenode = cvalue;
+ }
+
public CCodeNode? get_ccodenode (CodeNode node) {
if (node.ccodenode == null) {
node.emit (this);
public class Vala.DovaControlFlowModule : DovaMethodModule {
public override void visit_if_statement (IfStatement stmt) {
- ccode.open_if ((CCodeExpression) stmt.condition.ccodenode);
+ ccode.open_if (get_cvalue (stmt.condition));
stmt.true_statement.emit (this);
}
public override void visit_switch_statement (SwitchStatement stmt) {
- ccode.open_switch ((CCodeExpression) stmt.expression.ccodenode);
+ ccode.open_switch (get_cvalue (stmt.expression));
foreach (SwitchSection section in stmt.get_sections ()) {
if (section.has_default_label ()) {
visit_end_full_expression (label.expression);
- ccode.add_case ((CCodeExpression) label.expression.ccodenode);
+ ccode.add_case (get_cvalue (label.expression));
}
}
private bool is_in_catch = false;
public override void visit_throw_statement (ThrowStatement stmt) {
- ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("dova_error"), (CCodeExpression) stmt.error_expression.ccodenode));
+ ccode.add_expression (new CCodeAssignment (new CCodeIdentifier ("dova_error"), get_cvalue (stmt.error_expression)));
add_simple_check (stmt, true);
}
DataType base_type = null;
if (expr.inner != null) {
- pub_inst = (CCodeExpression) expr.inner.ccodenode;
+ pub_inst = get_cvalue (expr.inner);
if (expr.inner.value_type != null) {
base_type = expr.inner.value_type;
if (m.base_method != null) {
var base_class = (Class) m.base_method.parent_symbol;
- expr.ccodenode = new CCodeIdentifier ("%s_base_%s".printf (base_class.get_lower_case_cname (null), m.name));
+ set_cvalue (expr, new CCodeIdentifier ("%s_base_%s".printf (base_class.get_lower_case_cname (null), m.name)));
return;
} else if (m.base_interface_method != null) {
var base_iface = (Interface) m.base_interface_method.parent_symbol;
- expr.ccodenode = new CCodeIdentifier ("%s_base_%s".printf (base_iface.get_lower_case_cname (null), m.name));
+ set_cvalue (expr, new CCodeIdentifier ("%s_base_%s".printf (base_iface.get_lower_case_cname (null), m.name)));
return;
}
}
emit_temp_var (temp_var);
var ctemp = new CCodeIdentifier (temp_var.name);
inst = new CCodeAssignment (ctemp, pub_inst);
- expr.inner.ccodenode = ctemp;
+ set_cvalue (expr.inner, ctemp);
}
var base_class = (Class) m.base_method.parent_symbol;
var vclass = new CCodeFunctionCall (new CCodeIdentifier ("%s_GET_CLASS".printf (base_class.get_upper_case_cname (null))));
vclass.add_argument (inst);
- expr.ccodenode = new CCodeMemberAccess.pointer (vclass, m.name);
+ set_cvalue (expr, new CCodeMemberAccess.pointer (vclass, m.name));
} else {
- expr.ccodenode = new CCodeIdentifier (m.base_method.get_cname ());
+ set_cvalue (expr, new CCodeIdentifier (m.base_method.get_cname ()));
}
} else if (m.base_interface_method != null) {
- expr.ccodenode = new CCodeIdentifier (m.base_interface_method.get_cname ());
+ set_cvalue (expr, new CCodeIdentifier (m.base_interface_method.get_cname ()));
} else if (m is CreationMethod) {
- expr.ccodenode = new CCodeIdentifier (m.get_real_cname ());
+ set_cvalue (expr, new CCodeIdentifier (m.get_real_cname ()));
} else {
- expr.ccodenode = new CCodeIdentifier (m.get_cname ());
+ set_cvalue (expr, new CCodeIdentifier (m.get_cname ()));
}
} else if (expr.symbol_reference is ArrayLengthField) {
generate_property_accessor_declaration (((Property) array_class.scope.lookup ("length")).get_accessor, cfile);
var ccall = new CCodeFunctionCall (new CCodeIdentifier ("dova_array_get_length"));
ccall.add_argument (pub_inst);
- expr.ccodenode = ccall;
+ set_cvalue (expr, ccall);
} else if (expr.symbol_reference is Field) {
var f = (Field) expr.symbol_reference;
if (f.binding == MemberBinding.INSTANCE) {
inst = pub_inst;
}
if (instance_target_type.data_type.is_reference_type () || (expr.inner != null && expr.inner.value_type is PointerType)) {
- expr.ccodenode = new CCodeMemberAccess.pointer (inst, f.get_cname ());
+ set_cvalue (expr, new CCodeMemberAccess.pointer (inst, f.get_cname ()));
} else {
- expr.ccodenode = new CCodeMemberAccess (inst, f.get_cname ());
+ set_cvalue (expr, new CCodeMemberAccess (inst, f.get_cname ()));
}
} else {
generate_field_declaration (f, cfile);
- expr.ccodenode = new CCodeIdentifier (f.get_cname ());
+ set_cvalue (expr, new CCodeIdentifier (f.get_cname ()));
}
} else if (expr.symbol_reference is EnumValue) {
var ev = (EnumValue) expr.symbol_reference;
generate_enum_declaration ((Enum) ev.parent_symbol, cfile);
- expr.ccodenode = new CCodeConstant (ev.get_cname ());
+ set_cvalue (expr, new CCodeConstant (ev.get_cname ()));
} else if (expr.symbol_reference is Constant) {
var c = (Constant) expr.symbol_reference;
generate_constant_declaration (c, cfile);
- expr.ccodenode = new CCodeIdentifier (c.get_cname ());
+ set_cvalue (expr, new CCodeIdentifier (c.get_cname ()));
} else if (expr.symbol_reference is Property) {
var prop = (Property) expr.symbol_reference;
vcast.add_argument (new CCodeIdentifier ("%s_parent_class".printf (current_class.get_lower_case_cname (null))));
var ccall = new CCodeFunctionCall (new CCodeMemberAccess.pointer (vcast, "get_%s".printf (prop.name)));
- ccall.add_argument ((CCodeExpression) expr.inner.ccodenode);
- expr.ccodenode = ccall;
+ ccall.add_argument (get_cvalue (expr.inner));
+ set_cvalue (expr, ccall);
return;
} else if (prop.base_interface_property != null) {
var base_iface = (Interface) prop.base_interface_property.parent_symbol;
string parent_iface_var = "%s_%s_parent_iface".printf (current_class.get_lower_case_cname (null), base_iface.get_lower_case_cname (null));
var ccall = new CCodeFunctionCall (new CCodeMemberAccess.pointer (new CCodeIdentifier (parent_iface_var), "get_%s".printf (prop.name)));
- ccall.add_argument ((CCodeExpression) expr.inner.ccodenode);
- expr.ccodenode = ccall;
+ ccall.add_argument (get_cvalue (expr.inner));
+ set_cvalue (expr, ccall);
return;
}
}
ccall.add_argument (pub_inst);
}
- expr.ccodenode = ccall;
+ set_cvalue (expr, ccall);
} else if (expr.symbol_reference is LocalVariable) {
var local = (LocalVariable) expr.symbol_reference;
if (local.is_result) {
// used in postconditions
- expr.ccodenode = new CCodeIdentifier ("result");
+ set_cvalue (expr, new CCodeIdentifier ("result"));
} else if (local.captured) {
// captured variables are stored on the heap
var block = (Block) local.parent_symbol;
- expr.ccodenode = new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (get_block_id (block))), get_variable_cname (local.name));
+ set_cvalue (expr, new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (get_block_id (block))), get_variable_cname (local.name)));
} else {
- expr.ccodenode = get_variable_cexpression (local.name);
+ set_cvalue (expr, get_variable_cexpression (local.name));
}
} else if (expr.symbol_reference is FormalParameter) {
var p = (FormalParameter) expr.symbol_reference;
if (p.name == "this") {
if (current_method != null && current_method.coroutine) {
// use closure
- expr.ccodenode = new CCodeMemberAccess.pointer (new CCodeIdentifier ("data"), "this");
+ set_cvalue (expr, new CCodeMemberAccess.pointer (new CCodeIdentifier ("data"), "this"));
} else {
var st = current_type_symbol as Struct;
if (st != null && !st.is_boolean_type () && !st.is_integer_type () && !st.is_floating_type () && (!st.is_simple_type () || current_method is CreationMethod)) {
- expr.ccodenode = new CCodeIdentifier ("(*this)");
+ set_cvalue (expr, new CCodeIdentifier ("(*this)"));
} else {
- expr.ccodenode = new CCodeIdentifier ("this");
+ set_cvalue (expr, new CCodeIdentifier ("this"));
}
}
} else {
if (block == null) {
block = ((Method) p.parent_symbol).body;
}
- expr.ccodenode = new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (get_block_id (block))), get_variable_cname (p.name));
+ set_cvalue (expr, new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (get_block_id (block))), get_variable_cname (p.name)));
} else {
if (current_method != null && current_method.coroutine) {
// use closure
- expr.ccodenode = get_variable_cexpression (p.name);
+ set_cvalue (expr, get_variable_cexpression (p.name));
} else {
var type_as_struct = p.variable_type.data_type as Struct;
if (p.direction != ParameterDirection.IN
|| (type_as_struct != null && !type_as_struct.is_simple_type () && !p.variable_type.nullable)) {
if (p.variable_type is GenericType) {
- expr.ccodenode = get_variable_cexpression (p.name);
+ set_cvalue (expr, get_variable_cexpression (p.name));
} else {
- expr.ccodenode = new CCodeIdentifier ("(*%s)".printf (get_variable_cname (p.name)));
+ set_cvalue (expr, new CCodeIdentifier ("(*%s)".printf (get_variable_cname (p.name))));
}
} else {
// Property setters of non simple structs shall replace all occurences
current_property_accessor.writable &&
current_property_accessor.value_parameter == p &&
current_property_accessor.prop.property_type.is_real_struct_type ()) {
- expr.ccodenode = new CCodeIdentifier ("(*value)");
+ set_cvalue (expr, new CCodeIdentifier ("(*value)"));
} else {
- expr.ccodenode = get_variable_cexpression (p.name);
+ set_cvalue (expr, get_variable_cexpression (p.name));
}
}
}
public class Vala.DovaMethodCallModule : DovaAssignmentModule {
public override void visit_method_call (MethodCall expr) {
// the bare function call
- var ccall = new CCodeFunctionCall ((CCodeExpression) expr.call.ccodenode);
+ var ccall = new CCodeFunctionCall (get_cvalue (expr.call));
Method m = null;
Delegate deleg = null;
} else if (itype is DelegateType) {
deleg = ((DelegateType) itype).delegate_symbol;
ccall = new CCodeFunctionCall (new CCodeIdentifier ("%s_invoke".printf (deleg.get_lower_case_cname ())));
- ccall.add_argument ((CCodeExpression) expr.call.ccodenode);
+ ccall.add_argument (get_cvalue (expr.call));
}
if (m is CreationMethod) {
}
} else if (m != null) {
if (m.binding == MemberBinding.INSTANCE) {
- var instance = (CCodeExpression) ma.inner.ccodenode;
+ var instance = get_cvalue (ma.inner);
if (ma.member_name == "begin" && ma.inner.symbol_reference == ma.symbol_reference) {
var inner_ma = (MemberAccess) ma.inner;
- instance = (CCodeExpression) inner_ma.inner.ccodenode;
+ instance = get_cvalue (inner_ma.inner);
}
var st = m.parent_symbol as Struct;
int i = 1;
Iterator<FormalParameter> params_it = params.iterator ();
foreach (Expression arg in expr.get_argument_list ()) {
- CCodeExpression cexpr = (CCodeExpression) arg.ccodenode;
+ CCodeExpression cexpr = get_cvalue (arg);
if (params_it.next ()) {
var param = params_it.get ();
if (param.direction == ParameterDirection.REF) {
var crefcomma = new CCodeCommaExpression ();
- crefcomma.append_expression (new CCodeAssignment (get_variable_cexpression (temp_var.name), (CCodeExpression) unary.inner.ccodenode));
+ crefcomma.append_expression (new CCodeAssignment (get_variable_cexpression (temp_var.name), get_cvalue (unary.inner)));
crefcomma.append_expression (cexpr);
cexpr = crefcomma;
}
cassign_comma.append_expression (new CCodeAssignment (get_variable_cexpression (assign_temp_var.name), transform_expression (get_variable_cexpression (temp_var.name), param.variable_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 (get_unref_expression (get_cvalue (unary.inner), arg.value_type, arg));
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));
+ ccomma.append_expression (new CCodeAssignment (get_cvalue (unary.inner), cassign_comma));
// return value
if (!(itype.get_return_type () is VoidType)) {
ccall_expr = ccomma;
}
- expr.ccodenode = ccall_expr;
+ set_cvalue (expr, ccall_expr);
}
}
var field_st = f.parent_symbol as Struct;
if (field_st != null && !field_st.is_simple_type ()) {
- this_access.ccodenode = new CCodeIdentifier ("(*this)");
+ set_cvalue (this_access, new CCodeIdentifier ("(*this)"));
} else {
- this_access.ccodenode = new CCodeIdentifier ("this");
+ set_cvalue (this_access, new CCodeIdentifier ("this"));
}
var ma = new MemberAccess (this_access, f.name);
expr.accept_children (this);
List<Expression> indices = expr.get_indices ();
- var cindex = (CCodeExpression) indices[0].ccodenode;
+ var cindex = get_cvalue (indices[0]);
if (array_type.inline_allocated) {
- expr.ccodenode = new CCodeElementAccess ((CCodeExpression) expr.container.ccodenode, cindex);
+ set_cvalue (expr, new CCodeElementAccess (get_cvalue (expr.container), cindex));
} else {
generate_property_accessor_declaration (((Property) array_class.scope.lookup ("data")).get_accessor, cfile);
var ccontainer = new CCodeFunctionCall (new CCodeIdentifier ("dova_array_get_data"));
- ccontainer.add_argument ((CCodeExpression) expr.container.ccodenode);
+ ccontainer.add_argument (get_cvalue (expr.container));
if (array_type.element_type is GenericType) {
// generic array
// calculate offset in bytes based on value size
var value_size = new CCodeFunctionCall (new CCodeIdentifier ("dova_type_get_value_size"));
value_size.add_argument (get_type_id_expression (array_type.element_type));
- expr.ccodenode = new CCodeBinaryExpression (CCodeBinaryOperator.PLUS, new CCodeCastExpression (ccontainer, "char*"), new CCodeBinaryExpression (CCodeBinaryOperator.MUL, value_size, cindex));
+ set_cvalue (expr, new CCodeBinaryExpression (CCodeBinaryOperator.PLUS, new CCodeCastExpression (ccontainer, "char*"), new CCodeBinaryExpression (CCodeBinaryOperator.MUL, value_size, cindex)));
} else {
- expr.ccodenode = new CCodeElementAccess (new CCodeCastExpression (ccontainer, "%s*".printf (array_type.element_type.get_cname ())), cindex);
+ set_cvalue (expr, new CCodeElementAccess (new CCodeCastExpression (ccontainer, "%s*".printf (array_type.element_type.get_cname ())), cindex));
}
}
field.initializer.emit (this);
var lhs = new CCodeIdentifier (field.get_cname ());
- var rhs = (CCodeExpression) field.initializer.ccodenode;
+ var rhs = get_cvalue (field.initializer);
ccode.add_expression (new CCodeAssignment (lhs, rhs));
}
if (requires_destroy (f.variable_type)) {
var this_access = new MemberAccess.simple ("this");
this_access.value_type = get_data_type_for_symbol ((TypeSymbol) f.parent_symbol);
- this_access.ccodenode = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, dest);
+ set_cvalue (this_access, new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, dest));
var ma = new MemberAccess (this_access, f.name);
ma.symbol_reference = f;
ma.value_type = f.variable_type.copy ();
if (requires_copy (f.variable_type)) {
var this_access = new MemberAccess.simple ("this");
this_access.value_type = get_data_type_for_symbol ((TypeSymbol) f.parent_symbol);
- this_access.ccodenode = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, src);
+ set_cvalue (this_access, new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, src));
var ma = new MemberAccess (this_access, f.name);
ma.symbol_reference = f;
copy = get_ref_cexpression (f.variable_type, copy, ma, f);
if (src is NullLiteral) {
// TODO destroy dest
- assignment.ccodenode = new CCodeConstant ("0");
+ set_cvalue (assignment, new CCodeConstant ("0"));
return;
}
ccall.add_argument (dest_index);
ccall.add_argument (csrc);
ccall.add_argument (src_index);
- assignment.ccodenode = ccall;
+ set_cvalue (assignment, ccall);
}
public override void visit_binary_expression (BinaryExpression expr) {
ccall.add_argument (right_index);
if (expr.operator == BinaryOperator.EQUALITY) {
- expr.ccodenode = ccall;
+ set_cvalue (expr, ccall);
} else {
- expr.ccodenode = new CCodeUnaryExpression (CCodeUnaryOperator.LOGICAL_NEGATION, ccall);
+ set_cvalue (expr, new CCodeUnaryExpression (CCodeUnaryOperator.LOGICAL_NEGATION, ccall));
}
}
ccall.add_argument (cval);
ccall.add_argument (val_index);
- expr.ccodenode = ccall;
+ set_cvalue (expr, ccall);
}
}
int i = 0;
foreach (Expression e in expr.get_expressions ()) {
- ce.append_expression (new CCodeAssignment (new CCodeElementAccess (name_cnode, new CCodeConstant (i.to_string ())), (CCodeExpression) e.ccodenode));
+ ce.append_expression (new CCodeAssignment (new CCodeElementAccess (name_cnode, new CCodeConstant (i.to_string ())), get_cvalue (e)));
i++;
}
list_creation.add_argument (new CCodeConstant (length.to_string ()));
list_creation.add_argument (ce);
- expr.ccodenode = list_creation;
+ set_cvalue (expr, list_creation);
}
public override void visit_set_literal (SetLiteral expr) {
int i = 0;
foreach (Expression e in expr.get_expressions ()) {
- ce.append_expression (new CCodeAssignment (new CCodeElementAccess (name_cnode, new CCodeConstant (i.to_string ())), (CCodeExpression) e.ccodenode));
+ ce.append_expression (new CCodeAssignment (new CCodeElementAccess (name_cnode, new CCodeConstant (i.to_string ())), get_cvalue (e)));
i++;
}
set_creation.add_argument (new CCodeConstant (length.to_string ()));
set_creation.add_argument (ce);
- expr.ccodenode = set_creation;
+ set_cvalue (expr, set_creation);
}
public override void visit_map_literal (MapLiteral expr) {
emit_temp_var (value_temp_var);
for (int i = 0; i < length; i++) {
- key_ce.append_expression (new CCodeAssignment (new CCodeElementAccess (key_name_cnode, new CCodeConstant (i.to_string ())), (CCodeExpression) expr.get_keys ().get (i).ccodenode));
- value_ce.append_expression (new CCodeAssignment (new CCodeElementAccess (value_name_cnode, new CCodeConstant (i.to_string ())), (CCodeExpression) expr.get_values ().get (i).ccodenode));
+ key_ce.append_expression (new CCodeAssignment (new CCodeElementAccess (key_name_cnode, new CCodeConstant (i.to_string ())), get_cvalue (expr.get_keys ().get (i))));
+ value_ce.append_expression (new CCodeAssignment (new CCodeElementAccess (value_name_cnode, new CCodeConstant (i.to_string ())), get_cvalue (expr.get_values ().get (i))));
}
key_ce.append_expression (key_name_cnode);
map_creation.add_argument (key_ce);
map_creation.add_argument (value_ce);
- expr.ccodenode = map_creation;
+ set_cvalue (expr, map_creation);
}
public override void visit_tuple (Tuple tuple) {
type_ce.append_expression (new CCodeAssignment (new CCodeElementAccess (type_name_cnode, new CCodeConstant (i.to_string ())), get_type_id_expression (element_type)));
- var cexpr = (CCodeExpression) e.ccodenode;
+ var cexpr = get_cvalue (e);
var unary = cexpr as CCodeUnaryExpression;
if (unary != null && unary.operator == CCodeUnaryOperator.POINTER_INDIRECTION) {
tuple_creation.add_argument (type_ce);
tuple_creation.add_argument (ce);
- tuple.ccodenode = tuple_creation;
+ set_cvalue (tuple, tuple_creation);
}
}
return;
}
- ccode.add_expression ((CCodeExpression) stmt.yield_expression.ccodenode);
+ ccode.add_expression (get_cvalue (stmt.yield_expression));
if (stmt.tree_can_fail && stmt.yield_expression.tree_can_fail) {
// simple case, no node breakdown necessary
var ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_initable_new"));
ccall.add_argument (new CCodeIdentifier ("%s_PROXY".printf (iface.get_type_id ())));
cancellable.emit (this);
- ccall.add_argument ((CCodeExpression) cancellable.ccodenode);
+ ccall.add_argument (get_cvalue (cancellable));
ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_variable_cexpression ("_inner_error_")));
ccall.add_argument (new CCodeConstant ("\"g-flags\""));
ccall.add_argument (new CCodeConstant ("G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES"));
ccall.add_argument (new CCodeConstant ("\"g-name\""));
name.emit (this);
- ccall.add_argument ((CCodeExpression) name.ccodenode);
+ ccall.add_argument (get_cvalue (name));
if (bus_get_proxy_sync) {
Expression bus_type = args.get (0);
ccall.add_argument (new CCodeConstant ("\"g-bus-type\""));
bus_type.emit (this);
- ccall.add_argument ((CCodeExpression) bus_type.ccodenode);
+ ccall.add_argument (get_cvalue (bus_type));
} else {
Expression connection = ((MemberAccess) expr.call).inner;
ccall.add_argument (new CCodeConstant ("\"g-connection\""));
connection.emit (this);
- ccall.add_argument ((CCodeExpression) connection.ccodenode);
+ ccall.add_argument (get_cvalue (connection));
}
ccall.add_argument (new CCodeConstant ("\"g-object-path\""));
object_path.emit (this);
- ccall.add_argument ((CCodeExpression) object_path.ccodenode);
+ ccall.add_argument (get_cvalue (object_path));
ccall.add_argument (new CCodeConstant ("\"g-interface-name\""));
ccall.add_argument (new CCodeConstant ("\"%s\"".printf (get_dbus_name (iface))));
ccall.add_argument (new CCodeConstant ("NULL"));
- expr.ccodenode = ccall;
+ set_cvalue (expr, ccall);
}
string generate_dbus_signal_handler (Signal sig, ObjectTypeSymbol sym) {
current_method_inner_error = true;
var cregister = new CCodeFunctionCall (new CCodeIdentifier ("%sregister_object".printf (type_arg.type_symbol.get_lower_case_cprefix ())));
- cregister.add_argument ((CCodeExpression) obj_arg.ccodenode);
- cregister.add_argument ((CCodeExpression) ma.inner.ccodenode);
- cregister.add_argument ((CCodeExpression) path_arg.ccodenode);
+ cregister.add_argument (get_cvalue (obj_arg));
+ cregister.add_argument (get_cvalue (ma.inner));
+ cregister.add_argument (get_cvalue (path_arg));
cregister.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_variable_cexpression ("_inner_error_")));
- expr.ccodenode = cregister;
+ set_cvalue (expr, cregister);
}
public override void generate_class_declaration (Class cl, CCodeFile decl_space) {
cenum.add_value (new CCodeEnumValue (ecode.get_cname ()));
} else {
ecode.value.emit (this);
- cenum.add_value (new CCodeEnumValue (ecode.get_cname (), (CCodeExpression) ecode.value.ccodenode));
+ cenum.add_value (new CCodeEnumValue (ecode.get_cname (), get_cvalue (ecode.value)));
}
}
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_"), (CCodeExpression) stmt.error_expression.ccodenode));
+ ccode.add_expression (new CCodeAssignment (get_variable_cexpression ("_inner_error_"), get_cvalue (stmt.error_expression)));
add_simple_check (stmt, true);
}
var ccomma = new CCodeCommaExpression ();
var temp_var = get_temp_variable (expr.value_type, false, expr, false);
emit_temp_var (temp_var);
- ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (temp_var.name), (CCodeExpression) expr.ccodenode));
+ ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (temp_var.name), get_cvalue (expr)));
var initiallyunowned_ccall = new CCodeFunctionCall (new CCodeIdentifier ("G_IS_INITIALLY_UNOWNED"));
initiallyunowned_ccall.add_argument (get_variable_cexpression (temp_var.name));
sink_ref_ccall.add_argument (get_variable_cexpression (temp_var.name));
ccomma.append_expression (new CCodeConditionalExpression (initiallyunowned_ccall, sink_ref_ccall, get_variable_cexpression (temp_var.name)));
- expr.ccodenode = ccomma;
+ set_cvalue (expr, ccomma);
return;
} else if (ma.symbol_reference == gobject_type) {
// Object (...) chain up
var ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_strconcat"));
ccall.add_argument (sig.get_canonical_cconstant (""));
- ccall.add_argument ((CCodeExpression) detail_expr.ccodenode);
+ ccall.add_argument (get_cvalue (detail_expr));
ccall.add_argument (new CCodeConstant ("NULL"));
var ccomma = new CCodeCommaExpression ();
var signal_name_cexpr = get_signal_name_cexpression (sig, detail_expr, expr);
var ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_signal_emit_by_name"));
- ccall.add_argument ((CCodeExpression) ma.inner.ccodenode);
+ ccall.add_argument (get_cvalue (ma.inner));
if (signal_name_cexpr != null) {
ccall.add_argument (signal_name_cexpr);
}
- expr.ccodenode = ccall;
+ set_cvalue (expr, ccall);
} else {
base.visit_element_access (expr);
}
return;
}
- assignment.ccodenode = emit_signal_assignment (assignment);
+ set_cvalue (assignment, emit_signal_assignment (assignment));
} else {
base.visit_assignment (assignment);
}
CCodeExpression pub_inst = null;
if (expr.inner != null) {
- pub_inst = (CCodeExpression) expr.inner.ccodenode;
+ pub_inst = get_cvalue (expr.inner);
}
var sig = (Signal) expr.symbol_reference;
var vcast = new CCodeFunctionCall (new CCodeIdentifier ("%s_CLASS".printf (base_class.get_upper_case_cname (null))));
vcast.add_argument (new CCodeIdentifier ("%s_parent_class".printf (current_class.get_lower_case_cname (null))));
- expr.ccodenode = new CCodeMemberAccess.pointer (vcast, m.name);
+ set_cvalue (expr, new CCodeMemberAccess.pointer (vcast, m.name));
return;
}
var ccall = new CCodeFunctionCall (new CCodeIdentifier ("%s_%s".printf (cl.get_lower_case_cname (null), sig.name)));
ccall.add_argument (pub_inst);
- expr.ccodenode = ccall;
+ set_cvalue (expr, ccall);
} else {
var ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_signal_emit_by_name"));
ccall.add_argument (pub_inst);
ccall.add_argument (sig.get_canonical_cconstant ());
- expr.ccodenode = ccall;
+ set_cvalue (expr, ccall);
}
} else {
base.visit_member_access (expr);
bool disconnect = (method_type.method_symbol.name == "disconnect");
bool after = (method_type.method_symbol.name == "connect_after");
- expr.ccodenode = connect_signal (sig, signal_access, handler, disconnect, after, expr);
+ set_cvalue (expr, connect_signal (sig, signal_access, handler, disconnect, after, expr));
}
CCodeExpression? connect_signal (Signal sig, Expression signal_access, Expression handler, bool disconnect, bool after, CodeNode expr) {
}
// third resp. sixth argument: handler
- ccall.add_argument (new CCodeCastExpression ((CCodeExpression) handler.ccodenode, "GCallback"));
+ ccall.add_argument (new CCodeCastExpression (get_cvalue (handler), "GCallback"));
if (m.closure) {
// g_signal_connect_data
if (handler is MemberAccess) {
var right_ma = (MemberAccess) handler;
if (right_ma.inner != null) {
- ccall.add_argument ((CCodeExpression) right_ma.inner.ccodenode);
+ ccall.add_argument (get_cvalue (right_ma.inner));
} else {
ccall.add_argument (get_result_cexpression ("self"));
}
ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (temp_var.name), get_value));
var is_null_value = new CCodeBinaryExpression (CCodeBinaryOperator.INEQUALITY, get_variable_cexpression (temp_var.name), new CCodeIdentifier ("NULL"));
ccomma.append_expression (new CCodeConditionalExpression (is_null_value, new CCodeMemberAccess.pointer (get_variable_cexpression (temp_var.name), "value_name"), new CCodeIdentifier ("NULL")));
- expr.ccodenode = ccomma;
+ set_cvalue (expr, ccomma);
}
public override void visit_property (Property prop) {
projects / thirdparty / vala.git / commitdiff
