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                 return true;
 213         }
 214
 215         public override void accept (CodeVisitor visitor) {
 216                 visitor.visit_delegate (this);
 217         }
 218
 219         public override void accept_children (CodeVisitor visitor) {
 220                 foreach (TypeParameter p in type_parameters) {
 221                         p.accept (visitor);
 222                 }
 223
 224                 return_type.accept (visitor);
 225
 226                 foreach (Parameter param in parameters) {
 227                         param.accept (visitor);
 228                 }
 229
 230                 foreach (DataType error_type in get_error_types ()) {
 231                         error_type.accept (visitor);
 232                 }
 233         }
 234
 235         public override string get_cname (bool const_type = false) {
 236                 if (cname == null) {
 237                         cname = "%s%s".printf (parent_symbol.get_cprefix (), name);
 238                 }
 239                 return cname;
 240         }
 241
 242         /**
 243          * Sets the name of this callback as it is used in C code.
 244          *
 245          * @param cname the name to be used in C code
 246          */
 247         public void set_cname (string cname) {
 248                 this.cname = cname;
 249         }
 250
 251         public override string? get_lower_case_cname (string? infix) {
 252                 if (infix == null) {
 253                         infix = "";
 254                 }
 255                 return "%s%s%s".printf (parent_symbol.get_lower_case_cprefix (), infix, camel_case_to_lower_case (name));
 256         }
 257
 258         public override string? get_upper_case_cname (string? infix) {
 259                 return get_lower_case_cname (infix).up ();
 260         }
 261
 262         private void process_ccode_attribute (Attribute a) {
 263                 if (a.has_argument ("cname")) {
 264                         set_cname (a.get_string ("cname"));
 265                 }
 266                 if (a.has_argument ("has_target")) {
 267                         has_target = a.get_bool ("has_target");
 268                 }
 269                 if (a.has_argument ("instance_pos")) {
 270                         cinstance_parameter_position = a.get_double ("instance_pos");
 271                 }
 272                 if (a.has_argument ("array_length")) {
 273                         no_array_length = !a.get_bool ("array_length");
 274                 }
 275                 if (a.has_argument ("array_null_terminated")) {
 276                         array_null_terminated = a.get_bool ("array_null_terminated");
 277                 }
 278                 if (a.has_argument ("array_length_pos")) {
 279                         carray_length_parameter_position = a.get_double ("array_length_pos");
 280                 }
 281                 if (a.has_argument ("delegate_target_pos")) {
 282                         cdelegate_target_parameter_position = a.get_double ("delegate_target_pos");
 283                 }
 284                 if (a.has_argument ("cheader_filename")) {
 285                         var val = a.get_string ("cheader_filename");
 286                         foreach (string filename in val.split (",")) {
 287                                 add_cheader_filename (filename);
 288                         }
 289                 }
 290         }
 291
 292         /**
 293          * Process all associated attributes.
 294          */
 295         public void process_attributes () {
 296                 foreach (Attribute a in attributes) {
 297                         if (a.name == "CCode") {
 298                                 process_ccode_attribute (a);
 299                         } else if (a.name == "Deprecated") {
 300                                 process_deprecated_attribute (a);
 301                         }
 302                 }
 303         }
 304
 305         public override bool is_reference_type () {
 306                 return false;
 307         }
 308
 309         public override string? get_type_id () {
 310                 return "G_TYPE_POINTER";
 311         }
 312
 313         public override string? get_marshaller_type_name () {
 314                 return "POINTER";
 315         }
 316
 317         public override string? get_get_value_function () {
 318                 return "g_value_get_pointer";
 319         }
 320
 321         public override string? get_set_value_function () {
 322                 return "g_value_set_pointer";
 323         }
 324
 325         public override void replace_type (DataType old_type, DataType new_type) {
 326                 if (return_type == old_type) {
 327                         return_type = new_type;
 328                         return;
 329                 }
 330                 var error_types = get_error_types ();
 331                 for (int i = 0; i < error_types.size; i++) {
 332                         if (error_types[i] == old_type) {
 333                                 error_types[i] = new_type;
 334                                 return;
 335                         }
 336                 }
 337         }
 338
 339         public string get_prototype_string (string name) {
 340                 return "%s %s %s".printf (get_return_type_string (), name, get_parameters_string ());
 341         }
 342
 343         string get_return_type_string () {
 344                 string str = "";
 345                 if (!return_type.value_owned && return_type is ReferenceType) {
 346                         str = "weak ";
 347                 }
 348                 str += return_type.to_string ();
 349
 350                 return str;
 351         }
 352
 353         string get_parameters_string () {
 354                 string str = "(";
 355
 356                 int i = 1;
 357                 foreach (Parameter param in parameters) {
 358                         if (i > 1) {
 359                                 str += ", ";
 360                         }
 361
 362                         if (param.direction == ParameterDirection.IN) {
 363                                 if (param.variable_type.value_owned) {
 364                                         str += "owned ";
 365                                 }
 366                         } else {
 367                                 if (param.direction == ParameterDirection.REF) {
 368                                         str += "ref ";
 369                                 } else if (param.direction == ParameterDirection.OUT) {
 370                                         str += "out ";
 371                                 }
 372                                 if (!param.variable_type.value_owned && param.variable_type is ReferenceType) {
 373                                         str += "weak ";
 374                                 }
 375                         }
 376
 377                         str += param.variable_type.to_string ();
 378
 379                         i++;
 380                 }
 381
 382                 str += ")";
 383
 384                 return str;
 385         }
 386
 387         public override bool check (CodeContext context) {
 388                 if (checked) {
 389                         return !error;
 390                 }
 391
 392                 checked = true;
 393
 394                 process_attributes ();
 395
 396                 var old_source_file = context.analyzer.current_source_file;
 397
 398                 if (source_reference != null) {
 399                         context.analyzer.current_source_file = source_reference.file;
 400                 }
 401
 402                 foreach (TypeParameter p in type_parameters) {
 403                         p.check (context);
 404                 }
 405
 406                 return_type.check (context);
 407
 408                 foreach (Parameter param in parameters) {
 409                         param.check (context);
 410                 }
 411
 412                 foreach (DataType error_type in get_error_types ()) {
 413                         error_type.check (context);
 414                 }
 415
 416                 context.analyzer.current_source_file = old_source_file;
 417
 418                 return !error;
 419         }
 420 }