private HighlightingRuleSet Wrap(HighlightingRuleSet ruleSet)
{
if (ruleSet is null)
{
return(null);
}
if (!String.IsNullOrEmpty(ruleSet.Name) &&
NamedRuleSet.TryGetValue(ruleSet.Name, out var cachedRule))
{
return(cachedRule);
}
if (Converted.TryGetValue(ruleSet, out var cachedRule2))
{
return(cachedRule2);
}
var copySet = new HighlightingRuleSet();
copySet.Name = ruleSet.Name;
Converted[ruleSet] = copySet;
if (!String.IsNullOrEmpty(copySet.Name))
{
NamedRuleSet[copySet.Name] = copySet;
}
foreach (var baseSpan in ruleSet.Spans)
{
if (baseSpan is null)
{
continue;
}
var copySpan = new HighlightingSpan();
copySpan.StartExpression = baseSpan.StartExpression;
copySpan.EndExpression = baseSpan.EndExpression;
copySpan.RuleSet = Wrap(baseSpan.RuleSet);
copySpan.StartColor = Wrap(baseSpan.StartColor);
copySpan.SpanColor = Wrap(baseSpan.SpanColor);
copySpan.EndColor = Wrap(baseSpan.EndColor);
copySpan.SpanColorIncludesStart = baseSpan.SpanColorIncludesStart;
copySpan.SpanColorIncludesEnd = baseSpan.SpanColorIncludesEnd;
copySet.Spans.Add(copySpan);
}
foreach (var baseRule in ruleSet.Rules)
{
var copyRule = new HighlightingRule();
copyRule.Regex = baseRule.Regex;
copyRule.Color = Wrap(baseRule.Color);
copySet.Rules.Add(copyRule);
}
return(copySet);
}
public object VisitRuleSet(XshdRuleSet ruleSet)
{
HighlightingRuleSet rs = ruleSetDict[ruleSet];
if (processedRuleSets.Contains(ruleSet))
{
return(rs);
}
if (!processingStartedRuleSets.Add(ruleSet))
{
throw Error(ruleSet, "RuleSet cannot be processed because it contains cyclic <Import>");
}
bool oldIgnoreCase = ignoreCase;
if (ruleSet.IgnoreCase != null)
{
ignoreCase = ruleSet.IgnoreCase.Value;
}
rs.Name = ruleSet.Name;
foreach (XshdElement element in ruleSet.Elements)
{
object o = element.AcceptVisitor(this);
HighlightingRuleSet elementRuleSet = o as HighlightingRuleSet;
if (elementRuleSet != null)
{
Merge(rs, elementRuleSet);
}
else
{
HighlightingSpan span = o as HighlightingSpan;
if (span != null)
{
rs.Spans.Add(span);
}
else
{
HighlightingRule elementRule = o as HighlightingRule;
if (elementRule != null)
{
rs.Rules.Add(elementRule);
}
}
}
}
ignoreCase = oldIgnoreCase;
processedRuleSets.Add(ruleSet);
return(rs);
}
public object VisitRuleSet(XshdRuleSet ruleSet)
{
HighlightingRuleSet rs;
if (ruleSet.Name != null)
{
rs = def.ruleSetDict[ruleSet.Name];
}
else
{
rs = new HighlightingRuleSet();
}
bool oldIgnoreCase = ignoreCase;
if (ruleSet.IgnoreCase != null)
{
ignoreCase = ruleSet.IgnoreCase.Value;
}
rs.Name = ruleSet.Name;
foreach (XshdElement element in ruleSet.Elements)
{
object o = element.AcceptVisitor(this);
HighlightingRuleSet elementRuleSet = o as HighlightingRuleSet;
if (elementRuleSet != null)
{
Merge(rs, elementRuleSet);
}
else
{
HighlightingSpan span = o as HighlightingSpan;
if (span != null)
{
rs.Spans.Add(span);
}
else
{
HighlightingRule elementRule = o as HighlightingRule;
if (elementRule != null)
{
rs.Rules.Add(elementRule);
}
}
}
}
ignoreCase = oldIgnoreCase;
return(rs);
}
public HighlightingDefinition AddSpan(HighlightingSpan span)
{
MainRuleSet.Spans.Add(span);
foreach (var color in GetColors(span))
{
AddColor(color);
}
foreach (var ruleSet in GetRuleSets(span))
{
AddRuleSet(ruleSet);
}
return(this);
}
public HighlightingDefinition AddSpan(string startExpression, string endExpression, HighlightingColor color)
{
var span = new HighlightingSpan
{
StartExpression = startExpression.ToRegex(),
EndExpression = endExpression.ToRegex(),
SpanColor = color,
SpanColorIncludesStart = true,
SpanColorIncludesEnd = true
};
return(AddSpan(span));
}
private IEnumerable <HighlightingRuleSet> GetRuleSets(HighlightingSpan span)
{
if (span.RuleSet == null)
{
yield break;
}
yield return(span.RuleSet);
foreach (var ruleSet in span.RuleSet.Spans.SelectMany(GetRuleSets))
{
yield return(ruleSet);
}
}
private IEnumerable <HighlightingColor> GetColors(HighlightingSpan span)
{
yield return(span.SpanColor);
yield return(span.StartColor);
yield return(span.EndColor);
if (span.RuleSet == null)
{
yield break;
}
foreach (var rule in span.RuleSet.Rules)
{
yield return(rule.Color);
}
foreach (var color in span.RuleSet.Spans.SelectMany(GetColors))
{
yield return(color);
}
}
