Daily update on 20250318-203619 by Nitload Youmu. Additional Message : Syntax analyzer rebuilding, a neet and flexible structure introduced

Signed-off-by: Nitload <YoumuLiu_NSI@whv0t.onmicrosoft.com>
2025-03-18 20:36:20 +08:00
parent e3741687a7
commit 5d99be7f3d
36 changed files with 3962 additions and 1904 deletions
@@ -147,6 +147,23 @@ namespace StgSharp.Script.Express
            };
        }

+        public static ExpBinaryOperatorNode LessThan(
+                                                    Token source,
+                                                    ExpNode left,
+                                                    ExpNode right )
+        {
+            if( !left.IsNumber && !right.IsNumber ) {
+                throw new ExpInvalidTypeException(
+                    "Number", left.EqualityTypeConvert.Name );
+            }
+            return new ExpBinaryOperatorNode( source )
+            {
+                _returnType = ExpCompile.ExpBool,
+                _nodeFlag = ExpNodeFlag.BuiltinType_Boolean | ExpNodeFlag.Operator_Binary,
+                CodeConvertTemplate = "{0} < {1}",
+            };
+        }
+
        public static ExpBinaryOperatorNode Mul(
                                                    Token source,
                                                    ExpNode left,
@@ -39,7 +39,7 @@ namespace StgSharp.Script.Express
    public class ExpElementMemberNameNode : ExpNode
    {

-        public ExpElementMemberNameNode( Token source )
+        internal ExpElementMemberNameNode( Token source )
            : base( source )
        {
            _nodeFlag = ExpNodeFlag.Name_Operator;
@@ -62,5 +62,10 @@ namespace StgSharp.Script.Express
            }
        }

+        public static ExpElementMemberNameNode Create( Token t )
+        {
+            return new ExpElementMemberNameNode( t );
+        }
+
    }
 }
@@ -31,6 +31,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading.Tasks;

@@ -39,11 +40,11 @@ namespace StgSharp.Script.Express
    public class ExpInstanceReferenceNode : ExpNode
    {

-        private ExpElementInstanceBase _instance;
+        private ExpElementInstanceNode _instance;

-        public ExpInstanceReferenceNode(
-                       Token source,
-                       ExpElementInstanceBase instance )
+        internal ExpInstanceReferenceNode(
+                         Token source,
+                         ExpElementInstanceNode instance )
            : base( source )
        {
            _instance = instance;
@@ -56,5 +57,13 @@ namespace StgSharp.Script.Express

        public override IExpElementSource EqualityTypeConvert => _instance.EqualityTypeConvert;

+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static ExpInstanceReferenceNode Create(
+                                                       Token source,
+                                                       ExpElementInstanceNode instance )
+        {
+            return new ExpInstanceReferenceNode( source, instance );
+        }
+
    }
 }
@@ -0,0 +1,63 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="ExpNodeGenerator.BranchParser.cs"
+//     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;
+
+using ExpKeyWord = StgSharp.Script.Express.ExpCompile.KeyWord;
+
+namespace StgSharp.Script.Express
+{
+    public partial class ExpNodeGenerator
+    {
+
+        private bool TryParseBranch( Token t )
+        {
+            if( t.Value == ExpKeyWord.Case ) {
+                _cache.PushOperator( t );
+                _cache.IncreaseDepth( ( int )ExpCompileStateCode.CaseBranch );
+                return true;
+            } else if( t.Value == ExpKeyWord.If ) {
+                _cache.PushOperator( t );
+                _cache.IncreaseDepth( ( int )ExpCompileStateCode.IfBranch );
+                return true;
+            } else if( t.Value == ExpKeyWord.Repeat ) {
+                _cache.PushOperator( t );
+                _cache.IncreaseDepth( ( int )ExpCompileStateCode.RepeatLoop );
+                return true;
+            }
+            return false;
+        }
+
+    }
+}
@@ -0,0 +1,108 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="ExpNodeGenerator.OperatorParser.cs"
+//     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;
+
+using ExpKeyWord = StgSharp.Script.Express.ExpCompile.KeyWord;
+
+namespace StgSharp.Script.Express
+{
+    public partial class ExpNodeGenerator
+    {
+
+        public int CompareOperatorPrecedence( Token left, Token right )
+        {
+            ExpCompile.TryGetOperatorPrecedence(
+                left.Value, out int leftPrecedence );
+            ExpCompile.TryGetOperatorPrecedence(
+                right.Value, out int rightPrecedence );
+            return leftPrecedence - rightPrecedence;
+        }
+
+        public bool TryGenerateBinaryNode( Token t, out ExpNode node )
+        {
+            ExpNode left = GetNextOperandCache();
+            ExpNode right = GetNextOperandCache();
+            switch( t.Value ) {
+                case ExpKeyWord.Add:
+                    node = ExpBinaryOperatorNode.Add( t, left, right );
+                    return true;
+                case ExpKeyWord.Sub:
+                    node = ExpBinaryOperatorNode.Sub( t, left, right );
+                    return true;
+                case ExpKeyWord.Mul:
+                    node = ExpBinaryOperatorNode.Mul( t, left, right );
+                    return true;
+                case ExpKeyWord.Div:
+                    node = ExpBinaryOperatorNode.Div( t, left, right );
+                    return true;
+                case ExpKeyWord.Equal:
+                    node = ExpBinaryOperatorNode.EqualTo( t, left, right );
+                    return true;
+                case ExpKeyWord.NotEqual:
+                    node = ExpBinaryOperatorNode.NotEqualTo( t, left, right );
+                    return true;
+                case ExpKeyWord.GreaterThan:
+                    node = ExpBinaryOperatorNode.GreaterThan( t, left, right );
+                    return true;
+                case ExpKeyWord.LessThan:
+                    node = ExpBinaryOperatorNode.LessThan( t, left, right );
+                    return true;
+                default:
+                    node = ExpNode.Empty;
+                    return false;
+            }
+        }
+
+        public bool TryGenerateUnaryNode( Token t, out ExpNode node )
+        {
+            ExpNode 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 = ExpNode.Empty;
+                    return false;
+            }
+        }
+
+    }
+}
@@ -0,0 +1,212 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="ExpNodeGenerator.TokenSpliter.cs"
+//     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;
+
+using ExpKeyWord = StgSharp.Script.Express.ExpCompile.KeyWord;
+
+namespace StgSharp.Script.Express
+{
+    public partial class ExpNodeGenerator
+    {
+
+        private void AppendToken_Common( Token t )
+        {
+            switch( t.Flag ) {
+                // instance ref, make ref and push
+                // function call, push as operator
+                // keyword, call TryParseConstant method to process
+                // name of member in instance, parse as MemberNameNode
+                case TokenFlag.Member:
+                    if( _context.TryGetFunction( t.Value, out _ ) ) {
+                        _cache.PushOperator( t );
+                    } else if( _local.TryGetMember( t.Value,
+                                                    out ExpNode? node ) ) {
+                        if( node is ExpElementInstanceBase instance ) {
+                            _cache.PushOperand( instance.MakeReference( t ) );
+                            return;// ref of an instance
+                        }
+                    } else if( TryParseConstant( t ) ) {
+                        return;
+                    } else if( TryParseFunction( t ) ) {
+                        return;
+                    } else if( TryParseBranch( t ) ) {
+                        return;
+                    } else {
+                        _cache.PushOperand( t );
+                    }
+                    break;
+                case TokenFlag.Separator_Single:         //a , ; found
+                    // if operator stack is not empty, convert all operators to node until meet a same separator
+                    // or OperandAheadOfSeparator property is less than certain value
+                    _cache.PushOperator( t );
+                    break;
+                case TokenFlag.Separator_Left:           //a ( [ { found
+                    // check if the last token is a function name, loop block or branch
+                    _cache.PushOperator( t );
+                    break;
+                case TokenFlag.Separator_Right:          //a } ] ) found
+                    //Convert operator until meet a matched separator
+                    while( _cache.TryPopOperator( out Token op ) ) {
+                        if( IsSeparatorMatch( t, op ) ) {
+                            if( _cache.OperatorAheadOfDepth == 0 ) {
+                                _cache.TryPeekOperand(
+                                    out _, out Token tOperand,
+                                    out ExpNode nOperand );
+
+                                return;
+                            }
+                        } else {
+                            return;
+                        }
+                    }
+
+                    break;
+
+
+                case TokenFlag.Index_Left:               // a [ found
+                    _cache.PushOperand( t );
+                    return;
+                case TokenFlag.Index_Right:              // a ] found
+                    while( _cache.TryPopOperator( out Token op ) ) {
+                        if( op.Value == ExpKeyWord.IndexOf ) { } else { }
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        private bool IsSeparatorMatch( Token source, Token target )
+        {
+            return source.Value switch
+            {
+                ExpKeyWord.LeftBrace => target.Value == ExpKeyWord.RightBrace,
+                ExpKeyWord.LeftParen => target.Value == ExpKeyWord.RightParen,
+                ExpKeyWord.Comma => target.Value == ExpKeyWord.Comma,
+                ExpKeyWord.Semicolon => target.Value == ExpKeyWord.Semicolon,
+                _ => false
+            };
+        }
+
+        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;
+            }
+
+            //Many thing miss here
+
+            _cache.PushOperand( ExpElementMemberNameNode.Create( t ) );
+
+            return true;
+        }
+
+        private bool TryAppendNumAndStrLiteral( Token t )
+        {
+            if( ( t.Flag & ( TokenFlag.String | TokenFlag.Number ) ) == 0 ) {
+                return false;
+            }
+            _cache.PushOperand( ExpElementInstanceBase.CreateLiteral( t ) );
+            return true;
+        }
+
+        private bool TryAppendPrefixSeparator( Token t ) { }
+
+        private bool TryAppendSymbol( Token t )
+        {
+            if( ( t.Flag & ( TokenFlag.Symbol_Unary | TokenFlag.Symbol_Binary ) ) ==
+                0 ) {
+                return false;
+            }
+
+            int cmp = -1;
+            processPrecedence:
+            Token tmp = _cache.PeekOperator();
+            cmp = CompareOperatorPrecedence( t, tmp );
+            if( cmp <= 0 ) {
+                ConvertOneOperator();
+                goto processPrecedence;
+            }
+            _cache.PushOperand( t );
+            return true;
+        }
+
+        private bool TryParseConstant( Token t )
+        {
+            if( t.Value == ExpKeyWord.True ) {
+                _cache.PushOperand( new ExpBoolNode( t, true ) );
+                return true;
+            } else if( t.Value == ExpKeyWord.False ) {
+                _cache.PushOperand( new ExpBoolNode( t, false ) );
+                return true;
+            }
+            return false;
+        }
+
+        private bool TryParseFunction( Token t )
+        {
+            if( ExpKeyWord.BuiltinFunctions.Contains( t.Value ) ) {
+                _cache.PushOperator( t );
+                return true;
+            } else if( _context.TryGetFunction(
+                       t.Value, out ExpFunctionSource? f ) ) {
+                _cache.PushOperand( t );
+                return true;
+            }
+            return false;
+        }
+
+        private bool TryParseInstance( Token t )
+        {
+            if( _local.TryGetMember( t.Value,
+                                     out ExpNode? node ) && node is ExpElementInstanceNode instance ) {
+                _cache.PushOperand(
+                    ExpInstanceReferenceNode.Create( t, instance ) );
+                return true;
+            }
+            return false;
+        }
+
+    }
+}
@@ -107,16 +107,17 @@ namespace StgSharp.Script.Express

        /**/

-        public enum StateCode
+        public enum ExpCompileStateCode
        {

            Common,
-            FunctionCalling,
            ForLoop,
            RepeatLoop,
            UntilLoop,
            IfBranch,
            CaseBranch,
+            PrefixSeparator,
+            MiddleSeparator,

        }

@@ -9,6 +9,7 @@
      "StgSharp.Script/1.0.0": {
        "dependencies": {
          "CommunityToolkit.HighPerformance": "8.4.0",
+          "Microsoft.CodeAnalysis.CSharp": "4.13.0",
          "StgSharp.Common": "1.0.0"
        },
        "runtime": {
@@ -23,7 +24,123 @@
          }
        }
      },
+      "Microsoft.CodeAnalysis.Analyzers/3.11.0": {},
+      "Microsoft.CodeAnalysis.Common/4.13.0": {
+        "dependencies": {
+          "Microsoft.CodeAnalysis.Analyzers": "3.11.0",
+          "System.Collections.Immutable": "8.0.0",
+          "System.Reflection.Metadata": "8.0.0"
+        },
+        "runtime": {
+          "lib/net8.0/Microsoft.CodeAnalysis.dll": {
+            "assemblyVersion": "4.13.0.0",
+            "fileVersion": "4.1300.25.12011"
+          }
+        },
+        "resources": {
+          "lib/net8.0/cs/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "cs"
+          },
+          "lib/net8.0/de/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "de"
+          },
+          "lib/net8.0/es/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "es"
+          },
+          "lib/net8.0/fr/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "fr"
+          },
+          "lib/net8.0/it/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "it"
+          },
+          "lib/net8.0/ja/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "ja"
+          },
+          "lib/net8.0/ko/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "ko"
+          },
+          "lib/net8.0/pl/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "pl"
+          },
+          "lib/net8.0/pt-BR/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "pt-BR"
+          },
+          "lib/net8.0/ru/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "ru"
+          },
+          "lib/net8.0/tr/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "tr"
+          },
+          "lib/net8.0/zh-Hans/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "zh-Hans"
+          },
+          "lib/net8.0/zh-Hant/Microsoft.CodeAnalysis.resources.dll": {
+            "locale": "zh-Hant"
+          }
+        }
+      },
+      "Microsoft.CodeAnalysis.CSharp/4.13.0": {
+        "dependencies": {
+          "Microsoft.CodeAnalysis.Analyzers": "3.11.0",
+          "Microsoft.CodeAnalysis.Common": "4.13.0",
+          "System.Collections.Immutable": "8.0.0",
+          "System.Reflection.Metadata": "8.0.0"
+        },
+        "runtime": {
+          "lib/net8.0/Microsoft.CodeAnalysis.CSharp.dll": {
+            "assemblyVersion": "4.13.0.0",
+            "fileVersion": "4.1300.25.12011"
+          }
+        },
+        "resources": {
+          "lib/net8.0/cs/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "cs"
+          },
+          "lib/net8.0/de/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "de"
+          },
+          "lib/net8.0/es/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "es"
+          },
+          "lib/net8.0/fr/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "fr"
+          },
+          "lib/net8.0/it/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "it"
+          },
+          "lib/net8.0/ja/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "ja"
+          },
+          "lib/net8.0/ko/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "ko"
+          },
+          "lib/net8.0/pl/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "pl"
+          },
+          "lib/net8.0/pt-BR/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "pt-BR"
+          },
+          "lib/net8.0/ru/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "ru"
+          },
+          "lib/net8.0/tr/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "tr"
+          },
+          "lib/net8.0/zh-Hans/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "zh-Hans"
+          },
+          "lib/net8.0/zh-Hant/Microsoft.CodeAnalysis.CSharp.resources.dll": {
+            "locale": "zh-Hant"
+          }
+        }
+      },
      "Microsoft.CSharp/4.7.0": {},
+      "System.Collections.Immutable/8.0.0": {},
+      "System.Reflection.Metadata/8.0.0": {
+        "dependencies": {
+          "System.Collections.Immutable": "8.0.0"
+        }
+      },
      "System.Runtime.CompilerServices.Unsafe/6.1.0": {},
      "StgSharp.Common/1.0.0": {
        "dependencies": {
@@ -52,6 +169,27 @@
      "path": "communitytoolkit.highperformance/8.4.0",
      "hashPath": "communitytoolkit.highperformance.8.4.0.nupkg.sha512"
    },
+    "Microsoft.CodeAnalysis.Analyzers/3.11.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-v/EW3UE8/lbEYHoC2Qq7AR/DnmvpgdtAMndfQNmpuIMx/Mto8L5JnuCfdBYtgvalQOtfNCnxFejxuRrryvUTsg==",
+      "path": "microsoft.codeanalysis.analyzers/3.11.0",
+      "hashPath": "microsoft.codeanalysis.analyzers.3.11.0.nupkg.sha512"
+    },
+    "Microsoft.CodeAnalysis.Common/4.13.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-T8nRl4mAUY4mhdYM4U2ra2vP2EL+ol8Yqwo0gwC/V55vmlXq9NxdIkZJynTpTL1uX/jHijJ90AeOEx4lf7OwzQ==",
+      "path": "microsoft.codeanalysis.common/4.13.0",
+      "hashPath": "microsoft.codeanalysis.common.4.13.0.nupkg.sha512"
+    },
+    "Microsoft.CodeAnalysis.CSharp/4.13.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-BsH7Vijbj9IL7Fj4k/ysZSVyLGFqr75wmdFGwCKWJvSjnA1xwPaQ3hkB2BQdHOt5CpEYA6Q0I6Oo5sDTDHqHsg==",
+      "path": "microsoft.codeanalysis.csharp/4.13.0",
+      "hashPath": "microsoft.codeanalysis.csharp.4.13.0.nupkg.sha512"
+    },
    "Microsoft.CSharp/4.7.0": {
      "type": "package",
      "serviceable": true,
@@ -59,6 +197,20 @@
      "path": "microsoft.csharp/4.7.0",
      "hashPath": "microsoft.csharp.4.7.0.nupkg.sha512"
    },
+    "System.Collections.Immutable/8.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-AurL6Y5BA1WotzlEvVaIDpqzpIPvYnnldxru8oXJU2yFxFUy3+pNXjXd1ymO+RA0rq0+590Q8gaz2l3Sr7fmqg==",
+      "path": "system.collections.immutable/8.0.0",
+      "hashPath": "system.collections.immutable.8.0.0.nupkg.sha512"
+    },
+    "System.Reflection.Metadata/8.0.0": {
+      "type": "package",
+      "serviceable": true,
+      "sha512": "sha512-ptvgrFh7PvWI8bcVqG5rsA/weWM09EnthFHR5SCnS6IN+P4mj6rE1lBDC4U8HL9/57htKAqy4KQ3bBj84cfYyQ==",
+      "path": "system.reflection.metadata/8.0.0",
+      "hashPath": "system.reflection.metadata.8.0.0.nupkg.sha512"
+    },
    "System.Runtime.CompilerServices.Unsafe/6.1.0": {
      "type": "package",
      "serviceable": true,
@@ -14,7 +14,7 @@ using System.Reflection;
 [assembly: System.Reflection.AssemblyCompanyAttribute("StgSharp.Script")]
 [assembly: System.Reflection.AssemblyConfigurationAttribute("Debug")]
 [assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")]
-[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0+a5aef8506d3bfaf536d5fb576068a073ecf212c4")]
+[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0+e3741687a706609a1d0055c3fd11f41945838a70")]
 [assembly: System.Reflection.AssemblyProductAttribute("StgSharp.Script")]
 [assembly: System.Reflection.AssemblyTitleAttribute("StgSharp.Script")]
 [assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")]
@@ -1 +1 @@
-{"documents":{"D:\\NitloadIndustry\\研究项目\\1-Flagship\\TH2020\\ProjectFile\\内核源代码\\*":"https://raw.githubusercontent.com/Nitload-NSI/CCD_Github/6222f8c8be57d511d2ec40523717e20b87fcff9d/*"}}
+{"documents":{"D:\\NitloadIndustry\\研究项目\\1-Flagship\\TH2020\\ProjectFile\\内核源代码\\*":"https://raw.githubusercontent.com/Nitload-NSI/CCD_Github/e3741687a706609a1d0055c3fd11f41945838a70/*"}}