Prototype complete InterpreterEntry serialization

Tests/SimpleDebugClient/Program.cs

@@ -8,7 +8,7 @@ internal class Program
 {
     static IDebuggerClient? Debugger { get; set; }
 
-    static void Main(string[] args)
+    static int Main(string[] args)
     {
         string connectionString = args.Length >= 2
             ? args[1] : "tcp://127.0.0.1:5556";
@@ -17,10 +17,12 @@ internal class Program
 
         Debugger = new ZmqDebuggerClient(connectionString);
         Debugger.DispatcherStep += Debugger_DispatcherStep;
-        //Debugger.InterpreterStep += Debugger_InterpreterStep;
+        Debugger.InterpreterStep += Debugger_InterpreterStep;
 
         Console.WriteLine("Listening for debug messages. Press Ctrl-C to exit.");
         Console.ReadLine();
+
+        return 0;
     }
 
     private static void Console_CancelKeyPress(object sender, ConsoleCancelEventArgs e)

UIX/Microsoft/Iris/Debug/Data/InterpreterEntry.cs

@@ -1,11 +1,15 @@
-using System;
+using Microsoft.Iris.Markup;
+using System;
 using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Serialization;
 
 namespace Microsoft.Iris.Debug.Data;
 
+[Serializable]
 public class InterpreterEntry
 {
-    public InterpreterEntry(object opCode, params OpCodeArgument[] args)
+    public InterpreterEntry(OpCode opCode, params OpCodeArgument[] args)
     {
         OpCode = opCode;
 
@@ -15,22 +19,25 @@ public class InterpreterEntry
             Arguments = new List<OpCodeArgument>();
     }
 
-    public object OpCode { get; }
+    public OpCode OpCode { get; }
     public IList<OpCodeArgument> Arguments { get; }
     public IList<object> ReturnValues { get; } = new List<object>();
 
     public override string ToString()
     {
-        return $"{OpCode}({string.Join(", ", Arguments)}) -> [{ReturnValues}]";
+        return $"{OpCode}({string.Join(", ", Arguments)}) -> [{string.Join(", ", ReturnValues)}]";
     }
 }
 
-public class OpCodeArgument
+[Serializable]
+public class OpCodeArgument : ISerializable
 {
     public string Name { get; set; }
     public Type Type { get; set; }
     public object Value { get; set; }
 
+    protected bool CanSerializeValue => Value is ISerializable;
+
     public OpCodeArgument(string name, Type type, object value)
     {
         Name = name;
@@ -38,5 +45,23 @@ public class OpCodeArgument
         Value = value;
     }
 
+    protected OpCodeArgument(SerializationInfo info, StreamingContext context)
+    {
+        Name = info.GetString(nameof(Name));
+        Type = Type.GetType(info.GetString(nameof(Type)), false);
+
+        bool canSerializeValue = info.GetBoolean(nameof(CanSerializeValue));
+        Type valueSerializeType = canSerializeValue ? Type : typeof(string);
+        Value = info.GetValue(nameof(Value), valueSerializeType);
+    }
+
     public override string ToString() => $"{Type} {Value}";
+
+    public void GetObjectData(SerializationInfo info, StreamingContext context)
+    {
+        info.AddValue(nameof(Name), Name);
+        info.AddValue(nameof(Type), Type.FullName);
+        info.AddValue(nameof(CanSerializeValue), CanSerializeValue);
+        info.AddValue(nameof(Value), CanSerializeValue ? Value : Value.ToString());
+    }
 }

UIX/Microsoft/Iris/Debug/ZmqDebuggerClient.cs

@@ -2,6 +2,8 @@
 using NetMQ;
 using NetMQ.Sockets;
 using System;
+using System.IO;
+using System.Runtime.Serialization.Formatters.Binary;
 using System.Text;
 
 namespace Microsoft.Iris.Debug;
@@ -34,8 +36,11 @@ public class ZmqDebuggerClient : IDebuggerClient, IDisposable
             switch (type)
             {
                 case DebuggerMessageType.InterpreterOpCode:
-                    string entry = Encoding.Unicode.GetString(bytes);
-                    InterpreterStep?.Invoke(this, null);
+                    {
+                        using MemoryStream stream = new(bytes);
+                        var entry = (InterpreterEntry)new BinaryFormatter().Deserialize(stream);
+                        InterpreterStep?.Invoke(this, entry);
+                    }
                     break;
 
                 case DebuggerMessageType.DispatcherStep:
@@ -46,7 +51,7 @@ public class ZmqDebuggerClient : IDebuggerClient, IDisposable
         }
     }
 
-    private DebuggerMessageType RecieveDebuggerMessage(SubscriberSocket socket, out byte[] bytes)
+    private static DebuggerMessageType RecieveDebuggerMessage(SubscriberSocket socket, out byte[] bytes)
     {
         var frames = socket.ReceiveMultipartBytes(2);
 

UIX/Microsoft/Iris/Debug/ZmqDebuggerServer.cs

@@ -1,6 +1,8 @@
 using NetMQ;
 using NetMQ.Sockets;
 using System;
+using System.IO;
+using System.Runtime.Serialization.Formatters.Binary;
 using System.Text;
 
 namespace Microsoft.Iris.Debug;
@@ -22,7 +24,10 @@ internal class ZmqDebuggerServer : IDebuggerServer, IDisposable
 
     public void LogInterpreterOpCode(object context, Data.InterpreterEntry entry)
     {
-        SendDebuggerMessage(DebuggerMessageType.InterpreterOpCode, entry.ToString());
+        using MemoryStream entryStream = new();
+        new BinaryFormatter().Serialize(entryStream, entry);
+
+        SendDebuggerMessage(DebuggerMessageType.InterpreterOpCode, entryStream.ToArray());
     }
 
     public void LogDispatcher(string message)

UIX/Microsoft/Iris/Markup/Interpreter.cs

@@ -90,6 +90,10 @@ namespace Microsoft.Iris.Markup
                             int num = reader.ReadUInt16();
                             TypeSchema typeSchema = importTables.TypeImports[num];
                             object obj = typeSchema.ConstructDefault();
+                            
+                            entry.Arguments.Add(new Debug.Data.OpCodeArgument(
+                                "type", typeof(TypeSchema), typeSchema));
+                                
                             ReportErrorOnNull(obj, "Construction", typeSchema.Name);
                             if (!ErrorsDetected(watermark, ref result, ref errorsDetected))
                             {
@@ -210,7 +214,12 @@ namespace Microsoft.Iris.Markup
                             int num8 = reader.ReadUInt16();
                             SymbolReference symbolRef = symbolReferenceTable[num8];
                             object obj8 = context.ReadSymbol(symbolRef);
+
+                            entry.Arguments.Add(new Debug.Data.OpCodeArgument(
+                                "symbolRef", typeof(SymbolReference), symbolRef));
+
                             stack.Push(obj8);
+
                             if (Trace.IsCategoryEnabled(TraceCategory.Markup))
                             {
                             }
@@ -222,7 +231,14 @@ namespace Microsoft.Iris.Markup
                             object value = (opCode == OpCode.WriteSymbolPeek) ? stack.Peek() : stack.Pop();
                             int num9 = reader.ReadUInt16();
                             SymbolReference symbolRef2 = symbolReferenceTable[num9];
+
+                            entry.Arguments.Add(new Debug.Data.OpCodeArgument(
+                                "symbolRef", typeof(SymbolReference), symbolRef2));
+                            entry.Arguments.Add(new Debug.Data.OpCodeArgument(
+                                "value", typeof(object), value));
+
                             context.WriteSymbol(symbolRef2, value);
+
                             if (Trace.IsCategoryEnabled(TraceCategory.Markup))
                             {
                             }

UIX/Microsoft/Iris/Markup/OpCode.cs

@@ -4,10 +4,13 @@
 // MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
 // Assembly location: C:\Program Files\Zune\UIX.dll
 
-namespace Microsoft.Iris.Markup
+using System;
+
+namespace Microsoft.Iris.Markup;
+
+[Serializable]
+public enum OpCode : byte
 {
-    public enum OpCode : byte
-    {
     ConstructObject = 1,
     ConstructObjectIndirect = 2,
     ConstructObjectParam = 3,
@@ -55,5 +58,4 @@ namespace Microsoft.Iris.Markup
     Listen = 45, // 0x2D
     DestructiveListen = 46, // 0x2E
     EnterDebugState = 47, // 0x2F
-    }
 }