vala/valatrystatement.vala

   1 /* valatrystatement.vala
   2  *
   3  * Copyright (C) 2007-2008  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 try statement in the source code.
  27  */
  28 public class Vala.TryStatement : CodeNode, Statement {
  29         /**
  30          * Specifies the body of the try statement.
  31          */
  32         public Block body {
  33                 get { return _body; }
  34                 set {
  35                         _body = value;
  36                         _body.parent_node = this;
  37                 }
  38         }
  39
  40         /**
  41          * Specifies the body of the optional finally clause.
  42          */
  43         public Block? finally_body {
  44                 get { return _finally_body; }
  45                 set {
  46                         _finally_body = value;
  47                         if (_finally_body != null)
  48                                 _finally_body.parent_node = this;
  49                 }
  50         }
  51
  52         private Block _body;
  53         private Block _finally_body;
  54         private List<CatchClause> catch_clauses = new ArrayList<CatchClause> ();
  55
  56         /**
  57          * Creates a new try statement.
  58          *
  59          * @param body             body of the try statement
  60          * @param finally_body     body of the optional finally clause
  61          * @param source_reference reference to source code
  62          * @return                 newly created try statement
  63          */
  64         public TryStatement (Block body, Block? finally_body, SourceReference? source_reference = null) {
  65                 this.body = body;
  66                 this.finally_body = finally_body;
  67                 this.source_reference = source_reference;
  68         }
  69
  70         /**
  71          * Appends the specified clause to the list of catch clauses.
  72          *
  73          * @param clause a catch clause
  74          */
  75         public void add_catch_clause (CatchClause clause) {
  76                 clause.parent_node = this;
  77                 catch_clauses.add (clause);
  78         }
  79
  80         /**
  81          * Returns a copy of the list of catch clauses.
  82          *
  83          * @return list of catch clauses
  84          */
  85         public List<CatchClause> get_catch_clauses () {
  86                 return new ReadOnlyList<CatchClause> (catch_clauses);
  87         }
  88
  89         public override void accept (CodeVisitor visitor) {
  90                 visitor.visit_try_statement (this);
  91         }
  92
  93         public override void accept_children (CodeVisitor visitor) {
  94                 body.accept (visitor);
  95
  96                 foreach (CatchClause clause in catch_clauses) {
  97                         clause.accept (visitor);
  98                 }
  99
 100                 if (finally_body != null) {
 101                         finally_body.accept (visitor);
 102                 }
 103         }
 104
 105         public override bool check (SemanticAnalyzer analyzer) {
 106                 if (checked) {
 107                         return !error;
 108                 }
 109
 110                 checked = true;
 111
 112                 body.check (analyzer);
 113
 114                 var error_types = new ArrayList<DataType> ();
 115                 foreach (DataType body_error_type in body.get_error_types ()) {
 116                         error_types.add (body_error_type);
 117                 }
 118
 119                 var handled_error_types = new ArrayList<DataType> ();
 120                 foreach (CatchClause clause in catch_clauses) {
 121                         foreach (DataType body_error_type in error_types) {
 122                                 if (clause.error_type == null || body_error_type.compatible (clause.error_type)) {
 123                                         handled_error_types.add (body_error_type);
 124                                 }
 125                         }
 126                         foreach (DataType handled_error_type in handled_error_types) {
 127                                 error_types.remove (handled_error_type);
 128                         }
 129                         handled_error_types.clear ();
 130
 131                         clause.check (analyzer);
 132                         foreach (DataType body_error_type in clause.body.get_error_types ()) {
 133                                 error_types.add (body_error_type);
 134                         }
 135                 }
 136
 137                 if (finally_body != null) {
 138                         finally_body.check (analyzer);
 139                         foreach (DataType body_error_type in finally_body.get_error_types ()) {
 140                                 error_types.add (body_error_type);
 141                         }
 142                 }
 143
 144                 add_error_types (error_types);
 145
 146                 return !error;
 147         }
 148 }