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

MulAvailable

Browse Source
This commit is contained in:
Nitload
2025-12-16 23:13:17 +08:00
parent 28ea5d1d1e
commit 3486375470
2637 changed files with 23787 additions and 838773 deletions
Download Patch File Download Diff File Expand all files Collapse all files
StgSharp.Model/Step/Analyser/ExpSyntaxAnalyzer.Common.cs
+303
View File
@@ -0,0 +1,303 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="ExpSyntaxAnalyzer.Common"
// 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 Microsoft.CodeAnalysis.CSharp.Syntax;
using StgSharp.Script;
using StgSharp.Script.Express;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Xml.Schema;
using ExpKeyword = StgSharp.Script.Express.ExpressCompile.Keyword;
namespace StgSharp.Model.Step
{
internal partial class StepExpSyntaxAnalyzer
{
private static Regex _entityTypeCheckPattern = GetEntityTypeCheckPattern();
private StepDependencyDetector _dependencyDetector = new StepDependencyDetector();
[GeneratedRegex(@"^[A-Z0-9_]+$", RegexOptions.Singleline)]
private static partial Regex GetEntityTypeCheckPattern();
private bool IsSeparatorMatch(Token leftSeparator, Token rightSeparator)
{
return leftSeparator.Value switch
{
ExpKeyword.LeftBrace => rightSeparator.Value == ExpKeyword.RightBrace,
ExpKeyword.LeftParen => rightSeparator.Value == ExpKeyword.RightParen,
ExpKeyword.Comma => rightSeparator.Value == ExpKeyword.Comma,
ExpKeyword.Semicolon => rightSeparator.Value == ExpKeyword.Semicolon,
_ => false
};
}
private bool TryAppendIndexLeft(Token t)
{
if (t.Flag != TokenFlag.Index_Left) {
return false;
}
if (_cache.TryPeekOperand(out bool isNode, out _, out ExpSyntaxNode? node))
{
if (node.EqualityTypeConvert is not ExpCollectionBase) {
ExpInvalidSyntaxException.ThrowNonCollectionIndex(t);
}
}
_cache.PushOperator(t);
_cache.IncreaseDepth((int)ExpCompileStateCode.CollectionIndex);
return true;
}
private bool TryAppendIndexRight(Token t)
{
if (t.Flag != TokenFlag.Index_Right) {
return false;
}
// reverse building
ClosePrefixReverse(t);
// make index node
_cache.PopOperand(out _, out ExpSyntaxNode? expNode);
if (!_cache.PopOperand(out Token colleToken, out ExpSyntaxNode? colleNode)) { }
_cache.PushOperand(
ExpCollectionIndexNode.Create(
t, (colleNode as ExpCollectionInstanceBase)!, expNode));
return true;
}
private bool TryAppendMember(Token t)
{
if (t.Flag != TokenFlag.Member) {
return false;
}
if (TryParseConstant(t)) {
return true;
}
if (TryParseFunction(t)) {
return true;
}
if (TryParseInstance(t)) {
return true;
}
if (TryParseKeyword(t)) {
return true;
}
if (TryParseElementName(t)) {
return true;
}
// Many thing miss here
_cache.PushOperand(ExpElementMemberNameNode.Create(t));
return true;
}
private bool TryAppendMiddleSeparator(Token t)
{
if (t.Flag != TokenFlag.Separator_Middle) {
return false;
}
while (_cache.OperatorAheadOfDepth > 0)
{
_cache.TryPopOperator(out Token op);
ExpSyntaxNode node = ConvertAndPushOneOperator(op);
}
switch (_cache.OperandAheadOfDepth)
{
case 0:
if (t.Value == ";") {
return true;
}
_cache.StatementsInDepth.Push(ExpSyntaxNode.Empty);
goto case 1;
case 1:
_cache.PopOperand(out _, out ExpSyntaxNode? statement);
if (t.Value == ";")
{
StepEntityDefineSequence sequence = new StepEntityDefineSequence(
statement, _dependencyDetector.ExportAllDependencies());
StepEntityInitStatements.Enqueue(sequence);
} else
{
_cache.StatementsInDepth.Push(statement);
}
return true;
default:
ExpInvalidSyntaxException.ThrowNoOperator(t);
break;
}
return true;
}
private bool TryAppendNumAndStrLiteral(Token t)
{
if ((t.Flag & (TokenFlag.String | TokenFlag.Number)) == 0) {
return false;
}
_cache.PushOperand(ExpElementInstance.CreateLiteral(t));
return true;
}
private bool TryAppendPrefixSeparator(Token t)
{
if (t.Flag != TokenFlag.Separator_Left) {
return false;
}
_cache.PushOperator(t);
_cache.IncreaseDepth((int)ExpCompileStateCode.Common);
return true;
}
private bool TryAppendPrefixSeparatorEnd(Token t)
{
if (t.Flag != TokenFlag.Separator_Right) {
return false;
}
ClosePrefixReverse(t);
return true;
}
private bool TryAppendSymbol(Token t)
{
if ((t.Flag & (TokenFlag.Symbol_Unary | TokenFlag.Symbol_Binary)) == 0) {
return false;
}
int cmp = -1;
processPrecedence:
if (_cache.TryPeekOperator(out Token tmp))
{
cmp = CompareOperatorPrecedence(t, tmp);
if (cmp >= 0)
{
_cache.PopOperator();
ExpSyntaxNode node = ConvertAndPushOneOperator(tmp);
goto processPrecedence;
}
}
_cache.PushOperator(t);
return true;
}
private bool TryParseConstant(Token t)
{
switch (t.Value)
{
case "$":
_cache.PushOperand(StepEntityInstanceNode.RegisterNull(t));
return true;
case "*":
_cache.PushOperand(StepEntityInstanceNode.RegisterRuntimeInference(t));
return true;
case ExpKeyword.E:
_cache.PushOperand(new ExpRealNumberNode(t, MathF.E, true));
return true;
case ExpKeyword.Pi:
_cache.PushOperand(new ExpRealNumberNode(t, MathF.PI, true));
return true;
default:
if (ExpElementInstance.TryCreateLiteral(t, out ExpElementInstance? node))
{
_cache.PushOperand(node);
return true;
}
return false;
}
}
private bool TryParseElementName(Token t)
{
if (_context.TryGetType(t.Value, out ExpTypeSource? type))
{
_cache.PushOperand(ExpMetaRefNode.RefType(t, type));
return true;
}
if (_context.TryGetEntity(t.Value, out ExpEntitySource? entity))
{
_cache.PushOperand(ExpMetaRefNode.RefEntity(t, entity));
return true;
}
return false;
}
private bool TryParseFunction(Token t)
{
if (_entityTypeCheckPattern.IsMatch(t.Value))
{
if (_cache.PeekOperator().Flag == TokenFlag.Member)
{
Token op = _cache.PopOperator();
ConvertAndPushOneOperator(op);
}
_cache.PushOperator(t);
return true;
}
return false;
}
private bool TryParseInstance(Token t)
{
if (t.Value[0] == '#')
{
StepEntityInstanceNode node = StepEntityInstanceNode.Register(t);
if (t.Column != 0) {
_dependencyDetector.AddDependency(node);
}
_cache.PushOperand(node);
return true;
}
return false;
}
private bool TryParseKeyword(Token t)
{
switch (t.Value)
{
case ExpKeyword.Return:
_cache.PushOperator(t);
return true;
case ExpKeyword.Skip:
_cache.PushOperand(ExpProcedureControlNode.Skip(t));
return true;
default:
return false;
}
}
}
}
StgSharp.Model/Step/Analyser/ExpSyntaxAnalyzer.Enum.cs
+65
View File
@@ -0,0 +1,65 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="ExpSyntaxAnalyzer.Enum"
// 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.Script;
using StgSharp.Script.Express;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.Model.Step
{
internal partial class StepExpSyntaxAnalyzer
{
private static string ParseStepEnumLiteral(string source)
{
int length = source.Length;
ReadOnlySpan<char> span = source.AsSpan();
if (length > 2 && span[0] == '.' && span[length - 1] == '.') {
return span.Slice(1, length - 2).ToString();
}
throw new ExpInvalidSyntaxException($"\"{source}\" is not a valid enum syntax");
}
private void TryAppendEnum(Token e)
{
ExpSyntaxNode node = e.Value switch
{
".T." => new ExpBoolNode(e, true, true),
".F." => new ExpBoolNode(e, false, true),
".U." => new ExpLogicValueNode(e, ExpLogic.Unknown, true),
_ => ExpEnumLiteralNode.Create(e, ParseStepEnumLiteral),
};
_cache.PushOperand(node);
}
}
}
StgSharp.Model/Step/Analyser/ExpSyntaxAnalyzer.ErrorProcess.cs
+53
View File
@@ -0,0 +1,53 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="ExpSyntaxAnalyzer.ErrorProcess"
// 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.Model.Step
{
internal partial class StepExpSyntaxAnalyzer
{
public void ThrowCompileException(int errorCode)
{
switch (errorCode)
{
case 0 or 1:
return;
case TokenTypeNotMatch:
throw new Exception();
default:
break;
}
}
}
}
StgSharp.Model/Step/Analyser/ExpSyntaxAnalyzer.OperatorParser.cs
+128
View File
@@ -0,0 +1,128 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="ExpSyntaxAnalyzer.OperatorParser"
// 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.Script;
using StgSharp.Script.Express;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using ExpKeyword = StgSharp.Script.Express.ExpressCompile.Keyword;
namespace StgSharp.Model.Step
{
internal partial class StepExpSyntaxAnalyzer
{
public int CompareOperatorPrecedence(Token left, Token right)
{
ExpressCompile.TryGetOperatorPrecedence(left.Value, out int leftPrecedence);
ExpressCompile.TryGetOperatorPrecedence(right.Value, out int rightPrecedence);
return leftPrecedence - rightPrecedence;
}
public bool TryGenerateUnaryNode(Token t, out ExpSyntaxNode node)
{
ExpSyntaxNode operand = GetNextOperandCache();
switch (t.Value)
{
case ExpKeyword.UnaryPlus:
node = ExpUnaryOperatorNode.UnaryPlus(t, operand);
return true;
case ExpKeyword.UnaryMinus:
node = ExpUnaryOperatorNode.UnaryMinus(t, operand);
return true;
case ExpKeyword.Not:
node = ExpUnaryOperatorNode.UnaryNot(t, operand);
return true;
default:
node = ExpSyntaxNode.Empty;
return false;
}
}
/// <summary>
/// WARNING: This method cannot process INDEXOF, FUNCTION CALLING, LOOP and any ENDING
/// SYMBOLS.
/// </summary>
private ExpSyntaxNode ConvertAndPushOneOperator(Token op)
{
switch (op.Flag)
{
case TokenFlag.Symbol_Unary:
TryGenerateUnaryNode(op, out ExpSyntaxNode? node);
_cache.PushOperand(node);
return node;
case TokenFlag.Symbol_Binary:
TryGenerateBinaryNode(op, out node);
_cache.PushOperand(node);
return node;
case TokenFlag.Member:
_cache.PopOperand(out _, out ExpSyntaxNode? p);
StepEntityInitCaller caller = StepEntityInitCaller.CreateCaller(op.Value);
node = ExpFunctionCallingNode.CallFunction(op, caller, p);
_cache.StatementsInDepth.Push(node);
return node;
default:
throw new NotImplementedException();
}
}
private bool TryGenerateBinaryNode(Token t, out ExpSyntaxNode node)
{
/*
ExpSyntaxNode right = GetNextOperandCache();
ExpSyntaxNode left = GetNextOperandCache();
/**/
switch (t.Value)
{
case "=":
ExpSyntaxNode right = GetNextOperandCache();
ExpSyntaxNode left;
if (right is ExpTupleNode tuple)
{
right = StepComplexEntityNode.FromTuple(tuple);
left = GetNextOperandCache();
} else
{
left = right;
right = _cache.StatementsInDepth.Pop();
}
node = ExpBinaryOperatorNode.Assign(t, left, right);
return true;
default:
node = ExpSyntaxNode.Empty;
return false;
}
}
}
}
StgSharp.Model/Step/Analyser/ExpSyntaxAnalyzer.PrefixReverseAnalysing.cs
+87
View File
@@ -0,0 +1,87 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="ExpSyntaxAnalyzer.PrefixReverseAnalysing"
// 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.Script;
using StgSharp.Script.Express;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using ExpKeyword = StgSharp.Script.Express.ExpressCompile.Keyword;
namespace StgSharp.Model.Step
{
internal partial class StepExpSyntaxAnalyzer
{
private void ClosePrefixReverse(Token rightSeparator)
{
Token op;
ExpSyntaxNode root;
if (_cache.OperatorAheadOfDepth == 0)
{
if (_cache.OperandAheadOfDepth == 1)
{
_cache.PopOperand(out _, out ExpSyntaxNode? statement);
_cache.StatementsInDepth.Push(statement);
} else
{
_cache.StatementsInDepth.Push(ExpSyntaxNode.Empty);
}
} else
{
while (_cache.TryPopOperator(out op))
{
ExpSyntaxNode node = ConvertAndPushOneOperator(op);
}
if (_cache.OperandAheadOfDepth == 1)
{
_cache.PopOperand(out _, out root);
_cache.StatementsInDepth.Push(root);
}
}
root = _cache.PackAllStatements();
_cache.DecreaseDepth();
if (IsSeparatorMatch(_cache.PeekOperator(), rightSeparator))
{
_cache.PopOperator();
root = ExpTupleNode.Pack(root);
_cache.PushOperand(root);
} else
{
throw new ExpCompileException(
rightSeparator, "Ending of block does not match its begging");
}
}
}
}
StgSharp.Model/Step/Analyser/ExpSyntaxAnalyzer.cs
+135
View File
@@ -0,0 +1,135 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="ExpSyntaxAnalyzer"
// 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 Microsoft.CodeAnalysis.CSharp.Syntax;
using StgSharp.Script;
using StgSharp.Script.Express;
using StgSharp.Threading;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO.Pipes;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using ExpKeyword = StgSharp.Script.Express.ExpressCompile.Keyword;
namespace StgSharp.Model.Step
{
internal partial class StepExpSyntaxAnalyzer : ISyntaxAnalyzer
{
private const int EndLine = 1;
private const int TokenGenerated = 0;
private const int TokenTypeNotMatch = -1;
private CompileStack<ExpSyntaxNode, IExpElementSource> _cache;
private ExpSchema _context;
private ExpSyntaxNode _lastStatement;
private IExpElementSource _local;
public StepExpSyntaxAnalyzer()
{
_cache = new CompileStack<ExpSyntaxNode, IExpElementSource>();
_context = new ExpressStepUtil();
}
public ConcurrentQueue<StepEntityDefineSequence> StepEntityInitStatements { get; } = new();
/// <summary>
/// Append a token to top of cache. This method will automatically convert token to node
/// if meets separators or operators.
/// </summary>
public void AppendToken(Token expToken)
{
switch (expToken.Flag)
{
case TokenFlag.Symbol_Unary or TokenFlag.Symbol_Binary:
TryAppendSymbol(expToken);
break;
case TokenFlag.Number or TokenFlag.String:
ExpElementInstance node = ExpElementInstance.CreateLiteral(expToken);
_cache.PushOperand(node);
break;
case TokenFlag.Separator_Left:
TryAppendPrefixSeparator(expToken);
break;
case TokenFlag.Separator_Right:
TryAppendPrefixSeparatorEnd(expToken);
break;
case TokenFlag.Separator_Middle:
TryAppendMiddleSeparator(expToken);
break;
case TokenFlag.Index_Left:
TryAppendIndexLeft(expToken);
break;
case TokenFlag.Index_Right:
TryAppendIndexRight(expToken);
break;
case TokenFlag.Member:
TryAppendMember(expToken);
break;
case TokenFlag.Enum:
TryAppendEnum(expToken);
break;
default:
break;
}
}
public ExpSyntaxNode GetNextOperandCache()
{
if (_cache.PopOperand(out Token t, out ExpSyntaxNode? n))
{
return n;
} else
{
// process some rare case here
}
throw new NotImplementedException();
}
public enum ExpCompileStateCode
{
Common,
ForLoop,
RepeatLoop,
UntilLoop,
IfBranch,
CaseBranch,
CollectionIndex,
}
}
}
StgSharp.Model/Step/Analyser/StepDataSectionsTranmitter.cs
+108
View File
@@ -0,0 +1,108 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="StepDataSectionsTranmitter"
// 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.Script;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.Model.Step
{
public class StepDataSectionTransmitter : IScriptSourceProvider
{
private const string EndDataText = "ENDSEC;";
// private bool _isEmpty;
private ConcurrentQueue<string> _cache = new ConcurrentQueue<string>();
private int _line = 0;
public StepDataSectionTransmitter() { }
public StepDataSectionTransmitter(int begins)
{
Begin = begins;
_line = Begin;
}
public bool IsEmpty => _cache.IsEmpty && !IsWriting;
public bool IsWriting { get; private set; } = true;
public int Begin { get; internal set; }
public int Location => _line;
public void EndWriting()
{
IsWriting = false;
}
public string ReadLine()
{
if (_cache.TryDequeue(out string? line))
{
_line++;
return line;
}
return string.Empty;
}
public string ReadLine(out int position)
{
string ret = ReadLine();
position = _line;
return ret;
}
public void WriteLine(string line)
{
if (line == "DATA;") {
return;
}
if (line == EndDataText)
{
EndWriting();
return;
}
if (IsWriting) {
_cache.Enqueue(line);
}
}
IScriptSourceProvider IScriptSourceProvider.Slice(int location, int count)
{
throw new NotSupportedException();
}
}
}
StgSharp.Model/Step/Analyser/StepDataTokenReader.cs
+165
View File
@@ -0,0 +1,165 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="StepDataTokenReader"
// 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.Model.Step;
using StgSharp.Script;
using StgSharp.Script.Express;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
namespace StgSharp.Model.Step
{
public partial class StepDataTokenReader : IScriptTokenReader
{
private ExpTokenReader _reader;
private HashSet<string> tokenHash = [ "T", "F", "UNSPECIFIED" ];
private Queue<Token> _cache = new Queue<Token>();
private StepDataSectionTransmitter _transmitter;
public StepDataTokenReader(StepDataSectionTransmitter transmitter)
{
_reader = new ExpTokenReader(transmitter);
_reader.TokenReaderPreProcessor = new TokenPreReader();
_transmitter = transmitter;
}
public bool IsEmpty
{
get
{
if (_reader.IsEmpty) {
return !_transmitter.IsWriting;
}
return false;
}
}
public Token ReadToken()
{
return _reader.ReadToken();
}
public bool TryReadToken(out Token t)
{
return _reader.TryReadToken(out t);
}
private partial class TokenPreReader : ExpTokenReaderPreProcessor
{
private static Regex
_nextHashtagSymbolPattern = GetEntityTagSymbolPattern(),
_nextEnumPattern = GetNextEnumPattern(),
_stringPattern = GetStringPattern();
public override bool Process(string codeLine, int line, ref int current, out Token t)
{
ReadOnlySpan<char> chars = codeLine.AsSpan(current);
char c = chars[0];
Match match;
switch (c)
{
case '#':
match = _nextHashtagSymbolPattern.Match(codeLine, current);
if (match.Success)
{
int begin = match.Groups["token"].Index;
int end = match.Groups["end"].Index;
int rest = match.Groups["rest"].Index;
current = rest;
t = new(
ExpressCompile.PoolString(chars[0..(end - begin)]), line,
begin, TokenFlag.Member);
return true;
}
break;
case '.':
match = _nextEnumPattern.Match(codeLine, current);
if (match.Success)
{
int begin = match.Groups["token"].Index;
int end = match.Groups["end"].Index;
int rest = match.Groups["rest"].Index;
current = rest;
t = new Token(
match.Groups["token"].Value, line, begin, TokenFlag.Enum);
return true;
}
break;
case '$':
t = new Token("$", line, current, TokenFlag.Member);
current++;
return true;
case '*':
t = new Token("*", line, current, TokenFlag.Member);
current++;
return true;
case '\'':
match = _stringPattern.Match(codeLine, current);
if (match.Success)
{
int begin = match.Groups["token"].Index;
int end = match.Groups["end"].Index;
int rest = match.Groups["rest"].Index;
current = rest;
string value = chars.Slice(1, (end - begin - 1)).ToString();
if (string.IsNullOrWhiteSpace(value)) {
value = string.Empty;
}
t = new Token(value, line, begin, TokenFlag.String);
return true;
}
break;
default:
break;
}
t = Token.Empty;
return false;
}
[GeneratedRegex(@"(?<token>#[0-9A-Za-z]+)(?<end>\s*?)(?<rest>\S|$)", RegexOptions.Singleline)]
private static partial Regex GetEntityTagSymbolPattern();
[GeneratedRegex(@"(?<token>\.[A-Za-z_]+\.)(?<end>\s*)(?<rest>\S*)", RegexOptions.Singleline)]
private static partial Regex GetNextEnumPattern();
[GeneratedRegex(@"(?<token>')(?>\\\\|''|(?!')[^'])*(?<end>')\s*?(?<rest>\S|$)", RegexOptions.Singleline)]
private static partial Regex GetStringPattern();
}
}
}
StgSharp.Model/Step/Analyser/StepDependencyDetector.cs
+58
View File
@@ -0,0 +1,58 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="StepDependencyDetector"
// 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.Model.Step;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.Model.Step
{
internal class StepDependencyDetector
{
public StepDependencyDetector() { }
public List<int> Dependencies { get; private set; } = new();
public void AddDependency(StepEntityInstanceNode node)
{
Dependencies.Add(node.Id);
}
public IEnumerable<int> ExportAllDependencies()
{
List<int> ret = Dependencies;
Dependencies = new List<int>();
return ret;
}
}
}
StgSharp.Model/Step/Analyser/StepEntityDefineSequence.cs
+53
View File
@@ -0,0 +1,53 @@
//-----------------------------------------------------------------------
// -----------------------------------------------------------------------
// file="StepEntityDefineSequence"
// 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.Script.Express;
using System;
using System.Collections.Generic;
using System.ComponentModel.Design;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StgSharp.Model.Step
{
public record class StepEntityDefineSequence
{
public StepEntityDefineSequence(ExpSyntaxNode node, IEnumerable<int> dep)
{
Expression = node;
Dependencies = dep;
}
public ExpSyntaxNode Expression { get; init; }
public IEnumerable<int> Dependencies { get; init; }
}
}