private static void ParseDefSubClass(ScanReader reader, GenDataDef f, string className)
{
reader.ScanWhile(ScanReader.WhiteSpace);
var sub = reader.ScanWhile(ScanReader.AlphaNumeric);
if (reader.CheckChar('['))
{
reader.SkipChar();
reader.ScanWhile(ScanReader.WhiteSpace);
var field = reader.ScanWhile(ScanReader.Identifier);
Contract.Assert(field.Equals("Reference", StringComparison.InvariantCultureIgnoreCase), "Data definition reference expected: " + field);
reader.ScanWhile(ScanReader.WhiteSpace);
Contract.Assert(reader.CheckChar('='), "Data definition [Reference=definition] expected: " + field);
reader.SkipChar();
reader.ScanWhile(ScanReader.WhiteSpace);
var value = reader.CheckChar('\'')
? reader.ScanQuotedString()
: reader.ScanWhile(ScanReader.Identifier);
f.AddSubClass(className, sub, value);
reader.ScanWhile(ScanReader.WhiteSpace);
Contract.Assert(reader.CheckChar(']'), "Data definition ] expected");
reader.SkipChar();
}
else
{
f.AddSubClass(className, sub);
}
reader.ScanWhile(ScanReader.WhiteSpace);
}
/// <summary>
/// Extracts the generator data definition from the stream text.
/// </summary>
/// <param name="stream">The stream text data being loaded.</param>
/// <returns>The extracted generator data definition.</returns>
public static GenDataDef ExtractDef(Stream stream)
{
var scan = new ScanReader(stream);
var f = ExtractDef(scan);
stream.Seek(0, SeekOrigin.Begin);
return(f);
}
public void SimpleBlockTest()
{
const string input = "[**]";
using (var scan = new ScanReader(input))
{
Assert.AreEqual(input, scan.ScanSimpleBlock("[*", "*]"), "Scan Keyword");
}
}
public void ScanForKeyword()
{
const string input = "**]";
using (var scan = new ScanReader(input))
{
Assert.AreEqual("*", scan.ScanUntilKeyword("*]"), "Scan Until Keyword");
Assert.IsTrue(scan.CheckChar('*'), "First character of keyword");
}
}
public void ScanKeyword()
{
const string input = "[* *]";
using (var scan = new ScanReader(input))
{
Assert.AreEqual("[*", scan.ScanKeyword("[*"), "Scan Keyword");
Assert.IsTrue(scan.CheckChar(' '), "Space after keyword");
}
}
public void EofCharTest()
{
const string input = "AbCd # 12345";
using (var scan = new ScanReader(input))
{
Assert.AreEqual(input, scan.ScanUntilChar(ScanReader.EofChar));
CheckScannerEofConditions(scan);
}
}
public void EofScanToEndTest()
{
const string input = "12345";
using (var scan = new ScanReader(input))
{
var s = scan.ScanWhile(ScanReader.AlphaNumeric);
Assert.AreEqual("12345", s, "numeric value expected");
CheckScannerEofConditions(scan);
}
}
public void UntilTest()
{
const string input = "AbCd # 12345";
const string output = "AbCd ";
using (var scan = new ScanReader(input))
{
Assert.AreEqual(output, scan.ScanUntilChar('#'));
CheckScannerNotEofConditions(scan);
}
}
public void WhileTest()
{
const string input = "AbCd # 12345";
const string output = "AbCd";
using (var scan = new ScanReader(input))
{
Assert.AreEqual(output, scan.ScanWhile(ScanReader.Alpha));
CheckScannerNotEofConditions(scan);
}
}
public void EmptyTest()
{
const string text = "";
using (var scan = new ScanReader(text))
{
var s = scan.ScanUntilChar('#');
Assert.AreEqual("", s, "Empty string expected");
CheckScannerEofConditions(scan);
}
}
public void SkipCharTest()
{
const string input = "AbCd # 12345";
using (var scan = new ScanReader(input))
{
scan.ScanUntilChar('#');
Assert.IsTrue(scan.CheckChar('#'), "Scan to start point");
scan.SkipChar();
Assert.IsTrue(scan.CheckChar(' '), "Space after #");
CheckScannerNotEofConditions(scan);
}
}
public void MacroTest()
{
const string input = "Prefix #Macro1 Suffix";
const string output = "Prefix [1[2]] Suffix";
var macros = new Dictionary <string, string> {
{ "Macro1", "[1#Macro2]" }, { "Macro2", "[2]" }
};
using (var scan = new ScanReader(input))
{
var s = scan.ScanUntilChar('#');
while (scan.CheckChar('#'))
{
scan.SkipChar();
var t = scan.ScanWhile(ScanReader.AlphaNumeric);
scan.Rescan(macros[t]);
s += scan.ScanUntilChar('#');
}
s += scan.ScanUntilChar(ScanReader.EofChar);
Assert.AreEqual(output, s);
}
}
public void StreamTest()
{
const string input = "AbCd # 12345";
const string output1 = "AbCd";
const string output2 = "12345";
const string fileName = "StreamTest.txt";
if (File.Exists(fileName))
{
File.Delete(fileName);
}
File.WriteAllText(fileName, input);
using (var stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
{
using (var scan = new ScanReader(stream))
{
Assert.AreEqual("Unicode (UTF-8)", scan.Encoding.EncodingName);
Assert.AreEqual(output1, scan.ScanWhile(ScanReader.Alpha));
CheckScannerNotEofConditions(scan);
scan.ScanUntil(ScanReader.Numeric);
Assert.AreEqual(output2, scan.ScanWhile(ScanReader.Numeric));
}
}
}
private static GenDataDef ExtractDef(ScanReader reader)
{
var f = new GenDataDef();
var classId = -1;
var className = "";
var token = reader.ScanWhile(ScanReader.Identifier);
while (token != "")
{
switch (token)
{
case "Definition":
reader.ScanWhile(ScanReader.WhiteSpace);
if (reader.CheckChar('='))
{
reader.SkipChar();
}
reader.ScanWhile(ScanReader.WhiteSpace);
f.DefinitionName = reader.ScanWhile(ScanReader.QualifiedIdentifier);
break;
case "Class":
reader.ScanWhile(ScanReader.WhiteSpace);
if (reader.CheckChar('='))
{
reader.SkipChar();
}
reader.ScanWhile(ScanReader.WhiteSpace);
className = reader.ScanWhile(ScanReader.Identifier);
classId = f.AddClass(className);
if (f.Classes.Count == 2)
{
f.AddSubClass("", className);
}
reader.ScanWhile(ScanReader.WhiteSpace);
if (reader.CheckChar('['))
{
do
{
reader.SkipChar();
reader.ScanWhile(ScanReader.WhiteSpace);
var inheritorClassName = reader.ScanWhile(ScanReader.Identifier);
f.AddInheritor(className, inheritorClassName);
reader.ScanWhile(ScanReader.WhiteSpace);
} while (reader.CheckChar(','));
Contract.Assert(reader.CheckChar(']'), "Definition Error for class " + className + ": ] expected");
reader.SkipChar();
}
break;
case "Field":
reader.ScanWhile(ScanReader.WhiteSpace);
if (reader.CheckChar('='))
{
reader.SkipChar();
}
if (reader.CheckChar('{'))
{
do
{
reader.SkipChar();
reader.ScanWhile(ScanReader.WhiteSpace);
var field = reader.ScanWhile(ScanReader.Identifier);
f.AddClassInstanceProperty(classId, field);
reader.ScanWhile(ScanReader.WhiteSpace);
} while (reader.CheckChar(','));
Contract.Assert(reader.CheckChar('}'), "Definition Error for class " + className + " fields list: } expected");
reader.SkipChar();
}
else
{
reader.ScanWhile(ScanReader.WhiteSpace);
var field = reader.ScanWhile(ScanReader.Identifier);
f.AddClassInstanceProperty(classId, field);
}
break;
case "SubClass":
reader.ScanWhile(ScanReader.WhiteSpace);
if (reader.CheckChar('='))
{
reader.SkipChar();
}
if (reader.CheckChar('{'))
{
while (!reader.CheckChar('}'))
{
reader.SkipChar();
ParseDefSubClass(reader, f, className);
}
reader.SkipChar();
}
else
{
ParseDefSubClass(reader, f, className);
reader.ScanWhile(ScanReader.WhiteSpace);
}
break;
}
reader.ScanWhile(ScanReader.WhiteSpace);
token = reader.ScanWhile(ScanReader.Identifier);
}
return(f);
}
/// <summary>
/// Extracts the generator data definition from the text.
/// </summary>
/// <param name="text">The text data being loaded.</param>
/// <returns>The extracted generator data definition.</returns>
public static GenDataDef ExtractDef(string text)
{
var scan = new ScanReader(text);
return(ExtractDef(scan));
}
/// <summary>
/// Verify that the scanner state is correct when the end of the data has
/// not been reached
/// </summary>
/// <param name="scan"></param>
private static void CheckScannerNotEofConditions(ScanReader scan)
{
Assert.IsFalse(scan.Eof);
Assert.IsFalse(scan.CheckChar(ScanReader.EofChar), "Ctrl-Z expected at EOF");
}
