vala/valaexpression.vala

   1 /* valaexpression.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
  25 /**
  26  * Base class for all code nodes that might be used as an expression.
  27  */
  28 public abstract class Vala.Expression : CodeNode {
  29         /**
  30          * The static type of the value of this expression.
  31          *
  32          * The semantic analyzer computes this value.
  33          */
  34         public DataType value_type { get; set; }
  35
  36         public DataType? formal_value_type { get; set; }
  37
  38         /*
  39          * The static type this expression is expected to have.
  40          *
  41          * The semantic analyzer computes this value, lambda expressions use it.
  42          */
  43         public DataType target_type { get; set; }
  44
  45         public DataType? formal_target_type { get; set; }
  46
  47         /**
  48          * The symbol this expression refers to.
  49          */
  50         public weak Symbol symbol_reference { get; set; }
  51
  52         /**
  53          * Specifies that this expression is used as lvalue, i.e. the
  54          * left hand side of an assignment.
  55          */
  56         public bool lvalue { get; set; }
  57
  58         /**
  59          * Contains all temporary variables this expression requires for
  60          * execution.
  61          *
  62          * The code generator sets and uses them for memory management.
  63          */
  64         public ArrayList<LocalVariable> temp_vars = new ArrayList<LocalVariable> ();
  65
  66         private List<CCodeExpression> array_sizes = new ArrayList<CCodeExpression> ();
  67
  68         public CCodeExpression? delegate_target { get; set; }
  69         public CCodeExpression? delegate_target_destroy_notify { get; set; }
  70
  71         /**
  72          * Returns whether this expression is constant, i.e. whether this
  73          * expression only consists of literals and other constants.
  74          */
  75         public virtual bool is_constant () {
  76                 return false;
  77         }
  78
  79         /**
  80          * Returns whether this expression is pure, i.e. whether this expression
  81          * is free of side-effects.
  82          */
  83         public abstract bool is_pure ();
  84
  85         /**
  86          * Returns whether this expression is guaranteed to be non-null.
  87          */
  88         public virtual bool is_non_null () {
  89                 return false;
  90         }
  91
  92         /**
  93          * Add an array size C code expression.
  94          */
  95         public void append_array_size (CCodeExpression size) {
  96                 array_sizes.add (size);
  97         }
  98
  99         /**
 100          * Get the C code expression for array sizes for all dimensions
 101          * ascending from left to right.
 102          */
 103         public List<CCodeExpression> get_array_sizes () {
 104                 return new ReadOnlyList<CCodeExpression> (array_sizes);
 105         }
 106
 107         public Statement? parent_statement {
 108                 get {
 109                         var expr = parent_node as Expression;
 110                         var stmt = parent_node as Statement;
 111                         var local = parent_node as LocalVariable;
 112                         if (stmt != null) {
 113                                 return (Statement) parent_node;
 114                         } else if (expr != null) {
 115                                 return expr.parent_statement;
 116                         } else if (local != null) {
 117                                 return (Statement) local.parent_node;
 118                         } else {
 119                                 return null;
 120                         }
 121                 }
 122         }
 123
 124         public void insert_statement (Block block, Statement stmt) {
 125                 block.insert_before (parent_statement, stmt);
 126         }
 127 }