public Task <IEnumerable <(string Url, string Type)> > Discover(TextReader source, string baseUri = null,
LanguageSyntax syntax = LanguageSyntax.Html, CancellationToken cancellationToken = default)
{
return(Discover(baseUri, syntax,
async(p, b, c) => await p.ParseAsync(await source.ReadToEndAsync().ConfigureAwait(false), c)
.ConfigureAwait(false), null, (s, b) => XmlReader.Create(source, s, b), cancellationToken));
}
public ParsingState(string source, LanguageSyntax languageSyntax)
{
this.languageSyntax = languageSyntax;
String = new EscapedString(source, languageSyntax.EscapeChar);
Position = 0;
tagStack = new Stack <SyntaxNode>();
Root = SyntaxNode.CreateTag(LanguageSyntax.RootTagName);
tagStack.Push(Root);
}
public void CreateLSCScript()
{
LanguageSyntax syntax = new LanguageSyntax();
syntax.Language = "lsc";
syntax.SyntaxList.Add(new SyntaxItem(Color.FromArgb(127, 85, 0), @"\b(on|TimeElapsed|Periodic|MapInit|UnitCreated|UnitDied|RegionEntered|RegionLeft|AbilityCast|AbilitySmart|ParticleSystem|Update|ProjectileCreated|ProjectileDestroyed|UnitAttacked|UnitRemoved)\b"));
syntax.SyntaxList.Add(new SyntaxItem(Color.Blue, @"\b(new|as|null|switch|object|bool|false|throw|break|finally|out|true|byte|try|case|float|params|typeof|catch|for|uint|char)\b"));
syntax.SyntaxList.Add(new SyntaxItem(Color.Blue, @"\b(foreach|ulong|goto|if|readonly|const|ref|ushort|continue|in|return|using|decimal|int|sbyte|default|volatile|delegate|internal|short|void|do|is|sizeof|while|double|lock|else|long|static|enum|string)\b"));
syntax.SyntaxList.Add(new SyntaxItem(Color.Teal, @"\b(Dictionary|List|Queue|Stack|String|System|Vector3|Vector2|Matrix|Texture2D|Model|GameTime|Color|MathHelper|Unit|Player|UnitType|Map|Region|Projectile|Ability|ContextButton|Tooltip|UnitGroup|Visibility|UnitState|UnitQueue|Rotation|League|Blend|ParticleSystem|ParticleEmitter|ParticleSettings|GameObject|GameMessage)\b"));
syntax.SyntaxList.Add(new SyntaxItem(Color.Red /*FromArgb(100, 100, 100)*/, @"^#.*$", RegexOptions.Multiline));
syntax.SyntaxList.Add(new SyntaxItem(Color.FromArgb(0xA31515), "\"[^\"]*\""));
syntax.SyntaxList.Add(new SyntaxItem(Color.Green, @"(\/\/.*)", RegexOptions.Multiline));
syntax.SyntaxList.Add(new SyntaxItem(Color.Green, @"\/\*.*\*\/"));
if (this.languageSet.ContainsKey(syntax.Language))
{
this.languageSet.Remove(syntax.Language);
}
this.languageSet.Add(syntax.Language, syntax);
}
public SyntaxTreeCompiler(LanguageSyntax syntax)
{
Syntax = syntax;
}
private static IEnumerable <IEnumerable <SyntaxNode> > OrderInGroups(this IEnumerable <IReadOnlyList <SyntaxNode> > groups, LanguageSyntax syntax)
{
return(groups.Select(group => !group.IsGroup(syntax) ? group : group.OrderBy(n => syntax.GetTag(n.TagName).GroupIndex) as IEnumerable <SyntaxNode>));
}
public static SyntaxNode RevertParseForIncompleteGroups(this SyntaxNode root, LanguageSyntax syntax)
{
if (root.IsRawString)
{
return(root);
}
var newRoot = SyntaxNode.CreateTag(root.TagName);
var nested = root.NestedNodes.Select(n => n.RevertParseForIncompleteGroups(syntax)).ToList();
var processed = nested.RevertParseForIncompleteGroups(syntax).ConcatRaw();
newRoot.AddManyNestedNode(processed.SelectMany(a => a));
return(newRoot);
}
private static IEnumerable <IReadOnlyList <SyntaxNode> > RevertParseForIncompleteGroups(this IEnumerable <SyntaxNode> tags, LanguageSyntax syntax)
{
var groups = tags.CutToGroups(syntax).ToList();
foreach (var group in groups)
{
if (group.First().IsRawString || syntax.GetTag(group.First().TagName).GroupName == null)
{
foreach (var node in group)
{
yield return(new List <SyntaxNode> {
node
});
}
}
else
{
var groupName = syntax.GetTag(group.First().TagName).GroupName;
var expected = syntax.GetTagInGroup(groupName);
if (group.Count != expected.Count())
{
var str = group.Select(syntax.Build).SequenceToString("", "", "");
yield return(new List <SyntaxNode> {
SyntaxNode.CreateRawString(str)
});
}
else
{
yield return(group);
}
}
}
}
private Task <IEnumerable <(string Url, string Type)> > Discover(Stream source, IBrowsingContext browsingContext, string baseUri = null,
LanguageSyntax syntax = LanguageSyntax.Html, CancellationToken cancellationToken = default)
{
return(Discover(baseUri, syntax, async(p, b, c) => await p.ParseAsync(source, c).ConfigureAwait(false),
browsingContext, (s, b) => XmlReader.Create(source, s, b), cancellationToken));
}
private static bool IsGroup(this IReadOnlyList <SyntaxNode> nodes, LanguageSyntax syntax)
{
return(nodes.First().IsTag&& syntax.GetTag(nodes.First().TagName).GroupName != null);
}
public static SyntaxNode Parse(this LanguageSyntax syntax, string line)
{
return(new SyntaxTreeParser(syntax).Parse(line));
}
public static string Build(this LanguageSyntax syntax, SyntaxNode tree, string metaUrl)
{
return(new SyntaxTreeBuilder(syntax).Build(tree, metaUrl));
}
public static SyntaxNode ParseMultiline(this LanguageSyntax syntax, string text)
{
return(new MultilineSyntaxTreeParser(syntax).ParseMultiline(text));
}
public SyntaxTreeParser(LanguageSyntax syntax)
{
Syntax = syntax;
}
public unsafe void ColorizeRTB(RichTextBox rtb, string language)
{
if (this.languageSet.ContainsKey(language) == false ||
rtb.Text.Length == 0)
{
return;
}
if (rtb.Parent != null)
{
if (rtb.Parent.Parent != null)
{
Win32.LockWindowUpdate(rtb.Parent.Parent.Handle);
}
else
{
Win32.LockWindowUpdate(rtb.Parent.Handle);
}
}
else
{
Win32.LockWindowUpdate(rtb.Handle);
}
try {
Point pScrollPos = Win32.GetScrollPos(rtb.Handle);
int iSelStart = rtb.SelectionStart;
rtb.SelectAll();
rtb.SelectionColor = Color.Black;
LanguageSyntax syntax = languageSet[language];
foreach (SyntaxItem si in syntax.SyntaxList)
{
Regex regx = new Regex(si.Expression, si.RegexOptions);
foreach (Match m in regx.Matches(rtb.Text))
{
rtb.SelectionStart = m.Index;
rtb.SelectionLength = m.Length;
rtb.SelectionColor = si.Color;
}
}
rtb.DeselectAll();
rtb.SelectionStart = iSelStart;
rtb.SelectionLength = 0;
Win32.SetScrollPos(rtb.Handle, pScrollPos);
} catch (Exception e) {
System.Windows.Forms.MessageBox.Show("Error evaluating regex expression during rtb colorizing: " + e.Message);
} finally {
Win32.LockWindowUpdate(IntPtr.Zero);
}
}
public Language(LanguageSyntax syntax)
{
Syntax = syntax;
}
private static IEnumerable <IReadOnlyList <SyntaxNode> > CutToGroups(this IEnumerable <SyntaxNode> nodes, LanguageSyntax syntax)
{
return(nodes
.GroupWithSaveOrderBy(n => n.IsRawString ? null : syntax.GetTag(n.TagName).GroupName)
.Select(g => g.ToList())
.SelectMany(g => g.CutToFullGroups(syntax)));
}
public SyntaxTreeBuilder(LanguageSyntax syntax)
{
Syntax = syntax;
}
private static IEnumerable <IReadOnlyList <SyntaxNode> > CutToFullGroups(this List <SyntaxNode> group, LanguageSyntax syntax)
{
if (group.Count == 0)
{
return(new List <IReadOnlyList <SyntaxNode> >());
}
var groupName = group.First().IsRawString ? null : syntax.GetTag(group.First().TagName).GroupName;
if (groupName == null)
{
return new[] { group.ToList() }
}
;
var expected = syntax.GetTagInGroup(groupName).Select(t => t.Name).ToList();
var tags = group.ToList();
if (tags.Count < expected.Count)
{
return new[] { group.ToList() }
}
;
var isFullCombination = tags.IsFullCombination(expected);
var length = isFullCombination ? expected.Count : 1;
var result = new List <IReadOnlyList <SyntaxNode> >();
result.Add(tags.SubEnumerable(0, length).ToList());
result.AddRange(tags.SubEnumerable(length, tags.Count - length).ToList().CutToFullGroups(syntax));
return(result);
}
public Task <IEnumerable <(string Url, string Type)> > Discover(Stream source, string baseUri = null,
LanguageSyntax syntax = LanguageSyntax.Html, CancellationToken cancellationToken = default)
{
return(Discover(source, null, baseUri, syntax, cancellationToken));
}
public static IEnumerable <SyntaxNode> OrderTagsInGroups(this IEnumerable <SyntaxNode> nodes, LanguageSyntax syntax)
{
return(nodes.CutToGroups(syntax).OrderInGroups(syntax).SelectMany(g => g));
}
private async Task <IEnumerable <(string Url, string Type)> > Discover(string baseUri, LanguageSyntax syntax,
Func <HtmlParser, string, CancellationToken, Task <IDocument> > htmlParseAsync, IBrowsingContext browsingContext,
Func <XmlReaderSettings, string, XmlReader> createReader, CancellationToken cancellationToken = default)
{
switch (syntax)
{
case LanguageSyntax.Html:
var parser = browsingContext == null
? new HtmlParser(AngleSharpConfig())
: new HtmlParser(new HtmlParserOptions(), browsingContext);
return(Discover(await htmlParseAsync(parser, baseUri, cancellationToken).ConfigureAwait(false)));
case LanguageSyntax.Xhtml:
using (var xmlReader = createReader(new XmlReaderSettings {
DtdProcessing = DtdProcessing.Ignore
}, baseUri))
{
return(Discover(XDocument.Load(xmlReader, LoadOptions.SetBaseUri), xmlReader.NameTable));
}
default:
throw new ArgumentOutOfRangeException(nameof(syntax), syntax, null);
}
}
public MultilineSyntaxTreeParser(LanguageSyntax syntax) : base(syntax)
{
}
