abstractastvisitor.cs

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

		
		public virtual object Visit(ReDimClause reDimClause, object data)
		{
			foreach (Expression e in reDimClause.Initializers) {
				e.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(UsingStatement usingStatement, object data)
		{
			if (usingStatement.ResourceAcquisition != null) {
				usingStatement.ResourceAcquisition.AcceptVisitor(this, data);
			}
			if (usingStatement.EmbeddedStatement != null) {
				usingStatement.EmbeddedStatement.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(WithStatement withStatement, object data)
		{
			if (withStatement.Expression != null) {
				withStatement.Expression.AcceptVisitor(this, data);
			}
			if (withStatement.Body != null) {
				withStatement.Body.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(EmptyStatement emptyStatement, object data)
		{
			return data;
		}
		
		public virtual object Visit(LocalVariableDeclaration localVariableDeclaration, object data)
		{
			Debug.Assert(localVariableDeclaration.TypeReference != null);
			localVariableDeclaration.TypeReference.AcceptVisitor(this, data);
			foreach (VariableDeclaration decl in localVariableDeclaration.Variables) {
				decl.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(IfElseStatement ifElseStatement, object data)
		{
			if (ifElseStatement.Condition != null) {
				ifElseStatement.Condition.AcceptVisitor(this, data);
			}
			if (ifElseStatement.TrueStatement != null) {
				ifElseStatement.TrueStatement.AcceptVisitor(this, data);
			}
			if (ifElseStatement.FalseStatement != null) {
				ifElseStatement.FalseStatement.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(DoLoopStatement doLoopStatement, object data)
		{
			doLoopStatement.Condition.AcceptVisitor(this, data);
			doLoopStatement.EmbeddedStatement.AcceptVisitor(this, data);
			return data;
		}
		
		public virtual object Visit(ForStatement forStatement, object data)
		{
			foreach(INode n in forStatement.Initializers) {
				n.AcceptVisitor(this, data);
			}
			if (forStatement.Condition != null) {
				forStatement.Condition.AcceptVisitor(this, data);
			}
			foreach(INode n in forStatement.Iterator) {
				n.AcceptVisitor(this, data);
			}
			if (forStatement.EmbeddedStatement == null) {
				return forStatement.EmbeddedStatement.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(ForeachStatement foreachStatement, object data)
		{
			foreachStatement.TypeReference.AcceptVisitor(this, data);
			if (foreachStatement.Expression != null) {
				foreachStatement.Expression.AcceptVisitor(this, data);
			}
			if (foreachStatement.EmbeddedStatement != null) {
				return foreachStatement.EmbeddedStatement.AcceptVisitor(this, data);
			}
			return 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(GotoCaseStatement gotoCaseStatement, object data)
		{
			if (!gotoCaseStatement.IsDefaultCase) {
				gotoCaseStatement.Expression.AcceptVisitor(this, data);
			}
			return data;
		}
		public virtual object Visit(BreakStatement breakStatement, object data)
		{
			return data;
		}
		public virtual object Visit(StopStatement stopStatement, object data)
		{
			return data;
		}
		public virtual object Visit(ResumeStatement breakStatement, object data)
		{
			return data;
		}
		public virtual object Visit(EndStatement endStatement, object data)
		{
			return data;
		}
		public virtual object Visit(ContinueStatement emptyStatement, object data)
		{
			return data;
		}
		public virtual object Visit(ReturnStatement returnStatement, object data)
		{
			if (returnStatement.Expression != null) {
				return returnStatement.Expression.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) {
				label.AcceptVisitor(this, data);
			}
			switchSection.AcceptChildren(this, data);
			return switchSection.AcceptChildren(this, data);
		}
		
		public virtual object Visit(CaseLabel caseLabel, object data)
		{
			if (caseLabel.Label != null) {
				return caseLabel.Label.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(LockStatement lockStatement, object data)
		{
			if (lockStatement.EmbeddedStatement != null) {
				return lockStatement.EmbeddedStatement.AcceptVisitor(this, data);
			}
			return data;
		}
		public virtual object Visit(FixedStatement fixedStatement, object data)
		{
			fixedStatement.TypeReference.AcceptVisitor(this, data);
			foreach (VariableDeclaration var in fixedStatement.PointerDeclarators) {
				var.AcceptVisitor(this, data);
			}
			fixedStatement.EmbeddedStatement.AcceptVisitor(this, data);
			return data;
		}
		public virtual object Visit(UnsafeStatement unsafeStatement, object data)
		{
			unsafeStatement.Block.AcceptVisitor(this, data);
			return data;
		}
		public virtual object Visit(CheckedStatement checkedStatement, object data)
		{
			checkedStatement.Block.AcceptVisitor(this, data);
			return data;
		}
		public virtual object Visit(UncheckedStatement uncheckedStatement, object data)
		{
			uncheckedStatement.Block.AcceptVisitor(this, data);
			return data;
		}
		
		public virtual object Visit(TryCatchStatement tryCatchStatement, object data)
		{
			if (tryCatchStatement.StatementBlock != null) {
				tryCatchStatement.StatementBlock.AcceptVisitor(this, data);
			}
			foreach (CatchClause catchClause in tryCatchStatement.CatchClauses) {
				catchClause.AcceptVisitor(this, data);
			}
			if (tryCatchStatement.FinallyBlock != null) {
				return tryCatchStatement.FinallyBlock.AcceptVisitor(this, data);
			}
			return data;
		}
		public virtual object Visit(CatchClause catchClause, object data)
		{
			if (catchClause.StatementBlock != null) {
				return catchClause.StatementBlock.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(ThrowStatement throwStatement, object data)
		{
			if (throwStatement.Expression != null) {
				return throwStatement.Expression.AcceptVisitor(this, data);
			}
			return data;
		}
		
		public virtual object Visit(StatementExpression statementExpression, object data)
		{
			if (statementExpression.Expression != null) {
				return statementExpression.Expression.AcceptVisitor(this, data);
			}
			return data;
		}
#endregion
		
#region expressions
		public virtual object Visit(LoopControlVariableExpression loopControlVariableExpression, object data)
		{
			loopControlVariableExpression.Type.AcceptVisitor(this, data);
			loopControlVariableExpression.Expression.AcceptVisitor(this, data);
			return data;
		}
		public virtual object Visit(PrimitiveExpression primitiveExpression, object data)
		{
			return data;
		}
		public virtual object Visit(UnaryOperatorExpression unaryOperatorExpression, object data)
		{
			return unaryOperatorExpression.Expression.AcceptVisitor(this, data);
		}
		public virtual object Visit(BinaryOperatorExpression binaryOperatorExpression, object data)
		{
			binaryOperatorExpression.Left.AcceptVisitor(this, data);
			return binaryOperatorExpression.Right.AcceptVisitor(this, data);;
		}
		public virtual object Visit(ConditionalExpression conditionalExpression, object data)
		{
			conditionalExpression.Condition.AcceptVisitor(this, data);
			conditionalExpression.TrueExpression.AcceptVisitor(this, data);
			conditionalExpression.FalseExpression.AcceptVisitor(this, data);
			return data;
		}
		public virtual object Visit(ParenthesizedExpression parenthesizedExpression, object data)
		{
			return parenthesizedExpression.Expression.AcceptVisitor(this, data);
		}
		public virtual object Visit(ClassReferenceExpression classReferenceExpression, object 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(IndexerExpression indexerExpression, object data)
		{
			if (indexerExpression.TargetObject != null) {
				indexerExpression.TargetObject.AcceptVisitor(this, data);
			}
			foreach (Expression e in indexerExpression.Indices) {
				e.AcceptVisitor(this, data);
			}
			return data;
		}
		public virtual object Visit(InvocationExpression invocationExpression, object data)
		{
			if (invocationExpression.TargetObject != null) {
				invocationExpression.TargetObject.AcceptVisitor(this, data);
			}
			foreach (ParameterDeclarationExpression p in invocationExpression.Parameters) {
				p.AcceptVisitor(this, data);
			}
			return data;
		}
		public virtual object Visit(IdentifierExpression identifierExpression, object data)
		{
			return data;
		}
		public virtual object Visit(TypeReferenceExpression typeReferenceExpression, object data)
		{
			typeReferenceExpression.TypeReference.AcceptVisitor(this, data);
			return data;
		}
		public virtual object Visit(AssignmentExpression assignmentExpression, object data)
		{
			assignmentExpression.Left.AcceptVisitor(this, data);
			return assignmentExpression.Right.AcceptVisitor(this, data);
		}
		public virtual object Visit(CastExpression castExpression, object data)
		{
			return castExpression.Expression.AcceptVisitor(this, data);
		}
		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)
		{
			objectCreateExpression.CreateType.AcceptVisitor(this, data);
			foreach (Expression e in objectCreateExpression.Parameters) {
				e.AcceptVisitor(this, data);
			}
			return data;
		}
		public virtual object Visit(ArrayCreateExpression arrayCreateExpression, object data)
		{
			arrayCreateExpression.CreateType.AcceptVisitor(this, data);
			foreach (ParameterDeclarationExpression p in arrayCreateExpression.Parameters) {
				p.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(CheckedExpression checkedExpression, object data)
		{
			checkedExpression.Expression.AcceptVisitor(this, data);
			return data;
		}
		public virtual object Visit(UncheckedExpression uncheckedExpression, object data)
		{
			uncheckedExpression.Expression.AcceptVisitor(this, data);
			return data;
		}
		public virtual object Visit(TypeOfIsExpression typeOfIsExpression, object data)
		{
			typeOfIsExpression.Expression.AcceptVisitor(this, data);
			typeOfIsExpression.TypeReference.AcceptVisitor(this, data);
			return data;
		}
		public virtual object Visit(TypeOfExpression typeOfExpression, object data)
		{
			typeOfExpression.TypeReference.AcceptVisitor(this, data);
			return data;
		}
		public virtual object Visit(AddressOfExpression addressOfExpression, object data)
		{
			addressOfExpression.Expression.AcceptVisitor(this, data);
			return data;
		}
		public virtual object Visit(SizeOfExpression sizeOfExpression, object data)
		{
			sizeOfExpression.TypeReference.AcceptVisitor(this, data);
			return data;
		}
		public virtual object Visit(PointerReferenceExpression pointerReferenceExpression, object data)
		{
			pointerReferenceExpression.TargetObject.AcceptVisitor(this, data);
			return data;
		}
		public virtual object Visit(DirectionExpression directionExpression, object data)
		{
			directionExpression.Expression.AcceptVisitor(this, data);
			return data;
		}
		public virtual object Visit(StackAllocExpression stackAllocExpression, object data)
		{
			stackAllocExpression.TypeReference.AcceptVisitor(this, data);
			stackAllocExpression.Expression.AcceptVisitor(this, data);
			return data;
		}
#endregion
#endregion 
	}
}