abstractastvisitor.cs

c#源代码

		
		public virtual object Visit(SimpleIfStatement ifStatement, object data)
		{
			object ret = ifStatement.Condition.AcceptVisitor(this, data);
			if(ifStatement.Statements != null) {
				foreach (Statement s in ifStatement.Statements) {
					ret = s.AcceptVisitor(this, data);
				}
			}
			if(ifStatement.ElseStatements != null) {
				foreach (Statement s in ifStatement.ElseStatements) {
					ret = s.AcceptVisitor(this, data);
				}
			}
			return ret;
		}
		
		public virtual object Visit(IfStatement ifStatement, object data)
		{
			object ret = ifStatement.Condition.AcceptVisitor(this, data);
			if(ifStatement.ElseIfStatements != null) {
				foreach (Statement s in ifStatement.ElseIfStatements) {
					ret = s.AcceptVisitor(this, data);
				}
			}
			if (ifStatement.EmbeddedElseStatement != null) {
				ret = ifStatement.EmbeddedElseStatement.AcceptVisitor(this, data);
			}
			return ret;
		}
		
		public virtual object Visit(LabelStatement labelStatement, object data)
		{
			if (labelStatement.EmbeddedStatement == null) {
				return null;
			}
			return labelStatement.EmbeddedStatement.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(GoToStatement goToStatement, object data)
		{
			return data;
		}
		
		public virtual object Visit(SelectStatement selectStatement, object data)
		{
			selectStatement.SelectExpression.AcceptVisitor(this, data);
			if (selectStatement.SelectSections != null) {
				foreach (SelectSection s in selectStatement.SelectSections) {
					s.AcceptVisitor(this, data);
				}
			}
			return data;
		}
		
		public virtual object Visit(SelectSection selectSection, object data)
		{
			if (selectSection.CaseClauses != null) {
				foreach (CaseClause c in selectSection.CaseClauses) {
					c.AcceptVisitor(this, data);
				}
			}
			return data;
		}
		
		public virtual object Visit(CaseClause caseClause, object data)
		{
			caseClause.ComparisonExpression.AcceptVisitor(this, data);
			return caseClause.BoundaryExpression.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(ExitStatement exitStatement, object data)
		{
			return data;
		}
		
		public virtual object Visit(EndStatement endStatement, object data)
		{
			return data;
		}
		
		public virtual object Visit(StopStatement stopStatement, object data)
		{
			return data;
		}
		
		public virtual object Visit(ResumeStatement resumeStatement, object data)
		{
			return data;
		}
		
		public virtual object Visit(ErrorStatement errorStatement, object data)
		{
			return errorStatement.Expression.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(OnErrorStatement onErrorStatement, object data)
		{
			return onErrorStatement.EmbeddedStatement.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(EraseStatement eraseStatement, object data)
		{
			return data;
		}
		
		public virtual object Visit(ReDimStatement reDimStatement, object data)
		{
			return data;
		}
		
		public virtual object Visit(AddHandlerStatement addHandlerStatement, object data)
		{
			addHandlerStatement.EventExpression.AcceptVisitor(this, data);
			addHandlerStatement.HandlerExpression.AcceptVisitor(this, data);
			return data;
		}
		
		public virtual object Visit(RemoveHandlerStatement removeHandlerStatement, object data)
		{
			removeHandlerStatement.EventExpression.AcceptVisitor(this, data);
			removeHandlerStatement.HandlerExpression.AcceptVisitor(this, data);
			return data;
		}
		
		public virtual object Visit(ReturnStatement returnStatement, object data)
		{
			return returnStatement.ReturnExpression.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(RaiseEventStatement raiseEventStatement, object data)
		{
			if (raiseEventStatement.Parameters != null) {
				foreach (INode node in raiseEventStatement.Parameters) {
					node.AcceptVisitor(this, data);
				}
			}
			return data;
		}
		
		public virtual object Visit(WhileStatement whileStatement, object data)
		{
			if (whileStatement.EmbeddedStatement == null) {
				return null;
			}
			return whileStatement.EmbeddedStatement.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(WithStatement withStatement, object data)
		{
			if (withStatement.WithExpression != null) {
				withStatement.WithExpression.AcceptVisitor(this, data);
			}
			
			if (withStatement.Body == null) {
				return null;
			}
			return withStatement.Body.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(DoLoopStatement doLoopStatement, object data)
		{
			if (doLoopStatement.EmbeddedStatement == null) {
				return null;
			}
			return doLoopStatement.EmbeddedStatement.AcceptVisitor(this, data);
		}
		public virtual object Visit(ForStatement forStatement, object data)
		{
			if (forStatement.EmbeddedStatement == null) {
				return null;
			}
			return forStatement.EmbeddedStatement.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(ForeachStatement foreachStatement, object data)
		{
			if (foreachStatement.LoopControlVariable != null) {
				foreachStatement.LoopControlVariable.AcceptVisitor(this, data);
			}
			if (foreachStatement.EmbeddedStatement == null) {
				return null;
			}
			return foreachStatement.EmbeddedStatement.AcceptVisitor(this, data);
		}
		public virtual object Visit(LockStatement lockStatement, object data)
		{
			if (lockStatement.EmbeddedStatement == null) {
				return null;
			}
			return lockStatement.EmbeddedStatement.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(TryCatchStatement tryCatchStatement, object data)
		{
			if (tryCatchStatement.StatementBlock == null) {
				return null;
			}
			return tryCatchStatement.StatementBlock.AcceptVisitor(this, data);
		}
		public virtual object Visit(ThrowStatement throwStatement, object data)
		{
			if (throwStatement.ThrowExpression == null) {
				return null;
			}
			return throwStatement.ThrowExpression.AcceptVisitor(this, data);
		}
		
#region Expressions
		public virtual object Visit(FieldReferenceOrInvocationExpression fieldReferenceOrInvocationExpression, object data)
		{
			if (fieldReferenceOrInvocationExpression.TargetObject == null) {
				return null;
			}
			return fieldReferenceOrInvocationExpression.TargetObject.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(PrimitiveExpression primitiveExpression, object data)
		{
			// nothing to visit
			return data;
		}
		
		public virtual object Visit(BinaryOperatorExpression binaryOperatorExpression, object data)
		{
			// visit but can't give back 2 values
			binaryOperatorExpression.Left.AcceptVisitor(this, data);
			binaryOperatorExpression.Right.AcceptVisitor(this, data);
			
			return data;
		}
		public virtual object Visit(ParenthesizedExpression parenthesizedExpression, object data)
		{
			return parenthesizedExpression.Expression.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(InvocationExpression invocationExpression, object data)
		{
			if (invocationExpression.TargetObject == null) {
				return data;
			}
			return invocationExpression.TargetObject.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(IdentifierExpression identifierExpression, object data)
		{
			// nothing to visit
			return data;
		}
		
		public virtual object Visit(TypeReferenceExpression typeReferenceExpression, object data)
		{
			// nothing to visit
			return data;
		}
		
		public virtual object Visit(UnaryOperatorExpression unaryOperatorExpression, object data)
		{
			return unaryOperatorExpression.Expression.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(AssignmentExpression assignmentExpression, object data)
		{
			// visit but can't give back 2 values
			assignmentExpression.Left.AcceptVisitor(this, data);
			assignmentExpression.Right.AcceptVisitor(this, data);
			
			return data;
		}
		
		public virtual object Visit(CastExpression castExpression, object data)
		{
			return castExpression.Expression.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(ThisReferenceExpression thisReferenceExpression, object data)
		{
			// nothing to visit
			return data;
		}
		
		public virtual object Visit(BaseReferenceExpression baseReferenceExpression, object data)
		{
			// nothing to visit
			return data;
		}
		
		public virtual object Visit(ObjectCreateExpression objectCreateExpression, object data)
		{
			// nothing to visit
			return data;
		}
		
		public virtual object Visit(ArrayInitializerExpression arrayInitializerExpression, object data)
		{
			if (arrayInitializerExpression.CreateExpressions != null) {
				foreach (INode node in arrayInitializerExpression.CreateExpressions) {
					node.AcceptVisitor(this, data);
				}
			}
			
			return data;
		}
		
		public virtual object Visit(GetTypeExpression getTypeExpression, object data)
		{
			// nothing to visit
			return data;
		}
		
		public virtual object Visit(ClassReferenceExpression classReferenceExpression, object data)
		{
			// nothing to visit
			return data;
		}
		
		public virtual object Visit(LoopControlVariableExpression loopControlVariableExpression, object data)
		{
			return loopControlVariableExpression.Expression.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(AddressOfExpression addressOfExpression, object data)
		{
			return addressOfExpression.Procedure.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(TypeOfExpression typeOfExpression, object data)
		{
			return typeOfExpression.Expression.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(ArrayCreateExpression arrayCreateExpression, object data)
		{
			if (arrayCreateExpression.ArrayInitializer == null) {
				return data;
			}
			return arrayCreateExpression.ArrayInitializer.AcceptVisitor(this, data);
		}
#endregion
	}
}