vala/valacodenode.vala

   1 /* valacodenode.vala
   2  *
   3  * Copyright (C) 2006-2009  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 using Gee;
  25
  26 /**
  27  * Represents a part of the parsed source code.
  28  *
  29  * Code nodes get created by the parser and are used throughout the whole
  30  * compilation process.
  31  */
  32 public abstract class Vala.CodeNode {
  33         /**
  34          * Parent of this code node.
  35          */
  36         public weak CodeNode? parent_node { get; set; }
  37
  38         /**
  39          * References the location in the source file where this code node has
  40          * been written.
  41          */
  42         public SourceReference? source_reference { get; set; }
  43
  44         /**
  45          * Contains all attributes that have been specified for this code node.
  46          */
  47         public GLib.List<Attribute> attributes;
  48
  49         /**
  50          * Generated CCodeNode that corresponds to this code node.
  51          */
  52         public CCodeNode? ccodenode {
  53                 get {
  54                         return _ccodenode;
  55                 }
  56                 set {
  57                         if (value != null && source_reference != null) {
  58                                 value.line = new CCodeLineDirective (
  59                                         Path.get_basename (source_reference.file.filename),
  60                                         source_reference.first_line);
  61                         }
  62
  63                         _ccodenode = value;
  64                 }
  65         }
  66
  67         public bool checked { get; set; }
  68
  69         /**
  70          * Specifies whether a fatal error has been detected in this code node.
  71          */
  72         public bool error { get; set; }
  73
  74         /**
  75          * Specifies that this node or a child node may throw an exception.
  76          */
  77         public bool tree_can_fail {
  78                 get { return _error_types != null && _error_types.size > 0; }
  79         }
  80
  81         private Gee.List<DataType> _error_types;
  82         private static Gee.List<DataType> _empty_type_list;
  83
  84         private CCodeNode? _ccodenode;
  85
  86         static int last_temp_nr = 0;
  87
  88         /**
  89          * Specifies the exceptions that can be thrown by this node or a child node
  90          */
  91         public Gee.List<DataType> get_error_types () {
  92                 if (_error_types != null) {
  93                         return _error_types;
  94                 }
  95                 if (_empty_type_list == null) {
  96                         _empty_type_list = new ReadOnlyList<DataType> (new ArrayList<DataType> ());
  97                 }
  98                 return _empty_type_list;
  99         }
 100
 101         /**
 102          * Adds an error type to the exceptions that can be thrown by this node
 103          * or a child node
 104          */
 105         public void add_error_type (DataType error_type) {
 106                 if (_error_types == null) {
 107                         _error_types = new ArrayList<DataType> ();
 108                 }
 109                 _error_types.add (error_type);
 110                 error_type.parent_node = this;
 111         }
 112
 113         /**
 114          * Adds a collection of error types to the exceptions that can be thrown by this node
 115          * or a child node
 116          */
 117         public void add_error_types (Gee.List<DataType> error_types) {
 118                 foreach (DataType error_type in error_types) {
 119                         add_error_type (error_type);
 120                 }
 121         }
 122
 123         /**
 124          * Visits this code node with the specified CodeVisitor.
 125          *
 126          * @param visitor the visitor to be called while traversing
 127          */
 128         public virtual void accept (CodeVisitor visitor) {
 129         }
 130
 131         /**
 132          * Visits all children of this code node with the specified CodeVisitor.
 133          *
 134          * @param visitor the visitor to be called while traversing
 135          */
 136         public virtual void accept_children (CodeVisitor visitor) {
 137         }
 138
 139         public virtual bool check (SemanticAnalyzer analyzer) {
 140                 return true;
 141         }
 142
 143         public virtual void replace_type (DataType old_type, DataType new_type) {
 144         }
 145
 146         public virtual void replace_expression (Expression old_node, Expression new_node) {
 147         }
 148
 149         /**
 150          * Returns the specified attribute.
 151          *
 152          * @param name attribute name
 153          * @return     attribute
 154          */
 155         public Attribute? get_attribute (string name) {
 156                 // FIXME: use hash table
 157                 foreach (Attribute a in attributes) {
 158                         if (a.name == name) {
 159                                 return a;
 160                         }
 161                 }
 162
 163                 return null;
 164         }
 165
 166         /**
 167          * Returns a string that represents this code node.
 168          *
 169          * @return a string representation
 170          */
 171         public virtual string to_string () {
 172                 var str = new StringBuilder ();
 173
 174                 str.append ("/* ");
 175
 176                 if (source_reference != null) {
 177                         str.append ("@").append (source_reference.to_string ());
 178                 }
 179
 180                 return str.append (" */").str;
 181         }
 182
 183         public virtual void get_defined_variables (Collection<LocalVariable> collection) {
 184         }
 185
 186         public virtual void get_used_variables (Collection<LocalVariable> collection) {
 187         }
 188
 189         public string get_temp_name () {
 190                 return "." + (++last_temp_nr).to_string ();
 191         }
 192
 193         public weak string get_type_name () {
 194                 return Type.from_instance (this).name ();
 195         }
 196 }