public RegexParser(Action <RegexExpression> parseCallback = null, bool ignorePatternWhitespace = true, bool breakOnSlash = false)
{
this.IgnorePatternWhitespace = ignorePatternWhitespace;
this.BreakOnSlash = breakOnSlash;
this.parseCallback = parseCallback;
this.currentGroup = new RegexGroup(null);
}
public RegexGroup(RegexGroup parent, bool?caseSensitive = null)
{
this.parent = parent;
this.caseSensitive = caseSensitive;
this.current = RegexNoOp.Default;
this.pending = null;
}
public static string GetRegexValue(this string line, RegexKey regexKey, RegexGroup regexGroup)
{
string result = "";
string replaceLine = "";
var patterns = new RegexPatterns();
var keys = patterns.GetValue(regexKey);
if (line != null)
{
replaceLine = Regex.Replace(line, keys.OriginalKey, keys.ReplaceKey);
var match = Regex.Match(replaceLine, keys.RegexSearchKey);
result = match.Groups[(int)regexGroup].Value;
}
return(result);
}
internal AddressTruncator(AOTypeDictionary typeDictionary)
{
this.typeDictionary = typeDictionary;
sb = new StringBuilder();
houseTypesMultiPattern = typeDictionary.GetRegexMultiPattern((int)ObjectLevel.House);
roomTypesMultiPattern = typeDictionary.GetRegexMultiPattern((int)ObjectLevel.Room);
regionTypesMultiPattern = typeDictionary.GetRegexMultiPattern((int)ObjectLevel.Region, GenderNoun.Fiminine);
streetTypesMultiPattern = typeDictionary.GetRegexMultiPattern((int)ObjectLevel.Street);
fullHouseTypesPattern = String.Format(typeAndNumber, houseTypesMultiPattern);
fullRoomTypesPattern = String.Format(typeAndNumber, roomTypesMultiPattern);
regionPattern = String.Format("^[^ ]+ая +{0}(?=[^а-я]+?)", regionTypesMultiPattern);
allTypesMultiPattern = String.Format(@"(?<=[^а-я]|^){0}(\.+?|(?=[^а-я]|$))", typeDictionary.GetRegexMultiPattern());
housePredictPattern = String.Format("(?<=([^а-я]|^){0}[^а-я]*)[0-9]+([^а-я]*)([а-я](?=[^а-я]|$))*", streetTypesMultiPattern) + litterPattern;
regexGroup = new RegexGroup(RegexOptions.Compiled | RegexOptions.IgnoreCase);
}
private void ProcessTerminal(SymbolId symbol, Capture <char> capture)
{
switch ((int)symbol)
{
case RegexLexer.SymWhitespace:
if (!this.IgnorePatternWhitespace)
{
foreach (var ch in capture)
{
this.currentGroup.AppendExpression(RegexMatchSet.FromChars(ch));
}
}
break;
case RegexLexer.SymSlash:
if (this.BreakOnSlash)
{
goto case int.MinValue; // EOF
}
this.currentGroup.AppendExpression(RegexMatchSet.FromCodepoints('/'));
break;
case RegexLexer.SymCharset:
this.currentGroup.AppendExpression(RegexMatchSet.FromNamedCharset(capture.AsString()));
break;
case RegexLexer.SymRegexLetter:
this.currentGroup.AppendExpression(RegexMatchGrapheme.Create(capture.AsString()));
break;
case RegexLexer.SymRegexEscape:
this.currentGroup.AppendExpression(RegexMatchSet.FromEscape(capture.AsString()));
break;
case RegexLexer.SymRegexCharset:
this.currentGroup.AppendExpression(RegexMatchSet.FromSet(capture.AsString()));
break;
case RegexLexer.SymRegexDot:
this.currentGroup.AppendExpression(RegexMatchSet.Dot());
break;
case RegexLexer.SymQuantifyKleene:
this.currentGroup.Quantify(RegexQuantifier.Kleene());
break;
case RegexLexer.SymQuantifyAny:
this.currentGroup.Quantify(RegexQuantifier.Any());
break;
case RegexLexer.SymQuantifyOptional:
this.currentGroup.Quantify(RegexQuantifier.Optional());
break;
case RegexLexer.SymQuantifyRepeat:
this.currentGroup.Quantify(RegexQuantifier.Repeat(capture.AsString()));
break;
case RegexLexer.SymAlternate:
this.currentGroup.Alternate();
break;
case RegexLexer.SymBeginGroup:
this.currentGroup = this.currentGroup.BeginGroup(null);
break;
case RegexLexer.SymSensitiveGroup:
this.currentGroup = this.currentGroup.BeginGroup(true);
break;
case RegexLexer.SymInsensitiveGroup:
this.currentGroup = this.currentGroup.BeginGroup(false);
break;
case RegexLexer.SymEndGroup:
this.currentGroup = this.currentGroup.EndGroup();
break;
case int.MinValue: // EOF
if (!this.currentGroup.IsRoot)
{
throw new InvalidOperationException("Regex has open groups");
}
this.parseCallback?.Invoke(this.Flush());
break;
default:
throw new NotSupportedException("Unexpected symbol at index " + capture.Index);
}
}
public RegexFSMCaptureEndTransition(RegexGroup <T> group) => this.group = group ?? throw new ArgumentNullException(nameof(group));
protected virtual IRegexFSMTransition <T> GenerateNFATransitionFromRegexGroupReference(
RegexGroupReference <T> groupReference,
IRegexNFA <T> nfa,
IRegexNFAState <T> state
)
{
RegexGroup <T> group;
if (groupReference.IsDetermined)
{
group = groupReference.Group;
}
else
{
IRegexFSMEpsilonTransition <T> epsilonTransition = this.contextInfo.ActivateRegexFSMEpsilonTransition();
var groups = this.regexGroups.Where(_group => _group.ID == groupReference.GroupID).ToArray();
switch (groups.Length)
{
case 0:
//throw new InvalidOperationException("未找到引用的正则组。");
epsilonTransition = this.contextInfo.ActivateRegexFSMEpsilonTransition();
nfa.AttachTransition(state, epsilonTransition);
return(epsilonTransition);
case 1:
group = groups[0];
break;
default:
group = new RegexGroup <T>(
groups.Select(_group => _group.InnerRegex).UnionMany()
);
break;
//throw new InvalidOperationException("找到多个重复 ID 的正则组。");
//epsilonTransition = this.contextInfo.ActivateRegexNFAEpsilonTransition();
//nfa.AttachTransition(state, epsilonTransition);
//return epsilonTransition;
}
}
IRegexNFAState <T> nextState = state;
var lastCaptureReferenceTransition = new RegexFSMLastCaptureReferenceTransition <T>(group, group.ID, (sender, readerSource, handler, args) =>
{
if (args.FirstOrDefault() is IRegexFSM <T> fsm)
{
if (fsm.TryGetLastCapture(sender.IDToken, sender.ID, out int start, out int length))
{
var progressService = fsm.GetService <RegexFSM <T> .ProgressService>();
var progress = progressService.GetProgress();
foreach (var t in fsm.Inputs.Skip(start).Take(length))
{
if (!(readerSource.HasNext() && EqualityComparer <T> .Default.Equals(readerSource.Read(), t)))
{
progressService.SetProgress(progress);
return(false);
}
}
return(true);
}
}
