348 lines
13 KiB
C#
348 lines
13 KiB
C#
//-----------------------------------------------------------------------
|
|
// -----------------------------------------------------------------------
|
|
// file="RegexInterpreter.Optimize"
|
|
// Project: StgSharp
|
|
// AuthorGroup: Nitload
|
|
// Copyright (c) Nitload. All rights reserved.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to deal
|
|
// in the Software without restriction, including without limitation the rights
|
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
// copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in all
|
|
// copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
// SOFTWARE.
|
|
//
|
|
// -----------------------------------------------------------------------
|
|
// -----------------------------------------------------------------------
|
|
using StgSharp.RegularAnalysis.Abstraction;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net.Security;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Security.Permissions;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace StgSharp.RegularAnalysis.TextRegex
|
|
{
|
|
public partial class RegexInterpreter
|
|
{
|
|
|
|
private static List<RegexAstNode> FlattenAlt(
|
|
RegexAstNode root
|
|
)
|
|
{
|
|
TreeEnumerator<RegexAstNode, RegexElementLabel> enumerator = new(root);
|
|
List<RegexAstNode> cases = [];
|
|
RegexAstNode current;
|
|
_ = enumerator.MoveNext(); // skip root
|
|
while (enumerator.MoveNext())
|
|
{
|
|
current = enumerator.Current;
|
|
if (current.EqualityTypeConvert != RegexElementLabel.ALT)
|
|
{
|
|
cases.Add(current);
|
|
enumerator.SkipNode(current);
|
|
}
|
|
current.Parent.RemoveChild(current);
|
|
}
|
|
return cases;
|
|
}
|
|
|
|
private static bool MergeConcat(
|
|
RegexAstNode root
|
|
)
|
|
{
|
|
if (root.EqualityTypeConvert != RegexElementLabel.CONCAT) {
|
|
return false;
|
|
}
|
|
/*
|
|
* concat → concat
|
|
* ╱ ╲ /
|
|
* 'a' concat "abc"
|
|
* / \
|
|
* 'b' 'c'
|
|
*/
|
|
List<string> buffer = [];
|
|
int length = 0;
|
|
RegexAstNode right = root.Right;
|
|
RegexAstNode left = root.Left;
|
|
if (left.EqualityTypeConvert != RegexElementLabel.UNIT_SPAN &&
|
|
left.EqualityTypeConvert != RegexElementLabel.UNIT) {
|
|
return false;
|
|
}
|
|
string str = left.Value;
|
|
buffer.Add(str);
|
|
length += str.Length;
|
|
while (!RegexAstNode.IsNullOrEmpty(right) &&
|
|
right.EqualityTypeConvert == RegexElementLabel.CONCAT)
|
|
{
|
|
left = right.Left;
|
|
if (left.EqualityTypeConvert != RegexElementLabel.UNIT_SPAN &&
|
|
left.EqualityTypeConvert != RegexElementLabel.UNIT)
|
|
{
|
|
break;
|
|
}
|
|
str = left.Value;
|
|
buffer.Add(str);
|
|
length += str.Length;
|
|
root.Right = right.Right;
|
|
right.Parent = RegexAstNode.Empty;
|
|
right = root.Right;
|
|
right.Parent = root;
|
|
}
|
|
if (right.EqualityTypeConvert == RegexElementLabel.UNIT_SPAN ||
|
|
right.EqualityTypeConvert == RegexElementLabel.UNIT)
|
|
{
|
|
root.Right = RegexAstNode.Empty;
|
|
buffer.Add(right.Value);
|
|
length += right.Value.Length;
|
|
}
|
|
str = string.Create(length, buffer, static(
|
|
span,
|
|
buffer
|
|
) => {
|
|
int offset = 0;
|
|
for (int i = 0; i < buffer.Count; i++)
|
|
{
|
|
buffer[i].AsSpan().CopyTo(span[offset..]);
|
|
offset += buffer[i].Length;
|
|
}
|
|
});
|
|
root.Left = new RegexAstNode(new Token<RegexElementLabel>(str, left.Source.Line,
|
|
left.Source.Column,
|
|
str.Length == 1 ?
|
|
RegexElementLabel.UNIT :
|
|
RegexElementLabel.UNIT_SPAN));
|
|
return true;
|
|
}
|
|
|
|
private static void RotateConcat(
|
|
RegexAstNode root
|
|
)
|
|
{
|
|
RegexAstNode left = root.Left;
|
|
while (!RegexAstNode.IsNullOrEmpty(left) &&
|
|
left.EqualityTypeConvert == RegexElementLabel.CONCAT)
|
|
{
|
|
/*
|
|
* root → root
|
|
* ╱ ╲ ╱ ╲
|
|
* left c a left
|
|
* ╱ ╲ ╱ ╲
|
|
* a b b c
|
|
*/
|
|
RegexAstNode a = left.Left;
|
|
RegexAstNode b = left.Right;
|
|
RegexAstNode c = root.Right;
|
|
root.Left = a;
|
|
if (RegexAstNode.IsNullOrEmpty(a)) {
|
|
a.Parent = root;
|
|
}
|
|
|
|
root.Right = left;
|
|
left.Left = b;
|
|
left.Right = c;
|
|
if (RegexAstNode.IsNullOrEmpty(b)) {
|
|
b.Parent = left;
|
|
}
|
|
|
|
if (RegexAstNode.IsNullOrEmpty(c)) {
|
|
c.Parent = left;
|
|
}
|
|
left = root.Left;
|
|
}
|
|
}
|
|
|
|
#region merge alt
|
|
|
|
/// <summary>
|
|
/// Get union beginning part of cases
|
|
/// </summary>
|
|
/// <param name="cases">
|
|
///
|
|
/// </param>
|
|
/// <returns>
|
|
///
|
|
/// </returns>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static RegexAstNode MergeAlt(
|
|
List<RegexAstNode> cases
|
|
)
|
|
{
|
|
UnionAlt union = new(0, cases);
|
|
return union.AsNormal();
|
|
}
|
|
|
|
private class UnionAlt : RegexAstNode
|
|
{
|
|
|
|
private const int MaxLevel = 8;
|
|
|
|
private UnionAlt(
|
|
int level,
|
|
RegexAstNode node
|
|
)
|
|
: base(new Token<RegexElementLabel>(string.Empty, 0, 0, 0))
|
|
{
|
|
Level = level;
|
|
Cases = new List<RegexAstNode>();
|
|
Cases.Add(node.Right ?? Empty);
|
|
UnionBegin = node;
|
|
UnionEnd = node;
|
|
}
|
|
|
|
public UnionAlt(
|
|
int level,
|
|
List<RegexAstNode> c
|
|
)
|
|
: base(new Token<RegexElementLabel>(string.Empty, 0, 0, 0))
|
|
{
|
|
Cases = c;
|
|
Level = level;
|
|
}
|
|
|
|
public List<RegexAstNode> Cases { get; set; }
|
|
|
|
public RegexAstNode UnionBegin { get; set; }
|
|
|
|
public RegexAstNode UnionEnd { get; set; }
|
|
|
|
private int Level { get; set; }
|
|
|
|
public RegexAstNode AsNormal()
|
|
{
|
|
if (Level >= MaxLevel)
|
|
{
|
|
goto build;
|
|
}
|
|
merge:
|
|
List<RegexAstNode> buffer = [];
|
|
for (int i = 0; i < Cases.Count; i++)
|
|
{
|
|
RegexAstNode current = Cases[i];
|
|
int j = 0;
|
|
for (; j < buffer.Count; j++)
|
|
{
|
|
if (CanMerge(current, buffer[j]))
|
|
{
|
|
// find a case in buffer that can merge with current case,
|
|
// then merge them and break
|
|
RegexAstNode b = buffer[j];
|
|
if (b is not UnionAlt alt)
|
|
{
|
|
alt = new UnionAlt(Level + 1, b);
|
|
alt.AddCase(current);
|
|
buffer[j] = alt;
|
|
} else
|
|
{
|
|
alt.AddCase(current);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (j >= buffer.Count) {
|
|
buffer.Add(current);
|
|
}
|
|
}
|
|
Cases = buffer;
|
|
|
|
// TODO problem1 没处理case链表
|
|
// TODO problem2 没有处理立刻返回策略
|
|
if (Cases.Count == 1)
|
|
{
|
|
// if there is only one case,
|
|
// then we suppose that its contained cases has a same beginning,
|
|
// so we attach it to UnionEnd and stay level unchanged
|
|
UnionAlt alt = (Cases[0] as UnionAlt)!;
|
|
if (IsNullOrEmpty(UnionBegin))
|
|
{
|
|
UnionBegin = alt.UnionBegin;
|
|
UnionEnd = alt.UnionEnd;
|
|
} else
|
|
{
|
|
alt.UnionBegin.Parent = UnionEnd;
|
|
UnionEnd.Right = alt.UnionBegin;
|
|
}
|
|
|
|
Cases = alt.Cases;
|
|
goto merge;
|
|
}
|
|
|
|
build:
|
|
|
|
// suppose that from UnionBegin to UnionEnd is a normal form without union
|
|
for (int i = 0; i < Cases.Count; i++)
|
|
{
|
|
if (Cases[i] is UnionAlt union) {
|
|
Cases[i] = union.AsNormal();
|
|
}
|
|
}
|
|
RegexAstNode branch = new RegexAstNode(new Token<RegexElementLabel>(string.Empty, 0,
|
|
UnionEnd.Source.Column,
|
|
RegexElementLabel.ALT));
|
|
UnionEnd.Right = branch;
|
|
branch.Parent = UnionEnd;
|
|
UnionEnd = branch;
|
|
for (int i = 0; i < Cases.Count - 1; i++)
|
|
{
|
|
Cases[i].AppendNode(Cases[i + 1]);
|
|
Cases[i].Parent = UnionEnd;
|
|
}
|
|
UnionEnd.Right = Cases[0];
|
|
return UnionBegin;
|
|
}
|
|
|
|
private void AddCase(
|
|
RegexAstNode _case
|
|
)
|
|
{
|
|
RegexAstNode right = _case.Right;
|
|
right ??= Empty;
|
|
Cases.Add(right);
|
|
}
|
|
|
|
private static bool CanMerge(
|
|
RegexAstNode origin,
|
|
RegexAstNode target
|
|
)
|
|
{
|
|
// suppose that origin is not a union,
|
|
if (target is UnionAlt alt)
|
|
{
|
|
// then we suppose that alt has only one are same
|
|
return origin .EqualityTypeConvert == RegexElementLabel.CONCAT &&
|
|
(origin.Left.EqualityTypeConvert & RegexElementLabel.SINGLE) != 0 &&
|
|
origin.Left.EqualityTypeConvert == alt.UnionEnd.Left.EqualityTypeConvert &&
|
|
origin.Left.Value == alt.UnionEnd.Left.Value;
|
|
} else
|
|
{
|
|
return origin.EqualityTypeConvert == RegexElementLabel.CONCAT &&
|
|
target.EqualityTypeConvert == RegexElementLabel.CONCAT &&
|
|
(origin.Left.EqualityTypeConvert & RegexElementLabel.SINGLE) != 0 &&
|
|
origin.Left.EqualityTypeConvert == target.Left.EqualityTypeConvert &&
|
|
origin.Left.Value == target.Left.Value;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
/**/
|
|
}
|
|
}
|