vala/valaelementaccess.vala

   1 /* valaelementaccess.vala
   2  *
   3  * Copyright (C) 2006-2009  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  *      Raffaele Sandrini <raffaele@sandrini.ch>
  22  *      Jürg Billeter <j@bitron.ch>
  23  */
  24
  25 using GLib;
  26
  27 /**
  28  * Represents an array access expression e.g. "a[1,2]".
  29  */
  30 public class Vala.ElementAccess : Expression {
  31         /**
  32          * Expression representing the container on wich we want to access.
  33          */
  34         public Expression container {
  35                 get {
  36                         return _container;
  37                 }
  38                 set {
  39                         _container = value;
  40                         _container.parent_node = this;
  41                 }
  42         }
  43
  44         /**
  45          * Expressions representing the indices we want to access inside the container.
  46          */
  47         private List<Expression> indices = new ArrayList<Expression> ();
  48
  49         Expression _container;
  50
  51         public void append_index (Expression index) {
  52                 indices.add (index);
  53                 index.parent_node = this;
  54         }
  55
  56         public List<Expression> get_indices () {
  57                 return indices;
  58         }
  59
  60         public ElementAccess (Expression container, SourceReference source_reference) {
  61                 this.source_reference = source_reference;
  62                 this.container = container;
  63         }
  64
  65         public override void accept (CodeVisitor visitor) {
  66                 visitor.visit_element_access (this);
  67
  68                 visitor.visit_expression (this);
  69         }
  70
  71         public override void accept_children (CodeVisitor visitor) {
  72                 container.accept (visitor);
  73                 foreach (Expression e in indices) {
  74                         e.accept (visitor);
  75                 }
  76         }
  77
  78         public override void replace_expression (Expression old_node, Expression new_node) {
  79                 if (container == old_node) {
  80                         container = new_node;
  81                 }
  82
  83                 int index = indices.index_of (old_node);
  84                 if (index >= 0 && new_node.parent_node == null) {
  85                         indices[index] = new_node;
  86                         new_node.parent_node = this;
  87                 }
  88         }
  89
  90         public override bool is_pure () {
  91                 foreach (Expression index in indices) {
  92                         if (!index.is_pure ()) {
  93                                 return false;
  94                         }
  95                 }
  96                 return container.is_pure ();
  97         }
  98
  99         public override bool check (SemanticAnalyzer analyzer) {
 100                 if (checked) {
 101                         return !error;
 102                 }
 103
 104                 checked = true;
 105
 106                 if (!container.check (analyzer)) {
 107                         /* don't proceed if a child expression failed */
 108                         error = true;
 109                         return false;
 110                 }
 111
 112                 if (container.value_type == null) {
 113                         error = true;
 114                         Report.error (container.source_reference, "Invalid container expression");
 115                         return false;
 116                 }
 117
 118                 var container_type = container.value_type.data_type;
 119
 120                 if (container is MemberAccess && container.symbol_reference is Signal) {
 121                         // signal detail access
 122                         if (get_indices ().size != 1) {
 123                                 error = true;
 124                                 Report.error (source_reference, "Element access with more than one dimension is not supported for signals");
 125                                 return false;
 126                         }
 127                         get_indices ().get (0).target_type = analyzer.string_type.copy ();
 128                 }
 129
 130                 foreach (Expression index in get_indices ()) {
 131                         index.check (analyzer);
 132                 }
 133
 134                 bool index_int_type_check = true;
 135
 136                 var pointer_type = container.value_type as PointerType;
 137
 138                 /* assign a value_type when possible */
 139                 if (container.value_type is ArrayType) {
 140                         var array_type = (ArrayType) container.value_type;
 141                         value_type = array_type.element_type.copy ();
 142                         if (!lvalue) {
 143                                 value_type.value_owned = false;
 144                         }
 145                 } else if (pointer_type != null && !pointer_type.base_type.is_reference_type_or_type_parameter ()) {
 146                         value_type = pointer_type.base_type.copy ();
 147                 } else if (analyzer.context.profile == Profile.GOBJECT && container_type == analyzer.string_type.data_type) {
 148                         if (get_indices ().size != 1) {
 149                                 error = true;
 150                                 Report.error (source_reference, "Element access with more than one dimension is not supported for strings");
 151                                 return false;
 152                         }
 153
 154                         value_type = analyzer.unichar_type;
 155                 } else if (analyzer.context.profile == Profile.DOVA && container_type == analyzer.tuple_type.data_type) {
 156                         if (get_indices ().size != 1) {
 157                                 error = true;
 158                                 Report.error (source_reference, "Element access with more than one dimension is not supported for tuples");
 159                                 return false;
 160                         }
 161                         var index = get_indices ().get (0) as IntegerLiteral;
 162                         if (index == null) {
 163                                 error = true;
 164                                 Report.error (source_reference, "Element access with non-literal index is not supported for tuples");
 165                                 return false;
 166                         }
 167                         int i = index.value.to_int ();
 168                         if (container.value_type.get_type_arguments ().size == 0) {
 169                                 error = true;
 170                                 Report.error (source_reference, "Element access is not supported for untyped tuples");
 171                                 return false;
 172                         }
 173                         if (i < 0 || i >= container.value_type.get_type_arguments ().size) {
 174                                 error = true;
 175                                 Report.error (source_reference, "Index out of range");
 176                                 return false;
 177                         }
 178
 179                         value_type = container.value_type.get_type_arguments ().get (i);
 180
 181                         // replace element access by call to generic get method
 182                         var ma = new MemberAccess (container, "get");
 183                         ma.add_type_argument (value_type);
 184                         var get_call = new MethodCall (ma);
 185                         get_call.add_argument (index);
 186                         get_call.target_type = this.target_type;
 187                         parent_node.replace_expression (this, get_call);
 188                         return get_call.check (analyzer);
 189                 } else if (container is MemberAccess && container.symbol_reference is Signal) {
 190                         index_int_type_check = false;
 191
 192                         symbol_reference = container.symbol_reference;
 193                         value_type = container.value_type;
 194                 } else {
 195                         if (lvalue) {
 196                                 var set_method = container.value_type.get_member ("set") as Method;
 197                                 var assignment = parent_node as Assignment;
 198                                 if (set_method != null && assignment != null) {
 199                                         return !error;
 200                                 }
 201                         } else {
 202                                 var get_method = container.value_type.get_member ("get") as Method;
 203                                 if (get_method != null) {
 204                                         var get_call = new MethodCall (new MemberAccess (container, "get"));
 205                                         foreach (Expression e in get_indices ()) {
 206                                                 get_call.add_argument (e);
 207                                         }
 208                                         get_call.target_type = this.target_type;
 209                                         parent_node.replace_expression (this, get_call);
 210                                         return get_call.check (analyzer);
 211                                 }
 212                         }
 213
 214                         error = true;
 215                         Report.error (source_reference, "The expression `%s' does not denote an array".printf (container.value_type.to_string ()));
 216                 }
 217
 218                 if (index_int_type_check) {
 219                         /* check if the index is of type integer */
 220                         foreach (Expression e in get_indices ()) {
 221                                 /* don't proceed if a child expression failed */
 222                                 if (e.value_type == null) {
 223                                         return false;
 224                                 }
 225
 226                                 /* check if the index is of type integer */
 227                                 if (!(e.value_type is IntegerType || e.value_type is EnumValueType)) {
 228                                         error = true;
 229                                         Report.error (e.source_reference, "Expression of integer type expected");
 230                                 }
 231                         }
 232                 }
 233
 234                 return !error;
 235         }
 236
 237         public override void get_defined_variables (Collection<LocalVariable> collection) {
 238                 container.get_defined_variables (collection);
 239                 foreach (Expression index in indices) {
 240                         index.get_defined_variables (collection);
 241                 }
 242         }
 243
 244         public override void get_used_variables (Collection<LocalVariable> collection) {
 245                 container.get_used_variables (collection);
 246                 foreach (Expression index in indices) {
 247                         index.get_used_variables (collection);
 248                 }
 249         }
 250 }