app commands (#46)

* app commands

* JitCommand

* notes

* jit command works once

* mostly working

* progress event

* folders

* key

Author: bitfaster

…ne.UnitTests/DissassemblyBuilderTests.cs …ine.UnitTests/DisassemblyBuilderTests.csJitExplorer.Engine.UnitTests/DissassemblyBuilderTests.cs renamed to JitExplorer.Engine.UnitTests/DisassemblyBuilderTests.cs JitExplorer.Engine.UnitTests/DissassemblyBuilderTests.cs renamed to JitExplorer.Engine.UnitTests/DisassemblyBuilderTests.cs

@@ -6,12 +6,12 @@
 
 namespace JitExplorer.Engine.UnitTests
 {
-    public class DissassemblyBuilderTests
+    public class DisassemblyBuilderTests
     {
         [Fact]
         public void WhenAddingLinesTheAddressesAreCountedCorrectly()
         {
-            var b = new DissassemblyBuilder();
+            var b = new DisassemblyBuilder();
 
             b.AddLine();
             b.AddLine("line2");

JitExplorer.Engine/Dissassembly.cs JitExplorer.Engine/Disassembly.csJitExplorer.Engine/Dissassembly.cs renamed to JitExplorer.Engine/Disassembly.cs

@@ -4,9 +4,9 @@
 
 namespace JitExplorer.Engine
 {
-    public class Dissassembly
+    public class Disassembly
     {
-        public Dissassembly(string text)
+        public Disassembly(string text)
         {
             this.IsSuccess = false;
             this.OutputText = text;
@@ -15,7 +15,7 @@ public Dissassembly(string text)
             this.AsmLineToAsmLineIndex = new Dictionary<int, int>();
         }
 
-        public Dissassembly(string text, Dictionary<int, string> lineAddressIndex, Dictionary<int, int> asmToSourceLineIndex, Dictionary<int, int> asmLineToAsmLineIndex)
+        public Disassembly(string text, Dictionary<int, string> lineAddressIndex, Dictionary<int, int> asmToSourceLineIndex, Dictionary<int, int> asmLineToAsmLineIndex)
         {
             this.IsSuccess = true;
             this.AsmText = text;

JitExplorer.Engine/DissassemblyBuilder.cs JitExplorer.Engine/DisassemblyBuilder.csJitExplorer.Engine/DissassemblyBuilder.cs renamed to JitExplorer.Engine/DisassemblyBuilder.cs

@@ -6,7 +6,7 @@
 
 namespace JitExplorer.Engine
 {
-    public class DissassemblyBuilder
+    public class DisassemblyBuilder
     {
         private int lineNo = 1;
         private StringBuilder sb = new StringBuilder();
@@ -72,7 +72,7 @@ private void HandleMultiline(string text)
             }
         }
 
-        public Dissassembly Build()
+        public Disassembly Build()
         {
             var asmLineToAsmLineIndex = new Dictionary<int, int>(this.linesContainingLabels.Count);
 
@@ -84,7 +84,7 @@ public Dissassembly Build()
                 }
             }
 
-            return new Dissassembly(
+            return new Disassembly(
                 sb.ToString(), 
                 asmLineToAddressIndex, 
                 asmToSourceLineIndex,

JitExplorer.Engine/RuntimeDisassembler.cs

@@ -36,7 +36,7 @@ public RuntimeDisassembler(string exeName)
             this.csFileName = "program.cs";
         }
 
-        public Dissassembly CompileJitAndDisassemble(string sourceCode, Config config)
+        public Disassembly CompileJitAndDisassemble(string sourceCode, Config config)
         {
             this.Progress?.Invoke(this, new ProgressEventArgs() { StatusMessage = "Compiling..." });
             (ExtractMarkedMethod userMethod, Compile.Compilation compilation) = Compile(this.exeName, sourceCode, config);
@@ -56,7 +56,7 @@ public Dissassembly CompileJitAndDisassemble(string sourceCode, Config config)
                         sb.AppendLine(e.ToString());
                     }
 
-                    return new Dissassembly(sb.ToString());
+                    return new Disassembly(sb.ToString());
                 }
 
                 this.Progress?.Invoke(this, new ProgressEventArgs() { StatusMessage = "Writing to disk..." });
@@ -315,9 +315,9 @@ private DisassemblyResult AttachAndDecompile(int processId, string className, st
             return dissassembler.AttachAndDisassemble(settings);
         }
 
-        private static Dissassembly FormatResult(DisassemblyResult result)
+        private static Disassembly FormatResult(DisassemblyResult result)
         {
-            var builder = new DissassemblyBuilder();
+            var builder = new DisassemblyBuilder();
 
             int referenceIndex = 0;
             int methodIndex = 0;

JitExplorer/AppModel.cs

@@ -0,0 +1,66 @@
+using ICSharpCode.AvalonEdit;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Windows;
+using System.Windows.Interactivity;
+
+namespace JitExplorer.Behaviors
+{
+    // https://stackoverflow.com/questions/18964176/two-way-binding-to-avalonedit-document-text-using-mvvm
+    public sealed class AvalonEditBehaviour : Behavior<TextEditor>
+    {
+        public static readonly DependencyProperty EditorTextProperty =
+            DependencyProperty.Register(nameof(EditorText), typeof(string), typeof(AvalonEditBehaviour),
+            new FrameworkPropertyMetadata(default(string), FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, PropertyChangedCallback));
+
+        public string EditorText
+        {
+            get { return (string)GetValue(EditorTextProperty); }
+            set { 
+                SetValue(EditorTextProperty, value); 
+            }
+        }
+
+        protected override void OnAttached()
+        {
+            base.OnAttached();
+            if (AssociatedObject != null)
+                AssociatedObject.TextChanged += AssociatedObjectOnTextChanged;
+        }
+
+        protected override void OnDetaching()
+        {
+            base.OnDetaching();
+            if (AssociatedObject != null)
+                AssociatedObject.TextChanged -= AssociatedObjectOnTextChanged;
+        }
+
+        private void AssociatedObjectOnTextChanged(object sender, EventArgs eventArgs)
+        {
+            var textEditor = sender as TextEditor;
+            if (textEditor != null)
+            {
+                if (textEditor.Document != null)
+                    EditorText = textEditor.Document.Text;
+            }
+        }
+
+        private static void PropertyChangedCallback(
+            DependencyObject dependencyObject,
+            DependencyPropertyChangedEventArgs dependencyPropertyChangedEventArgs)
+        {
+            var behavior = dependencyObject as AvalonEditBehaviour;
+            if (behavior.AssociatedObject != null)
+            {
+                var editor = behavior.AssociatedObject as TextEditor;
+                if (editor.Document != null)
+                {
+                    var caretOffset = editor.CaretOffset;
+                    editor.Document.Text = dependencyPropertyChangedEventArgs.NewValue.ToString();
+                    editor.CaretOffset = caretOffset;
+                }
+            }
+        }
+    }
+}

JitExplorer/Behaviors/AvalonTextBehavior.cs

@@ -0,0 +1,61 @@
+using BitFaster.Caching.Lru;
+using JitExplorer.Engine;
+using JitExplorer.Model;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Input;
+
+namespace JitExplorer.Commands
+{
+    public class JitCommand : ICommand
+    {
+        private readonly ClassicLru<JitKey, Disassembly> cache = new ClassicLru<JitKey, Disassembly>(100);
+
+        private bool canExecute = true;
+
+        public event EventHandler CanExecuteChanged;
+
+        public JitCommand()
+        {         
+        }
+
+        public bool CanExecute(object parameter)
+        {
+            return this.canExecute;
+        }
+
+        public void Execute(object parameter)
+        {
+            this.canExecute = false;
+            RaiseCanExecuteChanged();
+
+            var model = parameter as AppModel;
+
+            Task.Run(() => 
+            {
+                model.StatusModel.SetRunning();
+
+                var dissassembler = new RuntimeDisassembler("test.exe");
+                dissassembler.Progress += (object sender, ProgressEventArgs e) => { model.StatusModel.Status = e.StatusMessage; };
+
+                var jitKey = new JitKey(model.SourceCode, model.GetConfig());
+
+                var disassembly = this.cache.GetOrAdd(jitKey, k => dissassembler.CompileJitAndDisassemble(k.SourceCode, k.Config));
+
+                model.Disassembly = disassembly;
+
+                this.canExecute = true;
+                Application.Current.Dispatcher.Invoke((() => { RaiseCanExecuteChanged(); }));
+                model.StatusModel.SetReady();
+            });
+        }
+
+        private void RaiseCanExecuteChanged()
+        {
+            CanExecuteChanged?.Invoke(this, EventArgs.Empty);
+        }
+    }
+}

JitExplorer/Commands/JitCommand.cs

@@ -5,7 +5,7 @@
 using System.Collections.Generic;
 using System.Text;
 
-namespace JitExplorer
+namespace JitExplorer.Commands
 {
     public class JitKey : IEquatable<JitKey>
     {

JitExplorer/JitKey.cs JitExplorer/Commands/JitKey.csJitExplorer/JitKey.cs renamed to JitExplorer/Commands/JitKey.cs

@@ -9,26 +9,26 @@
 using System.Windows;
 using ICSharpCode.AvalonEdit.Utils;
 using ICSharpCode.AvalonEdit.Highlighting;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Wrapping;
 
 namespace JitExplorer.Controls
 {
-    public class AssemblyTextEditor : TextEditor
+    public class AssemblyTextEditor : BindableTextEditor
     {
         private ILineAddressResolver lineAddressResolver = new EmptyAddressResolver();
 
-        public AssemblyTextEditor() : base(new TextArea())
+        public AssemblyTextEditor()
         {
             this.IsReadOnly = true;
             this.WordWrap = true;
             this.ShowLineNumbers = false;
             this.SyntaxHighlighting = HighlightingManager.Instance.GetDefinition("Asm");
         }
 
-        public void Update(string text, ILineAddressResolver addressResolver)
+        public Dictionary<int, string> AsmLineAddressIndex
         {
-            this.lineAddressResolver = addressResolver;
-            this.Text = text;
-            this.HookAddressResolver();
+            set { this.lineAddressResolver = new LineAddressResolver(value); this.HookAddressResolver(); } 
         }
 
         protected override void OnDocumentChanged(EventArgs e)
@@ -44,6 +44,22 @@ private void HookAddressResolver()
             this.Document.ServiceProvider = wrapped;
         }
 
+        public static readonly DependencyProperty AsmLineAddressIndexProperty =
+            DependencyProperty.Register("AsmLineAddressIndex", typeof(Dictionary<int, string>), typeof(TextEditor),
+                                        new FrameworkPropertyMetadata(null, OnAsmLineAddressIndexChanged));
+
+        static void OnAsmLineAddressIndexChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            AssemblyTextEditor editor = (AssemblyTextEditor)d;
+
+            var index = e.NewValue as Dictionary<int, string>;
+
+            if (index != null)
+            {
+                editor.AsmLineAddressIndex = index;
+            }
+        }
+
         public static readonly DependencyProperty ShowMemoryAddressesProperty =
             DependencyProperty.Register("ShowMemoryAddresses", typeof(bool), typeof(TextEditor),
                                         new FrameworkPropertyMetadata(Boxes.False, OnShowMemoryAddressesChanged));

JitExplorer/Controls/AssemblyTextEditor.cs

@@ -0,0 +1,34 @@
+using ICSharpCode.AvalonEdit;
+using ICSharpCode.AvalonEdit.Editing;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Windows;
+
+namespace JitExplorer.Controls
+{
+    public class BindableTextEditor : TextEditor
+    {
+        public BindableTextEditor() : base(new TextArea())
+        { }
+
+        public string EditorText
+        {
+            get { return this.Text;}
+            set { this.Text = value; }
+        }
+
+        public static readonly DependencyProperty EditorTextProperty =
+            DependencyProperty.Register("EditorText", typeof(string), typeof(TextEditor),
+                new FrameworkPropertyMetadata(string.Empty, OnEditorTextChanged));
+
+        static void OnEditorTextChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            BindableTextEditor editor = (BindableTextEditor)d;
+
+            var text = e.NewValue as string ?? string.Empty;
+
+            editor.Text = text;
+        }
+    }
+}