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