/* valaccodearraymodule.vala
*
- * Copyright (C) 2006-2009 Jürg Billeter
+ * Copyright (C) 2006-2010 Jürg Billeter
* Copyright (C) 2006-2008 Raffaele Sandrini
*
* This library is free software; you can redistribute it and/or
}
public override void visit_array_creation_expression (ArrayCreationExpression expr) {
- expr.accept_children (codegen);
-
var array_type = expr.target_type as ArrayType;
if (array_type != null && array_type.fixed_length) {
// no heap allocation for fixed-length arrays
}
public override void visit_element_access (ElementAccess expr) {
- expr.accept_children (codegen);
-
List<Expression> indices = expr.get_indices ();
int rank = indices.size;
}
public override void visit_slice_expression (SliceExpression expr) {
- expr.accept_children (codegen);
-
var ccontainer = (CCodeExpression) expr.container.ccodenode;
var cstart = (CCodeExpression) expr.start.ccodenode;
var cstop = (CCodeExpression) expr.stop.ccodenode;
var array_type = (ArrayType) array.value_type;
var element = binary.right;
- array.accept (codegen);
- element.target_type = array_type.element_type.copy ();
- element.accept (codegen);
-
var value_param = new FormalParameter ("value", element.target_type);
var ccall = new CCodeFunctionCall (new CCodeIdentifier (generate_array_add_wrapper (array_type)));
/* valaccodeassignmentmodule.vala
*
- * Copyright (C) 2006-2009 Jürg Billeter
+ * Copyright (C) 2006-2010 Jürg Billeter
* Copyright (C) 2006-2008 Raffaele Sandrini
*
* This library is free software; you can redistribute it and/or
}
public override void visit_assignment (Assignment assignment) {
- assignment.right.accept (codegen);
-
if (assignment.left.error || assignment.right.error) {
assignment.error = true;
return;
flag_shift += 1;
}
} else {
- ev.value.accept (codegen);
+ ev.value.emit (codegen);
c_ev = new CCodeEnumValue (ev.get_cname (), (CCodeExpression) ev.value.ccodenode);
}
c_ev.deprecated = ev.deprecated;
return;
}
- c.accept_children (codegen);
-
if (!c.external) {
generate_type_declaration (c.type_reference, decl_space);
+ c.value.emit (codegen);
+
var initializer_list = c.value as InitializerList;
if (initializer_list != null) {
var cdecl = new CCodeDeclaration (c.type_reference.get_const_cname ());
check_type (f.variable_type);
- f.accept_children (codegen);
+ if (f.initializer != null) {
+ f.initializer.emit (codegen);
+ }
var cl = f.parent_symbol as Class;
bool is_gtypeinstance = (cl != null && !cl.is_compact);
bool returns_real_struct = acc.readable && prop.property_type.is_real_non_null_struct_type ();
- acc.accept_children (codegen);
+ if (acc.result_var != null) {
+ acc.result_var.accept (codegen);
+ }
+
+ if (acc.body != null) {
+ acc.body.emit (codegen);
+ }
var t = (TypeSymbol) prop.parent_symbol;
bool old_method_inner_error = current_method_inner_error;
current_method_inner_error = false;
- d.accept_children (codegen);
+ d.body.emit (codegen);
if (d.binding == MemberBinding.STATIC && !in_plugin) {
Report.error (d.source_reference, "static destructors are only supported for dynamic types");
var old_symbol = current_symbol;
current_symbol = b;
- b.accept_children (codegen);
+ foreach (Statement stmt in b.get_statements ()) {
+ stmt.emit (codegen);
+ }
var local_vars = b.get_local_variables ();
foreach (LocalVariable local in local_vars) {
public override void visit_local_variable (LocalVariable local) {
check_type (local.variable_type);
- local.accept_children (codegen);
+ if (local.initializer != null) {
+ local.initializer.emit (codegen);
+
+ visit_end_full_expression (local.initializer);
+ }
generate_type_declaration (local.variable_type, source_declarations);
}
public override void visit_initializer_list (InitializerList list) {
- list.accept_children (codegen);
-
if (list.target_type.data_type is Struct) {
/* initializer is used as struct initializer */
var st = (Struct) list.target_type.data_type;
}
public override void visit_expression_statement (ExpressionStatement stmt) {
- stmt.accept_children (codegen);
-
if (stmt.expression.error) {
stmt.error = true;
return;
stmt.ccodenode = cfrag;
}
- public virtual bool variable_accessible_in_finally (LocalVariable local) {
+ public bool variable_accessible_in_finally (LocalVariable local) {
if (current_try == null) {
return false;
}
}
public override void visit_return_statement (ReturnStatement stmt) {
- // avoid unnecessary ref/unref pair
- if (stmt.return_expression != null) {
- var local = stmt.return_expression.symbol_reference as LocalVariable;
- if (current_return_type.value_owned
- && local != null && local.variable_type.value_owned
- && !local.captured
- && !variable_accessible_in_finally (local)) {
- /* return expression is local variable taking ownership and
- * current method is transferring ownership */
-
- // don't ref expression
- stmt.return_expression.value_type.value_owned = true;
- }
- }
-
- stmt.accept_children (codegen);
-
Symbol return_expression_symbol = null;
if (stmt.return_expression != null) {
/* return expression is local variable taking ownership and
* current method is transferring ownership */
- // don't unref variable
return_expression_symbol = local;
- return_expression_symbol.active = false;
}
}
}
public override void visit_delete_statement (DeleteStatement stmt) {
- stmt.accept_children (codegen);
-
var pointer_type = (PointerType) stmt.expression.value_type;
DataType type = pointer_type;
if (pointer_type.base_type.data_type != null && pointer_type.base_type.data_type.is_reference_type ()) {
}
public override void visit_object_creation_expression (ObjectCreationExpression expr) {
- expr.accept_children (codegen);
-
CCodeExpression instance = null;
CCodeExpression creation_expr = null;
/* evaluate default expression here as the code
* generator might not have visited the formal
* parameter yet */
- param.initializer.accept (codegen);
+ param.initializer.emit (codegen);
carg_map.set (get_param_pos (param.cparameter_position), (CCodeExpression) param.initializer.ccodenode);
i++;
}
public override void visit_unary_expression (UnaryExpression expr) {
- expr.accept_children (codegen);
-
CCodeUnaryOperator op;
if (expr.operator == UnaryOperator.PLUS) {
op = CCodeUnaryOperator.PLUS;
}
public override void visit_named_argument (NamedArgument expr) {
- expr.accept_children (codegen);
-
expr.ccodenode = expr.inner.ccodenode;
}
}
public override void visit_reference_transfer_expression (ReferenceTransferExpression expr) {
- expr.accept_children (codegen);
-
/* (tmp = var, var = null, tmp) */
var ccomma = new CCodeCommaExpression ();
var temp_decl = get_temp_variable (expr.value_type, true, expr, false);
}
public override void visit_binary_expression (BinaryExpression expr) {
- expr.accept_children (codegen);
-
var cleft = (CCodeExpression) expr.left.ccodenode;
var cright = (CCodeExpression) expr.right.ccodenode;
public CCodeNode? get_ccodenode (CodeNode node) {
if (node.ccodenode == null) {
- node.accept (codegen);
+ node.emit (codegen);
}
return node.ccodenode;
}
}
public override void visit_if_statement (IfStatement stmt) {
- stmt.accept_children (codegen);
+ stmt.true_statement.emit (codegen);
+ if (stmt.false_statement != null) {
+ stmt.false_statement.emit (codegen);
+ }
if (stmt.false_statement != null) {
stmt.ccodenode = new CCodeIfStatement ((CCodeExpression) stmt.condition.ccodenode, (CCodeStatement) stmt.true_statement.ccodenode, (CCodeStatement) stmt.false_statement.ccodenode);
}
public override void visit_switch_statement (SwitchStatement stmt) {
- stmt.accept_children (codegen);
+ foreach (SwitchSection section in stmt.get_sections ()) {
+ section.emit (codegen);
+ }
if (stmt.expression.value_type.compatible (string_type)) {
visit_string_switch_statement (stmt);
create_temp_decl (stmt, stmt.expression.temp_vars);
}
- public override void visit_switch_section (SwitchSection section) {
- visit_block (section);
- }
-
public override void visit_switch_label (SwitchLabel label) {
- label.accept_children (codegen);
+ if (label.expression != null) {
+ label.expression.emit (codegen);
+
+ codegen.visit_end_full_expression (label.expression);
+ }
}
public override void visit_loop (Loop stmt) {
- stmt.accept_children (codegen);
+ stmt.body.emit (codegen);
if (context.profile == Profile.GOBJECT) {
stmt.ccodenode = new CCodeWhileStatement (new CCodeConstant ("TRUE"), (CCodeStatement) stmt.body.ccodenode);
}
public override void visit_foreach_statement (ForeachStatement stmt) {
- stmt.element_variable.active = true;
- stmt.collection_variable.active = true;
- if (stmt.iterator_variable != null) {
- stmt.iterator_variable.active = true;
- }
+ stmt.body.emit (codegen);
visit_block (stmt);
}
public override void visit_member_access (MemberAccess expr) {
- expr.accept_children (codegen);
-
CCodeExpression pub_inst = null;
DataType base_type = null;
expr.ccodenode = 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);
+
+ if (expr.parent_node is ReturnStatement &&
+ current_return_type.value_owned &&
+ local.variable_type.value_owned &&
+ !variable_accessible_in_finally (local)) {
+ /* return expression is local variable taking ownership and
+ * current method is transferring ownership */
+
+ // don't ref expression
+ expr.value_type.value_owned = true;
+
+ // don't unref variable
+ local.active = false;
+ }
}
} else if (expr.symbol_reference is FormalParameter) {
var p = (FormalParameter) expr.symbol_reference;
}
public override void visit_method_call (MethodCall expr) {
- expr.accept_children (codegen);
-
// the bare function call
var ccall = new CCodeFunctionCall ((CCodeExpression) expr.call.ccodenode);
if (m.binding == MemberBinding.CLASS || m.binding == MemberBinding.STATIC) {
in_static_or_class_context = true;
}
- m.accept_children (codegen);
+
+
+ foreach (FormalParameter param in m.get_parameters ()) {
+ param.accept (codegen);
+ }
+
+ if (m.result_var != null) {
+ m.result_var.accept (codegen);
+ }
+
+ foreach (Expression precondition in m.get_preconditions ()) {
+ precondition.emit (codegen);
+ }
+
+ foreach (Expression postcondition in m.get_postconditions ()) {
+ postcondition.emit (codegen);
+ }
+
+ if (m.body != null) {
+ m.body.emit (codegen);
+ }
+
+
in_static_or_class_context = false;
if (m is CreationMethod) {
Expression object_path = args.get (1);
var ccall = new CCodeFunctionCall (new CCodeIdentifier (type.type_symbol.get_lower_case_cprefix () + "dbus_proxy_new"));
- connection.accept (codegen);
+ connection.emit (codegen);
ccall.add_argument ((CCodeExpression) connection.ccodenode);
- bus_name.accept (codegen);
+ bus_name.emit (codegen);
ccall.add_argument ((CCodeExpression) bus_name.ccodenode);
- object_path.accept (codegen);
+ object_path.emit (codegen);
ccall.add_argument ((CCodeExpression) object_path.ccodenode);
expr.ccodenode = ccall;
}
if (proxy_get_all) {
var ma = expr.call as MemberAccess;
var instance = ma.inner;
- instance.accept (codegen);
+ instance.emit (codegen);
var args = expr.get_argument_list ();
Expression interface_name = args.get (0);
- interface_name.accept (codegen);
+ interface_name.emit (codegen);
var ccall = new CCodeFunctionCall (new CCodeIdentifier (generate_get_all_function (mtype.method_symbol)));
ccall.add_argument ((CCodeExpression) instance.ccodenode);
quark_call.add_argument (new CCodeConstant ("\"ValaDBusInterfaceProxyType\""));
var qdata_call = new CCodeFunctionCall (new CCodeIdentifier ("g_type_get_qdata"));
- type.accept (codegen);
+ type.emit (codegen);
qdata_call.add_argument ((CCodeExpression) type.ccodenode);
qdata_call.add_argument (quark_call);
var ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_object_new"));
ccall.add_argument (get_type_call);
ccall.add_argument (new CCodeConstant ("\"connection\""));
- connection.accept (codegen);
+ connection.emit (codegen);
ccall.add_argument ((CCodeExpression) connection.ccodenode);
ccall.add_argument (new CCodeConstant ("\"name\""));
- bus_name.accept (codegen);
+ bus_name.emit (codegen);
ccall.add_argument ((CCodeExpression) bus_name.ccodenode);
ccall.add_argument (new CCodeConstant ("\"path\""));
- object_path.accept (codegen);
+ object_path.emit (codegen);
ccall.add_argument ((CCodeExpression) object_path.ccodenode);
ccall.add_argument (new CCodeConstant ("\"interface\""));
- interface_name.accept (codegen);
+ interface_name.emit (codegen);
ccall.add_argument ((CCodeExpression) interface_name.ccodenode);
ccall.add_argument (new CCodeConstant ("NULL"));
expr.ccodenode = ccall;
add_dbus_helpers ();
- expr.accept_children (codegen);
-
var ma = (MemberAccess) expr.call;
var raw_conn = new CCodeFunctionCall (new CCodeIdentifier ("dbus_g_connection_get_connection"));
}
public override void visit_array_creation_expression (ArrayCreationExpression expr) {
- expr.accept_children (codegen);
-
var array_type = expr.target_type as ArrayType;
if (array_type != null && array_type.fixed_length) {
// no heap allocation for fixed-length arrays
}
public override void visit_element_access (ElementAccess expr) {
- expr.accept_children (codegen);
-
List<Expression> indices = expr.get_indices ();
var ccontainer = (CCodeExpression) expr.container.ccodenode;
}
public override void visit_assignment (Assignment assignment) {
- assignment.right.accept (codegen);
-
if (assignment.left.error || assignment.right.error) {
assignment.error = true;
return;
if (ev.value == null) {
cenum.add_value (new CCodeEnumValue (ev.get_cname ()));
} else {
- ev.value.accept (codegen);
+ ev.value.emit (codegen);
cenum.add_value (new CCodeEnumValue (ev.get_cname (), (CCodeExpression) ev.value.ccodenode));
}
}
return;
}
- c.accept_children (codegen);
-
if (!c.external) {
+ c.value.emit (codegen);
+
if (c.value is InitializerList) {
var cdecl = new CCodeDeclaration (c.type_reference.get_const_cname ());
var arr = "";
}
public override void visit_field (Field f) {
- f.accept_children (codegen);
+ if (f.initializer != null) {
+ f.initializer.emit (codegen);
+ }
var cl = f.parent_symbol as Class;
}
public override void visit_formal_parameter (FormalParameter p) {
- p.accept_children (codegen);
}
public override void visit_property (Property prop) {
}
public override void visit_destructor (Destructor d) {
- d.accept_children (codegen);
+ d.body.emit (codegen);
CCodeFragment cfrag = new CCodeFragment ();
var old_symbol = current_symbol;
current_symbol = b;
- b.accept_children (codegen);
+ foreach (Statement stmt in b.get_statements ()) {
+ stmt.emit (codegen);
+ }
var local_vars = b.get_local_variables ();
foreach (LocalVariable local in local_vars) {
}
public override void visit_local_variable (LocalVariable local) {
- local.accept_children (codegen);
+ if (local.initializer != null) {
+ local.initializer.emit (codegen);
+
+ visit_end_full_expression (local.initializer);
+ }
generate_type_declaration (local.variable_type, source_declarations);
}
public override void visit_initializer_list (InitializerList list) {
- list.accept_children (codegen);
-
if (list.target_type.data_type is Struct) {
/* initializer is used as struct initializer */
var st = (Struct) list.target_type.data_type;
}
public override void visit_expression_statement (ExpressionStatement stmt) {
- stmt.accept_children (codegen);
-
if (stmt.expression.error) {
stmt.error = true;
return;
}
public override void visit_return_statement (ReturnStatement stmt) {
- stmt.accept_children (codegen);
-
var cfrag = new CCodeFragment ();
// free local variables
}
public override void visit_delete_statement (DeleteStatement stmt) {
- stmt.accept_children (codegen);
-
var pointer_type = (PointerType) stmt.expression.value_type;
DataType type = pointer_type;
if (pointer_type.base_type.data_type != null && pointer_type.base_type.data_type.is_reference_type ()) {
}
public override void visit_object_creation_expression (ObjectCreationExpression expr) {
- expr.accept_children (codegen);
-
CCodeExpression instance = null;
CCodeExpression creation_expr = null;
/* evaluate default expression here as the code
* generator might not have visited the formal
* parameter yet */
- param.initializer.accept (codegen);
+ param.initializer.emit (codegen);
creation_call.add_argument ((CCodeExpression) param.initializer.ccodenode);
i++;
}
public override void visit_unary_expression (UnaryExpression expr) {
- expr.accept_children (codegen);
-
CCodeUnaryOperator op;
if (expr.operator == UnaryOperator.PLUS) {
op = CCodeUnaryOperator.PLUS;
}
public override void visit_reference_transfer_expression (ReferenceTransferExpression expr) {
- expr.accept_children (codegen);
-
/* (tmp = var, var = null, tmp) */
var ccomma = new CCodeCommaExpression ();
var temp_decl = get_temp_variable (expr.value_type, true, expr);
}
public override void visit_binary_expression (BinaryExpression expr) {
- expr.accept_children (codegen);
-
var cleft = (CCodeExpression) expr.left.ccodenode;
var cright = (CCodeExpression) expr.right.ccodenode;
public CCodeNode? get_ccodenode (CodeNode node) {
if (node.ccodenode == null) {
- node.accept (codegen);
+ node.emit (codegen);
}
return node.ccodenode;
}
}
public override void visit_if_statement (IfStatement stmt) {
- stmt.accept_children (codegen);
+ stmt.true_statement.emit (codegen);
+ if (stmt.false_statement != null) {
+ stmt.false_statement.emit (codegen);
+ }
if (stmt.false_statement != null) {
stmt.ccodenode = new CCodeIfStatement ((CCodeExpression) stmt.condition.ccodenode, (CCodeStatement) stmt.true_statement.ccodenode, (CCodeStatement) stmt.false_statement.ccodenode);
}
public override void visit_switch_statement (SwitchStatement stmt) {
- stmt.accept_children (codegen);
+ foreach (SwitchSection section in stmt.get_sections ()) {
+ section.emit (codegen);
+ }
var cswitch = new CCodeSwitchStatement ((CCodeExpression) stmt.expression.ccodenode);
stmt.ccodenode = cswitch;
create_temp_decl (stmt, stmt.expression.temp_vars);
}
- public override void visit_switch_section (SwitchSection section) {
- visit_block (section);
- }
-
public override void visit_switch_label (SwitchLabel label) {
- label.accept_children (codegen);
+ if (label.expression != null) {
+ label.expression.emit (codegen);
+
+ codegen.visit_end_full_expression (label.expression);
+ }
}
public override void visit_loop (Loop stmt) {
- stmt.accept_children (codegen);
+ stmt.body.emit (codegen);
stmt.ccodenode = new CCodeWhileStatement (new CCodeConstant ("true"), (CCodeStatement) stmt.body.ccodenode);
}
}
public override void visit_throw_statement (ThrowStatement stmt) {
- stmt.accept_children (codegen);
-
var cfrag = new CCodeFragment ();
// method will fail
}
if (stmt.finally_body != null) {
- stmt.finally_body.accept (codegen);
+ stmt.finally_body.emit (codegen);
}
is_in_catch = false;
- stmt.body.accept (codegen);
+ stmt.body.emit (codegen);
is_in_catch = true;
foreach (CatchClause clause in stmt.get_catch_clauses ()) {
- clause.accept (codegen);
+ clause.emit (codegen);
}
current_try = old_try;
}
public override void visit_catch_clause (CatchClause clause) {
- if (clause.error_variable != null) {
- clause.error_variable.active = true;
- }
-
generate_type_declaration (clause.error_type, source_declarations);
- clause.accept_children (codegen);
+ clause.body.emit (codegen);
var cfrag = new CCodeFragment ();
cfrag.append (new CCodeLabel (clause.clabel_name));
}
public override void visit_member_access (MemberAccess expr) {
- expr.accept_children (codegen);
-
CCodeExpression pub_inst = null;
DataType base_type = null;
}
public override void visit_method_call (MethodCall expr) {
- expr.accept_children (codegen);
-
// the bare function call
var ccall = new CCodeFunctionCall ((CCodeExpression) expr.call.ccodenode);
var prop = (Property) acc.prop;
- acc.accept_children (codegen);
+ if (acc.result_var != null) {
+ acc.result_var.accept (codegen);
+ }
+
+ if (acc.body != null) {
+ acc.body.emit (codegen);
+ }
// do not declare overriding properties and interface implementations
if (prop.is_abstract || prop.is_virtual
variable_name_map = new HashMap<string,string> (str_hash, str_equal);
current_try = null;
- m.accept_children (codegen);
+
+ foreach (FormalParameter param in m.get_parameters ()) {
+ param.accept (codegen);
+ }
+
+ if (m.result_var != null) {
+ m.result_var.accept (codegen);
+ }
+
+ foreach (Expression precondition in m.get_preconditions ()) {
+ precondition.emit (codegen);
+ }
+
+ foreach (Expression postcondition in m.get_postconditions ()) {
+ postcondition.emit (codegen);
+ }
+
+ if (m.body != null) {
+ m.body.emit (codegen);
+ }
+
current_symbol = old_symbol;
next_temp_var_id = old_next_temp_var_id;
}
public override void visit_list_literal (ListLiteral expr) {
- expr.accept_children (codegen);
-
var ce = new CCodeCommaExpression ();
int length = expr.get_expressions ().size;
}
public override void visit_set_literal (SetLiteral expr) {
- expr.accept_children (codegen);
-
var ce = new CCodeCommaExpression ();
int length = expr.get_expressions ().size;
}
public override void visit_map_literal (MapLiteral expr) {
- expr.accept_children (codegen);
-
var key_ce = new CCodeCommaExpression ();
var value_ce = new CCodeCommaExpression ();
int length = expr.get_keys ().size;
}
public override void visit_tuple (Tuple tuple) {
- tuple.accept_children (codegen);
-
var type_array_type = new ArrayType (new PointerType (new VoidType ()), 1, tuple.source_reference);
type_array_type.inline_allocated = true;
type_array_type.fixed_length = true;
return;
}
- stmt.accept_children (codegen);
-
if (stmt.yield_expression.error) {
stmt.error = true;
return;
var ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_initable_new"));
ccall.add_argument (new CCodeIdentifier ("%s_PROXY".printf (iface.get_type_id ())));
- cancellable.accept (codegen);
+ cancellable.emit (codegen);
ccall.add_argument ((CCodeExpression) cancellable.ccodenode);
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.accept (codegen);
+ name.emit (codegen);
ccall.add_argument ((CCodeExpression) name.ccodenode);
ccall.add_argument (new CCodeConstant ("\"g-bus-type\""));
- bus_type.accept (codegen);
+ bus_type.emit (codegen);
ccall.add_argument ((CCodeExpression) bus_type.ccodenode);
ccall.add_argument (new CCodeConstant ("\"g-object-path\""));
- object_path.accept (codegen);
+ object_path.emit (codegen);
ccall.add_argument ((CCodeExpression) object_path.ccodenode);
ccall.add_argument (new CCodeConstant ("\"g-interface-name\""));
ccall.add_argument (new CCodeConstant ("\"%s\"".printf (get_dbus_name (iface))));
return;
}
- expr.accept_children (codegen);
-
var ma = (MemberAccess) expr.call;
var type_arg = (ObjectType) ma.get_type_arguments ().get (0);
/* valagerrormodule.vala
*
- * Copyright (C) 2008-2009 Jürg Billeter
+ * Copyright (C) 2008-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
if (ecode.value == null) {
cenum.add_value (new CCodeEnumValue (ecode.get_cname ()));
} else {
- ecode.value.accept (codegen);
+ ecode.value.emit (codegen);
cenum.add_value (new CCodeEnumValue (ecode.get_cname (), (CCodeExpression) ecode.value.ccodenode));
}
}
}
public override void visit_throw_statement (ThrowStatement stmt) {
- stmt.accept_children (codegen);
-
var cfrag = new CCodeFragment ();
// method will fail
}
if (stmt.finally_body != null) {
- stmt.finally_body.accept (codegen);
+ stmt.finally_body.emit (codegen);
}
is_in_catch = false;
- stmt.body.accept (codegen);
+ stmt.body.emit (codegen);
is_in_catch = true;
foreach (CatchClause clause in stmt.get_catch_clauses ()) {
- clause.accept (codegen);
+ clause.emit (codegen);
}
current_try = old_try;
}
public override void visit_catch_clause (CatchClause clause) {
- if (clause.error_variable != null) {
- clause.error_variable.active = true;
- }
-
current_method_inner_error = true;
var error_type = (ErrorType) clause.error_type;
generate_error_domain_declaration (error_type.error_domain, source_declarations);
}
- clause.accept_children (codegen);
+ clause.body.emit (codegen);
var cfrag = new CCodeFragment ();
cfrag.append (new CCodeLabel (clause.clabel_name));
} else {
in_constructor = true;
}
- c.accept_children (codegen);
+ c.body.emit (codegen);
in_static_or_class_context = false;
in_constructor = false;
/* valagsignalmodule.vala
*
- * Copyright (C) 2006-2009 Jürg Billeter
+ * Copyright (C) 2006-2010 Jürg Billeter
* Copyright (C) 2006-2008 Raffaele Sandrini
*
* This library is free software; you can redistribute it and/or
// detailed signal emission
var sig = (Signal) expr.symbol_reference;
var ma = (MemberAccess) expr.container;
- expr.accept_children (codegen);
var detail_expr = expr.get_indices ().get (0) as StringLiteral;
string signal_detail = detail_expr.eval ();
public override void visit_assignment (Assignment assignment) {
if (assignment.left.symbol_reference is Signal) {
- assignment.right.accept (codegen);
-
if (assignment.left.error || assignment.right.error) {
assignment.error = true;
return;
public override void visit_member_access (MemberAccess expr) {
if (expr.symbol_reference is Signal) {
- expr.accept_children (codegen);
-
CCodeExpression pub_inst = null;
if (expr.inner != null) {
var signal_access = ((MemberAccess) expr.call).inner;
var handler = expr.get_argument_list ().get (0);
- signal_access.accept (codegen);
- handler.accept (codegen);
-
bool disconnect = (method_type.method_symbol.name == "disconnect");
bool after = (method_type.method_symbol.name == "connect_after");
/* valaaddressofexpression.vala
*
- * Copyright (C) 2007-2008 Jürg Billeter
+ * Copyright (C) 2007-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ inner.emit (codegen);
+
+ codegen.visit_addressof_expression (this);
+
+ codegen.visit_expression (this);
+ }
}
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ foreach (Expression e in sizes) {
+ e.emit (codegen);
+ }
+
+ if (initializer_list != null) {
+ initializer_list.emit (codegen);
+ }
+
+ codegen.visit_array_creation_expression (this);
+
+ codegen.visit_expression (this);
+ }
}
return !error;
}
+ public override void emit (CodeGenerator codegen) {
+ var ma = left as MemberAccess;
+ var ea = left as ElementAccess;
+ var pi = left as PointerIndirection;
+ if (ma != null) {
+ var field = ma.symbol_reference as Field;
+ var property = ma.symbol_reference as Property;
+
+ bool instance = (field != null && field.binding == MemberBinding.INSTANCE)
+ || (property != null && property.binding == MemberBinding.INSTANCE);
+
+ if (instance) {
+ ma.inner.emit (codegen);
+ }
+ } else if (ea != null) {
+ ea.container.emit (codegen);
+
+ foreach (var index in ea.get_indices ()) {
+ index.emit (codegen);
+ }
+ } else if (pi != null) {
+ pi.inner.emit (codegen);
+ }
+
+ right.emit (codegen);
+
+ codegen.visit_assignment (this);
+
+ codegen.visit_expression (this);
+ }
+
public override void get_defined_variables (Collection<LocalVariable> collection) {
right.get_defined_variables (collection);
left.get_defined_variables (collection);
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ codegen.visit_base_access (this);
+
+ codegen.visit_expression (this);
+ }
}
return false;
}
+ right.target_type = array_type.element_type.copy ();
+
value_type = array_type.copy ();
value_type.value_owned = true;
} else if (operator == BinaryOperator.PLUS
return !error;
}
+ public override void emit (CodeGenerator codegen) {
+ left.emit (codegen);
+ right.emit (codegen);
+
+ codegen.visit_binary_expression (this);
+
+ codegen.visit_expression (this);
+ }
+
public override void get_defined_variables (Collection<LocalVariable> collection) {
left.get_defined_variables (collection);
right.get_defined_variables (collection);
return !error;
}
+ public override void emit (CodeGenerator codegen) {
+ codegen.visit_block (this);
+ }
+
public void insert_before (Statement stmt, Statement new_stmt) {
for (int i = 0; i < statement_list.size; i++) {
var stmt_list = statement_list[i] as StatementList;
/* valabooleanliteral.vala
*
- * Copyright (C) 2006-2008 Jürg Billeter
+ * Copyright (C) 2006-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ codegen.visit_boolean_literal (this);
+
+ codegen.visit_expression (this);
+ }
}
/* valabreakstatement.vala
*
- * Copyright (C) 2006-2007 Jürg Billeter
+ * Copyright (C) 2006-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
public override void accept (CodeVisitor visitor) {
visitor.visit_break_statement (this);
}
+
+ public override void emit (CodeGenerator codegen) {
+ codegen.visit_break_statement (this);
+ }
}
return !error;
}
+ public override void emit (CodeGenerator codegen) {
+ inner.emit (codegen);
+
+ codegen.visit_cast_expression (this);
+
+ codegen.visit_expression (this);
+ }
+
public override void get_defined_variables (Collection<LocalVariable> collection) {
inner.get_defined_variables (collection);
}
/* valacatchclause.vala
*
- * Copyright (C) 2007-2009 Jürg Billeter
+ * Copyright (C) 2007-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
return !error;
}
+ public override void emit (CodeGenerator codegen) {
+ if (error_variable != null) {
+ error_variable.active = true;
+ }
+
+ codegen.visit_catch_clause (this);
+ }
+
public override void get_defined_variables (Collection<LocalVariable> collection) {
if (error_variable != null) {
collection.add (error_variable);
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ codegen.visit_character_literal (this);
+
+ codegen.visit_expression (this);
+ }
}
/* valacodegenerator.vala
*
- * Copyright (C) 2007-2008 Jürg Billeter
+ * Copyright (C) 2007-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* Jürg Billeter <j@bitron.ch>
*/
-using GLib;
-
/**
* Abstract code visitor generating code.
*/
return true;
}
+ public virtual void emit (CodeGenerator codegen) {
+ }
+
public virtual void replace_type (DataType old_type, DataType new_type) {
}
/* valacontinuestatement.vala
*
- * Copyright (C) 2006-2007 Jürg Billeter
+ * Copyright (C) 2006-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
public override void accept (CodeVisitor visitor) {
visitor.visit_continue_statement (this);
}
+
+ public override void emit (CodeGenerator codegen) {
+ codegen.visit_continue_statement (this);
+ }
}
/* valadeclarationstatement.vala
*
- * Copyright (C) 2006-2009 Jürg Billeter
+ * Copyright (C) 2006-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
return !error;
}
+ public override void emit (CodeGenerator codegen) {
+ codegen.visit_declaration_statement (this);
+ }
+
public override void get_defined_variables (Collection<LocalVariable> collection) {
var local = declaration as LocalVariable;
if (local != null) {
/* valadeletestatement.vala
*
- * Copyright (C) 2008 Jürg Billeter
+ * Copyright (C) 2008-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* Jürg Billeter <j@bitron.ch>
*/
-using GLib;
-
/**
* Represents a delete statement e.g. "delete a".
*/
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ expression.emit (codegen);
+
+ codegen.visit_delete_statement (this);
+ }
}
return !error;
}
+ public override void emit (CodeGenerator codegen) {
+ container.emit (codegen);
+ foreach (Expression e in indices) {
+ e.emit (codegen);
+ }
+
+ codegen.visit_element_access (this);
+
+ codegen.visit_expression (this);
+ }
+
public override void get_defined_variables (Collection<LocalVariable> collection) {
container.get_defined_variables (collection);
foreach (Expression index in indices) {
/* valaemptystatement.vala
*
- * Copyright (C) 2006-2007 Jürg Billeter
+ * Copyright (C) 2006-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
public override void accept (CodeVisitor visitor) {
visitor.visit_empty_statement (this);
}
+
+ public override void emit (CodeGenerator codegen) {
+ codegen.visit_empty_statement (this);
+ }
}
return !error;
}
+ public override void emit (CodeGenerator codegen) {
+ expression.emit (codegen);
+
+ codegen.visit_expression_statement (this);
+ }
+
public override void get_defined_variables (Collection<LocalVariable> collection) {
expression.get_defined_variables (collection);
}
return !error;
}
+ public override void emit (CodeGenerator codegen) {
+ if (use_iterator) {
+ base.emit (codegen);
+ return;
+ }
+
+ collection.emit (codegen);
+ codegen.visit_end_full_expression (collection);
+
+ element_variable.active = true;
+ collection_variable.active = true;
+ if (iterator_variable != null) {
+ iterator_variable.active = true;
+ }
+
+ codegen.visit_foreach_statement (this);
+ }
+
public override void get_defined_variables (Collection<LocalVariable> collection) {
collection.add (element_variable);
}
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ condition.emit (codegen);
+
+ codegen.visit_end_full_expression (condition);
+
+ codegen.visit_if_statement (this);
+ }
}
/* valainitializerlist.vala
*
- * Copyright (C) 2006-2009 Jürg Billeter
+ * Copyright (C) 2006-2010 Jürg Billeter
* Copyright (C) 2006-2008 Raffaele Sandrini
*
* This library is free software; you can redistribute it and/or
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ foreach (Expression expr in initializers) {
+ expr.emit (codegen);
+ }
+
+ codegen.visit_initializer_list (this);
+ }
}
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ codegen.visit_integer_literal (this);
+
+ codegen.visit_expression (this);
+ }
}
return !error;
}
+ public override void emit (CodeGenerator codegen) {
+ codegen.visit_lambda_expression (this);
+
+ codegen.visit_expression (this);
+ }
+
public override void get_used_variables (Collection<LocalVariable> collection) {
// require captured variables to be initialized
if (method.closure) {
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ foreach (Expression expr in expression_list) {
+ expr.emit (codegen);
+ }
+
+ codegen.visit_list_literal (this);
+
+ codegen.visit_expression (this);
+ }
}
/* valalockstatement.vala
*
* Copyright (C) 2009 Jiří Zárevúcky
- * Copyright (C) 2006-2007 Raffaele Sandrini, Jürg Billeter
+ * Copyright (C) 2006-2010 Jürg Billeter
+ * Copyright (C) 2006-2007 Raffaele Sandrini
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ resource.emit (codegen);
+ codegen.visit_lock_statement (this);
+ }
}
/* valaloop.vala
*
- * Copyright (C) 2009 Jürg Billeter
+ * Copyright (C) 2009-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ codegen.visit_loop (this);
+ }
}
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ for (int i = 0; i < keys.size; i++) {
+ keys[i].emit (codegen);
+ values[i].emit (codegen);
+ }
+
+ codegen.visit_map_literal (this);
+
+ codegen.visit_expression (this);
+ }
}
return !error;
}
+ public override void emit (CodeGenerator codegen) {
+ if (inner != null) {
+ inner.emit (codegen);
+ }
+
+ codegen.visit_member_access (this);
+
+ codegen.visit_expression (this);
+ }
+
public override void get_defined_variables (Collection<LocalVariable> collection) {
if (inner != null) {
inner.get_defined_variables (collection);
/* valamemberinitializer.vala
*
- * Copyright (C) 2007-2009 Jürg Billeter
+ * Copyright (C) 2007-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
return initializer.check (analyzer);
}
+ public override void emit (CodeGenerator codegen) {
+ initializer.emit (codegen);
+ }
+
public override void replace_expression (Expression old_node, Expression new_node) {
if (initializer == old_node) {
initializer = new_node;
return !error;
}
+ public override void emit (CodeGenerator codegen) {
+ var method_type = call.value_type as MethodType;
+
+ if (method_type != null && method_type.method_symbol.parent_symbol is Signal) {
+ var signal_access = ((MemberAccess) call).inner;
+ signal_access.emit (codegen);
+ } else {
+ call.emit (codegen);
+ }
+
+ foreach (Expression expr in argument_list) {
+ expr.emit (codegen);
+ }
+
+ codegen.visit_method_call (this);
+
+ codegen.visit_expression (this);
+ }
+
public override void get_defined_variables (Collection<LocalVariable> collection) {
call.get_defined_variables (collection);
return !error;
}
+ public override void emit (CodeGenerator codegen) {
+ inner.emit (codegen);
+
+ codegen.visit_named_argument (this);
+
+ codegen.visit_expression (this);
+ }
+
public override void get_defined_variables (Collection<LocalVariable> collection) {
inner.get_defined_variables (collection);
}
/* valanullliteral.vala
*
- * Copyright (C) 2006-2008 Jürg Billeter
+ * Copyright (C) 2006-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ codegen.visit_null_literal (this);
+
+ codegen.visit_expression (this);
+ }
}
return !error;
}
+ public override void emit (CodeGenerator codegen) {
+ foreach (Expression arg in argument_list) {
+ arg.emit (codegen);
+ }
+
+ foreach (MemberInitializer init in object_initializer) {
+ init.emit (codegen);
+ }
+
+ codegen.visit_object_creation_expression (this);
+
+ codegen.visit_expression (this);
+ }
+
public override void get_defined_variables (Collection<LocalVariable> collection) {
foreach (Expression arg in argument_list) {
arg.get_defined_variables (collection);
/* valapointerindirection.vala
*
- * Copyright (C) 2007-2008 Jürg Billeter
+ * Copyright (C) 2007-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
return !error;
}
+ public override void emit (CodeGenerator codegen) {
+ inner.emit (codegen);
+
+ codegen.visit_pointer_indirection (this);
+
+ codegen.visit_expression (this);
+ }
+
public override void get_defined_variables (Collection<LocalVariable> collection) {
inner.get_defined_variables (collection);
}
/* valapostfixexpression.vala
*
- * Copyright (C) 2006-2009 Jürg Billeter
+ * Copyright (C) 2006-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ inner.emit (codegen);
+
+ codegen.visit_postfix_expression (this);
+
+ codegen.visit_expression (this);
+ }
}
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ codegen.visit_real_literal (this);
+
+ codegen.visit_expression (this);
+ }
}
/* valareferencetransferexpression.vala
*
- * Copyright (C) 2007-2008 Jürg Billeter
+ * Copyright (C) 2007-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
return !error;
}
+ public override void emit (CodeGenerator codegen) {
+ inner.emit (codegen);
+
+ codegen.visit_reference_transfer_expression (this);
+
+ codegen.visit_expression (this);
+ }
+
public override void get_defined_variables (Collection<LocalVariable> collection) {
inner.get_defined_variables (collection);
}
/* valaregexliteral.vala
*
* Copyright (C) 2010 Jukka-Pekka Iivonen
+ * Copyright (C) 2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ codegen.visit_regex_literal (this);
+
+ codegen.visit_expression (this);
+ }
}
/* valareturnstatement.vala
*
- * Copyright (C) 2006-2009 Jürg Billeter
+ * Copyright (C) 2006-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
return !error;
}
+ public override void emit (CodeGenerator codegen) {
+ if (return_expression != null) {
+ return_expression.emit (codegen);
+
+ codegen.visit_end_full_expression (return_expression);
+ }
+
+ codegen.visit_return_statement (this);
+ }
+
public override void get_defined_variables (Collection<LocalVariable> collection) {
if (return_expression != null) {
return_expression.get_defined_variables (collection);
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ foreach (Expression expr in expression_list) {
+ expr.emit (codegen);
+ }
+
+ codegen.visit_set_literal (this);
+
+ codegen.visit_expression (this);
+ }
}
/* valasizeofexpression.vala
*
- * Copyright (C) 2006-2009 Jürg Billeter
+ * Copyright (C) 2006-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ codegen.visit_sizeof_expression (this);
+
+ codegen.visit_expression (this);
+ }
}
/* valasliceexpression.vala
*
* Copyright (C) 2009 Robin Sonefors
- * Copyright (C) 2009 Jürg Billeter
+ * Copyright (C) 2009-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
return !error;
}
+ public override void emit (CodeGenerator codegen) {
+ container.emit (codegen);
+
+ start.emit (codegen);
+ stop.emit (codegen);
+
+ codegen.visit_slice_expression (this);
+
+ codegen.visit_expression (this);
+ }
+
public override void get_defined_variables (Collection<LocalVariable> collection) {
container.get_defined_variables (collection);
start.get_defined_variables (collection);
/* valastatementlist.vala
*
- * Copyright (C) 2008 Jürg Billeter
+ * Copyright (C) 2008-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
stmt.accept (visitor);
}
}
+
+ public override void emit (CodeGenerator codegen) {
+ foreach (Statement stmt in list) {
+ stmt.emit (codegen);
+ }
+ }
}
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ codegen.visit_string_literal (this);
+
+ codegen.visit_expression (this);
+ }
}
/* valaswitchlabel.vala
*
- * Copyright (C) 2006-2009 Jürg Billeter
+ * Copyright (C) 2006-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
return true;
}
+
+ public override void emit (CodeGenerator codegen) {
+ codegen.visit_switch_label (this);
+ }
}
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ foreach (SwitchLabel label in labels) {
+ label.emit (codegen);
+ }
+
+ base.emit (codegen);
+ }
}
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ expression.emit (codegen);
+
+ codegen.visit_end_full_expression (expression);
+
+ codegen.visit_switch_statement (this);
+ }
}
return !error;
}
+ public override void emit (CodeGenerator codegen) {
+ if (error_expression != null) {
+ error_expression.emit (codegen);
+
+ codegen.visit_end_full_expression (error_expression);
+ }
+
+ codegen.visit_throw_statement (this);
+ }
+
public override void get_defined_variables (Collection<LocalVariable> collection) {
error_expression.get_defined_variables (collection);
}
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ codegen.visit_try_statement (this);
+ }
}
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ foreach (Expression expr in expression_list) {
+ expr.emit (codegen);
+ }
+
+ codegen.visit_tuple (this);
+
+ codegen.visit_expression (this);
+ }
}
/* valatypecheck.vala
*
- * Copyright (C) 2006-2009 Jürg Billeter
+ * Copyright (C) 2006-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ expression.emit (codegen);
+
+ codegen.visit_type_check (this);
+
+ codegen.visit_expression (this);
+ }
}
/* valatypeofexpression.vala
*
- * Copyright (C) 2006-2009 Jürg Billeter
+ * Copyright (C) 2006-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ codegen.visit_typeof_expression (this);
+
+ codegen.visit_expression (this);
+ }
}
return !error;
}
+ public override void emit (CodeGenerator codegen) {
+ inner.emit (codegen);
+
+ codegen.visit_unary_expression (this);
+
+ codegen.visit_expression (this);
+ }
+
public override void get_defined_variables (Collection<LocalVariable> collection) {
inner.get_defined_variables (collection);
if (operator == UnaryOperator.OUT || operator == UnaryOperator.REF) {
/* valaunlockstatement.vala
*
- * Copyright (C) 2009 Jiří Zárevúcky, Jürg Billeter
+ * Copyright (C) 2009-2010 Jürg Billeter
+ * Copyright (C) 2009 Jiří Zárevúcky
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ resource.emit (codegen);
+ codegen.visit_unlock_statement (this);
+ }
}
/* valayieldstatement.vala
*
- * Copyright (C) 2008 Jürg Billeter
+ * Copyright (C) 2008-2010 Jürg Billeter
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
return !error;
}
+
+ public override void emit (CodeGenerator codegen) {
+ if (yield_expression != null) {
+ yield_expression.emit (codegen);
+
+ codegen.visit_end_full_expression (yield_expression);
+ }
+
+ codegen.visit_yield_statement (this);
+ }
}
projects / thirdparty / vala.git / commitdiff
