public static CCodeMacroReplacement with_expression(string name, CCodeExpression replacement_expression)
{
CCodeMacroReplacement @this = new CCodeMacroReplacement(name, null);
@this.replacement_expression = replacement_expression;
return(@this);
}
CCodeExpression serialize_basic(BasicTypeInfo basic_type, CCodeExpression expr)
{
var new_call = new CCodeFunctionCall(new CCodeIdentifier("g_variant_new_" + basic_type.type_name));
new_call.add_argument(expr);
return(new_call);
}
public override void return_with_exception(CCodeExpression error_expr)
{
if (!is_in_coroutine())
{
base.return_with_exception(error_expr);
return;
}
var async_result_expr = CCodeMemberAccess.pointer(new CCodeIdentifier("_data_"), "_async_result");
CCodeFunctionCall set_error = null;
set_error = new CCodeFunctionCall(new CCodeIdentifier("g_task_return_error"));
set_error.add_argument(async_result_expr);
set_error.add_argument(error_expr);
ccode.add_expression(set_error);
append_local_free(current_symbol, false);
// We already returned the error above, we must not return anything else here.
var unref = new CCodeFunctionCall(new CCodeIdentifier("g_object_unref"));
unref.add_argument(async_result_expr);
ccode.add_expression(unref);
ccode.add_return(new CCodeConstant("FALSE"));
}
CCodeExpression serialize_buffer_array(ArrayType array_type, CCodeExpression array_expr)
{
string buffer_name = "_tmp%d_".printf(next_temp_var_id++);
var gvariant_type = new CCodeFunctionCall(new CCodeIdentifier("G_VARIANT_TYPE"));
gvariant_type.add_argument(new CCodeConstant("\"%s\"".printf(get_type_signature(array_type))));
var dup_call = new CCodeFunctionCall(new CCodeIdentifier("g_memdup"));
dup_call.add_argument(array_expr);
dup_call.add_argument(get_array_length(array_expr, 1));
ccode.add_declaration(get_ccode_name(array_type), new CCodeVariableDeclarator(buffer_name, dup_call));
var new_call = new CCodeFunctionCall(new CCodeIdentifier("g_variant_new_from_data"));
new_call.add_argument(gvariant_type);
new_call.add_argument(new CCodeIdentifier(buffer_name));
new_call.add_argument(get_array_length(array_expr, 1));
new_call.add_argument(new CCodeConstant("TRUE"));
new_call.add_argument(new CCodeIdentifier("g_free"));
new_call.add_argument(new CCodeIdentifier(buffer_name));
return(new_call);
}
public override CCodeExpression get_array_length_cvalue(TargetValue value, int dim = -1)
{
var array_type = value.value_type as ArrayType;
if (array_type != null && array_type.fixed_length)
{
return(get_ccodenode(array_type.length));
}
// dim == -1 => total size over all dimensions
if (dim == -1)
{
if (array_type != null && array_type.rank > 1)
{
CCodeExpression cexpr = get_array_length_cvalue(value, 1);
for (dim = 2; dim <= array_type.rank; dim++)
{
cexpr = new CCodeBinaryExpression(CCodeBinaryOperator.MUL, cexpr, get_array_length_cvalue(value, dim));
}
return(cexpr);
}
else
{
dim = 1;
}
}
List <CCodeExpression> size = ((GLibValue)value).array_length_cvalues;
Debug.Assert(size != null && size.Count >= dim);
return(size[dim - 1]);
}
CCodeExpression deserialize_buffer_array(ArrayType array_type, CCodeExpression variant_expr, CCodeExpression expr)
{
string temp_name = "_tmp%d_".printf(next_temp_var_id++);
var get_data_call = new CCodeFunctionCall(new CCodeIdentifier("g_variant_get_data"));
get_data_call.add_argument(variant_expr);
var get_size_call = new CCodeFunctionCall(new CCodeIdentifier("g_variant_get_size"));
get_size_call.add_argument(variant_expr);
ccode.add_declaration("gsize", new CCodeVariableDeclarator(temp_name + "_length", get_size_call));
var length = new CCodeIdentifier(temp_name + "_length");
var dup_call = new CCodeFunctionCall(new CCodeIdentifier("g_memdup"));
dup_call.add_argument(get_data_call);
dup_call.add_argument(length);
ccode.add_declaration(get_ccode_name(array_type), new CCodeVariableDeclarator(temp_name, dup_call));
if (expr != null)
{
ccode.add_assignment(get_array_length(expr, 1), length);
}
return(new CCodeIdentifier(temp_name));
}
CCodeExpression get_file_descriptor(DataType type, CCodeExpression expr)
{
if (type is ObjectType)
{
if (type.data_type.get_full_name() == "GLib.UnixInputStream")
{
var result = new CCodeFunctionCall(new CCodeIdentifier("g_unix_input_stream_get_fd"));
result.add_argument(expr);
return(result);
}
else if (type.data_type.get_full_name() == "GLib.UnixOutputStream")
{
var result = new CCodeFunctionCall(new CCodeIdentifier("g_unix_output_stream_get_fd"));
result.add_argument(expr);
return(result);
}
else if (type.data_type.get_full_name() == "GLib.Socket")
{
var result = new CCodeFunctionCall(new CCodeIdentifier("g_socket_get_fd"));
result.add_argument(expr);
return(result);
}
else if (type.data_type.get_full_name() == "GLib.FileDescriptorBased")
{
var result = new CCodeFunctionCall(new CCodeIdentifier("g_file_descriptor_based_get_fd"));
result.add_argument(expr);
return(result);
}
}
return(null);
}
CCodeExpression deserialize_array(ArrayType array_type, CCodeExpression variant_expr, CCodeExpression expr)
{
if (array_type.rank == 1 && get_type_signature(array_type) == "ay")
{
return(deserialize_buffer_array(array_type, variant_expr, expr));
}
string temp_name = "_tmp%d_".printf(next_temp_var_id++);
var new_call = new CCodeFunctionCall(new CCodeIdentifier("g_new"));
new_call.add_argument(new CCodeIdentifier(get_ccode_name(array_type.element_type)));
// add one extra element for NULL-termination
new_call.add_argument(new CCodeConstant("5"));
ccode.add_declaration(get_ccode_name(array_type), new CCodeVariableDeclarator(temp_name, new_call));
ccode.add_declaration("int", new CCodeVariableDeclarator(temp_name + "_length", new CCodeConstant("0")));
ccode.add_declaration("int", new CCodeVariableDeclarator(temp_name + "_size", new CCodeConstant("4")));
deserialize_array_dim(array_type, 1, temp_name, variant_expr, expr);
if (array_type.element_type.is_reference_type_or_type_parameter())
{
// NULL terminate array
var length = new CCodeIdentifier(temp_name + "_length");
var element_access = new CCodeElementAccess(new CCodeIdentifier(temp_name), length);
ccode.add_assignment(element_access, new CCodeIdentifier("NULL"));
}
return(new CCodeIdentifier(temp_name));
}
CCodeExpression get_array_length(CCodeExpression expr, int dim)
{
var id = expr as CCodeIdentifier;
var ma = expr as CCodeMemberAccess;
if (id != null)
{
return(new CCodeIdentifier("%s_length%d".printf(id.name, dim)));
}
else if (ma != null)
{
if (ma.is_pointer)
{
return(CCodeMemberAccess.pointer(ma.inner, "%s_length%d".printf(ma.member_name, dim)));
}
else
{
return(new CCodeMemberAccess(ma.inner, "%s_length%d".printf(ma.member_name, dim)));
}
}
else
{
// must be NULL-terminated
var len_call = new CCodeFunctionCall(new CCodeIdentifier("g_strv_length"));
len_call.add_argument(expr);
return(len_call);
}
}
public static CCodeVariableDeclarator zero(string name, CCodeExpression initializer, CCodeDeclaratorSuffix declarator_suffix = null)
{
CCodeVariableDeclarator @this = new CCodeVariableDeclarator(name, initializer, declarator_suffix);
@this.init0 = true;
return(@this);
}
public virtual void return_with_exception(CCodeExpression error_expr)
{
var cpropagate = new CCodeFunctionCall(new CCodeIdentifier("g_propagate_error"));
cpropagate.add_argument(new CCodeIdentifier("error"));
cpropagate.add_argument(error_expr);
ccode.add_expression(cpropagate);
// free local variables
append_local_free(current_symbol, false);
if (current_method is CreationMethod && current_method.parent_symbol is Class)
{
var cl = (Class)current_method.parent_symbol;
ccode.add_expression(destroy_value(new GLibValue(new ObjectType(cl), new CCodeIdentifier("self"), true)));
ccode.add_return(new CCodeConstant("NULL"));
}
else if (is_in_coroutine())
{
ccode.add_return(new CCodeConstant("FALSE"));
}
else
{
return_default_value(current_return_type);
}
}
CCodeExpression create_from_file_descriptor(DataType type, CCodeExpression expr)
{
if (type is ObjectType)
{
if (type.data_type.get_full_name() == "GLib.UnixInputStream")
{
var result = new CCodeFunctionCall(new CCodeIdentifier("g_unix_input_stream_new"));
result.add_argument(expr);
result.add_argument(new CCodeConstant("TRUE"));
return(new CCodeCastExpression(result, "GUnixInputStream *"));
}
else if (type.data_type.get_full_name() == "GLib.UnixOutputStream")
{
var result = new CCodeFunctionCall(new CCodeIdentifier("g_unix_output_stream_new"));
result.add_argument(expr);
result.add_argument(new CCodeConstant("TRUE"));
return(new CCodeCastExpression(result, "GUnixOutputStream *"));
}
else if (type.data_type.get_full_name() == "GLib.Socket")
{
var result = new CCodeFunctionCall(new CCodeIdentifier("g_socket_new_from_fd"));
result.add_argument(expr);
result.add_argument(new CCodeConstant("NULL"));
return(result);
}
}
return(null);
}
public static CCodeDeclaratorSuffix with_array(CCodeExpression array_length = null)
{
CCodeDeclaratorSuffix @this = new CCodeDeclaratorSuffix();
@this.array_length = array_length;
@this.array = true;
return(@this);
}
public override CCodeExpression deserialize_expression(DataType type, CCodeExpression variant_expr, CCodeExpression expr, out bool may_fail, CCodeExpression error_expr = null)
{
BasicTypeInfo basic_type;
CCodeExpression result = null;
may_fail = false;
if (is_string_marshalled_enum(type.data_type))
{
get_basic_type_info("s", out basic_type);
result = deserialize_basic(basic_type, variant_expr, true);
result = generate_enum_value_from_string(type as EnumValueType, result, error_expr);
may_fail = true;
}
else if (get_basic_type_info(get_type_signature(type), out basic_type))
{
result = deserialize_basic(basic_type, variant_expr);
}
else if (type is ArrayType)
{
result = deserialize_array((ArrayType)type, variant_expr, expr);
}
else if (type.data_type is Struct)
{
var st = (Struct)type.data_type;
result = deserialize_struct(st, variant_expr);
if (result != null && type.nullable)
{
var csizeof = new CCodeFunctionCall(new CCodeIdentifier("sizeof"));
csizeof.add_argument(new CCodeIdentifier(get_ccode_name(st)));
var cdup = new CCodeFunctionCall(new CCodeIdentifier("g_memdup"));
cdup.add_argument(new CCodeUnaryExpression(CCodeUnaryOperator.ADDRESS_OF, result));
cdup.add_argument(csizeof);
result = cdup;
}
}
else if (type is ObjectType)
{
if (type.data_type.get_full_name() == "GLib.Variant")
{
var variant_get = new CCodeFunctionCall(new CCodeIdentifier("g_variant_get_variant"));
variant_get.add_argument(variant_expr);
result = variant_get;
}
else if (type.data_type.get_full_name() == "GLib.HashTable")
{
result = deserialize_hash_table((ObjectType)type, variant_expr);
}
}
if (result == null)
{
Report.error(type.source_reference, "GVariant deserialization of type `%s' is not supported".printf(type.ToString()));
}
return(result);
}
private void write_expression(CCodeWriter writer, CCodeExpression expr)
{
writer.write_indent(line);
if (expr != null)
{
expr.write(writer);
}
writer.write_string(";");
writer.write_newline();
}
CCodeExpression serialize_array_dim(ArrayType array_type, int dim, CCodeExpression array_expr, CCodeExpression array_iter_expr)
{
string builder_name = "_tmp%d_".printf(next_temp_var_id++);
string index_name = "_tmp%d_".printf(next_temp_var_id++);
ccode.add_declaration("GVariantBuilder", new CCodeVariableDeclarator(builder_name));
ccode.add_declaration("int", new CCodeVariableDeclarator(index_name));
var gvariant_type = new CCodeFunctionCall(new CCodeIdentifier("G_VARIANT_TYPE"));
gvariant_type.add_argument(new CCodeConstant("\"%s\"".printf(get_type_signature(array_type))));
var builder_init = new CCodeFunctionCall(new CCodeIdentifier("g_variant_builder_init"));
builder_init.add_argument(new CCodeUnaryExpression(CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier(builder_name)));
builder_init.add_argument(gvariant_type);
ccode.add_expression(builder_init);
var cforinit = new CCodeAssignment(new CCodeIdentifier(index_name), new CCodeConstant("0"));
var cforcond = new CCodeBinaryExpression(CCodeBinaryOperator.LESS_THAN, new CCodeIdentifier(index_name), get_array_length(array_expr, dim));
var cforiter = new CCodeUnaryExpression(CCodeUnaryOperator.POSTFIX_INCREMENT, new CCodeIdentifier(index_name));
ccode.open_for(cforinit, cforcond, cforiter);
CCodeExpression element_variant;
if (dim < array_type.rank)
{
element_variant = serialize_array_dim(array_type, dim + 1, array_expr, array_iter_expr);
}
else
{
var element_expr = new CCodeUnaryExpression(CCodeUnaryOperator.POINTER_INDIRECTION, array_iter_expr);
element_variant = serialize_expression(array_type.element_type, element_expr);
}
var builder_add = new CCodeFunctionCall(new CCodeIdentifier("g_variant_builder_add_value"));
builder_add.add_argument(new CCodeUnaryExpression(CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier(builder_name)));
builder_add.add_argument(element_variant);
ccode.add_expression(builder_add);
if (dim == array_type.rank)
{
var array_iter_incr = new CCodeUnaryExpression(CCodeUnaryOperator.POSTFIX_INCREMENT, array_iter_expr);
ccode.add_expression(array_iter_incr);
}
ccode.close();
var builder_end = new CCodeFunctionCall(new CCodeIdentifier("g_variant_builder_end"));
builder_end.add_argument(new CCodeUnaryExpression(CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier(builder_name)));
return(builder_end);
}
CCodeExpression generate_enum_value_to_string(EnumValueType type, CCodeExpression expr)
{
var en = type.type_symbol as ValaEnum;
var to_string_name = "%s_to_string".printf(get_ccode_lower_case_name(en, null));
var to_string_call = new CCodeFunctionCall(new CCodeIdentifier(to_string_name));
to_string_call.add_argument(expr);
return(to_string_call);
}
public void open_switch(CCodeExpression expression)
{
statement_stack.Add(current_block);
var parent_block = current_block;
var cswitch = new CCodeSwitchStatement(expression);
cswitch.line = current_line;
current_block = cswitch;
parent_block.add_statement(cswitch);
}
CCodeExpression generate_enum_value_from_string(EnumValueType type, CCodeExpression expr, CCodeExpression error_expr)
{
var en = type.type_symbol as ValaEnum;
var from_string_name = "%s_from_string".printf(get_ccode_lower_case_name(en, null));
var from_string_call = new CCodeFunctionCall(new CCodeIdentifier(from_string_name));
from_string_call.add_argument(expr);
from_string_call.add_argument(error_expr != null ? error_expr : new CCodeConstant("NULL"));
return(from_string_call);
}
public void open_while(CCodeExpression condition)
{
statement_stack.Add(current_block);
var parent_block = current_block;
current_block = new CCodeBlock();
var cwhile = new CCodeWhileStatement(condition, current_block);
cwhile.line = current_line;
parent_block.add_statement(cwhile);
}
void uncaught_error_statement(CCodeExpression inner_error, bool unexpected = false)
{
// free local variables
append_local_free(current_symbol, false);
var ccritical = new CCodeFunctionCall(new CCodeIdentifier("g_critical"));
ccritical.add_argument(new CCodeConstant(unexpected ? "\"file %s: line %d: unexpected error: %s (%s, %d)\"" : "\"file %s: line %d: uncaught error: %s (%s, %d)\""));
ccritical.add_argument(new CCodeConstant("__FILE__"));
ccritical.add_argument(new CCodeConstant("__LINE__"));
ccritical.add_argument(CCodeMemberAccess.pointer(inner_error, "message"));
var domain_name = new CCodeFunctionCall(new CCodeIdentifier("g_quark_to_string"));
domain_name.add_argument(CCodeMemberAccess.pointer(inner_error, "domain"));
ccritical.add_argument(domain_name);
ccritical.add_argument(CCodeMemberAccess.pointer(inner_error, "code"));
var cclear = new CCodeFunctionCall(new CCodeIdentifier("g_clear_error"));
cclear.add_argument(new CCodeUnaryExpression(CCodeUnaryOperator.ADDRESS_OF, inner_error));
// print critical message
ccode.add_expression(ccritical);
ccode.add_expression(cclear);
if (is_in_constructor() || is_in_destructor())
{
// just print critical, do not return prematurely
}
else if (current_method is CreationMethod)
{
if (current_method.parent_symbol is Struct)
{
ccode.add_return();
}
else
{
ccode.add_return(new CCodeConstant("NULL"));
}
}
else if (is_in_coroutine())
{
var async_result_expr = CCodeMemberAccess.pointer(new CCodeIdentifier("_data_"), "_async_result");
var unref = new CCodeFunctionCall(new CCodeIdentifier("g_object_unref"));
unref.add_argument(async_result_expr);
ccode.add_expression(unref);
ccode.add_return(new CCodeConstant("FALSE"));
}
else if (current_return_type != null)
{
return_default_value(current_return_type);
}
}
public void receive_dbus_value(DataType type, CCodeExpression message_expr, CCodeExpression iter_expr, CCodeExpression target_expr, Symbol sym, out bool may_fail, CCodeExpression error_expr = null)
{
may_fail = true;
var fd_list = new CCodeFunctionCall(new CCodeIdentifier("g_dbus_message_get_unix_fd_list"));
fd_list.add_argument(message_expr);
var fd_var = new CCodeIdentifier("_fd");
var stream = create_from_file_descriptor(type, fd_var);
if (stream != null)
{
var fd_list_var = new CCodeIdentifier("_fd_list");
var fd = new CCodeFunctionCall(new CCodeIdentifier("g_unix_fd_list_get"));
fd.add_argument(fd_list_var);
fd.add_argument(new CCodeIdentifier("_fd_index"));
fd.add_argument(error_expr);
ccode.add_assignment(fd_list_var, fd_list);
ccode.open_if(fd_list_var);
var get_fd = new CCodeFunctionCall(new CCodeIdentifier("g_variant_iter_next"));
get_fd.add_argument(new CCodeUnaryExpression(CCodeUnaryOperator.ADDRESS_OF, iter_expr));
get_fd.add_argument(new CCodeConstant("\"h\""));
get_fd.add_argument(new CCodeUnaryExpression(CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier("_fd_index")));
ccode.add_expression(get_fd);
ccode.add_assignment(fd_var, fd);
ccode.open_if(new CCodeBinaryExpression(CCodeBinaryOperator.GREATER_THAN_OR_EQUAL, fd_var, new CCodeConstant("0")));
ccode.add_assignment(target_expr, stream);
may_fail = true;
ccode.close();
ccode.add_else();
var set_error = new CCodeFunctionCall(new CCodeIdentifier("g_set_error_literal"));
set_error.add_argument(error_expr);
set_error.add_argument(new CCodeIdentifier("G_IO_ERROR"));
set_error.add_argument(new CCodeIdentifier("G_IO_ERROR_FAILED"));
set_error.add_argument(new CCodeConstant("\"FD List is NULL\""));
ccode.add_expression(set_error);
ccode.close();
}
else
{
read_expression(type, iter_expr, target_expr, sym, out may_fail, error_expr);
}
}
public void open_if(CCodeExpression condition)
{
statement_stack.Add(current_block);
var parent_block = current_block;
current_block = new CCodeBlock();
var cif = new CCodeIfStatement(condition, current_block);
cif.line = current_line;
statement_stack.Add(cif);
parent_block.add_statement(cif);
}
CCodeExpression serialize_array(ArrayType array_type, CCodeExpression array_expr)
{
if (array_type.rank == 1 && get_type_signature(array_type) == "ay")
{
return(serialize_buffer_array(array_type, array_expr));
}
string array_iter_name = "_tmp%d_".printf(next_temp_var_id++);
ccode.add_declaration(get_ccode_name(array_type), new CCodeVariableDeclarator(array_iter_name));
ccode.add_assignment(new CCodeIdentifier(array_iter_name), array_expr);
return(serialize_array_dim(array_type, 1, array_expr, new CCodeIdentifier(array_iter_name)));
}
private void add_guarded_expression(Symbol sym, CCodeExpression expression)
{
// prevent deprecation warnings
if (sym.version.deprecated)
{
var guard = new CCodeGGnucSection(GGnucSectionType.IGNORE_DEPRECATIONS);
ccode.add_statement(guard);
guard.append(new CCodeExpressionStatement(expression));
}
else
{
ccode.add_expression(expression);
}
}
public override CCodeExpression serialize_expression(DataType type, CCodeExpression expr)
{
BasicTypeInfo basic_type;
CCodeExpression result = null;
if (is_string_marshalled_enum(type.data_type))
{
get_basic_type_info("s", out basic_type);
result = generate_enum_value_to_string(type as EnumValueType, expr);
result = serialize_basic(basic_type, result);
}
else if (get_basic_type_info(get_type_signature(type), out basic_type))
{
result = serialize_basic(basic_type, expr);
}
else if (type is ArrayType)
{
result = serialize_array((ArrayType)type, expr);
}
else if (type.data_type is Struct)
{
var st_expr = expr;
if (type.nullable)
{
st_expr = new CCodeUnaryExpression(CCodeUnaryOperator.POINTER_INDIRECTION, st_expr);
}
result = serialize_struct((Struct)type.data_type, st_expr);
}
else if (type is ObjectType)
{
if (type.data_type.get_full_name() == "GLib.Variant")
{
var variant_new = new CCodeFunctionCall(new CCodeIdentifier("g_variant_new_variant"));
variant_new.add_argument(expr);
result = variant_new;
}
else if (type.data_type.get_full_name() == "GLib.HashTable")
{
result = serialize_hash_table((ObjectType)type, expr);
}
}
if (result == null)
{
Report.error(type.source_reference, "GVariant serialization of type `%s' is not supported".printf(type.ToString()));
}
return(result);
}
void append_initializer_list(CCodeExpression name_cnode, InitializerList initializer_list, int rank, ref int i)
{
foreach (Expression e in initializer_list.get_initializers())
{
if (rank > 1)
{
append_initializer_list(name_cnode, (InitializerList)e, rank - 1, ref i);
}
else
{
ccode.add_assignment(new CCodeElementAccess(name_cnode, new CCodeConstant(i.ToString())), get_cvalue(e));
i++;
}
}
}
public void else_if(CCodeExpression condition)
{
var parent_if = (CCodeIfStatement)statement_stack[statement_stack.Count - 1];
statement_stack.RemoveAt(statement_stack.Count - 1);
Debug.Assert(parent_if.false_statement == null);
current_block = new CCodeBlock();
var cif = new CCodeIfStatement(condition, current_block);
cif.line = current_line;
parent_if.false_statement = cif;
statement_stack.Add(cif);
}
public void write_expression(DataType type, CCodeExpression builder_expr, CCodeExpression expr, Symbol sym)
{
var variant_expr = expr;
if (sym == null || get_dbus_signature(sym) == null)
{
// perform boxing
variant_expr = serialize_expression(type, expr);
}
if (variant_expr != null)
{
var builder_add = new CCodeFunctionCall(new CCodeIdentifier("g_variant_builder_add_value"));
builder_add.add_argument(new CCodeUnaryExpression(CCodeUnaryOperator.ADDRESS_OF, builder_expr));
builder_add.add_argument(variant_expr);
ccode.add_expression(builder_add);
}
}
public void open_for(CCodeExpression initializer, CCodeExpression condition, CCodeExpression iterator)
{
statement_stack.Add(current_block);
var parent_block = current_block;
current_block = new CCodeBlock();
var cfor = new CCodeForStatement(condition, current_block);
cfor.line = current_line;
if (initializer != null)
{
cfor.add_initializer(initializer);
}
if (iterator != null)
{
cfor.add_iterator(iterator);
}
parent_block.add_statement(cfor);
}
