public virtual InsertedUtokens GetUtokensBetweenCommentAndOwner(UnparsableAst owner, Comment comment, int commentIndex, int commentCount,
IEnumerable <Comment> commentsBetweenThisAndOwner)
{
if (comment.LineIndexDistanceFromOwner > 0)
{
int newLinesCount;
if (comment.Placement == CommentPlacement.OwnerLeft)
{
newLinesCount = comment.LineIndexDistanceFromOwner - (comment.TextLines.Length - 1);
Comment nextComment = commentsBetweenThisAndOwner.FirstOrDefault();
if (nextComment != null)
{
newLinesCount -= nextComment.LineIndexDistanceFromOwner;
}
}
else
{
newLinesCount = comment.LineIndexDistanceFromOwner;
Comment prevComment = commentsBetweenThisAndOwner.FirstOrDefault();
if (prevComment != null)
{
newLinesCount -= prevComment.LineIndexDistanceFromOwner + (prevComment.TextLines.Length - 1);
}
}
if (comment.Placement == CommentPlacement.OwnerLeft && comment.Kind == CommentKind.SingleLine)
{
/*
* We have already yielded a NewLine in Unparser.UnparseComment (see comment there),
* thus we have to yield one less "formatting" NewLine here.
* */
newLinesCount--;
}
return(new UtokenRepeat(UtokenWhitespace.NewLine(), newLinesCount));
}
else
{
return(UtokenWhitespace.Space());
}
}
public static IEnumerable <Utoken> ProcessControls(this IEnumerable <UtokenBase> utokens, IPostProcessHelper postProcessHelper)
{
var formatter = postProcessHelper.Formatter;
int indentLevel = 0;
int indentLevelForCurrentLine = 0;
Stack <int> storedIndentLevel = new Stack <int>();
bool allowWhitespaceBetweenUtokens = true;
UtokenBase prevNotControlUtoken = null;
/*
* We have to yield the indentation after consuming the last utoken (regardless of left-to-right or right-to-left unparse),
* so we use an extra null utoken.
*
* e.g.: In case of right-to-left unparse if utokens enumerable is not empty and the last processed utoken (which is the leftmost utoken)
* is not a line separator (which is the common case) then we didn't yielded the utokenindent for the last processed line
* (which is the topmost line), so we yield it now when processing the extra null utoken.
* */
foreach (UtokenBase utoken in utokens.Concat((UtokenBase)null))
{
if (IsControl(utoken))
{
UtokenControl utokenControl = (UtokenControl)utoken;
switch (utokenControl.kind)
{
case UtokenControl.Kind.IncreaseIndentLevel:
indentLevel++;
break;
case UtokenControl.Kind.DecreaseIndentLevel:
indentLevel--;
break;
case UtokenControl.Kind.SetIndentLevelToNone:
storedIndentLevel.Push(indentLevel);
indentLevel = 0;
break;
case UtokenControl.Kind.RestoreIndentLevel:
indentLevel = storedIndentLevel.Pop();
break;
case UtokenControl.Kind.NoWhitespace:
allowWhitespaceBetweenUtokens = false;
break;
default:
throw new InvalidOperationException(string.Format("Unknown UtokenControl '{0}'", utokenControl.kind));
}
}
else if (utoken == UtokenValueControl.NoWhitespace)
{
allowWhitespaceBetweenUtokens = false;
}
else
{
if (postProcessHelper.Direction == Unparser.Direction.RightToLeft && IsLineSeparator(utoken) && (formatter.IndentEmptyLines || !IsLineSeparator(prevNotControlUtoken)))
{
yield return(new UtokenIndent(indentLevelForCurrentLine));
}
indentLevelForCurrentLine = indentLevel;
if (postProcessHelper.Direction == Unparser.Direction.LeftToRight && IsLineSeparator(prevNotControlUtoken) && (formatter.IndentEmptyLines || !IsLineSeparator(utoken)))
{
yield return(new UtokenIndent(indentLevelForCurrentLine));
}
if (allowWhitespaceBetweenUtokens && prevNotControlUtoken != null && utoken != null && !IsWhitespace(prevNotControlUtoken) && !IsWhitespace(utoken))
{
yield return(UtokenWhitespace.WhiteSpaceBetweenUtokens());
}
if (utoken != null)
{
yield return((Utoken)utoken);
}
allowWhitespaceBetweenUtokens = true;
prevNotControlUtoken = utoken;
}
}
}
public static UtokenInsert NewLine()
{
return(UtokenWhitespace.NewLine());
}
public static UtokenInsert Tab()
{
return(UtokenWhitespace.Tab());
}
public static UtokenInsert Space()
{
return(UtokenWhitespace.Space());
}
public static UtokenInsert EmptyLine()
{
return(UtokenWhitespace.EmptyLine());
}