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