private void UpdateTags(AntlrParseResultEventArgs antlrParseResultArgs)
{
List <ITagSpan <IOutliningRegionTag> > outliningRegions = null;
IAstRuleReturnScope parseResult = antlrParseResultArgs.Result as IAstRuleReturnScope;
if (parseResult != null)
{
outliningRegions = AlloyOutliningTaggerWalker.ExtractOutliningRegions(parseResult, antlrParseResultArgs.Tokens, _provider, antlrParseResultArgs.Snapshot);
}
this._outliningRegions = outliningRegions ?? new List <ITagSpan <IOutliningRegionTag> >();
OnTagsChanged(new SnapshotSpanEventArgs(new SnapshotSpan(antlrParseResultArgs.Snapshot, new Span(0, antlrParseResultArgs.Snapshot.Length))));
}
private void UpdateNavigationTargets(AntlrParseResultEventArgs antlrParseResultArgs)
{
Contract.Requires(antlrParseResultArgs != null);
List <IEditorNavigationTarget> navigationTargets = null;
if (antlrParseResultArgs != null)
{
IAstRuleReturnScope parseResult = antlrParseResultArgs.Result as IAstRuleReturnScope;
if (parseResult != null)
{
navigationTargets = AlloyEditorNavigationSourceWalker.ExtractNavigationTargets(parseResult, antlrParseResultArgs.Tokens, _provider, antlrParseResultArgs.Snapshot);
}
}
this._navigationTargets = navigationTargets ?? new List <IEditorNavigationTarget>();
OnNavigationTargetsChanged(EventArgs.Empty);
}
private void ExtractRuleSpans()
{
Dictionary <string, KeyValuePair <ITrackingSpan, ITrackingPoint> > rules = new Dictionary <string, KeyValuePair <ITrackingSpan, ITrackingPoint> >();
var antlrParseResultArgs = PreviousParseResult;
if (antlrParseResultArgs != null)
{
IAstRuleReturnScope resultArgs = antlrParseResultArgs.Result as IAstRuleReturnScope;
var result = resultArgs != null ? resultArgs.Tree as CommonTree : null;
if (result != null)
{
foreach (CommonTree child in result.Children)
{
if (child == null || string.IsNullOrEmpty(child.Text))
{
continue;
}
if (child.Text == "rule" && child.ChildCount > 0)
{
var ruleName = child.GetChild(0).Text;
if (string.IsNullOrEmpty(ruleName))
{
continue;
}
if (ruleName == "Tokens")
{
continue;
}
IToken startToken = antlrParseResultArgs.Tokens[child.TokenStartIndex];
IToken stopToken = antlrParseResultArgs.Tokens[child.TokenStopIndex];
Span span = new Span(startToken.StartIndex, stopToken.StopIndex - startToken.StartIndex + 1);
ITrackingSpan trackingSpan = antlrParseResultArgs.Snapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeNegative);
ITrackingPoint trackingPoint = antlrParseResultArgs.Snapshot.CreateTrackingPoint(((CommonTree)child.GetChild(0)).Token.StartIndex, PointTrackingMode.Negative);
rules[ruleName] = new KeyValuePair <ITrackingSpan, ITrackingPoint>(trackingSpan, trackingPoint);
}
else if (child.Text.StartsWith("tokens"))
{
foreach (CommonTree tokenChild in child.Children)
{
if (tokenChild.Text == "=" && tokenChild.ChildCount == 2)
{
var ruleName = tokenChild.GetChild(0).Text;
if (string.IsNullOrEmpty(ruleName))
{
continue;
}
IToken startToken = antlrParseResultArgs.Tokens[tokenChild.TokenStartIndex];
IToken stopToken = antlrParseResultArgs.Tokens[tokenChild.TokenStopIndex];
Span span = new Span(startToken.StartIndex, stopToken.StopIndex - startToken.StartIndex + 1);
ITrackingSpan trackingSpan = antlrParseResultArgs.Snapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeNegative);
ITrackingPoint trackingPoint = antlrParseResultArgs.Snapshot.CreateTrackingPoint(((CommonTree)tokenChild.GetChild(0)).Token.StartIndex, PointTrackingMode.Negative);
rules[ruleName] = new KeyValuePair <ITrackingSpan, ITrackingPoint>(trackingSpan, trackingPoint);
}
else if (tokenChild.ChildCount == 0)
{
var ruleName = tokenChild.Text;
if (string.IsNullOrEmpty(ruleName))
{
continue;
}
IToken startToken = antlrParseResultArgs.Tokens[tokenChild.TokenStartIndex];
IToken stopToken = antlrParseResultArgs.Tokens[tokenChild.TokenStopIndex];
Span span = new Span(startToken.StartIndex, stopToken.StopIndex - startToken.StartIndex + 1);
ITrackingSpan trackingSpan = antlrParseResultArgs.Snapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeNegative);
ITrackingPoint trackingPoint = antlrParseResultArgs.Snapshot.CreateTrackingPoint(tokenChild.Token.StartIndex, PointTrackingMode.Negative);
rules[ruleName] = new KeyValuePair <ITrackingSpan, ITrackingPoint>(trackingSpan, trackingPoint);
}
}
}
}
}
}
RuleSpans = rules;
}
private void UpdateTags(AntlrParseResultEventArgs antlrParseResultArgs)
{
List <ITagSpan <IOutliningRegionTag> > outliningRegions = new List <ITagSpan <IOutliningRegionTag> >();
if (antlrParseResultArgs != null)
{
ITextSnapshot snapshot = antlrParseResultArgs.Snapshot;
IAstRuleReturnScope resultArgs = antlrParseResultArgs.Result as IAstRuleReturnScope;
var result = resultArgs.Tree as CommonTree;
if (result != null)
{
foreach (CommonTree child in result.Children)
{
if (child == null || string.IsNullOrEmpty(child.Text))
{
continue;
}
if (child.Text == "rule" && child.ChildCount > 0 || child.Text.StartsWith("tokens") || child.Text.StartsWith("options"))
{
string blockHint = "...";
if (child.Text == "rule")
{
string ruleName = child.Children[0].Text;
// don't try to outline the artificial tokens rule
if (ruleName == "Tokens")
{
continue;
}
blockHint = child.Children[0].Text + "...";
}
else if (child.Text.StartsWith("tokens"))
{
// this is the special tokens{} block of a combined grammar
blockHint = "tokens {...}";
}
else if (child.Text.StartsWith("options"))
{
// this is the special options{} block of a grammar
blockHint = "options {...}";
}
var startToken = antlrParseResultArgs.Tokens[child.TokenStartIndex];
var stopToken = antlrParseResultArgs.Tokens[child.TokenStopIndex];
if (startToken.Type == ANTLRParser.DOC_COMMENT)
{
for (int index = child.TokenStartIndex; index <= child.TokenStopIndex; index++)
{
startToken = antlrParseResultArgs.Tokens[index];
if (startToken.Type != ANTLRParser.DOC_COMMENT && startToken.Channel != TokenChannels.Hidden)
{
break;
}
}
}
Span span = new Span(startToken.StartIndex, stopToken.StopIndex - startToken.StartIndex + 1);
if (snapshot.GetLineNumberFromPosition(span.Start) == snapshot.GetLineNumberFromPosition(span.End))
{
continue;
}
SnapshotSpan snapshotSpan = new SnapshotSpan(antlrParseResultArgs.Snapshot, span);
IOutliningRegionTag tag = new OutliningRegionTag(blockHint, snapshotSpan.GetText());
TagSpan <IOutliningRegionTag> tagSpan = new TagSpan <IOutliningRegionTag>(snapshotSpan, tag);
outliningRegions.Add(tagSpan);
}
}
}
foreach (var token in antlrParseResultArgs.Tokens)
{
switch (token.Type)
{
case ANTLRParser.DOC_COMMENT:
case ANTLRParser.ML_COMMENT:
Span commentSpan = Span.FromBounds(token.StartIndex, token.StopIndex + 1);
if (snapshot.GetLineNumberFromPosition(commentSpan.Start) != snapshot.GetLineNumberFromPosition(commentSpan.End))
{
SnapshotSpan commentSnapshotSpan = new SnapshotSpan(antlrParseResultArgs.Snapshot, commentSpan);
IOutliningRegionTag commentTag = new OutliningRegionTag(string.Format("/*{0} ... */", token.Type == ANTLRParser.DOC_COMMENT ? "*" : string.Empty), commentSnapshotSpan.GetText());
TagSpan <IOutliningRegionTag> commentTagSpan = new TagSpan <IOutliningRegionTag>(commentSnapshotSpan, commentTag);
outliningRegions.Add(commentTagSpan);
}
break;
default:
continue;
}
}
}
this._outliningRegions = outliningRegions;
OnTagsChanged(new SnapshotSpanEventArgs(new SnapshotSpan(antlrParseResultArgs.Snapshot, new Span(0, antlrParseResultArgs.Snapshot.Length))));
}
