src/Boo.Lang.Compiler/Steps/BranchChecking.cs

   1 #region license
   2 // Copyright (c) 2003, 2004, 2005 Rodrigo B. de Oliveira (rbo@acm.org)
   3 // All rights reserved.
   4 //
   5 // Redistribution and use in source and binary forms, with or without modification,
   6 // are permitted provided that the following conditions are met:
   7 //
   8 //     * Redistributions of source code must retain the above copyright notice,
   9 //     this list of conditions and the following disclaimer.
  10 //     * Redistributions in binary form must reproduce the above copyright notice,
  11 //     this list of conditions and the following disclaimer in the documentation
  12 //     and/or other materials provided with the distribution.
  13 //     * Neither the name of Rodrigo B. de Oliveira nor the names of its
  14 //     contributors may be used to endorse or promote products derived from this
  15 //     software without specific prior written permission.
  16 //
  17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  18 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19 // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
  21 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  23 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  24 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  25 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26 // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27 #endregion
  28
  29
  30 using System;
  31 using System.Collections;
  32 using System.Collections.Generic;
  33 using Boo.Lang.Compiler.Ast;
  34 using Boo.Lang.Compiler.TypeSystem;
  35
  36 namespace Boo.Lang.Compiler.Steps
  37 {
  38         class MethodBodyState
  39         {
  40                 private int _loopDepth;
  41
  42                 private int _protectedBlockDepth;
  43                 private int _exceptionHandlerDepth;
  44
  45                 private Stack<TryStatement> _tryBlocks = new Stack<TryStatement>();
  46
  47                 private List _labelReferences = new List();
  48
  49                 private Hashtable _labels = new Hashtable();
  50
  51                 public void Reset()
  52                 {
  53                         _loopDepth = 0;
  54                         _exceptionHandlerDepth = 0;
  55                         _tryBlocks.Clear();
  56                         _labelReferences.Clear();
  57                         _labels.Clear();
  58                 }
  59
  60                 public void AddLabelReference(ReferenceExpression node)
  61                 {
  62                         _labelReferences.Add(node);
  63                 }
  64
  65                 public List LabelReferences
  66                 {
  67                         get { return _labelReferences; }
  68                 }
  69
  70                 public void EnterTryBlock(TryStatement tryBlock)
  71                 {
  72                         _tryBlocks.Push(tryBlock);
  73                 }
  74
  75                 public void LeaveTryBlock()
  76                 {
  77                         _tryBlocks.Pop();
  78                 }
  79
  80                 public void EnterProtectedBlock()
  81                 {
  82                         ++_protectedBlockDepth;
  83                 }
  84
  85                 public void LeaveProtectedBlock()
  86                 {
  87                         --_protectedBlockDepth;
  88                 }
  89
  90                 public int TryBlockDepth {
  91                         get { return _tryBlocks.Count; }
  92                 }
  93
  94                 public IEnumerable<TryStatement> TryBlocks {
  95                         get { return _tryBlocks; }
  96                 }
  97
  98                 public int ProtectedBlockDepth {
  99                         get { return _protectedBlockDepth; }
 100                 }
 101
 102                 public void EnterExceptionHandler()
 103                 {
 104                         ++_exceptionHandlerDepth;
 105                 }
 106
 107                 public bool InExceptionHandler
 108                 {
 109                         get { return _exceptionHandlerDepth > 0; }
 110                 }
 111
 112                 public void LeaveExceptionHandler()
 113                 {
 114                         --_exceptionHandlerDepth;
 115                 }
 116
 117                 public void EnterLoop()
 118                 {
 119                         ++_loopDepth;
 120                 }
 121
 122                 public bool InLoop
 123                 {
 124                         get { return _loopDepth > 0; }
 125                 }
 126
 127                 public void LeaveLoop()
 128                 {
 129                         --_loopDepth;
 130                 }
 131
 132                 public InternalLabel ResolveLabel(string name)
 133                 {
 134                         return (InternalLabel)_labels[name];
 135                 }
 136
 137                 public void AddLabel(InternalLabel label)
 138                 {
 139                         _labels.Add(label.Name, label);
 140                 }
 141         }
 142
 143         public class BranchChecking : AbstractVisitorCompilerStep
 144         {
 145                 private InternalMethod _currentMethod;
 146
 147                 private MethodBodyState _state = new MethodBodyState();
 148
 149                 public override void Run()
 150                 {
 151                         Visit(CompileUnit);
 152                 }
 153
 154                 override public void OnTryStatement(TryStatement node)
 155                 {
 156                         _state.EnterTryBlock(node);
 157                         _state.EnterProtectedBlock();
 158                         Visit(node.ProtectedBlock);
 159                         _state.LeaveProtectedBlock();
 160
 161                         Visit(node.ExceptionHandlers);
 162
 163                         Visit(node.FailureBlock);
 164
 165                         Visit(node.EnsureBlock);
 166                         _state.LeaveTryBlock();
 167                 }
 168
 169                 override public void OnExceptionHandler(ExceptionHandler node)
 170                 {
 171                         _state.EnterExceptionHandler();
 172                         Visit(node.Block);
 173                         _state.LeaveExceptionHandler();
 174                 }
 175
 176                 override public void LeaveRaiseStatement(RaiseStatement node)
 177                 {
 178                         if (node.Exception != null) return;
 179                         if (_state.InExceptionHandler) return;
 180                         Error(CompilerErrorFactory.ReRaiseOutsideExceptionHandler(node));
 181                 }
 182
 183                 public override void OnConstructor(Constructor node)
 184                 {
 185                         OnMethod(node);
 186                 }
 187
 188                 public override void OnDestructor(Destructor node)
 189                 {
 190                         OnMethod(node);
 191                 }
 192
 193                 override public void OnMethod(Method node)
 194                 {
 195                         _currentMethod = (InternalMethod) node.Entity;
 196                         _state.Reset();
 197                         Visit(node.Body);
 198                         ResolveLabelReferences();
 199                 }
 200
 201                 void ResolveLabelReferences()
 202                 {
 203                         foreach (ReferenceExpression reference in _state.LabelReferences)
 204                         {
 205                                 InternalLabel label = _state.ResolveLabel(reference.Name);
 206                                 if (null == label)
 207                                 {
 208                                         Error(reference, CompilerErrorFactory.NoSuchLabel(reference, reference.Name));
 209                                 }
 210                                 else
 211                                 {
 212                                         reference.Entity = label;
 213                                 }
 214                         }
 215                 }
 216
 217                 override public void OnWhileStatement(WhileStatement node)
 218                 {
 219                         VisitLoop(node.Block);
 220                 }
 221
 222                 private void VisitLoop(Block block)
 223                 {
 224                         _state.EnterLoop();
 225                         Visit(block);
 226                         _state.LeaveLoop();
 227                 }
 228
 229                 override public void OnForStatement(ForStatement node)
 230                 {
 231                         VisitLoop(node.Block);
 232                 }
 233
 234                 override public void OnLabelStatement(LabelStatement node)
 235                 {
 236                         AstAnnotations.SetTryBlockDepth(node, _state.TryBlockDepth);
 237
 238                         if (null == _state.ResolveLabel(node.Name))
 239                         {
 240                                 _state.AddLabel(new InternalLabel(node));
 241                         }
 242                         else
 243                         {
 244                                 Error(
 245                                         CompilerErrorFactory.LabelAlreadyDefined(node,
 246                                                                                         _currentMethod.FullName,
 247                                                                                         node.Name));
 248                         }
 249                 }
 250
 251                 override public void OnYieldStatement(YieldStatement node)
 252                 {
 253                         if (_state.TryBlockDepth == _state.ProtectedBlockDepth) {
 254                                 // we are currently only in the protected blocks, not in any "except" or "ensure" blocks.
 255                                 foreach (TryStatement tryBlock in _state.TryBlocks) {
 256                                         // only allow yield in the try part of try-ensure blocks, fail if it is a try-except block
 257                                         if (tryBlock.FailureBlock != null || tryBlock.ExceptionHandlers.Count > 0) {
 258                                                 Error(CompilerErrorFactory.YieldInsideTryExceptOrEnsureBlock(node));
 259                                                 break;
 260                                         }
 261                                 }
 262                         } else {
 263                                 Error(CompilerErrorFactory.YieldInsideTryExceptOrEnsureBlock(node));
 264                         }
 265                 }
 266
 267                 public override void OnMethodInvocationExpression(MethodInvocationExpression node)
 268                 {
 269                         if (BuiltinFunction.Switch != node.Target.Entity) return;
 270
 271                         for (int i = 1; i < node.Arguments.Count; ++i)
 272                         {
 273                                 ReferenceExpression label = (ReferenceExpression)node.Arguments[i];
 274                                 _state.AddLabelReference(label);
 275                         }
 276                 }
 277
 278                 override public void OnGotoStatement(GotoStatement node)
 279                 {
 280                         AstAnnotations.SetTryBlockDepth(node, _state.TryBlockDepth);
 281
 282                         _state.AddLabelReference(node.Label);
 283                 }
 284
 285                 override public void OnBreakStatement(BreakStatement node)
 286                 {
 287                         CheckInLoop(node);
 288                 }
 289
 290                 override public void OnContinueStatement(ContinueStatement node)
 291                 {
 292                         CheckInLoop(node);
 293                 }
 294
 295                 override public void OnBlockExpression(BlockExpression node)
 296                 {
 297                         // nothing to do
 298                 }
 299
 300                 private void CheckInLoop(Statement node)
 301                 {
 302                         if (!_state.InLoop)
 303                         {
 304                                 Error(CompilerErrorFactory.NoEnclosingLoop(node));
 305                         }
 306                 }
 307         }
 308 }