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