更新 README.md

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
@@ -22,12 +23,46 @@ namespace Convention.RScript.Runner
             // 还原上层命名空间的变量
             foreach (var local in context.CurrentLocalSpaceVariableNames.Peek())
             {
-                parser.context.Variables[local] = context.Variables[local].data;
+                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,7 @@
 using Convention.RScript.Parser;
 using System;
+using System.Collections;
+using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 
 namespace Convention.RScript.Runner
@@ -8,28 +10,39 @@ namespace Convention.RScript.Runner
     {
         protected static void DoJumpRuntimePointer(ExpressionParser parser, int target, RScriptContext context)
         {
+            Tuple<int, int> enterKey = Tuple.Create(context.CurrentRuntimePointer, target);
             int currentPointer = context.CurrentRuntimePointer;
-            bool isForwardMove = target > context.CurrentRuntimePointer;
-            int step = isForwardMove ? 1 : -1;
             int depth = 0;
             int lastLayer = 0;
-            for (; context.CurrentRuntimePointer != target; context.CurrentRuntimePointer += step)
+            if (context.JumpPointerCache.TryGetValue(enterKey, out var jumpResult))
             {
-                if (context.CurrentSentence.mode == RScriptSentence.Mode.ExitNamespace)
+                depth = jumpResult.Item1;
+                lastLayer = jumpResult.Item2;
+                context.CurrentRuntimePointer = target;
+            }
+            else
+            {
+                bool isForwardMove = target > context.CurrentRuntimePointer;
+                int step = isForwardMove ? 1 : -1;
+                for (; context.CurrentRuntimePointer != target; context.CurrentRuntimePointer += step)
                 {
-                    if (isForwardMove)
+                    if (context.CurrentSentence.mode == RScriptSentence.Mode.ExitNamespace)
-                        lastLayer--;
+                    {
-                    else
+                        if (isForwardMove)
-                        lastLayer++;
+                            lastLayer--;
+                        else
+                            lastLayer++;
+                    }
+                    else if (context.CurrentSentence.mode == RScriptSentence.Mode.EnterNamespace)
+                    {
+                        if (isForwardMove)
+                            lastLayer++;
+                        else
+                            lastLayer--;
+                    }
+                    depth = lastLayer < depth ? lastLayer : depth;
                 }
-                else if (context.CurrentSentence.mode == RScriptSentence.Mode.EnterNamespace)
+                context.JumpPointerCache.Add(enterKey, Tuple.Create(depth, lastLayer));
-                {
-                    if (isForwardMove)
-                        lastLayer++;
-                    else
-                        lastLayer--;
-                }
-                depth = lastLayer < depth ? lastLayer : depth;
             }
             // 对上层的最深影响
             for (; depth < 0; depth++)
@@ -60,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
 {
@@ -95,6 +96,16 @@ namespace Convention.RScript.Parser
         public ExpressionParser(ExpressionContext context)
         {
             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();
@@ -111,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

@@ -0,0 +1,189 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+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)
+        {
+            if (type == typeof(int))
+                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;
+        private int layer
+        {
+            get=>m_layer;
+            set
+            {
+                m_layer = value;
+                Prefix = new('\t', layer);
+            }
+        }
+        private string Prefix = "";
+
+        public CScriptRScriptVariableGenerater(Type targetType, Generater generater, Destorier destorier, string name) : base(targetType, generater, destorier, name)
+        {
+        }
+
+        protected override string WriteClassBodyEnter(Type currentType)
+        {
+            string result = $"{Prefix}{"{"}\n{Prefix}public:";
+            layer++;
+            return result;
+        }
+
+        protected override string WriteClassBodyExit(Type currentType)
+        {
+            layer--;
+            return $"{Prefix}{"};"}";
+        }
+
+        protected override string WriteClassHead(Type currentType)
+        {
+            string description = string.IsNullOrEmpty(this.description) ? "" : string.Join("", from item in this.description.Split('\n') where string.IsNullOrEmpty(item) == false select $"{Prefix}{item}\n");
+            string suffix = currentType.BaseType == typeof(object) ? string.Empty : $" : public {GetTypename(currentType.BaseType)}";
+            string result = $"{Prefix}\\*{description}*\\\n{Prefix}{Prefix}class {GetTypename(currentType)}{suffix}";
+            return result;
+        }
+
+        protected override string WriteClassMethod(Type returnType, string methodName, string[] parameterNames, Type[] parameterTypes)
+        {
+            List<string> parameters = new();
+            for (int i = 0, e = parameterNames.Length; i < e; i++)
+            {
+                parameters.Add($"{GetTypename(parameterTypes[i])} {parameterNames[i]}");
+            }
+            return $"{Prefix}{GetTypename(returnType)} {methodName}({string.Join(", ", parameters)});";
+        }
+
+        protected override string WriteClassTail(Type currentType)
+        {
+            return "";
+        }
+
+        protected override string WriteEnumBodyEnter(Type currentType)
+        {
+            string result = $"{Prefix}{"{"}";
+            layer++;
+            return result;
+        }
+
+        protected override string WriteEnumBodyExit(Type currentType)
+        {
+            layer--;
+            return $"{Prefix}{"};"}";
+        }
+
+        protected override string WriteEnumHead(Type currentEnum)
+        {
+            return $"{Prefix}enum {GetTypename(currentEnum)}";
+        }
+
+        protected override string WriteEnumName(string enumName)
+        {
+            return $"{Prefix}{enumName},";
+        }
+
+        protected override string WriteEnumTail(Type currentType)
+        {
+            return "";
+        }
+
+        protected override string WritePageEnd(Type currentType)
+        {
+            return "";
+        }
+
+        protected override string WritePageHead(Type currentType)
+        {
+            if (currentType.BaseType != null)
+                return $"#include\"{GetFilename(currentType.BaseType)}\"";
+            return string.Empty;
+        }
+
+        public override string GetFilename(Type currentType)
+        {
+            return GetTypename(currentType);
+        }
+    }
+}

PublicTypes/RScriptInjectVariableGenerater.cs

@@ -0,0 +1,273 @@
+using Flee.InternalTypes;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+
+namespace Convention.RScript.Variable
+{
+    namespace Attr
+    {
+
+        [AttributeUsage(AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
+        public sealed class MethodAttribute : Attribute
+        {
+        }
+
+        [AttributeUsage(AttributeTargets.Enum, Inherited = true, AllowMultiple = false)]
+        public sealed class EnumAttribute : Attribute
+        {
+        }
+
+        [AttributeUsage(AttributeTargets.Class|AttributeTargets.Struct, Inherited = false, AllowMultiple = false)]
+        public sealed class DefaultAttribute : Attribute
+        {
+            public string defaultScript;
+            public DefaultAttribute(string defaultScript)
+            {
+                this.defaultScript = defaultScript;
+            }
+        }
+
+        [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, Inherited = false, AllowMultiple = false)]
+        public sealed class DescriptionAttribute : Attribute
+        {
+            public string description;
+            public DescriptionAttribute(string description)
+            {
+                this.description = description;
+            }
+        }
+    }
+
+    public abstract class RScriptInjectVariableGenerater
+    {
+        public string RScriptString { get; private set; }
+
+        public abstract string GetFilename(Type currentType);
+
+        protected abstract string WritePageHead(Type currentType);
+
+        #region Enum
+
+        protected abstract string WriteEnumHead(Type currentEnum);
+        protected abstract string WriteEnumBodyEnter(Type currentType);
+        protected abstract string WriteEnumName(string enumName);
+        protected abstract string WriteEnumBodyExit(Type currentType);
+        protected abstract string WriteEnumTail(Type currentType);
+
+        #endregion
+
+        #region Class
+
+        protected abstract string WriteClassHead(Type currentType);
+        protected abstract string WriteClassBodyEnter(Type currentType);
+        protected abstract string WriteClassMethod(Type returnType, string methodName, string[] parameterNames, Type[] parameterTypes);
+        protected abstract string WriteClassBodyExit(Type currentType);
+        protected abstract string WriteClassTail(Type currentType);
+
+        #endregion
+
+        protected abstract string WritePageEnd(Type currentType);
+
+        /// <summary>
+        /// 生成targetType类型的实体
+        /// </summary>
+        /// <returns></returns>
+        public delegate object Generater();
+
+        public delegate void Destorier(object o);
+
+        private readonly Generater MyGenerater;
+        private readonly Destorier MyDestorier;
+        private readonly HashSet<object> GenerateObjects = new();
+
+        public readonly static Dictionary<string, RScriptInjectVariableGenerater> AllRScriptInjectVariables = new();
+
+        public readonly Type targetType;
+        public readonly string name;
+        public readonly string scriptIndicator;
+        public readonly string defaultScript;
+        public readonly string description;
+
+        public object Generate()
+        {
+            return MyGenerater();
+        }
+
+        public RScriptInjectVariableGenerater(Type targetType, [MaybeNull] Generater generater, [MaybeNull] Destorier destorier, string name)
+        {
+            if (AllRScriptInjectVariables.TryGetValue(name, out var exist_var))
+            {
+                throw new InvalidOperationException($"{name} is been used");
+            }
+
+            this.targetType = targetType;
+            this.MyGenerater = generater;
+            this.MyDestorier = destorier;
+            this.name = name;
+            var defaultAttr = targetType.GetCustomAttribute<Attr.DefaultAttribute>();
+            this.defaultScript = defaultAttr?.defaultScript ?? "";
+            var descriptionAttr = targetType.GetCustomAttribute<Attr.DescriptionAttribute>();
+            this.description = descriptionAttr?.description ?? "";
+
+            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));
+                // 绘制枚举
+                {
+                    var scriptEnums = from enumItem in targetType.GetNestedTypes(BindingFlags.NonPublic | BindingFlags.Public)
+                                      where enumItem.GetCustomAttribute<Attr.EnumAttribute>() != null
+                                      select enumItem;
+                    foreach (var enumItem in scriptEnums)
+                    {
+                        var attr = enumItem.GetCustomAttribute<Attr.EnumAttribute>();
+                        this.WriteEnumHead(targetType);
+                        this.WriteEnumBodyEnter(targetType);
+                        foreach (var enumName in enumItem.GetEnumNames())
+                        {
+                            this.WriteEnumName(enumName);
+                        }
+                        this.WriteEnumBodyExit(targetType);
+                        this.WriteEnumTail(targetType);
+                    }
+                }
+                // 绘制方法
+                {
+                    var scriptMethods = from method in targetType.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly)
+                                        where method.GetCustomAttribute<Attr.MethodAttribute>() != null
+                                        select method;
+                    foreach (var method in scriptMethods)
+                    {
+                        var attr = method.GetCustomAttribute<Attr.MethodAttribute>();
+                        var returnType = method.ReturnType;
+                        var methodName = method.Name;
+                        var parameters = method.GetParameters();
+                        var parameterNames = from item in parameters select item.Name;
+                        var parameterTypes = from item in parameters select item.ParameterType;
+                        builder.AppendLine(this.WriteClassMethod(returnType, methodName, parameterNames.ToArray(), parameterTypes.ToArray()));
+                    }
+                }
+                builder.AppendLine(this.WriteClassBodyExit(targetType));
+                builder.AppendLine(this.WriteClassTail(targetType));
+            }
+            builder.AppendLine(this.WritePageEnd(targetType));
+            this.scriptIndicator = builder.ToString();
+        }
+
+        public void Register()
+        {
+            AllRScriptInjectVariables.Add(name, this);
+        }
+
+        public bool Unregister()
+        {
+            if (MyDestorier != null)
+                foreach (var item in GenerateObjects)
+                {
+                    MyDestorier(item);
+                }
+            this.GenerateObjects.Clear();
+            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)
+                    {
+                        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");
+                    }
+                    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");
+        }
+
+        public static string DestoryRScriptVariable(object o)
+        {
+            if (o == null)
+                return string.Empty;
+            foreach (var (name,variable) in AllRScriptInjectVariables)
+            {
+                variable.GenerateObjects.RemoveWhere(x => x == null);
+                if(variable.GenerateObjects.Remove(o))
+                {
+                    variable.MyDestorier(o);
+                    return variable.name;
+                }
+            }
+            return string.Empty;
+        }
+    }
+
+    public static class RScriptVariableGenerater
+    {
+        public static object New(string name)
+        {
+            return RScriptInjectVariableGenerater.GenerateRScriptVariable(name);
+        }
+
+        public static string Delete(object o)
+        {
+            return RScriptInjectVariableGenerater.DestoryRScriptVariable(o);
+        }
+    }
+}

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);

README.md

@@ -1,2 +1,2 @@
-需要与 http://www.liubai.site:3000/ninemine/Flee.git 一起工作
+需要与 http://gitea.liubai.site/ninemine/Flee.git 一起工作
 

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,7 +92,10 @@ 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);
     }
 
     public partial class RScriptContext : IBasicRScriptContext
@@ -110,7 +114,8 @@ 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;
         }
 
         public List<IRSentenceMatcher> SentenceParser = new()
@@ -250,18 +255,20 @@ namespace Convention.RScript
             this.Variables.Add("context", new(typeof(object), new BuildInContext(this)));
 
             this.Sentences = data.Sentences;
-            this.Labels = (from item in data.Labels select item).ToDictionary(t => t.Item1, t => t.Item2);
+            if (data.Labels != null)
-            this.NamespaceLayer = (from item in data.NamespaceLayer select item).ToDictionary(t => t.Item1, t => t.Item2);
+                this.Labels = (from item in data.Labels select item).ToDictionary(t => t.Item1, t => t.Item2);
-            this.NamespaceLabels = (from item in data.NamespaceLabels select item).ToDictionary(t => t.Item1, t => t.Item2);
+            if (data.NamespaceLayer != null)
+                this.NamespaceLayer = (from item in data.NamespaceLayer select item).ToDictionary(t => t.Item1, t => t.Item2);
+            if (data.NamespaceLabels != null)
+                this.NamespaceLabels = (from item in data.NamespaceLabels select item).ToDictionary(t => t.Item1, t => t.Item2);
+            if (data.JumpPointerCache != null)
+                this.JumpPointerCache = (from item in data.JumpPointerCache select item).ToDictionary(t => t.Item1, t => t.Item2);
         }
 
         public RScriptSentence CurrentSentence => Sentences[CurrentRuntimePointer];
 
-        public int StepCount { get; private set; }
-
         internal object RunNextStep(ExpressionParser parser)
         {
-            StepCount++;
             var sentence = CurrentSentence;
             try
             {
@@ -276,9 +283,16 @@ 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();
+        internal readonly Dictionary<Tuple<int, int>, Tuple<int, int>> JumpPointerCache = new();
         public int CurrentRuntimePointer { get; internal set; } = 0;
         internal readonly Stack<HashSet<string>> CurrentLocalSpaceVariableNames = new();
 
@@ -294,12 +308,13 @@ namespace Convention.RScript
 
         private void BeforeRun(ExpressionParser parser)
         {
-            StepCount = 0;
             CurrentLocalSpaceVariableNames.Clear();
             RuntimePointerStack.Clear();
             GotoPointerStack.Clear();
             CurrentLocalSpaceVariableNames.Clear();
             CurrentLocalSpaceVariableNames.Push(new());
+            JumpPointerCache.Clear();
+            parser.context.Imports.AddType(typeof(Variable.RScriptVariableGenerater));
             foreach (var staticType in Import)
             {
                 parser.context.Imports.AddType(staticType);
@@ -310,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)
@@ -322,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);
@@ -334,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)
+            }
-                {
+            AfterRun(parser);
-                    yield return ir;
+        }
-                }
+
-                yield return null;
+        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);
         }
@@ -347,18 +393,31 @@ 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(),
                 Sentences = Sentences,
+                JumpPointerCache = (from item in JumpPointerCache select Tuple.Create(item.Key, item.Value)).ToArray(),
+            };
+        }
+        public SerializableClass CompileFromCurrent(ExpressionParser parser)
+        {
+            return new SerializableClass()
+            {
+                //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(),
+                Sentences = Sentences,
+                JumpPointerCache = (from item in JumpPointerCache select Tuple.Create(item.Key, item.Value)).ToArray(),
             };
         }
     }

RScriptEngine.cs

@@ -17,6 +17,7 @@ namespace Convention.RScript
         Dictionary<string, RScriptVariableEntry> Run(string script, RScriptImportClass import = null, RScriptVariables variables = null);
         IEnumerator RunAsync(string script, RScriptImportClass import = null, RScriptVariables variables = null);
         SerializableClass Compile(string script, RScriptImportClass import = null, RScriptVariables variables = null);
+        SerializableClass GetCompileResultFromCurrent();
         Dictionary<string, RScriptVariableEntry> Run(SerializableClass data, RScriptImportClass import = null, RScriptVariables variables = null);
         IEnumerator RunAsync(SerializableClass data, RScriptImportClass import = null, RScriptVariables variables = null);
     }
@@ -56,16 +57,8 @@ namespace Convention.RScript
                         // Skip single-line comment
                         if (line[i + 1] == '/')
                         {
-                            while (i < line.Length && line[i] != '\n')
+                            PushBuilder();
-                                i++;
+                            break;
-                        }
-                        // Skip multi-line comment
-                        else if (line[i + 1] == '*')
-                        {
-                            i += 2;
-                            while (i + 1 < line.Length && !(line[i] == '*' && line[i + 1] == '/'))
-                                i++;
-                            i++;
                         }
                         else
                         {
@@ -74,9 +67,8 @@ namespace Convention.RScript
                     }
                     else if (c == '#')
                     {
-                        // Skip single-line comment
+                        PushBuilder();
-                        while (i < line.Length && line[i] != '\n')
+                        break;
-                            i++;
                     }
                     else if (c == '\"')
                     {
@@ -126,10 +118,7 @@ namespace Convention.RScript
                     }
                 }
             }
-            if (builder.Length > 0)
+            PushBuilder();
-            {
-                PushBuilder();
-            }
 
             return statements.Where(s => !string.IsNullOrWhiteSpace(s));
         }
@@ -154,15 +143,18 @@ 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());
             context = CreateContext(SplitScript(script).ToArray(), import, variables);
             return context.Compile(parser);
         }
+        public SerializableClass GetCompileResultFromCurrent()
+        {
+            return context.CompileFromCurrent(parser);
+        }
 
         public Dictionary<string, RScriptVariableEntry> Run(SerializableClass data, RScriptImportClass import = null, RScriptVariables variables = null)
         {
@@ -178,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

@@ -63,8 +63,18 @@ namespace Convention.RScript
                     }
                 }
 
-                // 这里需要根据 ExpressionParser.SerializableParser 的结构来序列化
+                // 序列化 JumpPointerCache 数组
-                // writer.Write(...); // CompileParser 的序列化
+                writer.Write(data.JumpPointerCache?.Length ?? 0);
+                if (data.JumpPointerCache != null)
+                {
+                    foreach (var jpItem in data.JumpPointerCache)
+                    {
+                        writer.Write(jpItem.Item1.Item1);
+                        writer.Write(jpItem.Item1.Item2);
+                        writer.Write(jpItem.Item2.Item1);
+                        writer.Write(jpItem.Item2.Item2);
+                    }
+                }
 
                 return stream.ToArray();
             }
@@ -79,70 +89,67 @@ namespace Convention.RScript
 
                 // 反序列化 Sentences 数组
                 int sentencesLength = reader.ReadInt32();
-                if (sentencesLength > 0)
+                result.Sentences = new RScriptSentence[sentencesLength];
+                for (int i = 0; i < sentencesLength; i++)
                 {
-                    result.Sentences = new RScriptSentence[sentencesLength];
+                    var sentence = new RScriptSentence();
-                    for (int i = 0; i < sentencesLength; i++)
+                    sentence.content = reader.ReadString();
+
+                    int infoLength = reader.ReadInt32();
+                    if (infoLength > 0)
                     {
-                        var sentence = new RScriptSentence();
+                        sentence.info = new string[infoLength];
-                        sentence.content = reader.ReadString();
+                        for (int j = 0; j < infoLength; j++)
-
-                        int infoLength = reader.ReadInt32();
-                        if (infoLength > 0)
                         {
-                            sentence.info = new string[infoLength];
+                            sentence.info[j] = reader.ReadString();
-                            for (int j = 0; j < infoLength; j++)
-                            {
-                                sentence.info[j] = reader.ReadString();
-                            }
                         }
-
-                        sentence.mode = (RScriptSentence.Mode)reader.ReadInt32();
-                        result.Sentences[i] = sentence;
                     }
+
+                    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++)
                 {
-                    result.Labels = new Tuple<string, int>[labelsLength];
+                    string item1 = reader.ReadString();
-                    for (int i = 0; i < labelsLength; i++)
+                    int item2 = reader.ReadInt32();
-                    {
+                    result.Labels[i] = Tuple.Create(item1, item2);
-                        string item1 = reader.ReadString();
-                        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++)
                 {
-                    result.NamespaceLayer = new Tuple<int, int>[namespaceLayerLength];
+                    int item1 = reader.ReadInt32();
-                    for (int i = 0; i < namespaceLayerLength; i++)
+                    int item2 = reader.ReadInt32();
-                    {
+                    result.NamespaceLayer[i] = Tuple.Create(item1, item2);
-                        int item1 = reader.ReadInt32();
-                        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++)
                 {
-                    result.NamespaceLabels = new Tuple<string, int>[namespaceLabelsLength];
+                    string item1 = reader.ReadString();
-                    for (int i = 0; i < namespaceLabelsLength; i++)
+                    int item2 = reader.ReadInt32();
-                    {
+                    result.NamespaceLabels[i] = Tuple.Create(item1, item2);
-                        string item1 = reader.ReadString();
-                        int item2 = reader.ReadInt32();
-                        result.NamespaceLabels[i] = Tuple.Create(item1, item2);
-                    }
                 }
 
-                // 反序列化 CompileParser
+                // 反序列化 JumpPointerCache 数组
-                // result.CompileParser = ...; // 根据具体结构实现
+                int jumpPointerCacheLength = reader.ReadInt32();
+                result.JumpPointerCache = new Tuple<Tuple<int, int>, Tuple<int, int>>[jumpPointerCacheLength];
+                for (int i = 0; i < jumpPointerCacheLength; i++)
+                {
+                    int x = reader.ReadInt32();
+                    int y = reader.ReadInt32();
+                    int z = reader.ReadInt32();
+                    int w = reader.ReadInt32();
+                    result.JumpPointerCache[i] = Tuple.Create(Tuple.Create(x, y), Tuple.Create(z, w));
+                }
 
                 return result;
             }