vala/valadelegate.vala

   1 /* valadelegate.vala
   2  *
   3  * Copyright (C) 2006-2009  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 using Gee;
  25
  26 /**
  27  * Represents a function callback type.
  28  */
  29 public class Vala.Delegate : TypeSymbol {
  30         /**
  31          * The return type of this callback.
  32          */
  33         public DataType return_type {
  34                 get { return _return_type; }
  35                 set {
  36                         _return_type = value;
  37                         _return_type.parent_node = this;
  38                 }
  39         }
  40
  41         /**
  42          * Specifies whether callback supports calling instance methods.
  43          * The reference to the object instance will be appended to the end of
  44          * the argument list in the generated C code.
  45          */
  46         public bool has_target { get; set; }
  47
  48         /**
  49          * Specifies the position of the instance parameter in the C function.
  50          */
  51         public double cinstance_parameter_position { get; set; }
  52
  53         /**
  54          * Specifies the position of the array length out parameter in the C
  55          * function.
  56          */
  57         public double carray_length_parameter_position { get; set; }
  58
  59         /**
  60          * Specifies the position of the delegate target out parameter in the C
  61          * function.
  62          */
  63         public double cdelegate_target_parameter_position { get; set; }
  64
  65         /**
  66          * Specifies whether the array length should be returned implicitly
  67          * if the return type is an array.
  68          */
  69         public bool no_array_length { get; set; }
  70
  71         /**
  72          * Specifies whether the array is null terminated.
  73          */
  74         public bool array_null_terminated { get; set; }
  75
  76         private Gee.List<TypeParameter> type_parameters = new ArrayList<TypeParameter> ();
  77
  78         private Gee.List<FormalParameter> parameters = new ArrayList<FormalParameter> ();
  79         private string cname;
  80
  81         private DataType _return_type;
  82
  83         /**
  84          * Creates a new delegate.
  85          *
  86          * @param name        delegate type name
  87          * @param return_type return type
  88          * @param source      reference to source code
  89          * @return            newly created delegate
  90          */
  91         public Delegate (string? name, DataType return_type, SourceReference? source_reference = null) {
  92                 base (name, source_reference);
  93                 this.return_type = return_type;
  94
  95                 // error is -1 (right of user_data)
  96                 cinstance_parameter_position = -2;
  97                 carray_length_parameter_position = -3;
  98                 cdelegate_target_parameter_position = -3;
  99         }
 100
 101         /**
 102          * Appends the specified parameter to the list of type parameters.
 103          *
 104          * @param p a type parameter
 105          */
 106         public void add_type_parameter (TypeParameter p) {
 107                 type_parameters.add (p);
 108                 p.type = this;
 109                 scope.add (p.name, p);
 110         }
 111
 112         /**
 113          * Appends paramater to this callback function.
 114          *
 115          * @param param a formal parameter
 116          */
 117         public void add_parameter (FormalParameter param) {
 118                 // default C parameter position
 119                 param.cparameter_position = parameters.size + 1;
 120                 param.carray_length_parameter_position = param.cparameter_position + 0.1;
 121                 param.cdelegate_target_parameter_position = param.cparameter_position + 0.1;
 122
 123                 parameters.add (param);
 124                 scope.add (param.name, param);
 125         }
 126
 127         /**
 128          * Return copy of parameter list.
 129          *
 130          * @return parameter list
 131          */
 132         public Gee.List<FormalParameter> get_parameters () {
 133                 return new ReadOnlyList<FormalParameter> (parameters);
 134         }
 135
 136         /**
 137          * Checks whether the arguments and return type of the specified method
 138          * matches this callback.
 139          *
 140          * @param m a method
 141          * @return  true if the specified method is compatible to this callback
 142          */
 143         public bool matches_method (Method m) {
 144                 // method is allowed to ensure stricter return type (stronger postcondition)
 145                 if (!m.return_type.stricter (return_type)) {
 146                         return false;
 147                 }
 148
 149                 var method_params = m.get_parameters ();
 150                 Iterator<FormalParameter> method_params_it = method_params.iterator ();
 151                 bool first = true;
 152                 foreach (FormalParameter param in parameters) {
 153                         /* use first callback parameter as instance parameter if
 154                          * an instance method is being compared to a static
 155                          * callback
 156                          */
 157                         if (first && m.binding == MemberBinding.INSTANCE && !has_target) {
 158                                 first = false;
 159                                 continue;
 160                         }
 161
 162                         /* method is allowed to accept less arguments */
 163                         if (!method_params_it.next ()) {
 164                                 break;
 165                         }
 166
 167                         // method is allowed to accept arguments of looser types (weaker precondition)
 168                         var method_param = method_params_it.get ();
 169                         if (!param.parameter_type.stricter (method_param.parameter_type)) {
 170                                 return false;
 171                         }
 172                 }
 173
 174                 /* method may not expect more arguments */
 175                 if (method_params_it.next ()) {
 176                         return false;
 177                 }
 178
 179                 return true;
 180         }
 181
 182         public override void accept (CodeVisitor visitor) {
 183                 visitor.visit_delegate (this);
 184         }
 185
 186         public override void accept_children (CodeVisitor visitor) {
 187                 foreach (TypeParameter p in type_parameters) {
 188                         p.accept (visitor);
 189                 }
 190
 191                 return_type.accept (visitor);
 192
 193                 foreach (FormalParameter param in parameters) {
 194                         param.accept (visitor);
 195                 }
 196
 197                 foreach (DataType error_type in get_error_types ()) {
 198                         error_type.accept (visitor);
 199                 }
 200         }
 201
 202         public override string get_cname (bool const_type = false) {
 203                 if (cname == null) {
 204                         cname = "%s%s".printf (parent_symbol.get_cprefix (), name);
 205                 }
 206                 return cname;
 207         }
 208
 209         /**
 210          * Sets the name of this callback as it is used in C code.
 211          *
 212          * @param cname the name to be used in C code
 213          */
 214         public void set_cname (string cname) {
 215                 this.cname = cname;
 216         }
 217
 218         private void process_ccode_attribute (Attribute a) {
 219                 if (a.has_argument ("cname")) {
 220                         set_cname (a.get_string ("cname"));
 221                 }
 222                 if (a.has_argument ("instance_pos")) {
 223                         cinstance_parameter_position = a.get_double ("instance_pos");
 224                 }
 225                 if (a.has_argument ("array_length")) {
 226                         no_array_length = !a.get_bool ("array_length");
 227                 }
 228                 if (a.has_argument ("array_null_terminated")) {
 229                         array_null_terminated = a.get_bool ("array_null_terminated");
 230                 }
 231                 if (a.has_argument ("array_length_pos")) {
 232                         carray_length_parameter_position = a.get_double ("array_length_pos");
 233                 }
 234                 if (a.has_argument ("delegate_target_pos")) {
 235                         cdelegate_target_parameter_position = a.get_double ("delegate_target_pos");
 236                 }
 237                 if (a.has_argument ("cheader_filename")) {
 238                         var val = a.get_string ("cheader_filename");
 239                         foreach (string filename in val.split (",")) {
 240                                 add_cheader_filename (filename);
 241                         }
 242                 }
 243         }
 244
 245         /**
 246          * Process all associated attributes.
 247          */
 248         public void process_attributes () {
 249                 foreach (Attribute a in attributes) {
 250                         if (a.name == "CCode") {
 251                                 process_ccode_attribute (a);
 252                         }
 253                 }
 254         }
 255
 256         public override bool is_reference_type () {
 257                 return false;
 258         }
 259
 260         public override string? get_type_id () {
 261                 return "G_TYPE_POINTER";
 262         }
 263
 264         public override string? get_marshaller_type_name () {
 265                 return "POINTER";
 266         }
 267
 268         public override string? get_get_value_function () {
 269                 return "g_value_get_pointer";
 270         }
 271
 272         public override string? get_set_value_function () {
 273                 return "g_value_set_pointer";
 274         }
 275
 276         public override void replace_type (DataType old_type, DataType new_type) {
 277                 if (return_type == old_type) {
 278                         return_type = new_type;
 279                         return;
 280                 }
 281                 var error_types = get_error_types ();
 282                 for (int i = 0; i < error_types.size; i++) {
 283                         if (error_types[i] == old_type) {
 284                                 error_types[i] = new_type;
 285                                 return;
 286                         }
 287                 }
 288         }
 289
 290         public string get_prototype_string (string name) {
 291                 return "%s %s %s".printf (get_return_type_string (), name, get_parameters_string ());
 292         }
 293
 294         string get_return_type_string () {
 295                 string str = "";
 296                 if (!return_type.value_owned && return_type is ReferenceType) {
 297                         str = "weak ";
 298                 }
 299                 str += return_type.to_string ();
 300
 301                 return str;
 302         }
 303
 304         string get_parameters_string () {
 305                 string str = "(";
 306
 307                 int i = 1;
 308                 foreach (FormalParameter param in parameters) {
 309                         if (i > 1) {
 310                                 str += ", ";
 311                         }
 312
 313                         if (param.direction != ParameterDirection.IN) {
 314                                 if (param.direction == ParameterDirection.REF) {
 315                                         str += "ref ";
 316                                 } else if (param.direction == ParameterDirection.OUT) {
 317                                         str += "out ";
 318                                 }
 319                                 if (!param.parameter_type.value_owned && param.parameter_type is ReferenceType) {
 320                                         str += "weak ";
 321                                 }
 322                         }
 323
 324                         str += param.parameter_type.to_string ();
 325
 326                         if (param.direction == ParameterDirection.IN && param.parameter_type.value_owned) {
 327                                 str += "#";
 328                         }
 329
 330                         i++;
 331                 }
 332
 333                 str += ")";
 334
 335                 return str;
 336         }
 337
 338         public override bool check (SemanticAnalyzer analyzer) {
 339                 if (checked) {
 340                         return !error;
 341                 }
 342
 343                 checked = true;
 344
 345                 process_attributes ();
 346
 347                 var old_source_file = analyzer.current_source_file;
 348
 349                 if (source_reference != null) {
 350                         analyzer.current_source_file = source_reference.file;
 351                 }
 352
 353                 foreach (TypeParameter p in type_parameters) {
 354                         p.check (analyzer);
 355                 }
 356
 357                 return_type.check (analyzer);
 358
 359                 foreach (FormalParameter param in parameters) {
 360                         param.check (analyzer);
 361                 }
 362
 363                 foreach (DataType error_type in get_error_types ()) {
 364                         error_type.check (analyzer);
 365                 }
 366
 367                 analyzer.current_source_file = old_source_file;
 368
 369                 return !error;
 370         }
 371 }