private void add(SYMBOL_ENUM[] context, int patternId, string printablePattern, Action <TokenMatch <SYMBOL_ENUM> > action,
STATE_ENUM[] states, StringCaseComparison stringComparison = StringCaseComparison.Sensitive)
{
if (printablePattern == null)
{
throw new NotImplementedException();
}
if (patternId != rules.Count) // just a precaution that we can index rules by id
{
throw new ArgumentException();
}
var rule = new Rule <SYMBOL_ENUM, STATE_ENUM>(stringComparison, patternId, printablePattern)
{
Context = context ?? new SYMBOL_ENUM[] { },
Action = action,
States = new HashSet <STATE_ENUM>(states.Length == 0 ? DefaultStates : states),
};
// we should check if pattern matches empty string, but since now we use length>0 as indication of match
// and length=0 no match, matching against empty string fails by definition
// it is safe for lexer execution, but does not discourage users from using "A*" regexes and alike
rules.Add(rule);
}
public static object ToCaseComparison(object this_, StringCaseComparison caseComp)
{
switch (AtomType(this_))
{
case RegexAtom.Bracket: return(AsBracket(this_).ToCaseComparison(caseComp));
case RegexAtom.Alternatives: return(AsAlternatives(this_).ToCaseComparison(caseComp));
case RegexAtom.Char:
{
if (caseComp == StringCaseComparison.Sensitive)
{
return(this_);
}
if (UnicodeChar.GetLowerUpperCases(AsChar(this_)).Length == 2)
{
return(new Bracket(false, this_).ToCaseComparison(caseComp));
}
else
{
return(this_);
}
}
}
throw new Exception();
}
private static IEnumerable <Tuple <char, char> > resolve(bool negated, StringCaseComparison stringCase, object[] bracketElements)
{
// convert char classes into chars/ranges
bracketElements = convertCharClasses(bracketElements).ToArray();
List <Tuple <char, char> > char_ranges = convertSingleCharacters(bracketElements).ToList();
if (stringCase == StringCaseComparison.Insensitive)
{
char_ranges = expandCase(char_ranges).ToList();
}
// convert chars into ranges
List <Tuple <int, int> > int_ranges = char_ranges
.Select(it => Tuple.Create((int)it.Item1, (int)it.Item2))
.OrderBy(it => it)
.ToList();
validate(int_ranges);
// compress adjacent and overlapping ranges
int_ranges = compress(int_ranges).ToList();
// just casting
char_ranges = int_ranges
.Select(it => Tuple.Create((char)it.Item1, (char)it.Item2)).ToList();
// switch negation
if (negated)
{
char_ranges = Negate(char_ranges).ToList();
}
return(char_ranges);
}
internal static LexPattern Merge(TypeEnum type, StringCaseComparison stringComparison, IEnumerable <LexPattern> patterns)
{
var result = new LexPattern(type)
{
pattern = PatternBuilder.Merge(patterns.Select(it => it.pattern))
};
result.SetStringComparison(stringComparison);
return(result);
}
internal LexPattern SetStringComparison(StringCaseComparison stringComparison)
{
if (this.stringComparison.HasValue)
{
throw new ArgumentException();
}
this.stringComparison = stringComparison;
if (Type == TypeEnum.Regex)
{
try
{
Rule.FormatAsRegex(pattern.AsInternalRegex(), stringComparison);
}
catch (ArgumentException ex)
{
throw ParseControlException.NewAndRun(ex.Message);
}
}
return(this);
}
internal RegexElem ToCaseComparison(StringCaseComparison caseComp)
{
return(new RegexElem(RegexAtomTraits.ToCaseComparison(atom, caseComp), repetition));
}
public void AddStringAction(SYMBOL_ENUM[] context, string pattern, bool priority, StringCaseComparison stringComparison,
Action <TokenMatch <SYMBOL_ENUM> > action, params STATE_ENUM[] states)
{
int id = patternManager.AddString(pattern, priority, stringComparison);
add(context, id, "\"" + pattern.EscapedString() + "\"", action, states, stringComparison);
}
internal int Add(bool priority, string pattern, StringCaseComparison stringComparison)
{
return(Add(priority,
new RegexParser.AltRegex(new[] { pattern.Select(it => new RegexParser.RegexElem((object)it, RegexParser.Repetition.Create(1, 1))) }),
stringComparison));
}
public static Regex FormatAsRegex(string pattern, StringCaseComparison stringComparison)
{
return(new Regex(@"\G(" + pattern + @")", stringComparison == StringCaseComparison.Sensitive ? RegexOptions.None : RegexOptions.IgnoreCase));
}
public void AddIdRule(int patternId, string printablePattern,
StringCaseComparison stringComparison, SYMBOL_ENUM tokenId, params STATE_ENUM[] states)
{
AddIdRule(null, patternId, printablePattern, stringComparison, tokenId, states);
}
internal int Add(bool priority, NaiveLanguageTools.MultiRegex.RegexParser.AltRegex pattern, StringCaseComparison stringComparison)
{
pattern = pattern.ToCaseComparison(stringComparison);
Nfa pattern_nfa = pattern.BuildNfa();
pattern_nfa.Accepting().ForEach(it => it.SetValue(rulesCount, priority));
if (this.rulesCount == 0)
{
nfa = pattern_nfa;
}
else
{
nfa.StartNode.ConnectTo(pattern_nfa.StartNode, NfaEdge.CreateEmpty());
}
return(rulesCount++);
}
public int AddRegex(bool priority, string pattern, StringCaseComparison stringComparison)
{
return(AddRegex(priority, regexParser.GetRegex(pattern), stringComparison));
}
public void AddRegexAction(string pattern, bool priority, StringCaseComparison stringComparison, Action <TokenMatch <SYMBOL_ENUM> > action, params STATE_ENUM[] states)
{
AddRegexAction(null, pattern, priority, stringComparison, action, states);
}
public void AddIdRule(SYMBOL_ENUM[] context, int patternId, string printablePattern, StringCaseComparison stringComparison,
Func <TokenMatch <SYMBOL_ENUM>, SYMBOL_ENUM> function, params STATE_ENUM[] states)
{
AddIdAction(context, patternId, printablePattern, stringComparison, match => match.Token = function(match), states);
}
public void AddIdRule(SYMBOL_ENUM[] context, int patternId, string printablePattern,
StringCaseComparison stringComparison, SYMBOL_ENUM tokenId, params STATE_ENUM[] states)
{
AddIdRule(context, patternId, printablePattern, stringComparison, _ => tokenId, states);
}
public void AddRegexRule(string pattern, bool priority, StringCaseComparison stringComparison,
Func <TokenMatch <SYMBOL_ENUM>, SYMBOL_ENUM> function, params STATE_ENUM[] states)
{
AddRegexRule(null, pattern, priority, stringComparison, function, states);
}
public void AddIdRule(int patternId, string printablePattern, StringCaseComparison stringComparison,
Func <TokenMatch <SYMBOL_ENUM>, SYMBOL_ENUM> function, params STATE_ENUM[] states)
{
AddIdRule(null, patternId, printablePattern, stringComparison, function, states);
}
public void AddRegexAction(SYMBOL_ENUM[] context, string pattern, bool priority, StringCaseComparison stringComparison,
Action <TokenMatch <SYMBOL_ENUM> > action, params STATE_ENUM[] states)
{
int id = patternManager.AddRegex(Rule.FormatAsRegex(pattern, stringComparison), priority);
add(context, id, "/" + pattern.EscapedString() + "/", action, states);
}
internal AltRegex ToCaseComparison(StringCaseComparison caseComp)
{
return(new AltRegex(chains.Select(it => RegexChainTraits.ToCaseComparison(it, caseComp))));
}
public Bracket ToCaseComparison(StringCaseComparison caseComp)
{
this.bracketElements = resolve(rawNegated, caseComp, rawElements).ToList();
return(this);
}
public void AddIdAction(int patternId, string printablePattern,
StringCaseComparison stringComparison, Action <TokenMatch <SYMBOL_ENUM> > action, params STATE_ENUM[] states)
{
AddIdAction(null, patternId, printablePattern, stringComparison, action, states);
}
public void AddRegexRule(SYMBOL_ENUM[] context, string pattern, bool priority, StringCaseComparison stringComparison,
Func <TokenMatch <SYMBOL_ENUM>, SYMBOL_ENUM> function, params STATE_ENUM[] states)
{
AddRegexAction(context, pattern, priority, stringComparison, match => match.Token = function(match), states);
}
internal int AddRegex(bool priority, NaiveLanguageTools.MultiRegex.RegexParser.AltRegex pattern, StringCaseComparison stringComparison)
{
return(nfaWorker.Add(priority, pattern, stringComparison));
}
public void AddIdAction(SYMBOL_ENUM[] context, int patternId, string printablePattern, StringCaseComparison stringComparison,
Action <TokenMatch <SYMBOL_ENUM> > action, params STATE_ENUM[] states)
{
add(context, patternId, printablePattern, action, states, stringComparison);
}
public int AddString(bool priority, string pattern, StringCaseComparison stringComparison)
{
return(nfaWorker.Add(priority, pattern, stringComparison));
}
public void AddStringRule(string pattern, bool priority, StringCaseComparison stringComparison, SYMBOL_ENUM tokenId, params STATE_ENUM[] states)
{
AddStringRule(null, pattern, priority, stringComparison, tokenId, states);
}
public void AddStringRule(SYMBOL_ENUM[] context, string pattern, bool priority,
StringCaseComparison stringComparison, SYMBOL_ENUM tokenId, params STATE_ENUM[] states)
{
AddStringRule(context, pattern, priority, stringComparison, _ => tokenId, states);
}
public static IEnumerable <RegexElem> ToCaseComparison(IEnumerable <RegexElem> elems, StringCaseComparison caseComp)
{
return(elems.Select(it => it.ToCaseComparison(caseComp)));
}
