private DirectiveTriviaSyntax GetPreviousPossiblyRelatedDirective()
{
DirectiveTriviaSyntax d = this;
while (d != null)
{
d = d.GetPreviousDirective();
if (d != null)
{
// skip matched sets
switch (d.Kind)
{
case SyntaxKind.EndIfDirectiveTrivia:
while (d != null && d.Kind != SyntaxKind.IfDirectiveTrivia)
{
d = d.GetPreviousRelatedDirective();
}
continue;
case SyntaxKind.EndRegionDirectiveTrivia:
while (d != null && d.Kind != SyntaxKind.RegionDirectiveTrivia)
{
d = d.GetPreviousRelatedDirective();
}
continue;
}
}
return(d);
}
return(null);
}
private void ClassifyPreprocessorDirective(DirectiveTriviaSyntax node)
{
if (!_textSpan.OverlapsWith(node.Span))
{
return;
}
switch (node.Kind())
{
case SyntaxKind.IfDirectiveTrivia:
ClassifyIfDirective((IfDirectiveTriviaSyntax)node);
break;
case SyntaxKind.ElifDirectiveTrivia:
ClassifyElifDirective((ElifDirectiveTriviaSyntax)node);
break;
case SyntaxKind.ElseDirectiveTrivia:
ClassifyElseDirective((ElseDirectiveTriviaSyntax)node);
break;
case SyntaxKind.EndIfDirectiveTrivia:
ClassifyEndIfDirective((EndIfDirectiveTriviaSyntax)node);
break;
case SyntaxKind.RegionDirectiveTrivia:
ClassifyRegionDirective((RegionDirectiveTriviaSyntax)node);
break;
case SyntaxKind.EndRegionDirectiveTrivia:
ClassifyEndRegionDirective((EndRegionDirectiveTriviaSyntax)node);
break;
case SyntaxKind.ErrorDirectiveTrivia:
ClassifyErrorDirective((ErrorDirectiveTriviaSyntax)node);
break;
case SyntaxKind.WarningDirectiveTrivia:
ClassifyWarningDirective((WarningDirectiveTriviaSyntax)node);
break;
case SyntaxKind.BadDirectiveTrivia:
ClassifyBadDirective((BadDirectiveTriviaSyntax)node);
break;
case SyntaxKind.DefineDirectiveTrivia:
ClassifyDefineDirective((DefineDirectiveTriviaSyntax)node);
break;
case SyntaxKind.UndefDirectiveTrivia:
ClassifyUndefDirective((UndefDirectiveTriviaSyntax)node);
break;
case SyntaxKind.LineDirectiveTrivia:
ClassifyLineDirective((LineDirectiveTriviaSyntax)node);
break;
case SyntaxKind.PragmaChecksumDirectiveTrivia:
ClassifyPragmaChecksumDirective((PragmaChecksumDirectiveTriviaSyntax)node);
break;
case SyntaxKind.PragmaWarningDirectiveTrivia:
ClassifyPragmaWarningDirective((PragmaWarningDirectiveTriviaSyntax)node);
break;
case SyntaxKind.ReferenceDirectiveTrivia:
ClassifyReferenceDirective((ReferenceDirectiveTriviaSyntax)node);
break;
case SyntaxKind.LoadDirectiveTrivia:
ClassifyLoadDirective((LoadDirectiveTriviaSyntax)node);
break;
}
}
private static bool IsActiveConditionalDirective(DirectiveTriviaSyntax directive)
{
switch (directive.Kind())
{
case SyntaxKind.DefineDirectiveTrivia:
return ((DefineDirectiveTriviaSyntax)directive).IsActive;
case SyntaxKind.UndefDirectiveTrivia:
return ((UndefDirectiveTriviaSyntax)directive).IsActive;
default:
return false;
}
}
private static bool IsActiveConditionalDirective(DirectiveTriviaSyntax directive)
{
switch (directive.Kind())
{
case SyntaxKind.DefineDirectiveTrivia:
return(((DefineDirectiveTriviaSyntax)directive).IsActive);
case SyntaxKind.UndefDirectiveTrivia:
return(((UndefDirectiveTriviaSyntax)directive).IsActive);
default:
return(false);
}
}
private static bool HasRelatedDirectives(DirectiveTriviaSyntax directive)
{
switch (directive.Kind())
{
case SyntaxKind.IfDirectiveTrivia:
case SyntaxKind.ElseDirectiveTrivia:
case SyntaxKind.ElifDirectiveTrivia:
case SyntaxKind.EndIfDirectiveTrivia:
case SyntaxKind.RegionDirectiveTrivia:
case SyntaxKind.EndRegionDirectiveTrivia:
return(true);
default:
return(false);
}
}
private void ClassifyDirectiveTrivia(DirectiveTriviaSyntax node, bool allowComments = true)
{
var lastToken = node.EndOfDirectiveToken.GetPreviousToken(includeSkipped: false);
foreach (var trivia in lastToken.TrailingTrivia)
{
// skip initial whitespace
if (trivia.CSharpKind() == SyntaxKind.WhitespaceTrivia)
{
continue;
}
ClassifyPreprocessorTrivia(trivia, allowComments);
}
foreach (var trivia in node.EndOfDirectiveToken.LeadingTrivia)
{
ClassifyPreprocessorTrivia(trivia, allowComments);
}
}
private void TestShebang(DirectiveTriviaSyntax directive, string expectedSkippedText)
{
var shebang = (ShebangDirectiveTriviaSyntax)directive;
Assert.False(shebang.HasStructuredTrivia);
Assert.Equal(SyntaxKind.HashToken, shebang.HashToken.Kind());
Assert.Equal(SyntaxKind.ExclamationToken, shebang.ExclamationToken.Kind());
var endOfDirective = shebang.EndOfDirectiveToken;
Assert.Equal(SyntaxKind.EndOfDirectiveToken, endOfDirective.Kind());
Assert.Equal(0, endOfDirective.Span.Length);
var skippedText = endOfDirective.LeadingTrivia.Single();
Assert.Equal(SyntaxKind.PreprocessingMessageTrivia, skippedText.Kind());
Assert.Equal(expectedSkippedText, skippedText.ToString());
}
private void FinishIf(DirectiveTriviaSyntax directiveOpt)
{
var condDirectives = new List<DirectiveTriviaSyntax>();
if (directiveOpt != null)
{
condDirectives.Add(directiveOpt);
}
while (!_ifStack.IsEmpty())
{
var poppedDirective = _ifStack.Pop();
condDirectives.Add(poppedDirective);
if (poppedDirective.Kind() == SyntaxKind.IfDirectiveTrivia)
{
break;
}
}
condDirectives.Sort((n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));
foreach (var cond in condDirectives)
{
_conditionalMap.Add(cond, condDirectives);
}
// #If should be the first one in sorted order
var ifDirective = condDirectives.First();
Contract.Assert(
ifDirective.Kind() == SyntaxKind.IfDirectiveTrivia ||
ifDirective.Kind() == SyntaxKind.ElifDirectiveTrivia ||
ifDirective.Kind() == SyntaxKind.ElseDirectiveTrivia);
if (directiveOpt != null)
{
_directiveMap.Add(directiveOpt, ifDirective);
_directiveMap.Add(ifDirective, directiveOpt);
}
}
private void HandleElseDirective(DirectiveTriviaSyntax directive)
{
ifStack.Push(directive);
}
private Tristate EvaluateDirectiveExpression(DirectiveTriviaSyntax directive, Tristate previousRegionState)
{
switch (directive.Kind())
{
case SyntaxKind.IfDirectiveTrivia:
return EvaluateExpression(((IfDirectiveTriviaSyntax)directive).Condition);
case SyntaxKind.ElifDirectiveTrivia:
Tristate result = EvaluateExpression(((ElifDirectiveTriviaSyntax)directive).Condition);
return !previousRegionState & result;
case SyntaxKind.ElseDirectiveTrivia:
return !previousRegionState;
default:
Debug.Assert(false);
return Tristate.Varying;
}
}
private void HandleEndRegionDirective(DirectiveTriviaSyntax directive)
{
if (regionStack.IsEmpty())
{
return;
}
var previousDirective = regionStack.Pop();
directiveMap.Add(directive, previousDirective);
directiveMap.Add(previousDirective, directive);
}
private void HandleRegionDirective(DirectiveTriviaSyntax directive)
{
regionStack.Push(directive);
}
private static string GetReplacementText(DirectiveTriviaSyntax startDirective, DirectiveTriviaSyntax endDirective)
{
if (startDirective.Kind() == SyntaxKind.IfDirectiveTrivia && endDirective.Kind() == SyntaxKind.ElifDirectiveTrivia)
{
var elifDirective = (ElifDirectiveTriviaSyntax)endDirective;
var elifKeyword = elifDirective.ElifKeyword;
var newIfDirective = SyntaxFactory.IfDirectiveTrivia(
elifDirective.HashToken,
SyntaxFactory.Token(elifKeyword.LeadingTrivia, SyntaxKind.IfKeyword, "if", "if", elifKeyword.TrailingTrivia),
elifDirective.Condition,
elifDirective.EndOfDirectiveToken,
elifDirective.IsActive,
elifDirective.BranchTaken,
elifDirective.ConditionValue);
return newIfDirective.ToFullString();
}
else
{
return endDirective.ToFullString();
}
}
private void HandleEndIfDirective(DirectiveTriviaSyntax directive)
{
if (ifStack.IsEmpty())
{
return;
}
var condDirectives = new List<DirectiveTriviaSyntax>();
condDirectives.Add(directive);
while (!ifStack.IsEmpty())
{
var poppedDirective = ifStack.Pop();
condDirectives.Add(poppedDirective);
if (poppedDirective.CSharpKind() == SyntaxKind.IfDirectiveTrivia)
{
break;
}
}
condDirectives.Sort((n1, n2) => n1.SpanStart.CompareTo(n2.SpanStart));
foreach (var cond in condDirectives)
{
conditionalMap.Add(cond, condDirectives);
}
// #If should be the first one in sorted order
var ifDirective = condDirectives.First();
Contract.Assert(
ifDirective.CSharpKind() == SyntaxKind.IfDirectiveTrivia ||
ifDirective.CSharpKind() == SyntaxKind.ElifDirectiveTrivia ||
ifDirective.CSharpKind() == SyntaxKind.ElseDirectiveTrivia);
directiveMap.Add(directive, ifDirective);
directiveMap.Add(ifDirective, directive);
}
private void HandleIfDirective(DirectiveTriviaSyntax directive)
{
_ifStack.Push(directive);
}
private void HandleEndIfDirective(DirectiveTriviaSyntax directive)
{
if (_ifStack.IsEmpty())
{
return;
}
FinishIf(directive);
}
private DirectiveTriviaSyntax GetPreviousRelatedDirective()
{
DirectiveTriviaSyntax d = this;
switch (d.Kind)
{
case SyntaxKind.EndIfDirectiveTrivia:
while (d != null)
{
switch (d.Kind)
{
case SyntaxKind.IfDirectiveTrivia:
case SyntaxKind.ElifDirectiveTrivia:
case SyntaxKind.ElseDirectiveTrivia:
return(d);
}
d = d.GetPreviousPossiblyRelatedDirective();
}
break;
case SyntaxKind.ElifDirectiveTrivia:
while (d != null)
{
if (d.Kind == SyntaxKind.IfDirectiveTrivia)
{
return(d);
}
d = d.GetPreviousPossiblyRelatedDirective();
}
break;
case SyntaxKind.ElseDirectiveTrivia:
while (d != null)
{
switch (d.Kind)
{
case SyntaxKind.IfDirectiveTrivia:
case SyntaxKind.ElifDirectiveTrivia:
return(d);
}
d = d.GetPreviousPossiblyRelatedDirective();
}
break;
case SyntaxKind.EndRegionDirectiveTrivia:
while (d != null)
{
if (d.Kind == SyntaxKind.RegionDirectiveTrivia)
{
return(d);
}
d = d.GetPreviousPossiblyRelatedDirective();
}
break;
}
return(null);
}
private static bool IsBranchingDirective(DirectiveTriviaSyntax directive)
{
switch (directive.Kind())
{
case SyntaxKind.IfDirectiveTrivia:
case SyntaxKind.ElifDirectiveTrivia:
case SyntaxKind.ElseDirectiveTrivia:
return true;
default:
return false;
}
}
private DirectiveTriviaSyntax SimplifyDirectiveExpression(DirectiveTriviaSyntax directive)
{
switch (directive.Kind())
{
case SyntaxKind.IfDirectiveTrivia:
{
var ifDirective = (IfDirectiveTriviaSyntax)directive;
return ifDirective.WithCondition((ExpressionSyntax)ifDirective.Condition.Accept(_expressionSimplifier));
}
case SyntaxKind.ElifDirectiveTrivia:
{
var elifDirective = (ElifDirectiveTriviaSyntax)directive;
return elifDirective.WithCondition((ExpressionSyntax)elifDirective.Condition.Accept(_expressionSimplifier));
}
case SyntaxKind.ElseDirectiveTrivia:
return directive;
default:
Debug.Assert(false);
return null;
}
}
