prettyprintvisitor.cs

c#源代码

		public override object Visit(StatementExpression statementExpression, object data)
		{
			outputFormatter.Indent();
			statementExpression.Expression.AcceptVisitor(this, data);
			outputFormatter.PrintToken(Tokens.Semicolon);
			outputFormatter.NewLine();
			return null;
		}
		
		public override object Visit(UnsafeStatement unsafeStatement, object data)
		{
			outputFormatter.Indent();
			outputFormatter.PrintToken(Tokens.Unsafe);
			unsafeStatement.Block.AcceptVisitor(this, data);
			return null;
		}
		
		
#region Expressions
		public override object Visit(ArrayCreateExpression arrayCreateExpression, object data)
		{
			outputFormatter.PrintToken(Tokens.New);
			outputFormatter.Space();
			Visit(arrayCreateExpression.CreateType, null);
			for (int i = 0; i < arrayCreateExpression.Parameters.Count; ++i) {
				outputFormatter.PrintToken(Tokens.OpenSquareBracket);
				ArrayCreationParameter creationParameter = (ArrayCreationParameter)arrayCreateExpression.Parameters[i];
				if (creationParameter.IsExpressionList) {
					AppendCommaSeparatedList(creationParameter.Expressions);
				} else {
					for (int j = 0; j < creationParameter.Dimensions; ++j) {
						outputFormatter.PrintToken(Tokens.Comma);
					}
				}
				outputFormatter.PrintToken(Tokens.CloseSquareBracket);
			}
			
			
			if (arrayCreateExpression.ArrayInitializer != null) {
				outputFormatter.Space();
				arrayCreateExpression.ArrayInitializer.AcceptVisitor(this, null);
			}
			return null;
		}
		
		public override object Visit(ArrayInitializerExpression arrayCreateExpression, object data)
		{
			outputFormatter.PrintToken(Tokens.OpenCurlyBrace);
			this.AppendCommaSeparatedList(arrayCreateExpression.CreateExpressions);
			outputFormatter.PrintToken(Tokens.CloseCurlyBrace);
			return null;
		}
		
		public override object Visit(AssignmentExpression assignmentExpression, object data)
		{
			assignmentExpression.Left.AcceptVisitor(this, data);
			outputFormatter.Space();
			switch (assignmentExpression.Op) {
				case AssignmentOperatorType.Assign:
					outputFormatter.PrintToken(Tokens.Assign);
					break;
				case AssignmentOperatorType.Add:
					outputFormatter.PrintToken(Tokens.PlusAssign);
					break;
				case AssignmentOperatorType.Subtract:
					outputFormatter.PrintToken(Tokens.MinusAssign);
					break;
				case AssignmentOperatorType.Multiply:
					outputFormatter.PrintToken(Tokens.TimesAssign);
					break;
				case AssignmentOperatorType.Divide:
					outputFormatter.PrintToken(Tokens.DivAssign);
					break;
				case AssignmentOperatorType.ShiftLeft:
					outputFormatter.PrintToken(Tokens.ShiftLeftAssign);
					break;
				case AssignmentOperatorType.ShiftRight:
					outputFormatter.PrintToken(Tokens.ShiftRightAssign);
					break;
				case AssignmentOperatorType.ExclusiveOr:
					outputFormatter.PrintToken(Tokens.XorAssign);
					break;
				case AssignmentOperatorType.Modulus:
					outputFormatter.PrintToken(Tokens.ModAssign);
					break;
				case AssignmentOperatorType.BitwiseAnd:
					outputFormatter.PrintToken(Tokens.BitwiseAndAssign);
					break;
				case AssignmentOperatorType.BitwiseOr:
					outputFormatter.PrintToken(Tokens.BitwiseOrAssign);
					break;
			}
			outputFormatter.Space();
			assignmentExpression.Right.AcceptVisitor(this, data);
			return null;
		}
		
		public override object Visit(BaseReferenceExpression baseReferenceExpression, object data)
		{
			outputFormatter.PrintToken(Tokens.Base);
			return null;
		}
		
		public override object Visit(BinaryOperatorExpression binaryOperatorExpression, object data)
		{
			binaryOperatorExpression.Left.AcceptVisitor(this, data);
			outputFormatter.Space();
			switch (binaryOperatorExpression.Op) {
				case BinaryOperatorType.Add:
					outputFormatter.PrintToken(Tokens.Plus);
					break;
				
				case BinaryOperatorType.Subtract:
					outputFormatter.PrintToken(Tokens.Minus);
					break;
				
				case BinaryOperatorType.Multiply:
					outputFormatter.PrintToken(Tokens.Times);
					break;
				
				case BinaryOperatorType.Divide:
					outputFormatter.PrintToken(Tokens.Div);
					break;
				
				case BinaryOperatorType.Modulus:
					outputFormatter.PrintToken(Tokens.Mod);
					break;
				
				case BinaryOperatorType.ShiftLeft:
					outputFormatter.PrintToken(Tokens.ShiftLeft);
					break;
				
				case BinaryOperatorType.ShiftRight:
					outputFormatter.PrintToken(Tokens.ShiftRight);
					break;
				
				case BinaryOperatorType.BitwiseAnd:
					outputFormatter.PrintToken(Tokens.BitwiseAnd);
					break;
				case BinaryOperatorType.BitwiseOr:
					outputFormatter.PrintToken(Tokens.BitwiseOr);
					break;
				case BinaryOperatorType.ExclusiveOr:
					outputFormatter.PrintToken(Tokens.Xor);
					break;
				
				case BinaryOperatorType.LogicalAnd:
					outputFormatter.PrintToken(Tokens.LogicalAnd);
					break;
				case BinaryOperatorType.LogicalOr:
					outputFormatter.PrintToken(Tokens.LogicalOr);
					break;
				
				case BinaryOperatorType.AS:
					outputFormatter.PrintToken(Tokens.As);
					break;
				
				case BinaryOperatorType.IS:
					outputFormatter.PrintToken(Tokens.Is);
					break;
				case BinaryOperatorType.Equality:
					outputFormatter.PrintToken(Tokens.Equal);
					break;
				case BinaryOperatorType.GreaterThan:
					outputFormatter.PrintToken(Tokens.GreaterThan);
					break;
				case BinaryOperatorType.GreaterThanOrEqual:
					outputFormatter.PrintToken(Tokens.GreaterEqual);
					break;
				case BinaryOperatorType.InEquality:
					outputFormatter.PrintToken(Tokens.NotEqual);
					break;
				case BinaryOperatorType.LessThan:
					outputFormatter.PrintToken(Tokens.LessThan);
					break;
				case BinaryOperatorType.LessThanOrEqual:
					outputFormatter.PrintToken(Tokens.LessEqual);
					break;
			}
			outputFormatter.Space();
			binaryOperatorExpression.Right.AcceptVisitor(this, data);
			return null;
		}
		
		public override object Visit(CastExpression castExpression, object data)
		{
			outputFormatter.PrintToken(Tokens.OpenParenthesis);
			Visit(castExpression.CastTo, data);
			outputFormatter.PrintToken(Tokens.CloseParenthesis);
			castExpression.Expression.AcceptVisitor(this, data);
			return null;
		}
		
		public override object Visit(CheckedExpression checkedExpression, object data)
		{
			outputFormatter.PrintToken(Tokens.Checked);
			outputFormatter.PrintToken(Tokens.OpenParenthesis);
			checkedExpression.Expression.AcceptVisitor(this, data);
			outputFormatter.PrintToken(Tokens.CloseParenthesis);
			return null;
		}
		
		public override object Visit(ConditionalExpression conditionalExpression, object data)
		{
			conditionalExpression.TestCondition.AcceptVisitor(this, data);
			outputFormatter.Space();
			outputFormatter.PrintToken(Tokens.Question);
			outputFormatter.Space();
			conditionalExpression.TrueExpression.AcceptVisitor(this, data);
			outputFormatter.Space();
			outputFormatter.PrintToken(Tokens.Colon);
			outputFormatter.Space();
			conditionalExpression.FalseExpression.AcceptVisitor(this, data);
			return null;
		}
		
		public override object Visit(DirectionExpression directionExpression, object data)
		{
			switch (directionExpression.FieldDirection) {
				case FieldDirection.Out:
					outputFormatter.PrintToken(Tokens.Out);
					outputFormatter.Space();
					break;
				case FieldDirection.Ref:
					outputFormatter.PrintToken(Tokens.Ref);
					outputFormatter.Space();
					break;
			}
			directionExpression.Expression.AcceptVisitor(this, data);
			return null;
		}
		
		public override object Visit(FieldReferenceExpression fieldReferenceExpression, object data)
		{
			fieldReferenceExpression.TargetObject.AcceptVisitor(this, data);
			outputFormatter.PrintToken(Tokens.Dot);
			outputFormatter.PrintIdentifier(fieldReferenceExpression.FieldName);
			return null;
		}
		
		public override object Visit(IdentifierExpression identifierExpression, object data)
		{
			outputFormatter.PrintIdentifier(identifierExpression.Identifier);
			return null;
		}
		
		public override object Visit(IndexerExpression indexerExpression, object data)
		{
			indexerExpression.TargetObject.AcceptVisitor(this, data);
			outputFormatter.PrintToken(Tokens.OpenSquareBracket);
			AppendCommaSeparatedList(indexerExpression.Indices);
			outputFormatter.PrintToken(Tokens.CloseSquareBracket);
			return null;
		}
		
		public override object Visit(InvocationExpression invocationExpression, object data)
		{
			invocationExpression.TargetObject.AcceptVisitor(this, data);
			outputFormatter.PrintToken(Tokens.OpenParenthesis);
			AppendCommaSeparatedList(invocationExpression.Parameters);
			outputFormatter.PrintToken(Tokens.CloseParenthesis);
			return null;
		}
		
		public override object Visit(ObjectCreateExpression objectCreateExpression, object data)
		{
			outputFormatter.PrintToken(Tokens.New);
			outputFormatter.Space();
			this.Visit(objectCreateExpression.CreateType, data);
			outputFormatter.PrintToken(Tokens.OpenParenthesis);
			AppendCommaSeparatedList(objectCreateExpression.Parameters);
			outputFormatter.PrintToken(Tokens.CloseParenthesis);
			return null;
		}
		
		public override object Visit(ParenthesizedExpression parenthesizedExpression, object data)
		{
			outputFormatter.PrintToken(Tokens.OpenParenthesis);
			parenthesizedExpression.Expression.AcceptVisitor(this, data);
			outputFormatter.PrintToken(Tokens.CloseParenthesis);
			return null;
		}
		
		public override object Visit(PointerReferenceExpression pointerReferenceExpression, object data)
		{
			pointerReferenceExpression.Expression.AcceptVisitor(this, data);
			outputFormatter.PrintToken(Tokens.Pointer);
			outputFormatter.PrintIdentifier(pointerReferenceExpression.Identifier);
			return null;
		}
		
		public override object Visit(PrimitiveExpression primitiveExpression, object data)
		{
			outputFormatter.PrintIdentifier(primitiveExpression.StringValue);
			return null;
		}
		
		public override object Visit(SizeOfExpression sizeOfExpression, object data)
		{
			outputFormatter.PrintToken(Tokens.Sizeof);
			outputFormatter.PrintToken(Tokens.OpenParenthesis);
			Visit(sizeOfExpression.TypeReference, data);
			outputFormatter.PrintToken(Tokens.CloseParenthesis);
			return null;
		}
		
		public override object Visit(StackAllocExpression stackAllocExpression, object data)
		{
			outputFormatter.PrintToken(Tokens.Stackalloc);
			outputFormatter.Space();
			Visit(stackAllocExpression.Type, data);
			outputFormatter.PrintToken(Tokens.OpenSquareBracket);
			stackAllocExpression.Expression.AcceptVisitor(this, data);
			outputFormatter.PrintToken(Tokens.CloseSquareBracket);
			return null;
		}
		
		public override object Visit(ThisReferenceExpression thisReferenceExpression, object data)
		{
			outputFormatter.PrintToken(Tokens.This);
			return null;
		}
		
		public override object Visit(TypeOfExpression typeOfExpression, object data)
		{
			outputFormatter.PrintToken(Tokens.Typeof);
			outputFormatter.PrintToken(Tokens.OpenParenthesis);
			Visit(typeOfExpression.TypeReference, data);
			outputFormatter.PrintToken(Tokens.CloseParenthesis);
			return null;
		}
		
		public override object Visit(TypeReferenceExpression typeReferenceExpression, object data)
		{
			Visit(typeReferenceExpression.TypeReference, data);
			return null;
		}
		
		public override object Visit(UnaryOperatorExpression unaryOperatorExpression, object data)
		{
			switch (unaryOperatorExpression.Op) {
				case UnaryOperatorType.BitNot:
					outputFormatter.PrintToken(Tokens.BitwiseComplement);
					break;
				case UnaryOperatorType.Decrement:
					outputFormatter.PrintToken(Tokens.Decrement);
					break;
				case UnaryOperatorType.Increment:
					outputFormatter.PrintToken(Tokens.Increment);
					break;
				case UnaryOperatorType.Minus:
					outputFormatter.PrintToken(Tokens.Minus);
					break;
				case UnaryOperatorType.Not:
					outputFormatter.PrintToken(Tokens.Not);
					break;
				case UnaryOperatorType.Plus:
					outputFormatter.PrintToken(Tokens.Plus);
					break;
				case UnaryOperatorType.PostDecrement:
					unaryOperatorExpression.Expression.AcceptVisitor(this, data);
					outputFormatter.PrintToken(Tokens.Decrement);
					return null;
				case UnaryOperatorType.PostIncrement:
					unaryOperatorExpression.Expression.AcceptVisitor(this, data);
					outputFormatter.PrintToken(Tokens.Increment);
					return null;
				case UnaryOperatorType.Star:
					outputFormatter.PrintToken(Tokens.Times);
					break;
				case UnaryOperatorType.BitWiseAnd:
					outputFormatter.PrintToken(Tokens.BitwiseAnd);
					break;
			}
			unaryOperatorExpression.Expression.AcceptVisitor(this, data);
			return null;
		}
		
		public override object Visit(UncheckedExpression uncheckedExpression, object data)
		{
			outputFormatter.PrintToken(Tokens.Unchecked);
			outputFormatter.PrintToken(Tokens.OpenParenthesis);
			uncheckedExpression.Expression.AcceptVisitor(this, data);
			outputFormatter.PrintToken(Tokens.CloseParenthesis);
			return null;
		}
#endregion
	}
}