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