Begun adding support for the IEditorGuide interface.

Author: wiredwiz

GunWin/GrammarSelector.cs

@@ -8,6 +8,8 @@
 using System.Threading.Tasks;
 using System.Windows.Forms;
 
+using Org.Edgerunner.ANTLR4.Tools.Testing.Grammar;
+
 namespace Org.Edgerunner.ANTLR4.Tools.Testing.GrunWin
 {
    public partial class GrammarSelector : Form

GunWin/GunWin.csproj

@@ -126,6 +126,10 @@
       <Project>{ec6f674c-4d48-40c4-b28b-85627c1ea3ce}</Project>
       <Name>Code Grapher</Name>
     </ProjectReference>
+    <ProjectReference Include="..\Common\Common.csproj">
+      <Project>{8bd992fd-a3b3-4af9-9371-5aa14ddfda68}</Project>
+      <Name>Common</Name>
+    </ProjectReference>
     <ProjectReference Include="..\TestRig\TestRig.csproj">
       <Project>{4e020f1d-27bf-4853-8573-474d7edb4e72}</Project>
       <Name>TestRig</Name>

GunWin/Options.cs

@@ -49,7 +49,7 @@ public class Options
       [Option("rule", HelpText = "ANTLR grammar rule to use", Required = false)]
       public string RuleName { get; set; }
 
-      [Option("input-file", HelpText = "File name to parse", Required = false)]
+      [Option("file", HelpText = "File name to parse", Required = false)]
       public string FileName { get; set; }
 
       [Option("trace", HelpText = "Trace grammar parsing", Required = false)]

GunWin/VisualAnalyzer.cs

@@ -40,6 +40,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Reflection;
 using System.Windows.Forms;
 
 using Antlr4.Runtime;
@@ -55,11 +56,14 @@
 using Microsoft.Msagl.GraphViewerGdi;
 using Microsoft.Msagl.Layout.Layered;
 
+using Org.Edgerunner.ANTLR4.Tools.Common;
 using Org.Edgerunner.ANTLR4.Tools.Graphing;
 using Org.Edgerunner.ANTLR4.Tools.Testing.Grammar;
 using Org.Edgerunner.ANTLR4.Tools.Testing.Grammar.Errors;
 using Org.Edgerunner.ANTLR4.Tools.Testing.GrunWin.Properties;
 
+using Style = FastColoredTextBoxNS.Style;
+
 namespace Org.Edgerunner.ANTLR4.Tools.Testing.GrunWin
 {
    /// <summary>
@@ -73,10 +77,20 @@ public partial class VisualAnalyzer : Form
 
       private GrammarReference _Grammar;
 
+      private IEditorGuide _EditorGuide;
+
+      private Dictionary<string, FastColoredTextBoxNS.Style> _TokenStyles;
+
+      private Style _ErrorStyle;
+
       private List<string> _ParserRules;
 
       private GViewer _Viewer;
 
+      private IList<TokenViewModel> _Tokens;
+
+      private List<ParseMessage> _ParseErrors;
+
       #region Constructors And Finalizers
 
       /// <summary>
@@ -85,6 +99,8 @@ public partial class VisualAnalyzer : Form
       public VisualAnalyzer()
       {
          InitializeComponent();
+
+         _TokenStyles = new Dictionary<string, FastColoredTextBoxNS.Style>();
       }
 
       #endregion
@@ -160,8 +176,10 @@ public void ParseSource()
          if (ParseWithSllMode) options |= ParseOption.Sll;
          if (ParseWithTracing) options |= ParseOption.Trace;
          analyzer.Parse(CmbRules.SelectedItem.ToString(), options, listener);
+         _Tokens = analyzer.DisplayTokens;
          PopulateTokens(analyzer.DisplayTokens);
-         PopulateParserMessages(listener.Errors);
+         _ParseErrors = listener.Errors;
+         PopulateParserMessages(_ParseErrors);
          BuildParseTreeTreeViewGuide(analyzer.ParseContext);
          BuildParseTreeGraph(analyzer.ParseContext);
       }
@@ -194,6 +212,10 @@ public void SetGrammar(GrammarReference grammar)
          _ParserRules = scanner.GetParserRulesForGrammar(grammar).ToList();
          LoadParserRules();
          stripLabelGrammarName.Text = grammar.GrammarName;
+
+         // Now try to load an IEditorGuide instance for the specified Grammar
+         _TokenStyles.Clear();
+         LoadEditorGuide(grammar);
       }
 
       /// <summary>
@@ -267,6 +289,45 @@ private void BuildParseTreeTreeViewGuide(ITree tree)
          ParseTreeView.ResumeLayout();
       }
 
+      private void LoadEditorGuide([NotNull] GrammarReference grammar)
+      {
+         if (grammar == null)
+            throw new ArgumentNullException(nameof(grammar));
+
+         _EditorGuide = null;
+         _ErrorStyle = null;
+
+         var scanner = new Scanner();
+         var loader = new Loader();
+
+         // First try loading a guide from the target assembly's directory
+         var pathRoot = Path.GetDirectoryName(grammar.AssemblyPath);
+         if (LoadGuideFromPath(grammar, scanner, loader, pathRoot))
+            return;
+
+         // Now try loading a guide from the Grun.Net Guides folder
+         pathRoot = Path.GetDirectoryName(Assembly.GetExecutingAssembly().CodeBase);
+         pathRoot = Path.Combine(pathRoot, "Guides");
+         if (Directory.Exists(pathRoot))
+            LoadGuideFromPath(grammar, scanner, loader, pathRoot);
+      }
+
+      private bool LoadGuideFromPath(GrammarReference grammar, Scanner scanner, Loader loader, string pathRoot)
+      {
+         var guideReferences = scanner.LocateAllEditorGuides(pathRoot ?? throw new InvalidOperationException());
+         foreach (var reference in guideReferences)
+         {
+            var guide = loader.LoadEditorGuide(reference);
+            if (guide != null && guide.GrammarName == grammar.GrammarName)
+            {
+               _EditorGuide = guide;
+               return true;
+            }
+         }
+
+         return false;
+      }
+
       private void ParserRulesCombo_SelectedIndexChanged(object sender, EventArgs e)
       {
          if (CmbRules.Items.Count > 0)
@@ -276,6 +337,66 @@ private void ParserRulesCombo_SelectedIndexChanged(object sender, EventArgs e)
       private void CodeEditor_TextChanged(object sender, TextChangedEventArgs e)
       {
          ParseSource();
+         //CodeEditor.ClearStylesBuffer();
+         ColorizeTokens();
+         ColorizeErrors();
+      }
+
+      private void ColorizeErrors()
+      {
+         if (_EditorGuide == null)
+            return;
+
+         foreach (var error in _ParseErrors)
+         {
+            var token = error.Token;
+            var startingPlace = new Place(token.Column, token.Line - 1);
+            var stoppingPlace = new Place(token.Column + token.Text.Length, token.Line - 1);
+            var tokenRange = CodeEditor.GetRange(startingPlace, stoppingPlace);
+            tokenRange.SetStyle(GetParseErrorStyle());
+         }
+      }
+
+      private void ColorizeTokens()
+      {
+         if (_EditorGuide == null)
+            return;
+
+         CodeEditor.BeginUpdate();
+         try
+         {
+            foreach (var token in _Tokens)
+            {
+               var startingPlace = new Place(token.ActualToken.Column, token.ActualToken.Line - 1);
+               var stoppingPlace = new Place(token.ActualToken.Column + token.Text.Length, token.ActualToken.Line - 1);
+               var tokenRange = CodeEditor.GetRange(startingPlace, stoppingPlace);
+               tokenRange.ClearStyle(StyleIndex.All);
+               var style = GetTokenStyle(token);
+               tokenRange.SetStyle(style);
+            }
+         }
+         finally
+         {
+            CodeEditor.EndUpdate();
+         }
+      }
+
+      private Style GetTokenStyle(TokenViewModel token)
+      {
+         if (_TokenStyles.TryGetValue(token.Type, out var style))
+            return style;
+
+         var foregroundBrush = _EditorGuide.GetTokenForegroundBrush(token.Type);
+         var backgroundBrush = _EditorGuide.GetTokenBackgroundBrush(token.Type);
+         var fontStyle = _EditorGuide.GetTokenFontStyle(token.Type);
+         style = new TextStyle(foregroundBrush, backgroundBrush, fontStyle);
+         _TokenStyles[token.Type] = style;
+         return style;
+      }
+
+      private Style GetParseErrorStyle()
+      {
+         return _ErrorStyle ?? (_ErrorStyle = new WavyLineStyle(240, _EditorGuide.ErrorColor));
       }
 
       private void ExitToolStripMenuItem_Click(object sender, EventArgs e)

TestRig/Grammar/EditorGuideReference.cs

@@ -0,0 +1,68 @@
+#region BSD 3-Clause License
+// <copyright file="EditorGuideReference.cs" company="Edgerunner.org">
+// Copyright 2020 
+// </copyright>
+// 
+// BSD 3-Clause License
+// 
+// Copyright (c) 2020, 
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+// 
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+// 
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+// 
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#endregion
+
+using System;
+
+using JetBrains.Annotations;
+
+namespace Org.Edgerunner.ANTLR4.Tools.Testing.Grammar
+{
+   public class EditorGuideReference
+   {
+      /// <summary>
+      /// Initializes a new instance of the <see cref="EditorGuideReference"/> class.
+      /// </summary>
+      /// <param name="guideType">Type of the guide.</param>
+      /// <param name="assemblyPath">The assembly.</param>
+      /// <exception cref="ArgumentNullException">
+      /// guideType
+      /// or
+      /// assembly are null.
+      /// </exception>
+      public EditorGuideReference([NotNull] Type guideType, [NotNull] string assemblyPath)
+      {
+         if (string.IsNullOrEmpty(assemblyPath)) 
+            throw new ArgumentNullException(nameof(assemblyPath));
+
+         GuideType = guideType ?? throw new ArgumentNullException(nameof(guideType));
+         AssemblyPath = assemblyPath;
+      }
+
+      public Type GuideType { get; }
+
+      public string AssemblyPath { get; }
+   }
+}

TestRig/GrammarReference.cs TestRig/Grammar/GrammarReference.csTestRig/GrammarReference.cs renamed to TestRig/Grammar/GrammarReference.cs

@@ -41,7 +41,7 @@
 
 using JetBrains.Annotations;
 
-namespace Org.Edgerunner.ANTLR4.Tools.Testing
+namespace Org.Edgerunner.ANTLR4.Tools.Testing.Grammar
 {
    /// <summary>
    ///    Class that represents a reference to an ANTLR grammar.

TestRig/Grammar/Loader.cs

@@ -35,13 +35,16 @@
 #endregion
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Reflection;
 
 using Antlr4.Runtime;
 
 using JetBrains.Annotations;
 
+using Org.Edgerunner.ANTLR4.Tools.Common;
+
 namespace Org.Edgerunner.ANTLR4.Tools.Testing.Grammar
 {
    /// <summary>
@@ -90,5 +93,46 @@ public Antlr4.Runtime.Parser LoadParser([NotNull] GrammarReference reference, [N
          var lexer = Activator.CreateInstance(reference.Parser, stream) as Parser;
          return lexer;
       }
+
+      /// <summary>
+      /// Loads an <see cref="IEditorGuide"/> instance for the referenced grammar.
+      /// </summary>
+      /// <param name="reference">The editor guide reference.</param>
+      /// <returns>A new <see cref="IEditorGuide" />.</returns>
+      /// <exception cref="ArgumentNullException"><paramref name="reference"/> is <see langword="null"/></exception>
+      /// <exception cref="T:System.ArgumentNullException"><paramref name="reference" /> is <see langword="null" /></exception>
+      /// <exception cref="T:System.IO.FileLoadException">A file that was found could not be loaded.</exception>
+      /// <exception cref="T:System.IO.FileNotFoundException">The assembly path is an empty string ("") or does not exist.</exception>
+      /// <exception cref="T:System.BadImageFormatException">The assembly path is not a valid assembly.</exception>
+      public IEditorGuide LoadEditorGuide([NotNull] EditorGuideReference reference)
+      {
+         if (reference is null) throw new ArgumentNullException(nameof(reference));
+
+         Assembly.Load(File.ReadAllBytes(reference.AssemblyPath));
+         var guide = Activator.CreateInstance(reference.GuideType) as IEditorGuide;
+         return guide;
+      }
+
+      /// <summary>
+      /// Loads all editor guides.
+      /// </summary>
+      /// <param name="references">The references to load.</param>
+      /// <returns>An <see cref="IEnumerable{IEditorGuide}"/> instance.</returns>
+      /// <exception cref="ArgumentNullException">references is null.</exception>
+      /// <exception cref="T:System.IO.FileLoadException">A file that was found could not be loaded.</exception>
+      /// <exception cref="T:System.IO.FileNotFoundException">The assembly path is an empty string ("") or does not exist.</exception>
+      /// <exception cref="T:System.BadImageFormatException">The assembly path is not a valid assembly.</exception>
+      public IEnumerable<IEditorGuide> LoadAllEditorGuides([NotNull] IEnumerable<EditorGuideReference> references)
+      {
+         if (references == null)
+            throw new ArgumentNullException(nameof(references));
+
+         var results = new List<IEditorGuide>();
+
+         foreach (var guideReference in references)
+            results.Add(LoadEditorGuide(guideReference));
+
+         return results;
+      }
    }
 }