public override Tuple <IParseTree, int> VisitLexerRule([NotNull] AbstractGrammarParser.LexerRuleContext context)
{
if (context.name == null)
{
return(null);
}
if (ParseTrees.GetTerminalNodeType(targetElement) == GrammarParser.AT)
{
return(Tuple.Create <IParseTree, int>(context, 0));
}
if (context.COLON() != null)
{
if (ParseTrees.StartsBeforeStartOf(context.COLON(), targetElement))
{
switch (ParseTrees.GetTerminalNodeType(targetElement))
{
case GrammarParser.SEMI:
case GrammarParser.OR:
return(Tuple.Create <IParseTree, int>(context.COLON(), 0));
default:
return(Tuple.Create <IParseTree, int>(context.COLON(), _indentSize));
}
}
}
return(Tuple.Create <IParseTree, int>(context, _indentSize));
}
public override void EnterTokensSpec([NotNull] AbstractGrammarParser.TokensSpecContext context)
{
foreach (GrammarParser.IdContext id in context.id())
{
AddNavigationTarget(id, ParseTrees.GetStartNode(id), _navigationSource._lexerRuleNavigationType, _navigationSource._lexerRuleGlyph);
}
}
public override Tuple <IParseTree, int> VisitActionBlock([NotNull] AbstractGrammarParser.ActionBlockContext context)
{
if (context.ChildCount == 0 || targetElement == context.GetChild(0))
{
return(null);
}
if (ParseTrees.GetTerminalNodeType(targetElement) == GrammarParser.RBRACE)
{
return(Tuple.Create <IParseTree, int>(context, 0));
}
// align to the previous element
for (int i = priorSiblings.Count - 2; i >= 0; i--)
{
IParseTree sibling = priorSiblings[i];
// stop at the first id rule, index 0 is the BEGIN_ACTION terminal itself
if (i == 1 || ParseTrees.ElementStartsLine(sibling))
{
return(Tuple.Create(sibling, 0));
}
}
return(Tuple.Create <IParseTree, int>(context, _indentSize));
}
private Tuple <IParseTree, int> VisitElements()
{
// the non-terminals under these rules are straightforward
int firstElementIndex = -1;
for (int i = 0; i < priorSiblings.Count; i++)
{
IParseTree sibling = priorSiblings[i];
if (sibling is IRuleNode)
{
firstElementIndex = i;
break;
}
}
for (int i = priorSiblings.Count - 2; i >= 0; i--)
{
IParseTree sibling = priorSiblings[i];
if (!(sibling is IRuleNode))
{
continue;
}
if (i == firstElementIndex || ParseTrees.ElementStartsLine(sibling))
{
return(Tuple.Create(sibling, 0));
}
}
// handle at the parent
return(null);
}
public override Tuple <IParseTree, int> VisitLabeledAlt([NotNull] AbstractGrammarParser.LabeledAltContext context)
{
Debug.Assert(ParseTrees.GetTerminalNodeType(targetElement) == GrammarParser.POUND);
if (context.alternative() == null)
{
return(null);
}
return(Tuple.Create <IParseTree, int>(context.alternative(), 0));
}
public override Tuple <IParseTree, int> VisitLexerAlt([NotNull] AbstractGrammarParser.LexerAltContext context)
{
Debug.Assert(context.lexerCommands() != null && ParseTrees.IsAncestorOf(context.lexerCommands(), targetElement));
if (context.lexerElements() == null)
{
return(null);
}
return(Tuple.Create <IParseTree, int>(context.lexerElements(), 0));
}
private void ExitAnchor(ParserRuleContext context, int anchorId)
{
int start = _anchorPositions.Pop();
Interval sourceInterval = ParseTrees.GetSourceInterval(context);
int stop = sourceInterval.b + 1;
SpanTrackingMode trackingMode = context.Stop != null ? SpanTrackingMode.EdgeExclusive : SpanTrackingMode.EdgePositive;
if (stop >= start)
{
_anchors.Add(CreateAnchor(context, start, stop, trackingMode, anchorId));
}
}
public override Tuple <IParseTree, int> VisitRules([NotNull] AbstractGrammarParser.RulesContext context)
{
for (int i = priorSiblings.Count - 2; i >= 0; i--)
{
IParseTree sibling = priorSiblings[i];
if (i == 0 || ParseTrees.ElementStartsLine(sibling))
{
return(Tuple.Create(sibling, 0));
}
}
return(null);
}
public override Tuple <IParseTree, int> VisitOptionsSpec([NotNull] AbstractGrammarParser.OptionsSpecContext context)
{
// use previous option if any, otherwise use the block.
// special handling for closing }
if (targetElement == context.RBRACE())
{
return(Tuple.Create <IParseTree, int>(context, 0));
}
int firstOptionIndex = -1;
for (int i = 0; i < priorSiblings.Count; i++)
{
IRuleNode sibling = priorSiblings[i] as IRuleNode;
if (sibling == null)
{
continue;
}
if (sibling.RuleContext.RuleIndex == GrammarParser.RULE_option)
{
firstOptionIndex = i;
break;
}
}
bool semi = ParseTrees.GetTerminalNodeType(targetElement) == GrammarParser.SEMI;
for (int i = priorSiblings.Count - 2; i >= 0; i--)
{
IRuleNode sibling = priorSiblings[i] as IRuleNode;
if (sibling == null)
{
continue;
}
RuleContext ruleContext = sibling.RuleContext;
if (ruleContext.RuleIndex == GrammarParser.RULE_option)
{
if (i == firstOptionIndex || ParseTrees.ElementStartsLine(sibling))
{
return(Tuple.Create <IParseTree, int>(sibling, semi ? _indentSize : 0));
}
}
}
return(Tuple.Create <IParseTree, int>(context, _indentSize));
}
protected virtual ITerminalNode FindFirstNodeAfterOffset(IParseTree parseTree, int offset)
{
ITerminalNode lastNode = ParseTrees.GetStopNode(parseTree);
if (lastNode == null)
{
return(null);
}
ICaretToken caretToken = lastNode.Symbol as ICaretToken;
if (caretToken != null)
{
throw new NotImplementedException();
}
else if (lastNode.Symbol.StartIndex < offset)
{
return(null);
}
lastNode = parseTree as ITerminalNode;
if (lastNode != null)
{
return(lastNode);
}
for (int i = 0; i < parseTree.ChildCount; i++)
{
ITerminalNode node = FindFirstNodeAfterOffset(parseTree.GetChild(i), offset);
if (node != null)
{
return(node);
}
}
return(null);
}
protected virtual int?GetIndent(KeyValuePair <RuleContext, CaretReachedException> parseTree, IParseTree firstNodeOnLine, SnapshotPoint lineStart)
{
for (IParseTree ancestor = firstNodeOnLine; ancestor != null; ancestor = ancestor.Parent)
{
AlignmentRequirements requirements = GetAlignmentRequirement(parseTree, firstNodeOnLine, ancestor);
if ((requirements & AlignmentRequirements.UseAncestor) != 0)
{
continue;
}
if ((requirements & AlignmentRequirements.IgnoreTree) != 0)
{
return(null);
}
IList <IParseTree> siblings = null;
if ((requirements & AlignmentRequirements.PriorSibling) != 0)
{
int childCount = ancestor.ChildCount;
siblings = new List <IParseTree>(childCount);
for (int i = 0; i < childCount; i++)
{
IParseTree child = ancestor.GetChild(i);
siblings.Add(child);
if (ParseTrees.IsAncestorOf(child, firstNodeOnLine))
{
break;
}
}
}
Tuple <IParseTree, int> alignmentElement = GetAlignmentElement(parseTree, firstNodeOnLine, ancestor, siblings);
if (alignmentElement == null)
{
continue;
}
IToken startToken = ParseTrees.GetStartSymbol(alignmentElement.Item1);
string beginningOfLineText = startToken.TokenSource.InputStream.GetText(new Interval(startToken.StartIndex - startToken.Column, startToken.StartIndex - 1));
int elementIndent = 0;
for (int i = 0; i < beginningOfLineText.Length; i++)
{
if (beginningOfLineText[i] == '\t')
{
elementIndent += TabSize;
elementIndent -= (elementIndent % TabSize);
}
else
{
elementIndent++;
}
}
var diagnosticsPane = DiagnosticsPane;
if (diagnosticsPane != null)
{
if (ParseTrees.GetStartSymbol(firstNodeOnLine) == startToken)
{
diagnosticsPane.WriteLine("Attempting to indent a line relative to an element on that line.");
}
diagnosticsPane.WriteLine(string.Format("Indent {0} relative to {1} (offset {2}) => {3}", firstNodeOnLine, alignmentElement.Item1, alignmentElement.Item2, elementIndent + alignmentElement.Item2));
}
return(elementIndent + alignmentElement.Item2);
}
return(null);
}
private Tuple <IParseTree, int> VisitGenericBlock(ParserRuleContext container)
{
if (targetElement == ParseTrees.GetStartNode(container))
{
return(null);
}
if (ParseTrees.GetTerminalNodeType(targetElement) == GrammarParser.RPAREN)
{
return(Tuple.Create <IParseTree, int>(container, 0));
}
// OR lines up with previous OR
bool orNode = ParseTrees.GetTerminalNodeType(targetElement) == GrammarParser.OR;
if (orNode)
{
for (int i = priorSiblings.Count - 2; i >= 0; i--)
{
ITerminalNode sibling = priorSiblings[i] as ITerminalNode;
if (sibling == null)
{
continue;
}
if (i == 0 || ParseTrees.ElementStartsLine(sibling))
{
return(Tuple.Create <IParseTree, int>(sibling, 0));
}
}
if (ParseTrees.GetTerminalNodeType(ParseTrees.GetStartNode(container)) != GrammarParser.LPAREN)
{
// handle at the parent so it aligns at the (
return(null);
}
return(Tuple.Create <IParseTree, int>(container, 0));
}
// the non-terminals under these rules are straightforward
int firstRuleIndex = -1;
for (int i = 0; i < priorSiblings.Count; i++)
{
IParseTree sibling = priorSiblings[i];
if (sibling is IRuleNode)
{
firstRuleIndex = i;
break;
}
}
for (int i = priorSiblings.Count - 2; i >= 0; i--)
{
IRuleNode sibling = priorSiblings[i] as IRuleNode;
if (sibling == null)
{
continue;
}
if (i == firstRuleIndex || ParseTrees.ElementStartsLine(sibling))
{
return(Tuple.Create <IParseTree, int>(sibling, 0));
}
}
// handle at the parent
return(null);
}
protected override AlignmentRequirements GetAlignmentRequirement(KeyValuePair <RuleContext, CaretReachedException> parseTree, IParseTree targetElement, IParseTree ancestor)
{
if (ancestor == targetElement && !(targetElement is ITerminalNode))
{
// special handling for predicted tokens that don't actually exist yet
CaretReachedException ex = parseTree.Value;
if (ex != null && ex.Transitions != null)
{
bool validTransition = false;
bool selfTransition = false;
// examine transitions for predictions that don't actually exist yet
foreach (KeyValuePair <ATNConfig, IList <Transition> > entry in ex.Transitions)
{
if (entry.Value == null)
{
continue;
}
foreach (Transition transition in entry.Value)
{
IntervalSet label = transition.Label;
if (label == null)
{
continue;
}
bool containsInvalid =
label.Contains(GrammarParser.OR) ||
label.Contains(GrammarParser.RPAREN) ||
label.Contains(GrammarParser.RBRACE) ||
label.Contains(GrammarParser.END_ACTION) ||
label.Contains(GrammarParser.END_ARG_ACTION) ||
label.Contains(GrammarParser.OPTIONS) ||
label.Contains(GrammarParser.AT) ||
label.Contains(GrammarParser.ASSIGN) ||
label.Contains(GrammarParser.SEMI) ||
label.Contains(GrammarParser.COMMA) ||
label.Contains(GrammarParser.MODE) ||
label.Contains(GrammarParser.RARROW) ||
label.Contains(GrammarParser.POUND);
bool containsInvalidSelf =
label.Contains(GrammarParser.LPAREN) ||
label.Contains(GrammarParser.BEGIN_ACTION) ||
label.Contains(GrammarParser.BEGIN_ARG_ACTION);
if (transition is NotSetTransition)
{
containsInvalid = !containsInvalid;
containsInvalidSelf = !containsInvalidSelf;
}
validTransition |= !containsInvalid;
selfTransition |= !containsInvalidSelf;
}
}
if (!validTransition)
{
return(AlignmentRequirements.IgnoreTree);
}
else if (!selfTransition)
{
return(AlignmentRequirements.UseAncestor);
}
}
}
IRuleNode ruleNode = ancestor as IRuleNode;
if (ruleNode == null)
{
return(AlignmentRequirements.UseAncestor);
}
RuleContext ruleContext = ruleNode.RuleContext;
switch (ruleContext.RuleIndex)
{
case GrammarParser.RULE_parserRuleSpec:
if (((GrammarParser.ParserRuleSpecContext)ruleContext).RULE_REF() == null)
{
return(AlignmentRequirements.UseAncestor);
}
return(AlignmentRequirements.PriorSibling);
case GrammarParser.RULE_lexerRule:
if (((GrammarParser.LexerRuleContext)ruleContext).TOKEN_REF() == null)
{
return(AlignmentRequirements.UseAncestor);
}
return(AlignmentRequirements.PriorSibling);
case GrammarParser.RULE_ruleAltList:
case GrammarParser.RULE_lexerAltList:
case GrammarParser.RULE_altList:
case GrammarParser.RULE_blockSet:
case GrammarParser.RULE_lexerBlock:
case GrammarParser.RULE_block:
case GrammarParser.RULE_optionsSpec:
case GrammarParser.RULE_tokensSpec:
case GrammarParser.RULE_channelsSpec:
case GrammarParser.RULE_modeSpec:
case GrammarParser.RULE_delegateGrammars:
case GrammarParser.RULE_actionBlock:
case GrammarParser.RULE_elements:
case GrammarParser.RULE_lexerElements:
case GrammarParser.RULE_rules:
//case GrammarParser.RULE_lexerCommands:
return(AlignmentRequirements.PriorSibling);
case GrammarParser.RULE_lexerAlt:
GrammarParser.LexerAltContext lexerAltContext = ParseTrees.GetTypedRuleContext <GrammarParser.LexerAltContext>(ancestor);
if (lexerAltContext != null && lexerAltContext.lexerCommands() != null && ParseTrees.IsAncestorOf(lexerAltContext.lexerCommands(), targetElement))
{
return(AlignmentRequirements.PriorSibling);
}
else
{
return(AlignmentRequirements.UseAncestor);
}
case GrammarParser.RULE_labeledAlt:
if (ParseTrees.GetTerminalNodeType(targetElement) == GrammarParser.POUND)
{
return(AlignmentRequirements.PriorSibling);
}
else
{
return(AlignmentRequirements.UseAncestor);
}
case GrammarParser.RULE_delegateGrammar:
return(AlignmentRequirements.None);
default:
return(AlignmentRequirements.UseAncestor);
}
}
