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