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

Normalize all existing files to LF

Browse Source
This commit is contained in:
Youmu Liu
2026-03-06 18:31:11 +08:00
parent 0a0af53af1
commit 2149bbeede
323 changed files with 113191 additions and 113191 deletions
Download Patch File Download Diff File Expand all files Collapse all files
StgSharp.Script/Common/AbstractSyntaxTree.cs
+57 -57
View File
@@ -1,57 +1,57 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="AbstractSyntaxTree"
// 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.Collections;
using System;
using System.Collections.Generic;
using System.Text;
using System.Xml.Schema;
namespace StgSharp.Script
{
public sealed class AbstractSyntaxTree<TNode, TType> where TNode: ISyntaxNode<TNode, TType>
where TType: ITypeSource<TType>
{
private List<TNode> _allToken = new();
private TNode _root;
public int Count
{
get { return _allToken.Count; }
}
public TNode Root => _root;
public bool Contains(TNode node)
{
return _allToken.Contains(node);
}
}
}
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="AbstractSyntaxTree"
// 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.Collections;
using System;
using System.Collections.Generic;
using System.Text;
using System.Xml.Schema;
namespace StgSharp.Script
{
public sealed class AbstractSyntaxTree<TNode, TType> where TNode: ISyntaxNode<TNode, TType>
where TType: ITypeSource<TType>
{
private List<TNode> _allToken = new();
private TNode _root;
public int Count
{
get { return _allToken.Count; }
}
public TNode Root => _root;
public bool Contains(TNode node)
{
return _allToken.Contains(node);
}
}
}
StgSharp.Script/Common/CodeLineHelper.cs
+100 -100
View File
@@ -1,100 +1,100 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="CodeLineHelper"
// 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 System;
using System.Collections.Generic;
using System.Text;
namespace StgSharp.Script
{
public static class CodeLineHelper
{
public static string SliceAndTrim(this string line, int startIndex)
{
if (line == null) {
throw new ArgumentNullException(nameof(line));
}
if (startIndex < 0 || startIndex >= line.Length) {
throw new ArgumentOutOfRangeException(nameof(startIndex));
}
ReadOnlySpan<char> sourceSpan = line.AsSpan();
ReadOnlySpan<char> subSpan = sourceSpan.Slice(startIndex);
int start = 0;
while (start < subSpan.Length && char.IsWhiteSpace(subSpan[start])) {
start++;
}
int end = subSpan.Length - 1;
while (end >= start && char.IsWhiteSpace(subSpan[end])) {
end--;
}
if (start > end) {
return string.Empty;
}
int finalLength = end - start + 1;
return new string(subSpan.Slice(start, finalLength));
}
public static string SliceAndTrim(this string line, int startIndex, int length)
{
if (line == null) {
throw new ArgumentNullException(nameof(line));
}
if (startIndex < 0 || startIndex >= line.Length) {
throw new ArgumentOutOfRangeException(nameof(startIndex));
}
if (length < 0 || startIndex + length > line.Length) {
throw new ArgumentOutOfRangeException(nameof(length));
}
ReadOnlySpan<char> sourceSpan = line.AsSpan();
ReadOnlySpan<char> subSpan = sourceSpan.Slice(startIndex, length);
int start = 0;
while (start < subSpan.Length && char.IsWhiteSpace(subSpan[start])) {
start++;
}
int end = subSpan.Length - 1;
while (end >= start && char.IsWhiteSpace(subSpan[end])) {
end--;
}
if (start > end) {
return string.Empty;
}
int finalLength = end - start + 1;
return new string(subSpan.Slice(start, finalLength));
}
}
}
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="CodeLineHelper"
// 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 System;
using System.Collections.Generic;
using System.Text;
namespace StgSharp.Script
{
public static class CodeLineHelper
{
public static string SliceAndTrim(this string line, int startIndex)
{
if (line == null) {
throw new ArgumentNullException(nameof(line));
}
if (startIndex < 0 || startIndex >= line.Length) {
throw new ArgumentOutOfRangeException(nameof(startIndex));
}
ReadOnlySpan<char> sourceSpan = line.AsSpan();
ReadOnlySpan<char> subSpan = sourceSpan.Slice(startIndex);
int start = 0;
while (start < subSpan.Length && char.IsWhiteSpace(subSpan[start])) {
start++;
}
int end = subSpan.Length - 1;
while (end >= start && char.IsWhiteSpace(subSpan[end])) {
end--;
}
if (start > end) {
return string.Empty;
}
int finalLength = end - start + 1;
return new string(subSpan.Slice(start, finalLength));
}
public static string SliceAndTrim(this string line, int startIndex, int length)
{
if (line == null) {
throw new ArgumentNullException(nameof(line));
}
if (startIndex < 0 || startIndex >= line.Length) {
throw new ArgumentOutOfRangeException(nameof(startIndex));
}
if (length < 0 || startIndex + length > line.Length) {
throw new ArgumentOutOfRangeException(nameof(length));
}
ReadOnlySpan<char> sourceSpan = line.AsSpan();
ReadOnlySpan<char> subSpan = sourceSpan.Slice(startIndex, length);
int start = 0;
while (start < subSpan.Length && char.IsWhiteSpace(subSpan[start])) {
start++;
}
int end = subSpan.Length - 1;
while (end >= start && char.IsWhiteSpace(subSpan[end])) {
end--;
}
if (start > end) {
return string.Empty;
}
int finalLength = end - start + 1;
return new string(subSpan.Slice(start, finalLength));
}
}
}
StgSharp.Script/Common/CompileDepthState.cs
+73 -73
View File
@@ -1,73 +1,73 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="CompileDepthState"
// 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 System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.Script
{
public interface ICompileDepthState
{
string CurrentState { get; set; }
}
public class CompileDepthMark
{
internal CompileDepthMark(int operatorBegin, int operandBegin, int usage)
{
OperatorBegin = operatorBegin;
OperandBegin = operandBegin;
Usage = usage;
}
internal CompileDepthMark(int operatorBegin, int operandBegin, int usage, ICompileDepthState stateCache)
{
OperatorBegin = operatorBegin;
OperandBegin = operandBegin;
Usage = usage;
StateCache = stateCache;
}
public bool IsBeginOfBlock { get; internal set; }
public ICompileDepthState StateCache { get; internal set; }
public int OperandBegin { get; internal set; }
public int OperatorBegin { get; internal set; }
public int Usage { get; internal set; }
}
}
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="CompileDepthState"
// 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 System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.Script
{
public interface ICompileDepthState
{
string CurrentState { get; set; }
}
public class CompileDepthMark
{
internal CompileDepthMark(int operatorBegin, int operandBegin, int usage)
{
OperatorBegin = operatorBegin;
OperandBegin = operandBegin;
Usage = usage;
}
internal CompileDepthMark(int operatorBegin, int operandBegin, int usage, ICompileDepthState stateCache)
{
OperatorBegin = operatorBegin;
OperandBegin = operandBegin;
Usage = usage;
StateCache = stateCache;
}
public bool IsBeginOfBlock { get; internal set; }
public ICompileDepthState StateCache { get; internal set; }
public int OperandBegin { get; internal set; }
public int OperatorBegin { get; internal set; }
public int Usage { get; internal set; }
}
}
StgSharp.Script/Common/CompileStack.cs
+329 -329
View File
@@ -1,329 +1,329 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="CompileStack"
// 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.Collections;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.Script
{
public partial class CompileStack<TNode, TType> where TNode: ISyntaxNode<TNode, TType>
where TType: ITypeSource<TType>
{
private Token? _lastToken;
private TNode[] _nodeArray = new TNode[4];
private Token[] _operatorArray = new Token[4];
private Token[] _tokenArray = new Token[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;
public CompileStack()
{
_depthStack.Push(new CompileDepthMark(0, 0, 0, null!));
_statementCache.Push(new Stack<TNode>());
}
public bool IsLastAddedOperator { get; private set; }
public CompileDepthMark CurrentDepthMark
{
get => _depthStack.Peek();
}
public int Depth => _depthStack.Count;
public int OperandCount => _isNode.Count;
public int OperatorCount => _operatorCount;
public int OperatorAheadOfDepth
{
get => OperatorCount - _depthStack.Peek().OperatorBegin;
}
public int OperandAheadOfDepth
{
get => OperandCount - _depthStack.Peek().OperandBegin;
}
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 operandToken)
{
OperandIndex index = _isNode[i];
if (index.IsNode)
{
operandNode = _nodeArray[index.Index];
operandToken = Token.Empty;
return true;
} else
{
operandToken = _tokenArray[index.Index];
operandNode = default!;
return false;
}
}
public bool GetOperandAt(CompileDepthMark depth, Index i, out Token operandToken, out TNode operandNode)
{
OperandIndex index = _isNode[i];
_depthStack.Contains(depth);
if (index.IsNode)
{
operandNode = _nodeArray[index.Index];
operandToken = Token.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 t, out TNode n)
{
if (OperandAheadOfDepth <= 0)
{
t = Token.Empty;
n = TNode.Empty;
return false;
}
if (_isNode.Pop().IsNode)
{
t = Token.Empty;
n = _nodeArray[_nodeCount - 1];
return true;
} else
{
t = _tokenArray[_tokenCount - 1];
n = TNode.Empty;
return false;
}
}
public Token PeekOperator()
{
if (OperatorAheadOfDepth > 0) {
return _operatorArray[_operatorCount - 1];
}
return Token.Empty;
}
public bool PopOperand(out Token t, out TNode n)
{
if (OperandAheadOfDepth <= 0)
{
t = Token.Empty;
n = TNode.Empty;
return false;
}
if (_isNode.Pop().IsNode)
{
t = Token.Empty;
n = _nodeArray[--_nodeCount];
return true;
} else
{
t = _tokenArray[--_tokenCount];
n = TNode.Empty;
return false;
}
}
public Token PopOperator()
{
if (OperatorAheadOfDepth > 0)
{
_operatorCount--;
return _operatorArray[_operatorCount];
}
return Token.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 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 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 t, out TNode n)
{
if (OperandAheadOfDepth <= 0)
{
t = Token.Empty;
n = TNode.Empty;
isNode = false;
return false;
}
if (_isNode.Pop().IsNode)
{
t = Token.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 op)
{
if (OperatorAheadOfDepth > 0)
{
op = _operatorArray[_operatorCount - 1];
return true;
}
op = Token.Empty;
return false;
}
public bool TryPopOperand(out bool isNode, out Token t, out TNode n)
{
if (OperandAheadOfDepth <= 0)
{
t = Token.Empty;
n = TNode.Empty;
isNode = false;
return false;
}
if (_isNode.Pop().IsNode)
{
t = Token.Empty;
n = _nodeArray[--_nodeCount];
isNode = true;
return true;
} else
{
t = _tokenArray[--_tokenCount];
n = TNode.Empty;
isNode = false;
return true;
}
}
public bool TryPopOperator(out Token op)
{
if (OperatorAheadOfDepth > 0)
{
op = _operatorArray[--_operatorCount];
return true;
}
op = Token.Empty;
return false;
}
private record struct OperandIndex(bool IsNode, int Index);
}
}
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="CompileStack"
// 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.Collections;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.Script
{
public partial class CompileStack<TNode, TType> where TNode: ISyntaxNode<TNode, TType>
where TType: ITypeSource<TType>
{
private Token? _lastToken;
private TNode[] _nodeArray = new TNode[4];
private Token[] _operatorArray = new Token[4];
private Token[] _tokenArray = new Token[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;
public CompileStack()
{
_depthStack.Push(new CompileDepthMark(0, 0, 0, null!));
_statementCache.Push(new Stack<TNode>());
}
public bool IsLastAddedOperator { get; private set; }
public CompileDepthMark CurrentDepthMark
{
get => _depthStack.Peek();
}
public int Depth => _depthStack.Count;
public int OperandCount => _isNode.Count;
public int OperatorCount => _operatorCount;
public int OperatorAheadOfDepth
{
get => OperatorCount - _depthStack.Peek().OperatorBegin;
}
public int OperandAheadOfDepth
{
get => OperandCount - _depthStack.Peek().OperandBegin;
}
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 operandToken)
{
OperandIndex index = _isNode[i];
if (index.IsNode)
{
operandNode = _nodeArray[index.Index];
operandToken = Token.Empty;
return true;
} else
{
operandToken = _tokenArray[index.Index];
operandNode = default!;
return false;
}
}
public bool GetOperandAt(CompileDepthMark depth, Index i, out Token operandToken, out TNode operandNode)
{
OperandIndex index = _isNode[i];
_depthStack.Contains(depth);
if (index.IsNode)
{
operandNode = _nodeArray[index.Index];
operandToken = Token.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 t, out TNode n)
{
if (OperandAheadOfDepth <= 0)
{
t = Token.Empty;
n = TNode.Empty;
return false;
}
if (_isNode.Pop().IsNode)
{
t = Token.Empty;
n = _nodeArray[_nodeCount - 1];
return true;
} else
{
t = _tokenArray[_tokenCount - 1];
n = TNode.Empty;
return false;
}
}
public Token PeekOperator()
{
if (OperatorAheadOfDepth > 0) {
return _operatorArray[_operatorCount - 1];
}
return Token.Empty;
}
public bool PopOperand(out Token t, out TNode n)
{
if (OperandAheadOfDepth <= 0)
{
t = Token.Empty;
n = TNode.Empty;
return false;
}
if (_isNode.Pop().IsNode)
{
t = Token.Empty;
n = _nodeArray[--_nodeCount];
return true;
} else
{
t = _tokenArray[--_tokenCount];
n = TNode.Empty;
return false;
}
}
public Token PopOperator()
{
if (OperatorAheadOfDepth > 0)
{
_operatorCount--;
return _operatorArray[_operatorCount];
}
return Token.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 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 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 t, out TNode n)
{
if (OperandAheadOfDepth <= 0)
{
t = Token.Empty;
n = TNode.Empty;
isNode = false;
return false;
}
if (_isNode.Pop().IsNode)
{
t = Token.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 op)
{
if (OperatorAheadOfDepth > 0)
{
op = _operatorArray[_operatorCount - 1];
return true;
}
op = Token.Empty;
return false;
}
public bool TryPopOperand(out bool isNode, out Token t, out TNode n)
{
if (OperandAheadOfDepth <= 0)
{
t = Token.Empty;
n = TNode.Empty;
isNode = false;
return false;
}
if (_isNode.Pop().IsNode)
{
t = Token.Empty;
n = _nodeArray[--_nodeCount];
isNode = true;
return true;
} else
{
t = _tokenArray[--_tokenCount];
n = TNode.Empty;
isNode = false;
return true;
}
}
public bool TryPopOperator(out Token op)
{
if (OperatorAheadOfDepth > 0)
{
op = _operatorArray[--_operatorCount];
return true;
}
op = Token.Empty;
return false;
}
private record struct OperandIndex(bool IsNode, int Index);
}
}
StgSharp.Script/Common/IScriptSourceProvider.cs
+59 -59
View File
@@ -1,59 +1,59 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="IScriptSourceProvider"
// 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 System;
using System.Collections.Generic;
using System.Text;
namespace StgSharp.Script
{
public interface IScriptSourceProvider
{
bool IsEmpty { get; }
int Location { get; }
void EndWriting();
string ReadLine();
string ReadLine(out int position);
/// <summary>
/// Return part of current provider.
/// </summary>
/// <param name="count">
/// Count of lines to be sliced
/// </param>
/// <returns>
///
/// </returns>
public IScriptSourceProvider Slice(int location, int count);
}
}
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="IScriptSourceProvider"
// 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 System;
using System.Collections.Generic;
using System.Text;
namespace StgSharp.Script
{
public interface IScriptSourceProvider
{
bool IsEmpty { get; }
int Location { get; }
void EndWriting();
string ReadLine();
string ReadLine(out int position);
/// <summary>
/// Return part of current provider.
/// </summary>
/// <param name="count">
/// Count of lines to be sliced
/// </param>
/// <returns>
///
/// </returns>
public IScriptSourceProvider Slice(int location, int count);
}
}
StgSharp.Script/Common/IScriptTokenReader.cs
+39 -39
View File
@@ -1,40 +1,40 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="IScriptTokenReader"
// 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.
//
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
namespace StgSharp.Script
{
public interface IScriptTokenReader
{
bool IsEmpty { get; }
Token ReadToken();
bool TryReadToken(out Token t);
}
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="IScriptTokenReader"
// 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.
//
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
namespace StgSharp.Script
{
public interface IScriptTokenReader
{
bool IsEmpty { get; }
Token ReadToken();
bool TryReadToken(out Token t);
}
}
StgSharp.Script/Common/ISyntaxAnalyzer.cs
+35 -35
View File
@@ -1,36 +1,36 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="ISyntaxAnalyzer"
// 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.
//
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
namespace StgSharp.Script
{
public interface ISyntaxAnalyzer
{
void AppendToken(Token t);
}
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="ISyntaxAnalyzer"
// 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.
//
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
namespace StgSharp.Script
{
public interface ISyntaxAnalyzer
{
void AppendToken(Token t);
}
}
StgSharp.Script/Common/ISyntaxNode.cs
+65 -65
View File
@@ -1,65 +1,65 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="ISyntaxNode"
// 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.Collections;
using StgSharp.Script.Express;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
namespace StgSharp.Script
{
public interface ISyntaxNode<TNode, TType> where TNode: ISyntaxNode<TNode, TType> where TType: ITypeSource<TType>
{
long NodeFlag { get; }
string CodeConvertTemplate { get; }
TNode Previous { get; set; }
TNode Next { get; set; }
TNode Left { get; }
TNode Right { get; }
static abstract TNode Empty { get; }
Token Source { get; }
TType EqualityTypeConvert { get; }
void AppendNode(TNode nextToken);
void PrependNode(TNode previusNode);
}
}
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="ISyntaxNode"
// 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.Collections;
using StgSharp.Script.Express;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
namespace StgSharp.Script
{
public interface ISyntaxNode<TNode, TType> where TNode: ISyntaxNode<TNode, TType> where TType: ITypeSource<TType>
{
long NodeFlag { get; }
string CodeConvertTemplate { get; }
TNode Previous { get; set; }
TNode Next { get; set; }
TNode Left { get; }
TNode Right { get; }
static abstract TNode Empty { get; }
Token Source { get; }
TType EqualityTypeConvert { get; }
void AppendNode(TNode nextToken);
void PrependNode(TNode previusNode);
}
}
StgSharp.Script/Common/ITypeSource.cs
+42 -42
View File
@@ -1,42 +1,42 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="ITypeSource"
// 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 System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.Script
{
public interface ITypeSource<in TConvert> where TConvert: ITypeSource<TConvert>
{
bool IsConvertable(TConvert targetType);
}
}
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="ITypeSource"
// 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 System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.Script
{
public interface ITypeSource<in TConvert> where TConvert: ITypeSource<TConvert>
{
bool IsConvertable(TConvert targetType);
}
}
StgSharp.Script/Common/ScriptSourceTransmitter.cs
+151 -151
View File
@@ -1,151 +1,151 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="ScriptSourceTransmitter"
// 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 System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
namespace StgSharp.Script
{
/// <summary>
/// Transmit a continuous part of script code to interpreter or compiler. This transmitter is
/// designed for single-thread-write and single-thread read. Any multi thread operation will
/// cause undefined behaviour.
/// </summary>
public class ScriptSourceTransmitter : IScriptSourceProvider
{
private static ScriptSourceTransmitter _empty = new ScriptSourceTransmitter(
string.Empty, 0, 0)
{
_cache = [],
_buffer = []
};
private string[] _buffer;
private bool _isWriting = true;
private int _begin, _index;
private List<string> _cache;
private readonly string _completeMark;
internal ScriptSourceTransmitter(string[] buffer, int start)
{
_buffer = buffer;
_begin = start;
_isWriting = false;
}
public ScriptSourceTransmitter(string endMark, int start)
{
_cache = new List<string>();
_completeMark = endMark;
_begin = start;
_index = 0;
}
public ScriptSourceTransmitter(string endMark, int start, int capacity)
{
_cache = new List<string>(capacity);
_completeMark = endMark;
_begin = start;
_index = 0;
}
public bool IsEmpty => _isWriting ? (_cache.Count == 0) : (_buffer.Length == 0) || (_index >= _buffer.Length);
public bool IsFrozen => !_isWriting;
public int Location => _begin + _index;
public static ScriptSourceTransmitter Empty => _empty;
public void EndWriting()
{
if (!_isWriting) {
return;
}
_isWriting = false;
_buffer = _cache.ToArray();
_cache = null!;
}
public string ReadLine()
{
if (_isWriting) {
throw new InvalidOperationException("Cannot read before all writing operation.");
}
if (_index >= _buffer.Length) {
return string.Empty;
}
string str = _buffer[_index];
_index++;
return str;
}
public string ReadLine(out int position)
{
if (_isWriting) {
throw new InvalidOperationException("Cannot read before all writing operation.");
}
if (_index >= _buffer.Length)
{
position = -1;
return string.Empty;
}
position = _begin + _index;
string str = _buffer[_index];
_index++;
return str;
}
public IScriptSourceProvider Slice(int location, int count)
{
ArgumentOutOfRangeException.ThrowIfLessThan(location, _begin);
ArgumentOutOfRangeException.ThrowIfGreaterThan(
location + count, _begin + _buffer.Length);
return new ScriptSourceTransmitter(
_buffer.AsSpan().Slice(location, count).ToArray(), location);
}
public void WriteLine(string line)
{
if (!_isWriting) {
return;
}
if (string.Equals(_completeMark, line))
{
EndWriting();
return;
}
_cache.Add(line);
}
}
}
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="ScriptSourceTransmitter"
// 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 System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
namespace StgSharp.Script
{
/// <summary>
/// Transmit a continuous part of script code to interpreter or compiler. This transmitter is
/// designed for single-thread-write and single-thread read. Any multi thread operation will
/// cause undefined behaviour.
/// </summary>
public class ScriptSourceTransmitter : IScriptSourceProvider
{
private static ScriptSourceTransmitter _empty = new ScriptSourceTransmitter(
string.Empty, 0, 0)
{
_cache = [],
_buffer = []
};
private string[] _buffer;
private bool _isWriting = true;
private int _begin, _index;
private List<string> _cache;
private readonly string _completeMark;
internal ScriptSourceTransmitter(string[] buffer, int start)
{
_buffer = buffer;
_begin = start;
_isWriting = false;
}
public ScriptSourceTransmitter(string endMark, int start)
{
_cache = new List<string>();
_completeMark = endMark;
_begin = start;
_index = 0;
}
public ScriptSourceTransmitter(string endMark, int start, int capacity)
{
_cache = new List<string>(capacity);
_completeMark = endMark;
_begin = start;
_index = 0;
}
public bool IsEmpty => _isWriting ? (_cache.Count == 0) : (_buffer.Length == 0) || (_index >= _buffer.Length);
public bool IsFrozen => !_isWriting;
public int Location => _begin + _index;
public static ScriptSourceTransmitter Empty => _empty;
public void EndWriting()
{
if (!_isWriting) {
return;
}
_isWriting = false;
_buffer = _cache.ToArray();
_cache = null!;
}
public string ReadLine()
{
if (_isWriting) {
throw new InvalidOperationException("Cannot read before all writing operation.");
}
if (_index >= _buffer.Length) {
return string.Empty;
}
string str = _buffer[_index];
_index++;
return str;
}
public string ReadLine(out int position)
{
if (_isWriting) {
throw new InvalidOperationException("Cannot read before all writing operation.");
}
if (_index >= _buffer.Length)
{
position = -1;
return string.Empty;
}
position = _begin + _index;
string str = _buffer[_index];
_index++;
return str;
}
public IScriptSourceProvider Slice(int location, int count)
{
ArgumentOutOfRangeException.ThrowIfLessThan(location, _begin);
ArgumentOutOfRangeException.ThrowIfGreaterThan(
location + count, _begin + _buffer.Length);
return new ScriptSourceTransmitter(
_buffer.AsSpan().Slice(location, count).ToArray(), location);
}
public void WriteLine(string line)
{
if (!_isWriting) {
return;
}
if (string.Equals(_completeMark, line))
{
EndWriting();
return;
}
_cache.Add(line);
}
}
}
StgSharp.Script/Common/Token.cs
+82 -82
View File
@@ -1,82 +1,82 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="Token"
// 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 System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.Script
{
public readonly struct Token
{
private static Token EmptyToken = new Token();
public readonly int Column;
public readonly int Line;
public readonly string Value;
public readonly TokenFlag Flag;
public Token(string chars, int lineNumber, int columnNumber, TokenFlag flag)
{
Value = chars;
Line = lineNumber;
Column = columnNumber;
Flag = flag;
}
public static Token Empty => EmptyToken;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public Token ReLocate(int line, int column)
{
return new Token(Value, line, column, Flag);
}
}
public enum TokenFlag : int
{
None = 0,
Symbol_Unary = 1,
Symbol_Binary = 2,
Number = 3,
String = 4,
Member = 5,
Separator_Middle = 6,
Separator_Left = 7,
Separator_Right = 8,
Index_Left = 9,
Index_Right = 10,
Enum = 11
}
}
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="Token"
// 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 System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.Script
{
public readonly struct Token
{
private static Token EmptyToken = new Token();
public readonly int Column;
public readonly int Line;
public readonly string Value;
public readonly TokenFlag Flag;
public Token(string chars, int lineNumber, int columnNumber, TokenFlag flag)
{
Value = chars;
Line = lineNumber;
Column = columnNumber;
Flag = flag;
}
public static Token Empty => EmptyToken;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public Token ReLocate(int line, int column)
{
return new Token(Value, line, column, Flag);
}
}
public enum TokenFlag : int
{
None = 0,
Symbol_Unary = 1,
Symbol_Binary = 2,
Number = 3,
String = 4,
Member = 5,
Separator_Middle = 6,
Separator_Left = 7,
Separator_Right = 8,
Index_Left = 9,
Index_Right = 10,
Enum = 11
}
}