abstractastvisitor.cs

来自「全功能c#编译器」· CS 代码 · 共 812 行 · 第 1/2 页

using System;
using System.Diagnostics;
using System.Collections;
using ICSharpCode.CsVbRefactory.Parser.AST;

namespace ICSharpCode.CsVbRefactory.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.CsVbRefactory.Parser.IASTVisitor interface implementation
		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(TypeReference typeReference, object data)
		{
			return data;
		}
		
		public virtual object Visit(AttributeSection attributeSection, object data)
		{
			foreach (ICSharpCode.CsVbRefactory.Parser.AST.Attribute attribute in attributeSection.Attributes) {
				attribute.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(ICSharpCode.CsVbRefactory.Parser.AST.Attribute attribute, object data)
		{
			foreach (Expression e in attribute.PositionalArguments) {
				e.AcceptVisitor(this, data);
			}
			foreach (NamedArgument n in attribute.NamedArguments) {
				n.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(NamedArgument namedArgument, object data)
		{
			Debug.Assert(namedArgument != null);
			Debug.Assert(namedArgument.Expr != null);
			return namedArgument.Expr.AcceptVisitor(this, data);
		}
		
#region global scope
		public virtual object Visit(ImportsStatement importsStatement, object data)
		{
			// ImportsClauses contains UsingDeclaration and UsingAliasDeclaration
			foreach (INode n in importsStatement.ImportsClauses) {
				n.AcceptVisitor(this, data);
			}
			return data;
		}
		
		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(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 delegateDeclaration.ReturnType.AcceptVisitor(this, data);
		}
		// VB only:
		public virtual object Visit(OptionCompareDeclaration optionCompareDeclaration, object data)
		{
			return data;
		}
		public virtual object Visit(OptionExplicitDeclaration optionExplicitDeclaration, object data)
		{
			return data;
		}
		public virtual object Visit(OptionStrictDeclaration optionStrictDeclaration, object data)
		{
			return data;
		}
#endregion
		
#region type level
		public virtual object Visit(FieldDeclaration fieldDeclaration, object data)
		{
			foreach (AttributeSection section in fieldDeclaration.Attributes) {
				section.AcceptVisitor(this, data);
			}
			fieldDeclaration.TypeReference.AcceptVisitor(this, data);
			foreach (VariableDeclaration var in fieldDeclaration.Fields) {
				var.AcceptVisitor(this, fieldDeclaration);
			}
			return data;
		}
		
		public virtual object Visit(VariableDeclaration variableDeclaration, object data)
		{
			if (variableDeclaration.Initializer != null) {
				return variableDeclaration.Initializer.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(PropertyDeclaration propertyDeclaration, object data)
		{
			foreach (AttributeSection section in propertyDeclaration.Attributes) {
				section.AcceptVisitor(this, data);
			}
			propertyDeclaration.TypeReference.AcceptVisitor(this, data);
			propertyDeclaration.ImplementsClause.AcceptVisitor(this, data); // VB only
			propertyDeclaration.GetRegion.AcceptVisitor(this, data);
			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);
			propertyGetRegion.Block.AcceptChildren(this, data);
			blockStack.Pop();
			return data;
		}
		
		public virtual object Visit(PropertySetRegion propertySetRegion, object data)
		{
			foreach (AttributeSection section in propertySetRegion.Attributes) {
				section.AcceptVisitor(this, data);
			}
			blockStack.Push(propertySetRegion.Block);
			propertySetRegion.Block.AcceptChildren(this, data);
			blockStack.Pop();
			return data;
		}
		
		public virtual object Visit(EventDeclaration eventDeclaration, object data)
		{
			foreach (AttributeSection section in eventDeclaration.Attributes) {
				section.AcceptVisitor(this, data);
			}
			eventDeclaration.TypeReference.AcceptVisitor(this, data);
			if (eventDeclaration.Parameters != null) { // VB only
				foreach (ParameterDeclarationExpression p in eventDeclaration.Parameters) {
					p.AcceptVisitor(this, data);
				}
			} else if (eventDeclaration.VariableDeclarators != null) { // C# only
				foreach (VariableDeclaration v in eventDeclaration.VariableDeclarators) {
					v.AcceptVisitor(this, data);
				}
			} else { // C# only, not VariableDeclarators and eventregions at the same time present
				eventDeclaration.AddRegion.AcceptVisitor(this, data);
				eventDeclaration.RemoveRegion.AcceptVisitor(this, data);
			}
			eventDeclaration.ImplementsClause.AcceptVisitor(this, data);
			return data;
		}
		
		// C# only:
		public virtual object Visit(EventAddRegion eventAddRegion, object data)
		{
			foreach (AttributeSection section in eventAddRegion.Attributes) {
				section.AcceptVisitor(this, data);
			}
			blockStack.Push(eventAddRegion.Block);
			eventAddRegion.Block.AcceptChildren(this, data);
			blockStack.Pop();
			return data;
		}
		
		public virtual object Visit(EventRemoveRegion eventRemoveRegion, object data)
		{
			foreach (AttributeSection section in eventRemoveRegion.Attributes) {
				section.AcceptVisitor(this, data);
			}
			blockStack.Push(eventRemoveRegion.Block);
			eventRemoveRegion.Block.AcceptChildren(this, data);
			blockStack.Pop();
			return data;
		}
		
		// general:
		public virtual object Visit(ParameterDeclarationExpression parameterDeclarationExpression, object data)
		{
			foreach (AttributeSection section in parameterDeclarationExpression.Attributes) {
				section.AcceptVisitor(this, data);
			}
			return parameterDeclarationExpression.TypeReference.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(MethodDeclaration methodDeclaration, object data)
		{
			foreach (AttributeSection section in methodDeclaration.Attributes) {
				section.AcceptVisitor(this, data);
			}
			methodDeclaration.TypeReference.AcceptVisitor(this, data);
			foreach (ParameterDeclarationExpression p in methodDeclaration.Parameters) {
				p.AcceptVisitor(this, data);
			}
			methodDeclaration.HandlesClause.AcceptVisitor(this, data); // VB only
			methodDeclaration.ImplementsClause.AcceptVisitor(this, data); // VB only
			blockStack.Push(methodDeclaration.Body);
			methodDeclaration.Body.AcceptChildren(this, data);
			blockStack.Pop();
			return data;
		}
		
		public virtual object Visit(ConstructorDeclaration constructorDeclaration, object data)
		{
			foreach (AttributeSection section in constructorDeclaration.Attributes) {
				section.AcceptVisitor(this, data);
			}
			foreach (ParameterDeclarationExpression p in constructorDeclaration.Parameters) {
				p.AcceptVisitor(this, data);
			}
			constructorDeclaration.ConstructorInitializer.AcceptVisitor(this, data);
			blockStack.Push(constructorDeclaration.Body);
			constructorDeclaration.Body.AcceptChildren(this, data);
			blockStack.Pop();
			return data;
		}
		
		// C# only:
		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);
			}
			indexerDeclaration.GetRegion.AcceptVisitor(this, data);
			indexerDeclaration.SetRegion.AcceptVisitor(this, data);
			return data;
		}
		
		public virtual object Visit(ConstructorInitializer constructorInitializer, object data)
		{
			foreach (Expression expr in constructorInitializer.Arguments) {
				expr.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(DestructorDeclaration destructorDeclaration, object data)
		{
			foreach (AttributeSection section in destructorDeclaration.Attributes) {
				section.AcceptVisitor(this, data);
			}
			blockStack.Push(destructorDeclaration.Body);
			destructorDeclaration.Body.AcceptChildren(this, data);
			blockStack.Pop();
			return data;
		}
		
		public virtual object Visit(OperatorDeclaration operatorDeclaration, object data)
		{
			foreach (AttributeSection section in operatorDeclaration.Attributes) {
				section.AcceptVisitor(this, data);
			}
			blockStack.Push(operatorDeclaration.Body);
			operatorDeclaration.Body.AcceptChildren(this, data);
			blockStack.Pop();
			return data;
		}
		
		// VB only:
		public virtual object Visit(DeclareDeclaration declareDeclaration, object data)
		{
			foreach (AttributeSection section in declareDeclaration.Attributes) {
				section.AcceptVisitor(this, data);
			}
			declareDeclaration.ReturnType.AcceptVisitor(this, data);
			foreach (ParameterDeclarationExpression p in declareDeclaration.Parameters) {
				p.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(HandlesClause handlesClause, object data)
		{
			return data;
		}
		
		public virtual object Visit(ImplementsClause implementsClause, object data)
		{
			return data;
		}
#endregion
		
#region statements
		public virtual object Visit(BlockStatement blockStatement, object data)
		{
			Debug.Assert(blockStatement != null);
			blockStack.Push(blockStatement);
			blockStatement.AcceptChildren(this, data);
			blockStack.Pop();
			return data;
		}
		
		public virtual object Visit(AddHandlerStatement addHandlerStatement, object data)
		{
			if (addHandlerStatement.EventExpression != null) {
				addHandlerStatement.EventExpression.AcceptVisitor(this, data);
			}
			if (addHandlerStatement.HandlerExpression != null) {
				addHandlerStatement.HandlerExpression.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(RemoveHandlerStatement removeHandlerStatement, object data)
		{
			if (removeHandlerStatement.EventExpression != null) {
				removeHandlerStatement.EventExpression.AcceptVisitor(this, data);
			}
			if (removeHandlerStatement.HandlerExpression != null) {
				removeHandlerStatement.HandlerExpression.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(RaiseEventStatement raiseEventStatement, object data)
		{
			foreach (ParameterDeclarationExpression p in raiseEventStatement.Parameters) {
				p.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(EraseStatement eraseStatement, object data)
		{
			foreach (Expression e in eraseStatement.Expressions) {
				e.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(ErrorStatement errorStatement, object data)
		{
			if (errorStatement.Expression != null) {
				errorStatement.Expression.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(OnErrorStatement onErrorStatement, object data)
		{
			if (onErrorStatement.EmbeddedStatement != null) {
				onErrorStatement.EmbeddedStatement.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(ReDimStatement reDimStatement, object data)
		{
			foreach (ReDimClause clause in reDimStatement.ReDimClauses) {
				clause.AcceptVisitor(this, data);
			}
			return data;
		}