vala/valadelegate.vala

   1 /* valadelegate.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  * 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<Parameter> parameters = new ArrayList<Parameter> ();
  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         public List<TypeParameter> get_type_parameters () {
 113                 return type_parameters;
 114         }
 115
 116         public override int get_type_parameter_index (string name) {
 117                 int i = 0;
 118                 foreach (TypeParameter parameter in type_parameters) {
 119                         if (parameter.name == name) {
 120                                 return i;
 121                         }
 122                         i++;
 123                 }
 124                 return -1;
 125         }
 126
 127         /**
 128          * Appends paramater to this callback function.
 129          *
 130          * @param param a formal parameter
 131          */
 132         public void add_parameter (Parameter param) {
 133                 // default C parameter position
 134                 param.cparameter_position = parameters.size + 1;
 135                 param.carray_length_parameter_position = param.cparameter_position + 0.1;
 136                 param.cdelegate_target_parameter_position = param.cparameter_position + 0.1;
 137                 param.cdestroy_notify_parameter_position = param.cparameter_position + 0.1;
 138
 139                 parameters.add (param);
 140                 scope.add (param.name, param);
 141         }
 142
 143         /**
 144          * Return copy of parameter list.
 145          *
 146          * @return parameter list
 147          */
 148         public List<Parameter> get_parameters () {
 149                 return parameters;
 150         }
 151
 152         /**
 153          * Checks whether the arguments and return type of the specified method
 154          * matches this callback.
 155          *
 156          * @param m a method
 157          * @return  true if the specified method is compatible to this callback
 158          */
 159         public bool matches_method (Method m, DataType dt) {
 160                 if (m.coroutine) {
 161                         // async delegates are not yet supported
 162                         return false;
 163                 }
 164
 165                 // method is allowed to ensure stricter return type (stronger postcondition)
 166                 if (!m.return_type.stricter (return_type.get_actual_type (dt, null, this))) {
 167                         return false;
 168                 }
 169
 170                 var method_params = m.get_parameters ();
 171                 Iterator<Parameter> method_params_it = method_params.iterator ();
 172
 173                 if (sender_type != null && method_params.size == parameters.size + 1) {
 174                         // method has sender parameter
 175                         method_params_it.next ();
 176
 177                         // method is allowed to accept arguments of looser types (weaker precondition)
 178                         var method_param = method_params_it.get ();
 179                         if (!sender_type.stricter (method_param.variable_type)) {
 180                                 return false;
 181                         }
 182                 }
 183
 184                 bool first = true;
 185                 foreach (Parameter param in parameters) {
 186                         /* use first callback parameter as instance parameter if
 187                          * an instance method is being compared to a static
 188                          * callback
 189                          */
 190                         if (first && m.binding == MemberBinding.INSTANCE && !has_target) {
 191                                 first = false;
 192                                 continue;
 193                         }
 194
 195                         /* method is allowed to accept less arguments */
 196                         if (!method_params_it.next ()) {
 197                                 break;
 198                         }
 199
 200                         // method is allowed to accept arguments of looser types (weaker precondition)
 201                         var method_param = method_params_it.get ();
 202                         if (!param.variable_type.get_actual_type (dt, null, this).stricter (method_param.variable_type)) {
 203                                 return false;
 204                         }
 205                 }
 206
 207                 /* method may not expect more arguments */
 208                 if (method_params_it.next ()) {
 209                         return false;
 210                 }
 211
 212                 // method may throw less but not more errors than the delegate
 213                 foreach (DataType method_error_type in m.get_error_types ()) {
 214                         bool match = false;
 215                         foreach (DataType delegate_error_type in get_error_types ()) {
 216                                 if (method_error_type.compatible (delegate_error_type)) {
 217                                         match = true;
 218                                         break;
 219                                 }
 220                         }
 221
 222                         if (!match) {
 223                                 return false;
 224                         }
 225                 }
 226
 227                 return true;
 228         }
 229
 230         public override void accept (CodeVisitor visitor) {
 231                 visitor.visit_delegate (this);
 232         }
 233
 234         public override void accept_children (CodeVisitor visitor) {
 235                 foreach (TypeParameter p in type_parameters) {
 236                         p.accept (visitor);
 237                 }
 238
 239                 return_type.accept (visitor);
 240
 241                 foreach (Parameter param in parameters) {
 242                         param.accept (visitor);
 243                 }
 244
 245                 foreach (DataType error_type in get_error_types ()) {
 246                         error_type.accept (visitor);
 247                 }
 248         }
 249
 250         public override string get_cname (bool const_type = false) {
 251                 if (cname == null) {
 252                         cname = "%s%s".printf (parent_symbol.get_cprefix (), name);
 253                 }
 254                 return cname;
 255         }
 256
 257         /**
 258          * Sets the name of this callback as it is used in C code.
 259          *
 260          * @param cname the name to be used in C code
 261          */
 262         public void set_cname (string cname) {
 263                 this.cname = cname;
 264         }
 265
 266         public override string? get_lower_case_cname (string? infix) {
 267                 if (infix == null) {
 268                         infix = "";
 269                 }
 270                 return "%s%s%s".printf (parent_symbol.get_lower_case_cprefix (), infix, camel_case_to_lower_case (name));
 271         }
 272
 273         public override string? get_upper_case_cname (string? infix) {
 274                 return get_lower_case_cname (infix).up ();
 275         }
 276
 277         private void process_ccode_attribute (Attribute a) {
 278                 if (a.has_argument ("cname")) {
 279                         set_cname (a.get_string ("cname"));
 280                 }
 281                 if (a.has_argument ("has_target")) {
 282                         has_target = a.get_bool ("has_target");
 283                 }
 284                 if (a.has_argument ("instance_pos")) {
 285                         cinstance_parameter_position = a.get_double ("instance_pos");
 286                 }
 287                 if (a.has_argument ("array_length")) {
 288                         no_array_length = !a.get_bool ("array_length");
 289                 }
 290                 if (a.has_argument ("array_null_terminated")) {
 291                         array_null_terminated = a.get_bool ("array_null_terminated");
 292                 }
 293                 if (a.has_argument ("array_length_pos")) {
 294                         carray_length_parameter_position = a.get_double ("array_length_pos");
 295                 }
 296                 if (a.has_argument ("delegate_target_pos")) {
 297                         cdelegate_target_parameter_position = a.get_double ("delegate_target_pos");
 298                 }
 299                 if (a.has_argument ("cheader_filename")) {
 300                         var val = a.get_string ("cheader_filename");
 301                         foreach (string filename in val.split (",")) {
 302                                 add_cheader_filename (filename);
 303                         }
 304                 }
 305         }
 306
 307         /**
 308          * Process all associated attributes.
 309          */
 310         public void process_attributes () {
 311                 foreach (Attribute a in attributes) {
 312                         if (a.name == "CCode") {
 313                                 process_ccode_attribute (a);
 314                         } else if (a.name == "Deprecated") {
 315                                 process_deprecated_attribute (a);
 316                         }
 317                 }
 318         }
 319
 320         public override bool is_reference_type () {
 321                 return false;
 322         }
 323
 324         public override string? get_type_id () {
 325                 return "G_TYPE_POINTER";
 326         }
 327
 328         public override string? get_marshaller_type_name () {
 329                 return "POINTER";
 330         }
 331
 332         public override string? get_get_value_function () {
 333                 return "g_value_get_pointer";
 334         }
 335
 336         public override string? get_set_value_function () {
 337                 return "g_value_set_pointer";
 338         }
 339
 340         public override void replace_type (DataType old_type, DataType new_type) {
 341                 if (return_type == old_type) {
 342                         return_type = new_type;
 343                         return;
 344                 }
 345                 var error_types = get_error_types ();
 346                 for (int i = 0; i < error_types.size; i++) {
 347                         if (error_types[i] == old_type) {
 348                                 error_types[i] = new_type;
 349                                 return;
 350                         }
 351                 }
 352         }
 353
 354         public string get_prototype_string (string name) {
 355                 return "%s %s %s".printf (get_return_type_string (), name, get_parameters_string ());
 356         }
 357
 358         string get_return_type_string () {
 359                 string str = "";
 360                 if (!return_type.value_owned && return_type is ReferenceType) {
 361                         str = "weak ";
 362                 }
 363                 str += return_type.to_string ();
 364
 365                 return str;
 366         }
 367
 368         string get_parameters_string () {
 369                 string str = "(";
 370
 371                 int i = 1;
 372                 foreach (Parameter param in parameters) {
 373                         if (i > 1) {
 374                                 str += ", ";
 375                         }
 376
 377                         if (param.direction == ParameterDirection.IN) {
 378                                 if (param.variable_type.value_owned) {
 379                                         str += "owned ";
 380                                 }
 381                         } else {
 382                                 if (param.direction == ParameterDirection.REF) {
 383                                         str += "ref ";
 384                                 } else if (param.direction == ParameterDirection.OUT) {
 385                                         str += "out ";
 386                                 }
 387                                 if (!param.variable_type.value_owned && param.variable_type is ReferenceType) {
 388                                         str += "weak ";
 389                                 }
 390                         }
 391
 392                         str += param.variable_type.to_string ();
 393
 394                         i++;
 395                 }
 396
 397                 str += ")";
 398
 399                 return str;
 400         }
 401
 402         public override bool check (CodeContext context) {
 403                 if (checked) {
 404                         return !error;
 405                 }
 406
 407                 checked = true;
 408
 409                 process_attributes ();
 410
 411                 var old_source_file = context.analyzer.current_source_file;
 412
 413                 if (source_reference != null) {
 414                         context.analyzer.current_source_file = source_reference.file;
 415                 }
 416
 417                 foreach (TypeParameter p in type_parameters) {
 418                         p.check (context);
 419                 }
 420
 421                 return_type.check (context);
 422
 423                 foreach (Parameter param in parameters) {
 424                         param.check (context);
 425                 }
 426
 427                 foreach (DataType error_type in get_error_types ()) {
 428                         error_type.check (context);
 429                 }
 430
 431                 context.analyzer.current_source_file = old_source_file;
 432
 433                 return !error;
 434         }
 435 }