gobject/valatyperegisterfunction.vala

   1 /* valatyperegisterfunction.vala
   2  *
   3  * Copyright (C) 2006-2007  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 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         private CCodeFragment declaration_fragment = new CCodeFragment ();
  30
  31         private CCodeFragment definition_fragment = new CCodeFragment ();
  32
  33         /**
  34          * Constructs the C function from the specified type.
  35          */
  36         public void init_from_type (bool plugin = false) {
  37                 string type_id_name = "%s_type_id".printf (get_type_declaration ().get_lower_case_cname (null));
  38
  39                 var type_block = new CCodeBlock ();
  40                 var cdecl = new CCodeDeclaration ("GType");
  41                 cdecl.add_declarator (new CCodeVariableDeclarator.with_initializer (type_id_name, new CCodeConstant ("0")));
  42                 cdecl.modifiers = CCodeModifiers.STATIC;
  43                 if (!plugin) {
  44                         type_block.add_statement (cdecl);
  45                 } else {
  46                         definition_fragment.append (cdecl);
  47                 }
  48
  49                 CCodeFunction fun;
  50                 if (!plugin) {
  51                         fun = new CCodeFunction ("%s_get_type".printf (get_type_declaration ().get_lower_case_cname (null)), "GType");
  52                 } else {
  53                         fun = new CCodeFunction ("%s_register_type".printf (get_type_declaration ().get_lower_case_cname (null)), "GType");
  54                         fun.add_parameter (new CCodeFormalParameter ("module", "GTypeModule *"));
  55
  56                         var get_fun = new CCodeFunction ("%s_get_type".printf (get_type_declaration ().get_lower_case_cname (null)), "GType");
  57
  58                         declaration_fragment.append (get_fun.copy ());
  59
  60                         get_fun.block = new CCodeBlock ();
  61                         get_fun.block.add_statement (new CCodeReturnStatement (new CCodeIdentifier (type_id_name)));
  62
  63                         definition_fragment.append (get_fun);
  64                 }
  65
  66                 var type_init = new CCodeBlock ();
  67                 var ctypedecl = new CCodeDeclaration ("const GTypeInfo");
  68                 ctypedecl.modifiers = CCodeModifiers.STATIC;
  69                 ctypedecl.add_declarator (new CCodeVariableDeclarator.with_initializer ("g_define_type_info", new CCodeConstant ("{ sizeof (%s), (GBaseInitFunc) %s, (GBaseFinalizeFunc) NULL, (GClassInitFunc) %s, (GClassFinalizeFunc) NULL, NULL, %s, 0, (GInstanceInitFunc) %s }".printf (get_type_struct_name (), get_base_init_func_name (), get_class_init_func_name (), get_instance_struct_size (), get_instance_init_func_name ()))));
  70                 type_init.add_statement (ctypedecl);
  71
  72                 type_init.add_statement (get_type_interface_init_declaration ());
  73
  74                 CCodeFunctionCall reg_call;
  75                 if (!plugin) {
  76                         reg_call = new CCodeFunctionCall (new CCodeIdentifier ("g_type_register_static"));
  77                 } else {
  78                         reg_call = new CCodeFunctionCall (new CCodeIdentifier ("g_type_module_register_type"));
  79                         reg_call.add_argument (new CCodeIdentifier ("module"));
  80                 }
  81                 reg_call.add_argument (new CCodeIdentifier (get_parent_type_name ()));
  82                 reg_call.add_argument (new CCodeConstant ("\"%s\"".printf (get_type_declaration ().get_cname ())));
  83                 reg_call.add_argument (new CCodeIdentifier ("&g_define_type_info"));
  84                 reg_call.add_argument (new CCodeConstant (get_type_flags ()));
  85                 type_init.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeIdentifier (type_id_name), reg_call)));
  86
  87                 type_init.add_statement (get_type_interface_init_statements ());
  88
  89                 if (!plugin) {
  90                         var cond = new CCodeFunctionCall (new CCodeIdentifier ("G_UNLIKELY"));
  91                         cond.add_argument (new CCodeBinaryExpression (CCodeBinaryOperator.EQUALITY, new CCodeIdentifier (type_id_name), new CCodeConstant ("0")));
  92                         var cif = new CCodeIfStatement (cond, type_init);
  93                         type_block.add_statement (cif);
  94                 } else {
  95                         type_block = type_init;
  96                 }
  97
  98                 type_block.add_statement (new CCodeReturnStatement (new CCodeIdentifier (type_id_name)));
  99
 100                 declaration_fragment.append (fun.copy ());
 101
 102                 fun.block = type_block;
 103
 104                 definition_fragment.append (fun);
 105         }
 106
 107         /**
 108          * Returns the data type to be registered.
 109          *
 110          * @return type to be registered
 111          */
 112         public abstract DataType! get_type_declaration ();
 113
 114         /**
 115          * Returns the name of the type struct in C code.
 116          *
 117          * @return C struct name
 118          */
 119         public abstract string! get_type_struct_name ();
 120
 121         /**
 122          * Returns the name of the base_init function in C code.
 123          *
 124          * @return C function name
 125          */
 126         public abstract string! get_base_init_func_name ();
 127
 128         /**
 129          * Returns the name of the class_init function in C code.
 130          *
 131          * @return C function name
 132          */
 133         public abstract string! get_class_init_func_name ();
 134
 135         /**
 136          * Returns the size of the instance struct in C code.
 137          *
 138          * @return C instance struct size
 139          */
 140         public abstract string! get_instance_struct_size ();
 141
 142         /**
 143          * Returns the name of the instance_init function in C code.
 144          *
 145          * @return C function name
 146          */
 147         public abstract string! get_instance_init_func_name ();
 148
 149         /**
 150          * Returns the name of the parent type in C code.
 151          *
 152          * @return C parent type name
 153          */
 154         public abstract string! get_parent_type_name ();
 155
 156         /**
 157          * Returns the set of type flags to be applied when registering.
 158          *
 159          * @return type flags
 160          */
 161         public virtual string get_type_flags () {
 162                 return "0";
 163         }
 164
 165         /**
 166          * Returns additional C declarations to setup interfaces.
 167          *
 168          * @return C declarations
 169          */
 170         public virtual CCodeFragment! get_type_interface_init_declaration () {
 171                 return new CCodeFragment ();
 172         }
 173
 174         /**
 175          * Returns additional C initialization statements to setup interfaces.
 176          *
 177          * @return C statements
 178          */
 179         public abstract CCodeFragment! get_type_interface_init_statements ();
 180
 181         /**
 182          * Returns the declaration for this type register function in C code.
 183          *
 184          * @return C function declaration fragment
 185          */
 186         public CCodeFragment! get_declaration () {
 187                 return declaration_fragment;
 188         }
 189
 190         /**
 191          * Returns the definition for this type register function in C code.
 192          *
 193          * @return C function definition fragment
 194          */
 195         public CCodeFragment! get_definition () {
 196                 return definition_fragment;
 197         }
 198 }