codegen/valaclassregisterfunction.vala

   1 /* valaclassregisterfunction.vala
   2  *
   3  * Copyright (C) 2006-2008  Jürg Billeter
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  18  *
  19  * Author:
  20  *      Jürg Billeter <j@bitron.ch>
  21  */
  22
  23 using GLib;
  24
  25 /**
  26  * C function to register a class at runtime.
  27  */
  28 public class Vala.ClassRegisterFunction : TypeRegisterFunction {
  29         /**
  30          * Specifies the class to be registered.
  31          */
  32         public weak Class class_reference { get; set; }
  33
  34         /**
  35          * Creates a new C function to register the specified class at runtime.
  36          *
  37          * @param cl a class
  38          * @return   newly created class register function
  39          */
  40         public ClassRegisterFunction (Class cl, CodeContext context) {
  41                 class_reference = cl;
  42                 this.context = context;
  43         }
  44
  45         public override TypeSymbol get_type_declaration () {
  46                 return class_reference;
  47         }
  48
  49         public override string get_type_struct_name () {
  50                 return "%sClass".printf (class_reference.get_cname ());
  51         }
  52
  53         public override string get_base_init_func_name () {
  54                 if (class_reference.class_constructor != null || (!context.require_glib_version (2, 24) && class_reference.has_class_private_fields)) {
  55                         return "%s_base_init".printf (class_reference.get_lower_case_cname (null));
  56                 } else {
  57                         return "NULL";
  58                 }
  59         }
  60
  61         public override string get_class_finalize_func_name () {
  62                 if (class_reference.static_destructor != null) {
  63                         return "%s_class_finalize".printf (class_reference.get_lower_case_cname (null));
  64                 } else {
  65                         return "NULL";
  66                 }
  67         }
  68
  69         public override string get_base_finalize_func_name () {
  70                 if (class_reference.class_destructor != null || (!context.require_glib_version (2, 24) && class_reference.has_class_private_fields)) {
  71                         return "%s_base_finalize".printf (class_reference.get_lower_case_cname (null));
  72                 } else {
  73                         return "NULL";
  74                 }
  75         }
  76
  77         public override string get_class_init_func_name () {
  78                 return "%s_class_init".printf (class_reference.get_lower_case_cname (null));
  79         }
  80
  81         public override string get_instance_struct_size () {
  82                 return "sizeof (%s)".printf (class_reference.get_cname ());
  83         }
  84
  85         public override string get_instance_init_func_name () {
  86                 return "%s_instance_init".printf (class_reference.get_lower_case_cname (null));
  87         }
  88
  89         public override string get_parent_type_name () {
  90                 return class_reference.base_class.get_type_id ();
  91         }
  92
  93         public override string get_type_flags () {
  94                 if (class_reference.is_abstract) {
  95                         return "G_TYPE_FLAG_ABSTRACT";
  96                 } else {
  97                         return "0";
  98                 }
  99         }
 100
 101         public override SymbolAccessibility get_accessibility () {
 102                 return class_reference.access;
 103         }
 104
 105         public override string? get_gtype_value_table_init_function_name () {
 106                 bool is_fundamental = !class_reference.is_compact && class_reference.base_class == null;
 107                 if ( is_fundamental )
 108                         return "%s_init".printf (class_reference.get_lower_case_cname ("value_"));
 109
 110                 return null;
 111         }
 112
 113         public override string? get_gtype_value_table_free_function_name () {
 114                 bool is_fundamental = !class_reference.is_compact && class_reference.base_class == null;
 115                 if ( is_fundamental )
 116                         return "%s_free_value".printf (class_reference.get_lower_case_cname ("value_"));
 117
 118                 return null;
 119         }
 120
 121         public override string? get_gtype_value_table_copy_function_name () {
 122                 bool is_fundamental = !class_reference.is_compact && class_reference.base_class == null;
 123                 if ( is_fundamental )
 124                         return "%s_copy_value".printf (class_reference.get_lower_case_cname ("value_"));
 125
 126                 return null;
 127         }
 128
 129         public override string? get_gtype_value_table_peek_pointer_function_name () {
 130                 bool is_fundamental = !class_reference.is_compact && class_reference.base_class == null;
 131                 if ( is_fundamental )
 132                         return "%s_peek_pointer".printf (class_reference.get_lower_case_cname ("value_"));
 133
 134                 return null;
 135         }
 136
 137         public override string? get_gtype_value_table_collect_value_function_name () {
 138                 bool is_fundamental = !class_reference.is_compact && class_reference.base_class == null;
 139                 if ( is_fundamental )
 140                         return "%s_collect_value".printf (class_reference.get_lower_case_cname ("value_"));
 141
 142                 return null;
 143         }
 144
 145         public override string? get_gtype_value_table_lcopy_value_function_name () {
 146                 bool is_fundamental = !class_reference.is_compact && class_reference.base_class == null;
 147                 if ( is_fundamental )
 148                         return "%s_lcopy_value".printf (class_reference.get_lower_case_cname ("value_"));
 149
 150                 return null;
 151         }
 152
 153         public override CCodeFragment get_type_interface_init_declaration () {
 154                 var frag = new CCodeFragment ();
 155
 156                 foreach (DataType base_type in class_reference.get_base_types ()) {
 157                         if (!(base_type.data_type is Interface)) {
 158                                 continue;
 159                         }
 160
 161                         var iface = (Interface) base_type.data_type;
 162
 163                         var iface_info_name = "%s_info".printf (iface.get_lower_case_cname (null));
 164
 165                         var ctypedecl = new CCodeDeclaration ("const GInterfaceInfo");
 166                         ctypedecl.modifiers = CCodeModifiers.STATIC;
 167                         ctypedecl.add_declarator (new CCodeVariableDeclarator (iface_info_name, new CCodeConstant ("{ (GInterfaceInitFunc) %s_%s_interface_init, (GInterfaceFinalizeFunc) NULL, NULL}".printf (class_reference.get_lower_case_cname (null), iface.get_lower_case_cname (null)))));
 168                         frag.append (ctypedecl);
 169                 }
 170
 171                 return frag;
 172         }
 173
 174         public override void get_type_interface_init_statements (CCodeBlock block, bool plugin) {
 175                 foreach (DataType base_type in class_reference.get_base_types ()) {
 176                         if (!(base_type.data_type is Interface)) {
 177                                 continue;
 178                         }
 179
 180                         var iface = (Interface) base_type.data_type;
 181
 182                         var iface_info_name = "%s_info".printf (iface.get_lower_case_cname (null));
 183                         if (!plugin) {
 184                                 var reg_call = new CCodeFunctionCall (new CCodeIdentifier ("g_type_add_interface_static"));
 185                                 reg_call.add_argument (new CCodeIdentifier ("%s_type_id".printf (class_reference.get_lower_case_cname (null))));
 186                                 reg_call.add_argument (new CCodeIdentifier (iface.get_type_id ()));
 187                                 reg_call.add_argument (new CCodeIdentifier ("&%s".printf (iface_info_name)));
 188                                 block.add_statement (new CCodeExpressionStatement (reg_call));
 189                         } else {
 190                                 var reg_call = new CCodeFunctionCall (new CCodeIdentifier ("g_type_module_add_interface"));
 191                                 reg_call.add_argument (new CCodeIdentifier ("module"));
 192                                 reg_call.add_argument (new CCodeIdentifier ("%s_type_id".printf (class_reference.get_lower_case_cname (null))));
 193                                 reg_call.add_argument (new CCodeIdentifier (iface.get_type_id ()));
 194                                 reg_call.add_argument (new CCodeIdentifier ("&%s".printf (iface_info_name)));
 195                                 block.add_statement (new CCodeExpressionStatement (reg_call));
 196                         }
 197                 }
 198
 199                 ((CCodeBaseModule) context.codegen).register_dbus_info (block, class_reference);
 200         }
 201 }