abstractastvisitor.cs

c#源代码

using System;
using System.Collections;
using ICSharpCode.SharpRefactory.Parser.AST;

namespace ICSharpCode.SharpRefactory.Parser
{
	public abstract class AbstractASTVisitor : IASTVisitor
	{
		protected Stack blockStack = new Stack();
		
		public BlockStatement CurrentBlock {
			get {
				if (blockStack.Count == 0) {
					return null;
				}
				return (BlockStatement)blockStack.Peek();
			}
		}
		
#region ICSharpCode.SharpRefactory.Parser.IASTVisitor interface implementation
		public virtual object Visit(INode node, object data)
		{
			Console.WriteLine("Warning: INode visited");
			Console.WriteLine("Visitor was: " + this.GetType());
			Console.WriteLine("Node was : " + node.GetType());
			return node.AcceptChildren(this, data);
		}
		
		public virtual object Visit(CompilationUnit compilationUnit, object data)
		{
			if (compilationUnit == null) {
				return data;
			}
			return compilationUnit.AcceptChildren(this, data);
		}
		
#region Global Scope
		public virtual object Visit(UsingDeclaration usingDeclaration, object data)
		{
			return data;
		}
		
		public virtual object Visit(UsingAliasDeclaration usingAliasDeclaration, object data)
		{
			return data;
		}
		
		public virtual object Visit(NamespaceDeclaration namespaceDeclaration, object data)
		{
			return namespaceDeclaration.AcceptChildren(this, data);
		}
		
		public virtual object Visit(AttributeSection attributeSection, object data)
		{
			return data;
		}
		
		public virtual object Visit(TypeDeclaration typeDeclaration, object data)
		{
			foreach (AttributeSection section in typeDeclaration.Attributes) {
				section.AcceptVisitor(this, data);
			}
			return typeDeclaration.AcceptChildren(this, data);
		}
		
		public virtual object Visit(DelegateDeclaration delegateDeclaration, object data)
		{
			foreach (AttributeSection section in delegateDeclaration.Attributes) {
				section.AcceptVisitor(this, data);
			}
			foreach (ParameterDeclarationExpression p in delegateDeclaration.Parameters) {
				p.AcceptVisitor(this, data);
			}
			return data;
		}
#endregion

#region Type level
		public virtual object Visit(VariableDeclaration variableDeclaration, object data)
		{
			if (variableDeclaration.Initializer != null) {
				return variableDeclaration.Initializer.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(FieldDeclaration fieldDeclaration, object data)
		{
			foreach (AttributeSection section in fieldDeclaration.Attributes) {
				section.AcceptVisitor(this, data);
			}
			foreach (VariableDeclaration var in fieldDeclaration.Fields) {
				var.AcceptVisitor(this, fieldDeclaration);
			}
			return data;
		}
		
		public virtual object Visit(PropertyDeclaration propertyDeclaration, object data)
		{
			foreach (AttributeSection section in propertyDeclaration.Attributes) {
				section.AcceptVisitor(this, data);
			}
			if (propertyDeclaration.HasGetRegion) {
				propertyDeclaration.GetRegion.AcceptVisitor(this, data);
			}
			if (propertyDeclaration.HasSetRegion) {
				propertyDeclaration.SetRegion.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(PropertyGetRegion propertyGetRegion, object data)
		{
			foreach (AttributeSection section in propertyGetRegion.Attributes) {
				section.AcceptVisitor(this, data);
			}
			blockStack.Push(propertyGetRegion.Block);
			object ret = data;
			if (propertyGetRegion.Block != null) {
				ret = propertyGetRegion.Block.AcceptChildren(this, data);
			}
			blockStack.Pop();
			return ret;
		}
		
		public virtual object Visit(PropertySetRegion propertySetRegion, object data)
		{
			foreach (AttributeSection section in propertySetRegion.Attributes) {
				section.AcceptVisitor(this, data);
			}
			blockStack.Push(propertySetRegion.Block);
			object ret = data;
			if (propertySetRegion.Block != null) {
				ret = propertySetRegion.Block.AcceptChildren(this, data);
			}
			blockStack.Pop();
			return ret;
		}
		
		public virtual object Visit(EventDeclaration eventDeclaration, object data)
		{
			foreach (AttributeSection section in eventDeclaration.Attributes) {
				section.AcceptVisitor(this, data);
			}
			if (eventDeclaration.HasAddRegion) {
				eventDeclaration.AddRegion.AcceptVisitor(this, data);
			}
			if (eventDeclaration.HasRemoveRegion) {
				eventDeclaration.RemoveRegion.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(EventAddRegion eventAddRegion, object data)
		{
			foreach (AttributeSection section in eventAddRegion.Attributes) {
				section.AcceptVisitor(this, data);
			}
			blockStack.Push(eventAddRegion.Block);
			object ret = data;
			if (eventAddRegion.Block != null) {
				ret = eventAddRegion.Block.AcceptChildren(this, data);
			}
			blockStack.Pop();
			return ret;
		}
		
		public virtual object Visit(EventRemoveRegion eventRemoveRegion, object data)
		{
			foreach (AttributeSection section in eventRemoveRegion.Attributes) {
				section.AcceptVisitor(this, data);
			}
			blockStack.Push(eventRemoveRegion.Block);
			object ret = data;
			if (eventRemoveRegion.Block != null) {
				eventRemoveRegion.Block.AcceptChildren(this, data);
			}
			blockStack.Pop();
			return ret;
		}
		
		public virtual object Visit(ParameterDeclarationExpression parameterDeclarationExpression, object data)
		{
			foreach (AttributeSection section in parameterDeclarationExpression.Attributes) {
				section.AcceptVisitor(this, data);
			}
			return parameterDeclarationExpression.AcceptChildren(this, data);
		}
		
		public virtual object Visit(IndexerDeclaration indexerDeclaration, object data)
		{
			foreach (AttributeSection section in indexerDeclaration.Attributes) {
				section.AcceptVisitor(this, data);
			}
			foreach (ParameterDeclarationExpression p in indexerDeclaration.Parameters) {
				p.AcceptVisitor(this, data);
			}
			if (indexerDeclaration.HasGetRegion) {
				indexerDeclaration.GetRegion.AcceptVisitor(this, data);
			}
			if (indexerDeclaration.HasSetRegion) {
				indexerDeclaration.SetRegion.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(MethodDeclaration methodDeclaration, object data)
		{
			foreach (AttributeSection section in methodDeclaration.Attributes) {
				section.AcceptVisitor(this, data);
			}
			blockStack.Push(methodDeclaration.Body);
			foreach (ParameterDeclarationExpression p in methodDeclaration.Parameters) {
				p.AcceptVisitor(this, data);
			}
			object ret = data;
			if (methodDeclaration.Body != null) {
				methodDeclaration.Body.AcceptChildren(this, data);
			}
			blockStack.Pop();
			return ret;
		}
		
		public virtual object Visit(ConstructorDeclaration constructorDeclaration, object data)
		{
			foreach (AttributeSection section in constructorDeclaration.Attributes) {
				section.AcceptVisitor(this, data);
			}
			blockStack.Push(constructorDeclaration.Body);
			foreach (ParameterDeclarationExpression p in constructorDeclaration.Parameters) {
				p.AcceptVisitor(this, data);
			}
			object ret = data;
			if (constructorDeclaration.Body != null) {
				ret = constructorDeclaration.Body.AcceptChildren(this, data);
			}
			blockStack.Pop();
			return ret;
		}
		public virtual object Visit(DestructorDeclaration destructorDeclaration, object data)
		{
			foreach (AttributeSection section in destructorDeclaration.Attributes) {
				section.AcceptVisitor(this, data);
			}
			blockStack.Push(destructorDeclaration.Body);
			object ret = data;
			if (destructorDeclaration.Body != null) {
				destructorDeclaration.Body.AcceptChildren(this, data);
			}
			blockStack.Pop();
			return ret;
		}
		
		public virtual object Visit(OperatorDeclaration operatorDeclaration, object data)
		{
			foreach (AttributeSection section in operatorDeclaration.Attributes) {
				section.AcceptVisitor(this, data);
			}
			blockStack.Push(operatorDeclaration.Body);
			object ret = data;
			if (operatorDeclaration.Body != null) {
				ret = operatorDeclaration.Body.AcceptChildren(this, data);
			}
			blockStack.Pop();
			return ret;
		}
#endregion
		
#region Statements
		public virtual object Visit(BlockStatement blockStatement, object data)
		{
			if (blockStatement == null) {
				return null;
			}
			blockStack.Push(blockStatement);
			object ret = blockStatement.AcceptChildren(this, data);
			blockStack.Pop();
			return ret;
		}
		
		public virtual object Visit(LocalVariableDeclaration localVariableDeclaration, object data)
		{
			foreach (VariableDeclaration decl in localVariableDeclaration.Variables) {
				decl.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(EmptyStatement emptyStatement, object data)
		{
			return data;
		}
		
		public virtual object Visit(IfStatement ifStatement, object data)
		{
			object ret = data;
			if (ifStatement.Condition != null) {
				ret = ifStatement.Condition.AcceptVisitor(this, data);
			}
			if (ifStatement.EmbeddedStatement != null) {
				ret = ifStatement.EmbeddedStatement.AcceptVisitor(this, data);
			}
			return ret;
		}
		public virtual object Visit(IfElseStatement ifElseStatement, object data)
		{
			object ret = data;
			if (ifElseStatement.Condition != null) {
				ret = ifElseStatement.Condition.AcceptVisitor(this, data);
			}
			if (ifElseStatement.EmbeddedStatement != null) {
				ret = ifElseStatement.EmbeddedStatement.AcceptVisitor(this, data);
			}
			if (ifElseStatement.EmbeddedElseStatement != null) {
				ret = ifElseStatement.EmbeddedElseStatement.AcceptVisitor(this, data);
			}
			return ret;
		}
		
		public virtual object Visit(WhileStatement whileStatement, object data)
		{
			object ret = data;
			if (whileStatement.Condition != null) {
				ret = whileStatement.Condition.AcceptVisitor(this, data);
			}
			if (whileStatement.EmbeddedStatement == null) {
				return ret;
			}
			return whileStatement.EmbeddedStatement.AcceptVisitor(this, data);
		}
		public virtual object Visit(DoWhileStatement doWhileStatement, object data)