youmuliu/stgsharp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

all node type are defined

Browse Source
This commit is contained in:
Youmu Liu
2026-02-02 18:11:46 +08:00
parent 73b222bbc6
commit fe0e4ad7a4
9 changed files with 405 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files
StgSharp.RegularAnalysis/RegularMachine/Node.Boarder.cs
+97
View File
@@ -0,0 +1,97 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="Node.Boarder"
// 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 System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.RegularAnalysis
{
internal class RegularExpressionLeftBoarderNode : RegularStateNode
{
public RegularExpressionLeftBoarderNode(
int index,
string name
)
{
Boarder = new GroupIndex
{
Index = index,
Name = name
};
}
public event EventHandler<GroupIndex> OnBoarderEntered;
public GroupIndex Boarder { get; private set; }
public override NodeType Type => NodeType.LEFT_BOARDER;
public override bool IsValidateFrom(
RegularStateNode former,
RegularContext context
)
{
return true;
}
}
internal class RegularExpressionRightBoarderNode : RegularStateNode
{
public RegularExpressionRightBoarderNode(
int index,
string name
)
{
Boarder = new GroupIndex
{
Index = index,
Name = name
};
}
public event EventHandler<GroupIndex> OnBoarderEntered;
public GroupIndex Boarder { get; private set; }
public override NodeType Type => NodeType.RIGHT_BOARDER;
public override bool IsValidateFrom(
RegularStateNode former,
RegularContext context
)
{
return true;
}
}
}
StgSharp.RegularAnalysis/RegularMachine/Node.Branch.cs
+95
View File
@@ -0,0 +1,95 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="Node.Branch"
// 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.MVVM;
using System;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
namespace StgSharp.RegularAnalysis
{
internal class RegularBranchNode : RegularStateNode
{
private int _lastBranch;
private List<BranchMeasureResult> _result;
public override NodeType Type => NodeType.BRANCH;
public override bool IsValidateFrom(
RegularStateNode former,
RegularContext context
)
{
return true;
}
public override bool TryTransaction(
ReadOnlySpan<RegularStateNode> nodeSpan,
RegularContext context,
out int label
)
{
int pos = context.LastBranch.Peek();
if (AvailableNodes.Length > _lastBranch)
{
// return measure result
label = 0;
return true;
}
label = FailNodeIndex;
return false;
}
}
internal struct BranchMeasureResult
{
internal BranchMeasureResult(
bool match,
int size
)
{
IsMatch = match;
Length = size;
}
public bool IsMatch { get; init; }
public static BranchMeasureResult Fail { get; } = new BranchMeasureResult();
public int Length { get; init; }
}
}
StgSharp.RegularAnalysis/RegularMachine/Node.Char.cs
+196
View File
@@ -0,0 +1,196 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="Node.Char"
// 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.State;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.RegularAnalysis
{
internal enum EpsilonKind
{
Always,
Begin,
End,
LineBegin,
LineEnd,
WordBoundary,
NonWordBoundary
}
internal class RegularExpressionEpsilonNode : RegularStateNode
{
public RegularExpressionEpsilonNode(
EpsilonKind kind = EpsilonKind.Always
)
{
Kind = kind;
}
public EpsilonKind Kind { get; }
public override NodeType Type => NodeType.EPSILON;
public override bool IsValidateFrom(
RegularStateNode former,
RegularContext context
)
{
int pos = context.Position;
int len = context.Source?.Length ?? 0;
bool PrevIsWord()
{
if (pos - 1 < 0 || pos - 1 >= len) {
return false;
}
char c = context.Source[pos - 1];
return char.IsLetterOrDigit(c) || c == '_';
}
bool NextIsWord()
{
if (pos < 0 || pos >= len) {
return false;
}
char c = context.Source[pos];
return char.IsLetterOrDigit(c) || c == '_';
}
switch (Kind)
{
case EpsilonKind.Always:
return true;
case EpsilonKind.Begin:
return pos == context.Begin;
case EpsilonKind.End:
return pos == len;
case EpsilonKind.LineBegin:
if (pos == 0) {
return true;
}
if (pos - 1 < 0 || pos - 1 >= len) {
return false;
}
return context.Source[pos - 1] == '\n' || context.Source[pos - 1] == '\r';
case EpsilonKind.LineEnd:
if (pos == len) {
return true;
}
if (pos < 0 || pos >= len) {
return false;
}
return context.Source[pos] == '\n' || context.Source[pos] == '\r';
case EpsilonKind.WordBoundary:
return PrevIsWord() != NextIsWord();
case EpsilonKind.NonWordBoundary:
return PrevIsWord() == NextIsWord();
default:
return false;
}
}
}
internal class RegularExpressionCharNode : RegularStateNode
{
private char _char;
public RegularExpressionCharNode(
char c
)
{
_char = c;
}
public override NodeType Type => NodeType.CHAR;
public override bool IsValidateFrom(
RegularStateNode former,
RegularContext context
)
{
int pos = context.Position;
char c = context.CurrentCharSpan[pos + 1];
return c == _char;
}
}
internal class RegularExpressionCharsetNode : RegularStateNode
{
private bool _isNegated;
private HashSet<char> _charset;
public RegularExpressionCharsetNode(
IEnumerable<char> charset,
bool isNegated = false
)
{
_charset = new(charset);
_isNegated = isNegated;
}
public RegularExpressionCharsetNode(
ReadOnlySpan<char> charset,
bool isNegated = false
)
{
_charset = new(charset.Length);
_isNegated = isNegated;
}
public override NodeType Type => NodeType.CHARSET;
public override bool IsValidateFrom(
RegularStateNode former,
RegularContext context
)
{
int pos = context.Position;
char c = context.CurrentCharSpan[pos + 1];
bool contains = _charset.Contains(c);
return _isNegated ? !contains : contains;
}
}
}
StgSharp.RegularAnalysis/RegularMachine/Node.Count.cs
+73
View File
@@ -0,0 +1,73 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="Node.Count"
// 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 System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.RegularAnalysis
{
internal class RegularExpressionCounterNode : RegularStateNode
{
private readonly int _maxCount;
private readonly int _minCount;
public RegularExpressionCounterNode(
int minCount,
bool isEager
)
{
_minCount = minCount;
IsEager = isEager;
}
public bool IsEager { get; init; }
public int Count { get; private set; }
public override NodeType Type => NodeType.COUNT;
public RegularStateNode LoopBack { get; set; }
public override bool IsValidateFrom(
RegularStateNode former,
RegularContext context
)
{
return true;
}
public void Reset()
{
Count = 0;
}
}
}
StgSharp.RegularAnalysis/RegularMachine/Node.Sequence.cs
+37
View File
@@ -0,0 +1,37 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.RegularAnalysis
{
internal class RegularSequenceNode : RegularStateNode
{
private string _sequence;
public override NodeType Type => NodeType.SEQUENCE;
public override bool IsValidateFrom(
RegularStateNode former,
RegularContext context
)
{
return true;
}
public override bool TryTransaction(
ReadOnlySpan<RegularStateNode> nodeSpan,
RegularContext context,
out int label
)
{
int pos = context.Position + 1;
if (true) { }
label = -1;
return false;
}
}
}
StgSharp.RegularAnalysis/RegularMachine/Node.cs
+70
View File
@@ -0,0 +1,70 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="Node"
// 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.State;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.RegularAnalysis
{
internal abstract class RegularStateNode : SimpleStateMachineNode<RegularStateNode, int, RegularContext>
{
public int FailNodeIndex { get; set; }
public abstract NodeType Type { get; }
public override bool TryTransaction(
ReadOnlySpan<RegularStateNode> nodeSpan,
RegularContext context,
out int label
)
{
int pos = context.Position;
if (pos < 0)
{
label = FailNodeIndex;
return false;
}
char c = context.CurrentCharSpan[pos];
foreach (int index in AvailableNodes)
{
if (nodeSpan[index].IsValidateFrom(this, context))
{
label = index;
return true;
}
}
label = FailNodeIndex;
return false;
}
}
}
StgSharp.RegularAnalysis/RegularMachine/NodeType.cs
+65
View File
@@ -0,0 +1,65 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="RegularExpression.NodeState"
// 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 System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.RegularAnalysis
{
internal enum NodeType
{
// single unicode character: a、B、1、@、汉字 etc.
CHAR,
// collections of finate characters: [abc]、[^abc]、\d、\w、\s、\D、\W、\S etc.
CHARSET,
// increase count of a counter, half function of *+? quantifiers
COUNT,
// left boarder of a sub sequnce, usually begin of match group or lookaround
LEFT_BOARDER,
// right boarder of a sub sequnce, usually end of match group or lookaround
RIGHT_BOARDER,
// zero length char or structure
EPSILON,
// more than one cases to match, like alter|nation
BRANCH,
// a sequence of nodes to match in order, each char should be fully defined but not charset
SEQUENCE
}
}
StgSharp.RegularAnalysis/RegularMachine/StateMachine.cs
+137
View File
@@ -0,0 +1,137 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="StateMachine"
// 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.Internal;
using StgSharp.State;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.RegularAnalysis
{
internal class RegularExpressionState : ISimpleStateMachine<RegularStateNode, int, RegularContext>
{
private List<RegularStateNode> _nodes;
private RegularStateNode _currentState;
public RegularStateNode this[
int label
] => _nodes[label];
public ref readonly RegularStateNode GetCurrentStateNode()
{
throw new NotImplementedException();
}
public void Reset()
{
throw new NotImplementedException();
}
public bool TryMoveNext(
RegularContext ctx
)
{
throw new NotImplementedException();
}
#region node factory
public RegularExpressionCharNode AddChar(
char c
)
{
RegularExpressionCharNode node = new RegularExpressionCharNode(c);
int index = _nodes.Count;
_nodes.Add(node);
node.FailNodeIndex = index; // Point to self by default
return node;
}
public RegularExpressionCharsetNode AddCharset(
ReadOnlySpan<char> chars,
bool isNegate
)
{
RegularExpressionCharsetNode node = new RegularExpressionCharsetNode(chars, isNegate);
int index = _nodes.Count;
_nodes.Add(node);
node.FailNodeIndex = index; // Point to self by default
return node;
}
public (RegularExpressionLeftBoarderNode left,RegularExpressionRightBoarderNode right) AddBoarder(
string groupName,
int groupIndex
)
{
RegularExpressionLeftBoarderNode leftNode = new RegularExpressionLeftBoarderNode(groupIndex, groupName);
int leftIndex = _nodes.Count;
_nodes.Add(leftNode);
leftNode.FailNodeIndex = leftIndex; // Point to self by default
RegularExpressionRightBoarderNode rightNode = new RegularExpressionRightBoarderNode(groupIndex, groupName);
int rightIndex = _nodes.Count;
_nodes.Add(rightNode);
rightNode.FailNodeIndex = rightIndex; // Point to self by default
return (left: leftNode,right:rightNode);
}
public RegularExpressionCounterNode AddCounter(
int minCount,
bool isEager
)
{
RegularExpressionCounterNode node = new RegularExpressionCounterNode(minCount, isEager);
int index = _nodes.Count;
_nodes.Add(node);
node.FailNodeIndex = index; // Point to self by default
return node;
}
#endregion
}
internal class RegularContext : StateContext
{
public int Begin { get; set; }
public int Position { get; set; } = -1;
public ReadOnlySpan<char> CurrentCharSpan => Source.AsSpan()[Begin..Position];
public string Source { get; init; }
internal Stack<int> LastBranch { get; } = new();
}
}