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;
}
}
}
}
