vala/valaparameter.vala

   1 /* valaparameter.vala
   2  *
   3  * Copyright (C) 2006-2011  Jürg Billeter
   4  * Copyright (C) 2006-2008  Raffaele Sandrini
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  19  *
  20  * Author:
  21  *      Jürg Billeter <j@bitron.ch>
  22  *      Raffaele Sandrini <raffaele@sandrini.ch>
  23  */
  24
  25 using GLib;
  26
  27 /**
  28  * Represents a formal parameter in method and callback signatures.
  29  */
  30 public class Vala.Parameter : Variable {
  31         public ParameterDirection direction { get; set; default = ParameterDirection.IN; }
  32
  33         /**
  34          * Specifies whether the methods accepts an indefinite number of
  35          * parameters.
  36          */
  37         public bool ellipsis { get; set; }
  38
  39         /**
  40          * Specifies whether the methods accepts an indefinite number of
  41          * parameters.
  42          */
  43         public bool params_array { get; set; }
  44
  45         /**
  46          * Specifies the position of the parameter in the C function.
  47          */
  48         public double cparameter_position { get; set; }
  49
  50         /**
  51          * Specifies the position of the array length parameter in the C
  52          * function.
  53          */
  54         public double carray_length_parameter_position { get; set; }
  55
  56         /**
  57          * Specifies the position of the delegate target parameter in the C
  58          * function.
  59          */
  60         public double cdelegate_target_parameter_position { get; set; }
  61
  62         public double cdestroy_notify_parameter_position { get; set; }
  63
  64         /**
  65          * Specifies the type of the parameter in the C function.
  66          */
  67         public string? ctype { get; set; }
  68
  69         public bool captured { get; set; }
  70
  71         /**
  72          * Creates a new formal parameter.
  73          *
  74          * @param name   parameter name
  75          * @param type   parameter type
  76          * @param source reference to source code
  77          * @return       newly created formal parameter
  78          */
  79         public Parameter (string name, DataType variable_type, SourceReference? source_reference = null) {
  80                 base (variable_type, name, null, source_reference);
  81
  82                 access = SymbolAccessibility.PUBLIC;
  83         }
  84
  85         /**
  86          * Creates a new ellipsis parameter representing an indefinite number of
  87          * parameters.
  88          */
  89         public Parameter.with_ellipsis (SourceReference? source_reference = null) {
  90                 base (null, null, null, source_reference);
  91                 ellipsis = true;
  92
  93                 access = SymbolAccessibility.PUBLIC;
  94         }
  95
  96         public override void accept (CodeVisitor visitor) {
  97                 visitor.visit_formal_parameter (this);
  98         }
  99
 100         public override void accept_children (CodeVisitor visitor) {
 101                 if (!ellipsis) {
 102                         variable_type.accept (visitor);
 103
 104                         if (initializer != null) {
 105                                 initializer.accept (visitor);
 106                         }
 107                 }
 108         }
 109
 110         public override void replace_type (DataType old_type, DataType new_type) {
 111                 if (variable_type == old_type) {
 112                         variable_type = new_type;
 113                 }
 114         }
 115
 116         public override void replace_expression (Expression old_node, Expression new_node) {
 117                 if (initializer == old_node) {
 118                         initializer = new_node;
 119                 }
 120         }
 121
 122         private void process_ccode_attribute (Attribute a) {
 123                 if (a.has_argument ("type")) {
 124                         ctype = a.get_string ("type");
 125                 }
 126                 if (a.has_argument ("pos")) {
 127                         cparameter_position = a.get_double ("pos");
 128                 }
 129                 if (a.has_argument ("array_length_pos")) {
 130                         carray_length_parameter_position = a.get_double ("array_length_pos");
 131                 }
 132                 if (a.has_argument ("delegate_target_pos")) {
 133                         cdelegate_target_parameter_position = a.get_double ("delegate_target_pos");
 134                 }
 135                 if (a.has_argument ("destroy_notify_pos")) {
 136                         cdestroy_notify_parameter_position = a.get_double ("destroy_notify_pos");
 137                 }
 138         }
 139
 140         /**
 141          * Process all associated attributes.
 142          */
 143         public override void process_attributes () {
 144                 base.process_attributes ();
 145
 146                 foreach (Attribute a in attributes) {
 147                         if (a.name == "CCode") {
 148                                 process_ccode_attribute (a);
 149                         }
 150                 }
 151         }
 152
 153         public Parameter copy () {
 154                 if (!ellipsis) {
 155                         var result = new Parameter (name, variable_type, source_reference);
 156                         result.params_array = params_array;
 157                         result.direction = this.direction;
 158                         result.initializer = this.initializer;
 159                         result.no_array_length = this.no_array_length;
 160                         result.no_delegate_target = this.no_delegate_target;
 161                         result.array_null_terminated = this.array_null_terminated;
 162                         return result;
 163                 } else {
 164                         return new Parameter.with_ellipsis ();
 165                 }
 166         }
 167
 168         public override bool check (CodeContext context) {
 169                 if (checked) {
 170                         return !error;
 171                 }
 172
 173                 checked = true;
 174
 175                 process_attributes ();
 176
 177                 var old_source_file = context.analyzer.current_source_file;
 178                 var old_symbol = context.analyzer.current_symbol;
 179
 180                 if (source_reference != null) {
 181                         context.analyzer.current_source_file = source_reference.file;
 182                 }
 183                 context.analyzer.current_symbol = parent_symbol;
 184
 185                 if (variable_type != null) {
 186                         if (variable_type is VoidType) {
 187                                 error = true;
 188                                 Report.error (source_reference, "'void' not supported as parameter type");
 189                                 return false;
 190                         }
 191                         variable_type.check (context);
 192                 }
 193
 194                 if (!ellipsis) {
 195                         variable_type.check (context);
 196
 197                         if (params_array && !(variable_type is ArrayType)) {
 198                                 error = true;
 199                                 Report.error (source_reference, "parameter array expected");
 200                                 return false;
 201                         }
 202
 203                         if (initializer != null) {
 204                                 initializer.target_type = variable_type.copy ();
 205                                 initializer.check (context);
 206                         }
 207                 }
 208
 209                 if (initializer != null) {
 210                         if (initializer is NullLiteral
 211                             && !variable_type.nullable
 212                             && direction != ParameterDirection.OUT) {
 213                                 Report.warning (source_reference, "`null' incompatible with parameter type `%s`".printf (variable_type.to_string ()));
 214                         } else if (!(initializer is NullLiteral) && direction == ParameterDirection.OUT) {
 215                                 Report.error (source_reference, "only `null' is allowed as default value for out parameters");
 216                         } else if (direction == ParameterDirection.REF) {
 217                                 Report.error (source_reference, "default value not allowed for ref parameter");
 218                         }
 219                 }
 220
 221                 if (!ellipsis) {
 222                         // check whether parameter type is at least as accessible as the method
 223                         if (!context.analyzer.is_type_accessible (this, variable_type)) {
 224                                 error = true;
 225                                 Report.error (source_reference, "parameter type `%s` is less accessible than method `%s`".printf (variable_type.to_string (), parent_symbol.get_full_name ()));
 226                         }
 227                 }
 228
 229                 context.analyzer.current_source_file = old_source_file;
 230                 context.analyzer.current_symbol = old_symbol;
 231
 232                 return !error;
 233         }
 234 }
 235
 236 public enum Vala.ParameterDirection {
 237         IN,
 238         OUT,
 239         REF
 240 }
 241