building regex parser
This commit is contained in:
Youmu Liu
@@ -41,327 +41,129 @@ namespace StgSharp.RegularAnalysis.Abstraction
|
||||
where TLabel : unmanaged
|
||||
{
|
||||
|
||||
private Token<TLabel>? _lastToken;
|
||||
|
||||
private TNode[] _nodeArray = new TNode[4];
|
||||
private Token<TLabel>[] _operatorArray = new Token<TLabel>[4];
|
||||
private Token<TLabel>[] _tokenArray = new Token<TLabel>[4];
|
||||
|
||||
private int _nodeCount,_tokenCount, _operatorCount;
|
||||
private RandomAccessibleStack<CompileDepthMark> _depthStack = new RandomAccessibleStack<CompileDepthMark>(
|
||||
);
|
||||
|
||||
private RandomAccessibleStack<OperandIndex> _isNode = new RandomAccessibleStack<OperandIndex>(
|
||||
8);
|
||||
private Stack<Stack<TNode>> _statementCache = new Stack<Stack<TNode>>();
|
||||
private TNode _lastNode;
|
||||
private readonly RandomAccessibleStack<DepthMark> _depthMarks = [];
|
||||
private readonly RandomAccessibleStack<TNode> _operands = [];
|
||||
private readonly RandomAccessibleStack<TNode> _operators = [];
|
||||
|
||||
public CompileStack()
|
||||
{
|
||||
_depthStack.Push(new CompileDepthMark(0, 0, 0, null!));
|
||||
_statementCache.Push(new Stack<TNode>());
|
||||
_depthMarks.Push(new DepthMark(0, 0));
|
||||
}
|
||||
|
||||
public bool IsLastAddedOperator { get; private set; }
|
||||
|
||||
public CompileDepthMark CurrentDepthMark
|
||||
public int OperandInDepthCount
|
||||
{
|
||||
get => _depthStack.Peek();
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
get => _operands.Count - _depthMarks.Peek().OperandPos;
|
||||
}
|
||||
|
||||
public int Depth => _depthStack.Count;
|
||||
|
||||
public int OperandCount => _isNode.Count;
|
||||
|
||||
public int OperatorCount => _operatorCount;
|
||||
|
||||
public int OperatorAheadOfDepth
|
||||
public int OperatorInDepthCount
|
||||
{
|
||||
get => OperatorCount - _depthStack.Peek().OperatorBegin;
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
get => _operands.Count - _depthMarks.Peek().OperandPos;
|
||||
}
|
||||
|
||||
public int OperandAheadOfDepth
|
||||
public int Depth
|
||||
{
|
||||
get => OperandCount - _depthStack.Peek().OperandBegin;
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
get => _depthMarks.Count;
|
||||
}
|
||||
|
||||
public Stack<TNode> StatementsInDepth
|
||||
{
|
||||
get => _statementCache.Peek();
|
||||
}
|
||||
|
||||
public void DecreaseDepth()
|
||||
{
|
||||
CompileDepthMark mark = _depthStack.Pop();
|
||||
Stack<TNode> statementsInDepth = _statementCache.Pop();
|
||||
}
|
||||
|
||||
public bool GetOperandAt(
|
||||
Index i,
|
||||
out TNode operandNode,
|
||||
out Token<TLabel> operandToken
|
||||
)
|
||||
{
|
||||
OperandIndex index = _isNode[i];
|
||||
if (index.IsNode)
|
||||
{
|
||||
operandNode = _nodeArray[index.Index];
|
||||
operandToken = Token<TLabel>.Empty;
|
||||
return true;
|
||||
} else
|
||||
{
|
||||
operandToken = _tokenArray[index.Index];
|
||||
operandNode = default!;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public bool GetOperandAt(
|
||||
CompileDepthMark depth,
|
||||
Index i,
|
||||
out Token<TLabel> operandToken,
|
||||
out TNode operandNode
|
||||
)
|
||||
{
|
||||
OperandIndex index = _isNode[i];
|
||||
|
||||
_depthStack.Contains(depth);
|
||||
if (index.IsNode)
|
||||
{
|
||||
operandNode = _nodeArray[index.Index];
|
||||
operandToken = Token<TLabel>.Empty;
|
||||
return true;
|
||||
} else
|
||||
{
|
||||
operandToken = _tokenArray[index.Index];
|
||||
operandNode = default!;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public CompileDepthMark IncreaseDepth(
|
||||
int usage
|
||||
)
|
||||
{
|
||||
CompileDepthMark mark =
|
||||
new CompileDepthMark(OperatorCount, OperandCount, usage);
|
||||
|
||||
_depthStack.Push(mark);
|
||||
_statementCache.Push(new Stack<TNode>());
|
||||
return mark;
|
||||
}
|
||||
|
||||
public TNode PackAllStatements()
|
||||
{
|
||||
if (StatementsInDepth.Count == 0) {
|
||||
return TNode.Empty;
|
||||
}
|
||||
TNode end = StatementsInDepth.Peek();
|
||||
TNode first = end;
|
||||
while (StatementsInDepth.Count > 0)
|
||||
{
|
||||
first = StatementsInDepth.Pop();
|
||||
end.PrependNode(first);
|
||||
end = first;
|
||||
}
|
||||
return first;
|
||||
}
|
||||
|
||||
public bool PeekOperand(
|
||||
out Token<TLabel> t,
|
||||
out TNode n
|
||||
)
|
||||
{
|
||||
if (OperandAheadOfDepth <= 0)
|
||||
{
|
||||
t = Token<TLabel>.Empty;
|
||||
n = TNode.Empty;
|
||||
return false;
|
||||
}
|
||||
if (_isNode.Pop().IsNode)
|
||||
{
|
||||
t = Token<TLabel>.Empty;
|
||||
n = _nodeArray[_nodeCount - 1];
|
||||
return true;
|
||||
} else
|
||||
{
|
||||
t = _tokenArray[_tokenCount - 1];
|
||||
n = TNode.Empty;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public Token<TLabel> PeekOperator()
|
||||
{
|
||||
if (OperatorAheadOfDepth > 0) {
|
||||
return _operatorArray[_operatorCount - 1];
|
||||
}
|
||||
return Token<TLabel>.Empty;
|
||||
}
|
||||
|
||||
public bool PopOperand(
|
||||
out Token<TLabel> t,
|
||||
out TNode n
|
||||
)
|
||||
{
|
||||
if (OperandAheadOfDepth <= 0)
|
||||
{
|
||||
t = Token<TLabel>.Empty;
|
||||
n = TNode.Empty;
|
||||
return false;
|
||||
}
|
||||
if (_isNode.Pop().IsNode)
|
||||
{
|
||||
t = Token<TLabel>.Empty;
|
||||
n = _nodeArray[--_nodeCount];
|
||||
return true;
|
||||
} else
|
||||
{
|
||||
t = _tokenArray[--_tokenCount];
|
||||
n = TNode.Empty;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public Token<TLabel> PopOperator()
|
||||
{
|
||||
if (OperatorAheadOfDepth > 0)
|
||||
{
|
||||
_operatorCount--;
|
||||
return _operatorArray[_operatorCount];
|
||||
}
|
||||
return Token<TLabel>.Empty;
|
||||
}
|
||||
|
||||
public void PushOperand(
|
||||
TNode node
|
||||
)
|
||||
{
|
||||
if (_nodeArray.Length == _nodeCount) {
|
||||
Array.Resize(ref _nodeArray, _nodeArray.Length * 2);
|
||||
}
|
||||
_nodeArray[_nodeCount] = node;
|
||||
_isNode.Push(new(true, _nodeCount));
|
||||
_nodeCount++;
|
||||
IsLastAddedOperator = false;
|
||||
}
|
||||
|
||||
public void PushOperand(
|
||||
Token<TLabel> token
|
||||
)
|
||||
{
|
||||
if (_tokenArray.Length == _tokenCount) {
|
||||
Array.Resize(ref _tokenArray, _tokenArray.Length * 2);
|
||||
}
|
||||
_tokenArray[_tokenCount] = token;
|
||||
_isNode.Push(new(false, _tokenCount));
|
||||
_tokenCount++;
|
||||
IsLastAddedOperator = false;
|
||||
}
|
||||
|
||||
public void PushOperator(
|
||||
Token<TLabel> token
|
||||
)
|
||||
{
|
||||
if (_operatorArray.Length == _operatorCount) {
|
||||
Array.Resize(ref _operatorArray, _operatorArray.Length * 2);
|
||||
}
|
||||
_operatorArray[_operatorCount] = token;
|
||||
_operatorCount++;
|
||||
IsLastAddedOperator = true;
|
||||
}
|
||||
|
||||
public T StateOfCurrentDepth<T>() where T : class, ICompileDepthState
|
||||
{
|
||||
return (CurrentDepthMark.StateCache as T)!;
|
||||
}
|
||||
|
||||
public bool TryPeekOperand(
|
||||
out bool isNode,
|
||||
out Token<TLabel> t,
|
||||
out TNode n
|
||||
)
|
||||
{
|
||||
if (OperandAheadOfDepth <= 0)
|
||||
{
|
||||
t = Token<TLabel>.Empty;
|
||||
n = TNode.Empty;
|
||||
isNode = false;
|
||||
return false;
|
||||
}
|
||||
if (_isNode.Pop().IsNode)
|
||||
{
|
||||
t = Token<TLabel>.Empty;
|
||||
n = _nodeArray[_nodeCount - 1];
|
||||
isNode = true;
|
||||
return true;
|
||||
} else
|
||||
{
|
||||
t = _tokenArray[_tokenCount - 1];
|
||||
n = TNode.Empty;
|
||||
isNode = false;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
public bool TryPeekOperator(
|
||||
out Token<TLabel> op
|
||||
)
|
||||
{
|
||||
if (OperatorAheadOfDepth > 0)
|
||||
{
|
||||
op = _operatorArray[_operatorCount - 1];
|
||||
return true;
|
||||
}
|
||||
op = Token<TLabel>.Empty;
|
||||
return false;
|
||||
}
|
||||
|
||||
public bool TryPopOperand(
|
||||
out bool isNode,
|
||||
out Token<TLabel> t,
|
||||
out TNode n
|
||||
)
|
||||
{
|
||||
if (OperandAheadOfDepth <= 0)
|
||||
{
|
||||
t = Token<TLabel>.Empty;
|
||||
n = TNode.Empty;
|
||||
isNode = false;
|
||||
return false;
|
||||
}
|
||||
if (_isNode.Pop().IsNode)
|
||||
{
|
||||
t = Token<TLabel>.Empty;
|
||||
n = _nodeArray[--_nodeCount];
|
||||
isNode = true;
|
||||
return true;
|
||||
} else
|
||||
{
|
||||
t = _tokenArray[--_tokenCount];
|
||||
n = TNode.Empty;
|
||||
isNode = false;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
public bool TryPopOperator(
|
||||
out Token<TLabel> op
|
||||
)
|
||||
{
|
||||
if (OperatorAheadOfDepth > 0)
|
||||
{
|
||||
op = _operatorArray[--_operatorCount];
|
||||
return true;
|
||||
}
|
||||
op = Token<TLabel>.Empty;
|
||||
return false;
|
||||
}
|
||||
|
||||
private record struct OperandIndex(
|
||||
bool IsNode,
|
||||
int Index
|
||||
private record struct DepthMark(
|
||||
int OperandPos,
|
||||
int OperatorPos,
|
||||
int Mark
|
||||
);
|
||||
|
||||
#region operator
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
public TNode PopOperator(
|
||||
)
|
||||
{
|
||||
if (OperatorInDepthCount > 0) {
|
||||
return _operators.Pop();
|
||||
}
|
||||
return TNode.Empty;
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
public void PushOperator(
|
||||
TNode operatorNode
|
||||
)
|
||||
{
|
||||
_operators.Push(operatorNode);
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
public bool TryPopOperator(
|
||||
out TNode op
|
||||
)
|
||||
{
|
||||
if (OperatorInDepthCount > 0)
|
||||
{
|
||||
op = _operators.Pop();
|
||||
return true;
|
||||
}
|
||||
op = TNode.Empty;
|
||||
return false;
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region operand
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
public TNode PopOperand(
|
||||
)
|
||||
{
|
||||
if (OperatorInDepthCount > 0) {
|
||||
return _operators.Pop();
|
||||
}
|
||||
return TNode.Empty;
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
public void PushOperand(
|
||||
TNode operatorNode
|
||||
)
|
||||
{
|
||||
_operators.Push(operatorNode);
|
||||
}
|
||||
|
||||
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
||||
public bool TryPopOperand(
|
||||
out TNode op
|
||||
)
|
||||
{
|
||||
if (OperandInDepthCount > 0)
|
||||
{
|
||||
op = _operands.Pop();
|
||||
return true;
|
||||
}
|
||||
op = TNode.Empty;
|
||||
return false;
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region depth
|
||||
|
||||
public void DecreaseDepth(
|
||||
)
|
||||
{
|
||||
if (Depth > 1)
|
||||
{
|
||||
DepthMark mark = _depthMarks.Pop();
|
||||
}
|
||||
}
|
||||
|
||||
public void IncreaseDepth(
|
||||
int mark
|
||||
)
|
||||
{
|
||||
_depthMarks.Push(new DepthMark(_operands.Count, _operators.Count, mark));
|
||||
}
|
||||
|
||||
#endregion
|
||||
}
|
||||
}
|
||||
|
||||
@@ -49,9 +49,9 @@ namespace StgSharp.RegularAnalysis.Abstraction
|
||||
|
||||
TNode Next { get; set; }
|
||||
|
||||
TNode Left { get; }
|
||||
TNode Left { get; set; }
|
||||
|
||||
TNode Right { get; }
|
||||
TNode Right { get; set; }
|
||||
|
||||
static abstract TNode Empty { get; }
|
||||
|
||||
|
||||
Reference in New Issue
Block a user