private void ExecutionAcceptKeystroke()
{
// Send the key that was just typed (in pause mode) to the parser for execution.
// TODO: But then the two parsers get desynchronized???
// TODO: But what if the current message is not a keystroke?
upParser.Parse(((KeystrokeMessage)messageQueue.Dequeue()).Tag);
}
public void Parse(string text)
{
try
{
var scanner = new Scanner();
scanner.SetSource(text, 0);
var parser = new Parser.Parser(scanner);
var parseSuccess = parser.Parse();
if (parseSuccess)
{
ParsingCompleted(this, parser.root);
}
else
{
ParsingErrored(this, null);
}
}
catch (LexException ex)
{
ParsingLexErrored(this, ex);
}
catch (SyntaxException ex)
{
ParsingSyntaxErrored(this, ex);
}
}
/// <summary>
/// Executes all the statements in the script.
/// </summary>
public override PhaseResult Execute(PhaseContext phaseCtx)
{
var script = phaseCtx.ScriptText;
var memory = phaseCtx.Ctx.Memory;
var runResult = LangHelper.Execute(() =>
{
this.Ctx.Limits.CheckScriptLength(script);
_parser.Parse(script, memory);
if (phaseCtx.Nodes == null)
{
phaseCtx.Nodes = new List <Expr>();
}
if (phaseCtx.NodesStack == null)
{
phaseCtx.NodesStack = new List <List <Expr> >();
}
// 1. Keep track of all the statements.
phaseCtx.Nodes.AddRange(_parser.Statements);
// 2. Keep track of the each individual set of statements ( from multiple scripts )
phaseCtx.NodesStack.Add(_parser.Statements);
});
return(new PhaseResult(runResult));
}
public override string[] Build()
{
var options = new ParserOption();
var currentAssembly = GetType().Assembly;
var name = new FileInfo(currentAssembly.Location).Name;
var namespaces = currentAssembly.GetTypes().Select(t => t.Namespace).ToArray();
options.Namesapces.AddRange(namespaces);
options.References.Add("System.dll");
options.References.Add(@".\" + name);
options.SourceCode = Parameters.Template;
options.VariableCollection.Add("Namespace",
string.IsNullOrEmpty(Parameters.Namespace) ? "" : Parameters.Namespace);
var tmp = new List<string>();
foreach (Table table in Parameters.DataBase.Tables)
{
options.VariableParameter = table;
options.StatementParameters = new object[] {Parameters.DataBase, table};
var parser = new Parser.Parser(options);
string temp = parser.Parse(ParserType.XCODER);
string fileName = Path.Combine(Parameters.OutputDirectory.FullName, table.Name) + Extension;
File.WriteAllText(fileName, temp);
tmp.Add(fileName);
}
return tmp.ToArray();
}
static void Main(string[] args)
{
var message = @"MSH|^~\&|EPIC|ANCL||IRIS|20170410102836|HJ123|ORM^O01|254|T|2.4||||||||
PID|1|ITCC20170410^^^^MRN|ITCC20170410||DOE^JOHN||19581012|M||W|100 FOAMY WAY^APT A^BELLEVUE^WA^98104^US^^^KING|KING|(425)444-5555^^PH^^^425^4445555|||M||1234|111-22-3333|||
PV1||O|POC01|||||||||||||||||||||||||||||||||||||||||20170410082742|||||
ORC|NW|2017041006^EPC|||||^^^20170410^^R||20170410150905|HJ123^HOPKINS^JOHNS||OP0001^DOE^JACK^^^^^^SERDOTON^^^^SERDOTON|DFM^^^20403^^^^^TEST CLINIC|(425)123-4567^^^^^425^1234567||||H48033^H48033^^20403001^TEST CLINIC|||||||||||O|||
OBR|1|2017041006^EPC||92250^FUNDUS PHOTOGRAPHY^EAP^^FUNDAL PHOTO||20170410|||||L|||||OP0001^DOE^JACK^^^^^^SERDOTON^^^^SERDOTON|(425)598-6900^^^^^425^5986900|||||||OPHTHALMOLOG|||^^^20170410^^R|||||||||20170410||||||||
DG1|1|ICD-10|E11.41^Type 2 diabetes mellitus with diabetic mononeuropathy^I10|Type 2 diabetes mellitus with diabetic mononeuropathy
DG1|2|ICD-9|250.0|DIABETES MELLITUS WITHOUT MENTION OF COMPLICATION, TYPE II OR UNSPECIFIED TYPE, NOT STATED AS UNCONTROLLED";
var parser = new Parser.Parser();
var parsedMessage = parser.Parse(message);
var structure = parsedMessage.GetStructureName();
System.Console.WriteLine($"Message Type: {parsedMessage.GetStructureName()}");
if (structure == "ORM_O01")
{
var orm = parsedMessage as ORM_O01;
System.Console.WriteLine(
$"Patient Id: {orm.PATIENT.PID.PatientID.ID}. Patient Id Type: {orm.PATIENT.PID.PatientID.IdentifierTypeCode}");
var patientName = orm.PATIENT.PID.GetPatientName();
foreach (var name in patientName)
{
System.Console.WriteLine($"Patient Last Name: {name.FamilyName.Surname}. Patient First Name: {name.GivenName}");
}
}
}
public void TestExpressionFunctionReturnTypeBinding()
{
const string src = "namespace MyNamespace" +
"{" +
" class MyClass" +
" {" +
" func Add(int a, int b) -> return new MyClass2()" +
" }" +
"" +
" class MyClass2" +
" {" +
" " +
" }" +
"}";
var lexer = new Lexer.Lexer();
var tokens = lexer.Lex(src);
var parser = new Parser.Parser(tokens);
var ast = parser.Parse();
var binder = new Binder();
var semanticModel = binder.Bind(new List<CompilationUnitSyntax> { ast }).Single();
var boundNamespace = semanticModel.Namespaces.Single(x => x.Name == "MyNamespace");
var expectedFunctionReturnType = boundNamespace.Types.Single(x => x.Name == "MyClass2");
var function = boundNamespace.Types.Single(x => x.Name == "MyClass").Functions.Single(x => x.Name == "Add");
Assert.AreSame(expectedFunctionReturnType, function.ReturnType);
}
public static Parser.Parser ParseCore(this string expression, ExprBuilder builder)
{
Scanner scanner = new Scanner(expression);
Parser.Parser parser = new Parser.Parser(scanner, builder);
parser.Parse();
return parser;
}
public void TestParser()
{
var p = new Parser.Parser();
Assert.AreEqual(p.RemoveComments("lol;//Comment"), "lol;");
Assert.AreEqual(p.RemoveComments("lol;//Comment\nlol;//Comment 2\nlol/*Alex Sabala*/;"), "lol;\nlol;\nlol;");
Assert.AreEqual(p.Parse("lol;\nlol;").Count(), 4);
}
public void GraphNumeratorTest0()
{
var code = @"a = 1;
goto h;
h: b = 1;
goto h2;
h2: c = 1;
d = 1;";
var scanner = new Scanner();
scanner.SetSource(code, 0);
var parser = new Parser.Parser(scanner);
var b = parser.Parse();
var astRoot = parser.root;
var tacodeVisitor = new TACodeVisitor();
astRoot.Visit(tacodeVisitor);
var tacodeInstance = tacodeVisitor.Code;
tacodeInstance.CreateBasicBlockList();
var cfg = new ControlFlowGraph(tacodeInstance);
var numer = GraphNumerator.BackOrder(cfg);
Assert.AreEqual(0, numer.GetIndex(cfg.CFGNodes.ElementAt(0)));
Assert.AreEqual(1, numer.GetIndex(cfg.CFGNodes.ElementAt(1)));
Assert.AreEqual(2, numer.GetIndex(cfg.CFGNodes.ElementAt(2)));
}
public static ProgramNode Parse(string s)
{
var lex = LexerTest.Read(s);
var p = new Parser.Parser();
lex.Parser = p;
return(p.Parse(lex).Cast <ProgramNode>());
}
private Document Parse(string text, IHost host)
{
Parser.Parser parser = new Parser.Parser(host);
Document document;
parser.Parse(text, out document);
return(document);
}
public void TestBinaryExpression()
{
//Test
var testSrc = "1+1";
var compilation = parser.Parse(testSrc);
var result = evaluator.Evaluate(compilation);
Assert.Equal(2, result);
}
private Document Parse(string text)
{
Parser.Parser parsr = new Parser.Parser();
Document document;
parsr.Parse(text, out document);
return document;
}
internal static Document LoadDocument(string template)
{
Parser.Parser parser = new Parser.Parser();
Document document;
if (parser.Parse(template, out document))
{
return document;
}
throw new Exception("Unable to parse: " + parser.ErrorString);
}
protected string Render(string parrot, object model, IHost host)
{
Parser.Parser parser = new Parser.Parser(host);
Document document;
parser.Parse(parrot, out document);
DocumentRenderer renderer = new DocumentRenderer(new MemoryHost());
StringBuilder sb = new StringBuilder();
return renderer.Render(document, model);
}
internal Document LoadDocument(Stream template)
{
Parser.Parser parser = new Parser.Parser();
Document document;
if (parser.Parse(template, out document))
{
return document;
}
throw new Exception("Unable to parse: ");
}
internal Document LoadDocument(string template)
{
Parser.Parser parser = new Parser.Parser(_host);
Document document;
if (parser.Parse(template, out document))
{
return(document);
}
throw new Exception("Unable to parse: ");
}
/// <summary>
/// Parse the input and return the root of the AST node structure.
/// </summary>
/// <param name="reader">inputstream retrieved by a resource loader</param>
/// <param name="templateName">name of the template being parsed</param>
/// <param name="dumpNamespace">flag to dump the Velocimacro namespace for this template</param>
public SimpleNode Parse(TextReader reader, String templateName, bool dumpNamespace)
{
SimpleNode ast = null;
Parser.Parser parser = (Parser.Parser)parserPool.get();
bool madeNew = false;
if (parser == null)
{
// if we couldn't get a parser from the pool
// make one and log it.
Error(
"Runtime : ran out of parsers. Creating new. Please increment the parser.pool.size property. The current value is too small.");
parser = CreateNewParser();
if (parser != null)
{
madeNew = true;
}
}
// now, if we have a parser
if (parser == null)
{
Error("Runtime : ran out of parsers and unable to create more.");
}
else
{
try
{
// dump namespace if we are told to. Generally, you want to
// do this - you don't in special circumstances, such as
// when a VM is getting init()-ed & parsed
if (dumpNamespace)
{
DumpVMNamespace(templateName);
}
ast = parser.Parse(reader, templateName);
}
finally
{
// if this came from the pool, then put back
if (!madeNew)
{
parserPool.put(parser);
}
}
}
return(ast);
}
protected string Render(string parrot, object model, IHost host)
{
Parser.Parser parser = new Parser.Parser(host);
Document document;
parser.Parse(parrot, out document);
DocumentRenderer renderer = new DocumentRenderer(new MemoryHost());
StringBuilder sb = new StringBuilder();
return(renderer.Render(document, model));
}
public ApplyResult Apply(BuildEnvironment env, Command command)
{
string id = command.Arguments[1].GetAsText();
string path = env.GetPath(id, "mcfunction");
Logger.Debug($"Importing {id}...");
var parser = new Parser.Parser(env);
McFunction mcFunction = parser.Parse(id);
mcFunction.Compile(env, false);
return(new ApplyResult(true, mcFunction.Commands));
}
public void TestClass()
{
var lexer = new Lexer.Lexer();
var tokens =
lexer.Lex(
string.Format(NamespaceSource, string.Format(ClassSource, string.Empty, string.Empty, string.Empty)));
var parser = new Parser.Parser(tokens);
var ast = parser.Parse();
Assert.IsInstanceOf<CompilationUnitSyntax>(ast);
Assert.IsNotEmpty(ast.Namespaces);
Assert.IsNotEmpty(ast.Namespaces[0].Classes);
Assert.AreEqual("ClassSample", ast.Namespaces[0].Classes[0].Name.Value);
Assert.AreEqual("DSampleProtocol", ast.Namespaces[0].Classes[0].ProtocolName.Value);
}
public async Task <ICompletion <INative> > ExecuteAsync(string code)
{
try
{
var result = _parser.Parse(code);
var completion = await result.ExecuteAsync(GlobalScope);
return(completion);
}
catch (NativeException e)
{
Console.WriteLine($"Ha ocurrido un error: {e.Message}, {e.Position?.Line}-{e.Position?.Column}");
}
return(new Completion());
}
public static SyntaxTree Analyse(ParserOptions options = null, params string[] source)
{
List <Parser.Program> programs = new List <Parser.Program>();
Tokenizer tokenizer = new Tokenizer();
Parser.Parser parser = new Parser.Parser();
int index = 0;
foreach (var item in source)
{
programs.AddIfNotNull(parser.Parse(tokenizer.Tokenize(item), options ?? ParserOptions.Default, index.ToString()));
index++;
}
return(Analyse(options?.EntryPoint ?? 0, programs.ToArray()));
}
public void TestExpressionFunction()
{
const string functionSource = "func FunctionSample(int a, int b, int c) -> return a * b * c";
var lexer = new Lexer.Lexer();
var tokens =
lexer.Lex(
string.Format(
NamespaceSource,
string.Format(ClassSource, functionSource, string.Empty, string.Empty)));
var parser = new Parser.Parser(tokens);
var ast = parser.Parse();
Assert.IsNotEmpty(ast.Namespaces[0].Classes[0].Functions);
Assert.IsInstanceOf<FunctionSyntax>(ast.Namespaces[0].Classes[0].Functions[0]);
Assert.AreEqual("FunctionSample", ast.Namespaces[0].Classes[0].Functions[0].Name.Value);
}
public static SyntaxTree Analyse(ParserOptions options = null, params FileStream[] source)
{
List <Parser.Program> programs = new List <Parser.Program>();
Tokenizer tokenizer = new Tokenizer();
Parser.Parser parser = new Parser.Parser();
foreach (var item in source)
{
using (StreamReader reader = new StreamReader(item)) {
programs.AddIfNotNull(parser.Parse(tokenizer.Tokenize(reader.ReadToEnd()),
options ?? ParserOptions.Default, item.Name));
}
}
return(Analyse(options?.EntryPoint ?? 0, programs.ToArray()));
}
public static IStatement[] GetParseResultStatements(string expression, MethodInfo[] methodInfos = null)
{
var lexer = new Lexer.Lexer(expression);
var readOnlyList = lexer.Tokenize();
var context = new ParserContext(
readOnlyList,
new Dictionary <string, CompilerType>
{
{ "x", CompilerType.Long }, { "y", CompilerType.Long }, { "z", CompilerType.Long }
},
new Dictionary <string, FieldInfo>(),
methodInfos?.ToDictionary(x => x.Name, x => x) ?? new Dictionary <string, MethodInfo>(),
true);
var parser = new Parser.Parser(context);
var result = parser.Parse();
return(result.Statements);
}
public int Run()
{
var parser = new Parser.Parser(_parserStyle, Grouping);
foreach (Argument argument in GetArguments())
parser.Arguments.Add(argument);
foreach (Option option in GetOptions())
parser.Options.Add(option);
foreach (Command command in GetCommands())
parser.Commands.Add(command);
try
{
ParseResult result = parser.Parse(Environment.GetCommandLineArgs().Skip(1));
return Handle(result);
} catch (Exception ex)
{
Console.WriteLine(ex);
return -1;
}
}
public string Compile(string program)
{
Kernel = new List<uint>(KERNEL_SIZE);
for (int i = 0; i < KERNEL_SIZE; i++) { Kernel.Add(0); }
Parser.Parser parser = new Parser.Parser();
string output;
try
{
var tree = parser.Parse(program);
output = CompileTree(tree);
}
catch (Exception e)
{
Console.WriteLine($"Error {e.Message} on line {LineNumber}");
throw;
}
return output;
}
public void TestFieldTypeToVariableBinding()
{
const string src = "namespace MyNamespace" +
"{" +
" class MyClass" +
" {" +
" var field : false" +
" var field2 : new MyClass2()" +
" func MyFunc()" +
" {" +
" var i : field" +
" var i2 : field2" +
" }" +
" }" +
"" +
" class MyClass2" +
" {" +
" " +
" }" +
"}";
var lexer = new Lexer.Lexer();
var tokens = lexer.Lex(src);
var parser = new Parser.Parser(tokens);
var ast = parser.Parse();
var binder = new Binder();
var semanticModel = binder.Bind(new List<CompilationUnitSyntax> { ast }).Single();
var boundNamespace = semanticModel.Namespaces.Single(x => x.Name == "MyNamespace");
var referencedBoundType = boundNamespace.Types.Single(x => x.Name == "MyClass2");
var boundType = boundNamespace.Types.Single(x => x.Name == "MyClass");
var boundFunction = (BoundFunction)boundType.Functions.Single(x => x.Name == "MyFunc");
Assert.IsInstanceOf<BoolCompilerGeneratedType>(
((IBoundMember)((BoundScopeStatement)boundFunction.Statements).Statements[0]).Type);
Assert.AreSame(
((IBoundMember)((BoundScopeStatement)boundFunction.Statements).Statements[1]).Type,
referencedBoundType);
}
public static void Compile(TextReader input, string output, string[] asms)
{
var lex = new Lexer(new SourceCodeReader(input));
var par = new Parser.Parser();
lex.Parser = par;
var pgm = par.Parse(lex).Cast <ProgramNode>();
var root = new RootNamespace();
root.Assemblies.AddRange(asms.Map(Assembly.Load));
Lookup.LoadType(root, typeof(string)).Name = "String";
Lookup.LoadType(root, typeof(int)).Name = "Int";
Lookup.LoadType(root, typeof(long)).Name = "Long";
Lookup.LoadType(root, typeof(short)).Name = "Short";
Lookup.LoadType(root, typeof(byte)).Name = "Byte";
Lookup.LoadType(root, typeof(bool)).Name = "Bool";
Lookup.LoadType(root, typeof(double)).Name = "Double";
Lookup.LoadType(root, typeof(float)).Name = "Float";
Lookup.LoadType(root, typeof(object)).Name = "Object";
DefineNumericFunction(root, "Int");
DefineNumericFunction(root, "Long");
DefineNumericFunction(root, "Short");
DefineNumericFunction(root, "Byte");
DefineNumericFunction(root, "Double", "ldc.r8 0");
DefineNumericFunction(root, "Float", "ldc.r4 0");
_ = Lookup.LoadFunction(root, "print", typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) }) !);
_ = Lookup.LoadFunction(root, "print", typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }) !);
_ = Lookup.LoadFunction(root, "print", typeof(Console).GetMethod("WriteLine", new Type[] { typeof(long) }) !);
_ = Lookup.LoadFunction(root, "print", typeof(Console).GetMethod("WriteLine", new Type[] { typeof(byte) }) !);
_ = Lookup.LoadFunction(root, "print", typeof(Console).GetMethod("WriteLine", new Type[] { typeof(bool) }) !);
_ = Lookup.LoadFunction(root, "print", typeof(Console).GetMethod("WriteLine", new Type[] { typeof(double) }) !);
_ = Lookup.LoadFunction(root, "print", typeof(Console).GetMethod("WriteLine", new Type[] { typeof(float) }) !);
_ = Lookup.LoadFunction(root, "+", typeof(string).GetMethod("Concat", new Type[] { typeof(string), typeof(string) }) !);
var src = Definition.LoadProgram(root, pgm);
Typing.TypeInference(root, src);
CodeGenerator.Emit(root, src, output);
}
public SimpleNode Parse(TextReader reader, string templateName, bool dumpNamespace)
{
SimpleNode result = null;
Parser.Parser parser = (Parser.Parser) this.parserPool.get();
bool flag = false;
if (parser == null)
{
this.Error("Runtime : ran out of parsers. Creating new. Please increment the parser.pool.size property. The current value is too small.");
parser = this.CreateNewParser();
if (parser != null)
{
flag = true;
}
}
if (parser != null)
{
try
{
if (dumpNamespace)
{
this.DumpVMNamespace(templateName);
}
result = parser.Parse(reader, templateName);
}
finally
{
if (!flag)
{
this.parserPool.put(parser);
}
}
}
else
{
this.Error("Runtime : ran out of parsers and unable to create more.");
}
return(result);
}
public ActionResult Index(string template, string model)
{
if (string.IsNullOrWhiteSpace(template) || string.IsNullOrWhiteSpace(model))
{
return(View(Tuple.Create(DefaultHtmlTemplate, DefaultModelTemplate, "")));
}
Parser.Parser parser = new Parser.Parser(_host);
Type T = TypeBuilderFromJson.CreateType(Newtonsoft.Json.JsonConvert.DeserializeObject(model) as JObject);
var modelObject = Newtonsoft.Json.JsonConvert.DeserializeObject(model, T);
Document document;
string result = null;
if (parser.Parse(template, out document))
{
StringBuilder sb = new StringBuilder();
foreach (var element in document.Children)
{
if (element != null)
{
var renderer = _host.DependencyResolver.Resolve <IRendererFactory>().GetRenderer(element.Name);
sb.AppendLine(renderer.Render(element, modelObject));
}
}
result = sb.ToString();
}
else
{
//TODO: Get this later
result = "Oops!"; // parser.ErrorString;
}
return(View(Tuple.Create(template, model, result)));
}
public void LoadData(string programCode)
{
Lexer lexer = new Lexer(programCode);
IParser parser = new Parser.Parser(lexer);
AST root = parser.Parse();
AbstractSyntaxTree = root;
IDesignExtractor designExtractor = ImplementationFactory.CreateDesignExtractor();
designExtractor.ExtractData(root);
Variables = designExtractor.Variables;
Statements = designExtractor.Statements;
Procedures = designExtractor.Procedures;
Constants = designExtractor.Constants;
FollowsTable = designExtractor.FollowsTable;
ParentTable = designExtractor.ParentTable;
ModifiesTable = designExtractor.ModifiesTable;
UsesTable = designExtractor.UsesTable;
CallsTable = designExtractor.CallsTable;
NextTable = designExtractor.NextTable;
AffectsTable = designExtractor.AffectsTable;
}
private static BlockNode AST(string fileName)
{
Console.OutputEncoding = Encoding.UTF8;
try
{
string text = File.ReadAllText(fileName);
var scanner = new Scanner();
scanner.SetSource(text, 0);
var parser = new Parser.Parser(scanner);
var b = parser.Parse();
if (b)
{
Console.WriteLine("Синтаксическое дерево построено");
return(parser.root);
}
else
{
Console.WriteLine("Ошибка");
}
}
catch (FileNotFoundException)
{
Console.WriteLine($"Файл {fileName} не найден");
}
catch (LexException e)
{
Console.WriteLine($"Лексическая ошибка. {e.Message}");
}
catch (SyntaxException e)
{
Console.WriteLine($"Синтаксическая ошибка. {e.Message}");
}
return(null);
}
public void ParserParse_Test()
{
var parser = new Parser.Parser();
Assert.That(parser.Parse(""), Is.EqualTo(null));
Assert.That(parser.Parse("h1 header"), Is.EqualTo(new List <Tuple <string, string> >()
{
new Tuple <string, string>(KeyWords.Header1, "header")
}));
Assert.That(parser.Parse("h2 header"), Is.EqualTo(new List <Tuple <string, string> >()
{
new Tuple <string, string>(KeyWords.Header2, " header")
}));
Assert.That(parser.Parse("h2 header\r\n\r\np text"),
Is.EqualTo(new List <Tuple <string, string> >()
{
new Tuple <string, string>(KeyWords.Header2, "header"),
new Tuple <string, string>(KeyWords.Text, "text")
}));
Assert.That(parser.Parse("h2 header\r\n\r\np text\r\n\r\nignore text"),
Is.EqualTo(new List <Tuple <string, string> >()
{
new Tuple <string, string>(KeyWords.Header2, "header"),
new Tuple <string, string>(KeyWords.Text, "text"),
new Tuple <string, string>(null, "ignore text")
}));
Assert.That(parser.Parse("ordlist sometext\r\none\r\ntwo"),
Is.EqualTo(new List <Tuple <string, string> >()
{
new Tuple <string, string>(KeyWords.OrderedList, "sometext\r\none\r\ntwo")
}));
}
public void Test_IsExpression_ThrowsTypeNotDefined()
{
const string src = "namespace MyNamespace" +
"{" +
" class MyClass" +
" {" +
" func Add(int a, int b) -> return a * b" +
" }" +
"" +
" class MyClass2" +
" {" +
" var myClassField : new MyClass()" +
" func Foo() -> bool" +
" {" +
" return myClassField is MyClassS" +
" }" +
" }" +
"}";
var lexer = new Lexer.Lexer();
var tokens = lexer.Lex(src);
var parser = new Parser.Parser(tokens);
var ast = parser.Parse();
var binder = new Binder();
Assert.That(
() => binder.Bind(new List<CompilationUnitSyntax>() { ast }),
Throws.InstanceOf<KiwiSemanticException>().With.Message.EqualTo("MyClassS undefined Type"));
}
public void Test_MemberAccessExpressionBinding()
{
const string src = "namespace MyNamespace" +
"{" +
" class MyClass" +
" {" +
" func Add(int a, int b) -> return a * b" +
" }" +
"" +
" class MyClass2" +
" {" +
" var addMethod : new MyClass().Add" +
" }" +
"}";
var lexer = new Lexer.Lexer();
var tokens = lexer.Lex(src);
var parser = new Parser.Parser(tokens);
var ast = parser.Parse();
var binder = new Binder();
var boundCompilationUnit = binder.Bind(new List<CompilationUnitSyntax>() { ast }).Single();
var function =
boundCompilationUnit.Namespaces[0].Types.Single(x => x.Name == "MyClass")
.Functions.Single(x => x.Name == "Add");
var field =
boundCompilationUnit.Namespaces[0].Types.Single(x => x.Name == "MyClass2")
.Fields.Single(x => x.Name == "addMethod");
Assert.That(
() => field.Type,
Is.InstanceOf<FunctionCompilerGeneratedType>()
.And.Property("ReturnType")
.InstanceOf<IntCompilerGeneratedType>());
CollectionAssert.AllItemsAreInstancesOfType(
((FunctionCompilerGeneratedType)field.Type).ParameterTypes,
typeof(IntCompilerGeneratedType));
}
public void TestErrorParser()
{
var parser = new Parser.Parser();
parser.Parse(@"CaffeTests\Error.prototxt");
}
static void Main(string[] args)
{
if (args.Length != 1)
{
Console.WriteLine("Please provide input file");
Environment.Exit(-1);
}
string filePath = $@"{Environment.CurrentDirectory}\{args[0]}";
string fileName = Path.GetFileNameWithoutExtension(filePath);
string fileDirectory = Path.GetDirectoryName(filePath);
string inputText = File.ReadAllText(filePath);
Lexer.Lexer lex = new Lexer.Lexer(inputText);
List <Token> tokensToParse = new List <Token>();
using (StreamWriter tokenFile = new StreamWriter($@"{fileDirectory}\{fileName}.outlextokens"))
using (StreamWriter tokenErrorFile = new StreamWriter($@"{fileDirectory}\{fileName}.outlexerrors"))
{
Token t;
do
{
t = lex.GetNextToken();
//Console.WriteLine(t.ToString());
if (lex.IsErrorToken(t.TokenType))
{
tokenErrorFile.WriteLine(t.ToString());
Console.WriteLine($"LexError: {t.ToString()}");
}
else
{
tokenFile.WriteLine(t.ToString());
tokensToParse.Add(t);
}
}while (t.TokenType != TokenType.EOF);
tokensToParse.RemoveAll(x => lex.IsCommentToken(x.TokenType));
Console.WriteLine("INFO: Lexing completed.");
}
using (StreamWriter astStream = new StreamWriter($@"{fileDirectory}\{fileName}.outast"))
using (StreamWriter derivationsStream = new StreamWriter($@"{fileDirectory}\{fileName}.outderivation"))
using (StreamWriter syntaxErrorStream = new StreamWriter($@"{fileDirectory}\{fileName}.outsyntaxerrors"))
using (StreamWriter symbolTablesStream = new StreamWriter($@"{fileDirectory}\{fileName}.outsymboltables"))
using (StreamWriter semanticErrorStream = new StreamWriter($@"{fileDirectory}\{fileName}.outsemanticerrors"))
using (StreamWriter codeGenOutput = new StreamWriter($@"{fileDirectory}\{fileName}.moon"))
{
// Do parsing
Parser.Parser parser = new Parser.Parser(tokensToParse, syntaxErrorStream, derivationsStream, astStream);
Console.WriteLine(parser.Parse() ? "Parsing passed" : "Error: Parsing Failed");
var tree = parser.GetASTTree();
var printVisitor = new DOTPrinterVisitor(astStream);
tree.Accept(printVisitor);
astStream.Flush();
Console.WriteLine("INFO: AST Tree dumped to outast");
var symbolTableVisitor = new SymbolTableVisitor(semanticErrorStream);
tree.Accept(symbolTableVisitor);
Console.WriteLine("INFO: SymbolTable Generated");
var semanticCheckerVisitor = new SemanticCheckerVisitor(semanticErrorStream, symbolTableVisitor.GlobalSymbolTable);
tree.Accept(semanticCheckerVisitor);
Console.WriteLine("INFO: Semantic Checking Complete");
syntaxErrorStream.Flush();
semanticErrorStream.Flush();
bool hasErrors = semanticErrorStream.BaseStream.Length != 0 || syntaxErrorStream.BaseStream.Length != 0;
if (hasErrors)
{
Console.WriteLine("Errors generated during parsing/semantic checking, terminating...");
Console.ReadKey();
Environment.Exit(-10);
}
// Codegen
codeGenOutput.NewLine = "\n";
var codeWriter = new CodeWriter(codeGenOutput);
var codeGen = new CodeGen.CodeGen(tree, symbolTableVisitor.GlobalSymbolTable, codeWriter);
codeGen.GenerateCode();
symbolTablesStream.WriteLine(symbolTableVisitor.GlobalSymbolTable);
Console.WriteLine("INFO: Code Generated");
Console.ReadKey();
}
}
public void Test_SwitchStatement_CasesTypeMustMatchSwitchConditionType()
{
const string src = "namespace MyNamespace" +
"{" +
" class MyClass" +
" {" +
" func Add(int a, int b) " +
" { " +
" switch(a)" +
" {" +
" case \"LOL\" -> Add(1, 0)" +
" }" +
" }" +
" }" +
"" +
"}";
var lexer = new Lexer.Lexer();
var tokens = lexer.Lex(src);
var parser = new Parser.Parser(tokens);
var ast = parser.Parse();
var binder = new Binder();
Assert.That(
() => binder.Bind(new List<CompilationUnitSyntax>() { ast }),
Throws.InstanceOf<KiwiSemanticException>()
.With.Message.EqualTo("Switch cases condition type must match switch condition type"));
}
public void TestGoogLeNetDeploySuccessParser()
{
var parser = new Parser.Parser();
parser.Parse(@"CaffeTests\GoogLeNet-deploy.prototxt");
}
public void Test_IfElseExpression_IfTrueIfFalseTypeMustBeEqual()
{
const string src = "namespace MyNamespace" +
"{" +
" class MyClass" +
" {" +
" func Add(int a, float b) -> return if(true) a else b" +
" }" +
"" +
"}";
var lexer = new Lexer.Lexer();
var tokens = lexer.Lex(src);
var parser = new Parser.Parser(tokens);
var ast = parser.Parse();
var binder = new Binder();
Assert.That(
() => binder.Bind(new List<CompilationUnitSyntax>() { ast }),
Throws.InstanceOf<KiwiSemanticException>()
.With.Message.EqualTo("IfTrue and IfFalse expression Type must match"));
}
public void Test_VariableWithSameName_Throws()
{
const string src = "namespace MyNamespace" +
"{" +
" class MyClass" +
" {" +
" func Add(int a, int b)" +
" {" +
" var a : 1" +
" var b : 2" +
" var a : 1" +
" }" +
" }" +
"}";
var lexer = new Lexer.Lexer();
var tokens = lexer.Lex(src);
var parser = new Parser.Parser(tokens);
var ast = parser.Parse();
var binder = new Binder();
Assert.That(
() => binder.Bind(new List<CompilationUnitSyntax> { ast }),
Throws.TypeOf<KiwiSemanticException>().With.Message.EqualTo("a already defined."));
}
public void Test_IsExpression()
{
const string src = "namespace MyNamespace" +
"{" +
" class MyClass" +
" {" +
" func Add(int a, int b) -> return a * b" +
" }" +
"" +
" class MyClass2" +
" {" +
" var myClassField : new MyClass()" +
" func Foo() -> bool" +
" {" +
" return myClassField is MyClass" +
" }" +
" }" +
"}";
var lexer = new Lexer.Lexer();
var tokens = lexer.Lex(src);
var parser = new Parser.Parser(tokens);
var ast = parser.Parse();
var binder = new Binder();
var boundCompilationUnit = binder.Bind(new List<CompilationUnitSyntax>() { ast }).Single();
var type = boundCompilationUnit.Namespaces[0].Types.Single(x => x.Name == "MyClass");
var function =
(BoundFunction)
boundCompilationUnit.Namespaces[0].Types.Single(x => x.Name == "MyClass2")
.Functions.Single(x => x.Name == "Foo");
var returnStatement = (BoundReturnStatement)((BoundScopeStatement)function.Statements).Statements[0];
var boundBinaryExpression = (BoundBinaryExpression)returnStatement.Expression;
Assert.AreEqual(BinaryOperators.Is, boundBinaryExpression.Operator);
Assert.IsInstanceOf<BoundTypeExpression>(boundBinaryExpression.Right);
Assert.AreSame(((BoundTypeExpression)boundBinaryExpression.Right).ReferencedType, type);
}
public void Test_RecursivExpressionFunction_DoesThrow()
{
const string src = "namespace MyNamespace" +
"{" +
" class MyClass" +
" {" +
" func Add(int a, int b) -> return Add(1, 2)" +
" }" +
"" +
"}";
var lexer = new Lexer.Lexer();
var tokens = lexer.Lex(src);
var parser = new Parser.Parser(tokens);
var ast = parser.Parse();
var binder = new Binder();
Assert.That(
() => binder.Bind(new List<CompilationUnitSyntax>() { ast }),
Throws.InstanceOf<KiwiSemanticException>().With.Message.EqualTo("Add Type cannot be inferred"));
}
private void ExecutionProcessKeystrokeMessage
(KeystrokeMessage keystroke,
Engine engine,
Program program,
Stack stack,
ref bool ignoreNextDown,
ref bool ignoreNextUp,
out bool mustUnbusyUI)
{
try
{
mustUnbusyUI = true;
// We want to protect this sequence against asynchronous changes to the menus which
// may happen if the W/PGRM-RUN switch is moved: we wouldn't want the menus to be
// changed by the main thread between the invocation of notifyUI and the call to
// the parser, or during the execution of the keystroke.
lock (IsBusy)
{
bool programWasEmpty = program.IsEmpty;
display.Invoke
(notifyUI, new object [] { /* threadIsBusy */ true, programWasEmpty });
switch (keystroke.Motion)
{
case KeystrokeMotion.Up:
// We may have to ignore two up keystrokes after an error: the one for
// the key that caused the error, and the one for the key that clears
// the error.
if (ignoreNextUp)
{
ignoreNextUp = ignoreNextDown;
}
else
{
upParser.Parse(keystroke.Tag);
}
mustUnbusyUI = !ignoreNextDown;
break;
case KeystrokeMotion.Down:
// In general we *don't* refresh the display here because a down
// keystroke may display the current instruction. There are three
// exceptions to this, though: we refresh if the display is blurred, or
// if this is the key that clears an error, or if the state of the
// program changed. The latter is necessary because we are not sure to
// get an up keystroke for MERGE, as the mouse is likely to move to the
// dialog box.
// TODO: What if another down key was queued in-between?
downKeystrokeWasEnqueued.Reset();
if (ignoreNextDown)
{
Trace.Assert(ignoreNextUp);
ignoreNextDown = false;
}
else
{
downParser.Parse(keystroke.Tag);
}
mustUnbusyUI = ignoreNextUp ||
display.IsBlurred ||
program.IsEmpty != programWasEmpty;
break;
}
}
}
catch (Interrupt)
{
display.Formatter.Value = stack.X; // Refresh the numeric display.
ignoreNextDown = true;
ignoreNextUp = true;
mustUnbusyUI = true;
ExecutionCompleteKeystrokes();
}
}
public void Test_Operator_FunctionMapping()
{
const string src = "namespace MyNamespace" +
"{" +
" class MyClass2" +
" {" +
" operator Add(MyClass2 opA, MyClass2 opB) -> return new MyClass2()" +
" operator Sub(MyClass2 opA, MyClass2 opB) -> return new MyClass2()" +
" operator Mult(MyClass2 opA, MyClass2 opB) -> return new MyClass2()" +
" operator Div(MyClass2 opA, MyClass2 opB) -> return new MyClass2()" +
" operator Pow(MyClass2 opA, MyClass2 opB) -> return new MyClass2()" +
" operator Range(MyClass2 opA, MyClass2 opB) -> return new MyClass2[1]" +
" operator In(MyClass2 opA, MyClass2 opB) -> return true" +
" }" +
" " +
" class TestClass" +
" {" +
" func TestBinaryFunc()" +
" {" +
" var instance : new MyClass2()" +
" var testAdd : instance + new MyClass2()" +
" var testSub : instance - new MyClass2()" +
" var testMult : instance * new MyClass2()" +
" var testDiv : instance / new MyClass2()" +
" var testPow : instance ^ new MyClass2()" +
" var testRange : instance..newMyClass2()" +
" var testIn : instance in new myClass2[10]" +
" }" +
"" +
"" +
" func TestAssignFunc()" +
" {" +
" var instance : None MyClass2" +
" instance +: new MyClass2()" +
" instance -: new MyClass2()" +
" instance *: new MyClass2()" +
" instance ^: new MyClass2()" +
" instance /: new MyClass2()" +
" }" +
" }" +
"}";
var lexer = new Lexer.Lexer();
var tokens = lexer.Lex(src);
var parser = new Parser.Parser(tokens);
var ast = parser.Parse();
var binder = new Binder();
var boundCompilationUnit = binder.Bind(new List<CompilationUnitSyntax>() { ast }).Single();
var boundNamespace = boundCompilationUnit.Namespaces.Single(x=>x.Name== "MyNamespace");
var operatorClass = boundNamespace.Types.Single(x=>x.Name== "MyClass2");
var testClass = boundNamespace.Types.Single(x=>x.Name == "TestClass");
var testBinaryFunc = testClass.Functions.Single(x=>x.Name== "TestBinaryFunc");
var testAssignFunc = testClass.Functions.Single(x=>x.Name== "TestAssignFunc");
}
public void Test_ObjectCreationExpression_ThrowsNoConstructorWithoutArguments()
{
const string src = "namespace MyNamespace" +
"{" +
" class MyClass" +
" {" +
" Constructor(int a){}" +
" }" +
" class MyClass2" +
" {" +
" func Foo()" +
" {" +
" var a : new MyClass()" +
" }" +
" }" +
"}";
var lexer = new Lexer.Lexer();
var tokens = lexer.Lex(src);
var parser = new Parser.Parser(tokens);
var ast = parser.Parse();
var binder = new Binder();
Assert.That(
() => binder.Bind(new List<CompilationUnitSyntax>() { ast }),
Throws.InstanceOf<KiwiSemanticException>()
.With.Message.EqualTo("MyNamespace.MyClass has no constructor without arguments."));
}
static void Main(string[] args)
{
if (args.Length != 1)
{
Console.WriteLine("Please provide input file");
Environment.Exit(-1);
}
string filePath = $@"{Environment.CurrentDirectory}\{args[0]}";
string fileName = Path.GetFileNameWithoutExtension(filePath);
string fileDirectory = Path.GetDirectoryName(filePath);
string inputText = File.ReadAllText(filePath);
Lexer.Lexer lex = new Lexer.Lexer(inputText);
List <Token> tokensToParse = new List <Token>();
using (StreamWriter tokenFile = new StreamWriter($@"{fileDirectory}\{fileName}.outlextokens"))
using (StreamWriter tokenErrorFile = new StreamWriter($@"{fileDirectory}\{fileName}.outlexerrors"))
{
Token t;
do
{
t = lex.GetNextToken();
Console.WriteLine(t.ToString());
if (lex.IsErrorToken(t.TokenType))
{
tokenErrorFile.WriteLine(t.ToString());
}
else
{
tokenFile.WriteLine(t.ToString());
tokensToParse.Add(t);
}
}while (t.TokenType != TokenType.EOF);
tokensToParse.RemoveAll(x => lex.IsCommentToken(x.TokenType));
}
using (StreamWriter astStream = new StreamWriter($@"{fileDirectory}\{fileName}.outast"))
using (StreamWriter derivationsStream = new StreamWriter($@"{fileDirectory}\{fileName}.outderivation"))
using (StreamWriter syntaxErrorStream = new StreamWriter($@"{fileDirectory}\{fileName}.outsyntaxerrors"))
using (StreamWriter symbolTablesStream = new StreamWriter($@"{fileDirectory}\{fileName}.outsymboltables"))
using (StreamWriter semanticErrorStream = new StreamWriter($@"{fileDirectory}\{fileName}.outsemanticerrors"))
{
// Do parsing
Parser.Parser parser = new Parser.Parser(tokensToParse, syntaxErrorStream, derivationsStream, astStream);
Console.WriteLine(parser.Parse());
var tree = parser.GetASTTree();
derivationsStream.Flush();
syntaxErrorStream.Flush();
var printVisitor = new DOTPrinterVisitor(astStream);
tree.Accept(printVisitor);
astStream.Flush();
var symbolTableVisitor = new SymbolTableVisitor(semanticErrorStream);
tree.Accept(symbolTableVisitor);
symbolTablesStream.WriteLine(symbolTableVisitor.GlobalSymbolTable);
Console.WriteLine(symbolTableVisitor.GlobalSymbolTable);
var semanticCheckerVisitor = new SemanticCheckerVisitor(semanticErrorStream, symbolTableVisitor.GlobalSymbolTable);
tree.Accept(semanticCheckerVisitor);
}
}
public static GettextCatalog ParseFromStream(Stream poStream)
{
if (poStream == null) throw new ArgumentNullException("poStream");
GettextCatalog catalog = null;
try
{
var lexer = new Scanner();
lexer.SetSource(poStream);
var parser = new Parser.Parser(lexer);
parser.Parse();
catalog = parser.Catalog;
if (catalog == null) goto ret;
// another parsing step
catalog.ParseHeaders();
// transform all strings into internal UTF-8 representation
catalog.ConvertStringsToUtf8();
// parse comments
catalog.ParseComments();
// build lookup structures
catalog.Finalize();
} catch (Exception e)
{
throw new GettextException("Parsing exception!", e);
}
ret:
if (catalog == null) throw new GettextException("Couldn't parse the catalog. Check the syntax.");
return catalog;
}
internal void Process(string fileArg)
{
GetNames(fileArg);
// check for file exists
OpenSource();
// parse source file
if (inputFile != null)
{
DateTime start = DateTime.Now;
try
{
handler = new ErrorHandler();
scanner = new Scanner(inputFile);
parser = new Parser.Parser(scanner);
scanner.yyhdlr = handler;
parser.Initialize(this, scanner, handler, new OptionParser2(ParseOption));
aast = parser.Aast;
parser.Parse();
// aast.DiagnosticDump();
if (verbose)
{
Status(start);
}
CheckOptions();
if (!Errors && !ParseOnly)
{ // build NFSA
if (ChrClasses)
{
DateTime t0 = DateTime.Now;
partition = new Partition(TargetSymCardinality, this);
partition.FindClasses(aast);
partition.FixMap();
if (verbose)
{
ClassStatus(t0, partition.Length);
}
}
else
{
CharRange.Init(TargetSymCardinality);
}
nfsa = new NFSA(this);
nfsa.Build(aast);
if (!Errors)
{ // convert to DFSA
dfsa = new DFSA(this);
dfsa.Convert(nfsa);
if (!Errors)
{ // minimize automaton
if (minimize)
{
dfsa.Minimize();
}
if (!Errors && !checkOnly)
{ // emit the scanner to output file
TextReader frameRdr = FrameReader();
TextWriter outputWrtr = OutputWriter();
dfsa.EmitScanner(frameRdr, outputWrtr);
if (!embedBuffers)
{
CopyBufferCode();
}
// Clean up!
if (frameRdr != null)
{
frameRdr.Close();
}
if (outputWrtr != null)
{
outputWrtr.Close();
}
}
}
}
}
}
catch (Exception ex)
{
string str = ex.Message;
handler.AddError(str, aast.AtStart);
throw;
}
}
}
public void Test_InfixCall_Types()
{
const string src = "namespace MyNamespace" +
"{" +
" class MyClass2" +
" {" +
" infix func Add(int a, int b) -> return a + b" +
" func Foo()" +
" {" +
" var a : 1 Add 2" +
" }" +
" }" +
"}";
var lexer = new Lexer.Lexer();
var tokens = lexer.Lex(src);
var parser = new Parser.Parser(tokens);
var ast = parser.Parse();
var binder = new Binder();
var boundCompilationUnits = binder.Bind(new List<CompilationUnitSyntax>() { ast });
var myClass2Type = boundCompilationUnits[0].Namespaces[0].Types.Single();
var fooFunction = myClass2Type.Functions.Single(x => x.Name == "Foo");
var addFunction = myClass2Type.Functions.Single(x => x.Name == "Add");
Assert.IsInstanceOf<BoundFunction>(addFunction);
Assert.IsTrue(((BoundFunction)addFunction).IsInfixFunction);
Assert.IsInstanceOf<BoundFunction>(fooFunction);
var boundFunction = (BoundFunction)fooFunction;
Assert.IsInstanceOf<BoundScopeStatement>(boundFunction.Statements);
var boundScopeStatement = (BoundScopeStatement)boundFunction.Statements;
Assert.IsInstanceOf<BoundVariableDeclarationStatement>(boundScopeStatement.Statements[0]);
var boundVariableDeclarationStatement = (BoundVariableDeclarationStatement)boundScopeStatement.Statements[0];
Assert.IsInstanceOf<BoundInvocationExpression>(boundVariableDeclarationStatement.BoundExpression);
var boundInvocationExpression = (BoundInvocationExpression)boundVariableDeclarationStatement.BoundExpression;
Assert.IsInstanceOf<BoundMemberExpression>(boundInvocationExpression.ToInvoke);
var boundMemberExpression = (BoundMemberExpression)boundInvocationExpression.ToInvoke;
Assert.AreSame(addFunction, boundMemberExpression.BoundMember);
}
private static int Main( string[] args )
{
Stream inputFile = null;
Grammar grammar = null;
ErrorHandler handler = new ErrorHandler();
string inputFileInfo = null; // Filename plus revision time.
Lexers.Scanner scanner = null;
Parser.Parser parser = null;
Assembly assm = Assembly.GetExecutingAssembly();
object info = Attribute.GetCustomAttribute( assm, typeof( AssemblyFileVersionAttribute ) );
versionInfo = ((AssemblyFileVersionAttribute)info).Version;
try {
string filename = ProcessOptions( args );
if (filename == null)
return MC_OK;
try {
inputFile = new FileStream( filename, FileMode.Open, FileAccess.Read, FileShare.Read );
inputFileInfo = filename + " - " + File.GetLastWriteTime( filename ).ToString();
}
catch (IOException x) {
string message;
inputFile = null;
if (x is FileNotFoundException)
message = String.Format( CultureInfo.InvariantCulture,
"Source file <{0}> not found{1}",
filename, Environment.NewLine );
else
message = String.Format( CultureInfo.InvariantCulture,
"Source file <{0}> could not be opened{1}",
filename, Environment.NewLine );
handler.AddError( 4, message, null ); // aast.AtStart;
return MC_FILEERROR;
}
scanner = new Lexers.Scanner( inputFile );
scanner.SetHandler( handler );
parser = new Parser.Parser( filename, inputFileInfo, scanner, handler );
//
// If the parse is successful, then process the grammar.
// Otherwise just report the errors that have been listed.
//
if (parser.Parse()) {
grammar = parser.Grammar;
if (Terminal.Max > 255)
handler.ListError( null, 103, CharacterUtilities.Map( Terminal.Max ), '\'' );
LALRGenerator generator = new LALRGenerator( grammar );
List<AutomatonState> states = generator.BuildStates();
generator.ComputeLookAhead();
generator.BuildParseTable();
if (!grammar.CheckGrammar( handler ))
throw new ArgumentException( "Non-terminating grammar" );
//
// If the grammar has non-terminating non-terms we cannot
// create a diagnostic report as the grammar is incomplete.
//
if (!handler.Errors) {
CodeGenerator code = new CodeGenerator();
code.Generate( states, grammar );
}
bool DoDiagnose = Diagnose && !grammar.HasNonTerminatingNonTerms;
if (Report || DoDiagnose) {
string htmlName = System.IO.Path.ChangeExtension( filename, ".report.html" );
try {
System.IO.FileStream htmlFile = new System.IO.FileStream( htmlName, System.IO.FileMode.Create );
System.IO.StreamWriter htmlWriter = new System.IO.StreamWriter( htmlFile );
Grammar.HtmlHeader( htmlWriter, filename );
if (Report && DoDiagnose)
grammar.GenerateCompoundReport( htmlWriter, inputFileInfo, states );
else if (Report)
grammar.GenerateReport( htmlWriter, inputFileInfo, states );
Grammar.HtmlTrailer( htmlWriter );
if (htmlFile != null) {
htmlWriter.Flush();
htmlFile.Close();
}
}
catch (System.IO.IOException) {
Console.Error.WriteLine( "Cannot create html output file {0}", htmlName );
}
}
}
}
catch (System.Exception e) {
if (e is TooManyErrorsException)
return MC_TOOMANYERRORS;
Console.Error.WriteLine( "Unexpected Error {0}", e.Message );
if (NoThrowOnError) {
// report the error, do not let it go into the void
Console.Error.WriteLine( e );
return MC_EXCEPTION;
}
}
finally {
if (handler.Errors || handler.Warnings)
handler.DumpAll( (scanner == null ? null : scanner.Buffer), Console.Error );
if ((Listing || handler.Errors || handler.Warnings) && parser != null) {
string listName = parser.ListfileName;
StreamWriter listStream = ListingFile( listName );
if (listStream != null)
handler.MakeListing( scanner.Buffer, listStream, parser.SourceFileInfo, versionInfo );
}
}
return MC_OK;
}
public override string[] Build()
{
var options = BuildOption();
options.SourceCode = Parameters.Template;
var tmp = new List<string>();
var parser = new Parser.Parser(options);
string fileName;
string temp;
string fName;
DirectoryInfo dir;
switch (Parameters.FileDependency)
{
case FileDepend.DATABASE:
parser.Options.VariableParameter = Parameters.DataBase;
parser.Options.StatementParameters = new object[] { Parameters.DataBase };
temp = parser.Parse(ParserType.XCODER);
fName = string.IsNullOrEmpty(Parameters.FileNameFormat)
? Parameters.DataBase.Connection.Name
: string.Format(Parameters.FileNameFormat, Parameters.DataBase.Connection.Name);
fileName = Path.Combine(Parameters.OutputDirectory.FullName, fName + Extension);
dir = new FileInfo(fileName).Directory;
if (dir != null && !dir.Exists)
{
dir.Create();
}
if (Parameters.Override)
{
File.WriteAllText(fileName, temp);
tmp.Add(fileName);
}
else
{
if (!File.Exists(fileName))
{
File.WriteAllText(fileName, temp);
}
tmp.Add(fileName);
}
break;
case FileDepend.TABLES:
foreach (Table table in Parameters.DataBase.Tables)
{
parser.Options.VariableParameter = table;
parser.Options.StatementParameters = new object[] { Parameters.DataBase, table };
temp = parser.Parse(ParserType.XCODER);
fName = string.IsNullOrEmpty(Parameters.FileNameFormat)
? table.Name
: string.Format(Parameters.FileNameFormat, table.Name);
fileName = Path.Combine(Parameters.OutputDirectory.FullName, fName + Extension);
dir = new FileInfo(fileName).Directory;
if (dir != null && !dir.Exists)
{
dir.Create();
}
if (Parameters.Override)
{
File.WriteAllText(fileName, temp);
tmp.Add(fileName);
}
else
{
if (!File.Exists(fileName))
{
File.WriteAllText(fileName, temp);
}
tmp.Add(fileName);
}
}
break;
default:
throw new ArgumentOutOfRangeException();
}
parser.Release();
return tmp.ToArray();
}
public void TestResNet50DeploySuccessParser()
{
var parser = new Parser.Parser();
parser.Parse(@"CaffeTests\ResNet-50-deploy.prototxt");
}
public void TestAlexNetSuccessParser()
{
var parser = new Parser.Parser();
parser.Parse(@"CaffeTests\AlexNet.prototxt");
}
private Document Parse(string text, IHost host)
{
Parser.Parser parser = new Parser.Parser(host);
Document document;
parser.Parse(text, out document);
return document;
}
public void Test_Scope_VariableNotDefined()
{
const string src = "namespace MyNamespace" +
"{" +
" class MyClass" +
" {" +
" func Add(int a, int b) " +
" { " +
" {" +
" var i : 1337 + b" +
" }" +
" var c : a * b * i" +
" }" +
" }" +
"" +
"}";
var lexer = new Lexer.Lexer();
var tokens = lexer.Lex(src);
var parser = new Parser.Parser(tokens);
var ast = parser.Parse();
var binder = new Binder();
Assert.That(
() => binder.Bind(new List<CompilationUnitSyntax>() { ast }),
Throws.InstanceOf<KiwiSemanticException>().With.Message.EqualTo("i not defined"));
}
public void Test_ArrayAccessInvalidParameter_Throws()
{
const string src = "namespace MyNamespace" +
"{" +
" class MyClass" +
" {" +
" func Add(int a, int b)" +
" { " +
" var c : new int[1][1]" +
" var d : c[1]" +
" }" +
" }" +
"}";
var lexer = new Lexer.Lexer();
var tokens = lexer.Lex(src);
var parser = new Parser.Parser(tokens);
var ast = parser.Parse();
var binder = new Binder();
Assert.That(
() => binder.Bind(new List<CompilationUnitSyntax>() { ast }),
Throws.InstanceOf<KiwiSemanticException>()
.With.Message.EqualTo("Parameter count (1) must match array dimension count (2)"));
}
public void Test_IfStatement_IfConditionMustBeBool()
{
const string src = "namespace MyNamespace" +
"{" +
" class MyClass" +
" {" +
" func Add(int a, int b) " +
" { " +
" if(a)" +
" {" +
" " +
" }" +
" }" +
" }" +
"" +
"}";
var lexer = new Lexer.Lexer();
var tokens = lexer.Lex(src);
var parser = new Parser.Parser(tokens);
var ast = parser.Parse();
var binder = new Binder();
Assert.That(
() => binder.Bind(new List<CompilationUnitSyntax>() { ast }),
Throws.InstanceOf<KiwiSemanticException>().With.Message.EqualTo("If condition must be of Type Bool"));
}
