From: Jean-Philippe Bruyère Date: Sat, 8 Mar 2025 11:51:26 +0000 (+0100) Subject: Syntax analysing improvment wip start X-Git-Url: https://git.osiis.dedyn.io/?a=commitdiff_plain;h=9d68cad81cb61dd16d0a6b78230531906e0e72b2;p=jp%2Fcrowedit.git Syntax analysing improvment wip start --- diff --git a/CrowEditBase/src/Compiler/SourceDocument.cs b/CrowEditBase/src/Compiler/SourceDocument.cs index b7126be..d702db1 100644 --- a/CrowEditBase/src/Compiler/SourceDocument.cs +++ b/CrowEditBase/src/Compiler/SourceDocument.cs @@ -9,6 +9,7 @@ using System.Diagnostics; using System.Collections; using System.Collections.Generic; using Drawing2D; +using System.Security; namespace CrowEditBase { @@ -26,7 +27,10 @@ namespace CrowEditBase CMDRefreshSyntaxTree = new ActionCommand ("Reparse", parse, "#icons.refresh.svg", true); } - public SyntaxRootNode Root => root; + public SyntaxRootNode Root { + get => root; + } + public bool IsParsed => root != null && Tokens.Length > 0; public ReadOnlySpan Tokens => root.Tokens; public IEnumerable SyntaxRootChildNodes => root?.children; @@ -82,13 +86,9 @@ namespace CrowEditBase protected override void apply(TextChange change) { SyntaxNode editedNode = root?.FindNodeIncludingSpan (new TextSpan (change.Start, change.End)); - base.apply(change); - - SyntaxAnalyser syntaxAnalyser = CreateSyntaxAnalyser (); - root = syntaxAnalyser?.Process (); - - NotifyValueChanged("Exceptions", syntaxAnalyser?.Exceptions); + parse (); + //SyntaxNode changedNode = root.FindNodeIncludingSpan (TextSpan.FromStartAndLength (change.Start, change.ChangedText.Length)); @@ -140,9 +140,9 @@ namespace CrowEditBase protected abstract SyntaxAnalyser CreateSyntaxAnalyser (); public abstract IList GetSuggestions (int absoluteTextPos, int currentTokenIndex, SyntaxNode currentNode, CharLocation loc); - void parse () { + protected virtual async void parse () { SyntaxAnalyser syntaxAnalyser = CreateSyntaxAnalyser (); - root = syntaxAnalyser?.Process (); + root = await syntaxAnalyser.Process (); NotifyValueChanged("Exceptions", syntaxAnalyser?.Exceptions); NotifyValueChanged ("SyntaxRootChildNodes", (object)null); diff --git a/CrowEditBase/src/Compiler/SyntaxAnalyser.cs b/CrowEditBase/src/Compiler/SyntaxAnalyser.cs index 98a4117..4097874 100644 --- a/CrowEditBase/src/Compiler/SyntaxAnalyser.cs +++ b/CrowEditBase/src/Compiler/SyntaxAnalyser.cs @@ -4,25 +4,25 @@ using System; using System.Collections.Generic; using System.Linq; +using System.Threading.Tasks; using Crow.Text; namespace CrowEditBase { public abstract class SyntaxAnalyser { - //protected abstract void Parse(SyntaxNode node); - protected ReadOnlyMemory source; + protected SourceDocument document; protected LineCollection lines; protected SyntaxRootNode Root; public IEnumerable Exceptions => Root?.GetAllExceptions(); public SyntaxAnalyser (SourceDocument document) { - this.source = document.ImmutableBufferCopy; + this.document = document; this.lines = document.Lines; } - public abstract SyntaxRootNode Process (); + public abstract Task Process (); #region Token handling protected Token curTok => tokIdx < 0 ? default : tokens[tokIdx]; - protected ReadOnlySpan curTokString => curTok.AsString(source.Span); + protected ReadOnlySpan tokens => Root.Tokens; protected bool EOF => tokIdx == tokens.Length; protected bool tryRead (out Token tok) { diff --git a/CrowEditBase/src/Compiler/SyntaxNode.cs b/CrowEditBase/src/Compiler/SyntaxNode.cs index 00dd6c7..e886313 100644 --- a/CrowEditBase/src/Compiler/SyntaxNode.cs +++ b/CrowEditBase/src/Compiler/SyntaxNode.cs @@ -9,7 +9,12 @@ using Crow; namespace CrowEditBase { + /*public class SingleTokenSyntax { + Token token; + + }*/ public class SyntaxNode : CrowEditComponent { + #region CTOR internal SyntaxNode () {} public SyntaxNode (int startLine, int tokenBase, int? lastTokenIdx = null) { StartLine = startLine; @@ -17,12 +22,17 @@ namespace CrowEditBase if (lastTokenIdx.HasValue) lastTokenOfset = lastTokenIdx - tokenBase; } - - bool _isExpanded; + #endregion + + internal List children = new List (); + + internal int? lastTokenOfset; - internal bool isFolded; internal int lineCount; + #region Folding and ?expand? + bool _isExpanded; + internal bool isFolded; public bool isExpanded { get => _isExpanded; @@ -33,26 +43,60 @@ namespace CrowEditBase NotifyValueChanged (_isExpanded); } } + public virtual bool IsFoldable => IsComplete && !(Parent != Root && Parent.StartLine == StartLine) && lineCount > 1; public void ExpandToTheTop () { isExpanded = true; Parent?.ExpandToTheTop (); } - public SyntaxNode Parent { get; private set; } - public int StartLine { get; private set; } - public virtual int LineCount => lineCount; - public virtual bool IsComplete => lastTokenOfset.HasValue; - public virtual bool IsFoldable => IsComplete && !(Parent != Root && Parent.StartLine == StartLine) && lineCount > 1; - public virtual SyntaxRootNode Root => Parent.Root; public virtual void UnfoldToTheTop () { isFolded = false; Parent.UnfoldToTheTop (); } - protected Token getTokenByIndex (int idx) => Root.GetTokenByIndex(idx); - internal List children = new List (); + public IEnumerable VisibleFoldableNodes { + get { + if (IsFoldable) { + yield return this; + } + if (!isFolded) { + foreach (SyntaxNode n in Children) { + foreach (SyntaxNode folds in n.VisibleFoldableNodes) + yield return folds; + } + } + } + } + public virtual int FoldedLineCount { + get { + if (isFolded) + return lineCount; + int tmp = 0; + if (HasChilds) { + foreach (SyntaxNode n in children.Where (c => c.IsFoldable)) + tmp += n.FoldedLineCount; + } + return tmp; + } + } + #endregion + + + + public IEnumerable Children => children; + public bool HasChilds => children.Count > 0; + public SyntaxNode Parent { get; private set; } + public virtual bool IsComplete => lastTokenOfset.HasValue; + + public virtual SyntaxRootNode Root => Parent.Root; + + + public int StartLine { get; private set; } + public virtual int LineCount => lineCount; + + List exceptions = new List(); + public IEnumerable Exceptions => exceptions; public void AddException(SyntaxException e) => exceptions.Add(e); public void ResetExceptions(SyntaxException e) => exceptions.Clear(); - public IEnumerable Exceptions => exceptions; public IEnumerable GetAllExceptions() { foreach (SyntaxException e in exceptions) yield return e; @@ -62,9 +106,11 @@ namespace CrowEditBase } } - public IEnumerable Children => children; + + protected Token getTokenByIndex (int idx) => Root.GetTokenByIndex(idx); + + //public int IndexOf (SyntaxNode node) => children.IndexOf (node); - public bool HasChilds => children.Count > 0; public SyntaxNode NextSibling { get { if (Parent != null) { @@ -87,31 +133,6 @@ namespace CrowEditBase } public virtual SyntaxNode NextSiblingOrParentsNextSibling => NextSibling ?? Parent.NextSiblingOrParentsNextSibling; - public IEnumerable VisibleFoldableNodes { - get { - if (IsFoldable) { - yield return this; - } - if (!isFolded) { - foreach (SyntaxNode n in Children) { - foreach (SyntaxNode folds in n.VisibleFoldableNodes) - yield return folds; - } - } - } - } - public virtual int FoldedLineCount { - get { - if (isFolded) - return lineCount; - int tmp = 0; - if (HasChilds) { - foreach (SyntaxNode n in children.Where (c => c.IsFoldable)) - tmp += n.FoldedLineCount; - } - return tmp; - } - } public virtual int TokenIndexBase { get; private set; } public virtual int TokenCount => lastTokenOfset.HasValue ? lastTokenOfset.Value + 1 : 0; @@ -130,6 +151,8 @@ namespace CrowEditBase return new TextSpan (startTok.Start, endTok.End); } } + public int SpanStart; + public SyntaxNode AddChild (SyntaxNode child) { children.Add (child); child.Parent = this; diff --git a/CrowEditBase/src/Compiler/Tokenizer.cs b/CrowEditBase/src/Compiler/Tokenizer.cs index ee3f2d6..b9788a8 100644 --- a/CrowEditBase/src/Compiler/Tokenizer.cs +++ b/CrowEditBase/src/Compiler/Tokenizer.cs @@ -18,7 +18,7 @@ namespace CrowEditBase protected int startOfTok; public Tokenizer () {} - public abstract Token[] Tokenize (ReadOnlySpan source); + public abstract Token[] Tokenize (ReadOnlySpan source = default); /// /// First method to call in tokenizers to init parsing variables /// diff --git a/CrowEditBase/src/SourceEditor.cs b/CrowEditBase/src/SourceEditor.cs index 27b4d16..ce40fb6 100644 --- a/CrowEditBase/src/SourceEditor.cs +++ b/CrowEditBase/src/SourceEditor.cs @@ -413,6 +413,8 @@ namespace CrowEditBase doc.EnterReadLock(); try { int foldedLines = 0; + if (!doc.IsParsed) + return 0; IEnumerator foldsEnum = doc.Root.VisibleFoldableNodes.GetEnumerator(); bool notEndOfFolds = foldsEnum.MoveNext(); while (notEndOfFolds && foldsEnum.Current.StartLine < absoluteLine) { @@ -438,6 +440,8 @@ namespace CrowEditBase doc.EnterReadLock(); try { int foldedLines = 0; + if (!doc.IsParsed) + return 0; IEnumerator nodeEnum = doc.Root.VisibleFoldableNodes.GetEnumerator (); if (!nodeEnum.MoveNext()) return 0; diff --git a/plugins/CECrowPlugin/src/Parsing/IML/ImlSyntaxAnalyser.cs b/plugins/CECrowPlugin/src/Parsing/IML/ImlSyntaxAnalyser.cs index e1b9047..d8d9816 100644 --- a/plugins/CECrowPlugin/src/Parsing/IML/ImlSyntaxAnalyser.cs +++ b/plugins/CECrowPlugin/src/Parsing/IML/ImlSyntaxAnalyser.cs @@ -6,6 +6,7 @@ using System.Collections.Generic; using System.Linq; using CrowEditBase; using CrowEdit.Xml; +using System.Threading.Tasks; namespace CECrowPlugin { @@ -13,9 +14,9 @@ namespace CECrowPlugin public ImlSyntaxAnalyser (ImlDocument document) : base (document) {} - public override SyntaxRootNode Process () { + public override async Task Process () { - return base.Process(); + return await base.Process(); /* ImlDocument xmlDoc = source as ImlDocument; diff --git a/plugins/CECrowPlugin/src/Parsing/Styling/StyleSyntaxAnalyser.cs b/plugins/CECrowPlugin/src/Parsing/Styling/StyleSyntaxAnalyser.cs new file mode 100644 index 0000000..e7a670e --- /dev/null +++ b/plugins/CECrowPlugin/src/Parsing/Styling/StyleSyntaxAnalyser.cs @@ -0,0 +1,72 @@ +// Copyright (c) 2021-2021 Bruyère Jean-Philippe +// +// This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT) +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading.Tasks; +using CrowEditBase; + +namespace CECrowPlugin.Style +{ + public static class Extensions { + public static StyleTokenType GetTokenType (this Token tok) { + return (StyleTokenType)tok.Type; + } + public static void SetTokenType (this Token tok, StyleTokenType type) { + tok.Type = (TokenType)type; + } + } + public class StyleSyntaxAnalyser : SyntaxAnalyser { + public StyleSyntaxAnalyser (StyleDocument document) : base (document) {} + + public override async Task Process () { + Tokenizer tokenizer = new StyleTokenizer(); + ReadOnlyMemory source = document.ImmutableBufferCopy; + Token[] tokens = tokenizer.Tokenize(source.Span); + currentNode = Root = new StyleRootSyntax (source, tokens); + + currentLine = 0; + tokIdx = 0; + + while (tokIdx < tokens.Length) { + if (!skipTrivia(true)) + break; + Token curTok = tokens[tokIdx]; + if (currentNode is StyleRootSyntax srs) { + if (tokens[tokIdx].GetTokenType() != StyleTokenType.Name) { + addException ("Unexpected Token"); + } else { + StyleIdentifierSyntax sis = new StyleIdentifierSyntax(currentLine, tokIdx); + if (!skipTrivia(true)) { + addException ("Unexpected end of file"); + break; + } + if (tokens[tokIdx].GetTokenType() == StyleTokenType.EqualSign) { + ConstantDefinitionSyntax cds = new ConstantDefinitionSyntax(sis); + cds.equal = tokIdx; + if (!skipTrivia(true)) { + addException ("Unexpected end of file"); + break; + } + + + } + + } + } + + tokIdx++; + } + while (currentNode.Parent != null) { + if (!currentNode.LastTokenIndex.HasValue) + finishCurrentNode (-1); + else + currentNode = currentNode.Parent; + } + setCurrentNodeEndLine (currentLine); + + return Root; + } + } +} \ No newline at end of file diff --git a/plugins/CECrowPlugin/src/Parsing/Styling/SyntaxAnalyser.cs b/plugins/CECrowPlugin/src/Parsing/Styling/SyntaxAnalyser.cs deleted file mode 100644 index ee7f780..0000000 --- a/plugins/CECrowPlugin/src/Parsing/Styling/SyntaxAnalyser.cs +++ /dev/null @@ -1,63 +0,0 @@ -// Copyright (c) 2021-2021 Bruyère Jean-Philippe -// -// This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT) -using System; -using System.Collections.Generic; -using System.Linq; -using CrowEditBase; - -namespace CECrowPlugin.Style -{ - public static class Extensions { - public static StyleTokenType GetTokenType (this Token tok) { - return (StyleTokenType)tok.Type; - } - public static void SetTokenType (this Token tok, StyleTokenType type) { - tok.Type = (TokenType)type; - } - } - public class StyleSyntaxAnalyser : SyntaxAnalyser { - public StyleSyntaxAnalyser (StyleDocument document) : base (document) {} - - public override SyntaxRootNode Process () { - Tokenizer tokenizer = new StyleTokenizer(); - Token[] tokens = tokenizer.Tokenize(source.Span); - - currentNode = Root = new StyleRootSyntax (source, tokens); - - currentLine = 0; - tokIdx = 0; - - int firstNameIdx = -1; - - while (tokIdx < tokens.Length) { - Token curTok = tokens[tokIdx]; - if (curTok.Type == TokenType.LineBreak) - currentLine++; - else if (!curTok.Type.HasFlag (TokenType.Trivia)) { - /*if (currentNode is StyleRootSyntax root) { - if (firstNameIdx < 0) { - if (curTok.GetTokenType() == StyleTokenType.Name) { - firstNameIdx = tokIdx; - } else { - Exceptions.Add (new SyntaxException ("Unexpected Token", curTok)); - } - - } - - }*/ - } - tokIdx++; - } - while (currentNode.Parent != null) { - if (!currentNode.LastTokenIndex.HasValue) - finishCurrentNode (-1); - else - currentNode = currentNode.Parent; - } - setCurrentNodeEndLine (currentLine); - - return Root; - } - } -} \ No newline at end of file diff --git a/plugins/CECrowPlugin/src/Parsing/Styling/SyntaxNodes.cs b/plugins/CECrowPlugin/src/Parsing/Styling/SyntaxNodes.cs index 0619d71..a615950 100644 --- a/plugins/CECrowPlugin/src/Parsing/Styling/SyntaxNodes.cs +++ b/plugins/CECrowPlugin/src/Parsing/Styling/SyntaxNodes.cs @@ -14,12 +14,29 @@ namespace CECrowPlugin.Style public StyleRootSyntax (ReadOnlyMemory source, Token[] tokens) : base (source, tokens) { } } public class ConstantDefinitionSyntax : SyntaxNode { - internal int? name, equal, valueOpen, valueClose; - public override bool IsComplete => base.IsComplete & name.HasValue & equal.HasValue & + internal int? equal; + public readonly StyleIdentifierSyntax Identifier; + public readonly ImlValueSyntax Value; + public override bool IsComplete => base.IsComplete & Identifier != null & equal.HasValue; + public ConstantDefinitionSyntax (StyleIdentifierSyntax id) + : base (id.StartLine, id.TokenIndexBase) { + Identifier = id; + } + } + public class StyleIdentifierSyntax : SyntaxNode { + public StyleIdentifierSyntax (int startLine, int tokenBase) + : base (startLine, tokenBase, tokenBase) { + EndLine = startLine; + } + } + public class ImlValueSyntax : SyntaxNode { + internal int? valueOpen, value, valueClose; + public override bool IsComplete => base.IsComplete & value.HasValue & valueOpen.HasValue & valueClose.HasValue; - public ConstantDefinitionSyntax (int startLine, int tokenBase) + public ImlValueSyntax (int startLine, int tokenBase) : base (startLine, tokenBase) { } + } public class AttributeSyntax : SyntaxNode { public Token? NameToken { get; internal set; } diff --git a/plugins/CEEbnfPlugin/src/Parsing/EbnfSyntaxAnalyser.cs b/plugins/CEEbnfPlugin/src/Parsing/EbnfSyntaxAnalyser.cs index d733ab3..bfa4a9b 100644 --- a/plugins/CEEbnfPlugin/src/Parsing/EbnfSyntaxAnalyser.cs +++ b/plugins/CEEbnfPlugin/src/Parsing/EbnfSyntaxAnalyser.cs @@ -4,6 +4,7 @@ using System; using System.Collections.Generic; +using System.Threading.Tasks; using CrowEditBase; namespace CrowEdit.Ebnf @@ -21,12 +22,13 @@ namespace CrowEdit.Ebnf //NCName | StringLiteral | CharCode | CharClass | '(' Choice ')' // StringLiteral ::= '"' [^"]* '"' | "'" [^']* "'" - public override SyntaxRootNode Process() + public override async Task Process() { Tokenizer tokenizer = new EbnfTokenizer(); + ReadOnlyMemory source = document.ImmutableBufferCopy; Token[] tokens = tokenizer.Tokenize(source.Span); - currentNode = Root = new EbnfRootSyntax (source, tokens); + currentLine = 0; tokIdx = 0; diff --git a/plugins/CERoslynPlugin/src/CSDocument.cs b/plugins/CERoslynPlugin/src/CSDocument.cs index e4a3aac..adabef8 100644 --- a/plugins/CERoslynPlugin/src/CSDocument.cs +++ b/plugins/CERoslynPlugin/src/CSDocument.cs @@ -33,11 +33,10 @@ namespace CERoslynPlugin App.GetService ()?.Start (); } - CSharpSyntaxTree tree; + internal CSharpSyntaxTree tree; public CSDocument (string fullPath, string editorPath) : base (fullPath, editorPath) { tree = (CSharpSyntaxTree)CSharpSyntaxTree.ParseText (source.ToString(), CSharpParseOptions.Default); - var root = tree.GetRoot(); } #region SourceDocument abstract class implementation @@ -93,7 +92,20 @@ namespace CERoslynPlugin return Colors.DarkSlateBlue; return Colors.Red; - } + } + + protected override void apply(TextChange change) + { + buffer.Update(change); + NotifyValueChanged ("IsDirty", IsDirty); + CMDSave.CanExecute = IsDirty; - } + parse(); + } + protected override void parse() + { + tree = (CSharpSyntaxTree)CSharpSyntaxTree.ParseText (source.ToString(), CSharpParseOptions.Default); + base.parse(); + } + } } \ No newline at end of file diff --git a/plugins/CERoslynPlugin/src/CSSyntaxAnalyser.cs b/plugins/CERoslynPlugin/src/CSSyntaxAnalyser.cs index 6f17c91..a2e1fd5 100644 --- a/plugins/CERoslynPlugin/src/CSSyntaxAnalyser.cs +++ b/plugins/CERoslynPlugin/src/CSSyntaxAnalyser.cs @@ -4,6 +4,7 @@ using System; using System.Collections.Generic; using System.Linq; +using System.Threading.Tasks; using CrowEditBase; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; @@ -26,22 +27,20 @@ namespace CERoslynPlugin { throw new NotImplementedException(); }*/ + CSDocument csdoc; + public CSSyntaxAnalyser (CSDocument document) : base (document) { + csdoc = document; + } - public CSSyntaxAnalyser (CSDocument document) : base (document) {} - - public override SyntaxRootNode Process () { - CSTokenizer tokenizer = new CSTokenizer(); - Token[] tokens = tokenizer.Tokenize(source.Span); - - - + public override async Task Process () { + CSTokenizer tokenizer = new CSTokenizer(csdoc.tree); + ReadOnlyMemory source = document.ImmutableBufferCopy; + Token[] tokens = tokenizer.Tokenize(); CsharpSyntaxWalkerBridge bridge = new CsharpSyntaxWalkerBridge(new CSRootSyntax (source, tokens)); - bridge.Visit(tokenizer.syntaxTree.GetRoot()); - - Root = bridge.Root; - + bridge.Visit(await tokenizer.syntaxTree.GetRootAsync()); + Root = bridge.Root; return Root; } } diff --git a/plugins/CERoslynPlugin/src/CSTokenizer.cs b/plugins/CERoslynPlugin/src/CSTokenizer.cs index 5f0b3d4..e90d6ec 100644 --- a/plugins/CERoslynPlugin/src/CSTokenizer.cs +++ b/plugins/CERoslynPlugin/src/CSTokenizer.cs @@ -16,17 +16,19 @@ namespace CERoslynPlugin { public class CSTokenizer : Tokenizer { - protected List Toks; public SyntaxTree syntaxTree; + public CSTokenizer(SyntaxTree syntaxTree) { + this.syntaxTree = syntaxTree; + } - public override Token[] Tokenize(ReadOnlySpan source) + public override Token[] Tokenize(ReadOnlySpan source = default) { /*foreach (var e in Enum.GetNames(typeof(SyntaxKind))) { Console.WriteLine($"case SyntaxKind.{e}:"); Console.WriteLine($"\treturn CSTokenType.Unknown;"); }*/ - syntaxTree = CSharpSyntaxTree.ParseText(source.ToString()); +// syntaxTree = CSharpSyntaxTree.ParseText(source.ToString()); CsharpSyntaxWalkerTokenizer bridge = new CsharpSyntaxWalkerTokenizer(); bridge.Visit(syntaxTree.GetRoot()); Toks = bridge.Toks; diff --git a/plugins/CERoslynPlugin/src/ProjectTree/MSBuildProjectItemNodes.cs b/plugins/CERoslynPlugin/src/ProjectTree/MSBuildProjectItemNodes.cs index ff9f76a..72ff324 100644 --- a/plugins/CERoslynPlugin/src/ProjectTree/MSBuildProjectItemNodes.cs +++ b/plugins/CERoslynPlugin/src/ProjectTree/MSBuildProjectItemNodes.cs @@ -82,9 +82,13 @@ namespace CERoslynPlugin return "#icons.file_type_csharp.svg"; case ".svg": return "#icons.file_type_svg.svg"; - case ".crow": case ".xml": return "#icons.file_type_xml.svg"; + case ".crow": + case ".template": + case ".itemp": + case ".iml": + return "#icons.file_type_xml.svg"; default: return "#icons.blank-file.svg"; } diff --git a/plugins/CEXmlPlugin/src/Parsing/XmlSyntaxAnalyser.cs b/plugins/CEXmlPlugin/src/Parsing/XmlSyntaxAnalyser.cs index 42be30f..cf47c95 100644 --- a/plugins/CEXmlPlugin/src/Parsing/XmlSyntaxAnalyser.cs +++ b/plugins/CEXmlPlugin/src/Parsing/XmlSyntaxAnalyser.cs @@ -5,6 +5,7 @@ using System; using System.Collections.Generic; using System.Linq; using System.Reflection.Metadata.Ecma335; +using System.Threading.Tasks; using CrowEditBase; namespace CrowEdit.Xml @@ -14,11 +15,12 @@ namespace CrowEdit.Xml public virtual void ProcessAttributeValueSyntax(AttributeSyntax attrib) { attrib.valueTok = tokIdx - attrib.TokenIndexBase; } - public override SyntaxRootNode Process () { + public override async Task Process () { Tokenizer tokenizer = new XmlTokenizer(); + ReadOnlyMemory source = document.ImmutableBufferCopy; Token[] tokens = tokenizer.Tokenize(source.Span); - currentNode = Root = new XMLRootSyntax (source, tokens); + currentLine = 0; tokIdx = 0; diff --git a/src/CrowEdit.cs b/src/CrowEdit.cs index 7f865d4..aa4a47d 100644 --- a/src/CrowEdit.cs +++ b/src/CrowEdit.cs @@ -13,6 +13,7 @@ using CrowEditBase; using System.Linq; using System.Text; using Drawing2D; +using System.Diagnostics; namespace CrowEdit { @@ -177,6 +178,8 @@ namespace CrowEdit } catch (Exception ex) { MessageBox.ShowModal (this, MessageBox.Type.Alert, $"Unable to open {filePath}.\n{ex.Message}"); Log(LogType.Error, $"Unable to open {filePath}.\n{ex.Message}"); + Debug.WriteLine(ex.Message); + Debug.WriteLine(ex.StackTrace); } return doc; }