Experiments/Attic/Rook/Castle.Rook.Compiler/Visitors/AbstractVisitor.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.Rook.Compiler.Visitors
  16 {
  17         using System;
  18         using System.Collections;
  19
  20         using Castle.Rook.Compiler.AST;
  21
  22
  23         public abstract class AbstractVisitor : IASTVisitor
  24         {
  25                 public AbstractVisitor()
  26                 {
  27                 }
  28
  29                 public virtual bool VisitNode(IVisitableNode node)
  30                 {
  31                         if (node == null) return true;
  32
  33                         bool res = node.Accept(this);
  34
  35                         return res;
  36                 }
  37
  38                 public virtual bool VisitNodes(IList nodes)
  39                 {
  40                         foreach(IVisitableNode node in nodes)
  41                         {
  42                                 VisitNode( node );
  43                         }
  44
  45                         return true;
  46                 }
  47
  48                 public virtual void VisitCompilationUnit(CompilationUnit compilationUnit)
  49                 {
  50                         VisitNode(compilationUnit.EntryPointSourceUnit);
  51                         VisitNodes(compilationUnit.SourceUnits);
  52                 }
  53
  54                 public virtual bool VisitSourceUnit(SourceUnit unit)
  55                 {
  56                         VisitNodes(unit.Namespaces);
  57                         VisitNodes(unit.Statements);
  58
  59                         return true;
  60                 }
  61
  62                 public virtual bool VisitNamespace(NamespaceDescriptor ns)
  63                 {
  64                         if (VisitEnter(ns))
  65                         {
  66                                 VisitNodes(ns.TypeDefinitions);
  67
  68                                 return VisitLeave(ns);
  69                         }
  70
  71                         return true;
  72                 }
  73
  74                 public virtual bool VisitEnter(NamespaceDescriptor ns)
  75                 {
  76                         return true;
  77                 }
  78
  79                 public virtual bool VisitLeave(NamespaceDescriptor ns)
  80                 {
  81                         return true;
  82                 }
  83
  84                 public virtual bool VisitTypeDefinitionStatement(TypeDefinitionStatement typeDef)
  85                 {
  86                         if (VisitEnter(typeDef))
  87                         {
  88                                 VisitNodes(typeDef.Statements);
  89
  90                                 return VisitLeave(typeDef);
  91                         }
  92
  93                         return false;
  94                 }
  95
  96                 public virtual bool VisitEnter(TypeDefinitionStatement typeDef)
  97                 {
  98                         return true;
  99                 }
 100
 101                 public virtual bool VisitLeave(TypeDefinitionStatement typeDef)
 102                 {
 103                         return true;
 104                 }
 105
 106                 public virtual bool VisitMethodDefinitionStatement(MethodDefinitionStatement methodDef)
 107                 {
 108                         if (VisitEnter(methodDef))
 109                         {
 110                                 VisitNodes(methodDef.Arguments);
 111                                 VisitNodes(methodDef.Statements);
 112
 113                                 return VisitLeave(methodDef);
 114                         }
 115
 116                         return false;
 117                 }
 118
 119                 public virtual void VisitConstructorDefinitionStatement(ConstructorDefinitionStatement statement)
 120                 {
 121                         if (VisitEnter(statement))
 122                         {
 123                                 VisitNodes(statement.Arguments);
 124                                 VisitNodes(statement.Statements);
 125
 126                                 VisitLeave(statement);
 127                         }
 128                 }
 129
 130                 public virtual bool VisitEnter(MethodDefinitionStatement methodDef)
 131                 {
 132                         return true;
 133                 }
 134
 135                 public virtual bool VisitLeave(MethodDefinitionStatement methodDef)
 136                 {
 137                         return true;
 138                 }
 139
 140                 //
 141                 // References
 142                 //
 143
 144                 public virtual void VisitTypeReference(TypeReference reference)
 145                 {
 146                 }
 147
 148                 public virtual bool VisitIdentifier(Identifier identifier)
 149                 {
 150                         VisitNode(identifier.TypeReference);
 151
 152                         return true;
 153                 }
 154
 155                 public virtual void VisitParameterVarIdentifier(ParameterVarIdentifier parameterIdentifier)
 156                 {
 157                         VisitNode(parameterIdentifier.TypeReference);
 158                         VisitNode(parameterIdentifier.InitExpression);
 159                 }
 160
 161                 public virtual void VisitOpaqueIdentifier(OpaqueIdentifier opaqueIdentifier)
 162                 {
 163                         VisitNode(opaqueIdentifier.TypeReference);
 164
 165                 }
 166
 167                 //
 168                 // Statements
 169                 //
 170
 171                 public virtual void VisitExpressionStatement(ExpressionStatement statement)
 172                 {
 173                         VisitNode(statement.InnerExpression);
 174                 }
 175
 176                 //
 177                 // Expressions
 178                 //
 179
 180                 public virtual void VisitMethodInvocationExpression(MethodInvocationExpression invocationExpression)
 181                 {
 182                         VisitNode(invocationExpression.Designator);
 183                         VisitNodes(invocationExpression.Arguments);
 184                         VisitCommonExpNodes(invocationExpression);
 185                 }
 186
 187                 public virtual void VisitVariableReferenceExpression(VariableReferenceExpression expression)
 188                 {
 189                         VisitNode(expression.Identifier);
 190                         VisitCommonExpNodes(expression);
 191                 }
 192
 193                 public virtual void VisitConstExpression(ConstExpression expression)
 194                 {
 195                         VisitCommonExpNodes(expression);
 196                 }
 197
 198                 public virtual void VisitBlockExpression(BlockExpression expression)
 199                 {
 200                         VisitNodes(expression.Parameters);
 201                         VisitNodes(expression.Statements);
 202                         VisitCommonExpNodes(expression);
 203                 }
 204
 205                 public virtual void VisitMemberAccessExpression(MemberAccessExpression accessExpression)
 206                 {
 207                         VisitNode(accessExpression.Inner);
 208                         VisitCommonExpNodes(accessExpression);
 209                 }
 210
 211                 //
 212                 // Helpers
 213                 //
 214
 215                 private void VisitCommonExpNodes(IExpression expression)
 216                 {
 217                         VisitNode(expression.PostfixCondition);
 218                         VisitNode(expression.Block);
 219                 }
 220         }
 221 }