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/RegulartMachine/Node.Boarder.cs → StgSharp.RegularAnalysis/RegularMachine/Node.Boarder.cs
View File
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/RegulartMachine/Node.Count.cs → StgSharp.RegularAnalysis/RegularMachine/Node.Count.cs
View File
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/RegulartMachine/NodeType.cs → StgSharp.RegularAnalysis/RegularMachine/NodeType.cs
+4 -1
View File
@@ -55,7 +55,10 @@ namespace StgSharp.RegularAnalysis
EPSILON, EPSILON,
// more than one cases to match, like alter|nation // more than one cases to match, like alter|nation
BRANCH BRANCH,
// a sequence of nodes to match in order, each char should be fully defined but not charset
SEQUENCE
} }
} }
StgSharp.RegularAnalysis/RegulartMachine/StateMachine.cs → StgSharp.RegularAnalysis/RegularMachine/StateMachine.cs
+3 -36
View File
@@ -44,7 +44,7 @@ namespace StgSharp.RegularAnalysis
private RegularStateNode _currentState; private RegularStateNode _currentState;
public RegularStateNode this[ public RegularStateNode this[
int label int label
] => _nodes[label]; ] => _nodes[label];
public ref readonly RegularStateNode GetCurrentStateNode() public ref readonly RegularStateNode GetCurrentStateNode()
@@ -120,41 +120,6 @@ namespace StgSharp.RegularAnalysis
#endregion #endregion
} }
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
)
{
context.Position++;
int pos = context.Position;
if (pos < 0)
{
label = FailNodeIndex;
return true;
}
char c = context.CurrentCharSpan[pos];
foreach (int index in AvailableNodes)
{
if (nodeSpan[index].IsValidateFrom(this, context))
{
label = index;
return true;
}
}
label = FailNodeIndex;
return true;
}
}
internal class RegularContext : StateContext internal class RegularContext : StateContext
{ {
@@ -166,5 +131,7 @@ namespace StgSharp.RegularAnalysis
public string Source { get; init; } public string Source { get; init; }
internal Stack<int> LastBranch { get; } = new();
} }
} }
StgSharp.RegularAnalysis/RegulartMachine/Node.Char.cs
-93
View File
@@ -1,93 +0,0 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="Node.Char"
// Project: StgSharp
// AuthorGroup: Nitload Space
// Copyright (c) Nitload Space. 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 class RegularExpressionEpsilonNode : RegularStateNode
{
}
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;
}
}
}