内置更加友好的类型打印

DoRunner/BackpointRunner.cs

@@ -1,4 +1,5 @@
 using Convention.RScript.Parser;
+using System.Collections;
 using System.Diagnostics.CodeAnalysis;
 
 namespace Convention.RScript.Runner
@@ -27,5 +28,23 @@ namespace Convention.RScript.Runner
             }
             return null;
         }
+
+        [return: MaybeNull]
+        public override IEnumerator RunAsync(ExpressionParser parser, RScriptSentence sentence, RScriptContext context)
+        {
+            // 检查并跳转到上次跳转的位置
+            if (parser.Evaluate<bool>(sentence.content))
+            {
+                if (context.GotoPointerStack.Count == 0)
+                {
+                    throw new RScriptRuntimeException($"No position to back.", context.CurrentRuntimePointer);
+                }
+                else
+                {
+                    DoJumpRuntimePointer(parser, context.GotoPointerStack.Pop(), context);
+                }
+            }
+            yield break;
+        }
     }
 }

DoRunner/BreakpointRunner.cs

@@ -1,4 +1,5 @@
 using Convention.RScript.Parser;
+using System.Collections;
 using System.Diagnostics.CodeAnalysis;
 
 namespace Convention.RScript
@@ -23,7 +24,7 @@ namespace Convention.RScript
                 else if (context.NamespaceLayer.TryGetValue(context.RuntimePointerStack.Peek(), out var exitPointer))
                 {
                     context.CurrentRuntimePointer = exitPointer;
-                    context.SentenceRunners[RScriptSentence.Mode.ExitNamespace].Run(parser, context.CurrentSentence, context);
+                    return context.SentenceRunners[RScriptSentence.Mode.ExitNamespace].Run(parser, context.CurrentSentence, context);
                 }
                 else
                 {
@@ -32,5 +33,27 @@ namespace Convention.RScript
             }
             return null;
         }
+
+        [return: MaybeNull]
+        public IEnumerator RunAsync(ExpressionParser parser, RScriptSentence sentence, RScriptContext context)
+        {
+            // 检查并跳转到当前命名空间的结束位置
+            if (parser.Evaluate<bool>(sentence.content))
+            {
+                if (context.RuntimePointerStack.Count == 0)
+                {
+                    context.CurrentRuntimePointer = context.Sentences.Length;
+                }
+                else if (context.NamespaceLayer.TryGetValue(context.RuntimePointerStack.Peek(), out var exitPointer))
+                {
+                    context.CurrentRuntimePointer = exitPointer;
+                    yield return context.SentenceRunners[RScriptSentence.Mode.ExitNamespace].RunAsync(parser, context.CurrentSentence, context);
+                }
+                else
+                {
+                    throw new RScriptRuntimeException($"No namespace to break.", context.CurrentRuntimePointer);
+                }
+            }
+        }
     }
 }

DoRunner/DefineVariableRunner.cs

@@ -1,5 +1,6 @@
 using Convention.RScript.Parser;
 using System;
+using System.Collections;
 using System.Diagnostics.CodeAnalysis;
 
 namespace Convention.RScript.Runner
@@ -79,27 +80,27 @@ namespace Convention.RScript.Runner
                 if (varTypeName == "string")
                 {
                     varType = typeof(string);
-                    varDefaultValue = varInitExpression == null ? string.Empty : varInitExpression;
+                    varDefaultValue = varInitExpression == null ? string.Empty : varInitExpression.Trim('\"');
                 }
                 else if (varTypeName == "int")
                 {
                     varType = typeof(int);
-                    varDefaultValue = varInitExpression == null ? 0 : parser.Evaluate<int>(varInitExpression);
+                    varDefaultValue = varInitExpression == null ? 0 : Convert.ChangeType(parser.Evaluate(varInitExpression), typeof(int));
                 }
                 else if (varTypeName == "double")
                 {
                     varType = typeof(double);
-                    varDefaultValue = varInitExpression == null ? 0.0 : parser.Evaluate<double>(varInitExpression);
+                    varDefaultValue = varInitExpression == null ? 0.0 : Convert.ChangeType(parser.Evaluate(varInitExpression), typeof(double));
                 }
                 else if (varTypeName == "float")
                 {
                     varType = typeof(float);
-                    varDefaultValue = varInitExpression == null ? 0.0f : parser.Evaluate<float>(varInitExpression);
+                    varDefaultValue = varInitExpression == null ? 0.0f : Convert.ChangeType(parser.Evaluate(varInitExpression), typeof(float));
                 }
                 else if (varTypeName == "bool")
                 {
                     varType = typeof(bool);
-                    varDefaultValue = varInitExpression == null ? false : parser.Evaluate<bool>(varInitExpression);
+                    varDefaultValue = varInitExpression == null ? false : Convert.ChangeType(parser.Evaluate(varInitExpression), typeof(bool));
                 }
                 else if (varTypeName == "var")
                 {
@@ -123,5 +124,63 @@ namespace Convention.RScript.Runner
             }
             return null;
         }
+
+        [return: MaybeNull]
+        public IEnumerator RunAsync(ExpressionParser parser, RScriptSentence sentence, RScriptContext context)
+        {
+            // 定义变量
+            var varTypeName = sentence.info[0];
+            var varName = sentence.info[1];
+            var varInitExpression = sentence.info[2];
+            Type varType;
+            object varDefaultValue;
+            {
+                if (varTypeName == "string")
+                {
+                    varType = typeof(string);
+                    varDefaultValue = varInitExpression == null ? string.Empty : varInitExpression.Trim('\"');
+                }
+                else if (varTypeName == "int")
+                {
+                    varType = typeof(int);
+                    varDefaultValue = varInitExpression == null ? 0 : Convert.ChangeType(parser.Evaluate(varInitExpression), typeof(int));
+                }
+                else if (varTypeName == "double")
+                {
+                    varType = typeof(double);
+                    varDefaultValue = varInitExpression == null ? 0.0 : Convert.ChangeType(parser.Evaluate(varInitExpression), typeof(double));
+                }
+                else if (varTypeName == "float")
+                {
+                    varType = typeof(float);
+                    varDefaultValue = varInitExpression == null ? 0.0f : Convert.ChangeType(parser.Evaluate(varInitExpression), typeof(float));
+                }
+                else if (varTypeName == "bool")
+                {
+                    varType = typeof(bool);
+                    varDefaultValue = varInitExpression == null ? false : Convert.ChangeType(parser.Evaluate(varInitExpression), typeof(bool));
+                }
+                else if (varTypeName == "var")
+                {
+                    varType = typeof(object);
+                    varDefaultValue = varInitExpression == null ? new object() : parser.Evaluate(varInitExpression);
+                }
+                else
+                {
+                    throw new RScriptRuntimeException($"Unsupported variable type '{varTypeName}'.", context.CurrentRuntimePointer);
+                }
+            }
+            if (context.CurrentLocalSpaceVariableNames.Peek().Contains(varName) == false)
+            {
+                context.Variables.Add(varName, new(varType, varDefaultValue));
+                parser.context.Variables[varName] = varDefaultValue;
+                context.CurrentLocalSpaceVariableNames.Peek().Add(varName);
+            }
+            else
+            {
+                throw new RScriptRuntimeException($"Variable '{varName}' already defined on this namespace.", context.CurrentRuntimePointer);
+            }
+            yield break;
+        }
     }
 }

DoRunner/EnterNamedSpaceRunner.cs

@@ -1,4 +1,5 @@
 using Convention.RScript.Parser;
+using System.Collections;
 using System.Diagnostics.CodeAnalysis;
 
 namespace Convention.RScript.Runner
@@ -16,5 +17,12 @@ namespace Convention.RScript.Runner
             context.CurrentRuntimePointer = context.NamespaceLayer[context.NamespaceLabels[sentence.content]];
             return null;
         }
+
+        [return: MaybeNull]
+        public IEnumerator RunAsync(ExpressionParser parser, RScriptSentence sentence, RScriptContext context)
+        {
+            context.CurrentRuntimePointer = context.NamespaceLayer[context.NamespaceLabels[sentence.content]];
+            yield break;
+        }
     }
 }

DoRunner/EnterNamespaceRunner.cs

@@ -1,4 +1,5 @@
 using Convention.RScript.Parser;
+using System.Collections;
 using System.Diagnostics.CodeAnalysis;
 
 namespace Convention.RScript.Runner
@@ -24,5 +25,20 @@ namespace Convention.RScript.Runner
             context.RuntimePointerStack.Push(context.CurrentRuntimePointer);
             return null;
         }
+
+        [return: MaybeNull]
+        public IEnumerator RunAsync(ExpressionParser parser, RScriptSentence sentence, RScriptContext context)
+        {
+            // 准备记录当前命名空间中定义的变量, 清空上层命名空间的变量
+            context.CurrentLocalSpaceVariableNames.Push(new());
+            // 更新变量值
+            foreach (var (varName, varValue) in parser.context.Variables)
+            {
+                context.Variables.SetValue(varName, varValue);
+            }
+            // 压栈
+            context.RuntimePointerStack.Push(context.CurrentRuntimePointer);
+            yield break;
+        }
     }
 }

DoRunner/ExitNamespaceRunner.cs

@@ -1,4 +1,5 @@
 using Convention.RScript.Parser;
+using System.Collections;
 using System.Diagnostics.CodeAnalysis;
 
 namespace Convention.RScript.Runner
@@ -21,13 +22,47 @@ namespace Convention.RScript.Runner
             }
             // 还原上层命名空间的变量
             foreach (var local in context.CurrentLocalSpaceVariableNames.Peek())
+            {
+                if (context.Variables.ContainsKey(local))
                 {
                     parser.context.Variables[local] = context.Variables[local].data;
                 }
+                else
+                {
+                    parser.context.Variables.Remove(local);
+                }
+            }
             context.CurrentLocalSpaceVariableNames.Pop();
             // 弹栈
             context.RuntimePointerStack.Pop();
             return null;
         }
+
+        [return: MaybeNull]
+        public IEnumerator RunAsync(ExpressionParser parser, RScriptSentence sentence, RScriptContext context)
+        {
+            // 移除当前命名空间的变量
+            foreach (var local in context.CurrentLocalSpaceVariableNames.Peek())
+            {
+                context.Variables.Remove(local);
+                parser.context.Variables.Remove(local);
+            }
+            // 还原上层命名空间的变量
+            foreach (var local in context.CurrentLocalSpaceVariableNames.Peek())
+            {
+                if (context.Variables.ContainsKey(local))
+                {
+                    parser.context.Variables[local] = context.Variables[local].data;
+                }
+                else
+                {
+                    parser.context.Variables.Remove(local);
+                }
+            }
+            context.CurrentLocalSpaceVariableNames.Pop();
+            // 弹栈
+            context.RuntimePointerStack.Pop();
+            yield break;
+        }
     }
 }

DoRunner/ExpressionRunner.cs

@@ -1,4 +1,5 @@
 using Convention.RScript.Parser;
+using System.Collections;
 using System.Diagnostics.CodeAnalysis;
 
 namespace Convention.RScript.Runner
@@ -15,5 +16,14 @@ namespace Convention.RScript.Runner
         {
             return parser.Evaluate(sentence.content);
         }
+
+        [return: MaybeNull]
+        public IEnumerator RunAsync(ExpressionParser parser, RScriptSentence sentence, RScriptContext context)
+        {
+            var result = parser.Evaluate(sentence.content);
+            if(result is IEnumerator ir)
+                yield return ir;
+            yield return null;
+        }
     }
 }

DoRunner/GoToRunner.cs

@@ -1,4 +1,5 @@
 using Convention.RScript.Parser;
+using System.Collections;
 using System.Diagnostics.CodeAnalysis;
 
 namespace Convention.RScript.Runner
@@ -48,5 +49,43 @@ namespace Convention.RScript.Runner
             }
             return null;
         }
+
+        [return: MaybeNull]
+        public override IEnumerator RunAsync(ExpressionParser parser, RScriptSentence sentence, RScriptContext context)
+        {
+            // 检查并跳转到指定标签
+            if (parser.Evaluate<bool>(sentence.info[0]))
+            {
+                if (context.Labels.TryGetValue(sentence.content, out var labelPointer))
+                {
+                    context.GotoPointerStack.Push(context.CurrentRuntimePointer);
+                    DoJumpRuntimePointer(parser, labelPointer, context);
+                }
+                else if (context.NamespaceLabels.TryGetValue(sentence.content, out labelPointer))
+                {
+                    int current = context.CurrentRuntimePointer;
+                    //DoEnterNamespace(parser);
+                    context.SentenceRunners[RScriptSentence.Mode.EnterNamespace].Run(parser, context.CurrentSentence, context);
+                    context.CurrentRuntimePointer = labelPointer;
+                    for (int e = context.NamespaceLayer[context.NamespaceLabels[sentence.content]]; ;)
+                    {
+                        yield return context.RunNextStepAsync(parser);
+                        if (context.CurrentRuntimePointer >= context.Sentences.Length)
+                            break;
+                        else if (context.CurrentRuntimePointer == e)
+                            break;
+                        else
+                            context.CurrentRuntimePointer++;
+                    }
+                    //context.DoExitNamespace(parser);
+                    context.SentenceRunners[RScriptSentence.Mode.ExitNamespace].Run(parser, context.CurrentSentence, context);
+                    context.CurrentRuntimePointer = current;
+                }
+                else
+                {
+                    throw new RScriptRuntimeException($"Label '{sentence.content}' not found.", context.CurrentRuntimePointer);
+                }
+            }
+        }
     }
 }

DoRunner/JumpRuntimePointerRunner.cs

@@ -1,5 +1,6 @@
 using Convention.RScript.Parser;
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 
@@ -17,6 +18,7 @@ namespace Convention.RScript.Runner
             {
                 depth = jumpResult.Item1;
                 lastLayer = jumpResult.Item2;
+                context.CurrentRuntimePointer = target;
             }
             else
             {
@@ -71,5 +73,7 @@ namespace Convention.RScript.Runner
         public abstract void Compile(ExpressionParser parser, RScriptSentence sentence, RScriptContext context);
         [return: MaybeNull]
         public abstract object Run(ExpressionParser parser, RScriptSentence sentence, RScriptContext context);
+        [return: MaybeNull]
+        public abstract IEnumerator RunAsync(ExpressionParser parser, RScriptSentence sentence, RScriptContext context);
     }
 }

Parser/ExpressionParser.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System;
 using System.Linq;
+using System.Diagnostics;
 
 namespace Convention.RScript
 {
@@ -97,6 +98,14 @@ namespace Convention.RScript.Parser
             this.context = context;
             // 默认启用未定义标识符作为字符串的功能
             this.context.Options.UndefinedIdentifiersAsStrings = true;
+            // 启用大小写敏感
+            this.context.Options.CaseSensitive = true;
+            // 启用溢出检查
+            this.context.Options.Checked = true;
+#if UNITY_EDITOR
+            // 浮点数使用float而非double（Unity性能优化）
+            this.context.Options.RealLiteralDataType = RealLiteralDataType.Single;
+#endif
         }
 
         private readonly Dictionary<string, Type> CompileGenericExpressionTypen = new();
@@ -113,7 +122,10 @@ namespace Convention.RScript.Parser
         {
             if (CompileGenericExpression.TryGetValue(expression, out var result))
             {
-                return (result as IGenericExpression<T>).Evaluate();
+                if (result is IGenericExpression<T> genericExpression)
+                    return genericExpression.Evaluate();
+                else
+                    return context.CompileGeneric<T>(expression).Evaluate();
             }
             return Compile<T>(expression).Evaluate();
         }

PublicTypes/InjectVariable/CStyle.cs

@@ -1,18 +1,92 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Text;
-using System.Threading.Tasks;
 
 namespace Convention.RScript.Variable.CStyle
 {
     public class CScriptRScriptVariableGenerater : RScriptInjectVariableGenerater
     {
+        /// <summary>
+        /// 获取类型的友好显示名称，支持泛型、数组等复杂类型
+        /// </summary>
+        public static string GetFriendlyName(Type type)
+        {
+            if (type == null) return null;
+
+            // 处理泛型类型
+            if (type.IsGenericType)
+            {
+                // 特殊处理可空类型（Nullable<T>）
+                if (type.IsNullable())
+                {
+                    return $"{GetFriendlyName(type.GetGenericArguments()[0])}?";
+                }
+
+                var sb = new StringBuilder();
+                // 获取类型基础名称（移除 `1, `2 等后缀）
+                string baseName = type.Name.Contains('`') ? type.Name[..type.Name.IndexOf('`')] : type.Name;
+                sb.Append(baseName);
+                sb.Append('<');
+
+                // 递归处理泛型参数
+                Type[] args = type.GetGenericArguments();
+                for (int i = 0; i < args.Length; i++)
+                {
+                    if (i > 0) sb.Append(", ");
+                    sb.Append(GetFriendlyName(args[i]));
+                }
+
+                sb.Append('>');
+                return sb.ToString();
+            }
+
+            // 处理数组类型
+            if (type.IsArray)
+            {
+                string elementName = GetFriendlyName(type.GetElementType());
+                int rank = type.GetArrayRank();
+                return rank == 1 ? $"{elementName}[]" : $"{elementName}[{new string(',', rank - 1)}]";
+            }
+
+            // 处理指针类型
+            if (type.IsPointer)
+            {
+                return $"{GetFriendlyName(type.GetElementType())}*";
+            }
+
+            // 处理引用类型（ref/out 参数）
+            if (type.IsByRef)
+            {
+                return $"{GetFriendlyName(type.GetElementType())}&";
+            }
+
+            // 普通类型直接返回名称
+            return type.Name;
+        }
+
+        /// <summary>
+        /// 判断是否为可空类型
+        /// </summary>
+        public static bool IsNullable(Type type)
+        {
+            return type.IsGenericType &&
+                   type.GetGenericTypeDefinition() == typeof(Nullable<>);
+        }
+
         public static string GetTypename(Type type)
         {
-            var name = type.Name.Replace('`', '_');
+            if (type == typeof(int))
-            return name;
+                return "int";
+            if (type == typeof(float))
+                return "float";
+            if (type == typeof(double))
+                return "double";
+            if (type == typeof(bool))
+                return "bool";
+            if (type == typeof(void))
+                return "void";
+            return GetFriendlyName(type).Replace('`', '_');
         }
 
         private int m_layer = 0;
@@ -102,7 +176,9 @@ namespace Convention.RScript.Variable.CStyle
 
         protected override string WritePageHead(Type currentType)
         {
-            return $"#include\"{GetFilename(currentType)}\"";
+            if (currentType.BaseType != null)
+                return $"#include\"{GetFilename(currentType.BaseType)}\"";
+            return string.Empty;
         }
 
         public override string GetFilename(Type currentType)

PublicTypes/RScriptInjectVariableGenerater.cs

@@ -115,6 +115,20 @@ namespace Convention.RScript.Variable
 
             StringBuilder builder = new();
             builder.AppendLine(this.WritePageHead(targetType));
+            if (targetType.IsEnum)
+            {
+                // 绘制枚举
+                builder.AppendLine(this.WriteEnumHead(targetType));
+                builder.AppendLine(this.WriteEnumBodyEnter(targetType));
+                foreach (var enumName in targetType.GetEnumNames())
+                {
+                    builder.AppendLine(this.WriteEnumName(enumName));
+                }
+                builder.AppendLine(this.WriteEnumBodyExit(targetType));
+                builder.AppendLine(this.WriteEnumTail(targetType));
+            }
+            else
+            {
                 builder.AppendLine(this.WriteClassHead(targetType));
                 builder.AppendLine(this.WriteClassBodyEnter(targetType));
                 // 绘制枚举
@@ -153,6 +167,7 @@ namespace Convention.RScript.Variable
                 }
                 builder.AppendLine(this.WriteClassBodyExit(targetType));
                 builder.AppendLine(this.WriteClassTail(targetType));
+            }
             builder.AppendLine(this.WritePageEnd(targetType));
             this.scriptIndicator = builder.ToString();
         }
@@ -173,9 +188,24 @@ namespace Convention.RScript.Variable
             return AllRScriptInjectVariables.Remove(name);
         }
 
+        public class EnumGetter
+        {
+            public Type enumType;
+            public EnumGetter(Type enumType)
+            {
+                this.enumType = enumType;
+            }
+            public object Get(string name)
+            {
+                return Enum.Parse(enumType, name);
+            }
+        }
+
         public static object GenerateRScriptVariable(string name)
         {
             if (AllRScriptInjectVariables.TryGetValue(name, out var variable))
+            {
+                if (variable.targetType.IsEnum)
                 {
                     if (variable.MyGenerater != null)
                     {
@@ -188,6 +218,25 @@ namespace Convention.RScript.Variable
                         else
                             throw new InvalidOperationException($"{name} target is not sub-class of it's target type");
                     }
+                    else
+                    {
+                        return variable.targetType;
+                    }
+                }
+                else
+                {
+                    if (variable.MyGenerater != null)
+                    {
+                        var result = variable.Generate();
+                        if (result.GetType().IsSubclassOf(variable.targetType) || result.GetType() == variable.targetType)
+                        {
+                            variable.GenerateObjects.Add(result);
+                            return result;
+                        }
+                        else
+                            throw new InvalidOperationException($"{name} target is not sub-class of it's target type");
+                    }
+                }
             }
             throw new InvalidOperationException($"{name} target is not exist or abstract");
         }

PublicTypes/RScriptVariables.cs

@@ -32,7 +32,7 @@ namespace Convention.RScript
                     else
                         internalData = Activator.CreateInstance(type);
                 }
-                else if (type == typeof(object) || type == value.GetType())
+                else if (type == typeof(object) || type.IsAssignableFrom(value.GetType()))
                     internalData = value;
                 else
                     internalData = Convert.ChangeType(value, type);

RScriptContext.cs

@@ -77,6 +77,7 @@ namespace Convention.RScript
     public interface IRSentenceRunner
     {
         [return: MaybeNull] object Run(ExpressionParser parser, RScriptSentence sentence, RScriptContext context);
+        [return: MaybeNull] IEnumerator RunAsync(ExpressionParser parser, RScriptSentence sentence, RScriptContext context);
         void Compile(ExpressionParser parser, RScriptSentence sentence, RScriptContext context);
     }
 
@@ -91,6 +92,8 @@ namespace Convention.RScript
         Dictionary<string, RScriptVariableEntry> GetCurrentVariables();
         void Run(ExpressionParser parser);
         IEnumerator RunAsync(ExpressionParser parser);
+        public void ReRun(ExpressionParser parser);
+        public IEnumerator ReRunAsync(ExpressionParser parser);
         SerializableClass Compile(ExpressionParser parser);
         SerializableClass CompileFromCurrent(ExpressionParser parser);
     }
@@ -111,7 +114,7 @@ namespace Convention.RScript
             public Tuple<string, int>[] Labels;
             public Tuple<int, int>[] NamespaceLayer;
             public Tuple<string, int>[] NamespaceLabels;
-            public ExpressionParser.SerializableParser CompileParser;
+            //public ExpressionParser.SerializableParser CompileParser;
             public Tuple<Tuple<int, int>, Tuple<int, int>>[] JumpPointerCache;
         }
 
@@ -264,11 +267,8 @@ namespace Convention.RScript
 
         public RScriptSentence CurrentSentence => Sentences[CurrentRuntimePointer];
 
-        public int StepCount { get; private set; }
-
         internal object RunNextStep(ExpressionParser parser)
         {
-            StepCount++;
             var sentence = CurrentSentence;
             try
             {
@@ -283,6 +283,12 @@ namespace Convention.RScript
                 throw new RScriptRuntimeException($"Runtime error: {ex.Message}", CurrentRuntimePointer, ex);
             }
         }
+        internal IEnumerator RunNextStepAsync(ExpressionParser parser)
+        {
+            var sentence = CurrentSentence;
+            if (SentenceRunners.TryGetValue(sentence.mode, out var runner))
+                yield return runner.RunAsync(parser, sentence, this);
+        }
 
         internal readonly Stack<int> RuntimePointerStack = new();
         internal readonly Stack<int> GotoPointerStack = new();
@@ -302,7 +308,6 @@ namespace Convention.RScript
 
         private void BeforeRun(ExpressionParser parser)
         {
-            StepCount = 0;
             CurrentLocalSpaceVariableNames.Clear();
             RuntimePointerStack.Clear();
             GotoPointerStack.Clear();
@@ -320,6 +325,21 @@ namespace Convention.RScript
             }
         }
 
+        private void ResetAndSureRunAgain(ExpressionParser parser)
+        {
+            CurrentLocalSpaceVariableNames.Clear();
+            RuntimePointerStack.Clear();
+            GotoPointerStack.Clear();
+            CurrentLocalSpaceVariableNames.Clear();
+            CurrentLocalSpaceVariableNames.Push(new());
+            JumpPointerCache.Clear();
+            parser.context.Variables.Clear();
+            foreach (var (name, varObject) in Variables)
+            {
+                parser.context.Variables[name] = varObject.data;
+            }
+        }
+
         private void AfterRun(ExpressionParser parser)
         {
             foreach (var (varName, varValue) in parser.context.Variables)
@@ -332,6 +352,7 @@ namespace Convention.RScript
         public void Run(ExpressionParser parser)
         {
             BeforeRun(parser);
+            Stack<IEnumerator> buffer = new();
             for (CurrentRuntimePointer = 0; CurrentRuntimePointer < Sentences.Length; CurrentRuntimePointer++)
             {
                 RunNextStep(parser);
@@ -344,12 +365,27 @@ namespace Convention.RScript
             BeforeRun(parser);
             for (CurrentRuntimePointer = 0; CurrentRuntimePointer < Sentences.Length; CurrentRuntimePointer++)
             {
-                var ret = RunNextStep(parser);
+                yield return RunNextStepAsync(parser);
-                if (ret is IEnumerator ir)
-                {
-                    yield return ir;
             }
-                yield return null;
+            AfterRun(parser);
+        }
+
+        public void ReRun(ExpressionParser parser)
+        {
+            ResetAndSureRunAgain(parser);
+            for (CurrentRuntimePointer = 0; CurrentRuntimePointer < Sentences.Length; CurrentRuntimePointer++)
+            {
+                RunNextStep(parser);
+            }
+            AfterRun(parser);
+        }
+
+        public IEnumerator ReRunAsync(ExpressionParser parser)
+        {
+            ResetAndSureRunAgain(parser);
+            for (CurrentRuntimePointer = 0; CurrentRuntimePointer < Sentences.Length; CurrentRuntimePointer++)
+            {
+                yield return RunNextStepAsync(parser);
             }
             AfterRun(parser);
         }
@@ -357,14 +393,14 @@ namespace Convention.RScript
         public SerializableClass Compile(ExpressionParser parser)
         {
             BeforeRun(parser);
-            foreach (var item in Sentences)
+            //foreach (var item in Sentences)
-            {
+            //{
-                if (SentenceRunners.TryGetValue(item.mode, out var runner))
+            //    if (SentenceRunners.TryGetValue(item.mode, out var runner))
-                    runner.Compile(parser, item, this);
+            //        runner.Compile(parser, item, this);
-            }
+            //}
             return new SerializableClass()
             {
-                CompileParser = parser.Serialize(),
+                //CompileParser = parser.Serialize(),
                 Labels = (from item in Labels select Tuple.Create(item.Key, item.Value)).ToArray(),
                 NamespaceLayer = (from item in NamespaceLayer select Tuple.Create(item.Key, item.Value)).ToArray(),
                 NamespaceLabels = (from item in NamespaceLabels select Tuple.Create(item.Key, item.Value)).ToArray(),
@@ -376,7 +412,7 @@ namespace Convention.RScript
         {
             return new SerializableClass()
             {
-                CompileParser = parser.Serialize(),
+                //CompileParser = parser.Serialize(),
                 Labels = (from item in Labels select Tuple.Create(item.Key, item.Value)).ToArray(),
                 NamespaceLayer = (from item in NamespaceLayer select Tuple.Create(item.Key, item.Value)).ToArray(),
                 NamespaceLabels = (from item in NamespaceLabels select Tuple.Create(item.Key, item.Value)).ToArray(),

RScriptEngine.cs

@@ -143,9 +143,8 @@ namespace Convention.RScript
         {
             parser = new(new());
             context = CreateContext(SplitScript(script).ToArray(), import, variables);
-            return context.RunAsync(parser);
+            yield return context.RunAsync(parser);
         }
-
         public SerializableClass Compile(string script, RScriptImportClass import = null, RScriptVariables variables = null)
         {
             parser = new(new());
@@ -171,7 +170,17 @@ namespace Convention.RScript
             parser = new(new());
             //parser.Deserialize(data.CompileParser);
             context = CreateContext(data, import, variables);
-            return context.RunAsync(parser);
+            yield return context.RunAsync(parser);
         }
+        public Dictionary<string, RScriptVariableEntry> ReRun()
+        {
+            context.ReRun(parser);
+            return context.GetCurrentVariables();
+        }
+        public IEnumerator ReRunAsync()
+        {
+            yield return context.ReRunAsync(parser);
+        }
+
     }
 }

RScriptSerializer.cs

@@ -89,8 +89,6 @@ namespace Convention.RScript
 
                 // 反序列化 Sentences 数组
                 int sentencesLength = reader.ReadInt32();
-                if (sentencesLength > 0)
-                {
                 result.Sentences = new RScriptSentence[sentencesLength];
                 for (int i = 0; i < sentencesLength; i++)
                 {
@@ -110,12 +108,9 @@ namespace Convention.RScript
                     sentence.mode = (RScriptSentence.Mode)reader.ReadInt32();
                     result.Sentences[i] = sentence;
                 }
-                }
 
                 // 反序列化 Labels 数组
                 int labelsLength = reader.ReadInt32();
-                if (labelsLength > 0)
-                {
                 result.Labels = new Tuple<string, int>[labelsLength];
                 for (int i = 0; i < labelsLength; i++)
                 {
@@ -123,12 +118,9 @@ namespace Convention.RScript
                     int item2 = reader.ReadInt32();
                     result.Labels[i] = Tuple.Create(item1, item2);
                 }
-                }
 
                 // 反序列化 NamespaceLayer 数组
                 int namespaceLayerLength = reader.ReadInt32();
-                if (namespaceLayerLength > 0)
-                {
                 result.NamespaceLayer = new Tuple<int, int>[namespaceLayerLength];
                 for (int i = 0; i < namespaceLayerLength; i++)
                 {
@@ -136,12 +128,9 @@ namespace Convention.RScript
                     int item2 = reader.ReadInt32();
                     result.NamespaceLayer[i] = Tuple.Create(item1, item2);
                 }
-                }
 
                 // 反序列化 NamespaceLabels 数组
                 int namespaceLabelsLength = reader.ReadInt32();
-                if (namespaceLabelsLength > 0)
-                {
                 result.NamespaceLabels = new Tuple<string, int>[namespaceLabelsLength];
                 for (int i = 0; i < namespaceLabelsLength; i++)
                 {
@@ -149,22 +138,18 @@ namespace Convention.RScript
                     int item2 = reader.ReadInt32();
                     result.NamespaceLabels[i] = Tuple.Create(item1, item2);
                 }
-                }
 
                 // 反序列化 JumpPointerCache 数组
                 int jumpPointerCacheLength = reader.ReadInt32();
-                if (jumpPointerCacheLength > 0)
-                {
                 result.JumpPointerCache = new Tuple<Tuple<int, int>, Tuple<int, int>>[jumpPointerCacheLength];
-                    for(int i=0;i<jumpPointerCacheLength;i++)
+                for (int i = 0; i < jumpPointerCacheLength; i++)
                 {
-                        int x= reader.ReadInt32();
+                    int x = reader.ReadInt32();
-                        int y= reader.ReadInt32();
+                    int y = reader.ReadInt32();
-                        int z= reader.ReadInt32();
+                    int z = reader.ReadInt32();
-                        int w= reader.ReadInt32();
+                    int w = reader.ReadInt32();
                     result.JumpPointerCache[i] = Tuple.Create(Tuple.Create(x, y), Tuple.Create(z, w));
                 }
-                }
 
                 return result;
             }