[Minor] adds some asm abstraction helper (for later)

Author: remyCases

ModUtils/AsmUtils.cs

@@ -18,22 +18,22 @@ public static partial class Msl
         /// <param name="instructions"></param>
         public static void CheckInstructionsVariables(UndertaleCode originalCode, string instructions)
         {
-            Regex variableRegex = new (@"\bpop\.v\.\w\s(?<var>\w+)\.(?<name>\w+)");
+            Regex variableRegex = new(@"\bpop\.v\.\w\s(?<var>\w+)\.(?<name>\w+)");
             foreach (string instruction in instructions.Split('\n').Where(x => x.Contains("pop.v")))
             {
                 System.Text.RegularExpressions.Match matches = variableRegex.Match(instruction);
-                if (matches.Success) 
+                if (matches.Success)
                 {
                     string instanceValue = matches.Groups["var"].Value;
-                    if(instanceValue == "self")
+                    if (instanceValue == "self")
                     {
                         AssemblyWrapper.CheckRefVariableOrCreate(matches.Groups["name"].Value, UndertaleInstruction.InstanceType.Self);
                     }
-                    else if(instanceValue == "global")
+                    else if (instanceValue == "global")
                     {
                         AssemblyWrapper.CheckRefVariableOrCreate(matches.Groups["name"].Value, UndertaleInstruction.InstanceType.Global);
                     }
-                    else if(instanceValue == "local")
+                    else if (instanceValue == "local")
                     {
                         AssemblyWrapper.CheckRefLocalVariableOrCreate(originalCode, matches.Groups["name"].Value);
                     }
@@ -46,33 +46,33 @@ public static void CheckInstructionsVariables(UndertaleCode originalCode, string
         }
         public static string GetAssemblyString(string fileName)
         {
-            try 
+            try
             {
                 UndertaleCode originalCode = GetUMTCodeFromFile(fileName);
                 return originalCode.Disassemble(ModLoader.Data.Variables, ModLoader.Data.CodeLocals.For(originalCode));
             }
-            catch(Exception ex) 
+            catch (Exception ex)
             {
                 Log.Error(ex, "Something went wrong");
                 throw;
             }
         }
         public static void SetAssemblyString(string codeAsString, string fileName)
         {
-            try 
+            try
             {
                 UndertaleCode originalCode = GetUMTCodeFromFile(fileName);
                 originalCode.Replace(Assembler.Assemble(codeAsString, ModLoader.Data));
             }
-            catch(Exception ex) 
+            catch (Exception ex)
             {
                 Log.Error(ex, "Something went wrong");
                 throw;
             }
         }
         public static void InsertAssemblyString(string codeAsString, string fileName, int position)
         {
-            try 
+            try
             {
                 Log.Information(string.Format("Trying insert assembly in: {0}", fileName.ToString()));
 
@@ -82,15 +82,15 @@ public static void InsertAssemblyString(string codeAsString, string fileName, in
 
                 Log.Information(string.Format("Patched function with InsertAssemblyString: {0}", fileName.ToString()));
             }
-            catch(Exception ex) 
+            catch (Exception ex)
             {
                 Log.Error(ex, "Something went wrong");
                 throw;
             }
         }
         public static void ReplaceAssemblyString(string codeAsString, string fileName, int position)
         {
-            try 
+            try
             {
                 Log.Information(string.Format("Trying replace assembly in: {0}", fileName.ToString()));
 
@@ -100,37 +100,38 @@ public static void ReplaceAssemblyString(string codeAsString, string fileName, i
 
                 Log.Information(string.Format("Patched function with ReplaceAssemblyString: {0}", fileName.ToString()));
             }
-            catch(Exception ex) 
+            catch (Exception ex)
             {
                 Log.Error(ex, "Something went wrong");
                 throw;
             }
         }
         public static void ReplaceAssemblyString(string codeAsString, string fileName, int start, int len)
         {
-            try 
+            try
             {
                 Log.Information(string.Format("Trying replace assembly in: {0}", fileName.ToString()));
 
                 List<string>? originalCode = GetAssemblyString(fileName).Split("\n").ToList();
                 originalCode[start] = codeAsString;
-                for (int i = 1; i < Math.Min(len, originalCode.Count - start); i++) {
+                for (int i = 1; i < Math.Min(len, originalCode.Count - start); i++)
+                {
                     originalCode[start + i] = "";
                 }
 
                 SetAssemblyString(string.Join("\n", originalCode), fileName);
 
                 Log.Information(string.Format("Patched function with ReplaceAssemblyString: {0}", fileName.ToString()));
             }
-            catch(Exception ex) 
+            catch (Exception ex)
             {
                 Log.Error(ex, "Something went wrong");
                 throw;
             }
         }
         public static void InjectAssemblyInstruction(string name, Func<IEnumerable<UndertaleInstruction>, IEnumerable<UndertaleInstruction>> patch)
         {
-            try 
+            try
             {
                 Log.Information(string.Format("Trying inject assembly in: {0}", name.ToString()));
 
@@ -139,12 +140,43 @@ public static void InjectAssemblyInstruction(string name, Func<IEnumerable<Under
 
                 Log.Information(string.Format("Patched function with InjectAssemblyInstruction: {0}", name.ToString()));
             }
-            catch(Exception ex) 
+            catch (Exception ex)
             {
                 Log.Error(ex, "Something went wrong");
                 throw;
             }
         }
+        public static IEnumerable<UndertaleInstruction> ReplaceTable(this IEnumerable<UndertaleInstruction> original, IEnumerable<UndertaleInstruction> injected)
+        {
+            bool pushFound = false;
+            bool callFound = false;
+            foreach ((int index, UndertaleInstruction instruction) in original.Enumerate())
+            {
+                if (!pushFound && AssemblyWrapper.IsPushString(instruction))
+                {
+                    pushFound = true;
+                    foreach (UndertaleInstruction replacement in injected) yield return replacement;
+                }
+                else if (pushFound
+                    && instruction.Kind == UndertaleInstruction.Opcode.Call
+                    && instruction.Type1 == UndertaleInstruction.DataType.Int32
+                )
+                {
+                    callFound = true;
+                    yield return instruction;
+                }
+                else if (!pushFound || callFound)
+                {
+                    Log.Information(string.Format("yield line {0}: {1}", index, instruction));
+                    yield return instruction;
+                }
+            }
+
+            if (!pushFound)
+                throw new InvalidOperationException("Didnt find any string in that file, is that a legitimate table ?");
+            if (!callFound)
+                throw new InvalidOperationException("Didnt find any final call in that file, the function is maybe ill-formed.");
+        }
     }
     public static class AssemblyWrapper
     {
@@ -308,12 +340,13 @@ public static UndertaleResourceById<UndertaleString, UndertaleChunkSTRG> GetStri
                 (int ind, UndertaleString str) = ModLoader.Data.Strings.Enumerate().FirstOrDefault(x => x.Item2.Content == name);
 
                 if (str == null)
+                {
                     stringById = CreateString(name);
+                    Log.Information(string.Format("Created string: {0}", stringById.ToString()));
+                }
                 else
                     stringById = new UndertaleResourceById<UndertaleString, UndertaleChunkSTRG>(str, ind);
 
-                Log.Information(string.Format("Find string: {0}", stringById.ToString()));
-
                 return stringById;
             }
             catch (Exception ex)
@@ -397,7 +430,20 @@ public static UndertaleInstruction PopIntSelf(string val)
                 TypeInst = UndertaleInstruction.InstanceType.Self,
             };
         }
-
+        public static UndertaleInstruction ConvString()
+        {
+            return new()
+            {
+                Kind = UndertaleInstruction.Opcode.Conv,
+                Type1 = UndertaleInstruction.DataType.String,
+                Type2 = UndertaleInstruction.DataType.Variable,
+            };
+        }
+        public static IEnumerable<UndertaleInstruction> CreateStringLine(string s)
+        {
+            yield return PushString(s);
+            yield return ConvString();
+        }
         public static bool IsPushString(UndertaleInstruction instruction)
         {
             return instruction.Kind == UndertaleInstruction.Opcode.Push && instruction.Value is UndertaleResourceById<UndertaleString, UndertaleChunkSTRG> stringRef;