public void ITC01GetLineAndColumn()
{
string str = @"Firstline
SecondlineX
Thirdline
Z";
int line, column;
var buffer = new FlatBuffer(str);
int pos = str.IndexOf("F");
buffer.GetLineAndColumn(out line, out column, pos);
Assert.AreEqual(1, line, "find F line");
Assert.AreEqual(1, column, "find F col");
pos = str.IndexOf("X");
buffer.GetLineAndColumn(out line, out column, pos);
Assert.AreEqual(2, line, "find X line");
Assert.AreEqual(11, column, "find X col");
//Assert.AreEqual("Line 2, colomn 11", buffer.GetLineAndColumn(pos), "find X");
pos = str.IndexOf("Z");
buffer.GetLineAndColumn(out line, out column, pos);
Assert.AreEqual(4, line, "find Z line");
Assert.AreEqual(2, column, "find Z col");
// Assert.AreEqual("Line 4, colomn 2", buffer.GetLineAndColumn(pos), "find Z");
}
/// <summary>Create new buffer with a function to skip whitespaces.</summary>
/// <param name="code">Contains of buffer.</param>
/// <returns>A TextBuffer.</returns>
public static TextBuffer NewBufferWs(string code)
{
TextBuffer textBuffer = new FlatBuffer(code);
textBuffer.FindNextWord(null, false);
return(textBuffer);
}
/// <summary>Create the parser to read grammar definition</summary>
/// <exclude/>
private static void CreateMetaParser()
{
if (_instance != null)
{
return;
}
int step = 1;
TextBuffer buffer = new FlatBuffer(MetaParser.SoftMetaGrammarAndSettings);
CodeDocument metaGrammarDoc = null;
try
{
// Hard coded parser
Parser hardcodeParser = GetHardCodeParser(buffer.Status);
if (buffer.Status.Error == null)
{
step = 2;
// Use hard coded grammar to read meta grammar.
metaGrammarDoc = hardcodeParser.ParseString(buffer);
string gg = metaGrammarDoc.ToMarkup();
step = 3;
}
if (buffer.Status.Error == null)
{
_instance = new Parser()
{
Level = 2
};
ParserBuilder.BuildRules(_instance, metaGrammarDoc, buffer.Status);
}
}
catch (Exception e)
{
// if an exception occurs under parsing MetaGrammar it is an HardGrammar error
var e2 = new ParserException((step <= 2 ? HardGrammar_ : MetaGrammar_) + " " + e.Message);
if (e is ParserException)
{
e2.AllErrors = ((ParserException)e).AllErrors;
}
throw e2;
}
if (buffer.Status.Error != null)
{
// if an proces-error occurs under parsing MetaGrammar it is an MetaGrammar error
var e2 = new ParserException((step == 1 ? HardGrammar_ : MetaGrammar_) + " " + buffer.Status.Error.Message);
e2.AllErrors = buffer.Status.AllErrors;
throw e2;
}
}
/// <summary>
/// Parse code with a given parser.
/// </summary>
/// <param name="parser"></param>
/// <param name="input"></param>
/// <returns></returns>
public static CodeDocument Load(Parser parser, string input)
{
TextBuffer buffer = new FlatBuffer(input);
CodeDocument doc = parser.ParseString(buffer);
if (doc != null)
{
return(doc);
}
// only place to throw exception is CodeDocument.Load and Parser.SetGrammar (and MetaGrammar)
var error = new ParserException(buffer.Status.Error.Message);
error.AllErrors.AddRange(buffer.Status.AllErrors);
throw error;
}
/// <summary>Read a Grammar definition from text. </summary>
/// <param name="Grammar">Grammar text.</param>
/// <returns>Grammar is Ok.</returns>
/// <exclude/>
private void SetGrammar(string Grammar)
{
CodeDocument grammarDoc = null;
TextBuffer buffer = new FlatBuffer(Grammar);
grammarDoc = MetaParser.Instance.ParseString(buffer);
if (buffer.Status.Error != null || !ParserBuilder.BuildRules(this, grammarDoc, buffer.Status))
{
// only place to throw exception is CodeDocument.Load and Parser.SetGrammar (and MetaGrammar)
var error = new ParserException(buffer.Status.Error.Message);
error.AllErrors.AddRange(buffer.Status.AllErrors);
throw error;
}
}
public void ITC24MetaSyntax()
{
// Build a grammar to test meta grammar
string actual1, actual2, expect, msg;
expect = MetaParser.SoftMetaGrammarAndSettings;
var parser = new Parser(MetaParser.SoftMetaGrammarAndSettings);
actual1 = parser.GetGrammar(); // Test Meta grammar after after compilation in a Parser.
actual2 = MetaParser.Instance.GetGrammar(); // Test Meta grammar in internal Parser.
msg = Util.CompareTextLines(actual1, expect);
Assert.AreEqual(string.Empty, msg, "Meta grammar diff error");
msg = Util.CompareTextLines(actual2, expect);
Assert.AreEqual(string.Empty, msg, "Meta grammar internal diff error");
// Compare generated CodeDocument with 'selected nodes'
string actualTags1, actualTags2, expectTags;
CodeDocument docExpect = TestMetaGrammarDoc();
//var metaParser = _metaparser;
TextBuffer buffer = new FlatBuffer(MetaParser.SoftMetaGrammarAndSettings);
CodeDocument docActual1 = parser.ParseString(buffer);
buffer = new FlatBuffer(MetaParser.SoftMetaGrammarAndSettings);
CodeDocument docActual2 = MetaParser.Instance.ParseString(buffer);
expectTags = docExpect.ToMarkup();
actualTags1 = docActual1.ToMarkup();
actualTags2 = docActual2.ToMarkup();
msg = CodeDocument.CompareCode(docActual1, docExpect);
Assert.AreEqual(string.Empty, msg, "Meta grammar document diff error");
msg = CodeDocument.CompareCode(docActual2, docExpect);
Assert.AreEqual(string.Empty, msg, "Meta grammar internal document diff error");
Assert.AreEqual(docExpect.Name, docActual1.Name, "Document name diff error");
Assert.AreEqual(expectTags, actualTags1, "Meta grammar document.toMarkup diff error");
Assert.AreEqual(expectTags, actualTags2, "Meta grammar document.toMarkup diff error");
}
static void Main(string[] args)
{
Profiler.Init();
Console.WriteLine("Hello World!");
TTT tt = new TTT();
tt.tt1 = 1;
tt.tt2 = 2;
tt.tt3 = 3;
tt.tt4 = 4;
FlatBuffer buffer = new FlatBuffer(2);
CircularBuffer circularBuffer = new CircularBuffer();
buffer.Wirte <TTT>(tt);
circularBuffer.Enqueue <TTT>(tt);
tt.tt1 = 5;
tt.tt2 = 6;
tt.tt3 = 7;
tt.tt4 = 8;
buffer.Wirte <TTT>(tt);
circularBuffer.Enqueue <TTT>(tt);
tt.tt1 = 0;
tt.tt2 = 0;
tt.tt3 = 0;
tt.tt4 = 0;
buffer.Read <TTT>(out tt);
tt.tt1 = 0;
tt.tt2 = 0;
tt.tt3 = 0;
tt.tt4 = 0;
circularBuffer.Dequeue <TTT>(out tt);
tt.tt1 = 0;
tt.tt2 = 0;
tt.tt3 = 0;
tt.tt4 = 0;
buffer.Read <TTT>(out tt);
tt.tt1 = 0;
tt.tt2 = 0;
tt.tt3 = 0;
tt.tt4 = 0;
circularBuffer.Dequeue <TTT>(out tt);
Profiler.Fin();
}
public static string ParserLoad(string grammar, string code, string markup, params string[] errors)
{
// Try create parser
//Parser parser = ParserGrammar(grammar, errors);
Parser parser = null;
try { parser = new Parser(grammar); }
catch (ParserException e)
{
Assert.IsTrue(errors.Length > 0, "Grammar error: " + e.Message);
Assert.IsTrue(e.AllErrors.Count >= errors.Length, "Grammar error: missing error 1");
e.AllErrors.Sort(ParserError.Compare);
for (int i = 0; i < e.AllErrors.Count; i++)
{
if (i < errors.Length)
{
Assert.AreEqual(errors[i], e.AllErrors[i].Message, "Grammar error: Build error " + i);
}
}
}
if (errors.Length == 0)
{
Assert.IsNotNull(parser, "Grammar error: parser is null");
}
else if (string.IsNullOrEmpty(code) && markup != "grammar ok")
{
Assert.IsNull(parser, "Grammar error expected");
}
if (parser == null || (string.IsNullOrEmpty(code) && string.IsNullOrEmpty(markup)))
{
return(string.Empty);
}
// Try read the code
string s = parser.GetGrammar();
var buf = new FlatBuffer(code);
CodeDocument doc = parser.ParseString(buf);
if (buf.Status.Error == null)
{
Assert.IsTrue(errors.Count() == 0, " Expecting error");
Assert.IsNotNull(doc, " doc er null");
string actual = doc.ToMarkup();
if (!string.IsNullOrEmpty(markup))
{
string err = CompareTextLines(actual, markup);
Assert.AreEqual(string.Empty, err, " AST");
}
return(actual);
}
else
{
Assert.IsTrue(errors.Count() > 0, " Parsing error: " + buf.Status.Error.Message);
Assert.IsTrue(buf.Status.AllErrors.Count >= errors.Length, " Load missing error 1");
buf.Status.AllErrors.Sort(ParserError.Compare);
for (int i = 0; i < buf.Status.AllErrors.Count; i++)
{
if (i < errors.Length)
{
Assert.AreEqual(errors[i], buf.Status.AllErrors[i].Message, " Load error " + i);
}
else
{
return(buf.Status.AllErrors[i].Message);
}
}
}
return(string.Empty);
}
