vala/valainvocationexpression.vala

   1 /* valainvocationexpression.vala
   2  *
   3  * Copyright (C) 2006-2007  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 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 an invocation expression in the source code.
  27  */
  28 public class Vala.InvocationExpression : Expression {
  29         /**
  30          * The method to call.
  31          */
  32         public Expression! call {
  33                 get {
  34                         return _call;
  35                 }
  36                 set construct {
  37                         _call = value;
  38                         _call.parent_node = this;
  39                 }
  40         }
  41
  42         public Expression! _call;
  43
  44         private List<Expression> argument_list;
  45         private List<CCodeExpression> array_sizes;
  46
  47         /**
  48          * Creates a new invocation expression.
  49          *
  50          * @param call   method to call
  51          * @param source reference to source code
  52          * @return       newly created invocation expression
  53          */
  54         public InvocationExpression (Expression! _call, SourceReference source = null) {
  55                 call = _call;
  56                 source_reference = source;
  57         }
  58
  59         /**
  60          * Appends the specified expression to the list of arguments.
  61          *
  62          * @param arg an argument
  63          */
  64         public void add_argument (Expression! arg) {
  65                 argument_list.append (arg);
  66                 arg.parent_node = this;
  67         }
  68
  69         /**
  70          * Returns a copy of the argument list.
  71          *
  72          * @return argument list
  73          */
  74         public List<weak Expression> get_argument_list () {
  75                 return argument_list.copy ();
  76         }
  77
  78         /**
  79          * Add an array size C code expression.
  80          */
  81         public void append_array_size (CCodeExpression! size) {
  82                 array_sizes.append (size);
  83         }
  84
  85         /**
  86          * Get the C code expression for array sizes for all dimensions
  87          * ascending from left to right.
  88          */
  89         public List<weak CCodeExpression> get_array_sizes () {
  90                 return array_sizes.copy ();
  91         }
  92
  93         public override void accept (CodeVisitor! visitor) {
  94                 call.accept (visitor);
  95
  96                 visitor.visit_begin_invocation_expression (this);
  97
  98                 // iterate over list copy as list may change in loop body
  99                 foreach (Expression expr in argument_list.copy ()) {
 100                         expr.accept (visitor);
 101                 }
 102
 103                 visitor.visit_end_invocation_expression (this);
 104         }
 105
 106         public override void replace (CodeNode! old_node, CodeNode! new_node) {
 107                 if (call == old_node) {
 108                         call = (Expression) new_node;
 109                 }
 110
 111                 weak List<Expression> l = argument_list.find (old_node);
 112                 if (l != null) {
 113                         if (new_node.parent_node != null) {
 114                                 return;
 115                         }
 116
 117                         argument_list.insert_before (l, new_node);
 118                         argument_list.remove_link (l);
 119                         new_node.parent_node = this;
 120                 }
 121         }
 122 }