abstractastvisitor.cs

c#源代码

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

namespace ICSharpCode.SharpRefactory.Parser.VB
{
	public abstract class AbstractASTVisitor : IASTVisitor
	{
		protected Stack blockStack = new Stack();
		
		public BlockStatement CurrentBlock {
			get {
				if (blockStack.Count == 0) {
					return null;
				}
				return (BlockStatement)blockStack.Peek();
			}
		}
		
		public virtual object Visit(INode node, object data)
		{
			Console.WriteLine("Warning, INode visited!");
			Console.WriteLine("Type is " + node.GetType());
			Console.WriteLine("Visitor is " + this.GetType());
			return node.AcceptChildren(this, data);
		}
		
		public virtual object Visit(CompilationUnit compilationUnit, object data)
		{
			if (compilationUnit == null) {
				return data;
			}
			return compilationUnit.AcceptChildren(this, data);
		}
		
		public virtual object Visit(NamespaceDeclaration namespaceDeclaration, object data)
		{
			return namespaceDeclaration.AcceptChildren(this, data);
		}
		
		public virtual object Visit(OptionExplicitDeclaration optionExplicitDeclaration, object data)
		{
			return data;
		}
		
		public virtual object Visit(OptionStrictDeclaration optionStrictDeclaration, object data)
		{
			return data;
		}
		
		public virtual object Visit(OptionCompareDeclaration optionCompareDeclaration, object data)
		{
			return data;
		}
		
		public virtual object Visit(ImportsStatement importsStatement, object data)
		{
			object ret = data;
			foreach (INode n in importsStatement.ImportClauses) {
				ret = n.AcceptVisitor(this, data);
			}
			return ret;
		}
		
		public virtual object Visit(ImportsAliasDeclaration importsAliasDeclaration, object data)
		{
			return data;
		}
		
		public virtual object Visit(ImportsDeclaration importsDeclaration, object data)
		{
			return data;
		}
		
		public virtual object Visit(AttributeSection attributeSection, object data)
		{
			object ret = data;
			foreach (ICSharpCode.SharpRefactory.Parser.AST.VB.Attribute a in attributeSection.Attributes) {
				ret = a.AcceptVisitor(this, data);
			}
			return ret;
		}
		
		public virtual object Visit(ICSharpCode.SharpRefactory.Parser.AST.VB.Attribute attribute, object data)
		{
			object ret = data;
			foreach (Expression e in attribute.PositionalArguments) {
				ret = e.AcceptVisitor(this, data);
			}
			foreach (NamedArgumentExpression n in attribute.NamedArguments) {
				ret = n.AcceptVisitor(this, data);
			}
			return ret;
		}
		
		public virtual object Visit(NamedArgumentExpression namedArgumentExpression, object data)
		{
			return namedArgumentExpression.Expression.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(TypeReference typeReference, object data)
		{
			return data;
		}
		
		public virtual object Visit(TypeDeclaration typeDeclaration, object data)
		{
			foreach (AttributeSection a in typeDeclaration.Attributes) {
				a.AcceptVisitor(this, data);
			}
			return typeDeclaration.AcceptChildren(this, data);
		}
		
		public virtual object Visit(DelegateDeclaration delegateDeclaration, object data)
		{
			foreach (AttributeSection a in delegateDeclaration.Attributes) {
				a.AcceptVisitor(this, data);
			}
			if (delegateDeclaration.Parameters != null) {
				foreach (ParameterDeclarationExpression p in delegateDeclaration.Parameters) {
					p.AcceptVisitor(this, data);
				}
			}
			if (delegateDeclaration.ReturnType == null) {
				return data;
			}
			return delegateDeclaration.ReturnType.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(FieldDeclaration fieldDeclaration, object data)
		{
			foreach (AttributeSection a in fieldDeclaration.Attributes) {
				a.AcceptVisitor(this, data);
			}
			if (fieldDeclaration.Fields != null) {
				foreach (VariableDeclaration v in fieldDeclaration.Fields) {
					v.AcceptVisitor(this, data);
				}
			}
			if (fieldDeclaration.TypeReference == null) {
				return data;
			}
			return fieldDeclaration.TypeReference.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(VariableDeclaration variableDeclaration, object data)
		{
			if (variableDeclaration.Initializer == null) {
				return data;
			}
			return variableDeclaration.Initializer.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(ParameterDeclarationExpression parameterDeclarationExpression, object data)
		{
			object ret = data;
			foreach (AttributeSection a in parameterDeclarationExpression.Attributes) {
				a.AcceptVisitor(this, data);
			}
			ret = parameterDeclarationExpression.TypeReference.AcceptVisitor(this, data);
			if (parameterDeclarationExpression.DefaultValue != null) {
				ret = parameterDeclarationExpression.DefaultValue.AcceptVisitor(this, data);
			}
			return ret;
		}
		
		public virtual object Visit(ConstructorDeclaration constructorDeclaration, object data)
		{
			blockStack.Push(constructorDeclaration.Body);
			foreach (AttributeSection a in constructorDeclaration.Attributes) {
				a.AcceptVisitor(this, data);
			}
			if (constructorDeclaration.Parameters != null) {
				foreach (ParameterDeclarationExpression p in constructorDeclaration.Parameters) {
					p.AcceptVisitor(this, data);
				}
			}
			object ret = null;
			if (constructorDeclaration.Body != null) {
				ret = constructorDeclaration.Body.AcceptChildren(this, data);
			}
			blockStack.Pop();
			return ret;
		}
		
		public virtual object Visit(MethodDeclaration methodDeclaration, object data)
		{
			blockStack.Push(methodDeclaration.Body);
			foreach (AttributeSection a in methodDeclaration.Attributes) {
				a.AcceptVisitor(this, data);
			}
			if (methodDeclaration.TypeReference != null) {
				methodDeclaration.TypeReference.AcceptVisitor(this, data);
			}
			
			if (methodDeclaration.Parameters != null) {
				foreach (ParameterDeclarationExpression p in methodDeclaration.Parameters) {
					p.AcceptVisitor(this, data);
				}
			}
			
			if (methodDeclaration.HandlesClause != null) {
				methodDeclaration.HandlesClause.AcceptVisitor(this, data);
			}
			if (methodDeclaration.ImplementsClause != null) {
				methodDeclaration.ImplementsClause.AcceptVisitor(this, data);
			}
			object ret = null;
			if (methodDeclaration.Body != null) {
				methodDeclaration.Body.AcceptChildren(this, data);
			}
			blockStack.Pop();
			return ret;
		}
		
		public virtual object Visit(DeclareDeclaration declareDeclaration, object data)
		{
			if (declareDeclaration != null) {
				if (declareDeclaration.Attributes != null) {
					foreach (AttributeSection a in declareDeclaration.Attributes) {
						a.AcceptVisitor(this, data);
					}
				}
				
				if (declareDeclaration.ReturnType != null) {
					declareDeclaration.ReturnType.AcceptVisitor(this, data);
				}
				
				if (declareDeclaration.Parameters != null) {
					foreach (ParameterDeclarationExpression p in declareDeclaration.Parameters) {
						p.AcceptVisitor(this, data);
					}
				}
			}
			return data;
		}
		
		public virtual object Visit(PropertyDeclaration propertyDeclaration, object data)
		{
			foreach (AttributeSection a in propertyDeclaration.Attributes) {
				a.AcceptVisitor(this, data);
			}
			propertyDeclaration.TypeReference.AcceptVisitor(this, data);
			if (propertyDeclaration.Parameters != null) {
				foreach (ParameterDeclarationExpression p in propertyDeclaration.Parameters) {
					p.AcceptVisitor(this, data);
				}
			}
			if (propertyDeclaration.ImplementsClause != null) {
				propertyDeclaration.ImplementsClause.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)
		{
			blockStack.Push(propertyGetRegion.Block);
			foreach (AttributeSection a in propertyGetRegion.Attributes) {
				a.AcceptVisitor(this, data);
			}
			object ret = null;
			if (propertyGetRegion.Block != null) {
				ret = propertyGetRegion.Block.AcceptChildren(this, data);
			}
			blockStack.Pop();
			return ret;
		}
		
		public virtual object Visit(PropertySetRegion propertySetRegion, object data)
		{
			blockStack.Push(propertySetRegion.Block);
			foreach (AttributeSection a in propertySetRegion.Attributes) {
				a.AcceptVisitor(this, data);
			}
			object ret = null;
			if (propertySetRegion.Block != null) {
				ret = propertySetRegion.Block.AcceptChildren(this, data);
			}
			blockStack.Pop();
			return ret;
		}
		
		public virtual object Visit(EventDeclaration eventDeclaration, object data)
		{
			foreach (AttributeSection a in eventDeclaration.Attributes) {
				a.AcceptVisitor(this, data);
			}
			if(eventDeclaration.TypeReference != null){
				eventDeclaration.TypeReference.AcceptVisitor(this, data);
			}
			if (eventDeclaration.Parameters != null) {
				foreach (ParameterDeclarationExpression p in eventDeclaration.Parameters) {
					p.AcceptVisitor(this, data);
				}
			}
			if (eventDeclaration.ImplementsClause != null) {
				eventDeclaration.ImplementsClause.AcceptVisitor(this, data);
			}
			return data;
		}
		
		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(Statement statement, object data)
		{
			Console.WriteLine("Warning, visited Statement!");
			return data;
		}
		
		public virtual object Visit(StatementExpression statementExpression, object data)
		{
			if (statementExpression.Expression == null) {
				return data;
			}
			return statementExpression.Expression.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(LocalVariableDeclaration localVariableDeclaration, object data)
		{
			object ret = data;
			if (localVariableDeclaration.Variables != null) {
				foreach (VariableDeclaration v in localVariableDeclaration.Variables) {
					ret = v.AcceptVisitor(this, data);
				}
			}
			return ret;
		}