vala/valacodenode.vala

   1 /* valacodenode.vala
   2  *
   3  * Copyright (C) 2006-2010  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 a part of the parsed source code.
  27  *
  28  * Code nodes get created by the parser and are used throughout the whole
  29  * compilation process.
  30  */
  31 public abstract class Vala.CodeNode {
  32         /**
  33          * Parent of this code node.
  34          */
  35         public weak CodeNode? parent_node { get; set; }
  36
  37         /**
  38          * References the location in the source file where this code node has
  39          * been written.
  40          */
  41         public SourceReference? source_reference { get; set; }
  42
  43         public bool unreachable { get; set; }
  44
  45         /**
  46          * Contains all attributes that have been specified for this code node.
  47          */
  48         public GLib.List<Attribute> attributes;
  49
  50         public string type_name {
  51                 get { return Type.from_instance (this).name (); }
  52         }
  53
  54         public bool checked { get; set; }
  55
  56         /**
  57          * Specifies whether a fatal error has been detected in this code node.
  58          */
  59         public bool error { get; set; }
  60
  61         /**
  62          * Specifies that this node or a child node may throw an exception.
  63          */
  64         public bool tree_can_fail {
  65                 get { return _error_types != null && _error_types.size > 0; }
  66         }
  67
  68         private List<DataType> _error_types;
  69         private static List<DataType> _empty_type_list;
  70         private AttributeCache[] attributes_cache;
  71
  72         static int last_temp_nr = 0;
  73         static int next_attribute_cache_index = 0;
  74
  75         /**
  76          * Specifies the exceptions that can be thrown by this node or a child node
  77          */
  78         public List<DataType> get_error_types () {
  79                 if (_error_types != null) {
  80                         return _error_types;
  81                 }
  82                 if (_empty_type_list == null) {
  83                         _empty_type_list = new ArrayList<DataType> ();
  84                 }
  85                 return _empty_type_list;
  86         }
  87
  88         /**
  89          * Adds an error type to the exceptions that can be thrown by this node
  90          * or a child node
  91          */
  92         public void add_error_type (DataType error_type) {
  93                 if (_error_types == null) {
  94                         _error_types = new ArrayList<DataType> ();
  95                 }
  96                 _error_types.add (error_type);
  97                 error_type.parent_node = this;
  98         }
  99
 100         /**
 101          * Adds a collection of error types to the exceptions that can be thrown by this node
 102          * or a child node
 103          */
 104         public void add_error_types (List<DataType> error_types) {
 105                 foreach (DataType error_type in error_types) {
 106                         add_error_type (error_type);
 107                 }
 108         }
 109
 110         /**
 111          * Visits this code node with the specified CodeVisitor.
 112          *
 113          * @param visitor the visitor to be called while traversing
 114          */
 115         public virtual void accept (CodeVisitor visitor) {
 116         }
 117
 118         /**
 119          * Visits all children of this code node with the specified CodeVisitor.
 120          *
 121          * @param visitor the visitor to be called while traversing
 122          */
 123         public virtual void accept_children (CodeVisitor visitor) {
 124         }
 125
 126         public virtual bool check (CodeContext context) {
 127                 return true;
 128         }
 129
 130         public virtual void emit (CodeGenerator codegen) {
 131         }
 132
 133         public virtual void replace_type (DataType old_type, DataType new_type) {
 134         }
 135
 136         public virtual void replace_expression (Expression old_node, Expression new_node) {
 137         }
 138
 139         /**
 140          * Returns the specified attribute.
 141          *
 142          * @param name attribute name
 143          * @return     attribute
 144          */
 145         public Attribute? get_attribute (string name) {
 146                 // FIXME: use hash table
 147                 foreach (Attribute a in attributes) {
 148                         if (a.name == name) {
 149                                 return a;
 150                         }
 151                 }
 152
 153                 return null;
 154         }
 155
 156         /**
 157          * Returns true if the specified attribute argument is set.
 158          *
 159          * @param  attribute attribute name
 160          * @param  argument  argument name
 161          * @return           true if the attribute has the given argument
 162          */
 163         public bool has_attribute_argument (string attribute, string argument) {
 164                 var a = get_attribute (attribute);
 165                 if (a == null) {
 166                         return false;
 167                 }
 168                 return a.has_argument (argument);
 169         }
 170
 171         /**
 172          * Sets the specified named attribute to this code node.
 173          *
 174          * @param name  attribute name
 175          * @param value true to add the attribute, false to remove it
 176          */
 177         public void set_attribute (string name, bool value, SourceReference? source_reference = null) {
 178                 var a = get_attribute (name);
 179                 if (value && a == null) {
 180                         attributes.append (new Attribute (name, source_reference));
 181                 } else if (!value && a != null) {
 182                         attributes.remove (a);
 183                 }
 184         }
 185
 186         /**
 187          * Remove the specified named attribute argument
 188          *
 189          * @param attribute attribute name
 190          * @param argument  argument name
 191          */
 192         public void remove_attribute_argument (string attribute, string argument) {
 193                 var a = get_attribute (attribute);
 194                 if (a != null) {
 195                         a.args.remove (argument);
 196                         if (a.args.size == 0) {
 197                                 attributes.remove (a);
 198                         }
 199                 }
 200         }
 201
 202         /**
 203          * Returns the string value of the specified attribute argument.
 204          *
 205          * @param attribute attribute name
 206          * @param argument  argument name
 207          * @return          string value
 208          */
 209         public string? get_attribute_string (string attribute, string argument, string? default_value = null) {
 210                 var a = get_attribute (attribute);
 211                 if (a == null) {
 212                         return default_value;
 213                 }
 214                 return a.get_string (argument, default_value);
 215         }
 216
 217         /**
 218          * Returns the integer value of the specified attribute argument.
 219          *
 220          * @param attribute attribute name
 221          * @param argument  argument name
 222          * @return          integer value
 223          */
 224         public int get_attribute_integer (string attribute, string argument, int default_value = 0) {
 225                 var a = get_attribute (attribute);
 226                 if (a == null) {
 227                         return default_value;
 228                 }
 229                 return a.get_integer (argument, default_value);
 230         }
 231
 232         /**
 233          * Returns the double value of the specified attribute argument.
 234          *
 235          * @param attribute attribute name
 236          * @param argument  argument name
 237          * @return          double value
 238          */
 239         public double get_attribute_double (string attribute, string argument, double default_value = 0) {
 240                 if (attributes == null) {
 241                         return default_value;
 242                 }
 243                 var a = get_attribute (attribute);
 244                 if (a == null) {
 245                         return default_value;
 246                 }
 247                 return a.get_double (argument, default_value);
 248         }
 249
 250         /**
 251          * Returns the bool value of the specified attribute argument.
 252          *
 253          * @param attribute attribute name
 254          * @param argument  argument name
 255          * @return          bool value
 256          */
 257         public bool get_attribute_bool (string attribute, string argument, bool default_value = false) {
 258                 if (attributes == null) {
 259                         return default_value;
 260                 }
 261                 var a = get_attribute (attribute);
 262                 if (a == null) {
 263                         return default_value;
 264                 }
 265                 return a.get_bool (argument, default_value);
 266         }
 267
 268         /**
 269          * Sets the string value of the specified attribute argument.
 270          *
 271          * @param attribute attribute name
 272          * @param argument  argument name
 273          * @param value     string value
 274          */
 275         public void set_attribute_string (string attribute, string argument, string? value, SourceReference? source_reference = null) {
 276                 if (value == null) {
 277                         remove_attribute_argument (attribute, argument);
 278                         return;
 279                 }
 280
 281                 var a = get_attribute (attribute);
 282                 if (a == null) {
 283                         a = new Attribute (attribute, source_reference);
 284                         attributes.append (a);
 285                 }
 286                 a.add_argument (argument, "\"%s\"".printf (value));
 287         }
 288
 289         /**
 290          * Sets the integer value of the specified attribute argument.
 291          *
 292          * @param attribute attribute name
 293          * @param argument  argument name
 294          * @param value     integer value
 295          */
 296         public void set_attribute_integer (string attribute, string argument, int value, SourceReference? source_reference = null) {
 297                 var a = get_attribute (attribute);
 298                 if (a == null) {
 299                         a = new Attribute (attribute, source_reference);
 300                         attributes.append (a);
 301                 }
 302                 a.add_argument (argument, value.to_string ());
 303         }
 304
 305         /**
 306          * Sets the integer value of the specified attribute argument.
 307          *
 308          * @param attribute attribute name
 309          * @param argument  argument name
 310          * @param value     double value
 311          */
 312         public void set_attribute_double (string attribute, string argument, double value, SourceReference? source_reference = null) {
 313                 var a = get_attribute (attribute);
 314                 if (a == null) {
 315                         a = new Attribute (attribute, source_reference);
 316                         attributes.append (a);
 317                 }
 318                 a.add_argument (argument, value.format (new char[double.DTOSTR_BUF_SIZE]));
 319         }
 320
 321         /**
 322          * Sets the boolean value of the specified attribute argument.
 323          *
 324          * @param attribute attribute name
 325          * @param argument  argument name
 326          * @param value     bool value
 327          */
 328         public void set_attribute_bool (string attribute, string argument, bool value, SourceReference? source_reference = null) {
 329                 var a = get_attribute (attribute);
 330                 if (a == null) {
 331                         a = new Attribute (attribute, source_reference);
 332                         attributes.append (a);
 333                 }
 334                 a.add_argument (argument, value.to_string ());
 335         }
 336
 337         /**
 338          * Returns the attribute cache at the specified index.
 339          *
 340          * @param index attribute cache index
 341          * @return      attribute cache
 342          */
 343         public AttributeCache? get_attribute_cache (int index) {
 344                 if (index >= attributes_cache.length) {
 345                         return null;
 346                 }
 347                 return attributes_cache[index];
 348         }
 349
 350         /**
 351          * Sets the specified attribute cache to this code node.
 352          *
 353          * @param index attribute cache index
 354          * @param cache attribute cache
 355          */
 356         public void set_attribute_cache (int index, AttributeCache cache) {
 357                 if (index >= attributes_cache.length) {
 358                         attributes_cache.resize (index * 2 + 1);
 359                 }
 360                 attributes_cache[index] = cache;
 361         }
 362
 363         /**
 364          * Returns a string that represents this code node.
 365          *
 366          * @return a string representation
 367          */
 368         public virtual string to_string () {
 369                 var str = new StringBuilder ();
 370
 371                 str.append ("/* ");
 372
 373                 if (source_reference != null) {
 374                         str.append ("@").append (source_reference.to_string ());
 375                 }
 376
 377                 return str.append (" */").str;
 378         }
 379
 380         public virtual void get_defined_variables (Collection<Variable> collection) {
 381         }
 382
 383         public virtual void get_used_variables (Collection<Variable> collection) {
 384         }
 385
 386         public static string get_temp_name () {
 387                 return "." + (++last_temp_nr).to_string ();
 388         }
 389
 390         /**
 391          * Returns a new cache index for accessing the attributes cache of code nodes
 392          *
 393          * @return a new cache index
 394          */
 395         public static int get_attribute_cache_index () {
 396                 return next_attribute_cache_index++;
 397         }
 398 }
 399
 400 public class Vala.AttributeCache {
 401 }