vala/valasignal.vala

   1 /* valasignal.vala
   2  *
   3  * Copyright (C) 2006-2012  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, Callable {
  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 virtual method handler.
  52          */
  53         public bool is_virtual { get; set; }
  54
  55         private List<Parameter> parameters = new ArrayList<Parameter> ();
  56         /**
  57          * Refers to the default signal handler, which is an anonymous
  58          * function in the scope.
  59          * */
  60         public Method default_handler { get; private set; }
  61
  62         /**
  63          * Refers to the public signal emitter method, which is an anonymous
  64          * function in the scope.
  65          * */
  66         public Method emitter { get; private set; }
  67
  68         private bool lock_used = false;
  69
  70         private DataType _return_type;
  71
  72         private Block _body;
  73
  74         /**
  75          * Creates a new signal.
  76          *
  77          * @param name              signal name
  78          * @param return_type       signal return type
  79          * @param source_reference  reference to source code
  80          * @return                  newly created signal
  81          */
  82         public Signal (string name, DataType return_type, SourceReference? source_reference = null, Comment? comment = null) {
  83                 base (name, source_reference, comment);
  84                 this.return_type = return_type;
  85         }
  86
  87         /**
  88          * Appends parameter to signal handler.
  89          *
  90          * @param param a formal parameter
  91          */
  92         public void add_parameter (Parameter param) {
  93                 parameters.add (param);
  94                 scope.add (param.name, param);
  95         }
  96
  97         public List<Parameter> get_parameters () {
  98                 return parameters;
  99         }
 100
 101         /**
 102          * Returns generated delegate to be used for signal handlers.
 103          *
 104          * @return delegate
 105          */
 106         public Delegate get_delegate (DataType sender_type, CodeNode node_reference) {
 107                 var actual_return_type = return_type.get_actual_type (sender_type, null, node_reference);
 108
 109                 var generated_delegate = new Delegate (null, actual_return_type);
 110                 generated_delegate.access = SymbolAccessibility.PUBLIC;
 111                 generated_delegate.owner = scope;
 112
 113                 // sender parameter is never null and doesn't own its value
 114                 var sender_param_type = sender_type.copy ();
 115                 sender_param_type.value_owned = false;
 116                 sender_param_type.nullable = false;
 117
 118                 generated_delegate.sender_type = sender_param_type;
 119
 120                 bool is_generic = false;
 121
 122                 foreach (Parameter param in parameters) {
 123                         var actual_param = param.copy ();
 124                         actual_param.variable_type = actual_param.variable_type.get_actual_type (sender_type, null, node_reference);
 125                         generated_delegate.add_parameter (actual_param);
 126
 127                         if (actual_param.variable_type is GenericType) {
 128                                 is_generic = true;
 129                         }
 130                 }
 131
 132                 if (is_generic) {
 133                         var cl = (ObjectTypeSymbol) parent_symbol;
 134                         foreach (var type_param in cl.get_type_parameters ()) {
 135                                 generated_delegate.add_type_parameter (new TypeParameter (type_param.name, type_param.source_reference));
 136                         }
 137
 138                         // parameter types must refer to the delegate type parameters
 139                         // instead of to the class type parameters
 140                         foreach (var param in generated_delegate.get_parameters ()) {
 141                                 var generic_type = param.variable_type as GenericType;
 142                                 if (generic_type != null) {
 143                                         generic_type.type_parameter = generated_delegate.get_type_parameters ().get (generated_delegate.get_type_parameter_index (generic_type.type_parameter.name));
 144                                 }
 145                         }
 146                 }
 147
 148                 scope.add (null, generated_delegate);
 149
 150                 return generated_delegate;
 151         }
 152
 153         public override void accept (CodeVisitor visitor) {
 154                 visitor.visit_signal (this);
 155         }
 156
 157         public override void accept_children (CodeVisitor visitor) {
 158                 return_type.accept (visitor);
 159
 160                 foreach (Parameter param in parameters) {
 161                         param.accept (visitor);
 162                 }
 163                 if (default_handler == null && body != null) {
 164                         body.accept (visitor);
 165                 } else if (default_handler != null) {
 166                         default_handler.accept (visitor);
 167                 }
 168                 if (emitter != null) {
 169                         emitter.accept (visitor);
 170                 }
 171         }
 172
 173         public bool get_lock_used () {
 174                 return lock_used;
 175         }
 176
 177         public void set_lock_used (bool used) {
 178                 lock_used = used;
 179         }
 180
 181         public override void replace_type (DataType old_type, DataType new_type) {
 182                 if (return_type == old_type) {
 183                         return_type = new_type;
 184                 }
 185         }
 186
 187         public override bool check (CodeContext context) {
 188                 if (checked) {
 189                         return !error;
 190                 }
 191
 192                 checked = true;
 193
 194                 return_type.check (context);
 195
 196                 foreach (Parameter param in parameters) {
 197                         if (param.ellipsis) {
 198                                 Report.error  (param.source_reference, "Signals with variable argument lists are not supported");
 199                                 return false;
 200                         }
 201
 202                         param.check (context);
 203                 }
 204
 205                 if (!is_virtual && body != null) {
 206                         Report.error (source_reference, "Only virtual signals can have a default signal handler body");
 207                 }
 208
 209
 210                 if (is_virtual) {
 211                         default_handler = new Method (name, return_type, source_reference);
 212
 213                         default_handler.owner = owner;
 214                         default_handler.access = access;
 215                         default_handler.external = external;
 216                         default_handler.hides = hides;
 217                         default_handler.is_virtual = true;
 218                         default_handler.signal_reference = this;
 219                         default_handler.body = body;
 220
 221
 222                         foreach (Parameter param in parameters) {
 223                                 default_handler.add_parameter (param);
 224                         }
 225
 226                         var cl = parent_symbol as ObjectTypeSymbol;
 227
 228                         cl.add_hidden_method (default_handler);
 229                         default_handler.check (context);
 230                 }
 231
 232                 if (!external_package && get_attribute ("HasEmitter") != null) {
 233                         emitter = new Method (name, return_type, source_reference);
 234
 235                         emitter.owner = owner;
 236                         emitter.access = access;
 237
 238                         var body = new Block (source_reference);
 239                         var call = new MethodCall (new MemberAccess.simple (name, source_reference), source_reference);
 240
 241                         foreach (Parameter param in parameters) {
 242                                 emitter.add_parameter (param);
 243                                 call.add_argument (new MemberAccess.simple (param.name, source_reference));
 244                         }
 245
 246                         if (return_type is VoidType) {
 247                                 body.add_statement (new ExpressionStatement (call, source_reference));
 248                         } else {
 249                                 body.add_statement (new ReturnStatement (call, source_reference));
 250                         }
 251                         emitter.body = body;
 252
 253                         var cl = parent_symbol as ObjectTypeSymbol;
 254
 255                         cl.add_hidden_method (emitter);
 256                         emitter.check (context);
 257                 }
 258
 259
 260                 if (!external_package && !hides && get_hidden_member () != null) {
 261                         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 ()));
 262                 }
 263
 264                 return !error;
 265         }
 266 }
 267