abstractastvisitor.cs

c#源代码

		{
			object ret = data;
			if (doWhileStatement.Condition != null) {
				ret = doWhileStatement.Condition.AcceptVisitor(this, data);
			}
			if (doWhileStatement.EmbeddedStatement == null) {
				return ret;
			}
			return doWhileStatement.EmbeddedStatement.AcceptVisitor(this, data);
		}
		public virtual object Visit(ForStatement forStatement, object data)
		{
			object ret = data;
			if (forStatement.Initializers != null) {
				foreach(INode n in forStatement.Initializers) {
					n.AcceptVisitor(this, data);
				}
			}
			if (forStatement.Condition != null) {
				ret = forStatement.Condition.AcceptVisitor(this, data);
			}
			if (forStatement.Iterator != null) {
				foreach(INode n in forStatement.Iterator) {
					n.AcceptVisitor(this, data);
				}
			}
			if (forStatement.EmbeddedStatement == null) {
				return ret;
			}
			return forStatement.EmbeddedStatement.AcceptVisitor(this, data);
		}
		public virtual object Visit(ForeachStatement foreachStatement, object data)
		{
			if (foreachStatement.Expression != null) {
				foreachStatement.Expression.AcceptVisitor(this, data);
			}
			if (foreachStatement.EmbeddedStatement == null) {
				return data;
			}
			return foreachStatement.EmbeddedStatement.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(LabelStatement labelStatement, object data)
		{
			return data;
		}
		public virtual object Visit(GotoStatement gotoStatement, object data)
		{
			return data;
		}
		public virtual object Visit(BreakStatement breakStatement, object data)
		{
			return data;
		}
		public virtual object Visit(ContinueStatement continueStatement, object data)
		{
			return data;
		}
		public virtual object Visit(ReturnStatement returnStatement, object data)
		{
			if (returnStatement.ReturnExpression != null) {
				return returnStatement.ReturnExpression.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(SwitchStatement switchStatement, object data)
		{
			if (switchStatement == null) {
				return null;
			}
			if (switchStatement.SwitchExpression != null) {
				switchStatement.SwitchExpression.AcceptVisitor(this, data);
			}
			foreach (SwitchSection section in switchStatement.SwitchSections) {
				section.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(SwitchSection switchSection, object data)
		{
			foreach (CaseLabel label in switchSection.SwitchLabels) {
				if (label.Label != null) {
					label.Label.AcceptVisitor(this, data);
				}
			}
			return switchSection.AcceptChildren(this, data);
		}
		
		public virtual object Visit(GotoCaseStatement gotoCaseStatement, object data)
		{
			if (gotoCaseStatement.CaseExpression != null) {
				gotoCaseStatement.CaseExpression.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(LockStatement lockStatement, object data)
		{
			if (lockStatement.EmbeddedStatement == null) {
				return data;
			}
			return lockStatement.EmbeddedStatement.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(UsingStatement usingStatement, object data)
		{
			object ret = data;
			if (usingStatement.UsingStmnt != null) {
				ret = usingStatement.UsingStmnt.AcceptVisitor(this, data);
			}
			if (usingStatement.EmbeddedStatement != null) {
				ret = usingStatement.EmbeddedStatement.AcceptVisitor(this, data);
			}
			return ret;
		}
		public virtual object Visit(TryCatchStatement tryCatchStatement, object data)
		{
			if (tryCatchStatement == null) {
				return data;
			}
			if (tryCatchStatement.StatementBlock != null) {
				tryCatchStatement.StatementBlock.AcceptVisitor(this, data);
			}
			if (tryCatchStatement.CatchClauses != null) {
				foreach (CatchClause catchClause in tryCatchStatement.CatchClauses) {
					if (catchClause != null) {
						catchClause.StatementBlock.AcceptVisitor(this, data);
					}
				}
			}
			if (tryCatchStatement.FinallyBlock != null) {
				return tryCatchStatement.FinallyBlock.AcceptVisitor(this, data);
			}
			return data;
		}
		public virtual object Visit(ThrowStatement throwStatement, object data)
		{
			if (throwStatement.ThrowExpression == null) {
				return data;
			}
			return throwStatement.ThrowExpression.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(FixedStatement fixedStatement, object data)
		{
			return fixedStatement.EmbeddedStatement.AcceptVisitor(this, data);
		}
		public virtual object Visit(CheckedStatement checkedStatement, object data)
		{
			if (checkedStatement.Block == null) {
				return data;
			}
			return checkedStatement.Block.AcceptVisitor(this, data);
		}
		public virtual object Visit(UncheckedStatement uncheckedStatement, object data)
		{
			if (uncheckedStatement.Block == null) {
				return null;
			}
			return uncheckedStatement.Block.AcceptVisitor(this, data);
		}
		public virtual object Visit(StatementExpression statementExpression, object data)
		{
			if (statementExpression.Expression == null) {
				return null;
			}
			return statementExpression.Expression.AcceptVisitor(this, data);
		}
		
		public virtual object Visit(UnsafeStatement unsafeStatement, object data)
		{
			if (unsafeStatement.Block == null) {
				return null;
			}
			return unsafeStatement.Block.AcceptVisitor(this, data);
		}
#endregion
		
#region Expressions
		public virtual object Visit(PrimitiveExpression primitiveExpression, object data)
		{
			return data;
		}
		public virtual object Visit(BinaryOperatorExpression binaryOperatorExpression, object data)
		{
			binaryOperatorExpression.Left.AcceptVisitor(this, data);
			return binaryOperatorExpression.Right.AcceptVisitor(this, data);;
		}
		public virtual object Visit(ParenthesizedExpression parenthesizedExpression, object data)
		{
			if (parenthesizedExpression.Expression != null) {
				return parenthesizedExpression.Expression.AcceptVisitor(this, data);
			} 
			return data;
		}
		public virtual object Visit(FieldReferenceExpression fieldReferenceExpression, object data)
		{
			if (fieldReferenceExpression.TargetObject != null) {
				return fieldReferenceExpression.TargetObject.AcceptVisitor(this, data);
			}
			return data;
		}
		public virtual object Visit(InvocationExpression invocationExpression, object data)
		{
			object result = data;
			if (invocationExpression.TargetObject != null) {
				result = invocationExpression.TargetObject.AcceptVisitor(this, data);
			}
			if (invocationExpression.Parameters != null) {
				foreach (INode n in invocationExpression.Parameters) {
					n.AcceptVisitor(this, data);
				}
			}
			return result;
		}
		public virtual object Visit(IdentifierExpression identifierExpression, object data)
		{
			return data;
		}
		public virtual object Visit(TypeReferenceExpression typeReferenceExpression, object data)
		{
			return data;
		}
		public virtual object Visit(UnaryOperatorExpression unaryOperatorExpression, object data)
		{
			return unaryOperatorExpression.Expression.AcceptVisitor(this, data);
		}
		public virtual object Visit(AssignmentExpression assignmentExpression, object data)
		{
			assignmentExpression.Left.AcceptVisitor(this, data);
			return assignmentExpression.Right.AcceptVisitor(this, data);
		}
		public virtual object Visit(SizeOfExpression sizeOfExpression, object data)
		{
			return data;
		}
		public virtual object Visit(TypeOfExpression typeOfExpression, object data)
		{
			return data;
		}
		public virtual object Visit(CheckedExpression checkedExpression, object data)
		{
			return checkedExpression.Expression.AcceptVisitor(this, data);
		}
		public virtual object Visit(UncheckedExpression uncheckedExpression, object data)
		{
			return uncheckedExpression.Expression.AcceptVisitor(this, data);
		}
		public virtual object Visit(PointerReferenceExpression pointerReferenceExpression, object data)
		{
			return pointerReferenceExpression.Expression.AcceptVisitor(this, data);
		}
		public virtual object Visit(CastExpression castExpression, object data)
		{
			return castExpression.Expression.AcceptVisitor(this, data);
		}
		public virtual object Visit(StackAllocExpression stackAllocExpression, object data)
		{
			return stackAllocExpression.Expression.AcceptVisitor(this, data);
		}
		public virtual object Visit(IndexerExpression indexerExpression, object data)
		{
			object res = indexerExpression.TargetObject.AcceptVisitor(this, data);
			foreach (INode n in indexerExpression.Indices) {
				n.AcceptVisitor(this, data);
			}
			return res;
		}
		public virtual object Visit(ThisReferenceExpression thisReferenceExpression, object data)
		{
			return data;
		}
		public virtual object Visit(BaseReferenceExpression baseReferenceExpression, object data)
		{
			return data;
		}
		public virtual object Visit(ObjectCreateExpression objectCreateExpression, object data)
		{
			foreach (Expression e in objectCreateExpression.Parameters) {
				e.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(ArrayCreationParameter arrayCreationParameter, object data)
		{
			if (arrayCreationParameter.Expressions != null) {
				foreach (Expression e in arrayCreationParameter.Expressions) {
					e.AcceptVisitor(this, data);
				}
			}
			return data;
		}
		
		public virtual object Visit(ArrayCreateExpression arrayCreateExpression, object data)
		{
			if (arrayCreateExpression.Parameters != null) {
				foreach (INode node in arrayCreateExpression.Parameters) {
					node.AcceptVisitor(this, data);
				}
			}
			if (arrayCreateExpression.ArrayInitializer != null) {
				return arrayCreateExpression.ArrayInitializer.AcceptVisitor(this, data);
			}
			return data;
		}
		public virtual object Visit(ArrayInitializerExpression arrayInitializerExpression, object data)
		{
			foreach (Expression e in arrayInitializerExpression.CreateExpressions) {
				e.AcceptVisitor(this, data);
			}
			return data;
		}
		public virtual object Visit(DirectionExpression directionExpression, object data)
		{
			return directionExpression.Expression.AcceptVisitor(this, data);
		}
		public virtual object Visit(ConditionalExpression conditionalExpression, object data)
		{
			conditionalExpression.TestCondition.AcceptVisitor(this, data);
			conditionalExpression.TrueExpression.AcceptVisitor(this, data);
			return conditionalExpression.FalseExpression.AcceptVisitor(this, data);
		}
#endregion
#endregion
	}
}