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));
}
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 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> 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));
}
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);
}
}