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

   1 #region license
   2 // Copyright (c) 2004, 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 namespace Boo.Lang.Compiler.Steps
  30 {
  31         using Boo.Lang.Compiler.Ast;
  32         using Boo.Lang.Compiler;
  33
  34         public class NormalizeStatementModifiers : AbstractTransformerCompilerStep
  35         {
  36                 override public void Run()
  37                 {
  38                         Visit(CompileUnit.Modules);
  39                 }
  40
  41                 override public void LeaveUnpackStatement(UnpackStatement node)
  42                 {
  43                         LeaveStatement(node);
  44                 }
  45
  46                 override public void LeaveExpressionStatement(ExpressionStatement node)
  47                 {
  48                         LeaveStatement(node);
  49                 }
  50
  51                 override public void LeaveRaiseStatement(RaiseStatement node)
  52                 {
  53                         LeaveStatement(node);
  54                 }
  55
  56                 override public void LeaveReturnStatement(ReturnStatement node)
  57                 {
  58                         LeaveStatement(node);
  59                 }
  60
  61                 override public void LeaveBreakStatement(BreakStatement node)
  62                 {
  63                         LeaveStatement(node);
  64                 }
  65
  66                 override public void LeaveContinueStatement(ContinueStatement node)
  67                 {
  68                         LeaveStatement(node);
  69                 }
  70
  71                 override public void LeaveGotoStatement(GotoStatement node)
  72                 {
  73                         LeaveStatement(node);
  74                 }
  75
  76                 override public void LeaveYieldStatement(YieldStatement node)
  77                 {
  78                         LeaveStatement(node);
  79                 }
  80
  81                 override public void LeaveLabelStatement(LabelStatement node)
  82                 {
  83                         if (null != node.Modifier)
  84                         {
  85                                 Warnings.Add(
  86                                         CompilerWarningFactory.ModifiersInLabelsHaveNoEffect(node.Modifier));
  87                         }
  88                 }
  89
  90                 override public void LeaveMacroStatement(MacroStatement node)
  91                 {
  92                         LeaveStatement(node);
  93                 }
  94
  95                 public static Statement CreateModifiedStatement(StatementModifier modifier, Statement node)
  96                 {
  97                         Block block;
  98                         Statement stmt = MapStatementModifier(modifier, out block);
  99                         block.Add(node);
 100                         return stmt;
 101                 }
 102
 103                 public static Statement MapStatementModifier(StatementModifier modifier, out Block block)
 104                 {
 105                         switch (modifier.Type)
 106                         {
 107                                 case StatementModifierType.If:
 108                                 {
 109                                         IfStatement stmt = new IfStatement(modifier.LexicalInfo);
 110                                         stmt.Condition = modifier.Condition;
 111                                         stmt.TrueBlock = new Block();
 112                                         block = stmt.TrueBlock;
 113                                         return stmt;
 114                                 }
 115
 116                                 case StatementModifierType.Unless:
 117                                 {
 118                                         UnlessStatement stmt = new UnlessStatement(modifier.LexicalInfo);
 119                                         stmt.Condition = modifier.Condition;
 120                                         block = stmt.Block;
 121                                         return stmt;
 122                                 }
 123
 124                                 case StatementModifierType.While:
 125                                 {
 126                                         WhileStatement stmt = new WhileStatement(modifier.LexicalInfo);
 127                                         stmt.Condition = modifier.Condition;
 128                                         block = stmt.Block;
 129                                         return stmt;
 130                                 }
 131                         }
 132                         throw CompilerErrorFactory.NotImplemented(modifier, string.Format("modifier {0} supported", modifier.Type));
 133                 }
 134
 135                 public void LeaveStatement(Statement node)
 136                 {
 137                         StatementModifier modifier = node.Modifier;
 138                         if (null != modifier)
 139                         {
 140                                 node.Modifier = null;
 141                                 ReplaceCurrentNode(CreateModifiedStatement(modifier, node));
 142                         }
 143                 }
 144         }
 145 }