{
public abstract class SyntaxAnalyser {
protected SourceDocument document;
- protected LineCollection lines;
protected SyntaxRootNode Root;
- public IEnumerable<SyntaxException> Exceptions => Root?.GetAllExceptions();
+ public IEnumerable<SyntaxException> Exceptions => null;// Root?.GetAllExceptions();
public SyntaxAnalyser (SourceDocument document) {
this.document = document;
- this.lines = document.Lines;
}
public abstract Task<SyntaxRootNode> Process ();
/// </summary>
/// <param name="endToken">The final token of this node</param>
/// <param name="endLine">the endline number of this node</param>
- protected void finishCurrentNode (int endTokenOffsetFromCurrentTokIdx = 0) {
+ /*protected void finishCurrentNode (int endTokenOffsetFromCurrentTokIdx = 0) {
int lastTokOffset = tokIdx - currentNode.TokenIndexBase + endTokenOffsetFromCurrentTokIdx;
currentNode.lastTokenOfset = lastTokOffset < 0 ? null : lastTokOffset;
if (endTokenOffsetFromCurrentTokIdx < 0) {
currentNode = currentNode.Parent;
}
protected void setCurrentNodeEndLine (int endLine)
- => currentNode.EndLine = endLine;
+ => currentNode.EndLine = endLine;*/
protected bool skipTrivia(bool skipLineBreaks = true) {
while (tryPeekFlag(out Token tok, TokenType.Trivia)) {
if (tok.Type == TokenType.LineBreak) {
return !EOF;
}
protected void addException(string message) {
- CharLocation loc = lines.GetLocation(curTok.Start);
- currentNode.AddException(new SyntaxException(message, loc, curTok));
+ /*CharLocation loc = lines.GetLocation(curTok.Start);
+ currentNode.AddException(new SyntaxException(message, loc, curTok));*/
}
namespace CrowEditBase
{
- /*public class SingleTokenSyntax {
+ public class SingleTokenSyntax : SyntaxNode {
Token token;
-
- }*/
- public class SyntaxNode : CrowEditComponent {
- #region CTOR
- internal SyntaxNode () {}
- public SyntaxNode (int startLine, int tokenBase, int? lastTokenIdx = null) {
- StartLine = startLine;
- TokenIndexBase = tokenBase;
- if (lastTokenIdx.HasValue)
- lastTokenOfset = lastTokenIdx - tokenBase;
- }
- #endregion
-
+ public override TokenType Type => token.Type;
+ public override int SpanStart => token.Start;
+ public override int SpanEnd => token.End;
+ public SingleTokenSyntax(Token tok) {
+ token = tok;
+ }
+ }
+ public class MultiNodeSyntax : SyntaxNode {
internal List<SyntaxNode> children = new List<SyntaxNode> ();
+ public IEnumerable<SyntaxNode> Children => children;
+ public SyntaxNode AddChild (SyntaxNode child) {
+ children.Add (child);
+ child.Parent = this;
+ return child;
+ }
+ public void RemoveChild (SyntaxNode child) {
+ children.Remove (child);
+ child.Parent = null;
+ }
+ public IEnumerable<T> GetChilds<T> () => children.OfType<T>();
+
+ public override bool HasChilds => children.Count > 0;
+ public override int SpanStart => HasChilds ? children[0].SpanStart : 0;
+ public override int SpanEnd => HasChilds ? children[children.Count - 1].SpanEnd : 0;
- internal int? lastTokenOfset;
- internal int lineCount;
-
- #region Folding and ?expand?
- bool _isExpanded;
internal bool isFolded;
-
- public bool isExpanded {
- get => _isExpanded;
- set {
- if (_isExpanded == value)
- return;
- _isExpanded = value;
- NotifyValueChanged (_isExpanded);
- }
- }
- public virtual bool IsFoldable => IsComplete && !(Parent != Root && Parent.StartLine == StartLine) && lineCount > 1;
+ public virtual bool IsFoldable => IsComplete && !(Parent != Root && Parent.StartLocation.Line == StartLocation.Line) && LineCount > 1;
public void ExpandToTheTop () {
isExpanded = true;
Parent?.ExpandToTheTop ();
isFolded = false;
Parent.UnfoldToTheTop ();
}
- public IEnumerable<SyntaxNode> VisibleFoldableNodes {
+ public IEnumerable<MultiNodeSyntax> VisibleFoldableNodes {
get {
if (IsFoldable) {
yield return this;
}
if (!isFolded) {
- foreach (SyntaxNode n in Children) {
- foreach (SyntaxNode folds in n.VisibleFoldableNodes)
+ foreach (MultiNodeSyntax n in Children.OfType<MultiNodeSyntax>()) {
+ foreach (MultiNodeSyntax folds in n.VisibleFoldableNodes)
yield return folds;
}
}
public virtual int FoldedLineCount {
get {
if (isFolded)
- return lineCount;
+ return LineCount;
int tmp = 0;
if (HasChilds) {
- foreach (SyntaxNode n in children.Where (c => c.IsFoldable))
+ foreach (MultiNodeSyntax n in children.OfType<MultiNodeSyntax>().Where (c => c.IsFoldable))
tmp += n.FoldedLineCount;
}
return tmp;
}
}
+ public override SyntaxNode FindNodeIncludingSpan (TextSpan span) {
+ foreach (SyntaxNode node in children) {
+ if (node.Contains (span))
+ return node.FindNodeIncludingSpan (span);
+ }
+ return this;
+ }
+ public override SyntaxNode FindNodeIncludingPosition (int pos) {
+ foreach (SyntaxNode node in children) {
+ if (node.Contains (pos))
+ return node.FindNodeIncludingPosition (pos);
+ }
+ return this;
+ }
+ }
+ public abstract class SyntaxNode : CrowEditComponent {
+
+
+ #region Folding and ?expand?
+ bool _isExpanded;
+ public bool isExpanded {
+ get => _isExpanded;
+ set {
+ if (_isExpanded == value)
+ return;
+ _isExpanded = value;
+ NotifyValueChanged (_isExpanded);
+ }
+ }
#endregion
+ public MultiNodeSyntax Parent { get; internal set; }
+ public virtual SyntaxRootNode Root => Parent.Root;
+ public virtual TokenType Type => TokenType.Unknown;
+ public virtual int SpanStart => 0;
+ public virtual int SpanEnd => 0;
- public IEnumerable<SyntaxNode> Children => children;
- public bool HasChilds => children.Count > 0;
- public SyntaxNode Parent { get; private set; }
- public virtual bool IsComplete => lastTokenOfset.HasValue;
+ public virtual bool HasChilds => false;
+ public virtual bool IsComplete => false;
- public virtual SyntaxRootNode Root => Parent.Root;
- public int StartLine { get; private set; }
- public virtual int LineCount => lineCount;
+ /*public int StartLine { get; private set; }
+ public virtual int LineCount => lineCount;*/
- List<SyntaxException> exceptions = new List<SyntaxException>();
+ /*List<SyntaxException> exceptions = new List<SyntaxException>();
public IEnumerable<SyntaxException> Exceptions => exceptions;
public void AddException(SyntaxException e) => exceptions.Add(e);
public void ResetExceptions(SyntaxException e) => exceptions.Clear();
foreach (SyntaxException ce in n.GetAllExceptions())
yield return ce;
}
- }
+ }*/
protected Token getTokenByIndex (int idx) => Root.GetTokenByIndex(idx);
public virtual SyntaxNode NextSiblingOrParentsNextSibling
=> NextSibling ?? Parent.NextSiblingOrParentsNextSibling;
- public virtual int TokenIndexBase { get; private set; }
+ /*public virtual int TokenIndexBase { get; private set; }
public virtual int TokenCount => lastTokenOfset.HasValue ? lastTokenOfset.Value + 1 : 0;
public int? LastTokenIndex => lastTokenOfset.HasValue ? TokenIndexBase + lastTokenOfset.Value : null;
lineCount = value - StartLine + 1;
}
get => StartLine + lineCount - 1;
- }
- public TextSpan Span {
- get {
- Token startTok = getTokenByIndex(TokenIndexBase);
- Token endTok = LastTokenIndex.HasValue ? getTokenByIndex (LastTokenIndex.Value) : startTok;
- return new TextSpan (startTok.Start, endTok.End);
- }
- }
- public int SpanStart;
+ }*/
+ public TextSpan Span => new TextSpan (SpanStart, SpanEnd);
+ public CharLocation StartLocation => Root.GetLocation(SpanStart);
+ public CharLocation EndLocation => Root.GetLocation(SpanEnd);
+ public int LineCount => EndLocation.Line - StartLocation.Line + 1;
- public SyntaxNode AddChild (SyntaxNode child) {
- children.Add (child);
- child.Parent = this;
- return child;
- }
- public void RemoveChild (SyntaxNode child) {
- children.Remove (child);
- child.Parent = null;
- }
- public IEnumerable<T> GetChilds<T> () => children.OfType<T>();
/*
public void Replace (SyntaxNode newNode) {
Parent.replaceChild (this, newNode);
curNode = curNode.Parent;
}
}*/
- void offset (int tokenOffset, int lineOffset) {
+ /*void offset (int tokenOffset, int lineOffset) {
TokenIndexBase += tokenOffset;
StartLine += lineOffset;
foreach (SyntaxNode child in children) {
child.offset (tokenOffset, lineOffset);
}
- }
- public SyntaxNode FindNodeIncludingPosition (int pos) {
- foreach (SyntaxNode node in children) {
- if (node.Contains (pos))
- return node.FindNodeIncludingPosition (pos);
- }
- return this;
- }
+ }*/
+/*
public T FindNodeIncludingPosition<T> (int pos) {
foreach (SyntaxNode node in children) {
if (node.Contains (pos))
}
return this is T tt ? tt : default;
- }
- public SyntaxNode FindNodeIncludingSpan (TextSpan span) {
- foreach (SyntaxNode node in children) {
- if (node.Contains (span))
- return node.FindNodeIncludingSpan (span);
- }
- return this;
- }
+ }*/
+ public virtual SyntaxNode FindNodeIncludingPosition (int pos) => this;
+ public virtual SyntaxNode FindNodeIncludingSpan (TextSpan span) => this;
+
public bool Contains (int pos) => Span.Contains (pos);
public bool Contains (TextSpan span) => Span.Contains (span);
- public void Dump (int level = 0) {
+ /*public void Dump (int level = 0) {
Console.WriteLine ($"{new string('\t', level)}{this}");
foreach (SyntaxNode node in children)
node.Dump (level + 1);
- }
+ }*/
//public override string ToString() => $"l:({StartLine,3},{LineCount,3}) tks:{TokenIndexBase},{TokenCount} {this.GetType().Name}";
public override string ToString() => $"{this.GetType().Name}";
public string AsText() {
public class CompareOnStartLine : IComparer<SyntaxNode>
{
- public int Compare(SyntaxNode x, SyntaxNode y) => x.StartLine - y.StartLine;
+ public int Compare(SyntaxNode x, SyntaxNode y) => x.StartLocation.Line - y.StartLocation.Line;
}
}
}
\ No newline at end of file
namespace CrowEditBase
{
- public abstract class SyntaxRootNode : SyntaxNode {
- public SyntaxRootNode (ReadOnlyMemory<char> source, Token[] tokens) {
- this.source = source;
+ public abstract class SyntaxRootNode : MultiNodeSyntax {
+ public SyntaxRootNode (ReadOnlyTextBuffer buffer, Token[] tokens) {
+ this.buffer = buffer;
this.tokens = tokens;
}
- protected readonly ReadOnlyMemory<char> source;
+ protected readonly ReadOnlyTextBuffer buffer;
protected Token[] tokens;
- public override int TokenIndexBase => 0;
- public override int TokenCount => tokens == null ? 0 : Math.Max (0, tokens.Length - 1);
public override SyntaxRootNode Root => this;
+
+
public override bool IsFoldable => false;
- public override SyntaxNode NextSiblingOrParentsNextSibling => null;
public override void UnfoldToTheTop() {}
+ public override SyntaxNode NextSiblingOrParentsNextSibling => null;
public ReadOnlySpan<Token> Tokens => tokens;
+
+
public string GetTokenStringByIndex (int idx) => tokens != null ?
idx >= 0 && idx < tokens.Length ? GetText(tokens[idx].Span).ToString() : null : null;
public Token GetTokenByIndex (int idx) => tokens != null ?
return idx == 0 ? 0 : idx < 0 ? ~idx - 1 : idx;
}
public ReadOnlySpan<char> GetText(TextSpan span) =>
- source.Span.Slice(span.Start, span.Length);
+ buffer.Source.Span.Slice(span.Start, span.Length);
+ public CharLocation GetLocation(int pos) => buffer.Lines.GetLocation(pos);
+
public string GetTokenString(Token tok) =>
GetText(tok.Span).ToString();
}
BlockCommentEnd = 0x0106,
Name = 0x0200,
Punctuation = 0x0400,
+ OpenParen = 0x0401,
+ CloseParen = 0x0402,
+ OpenBracket = 0x0403,
+ CloseBracket = 0x0404,
+ OpenBrace = 0x0405,
+ CloseBrace = 0x0406,
+ DoubleQuote = 0x0407,
+ SingleQuote = 0x0408,
+
Operator = 0x0800,
Keyword = 0x1000,
+ Syntax = 0x8000
}
}
\ No newline at end of file
return;
currentLoc = value;
if (currentLoc.HasValue) {
- SyntaxNode fold = getFoldContainingLine (currentLoc.Value.Line);
- while (fold != null && fold.StartLine == currentLoc.Value.Line)
+ MultiNodeSyntax fold = getFoldContainingLine (currentLoc.Value.Line);
+ while (fold != null && fold.StartLocation.Line == currentLoc.Value.Line)
fold = fold.Parent;
fold?.UnfoldToTheTop();
updateCurrentTokAndNode();
hideOverlay ();
if (mouseIsInMargin) {
if (e.Button == MouseButton.Left && mouseIsInFoldRect) {
- SyntaxNode curNode = getFoldStartingAt (hoverLoc.Value.Line);
+ MultiNodeSyntax curNode = getFoldStartingAt (hoverLoc.Value.Line);
if (curNode != null) {
curNode.isFolded = !curNode.isFolded;
textMeasureIsUpToDate = false;
}
if (Document is SourceDocument doc) {
switch (e.Key) {
- case Key.F3:
+ /*case Key.F3:
doc.Root?.Dump();
- break;
+ break;*/
case Key.Enter:
case Key.KeypadEnter:
//doc.updateCurrentTokAndNode (Selection.Start);
}
#endregion
- SyntaxNode getFoldStartingAt (int line) {
+ MultiNodeSyntax getFoldStartingAt (int line) {
if (!(Document is SourceDocument doc))
return null;
- IEnumerable<SyntaxNode> folds = doc.Root.VisibleFoldableNodes;
+ IEnumerable<MultiNodeSyntax> folds = doc.Root.VisibleFoldableNodes;
if (folds == null)
return null;
- return folds.FirstOrDefault (n => n.StartLine == line);
+ return folds.FirstOrDefault (n => n.StartLocation.Line == line);
}
- SyntaxNode getFoldContainingLine (int line) {
+ MultiNodeSyntax getFoldContainingLine (int line) {
if (!(Document is SourceDocument doc))
return null;
doc.EnterReadLock();
try {
- IEnumerable<SyntaxNode> folds = doc.Root.VisibleFoldableNodes;
+ IEnumerable<MultiNodeSyntax> folds = doc.Root.VisibleFoldableNodes;
if (folds == null)
return null;
- return folds.LastOrDefault (n => n.StartLine <= line && n.EndLine >= line);
+ return folds.LastOrDefault (n => n.StartLocation.Line <= line && n.EndLocation.Line >= line);
} finally {
doc.ExitReadLock ();
}
int foldedLines = 0;
if (!doc.IsParsed)
return 0;
- IEnumerator<SyntaxNode> foldsEnum = doc.Root.VisibleFoldableNodes.GetEnumerator();
+ IEnumerator<MultiNodeSyntax> foldsEnum = doc.Root.VisibleFoldableNodes.GetEnumerator();
bool notEndOfFolds = foldsEnum.MoveNext();
- while (notEndOfFolds && foldsEnum.Current.StartLine < absoluteLine) {
+ while (notEndOfFolds && foldsEnum.Current.StartLocation.Line < absoluteLine) {
if (foldsEnum.Current.isFolded) {
foldedLines += foldsEnum.Current.LineCount - 1;
SyntaxNode nextNode = foldsEnum.Current.NextSiblingOrParentsNextSibling;
if (nextNode == null)
break;
notEndOfFolds = foldsEnum.MoveNext();
- while (notEndOfFolds && foldsEnum.Current.StartLine < nextNode.StartLine)
+ while (notEndOfFolds && foldsEnum.Current.StartLocation.Line < nextNode.StartLocation.Line)
notEndOfFolds = foldsEnum.MoveNext();
} else
notEndOfFolds = foldsEnum.MoveNext();
int foldedLines = 0;
if (!doc.IsParsed)
return 0;
- IEnumerator<SyntaxNode> nodeEnum = doc.Root.VisibleFoldableNodes.GetEnumerator ();
+ IEnumerator<MultiNodeSyntax> nodeEnum = doc.Root.VisibleFoldableNodes.GetEnumerator ();
if (!nodeEnum.MoveNext())
return 0;
int l = 0;
while (l < visualLine + foldedLines) {
- if (nodeEnum.Current.StartLine == l) {
+ if (nodeEnum.Current.StartLocation.Line == l) {
if (nodeEnum.Current.isFolded) {
- foldedLines += nodeEnum.Current.lineCount - 1;
+ foldedLines += nodeEnum.Current.LineCount - 1;
SyntaxNode nextNode = nodeEnum.Current.NextSiblingOrParentsNextSibling;
if (nextNode == null || !nodeEnum.MoveNext())
return foldedLines;
- while (nodeEnum.Current.StartLine < nextNode.StartLine) {
+ while (nodeEnum.Current.StartLocation.Line < nextNode.StartLocation.Line) {
if (!nodeEnum.MoveNext())
return foldedLines;
}
int linesToSkip = (int)Math.Floor(ScrollY / lineHeight);
- IEnumerator<SyntaxNode> foldsEnum = doc.Root.VisibleFoldableNodes.GetEnumerator ();
+ IEnumerator<MultiNodeSyntax> foldsEnum = doc.Root.VisibleFoldableNodes.GetEnumerator ();
bool notEndOfFolds = foldsEnum.MoveNext();
- while (notEndOfFolds && foldsEnum.Current.StartLine < linesToSkip) {
+ while (notEndOfFolds && foldsEnum.Current.StartLocation.Line < linesToSkip) {
if (foldsEnum.Current.isFolded)
linesToSkip += foldsEnum.Current.LineCount-1;
notEndOfFolds = foldsEnum.MoveNext();
int curLine = linesToSkip;
pixY = -(ScrollY % lineHeight);
- IEnumerator<int> exceptionLines = doc.Root.GetAllExceptions()?.Select(e=>e.Location.Line).Order().GetEnumerator();
- bool hasExceptions = exceptionLines.MoveNext();
+ /*IEnumerator<int> exceptionLines = doc.Root.GetAllExceptions()?.Select(e=>e.Location.Line).Order().GetEnumerator();
+ bool hasExceptions = exceptionLines.MoveNext();*/
while (curLine < doc.LinesCount && printedLines < Math.Min(visibleLines, doc.LinesCount)) {
- while (hasExceptions && exceptionLines.Current < curLine) {
+ /*while (hasExceptions && exceptionLines.Current < curLine) {
hasExceptions = exceptionLines.MoveNext();
- }
+ }*/
int encodedChar = 0;
TextLine curTxtLine = doc.GetLine (curLine);
#endif
if (selectionNotEmpty && curLine >= selStart.Line && curLine <= selEnd.Line)
fillHighlight (gr, curLine, selStart, selEnd, lineRect, SelectionBackground);
- if (hasExceptions && exceptionLines.Current == curLine) {
+ /*if (hasExceptions && exceptionLines.Current == curLine) {
gr.Operator = Operator.DestOver;
gr.SetSource (new Color(1.0,0,0.0,0.3));
gr.Rectangle (lineRect);
gr.Fill ();
gr.Operator = Operator.Over;
- }
+ }*/
//Draw line numbering
if (printLineNumbers){
if (tokPtr + 1 == doc.Tokens.Length && curLine < doc.LinesCount-1)
drawLineNumber (gr, curLine+1, marginRect.X + leftMarginGap + lineNumWidth, marginRect.Y + lineHeight + fe.Ascent);
}
- bool curFoldStart = notEndOfFolds && foldsEnum.Current.StartLine == curLine;
+ bool curFoldStart = notEndOfFolds && foldsEnum.Current.StartLocation.Line == curLine;
//draw fold
if (curFoldStart) {
Rectangle rFld = new Rectangle ((int)marginRect.Right - leftMarginGap - foldSize,
pixY += lineHeight;
printedLines++;
- if (curFoldStart && curLine == foldsEnum.Current.StartLine){
+ if (curFoldStart && curLine == foldsEnum.Current.StartLocation.Line){
if (foldsEnum.Current.isFolded)
curLine += foldsEnum.Current.LineCount;
else
curLine++;
notEndOfFolds = foldsEnum.MoveNext();
- while (notEndOfFolds && foldsEnum.Current.StartLine < curLine) {
+ while (notEndOfFolds && foldsEnum.Current.StartLocation.Line < curLine) {
/*if (foldsEnum.Current.isFolded && curLine <= foldsEnum.Current.EndLine)
curLine += foldsEnum.Current.LineCount;*/
notEndOfFolds = foldsEnum.MoveNext();
namespace CrowEditBase
{
+ public class ReadOnlyTextBuffer {
+ public readonly ReadOnlyMemory<char> Source;
+ public readonly LineCollection Lines;
+ public ReadOnlyTextBuffer(ReadOnlyMemory<char> source, LineCollection lines) {
+ Source = source;
+ Lines = lines;
+ }
+ }
public class TextDocument : Document {
public TextDocument (string fullPath, string editorPath = "default")
: base (fullPath, editorPath) {
protected TextBuffer buffer;
public ReadOnlySpan<char> source => buffer.ReadOnlySpan;
- public ReadOnlyMemory<char> ImmutableBufferCopy => buffer.ReadOnlyCopy;
- internal LineCollection Lines => buffer.GetLineListCopy();
+
+ public ReadOnlyTextBuffer ImmutableBufferCopy => new ReadOnlyTextBuffer(buffer.ReadOnlyCopy, buffer.GetLineListCopy());
System.Text.Encoding encoding = System.Text.Encoding.UTF8;
public event EventHandler<TextChangeEventArgs> TextChanged;
public class AttributeSyntax : SyntaxNode {
- internal int? name, equal, valueOpen, valueClose, valueTok;
+ /*internal int? name, equal, valueOpen, valueClose, valueTok;
public string Name => name.HasValue ? Root.GetTokenStringByIndex (TokenIndexBase + name.Value) : null;
public string Value => valueTok.HasValue ? Root.GetTokenStringByIndex (TokenIndexBase + valueTok.Value) : null;
public Token? ValueToken => valueTok.HasValue ? Root.GetTokenByIndex (TokenIndexBase + valueTok.Value) : null;
public AttributeSyntax (int startLine, int tokenBase)
: base (startLine, tokenBase) {}
- public override bool IsComplete => base.IsComplete & name.HasValue & equal.HasValue & valueTok.HasValue & valueOpen.HasValue & valueClose.HasValue;
+ public override bool IsComplete => base.IsComplete & name.HasValue & equal.HasValue & valueTok.HasValue & valueOpen.HasValue & valueClose.HasValue;*/
}
}
\ No newline at end of file
public override async Task<SyntaxRootNode> Process () {
Tokenizer tokenizer = new StyleTokenizer();
- ReadOnlyMemory<char> source = document.ImmutableBufferCopy;
- Token[] tokens = tokenizer.Tokenize(source.Span);
- currentNode = Root = new StyleRootSyntax (source, tokens);
+ ReadOnlyTextBuffer buff = document.ImmutableBufferCopy;
+ Token[] tokens = tokenizer.Tokenize(buff.Source.Span);
+ currentNode = Root = new StyleRootSyntax (buff, tokens);
currentLine = 0;
tokIdx = 0;
-
+ /*
while (tokIdx < tokens.Length) {
if (!skipTrivia(true))
break;
else
currentNode = currentNode.Parent;
}
- setCurrentNodeEndLine (currentLine);
+ setCurrentNodeEndLine (currentLine);*/
return Root;
}
{
public class StyleRootSyntax : SyntaxRootNode {
- public StyleRootSyntax (ReadOnlyMemory<char> source, Token[] tokens) : base (source, tokens) { }
+ public StyleRootSyntax (ReadOnlyTextBuffer source, Token[] tokens) : base (source, tokens) { }
}
public class ConstantDefinitionSyntax : SyntaxNode {
- 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 ImlValueSyntax (int startLine, int tokenBase)
- : base (startLine, tokenBase) {
- }
}
public class AttributeSyntax : SyntaxNode {
- public Token? NameToken { get; internal set; }
- public Token? EqualToken { get; internal set; }
- public Token? ValueOpenToken { get; internal set; }
- public Token? ValueCloseToken { get; internal set; }
- public Token? ValueToken { get; internal set; }
- public AttributeSyntax (int startLine, int startTok) : base (startLine, startTok) {}
- public override bool IsComplete => base.IsComplete & NameToken.HasValue & EqualToken.HasValue &
- ValueToken.HasValue & ValueOpenToken.HasValue & ValueCloseToken.HasValue;
}
}
\ No newline at end of file
public override async Task<SyntaxRootNode> Process()
{
Tokenizer tokenizer = new EbnfTokenizer();
- ReadOnlyMemory<char> source = document.ImmutableBufferCopy;
- Token[] tokens = tokenizer.Tokenize(source.Span);
- currentNode = Root = new EbnfRootSyntax (source, tokens);
+ ReadOnlyTextBuffer buff = document.ImmutableBufferCopy;
+ Token[] tokens = tokenizer.Tokenize(buff.Source.Span);
+ currentNode = Root = new EbnfRootSyntax (buff, tokens);
currentLine = 0;
tokIdx = 0;
}
tokIdx++;
- }*/
-
-
- setCurrentNodeEndLine (currentLine);
+ }
+ setCurrentNodeEndLine (currentLine);*/
return Root;
}
{
public class EbnfRootSyntax : SyntaxRootNode {
- public EbnfRootSyntax (ReadOnlyMemory<char> source, Token[] tokens) : base (source, tokens) { }
+ public EbnfRootSyntax (ReadOnlyTextBuffer source, Token[] tokens) : base (source, tokens) { }
}
public class EbnfSyntaxNode : SyntaxNode {
- public EbnfSyntaxNode(int startLine, int tokenBase)
- : base (startLine, tokenBase) {
- }
}
public class ProductionSyntax : SyntaxNode {
- public int? ncname, equal;
- public ExpressionSyntax expression;
- public ProductionSyntax(int startLine, int tokenBase)
- : base (startLine, tokenBase) {
- }
- public ProductionSyntax(int name, int startLine, int tokenBase)
- : base (startLine, tokenBase) {
- ncname = name;
- }
- public override bool IsComplete => base.IsComplete;
}
public class ExpressionSyntax : SyntaxNode {
- public ExpressionSyntax(int startLine, int tokenBase)
- : base (startLine, tokenBase) { }
}
public class LinkSyntax : ExpressionSyntax {
- public int? openBracket, closingBracket;
- public LinkSyntax(int openBracket, int startLine, int tokenBase)
- : base (startLine, tokenBase) {
- this.openBracket = openBracket;
- }
}
public class ChoiceSyntax : ExpressionSyntax {
- public ChoiceSyntax(int startLine, int tokenBase)
- : base (startLine, tokenBase) {
- }
}
// (Item ( '-' Item | Item* ))?
public class SequenceOrDifferenceSyntax : SyntaxNode {
- public SequenceOrDifferenceSyntax(int startLine, int tokenBase)
- : base (startLine, tokenBase) { }
}
// Item ::= Primary ( '?' | '*' | '+' )? */
public class ItemSyntax : SyntaxNode {
- public ItemSyntax(int startLine, int tokenBase)
- : base (startLine, tokenBase) { }
}
/* NCName | StringLiteral | CharCode | CharClass | '(' Choice ')' */
public class PrimarySyntax : SyntaxNode {
- public PrimarySyntax(int startLine, int tokenBase)
- : base (startLine, tokenBase) {
- }
}
// StringLiteral ::= '"' [^"]* '"' | "'" [^']* "'"
public class StringLiteralSyntax : SyntaxNode {
- public StringLiteralSyntax(int startLine, int tokenBase)
- : base (startLine, tokenBase) {
-
- }
}
// CharCode ::= '#x' [0-9a-fA-F]+
public class CharCodeSyntax : SyntaxNode {
- public CharCodeSyntax(int startLine, int tokenBase)
- : base (startLine, tokenBase) {
- }
}
// CharClass ::= '[' '^'? ( Char | CharCode | CharRange | CharCodeRange )+ ']'
public class CharClassSyntax : SyntaxNode {
- public int? closingBracket;
- public CharClassSyntax(int startLine, int tokenBase)
- : base (startLine, tokenBase) {}
}
// Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF] any Unicode character, excluding the surrogate blocks, FFFE, and FFFF.
public class CharSyntax : SyntaxNode {
- public CharSyntax(int startLine, int tokenBase)
- : base (startLine, tokenBase) {
- }
}
namespace CERoslynPlugin
{
public class CSRootSyntax : SyntaxRootNode {
- public CSRootSyntax (ReadOnlyMemory<char> source, Token[] tokens) : base (source, tokens) { }
+ public CSRootSyntax (ReadOnlyTextBuffer source, Token[] tokens) : base (source, tokens) { }
}
- public class CSSyntaxNode : CrowEditBase.SyntaxNode {
-
- public CSSyntaxNode (int startLine, int tokenBase, int? lastTokenIdx = null)
- : base (startLine, tokenBase, lastTokenIdx) {
- }
+ public class CSSyntaxNode : MultiNodeSyntax {
}
public class CSSyntaxAnalyser : SyntaxAnalyser {
public override async Task<SyntaxRootNode> Process () {
CSTokenizer tokenizer = new CSTokenizer(csdoc.tree);
- ReadOnlyMemory<char> source = document.ImmutableBufferCopy;
+ ReadOnlyTextBuffer buff = document.ImmutableBufferCopy;
Token[] tokens = tokenizer.Tokenize();
- CsharpSyntaxWalkerBridge bridge = new CsharpSyntaxWalkerBridge(new CSRootSyntax (source, tokens));
+ CsharpSyntaxWalkerBridge bridge = new CsharpSyntaxWalkerBridge(new CSRootSyntax (buff, tokens));
bridge.Visit(await tokenizer.syntaxTree.GetRootAsync());
class CsharpSyntaxWalkerBridge : Microsoft.CodeAnalysis.CSharp.CSharpSyntaxWalker
{
public CSRootSyntax Root;
- CrowEditBase.SyntaxNode currentNode;
+ MultiNodeSyntax currentNode;
public CsharpSyntaxWalkerBridge (CSRootSyntax root) : base (SyntaxWalkerDepth.StructuredTrivia)
{
currentNode = Root = root;
int indexBase = Root.FindTokenIndexIncludingPosition(node.Span.Start);
int lastTokIndex = Root.FindTokenIndexIncludingPosition(node.Span.End - 1);
- currentNode = currentNode.AddChild(new CSSyntaxNode(loc.GetLineSpan().StartLinePosition.Line, indexBase, lastTokIndex));
+ currentNode = currentNode.AddChild(new CSSyntaxNode()) as MultiNodeSyntax;
base.Visit (node);
- currentNode.EndLine = end.Line;
+
currentNode = currentNode.Parent;
}
+
+ public override void VisitToken(SyntaxToken token)
+ {
+ TextSpan fs = token.FullSpan;
+ Token tok = new Token(fs.Start,fs.Length,(TokenType)token.RawKind);
+ currentNode.AddChild(new SingleTokenSyntax(tok));
+ base.VisitToken(token);
+ }
}
}
\ No newline at end of file
protected virtual IEnumerable<Suggestion> getAttributeNameSuggestions(string eltName, string attribName, TextChange change) => null;
protected virtual IEnumerable<Suggestion> getAttributeValueSuggestions(string eltName, string attribName, string attribValue, TextChange change) => null;
public override IList GetSuggestions (int absoluteTextPos, int currentTokenIndex, SyntaxNode CurrentNode, CharLocation loc) {
- Token tok = GetTokenByIndex(currentTokenIndex);
+ /*Token tok = GetTokenByIndex(currentTokenIndex);
if (tok.Start != absoluteTextPos //middle of edited tok
&& currentTokenIndex >= CurrentNode?.Root.TokenCount - 1) //occurs when curTok is last tok of text
{
}
- /*if (tokType == XmlTokenType.AttributeName) {
+ *if (tokType == XmlTokenType.AttributeName) {
if (attrib.ValueToken.HasValue) {
change = new TextChange (tok.Start, tok.Length, selectedSugg);
newSelection = new TextSpan(
else if (tokType == XmlTokenType.AttributeValue)
change = new TextChange (tok.Start, tok.Length, selectedSugg);
newSelection = TextSpan.FromStartAndLength (change.End2 + offset);
- }*/
- }
+ }*
+ }*/
return null;
}
public class XmlSyntaxAnalyser : SyntaxAnalyser {
public XmlSyntaxAnalyser (XmlDocument document) : base (document) {}
public virtual void ProcessAttributeValueSyntax(AttributeSyntax attrib) {
- attrib.valueTok = tokIdx - attrib.TokenIndexBase;
+ //attrib.valueTok = tokIdx - attrib.TokenIndexBase;
}
public override async Task<SyntaxRootNode> Process () {
Tokenizer tokenizer = new XmlTokenizer();
- ReadOnlyMemory<char> source = document.ImmutableBufferCopy;
- Token[] tokens = tokenizer.Tokenize(source.Span);
- currentNode = Root = new XMLRootSyntax (source, tokens);
+ ReadOnlyTextBuffer buff = document.ImmutableBufferCopy;
+ Token[] tokens = tokenizer.Tokenize(buff.Source.Span);
+ currentNode = Root = new XMLRootSyntax (buff, tokens);
currentLine = 0;
tokIdx = 0;
- while (tokIdx < tokens.Length) {
+ /*while (tokIdx < tokens.Length) {
if (curTok.Type == TokenType.LineBreak)
currentLine++;
else if (!curTok.Type.HasFlag (TokenType.Trivia)) {
addException ("Open/Close element name mismatch");
}
finishCurrentNode ();
- /*else {
- addException ("Open/Close element name mismatch");
- finishCurrentNode ();//finish eltEndTag->curNode is parent elt
- currentNode.RemoveChild(eltEndTag);
- finishCurrentNode (-eltEndTag.TokenCount); //dont credit parent element with those tokens from the non matching end tag
- //curNode should be parent element of previous element
- while(currentNode is ElementSyntax esp) {
- //eltEndTag is out of tree, so Name get threw exception
- if (string.Equals(esp.StartTag.Name, eltEndTagName, StringComparison.Ordinal)) {
- esp.EndTag = eltEndTag;
- esp.AddChild (eltEndTag);
- finishCurrentNode ();
- break;
- } else {
- finishCurrentNode (-eltEndTag.TokenCount);
- }
- }
- }*/
} else {
addException ("Unexpected Token");
finishCurrentNode (-1);
currentNode = currentNode.Parent;
}
//check why this is required..
- setCurrentNodeEndLine (currentLine);
+ setCurrentNodeEndLine (currentLine);*/
return Root;
}
}
{
public class XMLRootSyntax : SyntaxRootNode {
- public XMLRootSyntax (ReadOnlyMemory<char> source, Token[] tokens) : base (source, tokens) { }
+ public XMLRootSyntax (ReadOnlyTextBuffer buff, Token[] tokens) : base (buff, tokens) { }
}
- public class ProcessingInstructionSyntax : SyntaxNode {
- public int? PIClose, name;
- public override bool IsComplete => base.IsComplete & name.HasValue & PIClose.HasValue;
- public ProcessingInstructionSyntax (int startLine, int tokenBase)
- : base (startLine, tokenBase) {
- }
+ public class ProcessingInstructionSyntax : MultiNodeSyntax {
+// public override bool IsComplete => base.IsComplete & name.HasValue & PIClose.HasValue;
+ public ProcessingInstructionSyntax (){}
}
public abstract class ElementTagSyntax : SyntaxNode {
- public int? name, close;
- public override bool IsComplete => base.IsComplete & name.HasValue & close.HasValue;
- public string Name => name.HasValue ?
- Root.GetTokenStringByIndex (TokenIndexBase + name.Value) : null;
- protected ElementTagSyntax (int startLine, int tokenBase)
- : base (startLine, tokenBase) {
- }
+// public override bool IsComplete => base.IsComplete & name.HasValue & close.HasValue;
+ protected ElementTagSyntax () { }
}
public class ElementStartTagSyntax : ElementTagSyntax {
- public ElementStartTagSyntax (int startLine, int tokenBase)
- : base (startLine, tokenBase) {
- }
+ public ElementStartTagSyntax () {}
}
public class ElementEndTagSyntax : ElementTagSyntax {
- public ElementEndTagSyntax (int startLine, int tokenBase)
- : base (startLine, tokenBase) {
- }
+ public ElementEndTagSyntax () { }
}
- public class EmptyElementSyntax : SyntaxNode {
- public readonly ElementStartTagSyntax StartTag;
- public EmptyElementSyntax (ElementStartTagSyntax startNode) : base (startNode.StartLine, startNode.TokenIndexBase, startNode.LastTokenIndex) {
- StartTag = startNode;
- AddChild (StartTag);
+ public class EmptyElementSyntax : MultiNodeSyntax {
+ public EmptyElementSyntax (ElementStartTagSyntax startNode) {
+ AddChild (startNode);
}
- public override bool IsComplete => base.IsComplete && StartTag != null;
+ //public override bool IsComplete => base.IsComplete && StartTag != null;
}
- public class ElementSyntax : SyntaxNode {
- public readonly ElementStartTagSyntax StartTag;
- public ElementEndTagSyntax EndTag { get; set; }
+ public class ElementSyntax : MultiNodeSyntax {
- public override bool IsComplete => base.IsComplete & StartTag.IsComplete & (EndTag != null && EndTag.IsComplete);
+ //public override bool IsComplete => base.IsComplete & StartTag.IsComplete & (EndTag != null && EndTag.IsComplete);
- public ElementSyntax (ElementStartTagSyntax startTag)
- : base (startTag.StartLine, startTag.TokenIndexBase) {
- StartTag = startTag;
- AddChild (StartTag);
+ public ElementSyntax (ElementStartTagSyntax startTag) {
+ AddChild (startTag);
}
}
- public class AttributeSyntax : SyntaxNode {
- public int? name, equal, valueOpen, valueClose, valueTok;
- public string Name => name.HasValue ? Root.GetTokenStringByIndex (TokenIndexBase + name.Value) : null;
- public string Value => valueTok.HasValue ? Root.GetTokenStringByIndex (TokenIndexBase + valueTok.Value) : null;
- public Token? ValueToken => valueTok.HasValue ? Root.GetTokenByIndex (TokenIndexBase + valueTok.Value) : null;
- public AttributeSyntax (int startLine, int tokenBase)
- : base (startLine, tokenBase) {}
- public override bool IsComplete => base.IsComplete & name.HasValue & equal.HasValue & valueTok.HasValue & valueOpen.HasValue & valueClose.HasValue;
+ public class AttributeSyntax : MultiNodeSyntax {
+ //public override bool IsComplete => base.IsComplete & name.HasValue & equal.HasValue & valueTok.HasValue & valueOpen.HasValue & valueClose.HasValue;
}
}
\ No newline at end of file
BlockComment = 0x0105,
BlockCommentEnd = 0x0106,
Name = 0x0200,
- ElementName = 0x0201,
- AttributeName = 0x0202,
- PI_Target = 0x0203,
+ ElementName = 0x8201,
+ AttributeName = 0x8202,
+ PI_Target = 0x8203,
Punctuation = 0x0400,
- PI_Start = 0x0401,// '<?'
- PI_End = 0x0402,// '?>'
- ElementOpen = 0x0403,// '<'
- EndElementOpen = 0x0404,// '</'
- EmptyElementClosing = 0x0405,// '/>'
- ClosingSign = 0x0406,// '>'
- DTDObjectOpen = 0x04A0,// '<!'
+
+ PI_Start = 0x8401,// '<?'
+ PI_End = 0x8402,// '?>'
+ ElementOpen = 0x8403,// '<'
+ EndElementOpen = 0x8404,// '</'
+ EmptyElementClosing = 0x8405,// '/>'
+ ClosingSign = 0x8406,// '>'
+ DTDObjectOpen = 0x84A0,// '<!'
Operator = 0x0800,
EqualSign = 0x0801,
Keyword = 0x1000,
- AttributeValue = 0x2000,
- AttributeValueOpen = 0x2001,
- AttributeValueClose = 0x2002,
+ AttributeValue = 0x8000,
+ AttributeValueOpen = 0x8401,
+ AttributeValueClose = 0x8402,
+
+
Content,
}
}
\ No newline at end of file
home / projects / jp / crowedit.git / commitdiff