vala/valasliceexpression.vala

   1 /* valasliceexpression.vala
   2  *
   3  * Copyright (C) 2009 Robin Sonefors
   4  * Copyright (C) 2009-2010 Jürg Billeter
   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  *      Robin Sonefors <ozamosi@flukkost.nu>
  22  *      Jürg Billeter <j@bitron.ch>
  23  */
  24
  25 using GLib;
  26
  27 /**
  28  * Represents an array slice expression e.g "a[1:5]".
  29  */
  30 public class Vala.SliceExpression : Expression {
  31         public Expression container {
  32                 get {
  33                         return _container;
  34                 }
  35                 set {
  36                         _container = value;
  37                         _container.parent_node = this;
  38                 }
  39         }
  40
  41         public Expression start {
  42                 get {
  43                         return _start;
  44                 }
  45                 private set {
  46                         _start = value;
  47                         _start.parent_node = this;
  48                 }
  49         }
  50
  51         public Expression stop {
  52                 get {
  53                         return _stop;
  54                 }
  55                 private set {
  56                         _stop = value;
  57                         _stop.parent_node = this;
  58                 }
  59         }
  60
  61         Expression _container;
  62         Expression _start;
  63         Expression _stop;
  64
  65         public SliceExpression (Expression container, Expression start, Expression stop, SourceReference? source_reference = null) {
  66                 this.container = container;
  67                 this.start = start;
  68                 this.stop = stop;
  69                 this.source_reference = source_reference;
  70         }
  71
  72         public override void accept (CodeVisitor visitor) {
  73                 visitor.visit_slice_expression (this);
  74
  75                 visitor.visit_expression (this);
  76         }
  77
  78         public override void accept_children (CodeVisitor visitor) {
  79                 container.accept (visitor);
  80
  81                 start.accept (visitor);
  82                 stop.accept (visitor);
  83         }
  84
  85         public override void replace_expression (Expression old_node, Expression new_node) {
  86                 if (container == old_node) {
  87                         container = new_node;
  88                 }
  89                 if (start == old_node) {
  90                         start = new_node;
  91                 }
  92                 if (stop == old_node) {
  93                         stop = new_node;
  94                 }
  95         }
  96
  97         public override bool is_pure () {
  98                 return false;
  99         }
 100
 101         public override bool check (CodeContext context) {
 102                 if (checked) {
 103                         return !error;
 104                 }
 105
 106                 checked = true;
 107
 108                 if (!container.check (context)) {
 109                         error = true;
 110                         return false;
 111                 }
 112
 113                 if (!start.check (context)) {
 114                         error = true;
 115                         return false;
 116                 }
 117
 118                 if (!stop.check (context)) {
 119                         error = true;
 120                         return false;
 121                 }
 122
 123                 if (container.value_type == null) {
 124                         error = true;
 125                         Report.error (container.source_reference, "Invalid container expression");
 126                         return false;
 127                 }
 128
 129                 if (lvalue) {
 130                         error = true;
 131                         Report.error (container.source_reference, "Slice expressions cannot be used as lvalue");
 132                         return false;
 133                 }
 134
 135                 if (container.value_type is ArrayType) {
 136                         value_type = container.value_type.copy ();
 137                         value_type.value_owned = false;
 138
 139                         /* check if the index is of type integer */
 140                         if (!(start.value_type is IntegerType || start.value_type is EnumValueType)) {
 141                                 error = true;
 142                                 Report.error (start.source_reference, "Expression of integer type expected");
 143                         }
 144                         if (!(stop.value_type is IntegerType || stop.value_type is EnumValueType)) {
 145                                 error = true;
 146                                 Report.error (stop.source_reference, "Expression of integer type expected");
 147                         }
 148                 } else {
 149                         var slice_method = container.value_type.get_member ("slice") as Method;
 150                         if (slice_method != null) {
 151                                 var slice_call = new MethodCall (new MemberAccess (container, "slice"));
 152                                 slice_call.add_argument (start);
 153                                 slice_call.add_argument (stop);
 154                                 slice_call.target_type = this.target_type;
 155                                 parent_node.replace_expression (this, slice_call);
 156                                 return slice_call.check (context);
 157                         }
 158
 159                         error = true;
 160                         Report.error (source_reference, "The expression `%s' does not denote an array".printf (container.value_type.to_string ()));
 161                 }
 162
 163                 return !error;
 164         }
 165
 166         public override void emit (CodeGenerator codegen) {
 167                 container.emit (codegen);
 168
 169                 start.emit (codegen);
 170                 stop.emit (codegen);
 171
 172                 codegen.visit_slice_expression (this);
 173
 174                 codegen.visit_expression (this);
 175         }
 176
 177         public override void get_defined_variables (Collection<LocalVariable> collection) {
 178                 container.get_defined_variables (collection);
 179                 start.get_defined_variables (collection);
 180                 stop.get_defined_variables (collection);
 181         }
 182
 183         public override void get_used_variables (Collection<LocalVariable> collection) {
 184                 container.get_used_variables (collection);
 185                 start.get_used_variables (collection);
 186                 stop.get_used_variables (collection);
 187         }
 188 }