Experiments/Attic/Rook/ASTViewer/TreeWalker.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 ASTViewer
  16 {
  17         using System;
  18         using System.Collections;
  19
  20         using System.Windows.Forms;
  21
  22         using Castle.Rook.Compiler.AST;
  23         using Castle.Rook.Compiler.Visitors;
  24
  25
  26         public class TreeWalker : DepthFirstVisitor
  27         {
  28                 private TreeNodeCollection nodes;
  29                 private Stack nodeStack = new Stack();
  30
  31                 public TreeWalker(CompilationUnit unit, TreeNodeCollection nodes)
  32                 {
  33                         this.nodes = nodes;
  34
  35                         VisitNode(unit);
  36                 }
  37
  38                 public TreeNode CurrentNode
  39                 {
  40                         get { return nodeStack.Peek() as TreeNode; }
  41                 }
  42
  43                 public override void VisitCompilationUnit(CompilationUnit compilationUnit)
  44                 {
  45                         nodeStack.Push( nodes.Add("CompilationUnit") );
  46                         CurrentNode.Tag = compilationUnit;
  47
  48                         base.VisitCompilationUnit(compilationUnit);
  49
  50                         nodeStack.Pop();
  51                 }
  52
  53                 public override bool VisitSourceUnit(SourceUnit unit)
  54                 {
  55                         nodeStack.Push( CurrentNode.Nodes.Add("SourceUnit") );
  56                         CurrentNode.Tag = unit;
  57
  58                         base.VisitSourceUnit(unit);
  59
  60                         nodeStack.Pop();
  61
  62                         return true;
  63                 }
  64
  65                 public override bool VisitNamespace(NamespaceDescriptor ns)
  66                 {
  67                         nodeStack.Push( CurrentNode.Nodes.Add("Namespace " + ns.Name) );
  68                         CurrentNode.Tag = ns;
  69
  70                         CurrentNode.EnsureVisible();
  71
  72                         base.VisitNamespace(ns);
  73
  74                         nodeStack.Pop();
  75
  76                         return true;
  77                 }
  78
  79                 public override bool VisitTypeDefinitionStatement(TypeDefinitionStatement typeDef)
  80                 {
  81                         nodeStack.Push( CurrentNode.Nodes.Add("Type " + typeDef.Name ) );
  82                         CurrentNode.Tag = typeDef;
  83
  84                         CurrentNode.EnsureVisible();
  85
  86                         base.VisitTypeDefinitionStatement(typeDef);
  87
  88                         nodeStack.Pop();
  89
  90                         return true;
  91                 }
  92
  93                 public override bool VisitMethodDefinitionStatement(MethodDefinitionStatement methodDef)
  94                 {
  95                         nodeStack.Push( CurrentNode.Nodes.Add("Method " + methodDef.Name + "[ret " + methodDef.ReturnType + "]" ));
  96                         CurrentNode.Tag = methodDef;
  97
  98                         CurrentNode.EnsureVisible();
  99
 100                         base.VisitMethodDefinitionStatement(methodDef);
 101
 102                         nodeStack.Pop();
 103
 104                         return true;
 105                 }
 106
 107                 public override void VisitConstructorDefinitionStatement(ConstructorDefinitionStatement statement)
 108                 {
 109                         nodeStack.Push( CurrentNode.Nodes.Add("Constructor " + statement.Name ));
 110                         CurrentNode.Tag = statement;
 111
 112                         CurrentNode.EnsureVisible();
 113
 114                         base.VisitConstructorDefinitionStatement(statement);
 115
 116                         nodeStack.Pop();
 117                 }
 118
 119                 public override void VisitTypeReference(TypeReference reference)
 120                 {
 121                         nodeStack.Push( CurrentNode.Nodes.Add("TypeReference " + reference.TypeName + " Resolved to [" + reference.ResolvedType + "]"));
 122                         CurrentNode.Tag = reference;
 123
 124                         CurrentNode.EnsureVisible();
 125
 126                         base.VisitTypeReference(reference);
 127
 128                         nodeStack.Pop();
 129                 }
 130
 131                 public override bool VisitIdentifier(Identifier identifier)
 132                 {
 133                         nodeStack.Push( CurrentNode.Nodes.Add("Identifier " + identifier.Name + " - " + identifier.TypeReference ));
 134                         CurrentNode.Tag = identifier;
 135
 136                         CurrentNode.EnsureVisible();
 137
 138                         base.VisitIdentifier(identifier);
 139
 140                         nodeStack.Pop();
 141
 142                         return true;
 143                 }
 144
 145                 public override void VisitParameterVarIdentifier(ParameterVarIdentifier identifier)
 146                 {
 147                         nodeStack.Push( CurrentNode.Nodes.Add("ParameterVarIdentifier " + identifier.Name + " - " + identifier.TypeReference ));
 148                         CurrentNode.Tag = identifier;
 149
 150                         base.VisitParameterVarIdentifier(identifier);
 151
 152                         nodeStack.Pop();
 153                 }
 154
 155                 public override void VisitOpaqueIdentifier(OpaqueIdentifier identifier)
 156                 {
 157                         nodeStack.Push( CurrentNode.Nodes.Add("OpaqueIdentifier " + identifier.Name + " - " + identifier.TypeReference ));
 158                         CurrentNode.Tag = identifier;
 159
 160                         base.VisitOpaqueIdentifier(identifier);
 161
 162                         nodeStack.Pop();
 163                 }
 164
 165                 public override void VisitExpressionStatement(ExpressionStatement statement)
 166                 {
 167                         nodeStack.Push( CurrentNode.Nodes.Add("ExpressionStatement "));
 168                         CurrentNode.Tag = statement;
 169
 170                         base.VisitExpressionStatement(statement);
 171
 172                         nodeStack.Pop();
 173                 }
 174
 175                 public override void VisitMethodInvocationExpression(MethodInvocationExpression invocationExpression)
 176                 {
 177                         nodeStack.Push( CurrentNode.Nodes.Add("MethodInvocationExpression " + invocationExpression.Designator));
 178                         CurrentNode.Tag = invocationExpression;
 179
 180                         base.VisitMethodInvocationExpression(invocationExpression);
 181
 182                         nodeStack.Pop();
 183                 }
 184
 185                 public override void VisitVariableReferenceExpression(VariableReferenceExpression expression)
 186                 {
 187                         nodeStack.Push( CurrentNode.Nodes.Add("VariableReferenceExpression - " + expression.Identifier.Name));
 188                         CurrentNode.Tag = expression;
 189
 190                         base.VisitVariableReferenceExpression(expression);
 191
 192                         nodeStack.Pop();
 193                 }
 194
 195                 public override void VisitConstExpression(ConstExpression expression)
 196                 {
 197                         nodeStack.Push( CurrentNode.Nodes.Add("ConstExpression " + expression.Value + " " + expression.ValueType ));
 198                         CurrentNode.Tag = expression;
 199
 200                         base.VisitConstExpression(expression);
 201
 202                         nodeStack.Pop();
 203                 }
 204
 205                 public override void VisitBlockExpression(BlockExpression expression)
 206                 {
 207                         nodeStack.Push( CurrentNode.Nodes.Add("BlockExpression [" + expression.Parameters.Count + " params ] " ));
 208                         CurrentNode.Tag = expression;
 209
 210                         base.VisitBlockExpression(expression);
 211
 212                         nodeStack.Pop();
 213                 }
 214
 215                 public override void VisitMemberAccessExpression(MemberAccessExpression accessExpression)
 216                 {
 217                         nodeStack.Push( CurrentNode.Nodes.Add("MemberAccessExpression [" + accessExpression.Name + " ] " ));
 218                         CurrentNode.Tag = accessExpression;
 219
 220                         base.VisitMemberAccessExpression(accessExpression);
 221
 222                         nodeStack.Pop();
 223                 }
 224
 225
 226         }
 227 }