vala/valasignal.vala

   1 /* valasignal.vala
   2  *
   3  * Copyright (C) 2006-2011  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 an object signal. Signals enable objects to provide notifications.
  27  */
  28 public class Vala.Signal : Symbol, Lockable {
  29         /**
  30          * The return type of handlers of this signal.
  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         public Block body {
  41                 get { return _body; }
  42                 set {
  43                         _body = value;
  44                         if (_body != null) {
  45                                 _body.owner = scope;
  46                         }
  47                 }
  48         }
  49
  50         /**
  51          * Specifies whether this signal has an emitter wrapper function.
  52          */
  53         public bool has_emitter { get; set; }
  54
  55         /**
  56          * Specifies whether this signal has virtual method handler.
  57          */
  58         public bool is_virtual { get; set; }
  59
  60         private List<Parameter> parameters = new ArrayList<Parameter> ();
  61         /**
  62          * Refers to the default signal handler, which is an anonymous
  63          * function in the scope.
  64          * */
  65         public Method default_handler { get; private set; }
  66
  67         public bool is_detailed { get; set; }
  68
  69         public bool no_recurse { get; set; }
  70
  71         public string run_type { get; set; }
  72
  73         public bool is_action { get; set; }
  74
  75         public bool no_hooks { get; set; }
  76
  77
  78         private string cname;
  79
  80         private bool lock_used = false;
  81
  82         private DataType _return_type;
  83
  84         private Block _body;
  85
  86         /**
  87          * Creates a new signal.
  88          *
  89          * @param name        signal name
  90          * @param return_type signal return type
  91          * @param source      reference to source code
  92          * @return            newly created signal
  93          */
  94         public Signal (string name, DataType return_type, SourceReference? source_reference = null, Comment? comment = null) {
  95                 base (name, source_reference, comment);
  96                 this.return_type = return_type;
  97                 this.run_type = "last";
  98         }
  99
 100         /**
 101          * Appends parameter to signal handler.
 102          *
 103          * @param param a formal parameter
 104          */
 105         public void add_parameter (Parameter param) {
 106                 // default C parameter position
 107                 param.cparameter_position = parameters.size + 1;
 108                 param.carray_length_parameter_position = param.cparameter_position + 0.1;
 109                 param.cdelegate_target_parameter_position = param.cparameter_position + 0.1;
 110                 param.cdestroy_notify_parameter_position = param.cparameter_position + 0.1;
 111
 112                 parameters.add (param);
 113                 scope.add (param.name, param);
 114         }
 115
 116         public List<Parameter> get_parameters () {
 117                 return parameters;
 118         }
 119
 120         /**
 121          * Returns generated delegate to be used for signal handlers.
 122          *
 123          * @return delegate
 124          */
 125         public Delegate get_delegate (DataType sender_type, CodeNode node_reference) {
 126                 var actual_return_type = return_type.get_actual_type (sender_type, null, node_reference);
 127
 128                 var generated_delegate = new Delegate (null, actual_return_type);
 129                 generated_delegate.has_target = true;
 130                 generated_delegate.access = SymbolAccessibility.PUBLIC;
 131                 generated_delegate.owner = scope;
 132
 133                 // sender parameter is never null and doesn't own its value
 134                 var sender_param_type = sender_type.copy ();
 135                 sender_param_type.value_owned = false;
 136                 sender_param_type.nullable = false;
 137
 138                 generated_delegate.sender_type = sender_param_type;
 139
 140                 bool is_generic = false;
 141
 142                 foreach (Parameter param in parameters) {
 143                         var actual_param = param.copy ();
 144                         actual_param.variable_type = actual_param.variable_type.get_actual_type (sender_type, null, node_reference);
 145                         generated_delegate.add_parameter (actual_param);
 146
 147                         if (actual_param.variable_type is GenericType) {
 148                                 is_generic = true;
 149                         }
 150                 }
 151
 152                 if (is_generic) {
 153                         var cl = (ObjectTypeSymbol) parent_symbol;
 154                         foreach (var type_param in cl.get_type_parameters ()) {
 155                                 generated_delegate.add_type_parameter (new TypeParameter (type_param.name, type_param.source_reference));
 156                         }
 157
 158                         // parameter types must refer to the delegate type parameters
 159                         // instead of to the class type parameters
 160                         foreach (var param in generated_delegate.get_parameters ()) {
 161                                 if (param.variable_type is GenericType) {
 162                                         param.variable_type.type_parameter = generated_delegate.get_type_parameters ().get (generated_delegate.get_type_parameter_index (param.variable_type.type_parameter.name));
 163                                 }
 164                         }
 165                 }
 166
 167                 scope.add (null, generated_delegate);
 168
 169                 return generated_delegate;
 170         }
 171
 172         /**
 173          * Returns the name of this signal as it is used in C code.
 174          *
 175          * @return the name to be used in C code
 176          */
 177         public string get_cname () {
 178                 if (cname == null) {
 179                         cname = camel_case_to_lower_case (name);
 180                 }
 181                 return cname;
 182         }
 183
 184         public void set_cname (string cname) {
 185                 this.cname = cname;
 186         }
 187
 188         /**
 189          * Returns the string literal of this signal to be used in C code.
 190          *
 191          * @return string literal to be used in C code
 192          */
 193         public CCodeConstant get_canonical_cconstant (string? detail = null) {
 194                 var str = new StringBuilder ("\"");
 195
 196                 string i = get_cname ();
 197
 198                 while (i.length > 0) {
 199                         unichar c = i.get_char ();
 200                         if (c == '_') {
 201                                 str.append_c ('-');
 202                         } else {
 203                                 str.append_unichar (c);
 204                         }
 205
 206                         i = i.next_char ();
 207                 }
 208
 209                 if (detail != null) {
 210                         str.append ("::");
 211                         str.append (detail);
 212                 }
 213
 214                 str.append_c ('"');
 215
 216                 return new CCodeConstant (str.str);
 217         }
 218
 219         public override void accept (CodeVisitor visitor) {
 220                 visitor.visit_signal (this);
 221         }
 222
 223         public override void accept_children (CodeVisitor visitor) {
 224                 return_type.accept (visitor);
 225
 226                 foreach (Parameter param in parameters) {
 227                         param.accept (visitor);
 228                 }
 229                 if (default_handler == null && body != null) {
 230                         body.accept (visitor);
 231                 } else if (default_handler != null) {
 232                         default_handler.accept (visitor);
 233                 }
 234         }
 235
 236         void process_signal_attribute (Attribute a) {
 237                 if (a.has_argument ("detailed")) {
 238                         is_detailed = a.get_bool ("detailed");
 239                 }
 240                 if (a.has_argument ("no_recurse")) {
 241                         no_recurse = a.get_bool ("no_recurse");
 242                 }
 243                 if (a.has_argument ("run")) {
 244                         var arg = a.get_string ("run");
 245                         if (arg == "first") {
 246                                 run_type = "first";
 247                         } else if (arg == "last") {
 248                                 run_type = "last";
 249                         } else if (arg == "cleanup") {
 250                                 run_type = "cleanup";
 251                         }
 252                 }
 253
 254                 if (a.has_argument ("action")) {
 255                         is_action = a.get_bool ("action");
 256                 }
 257
 258                 if (a.has_argument ("no_hooks")) {
 259                         no_hooks = a.get_bool ("no_hooks");
 260                 }
 261         }
 262
 263         /**
 264          * Process all associated attributes.
 265          */
 266         public void process_attributes () {
 267                 foreach (Attribute a in attributes) {
 268                         if (a.name == "HasEmitter") {
 269                                 has_emitter = true;
 270                         } else if (a.name == "Signal") {
 271                                 process_signal_attribute (a);
 272                         } else if (a.name == "Deprecated") {
 273                                 process_deprecated_attribute (a);
 274                         }
 275                 }
 276         }
 277
 278         public bool get_lock_used () {
 279                 return lock_used;
 280         }
 281
 282         public void set_lock_used (bool used) {
 283                 lock_used = used;
 284         }
 285
 286         public override void replace_type (DataType old_type, DataType new_type) {
 287                 if (return_type == old_type) {
 288                         return_type = new_type;
 289                 }
 290         }
 291
 292         public override bool check (CodeContext context) {
 293                 if (checked) {
 294                         return !error;
 295                 }
 296
 297                 checked = true;
 298
 299                 process_attributes ();
 300
 301                 return_type.check (context);
 302
 303                 foreach (Parameter param in parameters) {
 304                         param.check (context);
 305                 }
 306
 307                 if (!is_virtual && body != null) {
 308                         Report.error (source_reference, "Only virtual signals can have a default signal handler body");
 309                 }
 310
 311
 312                 if (is_virtual) {
 313                         default_handler = new Method (name, return_type, source_reference);
 314
 315                         default_handler.owner = owner;
 316                         default_handler.access = access;
 317                         default_handler.external = external;
 318                         default_handler.is_virtual = true;
 319                         default_handler.vfunc_name = name;
 320                         default_handler.signal_reference = this;
 321                         default_handler.body = body;
 322
 323
 324                         foreach (Parameter param in parameters) {
 325                                 default_handler.add_parameter (param);
 326                         }
 327
 328                         var cl = parent_symbol as ObjectTypeSymbol;
 329
 330                         cl.add_hidden_method (default_handler);
 331                         default_handler.check (context);
 332                 }
 333
 334
 335                 if (!external_package && !hides && get_hidden_member () != null) {
 336                         Report.warning (source_reference, "%s hides inherited signal `%s'. Use the `new' keyword if hiding was intentional".printf (get_full_name (), get_hidden_member ().get_full_name ()));
 337                 }
 338
 339                 return !error;
 340         }
 341 }
 342