public override void CreateSyntax(FileText owner, Storage.Character reference, CreateSyntaxResult result) { CreateToken(owner, reference, (owner, textToken, referenceBegin, referenceEnd) => new Comment(owner, referenceBegin, referenceEnd, textToken == "-->"), "<!--", "-->"); }
public override void CreateSyntax(FileText owner, Storage.Character reference, CreateSyntaxResult result) { CreateToken(owner, reference, (owner, textToken, referenceBegin, referenceEnd) => new NewLine(owner, referenceBegin, referenceEnd), "\r\n", "\r", "\n"); }
public override void CreateSyntax(FileText owner, Storage.Character reference, CreateSyntaxResult result) { if (reference.Text == '*') { new Bullet(owner, reference); } }
public override void CreateSyntax(FileText owner, Storage.Character reference, CreateSyntaxResult result) { if (owner.Last is Content content) { content.Remove(); new Content((FileText)owner, content.ReferenceBegin, reference); } else { new Content((FileText)owner, reference, reference); } }
public override void CreateSyntax(Tree.Component owner, MarkdownLexer.Token reference, CreateSyntaxResult result) { if (reference is MarkdownLexer.Header tokenHeader) { // Previous bool isNull = tokenHeader.Previous == null; bool isSpace = tokenHeader.Previous is MarkdownLexer.Space && (tokenHeader.Previous.Previous == null || tokenHeader.Previous.Previous is MarkdownLexer.NewLine); bool isNewLine = tokenHeader.Previous is MarkdownLexer.NewLine; if (isNull || isSpace || isNewLine) { var header = new Header(owner, reference); result.CreateSyntaxTree(header, reference.Next, SyntaxFactoryStopList()); } } }
public override void CreateSyntax(FileText owner, Storage.Character reference, CreateSyntaxResult result) { CreateToken(owner, reference, (owner, textToken, referenceBegin, referenceEnd) => new Special(owner, referenceBegin, referenceEnd), "(", ")", "[", "]"); }
public override void CreateSyntax(Tree.Component owner, Tree.Syntax reference, CreateSyntaxResult result) { CreateSyntax((FileText)owner, (Storage.Character)reference, result); }
public virtual void CreateSyntax(Tree.Component owner, MarkdownLexer.Token reference, CreateSyntaxResult result) { }
/// <summary> /// Create one new Syntax component or replace owners last Syntax component. /// </summary> public virtual void CreateSyntax(Component owner, Syntax reference, CreateSyntaxResult result) { }
public override void CreateSyntax(Tree.Component owner, Tree.Syntax reference, CreateSyntaxResult result) { if (reference is Storage.FileText referenceFileText) { var fileText = new FileText((Document)owner, referenceFileText); result.CreateSyntaxTree(fileText, reference.NextAll); } }
/// <summary> /// Create syntax tree. /// </summary> /// <param name="owner">Owner of new syntax tree.</param> /// <param name="referenceList">Reference list to walk through to create new syntax components.</param> /// <param name="reference">Reference component in referenceList to start with or null to start with first component.</param> /// <param name="syntaxFactoryList">Factories to create syntax components.</param> /// <param name="syntaxFactoryStopList">If referenceList hits one of this factories, walk through stops.</param> private static void CreateSyntaxTree(Component owner, List <Component> referenceList, Syntax reference, List <Syntax> syntaxFactoryList, List <Syntax> syntaxFactoryStopList) { int referenceIndex = 0; if (reference != null) { UtilFramework.Assert(referenceList.Contains(reference)); referenceIndex = referenceList.IndexOf(reference); } // Loop through reference list starting at item. for (int index = referenceIndex; index < referenceList.Count; index++) { Syntax item = (Syntax)referenceList[index]; // Create syntax from factory Syntax syntax = null; // Syntax factory used to create syntax Syntax syntaxFactory = null; foreach (var syntaxFactoryItem in syntaxFactoryList) { // Create before int syntaxLength = owner.List.Count; Syntax syntaxLast = (Syntax)owner.Last; // Create var result = new CreateSyntaxResult(referenceList, syntaxFactoryList); syntaxFactoryItem.CreateSyntax(owner, item, result); if (result.Reference != null) { CreateSyntaxTree(result.Owner, result.ReferenceList, result.Reference, result.SyntaxFactoryList, result.SyntaxFactoryStopList); } // Create after int syntaxLengthNew = owner.List.Count; Syntax syntaxLastNew = (Syntax)owner.Last; // Create result get UtilFramework.Assert(syntaxLengthNew - syntaxLength == 0 || syntaxLengthNew - syntaxLength == 1); // Zero or one token added. if (syntaxLengthNew - syntaxLength == 1) { syntax = syntaxLastNew; } else { if (syntaxLast != syntaxLastNew) { syntax = syntaxLastNew; } } // Create result if (syntax != null) { UtilFramework.Assert(syntax.GetType() == syntaxFactoryItem.GetType()); syntaxFactory = syntaxFactoryItem; break; } } // Created syntax UtilFramework.Assert(syntax != null); var syntaxPrevious = (Syntax)syntax.PreviousAll; if (syntaxPrevious != null) { // Make sure every reference component is covered. UtilFramework.Assert(syntaxPrevious.ReferenceEnd.Index + 1 == syntax.ReferenceBegin.Index); } int referenceEndIndex = referenceList.IndexOf(syntax.ReferenceEndAll); UtilFramework.Assert(index <= referenceEndIndex && referenceEndIndex < referenceList.Count); // Move index to new end index = referenceEndIndex; if (syntaxFactoryStopList.Contains(syntaxFactory)) { syntax.Remove(); break; } } }
public override void CreateSyntax(Tree.Component owner, MarkdownLexer.Token reference, CreateSyntaxResult result) { if (owner.Last is Content content) { content.Remove(); new Content(owner, content.ReferenceBegin, reference); } else { new Content(owner, reference, reference); } }
public override void CreateSyntax(Tree.Component owner, MarkdownLexer.Token reference, CreateSyntaxResult result) { if (reference is MarkdownLexer.Special specialOpen && specialOpen.Text == "[") { if (reference.Next is MarkdownLexer.Content contentLinkUrl) { if (reference.Next?.Next is MarkdownLexer.Special specialClose && specialClose.Text == "]") { if (reference.Next?.Next?.Next is MarkdownLexer.Special specialOpen2 && specialOpen2.Text == "(") { if (reference.Next?.Next?.Next?.Next is MarkdownLexer.Content contentLinkText) { if (reference.Next?.Next?.Next?.Next?.Next is MarkdownLexer.Special specialClose2 && specialClose2.Text == ")") { new Link(owner, reference, specialClose2, LinkUrl, LinkText); } } } } } } }
public override void CreateSyntax(Tree.Component owner, Tree.Syntax reference, CreateSyntaxResult result) { if (reference is MarkdownLexer.FileText referenceFileText) { var page = new Page((Document)owner, referenceFileText); result.CreateSyntaxTree(page, reference.NextAll); } }
public virtual void CreateSyntax(FileText owner, Storage.Character reference, CreateSyntaxResult result) { }
public override void CreateSyntax(Tree.Component owner, Tree.Syntax reference, CreateSyntaxResult result) { CreateSyntax(owner, (MarkdownLexer.Token)reference, result); }
public override void CreateSyntax(FileText owner, Storage.Character reference, CreateSyntaxResult result) { var character = reference; if (character.Text == ' ') { if (owner.Last is Space space) { space.Remove(); new Space(owner, space.ReferenceBegin, reference); } else { new Space(owner, reference, reference); } } }
public override void CreateSyntax(Tree.Component owner, MarkdownLexer.Token reference, CreateSyntaxResult result) { if (reference is MarkdownLexer.NewLine) { new NewLine(owner, reference, reference); } }
public override void CreateSyntax(Tree.Component owner, MarkdownLexer.Token reference, CreateSyntaxResult result) { if (reference is MarkdownLexer.Comment comment && comment.IsEnd == false) { MarkdownLexer.Token referenceNext = reference; while ((referenceNext = referenceNext.Next) != null) { if (referenceNext is MarkdownLexer.Comment commentNext && commentNext.IsEnd) { new Comment(owner, reference, referenceNext); break; } } } }