Logo Search packages:      
Sourcecode: vala-0.14 version File versions  Download package

valatyperegisterfunction.c

/* valatyperegisterfunction.c generated by valac, the Vala compiler
 * generated from valatyperegisterfunction.vala, do not modify */

/* valatyperegisterfunction.vala
 *
 * Copyright (C) 2006-2010  Jürg Billeter
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.

 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.

 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 *
 * Author:
 *    Jürg Billeter <j@bitron.ch>
 */

#include <glib.h>
#include <glib-object.h>
#include <vala.h>
#include <stdlib.h>
#include <string.h>
#include <valaccode.h>
#include <valagee.h>
#include <gobject/gvaluecollector.h>


#define VALA_TYPE_TYPEREGISTER_FUNCTION (vala_typeregister_function_get_type ())
#define VALA_TYPEREGISTER_FUNCTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), VALA_TYPE_TYPEREGISTER_FUNCTION, ValaTypeRegisterFunction))
#define VALA_TYPEREGISTER_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), VALA_TYPE_TYPEREGISTER_FUNCTION, ValaTypeRegisterFunctionClass))
#define VALA_IS_TYPEREGISTER_FUNCTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), VALA_TYPE_TYPEREGISTER_FUNCTION))
#define VALA_IS_TYPEREGISTER_FUNCTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), VALA_TYPE_TYPEREGISTER_FUNCTION))
#define VALA_TYPEREGISTER_FUNCTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), VALA_TYPE_TYPEREGISTER_FUNCTION, ValaTypeRegisterFunctionClass))

typedef struct _ValaTypeRegisterFunction ValaTypeRegisterFunction;
typedef struct _ValaTypeRegisterFunctionClass ValaTypeRegisterFunctionClass;
typedef struct _ValaTypeRegisterFunctionPrivate ValaTypeRegisterFunctionPrivate;
#define _vala_ccode_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_ccode_node_unref (var), NULL)))
#define _vala_code_context_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_context_unref (var), NULL)))
#define _g_free0(var) (var = (g_free (var), NULL))
#define _vala_code_node_unref0(var) ((var == NULL) ? NULL : (var = (vala_code_node_unref (var), NULL)))
#define _vala_iterable_unref0(var) ((var == NULL) ? NULL : (var = (vala_iterable_unref (var), NULL)))
typedef struct _ValaParamSpecTypeRegisterFunction ValaParamSpecTypeRegisterFunction;

struct _ValaTypeRegisterFunction {
      GTypeInstance parent_instance;
      volatile int ref_count;
      ValaTypeRegisterFunctionPrivate * priv;
};

struct _ValaTypeRegisterFunctionClass {
      GTypeClass parent_class;
      void (*finalize) (ValaTypeRegisterFunction *self);
      ValaTypeSymbol* (*get_type_declaration) (ValaTypeRegisterFunction* self);
      gchar* (*get_type_struct_name) (ValaTypeRegisterFunction* self);
      gchar* (*get_base_init_func_name) (ValaTypeRegisterFunction* self);
      gchar* (*get_class_finalize_func_name) (ValaTypeRegisterFunction* self);
      gchar* (*get_base_finalize_func_name) (ValaTypeRegisterFunction* self);
      gchar* (*get_class_init_func_name) (ValaTypeRegisterFunction* self);
      gchar* (*get_instance_struct_size) (ValaTypeRegisterFunction* self);
      gchar* (*get_instance_init_func_name) (ValaTypeRegisterFunction* self);
      gchar* (*get_parent_type_name) (ValaTypeRegisterFunction* self);
      gchar* (*get_gtype_value_table_init_function_name) (ValaTypeRegisterFunction* self);
      gchar* (*get_gtype_value_table_peek_pointer_function_name) (ValaTypeRegisterFunction* self);
      gchar* (*get_gtype_value_table_free_function_name) (ValaTypeRegisterFunction* self);
      gchar* (*get_gtype_value_table_copy_function_name) (ValaTypeRegisterFunction* self);
      gchar* (*get_gtype_value_table_lcopy_value_function_name) (ValaTypeRegisterFunction* self);
      gchar* (*get_gtype_value_table_collect_value_function_name) (ValaTypeRegisterFunction* self);
      gchar* (*get_type_flags) (ValaTypeRegisterFunction* self);
      ValaCCodeFragment* (*get_type_interface_init_declaration) (ValaTypeRegisterFunction* self);
      void (*get_type_interface_init_statements) (ValaTypeRegisterFunction* self, ValaCCodeBlock* block, gboolean plugin);
      ValaSymbolAccessibility (*get_accessibility) (ValaTypeRegisterFunction* self);
};

00083 struct _ValaTypeRegisterFunctionPrivate {
      ValaCCodeFragment* source_declaration_fragment;
      ValaCCodeFragment* declaration_fragment;
      ValaCCodeFragment* definition_fragment;
      ValaCodeContext* _context;
};

00090 struct _ValaParamSpecTypeRegisterFunction {
      GParamSpec parent_instance;
};


static gpointer vala_typeregister_function_parent_class = NULL;

gpointer vala_typeregister_function_ref (gpointer instance);
void vala_typeregister_function_unref (gpointer instance);
GParamSpec* vala_param_spec_typeregister_function (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void vala_value_set_typeregister_function (GValue* value, gpointer v_object);
void vala_value_take_typeregister_function (GValue* value, gpointer v_object);
gpointer vala_value_get_typeregister_function (const GValue* value);
GType vala_typeregister_function_get_type (void) G_GNUC_CONST;
#define VALA_TYPEREGISTER_FUNCTION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), VALA_TYPE_TYPEREGISTER_FUNCTION, ValaTypeRegisterFunctionPrivate))
enum  {
      VALA_TYPEREGISTER_FUNCTION_DUMMY_PROPERTY
};
void vala_typeregister_function_init_from_type (ValaTypeRegisterFunction* self, gboolean plugin, gboolean declaration_only);
ValaTypeSymbol* vala_typeregister_function_get_type_declaration (ValaTypeRegisterFunction* self);
ValaSymbolAccessibility vala_typeregister_function_get_accessibility (ValaTypeRegisterFunction* self);
gchar* vala_typeregister_function_get_gtype_value_table_init_function_name (ValaTypeRegisterFunction* self);
gchar* vala_typeregister_function_get_gtype_value_table_free_function_name (ValaTypeRegisterFunction* self);
gchar* vala_typeregister_function_get_gtype_value_table_copy_function_name (ValaTypeRegisterFunction* self);
gchar* vala_typeregister_function_get_gtype_value_table_peek_pointer_function_name (ValaTypeRegisterFunction* self);
gchar* vala_typeregister_function_get_gtype_value_table_collect_value_function_name (ValaTypeRegisterFunction* self);
gchar* vala_typeregister_function_get_gtype_value_table_lcopy_value_function_name (ValaTypeRegisterFunction* self);
gchar* vala_typeregister_function_get_base_finalize_func_name (ValaTypeRegisterFunction* self);
gchar* vala_typeregister_function_get_type_struct_name (ValaTypeRegisterFunction* self);
gchar* vala_typeregister_function_get_base_init_func_name (ValaTypeRegisterFunction* self);
gchar* vala_typeregister_function_get_class_init_func_name (ValaTypeRegisterFunction* self);
gchar* vala_typeregister_function_get_class_finalize_func_name (ValaTypeRegisterFunction* self);
gchar* vala_typeregister_function_get_instance_struct_size (ValaTypeRegisterFunction* self);
gchar* vala_typeregister_function_get_instance_init_func_name (ValaTypeRegisterFunction* self);
ValaCCodeFragment* vala_typeregister_function_get_type_interface_init_declaration (ValaTypeRegisterFunction* self);
ValaCodeContext* vala_typeregister_function_get_context (ValaTypeRegisterFunction* self);
gchar* vala_typeregister_function_get_parent_type_name (ValaTypeRegisterFunction* self);
gchar* vala_typeregister_function_get_type_flags (ValaTypeRegisterFunction* self);
void vala_typeregister_function_get_type_interface_init_statements (ValaTypeRegisterFunction* self, ValaCCodeBlock* block, gboolean plugin);
static ValaTypeSymbol* vala_typeregister_function_real_get_type_declaration (ValaTypeRegisterFunction* self);
static gchar* vala_typeregister_function_real_get_type_struct_name (ValaTypeRegisterFunction* self);
static gchar* vala_typeregister_function_real_get_base_init_func_name (ValaTypeRegisterFunction* self);
static gchar* vala_typeregister_function_real_get_class_finalize_func_name (ValaTypeRegisterFunction* self);
static gchar* vala_typeregister_function_real_get_base_finalize_func_name (ValaTypeRegisterFunction* self);
static gchar* vala_typeregister_function_real_get_class_init_func_name (ValaTypeRegisterFunction* self);
static gchar* vala_typeregister_function_real_get_instance_struct_size (ValaTypeRegisterFunction* self);
static gchar* vala_typeregister_function_real_get_instance_init_func_name (ValaTypeRegisterFunction* self);
static gchar* vala_typeregister_function_real_get_parent_type_name (ValaTypeRegisterFunction* self);
static gchar* vala_typeregister_function_real_get_gtype_value_table_init_function_name (ValaTypeRegisterFunction* self);
static gchar* vala_typeregister_function_real_get_gtype_value_table_peek_pointer_function_name (ValaTypeRegisterFunction* self);
static gchar* vala_typeregister_function_real_get_gtype_value_table_free_function_name (ValaTypeRegisterFunction* self);
static gchar* vala_typeregister_function_real_get_gtype_value_table_copy_function_name (ValaTypeRegisterFunction* self);
static gchar* vala_typeregister_function_real_get_gtype_value_table_lcopy_value_function_name (ValaTypeRegisterFunction* self);
static gchar* vala_typeregister_function_real_get_gtype_value_table_collect_value_function_name (ValaTypeRegisterFunction* self);
static gchar* vala_typeregister_function_real_get_type_flags (ValaTypeRegisterFunction* self);
static ValaCCodeFragment* vala_typeregister_function_real_get_type_interface_init_declaration (ValaTypeRegisterFunction* self);
static void vala_typeregister_function_real_get_type_interface_init_statements (ValaTypeRegisterFunction* self, ValaCCodeBlock* block, gboolean plugin);
ValaCCodeFragment* vala_typeregister_function_get_source_declaration (ValaTypeRegisterFunction* self);
ValaCCodeFragment* vala_typeregister_function_get_declaration (ValaTypeRegisterFunction* self);
ValaCCodeFragment* vala_typeregister_function_get_definition (ValaTypeRegisterFunction* self);
static ValaSymbolAccessibility vala_typeregister_function_real_get_accessibility (ValaTypeRegisterFunction* self);
ValaTypeRegisterFunction* vala_typeregister_function_construct (GType object_type);
void vala_typeregister_function_set_context (ValaTypeRegisterFunction* self, ValaCodeContext* value);
static void vala_typeregister_function_finalize (ValaTypeRegisterFunction* obj);


/**
 * Constructs the C function from the specified type.
 */
static gpointer _vala_ccode_node_ref0 (gpointer self) {
      return self ? vala_ccode_node_ref (self) : NULL;
}


void vala_typeregister_function_init_from_type (ValaTypeRegisterFunction* self, gboolean plugin, gboolean declaration_only) {
      gboolean use_thread_safe;
      gboolean fundamental;
      ValaTypeSymbol* _tmp0_ = NULL;
      ValaTypeSymbol* _tmp1_;
      ValaClass* cl;
      gboolean _tmp2_ = FALSE;
      gboolean _tmp3_ = FALSE;
      ValaTypeSymbol* _tmp6_ = NULL;
      ValaTypeSymbol* _tmp7_;
      gchar* _tmp8_ = NULL;
      gchar* _tmp9_;
      gchar* _tmp10_ = NULL;
      gchar* _tmp11_;
      gchar* type_id_name;
      ValaCCodeBlock* _tmp12_ = NULL;
      ValaCCodeBlock* type_block;
      ValaCCodeDeclaration* _cdecl_ = NULL;
      ValaCCodeFunction* fun = NULL;
      gchar* type_value_table_decl_name;
      ValaCCodeBlock* _tmp63_ = NULL;
      ValaCCodeBlock* type_init;
      ValaTypeSymbol* _tmp85_ = NULL;
      ValaTypeSymbol* _tmp86_;
      gboolean _tmp87_;
      ValaCCodeFragment* _tmp115_ = NULL;
      ValaCCodeFragment* _tmp116_;
      gboolean _tmp117_ = FALSE;
      gboolean _tmp118_ = FALSE;
      ValaCCodeFunctionCall* reg_call = NULL;
      ValaTypeSymbol* _tmp147_ = NULL;
      ValaTypeSymbol* _tmp148_;
      gboolean _tmp149_;
      ValaTypeSymbol* _tmp188_ = NULL;
      ValaTypeSymbol* _tmp189_;
      gchar* _tmp190_ = NULL;
      gchar* _tmp191_;
      gchar* _tmp192_ = NULL;
      gchar* _tmp193_;
      ValaCCodeConstant* _tmp194_ = NULL;
      ValaCCodeConstant* _tmp195_;
      ValaTypeSymbol* _tmp196_ = NULL;
      ValaTypeSymbol* _tmp197_;
      gboolean _tmp198_;
      gboolean _tmp255_ = FALSE;
      gboolean _tmp265_ = FALSE;
      gboolean _tmp266_ = FALSE;
      ValaCCodeFunction* _tmp329_ = NULL;
      ValaCCodeFunction* _tmp330_;
      g_return_if_fail (self != NULL);
      use_thread_safe = !plugin;
      fundamental = FALSE;
      _tmp0_ = vala_typeregister_function_get_type_declaration (self);
      _tmp1_ = _tmp0_;
      cl = VALA_IS_CLASS (_tmp1_) ? ((ValaClass*) _tmp1_) : NULL;
      if (cl != NULL) {
            gboolean _tmp4_;
            _tmp4_ = vala_class_get_is_compact (cl);
            _tmp3_ = !_tmp4_;
      } else {
            _tmp3_ = FALSE;
      }
      if (_tmp3_) {
            ValaClass* _tmp5_ = NULL;
            _tmp5_ = vala_class_get_base_class (cl);
            _tmp2_ = _tmp5_ == NULL;
      } else {
            _tmp2_ = FALSE;
      }
      if (_tmp2_) {
            fundamental = TRUE;
      }
      _tmp6_ = vala_typeregister_function_get_type_declaration (self);
      _tmp7_ = _tmp6_;
      _tmp8_ = vala_symbol_get_lower_case_cname ((ValaSymbol*) _tmp7_, NULL);
      _tmp9_ = _tmp8_;
      _tmp10_ = g_strdup_printf ("%s_type_id", _tmp9_);
      _tmp11_ = _tmp10_;
      _g_free0 (_tmp9_);
      _vala_code_node_unref0 (_tmp7_);
      type_id_name = _tmp11_;
      _tmp12_ = vala_ccode_block_new ();
      type_block = _tmp12_;
      if (use_thread_safe) {
            ValaCCodeDeclaration* _tmp13_ = NULL;
            gchar* _tmp14_;
            gchar* _tmp15_;
            ValaCCodeConstant* _tmp16_ = NULL;
            ValaCCodeConstant* _tmp17_;
            ValaCCodeVariableDeclarator* _tmp18_ = NULL;
            ValaCCodeVariableDeclarator* _tmp19_;
            _tmp13_ = vala_ccode_declaration_new ("gsize");
            _vala_ccode_node_unref0 (_cdecl_);
            _cdecl_ = _tmp13_;
            _tmp14_ = g_strconcat (type_id_name, "__volatile", NULL);
            _tmp15_ = _tmp14_;
            _tmp16_ = vala_ccode_constant_new ("0");
            _tmp17_ = _tmp16_;
            _tmp18_ = vala_ccode_variable_declarator_new (_tmp15_, (ValaCCodeExpression*) _tmp17_, NULL);
            _tmp19_ = _tmp18_;
            vala_ccode_declaration_add_declarator (_cdecl_, (ValaCCodeDeclarator*) _tmp19_);
            _vala_ccode_node_unref0 (_tmp19_);
            _vala_ccode_node_unref0 (_tmp17_);
            _g_free0 (_tmp15_);
      } else {
            ValaCCodeDeclaration* _tmp20_ = NULL;
            ValaCCodeConstant* _tmp21_ = NULL;
            ValaCCodeConstant* _tmp22_;
            ValaCCodeVariableDeclarator* _tmp23_ = NULL;
            ValaCCodeVariableDeclarator* _tmp24_;
            _tmp20_ = vala_ccode_declaration_new ("GType");
            _vala_ccode_node_unref0 (_cdecl_);
            _cdecl_ = _tmp20_;
            _tmp21_ = vala_ccode_constant_new ("0");
            _tmp22_ = _tmp21_;
            _tmp23_ = vala_ccode_variable_declarator_new (type_id_name, (ValaCCodeExpression*) _tmp22_, NULL);
            _tmp24_ = _tmp23_;
            vala_ccode_declaration_add_declarator (_cdecl_, (ValaCCodeDeclarator*) _tmp24_);
            _vala_ccode_node_unref0 (_tmp24_);
            _vala_ccode_node_unref0 (_tmp22_);
      }
      vala_ccode_declaration_set_modifiers (_cdecl_, VALA_CCODE_MODIFIERS_STATIC);
      if (use_thread_safe) {
            ValaCCodeModifiers _tmp25_;
            _tmp25_ = vala_ccode_declaration_get_modifiers (_cdecl_);
            vala_ccode_declaration_set_modifiers (_cdecl_, _tmp25_ | VALA_CCODE_MODIFIERS_VOLATILE);
      }
      if (!plugin) {
            vala_ccode_block_add_statement (type_block, (ValaCCodeNode*) _cdecl_);
      } else {
            vala_ccode_fragment_append (self->priv->source_declaration_fragment, (ValaCCodeNode*) _cdecl_);
      }
      if (!plugin) {
            ValaTypeSymbol* _tmp26_ = NULL;
            ValaTypeSymbol* _tmp27_;
            gchar* _tmp28_ = NULL;
            gchar* _tmp29_;
            gchar* _tmp30_ = NULL;
            gchar* _tmp31_;
            ValaCCodeFunction* _tmp32_ = NULL;
            ValaSymbolAccessibility _tmp33_;
            _tmp26_ = vala_typeregister_function_get_type_declaration (self);
            _tmp27_ = _tmp26_;
            _tmp28_ = vala_symbol_get_lower_case_cname ((ValaSymbol*) _tmp27_, NULL);
            _tmp29_ = _tmp28_;
            _tmp30_ = g_strdup_printf ("%s_get_type", _tmp29_);
            _tmp31_ = _tmp30_;
            _tmp32_ = vala_ccode_function_new (_tmp31_, "GType");
            _vala_ccode_node_unref0 (fun);
            fun = _tmp32_;
            _g_free0 (_tmp31_);
            _g_free0 (_tmp29_);
            _vala_code_node_unref0 (_tmp27_);
            vala_ccode_function_set_attributes (fun, "G_GNUC_CONST");
            _tmp33_ = vala_typeregister_function_get_accessibility (self);
            if (_tmp33_ == VALA_SYMBOL_ACCESSIBILITY_PRIVATE) {
                  const gchar* _tmp34_ = NULL;
                  gchar* _tmp35_;
                  gchar* _tmp36_;
                  vala_ccode_function_set_modifiers (fun, VALA_CCODE_MODIFIERS_STATIC);
                  _tmp34_ = vala_ccode_function_get_attributes (fun);
                  _tmp35_ = g_strconcat (_tmp34_, " G_GNUC_UNUSED", NULL);
                  _tmp36_ = _tmp35_;
                  vala_ccode_function_set_attributes (fun, _tmp36_);
                  _g_free0 (_tmp36_);
            }
      } else {
            ValaTypeSymbol* _tmp37_ = NULL;
            ValaTypeSymbol* _tmp38_;
            gchar* _tmp39_ = NULL;
            gchar* _tmp40_;
            gchar* _tmp41_ = NULL;
            gchar* _tmp42_;
            ValaCCodeFunction* _tmp43_ = NULL;
            ValaCCodeParameter* _tmp44_ = NULL;
            ValaCCodeParameter* _tmp45_;
            ValaTypeSymbol* _tmp46_ = NULL;
            ValaTypeSymbol* _tmp47_;
            gchar* _tmp48_ = NULL;
            gchar* _tmp49_;
            gchar* _tmp50_ = NULL;
            gchar* _tmp51_;
            ValaCCodeFunction* _tmp52_ = NULL;
            ValaCCodeFunction* _tmp53_;
            ValaCCodeFunction* get_fun;
            ValaCCodeFunction* _tmp54_ = NULL;
            ValaCCodeFunction* _tmp55_;
            ValaCCodeBlock* _tmp56_ = NULL;
            ValaCCodeBlock* _tmp57_;
            ValaCCodeBlock* _tmp58_ = NULL;
            ValaCCodeIdentifier* _tmp59_ = NULL;
            ValaCCodeIdentifier* _tmp60_;
            ValaCCodeReturnStatement* _tmp61_ = NULL;
            ValaCCodeReturnStatement* _tmp62_;
            _tmp37_ = vala_typeregister_function_get_type_declaration (self);
            _tmp38_ = _tmp37_;
            _tmp39_ = vala_symbol_get_lower_case_cname ((ValaSymbol*) _tmp38_, NULL);
            _tmp40_ = _tmp39_;
            _tmp41_ = g_strdup_printf ("%s_register_type", _tmp40_);
            _tmp42_ = _tmp41_;
            _tmp43_ = vala_ccode_function_new (_tmp42_, "GType");
            _vala_ccode_node_unref0 (fun);
            fun = _tmp43_;
            _g_free0 (_tmp42_);
            _g_free0 (_tmp40_);
            _vala_code_node_unref0 (_tmp38_);
            _tmp44_ = vala_ccode_parameter_new ("module", "GTypeModule *");
            _tmp45_ = _tmp44_;
            vala_ccode_function_add_parameter (fun, _tmp45_);
            _vala_ccode_node_unref0 (_tmp45_);
            _tmp46_ = vala_typeregister_function_get_type_declaration (self);
            _tmp47_ = _tmp46_;
            _tmp48_ = vala_symbol_get_lower_case_cname ((ValaSymbol*) _tmp47_, NULL);
            _tmp49_ = _tmp48_;
            _tmp50_ = g_strdup_printf ("%s_get_type", _tmp49_);
            _tmp51_ = _tmp50_;
            _tmp52_ = vala_ccode_function_new (_tmp51_, "GType");
            _tmp53_ = _tmp52_;
            _g_free0 (_tmp51_);
            _g_free0 (_tmp49_);
            _vala_code_node_unref0 (_tmp47_);
            get_fun = _tmp53_;
            vala_ccode_function_set_attributes (get_fun, "G_GNUC_CONST");
            vala_ccode_function_set_is_declaration (get_fun, TRUE);
            _tmp54_ = vala_ccode_function_copy (get_fun);
            _tmp55_ = _tmp54_;
            vala_ccode_fragment_append (self->priv->declaration_fragment, (ValaCCodeNode*) _tmp55_);
            _vala_ccode_node_unref0 (_tmp55_);
            vala_ccode_function_set_is_declaration (get_fun, FALSE);
            _tmp56_ = vala_ccode_block_new ();
            _tmp57_ = _tmp56_;
            vala_ccode_function_set_block (get_fun, _tmp57_);
            _vala_ccode_node_unref0 (_tmp57_);
            _tmp58_ = vala_ccode_function_get_block (get_fun);
            _tmp59_ = vala_ccode_identifier_new (type_id_name);
            _tmp60_ = _tmp59_;
            _tmp61_ = vala_ccode_return_statement_new ((ValaCCodeExpression*) _tmp60_);
            _tmp62_ = _tmp61_;
            vala_ccode_block_add_statement (_tmp58_, (ValaCCodeNode*) _tmp62_);
            _vala_ccode_node_unref0 (_tmp62_);
            _vala_ccode_node_unref0 (_tmp60_);
            vala_ccode_fragment_append (self->priv->definition_fragment, (ValaCCodeNode*) get_fun);
            _vala_ccode_node_unref0 (get_fun);
      }
      type_value_table_decl_name = NULL;
      _tmp63_ = vala_ccode_block_new ();
      type_init = _tmp63_;
      if (fundamental) {
            ValaCCodeDeclaration* _tmp64_ = NULL;
            ValaCCodeDeclaration* cgtypetabledecl;
            gchar* _tmp65_ = NULL;
            gchar* _tmp66_;
            gchar* _tmp67_ = NULL;
            gchar* _tmp68_;
            gchar* _tmp69_ = NULL;
            gchar* _tmp70_;
            gchar* _tmp71_ = NULL;
            gchar* _tmp72_;
            gchar* _tmp73_ = NULL;
            gchar* _tmp74_;
            gchar* _tmp75_ = NULL;
            gchar* _tmp76_;
            gchar* _tmp77_ = NULL;
            gchar* _tmp78_;
            ValaCCodeConstant* _tmp79_ = NULL;
            ValaCCodeConstant* _tmp80_;
            ValaCCodeVariableDeclarator* _tmp81_ = NULL;
            ValaCCodeVariableDeclarator* _tmp82_;
            gchar* _tmp83_;
            _tmp64_ = vala_ccode_declaration_new ("const GTypeValueTable");
            cgtypetabledecl = _tmp64_;
            vala_ccode_declaration_set_modifiers (cgtypetabledecl, VALA_CCODE_MODIFIERS_STATIC);
            _tmp65_ = vala_typeregister_function_get_gtype_value_table_init_function_name (self);
            _tmp66_ = _tmp65_;
            _tmp67_ = vala_typeregister_function_get_gtype_value_table_free_function_name (self);
            _tmp68_ = _tmp67_;
            _tmp69_ = vala_typeregister_function_get_gtype_value_table_copy_function_name (self);
            _tmp70_ = _tmp69_;
            _tmp71_ = vala_typeregister_function_get_gtype_value_table_peek_pointer_function_name (self);
            _tmp72_ = _tmp71_;
            _tmp73_ = vala_typeregister_function_get_gtype_value_table_collect_value_function_name (self);
            _tmp74_ = _tmp73_;
            _tmp75_ = vala_typeregister_function_get_gtype_value_table_lcopy_value_function_name (self);
            _tmp76_ = _tmp75_;
            _tmp77_ = g_strdup_printf ("{ %s, %s, %s, %s, \"p\", %s, \"p\", %s }", _tmp66_, _tmp68_, _tmp70_, _tmp72_, _tmp74_, _tmp76_);
            _tmp78_ = _tmp77_;
            _tmp79_ = vala_ccode_constant_new (_tmp78_);
            _tmp80_ = _tmp79_;
            _tmp81_ = vala_ccode_variable_declarator_new ("g_define_type_value_table", (ValaCCodeExpression*) _tmp80_, NULL);
            _tmp82_ = _tmp81_;
            vala_ccode_declaration_add_declarator (cgtypetabledecl, (ValaCCodeDeclarator*) _tmp82_);
            _vala_ccode_node_unref0 (_tmp82_);
            _vala_ccode_node_unref0 (_tmp80_);
            _g_free0 (_tmp78_);
            _g_free0 (_tmp76_);
            _g_free0 (_tmp74_);
            _g_free0 (_tmp72_);
            _g_free0 (_tmp70_);
            _g_free0 (_tmp68_);
            _g_free0 (_tmp66_);
            _tmp83_ = g_strdup ("&g_define_type_value_table");
            _g_free0 (type_value_table_decl_name);
            type_value_table_decl_name = _tmp83_;
            vala_ccode_block_add_statement (type_init, (ValaCCodeNode*) cgtypetabledecl);
            _vala_ccode_node_unref0 (cgtypetabledecl);
      } else {
            gchar* _tmp84_;
            _tmp84_ = g_strdup ("NULL");
            _g_free0 (type_value_table_decl_name);
            type_value_table_decl_name = _tmp84_;
      }
      _tmp85_ = vala_typeregister_function_get_type_declaration (self);
      _tmp86_ = _tmp85_;
      _tmp87_ = VALA_IS_OBJECT_TYPE_SYMBOL (_tmp86_);
      _vala_code_node_unref0 (_tmp86_);
      if (_tmp87_) {
            ValaCCodeDeclaration* _tmp88_ = NULL;
            ValaCCodeDeclaration* ctypedecl;
            gchar* _tmp89_ = NULL;
            gchar* _tmp92_ = NULL;
            gchar* _tmp93_;
            gchar* _tmp94_ = NULL;
            gchar* _tmp95_;
            gchar* _tmp96_ = NULL;
            gchar* _tmp97_;
            gchar* _tmp98_ = NULL;
            gchar* _tmp99_;
            gchar* _tmp100_ = NULL;
            gchar* _tmp101_;
            gchar* _tmp102_ = NULL;
            gchar* _tmp103_;
            gchar* _tmp104_ = NULL;
            gchar* _tmp105_;
            ValaCCodeConstant* _tmp106_ = NULL;
            ValaCCodeConstant* _tmp107_;
            ValaCCodeVariableDeclarator* _tmp108_ = NULL;
            ValaCCodeVariableDeclarator* _tmp109_;
            _tmp88_ = vala_ccode_declaration_new ("const GTypeInfo");
            ctypedecl = _tmp88_;
            vala_ccode_declaration_set_modifiers (ctypedecl, VALA_CCODE_MODIFIERS_STATIC);
            if (plugin) {
                  gchar* _tmp90_ = NULL;
                  _tmp90_ = vala_typeregister_function_get_base_finalize_func_name (self);
                  _g_free0 (_tmp89_);
                  _tmp89_ = _tmp90_;
            } else {
                  gchar* _tmp91_;
                  _tmp91_ = g_strdup ("NULL");
                  _g_free0 (_tmp89_);
                  _tmp89_ = _tmp91_;
            }
            _tmp92_ = vala_typeregister_function_get_type_struct_name (self);
            _tmp93_ = _tmp92_;
            _tmp94_ = vala_typeregister_function_get_base_init_func_name (self);
            _tmp95_ = _tmp94_;
            _tmp96_ = vala_typeregister_function_get_class_init_func_name (self);
            _tmp97_ = _tmp96_;
            _tmp98_ = vala_typeregister_function_get_class_finalize_func_name (self);
            _tmp99_ = _tmp98_;
            _tmp100_ = vala_typeregister_function_get_instance_struct_size (self);
            _tmp101_ = _tmp100_;
            _tmp102_ = vala_typeregister_function_get_instance_init_func_name (self);
            _tmp103_ = _tmp102_;
            _tmp104_ = g_strdup_printf ("{ sizeof (%s), (GBaseInitFunc) %s, (GBaseFinalizeFunc) %s, (GClassInit" \
"Func) %s, (GClassFinalizeFunc) %s, NULL, %s, 0, (GInstanceInitFunc) %s" \
", %s }", _tmp93_, _tmp95_, _tmp89_, _tmp97_, _tmp99_, _tmp101_, _tmp103_, type_value_table_decl_name);
            _tmp105_ = _tmp104_;
            _tmp106_ = vala_ccode_constant_new (_tmp105_);
            _tmp107_ = _tmp106_;
            _tmp108_ = vala_ccode_variable_declarator_new ("g_define_type_info", (ValaCCodeExpression*) _tmp107_, NULL);
            _tmp109_ = _tmp108_;
            vala_ccode_declaration_add_declarator (ctypedecl, (ValaCCodeDeclarator*) _tmp109_);
            _vala_ccode_node_unref0 (_tmp109_);
            _vala_ccode_node_unref0 (_tmp107_);
            _g_free0 (_tmp105_);
            _g_free0 (_tmp103_);
            _g_free0 (_tmp101_);
            _g_free0 (_tmp99_);
            _g_free0 (_tmp97_);
            _g_free0 (_tmp95_);
            _g_free0 (_tmp93_);
            vala_ccode_block_add_statement (type_init, (ValaCCodeNode*) ctypedecl);
            if (fundamental) {
                  ValaCCodeDeclaration* _tmp110_ = NULL;
                  ValaCCodeDeclaration* ctypefundamentaldecl;
                  ValaCCodeConstant* _tmp111_ = NULL;
                  ValaCCodeConstant* _tmp112_;
                  ValaCCodeVariableDeclarator* _tmp113_ = NULL;
                  ValaCCodeVariableDeclarator* _tmp114_;
                  _tmp110_ = vala_ccode_declaration_new ("const GTypeFundamentalInfo");
                  ctypefundamentaldecl = _tmp110_;
                  vala_ccode_declaration_set_modifiers (ctypefundamentaldecl, VALA_CCODE_MODIFIERS_STATIC);
                  _tmp111_ = vala_ccode_constant_new ("{ (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERI" \
"VABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }");
                  _tmp112_ = _tmp111_;
                  _tmp113_ = vala_ccode_variable_declarator_new ("g_define_type_fundamental_info", (ValaCCodeExpression*) _tmp112_, NULL);
                  _tmp114_ = _tmp113_;
                  vala_ccode_declaration_add_declarator (ctypefundamentaldecl, (ValaCCodeDeclarator*) _tmp114_);
                  _vala_ccode_node_unref0 (_tmp114_);
                  _vala_ccode_node_unref0 (_tmp112_);
                  vala_ccode_block_add_statement (type_init, (ValaCCodeNode*) ctypefundamentaldecl);
                  _vala_ccode_node_unref0 (ctypefundamentaldecl);
            }
            _g_free0 (_tmp89_);
            _vala_ccode_node_unref0 (ctypedecl);
      }
      _tmp115_ = vala_typeregister_function_get_type_interface_init_declaration (self);
      _tmp116_ = _tmp115_;
      vala_ccode_block_add_statement (type_init, (ValaCCodeNode*) _tmp116_);
      _vala_ccode_node_unref0 (_tmp116_);
      if (cl != NULL) {
            gboolean _tmp119_;
            _tmp119_ = vala_class_get_has_class_private_fields (cl);
            _tmp118_ = _tmp119_;
      } else {
            _tmp118_ = FALSE;
      }
      if (_tmp118_) {
            gboolean _tmp120_;
            _tmp120_ = vala_code_context_require_glib_version (self->priv->_context, 2, 24);
            _tmp117_ = !_tmp120_;
      } else {
            _tmp117_ = FALSE;
      }
      if (_tmp117_) {
            ValaCCodeFunctionCall* quark_reg_call = NULL;
            ValaTypeSymbol* _tmp127_ = NULL;
            ValaTypeSymbol* _tmp128_;
            gchar* _tmp129_ = NULL;
            gchar* _tmp130_;
            gchar* _tmp131_ = NULL;
            gchar* _tmp132_;
            ValaCCodeConstant* _tmp133_ = NULL;
            ValaCCodeConstant* _tmp134_;
            ValaTypeSymbol* _tmp135_ = NULL;
            ValaTypeSymbol* _tmp136_;
            gchar* _tmp137_ = NULL;
            gchar* _tmp138_;
            gchar* _tmp139_ = NULL;
            gchar* _tmp140_;
            ValaCCodeIdentifier* _tmp141_ = NULL;
            ValaCCodeIdentifier* _tmp142_;
            ValaCCodeAssignment* _tmp143_ = NULL;
            ValaCCodeAssignment* _tmp144_;
            ValaCCodeExpressionStatement* _tmp145_ = NULL;
            ValaCCodeExpressionStatement* _tmp146_;
            if (plugin) {
                  ValaCCodeIdentifier* _tmp121_ = NULL;
                  ValaCCodeIdentifier* _tmp122_;
                  ValaCCodeFunctionCall* _tmp123_ = NULL;
                  _tmp121_ = vala_ccode_identifier_new ("g_quark_from_string");
                  _tmp122_ = _tmp121_;
                  _tmp123_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp122_);
                  _vala_ccode_node_unref0 (quark_reg_call);
                  quark_reg_call = _tmp123_;
                  _vala_ccode_node_unref0 (_tmp122_);
            } else {
                  ValaCCodeIdentifier* _tmp124_ = NULL;
                  ValaCCodeIdentifier* _tmp125_;
                  ValaCCodeFunctionCall* _tmp126_ = NULL;
                  _tmp124_ = vala_ccode_identifier_new ("g_quark_from_static_string");
                  _tmp125_ = _tmp124_;
                  _tmp126_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp125_);
                  _vala_ccode_node_unref0 (quark_reg_call);
                  quark_reg_call = _tmp126_;
                  _vala_ccode_node_unref0 (_tmp125_);
            }
            _tmp127_ = vala_typeregister_function_get_type_declaration (self);
            _tmp128_ = _tmp127_;
            _tmp129_ = vala_typesymbol_get_cname (_tmp128_, FALSE);
            _tmp130_ = _tmp129_;
            _tmp131_ = g_strdup_printf ("\"Vala%sClassPrivate\"", _tmp130_);
            _tmp132_ = _tmp131_;
            _tmp133_ = vala_ccode_constant_new (_tmp132_);
            _tmp134_ = _tmp133_;
            vala_ccode_function_call_add_argument (quark_reg_call, (ValaCCodeExpression*) _tmp134_);
            _vala_ccode_node_unref0 (_tmp134_);
            _g_free0 (_tmp132_);
            _g_free0 (_tmp130_);
            _vala_code_node_unref0 (_tmp128_);
            _tmp135_ = vala_typeregister_function_get_type_declaration (self);
            _tmp136_ = _tmp135_;
            _tmp137_ = vala_symbol_get_lower_case_cname ((ValaSymbol*) _tmp136_, NULL);
            _tmp138_ = _tmp137_;
            _tmp139_ = g_strdup_printf ("_vala_%s_class_private_quark", _tmp138_);
            _tmp140_ = _tmp139_;
            _tmp141_ = vala_ccode_identifier_new (_tmp140_);
            _tmp142_ = _tmp141_;
            _tmp143_ = vala_ccode_assignment_new ((ValaCCodeExpression*) _tmp142_, (ValaCCodeExpression*) quark_reg_call, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
            _tmp144_ = _tmp143_;
            _tmp145_ = vala_ccode_expression_statement_new ((ValaCCodeExpression*) _tmp144_);
            _tmp146_ = _tmp145_;
            vala_ccode_block_add_statement (type_init, (ValaCCodeNode*) _tmp146_);
            _vala_ccode_node_unref0 (_tmp146_);
            _vala_ccode_node_unref0 (_tmp144_);
            _vala_ccode_node_unref0 (_tmp142_);
            _g_free0 (_tmp140_);
            _g_free0 (_tmp138_);
            _vala_code_node_unref0 (_tmp136_);
            _vala_ccode_node_unref0 (quark_reg_call);
      }
      _tmp147_ = vala_typeregister_function_get_type_declaration (self);
      _tmp148_ = _tmp147_;
      _tmp149_ = VALA_IS_STRUCT (_tmp148_);
      _vala_code_node_unref0 (_tmp148_);
      if (_tmp149_) {
            ValaCCodeIdentifier* _tmp150_ = NULL;
            ValaCCodeIdentifier* _tmp151_;
            ValaCCodeFunctionCall* _tmp152_ = NULL;
            _tmp150_ = vala_ccode_identifier_new ("g_boxed_type_register_static");
            _tmp151_ = _tmp150_;
            _tmp152_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp151_);
            _vala_ccode_node_unref0 (reg_call);
            reg_call = _tmp152_;
            _vala_ccode_node_unref0 (_tmp151_);
      } else {
            ValaTypeSymbol* _tmp153_ = NULL;
            ValaTypeSymbol* _tmp154_;
            gboolean _tmp155_;
            _tmp153_ = vala_typeregister_function_get_type_declaration (self);
            _tmp154_ = _tmp153_;
            _tmp155_ = VALA_IS_ENUM (_tmp154_);
            _vala_code_node_unref0 (_tmp154_);
            if (_tmp155_) {
                  ValaTypeSymbol* _tmp156_ = NULL;
                  ValaTypeSymbol* _tmp157_;
                  ValaEnum* en;
                  gboolean _tmp158_;
                  _tmp156_ = vala_typeregister_function_get_type_declaration (self);
                  _tmp157_ = _tmp156_;
                  en = VALA_IS_ENUM (_tmp157_) ? ((ValaEnum*) _tmp157_) : NULL;
                  _tmp158_ = vala_enum_get_is_flags (en);
                  if (_tmp158_) {
                        ValaCCodeIdentifier* _tmp159_ = NULL;
                        ValaCCodeIdentifier* _tmp160_;
                        ValaCCodeFunctionCall* _tmp161_ = NULL;
                        _tmp159_ = vala_ccode_identifier_new ("g_flags_register_static");
                        _tmp160_ = _tmp159_;
                        _tmp161_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp160_);
                        _vala_ccode_node_unref0 (reg_call);
                        reg_call = _tmp161_;
                        _vala_ccode_node_unref0 (_tmp160_);
                  } else {
                        ValaCCodeIdentifier* _tmp162_ = NULL;
                        ValaCCodeIdentifier* _tmp163_;
                        ValaCCodeFunctionCall* _tmp164_ = NULL;
                        _tmp162_ = vala_ccode_identifier_new ("g_enum_register_static");
                        _tmp163_ = _tmp162_;
                        _tmp164_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp163_);
                        _vala_ccode_node_unref0 (reg_call);
                        reg_call = _tmp164_;
                        _vala_ccode_node_unref0 (_tmp163_);
                  }
                  _vala_code_node_unref0 (en);
            } else {
                  if (fundamental) {
                        ValaCCodeIdentifier* _tmp165_ = NULL;
                        ValaCCodeIdentifier* _tmp166_;
                        ValaCCodeFunctionCall* _tmp167_ = NULL;
                        ValaCCodeIdentifier* _tmp168_ = NULL;
                        ValaCCodeIdentifier* _tmp169_;
                        ValaCCodeFunctionCall* _tmp170_ = NULL;
                        ValaCCodeFunctionCall* _tmp171_;
                        _tmp165_ = vala_ccode_identifier_new ("g_type_register_fundamental");
                        _tmp166_ = _tmp165_;
                        _tmp167_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp166_);
                        _vala_ccode_node_unref0 (reg_call);
                        reg_call = _tmp167_;
                        _vala_ccode_node_unref0 (_tmp166_);
                        _tmp168_ = vala_ccode_identifier_new ("g_type_fundamental_next");
                        _tmp169_ = _tmp168_;
                        _tmp170_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp169_);
                        _tmp171_ = _tmp170_;
                        vala_ccode_function_call_add_argument (reg_call, (ValaCCodeExpression*) _tmp171_);
                        _vala_ccode_node_unref0 (_tmp171_);
                        _vala_ccode_node_unref0 (_tmp169_);
                  } else {
                        if (!plugin) {
                              ValaCCodeIdentifier* _tmp172_ = NULL;
                              ValaCCodeIdentifier* _tmp173_;
                              ValaCCodeFunctionCall* _tmp174_ = NULL;
                              gchar* _tmp175_ = NULL;
                              gchar* _tmp176_;
                              ValaCCodeIdentifier* _tmp177_ = NULL;
                              ValaCCodeIdentifier* _tmp178_;
                              _tmp172_ = vala_ccode_identifier_new ("g_type_register_static");
                              _tmp173_ = _tmp172_;
                              _tmp174_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp173_);
                              _vala_ccode_node_unref0 (reg_call);
                              reg_call = _tmp174_;
                              _vala_ccode_node_unref0 (_tmp173_);
                              _tmp175_ = vala_typeregister_function_get_parent_type_name (self);
                              _tmp176_ = _tmp175_;
                              _tmp177_ = vala_ccode_identifier_new (_tmp176_);
                              _tmp178_ = _tmp177_;
                              vala_ccode_function_call_add_argument (reg_call, (ValaCCodeExpression*) _tmp178_);
                              _vala_ccode_node_unref0 (_tmp178_);
                              _g_free0 (_tmp176_);
                        } else {
                              ValaCCodeIdentifier* _tmp179_ = NULL;
                              ValaCCodeIdentifier* _tmp180_;
                              ValaCCodeFunctionCall* _tmp181_ = NULL;
                              ValaCCodeIdentifier* _tmp182_ = NULL;
                              ValaCCodeIdentifier* _tmp183_;
                              gchar* _tmp184_ = NULL;
                              gchar* _tmp185_;
                              ValaCCodeIdentifier* _tmp186_ = NULL;
                              ValaCCodeIdentifier* _tmp187_;
                              _tmp179_ = vala_ccode_identifier_new ("g_type_module_register_type");
                              _tmp180_ = _tmp179_;
                              _tmp181_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp180_);
                              _vala_ccode_node_unref0 (reg_call);
                              reg_call = _tmp181_;
                              _vala_ccode_node_unref0 (_tmp180_);
                              _tmp182_ = vala_ccode_identifier_new ("module");
                              _tmp183_ = _tmp182_;
                              vala_ccode_function_call_add_argument (reg_call, (ValaCCodeExpression*) _tmp183_);
                              _vala_ccode_node_unref0 (_tmp183_);
                              _tmp184_ = vala_typeregister_function_get_parent_type_name (self);
                              _tmp185_ = _tmp184_;
                              _tmp186_ = vala_ccode_identifier_new (_tmp185_);
                              _tmp187_ = _tmp186_;
                              vala_ccode_function_call_add_argument (reg_call, (ValaCCodeExpression*) _tmp187_);
                              _vala_ccode_node_unref0 (_tmp187_);
                              _g_free0 (_tmp185_);
                        }
                  }
            }
      }
      _tmp188_ = vala_typeregister_function_get_type_declaration (self);
      _tmp189_ = _tmp188_;
      _tmp190_ = vala_typesymbol_get_cname (_tmp189_, FALSE);
      _tmp191_ = _tmp190_;
      _tmp192_ = g_strdup_printf ("\"%s\"", _tmp191_);
      _tmp193_ = _tmp192_;
      _tmp194_ = vala_ccode_constant_new (_tmp193_);
      _tmp195_ = _tmp194_;
      vala_ccode_function_call_add_argument (reg_call, (ValaCCodeExpression*) _tmp195_);
      _vala_ccode_node_unref0 (_tmp195_);
      _g_free0 (_tmp193_);
      _g_free0 (_tmp191_);
      _vala_code_node_unref0 (_tmp189_);
      _tmp196_ = vala_typeregister_function_get_type_declaration (self);
      _tmp197_ = _tmp196_;
      _tmp198_ = VALA_IS_STRUCT (_tmp197_);
      _vala_code_node_unref0 (_tmp197_);
      if (_tmp198_) {
            ValaTypeSymbol* _tmp199_ = NULL;
            ValaStruct* st;
            gchar* _tmp200_ = NULL;
            gchar* _tmp201_;
            ValaCCodeIdentifier* _tmp202_ = NULL;
            ValaCCodeIdentifier* _tmp203_;
            ValaCCodeCastExpression* _tmp204_ = NULL;
            ValaCCodeCastExpression* _tmp205_;
            gchar* _tmp206_ = NULL;
            gchar* _tmp207_;
            ValaCCodeIdentifier* _tmp208_ = NULL;
            ValaCCodeIdentifier* _tmp209_;
            ValaCCodeCastExpression* _tmp210_ = NULL;
            ValaCCodeCastExpression* _tmp211_;
            _tmp199_ = vala_typeregister_function_get_type_declaration (self);
            st = VALA_STRUCT (_tmp199_);
            _tmp200_ = vala_typesymbol_get_dup_function ((ValaTypeSymbol*) st);
            _tmp201_ = _tmp200_;
            _tmp202_ = vala_ccode_identifier_new (_tmp201_);
            _tmp203_ = _tmp202_;
            _tmp204_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp203_, "GBoxedCopyFunc");
            _tmp205_ = _tmp204_;
            vala_ccode_function_call_add_argument (reg_call, (ValaCCodeExpression*) _tmp205_);
            _vala_ccode_node_unref0 (_tmp205_);
            _vala_ccode_node_unref0 (_tmp203_);
            _g_free0 (_tmp201_);
            _tmp206_ = vala_typesymbol_get_free_function ((ValaTypeSymbol*) st);
            _tmp207_ = _tmp206_;
            _tmp208_ = vala_ccode_identifier_new (_tmp207_);
            _tmp209_ = _tmp208_;
            _tmp210_ = vala_ccode_cast_expression_new ((ValaCCodeExpression*) _tmp209_, "GBoxedFreeFunc");
            _tmp211_ = _tmp210_;
            vala_ccode_function_call_add_argument (reg_call, (ValaCCodeExpression*) _tmp211_);
            _vala_ccode_node_unref0 (_tmp211_);
            _vala_ccode_node_unref0 (_tmp209_);
            _g_free0 (_tmp207_);
            _vala_code_node_unref0 (st);
      } else {
            ValaTypeSymbol* _tmp212_ = NULL;
            ValaTypeSymbol* _tmp213_;
            gboolean _tmp214_;
            _tmp212_ = vala_typeregister_function_get_type_declaration (self);
            _tmp213_ = _tmp212_;
            _tmp214_ = VALA_IS_ENUM (_tmp213_);
            _vala_code_node_unref0 (_tmp213_);
            if (_tmp214_) {
                  ValaTypeSymbol* _tmp215_ = NULL;
                  ValaTypeSymbol* _tmp216_;
                  ValaEnum* en;
                  ValaCCodeInitializerList* _tmp217_ = NULL;
                  ValaCCodeInitializerList* clist;
                  ValaCCodeInitializerList* clist_ev;
                  ValaCCodeInitializerList* _tmp234_ = NULL;
                  ValaCCodeConstant* _tmp235_ = NULL;
                  ValaCCodeConstant* _tmp236_;
                  ValaCCodeConstant* _tmp237_ = NULL;
                  ValaCCodeConstant* _tmp238_;
                  ValaCCodeConstant* _tmp239_ = NULL;
                  ValaCCodeConstant* _tmp240_;
                  ValaCCodeVariableDeclarator* _tmp241_ = NULL;
                  ValaCCodeVariableDeclarator* enum_decl;
                  gboolean _tmp242_;
                  ValaCCodeIdentifier* _tmp245_ = NULL;
                  ValaCCodeIdentifier* _tmp246_;
                  _tmp215_ = vala_typeregister_function_get_type_declaration (self);
                  _tmp216_ = _tmp215_;
                  en = VALA_IS_ENUM (_tmp216_) ? ((ValaEnum*) _tmp216_) : NULL;
                  _tmp217_ = vala_ccode_initializer_list_new ();
                  clist = _tmp217_;
                  clist_ev = NULL;
                  {
                        ValaList* _tmp218_ = NULL;
                        ValaList* _ev_list;
                        gint _tmp219_;
                        gint _ev_size;
                        gint _ev_index;
                        _tmp218_ = vala_enum_get_values (en);
                        _ev_list = _tmp218_;
                        _tmp219_ = vala_collection_get_size ((ValaCollection*) _ev_list);
                        _ev_size = _tmp219_;
                        _ev_index = -1;
                        while (TRUE) {
                              gpointer _tmp220_ = NULL;
                              ValaEnumValue* ev;
                              ValaCCodeInitializerList* _tmp221_ = NULL;
                              gchar* _tmp222_ = NULL;
                              gchar* _tmp223_;
                              ValaCCodeConstant* _tmp224_ = NULL;
                              ValaCCodeConstant* _tmp225_;
                              gchar* _tmp226_ = NULL;
                              gchar* _tmp227_;
                              gchar* _tmp228_ = NULL;
                              gchar* _tmp229_;
                              ValaCCodeIdentifier* _tmp230_ = NULL;
                              ValaCCodeIdentifier* _tmp231_;
                              ValaCCodeConstant* _tmp232_ = NULL;
                              ValaCCodeConstant* _tmp233_;
                              _ev_index = _ev_index + 1;
                              if (!(_ev_index < _ev_size)) {
                                    break;
                              }
                              _tmp220_ = vala_list_get (_ev_list, _ev_index);
                              ev = (ValaEnumValue*) _tmp220_;
                              _tmp221_ = vala_ccode_initializer_list_new ();
                              _vala_ccode_node_unref0 (clist_ev);
                              clist_ev = _tmp221_;
                              _tmp222_ = vala_constant_get_cname ((ValaConstant*) ev);
                              _tmp223_ = _tmp222_;
                              _tmp224_ = vala_ccode_constant_new (_tmp223_);
                              _tmp225_ = _tmp224_;
                              vala_ccode_initializer_list_append (clist_ev, (ValaCCodeExpression*) _tmp225_);
                              _vala_ccode_node_unref0 (_tmp225_);
                              _g_free0 (_tmp223_);
                              _tmp226_ = vala_constant_get_cname ((ValaConstant*) ev);
                              _tmp227_ = _tmp226_;
                              _tmp228_ = g_strdup_printf ("\"%s\"", _tmp227_);
                              _tmp229_ = _tmp228_;
                              _tmp230_ = vala_ccode_identifier_new (_tmp229_);
                              _tmp231_ = _tmp230_;
                              vala_ccode_initializer_list_append (clist_ev, (ValaCCodeExpression*) _tmp231_);
                              _vala_ccode_node_unref0 (_tmp231_);
                              _g_free0 (_tmp229_);
                              _g_free0 (_tmp227_);
                              _tmp232_ = vala_enum_value_get_canonical_cconstant (ev);
                              _tmp233_ = _tmp232_;
                              vala_ccode_initializer_list_append (clist_ev, (ValaCCodeExpression*) _tmp233_);
                              _vala_ccode_node_unref0 (_tmp233_);
                              vala_ccode_initializer_list_append (clist, (ValaCCodeExpression*) clist_ev);
                              _vala_code_node_unref0 (ev);
                        }
                        _vala_iterable_unref0 (_ev_list);
                  }
                  _tmp234_ = vala_ccode_initializer_list_new ();
                  _vala_ccode_node_unref0 (clist_ev);
                  clist_ev = _tmp234_;
                  _tmp235_ = vala_ccode_constant_new ("0");
                  _tmp236_ = _tmp235_;
                  vala_ccode_initializer_list_append (clist_ev, (ValaCCodeExpression*) _tmp236_);
                  _vala_ccode_node_unref0 (_tmp236_);
                  _tmp237_ = vala_ccode_constant_new ("NULL");
                  _tmp238_ = _tmp237_;
                  vala_ccode_initializer_list_append (clist_ev, (ValaCCodeExpression*) _tmp238_);
                  _vala_ccode_node_unref0 (_tmp238_);
                  _tmp239_ = vala_ccode_constant_new ("NULL");
                  _tmp240_ = _tmp239_;
                  vala_ccode_initializer_list_append (clist_ev, (ValaCCodeExpression*) _tmp240_);
                  _vala_ccode_node_unref0 (_tmp240_);
                  vala_ccode_initializer_list_append (clist, (ValaCCodeExpression*) clist_ev);
                  _tmp241_ = vala_ccode_variable_declarator_new ("values[]", (ValaCCodeExpression*) clist, NULL);
                  enum_decl = _tmp241_;
                  _tmp242_ = vala_enum_get_is_flags (en);
                  if (_tmp242_) {
                        ValaCCodeDeclaration* _tmp243_ = NULL;
                        _tmp243_ = vala_ccode_declaration_new ("const GFlagsValue");
                        _vala_ccode_node_unref0 (_cdecl_);
                        _cdecl_ = _tmp243_;
                  } else {
                        ValaCCodeDeclaration* _tmp244_ = NULL;
                        _tmp244_ = vala_ccode_declaration_new ("const GEnumValue");
                        _vala_ccode_node_unref0 (_cdecl_);
                        _cdecl_ = _tmp244_;
                  }
                  vala_ccode_declaration_add_declarator (_cdecl_, (ValaCCodeDeclarator*) enum_decl);
                  vala_ccode_declaration_set_modifiers (_cdecl_, VALA_CCODE_MODIFIERS_STATIC);
                  vala_ccode_block_add_statement (type_init, (ValaCCodeNode*) _cdecl_);
                  _tmp245_ = vala_ccode_identifier_new ("values");
                  _tmp246_ = _tmp245_;
                  vala_ccode_function_call_add_argument (reg_call, (ValaCCodeExpression*) _tmp246_);
                  _vala_ccode_node_unref0 (_tmp246_);
                  _vala_ccode_node_unref0 (enum_decl);
                  _vala_ccode_node_unref0 (clist_ev);
                  _vala_ccode_node_unref0 (clist);
                  _vala_code_node_unref0 (en);
            } else {
                  ValaCCodeIdentifier* _tmp247_ = NULL;
                  ValaCCodeIdentifier* _tmp248_;
                  gchar* _tmp251_ = NULL;
                  gchar* _tmp252_;
                  ValaCCodeConstant* _tmp253_ = NULL;
                  ValaCCodeConstant* _tmp254_;
                  _tmp247_ = vala_ccode_identifier_new ("&g_define_type_info");
                  _tmp248_ = _tmp247_;
                  vala_ccode_function_call_add_argument (reg_call, (ValaCCodeExpression*) _tmp248_);
                  _vala_ccode_node_unref0 (_tmp248_);
                  if (fundamental) {
                        ValaCCodeIdentifier* _tmp249_ = NULL;
                        ValaCCodeIdentifier* _tmp250_;
                        _tmp249_ = vala_ccode_identifier_new ("&g_define_type_fundamental_info");
                        _tmp250_ = _tmp249_;
                        vala_ccode_function_call_add_argument (reg_call, (ValaCCodeExpression*) _tmp250_);
                        _vala_ccode_node_unref0 (_tmp250_);
                  }
                  _tmp251_ = vala_typeregister_function_get_type_flags (self);
                  _tmp252_ = _tmp251_;
                  _tmp253_ = vala_ccode_constant_new (_tmp252_);
                  _tmp254_ = _tmp253_;
                  vala_ccode_function_call_add_argument (reg_call, (ValaCCodeExpression*) _tmp254_);
                  _vala_ccode_node_unref0 (_tmp254_);
                  _g_free0 (_tmp252_);
            }
      }
      if (use_thread_safe) {
            _tmp255_ = !plugin;
      } else {
            _tmp255_ = FALSE;
      }
      if (_tmp255_) {
            ValaCCodeDeclaration* _tmp256_ = NULL;
            ValaCCodeDeclaration* temp_decl;
            ValaCCodeVariableDeclarator* _tmp257_ = NULL;
            ValaCCodeVariableDeclarator* _tmp258_;
            _tmp256_ = vala_ccode_declaration_new ("GType");
            temp_decl = _tmp256_;
            _tmp257_ = vala_ccode_variable_declarator_new (type_id_name, (ValaCCodeExpression*) reg_call, NULL);
            _tmp258_ = _tmp257_;
            vala_ccode_declaration_add_declarator (temp_decl, (ValaCCodeDeclarator*) _tmp258_);
            _vala_ccode_node_unref0 (_tmp258_);
            vala_ccode_block_add_statement (type_init, (ValaCCodeNode*) temp_decl);
            _vala_ccode_node_unref0 (temp_decl);
      } else {
            ValaCCodeIdentifier* _tmp259_ = NULL;
            ValaCCodeIdentifier* _tmp260_;
            ValaCCodeAssignment* _tmp261_ = NULL;
            ValaCCodeAssignment* _tmp262_;
            ValaCCodeExpressionStatement* _tmp263_ = NULL;
            ValaCCodeExpressionStatement* _tmp264_;
            _tmp259_ = vala_ccode_identifier_new (type_id_name);
            _tmp260_ = _tmp259_;
            _tmp261_ = vala_ccode_assignment_new ((ValaCCodeExpression*) _tmp260_, (ValaCCodeExpression*) reg_call, VALA_CCODE_ASSIGNMENT_OPERATOR_SIMPLE);
            _tmp262_ = _tmp261_;
            _tmp263_ = vala_ccode_expression_statement_new ((ValaCCodeExpression*) _tmp262_);
            _tmp264_ = _tmp263_;
            vala_ccode_block_add_statement (type_init, (ValaCCodeNode*) _tmp264_);
            _vala_ccode_node_unref0 (_tmp264_);
            _vala_ccode_node_unref0 (_tmp262_);
            _vala_ccode_node_unref0 (_tmp260_);
      }
      if (cl != NULL) {
            gboolean _tmp267_;
            _tmp267_ = vala_class_get_has_class_private_fields (cl);
            _tmp266_ = _tmp267_;
      } else {
            _tmp266_ = FALSE;
      }
      if (_tmp266_) {
            gboolean _tmp268_;
            _tmp268_ = vala_code_context_require_glib_version (self->priv->_context, 2, 24);
            _tmp265_ = _tmp268_;
      } else {
            _tmp265_ = FALSE;
      }
      if (_tmp265_) {
            ValaCCodeFunctionCall* add_class_private_call = NULL;
            ValaCCodeIdentifier* _tmp269_ = NULL;
            ValaCCodeIdentifier* _tmp270_;
            ValaCCodeFunctionCall* _tmp271_ = NULL;
            ValaCCodeIdentifier* _tmp272_ = NULL;
            ValaCCodeIdentifier* _tmp273_;
            ValaTypeSymbol* _tmp274_ = NULL;
            ValaTypeSymbol* _tmp275_;
            gchar* _tmp276_ = NULL;
            gchar* _tmp277_;
            gchar* _tmp278_ = NULL;
            gchar* _tmp279_;
            ValaCCodeIdentifier* _tmp280_ = NULL;
            ValaCCodeIdentifier* _tmp281_;
            ValaCCodeExpressionStatement* _tmp282_ = NULL;
            ValaCCodeExpressionStatement* _tmp283_;
            _tmp269_ = vala_ccode_identifier_new ("g_type_add_class_private");
            _tmp270_ = _tmp269_;
            _tmp271_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp270_);
            _vala_ccode_node_unref0 (add_class_private_call);
            add_class_private_call = _tmp271_;
            _vala_ccode_node_unref0 (_tmp270_);
            _tmp272_ = vala_ccode_identifier_new (type_id_name);
            _tmp273_ = _tmp272_;
            vala_ccode_function_call_add_argument (add_class_private_call, (ValaCCodeExpression*) _tmp273_);
            _vala_ccode_node_unref0 (_tmp273_);
            _tmp274_ = vala_typeregister_function_get_type_declaration (self);
            _tmp275_ = _tmp274_;
            _tmp276_ = vala_typesymbol_get_cname (_tmp275_, FALSE);
            _tmp277_ = _tmp276_;
            _tmp278_ = g_strdup_printf ("sizeof (%sClassPrivate)", _tmp277_);
            _tmp279_ = _tmp278_;
            _tmp280_ = vala_ccode_identifier_new (_tmp279_);
            _tmp281_ = _tmp280_;
            vala_ccode_function_call_add_argument (add_class_private_call, (ValaCCodeExpression*) _tmp281_);
            _vala_ccode_node_unref0 (_tmp281_);
            _g_free0 (_tmp279_);
            _g_free0 (_tmp277_);
            _vala_code_node_unref0 (_tmp275_);
            _tmp282_ = vala_ccode_expression_statement_new ((ValaCCodeExpression*) add_class_private_call);
            _tmp283_ = _tmp282_;
            vala_ccode_block_add_statement (type_init, (ValaCCodeNode*) _tmp283_);
            _vala_ccode_node_unref0 (_tmp283_);
            _vala_ccode_node_unref0 (add_class_private_call);
      }
      if (!declaration_only) {
            vala_typeregister_function_get_type_interface_init_statements (self, type_init, plugin);
      }
      if (!plugin) {
            ValaCCodeExpression* condition = NULL;
            ValaCCodeExpression* cond = NULL;
            ValaCCodeIfStatement* _tmp317_ = NULL;
            ValaCCodeIfStatement* cif;
            if (use_thread_safe) {
                  ValaCCodeIdentifier* _tmp284_ = NULL;
                  ValaCCodeIdentifier* _tmp285_;
                  ValaCCodeFunctionCall* _tmp286_ = NULL;
                  ValaCCodeFunctionCall* _tmp287_;
                  ValaCCodeFunctionCall* enter;
                  gchar* _tmp288_;
                  gchar* _tmp289_;
                  ValaCCodeIdentifier* _tmp290_ = NULL;
                  ValaCCodeIdentifier* _tmp291_;
                  ValaCCodeUnaryExpression* _tmp292_ = NULL;
                  ValaCCodeUnaryExpression* _tmp293_;
                  ValaCCodeExpression* _tmp294_;
                  ValaCCodeIdentifier* _tmp295_ = NULL;
                  ValaCCodeIdentifier* _tmp296_;
                  ValaCCodeFunctionCall* _tmp297_ = NULL;
                  ValaCCodeFunctionCall* _tmp298_;
                  ValaCCodeFunctionCall* leave;
                  gchar* _tmp299_;
                  gchar* _tmp300_;
                  ValaCCodeIdentifier* _tmp301_ = NULL;
                  ValaCCodeIdentifier* _tmp302_;
                  ValaCCodeUnaryExpression* _tmp303_ = NULL;
                  ValaCCodeUnaryExpression* _tmp304_;
                  ValaCCodeIdentifier* _tmp305_ = NULL;
                  ValaCCodeIdentifier* _tmp306_;
                  ValaCCodeExpressionStatement* _tmp307_ = NULL;
                  ValaCCodeExpressionStatement* _tmp308_;
                  _tmp284_ = vala_ccode_identifier_new ("g_once_init_enter");
                  _tmp285_ = _tmp284_;
                  _tmp286_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp285_);
                  _tmp287_ = _tmp286_;
                  _vala_ccode_node_unref0 (_tmp285_);
                  enter = _tmp287_;
                  _tmp288_ = g_strconcat (type_id_name, "__volatile", NULL);
                  _tmp289_ = _tmp288_;
                  _tmp290_ = vala_ccode_identifier_new (_tmp289_);
                  _tmp291_ = _tmp290_;
                  _tmp292_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp291_);
                  _tmp293_ = _tmp292_;
                  vala_ccode_function_call_add_argument (enter, (ValaCCodeExpression*) _tmp293_);
                  _vala_ccode_node_unref0 (_tmp293_);
                  _vala_ccode_node_unref0 (_tmp291_);
                  _g_free0 (_tmp289_);
                  _tmp294_ = _vala_ccode_node_ref0 ((ValaCCodeExpression*) enter);
                  _vala_ccode_node_unref0 (condition);
                  condition = _tmp294_;
                  _tmp295_ = vala_ccode_identifier_new ("g_once_init_leave");
                  _tmp296_ = _tmp295_;
                  _tmp297_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp296_);
                  _tmp298_ = _tmp297_;
                  _vala_ccode_node_unref0 (_tmp296_);
                  leave = _tmp298_;
                  _tmp299_ = g_strconcat (type_id_name, "__volatile", NULL);
                  _tmp300_ = _tmp299_;
                  _tmp301_ = vala_ccode_identifier_new (_tmp300_);
                  _tmp302_ = _tmp301_;
                  _tmp303_ = vala_ccode_unary_expression_new (VALA_CCODE_UNARY_OPERATOR_ADDRESS_OF, (ValaCCodeExpression*) _tmp302_);
                  _tmp304_ = _tmp303_;
                  vala_ccode_function_call_add_argument (leave, (ValaCCodeExpression*) _tmp304_);
                  _vala_ccode_node_unref0 (_tmp304_);
                  _vala_ccode_node_unref0 (_tmp302_);
                  _g_free0 (_tmp300_);
                  _tmp305_ = vala_ccode_identifier_new (type_id_name);
                  _tmp306_ = _tmp305_;
                  vala_ccode_function_call_add_argument (leave, (ValaCCodeExpression*) _tmp306_);
                  _vala_ccode_node_unref0 (_tmp306_);
                  _tmp307_ = vala_ccode_expression_statement_new ((ValaCCodeExpression*) leave);
                  _tmp308_ = _tmp307_;
                  vala_ccode_block_add_statement (type_init, (ValaCCodeNode*) _tmp308_);
                  _vala_ccode_node_unref0 (_tmp308_);
                  _vala_ccode_node_unref0 (leave);
                  _vala_ccode_node_unref0 (enter);
            } else {
                  ValaCCodeIdentifier* _tmp309_ = NULL;
                  ValaCCodeIdentifier* id;
                  ValaCCodeConstant* _tmp310_ = NULL;
                  ValaCCodeConstant* zero;
                  ValaCCodeBinaryExpression* _tmp311_ = NULL;
                  _tmp309_ = vala_ccode_identifier_new (type_id_name);
                  id = _tmp309_;
                  _tmp310_ = vala_ccode_constant_new ("0");
                  zero = _tmp310_;
                  _tmp311_ = vala_ccode_binary_expression_new (VALA_CCODE_BINARY_OPERATOR_EQUALITY, (ValaCCodeExpression*) id, (ValaCCodeExpression*) zero);
                  _vala_ccode_node_unref0 (condition);
                  condition = (ValaCCodeExpression*) _tmp311_;
                  _vala_ccode_node_unref0 (zero);
                  _vala_ccode_node_unref0 (id);
            }
            if (use_thread_safe) {
                  ValaCCodeExpression* _tmp312_;
                  _tmp312_ = _vala_ccode_node_ref0 (condition);
                  _vala_ccode_node_unref0 (cond);
                  cond = _tmp312_;
            } else {
                  ValaCCodeIdentifier* _tmp313_ = NULL;
                  ValaCCodeIdentifier* _tmp314_;
                  ValaCCodeFunctionCall* _tmp315_ = NULL;
                  ValaCCodeExpression* _tmp316_;
                  _tmp313_ = vala_ccode_identifier_new ("G_UNLIKELY");
                  _tmp314_ = _tmp313_;
                  _tmp315_ = vala_ccode_function_call_new ((ValaCCodeExpression*) _tmp314_);
                  _vala_ccode_node_unref0 (cond);
                  cond = (ValaCCodeExpression*) _tmp315_;
                  _vala_ccode_node_unref0 (_tmp314_);
                  _tmp316_ = cond;
                  vala_ccode_function_call_add_argument (VALA_IS_CCODE_FUNCTION_CALL (_tmp316_) ? ((ValaCCodeFunctionCall*) _tmp316_) : NULL, condition);
            }
            _tmp317_ = vala_ccode_if_statement_new (cond, (ValaCCodeStatement*) type_init, NULL);
            cif = _tmp317_;
            vala_ccode_block_add_statement (type_block, (ValaCCodeNode*) cif);
            _vala_ccode_node_unref0 (cif);
            _vala_ccode_node_unref0 (cond);
            _vala_ccode_node_unref0 (condition);
      } else {
            ValaCCodeBlock* _tmp318_;
            _tmp318_ = _vala_ccode_node_ref0 (type_init);
            _vala_ccode_node_unref0 (type_block);
            type_block = _tmp318_;
      }
      if (use_thread_safe) {
            gchar* _tmp319_;
            gchar* _tmp320_;
            ValaCCodeIdentifier* _tmp321_ = NULL;
            ValaCCodeIdentifier* _tmp322_;
            ValaCCodeReturnStatement* _tmp323_ = NULL;
            ValaCCodeReturnStatement* _tmp324_;
            _tmp319_ = g_strconcat (type_id_name, "__volatile", NULL);
            _tmp320_ = _tmp319_;
            _tmp321_ = vala_ccode_identifier_new (_tmp320_);
            _tmp322_ = _tmp321_;
            _tmp323_ = vala_ccode_return_statement_new ((ValaCCodeExpression*) _tmp322_);
            _tmp324_ = _tmp323_;
            vala_ccode_block_add_statement (type_block, (ValaCCodeNode*) _tmp324_);
            _vala_ccode_node_unref0 (_tmp324_);
            _vala_ccode_node_unref0 (_tmp322_);
            _g_free0 (_tmp320_);
      } else {
            ValaCCodeIdentifier* _tmp325_ = NULL;
            ValaCCodeIdentifier* _tmp326_;
            ValaCCodeReturnStatement* _tmp327_ = NULL;
            ValaCCodeReturnStatement* _tmp328_;
            _tmp325_ = vala_ccode_identifier_new (type_id_name);
            _tmp326_ = _tmp325_;
            _tmp327_ = vala_ccode_return_statement_new ((ValaCCodeExpression*) _tmp326_);
            _tmp328_ = _tmp327_;
            vala_ccode_block_add_statement (type_block, (ValaCCodeNode*) _tmp328_);
            _vala_ccode_node_unref0 (_tmp328_);
            _vala_ccode_node_unref0 (_tmp326_);
      }
      vala_ccode_function_set_is_declaration (fun, TRUE);
      _tmp329_ = vala_ccode_function_copy (fun);
      _tmp330_ = _tmp329_;
      vala_ccode_fragment_append (self->priv->declaration_fragment, (ValaCCodeNode*) _tmp330_);
      _vala_ccode_node_unref0 (_tmp330_);
      vala_ccode_function_set_is_declaration (fun, FALSE);
      vala_ccode_function_set_block (fun, type_block);
      vala_ccode_fragment_append (self->priv->definition_fragment, (ValaCCodeNode*) fun);
      _vala_ccode_node_unref0 (reg_call);
      _vala_ccode_node_unref0 (type_init);
      _g_free0 (type_value_table_decl_name);
      _vala_ccode_node_unref0 (fun);
      _vala_ccode_node_unref0 (_cdecl_);
      _vala_ccode_node_unref0 (type_block);
      _g_free0 (type_id_name);
      _vala_code_node_unref0 (cl);
}


/**
 * Returns the data type to be registered.
 *
 * @return type to be registered
 */
static ValaTypeSymbol* vala_typeregister_function_real_get_type_declaration (ValaTypeRegisterFunction* self) {
      g_return_val_if_fail (self != NULL, NULL);
      g_critical ("Type `%s' does not implement abstract method `vala_typeregister_function_get_type_declaration'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
      return NULL;
}


ValaTypeSymbol* vala_typeregister_function_get_type_declaration (ValaTypeRegisterFunction* self) {
      return VALA_TYPEREGISTER_FUNCTION_GET_CLASS (self)->get_type_declaration (self);
}


/**
 * Returns the name of the type struct in C code.
 *
 * @return C struct name
 */
static gchar* vala_typeregister_function_real_get_type_struct_name (ValaTypeRegisterFunction* self) {
      gchar* result = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      g_assert_not_reached ();
      return result;
}


gchar* vala_typeregister_function_get_type_struct_name (ValaTypeRegisterFunction* self) {
      return VALA_TYPEREGISTER_FUNCTION_GET_CLASS (self)->get_type_struct_name (self);
}


/**
 * Returns the name of the base_init function in C code.
 *
 * @return C function name
 */
static gchar* vala_typeregister_function_real_get_base_init_func_name (ValaTypeRegisterFunction* self) {
      gchar* result = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      g_assert_not_reached ();
      return result;
}


gchar* vala_typeregister_function_get_base_init_func_name (ValaTypeRegisterFunction* self) {
      return VALA_TYPEREGISTER_FUNCTION_GET_CLASS (self)->get_base_init_func_name (self);
}


/**
 * Returns the name of the class_finalize function in C code.
 *
 * @return C function name
 */
static gchar* vala_typeregister_function_real_get_class_finalize_func_name (ValaTypeRegisterFunction* self) {
      gchar* result = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      g_assert_not_reached ();
      return result;
}


gchar* vala_typeregister_function_get_class_finalize_func_name (ValaTypeRegisterFunction* self) {
      return VALA_TYPEREGISTER_FUNCTION_GET_CLASS (self)->get_class_finalize_func_name (self);
}


/**
 * Returns the name of the base_finalize function in C code.
 *
 * @return C function name
 */
static gchar* vala_typeregister_function_real_get_base_finalize_func_name (ValaTypeRegisterFunction* self) {
      gchar* result = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      g_assert_not_reached ();
      return result;
}


gchar* vala_typeregister_function_get_base_finalize_func_name (ValaTypeRegisterFunction* self) {
      return VALA_TYPEREGISTER_FUNCTION_GET_CLASS (self)->get_base_finalize_func_name (self);
}


/**
 * Returns the name of the class_init function in C code.
 *
 * @return C function name
 */
static gchar* vala_typeregister_function_real_get_class_init_func_name (ValaTypeRegisterFunction* self) {
      gchar* result = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      g_assert_not_reached ();
      return result;
}


gchar* vala_typeregister_function_get_class_init_func_name (ValaTypeRegisterFunction* self) {
      return VALA_TYPEREGISTER_FUNCTION_GET_CLASS (self)->get_class_init_func_name (self);
}


/**
 * Returns the size of the instance struct in C code.
 *
 * @return C instance struct size
 */
static gchar* vala_typeregister_function_real_get_instance_struct_size (ValaTypeRegisterFunction* self) {
      gchar* result = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      g_assert_not_reached ();
      return result;
}


gchar* vala_typeregister_function_get_instance_struct_size (ValaTypeRegisterFunction* self) {
      return VALA_TYPEREGISTER_FUNCTION_GET_CLASS (self)->get_instance_struct_size (self);
}


/**
 * Returns the name of the instance_init function in C code.
 *
 * @return C function name
 */
static gchar* vala_typeregister_function_real_get_instance_init_func_name (ValaTypeRegisterFunction* self) {
      gchar* result = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      g_assert_not_reached ();
      return result;
}


gchar* vala_typeregister_function_get_instance_init_func_name (ValaTypeRegisterFunction* self) {
      return VALA_TYPEREGISTER_FUNCTION_GET_CLASS (self)->get_instance_init_func_name (self);
}


/**
 * Returns the name of the parent type in C code.
 *
 * @return C function name
 */
static gchar* vala_typeregister_function_real_get_parent_type_name (ValaTypeRegisterFunction* self) {
      gchar* result = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      g_assert_not_reached ();
      return result;
}


gchar* vala_typeregister_function_get_parent_type_name (ValaTypeRegisterFunction* self) {
      return VALA_TYPEREGISTER_FUNCTION_GET_CLASS (self)->get_parent_type_name (self);
}


/**
 * Returns the C-name of the new generated GTypeValueTable init function or null when not available.
 *
 * @return C function name
 */
static gchar* vala_typeregister_function_real_get_gtype_value_table_init_function_name (ValaTypeRegisterFunction* self) {
      gchar* result = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      result = NULL;
      return result;
}


gchar* vala_typeregister_function_get_gtype_value_table_init_function_name (ValaTypeRegisterFunction* self) {
      return VALA_TYPEREGISTER_FUNCTION_GET_CLASS (self)->get_gtype_value_table_init_function_name (self);
}


/**
 * Returns the C-name of the new generated GTypeValueTable peek pointer function or null when not available.
 *
 * @return C function name
 */
static gchar* vala_typeregister_function_real_get_gtype_value_table_peek_pointer_function_name (ValaTypeRegisterFunction* self) {
      gchar* result = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      result = NULL;
      return result;
}


gchar* vala_typeregister_function_get_gtype_value_table_peek_pointer_function_name (ValaTypeRegisterFunction* self) {
      return VALA_TYPEREGISTER_FUNCTION_GET_CLASS (self)->get_gtype_value_table_peek_pointer_function_name (self);
}


/**
 * Returns the C-name of the new generated GTypeValueTable free function or null when not available.
 *
 * @return C function name
 */
static gchar* vala_typeregister_function_real_get_gtype_value_table_free_function_name (ValaTypeRegisterFunction* self) {
      gchar* result = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      result = NULL;
      return result;
}


gchar* vala_typeregister_function_get_gtype_value_table_free_function_name (ValaTypeRegisterFunction* self) {
      return VALA_TYPEREGISTER_FUNCTION_GET_CLASS (self)->get_gtype_value_table_free_function_name (self);
}


/**
 * Returns the C-name of the new generated GTypeValueTable copy function or null when not available.
 *
 * @return C function name
 */
static gchar* vala_typeregister_function_real_get_gtype_value_table_copy_function_name (ValaTypeRegisterFunction* self) {
      gchar* result = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      result = NULL;
      return result;
}


gchar* vala_typeregister_function_get_gtype_value_table_copy_function_name (ValaTypeRegisterFunction* self) {
      return VALA_TYPEREGISTER_FUNCTION_GET_CLASS (self)->get_gtype_value_table_copy_function_name (self);
}


/**
 * Returns the C-name of the new generated GTypeValueTable lcopy function or null when not available.
 *
 * @return C function name
 */
static gchar* vala_typeregister_function_real_get_gtype_value_table_lcopy_value_function_name (ValaTypeRegisterFunction* self) {
      gchar* result = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      result = NULL;
      return result;
}


gchar* vala_typeregister_function_get_gtype_value_table_lcopy_value_function_name (ValaTypeRegisterFunction* self) {
      return VALA_TYPEREGISTER_FUNCTION_GET_CLASS (self)->get_gtype_value_table_lcopy_value_function_name (self);
}


/**
 * Returns the C-name of the new generated GTypeValueTable collect value function or null when not available.
 *
 * @return C function name
 */
static gchar* vala_typeregister_function_real_get_gtype_value_table_collect_value_function_name (ValaTypeRegisterFunction* self) {
      gchar* result = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      result = NULL;
      return result;
}


gchar* vala_typeregister_function_get_gtype_value_table_collect_value_function_name (ValaTypeRegisterFunction* self) {
      return VALA_TYPEREGISTER_FUNCTION_GET_CLASS (self)->get_gtype_value_table_collect_value_function_name (self);
}


/**
 * Returns the set of type flags to be applied when registering.
 *
 * @return type flags
 */
static gchar* vala_typeregister_function_real_get_type_flags (ValaTypeRegisterFunction* self) {
      gchar* result = NULL;
      gchar* _tmp0_;
      g_return_val_if_fail (self != NULL, NULL);
      _tmp0_ = g_strdup ("0");
      result = _tmp0_;
      return result;
}


gchar* vala_typeregister_function_get_type_flags (ValaTypeRegisterFunction* self) {
      return VALA_TYPEREGISTER_FUNCTION_GET_CLASS (self)->get_type_flags (self);
}


/**
 * Returns additional C declarations to setup interfaces.
 *
 * @return C declarations
 */
static ValaCCodeFragment* vala_typeregister_function_real_get_type_interface_init_declaration (ValaTypeRegisterFunction* self) {
      ValaCCodeFragment* result = NULL;
      ValaCCodeFragment* _tmp0_ = NULL;
      g_return_val_if_fail (self != NULL, NULL);
      _tmp0_ = vala_ccode_fragment_new ();
      result = _tmp0_;
      return result;
}


ValaCCodeFragment* vala_typeregister_function_get_type_interface_init_declaration (ValaTypeRegisterFunction* self) {
      return VALA_TYPEREGISTER_FUNCTION_GET_CLASS (self)->get_type_interface_init_declaration (self);
}


/**
 * Returns additional C initialization statements to setup interfaces.
 *
 * @return C statements
 */
static void vala_typeregister_function_real_get_type_interface_init_statements (ValaTypeRegisterFunction* self, ValaCCodeBlock* block, gboolean plugin) {
      g_return_if_fail (self != NULL);
      g_return_if_fail (block != NULL);
}


void vala_typeregister_function_get_type_interface_init_statements (ValaTypeRegisterFunction* self, ValaCCodeBlock* block, gboolean plugin) {
      VALA_TYPEREGISTER_FUNCTION_GET_CLASS (self)->get_type_interface_init_statements (self, block, plugin);
}


ValaCCodeFragment* vala_typeregister_function_get_source_declaration (ValaTypeRegisterFunction* self) {
      ValaCCodeFragment* result = NULL;
      ValaCCodeFragment* _tmp0_;
      g_return_val_if_fail (self != NULL, NULL);
      _tmp0_ = _vala_ccode_node_ref0 (self->priv->source_declaration_fragment);
      result = _tmp0_;
      return result;
}


/**
 * Returns the declaration for this type register function in C code.
 *
 * @return C function declaration fragment
 */
ValaCCodeFragment* vala_typeregister_function_get_declaration (ValaTypeRegisterFunction* self) {
      ValaCCodeFragment* result = NULL;
      ValaCCodeFragment* _tmp0_;
      g_return_val_if_fail (self != NULL, NULL);
      _tmp0_ = _vala_ccode_node_ref0 (self->priv->declaration_fragment);
      result = _tmp0_;
      return result;
}


/**
 * Returns the definition for this type register function in C code.
 *
 * @return C function definition fragment
 */
ValaCCodeFragment* vala_typeregister_function_get_definition (ValaTypeRegisterFunction* self) {
      ValaCCodeFragment* result = NULL;
      ValaCCodeFragment* _tmp0_;
      g_return_val_if_fail (self != NULL, NULL);
      _tmp0_ = _vala_ccode_node_ref0 (self->priv->definition_fragment);
      result = _tmp0_;
      return result;
}


/**
 * Returns the accessibility for this type.
 */
static ValaSymbolAccessibility vala_typeregister_function_real_get_accessibility (ValaTypeRegisterFunction* self) {
      g_return_val_if_fail (self != NULL, 0);
      g_critical ("Type `%s' does not implement abstract method `vala_typeregister_function_get_accessibility'", g_type_name (G_TYPE_FROM_INSTANCE (self)));
      return 0;
}


ValaSymbolAccessibility vala_typeregister_function_get_accessibility (ValaTypeRegisterFunction* self) {
      return VALA_TYPEREGISTER_FUNCTION_GET_CLASS (self)->get_accessibility (self);
}


ValaTypeRegisterFunction* vala_typeregister_function_construct (GType object_type) {
      ValaTypeRegisterFunction* self = NULL;
      self = (ValaTypeRegisterFunction*) g_type_create_instance (object_type);
      return self;
}


ValaCodeContext* vala_typeregister_function_get_context (ValaTypeRegisterFunction* self) {
      ValaCodeContext* result;
      g_return_val_if_fail (self != NULL, NULL);
      result = self->priv->_context;
      return result;
}


static gpointer _vala_code_context_ref0 (gpointer self) {
      return self ? vala_code_context_ref (self) : NULL;
}


void vala_typeregister_function_set_context (ValaTypeRegisterFunction* self, ValaCodeContext* value) {
      ValaCodeContext* _tmp0_;
      g_return_if_fail (self != NULL);
      _tmp0_ = _vala_code_context_ref0 (value);
      _vala_code_context_unref0 (self->priv->_context);
      self->priv->_context = _tmp0_;
}


static void vala_value_typeregister_function_init (GValue* value) {
      value->data[0].v_pointer = NULL;
}


static void vala_value_typeregister_function_free_value (GValue* value) {
      if (value->data[0].v_pointer) {
            vala_typeregister_function_unref (value->data[0].v_pointer);
      }
}


static void vala_value_typeregister_function_copy_value (const GValue* src_value, GValue* dest_value) {
      if (src_value->data[0].v_pointer) {
            dest_value->data[0].v_pointer = vala_typeregister_function_ref (src_value->data[0].v_pointer);
      } else {
            dest_value->data[0].v_pointer = NULL;
      }
}


static gpointer vala_value_typeregister_function_peek_pointer (const GValue* value) {
      return value->data[0].v_pointer;
}


static gchar* vala_value_typeregister_function_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
      if (collect_values[0].v_pointer) {
            ValaTypeRegisterFunction* object;
            object = collect_values[0].v_pointer;
            if (object->parent_instance.g_class == NULL) {
                  return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
            } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
                  return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
            }
            value->data[0].v_pointer = vala_typeregister_function_ref (object);
      } else {
            value->data[0].v_pointer = NULL;
      }
      return NULL;
}


static gchar* vala_value_typeregister_function_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
      ValaTypeRegisterFunction** object_p;
      object_p = collect_values[0].v_pointer;
      if (!object_p) {
            return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
      }
      if (!value->data[0].v_pointer) {
            *object_p = NULL;
      } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
            *object_p = value->data[0].v_pointer;
      } else {
            *object_p = vala_typeregister_function_ref (value->data[0].v_pointer);
      }
      return NULL;
}


GParamSpec* vala_param_spec_typeregister_function (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
      ValaParamSpecTypeRegisterFunction* spec;
      g_return_val_if_fail (g_type_is_a (object_type, VALA_TYPE_TYPEREGISTER_FUNCTION), NULL);
      spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
      G_PARAM_SPEC (spec)->value_type = object_type;
      return G_PARAM_SPEC (spec);
}


gpointer vala_value_get_typeregister_function (const GValue* value) {
      g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_TYPE_TYPEREGISTER_FUNCTION), NULL);
      return value->data[0].v_pointer;
}


void vala_value_set_typeregister_function (GValue* value, gpointer v_object) {
      ValaTypeRegisterFunction* old;
      g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_TYPE_TYPEREGISTER_FUNCTION));
      old = value->data[0].v_pointer;
      if (v_object) {
            g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_TYPE_TYPEREGISTER_FUNCTION));
            g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
            value->data[0].v_pointer = v_object;
            vala_typeregister_function_ref (value->data[0].v_pointer);
      } else {
            value->data[0].v_pointer = NULL;
      }
      if (old) {
            vala_typeregister_function_unref (old);
      }
}


void vala_value_take_typeregister_function (GValue* value, gpointer v_object) {
      ValaTypeRegisterFunction* old;
      g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, VALA_TYPE_TYPEREGISTER_FUNCTION));
      old = value->data[0].v_pointer;
      if (v_object) {
            g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, VALA_TYPE_TYPEREGISTER_FUNCTION));
            g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
            value->data[0].v_pointer = v_object;
      } else {
            value->data[0].v_pointer = NULL;
      }
      if (old) {
            vala_typeregister_function_unref (old);
      }
}


static void vala_typeregister_function_class_init (ValaTypeRegisterFunctionClass * klass) {
      vala_typeregister_function_parent_class = g_type_class_peek_parent (klass);
      VALA_TYPEREGISTER_FUNCTION_CLASS (klass)->finalize = vala_typeregister_function_finalize;
      g_type_class_add_private (klass, sizeof (ValaTypeRegisterFunctionPrivate));
      VALA_TYPEREGISTER_FUNCTION_CLASS (klass)->get_type_declaration = vala_typeregister_function_real_get_type_declaration;
      VALA_TYPEREGISTER_FUNCTION_CLASS (klass)->get_type_struct_name = vala_typeregister_function_real_get_type_struct_name;
      VALA_TYPEREGISTER_FUNCTION_CLASS (klass)->get_base_init_func_name = vala_typeregister_function_real_get_base_init_func_name;
      VALA_TYPEREGISTER_FUNCTION_CLASS (klass)->get_class_finalize_func_name = vala_typeregister_function_real_get_class_finalize_func_name;
      VALA_TYPEREGISTER_FUNCTION_CLASS (klass)->get_base_finalize_func_name = vala_typeregister_function_real_get_base_finalize_func_name;
      VALA_TYPEREGISTER_FUNCTION_CLASS (klass)->get_class_init_func_name = vala_typeregister_function_real_get_class_init_func_name;
      VALA_TYPEREGISTER_FUNCTION_CLASS (klass)->get_instance_struct_size = vala_typeregister_function_real_get_instance_struct_size;
      VALA_TYPEREGISTER_FUNCTION_CLASS (klass)->get_instance_init_func_name = vala_typeregister_function_real_get_instance_init_func_name;
      VALA_TYPEREGISTER_FUNCTION_CLASS (klass)->get_parent_type_name = vala_typeregister_function_real_get_parent_type_name;
      VALA_TYPEREGISTER_FUNCTION_CLASS (klass)->get_gtype_value_table_init_function_name = vala_typeregister_function_real_get_gtype_value_table_init_function_name;
      VALA_TYPEREGISTER_FUNCTION_CLASS (klass)->get_gtype_value_table_peek_pointer_function_name = vala_typeregister_function_real_get_gtype_value_table_peek_pointer_function_name;
      VALA_TYPEREGISTER_FUNCTION_CLASS (klass)->get_gtype_value_table_free_function_name = vala_typeregister_function_real_get_gtype_value_table_free_function_name;
      VALA_TYPEREGISTER_FUNCTION_CLASS (klass)->get_gtype_value_table_copy_function_name = vala_typeregister_function_real_get_gtype_value_table_copy_function_name;
      VALA_TYPEREGISTER_FUNCTION_CLASS (klass)->get_gtype_value_table_lcopy_value_function_name = vala_typeregister_function_real_get_gtype_value_table_lcopy_value_function_name;
      VALA_TYPEREGISTER_FUNCTION_CLASS (klass)->get_gtype_value_table_collect_value_function_name = vala_typeregister_function_real_get_gtype_value_table_collect_value_function_name;
      VALA_TYPEREGISTER_FUNCTION_CLASS (klass)->get_type_flags = vala_typeregister_function_real_get_type_flags;
      VALA_TYPEREGISTER_FUNCTION_CLASS (klass)->get_type_interface_init_declaration = vala_typeregister_function_real_get_type_interface_init_declaration;
      VALA_TYPEREGISTER_FUNCTION_CLASS (klass)->get_type_interface_init_statements = vala_typeregister_function_real_get_type_interface_init_statements;
      VALA_TYPEREGISTER_FUNCTION_CLASS (klass)->get_accessibility = vala_typeregister_function_real_get_accessibility;
}


static void vala_typeregister_function_instance_init (ValaTypeRegisterFunction * self) {
      ValaCCodeFragment* _tmp0_ = NULL;
      ValaCCodeFragment* _tmp1_ = NULL;
      ValaCCodeFragment* _tmp2_ = NULL;
      self->priv = VALA_TYPEREGISTER_FUNCTION_GET_PRIVATE (self);
      _tmp0_ = vala_ccode_fragment_new ();
      self->priv->source_declaration_fragment = _tmp0_;
      _tmp1_ = vala_ccode_fragment_new ();
      self->priv->declaration_fragment = _tmp1_;
      _tmp2_ = vala_ccode_fragment_new ();
      self->priv->definition_fragment = _tmp2_;
      self->ref_count = 1;
}


static void vala_typeregister_function_finalize (ValaTypeRegisterFunction* obj) {
      ValaTypeRegisterFunction * self;
      self = VALA_TYPEREGISTER_FUNCTION (obj);
      _vala_ccode_node_unref0 (self->priv->source_declaration_fragment);
      _vala_ccode_node_unref0 (self->priv->declaration_fragment);
      _vala_ccode_node_unref0 (self->priv->definition_fragment);
      _vala_code_context_unref0 (self->priv->_context);
}


/**
 * C function to register a type at runtime.
 */
GType vala_typeregister_function_get_type (void) {
      static volatile gsize vala_typeregister_function_type_id__volatile = 0;
      if (g_once_init_enter (&vala_typeregister_function_type_id__volatile)) {
            static const GTypeValueTable g_define_type_value_table = { vala_value_typeregister_function_init, vala_value_typeregister_function_free_value, vala_value_typeregister_function_copy_value, vala_value_typeregister_function_peek_pointer, "p", vala_value_typeregister_function_collect_value, "p", vala_value_typeregister_function_lcopy_value };
            static const GTypeInfo g_define_type_info = { sizeof (ValaTypeRegisterFunctionClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) vala_typeregister_function_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ValaTypeRegisterFunction), 0, (GInstanceInitFunc) vala_typeregister_function_instance_init, &g_define_type_value_table };
            static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
            GType vala_typeregister_function_type_id;
            vala_typeregister_function_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ValaTypeRegisterFunction", &g_define_type_info, &g_define_type_fundamental_info, G_TYPE_FLAG_ABSTRACT);
            g_once_init_leave (&vala_typeregister_function_type_id__volatile, vala_typeregister_function_type_id);
      }
      return vala_typeregister_function_type_id__volatile;
}


gpointer vala_typeregister_function_ref (gpointer instance) {
      ValaTypeRegisterFunction* self;
      self = instance;
      g_atomic_int_inc (&self->ref_count);
      return instance;
}


void vala_typeregister_function_unref (gpointer instance) {
      ValaTypeRegisterFunction* self;
      self = instance;
      if (g_atomic_int_dec_and_test (&self->ref_count)) {
            VALA_TYPEREGISTER_FUNCTION_GET_CLASS (self)->finalize (self);
            g_type_free_instance ((GTypeInstance *) self);
      }
}




Generated by  Doxygen 1.6.0   Back to index