codegen/valaccodebasemodule.vala

   1 /* valaccodebasemodule.vala
   2  *
   3  * Copyright (C) 2006-2011  Jürg Billeter
   4  * Copyright (C) 2006-2008  Raffaele Sandrini
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  19  *
  20  * Author:
  21  *      Jürg Billeter <j@bitron.ch>
  22  *      Raffaele Sandrini <raffaele@sandrini.ch>
  23  */
  24
  25
  26 /**
  27  * Code visitor generating C Code.
  28  */
  29 public abstract class Vala.CCodeBaseModule : CodeGenerator {
  30         public class EmitContext {
  31                 public Symbol? current_symbol;
  32                 public ArrayList<Symbol> symbol_stack = new ArrayList<Symbol> ();
  33                 public TryStatement current_try;
  34                 public CatchClause current_catch;
  35                 public CCodeFunction ccode;
  36                 public ArrayList<CCodeFunction> ccode_stack = new ArrayList<CCodeFunction> ();
  37                 public ArrayList<LocalVariable> temp_ref_vars = new ArrayList<LocalVariable> ();
  38                 public int next_temp_var_id;
  39                 public bool current_method_inner_error;
  40                 public bool current_method_return;
  41                 public Map<string,string> variable_name_map = new HashMap<string,string> (str_hash, str_equal);
  42
  43                 public EmitContext (Symbol? symbol = null) {
  44                         current_symbol = symbol;
  45                 }
  46
  47                 public void push_symbol (Symbol symbol) {
  48                         symbol_stack.add (current_symbol);
  49                         current_symbol = symbol;
  50                 }
  51
  52                 public void pop_symbol () {
  53                         current_symbol = symbol_stack[symbol_stack.size - 1];
  54                         symbol_stack.remove_at (symbol_stack.size - 1);
  55                 }
  56         }
  57
  58         public CodeContext context { get; set; }
  59
  60         public Symbol root_symbol;
  61
  62         public EmitContext emit_context = new EmitContext ();
  63
  64         List<EmitContext> emit_context_stack = new ArrayList<EmitContext> ();
  65
  66         public Symbol current_symbol { get { return emit_context.current_symbol; } }
  67
  68         public TryStatement current_try {
  69                 get { return emit_context.current_try; }
  70                 set { emit_context.current_try = value; }
  71         }
  72
  73         public CatchClause current_catch {
  74                 get { return emit_context.current_catch; }
  75                 set { emit_context.current_catch = value; }
  76         }
  77
  78         public TypeSymbol? current_type_symbol {
  79                 get {
  80                         var sym = current_symbol;
  81                         while (sym != null) {
  82                                 if (sym is TypeSymbol) {
  83                                         return (TypeSymbol) sym;
  84                                 }
  85                                 sym = sym.parent_symbol;
  86                         }
  87                         return null;
  88                 }
  89         }
  90
  91         public Class? current_class {
  92                 get { return current_type_symbol as Class; }
  93         }
  94
  95         public Method? current_method {
  96                 get {
  97                         var sym = current_symbol;
  98                         while (sym is Block) {
  99                                 sym = sym.parent_symbol;
 100                         }
 101                         return sym as Method;
 102                 }
 103         }
 104
 105         public PropertyAccessor? current_property_accessor {
 106                 get {
 107                         var sym = current_symbol;
 108                         while (sym is Block) {
 109                                 sym = sym.parent_symbol;
 110                         }
 111                         return sym as PropertyAccessor;
 112                 }
 113         }
 114
 115         public DataType? current_return_type {
 116                 get {
 117                         var m = current_method;
 118                         if (m != null) {
 119                                 return m.return_type;
 120                         }
 121
 122                         var acc = current_property_accessor;
 123                         if (acc != null) {
 124                                 if (acc.readable) {
 125                                         return acc.value_type;
 126                                 } else {
 127                                         return void_type;
 128                                 }
 129                         }
 130
 131                         if (is_in_constructor () || is_in_destructor ()) {
 132                                 return void_type;
 133                         }
 134
 135                         return null;
 136                 }
 137         }
 138
 139         public bool is_in_coroutine () {
 140                 return current_method != null && current_method.coroutine;
 141         }
 142
 143         public bool is_in_constructor () {
 144                 if (current_method != null) {
 145                         // make sure to not return true in lambda expression inside constructor
 146                         return false;
 147                 }
 148                 var sym = current_symbol;
 149                 while (sym != null) {
 150                         if (sym is Constructor) {
 151                                 return true;
 152                         }
 153                         sym = sym.parent_symbol;
 154                 }
 155                 return false;
 156         }
 157
 158         public bool is_in_destructor () {
 159                 if (current_method != null) {
 160                         // make sure to not return true in lambda expression inside constructor
 161                         return false;
 162                 }
 163                 var sym = current_symbol;
 164                 while (sym != null) {
 165                         if (sym is Destructor) {
 166                                 return true;
 167                         }
 168                         sym = sym.parent_symbol;
 169                 }
 170                 return false;
 171         }
 172
 173         public Block? current_closure_block {
 174                 get {
 175                         return next_closure_block (current_symbol);
 176                 }
 177         }
 178
 179         public unowned Block? next_closure_block (Symbol sym) {
 180                 unowned Block block = null;
 181                 while (true) {
 182                         block = sym as Block;
 183                         if (!(sym is Block || sym is Method)) {
 184                                 // no closure block
 185                                 break;
 186                         }
 187                         if (block != null && block.captured) {
 188                                 // closure block found
 189                                 break;
 190                         }
 191                         sym = sym.parent_symbol;
 192                 }
 193                 return block;
 194         }
 195
 196         public CCodeFile header_file;
 197         public CCodeFile internal_header_file;
 198         public CCodeFile cfile;
 199
 200         public EmitContext class_init_context;
 201         public EmitContext base_init_context;
 202         public EmitContext class_finalize_context;
 203         public EmitContext base_finalize_context;
 204         public EmitContext instance_init_context;
 205         public EmitContext instance_finalize_context;
 206
 207         public CCodeStruct param_spec_struct;
 208         public CCodeStruct closure_struct;
 209         public CCodeEnum prop_enum;
 210
 211         public CCodeFunction ccode { get { return emit_context.ccode; } }
 212
 213         /* temporary variables that own their content */
 214         public ArrayList<LocalVariable> temp_ref_vars { get { return emit_context.temp_ref_vars; } }
 215         /* cache to check whether a certain marshaller has been created yet */
 216         public Set<string> user_marshal_set;
 217         /* (constant) hash table with all predefined marshallers */
 218         public Set<string> predefined_marshal_set;
 219         /* (constant) hash table with all reserved identifiers in the generated code */
 220         Set<string> reserved_identifiers;
 221
 222         public int next_temp_var_id {
 223                 get { return emit_context.next_temp_var_id; }
 224                 set { emit_context.next_temp_var_id = value; }
 225         }
 226
 227         public int next_regex_id = 0;
 228         public bool in_creation_method { get { return current_method is CreationMethod; } }
 229         public bool in_constructor = false;
 230         public bool in_static_or_class_context = false;
 231
 232         public bool current_method_inner_error {
 233                 get { return emit_context.current_method_inner_error; }
 234                 set { emit_context.current_method_inner_error = value; }
 235         }
 236
 237         public bool current_method_return {
 238                 get { return emit_context.current_method_return; }
 239                 set { emit_context.current_method_return = value; }
 240         }
 241
 242         public int next_coroutine_state = 1;
 243         int next_block_id = 0;
 244         Map<Block,int> block_map = new HashMap<Block,int> ();
 245
 246         public DataType void_type = new VoidType ();
 247         public DataType bool_type;
 248         public DataType char_type;
 249         public DataType uchar_type;
 250         public DataType? unichar_type;
 251         public DataType short_type;
 252         public DataType ushort_type;
 253         public DataType int_type;
 254         public DataType uint_type;
 255         public DataType long_type;
 256         public DataType ulong_type;
 257         public DataType int8_type;
 258         public DataType uint8_type;
 259         public DataType int16_type;
 260         public DataType uint16_type;
 261         public DataType int32_type;
 262         public DataType uint32_type;
 263         public DataType int64_type;
 264         public DataType uint64_type;
 265         public DataType string_type;
 266         public DataType regex_type;
 267         public DataType float_type;
 268         public DataType double_type;
 269         public TypeSymbol gtype_type;
 270         public TypeSymbol gobject_type;
 271         public ErrorType gerror_type;
 272         public Class glist_type;
 273         public Class gslist_type;
 274         public Class gnode_type;
 275         public Class gvaluearray_type;
 276         public TypeSymbol gstringbuilder_type;
 277         public TypeSymbol garray_type;
 278         public TypeSymbol gbytearray_type;
 279         public TypeSymbol gptrarray_type;
 280         public TypeSymbol gthreadpool_type;
 281         public DataType gdestroynotify_type;
 282         public DataType gquark_type;
 283         public Struct gvalue_type;
 284         public Class gvariant_type;
 285         public Struct mutex_type;
 286         public TypeSymbol type_module_type;
 287         public TypeSymbol dbus_proxy_type;
 288         public TypeSymbol dbus_object_type;
 289
 290         public bool in_plugin = false;
 291         public string module_init_param_name;
 292
 293         public bool gvaluecollector_h_needed;
 294         public bool requires_array_free;
 295         public bool requires_array_move;
 296         public bool requires_array_length;
 297
 298         public Set<string> wrappers;
 299         Set<Symbol> generated_external_symbols;
 300
 301         public Map<string,string> variable_name_map { get { return emit_context.variable_name_map; } }
 302
 303         public CCodeBaseModule () {
 304                 predefined_marshal_set = new HashSet<string> (str_hash, str_equal);
 305                 predefined_marshal_set.add ("VOID:VOID");
 306                 predefined_marshal_set.add ("VOID:BOOLEAN");
 307                 predefined_marshal_set.add ("VOID:CHAR");
 308                 predefined_marshal_set.add ("VOID:UCHAR");
 309                 predefined_marshal_set.add ("VOID:INT");
 310                 predefined_marshal_set.add ("VOID:UINT");
 311                 predefined_marshal_set.add ("VOID:LONG");
 312                 predefined_marshal_set.add ("VOID:ULONG");
 313                 predefined_marshal_set.add ("VOID:ENUM");
 314                 predefined_marshal_set.add ("VOID:FLAGS");
 315                 predefined_marshal_set.add ("VOID:FLOAT");
 316                 predefined_marshal_set.add ("VOID:DOUBLE");
 317                 predefined_marshal_set.add ("VOID:STRING");
 318                 predefined_marshal_set.add ("VOID:POINTER");
 319                 predefined_marshal_set.add ("VOID:OBJECT");
 320                 predefined_marshal_set.add ("STRING:OBJECT,POINTER");
 321                 predefined_marshal_set.add ("VOID:UINT,POINTER");
 322                 predefined_marshal_set.add ("BOOLEAN:FLAGS");
 323
 324                 reserved_identifiers = new HashSet<string> (str_hash, str_equal);
 325
 326                 // C99 keywords
 327                 reserved_identifiers.add ("_Bool");
 328                 reserved_identifiers.add ("_Complex");
 329                 reserved_identifiers.add ("_Imaginary");
 330                 reserved_identifiers.add ("asm");
 331                 reserved_identifiers.add ("auto");
 332                 reserved_identifiers.add ("break");
 333                 reserved_identifiers.add ("case");
 334                 reserved_identifiers.add ("char");
 335                 reserved_identifiers.add ("const");
 336                 reserved_identifiers.add ("continue");
 337                 reserved_identifiers.add ("default");
 338                 reserved_identifiers.add ("do");
 339                 reserved_identifiers.add ("double");
 340                 reserved_identifiers.add ("else");
 341                 reserved_identifiers.add ("enum");
 342                 reserved_identifiers.add ("extern");
 343                 reserved_identifiers.add ("float");
 344                 reserved_identifiers.add ("for");
 345                 reserved_identifiers.add ("goto");
 346                 reserved_identifiers.add ("if");
 347                 reserved_identifiers.add ("inline");
 348                 reserved_identifiers.add ("int");
 349                 reserved_identifiers.add ("long");
 350                 reserved_identifiers.add ("register");
 351                 reserved_identifiers.add ("restrict");
 352                 reserved_identifiers.add ("return");
 353                 reserved_identifiers.add ("short");
 354                 reserved_identifiers.add ("signed");
 355                 reserved_identifiers.add ("sizeof");
 356                 reserved_identifiers.add ("static");
 357                 reserved_identifiers.add ("struct");
 358                 reserved_identifiers.add ("switch");
 359                 reserved_identifiers.add ("typedef");
 360                 reserved_identifiers.add ("union");
 361                 reserved_identifiers.add ("unsigned");
 362                 reserved_identifiers.add ("void");
 363                 reserved_identifiers.add ("volatile");
 364                 reserved_identifiers.add ("while");
 365
 366                 // MSVC keywords
 367                 reserved_identifiers.add ("cdecl");
 368
 369                 // reserved for Vala/GObject naming conventions
 370                 reserved_identifiers.add ("error");
 371                 reserved_identifiers.add ("result");
 372                 reserved_identifiers.add ("self");
 373         }
 374
 375         public override void emit (CodeContext context) {
 376                 this.context = context;
 377
 378                 root_symbol = context.root;
 379
 380                 bool_type = new BooleanType ((Struct) root_symbol.scope.lookup ("bool"));
 381                 char_type = new IntegerType ((Struct) root_symbol.scope.lookup ("char"));
 382                 uchar_type = new IntegerType ((Struct) root_symbol.scope.lookup ("uchar"));
 383                 short_type = new IntegerType ((Struct) root_symbol.scope.lookup ("short"));
 384                 ushort_type = new IntegerType ((Struct) root_symbol.scope.lookup ("ushort"));
 385                 int_type = new IntegerType ((Struct) root_symbol.scope.lookup ("int"));
 386                 uint_type = new IntegerType ((Struct) root_symbol.scope.lookup ("uint"));
 387                 long_type = new IntegerType ((Struct) root_symbol.scope.lookup ("long"));
 388                 ulong_type = new IntegerType ((Struct) root_symbol.scope.lookup ("ulong"));
 389                 int8_type = new IntegerType ((Struct) root_symbol.scope.lookup ("int8"));
 390                 uint8_type = new IntegerType ((Struct) root_symbol.scope.lookup ("uint8"));
 391                 int16_type = new IntegerType ((Struct) root_symbol.scope.lookup ("int16"));
 392                 uint16_type = new IntegerType ((Struct) root_symbol.scope.lookup ("uint16"));
 393                 int32_type = new IntegerType ((Struct) root_symbol.scope.lookup ("int32"));
 394                 uint32_type = new IntegerType ((Struct) root_symbol.scope.lookup ("uint32"));
 395                 int64_type = new IntegerType ((Struct) root_symbol.scope.lookup ("int64"));
 396                 uint64_type = new IntegerType ((Struct) root_symbol.scope.lookup ("uint64"));
 397                 float_type = new FloatingType ((Struct) root_symbol.scope.lookup ("float"));
 398                 double_type = new FloatingType ((Struct) root_symbol.scope.lookup ("double"));
 399                 string_type = new ObjectType ((Class) root_symbol.scope.lookup ("string"));
 400                 var unichar_struct = (Struct) root_symbol.scope.lookup ("unichar");
 401                 if (unichar_struct != null) {
 402                         unichar_type = new IntegerType (unichar_struct);
 403                 }
 404
 405                 if (context.profile == Profile.GOBJECT) {
 406                         var glib_ns = root_symbol.scope.lookup ("GLib");
 407
 408                         gtype_type = (TypeSymbol) glib_ns.scope.lookup ("Type");
 409                         gobject_type = (TypeSymbol) glib_ns.scope.lookup ("Object");
 410                         gerror_type = new ErrorType (null, null);
 411                         glist_type = (Class) glib_ns.scope.lookup ("List");
 412                         gslist_type = (Class) glib_ns.scope.lookup ("SList");
 413                         gnode_type = (Class) glib_ns.scope.lookup ("Node");
 414                         gvaluearray_type = (Class) glib_ns.scope.lookup ("ValueArray");
 415                         gstringbuilder_type = (TypeSymbol) glib_ns.scope.lookup ("StringBuilder");
 416                         garray_type = (TypeSymbol) glib_ns.scope.lookup ("Array");
 417                         gbytearray_type = (TypeSymbol) glib_ns.scope.lookup ("ByteArray");
 418                         gptrarray_type = (TypeSymbol) glib_ns.scope.lookup ("PtrArray");
 419                         gthreadpool_type = (TypeSymbol) glib_ns.scope.lookup ("ThreadPool");
 420                         gdestroynotify_type = new DelegateType ((Delegate) glib_ns.scope.lookup ("DestroyNotify"));
 421
 422                         gquark_type = new IntegerType ((Struct) glib_ns.scope.lookup ("Quark"));
 423                         gvalue_type = (Struct) glib_ns.scope.lookup ("Value");
 424                         gvariant_type = (Class) glib_ns.scope.lookup ("Variant");
 425                         mutex_type = (Struct) glib_ns.scope.lookup ("StaticRecMutex");
 426
 427                         type_module_type = (TypeSymbol) glib_ns.scope.lookup ("TypeModule");
 428
 429                         regex_type = new ObjectType ((Class) root_symbol.scope.lookup ("GLib").scope.lookup ("Regex"));
 430
 431                         if (context.module_init_method != null) {
 432                                 foreach (Parameter parameter in context.module_init_method.get_parameters ()) {
 433                                         if (parameter.variable_type.data_type == type_module_type) {
 434                                                 in_plugin = true;
 435                                                 module_init_param_name = parameter.name;
 436                                                 break;
 437                                         }
 438                                 }
 439                                 if (!in_plugin) {
 440                                         Report.error (context.module_init_method.source_reference, "[ModuleInit] requires a parameter of type `GLib.TypeModule'");
 441                                 }
 442                         }
 443
 444                         dbus_proxy_type = (TypeSymbol) glib_ns.scope.lookup ("DBusProxy");
 445
 446                         var dbus_ns = root_symbol.scope.lookup ("DBus");
 447                         if (dbus_ns != null) {
 448                                 dbus_object_type = (TypeSymbol) dbus_ns.scope.lookup ("Object");
 449                         }
 450                 }
 451
 452                 header_file = new CCodeFile ();
 453                 header_file.is_header = true;
 454                 internal_header_file = new CCodeFile ();
 455                 internal_header_file.is_header = true;
 456
 457                 /* we're only interested in non-pkg source files */
 458                 var source_files = context.get_source_files ();
 459                 foreach (SourceFile file in source_files) {
 460                         if (file.file_type == SourceFileType.SOURCE ||
 461                             (context.header_filename != null && file.file_type == SourceFileType.FAST)) {
 462                                 file.accept (this);
 463                         }
 464                 }
 465
 466                 // generate symbols file for public API
 467                 if (context.symbols_filename != null) {
 468                         var stream = FileStream.open (context.symbols_filename, "w");
 469                         if (stream == null) {
 470                                 Report.error (null, "unable to open `%s' for writing".printf (context.symbols_filename));
 471                                 return;
 472                         }
 473
 474                         foreach (string symbol in header_file.get_symbols ()) {
 475                                 stream.puts (symbol);
 476                                 stream.putc ('\n');
 477                         }
 478
 479                         stream = null;
 480                 }
 481
 482                 // generate C header file for public API
 483                 if (context.header_filename != null) {
 484                         bool ret;
 485                         if (context.profile == Profile.GOBJECT) {
 486                                 ret = header_file.store (context.header_filename, null, context.version_header, false, "G_BEGIN_DECLS", "G_END_DECLS");
 487                         } else {
 488                                 ret = header_file.store (context.header_filename, null, context.version_header, false);
 489                         }
 490                         if (!ret) {
 491                                 Report.error (null, "unable to open `%s' for writing".printf (context.header_filename));
 492                         }
 493                 }
 494
 495                 // generate C header file for internal API
 496                 if (context.internal_header_filename != null) {
 497                         bool ret;
 498                         if (context.profile == Profile.GOBJECT) {
 499                                 ret = internal_header_file.store (context.internal_header_filename, null, context.version_header, false, "G_BEGIN_DECLS", "G_END_DECLS");
 500                         } else {
 501                                 ret = internal_header_file.store (context.internal_header_filename, null, context.version_header, false);
 502                         }
 503                         if (!ret) {
 504                                 Report.error (null, "unable to open `%s' for writing".printf (context.internal_header_filename));
 505                         }
 506                 }
 507         }
 508
 509         public void push_context (EmitContext emit_context) {
 510                 if (this.emit_context != null) {
 511                         emit_context_stack.add (this.emit_context);
 512                 }
 513
 514                 this.emit_context = emit_context;
 515         }
 516
 517         public void pop_context () {
 518                 if (emit_context_stack.size > 0) {
 519                         this.emit_context = emit_context_stack[emit_context_stack.size - 1];
 520                         emit_context_stack.remove_at (emit_context_stack.size - 1);
 521                 } else {
 522                         this.emit_context = null;
 523                 }
 524         }
 525
 526         public void push_function (CCodeFunction func) {
 527                 emit_context.ccode_stack.add (ccode);
 528                 emit_context.ccode = func;
 529         }
 530
 531         public void pop_function () {
 532                 emit_context.ccode = emit_context.ccode_stack[emit_context.ccode_stack.size - 1];
 533                 emit_context.ccode_stack.remove_at (emit_context.ccode_stack.size - 1);
 534         }
 535
 536         public bool add_symbol_declaration (CCodeFile decl_space, Symbol sym, string name) {
 537                 if (decl_space.add_declaration (name)) {
 538                         return true;
 539                 }
 540                 if (sym.source_reference != null) {
 541                         sym.source_reference.file.used = true;
 542                 }
 543                 if (sym.external_package || (!decl_space.is_header && CodeContext.get ().use_header && !sym.is_internal_symbol ())) {
 544                         // add appropriate include file
 545                         foreach (string header_filename in sym.get_cheader_filenames ()) {
 546                                 decl_space.add_include (header_filename, !sym.external_package);
 547                         }
 548                         // declaration complete
 549                         return true;
 550                 } else {
 551                         // require declaration
 552                         return false;
 553                 }
 554         }
 555
 556         public CCodeIdentifier get_value_setter_function (DataType type_reference) {
 557                 var array_type = type_reference as ArrayType;
 558                 if (type_reference.data_type != null) {
 559                         return new CCodeIdentifier (type_reference.data_type.get_set_value_function ());
 560                 } else if (array_type != null && array_type.element_type.data_type == string_type.data_type) {
 561                         // G_TYPE_STRV
 562                         return new CCodeIdentifier ("g_value_set_boxed");
 563                 } else {
 564                         return new CCodeIdentifier ("g_value_set_pointer");
 565                 }
 566         }
 567
 568         public CCodeIdentifier get_value_taker_function (DataType type_reference) {
 569                 var array_type = type_reference as ArrayType;
 570                 if (type_reference.data_type != null) {
 571                         return new CCodeIdentifier (type_reference.data_type.get_take_value_function ());
 572                 } else if (array_type != null && array_type.element_type.data_type == string_type.data_type) {
 573                         // G_TYPE_STRV
 574                         return new CCodeIdentifier ("g_value_take_boxed");
 575                 } else {
 576                         return new CCodeIdentifier ("g_value_set_pointer");
 577                 }
 578         }
 579
 580         CCodeIdentifier get_value_getter_function (DataType type_reference) {
 581                 var array_type = type_reference as ArrayType;
 582                 if (type_reference.data_type != null) {
 583                         return new CCodeIdentifier (type_reference.data_type.get_get_value_function ());
 584                 } else if (array_type != null && array_type.element_type.data_type == string_type.data_type) {
 585                         // G_TYPE_STRV
 586                         return new CCodeIdentifier ("g_value_get_boxed");
 587                 } else {
 588                         return new CCodeIdentifier ("g_value_get_pointer");
 589                 }
 590         }
 591
 592         public virtual void append_vala_array_free () {
 593         }
 594
 595         public virtual void append_vala_array_move () {
 596         }
 597
 598         public virtual void append_vala_array_length () {
 599         }
 600
 601         public override void visit_source_file (SourceFile source_file) {
 602                 cfile = new CCodeFile ();
 603
 604                 user_marshal_set = new HashSet<string> (str_hash, str_equal);
 605
 606                 next_regex_id = 0;
 607
 608                 gvaluecollector_h_needed = false;
 609                 requires_array_free = false;
 610                 requires_array_move = false;
 611                 requires_array_length = false;
 612
 613                 wrappers = new HashSet<string> (str_hash, str_equal);
 614                 generated_external_symbols = new HashSet<Symbol> ();
 615
 616                 if (context.profile == Profile.GOBJECT) {
 617                         header_file.add_include ("glib.h");
 618                         internal_header_file.add_include ("glib.h");
 619                         cfile.add_include ("glib.h");
 620                         cfile.add_include ("glib-object.h");
 621                 }
 622
 623                 source_file.accept_children (this);
 624
 625                 if (context.report.get_errors () > 0) {
 626                         return;
 627                 }
 628
 629                 /* For fast-vapi, we only wanted the header declarations
 630                  * to be emitted, so bail out here without writing the
 631                  * C code output.
 632                  */
 633                 if (source_file.file_type == SourceFileType.FAST) {
 634                         return;
 635                 }
 636
 637                 if (requires_array_free) {
 638                         append_vala_array_free ();
 639                 }
 640                 if (requires_array_move) {
 641                         append_vala_array_move ();
 642                 }
 643                 if (requires_array_length) {
 644                         append_vala_array_length ();
 645                 }
 646
 647                 if (gvaluecollector_h_needed) {
 648                         cfile.add_include ("gobject/gvaluecollector.h");
 649                 }
 650
 651                 var comments = source_file.get_comments();
 652                 if (comments != null) {
 653                         foreach (Comment comment in comments) {
 654                                 var ccomment = new CCodeComment (comment.content);
 655                                 cfile.add_comment (ccomment);
 656                         }
 657                 }
 658
 659                 if (!cfile.store (source_file.get_csource_filename (), source_file.filename, context.version_header, context.debug)) {
 660                         Report.error (null, "unable to open `%s' for writing".printf (source_file.get_csource_filename ()));
 661                 }
 662
 663                 cfile = null;
 664         }
 665
 666         public virtual bool generate_enum_declaration (Enum en, CCodeFile decl_space) {
 667                 if (add_symbol_declaration (decl_space, en, en.get_cname ())) {
 668                         return false;
 669                 }
 670
 671                 var cenum = new CCodeEnum (en.get_cname ());
 672
 673                 cenum.deprecated = en.deprecated;
 674
 675                 int flag_shift = 0;
 676                 foreach (EnumValue ev in en.get_values ()) {
 677                         CCodeEnumValue c_ev;
 678                         if (ev.value == null) {
 679                                 c_ev = new CCodeEnumValue (ev.get_cname ());
 680                                 if (en.is_flags) {
 681                                         c_ev.value = new CCodeConstant ("1 << %d".printf (flag_shift));
 682                                         flag_shift += 1;
 683                                 }
 684                         } else {
 685                                 ev.value.emit (this);
 686                                 c_ev = new CCodeEnumValue (ev.get_cname (), get_cvalue (ev.value));
 687                         }
 688                         c_ev.deprecated = ev.deprecated;
 689                         cenum.add_value (c_ev);
 690                 }
 691
 692                 decl_space.add_type_definition (cenum);
 693                 decl_space.add_type_definition (new CCodeNewline ());
 694
 695                 if (!en.has_type_id) {
 696                         return true;
 697                 }
 698
 699                 decl_space.add_type_declaration (new CCodeNewline ());
 700
 701                 var macro = "(%s_get_type ())".printf (en.get_lower_case_cname (null));
 702                 decl_space.add_type_declaration (new CCodeMacroReplacement (en.get_type_id (), macro));
 703
 704                 var fun_name = "%s_get_type".printf (en.get_lower_case_cname (null));
 705                 var regfun = new CCodeFunction (fun_name, "GType");
 706                 regfun.attributes = "G_GNUC_CONST";
 707
 708                 if (en.access == SymbolAccessibility.PRIVATE) {
 709                         regfun.modifiers = CCodeModifiers.STATIC;
 710                         // avoid C warning as this function is not always used
 711                         regfun.attributes = "G_GNUC_UNUSED";
 712                 }
 713
 714                 decl_space.add_function_declaration (regfun);
 715
 716                 return true;
 717         }
 718
 719         public override void visit_enum (Enum en) {
 720                 en.accept_children (this);
 721
 722                 if (en.comment != null) {
 723                         cfile.add_type_member_definition (new CCodeComment (en.comment.content));
 724                 }
 725
 726                 generate_enum_declaration (en, cfile);
 727
 728                 if (!en.is_internal_symbol ()) {
 729                         generate_enum_declaration (en, header_file);
 730                 }
 731                 if (!en.is_private_symbol ()) {
 732                         generate_enum_declaration (en, internal_header_file);
 733                 }
 734         }
 735
 736         public void visit_member (Symbol m) {
 737                 /* stuff meant for all lockable members */
 738                 if (m is Lockable && ((Lockable) m).get_lock_used ()) {
 739                         CCodeExpression l = new CCodeIdentifier ("self");
 740                         var init_context = class_init_context;
 741                         var finalize_context = class_finalize_context;
 742
 743                         if (m.is_instance_member ()) {
 744                                 l = new CCodeMemberAccess.pointer (new CCodeMemberAccess.pointer (l, "priv"), get_symbol_lock_name (m.name));
 745                                 init_context = instance_init_context;
 746                                 finalize_context = instance_finalize_context;
 747                         } else if (m.is_class_member ()) {
 748                                 TypeSymbol parent = (TypeSymbol)m.parent_symbol;
 749
 750                                 var get_class_private_call = new CCodeFunctionCall (new CCodeIdentifier ("%s_GET_CLASS_PRIVATE".printf(parent.get_upper_case_cname ())));
 751                                 get_class_private_call.add_argument (new CCodeIdentifier ("klass"));
 752                                 l = new CCodeMemberAccess.pointer (get_class_private_call, get_symbol_lock_name (m.name));
 753                         } else {
 754                                 l = new CCodeIdentifier (get_symbol_lock_name ("%s_%s".printf(m.parent_symbol.get_lower_case_cname (), m.name)));
 755                         }
 756
 757                         push_context (init_context);
 758                         var initf = new CCodeFunctionCall (new CCodeIdentifier (mutex_type.default_construction_method.get_cname ()));
 759                         initf.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, l));
 760                         ccode.add_expression (initf);
 761                         pop_context ();
 762
 763                         if (finalize_context != null) {
 764                                 push_context (finalize_context);
 765                                 var fc = new CCodeFunctionCall (new CCodeIdentifier ("g_static_rec_mutex_free"));
 766                                 fc.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, l));
 767                                 ccode.add_expression (fc);
 768                                 pop_context ();
 769                         }
 770                 }
 771         }
 772
 773         public void generate_constant_declaration (Constant c, CCodeFile decl_space, bool definition = false) {
 774                 if (c.parent_symbol is Block) {
 775                         // local constant
 776                         return;
 777                 }
 778
 779                 if (add_symbol_declaration (decl_space, c, c.get_cname ())) {
 780                         return;
 781                 }
 782
 783                 if (!c.external) {
 784                         generate_type_declaration (c.type_reference, decl_space);
 785
 786                         c.value.emit (this);
 787
 788                         var initializer_list = c.value as InitializerList;
 789                         if (initializer_list != null) {
 790                                 var cdecl = new CCodeDeclaration (c.type_reference.get_const_cname ());
 791                                 var arr = "";
 792                                 if (c.type_reference is ArrayType) {
 793                                         arr = "[%d]".printf (initializer_list.size);
 794                                 }
 795
 796                                 var cinitializer = get_cvalue (c.value);
 797                                 if (!definition) {
 798                                         // never output value in header
 799                                         // special case needed as this method combines declaration and definition
 800                                         cinitializer = null;
 801                                 }
 802
 803                                 cdecl.add_declarator (new CCodeVariableDeclarator ("%s%s".printf (c.get_cname (), arr), cinitializer));
 804                                 if (c.is_private_symbol ()) {
 805                                         cdecl.modifiers = CCodeModifiers.STATIC;
 806                                 } else {
 807                                         cdecl.modifiers = CCodeModifiers.EXTERN;
 808                                 }
 809
 810                                 decl_space.add_constant_declaration (cdecl);
 811                         } else {
 812                                 var cdefine = new CCodeMacroReplacement.with_expression (c.get_cname (), get_cvalue (c.value));
 813                                 decl_space.add_type_member_declaration (cdefine);
 814                         }
 815                 }
 816         }
 817
 818         public override void visit_constant (Constant c) {
 819                 if (c.parent_symbol is Block) {
 820                         // local constant
 821
 822                         generate_type_declaration (c.type_reference, cfile);
 823
 824                         c.value.emit (this);
 825
 826                         string type_name = c.type_reference.get_const_cname ();
 827                         string arr = "";
 828                         if (c.type_reference is ArrayType) {
 829                                 arr = "[]";
 830                         }
 831
 832                         if (c.type_reference.compatible (string_type)) {
 833                                 type_name = "const char";
 834                                 arr = "[]";
 835                         }
 836
 837                         var cinitializer = get_cvalue (c.value);
 838
 839                         ccode.add_declaration (type_name, new CCodeVariableDeclarator ("%s%s".printf (c.get_cname (), arr), cinitializer), CCodeModifiers.STATIC);
 840
 841                         return;
 842                 }
 843
 844                 generate_constant_declaration (c, cfile, true);
 845
 846                 if (!c.is_internal_symbol ()) {
 847                         generate_constant_declaration (c, header_file);
 848                 }
 849                 if (!c.is_private_symbol ()) {
 850                         generate_constant_declaration (c, internal_header_file);
 851                 }
 852         }
 853
 854         public void generate_field_declaration (Field f, CCodeFile decl_space) {
 855                 if (add_symbol_declaration (decl_space, f, f.get_cname ())) {
 856                         return;
 857                 }
 858
 859                 generate_type_declaration (f.variable_type, decl_space);
 860
 861                 string field_ctype = f.variable_type.get_cname ();
 862                 if (f.is_volatile) {
 863                         field_ctype = "volatile " + field_ctype;
 864                 }
 865
 866                 var cdecl = new CCodeDeclaration (field_ctype);
 867                 cdecl.add_declarator (new CCodeVariableDeclarator (f.get_cname (), null, f.variable_type.get_cdeclarator_suffix ()));
 868                 if (f.is_private_symbol ()) {
 869                         cdecl.modifiers = CCodeModifiers.STATIC;
 870                 } else {
 871                         cdecl.modifiers = CCodeModifiers.EXTERN;
 872                 }
 873                 if (f.deprecated) {
 874                         cdecl.modifiers |= CCodeModifiers.DEPRECATED;
 875                 }
 876                 decl_space.add_type_member_declaration (cdecl);
 877
 878                 if (f.get_lock_used ()) {
 879                         // Declare mutex for static member
 880                         var flock = new CCodeDeclaration (mutex_type.get_cname ());
 881                         var flock_decl =  new CCodeVariableDeclarator (get_symbol_lock_name (f.get_cname ()), new CCodeConstant ("{0}"));
 882                         flock.add_declarator (flock_decl);
 883
 884                         if (f.is_private_symbol ()) {
 885                                 flock.modifiers = CCodeModifiers.STATIC;
 886                         } else {
 887                                 flock.modifiers = CCodeModifiers.EXTERN;
 888                         }
 889                         decl_space.add_type_member_declaration (flock);
 890                 }
 891
 892                 if (f.variable_type is ArrayType && !f.no_array_length) {
 893                         var array_type = (ArrayType) f.variable_type;
 894
 895                         if (!array_type.fixed_length) {
 896                                 for (int dim = 1; dim <= array_type.rank; dim++) {
 897                                         var len_type = int_type.copy ();
 898
 899                                         cdecl = new CCodeDeclaration (len_type.get_cname ());
 900                                         cdecl.add_declarator (new CCodeVariableDeclarator (get_array_length_cname (f.get_cname (), dim)));
 901                                         if (f.is_private_symbol ()) {
 902                                                 cdecl.modifiers = CCodeModifiers.STATIC;
 903                                         } else {
 904                                                 cdecl.modifiers = CCodeModifiers.EXTERN;
 905                                         }
 906                                         decl_space.add_type_member_declaration (cdecl);
 907                                 }
 908                         }
 909                 } else if (f.variable_type is DelegateType) {
 910                         var delegate_type = (DelegateType) f.variable_type;
 911                         if (delegate_type.delegate_symbol.has_target) {
 912                                 // create field to store delegate target
 913
 914                                 cdecl = new CCodeDeclaration ("gpointer");
 915                                 cdecl.add_declarator (new CCodeVariableDeclarator (get_delegate_target_cname  (f.get_cname ())));
 916                                 if (f.is_private_symbol ()) {
 917                                         cdecl.modifiers = CCodeModifiers.STATIC;
 918                                 } else {
 919                                         cdecl.modifiers = CCodeModifiers.EXTERN;
 920                                 }
 921                                 decl_space.add_type_member_declaration (cdecl);
 922
 923                                 if (delegate_type.value_owned) {
 924                                         cdecl = new CCodeDeclaration ("GDestroyNotify");
 925                                         cdecl.add_declarator (new CCodeVariableDeclarator (get_delegate_target_destroy_notify_cname  (f.get_cname ())));
 926                                         if (f.is_private_symbol ()) {
 927                                                 cdecl.modifiers = CCodeModifiers.STATIC;
 928                                         } else {
 929                                                 cdecl.modifiers = CCodeModifiers.EXTERN;
 930                                         }
 931                                         decl_space.add_type_member_declaration (cdecl);
 932                                 }
 933                         }
 934                 }
 935         }
 936
 937         public override void visit_field (Field f) {
 938                 visit_member (f);
 939
 940                 check_type (f.variable_type);
 941
 942                 var cl = f.parent_symbol as Class;
 943                 bool is_gtypeinstance = (cl != null && !cl.is_compact);
 944
 945                 CCodeExpression lhs = null;
 946
 947                 string field_ctype = f.variable_type.get_cname ();
 948                 if (f.is_volatile) {
 949                         field_ctype = "volatile " + field_ctype;
 950                 }
 951
 952                 if (f.binding == MemberBinding.INSTANCE)  {
 953                         if (is_gtypeinstance && f.access == SymbolAccessibility.PRIVATE) {
 954                                 lhs = new CCodeMemberAccess.pointer (new CCodeMemberAccess.pointer (new CCodeIdentifier ("self"), "priv"), f.get_cname ());
 955                         } else {
 956                                 lhs = new CCodeMemberAccess.pointer (new CCodeIdentifier ("self"), f.get_cname ());
 957                         }
 958
 959                         if (f.initializer != null) {
 960                                 push_context (instance_init_context);
 961
 962                                 f.initializer.emit (this);
 963
 964                                 var rhs = get_cvalue (f.initializer);
 965
 966                                 ccode.add_assignment (lhs, rhs);
 967
 968                                 if (f.variable_type is ArrayType && !f.no_array_length &&
 969                                     f.initializer is ArrayCreationExpression) {
 970                                         var array_type = (ArrayType) f.variable_type;
 971                                         var field_value = get_field_cvalue (f, load_this_parameter ((TypeSymbol) f.parent_symbol));
 972
 973                                         List<Expression> sizes = ((ArrayCreationExpression) f.initializer).get_sizes ();
 974                                         for (int dim = 1; dim <= array_type.rank; dim++) {
 975                                                 var array_len_lhs = get_array_length_cvalue (field_value, dim);
 976                                                 var size = sizes[dim - 1];
 977                                                 ccode.add_assignment (array_len_lhs, get_cvalue (size));
 978                                         }
 979
 980                                         if (array_type.rank == 1 && f.is_internal_symbol ()) {
 981                                                 var lhs_array_size = get_array_size_cvalue (field_value);
 982                                                 var rhs_array_len = get_array_length_cvalue (field_value, 1);
 983                                                 ccode.add_assignment (lhs_array_size, rhs_array_len);
 984                                         }
 985                                 }
 986
 987                                 foreach (LocalVariable local in temp_ref_vars) {
 988                                         ccode.add_expression (destroy_local (local));
 989                                 }
 990
 991                                 temp_ref_vars.clear ();
 992
 993                                 pop_context ();
 994                         }
 995
 996                         if (requires_destroy (f.variable_type) && instance_finalize_context != null) {
 997                                 push_context (instance_finalize_context);
 998                                 ccode.add_expression (destroy_field (f, load_this_parameter ((TypeSymbol) f.parent_symbol)));
 999                                 pop_context ();
1000                         }
1001                 } else if (f.binding == MemberBinding.CLASS)  {
1002                         if (!is_gtypeinstance) {
1003                                 Report.error (f.source_reference, "class fields are not supported in compact classes");
1004                                 f.error = true;
1005                                 return;
1006                         }
1007
1008                         if (f.access == SymbolAccessibility.PRIVATE) {
1009                                 var ccall = new CCodeFunctionCall (new CCodeIdentifier ("%s_GET_CLASS_PRIVATE".printf (cl.get_upper_case_cname ())));
1010                                 ccall.add_argument (new CCodeIdentifier ("klass"));
1011                                 lhs = new CCodeMemberAccess (ccall, f.get_cname (), true);
1012                         } else {
1013                                 lhs = new CCodeMemberAccess (new CCodeIdentifier ("klass"), f.get_cname (), true);
1014                         }
1015
1016                         if (f.initializer != null) {
1017                                 push_context (class_init_context);
1018
1019                                 f.initializer.emit (this);
1020
1021                                 var rhs = get_cvalue (f.initializer);
1022
1023                                 ccode.add_assignment (lhs, rhs);
1024
1025                                 foreach (LocalVariable local in temp_ref_vars) {
1026                                         ccode.add_expression (destroy_local (local));
1027                                 }
1028
1029                                 temp_ref_vars.clear ();
1030
1031                                 pop_context ();
1032                         }
1033                 } else {
1034                         generate_field_declaration (f, cfile);
1035
1036                         if (!f.is_internal_symbol ()) {
1037                                 generate_field_declaration (f, header_file);
1038                         }
1039                         if (!f.is_private_symbol ()) {
1040                                 generate_field_declaration (f, internal_header_file);
1041                         }
1042
1043                         lhs = new CCodeIdentifier (f.get_cname ());
1044
1045                         var var_decl = new CCodeVariableDeclarator (f.get_cname (), null, f.variable_type.get_cdeclarator_suffix ());
1046                         var_decl.initializer = default_value_for_type (f.variable_type, true);
1047
1048                         if (class_init_context != null) {
1049                                 push_context (class_init_context);
1050                         } else {
1051                                 push_context (new EmitContext ());
1052                         }
1053
1054                         if (f.initializer != null) {
1055                                 f.initializer.emit (this);
1056
1057                                 var init = get_cvalue (f.initializer);
1058                                 if (is_constant_ccode_expression (init)) {
1059                                         var_decl.initializer = init;
1060                                 }
1061                         }
1062
1063                         var var_def = new CCodeDeclaration (field_ctype);
1064                         var_def.add_declarator (var_decl);
1065                         if (!f.is_private_symbol ()) {
1066                                 var_def.modifiers = CCodeModifiers.EXTERN;
1067                         } else {
1068                                 var_def.modifiers = CCodeModifiers.STATIC;
1069                         }
1070                         cfile.add_type_member_declaration (var_def);
1071
1072                         /* add array length fields where necessary */
1073                         if (f.variable_type is ArrayType && !f.no_array_length) {
1074                                 var array_type = (ArrayType) f.variable_type;
1075
1076                                 if (!array_type.fixed_length) {
1077                                         for (int dim = 1; dim <= array_type.rank; dim++) {
1078                                                 var len_type = int_type.copy ();
1079
1080                                                 var len_def = new CCodeDeclaration (len_type.get_cname ());
1081                                                 len_def.add_declarator (new CCodeVariableDeclarator (get_array_length_cname (f.get_cname (), dim), new CCodeConstant ("0")));
1082                                                 if (!f.is_private_symbol ()) {
1083                                                         len_def.modifiers = CCodeModifiers.EXTERN;
1084                                                 } else {
1085                                                         len_def.modifiers = CCodeModifiers.STATIC;
1086                                                 }
1087                                                 cfile.add_type_member_declaration (len_def);
1088                                         }
1089
1090                                         if (array_type.rank == 1 && f.is_internal_symbol ()) {
1091                                                 var len_type = int_type.copy ();
1092
1093                                                 var cdecl = new CCodeDeclaration (len_type.get_cname ());
1094                                                 cdecl.add_declarator (new CCodeVariableDeclarator (get_array_size_cname (f.get_cname ()), new CCodeConstant ("0")));
1095                                                 cdecl.modifiers = CCodeModifiers.STATIC;
1096                                                 cfile.add_type_member_declaration (cdecl);
1097                                         }
1098                                 }
1099                         } else if (f.variable_type is DelegateType) {
1100                                 var delegate_type = (DelegateType) f.variable_type;
1101                                 if (delegate_type.delegate_symbol.has_target) {
1102                                         // create field to store delegate target
1103
1104                                         var target_def = new CCodeDeclaration ("gpointer");
1105                                         target_def.add_declarator (new CCodeVariableDeclarator (get_delegate_target_cname  (f.get_cname ()), new CCodeConstant ("NULL")));
1106                                         if (!f.is_private_symbol ()) {
1107                                                 target_def.modifiers = CCodeModifiers.EXTERN;
1108                                         } else {
1109                                                 target_def.modifiers = CCodeModifiers.STATIC;
1110                                         }
1111                                         cfile.add_type_member_declaration (target_def);
1112
1113                                         if (delegate_type.value_owned) {
1114                                                 var target_destroy_notify_def = new CCodeDeclaration ("GDestroyNotify");
1115                                                 target_destroy_notify_def.add_declarator (new CCodeVariableDeclarator (get_delegate_target_destroy_notify_cname  (f.get_cname ()), new CCodeConstant ("NULL")));
1116                                                 if (!f.is_private_symbol ()) {
1117                                                         target_destroy_notify_def.modifiers = CCodeModifiers.EXTERN;
1118                                                 } else {
1119                                                         target_destroy_notify_def.modifiers = CCodeModifiers.STATIC;
1120                                                 }
1121                                                 cfile.add_type_member_declaration (target_destroy_notify_def);
1122
1123                                         }
1124                                 }
1125                         }
1126
1127                         if (f.initializer != null) {
1128                                 var rhs = get_cvalue (f.initializer);
1129                                 if (!is_constant_ccode_expression (rhs)) {
1130                                         if (f.parent_symbol is Class) {
1131                                                 if (f.initializer is InitializerList) {
1132                                                         ccode.open_block ();
1133
1134                                                         var temp_decl = get_temp_variable (f.variable_type);
1135                                                         var vardecl = new CCodeVariableDeclarator.zero (temp_decl.name, rhs);
1136                                                         ccode.add_declaration (temp_decl.variable_type.get_cname (), vardecl);
1137
1138                                                         var tmp = get_variable_cexpression (get_variable_cname (temp_decl.name));
1139                                                         ccode.add_assignment (lhs, tmp);
1140
1141                                                         ccode.close ();
1142                                                 } else {
1143                                                         ccode.add_assignment (lhs, rhs);
1144                                                 }
1145
1146                                                 if (f.variable_type is ArrayType && !f.no_array_length &&
1147                                                     f.initializer is ArrayCreationExpression) {
1148                                                         var array_type = (ArrayType) f.variable_type;
1149                                                         var ma = new MemberAccess.simple (f.name);
1150                                                         ma.symbol_reference = f;
1151                                                         ma.value_type = f.variable_type.copy ();
1152                                                         visit_member_access (ma);
1153
1154                                                         List<Expression> sizes = ((ArrayCreationExpression) f.initializer).get_sizes ();
1155                                                         for (int dim = 1; dim <= array_type.rank; dim++) {
1156                                                                 var array_len_lhs = get_array_length_cexpression (ma, dim);
1157                                                                 var size = sizes[dim - 1];
1158                                                                 ccode.add_assignment (array_len_lhs, get_cvalue (size));
1159                                                         }
1160                                                 }
1161                                         } else {
1162                                                 f.error = true;
1163                                                 Report.error (f.source_reference, "Non-constant field initializers not supported in this context");
1164                                                 return;
1165                                         }
1166                                 }
1167                         }
1168
1169                         pop_context ();
1170                 }
1171         }
1172
1173         public bool is_constant_ccode_expression (CCodeExpression cexpr) {
1174                 if (cexpr is CCodeConstant) {
1175                         return true;
1176                 } else if (cexpr is CCodeCastExpression) {
1177                         var ccast = (CCodeCastExpression) cexpr;
1178                         return is_constant_ccode_expression (ccast.inner);
1179                 } else if (cexpr is CCodeBinaryExpression) {
1180                         var cbinary = (CCodeBinaryExpression) cexpr;
1181                         return is_constant_ccode_expression (cbinary.left) && is_constant_ccode_expression (cbinary.right);
1182                 }
1183
1184                 var cparenthesized = (cexpr as CCodeParenthesizedExpression);
1185                 return (null != cparenthesized && is_constant_ccode_expression (cparenthesized.inner));
1186         }
1187
1188         /**
1189          * Returns whether the passed cexpr is a pure expression, i.e. an
1190          * expression without side-effects.
1191          */
1192         public bool is_pure_ccode_expression (CCodeExpression cexpr) {
1193                 if (cexpr is CCodeConstant || cexpr is CCodeIdentifier) {
1194                         return true;
1195                 } else if (cexpr is CCodeBinaryExpression) {
1196                         var cbinary = (CCodeBinaryExpression) cexpr;
1197                         return is_pure_ccode_expression (cbinary.left) && is_constant_ccode_expression (cbinary.right);
1198                 } else if (cexpr is CCodeUnaryExpression) {
1199                         var cunary = (CCodeUnaryExpression) cexpr;
1200                         switch (cunary.operator) {
1201                         case CCodeUnaryOperator.PREFIX_INCREMENT:
1202                         case CCodeUnaryOperator.PREFIX_DECREMENT:
1203                         case CCodeUnaryOperator.POSTFIX_INCREMENT:
1204                         case CCodeUnaryOperator.POSTFIX_DECREMENT:
1205                                 return false;
1206                         default:
1207                                 return is_pure_ccode_expression (cunary.inner);
1208                         }
1209                 } else if (cexpr is CCodeMemberAccess) {
1210                         var cma = (CCodeMemberAccess) cexpr;
1211                         return is_pure_ccode_expression (cma.inner);
1212                 } else if (cexpr is CCodeElementAccess) {
1213                         var cea = (CCodeElementAccess) cexpr;
1214                         return is_pure_ccode_expression (cea.container) && is_pure_ccode_expression (cea.index);
1215                 } else if (cexpr is CCodeCastExpression) {
1216                         var ccast = (CCodeCastExpression) cexpr;
1217                         return is_pure_ccode_expression (ccast.inner);
1218                 } else if (cexpr is CCodeParenthesizedExpression) {
1219                         var cparenthesized = (CCodeParenthesizedExpression) cexpr;
1220                         return is_pure_ccode_expression (cparenthesized.inner);
1221                 }
1222
1223                 return false;
1224         }
1225
1226         public override void visit_formal_parameter (Parameter p) {
1227                 if (!p.ellipsis) {
1228                         check_type (p.variable_type);
1229                 }
1230         }
1231
1232         public override void visit_property (Property prop) {
1233                 visit_member (prop);
1234
1235                 check_type (prop.property_type);
1236
1237                 if (prop.get_accessor != null) {
1238                         prop.get_accessor.accept (this);
1239                 }
1240                 if (prop.set_accessor != null) {
1241                         prop.set_accessor.accept (this);
1242                 }
1243         }
1244
1245         public void generate_type_declaration (DataType type, CCodeFile decl_space) {
1246                 if (type is ObjectType) {
1247                         var object_type = (ObjectType) type;
1248                         if (object_type.type_symbol is Class) {
1249                                 generate_class_declaration ((Class) object_type.type_symbol, decl_space);
1250                         } else if (object_type.type_symbol is Interface) {
1251                                 generate_interface_declaration ((Interface) object_type.type_symbol, decl_space);
1252                         }
1253                 } else if (type is DelegateType) {
1254                         var deleg_type = (DelegateType) type;
1255                         var d = deleg_type.delegate_symbol;
1256                         generate_delegate_declaration (d, decl_space);
1257                 } else if (type.data_type is Enum) {
1258                         var en = (Enum) type.data_type;
1259                         generate_enum_declaration (en, decl_space);
1260                 } else if (type is ValueType) {
1261                         var value_type = (ValueType) type;
1262                         generate_struct_declaration ((Struct) value_type.type_symbol, decl_space);
1263                 } else if (type is ArrayType) {
1264                         var array_type = (ArrayType) type;
1265                         generate_type_declaration (array_type.element_type, decl_space);
1266                 } else if (type is ErrorType) {
1267                         var error_type = (ErrorType) type;
1268                         if (error_type.error_domain != null) {
1269                                 generate_error_domain_declaration (error_type.error_domain, decl_space);
1270                         }
1271                 } else if (type is PointerType) {
1272                         var pointer_type = (PointerType) type;
1273                         generate_type_declaration (pointer_type.base_type, decl_space);
1274                 }
1275
1276                 foreach (DataType type_arg in type.get_type_arguments ()) {
1277                         generate_type_declaration (type_arg, decl_space);
1278                 }
1279         }
1280
1281         public virtual void generate_class_struct_declaration (Class cl, CCodeFile decl_space) {
1282         }
1283
1284         public virtual void generate_struct_declaration (Struct st, CCodeFile decl_space) {
1285         }
1286
1287         public virtual void generate_delegate_declaration (Delegate d, CCodeFile decl_space) {
1288         }
1289
1290         public virtual void generate_cparameters (Method m, CCodeFile decl_space, Map<int,CCodeParameter> cparam_map, CCodeFunction func, CCodeFunctionDeclarator? vdeclarator = null, Map<int,CCodeExpression>? carg_map = null, CCodeFunctionCall? vcall = null, int direction = 3) {
1291         }
1292
1293         public void generate_property_accessor_declaration (PropertyAccessor acc, CCodeFile decl_space) {
1294                 if (add_symbol_declaration (decl_space, acc, acc.get_cname ())) {
1295                         return;
1296                 }
1297
1298                 var prop = (Property) acc.prop;
1299
1300                 bool returns_real_struct = acc.readable && prop.property_type.is_real_non_null_struct_type ();
1301
1302
1303                 CCodeParameter cvalueparam;
1304                 if (returns_real_struct) {
1305                         cvalueparam = new CCodeParameter ("result", acc.value_type.get_cname () + "*");
1306                 } else if (!acc.readable && prop.property_type.is_real_non_null_struct_type ()) {
1307                         cvalueparam = new CCodeParameter ("value", acc.value_type.get_cname () + "*");
1308                 } else {
1309                         cvalueparam = new CCodeParameter ("value", acc.value_type.get_cname ());
1310                 }
1311                 generate_type_declaration (acc.value_type, decl_space);
1312
1313                 CCodeFunction function;
1314                 if (acc.readable && !returns_real_struct) {
1315                         function = new CCodeFunction (acc.get_cname (), acc.value_type.get_cname ());
1316                 } else {
1317                         function = new CCodeFunction (acc.get_cname (), "void");
1318                 }
1319
1320                 if (prop.binding == MemberBinding.INSTANCE) {
1321                         var t = (TypeSymbol) prop.parent_symbol;
1322                         var this_type = get_data_type_for_symbol (t);
1323                         generate_type_declaration (this_type, decl_space);
1324                         var cselfparam = new CCodeParameter ("self", this_type.get_cname ());
1325                         if (t is Struct) {
1326                                 cselfparam.type_name += "*";
1327                         }
1328
1329                         function.add_parameter (cselfparam);
1330                 }
1331
1332                 if (acc.writable || acc.construction || returns_real_struct) {
1333                         function.add_parameter (cvalueparam);
1334                 }
1335
1336                 if (acc.value_type is ArrayType) {
1337                         var array_type = (ArrayType) acc.value_type;
1338
1339                         var length_ctype = "int";
1340                         if (acc.readable) {
1341                                 length_ctype = "int*";
1342                         }
1343
1344                         for (int dim = 1; dim <= array_type.rank; dim++) {
1345                                 function.add_parameter (new CCodeParameter (get_array_length_cname (acc.readable ? "result" : "value", dim), length_ctype));
1346                         }
1347                 } else if ((acc.value_type is DelegateType) && ((DelegateType) acc.value_type).delegate_symbol.has_target) {
1348                         function.add_parameter (new CCodeParameter (get_delegate_target_cname (acc.readable ? "result" : "value"), acc.readable ? "gpointer*" : "gpointer"));
1349                 }
1350
1351                 if (prop.is_private_symbol () || (!acc.readable && !acc.writable) || acc.access == SymbolAccessibility.PRIVATE) {
1352                         function.modifiers |= CCodeModifiers.STATIC;
1353                 }
1354                 decl_space.add_function_declaration (function);
1355         }
1356
1357         public override void visit_property_accessor (PropertyAccessor acc) {
1358                 push_context (new EmitContext (acc));
1359
1360                 var prop = (Property) acc.prop;
1361
1362                 if (acc.comment != null) {
1363                         cfile.add_type_member_definition (new CCodeComment (acc.comment.content));
1364                 }
1365
1366                 bool returns_real_struct = acc.readable && prop.property_type.is_real_non_null_struct_type ();
1367
1368                 if (acc.result_var != null) {
1369                         acc.result_var.accept (this);
1370                 }
1371
1372                 var t = (TypeSymbol) prop.parent_symbol;
1373
1374                 if (acc.construction && !t.is_subtype_of (gobject_type)) {
1375                         Report.error (acc.source_reference, "construct properties require GLib.Object");
1376                         acc.error = true;
1377                         return;
1378                 } else if (acc.construction && !is_gobject_property (prop)) {
1379                         Report.error (acc.source_reference, "construct properties not supported for specified property type");
1380                         acc.error = true;
1381                         return;
1382                 }
1383
1384                 // do not declare overriding properties and interface implementations
1385                 if (prop.is_abstract || prop.is_virtual
1386                     || (prop.base_property == null && prop.base_interface_property == null)) {
1387                         generate_property_accessor_declaration (acc, cfile);
1388
1389                         // do not declare construct-only properties in header files
1390                         if (acc.readable || acc.writable) {
1391                                 if (!prop.is_internal_symbol ()
1392                                     && (acc.access == SymbolAccessibility.PUBLIC
1393                                         || acc.access == SymbolAccessibility.PROTECTED)) {
1394                                         generate_property_accessor_declaration (acc, header_file);
1395                                 }
1396                                 if (!prop.is_private_symbol () && acc.access != SymbolAccessibility.PRIVATE) {
1397                                         generate_property_accessor_declaration (acc, internal_header_file);
1398                                 }
1399                         }
1400                 }
1401
1402                 if (acc.source_type == SourceFileType.FAST) {
1403                         return;
1404                 }
1405
1406                 var this_type = get_data_type_for_symbol (t);
1407                 var cselfparam = new CCodeParameter ("self", this_type.get_cname ());
1408                 if (t is Struct) {
1409                         cselfparam.type_name += "*";
1410                 }
1411                 CCodeParameter cvalueparam;
1412                 if (returns_real_struct) {
1413                         cvalueparam = new CCodeParameter ("result", acc.value_type.get_cname () + "*");
1414                 } else if (!acc.readable && prop.property_type.is_real_non_null_struct_type ()) {
1415                         cvalueparam = new CCodeParameter ("value", acc.value_type.get_cname () + "*");
1416                 } else {
1417                         cvalueparam = new CCodeParameter ("value", acc.value_type.get_cname ());
1418                 }
1419
1420                 if (prop.is_abstract || prop.is_virtual) {
1421                         CCodeFunction function;
1422                         if (acc.readable && !returns_real_struct) {
1423                                 function = new CCodeFunction (acc.get_cname (), current_return_type.get_cname ());
1424                         } else {
1425                                 function = new CCodeFunction (acc.get_cname (), "void");
1426                         }
1427                         function.add_parameter (cselfparam);
1428                         if (acc.writable || acc.construction || returns_real_struct) {
1429                                 function.add_parameter (cvalueparam);
1430                         }
1431
1432                         if (acc.value_type is ArrayType) {
1433                                 var array_type = (ArrayType) acc.value_type;
1434
1435                                 var length_ctype = "int";
1436                                 if (acc.readable) {
1437                                         length_ctype = "int*";
1438                                 }
1439
1440                                 for (int dim = 1; dim <= array_type.rank; dim++) {
1441                                         function.add_parameter (new CCodeParameter (get_array_length_cname (acc.readable ? "result" : "value", dim), length_ctype));
1442                                 }
1443                         } else if ((acc.value_type is DelegateType) && ((DelegateType) acc.value_type).delegate_symbol.has_target) {
1444                                 function.add_parameter (new CCodeParameter (get_delegate_target_cname (acc.readable ? "result" : "value"), acc.readable ? "gpointer*" : "gpointer"));
1445                         }
1446
1447                         if (prop.is_private_symbol () || !(acc.readable || acc.writable) || acc.access == SymbolAccessibility.PRIVATE) {
1448                                 // accessor function should be private if the property is an internal symbol or it's a construct-only setter
1449                                 function.modifiers |= CCodeModifiers.STATIC;
1450                         }
1451
1452                         push_function (function);
1453
1454                         CCodeFunctionCall vcast = null;
1455                         if (prop.parent_symbol is Interface) {
1456                                 var iface = (Interface) prop.parent_symbol;
1457
1458                                 vcast = new CCodeFunctionCall (new CCodeIdentifier ("%s_GET_INTERFACE".printf (iface.get_upper_case_cname (null))));
1459                         } else {
1460                                 var cl = (Class) prop.parent_symbol;
1461
1462                                 vcast = new CCodeFunctionCall (new CCodeIdentifier ("%s_GET_CLASS".printf (cl.get_upper_case_cname (null))));
1463                         }
1464                         vcast.add_argument (new CCodeIdentifier ("self"));
1465
1466                         if (acc.readable) {
1467                                 var vcall = new CCodeFunctionCall (new CCodeMemberAccess.pointer (vcast, "get_%s".printf (prop.name)));
1468                                 vcall.add_argument (new CCodeIdentifier ("self"));
1469                                 if (returns_real_struct) {
1470                                         vcall.add_argument (new CCodeIdentifier ("result"));
1471                                         ccode.add_expression (vcall);
1472                                 } else {
1473                                         if (acc.value_type is ArrayType) {
1474                                                 var array_type = (ArrayType) acc.value_type;
1475
1476                                                 for (int dim = 1; dim <= array_type.rank; dim++) {
1477                                                         var len_expr = new CCodeIdentifier (get_array_length_cname ("result", dim));
1478                                                         vcall.add_argument (len_expr);
1479                                                 }
1480                                         } else if ((acc.value_type is DelegateType) && ((DelegateType) acc.value_type).delegate_symbol.has_target) {
1481                                                 vcall.add_argument (new CCodeIdentifier (get_delegate_target_cname ("result")));
1482                                         }
1483
1484                                         ccode.add_return (vcall);
1485                                 }
1486                         } else {
1487                                 var vcall = new CCodeFunctionCall (new CCodeMemberAccess.pointer (vcast, "set_%s".printf (prop.name)));
1488                                 vcall.add_argument (new CCodeIdentifier ("self"));
1489                                 vcall.add_argument (new CCodeIdentifier ("value"));
1490
1491                                 if (acc.value_type is ArrayType) {
1492                                         var array_type = (ArrayType) acc.value_type;
1493
1494                                         for (int dim = 1; dim <= array_type.rank; dim++) {
1495                                                 var len_expr = new CCodeIdentifier (get_array_length_cname ("value", dim));
1496                                                 vcall.add_argument (len_expr);
1497                                         }
1498                                 } else if ((acc.value_type is DelegateType) && ((DelegateType) acc.value_type).delegate_symbol.has_target) {
1499                                         vcall.add_argument (new CCodeIdentifier (get_delegate_target_cname ("value")));
1500                                 }
1501
1502                                 ccode.add_expression (vcall);
1503                         }
1504
1505                         pop_function ();
1506
1507                         cfile.add_function (function);
1508                 }
1509
1510                 if (!prop.is_abstract) {
1511                         bool is_virtual = prop.base_property != null || prop.base_interface_property != null;
1512
1513                         string cname;
1514                         if (is_virtual) {
1515                                 if (acc.readable) {
1516                                         cname = "%s_real_get_%s".printf (t.get_lower_case_cname (null), prop.name);
1517                                 } else {
1518                                         cname = "%s_real_set_%s".printf (t.get_lower_case_cname (null), prop.name);
1519                                 }
1520                         } else {
1521                                 cname = acc.get_cname ();
1522                         }
1523
1524                         CCodeFunction function;
1525                         if (acc.writable || acc.construction || returns_real_struct) {
1526                                 function = new CCodeFunction (cname, "void");
1527                         } else {
1528                                 function = new CCodeFunction (cname, acc.value_type.get_cname ());
1529                         }
1530
1531                         ObjectType base_type = null;
1532                         if (prop.binding == MemberBinding.INSTANCE) {
1533                                 if (is_virtual) {
1534                                         if (prop.base_property != null) {
1535                                                 base_type = new ObjectType ((ObjectTypeSymbol) prop.base_property.parent_symbol);
1536                                         } else if (prop.base_interface_property != null) {
1537                                                 base_type = new ObjectType ((ObjectTypeSymbol) prop.base_interface_property.parent_symbol);
1538                                         }
1539                                         function.modifiers |= CCodeModifiers.STATIC;
1540                                         function.add_parameter (new CCodeParameter ("base", base_type.get_cname ()));
1541                                 } else {
1542                                         function.add_parameter (cselfparam);
1543                                 }
1544                         }
1545                         if (acc.writable || acc.construction || returns_real_struct) {
1546                                 function.add_parameter (cvalueparam);
1547                         }
1548
1549                         if (acc.value_type is ArrayType) {
1550                                 var array_type = (ArrayType) acc.value_type;
1551
1552                                 var length_ctype = "int";
1553                                 if (acc.readable) {
1554                                         length_ctype = "int*";
1555                                 }
1556
1557                                 for (int dim = 1; dim <= array_type.rank; dim++) {
1558                                         function.add_parameter (new CCodeParameter (get_array_length_cname (acc.readable ? "result" : "value", dim), length_ctype));
1559                                 }
1560                         } else if ((acc.value_type is DelegateType) && ((DelegateType) acc.value_type).delegate_symbol.has_target) {
1561                                 function.add_parameter (new CCodeParameter (get_delegate_target_cname (acc.readable ? "result" : "value"), acc.readable ? "gpointer*" : "gpointer"));
1562                         }
1563
1564                         if (!is_virtual) {
1565                                 if (prop.is_private_symbol () || !(acc.readable || acc.writable) || acc.access == SymbolAccessibility.PRIVATE) {
1566                                         // accessor function should be private if the property is an internal symbol or it's a construct-only setter
1567                                         function.modifiers |= CCodeModifiers.STATIC;
1568                                 }
1569                         }
1570
1571                         push_function (function);
1572
1573                         if (prop.binding == MemberBinding.INSTANCE && !is_virtual) {
1574                                 if (!acc.readable || returns_real_struct) {
1575                                         create_property_type_check_statement (prop, false, t, true, "self");
1576                                 } else {
1577                                         create_property_type_check_statement (prop, true, t, true, "self");
1578                                 }
1579                         }
1580
1581                         if (acc.readable && !returns_real_struct) {
1582                                 // do not declare result variable if exit block is known to be unreachable
1583                                 if (acc.return_block == null || acc.return_block.get_predecessors ().size > 0) {
1584                                         ccode.add_declaration (acc.value_type.get_cname (), new CCodeVariableDeclarator ("result"));
1585                                 }
1586                         }
1587
1588                         if (is_virtual) {
1589                                 ccode.add_declaration (this_type.get_cname (), new CCodeVariableDeclarator ("self"));
1590                                 ccode.add_assignment (new CCodeIdentifier ("self"), transform_expression (new CCodeIdentifier ("base"), base_type, this_type));
1591                         }
1592
1593                         acc.body.emit (this);
1594
1595                         if (current_method_inner_error) {
1596                                 ccode.add_declaration ("GError *", new CCodeVariableDeclarator.zero ("_inner_error_", new CCodeConstant ("NULL")));
1597                         }
1598
1599                         // notify on property changes
1600                         if (is_gobject_property (prop) &&
1601                             prop.notify &&
1602                             (acc.writable || acc.construction)) {
1603                                 var notify_call = new CCodeFunctionCall (new CCodeIdentifier ("g_object_notify"));
1604                                 notify_call.add_argument (new CCodeCastExpression (new CCodeIdentifier ("self"), "GObject *"));
1605                                 notify_call.add_argument (prop.get_canonical_cconstant ());
1606                                 ccode.add_expression (notify_call);
1607                         }
1608
1609                         cfile.add_function (function);
1610                 }
1611
1612                 pop_context ();
1613         }
1614
1615         public override void visit_destructor (Destructor d) {
1616                 if (d.binding == MemberBinding.STATIC && !in_plugin) {
1617                         Report.error (d.source_reference, "static destructors are only supported for dynamic types");
1618                         d.error = true;
1619                         return;
1620                 }
1621         }
1622
1623         public int get_block_id (Block b) {
1624                 int result = block_map[b];
1625                 if (result == 0) {
1626                         result = ++next_block_id;
1627                         block_map[b] = result;
1628                 }
1629                 return result;
1630         }
1631
1632         void capture_parameter (Parameter param, CCodeStruct data, int block_id) {
1633                 generate_type_declaration (param.variable_type, cfile);
1634
1635                 var param_type = param.variable_type.copy ();
1636                 param_type.value_owned = true;
1637                 data.add_field (param_type.get_cname (), get_variable_cname (param.name));
1638
1639                 bool is_unowned_delegate = param.variable_type is DelegateType && !param.variable_type.value_owned;
1640
1641                 // create copy if necessary as captured variables may need to be kept alive
1642                 CCodeExpression cparam = get_variable_cexpression (param.name);
1643                 if (param.variable_type.is_real_non_null_struct_type ()) {
1644                         cparam = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, cparam);
1645                 }
1646                 if (requires_copy (param_type) && !param.variable_type.value_owned && !is_unowned_delegate)  {
1647                         var ma = new MemberAccess.simple (param.name);
1648                         ma.symbol_reference = param;
1649                         ma.value_type = param.variable_type.copy ();
1650                         // directly access parameters in ref expressions
1651                         param.captured = false;
1652                         visit_member_access (ma);
1653                         cparam = get_ref_cexpression (param.variable_type, cparam, ma, param);
1654                         param.captured = true;
1655                 }
1656
1657                 ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), get_variable_cname (param.name)), cparam);
1658
1659                 if (param.variable_type is ArrayType) {
1660                         var array_type = (ArrayType) param.variable_type;
1661                         for (int dim = 1; dim <= array_type.rank; dim++) {
1662                                 data.add_field ("gint", get_parameter_array_length_cname (param, dim));
1663                                 ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), get_array_length_cname (get_variable_cname (param.name), dim)), new CCodeIdentifier (get_array_length_cname (get_variable_cname (param.name), dim)));
1664                         }
1665                 } else if (param.variable_type is DelegateType) {
1666                         CCodeExpression target_expr;
1667                         CCodeExpression delegate_target_destroy_notify;
1668                         if (is_in_coroutine ()) {
1669                                 target_expr = new CCodeMemberAccess.pointer (new CCodeIdentifier ("data"), get_delegate_target_cname (get_variable_cname (param.name)));
1670                                 delegate_target_destroy_notify = new CCodeMemberAccess.pointer (new CCodeIdentifier ("data"), get_delegate_target_destroy_notify_cname (get_variable_cname (param.name)));
1671                         } else {
1672                                 target_expr = new CCodeIdentifier (get_delegate_target_cname (get_variable_cname (param.name)));
1673                                 delegate_target_destroy_notify = new CCodeIdentifier (get_delegate_target_destroy_notify_cname (get_variable_cname (param.name)));
1674                         }
1675
1676                         data.add_field ("gpointer", get_delegate_target_cname (get_variable_cname (param.name)));
1677                         ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), get_delegate_target_cname (get_variable_cname (param.name))), target_expr);
1678                         if (param.variable_type.value_owned) {
1679                                 data.add_field ("GDestroyNotify", get_delegate_target_destroy_notify_cname (get_variable_cname (param.name)));
1680                                 ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), get_delegate_target_destroy_notify_cname (get_variable_cname (param.name))), delegate_target_destroy_notify);
1681                         }
1682                 }
1683         }
1684
1685         public override void visit_block (Block b) {
1686                 emit_context.push_symbol (b);
1687
1688                 var local_vars = b.get_local_variables ();
1689
1690                 if (b.parent_node is Block || b.parent_node is SwitchStatement) {
1691                         ccode.open_block ();
1692                 }
1693
1694                 if (b.captured) {
1695                         var parent_block = next_closure_block (b.parent_symbol);
1696
1697                         int block_id = get_block_id (b);
1698                         string struct_name = "Block%dData".printf (block_id);
1699
1700                         var data = new CCodeStruct ("_" + struct_name);
1701                         data.add_field ("int", "_ref_count_");
1702                         if (parent_block != null) {
1703                                 int parent_block_id = get_block_id (parent_block);
1704
1705                                 data.add_field ("Block%dData *".printf (parent_block_id), "_data%d_".printf (parent_block_id));
1706                         } else {
1707                                 if (in_constructor || (current_method != null && current_method.binding == MemberBinding.INSTANCE) ||
1708                                            (current_property_accessor != null && current_property_accessor.prop.binding == MemberBinding.INSTANCE)) {
1709                                         data.add_field ("%s *".printf (current_class.get_cname ()), "self");
1710                                 }
1711
1712                                 if (current_method != null) {
1713                                         // allow capturing generic type parameters
1714                                         foreach (var type_param in current_method.get_type_parameters ()) {
1715                                                 string func_name;
1716
1717                                                 func_name = "%s_type".printf (type_param.name.down ());
1718                                                 data.add_field ("GType", func_name);
1719
1720                                                 func_name = "%s_dup_func".printf (type_param.name.down ());
1721                                                 data.add_field ("GBoxedCopyFunc", func_name);
1722
1723                                                 func_name = "%s_destroy_func".printf (type_param.name.down ());
1724                                                 data.add_field ("GDestroyNotify", func_name);
1725                                         }
1726                                 }
1727                         }
1728                         foreach (var local in local_vars) {
1729                                 if (local.captured) {
1730                                         generate_type_declaration (local.variable_type, cfile);
1731
1732                                         data.add_field (local.variable_type.get_cname (), get_variable_cname (local.name) + local.variable_type.get_cdeclarator_suffix ());
1733
1734                                         if (local.variable_type is ArrayType) {
1735                                                 var array_type = (ArrayType) local.variable_type;
1736                                                 for (int dim = 1; dim <= array_type.rank; dim++) {
1737                                                         data.add_field ("gint", get_array_length_cname (get_variable_cname (local.name), dim));
1738                                                 }
1739                                                 data.add_field ("gint", get_array_size_cname (get_variable_cname (local.name)));
1740                                         } else if (local.variable_type is DelegateType) {
1741                                                 data.add_field ("gpointer", get_delegate_target_cname (get_variable_cname (local.name)));
1742                                                 if (local.variable_type.value_owned) {
1743                                                         data.add_field ("GDestroyNotify", get_delegate_target_destroy_notify_cname (get_variable_cname (local.name)));
1744                                                 }
1745                                         }
1746                                 }
1747                         }
1748
1749                         var data_alloc = new CCodeFunctionCall (new CCodeIdentifier ("g_slice_new0"));
1750                         data_alloc.add_argument (new CCodeIdentifier (struct_name));
1751
1752                         if (is_in_coroutine ()) {
1753                                 closure_struct.add_field (struct_name + "*", "_data%d_".printf (block_id));
1754                         } else {
1755                                 ccode.add_declaration (struct_name + "*", new CCodeVariableDeclarator ("_data%d_".printf (block_id)));
1756                         }
1757                         ccode.add_assignment (get_variable_cexpression ("_data%d_".printf (block_id)), data_alloc);
1758
1759                         // initialize ref_count
1760                         ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), "_ref_count_"), new CCodeIdentifier ("1"));
1761
1762                         if (parent_block != null) {
1763                                 int parent_block_id = get_block_id (parent_block);
1764
1765                                 var ref_call = new CCodeFunctionCall (new CCodeIdentifier ("block%d_data_ref".printf (parent_block_id)));
1766                                 ref_call.add_argument (get_variable_cexpression ("_data%d_".printf (parent_block_id)));
1767
1768                                 ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), "_data%d_".printf (parent_block_id)), ref_call);
1769                         } else {
1770                                 if (in_constructor || (current_method != null && current_method.binding == MemberBinding.INSTANCE &&
1771                                                               (!(current_method is CreationMethod) || current_method.body != b)) ||
1772                                            (current_property_accessor != null && current_property_accessor.prop.binding == MemberBinding.INSTANCE)) {
1773                                         var ref_call = new CCodeFunctionCall (get_dup_func_expression (new ObjectType (current_class), b.source_reference));
1774                                         ref_call.add_argument (get_result_cexpression ("self"));
1775
1776                                         ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), "self"), ref_call);
1777                                 }
1778
1779                                 if (current_method != null) {
1780                                         // allow capturing generic type parameters
1781                                         foreach (var type_param in current_method.get_type_parameters ()) {
1782                                                 string func_name;
1783
1784                                                 func_name = "%s_type".printf (type_param.name.down ());
1785                                                 ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), func_name), new CCodeIdentifier (func_name));
1786
1787                                                 func_name = "%s_dup_func".printf (type_param.name.down ());
1788                                                 ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), func_name), new CCodeIdentifier (func_name));
1789
1790                                                 func_name = "%s_destroy_func".printf (type_param.name.down ());
1791                                                 ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), func_name), new CCodeIdentifier (func_name));
1792                                         }
1793                                 }
1794                         }
1795
1796                         if (b.parent_symbol is Method) {
1797                                 var m = (Method) b.parent_symbol;
1798
1799                                 // parameters are captured with the top-level block of the method
1800                                 foreach (var param in m.get_parameters ()) {
1801                                         if (param.captured) {
1802                                                 capture_parameter (param, data, block_id);
1803                                         }
1804                                 }
1805
1806                                 if (m.coroutine) {
1807                                         // capture async data to allow invoking callback from inside closure
1808                                         data.add_field ("gpointer", "_async_data_");
1809
1810                                         // async method is suspended while waiting for callback,
1811                                         // so we never need to care about memory management of async data
1812                                         ccode.add_assignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), "_async_data_"), new CCodeIdentifier ("data"));
1813                                 }
1814                         } else if (b.parent_symbol is PropertyAccessor) {
1815                                 var acc = (PropertyAccessor) b.parent_symbol;
1816
1817                                 if (!acc.readable && acc.value_parameter.captured) {
1818                                         capture_parameter (acc.value_parameter, data, block_id);
1819                                 }
1820                         }
1821
1822                         var typedef = new CCodeTypeDefinition ("struct _" + struct_name, new CCodeVariableDeclarator (struct_name));
1823                         cfile.add_type_declaration (typedef);
1824                         cfile.add_type_definition (data);
1825
1826                         // create ref/unref functions
1827                         var ref_fun = new CCodeFunction ("block%d_data_ref".printf (block_id), struct_name + "*");
1828                         ref_fun.add_parameter (new CCodeParameter ("_data%d_".printf (block_id), struct_name + "*"));
1829                         ref_fun.modifiers = CCodeModifiers.STATIC;
1830                         cfile.add_function_declaration (ref_fun);
1831                         ref_fun.block = new CCodeBlock ();
1832
1833                         var ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_atomic_int_inc"));
1834                         ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeMemberAccess.pointer (new CCodeIdentifier ("_data%d_".printf (block_id)), "_ref_count_")));
1835                         ref_fun.block.add_statement (new CCodeExpressionStatement (ccall));
1836                         ref_fun.block.add_statement (new CCodeReturnStatement (new CCodeIdentifier ("_data%d_".printf (block_id))));
1837                         cfile.add_function (ref_fun);
1838
1839                         var unref_fun = new CCodeFunction ("block%d_data_unref".printf (block_id), "void");
1840                         unref_fun.add_parameter (new CCodeParameter ("_data%d_".printf (block_id), struct_name + "*"));
1841                         unref_fun.modifiers = CCodeModifiers.STATIC;
1842                         cfile.add_function_declaration (unref_fun);
1843
1844                         push_function (unref_fun);
1845
1846                         ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_atomic_int_dec_and_test"));
1847                         ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeMemberAccess.pointer (new CCodeIdentifier ("_data%d_".printf (block_id)), "_ref_count_")));
1848                         ccode.open_if (ccall);
1849
1850                         if (parent_block != null) {
1851                                 int parent_block_id = get_block_id (parent_block);
1852
1853                                 var unref_call = new CCodeFunctionCall (new CCodeIdentifier ("block%d_data_unref".printf (parent_block_id)));
1854                                 unref_call.add_argument (new CCodeMemberAccess.pointer (new CCodeIdentifier ("_data%d_".printf (block_id)), "_data%d_".printf (parent_block_id)));
1855                                 ccode.add_expression (unref_call);
1856                                 ccode.add_assignment (new CCodeMemberAccess.pointer (new CCodeIdentifier ("_data%d_".printf (block_id)), "_data%d_".printf (parent_block_id)), new CCodeConstant ("NULL"));
1857                         } else {
1858                                 if (in_constructor || (current_method != null && current_method.binding == MemberBinding.INSTANCE) ||
1859                                            (current_property_accessor != null && current_property_accessor.prop.binding == MemberBinding.INSTANCE)) {
1860                                         var ma = new MemberAccess.simple ("this");
1861                                         ma.symbol_reference = current_class;
1862                                         ccode.add_expression (get_unref_expression (new CCodeMemberAccess.pointer (new CCodeIdentifier ("_data%d_".printf (block_id)), "self"), new ObjectType (current_class), ma));
1863                                 }
1864                         }
1865
1866                         // free in reverse order
1867                         for (int i = local_vars.size - 1; i >= 0; i--) {
1868                                 var local = local_vars[i];
1869                                 if (local.captured) {
1870                                         if (requires_destroy (local.variable_type)) {
1871                                                 bool old_coroutine = false;
1872                                                 if (current_method != null) {
1873                                                         old_coroutine = current_method.coroutine;
1874                                                         current_method.coroutine = false;
1875                                                 }
1876
1877                                                 ccode.add_expression (destroy_local (local));
1878
1879                                                 if (old_coroutine) {
1880                                                         current_method.coroutine = true;
1881                                                 }
1882                                         }
1883                                 }
1884                         }
1885
1886                         if (b.parent_symbol is Method) {
1887                                 var m = (Method) b.parent_symbol;
1888
1889                                 // parameters are captured with the top-level block of the method
1890                                 foreach (var param in m.get_parameters ()) {
1891                                         if (param.captured) {
1892                                                 var param_type = param.variable_type.copy ();
1893                                                 param_type.value_owned = true;
1894
1895                                                 bool is_unowned_delegate = param.variable_type is DelegateType && !param.variable_type.value_owned;
1896
1897                                                 if (requires_destroy (param_type) && !is_unowned_delegate) {
1898                                                         bool old_coroutine = false;
1899                                                         if (m != null) {
1900                                                                 old_coroutine = m.coroutine;
1901                                                                 m.coroutine = false;
1902                                                         }
1903
1904                                                         ccode.add_expression (destroy_parameter (param));
1905
1906                                                         if (old_coroutine) {
1907                                                                 m.coroutine = true;
1908                                                         }
1909                                                 }
1910                                         }
1911                                 }
1912                         } else if (b.parent_symbol is PropertyAccessor) {
1913                                 var acc = (PropertyAccessor) b.parent_symbol;
1914
1915                                 if (!acc.readable && acc.value_parameter.captured) {
1916                                         var param_type = acc.value_parameter.variable_type.copy ();
1917                                         param_type.value_owned = true;
1918
1919                                         bool is_unowned_delegate = acc.value_parameter.variable_type is DelegateType && !acc.value_parameter.variable_type.value_owned;
1920
1921                                         if (requires_destroy (param_type) && !is_unowned_delegate) {
1922                                                 ccode.add_expression (destroy_parameter (acc.value_parameter));
1923                                         }
1924                                 }
1925                         }
1926
1927                         var data_free = new CCodeFunctionCall (new CCodeIdentifier ("g_slice_free"));
1928                         data_free.add_argument (new CCodeIdentifier (struct_name));
1929                         data_free.add_argument (new CCodeIdentifier ("_data%d_".printf (block_id)));
1930                         ccode.add_expression (data_free);
1931
1932                         ccode.close ();
1933
1934                         pop_function ();
1935
1936                         cfile.add_function (unref_fun);
1937                 }
1938
1939                 foreach (Statement stmt in b.get_statements ()) {
1940                         stmt.emit (this);
1941                 }
1942
1943                 // free in reverse order
1944                 for (int i = local_vars.size - 1; i >= 0; i--) {
1945                         var local = local_vars[i];
1946                         local.active = false;
1947                         if (!local.unreachable && !local.floating && !local.captured && requires_destroy (local.variable_type)) {
1948                                 ccode.add_expression (destroy_local (local));
1949                         }
1950                 }
1951
1952                 if (b.parent_symbol is Method) {
1953                         var m = (Method) b.parent_symbol;
1954                         foreach (Parameter param in m.get_parameters ()) {
1955                                 if (!param.captured && !param.ellipsis && requires_destroy (param.variable_type) && param.direction == ParameterDirection.IN) {
1956                                         ccode.add_expression (destroy_parameter (param));
1957                                 } else if (param.direction == ParameterDirection.OUT && !m.coroutine) {
1958                                         return_out_parameter (param);
1959                                 }
1960                         }
1961                 }
1962
1963                 if (b.captured) {
1964                         int block_id = get_block_id (b);
1965
1966                         var data_unref = new CCodeFunctionCall (new CCodeIdentifier ("block%d_data_unref".printf (block_id)));
1967                         data_unref.add_argument (get_variable_cexpression ("_data%d_".printf (block_id)));
1968                         ccode.add_expression (data_unref);
1969                         ccode.add_assignment (get_variable_cexpression ("_data%d_".printf (block_id)), new CCodeConstant ("NULL"));
1970                 }
1971
1972                 if (b.parent_node is Block || b.parent_node is SwitchStatement) {
1973                         ccode.close ();
1974                 }
1975
1976                 emit_context.pop_symbol ();
1977         }
1978
1979         public override void visit_declaration_statement (DeclarationStatement stmt) {
1980                 stmt.declaration.accept (this);
1981         }
1982
1983         public CCodeExpression get_variable_cexpression (string name) {
1984                 if (is_in_coroutine ()) {
1985                         return new CCodeMemberAccess.pointer (new CCodeIdentifier ("data"), get_variable_cname (name));
1986                 } else {
1987                         return new CCodeIdentifier (get_variable_cname (name));
1988                 }
1989         }
1990
1991         public string get_variable_cname (string name) {
1992                 if (name[0] == '.') {
1993                         if (name == ".result") {
1994                                 return "result";
1995                         }
1996                         // compiler-internal variable
1997                         if (!variable_name_map.contains (name)) {
1998                                 variable_name_map.set (name, "_tmp%d_".printf (next_temp_var_id));
1999                                 next_temp_var_id++;
2000                         }
2001                         return variable_name_map.get (name);
2002                 } else if (reserved_identifiers.contains (name)) {
2003                         return "_%s_".printf (name);
2004                 } else {
2005                         return name;
2006                 }
2007         }
2008
2009         public CCodeExpression get_result_cexpression (string cname = "result") {
2010                 if (is_in_coroutine ()) {
2011                         return new CCodeMemberAccess.pointer (new CCodeIdentifier ("data"), cname);
2012                 } else {
2013                         return new CCodeIdentifier (cname);
2014                 }
2015         }
2016
2017         bool has_simple_struct_initializer (LocalVariable local) {
2018                 var st = local.variable_type.data_type as Struct;
2019                 var initializer = local.initializer as ObjectCreationExpression;
2020                 if (st != null && (!st.is_simple_type () || st.get_cname () == "va_list") && !local.variable_type.nullable &&
2021                     initializer != null && initializer.get_object_initializer ().size == 0) {
2022                         return true;
2023                 } else {
2024                         return false;
2025                 }
2026         }
2027
2028         public override void visit_local_variable (LocalVariable local) {
2029                 check_type (local.variable_type);
2030
2031                 if (local.initializer != null) {
2032                         local.initializer.emit (this);
2033
2034                         visit_end_full_expression (local.initializer);
2035                 }
2036
2037                 generate_type_declaration (local.variable_type, cfile);
2038
2039                 CCodeExpression rhs = null;
2040                 if (local.initializer != null && get_cvalue (local.initializer) != null) {
2041                         rhs = get_cvalue (local.initializer);
2042                 }
2043
2044                 if (!local.captured) {
2045                         if (current_method != null && current_method.coroutine) {
2046                                 closure_struct.add_field (local.variable_type.get_cname (), get_variable_cname (local.name) + local.variable_type.get_cdeclarator_suffix ());
2047                         } else {
2048                                 var cvar = new CCodeVariableDeclarator (get_variable_cname (local.name), null, local.variable_type.get_cdeclarator_suffix ());
2049
2050                                 // try to initialize uninitialized variables
2051                                 // initialization not necessary for variables stored in closure
2052                                 if (rhs == null || has_simple_struct_initializer (local)) {
2053                                         cvar.initializer = default_value_for_type (local.variable_type, true);
2054                                         cvar.init0 = true;
2055                                 }
2056
2057                                 ccode.add_declaration (local.variable_type.get_cname (), cvar);
2058                         }
2059
2060                         if (local.variable_type is ArrayType) {
2061                                 // create variables to store array dimensions
2062                                 var array_type = (ArrayType) local.variable_type;
2063
2064                                 if (!array_type.fixed_length) {
2065                                         for (int dim = 1; dim <= array_type.rank; dim++) {
2066                                                 var len_var = new LocalVariable (int_type.copy (), get_array_length_cname (get_variable_cname (local.name), dim));
2067                                                 emit_temp_var (len_var, local.initializer == null);
2068                                         }
2069
2070                                         if (array_type.rank == 1) {
2071                                                 var size_var = new LocalVariable (int_type.copy (), get_array_size_cname (get_variable_cname (local.name)));
2072                                                 emit_temp_var (size_var, local.initializer == null);
2073                                         }
2074                                 }
2075                         } else if (local.variable_type is DelegateType) {
2076                                 var deleg_type = (DelegateType) local.variable_type;
2077                                 var d = deleg_type.delegate_symbol;
2078                                 if (d.has_target) {
2079                                         // create variable to store delegate target
2080                                         var target_var = new LocalVariable (new PointerType (new VoidType ()), get_delegate_target_cname (get_variable_cname (local.name)));
2081                                         emit_temp_var (target_var, local.initializer == null);
2082                                         if (deleg_type.value_owned) {
2083                                                 var target_destroy_notify_var = new LocalVariable (gdestroynotify_type, get_delegate_target_destroy_notify_cname (get_variable_cname (local.name)));
2084                                                 emit_temp_var (target_destroy_notify_var, local.initializer == null);
2085                                         }
2086                                 }
2087                         }
2088                 }
2089
2090                 if (rhs != null) {
2091                         if (!has_simple_struct_initializer (local)) {
2092                                 store_local (local, local.initializer.target_value, true);
2093                         }
2094                 }
2095
2096                 if (local.initializer != null && local.initializer.tree_can_fail) {
2097                         add_simple_check (local.initializer);
2098                 }
2099
2100                 local.active = true;
2101         }
2102
2103         public override void visit_initializer_list (InitializerList list) {
2104                 if (list.target_type.data_type is Struct) {
2105                         /* initializer is used as struct initializer */
2106                         var st = (Struct) list.target_type.data_type;
2107
2108                         if (list.parent_node is Constant || list.parent_node is Field || list.parent_node is InitializerList) {
2109                                 var clist = new CCodeInitializerList ();
2110
2111                                 var field_it = st.get_fields ().iterator ();
2112                                 foreach (Expression expr in list.get_initializers ()) {
2113                                         Field field = null;
2114                                         while (field == null) {
2115                                                 field_it.next ();
2116                                                 field = field_it.get ();
2117                                                 if (field.binding != MemberBinding.INSTANCE) {
2118                                                         // we only initialize instance fields
2119                                                         field = null;
2120                                                 }
2121                                         }
2122
2123                                         var cexpr = get_cvalue (expr);
2124
2125                                         string ctype = field.get_ctype ();
2126                                         if (ctype != null) {
2127                                                 cexpr = new CCodeCastExpression (cexpr, ctype);
2128                                         }
2129
2130                                         clist.append (cexpr);
2131                                 }
2132
2133                                 set_cvalue (list, clist);
2134                         } else {
2135                                 // used as expression
2136                                 var temp_decl = get_temp_variable (list.target_type, false, list);
2137                                 emit_temp_var (temp_decl);
2138
2139                                 var instance = get_variable_cexpression (get_variable_cname (temp_decl.name));
2140
2141                                 var field_it = st.get_fields ().iterator ();
2142                                 foreach (Expression expr in list.get_initializers ()) {
2143                                         Field field = null;
2144                                         while (field == null) {
2145                                                 field_it.next ();
2146                                                 field = field_it.get ();
2147                                                 if (field.binding != MemberBinding.INSTANCE) {
2148                                                         // we only initialize instance fields
2149                                                         field = null;
2150                                                 }
2151                                         }
2152
2153                                         var cexpr = get_cvalue (expr);
2154
2155                                         string ctype = field.get_ctype ();
2156                                         if (ctype != null) {
2157                                                 cexpr = new CCodeCastExpression (cexpr, ctype);
2158                                         }
2159
2160                                         var lhs = new CCodeMemberAccess (instance, field.get_cname ());;
2161                                         ccode.add_assignment (lhs, cexpr);
2162                                 }
2163
2164                                 set_cvalue (list, instance);
2165                         }
2166                 } else {
2167                         var clist = new CCodeInitializerList ();
2168                         foreach (Expression expr in list.get_initializers ()) {
2169                                 clist.append (get_cvalue (expr));
2170                         }
2171                         set_cvalue (list, clist);
2172                 }
2173         }
2174
2175         public override LocalVariable create_local (DataType type) {
2176                 var result = get_temp_variable (type, type.value_owned);
2177                 emit_temp_var (result);
2178                 return result;
2179         }
2180
2181         public LocalVariable get_temp_variable (DataType type, bool value_owned = true, CodeNode? node_reference = null, bool init = true) {
2182                 var var_type = type.copy ();
2183                 var_type.value_owned = value_owned;
2184                 var local = new LocalVariable (var_type, "_tmp%d_".printf (next_temp_var_id));
2185                 local.no_init = !init;
2186
2187                 if (node_reference != null) {
2188                         local.source_reference = node_reference.source_reference;
2189                 }
2190
2191                 next_temp_var_id++;
2192
2193                 return local;
2194         }
2195
2196         bool is_in_generic_type (DataType type) {
2197                 if (current_symbol != null && type.type_parameter.parent_symbol is TypeSymbol
2198                     && (current_method == null || current_method.binding == MemberBinding.INSTANCE)) {
2199                         return true;
2200                 } else {
2201                         return false;
2202                 }
2203         }
2204
2205         public CCodeExpression get_type_id_expression (DataType type, bool is_chainup = false) {
2206                 if (type is GenericType) {
2207                         string var_name = "%s_type".printf (type.type_parameter.name.down ());
2208                         if (is_in_generic_type (type) && !is_chainup && !in_creation_method) {
2209                                 return new CCodeMemberAccess.pointer (new CCodeMemberAccess.pointer (get_result_cexpression ("self"), "priv"), var_name);
2210                         } else {
2211                                 return new CCodeIdentifier (var_name);
2212                         }
2213                 } else {
2214                         string type_id = type.get_type_id ();
2215                         if (type_id == null) {
2216                                 type_id = "G_TYPE_INVALID";
2217                         } else {
2218                                 generate_type_declaration (type, cfile);
2219                         }
2220                         return new CCodeIdentifier (type_id);
2221                 }
2222         }
2223
2224         public virtual CCodeExpression? get_dup_func_expression (DataType type, SourceReference? source_reference, bool is_chainup = false) {
2225                 if (type is ErrorType) {
2226                         return new CCodeIdentifier ("g_error_copy");
2227                 } else if (type.data_type != null) {
2228                         string dup_function;
2229                         var cl = type.data_type as Class;
2230                         if (type.data_type.is_reference_counting ()) {
2231                                 dup_function = type.data_type.get_ref_function ();
2232                                 if (type.data_type is Interface && dup_function == null) {
2233                                         Report.error (source_reference, "missing class prerequisite for interface `%s', add GLib.Object to interface declaration if unsure".printf (type.data_type.get_full_name ()));
2234                                         return null;
2235                                 }
2236                         } else if (cl != null && cl.is_immutable) {
2237                                 // allow duplicates of immutable instances as for example strings
2238                                 dup_function = type.data_type.get_dup_function ();
2239                                 if (dup_function == null) {
2240                                         dup_function = "";
2241                                 }
2242                         } else if (cl != null && cl.is_gboxed) {
2243                                 // allow duplicates of gboxed instances
2244                                 dup_function = generate_dup_func_wrapper (type);
2245                                 if (dup_function == null) {
2246                                         dup_function = "";
2247                                 }
2248                         } else if (type is ValueType) {
2249                                 dup_function = type.data_type.get_dup_function ();
2250                                 if (dup_function == null && type.nullable) {
2251                                         dup_function = generate_struct_dup_wrapper ((ValueType) type);
2252                                 } else if (dup_function == null) {
2253                                         dup_function = "";
2254                                 }
2255                         } else {
2256                                 // duplicating non-reference counted objects may cause side-effects (and performance issues)
2257                                 Report.error (source_reference, "duplicating %s instance, use unowned variable or explicitly invoke copy method".printf (type.data_type.name));
2258                                 return null;
2259                         }
2260
2261                         return new CCodeIdentifier (dup_function);
2262                 } else if (type.type_parameter != null) {
2263                         string func_name = "%s_dup_func".printf (type.type_parameter.name.down ());
2264                         if (is_in_generic_type (type) && !is_chainup && !in_creation_method) {
2265                                 return new CCodeMemberAccess.pointer (new CCodeMemberAccess.pointer (get_result_cexpression ("self"), "priv"), func_name);
2266                         } else {
2267                                 return new CCodeIdentifier (func_name);
2268                         }
2269                 } else if (type is PointerType) {
2270                         var pointer_type = (PointerType) type;
2271                         return get_dup_func_expression (pointer_type.base_type, source_reference);
2272                 } else {
2273                         return new CCodeConstant ("NULL");
2274                 }
2275         }
2276
2277         void make_comparable_cexpression (ref DataType left_type, ref CCodeExpression cleft, ref DataType right_type, ref CCodeExpression cright) {
2278                 var left_type_as_struct = left_type.data_type as Struct;
2279                 var right_type_as_struct = right_type.data_type as Struct;
2280
2281                 // GValue support
2282                 var valuecast = try_cast_value_to_type (cleft, left_type, right_type);
2283                 if (valuecast != null) {
2284                         cleft = valuecast;
2285                         left_type = right_type;
2286                         make_comparable_cexpression (ref left_type, ref cleft, ref right_type, ref cright);
2287                         return;
2288                 }
2289
2290                 valuecast = try_cast_value_to_type (cright, right_type, left_type);
2291                 if (valuecast != null) {
2292                         cright = valuecast;
2293                         right_type = left_type;
2294                         make_comparable_cexpression (ref left_type, ref cleft, ref right_type, ref cright);
2295                         return;
2296                 }
2297
2298                 if (left_type.data_type is Class && !((Class) left_type.data_type).is_compact &&
2299                     right_type.data_type is Class && !((Class) right_type.data_type).is_compact) {
2300                         var left_cl = (Class) left_type.data_type;
2301                         var right_cl = (Class) right_type.data_type;
2302
2303                         if (left_cl != right_cl) {
2304                                 if (left_cl.is_subtype_of (right_cl)) {
2305                                         cleft = generate_instance_cast (cleft, right_cl);
2306                                 } else if (right_cl.is_subtype_of (left_cl)) {
2307                                         cright = generate_instance_cast (cright, left_cl);
2308                                 }
2309                         }
2310                 } else if (left_type_as_struct != null && right_type_as_struct != null) {
2311                         if (left_type is StructValueType) {
2312                                 // real structs (uses compare/equal function)
2313                                 if (!left_type.nullable) {
2314                                         cleft = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, cleft);
2315                                 }
2316                                 if (!right_type.nullable) {
2317                                         cright = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, cright);
2318                                 }
2319                         } else {
2320                                 // integer or floating or boolean type
2321                                 if (left_type.nullable && right_type.nullable) {
2322                                         // FIXME also compare contents, not just address
2323                                 } else if (left_type.nullable) {
2324                                         // FIXME check left value is not null
2325                                         cleft = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, cleft);
2326                                 } else if (right_type.nullable) {
2327                                         // FIXME check right value is not null
2328                                         cright = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, cright);
2329                                 }
2330                         }
2331                 }
2332         }
2333
2334         private string generate_struct_equal_function (Struct st) {
2335                 string equal_func = "_%sequal".printf (st.get_lower_case_cprefix ());
2336
2337                 if (!add_wrapper (equal_func)) {
2338                         // wrapper already defined
2339                         return equal_func;
2340                 }
2341
2342                 var function = new CCodeFunction (equal_func, "gboolean");
2343                 function.modifiers = CCodeModifiers.STATIC;
2344
2345                 function.add_parameter (new CCodeParameter ("s1", "const " + st.get_cname () + "*"));
2346                 function.add_parameter (new CCodeParameter ("s2", "const " + st.get_cname () + "*"));
2347
2348                 push_function (function);
2349
2350                 // if (s1 == s2) return TRUE;
2351                 {
2352                         var cexp = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, new CCodeIdentifier ("s1"), new CCodeIdentifier ("s2"));
2353                         ccode.open_if (cexp);
2354                         ccode.add_return (new CCodeConstant ("TRUE"));
2355                         ccode.close ();
2356                 }
2357                 // if (s1 == NULL || s2 == NULL) return FALSE;
2358                 {
2359                         var cexp = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, new CCodeIdentifier ("s1"), new CCodeConstant ("NULL"));
2360                         ccode.open_if (cexp);
2361                         ccode.add_return (new CCodeConstant ("FALSE"));
2362                         ccode.close ();
2363
2364                         cexp = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, new CCodeIdentifier ("s2"), new CCodeConstant ("NULL"));
2365                         ccode.open_if (cexp);
2366                         ccode.add_return (new CCodeConstant ("FALSE"));
2367                         ccode.close ();
2368                 }
2369
2370                 foreach (Field f in st.get_fields ()) {
2371                         if (f.binding != MemberBinding.INSTANCE) {
2372                                 // we only compare instance fields
2373                                 continue;
2374                         }
2375
2376                         CCodeExpression cexp; // if (cexp) return FALSE;
2377                         var s1 = (CCodeExpression) new CCodeMemberAccess.pointer (new CCodeIdentifier ("s1"), f.name); // s1->f
2378                         var s2 = (CCodeExpression) new CCodeMemberAccess.pointer (new CCodeIdentifier ("s2"), f.name); // s2->f
2379
2380                         var variable_type = f.variable_type.copy ();
2381                         make_comparable_cexpression (ref variable_type, ref s1, ref variable_type, ref s2);
2382
2383                         if (!(f.variable_type is NullType) && f.variable_type.compatible (string_type)) {
2384                                 var ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_strcmp0"));
2385                                 ccall.add_argument (s1);
2386                                 ccall.add_argument (s2);
2387                                 cexp = ccall;
2388                         } else if (f.variable_type is StructValueType) {
2389                                 var equalfunc = generate_struct_equal_function (f.variable_type.data_type as Struct);
2390                                 var ccall = new CCodeFunctionCall (new CCodeIdentifier (equalfunc));
2391                                 ccall.add_argument (s1);
2392                                 ccall.add_argument (s2);
2393                                 cexp = new CCodeUnaryExpression (CCodeUnaryOperator.LOGICAL_NEGATION, ccall);
2394                         } else {
2395                                 cexp = new CCodeBinaryExpression (CCodeBinaryOperator.INEQUALITY, s1, s2);
2396                         }
2397
2398                         ccode.open_if (cexp);
2399                         ccode.add_return (new CCodeConstant ("FALSE"));
2400                         ccode.close ();
2401                 }
2402
2403                 if (st.get_fields().size == 0) {
2404                         // either opaque structure or simple type
2405                         if (st.is_simple_type ()) {
2406                                 var cexp = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("s1")), new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("s2")));
2407                                 ccode.add_return (cexp);
2408                         } else {
2409                                 ccode.add_return (new CCodeConstant ("FALSE"));
2410                         }
2411                 } else {
2412                         ccode.add_return (new CCodeConstant ("TRUE"));
2413                 }
2414
2415                 pop_function ();
2416
2417                 cfile.add_function_declaration (function);
2418                 cfile.add_function (function);
2419
2420                 return equal_func;
2421         }
2422
2423         private string generate_numeric_equal_function (Struct st) {
2424                 string equal_func = "_%sequal".printf (st.get_lower_case_cprefix ());
2425
2426                 if (!add_wrapper (equal_func)) {
2427                         // wrapper already defined
2428                         return equal_func;
2429                 }
2430
2431                 var function = new CCodeFunction (equal_func, "gboolean");
2432                 function.modifiers = CCodeModifiers.STATIC;
2433
2434                 function.add_parameter (new CCodeParameter ("s1", "const " + st.get_cname () + "*"));
2435                 function.add_parameter (new CCodeParameter ("s2", "const " + st.get_cname () + "*"));
2436
2437                 push_function (function);
2438
2439                 // if (s1 == s2) return TRUE;
2440                 {
2441                         var cexp = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, new CCodeIdentifier ("s1"), new CCodeIdentifier ("s2"));
2442                         ccode.open_if (cexp);
2443                         ccode.add_return (new CCodeConstant ("TRUE"));
2444                         ccode.close ();
2445                 }
2446                 // if (s1 == NULL || s2 == NULL) return FALSE;
2447                 {
2448                         var cexp = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, new CCodeIdentifier ("s1"), new CCodeConstant ("NULL"));
2449                         ccode.open_if (cexp);
2450                         ccode.add_return (new CCodeConstant ("FALSE"));
2451                         ccode.close ();
2452
2453                         cexp = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, new CCodeIdentifier ("s2"), new CCodeConstant ("NULL"));
2454                         ccode.open_if (cexp);
2455                         ccode.add_return (new CCodeConstant ("FALSE"));
2456                         ccode.close ();
2457                 }
2458                 // return (*s1 == *s2);
2459                 {
2460                         var cexp = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("s1")), new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier ("s2")));
2461                         ccode.add_return (cexp);
2462                 }
2463
2464                 pop_function ();
2465
2466                 cfile.add_function_declaration (function);
2467                 cfile.add_function (function);
2468
2469                 return equal_func;
2470         }
2471
2472         private string generate_struct_dup_wrapper (ValueType value_type) {
2473                 string dup_func = "_%sdup".printf (value_type.type_symbol.get_lower_case_cprefix ());
2474
2475                 if (!add_wrapper (dup_func)) {
2476                         // wrapper already defined
2477                         return dup_func;
2478                 }
2479
2480                 var function = new CCodeFunction (dup_func, value_type.get_cname ());
2481                 function.modifiers = CCodeModifiers.STATIC;
2482
2483                 function.add_parameter (new CCodeParameter ("self", value_type.get_cname ()));
2484
2485                 push_function (function);
2486
2487                 if (value_type.type_symbol == gvalue_type) {
2488                         var dup_call = new CCodeFunctionCall (new CCodeIdentifier ("g_boxed_copy"));
2489                         dup_call.add_argument (new CCodeIdentifier ("G_TYPE_VALUE"));
2490                         dup_call.add_argument (new CCodeIdentifier ("self"));
2491
2492                         ccode.add_return (dup_call);
2493                 } else {
2494                         ccode.add_declaration (value_type.get_cname (), new CCodeVariableDeclarator ("dup"));
2495
2496                         var creation_call = new CCodeFunctionCall (new CCodeIdentifier ("g_new0"));
2497                         creation_call.add_argument (new CCodeConstant (value_type.data_type.get_cname ()));
2498                         creation_call.add_argument (new CCodeConstant ("1"));
2499                         ccode.add_assignment (new CCodeIdentifier ("dup"), creation_call);
2500
2501                         var st = value_type.data_type as Struct;
2502                         if (st != null && st.is_disposable ()) {
2503                                 if (!st.has_copy_function) {
2504                                         generate_struct_copy_function (st);
2505                                 }
2506
2507                                 var copy_call = new CCodeFunctionCall (new CCodeIdentifier (st.get_copy_function ()));
2508                                 copy_call.add_argument (new CCodeIdentifier ("self"));
2509                                 copy_call.add_argument (new CCodeIdentifier ("dup"));
2510                                 ccode.add_expression (copy_call);
2511                         } else {
2512                                 cfile.add_include ("string.h");
2513
2514                                 var sizeof_call = new CCodeFunctionCall (new CCodeIdentifier ("sizeof"));
2515                                 sizeof_call.add_argument (new CCodeConstant (value_type.data_type.get_cname ()));
2516
2517                                 var copy_call = new CCodeFunctionCall (new CCodeIdentifier ("memcpy"));
2518                                 copy_call.add_argument (new CCodeIdentifier ("dup"));
2519                                 copy_call.add_argument (new CCodeIdentifier ("self"));
2520                                 copy_call.add_argument (sizeof_call);
2521                                 ccode.add_expression (copy_call);
2522                         }
2523
2524                         ccode.add_return (new CCodeIdentifier ("dup"));
2525                 }
2526
2527                 pop_function ();
2528
2529                 cfile.add_function_declaration (function);
2530                 cfile.add_function (function);
2531
2532                 return dup_func;
2533         }
2534
2535         protected string generate_dup_func_wrapper (DataType type) {
2536                 string destroy_func = "_vala_%s_copy".printf (type.data_type.get_cname ());
2537
2538                 if (!add_wrapper (destroy_func)) {
2539                         // wrapper already defined
2540                         return destroy_func;
2541                 }
2542
2543                 var function = new CCodeFunction (destroy_func, type.get_cname ());
2544                 function.modifiers = CCodeModifiers.STATIC;
2545                 function.add_parameter (new CCodeParameter ("self", type.get_cname ()));
2546
2547                 push_function (function);
2548
2549                 var cl = type.data_type as Class;
2550                 assert (cl != null && cl.is_gboxed);
2551
2552                 var free_call = new CCodeFunctionCall (new CCodeIdentifier ("g_boxed_copy"));
2553                 free_call.add_argument (new CCodeIdentifier (cl.get_type_id ()));
2554                 free_call.add_argument (new CCodeIdentifier ("self"));
2555
2556                 ccode.add_return (free_call);
2557
2558                 pop_function ();
2559
2560                 cfile.add_function_declaration (function);
2561                 cfile.add_function (function);
2562
2563                 return destroy_func;
2564         }
2565
2566         protected string generate_free_func_wrapper (DataType type) {
2567                 string destroy_func = "_vala_%s_free".printf (type.data_type.get_cname ());
2568
2569                 if (!add_wrapper (destroy_func)) {
2570                         // wrapper already defined
2571                         return destroy_func;
2572                 }
2573
2574                 var function = new CCodeFunction (destroy_func, "void");
2575                 function.modifiers = CCodeModifiers.STATIC;
2576                 function.add_parameter (new CCodeParameter ("self", type.get_cname ()));
2577
2578                 push_function (function);
2579
2580                 var cl = type.data_type as Class;
2581                 if (cl != null && cl.is_gboxed) {
2582                         var free_call = new CCodeFunctionCall (new CCodeIdentifier ("g_boxed_free"));
2583                         free_call.add_argument (new CCodeIdentifier (cl.get_type_id ()));
2584                         free_call.add_argument (new CCodeIdentifier ("self"));
2585
2586                         ccode.add_expression (free_call);
2587                 } else if (cl != null) {
2588                         assert (cl.free_function_address_of);
2589
2590                         var free_call = new CCodeFunctionCall (new CCodeIdentifier (type.data_type.get_free_function ()));
2591                         free_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("self")));
2592
2593                         ccode.add_expression (free_call);
2594                 } else {
2595                         var st = type.data_type as Struct;
2596                         if (st != null && st.is_disposable ()) {
2597                                 if (!st.has_destroy_function) {
2598                                         generate_struct_destroy_function (st);
2599                                 }
2600
2601                                 var destroy_call = new CCodeFunctionCall (new CCodeIdentifier (st.get_destroy_function ()));
2602                                 destroy_call.add_argument (new CCodeIdentifier ("self"));
2603                                 ccode.add_expression (destroy_call);
2604                         }
2605
2606                         var free_call = new CCodeFunctionCall (new CCodeIdentifier ("g_free"));
2607                         free_call.add_argument (new CCodeIdentifier ("self"));
2608
2609                         ccode.add_expression (free_call);
2610                 }
2611
2612                 pop_function ();
2613
2614                 cfile.add_function_declaration (function);
2615                 cfile.add_function (function);
2616
2617                 return destroy_func;
2618         }
2619
2620         public CCodeExpression? get_destroy0_func_expression (DataType type, bool is_chainup = false) {
2621                 var element_destroy_func_expression = get_destroy_func_expression (type, is_chainup);
2622
2623                 if (element_destroy_func_expression is CCodeIdentifier) {
2624                         var freeid = (CCodeIdentifier) element_destroy_func_expression;
2625                         string free0_func = "_%s0_".printf (freeid.name);
2626
2627                         if (add_wrapper (free0_func)) {
2628                                 var function = new CCodeFunction (free0_func, "void");
2629                                 function.modifiers = CCodeModifiers.STATIC;
2630
2631                                 function.add_parameter (new CCodeParameter ("var", "gpointer"));
2632
2633                                 push_function (function);
2634
2635                                 ccode.add_expression (get_unref_expression (new CCodeIdentifier ("var"), type, null, true));
2636
2637                                 pop_function ();
2638
2639                                 cfile.add_function_declaration (function);
2640                                 cfile.add_function (function);
2641                         }
2642
2643                         element_destroy_func_expression = new CCodeIdentifier (free0_func);
2644                 }
2645
2646                 return element_destroy_func_expression;
2647         }
2648
2649         public CCodeExpression? get_destroy_func_expression (DataType type, bool is_chainup = false) {
2650                 if (context.profile == Profile.GOBJECT && (type.data_type == glist_type || type.data_type == gslist_type || type.data_type == gnode_type)) {
2651                         // create wrapper function to free list elements if necessary
2652
2653                         bool elements_require_free = false;
2654                         CCodeExpression element_destroy_func_expression = null;
2655
2656                         foreach (DataType type_arg in type.get_type_arguments ()) {
2657                                 elements_require_free = requires_destroy (type_arg);
2658                                 if (elements_require_free) {
2659                                         element_destroy_func_expression = get_destroy0_func_expression (type_arg);
2660                                 }
2661                         }
2662
2663                         if (elements_require_free && element_destroy_func_expression is CCodeIdentifier) {
2664                                 return new CCodeIdentifier (generate_collection_free_wrapper (type, (CCodeIdentifier) element_destroy_func_expression));
2665                         } else {
2666                                 return new CCodeIdentifier (type.data_type.get_free_function ());
2667                         }
2668                 } else if (type is ErrorType) {
2669                         return new CCodeIdentifier ("g_error_free");
2670                 } else if (type.data_type != null) {
2671                         string unref_function;
2672                         if (type is ReferenceType) {
2673                                 if (type.data_type.is_reference_counting ()) {
2674                                         unref_function = type.data_type.get_unref_function ();
2675                                         if (type.data_type is Interface && unref_function == null) {
2676                                                 Report.error (type.source_reference, "missing class prerequisite for interface `%s', add GLib.Object to interface declaration if unsure".printf (type.data_type.get_full_name ()));
2677                                                 return null;
2678                                         }
2679                                 } else {
2680                                         var cl = type.data_type as Class;
2681                                         if (cl != null && (cl.free_function_address_of || cl.is_gboxed)) {
2682                                                 unref_function = generate_free_func_wrapper (type);
2683                                         } else {
2684                                                 unref_function = type.data_type.get_free_function ();
2685                                         }
2686                                 }
2687                         } else {
2688                                 if (type.nullable) {
2689                                         unref_function = type.data_type.get_free_function ();
2690                                         if (unref_function == null) {
2691                                                 if (type.data_type is Struct && ((Struct) type.data_type).is_disposable ()) {
2692                                                         unref_function = generate_free_func_wrapper (type);
2693                                                 } else {
2694                                                         unref_function = "g_free";
2695                                                 }
2696                                         }
2697                                 } else {
2698                                         var st = (Struct) type.data_type;
2699                                         if (!st.has_destroy_function) {
2700                                                 generate_struct_destroy_function (st);
2701                                         }
2702                                         unref_function = st.get_destroy_function ();
2703                                 }
2704                         }
2705                         if (unref_function == null) {
2706                                 return new CCodeConstant ("NULL");
2707                         }
2708                         return new CCodeIdentifier (unref_function);
2709                 } else if (type.type_parameter != null && current_type_symbol is Class) {
2710                         string func_name = "%s_destroy_func".printf (type.type_parameter.name.down ());
2711                         if (is_in_generic_type (type) && !is_chainup && !in_creation_method) {
2712                                 return new CCodeMemberAccess.pointer (new CCodeMemberAccess.pointer (get_result_cexpression ("self"), "priv"), func_name);
2713                         } else {
2714                                 return new CCodeIdentifier (func_name);
2715                         }
2716                 } else if (type is ArrayType) {
2717                         if (context.profile == Profile.POSIX) {
2718                                 return new CCodeIdentifier ("free");
2719                         } else {
2720                                 return new CCodeIdentifier ("g_free");
2721                         }
2722                 } else if (type is PointerType) {
2723                         if (context.profile == Profile.POSIX) {
2724                                 return new CCodeIdentifier ("free");
2725                         } else {
2726                                 return new CCodeIdentifier ("g_free");
2727                         }
2728                 } else {
2729                         return new CCodeConstant ("NULL");
2730                 }
2731         }
2732
2733         private string generate_collection_free_wrapper (DataType collection_type, CCodeIdentifier element_destroy_func_expression) {
2734                 string destroy_func = "_%s_%s".printf (collection_type.data_type.get_free_function (), element_destroy_func_expression.name);
2735
2736                 if (!add_wrapper (destroy_func)) {
2737                         // wrapper already defined
2738                         return destroy_func;
2739                 }
2740
2741                 var function = new CCodeFunction (destroy_func, "void");
2742                 function.modifiers = CCodeModifiers.STATIC;
2743
2744                 function.add_parameter (new CCodeParameter ("self", collection_type.get_cname ()));
2745
2746                 push_function (function);
2747
2748                 CCodeFunctionCall element_free_call;
2749                 if (collection_type.data_type == gnode_type) {
2750                         /* A wrapper which converts GNodeTraverseFunc into GDestroyNotify */
2751                         string destroy_node_func = "%s_node".printf (destroy_func);
2752                         var wrapper = new CCodeFunction (destroy_node_func, "gboolean");
2753                         wrapper.modifiers = CCodeModifiers.STATIC;
2754                         wrapper.add_parameter (new CCodeParameter ("node", collection_type.get_cname ()));
2755                         wrapper.add_parameter (new CCodeParameter ("unused", "gpointer"));
2756                         var wrapper_block = new CCodeBlock ();
2757                         var free_call = new CCodeFunctionCall (element_destroy_func_expression);
2758                         free_call.add_argument (new CCodeMemberAccess.pointer(new CCodeIdentifier("node"), "data"));
2759                         wrapper_block.add_statement (new CCodeExpressionStatement (free_call));
2760                         wrapper_block.add_statement (new CCodeReturnStatement (new CCodeConstant ("FALSE")));
2761                         cfile.add_function_declaration (function);
2762                         wrapper.block = wrapper_block;
2763                         cfile.add_function (wrapper);
2764
2765                         /* Now the code to call g_traverse with the above */
2766                         element_free_call = new CCodeFunctionCall (new CCodeIdentifier ("g_node_traverse"));
2767                         element_free_call.add_argument (new CCodeIdentifier("self"));
2768                         element_free_call.add_argument (new CCodeConstant ("G_POST_ORDER"));
2769                         element_free_call.add_argument (new CCodeConstant ("G_TRAVERSE_ALL"));
2770                         element_free_call.add_argument (new CCodeConstant ("-1"));
2771                         element_free_call.add_argument (new CCodeIdentifier (destroy_node_func));
2772                         element_free_call.add_argument (new CCodeConstant ("NULL"));
2773                 } else {
2774                         if (collection_type.data_type == glist_type) {
2775                                 element_free_call = new CCodeFunctionCall (new CCodeIdentifier ("g_list_foreach"));
2776                         } else {
2777                                 element_free_call = new CCodeFunctionCall (new CCodeIdentifier ("g_slist_foreach"));
2778                         }
2779
2780                         element_free_call.add_argument (new CCodeIdentifier ("self"));
2781                         element_free_call.add_argument (new CCodeCastExpression (element_destroy_func_expression, "GFunc"));
2782                         element_free_call.add_argument (new CCodeConstant ("NULL"));
2783                 }
2784
2785                 ccode.add_expression (element_free_call);
2786
2787                 var cfreecall = new CCodeFunctionCall (new CCodeIdentifier (collection_type.data_type.get_free_function ()));
2788                 cfreecall.add_argument (new CCodeIdentifier ("self"));
2789                 ccode.add_expression (cfreecall);
2790
2791                 pop_function ();
2792
2793                 cfile.add_function_declaration (function);
2794                 cfile.add_function (function);
2795
2796                 return destroy_func;
2797         }
2798
2799         public virtual string? append_struct_array_free (Struct st) {
2800                 return null;
2801         }
2802
2803         // logic in this method is temporarily duplicated in destroy_value
2804         // apply changes to both methods
2805         public virtual CCodeExpression destroy_variable (Variable variable, TargetValue target_lvalue) {
2806                 var type = variable.variable_type;
2807                 var cvar = get_cvalue_ (target_lvalue);
2808
2809                 if (type is DelegateType) {
2810                         var delegate_target = get_delegate_target_cvalue (target_lvalue);
2811                         var delegate_target_destroy_notify = get_delegate_target_destroy_notify_cvalue (target_lvalue);
2812
2813                         var ccall = new CCodeFunctionCall (delegate_target_destroy_notify);
2814                         ccall.add_argument (delegate_target);
2815
2816                         var destroy_call = new CCodeCommaExpression ();
2817                         destroy_call.append_expression (ccall);
2818                         destroy_call.append_expression (new CCodeConstant ("NULL"));
2819
2820                         var cisnull = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, delegate_target_destroy_notify, new CCodeConstant ("NULL"));
2821
2822                         var ccomma = new CCodeCommaExpression ();
2823                         ccomma.append_expression (new CCodeConditionalExpression (cisnull, new CCodeConstant ("NULL"), destroy_call));
2824                         ccomma.append_expression (new CCodeAssignment (cvar, new CCodeConstant ("NULL")));
2825                         ccomma.append_expression (new CCodeAssignment (delegate_target, new CCodeConstant ("NULL")));
2826                         ccomma.append_expression (new CCodeAssignment (delegate_target_destroy_notify, new CCodeConstant ("NULL")));
2827
2828                         return ccomma;
2829                 }
2830
2831                 var ccall = new CCodeFunctionCall (get_destroy_func_expression (type));
2832
2833                 if (type is ValueType && !type.nullable) {
2834                         // normal value type, no null check
2835                         var st = type.data_type as Struct;
2836                         if (st != null && st.is_simple_type ()) {
2837                                 // used for va_list
2838                                 ccall.add_argument (cvar);
2839                         } else {
2840                                 ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, cvar));
2841                         }
2842
2843                         if (gvalue_type != null && type.data_type == gvalue_type) {
2844                                 // g_value_unset must not be called for already unset values
2845                                 var cisvalid = new CCodeFunctionCall (new CCodeIdentifier ("G_IS_VALUE"));
2846                                 cisvalid.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, cvar));
2847
2848                                 var ccomma = new CCodeCommaExpression ();
2849                                 ccomma.append_expression (ccall);
2850                                 ccomma.append_expression (new CCodeConstant ("NULL"));
2851
2852                                 return new CCodeConditionalExpression (cisvalid, ccomma, new CCodeConstant ("NULL"));
2853                         } else {
2854                                 return ccall;
2855                         }
2856                 }
2857
2858                 if (ccall.call is CCodeIdentifier && !(type is ArrayType)) {
2859                         // generate and use NULL-aware free macro to simplify code
2860
2861                         var freeid = (CCodeIdentifier) ccall.call;
2862                         string free0_func = "_%s0".printf (freeid.name);
2863
2864                         if (add_wrapper (free0_func)) {
2865                                 var macro = destroy_value (new GLibValue (type, new CCodeIdentifier ("var")), true);
2866                                 cfile.add_type_declaration (new CCodeMacroReplacement.with_expression ("%s(var)".printf (free0_func), macro));
2867                         }
2868
2869                         ccall = new CCodeFunctionCall (new CCodeIdentifier (free0_func));
2870                         ccall.add_argument (cvar);
2871                         return ccall;
2872                 }
2873
2874                 /* (foo == NULL ? NULL : foo = (unref (foo), NULL)) */
2875
2876                 /* can be simplified to
2877                  * foo = (unref (foo), NULL)
2878                  * if foo is of static type non-null
2879                  */
2880
2881                 var cisnull = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, cvar, new CCodeConstant ("NULL"));
2882                 if (type.type_parameter != null) {
2883                         if (!(current_type_symbol is Class) || current_class.is_compact) {
2884                                 return new CCodeConstant ("NULL");
2885                         }
2886
2887                         // unref functions are optional for type parameters
2888                         var cunrefisnull = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, get_destroy_func_expression (type), new CCodeConstant ("NULL"));
2889                         cisnull = new CCodeBinaryExpression (CCodeBinaryOperator.OR, cisnull, cunrefisnull);
2890                 }
2891
2892                 ccall.add_argument (cvar);
2893
2894                 /* set freed references to NULL to prevent further use */
2895                 var ccomma = new CCodeCommaExpression ();
2896
2897                 if (context.profile == Profile.GOBJECT) {
2898                         if (type.data_type != null && !type.data_type.is_reference_counting () &&
2899                             (type.data_type == gstringbuilder_type
2900                              || type.data_type == garray_type
2901                              || type.data_type == gbytearray_type
2902                              || type.data_type == gptrarray_type)) {
2903                                 ccall.add_argument (new CCodeConstant ("TRUE"));
2904                         } else if (type.data_type == gthreadpool_type) {
2905                                 ccall.add_argument (new CCodeConstant ("FALSE"));
2906                                 ccall.add_argument (new CCodeConstant ("TRUE"));
2907                         } else if (type is ArrayType) {
2908                                 var array_type = (ArrayType) type;
2909                                 if (requires_destroy (array_type.element_type)) {
2910                                         CCodeExpression csizeexpr = null;
2911                                         if (variable.array_null_terminated) {
2912                                                 var len_call = new CCodeFunctionCall (new CCodeIdentifier ("_vala_array_length"));
2913                                                 len_call.add_argument (cvar);
2914                                                 csizeexpr = len_call;
2915                                         } else if (variable.has_array_length_cexpr) {
2916                                                 csizeexpr = new CCodeConstant (variable.get_array_length_cexpr ());
2917                                         } else if (!variable.no_array_length) {
2918                                                 bool first = true;
2919                                                 for (int dim = 1; dim <= array_type.rank; dim++) {
2920                                                         if (first) {
2921                                                                 csizeexpr = get_array_length_cvalue (target_lvalue, dim);
2922                                                                 first = false;
2923                                                         } else {
2924                                                                 csizeexpr = new CCodeBinaryExpression (CCodeBinaryOperator.MUL, csizeexpr, get_array_length_cvalue (target_lvalue, dim));
2925                                                         }
2926                                                 }
2927                                         }
2928
2929                                         if (csizeexpr != null) {
2930                                                 var st = array_type.element_type.data_type as Struct;
2931                                                 if (st != null && !array_type.element_type.nullable) {
2932                                                         ccall.call = new CCodeIdentifier (append_struct_array_free (st));
2933                                                         ccall.add_argument (csizeexpr);
2934                                                 } else {
2935                                                         requires_array_free = true;
2936                                                         ccall.call = new CCodeIdentifier ("_vala_array_free");
2937                                                         ccall.add_argument (csizeexpr);
2938                                                         ccall.add_argument (new CCodeCastExpression (get_destroy_func_expression (array_type.element_type), "GDestroyNotify"));
2939                                                 }
2940                                         }
2941                                 }
2942                         }
2943                 }
2944
2945                 ccomma.append_expression (ccall);
2946                 ccomma.append_expression (new CCodeConstant ("NULL"));
2947
2948                 var cassign = new CCodeAssignment (cvar, ccomma);
2949
2950                 // g_free (NULL) is allowed
2951                 bool uses_gfree = (type.data_type != null && !type.data_type.is_reference_counting () && type.data_type.get_free_function () == "g_free");
2952                 uses_gfree = uses_gfree || type is ArrayType;
2953                 if (uses_gfree) {
2954                         return cassign;
2955                 }
2956
2957                 return new CCodeConditionalExpression (cisnull, new CCodeConstant ("NULL"), cassign);
2958         }
2959
2960         public CCodeExpression destroy_local (LocalVariable local) {
2961                 return destroy_variable (local, get_local_cvalue (local));
2962         }
2963
2964         public CCodeExpression destroy_parameter (Parameter param) {
2965                 return destroy_variable (param, get_parameter_cvalue (param));
2966         }
2967
2968         public CCodeExpression destroy_field (Field field, TargetValue? instance) {
2969                 return destroy_variable (field, get_field_cvalue (field, instance));
2970         }
2971
2972         public CCodeExpression get_unref_expression (CCodeExpression cvar, DataType type, Expression? expr, bool is_macro_definition = false) {
2973                 if (expr != null) {
2974                         if (expr.symbol_reference is LocalVariable) {
2975                                 return destroy_local ((LocalVariable) expr.symbol_reference);
2976                         } else if (expr.symbol_reference is Parameter) {
2977                                 return destroy_parameter ((Parameter) expr.symbol_reference);
2978                         }
2979                 }
2980                 var value = new GLibValue (type, cvar);
2981                 if (expr != null && expr.target_value != null) {
2982                         value.array_length_cvalues = ((GLibValue) expr.target_value).array_length_cvalues;
2983                         value.delegate_target_cvalue = get_delegate_target_cvalue (expr.target_value);
2984                         value.delegate_target_destroy_notify_cvalue = get_delegate_target_destroy_notify_cvalue (expr.target_value);
2985                 }
2986                 return destroy_value (value, is_macro_definition);
2987         }
2988
2989         // logic in this method is temporarily duplicated in destroy_variable
2990         // apply changes to both methods
2991         public virtual CCodeExpression destroy_value (TargetValue value, bool is_macro_definition = false) {
2992                 var type = value.value_type;
2993                 var cvar = get_cvalue_ (value);
2994
2995                 if (type is DelegateType) {
2996                         var delegate_target = get_delegate_target_cvalue (value);
2997                         var delegate_target_destroy_notify = get_delegate_target_destroy_notify_cvalue (value);
2998
2999                         var ccall = new CCodeFunctionCall (delegate_target_destroy_notify);
3000                         ccall.add_argument (delegate_target);
3001
3002                         var destroy_call = new CCodeCommaExpression ();
3003                         destroy_call.append_expression (ccall);
3004                         destroy_call.append_expression (new CCodeConstant ("NULL"));
3005
3006                         var cisnull = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, delegate_target_destroy_notify, new CCodeConstant ("NULL"));
3007
3008                         var ccomma = new CCodeCommaExpression ();
3009                         ccomma.append_expression (new CCodeConditionalExpression (cisnull, new CCodeConstant ("NULL"), destroy_call));
3010                         ccomma.append_expression (new CCodeAssignment (cvar, new CCodeConstant ("NULL")));
3011                         ccomma.append_expression (new CCodeAssignment (delegate_target, new CCodeConstant ("NULL")));
3012                         ccomma.append_expression (new CCodeAssignment (delegate_target_destroy_notify, new CCodeConstant ("NULL")));
3013
3014                         return ccomma;
3015                 }
3016
3017                 var ccall = new CCodeFunctionCall (get_destroy_func_expression (type));
3018
3019                 if (type is ValueType && !type.nullable) {
3020                         // normal value type, no null check
3021                         var st = type.data_type as Struct;
3022                         if (st != null && st.is_simple_type ()) {
3023                                 // used for va_list
3024                                 ccall.add_argument (cvar);
3025                         } else {
3026                                 ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, cvar));
3027                         }
3028
3029                         if (gvalue_type != null && type.data_type == gvalue_type) {
3030                                 // g_value_unset must not be called for already unset values
3031                                 var cisvalid = new CCodeFunctionCall (new CCodeIdentifier ("G_IS_VALUE"));
3032                                 cisvalid.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, cvar));
3033
3034                                 var ccomma = new CCodeCommaExpression ();
3035                                 ccomma.append_expression (ccall);
3036                                 ccomma.append_expression (new CCodeConstant ("NULL"));
3037
3038                                 return new CCodeConditionalExpression (cisvalid, ccomma, new CCodeConstant ("NULL"));
3039                         } else {
3040                                 return ccall;
3041                         }
3042                 }
3043
3044                 if (ccall.call is CCodeIdentifier && !(type is ArrayType) && !is_macro_definition) {
3045                         // generate and use NULL-aware free macro to simplify code
3046
3047                         var freeid = (CCodeIdentifier) ccall.call;
3048                         string free0_func = "_%s0".printf (freeid.name);
3049
3050                         if (add_wrapper (free0_func)) {
3051                                 var macro = destroy_value (new GLibValue (type, new CCodeIdentifier ("var")), true);
3052                                 cfile.add_type_declaration (new CCodeMacroReplacement.with_expression ("%s(var)".printf (free0_func), macro));
3053                         }
3054
3055                         ccall = new CCodeFunctionCall (new CCodeIdentifier (free0_func));
3056                         ccall.add_argument (cvar);
3057                         return ccall;
3058                 }
3059
3060                 /* (foo == NULL ? NULL : foo = (unref (foo), NULL)) */
3061
3062                 /* can be simplified to
3063                  * foo = (unref (foo), NULL)
3064                  * if foo is of static type non-null
3065                  */
3066
3067                 var cisnull = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, cvar, new CCodeConstant ("NULL"));
3068                 if (type.type_parameter != null) {
3069                         if (!(current_type_symbol is Class) || current_class.is_compact) {
3070                                 return new CCodeConstant ("NULL");
3071                         }
3072
3073                         // unref functions are optional for type parameters
3074                         var cunrefisnull = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, get_destroy_func_expression (type), new CCodeConstant ("NULL"));
3075                         cisnull = new CCodeBinaryExpression (CCodeBinaryOperator.OR, cisnull, cunrefisnull);
3076                 }
3077
3078                 ccall.add_argument (cvar);
3079
3080                 /* set freed references to NULL to prevent further use */
3081                 var ccomma = new CCodeCommaExpression ();
3082
3083                 if (context.profile == Profile.GOBJECT) {
3084                         if (type.data_type != null && !type.data_type.is_reference_counting () &&
3085                             (type.data_type == gstringbuilder_type
3086                              || type.data_type == garray_type
3087                              || type.data_type == gbytearray_type
3088                              || type.data_type == gptrarray_type)) {
3089                                 ccall.add_argument (new CCodeConstant ("TRUE"));
3090                         } else if (type.data_type == gthreadpool_type) {
3091                                 ccall.add_argument (new CCodeConstant ("FALSE"));
3092                                 ccall.add_argument (new CCodeConstant ("TRUE"));
3093                         } else if (type is ArrayType) {
3094                                 var array_type = (ArrayType) type;
3095                                 if (requires_destroy (array_type.element_type)) {
3096                                         CCodeExpression csizeexpr = null;
3097                                         bool first = true;
3098                                         for (int dim = 1; dim <= array_type.rank; dim++) {
3099                                                 if (first) {
3100                                                         csizeexpr = get_array_length_cvalue (value, dim);
3101                                                         first = false;
3102                                                 } else {
3103                                                         csizeexpr = new CCodeBinaryExpression (CCodeBinaryOperator.MUL, csizeexpr, get_array_length_cvalue (value, dim));
3104                                                 }
3105                                         }
3106
3107                                         var st = array_type.element_type.data_type as Struct;
3108                                         if (st != null && !array_type.element_type.nullable) {
3109                                                 ccall.call = new CCodeIdentifier (append_struct_array_free (st));
3110                                                 ccall.add_argument (csizeexpr);
3111                                         } else {
3112                                                 requires_array_free = true;
3113                                                 ccall.call = new CCodeIdentifier ("_vala_array_free");
3114                                                 ccall.add_argument (csizeexpr);
3115                                                 ccall.add_argument (new CCodeCastExpression (get_destroy_func_expression (array_type.element_type), "GDestroyNotify"));
3116                                         }
3117                                 }
3118                         }
3119                 }
3120
3121                 ccomma.append_expression (ccall);
3122                 ccomma.append_expression (new CCodeConstant ("NULL"));
3123
3124                 var cassign = new CCodeAssignment (cvar, ccomma);
3125
3126                 // g_free (NULL) is allowed
3127                 bool uses_gfree = (type.data_type != null && !type.data_type.is_reference_counting () && type.data_type.get_free_function () == "g_free");
3128                 uses_gfree = uses_gfree || type is ArrayType;
3129                 if (uses_gfree) {
3130                         return cassign;
3131                 }
3132
3133                 return new CCodeConditionalExpression (cisnull, new CCodeConstant ("NULL"), cassign);
3134         }
3135
3136         public override void visit_end_full_expression (Expression expr) {
3137                 /* expr is a full expression, i.e. an initializer, the
3138                  * expression in an expression statement, the controlling
3139                  * expression in if, while, for, or foreach statements
3140                  *
3141                  * we unref temporary variables at the end of a full
3142                  * expression
3143                  */
3144                 if (temp_ref_vars.size == 0) {
3145                         /* nothing to do without temporary variables */
3146                         return;
3147                 }
3148
3149                 LocalVariable full_expr_var = null;
3150
3151                 var local_decl = expr.parent_node as LocalVariable;
3152                 if (!(local_decl != null && has_simple_struct_initializer (local_decl))) {
3153                         var expr_type = expr.value_type;
3154                         if (expr.target_type != null) {
3155                                 expr_type = expr.target_type;
3156                         }
3157
3158                         full_expr_var = get_temp_variable (expr_type, true, expr, false);
3159                         emit_temp_var (full_expr_var);
3160
3161                         ccode.add_assignment (get_variable_cexpression (full_expr_var.name), get_cvalue (expr));
3162                 }
3163
3164                 foreach (LocalVariable local in temp_ref_vars) {
3165                         ccode.add_expression (destroy_local (local));
3166                 }
3167
3168                 if (full_expr_var != null) {
3169                         set_cvalue (expr, get_variable_cexpression (full_expr_var.name));
3170                 }
3171
3172                 temp_ref_vars.clear ();
3173         }
3174
3175         public void emit_temp_var (LocalVariable local, bool always_init = false) {
3176                 var vardecl = new CCodeVariableDeclarator (local.name, null, local.variable_type.get_cdeclarator_suffix ());
3177
3178                 var st = local.variable_type.data_type as Struct;
3179                 var array_type = local.variable_type as ArrayType;
3180
3181                 if (local.name.has_prefix ("*")) {
3182                         // do not dereference unintialized variable
3183                         // initialization is not needed for these special
3184                         // pointer temp variables
3185                         // used to avoid side-effects in assignments
3186                 } else if (local.no_init) {
3187                         // no initialization necessary for this temp var
3188                 } else if (!local.variable_type.nullable &&
3189                            (st != null && !st.is_simple_type ()) ||
3190                            (array_type != null && array_type.fixed_length)) {
3191                         // 0-initialize struct with struct initializer { 0 }
3192                         // necessary as they will be passed by reference
3193                         var clist = new CCodeInitializerList ();
3194                         clist.append (new CCodeConstant ("0"));
3195
3196                         vardecl.initializer = clist;
3197                         vardecl.init0 = true;
3198                 } else if (local.variable_type.is_reference_type_or_type_parameter () ||
3199                            local.variable_type.nullable ||
3200                            local.variable_type is DelegateType) {
3201                         vardecl.initializer = new CCodeConstant ("NULL");
3202                         vardecl.init0 = true;
3203                 } else if (always_init) {
3204                         vardecl.initializer = default_value_for_type (local.variable_type, true);
3205                         vardecl.init0 = true;
3206                 }
3207
3208                 if (is_in_coroutine ()) {
3209                         closure_struct.add_field (local.variable_type.get_cname (), local.name);
3210
3211                         // even though closure struct is zerod, we need to initialize temporary variables
3212                         // as they might be used multiple times when declared in a loop
3213
3214                         if (vardecl.initializer  is CCodeInitializerList) {
3215                                 // C does not support initializer lists in assignments, use memset instead
3216                                 cfile.add_include ("string.h");
3217                                 var memset_call = new CCodeFunctionCall (new CCodeIdentifier ("memset"));
3218                                 memset_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_variable_cexpression (local.name)));
3219                                 memset_call.add_argument (new CCodeConstant ("0"));
3220                                 memset_call.add_argument (new CCodeIdentifier ("sizeof (%s)".printf (local.variable_type.get_cname ())));
3221                                 ccode.add_expression (memset_call);
3222                         } else if (vardecl.initializer != null) {
3223                                 ccode.add_assignment (get_variable_cexpression (local.name), vardecl.initializer);
3224                         }
3225                 } else {
3226                         ccode.add_declaration (local.variable_type.get_cname (), vardecl);
3227                 }
3228         }
3229
3230         public override void visit_expression_statement (ExpressionStatement stmt) {
3231                 if (stmt.expression.error) {
3232                         stmt.error = true;
3233                         return;
3234                 }
3235
3236                 /* free temporary objects and handle errors */
3237
3238                 foreach (LocalVariable local in temp_ref_vars) {
3239                         ccode.add_expression (destroy_local (local));
3240                 }
3241
3242                 if (stmt.tree_can_fail && stmt.expression.tree_can_fail) {
3243                         // simple case, no node breakdown necessary
3244                         add_simple_check (stmt.expression);
3245                 }
3246
3247                 temp_ref_vars.clear ();
3248         }
3249
3250         public virtual void append_local_free (Symbol sym, bool stop_at_loop = false, CodeNode? stop_at = null) {
3251                 var b = (Block) sym;
3252
3253                 var local_vars = b.get_local_variables ();
3254                 // free in reverse order
3255                 for (int i = local_vars.size - 1; i >= 0; i--) {
3256                         var local = local_vars[i];
3257                         if (!local.unreachable && local.active && !local.floating && !local.captured && requires_destroy (local.variable_type)) {
3258                                 ccode.add_expression (destroy_local (local));
3259                         }
3260                 }
3261
3262                 if (b.captured) {
3263                         int block_id = get_block_id (b);
3264
3265                         var data_unref = new CCodeFunctionCall (new CCodeIdentifier ("block%d_data_unref".printf (block_id)));
3266                         data_unref.add_argument (get_variable_cexpression ("_data%d_".printf (block_id)));
3267                         ccode.add_expression (data_unref);
3268                         ccode.add_assignment (get_variable_cexpression ("_data%d_".printf (block_id)), new CCodeConstant ("NULL"));
3269                 }
3270
3271                 if (stop_at_loop) {
3272                         if (b.parent_node is Loop ||
3273                             b.parent_node is ForeachStatement ||
3274                             b.parent_node is SwitchStatement) {
3275                                 return;
3276                         }
3277                 }
3278
3279                 if (stop_at != null && b.parent_node == stop_at) {
3280                         return;
3281                 }
3282
3283                 if (sym.parent_symbol is Block) {
3284                         append_local_free (sym.parent_symbol, stop_at_loop, stop_at);
3285                 } else if (sym.parent_symbol is Method) {
3286                         append_param_free ((Method) sym.parent_symbol);
3287                 }
3288         }
3289
3290         private void append_param_free (Method m) {
3291                 foreach (Parameter param in m.get_parameters ()) {
3292                         if (!param.ellipsis && requires_destroy (param.variable_type) && param.direction == ParameterDirection.IN) {
3293                                 ccode.add_expression (destroy_parameter (param));
3294                         }
3295                 }
3296         }
3297
3298         public bool variable_accessible_in_finally (LocalVariable local) {
3299                 if (current_try == null) {
3300                         return false;
3301                 }
3302
3303                 var sym = current_symbol;
3304
3305                 while (!(sym is Method || sym is PropertyAccessor) && sym.scope.lookup (local.name) == null) {
3306                         if ((sym.parent_node is TryStatement && ((TryStatement) sym.parent_node).finally_body != null) ||
3307                                 (sym.parent_node is CatchClause && ((TryStatement) sym.parent_node.parent_node).finally_body != null)) {
3308
3309                                 return true;
3310                         }
3311
3312                         sym = sym.parent_symbol;
3313                 }
3314
3315                 return false;
3316         }
3317
3318         void return_out_parameter (Parameter param) {
3319                 var delegate_type = param.variable_type as DelegateType;
3320
3321                 ccode.open_if (get_variable_cexpression (param.name));
3322                 ccode.add_assignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, get_variable_cexpression (param.name)), get_variable_cexpression ("_" + param.name));
3323
3324                 if (delegate_type != null && delegate_type.delegate_symbol.has_target) {
3325                         ccode.add_assignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, get_variable_cexpression (get_delegate_target_cname (param.name))), new CCodeIdentifier (get_delegate_target_cname (get_variable_cname ("_" + param.name))));
3326                         if (delegate_type.value_owned) {
3327                                 ccode.add_assignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, get_variable_cexpression (get_delegate_target_destroy_notify_cname (param.name))), new CCodeIdentifier (get_delegate_target_destroy_notify_cname (get_variable_cname ("_" + param.name))));
3328                         }
3329                 }
3330
3331                 if (param.variable_type.is_disposable ()){
3332                         ccode.add_else ();
3333                         ccode.add_expression (destroy_parameter (param));
3334                 }
3335                 ccode.close ();
3336
3337                 var array_type = param.variable_type as ArrayType;
3338                 if (array_type != null && !array_type.fixed_length && !param.no_array_length) {
3339                         for (int dim = 1; dim <= array_type.rank; dim++) {
3340                                 ccode.open_if (get_variable_cexpression (get_parameter_array_length_cname (param, dim)));
3341                                 ccode.add_assignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, get_variable_cexpression (get_parameter_array_length_cname (param, dim))), new CCodeIdentifier (get_array_length_cname (get_variable_cname ("_" + param.name), dim)));
3342                                 ccode.close ();
3343                         }
3344                 }
3345         }
3346
3347         public override void visit_return_statement (ReturnStatement stmt) {
3348                 Symbol return_expression_symbol = null;
3349
3350                 if (stmt.return_expression != null) {
3351                         // avoid unnecessary ref/unref pair
3352                         var local = stmt.return_expression.symbol_reference as LocalVariable;
3353                         if (current_return_type.value_owned
3354                             && local != null && local.variable_type.value_owned
3355                             && !local.captured
3356                             && !variable_accessible_in_finally (local)) {
3357                                 /* return expression is local variable taking ownership and
3358                                  * current method is transferring ownership */
3359
3360                                 return_expression_symbol = local;
3361                         }
3362                 }
3363
3364                 // return array length if appropriate
3365                 if (((current_method != null && !current_method.no_array_length) || current_property_accessor != null) && current_return_type is ArrayType) {
3366                         var return_expr_decl = get_temp_variable (stmt.return_expression.value_type, true, stmt, false);
3367
3368                         ccode.add_assignment (get_variable_cexpression (return_expr_decl.name), get_cvalue (stmt.return_expression));
3369
3370                         var array_type = (ArrayType) current_return_type;
3371
3372                         for (int dim = 1; dim <= array_type.rank; dim++) {
3373                                 var len_l = get_result_cexpression (get_array_length_cname ("result", dim));
3374                                 if (!is_in_coroutine ()) {
3375                                         len_l = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, len_l);
3376                                 }
3377                                 var len_r = get_array_length_cexpression (stmt.return_expression, dim);
3378                                 ccode.add_assignment (len_l, len_r);
3379                         }
3380
3381                         set_cvalue (stmt.return_expression, get_variable_cexpression (return_expr_decl.name));
3382
3383                         emit_temp_var (return_expr_decl);
3384                 } else if ((current_method != null || current_property_accessor != null) && current_return_type is DelegateType) {
3385                         var delegate_type = (DelegateType) current_return_type;
3386                         if (delegate_type.delegate_symbol.has_target) {
3387                                 var return_expr_decl = get_temp_variable (stmt.return_expression.value_type, true, stmt, false);
3388
3389                                 ccode.add_assignment (get_variable_cexpression (return_expr_decl.name), get_cvalue (stmt.return_expression));
3390
3391                                 var target_l = get_result_cexpression (get_delegate_target_cname ("result"));
3392                                 if (!is_in_coroutine ()) {
3393                                         target_l = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, target_l);
3394                                 }
3395                                 CCodeExpression target_r_destroy_notify;
3396                                 var target_r = get_delegate_target_cexpression (stmt.return_expression, out target_r_destroy_notify);
3397                                 ccode.add_assignment (target_l, target_r);
3398                                 if (delegate_type.value_owned) {
3399                                         var target_l_destroy_notify = get_result_cexpression (get_delegate_target_destroy_notify_cname ("result"));
3400                                         if (!is_in_coroutine ()) {
3401                                                 target_l_destroy_notify = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, target_l_destroy_notify);
3402                                         }
3403                                         ccode.add_assignment (target_l_destroy_notify, target_r_destroy_notify);
3404                                 }
3405
3406                                 set_cvalue (stmt.return_expression, get_variable_cexpression (return_expr_decl.name));
3407
3408                                 emit_temp_var (return_expr_decl);
3409                         }
3410                 }
3411
3412                 if (stmt.return_expression != null) {
3413                         // assign method result to `result'
3414                         CCodeExpression result_lhs = get_result_cexpression ();
3415                         if (current_return_type.is_real_non_null_struct_type () && !is_in_coroutine ()) {
3416                                 result_lhs = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, result_lhs);
3417                         }
3418                         ccode.add_assignment (result_lhs, get_cvalue (stmt.return_expression));
3419                 }
3420
3421                 // free local variables
3422                 append_local_free (current_symbol);
3423
3424                 if (current_method != null) {
3425                         // check postconditions
3426                         foreach (Expression postcondition in current_method.get_postconditions ()) {
3427                                 create_postcondition_statement (postcondition);
3428                         }
3429                 }
3430
3431                 if (current_method != null && !current_method.coroutine) {
3432                         // assign values to output parameters if they are not NULL
3433                         // otherwise, free the value if necessary
3434                         foreach (var param in current_method.get_parameters ()) {
3435                                 if (param.direction != ParameterDirection.OUT) {
3436                                         continue;
3437                                 }
3438
3439                                 return_out_parameter (param);
3440                         }
3441                 }
3442
3443                 if (is_in_constructor ()) {
3444                         ccode.add_return (new CCodeIdentifier ("obj"));
3445                 } else if (is_in_destructor ()) {
3446                         // do not call return as member cleanup and chain up to base finalizer
3447                         // stil need to be executed
3448                         ccode.add_goto ("_return");
3449                 } else if (current_method is CreationMethod) {
3450                         ccode.add_return (new CCodeIdentifier ("self"));
3451                 } else if (is_in_coroutine ()) {
3452                 } else if (current_return_type is VoidType || current_return_type.is_real_non_null_struct_type ()) {
3453                         // structs are returned via out parameter
3454                         ccode.add_return ();
3455                 } else {
3456                         ccode.add_return (new CCodeIdentifier ("result"));
3457                 }
3458
3459                 if (return_expression_symbol != null) {
3460                         return_expression_symbol.active = true;
3461                 }
3462
3463                 // required for destructors
3464                 current_method_return = true;
3465         }
3466
3467         public string get_symbol_lock_name (string symname) {
3468                 return "__lock_%s".printf (symname);
3469         }
3470
3471         private CCodeExpression get_lock_expression (Statement stmt, Expression resource) {
3472                 CCodeExpression l = null;
3473                 var inner_node = ((MemberAccess)resource).inner;
3474                 var member = resource.symbol_reference;
3475                 var parent = (TypeSymbol)resource.symbol_reference.parent_symbol;
3476
3477                 if (member.is_instance_member ()) {
3478                         if (inner_node  == null) {
3479                                 l = new CCodeIdentifier ("self");
3480                         } else if (resource.symbol_reference.parent_symbol != current_type_symbol) {
3481                                 l = generate_instance_cast (get_cvalue (inner_node), parent);
3482                         } else {
3483                                 l = get_cvalue (inner_node);
3484                         }
3485
3486                         l = new CCodeMemberAccess.pointer (new CCodeMemberAccess.pointer (l, "priv"), get_symbol_lock_name (resource.symbol_reference.name));
3487                 } else if (member.is_class_member ()) {
3488                         CCodeExpression klass;
3489
3490                         if (current_method != null && current_method.binding == MemberBinding.INSTANCE ||
3491                             current_property_accessor != null && current_property_accessor.prop.binding == MemberBinding.INSTANCE ||
3492                             (in_constructor && !in_static_or_class_context)) {
3493                                 var k = new CCodeFunctionCall (new CCodeIdentifier ("G_OBJECT_GET_CLASS"));
3494                                 k.add_argument (new CCodeIdentifier ("self"));
3495                                 klass = k;
3496                         } else {
3497                                 klass = new CCodeIdentifier ("klass");
3498                         }
3499
3500                         var get_class_private_call = new CCodeFunctionCall (new CCodeIdentifier ("%s_GET_CLASS_PRIVATE".printf(parent.get_upper_case_cname ())));
3501                         get_class_private_call.add_argument (klass);
3502                         l = new CCodeMemberAccess.pointer (get_class_private_call, get_symbol_lock_name (resource.symbol_reference.name));
3503                 } else {
3504                         string lock_name = "%s_%s".printf(parent.get_lower_case_cname (), resource.symbol_reference.name);
3505                         l = new CCodeIdentifier (get_symbol_lock_name (lock_name));
3506                 }
3507                 return l;
3508         }
3509
3510         public override void visit_lock_statement (LockStatement stmt) {
3511                 var l = get_lock_expression (stmt, stmt.resource);
3512
3513                 var fc = new CCodeFunctionCall (new CCodeIdentifier (((Method) mutex_type.scope.lookup ("lock")).get_cname ()));
3514                 fc.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, l));
3515
3516                 ccode.add_expression (fc);
3517         }
3518
3519         public override void visit_unlock_statement (UnlockStatement stmt) {
3520                 var l = get_lock_expression (stmt, stmt.resource);
3521
3522                 var fc = new CCodeFunctionCall (new CCodeIdentifier (((Method) mutex_type.scope.lookup ("unlock")).get_cname ()));
3523                 fc.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, l));
3524
3525                 ccode.add_expression (fc);
3526         }
3527
3528         public override void visit_delete_statement (DeleteStatement stmt) {
3529                 var pointer_type = (PointerType) stmt.expression.value_type;
3530                 DataType type = pointer_type;
3531                 if (pointer_type.base_type.data_type != null && pointer_type.base_type.data_type.is_reference_type ()) {
3532                         type = pointer_type.base_type;
3533                 }
3534
3535                 var ccall = new CCodeFunctionCall (get_destroy_func_expression (type));
3536                 ccall.add_argument (get_cvalue (stmt.expression));
3537                 ccode.add_expression (ccall);
3538         }
3539
3540         public override void visit_expression (Expression expr) {
3541                 if (get_cvalue (expr) != null && !expr.lvalue) {
3542                         if (expr.formal_value_type is GenericType && !(expr.value_type is GenericType)) {
3543                                 var st = expr.formal_value_type.type_parameter.parent_symbol.parent_symbol as Struct;
3544                                 if (expr.formal_value_type.type_parameter.parent_symbol != garray_type &&
3545                                     (st == null || st.get_cname () != "va_list")) {
3546                                         // GArray and va_list don't use pointer-based generics
3547                                         set_cvalue (expr, convert_from_generic_pointer (get_cvalue (expr), expr.value_type));
3548                                 }
3549                         }
3550
3551                         // memory management, implicit casts, and boxing/unboxing
3552                         set_cvalue (expr, transform_expression (get_cvalue (expr), expr.value_type, expr.target_type, expr));
3553
3554                         if (expr.formal_target_type is GenericType && !(expr.target_type is GenericType)) {
3555                                 if (expr.formal_target_type.type_parameter.parent_symbol != garray_type) {
3556                                         // GArray doesn't use pointer-based generics
3557                                         set_cvalue (expr, convert_to_generic_pointer (get_cvalue (expr), expr.target_type));
3558                                 }
3559                         }
3560                 }
3561         }
3562
3563         public override void visit_boolean_literal (BooleanLiteral expr) {
3564                 if (context.profile == Profile.GOBJECT) {
3565                         set_cvalue (expr, new CCodeConstant (expr.value ? "TRUE" : "FALSE"));
3566                 } else {
3567                         cfile.add_include ("stdbool.h");
3568                         set_cvalue (expr, new CCodeConstant (expr.value ? "true" : "false"));
3569                 }
3570         }
3571
3572         public override void visit_character_literal (CharacterLiteral expr) {
3573                 if (expr.get_char () >= 0x20 && expr.get_char () < 0x80) {
3574                         set_cvalue (expr, new CCodeConstant (expr.value));
3575                 } else {
3576                         set_cvalue (expr, new CCodeConstant ("%uU".printf (expr.get_char ())));
3577                 }
3578         }
3579
3580         public override void visit_integer_literal (IntegerLiteral expr) {
3581                 set_cvalue (expr, new CCodeConstant (expr.value + expr.type_suffix));
3582         }
3583
3584         public override void visit_real_literal (RealLiteral expr) {
3585                 string c_literal = expr.value;
3586                 if (c_literal.has_suffix ("d") || c_literal.has_suffix ("D")) {
3587                         // there is no suffix for double in C
3588                         c_literal = c_literal.substring (0, c_literal.length - 1);
3589                 }
3590                 if (!("." in c_literal || "e" in c_literal || "E" in c_literal)) {
3591                         // C requires period or exponent part for floating constants
3592                         if ("f" in c_literal || "F" in c_literal) {
3593                                 c_literal = c_literal.substring (0, c_literal.length - 1) + ".f";
3594                         } else {
3595                                 c_literal += ".";
3596                         }
3597                 }
3598                 set_cvalue (expr, new CCodeConstant (c_literal));
3599         }
3600
3601         public override void visit_string_literal (StringLiteral expr) {
3602                 set_cvalue (expr, new CCodeConstant.string (expr.value.replace ("\n", "\\n")));
3603
3604                 if (expr.translate) {
3605                         // translated string constant
3606
3607                         var m = (Method) root_symbol.scope.lookup ("GLib").scope.lookup ("_");
3608                         add_symbol_declaration (cfile, m, m.get_cname ());
3609
3610                         var translate = new CCodeFunctionCall (new CCodeIdentifier ("_"));
3611                         translate.add_argument (get_cvalue (expr));
3612                         set_cvalue (expr, translate);
3613                 }
3614         }
3615
3616         public override void visit_regex_literal (RegexLiteral expr) {
3617                 string[] parts = expr.value.split ("/", 3);
3618                 string re = parts[2].escape ("");
3619                 string flags = "0";
3620
3621                 if (parts[1].contains ("i")) {
3622                         flags += " | G_REGEX_CASELESS";
3623                 }
3624                 if (parts[1].contains ("m")) {
3625                         flags += " | G_REGEX_MULTILINE";
3626                 }
3627                 if (parts[1].contains ("s")) {
3628                         flags += " | G_REGEX_DOTALL";
3629                 }
3630                 if (parts[1].contains ("x")) {
3631                         flags += " | G_REGEX_EXTENDED";
3632                 }
3633
3634                 var regex_var = get_temp_variable (regex_type, true, expr, false);
3635                 emit_temp_var (regex_var);
3636
3637                 var cdecl = new CCodeDeclaration ("GRegex*");
3638
3639                 var cname = regex_var.name + "regex_" + next_regex_id.to_string ();
3640                 if (this.next_regex_id == 0) {
3641                         var fun = new CCodeFunction ("_thread_safe_regex_init", "GRegex*");
3642                         fun.modifiers = CCodeModifiers.STATIC | CCodeModifiers.INLINE;
3643                         fun.add_parameter (new CCodeParameter ("re", "GRegex**"));
3644                         fun.add_parameter (new CCodeParameter ("pattern", "const gchar *"));
3645                         fun.add_parameter (new CCodeParameter ("match_options", "GRegexMatchFlags"));
3646
3647                         push_function (fun);
3648
3649                         var once_enter_call = new CCodeFunctionCall (new CCodeIdentifier ("g_once_init_enter"));
3650                         once_enter_call.add_argument (new CCodeConstant ("(volatile gsize*) re"));
3651                         ccode.open_if (once_enter_call);
3652
3653                         var regex_new_call = new CCodeFunctionCall (new CCodeIdentifier ("g_regex_new"));
3654                         regex_new_call.add_argument (new CCodeConstant ("pattern"));
3655                         regex_new_call.add_argument (new CCodeConstant ("match_options"));
3656                         regex_new_call.add_argument (new CCodeConstant ("0"));
3657                         regex_new_call.add_argument (new CCodeConstant ("NULL"));
3658                         ccode.add_assignment (new CCodeIdentifier ("GRegex* val"), regex_new_call);
3659
3660                         var once_leave_call = new CCodeFunctionCall (new CCodeIdentifier ("g_once_init_leave"));
3661                         once_leave_call.add_argument (new CCodeConstant ("(volatile gsize*) re"));
3662                         once_leave_call.add_argument (new CCodeConstant ("(gsize) val"));
3663                         ccode.add_expression (once_leave_call);
3664
3665                         ccode.close ();
3666
3667                         ccode.add_return (new CCodeIdentifier ("*re"));
3668
3669                         pop_function ();
3670
3671                         cfile.add_function (fun);
3672                 }
3673                 this.next_regex_id++;
3674
3675                 cdecl.add_declarator (new CCodeVariableDeclarator (cname + " = NULL"));
3676                 cdecl.modifiers = CCodeModifiers.STATIC;
3677
3678                 var regex_const = new CCodeConstant ("_thread_safe_regex_init (&%s, \"%s\", %s)".printf (cname, re, flags));
3679
3680                 cfile.add_constant_declaration (cdecl);
3681                 set_cvalue (expr, regex_const);
3682         }
3683
3684         public override void visit_null_literal (NullLiteral expr) {
3685                 if (context.profile != Profile.GOBJECT) {
3686                         cfile.add_include ("stddef.h");
3687                 }
3688                 set_cvalue (expr, new CCodeConstant ("NULL"));
3689
3690                 var array_type = expr.target_type as ArrayType;
3691                 var delegate_type = expr.target_type as DelegateType;
3692                 if (array_type != null) {
3693                         for (int dim = 1; dim <= array_type.rank; dim++) {
3694                                 append_array_length (expr, new CCodeConstant ("0"));
3695                         }
3696                 } else if (delegate_type != null && delegate_type.delegate_symbol.has_target) {
3697                         set_delegate_target (expr, new CCodeConstant ("NULL"));
3698                         set_delegate_target_destroy_notify (expr, new CCodeConstant ("NULL"));
3699                 }
3700         }
3701
3702         public abstract TargetValue get_local_cvalue (LocalVariable local);
3703
3704         public abstract TargetValue get_parameter_cvalue (Parameter param);
3705
3706         public abstract TargetValue get_field_cvalue (Field field, TargetValue? instance);
3707
3708         public abstract TargetValue load_this_parameter (TypeSymbol sym);
3709
3710         public virtual string get_delegate_target_cname (string delegate_cname) {
3711                 assert_not_reached ();
3712         }
3713
3714         public virtual CCodeExpression get_delegate_target_cexpression (Expression delegate_expr, out CCodeExpression delegate_target_destroy_notify) {
3715                 assert_not_reached ();
3716         }
3717
3718         public virtual CCodeExpression get_delegate_target_cvalue (TargetValue value) {
3719                 return new CCodeInvalidExpression ();
3720         }
3721
3722         public virtual CCodeExpression get_delegate_target_destroy_notify_cvalue (TargetValue value) {
3723                 return new CCodeInvalidExpression ();
3724         }
3725
3726         public virtual string get_delegate_target_destroy_notify_cname (string delegate_cname) {
3727                 assert_not_reached ();
3728         }
3729
3730         public override void visit_base_access (BaseAccess expr) {
3731                 CCodeExpression this_access;
3732                 if (is_in_coroutine ()) {
3733                         // use closure
3734                         this_access = new CCodeMemberAccess.pointer (new CCodeIdentifier ("data"), "self");
3735                 } else {
3736                         this_access = new CCodeIdentifier ("self");
3737                 }
3738
3739                 set_cvalue (expr, generate_instance_cast (this_access, expr.value_type.data_type));
3740         }
3741
3742         public override void visit_postfix_expression (PostfixExpression expr) {
3743                 MemberAccess ma = find_property_access (expr.inner);
3744                 if (ma != null) {
3745                         // property postfix expression
3746                         var prop = (Property) ma.symbol_reference;
3747
3748                         // assign current value to temp variable
3749                         var temp_decl = get_temp_variable (prop.property_type, true, expr, false);
3750                         emit_temp_var (temp_decl);
3751                         ccode.add_assignment (get_variable_cexpression (temp_decl.name), get_cvalue (expr.inner));
3752
3753                         // increment/decrement property
3754                         var op = expr.increment ? CCodeBinaryOperator.PLUS : CCodeBinaryOperator.MINUS;
3755                         var cexpr = new CCodeBinaryExpression (op, get_variable_cexpression (temp_decl.name), new CCodeConstant ("1"));
3756                         store_property (prop, ma.inner, new GLibValue (expr.value_type, cexpr));
3757
3758                         // return previous value
3759                         set_cvalue (expr, get_variable_cexpression (temp_decl.name));
3760                         return;
3761                 }
3762
3763                 if (expr.parent_node is ExpressionStatement) {
3764                         var op = expr.increment ? CCodeUnaryOperator.POSTFIX_INCREMENT : CCodeUnaryOperator.POSTFIX_DECREMENT;
3765
3766                         ccode.add_expression (new CCodeUnaryExpression (op, get_cvalue (expr.inner)));
3767                 } else {
3768                         // assign current value to temp variable
3769                         var temp_decl = get_temp_variable (expr.inner.value_type, true, expr, false);
3770                         emit_temp_var (temp_decl);
3771                         ccode.add_assignment (get_variable_cexpression (temp_decl.name), get_cvalue (expr.inner));
3772
3773                         // increment/decrement variable
3774                         var op = expr.increment ? CCodeBinaryOperator.PLUS : CCodeBinaryOperator.MINUS;
3775                         var cexpr = new CCodeBinaryExpression (op, get_variable_cexpression (temp_decl.name), new CCodeConstant ("1"));
3776                         ccode.add_assignment (get_cvalue (expr.inner), cexpr);
3777
3778                         // return previous value
3779                         set_cvalue (expr, get_variable_cexpression (temp_decl.name));
3780                 }
3781         }
3782
3783         private MemberAccess? find_property_access (Expression expr) {
3784                 if (!(expr is MemberAccess)) {
3785                         return null;
3786                 }
3787
3788                 var ma = (MemberAccess) expr;
3789                 if (ma.symbol_reference is Property) {
3790                         return ma;
3791                 }
3792
3793                 return null;
3794         }
3795
3796         bool is_limited_generic_type (DataType type) {
3797                 var cl = type.type_parameter.parent_symbol as Class;
3798                 var st = type.type_parameter.parent_symbol as Struct;
3799                 if ((cl != null && cl.is_compact) || st != null) {
3800                         // compact classes and structs only
3801                         // have very limited generics support
3802                         return true;
3803                 }
3804                 return false;
3805         }
3806
3807         public bool requires_copy (DataType type) {
3808                 if (!type.is_disposable ()) {
3809                         return false;
3810                 }
3811
3812                 var cl = type.data_type as Class;
3813                 if (cl != null && cl.is_reference_counting ()
3814                     && cl.get_ref_function () == "") {
3815                         // empty ref_function => no ref necessary
3816                         return false;
3817                 }
3818
3819                 if (type.type_parameter != null) {
3820                         if (is_limited_generic_type (type)) {
3821                                 return false;
3822                         }
3823                 }
3824
3825                 return true;
3826         }
3827
3828         public bool requires_destroy (DataType type) {
3829                 if (!type.is_disposable ()) {
3830                         return false;
3831                 }
3832
3833                 var array_type = type as ArrayType;
3834                 if (array_type != null && array_type.fixed_length) {
3835                         return requires_destroy (array_type.element_type);
3836                 }
3837
3838                 var cl = type.data_type as Class;
3839                 if (cl != null && cl.is_reference_counting ()
3840                     && cl.get_unref_function () == "") {
3841                         // empty unref_function => no unref necessary
3842                         return false;
3843                 }
3844
3845                 if (type.type_parameter != null) {
3846                         if (is_limited_generic_type (type)) {
3847                                 return false;
3848                         }
3849                 }
3850
3851                 return true;
3852         }
3853
3854         bool is_ref_function_void (DataType type) {
3855                 var cl = type.data_type as Class;
3856                 if (cl != null && cl.ref_function_void) {
3857                         return true;
3858                 } else {
3859                         return false;
3860                 }
3861         }
3862
3863         public virtual CCodeExpression? get_ref_cexpression (DataType expression_type, CCodeExpression cexpr, Expression? expr, CodeNode node) {
3864                 if (expression_type is DelegateType) {
3865                         return cexpr;
3866                 }
3867
3868                 if (expression_type is ValueType && !expression_type.nullable) {
3869                         // normal value type, no null check
3870
3871                         var decl = get_temp_variable (expression_type, false, node);
3872                         emit_temp_var (decl);
3873                         var ctemp = get_variable_cexpression (decl.name);
3874
3875                         var vt = (ValueType) expression_type;
3876                         var st = (Struct) vt.type_symbol;
3877                         var copy_call = new CCodeFunctionCall (new CCodeIdentifier (st.get_copy_function ()));
3878                         copy_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, cexpr));
3879                         copy_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, ctemp));
3880
3881                         if (!st.has_copy_function) {
3882                                 generate_struct_copy_function (st);
3883                         }
3884
3885                         if (gvalue_type != null && expression_type.data_type == gvalue_type) {
3886                                 var cisvalid = new CCodeFunctionCall (new CCodeIdentifier ("G_IS_VALUE"));
3887                                 cisvalid.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, cexpr));
3888
3889                                 ccode.open_if (cisvalid);
3890
3891                                 // GValue requires g_value_init in addition to g_value_copy
3892                                 var value_type_call = new CCodeFunctionCall (new CCodeIdentifier ("G_VALUE_TYPE"));
3893                                 value_type_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, cexpr));
3894
3895                                 var init_call = new CCodeFunctionCall (new CCodeIdentifier ("g_value_init"));
3896                                 init_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, ctemp));
3897                                 init_call.add_argument (value_type_call);
3898                                 ccode.add_expression (init_call);
3899                                 ccode.add_expression (copy_call);
3900
3901                                 ccode.add_else ();
3902
3903                                 // g_value_init/copy must not be called for uninitialized values
3904                                 ccode.add_assignment (ctemp, cexpr);
3905                                 ccode.close ();
3906                         } else {
3907                                 ccode.add_expression (copy_call);
3908                         }
3909
3910                         return ctemp;
3911                 }
3912
3913                 /* (temp = expr, temp == NULL ? NULL : ref (temp))
3914                  *
3915                  * can be simplified to
3916                  * ref (expr)
3917                  * if static type of expr is non-null
3918                  */
3919
3920                 var dupexpr = get_dup_func_expression (expression_type, node.source_reference);
3921
3922                 if (dupexpr == null) {
3923                         node.error = true;
3924                         return null;
3925                 }
3926
3927                 if (dupexpr is CCodeIdentifier && !(expression_type is ArrayType) && !(expression_type is GenericType) && !is_ref_function_void (expression_type)) {
3928                         // generate and call NULL-aware ref function to reduce number
3929                         // of temporary variables and simplify code
3930
3931                         var dupid = (CCodeIdentifier) dupexpr;
3932                         string dup0_func = "_%s0".printf (dupid.name);
3933
3934                         // g_strdup is already NULL-safe
3935                         if (dupid.name == "g_strdup") {
3936                                 dup0_func = dupid.name;
3937                         } else if (add_wrapper (dup0_func)) {
3938                                 string pointer_cname = "gpointer";
3939                                 if (context.profile == Profile.POSIX) {
3940                                         pointer_cname = "void*";
3941                                 }
3942                                 var dup0_fun = new CCodeFunction (dup0_func, pointer_cname);
3943                                 dup0_fun.add_parameter (new CCodeParameter ("self", pointer_cname));
3944                                 dup0_fun.modifiers = CCodeModifiers.STATIC;
3945
3946                                 push_function (dup0_fun);
3947
3948                                 var dup_call = new CCodeFunctionCall (dupexpr);
3949                                 dup_call.add_argument (new CCodeIdentifier ("self"));
3950
3951                                 ccode.add_return (new CCodeConditionalExpression (new CCodeIdentifier ("self"), dup_call, new CCodeConstant ("NULL")));
3952
3953                                 pop_function ();
3954
3955                                 cfile.add_function (dup0_fun);
3956                         }
3957
3958                         var ccall = new CCodeFunctionCall (new CCodeIdentifier (dup0_func));
3959                         ccall.add_argument (cexpr);
3960                         return ccall;
3961                 }
3962
3963                 var ccall = new CCodeFunctionCall (dupexpr);
3964
3965                 if (!(expression_type is ArrayType) && expr != null && expr.is_non_null ()
3966                     && !is_ref_function_void (expression_type)) {
3967                         // expression is non-null
3968                         ccall.add_argument (get_cvalue (expr));
3969
3970                         return ccall;
3971                 } else {
3972                         var decl = get_temp_variable (expression_type, false, node, false);
3973                         emit_temp_var (decl);
3974
3975                         var ctemp = get_variable_cexpression (decl.name);
3976
3977                         var cisnull = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, ctemp, new CCodeConstant ("NULL"));
3978                         if (expression_type.type_parameter != null) {
3979                                 // dup functions are optional for type parameters
3980                                 var cdupisnull = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, get_dup_func_expression (expression_type, node.source_reference), new CCodeConstant ("NULL"));
3981                                 cisnull = new CCodeBinaryExpression (CCodeBinaryOperator.OR, cisnull, cdupisnull);
3982                         }
3983
3984                         if (expression_type.type_parameter != null) {
3985                                 // cast from gconstpointer to gpointer as GBoxedCopyFunc expects gpointer
3986                                 ccall.add_argument (new CCodeCastExpression (ctemp, "gpointer"));
3987                         } else {
3988                                 ccall.add_argument (ctemp);
3989                         }
3990
3991                         if (expression_type is ArrayType) {
3992                                 var array_type = (ArrayType) expression_type;
3993                                 bool first = true;
3994                                 CCodeExpression csizeexpr = null;
3995                                 for (int dim = 1; dim <= array_type.rank; dim++) {
3996                                         if (first) {
3997                                                 csizeexpr = get_array_length_cexpression (expr, dim);
3998                                                 first = false;
3999                                         } else {
4000                                                 csizeexpr = new CCodeBinaryExpression (CCodeBinaryOperator.MUL, csizeexpr, get_array_length_cexpression (expr, dim));
4001                                         }
4002                                 }
4003
4004                                 ccall.add_argument (csizeexpr);
4005
4006                                 if (array_type.element_type is GenericType) {
4007                                         var elem_dupexpr = get_dup_func_expression (array_type.element_type, node.source_reference);
4008                                         if (elem_dupexpr == null) {
4009                                                 elem_dupexpr = new CCodeConstant ("NULL");
4010                                         }
4011                                         ccall.add_argument (elem_dupexpr);
4012                                 }
4013                         }
4014
4015                         var ccomma = new CCodeCommaExpression ();
4016                         ccomma.append_expression (new CCodeAssignment (ctemp, cexpr));
4017
4018                         CCodeExpression cifnull;
4019                         if (expression_type.data_type != null) {
4020                                 cifnull = new CCodeConstant ("NULL");
4021                         } else {
4022                                 // the value might be non-null even when the dup function is null,
4023                                 // so we may not just use NULL for type parameters
4024
4025                                 // cast from gconstpointer to gpointer as methods in
4026                                 // generic classes may not return gconstpointer
4027                                 cifnull = new CCodeCastExpression (ctemp, "gpointer");
4028                         }
4029                         ccomma.append_expression (new CCodeConditionalExpression (cisnull, cifnull, ccall));
4030
4031                         // repeat temp variable at the end of the comma expression
4032                         // if the ref function returns void
4033                         if (is_ref_function_void (expression_type)) {
4034                                 ccomma.append_expression (ctemp);
4035                         }
4036
4037                         return ccomma;
4038                 }
4039         }
4040
4041         bool is_reference_type_argument (DataType type_arg) {
4042                 if (type_arg is ErrorType || (type_arg.data_type != null && type_arg.data_type.is_reference_type ())) {
4043                         return true;
4044                 } else {
4045                         return false;
4046                 }
4047         }
4048
4049         bool is_nullable_value_type_argument (DataType type_arg) {
4050                 if (type_arg is ValueType && type_arg.nullable) {
4051                         return true;
4052                 } else {
4053                         return false;
4054                 }
4055         }
4056
4057         bool is_signed_integer_type_argument (DataType type_arg) {
4058                 var st = type_arg.data_type as Struct;
4059                 if (type_arg.nullable) {
4060                         return false;
4061                 } else if (st == bool_type.data_type) {
4062                         return true;
4063                 } else if (st == char_type.data_type) {
4064                         return true;
4065                 } else if (unichar_type != null && st == unichar_type.data_type) {
4066                         return true;
4067                 } else if (st == short_type.data_type) {
4068                         return true;
4069                 } else if (st == int_type.data_type) {
4070                         return true;
4071                 } else if (st == long_type.data_type) {
4072                         return true;
4073                 } else if (st == int8_type.data_type) {
4074                         return true;
4075                 } else if (st == int16_type.data_type) {
4076                         return true;
4077                 } else if (st == int32_type.data_type) {
4078                         return true;
4079                 } else if (st == gtype_type) {
4080                         return true;
4081                 } else if (type_arg is EnumValueType) {
4082                         return true;
4083                 } else {
4084                         return false;
4085                 }
4086         }
4087
4088         bool is_unsigned_integer_type_argument (DataType type_arg) {
4089                 var st = type_arg.data_type as Struct;
4090                 if (type_arg.nullable) {
4091                         return false;
4092                 } else if (st == uchar_type.data_type) {
4093                         return true;
4094                 } else if (st == ushort_type.data_type) {
4095                         return true;
4096                 } else if (st == uint_type.data_type) {
4097                         return true;
4098                 } else if (st == ulong_type.data_type) {
4099                         return true;
4100                 } else if (st == uint8_type.data_type) {
4101                         return true;
4102                 } else if (st == uint16_type.data_type) {
4103                         return true;
4104                 } else if (st == uint32_type.data_type) {
4105                         return true;
4106                 } else {
4107                         return false;
4108                 }
4109         }
4110
4111         public void check_type (DataType type) {
4112                 var array_type = type as ArrayType;
4113                 if (array_type != null) {
4114                         check_type (array_type.element_type);
4115                         if (array_type.element_type is ArrayType) {
4116                                 Report.error (type.source_reference, "Stacked arrays are not supported");
4117                         } else if (array_type.element_type is DelegateType) {
4118                                 var delegate_type = (DelegateType) array_type.element_type;
4119                                 if (delegate_type.delegate_symbol.has_target) {
4120                                         Report.error (type.source_reference, "Delegates with target are not supported as array element type");
4121                                 }
4122                         }
4123                 }
4124                 foreach (var type_arg in type.get_type_arguments ()) {
4125                         check_type (type_arg);
4126                         check_type_argument (type_arg);
4127                 }
4128         }
4129
4130         void check_type_argument (DataType type_arg) {
4131                 if (type_arg is GenericType
4132                     || type_arg is PointerType
4133                     || is_reference_type_argument (type_arg)
4134                     || is_nullable_value_type_argument (type_arg)
4135                     || is_signed_integer_type_argument (type_arg)
4136                     || is_unsigned_integer_type_argument (type_arg)) {
4137                         // no error
4138                 } else if (type_arg is DelegateType) {
4139                         var delegate_type = (DelegateType) type_arg;
4140                         if (delegate_type.delegate_symbol.has_target) {
4141                                 Report.error (type_arg.source_reference, "Delegates with target are not supported as generic type arguments");
4142                         }
4143                 } else {
4144                         Report.error (type_arg.source_reference, "`%s' is not a supported generic type argument, use `?' to box value types".printf (type_arg.to_string ()));
4145                 }
4146         }
4147
4148         public virtual void generate_class_declaration (Class cl, CCodeFile decl_space) {
4149                 if (add_symbol_declaration (decl_space, cl, cl.get_cname ())) {
4150                         return;
4151                 }
4152         }
4153
4154         public virtual void generate_interface_declaration (Interface iface, CCodeFile decl_space) {
4155         }
4156
4157         public virtual void generate_method_declaration (Method m, CCodeFile decl_space) {
4158         }
4159
4160         public virtual void generate_error_domain_declaration (ErrorDomain edomain, CCodeFile decl_space) {
4161         }
4162
4163         public void add_generic_type_arguments (Map<int,CCodeExpression> arg_map, List<DataType> type_args, CodeNode expr, bool is_chainup = false) {
4164                 int type_param_index = 0;
4165                 foreach (var type_arg in type_args) {
4166                         arg_map.set (get_param_pos (0.1 * type_param_index + 0.01), get_type_id_expression (type_arg, is_chainup));
4167                         if (requires_copy (type_arg)) {
4168                                 var dup_func = get_dup_func_expression (type_arg, type_arg.source_reference, is_chainup);
4169                                 if (dup_func == null) {
4170                                         // type doesn't contain a copy function
4171                                         expr.error = true;
4172                                         return;
4173                                 }
4174                                 arg_map.set (get_param_pos (0.1 * type_param_index + 0.02), new CCodeCastExpression (dup_func, "GBoxedCopyFunc"));
4175                                 arg_map.set (get_param_pos (0.1 * type_param_index + 0.03), get_destroy_func_expression (type_arg, is_chainup));
4176                         } else {
4177                                 arg_map.set (get_param_pos (0.1 * type_param_index + 0.02), new CCodeConstant ("NULL"));
4178                                 arg_map.set (get_param_pos (0.1 * type_param_index + 0.03), new CCodeConstant ("NULL"));
4179                         }
4180                         type_param_index++;
4181                 }
4182         }
4183
4184         public override void visit_object_creation_expression (ObjectCreationExpression expr) {
4185                 CCodeExpression instance = null;
4186                 CCodeExpression creation_expr = null;
4187
4188                 check_type (expr.type_reference);
4189
4190                 var st = expr.type_reference.data_type as Struct;
4191                 if ((st != null && (!st.is_simple_type () || st.get_cname () == "va_list")) || expr.get_object_initializer ().size > 0) {
4192                         // value-type initialization or object creation expression with object initializer
4193
4194                         var local = expr.parent_node as LocalVariable;
4195                         if (local != null && has_simple_struct_initializer (local)) {
4196                                 if (local.captured) {
4197                                         var block = (Block) local.parent_symbol;
4198                                         instance = new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (get_block_id (block))), get_variable_cname (local.name));
4199                                 } else {
4200                                         instance = get_variable_cexpression (get_variable_cname (local.name));
4201                                 }
4202                         } else {
4203                                 var temp_decl = get_temp_variable (expr.type_reference, false, expr);
4204                                 emit_temp_var (temp_decl);
4205
4206                                 instance = get_variable_cexpression (get_variable_cname (temp_decl.name));
4207                         }
4208                 }
4209
4210                 if (expr.symbol_reference == null) {
4211                         // no creation method
4212                         if (expr.type_reference.data_type is Struct) {
4213                                 // memset needs string.h
4214                                 cfile.add_include ("string.h");
4215                                 var creation_call = new CCodeFunctionCall (new CCodeIdentifier ("memset"));
4216                                 creation_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, instance));
4217                                 creation_call.add_argument (new CCodeConstant ("0"));
4218                                 creation_call.add_argument (new CCodeIdentifier ("sizeof (%s)".printf (expr.type_reference.get_cname ())));
4219
4220                                 creation_expr = creation_call;
4221                         }
4222                 } else if (expr.type_reference.data_type == glist_type ||
4223                            expr.type_reference.data_type == gslist_type) {
4224                         // NULL is an empty list
4225                         set_cvalue (expr, new CCodeConstant ("NULL"));
4226                 } else if (expr.symbol_reference is Method) {
4227                         // use creation method
4228                         var m = (Method) expr.symbol_reference;
4229                         var params = m.get_parameters ();
4230                         CCodeFunctionCall creation_call;
4231
4232                         generate_method_declaration (m, cfile);
4233
4234                         var cl = expr.type_reference.data_type as Class;
4235
4236                         if (!m.has_new_function) {
4237                                 // use construct function directly
4238                                 creation_call = new CCodeFunctionCall (new CCodeIdentifier (m.get_real_cname ()));
4239                                 creation_call.add_argument (new CCodeIdentifier (cl.get_type_id ()));
4240                         } else {
4241                                 creation_call = new CCodeFunctionCall (new CCodeIdentifier (m.get_cname ()));
4242                         }
4243
4244                         if ((st != null && !st.is_simple_type ()) && !(m.cinstance_parameter_position < 0)) {
4245                                 creation_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, instance));
4246                         } else if (st != null && st.get_cname () == "va_list") {
4247                                 creation_call.add_argument (instance);
4248                                 if (m.get_cname () == "va_start") {
4249                                         Parameter last_param = null;
4250                                         foreach (var param in current_method.get_parameters ()) {
4251                                                 if (param.ellipsis) {
4252                                                         break;
4253                                                 }
4254                                                 last_param = param;
4255                                         }
4256                                         creation_call.add_argument (new CCodeIdentifier (get_variable_cname (last_param.name)));
4257                                 }
4258                         }
4259
4260                         generate_type_declaration (expr.type_reference, cfile);
4261
4262                         var carg_map = new HashMap<int,CCodeExpression> (direct_hash, direct_equal);
4263
4264                         if (cl != null && !cl.is_compact) {
4265                                 add_generic_type_arguments (carg_map, expr.type_reference.get_type_arguments (), expr);
4266                         } else if (cl != null && m.simple_generics) {
4267                                 int type_param_index = 0;
4268                                 foreach (var type_arg in expr.type_reference.get_type_arguments ()) {
4269                                         if (requires_copy (type_arg)) {
4270                                                 carg_map.set (get_param_pos (-1 + 0.1 * type_param_index + 0.03), get_destroy0_func_expression (type_arg));
4271                                         } else {
4272                                                 carg_map.set (get_param_pos (-1 + 0.1 * type_param_index + 0.03), new CCodeConstant ("NULL"));
4273                                         }
4274                                         type_param_index++;
4275                                 }
4276                         }
4277
4278                         bool ellipsis = false;
4279
4280                         int i = 1;
4281                         int arg_pos;
4282                         Iterator<Parameter> params_it = params.iterator ();
4283                         foreach (Expression arg in expr.get_argument_list ()) {
4284                                 CCodeExpression cexpr = get_cvalue (arg);
4285                                 Parameter param = null;
4286                                 if (params_it.next ()) {
4287                                         param = params_it.get ();
4288                                         ellipsis = param.ellipsis;
4289                                         if (!ellipsis) {
4290                                                 if (!param.no_array_length && param.variable_type is ArrayType) {
4291                                                         var array_type = (ArrayType) param.variable_type;
4292                                                         for (int dim = 1; dim <= array_type.rank; dim++) {
4293                                                                 carg_map.set (get_param_pos (param.carray_length_parameter_position + 0.01 * dim), get_array_length_cexpression (arg, dim));
4294                                                         }
4295                                                 } else if (param.variable_type is DelegateType) {
4296                                                         var deleg_type = (DelegateType) param.variable_type;
4297                                                         var d = deleg_type.delegate_symbol;
4298                                                         if (d.has_target) {
4299                                                                 CCodeExpression delegate_target_destroy_notify;
4300                                                                 var delegate_target = get_delegate_target_cexpression (arg, out delegate_target_destroy_notify);
4301                                                                 carg_map.set (get_param_pos (param.cdelegate_target_parameter_position), delegate_target);
4302                                                                 if (deleg_type.value_owned) {
4303                                                                         carg_map.set (get_param_pos (param.cdelegate_target_parameter_position + 0.01), delegate_target_destroy_notify);
4304                                                                 }
4305                                                         }
4306                                                 }
4307
4308                                                 cexpr = handle_struct_argument (param, arg, cexpr);
4309
4310                                                 if (param.ctype != null) {
4311                                                         cexpr = new CCodeCastExpression (cexpr, param.ctype);
4312                                                 }
4313                                         } else {
4314                                                 cexpr = handle_struct_argument (null, arg, cexpr);
4315                                         }
4316
4317                                         arg_pos = get_param_pos (param.cparameter_position, ellipsis);
4318                                 } else {
4319                                         // default argument position
4320                                         cexpr = handle_struct_argument (null, arg, cexpr);
4321                                         arg_pos = get_param_pos (i, ellipsis);
4322                                 }
4323
4324                                 carg_map.set (arg_pos, cexpr);
4325
4326                                 i++;
4327                         }
4328                         while (params_it.next ()) {
4329                                 var param = params_it.get ();
4330
4331                                 if (param.ellipsis) {
4332                                         ellipsis = true;
4333                                         break;
4334                                 }
4335
4336                                 if (param.initializer == null) {
4337                                         Report.error (expr.source_reference, "no default expression for argument %d".printf (i));
4338                                         return;
4339                                 }
4340
4341                                 /* evaluate default expression here as the code
4342                                  * generator might not have visited the formal
4343                                  * parameter yet */
4344                                 param.initializer.emit (this);
4345
4346                                 carg_map.set (get_param_pos (param.cparameter_position), get_cvalue (param.initializer));
4347                                 i++;
4348                         }
4349
4350                         // append C arguments in the right order
4351                         int last_pos = -1;
4352                         int min_pos;
4353                         while (true) {
4354                                 min_pos = -1;
4355                                 foreach (int pos in carg_map.get_keys ()) {
4356                                         if (pos > last_pos && (min_pos == -1 || pos < min_pos)) {
4357                                                 min_pos = pos;
4358                                         }
4359                                 }
4360                                 if (min_pos == -1) {
4361                                         break;
4362                                 }
4363                                 creation_call.add_argument (carg_map.get (min_pos));
4364                                 last_pos = min_pos;
4365                         }
4366
4367                         if ((st != null && !st.is_simple_type ()) && m.cinstance_parameter_position < 0) {
4368                                 // instance parameter is at the end in a struct creation method
4369                                 creation_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, instance));
4370                         }
4371
4372                         if (expr.tree_can_fail) {
4373                                 // method can fail
4374                                 current_method_inner_error = true;
4375                                 creation_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_variable_cexpression ("_inner_error_")));
4376                         }
4377
4378                         if (ellipsis) {
4379                                 /* ensure variable argument list ends with NULL
4380                                  * except when using printf-style arguments */
4381                                 if (!m.printf_format && !m.scanf_format && m.sentinel != "") {
4382                                         creation_call.add_argument (new CCodeConstant (m.sentinel));
4383                                 }
4384                         }
4385
4386                         creation_expr = creation_call;
4387
4388                         // cast the return value of the creation method back to the intended type if
4389                         // it requested a special C return type
4390                         if (get_custom_creturn_type (m) != null) {
4391                                 creation_expr = new CCodeCastExpression (creation_expr, expr.type_reference.get_cname ());
4392                         }
4393                 } else if (expr.symbol_reference is ErrorCode) {
4394                         var ecode = (ErrorCode) expr.symbol_reference;
4395                         var edomain = (ErrorDomain) ecode.parent_symbol;
4396                         CCodeFunctionCall creation_call;
4397
4398                         generate_error_domain_declaration (edomain, cfile);
4399
4400                         if (expr.get_argument_list ().size == 1) {
4401                                 // must not be a format argument
4402                                 creation_call = new CCodeFunctionCall (new CCodeIdentifier ("g_error_new_literal"));
4403                         } else {
4404                                 creation_call = new CCodeFunctionCall (new CCodeIdentifier ("g_error_new"));
4405                         }
4406                         creation_call.add_argument (new CCodeIdentifier (edomain.get_upper_case_cname ()));
4407                         creation_call.add_argument (new CCodeIdentifier (ecode.get_cname ()));
4408
4409                         foreach (Expression arg in expr.get_argument_list ()) {
4410                                 creation_call.add_argument (get_cvalue (arg));
4411                         }
4412
4413                         creation_expr = creation_call;
4414                 } else {
4415                         assert (false);
4416                 }
4417
4418                 var local = expr.parent_node as LocalVariable;
4419                 if (local != null && has_simple_struct_initializer (local)) {
4420                         // no temporary variable necessary
4421                         ccode.add_expression (creation_expr);
4422                         set_cvalue (expr, instance);
4423                         return;
4424                 } else if (instance != null) {
4425                         if (expr.type_reference.data_type is Struct) {
4426                                 ccode.add_expression (creation_expr);
4427                         } else {
4428                                 ccode.add_assignment (instance, creation_expr);
4429                         }
4430
4431                         foreach (MemberInitializer init in expr.get_object_initializer ()) {
4432                                 if (init.symbol_reference is Field) {
4433                                         var f = (Field) init.symbol_reference;
4434                                         var instance_target_type = get_data_type_for_symbol ((TypeSymbol) f.parent_symbol);
4435                                         var typed_inst = transform_expression (instance, expr.type_reference, instance_target_type);
4436                                         CCodeExpression lhs;
4437                                         if (expr.type_reference.data_type is Struct) {
4438                                                 lhs = new CCodeMemberAccess (typed_inst, f.get_cname ());
4439                                         } else {
4440                                                 lhs = new CCodeMemberAccess.pointer (typed_inst, f.get_cname ());
4441                                         }
4442                                         ccode.add_assignment (lhs, get_cvalue (init.initializer));
4443
4444                                         if (f.variable_type is ArrayType && !f.no_array_length) {
4445                                                 var array_type = (ArrayType) f.variable_type;
4446                                                 for (int dim = 1; dim <= array_type.rank; dim++) {
4447                                                         if (expr.type_reference.data_type is Struct) {
4448                                                                 lhs = new CCodeMemberAccess (typed_inst, get_array_length_cname (f.get_cname (), dim));
4449                                                         } else {
4450                                                                 lhs = new CCodeMemberAccess.pointer (typed_inst, get_array_length_cname (f.get_cname (), dim));
4451                                                         }
4452                                                         var rhs_array_len = get_array_length_cexpression (init.initializer, dim);
4453                                                         ccode.add_assignment (lhs, rhs_array_len);
4454                                                 }
4455                                         } else if (f.variable_type is DelegateType && (f.variable_type as DelegateType).delegate_symbol.has_target && !f.no_delegate_target) {
4456                                                 if (expr.type_reference.data_type is Struct) {
4457                                                         lhs = new CCodeMemberAccess (typed_inst, get_delegate_target_cname (f.get_cname ()));
4458                                                 } else {
4459                                                         lhs = new CCodeMemberAccess.pointer (typed_inst, get_delegate_target_cname (f.get_cname ()));
4460                                                 }
4461                                                 CCodeExpression rhs_delegate_target_destroy_notify;
4462                                                 var rhs_delegate_target = get_delegate_target_cexpression (init.initializer, out rhs_delegate_target_destroy_notify);
4463                                                 ccode.add_assignment (lhs, rhs_delegate_target);
4464                                         }
4465
4466                                         var cl = f.parent_symbol as Class;
4467                                         if (cl != null) {
4468                                                 generate_class_struct_declaration (cl, cfile);
4469                                         }
4470                                 } else if (init.symbol_reference is Property) {
4471                                         var inst_ma = new MemberAccess.simple ("new");
4472                                         inst_ma.value_type = expr.type_reference;
4473                                         set_cvalue (inst_ma, instance);
4474                                         store_property ((Property) init.symbol_reference, inst_ma, init.initializer.target_value);
4475                                 }
4476                         }
4477
4478                         creation_expr = instance;
4479                 }
4480
4481                 if (creation_expr != null) {
4482                         var temp_var = get_temp_variable (expr.value_type);
4483                         var temp_ref = get_variable_cexpression (temp_var.name);
4484
4485                         emit_temp_var (temp_var);
4486
4487                         ccode.add_assignment (temp_ref, creation_expr);
4488                         set_cvalue (expr, temp_ref);
4489                 }
4490         }
4491
4492         public CCodeExpression? handle_struct_argument (Parameter? param, Expression arg, CCodeExpression? cexpr) {
4493                 DataType type;
4494                 if (param != null) {
4495                         type = param.variable_type;
4496                 } else {
4497                         // varargs
4498                         type = arg.value_type;
4499                 }
4500
4501                 // pass non-simple struct instances always by reference
4502                 if (!(arg.value_type is NullType) && type.is_real_struct_type ()) {
4503                         // we already use a reference for arguments of ref, out, and nullable parameters
4504                         if ((param == null || param.direction == ParameterDirection.IN) && !type.nullable) {
4505                                 var unary = cexpr as CCodeUnaryExpression;
4506                                 if (unary != null && unary.operator == CCodeUnaryOperator.POINTER_INDIRECTION) {
4507                                         // *expr => expr
4508                                         return unary.inner;
4509                                 } else if (cexpr is CCodeIdentifier || cexpr is CCodeMemberAccess) {
4510                                         return new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, cexpr);
4511                                 } else {
4512                                         // if cexpr is e.g. a function call, we can't take the address of the expression
4513                                         var temp_var = get_temp_variable (type, true, null, false);
4514                                         emit_temp_var (temp_var);
4515
4516                                         ccode.add_assignment (get_variable_cexpression (temp_var.name), cexpr);
4517                                         return new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_variable_cexpression (temp_var.name));
4518                                 }
4519                         }
4520                 }
4521
4522                 return cexpr;
4523         }
4524
4525         public override void visit_sizeof_expression (SizeofExpression expr) {
4526                 generate_type_declaration (expr.type_reference, cfile);
4527
4528                 var csizeof = new CCodeFunctionCall (new CCodeIdentifier ("sizeof"));
4529                 csizeof.add_argument (new CCodeIdentifier (expr.type_reference.get_cname ()));
4530                 set_cvalue (expr, csizeof);
4531         }
4532
4533         public override void visit_typeof_expression (TypeofExpression expr) {
4534                 set_cvalue (expr, get_type_id_expression (expr.type_reference));
4535         }
4536
4537         public override void visit_unary_expression (UnaryExpression expr) {
4538                 if (expr.operator == UnaryOperator.REF || expr.operator == UnaryOperator.OUT) {
4539                         var glib_value = (GLibValue) expr.inner.target_value;
4540
4541                         var ref_value = new GLibValue (glib_value.value_type);
4542                         ref_value.cvalue = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, glib_value.cvalue);
4543
4544                         if (glib_value.array_length_cvalues != null) {
4545                                 for (int i = 0; i < glib_value.array_length_cvalues.size; i++) {
4546                                         ref_value.append_array_length_cvalue (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, glib_value.array_length_cvalues[i]));
4547                                 }
4548                         }
4549
4550                         if (glib_value.delegate_target_cvalue != null) {
4551                                 ref_value.delegate_target_cvalue = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, glib_value.delegate_target_cvalue);
4552                         }
4553                         if (glib_value.delegate_target_destroy_notify_cvalue != null) {
4554                                 ref_value.delegate_target_destroy_notify_cvalue = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, glib_value.delegate_target_destroy_notify_cvalue);
4555                         }
4556
4557                         expr.target_value = ref_value;
4558                         return;
4559                 }
4560
4561                 CCodeUnaryOperator op;
4562                 if (expr.operator == UnaryOperator.PLUS) {
4563                         op = CCodeUnaryOperator.PLUS;
4564                 } else if (expr.operator == UnaryOperator.MINUS) {
4565                         op = CCodeUnaryOperator.MINUS;
4566                 } else if (expr.operator == UnaryOperator.LOGICAL_NEGATION) {
4567                         op = CCodeUnaryOperator.LOGICAL_NEGATION;
4568                 } else if (expr.operator == UnaryOperator.BITWISE_COMPLEMENT) {
4569                         op = CCodeUnaryOperator.BITWISE_COMPLEMENT;
4570                 } else if (expr.operator == UnaryOperator.INCREMENT) {
4571                         op = CCodeUnaryOperator.PREFIX_INCREMENT;
4572                 } else if (expr.operator == UnaryOperator.DECREMENT) {
4573                         op = CCodeUnaryOperator.PREFIX_DECREMENT;
4574                 } else {
4575                         assert_not_reached ();
4576                 }
4577                 set_cvalue (expr, new CCodeUnaryExpression (op, get_cvalue (expr.inner)));
4578         }
4579
4580         public CCodeExpression? try_cast_value_to_type (CCodeExpression ccodeexpr, DataType from, DataType to, Expression? expr = null) {
4581                 if (from == null || gvalue_type == null || from.data_type != gvalue_type || to.get_type_id () == null) {
4582                         return null;
4583                 }
4584
4585                 // explicit conversion from GValue
4586                 var ccall = new CCodeFunctionCall (get_value_getter_function (to));
4587                 CCodeExpression gvalue;
4588                 if (from.nullable) {
4589                         gvalue = ccodeexpr;
4590                 } else {
4591                         gvalue = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, ccodeexpr);
4592                 }
4593                 ccall.add_argument (gvalue);
4594
4595                 CCodeExpression rv = ccall;
4596
4597                 if (expr != null && to is ArrayType) {
4598                         // null-terminated string array
4599                         var len_call = new CCodeFunctionCall (new CCodeIdentifier ("g_strv_length"));
4600                         len_call.add_argument (rv);
4601                         append_array_length (expr, len_call);
4602                 } else if (to is StructValueType) {
4603                         var temp_decl = get_temp_variable (to, true, null, true);
4604                         emit_temp_var (temp_decl);
4605                         var ctemp = get_variable_cexpression (temp_decl.name);
4606
4607                         rv = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeCastExpression (rv, (new PointerType(to)).get_cname ()));
4608                         var holds = new CCodeFunctionCall (new CCodeIdentifier ("G_VALUE_HOLDS"));
4609                         holds.add_argument (gvalue);
4610                         holds.add_argument (new CCodeIdentifier (to.get_type_id ()));
4611                         var cond = new CCodeBinaryExpression (CCodeBinaryOperator.AND, holds, ccall);
4612                         var warn = new CCodeFunctionCall (new CCodeIdentifier ("g_warning"));
4613                         warn.add_argument (new CCodeConstant ("\"Invalid GValue unboxing (wrong type or NULL)\""));
4614                         var fail = new CCodeCommaExpression ();
4615                         fail.append_expression (warn);
4616                         fail.append_expression (ctemp);
4617                         rv = new CCodeConditionalExpression (cond, rv,  fail);
4618                 }
4619
4620                 return rv;
4621         }
4622
4623         int next_variant_function_id = 0;
4624
4625         public CCodeExpression? try_cast_variant_to_type (CCodeExpression ccodeexpr, DataType from, DataType to, Expression? expr = null) {
4626                 if (from == null || gvariant_type == null || from.data_type != gvariant_type) {
4627                         return null;
4628                 }
4629
4630                 string variant_func = "_variant_get%d".printf (++next_variant_function_id);
4631
4632                 var ccall = new CCodeFunctionCall (new CCodeIdentifier (variant_func));
4633                 ccall.add_argument (ccodeexpr);
4634
4635                 var cfunc = new CCodeFunction (variant_func);
4636                 cfunc.modifiers = CCodeModifiers.STATIC;
4637                 cfunc.add_parameter (new CCodeParameter ("value", "GVariant*"));
4638
4639                 if (!to.is_real_non_null_struct_type ()) {
4640                         cfunc.return_type = to.get_cname ();
4641                 }
4642
4643                 if (to.is_real_non_null_struct_type ()) {
4644                         // structs are returned via out parameter
4645                         cfunc.add_parameter (new CCodeParameter ("result", to.get_cname () + "*"));
4646                 } else if (to is ArrayType) {
4647                         // return array length if appropriate
4648                         var array_type = (ArrayType) to;
4649
4650                         for (int dim = 1; dim <= array_type.rank; dim++) {
4651                                 var temp_decl = get_temp_variable (int_type, false, expr);
4652                                 emit_temp_var (temp_decl);
4653
4654                                 ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_variable_cexpression (temp_decl.name)));
4655                                 cfunc.add_parameter (new CCodeParameter (get_array_length_cname ("result", dim), "int*"));
4656                                 append_array_length (expr, get_variable_cexpression (temp_decl.name));
4657                         }
4658                 }
4659
4660                 push_function (cfunc);
4661
4662                 var result = deserialize_expression (to, new CCodeIdentifier ("value"), new CCodeIdentifier ("*result"));
4663                 ccode.add_return (result);
4664
4665                 pop_function ();
4666
4667                 cfile.add_function_declaration (cfunc);
4668                 cfile.add_function (cfunc);
4669
4670                 return ccall;
4671         }
4672
4673         public virtual CCodeExpression? deserialize_expression (DataType type, CCodeExpression variant_expr, CCodeExpression? expr, CCodeExpression? error_expr = null, out bool may_fail = null) {
4674                 return null;
4675         }
4676
4677         public virtual CCodeExpression? serialize_expression (DataType type, CCodeExpression expr) {
4678                 return null;
4679         }
4680
4681         public override void visit_cast_expression (CastExpression expr) {
4682                 var valuecast = try_cast_value_to_type (get_cvalue (expr.inner), expr.inner.value_type, expr.type_reference, expr);
4683                 if (valuecast != null) {
4684                         set_cvalue (expr, valuecast);
4685                         return;
4686                 }
4687
4688                 var variantcast = try_cast_variant_to_type (get_cvalue (expr.inner), expr.inner.value_type, expr.type_reference, expr);
4689                 if (variantcast != null) {
4690                         set_cvalue (expr, variantcast);
4691                         return;
4692                 }
4693
4694                 generate_type_declaration (expr.type_reference, cfile);
4695
4696                 var cl = expr.type_reference.data_type as Class;
4697                 var iface = expr.type_reference.data_type as Interface;
4698                 if (context.profile == Profile.GOBJECT && (iface != null || (cl != null && !cl.is_compact))) {
4699                         // checked cast for strict subtypes of GTypeInstance
4700                         if (expr.is_silent_cast) {
4701                                 var temp_decl = get_temp_variable (expr.inner.value_type, expr.inner.value_type.value_owned, expr, false);
4702                                 emit_temp_var (temp_decl);
4703                                 var ctemp = get_variable_cexpression (temp_decl.name);
4704
4705                                 ccode.add_assignment (ctemp, get_cvalue (expr.inner));
4706                                 var ccheck = create_type_check (ctemp, expr.type_reference);
4707                                 var ccast = new CCodeCastExpression (ctemp, expr.type_reference.get_cname ());
4708                                 var cnull = new CCodeConstant ("NULL");
4709
4710                                 set_cvalue (expr, new CCodeConditionalExpression (ccheck, ccast, cnull));
4711                         } else {
4712                                 set_cvalue (expr, generate_instance_cast (get_cvalue (expr.inner), expr.type_reference.data_type));
4713                         }
4714                 } else {
4715                         if (expr.is_silent_cast) {
4716                                 expr.error = true;
4717                                 Report.error (expr.source_reference, "Operation not supported for this type");
4718                                 return;
4719                         }
4720
4721                         // retain array length
4722                         var array_type = expr.type_reference as ArrayType;
4723                         if (array_type != null && expr.inner.value_type is ArrayType) {
4724                                 for (int dim = 1; dim <= array_type.rank; dim++) {
4725                                         append_array_length (expr, get_array_length_cexpression (expr.inner, dim));
4726                                 }
4727                         } else if (array_type != null) {
4728                                 // cast from non-array to array, set invalid length
4729                                 // required by string.data, e.g.
4730                                 for (int dim = 1; dim <= array_type.rank; dim++) {
4731                                         append_array_length (expr, new CCodeConstant ("-1"));
4732                                 }
4733                         }
4734
4735                         var innercexpr = get_cvalue (expr.inner);
4736                         if (expr.type_reference.data_type is Struct && !expr.type_reference.nullable &&
4737                                 expr.inner.value_type.data_type is Struct && expr.inner.value_type.nullable) {
4738                                 // nullable integer or float or boolean or struct cast to non-nullable
4739                                 innercexpr = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, innercexpr);
4740                         }
4741                         set_cvalue (expr, new CCodeCastExpression (innercexpr, expr.type_reference.get_cname ()));
4742
4743                         if (expr.type_reference is DelegateType) {
4744                                 if (get_delegate_target (expr.inner) != null) {
4745                                         set_delegate_target (expr, get_delegate_target (expr.inner));
4746                                 } else {
4747                                         set_delegate_target (expr, new CCodeConstant ("NULL"));
4748                                 }
4749                                 if (get_delegate_target_destroy_notify (expr.inner) != null) {
4750                                         set_delegate_target_destroy_notify (expr, get_delegate_target_destroy_notify (expr.inner));
4751                                 } else {
4752                                         set_delegate_target_destroy_notify (expr, new CCodeConstant ("NULL"));
4753                                 }
4754                         }
4755                 }
4756         }
4757
4758         public override void visit_named_argument (NamedArgument expr) {
4759                 set_cvalue (expr, get_cvalue (expr.inner));
4760         }
4761
4762         public override void visit_pointer_indirection (PointerIndirection expr) {
4763                 set_cvalue (expr, new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, get_cvalue (expr.inner)));
4764         }
4765
4766         public override void visit_addressof_expression (AddressofExpression expr) {
4767                 set_cvalue (expr, new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_cvalue (expr.inner)));
4768         }
4769
4770         public override void visit_reference_transfer_expression (ReferenceTransferExpression expr) {
4771                 /* (tmp = var, var = null, tmp) */
4772                 var temp_decl = get_temp_variable (expr.value_type, true, expr, false);
4773                 emit_temp_var (temp_decl);
4774                 var cvar = get_variable_cexpression (temp_decl.name);
4775
4776                 ccode.add_assignment (cvar, get_cvalue (expr.inner));
4777                 if (!(expr.value_type is DelegateType)) {
4778                         ccode.add_assignment (get_cvalue (expr.inner), new CCodeConstant ("NULL"));
4779                 }
4780
4781                 set_cvalue (expr, cvar);
4782
4783                 var array_type = expr.value_type as ArrayType;
4784                 if (array_type != null) {
4785                         for (int dim = 1; dim <= array_type.rank; dim++) {
4786                                 append_array_length (expr, get_array_length_cexpression (expr.inner, dim));
4787                         }
4788                 }
4789
4790                 var delegate_type = expr.value_type as DelegateType;
4791                 if (delegate_type != null && delegate_type.delegate_symbol.has_target) {
4792                         var temp_target_decl = get_temp_variable (new PointerType (new VoidType ()), true, expr, false);
4793                         emit_temp_var (temp_target_decl);
4794                         var target_cvar = get_variable_cexpression (temp_target_decl.name);
4795                         CCodeExpression target_destroy_notify;
4796                         var target = get_delegate_target_cexpression (expr.inner, out target_destroy_notify);
4797                         ccode.add_assignment (target_cvar, target);
4798                         set_delegate_target (expr, target_cvar);
4799                         if (target_destroy_notify != null) {
4800                                 var temp_target_destroy_notify_decl = get_temp_variable (gdestroynotify_type, true, expr, false);
4801                                 emit_temp_var (temp_target_destroy_notify_decl);
4802                                 var target_destroy_notify_cvar = get_variable_cexpression (temp_target_destroy_notify_decl.name);
4803                                 ccode.add_assignment (target_destroy_notify_cvar, target_destroy_notify);
4804                                 ccode.add_assignment (target_destroy_notify, new CCodeConstant ("NULL"));
4805                                 set_delegate_target_destroy_notify (expr, target_destroy_notify_cvar);
4806                         }
4807                 }
4808         }
4809
4810         public override void visit_binary_expression (BinaryExpression expr) {
4811                 var cleft = get_cvalue (expr.left);
4812                 var cright = get_cvalue (expr.right);
4813
4814                 CCodeExpression? left_chain = null;
4815                 if (expr.chained) {
4816                         var lbe = (BinaryExpression) expr.left;
4817
4818                         var temp_decl = get_temp_variable (lbe.right.value_type, true, null, false);
4819                         emit_temp_var (temp_decl);
4820                         var cvar = get_variable_cexpression (temp_decl.name);
4821                         var clbe = (CCodeBinaryExpression) get_cvalue (lbe);
4822                         if (lbe.chained) {
4823                                 clbe = (CCodeBinaryExpression) clbe.right;
4824                         }
4825                         ccode.add_assignment (cvar, get_cvalue (lbe.right));
4826                         clbe.right = get_variable_cexpression (temp_decl.name);
4827                         left_chain = cleft;
4828                         cleft = cvar;
4829                 }
4830
4831                 CCodeBinaryOperator op;
4832                 if (expr.operator == BinaryOperator.PLUS) {
4833                         op = CCodeBinaryOperator.PLUS;
4834                 } else if (expr.operator == BinaryOperator.MINUS) {
4835                         op = CCodeBinaryOperator.MINUS;
4836                 } else if (expr.operator == BinaryOperator.MUL) {
4837                         op = CCodeBinaryOperator.MUL;
4838                 } else if (expr.operator == BinaryOperator.DIV) {
4839                         op = CCodeBinaryOperator.DIV;
4840                 } else if (expr.operator == BinaryOperator.MOD) {
4841                         if (expr.value_type.equals (double_type)) {
4842                                 cfile.add_include ("math.h");
4843                                 var ccall = new CCodeFunctionCall (new CCodeIdentifier ("fmod"));
4844                                 ccall.add_argument (cleft);
4845                                 ccall.add_argument (cright);
4846                                 set_cvalue (expr, ccall);
4847                                 return;
4848                         } else if (expr.value_type.equals (float_type)) {
4849                                 cfile.add_include ("math.h");
4850                                 var ccall = new CCodeFunctionCall (new CCodeIdentifier ("fmodf"));
4851                                 ccall.add_argument (cleft);
4852                                 ccall.add_argument (cright);
4853                                 set_cvalue (expr, ccall);
4854                                 return;
4855                         } else {
4856                                 op = CCodeBinaryOperator.MOD;
4857                         }
4858                 } else if (expr.operator == BinaryOperator.SHIFT_LEFT) {
4859                         op = CCodeBinaryOperator.SHIFT_LEFT;
4860                 } else if (expr.operator == BinaryOperator.SHIFT_RIGHT) {
4861                         op = CCodeBinaryOperator.SHIFT_RIGHT;
4862                 } else if (expr.operator == BinaryOperator.LESS_THAN) {
4863                         op = CCodeBinaryOperator.LESS_THAN;
4864                 } else if (expr.operator == BinaryOperator.GREATER_THAN) {
4865                         op = CCodeBinaryOperator.GREATER_THAN;
4866                 } else if (expr.operator == BinaryOperator.LESS_THAN_OR_EQUAL) {
4867                         op = CCodeBinaryOperator.LESS_THAN_OR_EQUAL;
4868                 } else if (expr.operator == BinaryOperator.GREATER_THAN_OR_EQUAL) {
4869                         op = CCodeBinaryOperator.GREATER_THAN_OR_EQUAL;
4870                 } else if (expr.operator == BinaryOperator.EQUALITY) {
4871                         op = CCodeBinaryOperator.EQUALITY;
4872                 } else if (expr.operator == BinaryOperator.INEQUALITY) {
4873                         op = CCodeBinaryOperator.INEQUALITY;
4874                 } else if (expr.operator == BinaryOperator.BITWISE_AND) {
4875                         op = CCodeBinaryOperator.BITWISE_AND;
4876                 } else if (expr.operator == BinaryOperator.BITWISE_OR) {
4877                         op = CCodeBinaryOperator.BITWISE_OR;
4878                 } else if (expr.operator == BinaryOperator.BITWISE_XOR) {
4879                         op = CCodeBinaryOperator.BITWISE_XOR;
4880                 } else if (expr.operator == BinaryOperator.AND) {
4881                         op = CCodeBinaryOperator.AND;
4882                 } else if (expr.operator == BinaryOperator.OR) {
4883                         op = CCodeBinaryOperator.OR;
4884                 } else if (expr.operator == BinaryOperator.IN) {
4885                         if (expr.right.value_type is ArrayType) {
4886                                 var array_type = (ArrayType) expr.right.value_type;
4887                                 var node = new CCodeFunctionCall (new CCodeIdentifier (generate_array_contains_wrapper (array_type)));
4888                                 node.add_argument (cright);
4889                                 node.add_argument (get_array_length_cexpression (expr.right));
4890                                 if (array_type.element_type is StructValueType) {
4891                                         node.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, cleft));
4892                                 } else {
4893                                         node.add_argument (cleft);
4894                                 }
4895                                 set_cvalue (expr, node);
4896                         } else {
4897                                 set_cvalue (expr, new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, new CCodeBinaryExpression (CCodeBinaryOperator.BITWISE_AND, cright, cleft), cleft));
4898                         }
4899                         return;
4900                 } else {
4901                         assert_not_reached ();
4902                 }
4903
4904                 if (expr.operator == BinaryOperator.EQUALITY ||
4905                     expr.operator == BinaryOperator.INEQUALITY) {
4906                         var left_type = expr.left.target_type;
4907                         var right_type = expr.right.target_type;
4908                         make_comparable_cexpression (ref left_type, ref cleft, ref right_type, ref cright);
4909
4910                         if (left_type is StructValueType && right_type is StructValueType) {
4911                                 var equalfunc = generate_struct_equal_function ((Struct) left_type.data_type as Struct);
4912                                 var ccall = new CCodeFunctionCall (new CCodeIdentifier (equalfunc));
4913                                 ccall.add_argument (cleft);
4914                                 ccall.add_argument (cright);
4915                                 cleft = ccall;
4916                                 cright = new CCodeConstant ("TRUE");
4917                         } else if ((left_type is IntegerType || left_type is FloatingType || left_type is BooleanType) && left_type.nullable &&
4918                                    (right_type is IntegerType || right_type is FloatingType || right_type is BooleanType) && right_type.nullable) {
4919                                 var equalfunc = generate_numeric_equal_function ((Struct) left_type.data_type as Struct);
4920                                 var ccall = new CCodeFunctionCall (new CCodeIdentifier (equalfunc));
4921                                 ccall.add_argument (cleft);
4922                                 ccall.add_argument (cright);
4923                                 cleft = ccall;
4924                                 cright = new CCodeConstant ("TRUE");
4925                         }
4926                 }
4927
4928                 if (!(expr.left.value_type is NullType)
4929                     && expr.left.value_type.compatible (string_type)
4930                     && !(expr.right.value_type is NullType)
4931                     && expr.right.value_type.compatible (string_type)) {
4932                         if (expr.operator == BinaryOperator.PLUS) {
4933                                 // string concatenation
4934                                 if (expr.left.is_constant () && expr.right.is_constant ()) {
4935                                         string left, right;
4936
4937                                         if (cleft is CCodeIdentifier) {
4938                                                 left = ((CCodeIdentifier) cleft).name;
4939                                         } else if (cleft is CCodeConstant) {
4940                                                 left = ((CCodeConstant) cleft).name;
4941                                         } else {
4942                                                 assert_not_reached ();
4943                                         }
4944                                         if (cright is CCodeIdentifier) {
4945                                                 right = ((CCodeIdentifier) cright).name;
4946                                         } else if (cright is CCodeConstant) {
4947                                                 right = ((CCodeConstant) cright).name;
4948                                         } else {
4949                                                 assert_not_reached ();
4950                                         }
4951
4952                                         set_cvalue (expr, new CCodeConstant ("%s %s".printf (left, right)));
4953                                         return;
4954                                 } else {
4955                                         if (context.profile == Profile.POSIX) {
4956                                                 // convert to strcat(strcpy(malloc(1+strlen(a)+strlen(b)),a),b)
4957                                                 var strcat = new CCodeFunctionCall (new CCodeIdentifier ("strcat"));
4958                                                 var strcpy = new CCodeFunctionCall (new CCodeIdentifier ("strcpy"));
4959                                                 var malloc = new CCodeFunctionCall (new CCodeIdentifier ("malloc"));
4960
4961                                                 var strlen_a = new CCodeFunctionCall (new CCodeIdentifier ("strlen"));
4962                                                 strlen_a.add_argument(cleft);
4963                                                 var strlen_b = new CCodeFunctionCall (new CCodeIdentifier ("strlen"));
4964                                                 strlen_b.add_argument(cright);
4965                                                 var newlength = new CCodeBinaryExpression (CCodeBinaryOperator.PLUS, new CCodeIdentifier("1"),
4966                                                         new CCodeBinaryExpression (CCodeBinaryOperator.PLUS, strlen_a, strlen_b));
4967                                                 malloc.add_argument(newlength);
4968
4969                                                 strcpy.add_argument(malloc);
4970                                                 strcpy.add_argument(cleft);
4971
4972                                                 strcat.add_argument(strcpy);
4973                                                 strcat.add_argument(cright);
4974                                                 set_cvalue (expr, strcat);
4975                                         } else {
4976                                                 // convert to g_strconcat (a, b, NULL)
4977                                                 var temp_var = get_temp_variable (expr.value_type, true, null, false);
4978                                                 var temp_ref = get_variable_cexpression (temp_var.name);
4979                                                 emit_temp_var (temp_var);
4980
4981                                                 var ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_strconcat"));
4982                                                 ccall.add_argument (cleft);
4983                                                 ccall.add_argument (cright);
4984                                                 ccall.add_argument (new CCodeConstant("NULL"));
4985
4986                                                 ccode.add_assignment (temp_ref, ccall);
4987                                                 set_cvalue (expr, temp_ref);
4988                                         }
4989                                         return;
4990                                 }
4991                         } else if (expr.operator == BinaryOperator.EQUALITY
4992                                    || expr.operator == BinaryOperator.INEQUALITY
4993                                    || expr.operator == BinaryOperator.LESS_THAN
4994                                    || expr.operator == BinaryOperator.GREATER_THAN
4995                                    || expr.operator == BinaryOperator.LESS_THAN_OR_EQUAL
4996                                    || expr.operator == BinaryOperator.GREATER_THAN_OR_EQUAL) {
4997                                 var ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_strcmp0"));
4998                                 ccall.add_argument (cleft);
4999                                 ccall.add_argument (cright);
5000                                 cleft = ccall;
5001                                 cright = new CCodeConstant ("0");
5002                         }
5003                 }
5004
5005                 set_cvalue (expr, new CCodeBinaryExpression (op, cleft, cright));
5006                 if (left_chain != null) {
5007                         set_cvalue (expr, new CCodeBinaryExpression (CCodeBinaryOperator.AND, left_chain, get_cvalue (expr)));
5008                 }
5009         }
5010
5011         public string? get_type_check_function (TypeSymbol type) {
5012                 var cl = type as Class;
5013                 if (cl != null && cl.type_check_function != null) {
5014                         return cl.type_check_function;
5015                 } else if ((cl != null && cl.is_compact) || type is Struct || type is Enum || type is Delegate) {
5016                         return null;
5017                 } else {
5018                         return type.get_upper_case_cname ("IS_");
5019                 }
5020         }
5021
5022         CCodeExpression? create_type_check (CCodeNode ccodenode, DataType type) {
5023                 var et = type as ErrorType;
5024                 if (et != null && et.error_code != null) {
5025                         var matches_call = new CCodeFunctionCall (new CCodeIdentifier ("g_error_matches"));
5026                         matches_call.add_argument ((CCodeExpression) ccodenode);
5027                         matches_call.add_argument (new CCodeIdentifier (et.error_domain.get_upper_case_cname ()));
5028                         matches_call.add_argument (new CCodeIdentifier (et.error_code.get_cname ()));
5029                         return matches_call;
5030                 } else if (et != null && et.error_domain != null) {
5031                         var instance_domain = new CCodeMemberAccess.pointer ((CCodeExpression) ccodenode, "domain");
5032                         var type_domain = new CCodeIdentifier (et.error_domain.get_upper_case_cname ());
5033                         return new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, instance_domain, type_domain);
5034                 } else {
5035                         string type_check_func = get_type_check_function (type.data_type);
5036                         if (type_check_func == null) {
5037                                 return new CCodeInvalidExpression ();
5038                         }
5039                         var ccheck = new CCodeFunctionCall (new CCodeIdentifier (type_check_func));
5040                         ccheck.add_argument ((CCodeExpression) ccodenode);
5041                         return ccheck;
5042                 }
5043         }
5044
5045         string generate_array_contains_wrapper (ArrayType array_type) {
5046                 string array_contains_func = "_vala_%s_array_contains".printf (array_type.element_type.get_lower_case_cname ());
5047
5048                 if (!add_wrapper (array_contains_func)) {
5049                         return array_contains_func;
5050                 }
5051
5052                 var function = new CCodeFunction (array_contains_func, "gboolean");
5053                 function.modifiers = CCodeModifiers.STATIC;
5054
5055                 function.add_parameter (new CCodeParameter ("stack", array_type.get_cname ()));
5056                 function.add_parameter (new CCodeParameter ("stack_length", "int"));
5057                 if (array_type.element_type is StructValueType) {
5058                         function.add_parameter (new CCodeParameter ("needle", array_type.element_type.get_cname () + "*"));
5059                 } else {
5060                         function.add_parameter (new CCodeParameter ("needle", array_type.element_type.get_cname ()));
5061                 }
5062
5063                 push_function (function);
5064
5065                 ccode.add_declaration ("int", new CCodeVariableDeclarator ("i"));
5066
5067                 var cloop_initializer = new CCodeAssignment (new CCodeIdentifier ("i"), new CCodeConstant ("0"));
5068                 var cloop_condition = new CCodeBinaryExpression (CCodeBinaryOperator.LESS_THAN, new CCodeIdentifier ("i"), new CCodeIdentifier ("stack_length"));
5069                 var cloop_iterator = new CCodeUnaryExpression (CCodeUnaryOperator.POSTFIX_INCREMENT, new CCodeIdentifier ("i"));
5070                 ccode.open_for (cloop_initializer, cloop_condition, cloop_iterator);
5071
5072                 var celement = new CCodeElementAccess (new CCodeIdentifier ("stack"), new CCodeIdentifier ("i"));
5073                 var cneedle = new CCodeIdentifier ("needle");
5074                 CCodeBinaryExpression cif_condition;
5075                 if (array_type.element_type.compatible (string_type)) {
5076                         var ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_strcmp0"));
5077                         ccall.add_argument (celement);
5078                         ccall.add_argument (cneedle);
5079                         cif_condition = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, ccall, new CCodeConstant ("0"));
5080                 } else if (array_type.element_type is StructValueType) {
5081                         var equalfunc = generate_struct_equal_function ((Struct) array_type.element_type.data_type as Struct);
5082                         var ccall = new CCodeFunctionCall (new CCodeIdentifier (equalfunc));
5083                         ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, celement));
5084                         ccall.add_argument (cneedle);
5085                         cif_condition = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, ccall, new CCodeConstant ("TRUE"));
5086                 } else {
5087                         cif_condition = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, cneedle, celement);
5088                 }
5089
5090                 ccode.open_if (cif_condition);
5091                 ccode.add_return (new CCodeConstant ("TRUE"));
5092                 ccode.close ();
5093
5094                 ccode.close ();
5095
5096                 ccode.add_return (new CCodeConstant ("FALSE"));
5097
5098                 pop_function ();
5099
5100                 cfile.add_function_declaration (function);
5101                 cfile.add_function (function);
5102
5103                 return array_contains_func;
5104         }
5105
5106         public override void visit_type_check (TypeCheck expr) {
5107                 generate_type_declaration (expr.type_reference, cfile);
5108
5109                 set_cvalue (expr, create_type_check (get_cvalue (expr.expression), expr.type_reference));
5110                 if (get_cvalue (expr) is CCodeInvalidExpression) {
5111                         Report.error (expr.source_reference, "type check expressions not supported for compact classes, structs, and enums");
5112                 }
5113         }
5114
5115         public override void visit_lambda_expression (LambdaExpression lambda) {
5116                 // use instance position from delegate
5117                 var dt = (DelegateType) lambda.target_type;
5118                 lambda.method.cinstance_parameter_position = dt.delegate_symbol.cinstance_parameter_position;
5119
5120                 lambda.accept_children (this);
5121
5122                 bool expr_owned = lambda.value_type.value_owned;
5123
5124                 set_cvalue (lambda, new CCodeIdentifier (lambda.method.get_cname ()));
5125
5126                 var delegate_type = (DelegateType) lambda.target_type;
5127                 if (lambda.method.closure) {
5128                         int block_id = get_block_id (current_closure_block);
5129                         var delegate_target = get_variable_cexpression ("_data%d_".printf (block_id));
5130                         if (expr_owned || delegate_type.is_called_once) {
5131                                 var ref_call = new CCodeFunctionCall (new CCodeIdentifier ("block%d_data_ref".printf (block_id)));
5132                                 ref_call.add_argument (delegate_target);
5133                                 delegate_target = ref_call;
5134                                 set_delegate_target_destroy_notify (lambda, new CCodeIdentifier ("block%d_data_unref".printf (block_id)));
5135                         } else {
5136                                 set_delegate_target_destroy_notify (lambda, new CCodeConstant ("NULL"));
5137                         }
5138                         set_delegate_target (lambda, delegate_target);
5139                 } else if (get_this_type () != null || in_constructor) {
5140                         CCodeExpression delegate_target = get_result_cexpression ("self");
5141                         if (expr_owned || delegate_type.is_called_once) {
5142                                 if (get_this_type () != null) {
5143                                         var ref_call = new CCodeFunctionCall (get_dup_func_expression (get_this_type (), lambda.source_reference));
5144                                         ref_call.add_argument (delegate_target);
5145                                         delegate_target = ref_call;
5146                                         set_delegate_target_destroy_notify (lambda, get_destroy_func_expression (get_this_type ()));
5147                                 } else {
5148                                         // in constructor
5149                                         var ref_call = new CCodeFunctionCall (new CCodeIdentifier ("g_object_ref"));
5150                                         ref_call.add_argument (delegate_target);
5151                                         delegate_target = ref_call;
5152                                         set_delegate_target_destroy_notify (lambda, new CCodeIdentifier ("g_object_unref"));
5153                                 }
5154                         } else {
5155                                 set_delegate_target_destroy_notify (lambda, new CCodeConstant ("NULL"));
5156                         }
5157                         set_delegate_target (lambda, delegate_target);
5158                 } else {
5159                         set_delegate_target (lambda, new CCodeConstant ("NULL"));
5160                         set_delegate_target_destroy_notify (lambda, new CCodeConstant ("NULL"));
5161                 }
5162         }
5163
5164         public CCodeExpression convert_from_generic_pointer (CCodeExpression cexpr, DataType actual_type) {
5165                 var result = cexpr;
5166                 if (is_reference_type_argument (actual_type) || is_nullable_value_type_argument (actual_type)) {
5167                         result = new CCodeCastExpression (cexpr, actual_type.get_cname ());
5168                 } else if (is_signed_integer_type_argument (actual_type)) {
5169                         var cconv = new CCodeFunctionCall (new CCodeIdentifier ("GPOINTER_TO_INT"));
5170                         cconv.add_argument (cexpr);
5171                         result = cconv;
5172                 } else if (is_unsigned_integer_type_argument (actual_type)) {
5173                         var cconv = new CCodeFunctionCall (new CCodeIdentifier ("GPOINTER_TO_UINT"));
5174                         cconv.add_argument (cexpr);
5175                         result = cconv;
5176                 }
5177                 return result;
5178         }
5179
5180         public CCodeExpression convert_to_generic_pointer (CCodeExpression cexpr, DataType actual_type) {
5181                 var result = cexpr;
5182                 if (is_signed_integer_type_argument (actual_type)) {
5183                         var cconv = new CCodeFunctionCall (new CCodeIdentifier ("GINT_TO_POINTER"));
5184                         cconv.add_argument (cexpr);
5185                         result = cconv;
5186                 } else if (is_unsigned_integer_type_argument (actual_type)) {
5187                         var cconv = new CCodeFunctionCall (new CCodeIdentifier ("GUINT_TO_POINTER"));
5188                         cconv.add_argument (cexpr);
5189                         result = cconv;
5190                 }
5191                 return result;
5192         }
5193
5194         // manage memory and implicit casts
5195         public CCodeExpression transform_expression (CCodeExpression source_cexpr, DataType? expression_type, DataType? target_type, Expression? expr = null) {
5196                 var cexpr = source_cexpr;
5197                 if (expression_type == null) {
5198                         return cexpr;
5199                 }
5200
5201
5202                 if (expression_type.value_owned
5203                     && expression_type.floating_reference) {
5204                         /* floating reference, sink it.
5205                          */
5206                         var cl = expression_type.data_type as ObjectTypeSymbol;
5207                         var sink_func = (cl != null) ? cl.get_ref_sink_function () : null;
5208
5209                         if (sink_func != null) {
5210                                 var csink = new CCodeFunctionCall (new CCodeIdentifier (sink_func));
5211                                 csink.add_argument (cexpr);
5212
5213                                 cexpr = csink;
5214                         } else {
5215                                 Report.error (null, "type `%s' does not support floating references".printf (expression_type.data_type.name));
5216                         }
5217                 }
5218
5219                 bool boxing = (expression_type is ValueType && !expression_type.nullable
5220                                && target_type is ValueType && target_type.nullable);
5221                 bool unboxing = (expression_type is ValueType && expression_type.nullable
5222                                  && target_type is ValueType && !target_type.nullable);
5223
5224                 bool gvalue_boxing = (context.profile == Profile.GOBJECT
5225                                       && target_type != null
5226                                       && target_type.data_type == gvalue_type
5227                                       && !(expression_type is NullType)
5228                                       && expression_type.get_type_id () != "G_TYPE_VALUE");
5229                 bool gvariant_boxing = (context.profile == Profile.GOBJECT
5230                                         && target_type != null
5231                                         && target_type.data_type == gvariant_type
5232                                         && !(expression_type is NullType)
5233                                         && expression_type.data_type != gvariant_type);
5234
5235                 if (expression_type.value_owned
5236                     && (target_type == null || !target_type.value_owned || boxing || unboxing)
5237                     && !gvalue_boxing /* gvalue can assume ownership of value, no need to free it */) {
5238                         // value leaked, destroy it
5239                         var pointer_type = target_type as PointerType;
5240                         if (pointer_type != null && !(pointer_type.base_type is VoidType)) {
5241                                 // manual memory management for non-void pointers
5242                                 // treat void* special to not leak memory with void* method parameters
5243                         } else if (requires_destroy (expression_type)) {
5244                                 var decl = get_temp_variable (expression_type, true, expression_type, false);
5245                                 emit_temp_var (decl);
5246                                 temp_ref_vars.insert (0, decl);
5247                                 ccode.add_assignment (get_variable_cexpression (decl.name), cexpr);
5248                                 cexpr = get_variable_cexpression (decl.name);
5249
5250                                 if (expression_type is ArrayType && expr != null) {
5251                                         var array_type = (ArrayType) expression_type;
5252                                         for (int dim = 1; dim <= array_type.rank; dim++) {
5253                                                 var len_decl = new LocalVariable (int_type.copy (), get_array_length_cname (decl.name, dim));
5254                                                 emit_temp_var (len_decl);
5255                                                 ccode.add_assignment (get_variable_cexpression (len_decl.name), get_array_length_cexpression (expr, dim));
5256                                         }
5257                                 } else if (expression_type is DelegateType && expr != null) {
5258                                         var target_decl = new LocalVariable (new PointerType (new VoidType ()), get_delegate_target_cname (decl.name));
5259                                         emit_temp_var (target_decl);
5260                                         var target_destroy_notify_decl = new LocalVariable (gdestroynotify_type, get_delegate_target_destroy_notify_cname (decl.name));
5261                                         emit_temp_var (target_destroy_notify_decl);
5262                                         CCodeExpression target_destroy_notify;
5263                                         ccode.add_assignment (get_variable_cexpression (target_decl.name), get_delegate_target_cexpression (expr, out target_destroy_notify));
5264                                         ccode.add_assignment (get_variable_cexpression (target_destroy_notify_decl.name), target_destroy_notify);
5265
5266                                 }
5267                         }
5268                 }
5269
5270                 if (target_type == null) {
5271                         // value will be destroyed, no need for implicit casts
5272                         return cexpr;
5273                 }
5274
5275                 if (gvalue_boxing) {
5276                         // implicit conversion to GValue
5277                         var decl = get_temp_variable (target_type, true, target_type);
5278                         emit_temp_var (decl);
5279
5280                         if (!target_type.value_owned) {
5281                                 // boxed GValue leaked, destroy it
5282                                 temp_ref_vars.insert (0, decl);
5283                         }
5284
5285                         if (target_type.nullable) {
5286                                 var newcall = new CCodeFunctionCall (new CCodeIdentifier ("g_new0"));
5287                                 newcall.add_argument (new CCodeConstant ("GValue"));
5288                                 newcall.add_argument (new CCodeConstant ("1"));
5289                                 var newassignment = new CCodeAssignment (get_variable_cexpression (decl.name), newcall);
5290                                 ccode.add_expression (newassignment);
5291                         }
5292
5293                         var ccall = new CCodeFunctionCall (new CCodeIdentifier ("g_value_init"));
5294                         if (target_type.nullable) {
5295                                 ccall.add_argument (get_variable_cexpression (decl.name));
5296                         } else {
5297                                 ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_variable_cexpression (decl.name)));
5298                         }
5299                         ccall.add_argument (new CCodeIdentifier (expression_type.get_type_id ()));
5300                         ccode.add_expression (ccall);
5301
5302                         if (requires_destroy (expression_type)) {
5303                                 ccall = new CCodeFunctionCall (get_value_taker_function (expression_type));
5304                         } else {
5305                                 ccall = new CCodeFunctionCall (get_value_setter_function (expression_type));
5306                         }
5307                         if (target_type.nullable) {
5308                                 ccall.add_argument (get_variable_cexpression (decl.name));
5309                         } else {
5310                                 ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_variable_cexpression (decl.name)));
5311                         }
5312                         if (expression_type.is_real_non_null_struct_type ()) {
5313                                 ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, cexpr));
5314                         } else {
5315                                 ccall.add_argument (cexpr);
5316                         }
5317
5318                         ccode.add_expression (ccall);
5319
5320                         cexpr = get_variable_cexpression (decl.name);
5321
5322                         return cexpr;
5323                 } else if (gvariant_boxing) {
5324                         // implicit conversion to GVariant
5325                         string variant_func = "_variant_new%d".printf (++next_variant_function_id);
5326
5327                         var ccall = new CCodeFunctionCall (new CCodeIdentifier (variant_func));
5328                         ccall.add_argument (cexpr);
5329
5330                         var cfunc = new CCodeFunction (variant_func, "GVariant*");
5331                         cfunc.modifiers = CCodeModifiers.STATIC;
5332                         cfunc.add_parameter (new CCodeParameter ("value", expression_type.get_cname ()));
5333
5334                         if (expression_type is ArrayType) {
5335                                 // return array length if appropriate
5336                                 var array_type = (ArrayType) expression_type;
5337
5338                                 for (int dim = 1; dim <= array_type.rank; dim++) {
5339                                         ccall.add_argument (get_array_length_cexpression (expr, dim));
5340                                         cfunc.add_parameter (new CCodeParameter (get_array_length_cname ("value", dim), "gint"));
5341                                 }
5342                         }
5343
5344                         push_function (cfunc);
5345
5346                         var result = serialize_expression (expression_type, new CCodeIdentifier ("value"));
5347
5348                         // sink floating reference
5349                         var sink = new CCodeFunctionCall (new CCodeIdentifier ("g_variant_ref_sink"));
5350                         sink.add_argument (result);
5351                         ccode.add_return (sink);
5352
5353                         pop_function ();
5354
5355                         cfile.add_function_declaration (cfunc);
5356                         cfile.add_function (cfunc);
5357
5358                         return ccall;
5359                 } else if (boxing) {
5360                         // value needs to be boxed
5361
5362                         var unary = cexpr as CCodeUnaryExpression;
5363                         if (unary != null && unary.operator == CCodeUnaryOperator.POINTER_INDIRECTION) {
5364                                 // *expr => expr
5365                                 cexpr = unary.inner;
5366                         } else if (cexpr is CCodeIdentifier || cexpr is CCodeMemberAccess) {
5367                                 cexpr = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, cexpr);
5368                         } else {
5369                                 var decl = get_temp_variable (expression_type, expression_type.value_owned, expression_type, false);
5370                                 emit_temp_var (decl);
5371
5372                                 ccode.add_assignment (get_variable_cexpression (decl.name), cexpr);
5373                                 cexpr = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_variable_cexpression (decl.name));
5374                         }
5375                 } else if (unboxing) {
5376                         // unbox value
5377
5378                         cexpr = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, cexpr);
5379                 } else {
5380                         cexpr = get_implicit_cast_expression (cexpr, expression_type, target_type, expr);
5381                 }
5382
5383                 if (target_type.value_owned && (!expression_type.value_owned || boxing || unboxing)) {
5384                         // need to copy value
5385                         if (requires_copy (target_type) && !(expression_type is NullType)) {
5386                                 CodeNode node = expr;
5387                                 if (node == null) {
5388                                         node = expression_type;
5389                                 }
5390
5391                                 var decl = get_temp_variable (target_type, true, node, false);
5392                                 emit_temp_var (decl);
5393                                 ccode.add_assignment (get_variable_cexpression (decl.name), get_ref_cexpression (target_type, cexpr, expr, node));
5394                                 cexpr = get_variable_cexpression (decl.name);
5395                         }
5396                 }
5397
5398                 return cexpr;
5399         }
5400
5401         public virtual CCodeExpression get_implicit_cast_expression (CCodeExpression source_cexpr, DataType? expression_type, DataType? target_type, Expression? expr = null) {
5402                 var cexpr = source_cexpr;
5403
5404                 if (expression_type.data_type != null && expression_type.data_type == target_type.data_type) {
5405                         // same type, no cast required
5406                         return cexpr;
5407                 }
5408
5409                 if (expression_type is NullType) {
5410                         // null literal, no cast required when not converting to generic type pointer
5411                         return cexpr;
5412                 }
5413
5414                 generate_type_declaration (target_type, cfile);
5415
5416                 var cl = target_type.data_type as Class;
5417                 var iface = target_type.data_type as Interface;
5418                 if (context.checking && (iface != null || (cl != null && !cl.is_compact))) {
5419                         // checked cast for strict subtypes of GTypeInstance
5420                         return generate_instance_cast (cexpr, target_type.data_type);
5421                 } else if (target_type.data_type != null && expression_type.get_cname () != target_type.get_cname ()) {
5422                         var st = target_type.data_type as Struct;
5423                         if (target_type.data_type.is_reference_type () || (st != null && st.is_simple_type ())) {
5424                                 // don't cast non-simple structs
5425                                 return new CCodeCastExpression (cexpr, target_type.get_cname ());
5426                         } else {
5427                                 return cexpr;
5428                         }
5429                 } else {
5430                         return cexpr;
5431                 }
5432         }
5433
5434         public void store_property (Property prop, Expression? instance, TargetValue value) {
5435                 if (instance is BaseAccess) {
5436                         if (prop.base_property != null) {
5437                                 var base_class = (Class) prop.base_property.parent_symbol;
5438                                 var vcast = new CCodeFunctionCall (new CCodeIdentifier ("%s_CLASS".printf (base_class.get_upper_case_cname (null))));
5439                                 vcast.add_argument (new CCodeIdentifier ("%s_parent_class".printf (current_class.get_lower_case_cname (null))));
5440
5441                                 var ccall = new CCodeFunctionCall (new CCodeMemberAccess.pointer (vcast, "set_%s".printf (prop.name)));
5442                                 ccall.add_argument ((CCodeExpression) get_ccodenode (instance));
5443                                 ccall.add_argument (get_cvalue_ (value));
5444
5445                                 ccode.add_expression (ccall);
5446                         } else if (prop.base_interface_property != null) {
5447                                 var base_iface = (Interface) prop.base_interface_property.parent_symbol;
5448                                 string parent_iface_var = "%s_%s_parent_iface".printf (current_class.get_lower_case_cname (null), base_iface.get_lower_case_cname (null));
5449
5450                                 var ccall = new CCodeFunctionCall (new CCodeMemberAccess.pointer (new CCodeIdentifier (parent_iface_var), "set_%s".printf (prop.name)));
5451                                 ccall.add_argument ((CCodeExpression) get_ccodenode (instance));
5452                                 ccall.add_argument (get_cvalue_ (value));
5453
5454                                 ccode.add_expression (ccall);
5455                         }
5456                         return;
5457                 }
5458
5459                 var set_func = "g_object_set";
5460
5461                 var base_property = prop;
5462                 if (!prop.no_accessor_method) {
5463                         if (prop.base_property != null) {
5464                                 base_property = prop.base_property;
5465                         } else if (prop.base_interface_property != null) {
5466                                 base_property = prop.base_interface_property;
5467                         }
5468
5469                         if (prop is DynamicProperty) {
5470                                 set_func = get_dynamic_property_setter_cname ((DynamicProperty) prop);
5471                         } else {
5472                                 generate_property_accessor_declaration (base_property.set_accessor, cfile);
5473                                 set_func = base_property.set_accessor.get_cname ();
5474
5475                                 if (!prop.external && prop.external_package) {
5476                                         // internal VAPI properties
5477                                         // only add them once per source file
5478                                         if (add_generated_external_symbol (prop)) {
5479                                                 visit_property (prop);
5480                                         }
5481                                 }
5482                         }
5483                 }
5484
5485                 var ccall = new CCodeFunctionCall (new CCodeIdentifier (set_func));
5486
5487                 if (prop.binding == MemberBinding.INSTANCE) {
5488                         /* target instance is first argument */
5489                         var cinstance = (CCodeExpression) get_ccodenode (instance);
5490
5491                         if (prop.parent_symbol is Struct) {
5492                                 // we need to pass struct instance by reference
5493                                 var unary = cinstance as CCodeUnaryExpression;
5494                                 if (unary != null && unary.operator == CCodeUnaryOperator.POINTER_INDIRECTION) {
5495                                         // *expr => expr
5496                                         cinstance = unary.inner;
5497                                 } else if (cinstance is CCodeIdentifier || cinstance is CCodeMemberAccess) {
5498                                         cinstance = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, cinstance);
5499                                 } else {
5500                                         // if instance is e.g. a function call, we can't take the address of the expression
5501                                         // (tmp = expr, &tmp)
5502
5503                                         var temp_var = get_temp_variable (instance.target_type, true, null, false);
5504                                         emit_temp_var (temp_var);
5505                                         ccode.add_assignment (get_variable_cexpression (temp_var.name), cinstance);
5506
5507                                         cinstance = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_variable_cexpression (temp_var.name));
5508                                 }
5509                         }
5510
5511                         ccall.add_argument (cinstance);
5512                 }
5513
5514                 if (prop.no_accessor_method) {
5515                         /* property name is second argument of g_object_set */
5516                         ccall.add_argument (prop.get_canonical_cconstant ());
5517                 }
5518
5519                 var cexpr = get_cvalue_ (value);
5520
5521                 if (prop.property_type.is_real_non_null_struct_type ()) {
5522                         cexpr = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, cexpr);
5523                 }
5524
5525                 var array_type = prop.property_type as ArrayType;
5526
5527                 if (array_type != null && !prop.no_array_length) {
5528                         var temp_var = get_temp_variable (prop.property_type, true, null, false);
5529                         emit_temp_var (temp_var);
5530                         ccode.add_assignment (get_variable_cexpression (temp_var.name), cexpr);
5531                         ccall.add_argument (get_variable_cexpression (temp_var.name));
5532                 } else {
5533                         ccall.add_argument (cexpr);
5534                 }
5535
5536                 if (array_type != null && !prop.no_array_length) {
5537                         for (int dim = 1; dim <= array_type.rank; dim++) {
5538                                 ccall.add_argument (get_array_length_cvalue (value, dim));
5539                         }
5540                 } else if (prop.property_type is DelegateType) {
5541                         var delegate_type = (DelegateType) prop.property_type;
5542                         if (delegate_type.delegate_symbol.has_target) {
5543                                 ccall.add_argument (get_delegate_target_cvalue (value));
5544                         }
5545                 }
5546
5547                 if (prop.no_accessor_method) {
5548                         ccall.add_argument (new CCodeConstant ("NULL"));
5549                 }
5550
5551                 ccode.add_expression (ccall);
5552         }
5553
5554         public bool add_wrapper (string wrapper_name) {
5555                 return wrappers.add (wrapper_name);
5556         }
5557
5558         public bool add_generated_external_symbol (Symbol external_symbol) {
5559                 return generated_external_symbols.add (external_symbol);
5560         }
5561
5562         public static DataType get_data_type_for_symbol (TypeSymbol sym) {
5563                 DataType type = null;
5564
5565                 if (sym is Class) {
5566                         type = new ObjectType ((Class) sym);
5567                 } else if (sym is Interface) {
5568                         type = new ObjectType ((Interface) sym);
5569                 } else if (sym is Struct) {
5570                         var st = (Struct) sym;
5571                         if (st.is_boolean_type ()) {
5572                                 type = new BooleanType (st);
5573                         } else if (st.is_integer_type ()) {
5574                                 type = new IntegerType (st);
5575                         } else if (st.is_floating_type ()) {
5576                                 type = new FloatingType (st);
5577                         } else {
5578                                 type = new StructValueType (st);
5579                         }
5580                 } else if (sym is Enum) {
5581                         type = new EnumValueType ((Enum) sym);
5582                 } else if (sym is ErrorDomain) {
5583                         type = new ErrorType ((ErrorDomain) sym, null);
5584                 } else if (sym is ErrorCode) {
5585                         type = new ErrorType ((ErrorDomain) sym.parent_symbol, (ErrorCode) sym);
5586                 } else {
5587                         Report.error (null, "internal error: `%s' is not a supported type".printf (sym.get_full_name ()));
5588                         return new InvalidType ();
5589                 }
5590
5591                 return type;
5592         }
5593
5594         public CCodeExpression? default_value_for_type (DataType type, bool initializer_expression) {
5595                 var st = type.data_type as Struct;
5596                 var array_type = type as ArrayType;
5597                 if (initializer_expression && !type.nullable &&
5598                     ((st != null && !st.is_simple_type ()) ||
5599                      (array_type != null && array_type.fixed_length))) {
5600                         // 0-initialize struct with struct initializer { 0 }
5601                         // only allowed as initializer expression in C
5602                         var clist = new CCodeInitializerList ();
5603                         clist.append (new CCodeConstant ("0"));
5604                         return clist;
5605                 } else if ((type.data_type != null && type.data_type.is_reference_type ())
5606                            || type.nullable
5607                            || type is PointerType || type is DelegateType
5608                            || (array_type != null && !array_type.fixed_length)) {
5609                         return new CCodeConstant ("NULL");
5610                 } else if (type.data_type != null && type.data_type.get_default_value () != null) {
5611                         return new CCodeConstant (type.data_type.get_default_value ());
5612                 } else if (type.type_parameter != null) {
5613                         return new CCodeConstant ("NULL");
5614                 } else if (type is ErrorType) {
5615                         return new CCodeConstant ("NULL");
5616                 }
5617                 return null;
5618         }
5619
5620         private void create_property_type_check_statement (Property prop, bool check_return_type, TypeSymbol t, bool non_null, string var_name) {
5621                 if (check_return_type) {
5622                         create_type_check_statement (prop, prop.property_type, t, non_null, var_name);
5623                 } else {
5624                         create_type_check_statement (prop, new VoidType (), t, non_null, var_name);
5625                 }
5626         }
5627
5628         public void create_type_check_statement (CodeNode method_node, DataType ret_type, TypeSymbol t, bool non_null, string var_name) {
5629                 var ccheck = new CCodeFunctionCall ();
5630
5631                 if (!context.assert) {
5632                         return;
5633                 } else if (context.checking && ((t is Class && !((Class) t).is_compact) || t is Interface)) {
5634                         var ctype_check = new CCodeFunctionCall (new CCodeIdentifier (get_type_check_function (t)));
5635                         ctype_check.add_argument (new CCodeIdentifier (var_name));
5636
5637                         CCodeExpression cexpr = ctype_check;
5638                         if (!non_null) {
5639                                 var cnull = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, new CCodeIdentifier (var_name), new CCodeConstant ("NULL"));
5640
5641                                 cexpr = new CCodeBinaryExpression (CCodeBinaryOperator.OR, cnull, ctype_check);
5642                         }
5643                         ccheck.add_argument (cexpr);
5644                 } else if (!non_null) {
5645                         return;
5646                 } else if (t == glist_type || t == gslist_type) {
5647                         // NULL is empty list
5648                         return;
5649                 } else {
5650                         var cnonnull = new CCodeBinaryExpression (CCodeBinaryOperator.INEQUALITY, new CCodeIdentifier (var_name), new CCodeConstant ("NULL"));
5651                         ccheck.add_argument (cnonnull);
5652                 }
5653
5654                 var cm = method_node as CreationMethod;
5655                 if (cm != null && cm.parent_symbol is ObjectTypeSymbol) {
5656                         ccheck.call = new CCodeIdentifier ("g_return_val_if_fail");
5657                         ccheck.add_argument (new CCodeConstant ("NULL"));
5658                 } else if (ret_type is VoidType) {
5659                         /* void function */
5660                         ccheck.call = new CCodeIdentifier ("g_return_if_fail");
5661                 } else {
5662                         ccheck.call = new CCodeIdentifier ("g_return_val_if_fail");
5663
5664                         var cdefault = default_value_for_type (ret_type, false);
5665                         if (cdefault != null) {
5666                                 ccheck.add_argument (cdefault);
5667                         } else {
5668                                 return;
5669                         }
5670                 }
5671
5672                 ccode.add_expression (ccheck);
5673         }
5674
5675         public int get_param_pos (double param_pos, bool ellipsis = false) {
5676                 if (!ellipsis) {
5677                         if (param_pos >= 0) {
5678                                 return (int) (param_pos * 1000);
5679                         } else {
5680                                 return (int) ((100 + param_pos) * 1000);
5681                         }
5682                 } else {
5683                         if (param_pos >= 0) {
5684                                 return (int) ((100 + param_pos) * 1000);
5685                         } else {
5686                                 return (int) ((200 + param_pos) * 1000);
5687                         }
5688                 }
5689         }
5690
5691         public CCodeExpression? get_ccodenode (Expression node) {
5692                 if (get_cvalue (node) == null) {
5693                         node.emit (this);
5694                 }
5695                 return get_cvalue (node);
5696         }
5697
5698         public override void visit_class (Class cl) {
5699         }
5700
5701         public void create_postcondition_statement (Expression postcondition) {
5702                 var cassert = new CCodeFunctionCall (new CCodeIdentifier ("g_warn_if_fail"));
5703
5704                 postcondition.emit (this);
5705
5706                 cassert.add_argument (get_cvalue (postcondition));
5707
5708                 ccode.add_expression (cassert);
5709         }
5710
5711         public virtual bool is_gobject_property (Property prop) {
5712                 return false;
5713         }
5714
5715         public DataType? get_this_type () {
5716                 if (current_method != null && current_method.binding == MemberBinding.INSTANCE) {
5717                         return current_method.this_parameter.variable_type;
5718                 } else if (current_property_accessor != null && current_property_accessor.prop.binding == MemberBinding.INSTANCE) {
5719                         return current_property_accessor.prop.this_parameter.variable_type;
5720                 }
5721                 return null;
5722         }
5723
5724         public CCodeFunctionCall generate_instance_cast (CCodeExpression expr, TypeSymbol type) {
5725                 var result = new CCodeFunctionCall (new CCodeIdentifier (type.get_upper_case_cname (null)));
5726                 result.add_argument (expr);
5727                 return result;
5728         }
5729
5730         void generate_struct_destroy_function (Struct st) {
5731                 if (cfile.add_declaration (st.get_destroy_function ())) {
5732                         // only generate function once per source file
5733                         return;
5734                 }
5735
5736                 var function = new CCodeFunction (st.get_destroy_function (), "void");
5737                 function.modifiers = CCodeModifiers.STATIC;
5738                 function.add_parameter (new CCodeParameter ("self", st.get_cname () + "*"));
5739
5740                 push_function (function);
5741
5742                 foreach (Field f in st.get_fields ()) {
5743                         if (f.binding == MemberBinding.INSTANCE) {
5744                                 if (requires_destroy (f.variable_type)) {
5745                                         var this_access = new MemberAccess.simple ("this");
5746                                         this_access.value_type = get_data_type_for_symbol ((TypeSymbol) f.parent_symbol);
5747                                         set_cvalue (this_access, new CCodeIdentifier ("(*self)"));
5748
5749                                         ccode.add_expression (destroy_field (f, this_access.target_value));
5750                                 }
5751                         }
5752                 }
5753
5754                 pop_function ();
5755
5756                 cfile.add_function_declaration (function);
5757                 cfile.add_function (function);
5758         }
5759
5760         void generate_struct_copy_function (Struct st) {
5761                 if (cfile.add_declaration (st.get_copy_function ())) {
5762                         // only generate function once per source file
5763                         return;
5764                 }
5765
5766                 var function = new CCodeFunction (st.get_copy_function (), "void");
5767                 function.modifiers = CCodeModifiers.STATIC;
5768                 function.add_parameter (new CCodeParameter ("self", "const " + st.get_cname () + "*"));
5769                 function.add_parameter (new CCodeParameter ("dest", st.get_cname () + "*"));
5770
5771                 push_context (new EmitContext ());
5772                 push_function (function);
5773
5774                 foreach (Field f in st.get_fields ()) {
5775                         if (f.binding == MemberBinding.INSTANCE) {
5776                                 CCodeExpression copy = new CCodeMemberAccess.pointer (new CCodeIdentifier ("self"), f.name);
5777                                 if (requires_copy (f.variable_type))  {
5778                                         var this_access = new MemberAccess.simple ("this");
5779                                         this_access.value_type = get_data_type_for_symbol ((TypeSymbol) f.parent_symbol);
5780                                         set_cvalue (this_access, new CCodeIdentifier ("(*self)"));
5781                                         var ma = new MemberAccess (this_access, f.name);
5782                                         ma.symbol_reference = f;
5783                                         ma.value_type = f.variable_type.copy ();
5784                                         visit_member_access (ma);
5785                                         copy = get_ref_cexpression (f.variable_type, copy, ma, f);
5786                                 }
5787                                 var dest = new CCodeMemberAccess.pointer (new CCodeIdentifier ("dest"), f.name);
5788
5789                                 var array_type = f.variable_type as ArrayType;
5790                                 if (array_type != null && array_type.fixed_length) {
5791                                         // fixed-length (stack-allocated) arrays
5792                                         cfile.add_include ("string.h");
5793
5794                                         var sizeof_call = new CCodeFunctionCall (new CCodeIdentifier ("sizeof"));
5795                                         sizeof_call.add_argument (new CCodeIdentifier (array_type.element_type.get_cname ()));
5796                                         var size = new CCodeBinaryExpression (CCodeBinaryOperator.MUL, new CCodeConstant ("%d".printf (array_type.length)), sizeof_call);
5797
5798                                         var array_copy_call = new CCodeFunctionCall (new CCodeIdentifier ("memcpy"));
5799                                         array_copy_call.add_argument (dest);
5800                                         array_copy_call.add_argument (copy);
5801                                         array_copy_call.add_argument (size);
5802                                         ccode.add_expression (array_copy_call);
5803                                 } else {
5804                                         ccode.add_assignment (dest, copy);
5805
5806                                         if (array_type != null && !f.no_array_length) {
5807                                                 for (int dim = 1; dim <= array_type.rank; dim++) {
5808                                                         var len_src = new CCodeMemberAccess.pointer (new CCodeIdentifier ("self"), get_array_length_cname (f.name, dim));
5809                                                         var len_dest = new CCodeMemberAccess.pointer (new CCodeIdentifier ("dest"), get_array_length_cname (f.name, dim));
5810                                                         ccode.add_assignment (len_dest, len_src);
5811                                                 }
5812                                         }
5813                                 }
5814                         }
5815                 }
5816
5817                 pop_function ();
5818                 pop_context ();
5819
5820                 cfile.add_function_declaration (function);
5821                 cfile.add_function (function);
5822         }
5823
5824         public void return_default_value (DataType return_type) {
5825                 ccode.add_return (default_value_for_type (return_type, false));
5826         }
5827
5828         public virtual string? get_custom_creturn_type (Method m) {
5829                 return null;
5830         }
5831
5832         public virtual void generate_dynamic_method_wrapper (DynamicMethod method) {
5833         }
5834
5835         public virtual bool method_has_wrapper (Method method) {
5836                 return false;
5837         }
5838
5839         public virtual CCodeFunctionCall get_param_spec (Property prop) {
5840                 return new CCodeFunctionCall (new CCodeIdentifier (""));
5841         }
5842
5843         public virtual CCodeFunctionCall get_signal_creation (Signal sig, TypeSymbol type) {
5844                 return new CCodeFunctionCall (new CCodeIdentifier (""));
5845         }
5846
5847         public virtual void register_dbus_info (CCodeBlock block, ObjectTypeSymbol bindable) {
5848         }
5849
5850         public virtual string get_dynamic_property_getter_cname (DynamicProperty node) {
5851                 Report.error (node.source_reference, "dynamic properties are not supported for %s".printf (node.dynamic_type.to_string ()));
5852                 return "";
5853         }
5854
5855         public virtual string get_dynamic_property_setter_cname (DynamicProperty node) {
5856                 Report.error (node.source_reference, "dynamic properties are not supported for %s".printf (node.dynamic_type.to_string ()));
5857                 return "";
5858         }
5859
5860         public virtual string get_dynamic_signal_cname (DynamicSignal node) {
5861                 return "";
5862         }
5863
5864         public virtual string get_dynamic_signal_connect_wrapper_name (DynamicSignal node) {
5865                 return "";
5866         }
5867
5868         public virtual string get_dynamic_signal_connect_after_wrapper_name (DynamicSignal node) {
5869                 return "";
5870         }
5871
5872         public virtual string get_dynamic_signal_disconnect_wrapper_name (DynamicSignal node) {
5873                 return "";
5874         }
5875
5876         public virtual void generate_marshaller (List<Parameter> params, DataType return_type, bool dbus = false) {
5877         }
5878
5879         public virtual string get_marshaller_function (List<Parameter> params, DataType return_type, string? prefix = null, bool dbus = false) {
5880                 return "";
5881         }
5882
5883         public virtual string get_array_length_cname (string array_cname, int dim) {
5884                 return "";
5885         }
5886
5887         public virtual string get_parameter_array_length_cname (Parameter param, int dim) {
5888                 return "";
5889         }
5890
5891         public virtual CCodeExpression get_array_length_cexpression (Expression array_expr, int dim = -1) {
5892                 return new CCodeConstant ("");
5893         }
5894
5895         public virtual CCodeExpression get_array_length_cvalue (TargetValue value, int dim = -1) {
5896                 return new CCodeInvalidExpression ();
5897         }
5898
5899         public virtual string get_array_size_cname (string array_cname) {
5900                 return "";
5901         }
5902
5903         public virtual void add_simple_check (CodeNode node, bool always_fails = false) {
5904         }
5905
5906         public virtual string generate_ready_function (Method m) {
5907                 return "";
5908         }
5909
5910         public CCodeExpression? get_cvalue (Expression expr) {
5911                 if (expr.target_value == null) {
5912                         return null;
5913                 }
5914                 var glib_value = (GLibValue) expr.target_value;
5915                 return glib_value.cvalue;
5916         }
5917
5918         public CCodeExpression? get_cvalue_ (TargetValue value) {
5919                 var glib_value = (GLibValue) value;
5920                 return glib_value.cvalue;
5921         }
5922
5923         public void set_cvalue (Expression expr, CCodeExpression? cvalue) {
5924                 var glib_value = (GLibValue) expr.target_value;
5925                 if (glib_value == null) {
5926                         glib_value = new GLibValue (expr.value_type);
5927                         expr.target_value = glib_value;
5928                 }
5929                 glib_value.cvalue = cvalue;
5930         }
5931
5932         public CCodeExpression? get_array_size_cvalue (TargetValue value) {
5933                 var glib_value = (GLibValue) value;
5934                 return glib_value.array_size_cvalue;
5935         }
5936
5937         public void set_array_size_cvalue (TargetValue value, CCodeExpression? cvalue) {
5938                 var glib_value = (GLibValue) value;
5939                 glib_value.array_size_cvalue = cvalue;
5940         }
5941
5942         public CCodeExpression? get_delegate_target (Expression expr) {
5943                 if (expr.target_value == null) {
5944                         return null;
5945                 }
5946                 var glib_value = (GLibValue) expr.target_value;
5947                 return glib_value.delegate_target_cvalue;
5948         }
5949
5950         public void set_delegate_target (Expression expr, CCodeExpression? delegate_target) {
5951                 var glib_value = (GLibValue) expr.target_value;
5952                 if (glib_value == null) {
5953                         glib_value = new GLibValue (expr.value_type);
5954                         expr.target_value = glib_value;
5955                 }
5956                 glib_value.delegate_target_cvalue = delegate_target;
5957         }
5958
5959         public CCodeExpression? get_delegate_target_destroy_notify (Expression expr) {
5960                 if (expr.target_value == null) {
5961                         return null;
5962                 }
5963                 var glib_value = (GLibValue) expr.target_value;
5964                 return glib_value.delegate_target_destroy_notify_cvalue;
5965         }
5966
5967         public void set_delegate_target_destroy_notify (Expression expr, CCodeExpression? destroy_notify) {
5968                 var glib_value = (GLibValue) expr.target_value;
5969                 if (glib_value == null) {
5970                         glib_value = new GLibValue (expr.value_type);
5971                         expr.target_value = glib_value;
5972                 }
5973                 glib_value.delegate_target_destroy_notify_cvalue = destroy_notify;
5974         }
5975
5976         public void append_array_length (Expression expr, CCodeExpression size) {
5977                 var glib_value = (GLibValue) expr.target_value;
5978                 if (glib_value == null) {
5979                         glib_value = new GLibValue (expr.value_type);
5980                         expr.target_value = glib_value;
5981                 }
5982                 glib_value.append_array_length_cvalue (size);
5983         }
5984
5985         public List<CCodeExpression>? get_array_lengths (Expression expr) {
5986                 var glib_value = (GLibValue) expr.target_value;
5987                 if (glib_value == null) {
5988                         glib_value = new GLibValue (expr.value_type);
5989                         expr.target_value = glib_value;
5990                 }
5991                 return glib_value.array_length_cvalues;
5992         }
5993 }
5994
5995 public class Vala.GLibValue : TargetValue {
5996         public CCodeExpression cvalue;
5997
5998         public List<CCodeExpression> array_length_cvalues;
5999         public CCodeExpression? array_size_cvalue;
6000
6001         public CCodeExpression? delegate_target_cvalue;
6002         public CCodeExpression? delegate_target_destroy_notify_cvalue;
6003
6004         public GLibValue (DataType? value_type = null, CCodeExpression? cvalue = null) {
6005                 base (value_type);
6006                 this.cvalue = cvalue;
6007         }
6008
6009         public void append_array_length_cvalue (CCodeExpression length_cvalue) {
6010                 if (array_length_cvalues == null) {
6011                         array_length_cvalues = new ArrayList<CCodeExpression> ();
6012                 }
6013                 array_length_cvalues.add (length_cvalue);
6014         }
6015 }