prettyprintvisitor.cs

c#源代码

		public override object Visit(EventDeclaration eventDeclaration, object data)
		{
			VisitAttributes(eventDeclaration.Attributes, data);
			outputFormatter.Indent();
			VisitModifier(eventDeclaration.Modifier);
			outputFormatter.PrintToken(Tokens.Event);
			outputFormatter.Space();
			Visit(eventDeclaration.TypeReference, data);
			outputFormatter.Space();
			
			if (eventDeclaration.VariableDeclarators != null && eventDeclaration.VariableDeclarators.Count > 0) {
				AppendCommaSeparatedList(eventDeclaration.VariableDeclarators);
				outputFormatter.PrintToken(Tokens.Semicolon);
				outputFormatter.NewLine();
			} else {
				outputFormatter.PrintIdentifier(eventDeclaration.Name);
				if (eventDeclaration.AddRegion == null && eventDeclaration.RemoveRegion == null) {
					outputFormatter.PrintToken(Tokens.Semicolon);
					outputFormatter.NewLine();
				} else {
					outputFormatter.BeginBrace(this.prettyPrintOptions.PropertyBraceStyle);
					if (eventDeclaration.AddRegion != null) {
						eventDeclaration.AddRegion.AcceptVisitor(this, data);
					}
					if (eventDeclaration.RemoveRegion != null) {
						eventDeclaration.RemoveRegion.AcceptVisitor(this, data);
					}
					outputFormatter.EndBrace();
				}
			}
			return null;
		}
		
		public override object Visit(EventAddRegion addRegion, object data)
		{
			VisitAttributes(addRegion.Attributes, data);
			outputFormatter.Indent();
			outputFormatter.PrintIdentifier("add");
			if (addRegion.Block == null) {
				outputFormatter.PrintToken(Tokens.Semicolon);
				outputFormatter.NewLine();
			} else {
				outputFormatter.BeginBrace(this.prettyPrintOptions.PropertyGetBraceStyle);
				addRegion.Block.AcceptChildren(this, false);
				outputFormatter.EndBrace();
			}
			return null;
		}
		
		public override object Visit(EventRemoveRegion removeRegion, object data)
		{
			VisitAttributes(removeRegion.Attributes, data);
			outputFormatter.Indent();
			outputFormatter.PrintIdentifier("remove");
			if (removeRegion.Block == null) {
				outputFormatter.PrintToken(Tokens.Semicolon);
				outputFormatter.NewLine();
			} else {
				outputFormatter.BeginBrace(this.prettyPrintOptions.PropertySetBraceStyle);
				removeRegion.Block.AcceptChildren(this, false);
				outputFormatter.EndBrace();
			}
			return null;
		}
		
		public override object Visit(FieldDeclaration fieldDeclaration, object data)
		{
			VisitAttributes(fieldDeclaration.Attributes, data);
			outputFormatter.Indent();
			VisitModifier(fieldDeclaration.Modifier);
			Visit(fieldDeclaration.TypeReference, data);
			outputFormatter.Space();
			AppendCommaSeparatedList(fieldDeclaration.Fields);
			outputFormatter.PrintToken(Tokens.Semicolon);
			outputFormatter.NewLine();
			return null;
		}
		
		public override object Visit(ConstructorDeclaration constructorDeclaration, object data)
		{
			VisitAttributes(constructorDeclaration.Attributes, data);
			outputFormatter.Indent();
			VisitModifier(constructorDeclaration.Modifier);
			outputFormatter.PrintIdentifier(constructorDeclaration.Name);
			outputFormatter.PrintToken(Tokens.OpenParenthesis);
			AppendCommaSeparatedList(constructorDeclaration.Parameters);
			outputFormatter.PrintToken(Tokens.CloseParenthesis);
			
			if (constructorDeclaration.ConstructorInitializer != null) {
				outputFormatter.Space();
				outputFormatter.PrintToken(Tokens.Colon);
				outputFormatter.Space();
				if (constructorDeclaration.ConstructorInitializer.ConstructorInitializerType == ConstructorInitializerType.Base) {
					outputFormatter.PrintToken(Tokens.Base);
				} else {
					outputFormatter.PrintToken(Tokens.This);
				}
				outputFormatter.PrintToken(Tokens.OpenParenthesis);
				AppendCommaSeparatedList(constructorDeclaration.ConstructorInitializer.Arguments);
				outputFormatter.PrintToken(Tokens.CloseParenthesis);
			}
			
			outputFormatter.BeginBrace(this.prettyPrintOptions.ConstructorBraceStyle);
			constructorDeclaration.Body.AcceptChildren(this, data);
			outputFormatter.EndBrace();
			return null;
		}
		
		public override object Visit(DestructorDeclaration destructorDeclaration, object data)
		{
			VisitAttributes(destructorDeclaration.Attributes, data);
			outputFormatter.Indent();
			VisitModifier(destructorDeclaration.Modifier);
			outputFormatter.PrintToken(Tokens.BitwiseComplement);
			outputFormatter.PrintIdentifier(destructorDeclaration.Name);
			outputFormatter.PrintToken(Tokens.OpenParenthesis);
			outputFormatter.PrintToken(Tokens.CloseParenthesis);
			
			outputFormatter.BeginBrace(this.prettyPrintOptions.DestructorBraceStyle);
			destructorDeclaration.Body.AcceptChildren(this, data);
			outputFormatter.EndBrace();
			return null;
		}
		
		public override object Visit(MethodDeclaration methodDeclaration, object data)
		{
			VisitAttributes(methodDeclaration.Attributes, data);
			outputFormatter.Indent();
			VisitModifier(methodDeclaration.Modifier);
			Visit(methodDeclaration.TypeReference, data);
			outputFormatter.Space();
			outputFormatter.PrintIdentifier(methodDeclaration.Name);
			outputFormatter.PrintToken(Tokens.OpenParenthesis);
			AppendCommaSeparatedList(methodDeclaration.Parameters);
			outputFormatter.PrintToken(Tokens.CloseParenthesis);
			if (methodDeclaration.Body == null) {
				outputFormatter.PrintToken(Tokens.Semicolon);
				outputFormatter.NewLine();
			} else {
				outputFormatter.BeginBrace(this.prettyPrintOptions.MethodBraceStyle);
				methodDeclaration.Body.AcceptChildren(this, data);
				outputFormatter.EndBrace();
			}
			return null;
		}
		
		public override object Visit(IndexerDeclaration indexerDeclaration, object data)
		{
			VisitAttributes(indexerDeclaration.Attributes, data);
			outputFormatter.Indent();
			VisitModifier(indexerDeclaration.Modifier);
			Visit(indexerDeclaration.TypeReference, data);
			outputFormatter.Space();
			if (indexerDeclaration.NamespaceName != null && indexerDeclaration.NamespaceName.Length > 0) {
				outputFormatter.PrintIdentifier(indexerDeclaration.NamespaceName);
				outputFormatter.PrintToken(Tokens.Dot);
			}
			outputFormatter.PrintToken(Tokens.This);
			outputFormatter.PrintToken(Tokens.OpenSquareBracket);
			AppendCommaSeparatedList(indexerDeclaration.Parameters);
			outputFormatter.PrintToken(Tokens.CloseSquareBracket);
			outputFormatter.NewLine();
			outputFormatter.Indent();
			outputFormatter.PrintToken(Tokens.OpenCurlyBrace);
			outputFormatter.NewLine();
			++outputFormatter.IndentationLevel;
			if (indexerDeclaration.GetRegion != null) {
				indexerDeclaration.GetRegion.AcceptVisitor(this, data);
			}
			if (indexerDeclaration.SetRegion != null) {
				indexerDeclaration.SetRegion.AcceptVisitor(this, data);
			}
			--outputFormatter.IndentationLevel;
			outputFormatter.Indent();
			outputFormatter.PrintToken(Tokens.CloseCurlyBrace);
			outputFormatter.NewLine();
			return null;
		}
		
		public override object Visit(PropertyDeclaration propertyDeclaration, object data)
		{
			VisitAttributes(propertyDeclaration.Attributes, data);
			outputFormatter.Indent();
			VisitModifier(propertyDeclaration.Modifier);
			Visit(propertyDeclaration.TypeReference, data);
			outputFormatter.Space();
			outputFormatter.PrintIdentifier(propertyDeclaration.Name);
			outputFormatter.Space();
			outputFormatter.PrintToken(Tokens.OpenCurlyBrace);
			outputFormatter.NewLine();
			++outputFormatter.IndentationLevel;
			if (propertyDeclaration.GetRegion != null) {
				propertyDeclaration.GetRegion.AcceptVisitor(this, data);
			}
			if (propertyDeclaration.SetRegion != null) {
				propertyDeclaration.SetRegion.AcceptVisitor(this, data);
			}
			--outputFormatter.IndentationLevel;
			outputFormatter.Indent();
			outputFormatter.PrintToken(Tokens.CloseCurlyBrace);
			outputFormatter.NewLine();
			return null;
		}
		
		public override object Visit(PropertyGetRegion getRegion, object data)
		{
			this.VisitAttributes(getRegion.Attributes, data);
			outputFormatter.Indent();
			outputFormatter.PrintIdentifier("get");
			if (getRegion.Block == null) {
				outputFormatter.PrintToken(Tokens.Semicolon);
			} else {
				outputFormatter.Space();
				outputFormatter.PrintToken(Tokens.OpenCurlyBrace);
				outputFormatter.NewLine();
				++outputFormatter.IndentationLevel;
				getRegion.Block.AcceptChildren(this, false);
				--outputFormatter.IndentationLevel;
				outputFormatter.Indent();
				outputFormatter.PrintToken(Tokens.CloseCurlyBrace);
			}
			outputFormatter.NewLine();
			return null;
		}
		
		public override object Visit(PropertySetRegion setRegion, object data)
		{
			this.VisitAttributes(setRegion.Attributes, data);
			outputFormatter.Indent();
			outputFormatter.PrintIdentifier("set");
			if (setRegion.Block == null) {
				outputFormatter.PrintToken(Tokens.Semicolon);
			} else {
				outputFormatter.Space();
				outputFormatter.PrintToken(Tokens.OpenCurlyBrace);
				outputFormatter.NewLine();
				++outputFormatter.IndentationLevel;
				setRegion.Block.AcceptChildren(this, false);
				--outputFormatter.IndentationLevel;
				outputFormatter.Indent();
				outputFormatter.PrintToken(Tokens.CloseCurlyBrace);
			}
			outputFormatter.NewLine();
			return null;
		}
		
		public override object Visit(OperatorDeclaration operatorDeclaration, object data)
		{
			VisitAttributes(operatorDeclaration.Attributes, data);
			outputFormatter.Indent();
			VisitModifier(operatorDeclaration.Modifier);
			switch (operatorDeclaration.OpratorDeclarator.OperatorType) {
				case OperatorType.Explicit:
					outputFormatter.PrintToken(Tokens.Explicit);
					break;
				case OperatorType.Implicit:
					outputFormatter.PrintToken(Tokens.Implicit);
					break;
				default:
					Visit(operatorDeclaration.OpratorDeclarator.TypeReference, data);
					break;
			}
			outputFormatter.Space();
			outputFormatter.PrintToken(Tokens.Operator);
			outputFormatter.Space();
			if (!operatorDeclaration.OpratorDeclarator.IsConversion) {
				outputFormatter.PrintIdentifier(Tokens.GetTokenString(operatorDeclaration.OpratorDeclarator.OverloadOperatorToken));
			} else {
				Visit(operatorDeclaration.OpratorDeclarator.TypeReference, data);
			}
			
			outputFormatter.PrintToken(Tokens.OpenParenthesis);
			Visit(operatorDeclaration.OpratorDeclarator.FirstParameterType, data);
			outputFormatter.Space();
			outputFormatter.PrintIdentifier(operatorDeclaration.OpratorDeclarator.FirstParameterName);
			if (operatorDeclaration.OpratorDeclarator.OperatorType == OperatorType.Binary) {
				outputFormatter.PrintToken(Tokens.Comma);
				outputFormatter.Space();
				Visit(operatorDeclaration.OpratorDeclarator.SecondParameterType, data);
				outputFormatter.Space();
				outputFormatter.PrintIdentifier(operatorDeclaration.OpratorDeclarator.SecondParameterName);
			}
			outputFormatter.PrintToken(Tokens.CloseParenthesis);
			
			if (operatorDeclaration.Body == null) {
				outputFormatter.PrintToken(Tokens.Semicolon);
				outputFormatter.NewLine();
			} else {
				outputFormatter.NewLine();
				outputFormatter.Indent();
				outputFormatter.PrintToken(Tokens.OpenCurlyBrace);
				outputFormatter.NewLine();
				++outputFormatter.IndentationLevel;
				operatorDeclaration.Body.AcceptChildren(this, data);
				--outputFormatter.IndentationLevel;
				outputFormatter.Indent();
				outputFormatter.PrintToken(Tokens.CloseCurlyBrace);
				outputFormatter.NewLine();
			}
			return null;
		}
		
		public override object Visit(EmptyStatement emptyStatement, object data)
		{
			outputFormatter.Indent();
			outputFormatter.PrintToken(Tokens.Semicolon);
			outputFormatter.NewLine();
			return null;
		}
		public override object Visit(BlockStatement blockStatement, object data)
		{
			outputFormatter.Indent();
			outputFormatter.PrintToken(Tokens.OpenCurlyBrace);
			outputFormatter.NewLine();
			++outputFormatter.IndentationLevel;
			blockStatement.AcceptChildren(this, true);
			--outputFormatter.IndentationLevel;
			outputFormatter.Indent();
			outputFormatter.PrintToken(Tokens.CloseCurlyBrace);
			outputFormatter.NewLine();
			return null;
		}
		
		public override object Visit(ForStatement forStatement, object data)
		{
			outputFormatter.Indent();
			outputFormatter.PrintToken(Tokens.For);
			outputFormatter.Space();
			outputFormatter.PrintToken(Tokens.OpenParenthesis);
			outputFormatter.DoIndent = false;
			outputFormatter.DoNewLine = false;
			outputFormatter.EmitSemicolon = false;
			if (forStatement.Initializers != null && forStatement.Initializers.Count > 0) {
				for (int i = 0; i < forStatement.Initializers.Count; ++i) {
					INode node = (INode)forStatement.Initializers[i];
					node.AcceptVisitor(this, false);
					if (i + 1 < forStatement.Initializers.Count) {
						outputFormatter.PrintToken(Tokens.Comma);
					}
				}
			}
			outputFormatter.EmitSemicolon = true;
			outputFormatter.PrintToken(Tokens.Semicolon);
			outputFormatter.EmitSemicolon = false;
			if (forStatement.Condition != null) {
				outputFormatter.Space();
				forStatement.Condition.AcceptVisitor(this, data);
			}
			outputFormatter.EmitSemicolon = true;
			outputFormatter.PrintToken(Tokens.Semicolon);
			outputFormatter.EmitSemicolon = false;
			if (forStatement.Iterator != null && forStatement.Iterator.Count > 0) {
				outputFormatter.Space();
				for (int i = 0; i < forStatement.Iterator.Count; ++i) {
					INode node = (INode)forStatement.Iterator[i];
					node.AcceptVisitor(this, false);
					if (i + 1 < forStatement.Iterator.Count) {
						outputFormatter.PrintToken(Tokens.Comma);
					}
				}
			}
			outputFormatter.PrintToken(Tokens.CloseParenthesis);
			outputFormatter.EmitSemicolon = true;
			outputFormatter.DoNewLine     = true;
			outputFormatter.DoIndent      = true;
			outputFormatter.NewLine();
			++outputFormatter.IndentationLevel;
			if (forStatement.EmbeddedStatement is BlockStatement) {
				Visit((BlockStatement)forStatement.EmbeddedStatement, false);
			} else {
				forStatement.EmbeddedStatement.AcceptVisitor(this, data);
			}
			--outputFormatter.IndentationLevel;
			return null;
		}
		
		public override object Visit(ForeachStatement foreachStatement, object data)
		{
			outputFormatter.Indent();
			outputFormatter.PrintToken(Tokens.Foreach);
			outputFormatter.Space();
			outputFormatter.PrintToken(Tokens.OpenParenthesis);
			Visit(foreachStatement.TypeReference, data);
			outputFormatter.Space();
			outputFormatter.PrintIdentifier(foreachStatement.VariableName);
			outputFormatter.Space();
			outputFormatter.PrintToken(Tokens.In);
			outputFormatter.Space();
			foreachStatement.Expression.AcceptVisitor(this, data);
			outputFormatter.PrintToken(Tokens.CloseParenthesis);