abstractasttransformer.cs

根据cs源码解析为codedom

			Debug.Assert((conditionalExpression.FalseExpression != null));
			nodeStack.Push(conditionalExpression.Condition);
			conditionalExpression.Condition.AcceptVisitor(this, data);
			conditionalExpression.Condition = ((Expression)(nodeStack.Pop()));
			nodeStack.Push(conditionalExpression.TrueExpression);
			conditionalExpression.TrueExpression.AcceptVisitor(this, data);
			conditionalExpression.TrueExpression = ((Expression)(nodeStack.Pop()));
			nodeStack.Push(conditionalExpression.FalseExpression);
			conditionalExpression.FalseExpression.AcceptVisitor(this, data);
			conditionalExpression.FalseExpression = ((Expression)(nodeStack.Pop()));
			return null;
		}
		
		public virtual object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data) {
			Debug.Assert((constructorDeclaration != null));
			Debug.Assert((constructorDeclaration.Attributes != null));
			Debug.Assert((constructorDeclaration.Parameters != null));
			Debug.Assert((constructorDeclaration.ConstructorInitializer != null));
			Debug.Assert((constructorDeclaration.Body != null));
			for (int i = 0; i < constructorDeclaration.Attributes.Count; i++) {
				AttributeSection o = constructorDeclaration.Attributes[i];
				Debug.Assert(o != null);
				nodeStack.Push(o);
				o.AcceptVisitor(this, data);
				o = (AttributeSection)nodeStack.Pop();
				if (o == null)
					constructorDeclaration.Attributes.RemoveAt(i--);
				else
					constructorDeclaration.Attributes[i] = o;
			}
			for (int i = 0; i < constructorDeclaration.Parameters.Count; i++) {
				ParameterDeclarationExpression o = constructorDeclaration.Parameters[i];
				Debug.Assert(o != null);
				nodeStack.Push(o);
				o.AcceptVisitor(this, data);
				o = (ParameterDeclarationExpression)nodeStack.Pop();
				if (o == null)
					constructorDeclaration.Parameters.RemoveAt(i--);
				else
					constructorDeclaration.Parameters[i] = o;
			}
			nodeStack.Push(constructorDeclaration.ConstructorInitializer);
			constructorDeclaration.ConstructorInitializer.AcceptVisitor(this, data);
			constructorDeclaration.ConstructorInitializer = ((ConstructorInitializer)(nodeStack.Pop()));
			nodeStack.Push(constructorDeclaration.Body);
			constructorDeclaration.Body.AcceptVisitor(this, data);
			constructorDeclaration.Body = ((BlockStatement)(nodeStack.Pop()));
			return null;
		}
		
		public virtual object VisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data) {
			Debug.Assert((constructorInitializer != null));
			Debug.Assert((constructorInitializer.Arguments != null));
			for (int i = 0; i < constructorInitializer.Arguments.Count; i++) {
				Expression o = constructorInitializer.Arguments[i];
				Debug.Assert(o != null);
				nodeStack.Push(o);
				o.AcceptVisitor(this, data);
				o = (Expression)nodeStack.Pop();
				if (o == null)
					constructorInitializer.Arguments.RemoveAt(i--);
				else
					constructorInitializer.Arguments[i] = o;
			}
			return null;
		}
		
		public virtual object VisitContinueStatement(ContinueStatement continueStatement, object data) {
			Debug.Assert((continueStatement != null));
			return null;
		}
		
		public virtual object VisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data) {
			Debug.Assert((declareDeclaration != null));
			Debug.Assert((declareDeclaration.Attributes != null));
			Debug.Assert((declareDeclaration.Parameters != null));
			Debug.Assert((declareDeclaration.TypeReference != null));
			for (int i = 0; i < declareDeclaration.Attributes.Count; i++) {
				AttributeSection o = declareDeclaration.Attributes[i];
				Debug.Assert(o != null);
				nodeStack.Push(o);
				o.AcceptVisitor(this, data);
				o = (AttributeSection)nodeStack.Pop();
				if (o == null)
					declareDeclaration.Attributes.RemoveAt(i--);
				else
					declareDeclaration.Attributes[i] = o;
			}
			for (int i = 0; i < declareDeclaration.Parameters.Count; i++) {
				ParameterDeclarationExpression o = declareDeclaration.Parameters[i];
				Debug.Assert(o != null);
				nodeStack.Push(o);
				o.AcceptVisitor(this, data);
				o = (ParameterDeclarationExpression)nodeStack.Pop();
				if (o == null)
					declareDeclaration.Parameters.RemoveAt(i--);
				else
					declareDeclaration.Parameters[i] = o;
			}
			nodeStack.Push(declareDeclaration.TypeReference);
			declareDeclaration.TypeReference.AcceptVisitor(this, data);
			declareDeclaration.TypeReference = ((TypeReference)(nodeStack.Pop()));
			return null;
		}
		
		public virtual object VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data) {
			Debug.Assert((defaultValueExpression != null));
			Debug.Assert((defaultValueExpression.TypeReference != null));
			nodeStack.Push(defaultValueExpression.TypeReference);
			defaultValueExpression.TypeReference.AcceptVisitor(this, data);
			defaultValueExpression.TypeReference = ((TypeReference)(nodeStack.Pop()));
			return null;
		}
		
		public virtual object VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data) {
			Debug.Assert((delegateDeclaration != null));
			Debug.Assert((delegateDeclaration.Attributes != null));
			Debug.Assert((delegateDeclaration.ReturnType != null));
			Debug.Assert((delegateDeclaration.Parameters != null));
			Debug.Assert((delegateDeclaration.Templates != null));
			for (int i = 0; i < delegateDeclaration.Attributes.Count; i++) {
				AttributeSection o = delegateDeclaration.Attributes[i];
				Debug.Assert(o != null);
				nodeStack.Push(o);
				o.AcceptVisitor(this, data);
				o = (AttributeSection)nodeStack.Pop();
				if (o == null)
					delegateDeclaration.Attributes.RemoveAt(i--);
				else
					delegateDeclaration.Attributes[i] = o;
			}
			nodeStack.Push(delegateDeclaration.ReturnType);
			delegateDeclaration.ReturnType.AcceptVisitor(this, data);
			delegateDeclaration.ReturnType = ((TypeReference)(nodeStack.Pop()));
			for (int i = 0; i < delegateDeclaration.Parameters.Count; i++) {
				ParameterDeclarationExpression o = delegateDeclaration.Parameters[i];
				Debug.Assert(o != null);
				nodeStack.Push(o);
				o.AcceptVisitor(this, data);
				o = (ParameterDeclarationExpression)nodeStack.Pop();
				if (o == null)
					delegateDeclaration.Parameters.RemoveAt(i--);
				else
					delegateDeclaration.Parameters[i] = o;
			}
			for (int i = 0; i < delegateDeclaration.Templates.Count; i++) {
				TemplateDefinition o = delegateDeclaration.Templates[i];
				Debug.Assert(o != null);
				nodeStack.Push(o);
				o.AcceptVisitor(this, data);
				o = (TemplateDefinition)nodeStack.Pop();
				if (o == null)
					delegateDeclaration.Templates.RemoveAt(i--);
				else
					delegateDeclaration.Templates[i] = o;
			}
			return null;
		}
		
		public virtual object VisitDestructorDeclaration(DestructorDeclaration destructorDeclaration, object data) {
			Debug.Assert((destructorDeclaration != null));
			Debug.Assert((destructorDeclaration.Attributes != null));
			Debug.Assert((destructorDeclaration.Body != null));
			for (int i = 0; i < destructorDeclaration.Attributes.Count; i++) {
				AttributeSection o = destructorDeclaration.Attributes[i];
				Debug.Assert(o != null);
				nodeStack.Push(o);
				o.AcceptVisitor(this, data);
				o = (AttributeSection)nodeStack.Pop();
				if (o == null)
					destructorDeclaration.Attributes.RemoveAt(i--);
				else
					destructorDeclaration.Attributes[i] = o;
			}
			nodeStack.Push(destructorDeclaration.Body);
			destructorDeclaration.Body.AcceptVisitor(this, data);
			destructorDeclaration.Body = ((BlockStatement)(nodeStack.Pop()));
			return null;
		}
		
		public virtual object VisitDirectionExpression(DirectionExpression directionExpression, object data) {
			Debug.Assert((directionExpression != null));
			Debug.Assert((directionExpression.Expression != null));
			nodeStack.Push(directionExpression.Expression);
			directionExpression.Expression.AcceptVisitor(this, data);
			directionExpression.Expression = ((Expression)(nodeStack.Pop()));
			return null;
		}
		
		public virtual object VisitDoLoopStatement(DoLoopStatement doLoopStatement, object data) {
			Debug.Assert((doLoopStatement != null));
			Debug.Assert((doLoopStatement.Condition != null));
			Debug.Assert((doLoopStatement.EmbeddedStatement != null));
			nodeStack.Push(doLoopStatement.Condition);
			doLoopStatement.Condition.AcceptVisitor(this, data);
			doLoopStatement.Condition = ((Expression)(nodeStack.Pop()));
			nodeStack.Push(doLoopStatement.EmbeddedStatement);
			doLoopStatement.EmbeddedStatement.AcceptVisitor(this, data);
			doLoopStatement.EmbeddedStatement = ((Statement)(nodeStack.Pop()));
			return null;
		}
		
		public virtual object VisitElseIfSection(ElseIfSection elseIfSection, object data) {
			Debug.Assert((elseIfSection != null));
			Debug.Assert((elseIfSection.Condition != null));
			Debug.Assert((elseIfSection.EmbeddedStatement != null));
			nodeStack.Push(elseIfSection.Condition);
			elseIfSection.Condition.AcceptVisitor(this, data);
			elseIfSection.Condition = ((Expression)(nodeStack.Pop()));
			nodeStack.Push(elseIfSection.EmbeddedStatement);
			elseIfSection.EmbeddedStatement.AcceptVisitor(this, data);
			elseIfSection.EmbeddedStatement = ((Statement)(nodeStack.Pop()));
			return null;
		}
		
		public virtual object VisitEmptyStatement(EmptyStatement emptyStatement, object data) {
			Debug.Assert((emptyStatement != null));
			return null;
		}
		
		public virtual object VisitEndStatement(EndStatement endStatement, object data) {
			Debug.Assert((endStatement != null));
			return null;
		}
		
		public virtual object VisitEraseStatement(EraseStatement eraseStatement, object data) {
			Debug.Assert((eraseStatement != null));
			Debug.Assert((eraseStatement.Expressions != null));
			for (int i = 0; i < eraseStatement.Expressions.Count; i++) {
				Expression o = eraseStatement.Expressions[i];
				Debug.Assert(o != null);
				nodeStack.Push(o);
				o.AcceptVisitor(this, data);
				o = (Expression)nodeStack.Pop();
				if (o == null)
					eraseStatement.Expressions.RemoveAt(i--);
				else
					eraseStatement.Expressions[i] = o;
			}
			return null;
		}
		
		public virtual object VisitErrorStatement(ErrorStatement errorStatement, object data) {
			Debug.Assert((errorStatement != null));
			Debug.Assert((errorStatement.Expression != null));
			nodeStack.Push(errorStatement.Expression);
			errorStatement.Expression.AcceptVisitor(this, data);
			errorStatement.Expression = ((Expression)(nodeStack.Pop()));
			return null;
		}
		
		public virtual object VisitEventAddRegion(EventAddRegion eventAddRegion, object data) {
			Debug.Assert((eventAddRegion != null));
			Debug.Assert((eventAddRegion.Attributes != null));
			Debug.Assert((eventAddRegion.Block != null));
			Debug.Assert((eventAddRegion.Parameters != null));
			for (int i = 0; i < eventAddRegion.Attributes.Count; i++) {
				AttributeSection o = eventAddRegion.Attributes[i];
				Debug.Assert(o != null);
				nodeStack.Push(o);
				o.AcceptVisitor(this, data);
				o = (AttributeSection)nodeStack.Pop();
				if (o == null)
					eventAddRegion.Attributes.RemoveAt(i--);
				else
					eventAddRegion.Attributes[i] = o;
			}
			nodeStack.Push(eventAddRegion.Block);
			eventAddRegion.Block.AcceptVisitor(this, data);
			eventAddRegion.Block = ((BlockStatement)(nodeStack.Pop()));
			for (int i = 0; i < eventAddRegion.Parameters.Count; i++) {
				ParameterDeclarationExpression o = eventAddRegion.Parameters[i];
				Debug.Assert(o != null);
				nodeStack.Push(o);
				o.AcceptVisitor(this, data);
				o = (ParameterDeclarationExpression)nodeStack.Pop();
				if (o == null)
					eventAddRegion.Parameters.RemoveAt(i--);
				else
					eventAddRegion.Parameters[i] = o;
			}
			return null;
		}
		
		public virtual object VisitEventDeclaration(EventDeclaration eventDeclaration, object data) {
			Debug.Assert((eventDeclaration != null));
			Debug.Assert((eventDeclaration.Attributes != null));
			Debug.Assert((eventDeclaration.Parameters != null));
			Debug.Assert((eventDeclaration.TypeReference != null));
			Debug.Assert((eventDeclaration.InterfaceImplementations != null));
			Debug.Assert((eventDeclaration.AddRegion != null));
			Debug.Assert((eventDeclaration.RemoveRegion != null));
			Debug.Assert((eventDeclaration.RaiseRegion != null));
			Debug.Assert((eventDeclaration.Initializer != null));
			for (int i = 0; i < eventDeclaration.Attributes.Count; i++) {
				AttributeSection o = eventDeclaration.Attributes[i];
				Debug.Assert(o != null);
				nodeStack.Push(o);
				o.AcceptVisitor(this, data);
				o = (AttributeSection)nodeStack.Pop();
				if (o == null)
					eventDeclaration.Attributes.RemoveAt(i--);
				else
					eventDeclaration.Attributes[i] = o;
			}
			for (int i = 0; i < eventDeclaration.Parameters.Count; i++) {
				ParameterDeclarationExpression o = eventDeclaration.Parameters[i];
				Debug.Assert(o != null);
				nodeStack.Push(o);