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); }