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 new ReadOnlyList<Expression> (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 (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 (container is MemberAccess && container.symbol_reference is Signal) {
 156                         index_int_type_check = false;
 157
 158                         symbol_reference = container.symbol_reference;
 159                         value_type = container.value_type;
 160                 } else {
 161                         if (lvalue) {
 162                                 var set_method = container.value_type.get_member ("set") as Method;
 163                                 var assignment = parent_node as Assignment;
 164                                 if (set_method != null && assignment != null) {
 165                                         return !error;
 166                                 }
 167                         } else {
 168                                 var get_method = container.value_type.get_member ("get") as Method;
 169                                 if (get_method != null) {
 170                                         var get_call = new MethodCall (new MemberAccess (container, "get"));
 171                                         foreach (Expression e in get_indices ()) {
 172                                                 get_call.add_argument (e);
 173                                         }
 174                                         get_call.target_type = this.target_type;
 175                                         parent_node.replace_expression (this, get_call);
 176                                         return get_call.check (analyzer);
 177                                 }
 178                         }
 179
 180                         error = true;
 181                         Report.error (source_reference, "The expression `%s' does not denote an array".printf (container.value_type.to_string ()));
 182                 }
 183
 184                 if (index_int_type_check) {
 185                         /* check if the index is of type integer */
 186                         foreach (Expression e in get_indices ()) {
 187                                 /* don't proceed if a child expression failed */
 188                                 if (e.value_type == null) {
 189                                         return false;
 190                                 }
 191
 192                                 /* check if the index is of type integer */
 193                                 if (!(e.value_type is IntegerType || e.value_type is EnumValueType)) {
 194                                         error = true;
 195                                         Report.error (e.source_reference, "Expression of integer type expected");
 196                                 }
 197                         }
 198                 }
 199
 200                 return !error;
 201         }
 202
 203         public override void get_defined_variables (Collection<LocalVariable> collection) {
 204                 container.get_defined_variables (collection);
 205                 foreach (Expression index in indices) {
 206                         index.get_defined_variables (collection);
 207                 }
 208         }
 209
 210         public override void get_used_variables (Collection<LocalVariable> collection) {
 211                 container.get_used_variables (collection);
 212                 foreach (Expression index in indices) {
 213                         index.get_used_variables (collection);
 214                 }
 215         }
 216 }