public void ResolvingAmbiguities()
{
using (var interp = new Interpreter<AmbiguousCalculator>())
{
interp.Parse("2+8/2");
Assert.AreEqual(6, interp.Context.Result.Value);
interp.Parse("8/4/2");
Assert.AreEqual(1, interp.Context.Result.Value);
interp.Parse("2+3"); // can be interpreted as a "2 * (+3)"
Assert.AreEqual(5, interp.Context.Result.Value);
// Check that implicit multiplication works
interp.Parse("2 3");
Assert.AreEqual(6, interp.Context.Result.Value);
// A lot of ambiguities:
interp.Parse("1+-+6/3");
Assert.AreEqual(-1, interp.Context.Result.Value);
#if false
using (var g = new GvGraphView("expr.tmp.gv"))
{
interp.BuildTree("1+-+6/3").WriteGraph(g, interp.Grammar, true);
}
#endif
}
}
public void ExplicitSentinelCharTest()
{
var lang = Language.Get(typeof(WithSentinel));
int TOK1 = lang.Identify(typeof(ASB));
var input = "a\0b";
using (var interp = new Interpreter<WithSentinel>())
{
var tokens = interp.Scan(input).ToArray();
Assert.AreEqual(
new[] { new Msg(TOK1, ASB.Value, new Loc(0, 3)) },
tokens);
}
}
public void ImplicitSentinelTest()
{
var lang = Language.Get(typeof(LineComment));
int TOK1 = lang.Identify(typeof(string));
using (var interp = new Interpreter<LineComment>())
{
var input = "b";
var tokens = interp.Scan(input).ToArray();
Assert.AreEqual(
new[] { new Msg(TOK1, "b", new Loc(0, 1)) },
tokens);
}
}
public void Test()
{
var context = new LCLang();
using (var interp = new Interpreter<LCLang>(context))
{
var lang = Language.Get(typeof(LCLang));
string text = "at-1\r\natNL-2\nat-3\nat-4\nbegin-5\r\n\n\r\nend-8\r\nat-9";
var hlocs = interp.Scan(text).Select(msg => msg.HLocation).ToArray();
Assert.AreEqual(context.Result[0], hlocs[0]);
Assert.AreEqual(context.Result[1], hlocs[1]);
Assert.AreEqual(context.Result[2], hlocs[2]);
Assert.AreEqual(context.Result[3], hlocs[3]);
Assert.AreEqual(context.Result[4], hlocs[4]);
}
}
public static void Main(string[] args)
{
var context = new NestedCommentSyntax();
using (var interp = new Interpreter<NestedCommentSyntax>(context))
{
interp.LoggingKind = LoggingKind.Console;
const string text = "/*/* /* foo *//* middle */ * / * */ bar */";
bool success = interp.Parse(text);
if (success)
{
Console.WriteLine("Comment text is:");
Console.WriteLine(context.Result);
}
}
}
public void Test()
{
using (var interp = new Interpreter<MyCalc>())
{
Assert.IsTrue(interp.Parse("1 + 2 * 3"));
Assert.AreEqual(7, interp.Context.Outcome);
}
using (var freezer = new CilFreezer<MyCalc>())
{
Pipe<MyCalc> code = freezer.Compile("1 + 2 * 3");
var context = new MyCalc();
Assert.AreEqual(7, code(context).Outcome);
}
}
public void Test()
{
var context = new SAdBLang();
using (var interp = new Interpreter<SAdBLang>(context))
{
interp.Parse("d");
Assert.IsTrue(context.IsFinalRuleCalledLast);
Assert.IsTrue(context.WasMergeCalled);
// with SPPF producer
var sppf = interp.BuildTree("d");
using (var graph = new GvGraphView(typeof(SAdBLang).Name + "_sppf.gv"))
{
sppf.WriteGraph(graph, interp.Grammar, true);
}
}
}
public void Test()
{
var lang = Language.Get(typeof(MyParser));
foreach (var value in new[] {0, 1, 2, 3, 4})
{
using (var interp = new Interpreter<MyParser>())
{
string input = value.ToString();
if (value == 2 || value == 4)
{
input = Prefix + input + Suffix;
}
interp.Parse(input);
Assert.AreEqual(value, interp.Context.StartChoice);
}
}
}
public void HeatupTest()
{
var filePath = DataSamples.CompileSample1FilePath;
var source = new StreamReader(filePath);
ILanguageRuntime lang;
// Get language
{
var timer0 = new Stopwatch();
timer0.Start();
lang = Language.Get(typeof(ILLanguage));
timer0.Stop();
Trace.WriteLine("get lang: " + timer0.Elapsed);
}
// Cold state: Slow because of loading big methods:
{
var timer0 = new Stopwatch();
using (var interp = new Interpreter(lang))
{
interp.LoggingKind = LoggingKind.None;
timer0.Start();
interp.Parse("");
timer0.Stop();
}
Trace.WriteLine("heatup: " + timer0.Elapsed);
}
// Hot state: should be fast
{
var timer0 = new Stopwatch();
using (var interp = new Interpreter(lang))
{
interp.LoggingKind = LoggingKind.None;
timer0.Start();
interp.Parse("");
timer0.Stop();
}
Trace.WriteLine("heatup: " + timer0.Elapsed);
}
}
public void Test()
{
var lang = Language.Get(typeof(Re2cSample));
using (var interp = new Interpreter<Re2cSample>())
{
var tokens = interp.Scan("print x 123 0x434af").ToArray();
var expected = new object[] { "$print$", "x", new Decimal("123"), new HexDecimal("0x434af") };
var got = tokens.Select(msg => msg.Value).ToArray();
Assert.AreEqual(expected, got);
Assert.AreEqual(
new int[] {
lang.Identify("print") ,
lang.Identify(typeof(string)),
lang.Identify(typeof(Decimal)),
lang.Identify(typeof(HexDecimal))
},
tokens.Select(msg => msg.Id));
}
}
public static int Main(string[] args)
{
if (args.Length != 1)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.Error.WriteLine("Argument should be path to the BNF file.");
Console.ResetColor();
return 1;
}
string path = args[0];
if (!File.Exists(path))
{
Console.ForegroundColor = ConsoleColor.Red;
Console.Error.WriteLine("File does not exist.");
Console.ResetColor();
return 1;
}
string destBaseName = Path.GetFileNameWithoutExtension(path);
using (var interpreter = new Interpreter<BnfLanguage>(Bnf2CSharpConverter.Create(destBaseName)))
using (var input = new StreamReader(path))
{
interpreter.LoggingKind = LoggingKind.Console;
if (interpreter.Parse(input, path))
{
Console.WriteLine("Conversion succeeded!");
}
else
{
Console.WriteLine(
"============= {0} errors, {1} warnings ===========",
interpreter.ErrorCount,
interpreter.WarningCount);
}
}
return 0;
}
public static void Main(string[] args)
{
var context = new Calculator();
using (var interp = new Interpreter<Calculator>(context))
{
interp.LoggingKind = LoggingKind.Console;
while (true)
{
Console.Write("calc>");
var expr = Console.ReadLine();
try
{
interp.Parse(expr);
if (context.Done)
{
break;
}
if (interp.ErrorCount == 0)
{
Console.WriteLine(context.Result);
}
}
catch (Exception error)
{
while (error.InnerException != null)
{
error = error.InnerException;
}
Console.WriteLine(error.Message);
}
}
}
}
private AstNode GetAst(string pattern)
{
var context = new ScannerSyntax();
using (var interp = new Interpreter<ScannerSyntax>(context))
{
interp.CustomLogging = this.logging;
if (!interp.Parse(pattern))
{
return AstNode.Stub;
}
AstNode root = context.Result.Node;
return root;
}
}
private void Parse(ILanguageRuntime lang, string input)
{
using (var interp = new Interpreter(context, lang))
{
interp.LoggingKind = LoggingKind.Collect;
interp.Parse(input);
errorCount = interp.ErrorCount;
}
}
public void Test2Sppf()
{
var filePath = DataSamples.CompileSample2FilePath;
using (var source = new StreamReader(filePath))
using (var interpreter = new Interpreter<ILLanguage>())
{
SppfNode sppf = interpreter.BuildTree(source, filePath);
using (var graph = new GvGraphView("Cil_Sample2_sppf.gv"))
{
var lang = Language.Get(typeof(ILLanguage));
sppf.WriteGraph(graph, lang.Grammar, true);
}
}
}
private static string BuildAndRun(string filePath)
{
ILLanguage backend = new CecilBackendLanguage(filePath);
using (var interpreter = new Interpreter<ILLanguage>(backend))
using (var source = new StreamReader(filePath))
{
if (!interpreter.Parse(source, filePath))
{
throw new AssertionException("Parsing of file " + filePath + " failed!");
}
}
backend.Save();
return ProgramExecutor.Execute(Path.GetFileNameWithoutExtension(filePath) + ".exe");
}
private static void Benchmarks(
string path,
string title,
Type langDef,
int trialCount = 1,
BenchFlags flags = BenchFlags.All)
{
var timer = new Stopwatch();
timer.Start();
var lang = Language.Get(langDef);
using (var interp = new Interpreter(lang))
{
interp.Parse("a+a");
}
timer.Stop();
Log("--------------- " + title + " ---------------");
Log("heatup time = {0}", timer.Elapsed);
timer.Reset();
using (var testFile = new StreamReader(path))
{
timer.Start();
testFile.ReadToEnd();
timer.Stop();
Log("read time = {0}", timer.Elapsed);
}
using (var interp = new Interpreter(lang))
{
for (int trial = 0; trial != trialCount; ++trial)
{
timer.Reset();
using (var testFile = new StreamReader(path))
{
timer.Start();
int count = interp.Scan(testFile, path).Count();
timer.Stop();
Log("scan time = {0} tokenCount = {1}", timer.Elapsed, count);
}
}
// Recognize
if ((flags & BenchFlags.Recognize) == BenchFlags.Recognize)
{
for (int trial = 0; trial != trialCount; ++trial)
{
timer.Reset();
using (var testFile = new StreamReader(path))
{
timer.Start();
bool success = interp.Recognize(testFile, path);
timer.Stop();
Assert.IsTrue(success);
Log("parse (recognize) = {0}", timer.Elapsed);
}
}
}
// Parse actions
if ((flags & BenchFlags.ParseActions) == BenchFlags.ParseActions)
{
for (int trial = 0; trial != trialCount; ++trial)
{
timer.Reset();
using (var testFile = new StreamReader(path))
{
timer.Start();
bool success = interp.Parse(testFile, path);
timer.Stop();
Assert.IsTrue(success);
Log("parse (actions) = {0}", timer.Elapsed);
}
}
}
// Parse tree
if ((flags & BenchFlags.ParseTree) == BenchFlags.ParseTree)
{
for (int trial = 0; trial != trialCount; ++trial)
{
timer.Reset();
using (var testFile = new StreamReader(path))
{
timer.Start();
interp.BuildTree(testFile, path);
timer.Stop();
Log("parse (tree) = {0}", timer.Elapsed);
}
}
}
}
}
private static List<Msg> Scan(string input)
{
var context = new MyMiniLexer();
using (var interp = new Interpreter<MyMiniLexer>())
{
var result = interp.Scan(input).ToList();
return result;
}
}
