codegen/valatyperegisterfunction.vala

   1 /* valatyperegisterfunction.vala
   2  *
   3  * Copyright (C) 2006-2010  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 type at runtime.
  27  */
  28 public abstract class Vala.TypeRegisterFunction {
  29         CCodeFragment source_declaration_fragment = new CCodeFragment ();
  30         CCodeFragment declaration_fragment = new CCodeFragment ();
  31         CCodeFragment definition_fragment = new CCodeFragment ();
  32
  33         public CodeContext context { get; set; }
  34
  35         /**
  36          * Constructs the C function from the specified type.
  37          */
  38         public void init_from_type (bool plugin) {
  39                 bool use_thread_safe = !plugin;
  40
  41                 bool fundamental = false;
  42                 Class cl = get_type_declaration () as Class;
  43                 if (cl != null && !cl.is_compact && cl.base_class == null) {
  44                         fundamental = true;
  45                 }
  46
  47                 string type_id_name = "%s_type_id".printf (get_type_declaration ().get_lower_case_cname (null));
  48
  49                 var type_block = new CCodeBlock ();
  50                 CCodeDeclaration cdecl;
  51                 if (use_thread_safe) {
  52                         cdecl = new CCodeDeclaration ("gsize");
  53                         cdecl.add_declarator (new CCodeVariableDeclarator (type_id_name + "__volatile", new CCodeConstant ("0")));
  54                 } else {
  55                         cdecl = new CCodeDeclaration ("GType");
  56                         cdecl.add_declarator (new CCodeVariableDeclarator (type_id_name, new CCodeConstant ("0")));
  57                 }
  58                 cdecl.modifiers = CCodeModifiers.STATIC;
  59                 if (use_thread_safe) {
  60                         cdecl.modifiers |= CCodeModifiers.VOLATILE;
  61                 }
  62                 if (!plugin) {
  63                         type_block.add_statement (cdecl);
  64                 } else {
  65                         source_declaration_fragment.append (cdecl);
  66                 }
  67
  68                 CCodeFunction fun;
  69                 if (!plugin) {
  70                         fun = new CCodeFunction ("%s_get_type".printf (get_type_declaration ().get_lower_case_cname (null)), "GType");
  71                         fun.attributes = "G_GNUC_CONST";
  72
  73                         /* Function will not be prototyped anyway */
  74                         if (get_accessibility () == SymbolAccessibility.PRIVATE) {
  75                                 fun.modifiers = CCodeModifiers.STATIC;
  76                                 // avoid C warning as this function is not always used
  77                                 fun.attributes += " G_GNUC_UNUSED";
  78                         }
  79                 } else {
  80                         fun = new CCodeFunction ("%s_register_type".printf (get_type_declaration ().get_lower_case_cname (null)), "GType");
  81                         fun.add_parameter (new CCodeParameter ("module", "GTypeModule *"));
  82
  83                         var get_fun = new CCodeFunction ("%s_get_type".printf (get_type_declaration ().get_lower_case_cname (null)), "GType");
  84                         get_fun.attributes = "G_GNUC_CONST";
  85
  86                         get_fun.is_declaration = true;
  87                         declaration_fragment.append (get_fun.copy ());
  88                         get_fun.is_declaration = false;
  89
  90                         get_fun.block = new CCodeBlock ();
  91                         get_fun.block.add_statement (new CCodeReturnStatement (new CCodeIdentifier (type_id_name)));
  92
  93                         definition_fragment.append (get_fun);
  94                 }
  95
  96                 string type_value_table_decl_name = null;
  97                 var type_init = new CCodeBlock ();
  98
  99                 if (fundamental) {
 100                         var cgtypetabledecl = new CCodeDeclaration ("const GTypeValueTable");
 101                         cgtypetabledecl.modifiers = CCodeModifiers.STATIC;
 102
 103                         cgtypetabledecl.add_declarator (new CCodeVariableDeclarator ( "g_define_type_value_table", new CCodeConstant ("{ %s, %s, %s, %s, \"p\", %s, \"p\", %s }".printf (get_gtype_value_table_init_function_name (), get_gtype_value_table_free_function_name (), get_gtype_value_table_copy_function_name (), get_gtype_value_table_peek_pointer_function_name (), get_gtype_value_table_collect_value_function_name (), get_gtype_value_table_lcopy_value_function_name ()))));
 104                         type_value_table_decl_name = "&g_define_type_value_table";
 105                         type_init.add_statement ( cgtypetabledecl );
 106                 }
 107                 else {
 108                         type_value_table_decl_name = "NULL";
 109                 }
 110
 111
 112                 if (get_type_declaration () is ObjectTypeSymbol) {
 113                         var ctypedecl = new CCodeDeclaration ("const GTypeInfo");
 114                         ctypedecl.modifiers = CCodeModifiers.STATIC;
 115                         ctypedecl.add_declarator (new CCodeVariableDeclarator ("g_define_type_info", new CCodeConstant ("{ sizeof (%s), (GBaseInitFunc) %s, (GBaseFinalizeFunc) %s, (GClassInitFunc) %s, (GClassFinalizeFunc) %s, NULL, %s, 0, (GInstanceInitFunc) %s, %s }".printf (get_type_struct_name (), get_base_init_func_name (), (plugin) ? get_base_finalize_func_name () : "NULL", get_class_init_func_name (), get_class_finalize_func_name (), get_instance_struct_size (), get_instance_init_func_name (), type_value_table_decl_name))));
 116                         type_init.add_statement (ctypedecl);
 117                         if (fundamental) {
 118                                 var ctypefundamentaldecl = new CCodeDeclaration ("const GTypeFundamentalInfo");
 119                                 ctypefundamentaldecl.modifiers = CCodeModifiers.STATIC;
 120                                 ctypefundamentaldecl.add_declarator (new CCodeVariableDeclarator ("g_define_type_fundamental_info", new CCodeConstant ("{ (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }")));
 121                                 type_init.add_statement (ctypefundamentaldecl);
 122                         }
 123                 }
 124
 125                 type_init.add_statement (get_type_interface_init_declaration ());
 126
 127                 if (cl != null && cl.has_class_private_fields && !context.require_glib_version (2, 24)) {
 128                         CCodeFunctionCall quark_reg_call;
 129
 130                         if (plugin) {
 131                                 quark_reg_call = new CCodeFunctionCall (new CCodeIdentifier ("g_quark_from_string"));
 132                         } else {
 133                                 quark_reg_call = new CCodeFunctionCall (new CCodeIdentifier ("g_quark_from_static_string"));
 134                         }
 135
 136                         quark_reg_call.add_argument (new CCodeConstant ("\"Vala%sClassPrivate\"".printf (get_type_declaration ().get_cname ())));
 137
 138                         type_init.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier ("_vala_%s_class_private_quark".printf (get_type_declaration ().get_lower_case_cname ())), quark_reg_call)));
 139                 }
 140
 141                 CCodeFunctionCall reg_call;
 142                 if (get_type_declaration () is Struct) {
 143                         reg_call = new CCodeFunctionCall (new CCodeIdentifier ("g_boxed_type_register_static"));
 144                 } else if (get_type_declaration () is Enum) {
 145                         var en = get_type_declaration () as Enum;
 146                         if (en.is_flags) {
 147                                 reg_call = new CCodeFunctionCall (new CCodeIdentifier ("g_flags_register_static"));
 148                         } else {
 149                                 reg_call = new CCodeFunctionCall (new CCodeIdentifier ("g_enum_register_static"));
 150                         }
 151                 } else if (fundamental) {
 152                         reg_call = new CCodeFunctionCall (new CCodeIdentifier ("g_type_register_fundamental"));
 153                         reg_call.add_argument (new CCodeFunctionCall (new CCodeIdentifier ("g_type_fundamental_next")));
 154                 } else if (!plugin) {
 155                         reg_call = new CCodeFunctionCall (new CCodeIdentifier ("g_type_register_static"));
 156                         reg_call.add_argument (new CCodeIdentifier (get_parent_type_name ()));
 157                 } else {
 158                         reg_call = new CCodeFunctionCall (new CCodeIdentifier ("g_type_module_register_type"));
 159                         reg_call.add_argument (new CCodeIdentifier ("module"));
 160                         reg_call.add_argument (new CCodeIdentifier (get_parent_type_name ()));
 161                 }
 162                 reg_call.add_argument (new CCodeConstant ("\"%s\"".printf (get_type_declaration ().get_cname ())));
 163                 if (get_type_declaration () is Struct) {
 164                         var st = (Struct) get_type_declaration ();
 165                         reg_call.add_argument (new CCodeCastExpression (new CCodeIdentifier (st.get_dup_function ()), "GBoxedCopyFunc"));
 166                         reg_call.add_argument (new CCodeCastExpression (new CCodeIdentifier (st.get_free_function ()), "GBoxedFreeFunc"));
 167                 } else if (get_type_declaration () is Enum) {
 168                         var en = get_type_declaration () as Enum;
 169                         var clist = new CCodeInitializerList (); /* or during visit time? */
 170
 171                         CCodeInitializerList clist_ev = null;
 172                         foreach (EnumValue ev in en.get_values ()) {
 173                                 clist_ev = new CCodeInitializerList ();
 174                                 clist_ev.append (new CCodeConstant (ev.get_cname ()));
 175                                 clist_ev.append (new CCodeIdentifier ("\"%s\"".printf (ev.get_cname ())));
 176                                 clist_ev.append (ev.get_canonical_cconstant ());
 177                                 clist.append (clist_ev);
 178                         }
 179
 180                         clist_ev = new CCodeInitializerList ();
 181                         clist_ev.append (new CCodeConstant ("0"));
 182                         clist_ev.append (new CCodeConstant ("NULL"));
 183                         clist_ev.append (new CCodeConstant ("NULL"));
 184                         clist.append (clist_ev);
 185
 186                         var enum_decl = new CCodeVariableDeclarator ("values[]", clist);
 187
 188                         if (en.is_flags) {
 189                                 cdecl = new CCodeDeclaration ("const GFlagsValue");
 190                         } else {
 191                                 cdecl = new CCodeDeclaration ("const GEnumValue");
 192                         }
 193
 194                         cdecl.add_declarator (enum_decl);
 195                         cdecl.modifiers = CCodeModifiers.STATIC;
 196
 197                         type_init.add_statement (cdecl);
 198
 199                         reg_call.add_argument (new CCodeIdentifier ("values"));
 200                 } else {
 201                         reg_call.add_argument (new CCodeIdentifier ("&g_define_type_info"));
 202                         if (fundamental) {
 203                                 reg_call.add_argument (new CCodeIdentifier ("&g_define_type_fundamental_info"));
 204                         }
 205                         reg_call.add_argument (new CCodeConstant (get_type_flags ()));
 206                 }
 207
 208                 if (use_thread_safe && !plugin) {
 209                         var temp_decl = new CCodeDeclaration ("GType");
 210                         temp_decl.add_declarator (new CCodeVariableDeclarator (type_id_name, reg_call));
 211                         type_init.add_statement (temp_decl);
 212                 } else {
 213                         type_init.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier (type_id_name), reg_call)));
 214                 }
 215
 216                  if (cl != null && cl.has_class_private_fields && context.require_glib_version (2, 24)) {
 217                         CCodeFunctionCall add_class_private_call;
 218
 219                         add_class_private_call = new CCodeFunctionCall (new CCodeIdentifier ("g_type_add_class_private"));
 220                         add_class_private_call.add_argument (new CCodeIdentifier (type_id_name));
 221                         add_class_private_call.add_argument (new CCodeIdentifier ("sizeof (%sClassPrivate)".printf (get_type_declaration ().get_cname ())));
 222                         type_init.add_statement (new CCodeExpressionStatement (add_class_private_call));
 223                 }
 224
 225                 type_init.add_statement (get_type_interface_init_statements (plugin));
 226
 227                 if (!plugin) {
 228                         CCodeExpression condition; // the condition that guards the type initialisation
 229                         if (use_thread_safe) {
 230                                 var enter = new CCodeFunctionCall (new CCodeIdentifier ("g_once_init_enter"));
 231                                 enter.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (type_id_name + "__volatile")));
 232                                 condition = enter;
 233
 234                                 var leave = new CCodeFunctionCall (new CCodeIdentifier ("g_once_init_leave"));
 235                                 leave.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (type_id_name + "__volatile")));
 236                                 leave.add_argument (new CCodeIdentifier (type_id_name));
 237                                 type_init.add_statement (new CCodeExpressionStatement (leave));
 238                         } else {
 239                                 var id = new CCodeIdentifier (type_id_name);
 240                                 var zero = new CCodeConstant ("0");
 241                                 condition = new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, id, zero);
 242                         }
 243
 244                         CCodeExpression cond;
 245                         if (use_thread_safe) {
 246                                 cond = condition;
 247                         } else {
 248                                 cond = new CCodeFunctionCall (new CCodeIdentifier ("G_UNLIKELY"));
 249                                 (cond as CCodeFunctionCall).add_argument (condition);
 250                         }
 251                         var cif = new CCodeIfStatement (cond, type_init);
 252                         type_block.add_statement (cif);
 253                 } else {
 254                         type_block = type_init;
 255                 }
 256
 257                 if (use_thread_safe) {
 258                         type_block.add_statement (new CCodeReturnStatement (new CCodeIdentifier (type_id_name + "__volatile")));
 259                 } else {
 260                         type_block.add_statement (new CCodeReturnStatement (new CCodeIdentifier (type_id_name)));
 261                 }
 262
 263                 fun.is_declaration = true;
 264                 declaration_fragment.append (fun.copy ());
 265                 fun.is_declaration = false;
 266
 267                 fun.block = type_block;
 268
 269                 definition_fragment.append (fun);
 270         }
 271
 272         /**
 273          * Returns the data type to be registered.
 274          *
 275          * @return type to be registered
 276          */
 277         public abstract TypeSymbol get_type_declaration ();
 278
 279         /**
 280          * Returns the name of the type struct in C code.
 281          *
 282          * @return C struct name
 283          */
 284         public virtual string get_type_struct_name () {
 285                 assert_not_reached ();
 286         }
 287         /**
 288          * Returns the name of the base_init function in C code.
 289          *
 290          * @return C function name
 291          */
 292         public virtual string get_base_init_func_name () {
 293                 assert_not_reached ();
 294         }
 295
 296         /**
 297          * Returns the name of the class_finalize function in C code.
 298          *
 299          * @return C function name
 300          */
 301         public virtual string get_class_finalize_func_name () {
 302                 assert_not_reached ();
 303         }
 304
 305         /**
 306          * Returns the name of the base_finalize function in C code.
 307          *
 308          * @return C function name
 309          */
 310         public virtual string get_base_finalize_func_name () {
 311                 assert_not_reached ();
 312         }
 313
 314         /**
 315          * Returns the name of the class_init function in C code.
 316          *
 317          * @return C function name
 318          */
 319         public virtual string get_class_init_func_name () {
 320                 assert_not_reached ();
 321         }
 322
 323         /**
 324          * Returns the size of the instance struct in C code.
 325          *
 326          * @return C instance struct size
 327          */
 328         public virtual string get_instance_struct_size () {
 329                 assert_not_reached ();
 330         }
 331
 332         /**
 333          * Returns the name of the instance_init function in C code.
 334          *
 335          * @return C function name
 336          */
 337         public virtual string get_instance_init_func_name () {
 338                 assert_not_reached ();
 339         }
 340
 341         /**
 342          * Returns the name of the parent type in C code.
 343          *
 344          * @return C function name
 345          */
 346         public virtual string get_parent_type_name () {
 347                 assert_not_reached ();
 348         }
 349
 350
 351
 352         /**
 353          * Returns the C-name of the new generated GTypeValueTable init function or null when not available.
 354          *
 355          * @return C function name
 356          */
 357         public virtual string? get_gtype_value_table_init_function_name () {
 358                 return null;
 359         }
 360
 361         /**
 362          * Returns the C-name of the new generated GTypeValueTable peek pointer function or null when not available.
 363          *
 364          * @return C function name
 365          */
 366         public virtual string? get_gtype_value_table_peek_pointer_function_name () {
 367                 return null;
 368         }
 369
 370         /**
 371          * Returns the C-name of the new generated GTypeValueTable free function or null when not available.
 372          *
 373          * @return C function name
 374          */
 375         public virtual string? get_gtype_value_table_free_function_name () {
 376                 return null;
 377         }
 378
 379         /**
 380          * Returns the C-name of the new generated GTypeValueTable copy function or null when not available.
 381          *
 382          * @return C function name
 383          */
 384         public virtual string? get_gtype_value_table_copy_function_name () {
 385                 return null;
 386         }
 387
 388         /**
 389          * Returns the C-name of the new generated GTypeValueTable lcopy function or null when not available.
 390          *
 391          * @return C function name
 392          */
 393         public virtual string? get_gtype_value_table_lcopy_value_function_name () {
 394                 return null;
 395         }
 396
 397         /**
 398          * Returns the C-name of the new generated GTypeValueTable collect value function or null when not available.
 399          *
 400          * @return C function name
 401          */
 402         public virtual string? get_gtype_value_table_collect_value_function_name () {
 403                 return null;
 404         }
 405
 406         /**
 407          * Returns the set of type flags to be applied when registering.
 408          *
 409          * @return type flags
 410          */
 411         public virtual string get_type_flags () {
 412                 return "0";
 413         }
 414
 415         /**
 416          * Returns additional C declarations to setup interfaces.
 417          *
 418          * @return C declarations
 419          */
 420         public virtual CCodeFragment get_type_interface_init_declaration () {
 421                 return new CCodeFragment ();
 422         }
 423
 424         /**
 425          * Returns additional C initialization statements to setup interfaces.
 426          *
 427          * @return C statements
 428          */
 429         public abstract CCodeFragment get_type_interface_init_statements (bool plugin);
 430
 431         public CCodeFragment get_source_declaration () {
 432                 return source_declaration_fragment;
 433         }
 434
 435         /**
 436          * Returns the declaration for this type register function in C code.
 437          *
 438          * @return C function declaration fragment
 439          */
 440         public CCodeFragment get_declaration () {
 441                 return declaration_fragment;
 442         }
 443
 444         /**
 445          * Returns the definition for this type register function in C code.
 446          *
 447          * @return C function definition fragment
 448          */
 449         public CCodeFragment get_definition () {
 450                 return definition_fragment;
 451         }
 452
 453         /**
 454          * Returns the accessibility for this type.
 455          */
 456         public abstract SymbolAccessibility get_accessibility ();
 457 }