private Tag ReadNewGlobalTag(ParsedString parsed, EnviromentType enviroment)
{
var available = Syntax.GlobalTags.Select(Syntax.GetTag).Where(t => t.Enviroment.HasFlag(enviroment)).ToList();
var started = available.Where(t => t.Begin.IsMatch(parsed)).OrderByDescending(t => t.Begin.Length).ToList();
return(started.FirstOrDefault());
}
private bool IsMatch(ParsedString str, int pos, CharType expectedCharType)
{
if (pos < 0 || pos >= str.Length)
{
return(true);
}
return(str[pos].Value.IsMatch(expectedCharType));
}
public ParsingState(string source, LanguageSyntax languageSyntax)
{
this.languageSyntax = languageSyntax;
String = new ParsedString(source, languageSyntax.EscapeChar);
Position = 0;
tagStack = new Stack <SyntaxNode>();
Root = SyntaxNode.CreateTag(LanguageSyntax.RootTagName);
tagStack.Push(Root);
}
private bool ReadCloseOfTag(ParsedString parsed, Tag current, EnviromentType enviroment)
{
if (current.Enviroment.HasFlag(enviroment))
{
if (current.End.IsMatch(parsed, parsed.Length - current.End.Length))
{
return(true);
}
}
return(false);
}
public int?Find(ParsedString str, int findStart)
{
while (findStart >= 0)
{
if (IsMatch(str, findStart))
{
return(findStart);
}
findStart = str.StringWithoutEscaping.IndexOf(Lexem, findStart + 1, StringComparison.InvariantCulture);
}
return(null);
}
public bool IsMatch(ParsedString str, int startPosition = 0)
{
if ((str.Length - startPosition) < Lexem.Length)
{
return(false);
}
if (!IsMatch(str, startPosition + Lexem.Length, nextCharTemplate))
{
return(false);
}
if (!IsMatch(str, startPosition - 1, prevCharTemplate))
{
return(false);
}
return(str.SubstringOrdinalEqual(Lexem, startPosition));
}
private void ReadNext(ref Tag currentTag, ParsedString parsed, EnviromentType env, string current, List <SyntaxNode> buffer, List <SyntaxNode> result)
{
if (currentTag != null)
{
if (ReadCloseOfTag(parsed, currentTag, env))
{
buffer.AddRange(Parse(current.Substring(0, current.Length - currentTag.End.Length)).NestedNodes);
result.Add(SyntaxNode.CreateTag(currentTag.Name).AddManyNestedNode(buffer));
buffer.Clear();
currentTag = null;
}
else
{
buffer.AddRange(Parse(current.Substring(0, current.Length - 1)).NestedNodes);
}
}
}
public SyntaxNode ParseMultiline(string text)
{
var lines = text.Split('\n');
if (lines.Length < 2)
{
return(Parse(text));
}
string prev = null;
Tag currentTag = null;
var result = new List <SyntaxNode>();
var buffer = new List <SyntaxNode>();
for (int i = 0; i < lines.Length; i++)
{
var next = i < lines.Length - 1 ? lines[i + 1] : null;
var current = lines[i] + '\n';
var env = EnviromentTypeHelper.GetType(prev, next);
var parsed = new ParsedString(current, Syntax.EscapeChar);
ReadNext(ref currentTag, parsed, env, current, buffer, result);
if (currentTag == null)
{
currentTag = ReadNewGlobalTag(parsed, env);
if (currentTag == null)
{
result.AddRange(Parse(current).NestedNodes);
}
else
{
current = current.Substring(currentTag.Begin.Length, current.Length);
parsed = new ParsedString(current, Syntax.EscapeChar);
ReadNext(ref currentTag, parsed, env, current, buffer, result);
}
}
prev = current;
}
if (currentTag != null)
{
result.Add(SyntaxNode.CreateTag(currentTag.Name).AddManyNestedNode(buffer));
}
return(SyntaxNode.CreateTag(null).AddManyNestedNode(result));
}
public bool IsAt(ParsedString str, int pos)
{
if (pos < 0) return false;
if (!Begin.IsMatch(str, pos)) return false;
return End.Find(str, pos + Begin.Length) != null;
}
public RegistarAnuncio(ParsedString parsedMessage, Utilizador utilizador)
: base(parsedMessage, utilizador)
{
}
public void DoublequoteEscapes()
{
var parser = JsonParser.Create<ParsedString>().OnString("stringField", (parsed, value) => parsed.String = value);
var parsedString = new ParsedString();
parser.Parse("{ \"stringField\" : \"a\\\"b\"}", parsedString);
Assert.AreEqual("a\"b", parsedString.String);
}
public void ForwardslashEscapes()
{
var parser = JsonParser.Create<ParsedString>().OnString("stringField", (parsed, value) => parsed.String = value);
var parsedString = new ParsedString();
parser.Parse("{ \"stringField\" : \"a\\/b\"}", parsedString);
Assert.AreEqual("a/b", parsedString.String);
}
public void UnicodeEscapes_WithTrailingValue()
{
var parser = JsonParser.Create<ParsedString>().OnString("stringField", (parsed, value) => parsed.String = value);
var parsedString = new ParsedString();
parser.Parse("{ \"stringField\" : \"\\u0063blah\"}", parsedString);
Assert.AreEqual("cblah", parsedString.String);
}
public void NotOrdinalEqual_WhenSourceIs(string src, int compareStart, string other)
{
var parsed = new ParsedString(src, '\\');
parsed.SubstringOrdinalEqual(other, compareStart).Should().BeFalse();
}
public void CorrectlyParseEscapedLine_WhenString(string source, string expected)
{
var parsed = new ParsedString(source, '\\');
parsed.ToString().Should().Be(expected);
}
