public static SyntaxNode ParseExpression(string expression, Environment environment) { SyntaxTreeBuilder builder = new SyntaxTreeBuilder(); SyntaxNode root = builder.BuildTree(Lexer.Lex(new RawExpression(expression))); return(SemanticAnalyzer.Analyze(root, environment)); }
public void ProgramTests(string source) { Context.Source = Text.Of(source); var parser = new Parser(new Scanner()); var cfg = SemanticAnalyzer.Analyze((ProgramNode)parser.BuildTree()); var generated = new Generator(cfg).Generate(); }
public void Analyze_Keyword_ReturnsIdentifierNode() { SyntaxNode root = new IdentifierNode("e"); root = SemanticAnalyzer.Analyze(root, new Environment()); Assert.AreEqual("e", root.ToString()); }
private void AssertNoErrors(ProgramNode program) { var analyzer = new SemanticAnalyzer(program, errors); analyzer.Analyze(); Assert.That(!errors.HasErrors); Assert.That(errors.HasErrors, Is.False); }
public void Analyze_NumberValue_ReturnsNumberNode() { SyntaxNode node = new NumberNode(1); node = SemanticAnalyzer.Analyze(node, new Environment()); Assert.AreEqual("1", node.ToString()); }
public void Analyze_FunctionUndefinedName_ThrowsException() { FunctionNode node = new FunctionNode(new IdentifierNode("f"), new List <SyntaxNode> { new NumberNode(2) }); Assert.Throws <UndefinedSymbolException>(() => SemanticAnalyzer.Analyze(node, new Environment())); }
public void Analyze_FunctionIllegalCallExpression_ThrowsException() { FunctionNode node = new FunctionNode(new IdentifierNode("ln"), new List <SyntaxNode> { new IdentifierNode("x") }); Assert.Throws <UndefinedSymbolException>(() => SemanticAnalyzer.Analyze(node, new Environment())); }
private void AssertErrorContains(ProgramNode program, string expectedError) { var analyzer = new SemanticAnalyzer(program, errors); analyzer.Analyze(); Assert.That(errors.HasErrors); var error = errors.GetErrors()[0]; Assert.That(error.ErrorMessage, Does.Contain(expectedError)); }
public void Analyze_AmbiguousPredefinedFunction_ReturnsFunctionNode() { IdentifierNode left = new IdentifierNode("sin"); SyntaxNode right = new NumberNode(1); SyntaxNode root = new FunctionOrDistributionNode(left, right); root = SemanticAnalyzer.Analyze(root, new Environment()); Assert.AreEqual("sin(1)", root.ToString()); }
public void Analyze_OperatorIllegalRHS_ThrowsException() { OperatorNode node = new OperatorNode(Operator.Addition, new List <SyntaxNode> { new NumberNode(2), new IdentifierNode("x") }); Assert.Throws <UndefinedSymbolException>(() => SemanticAnalyzer.Analyze(node, new Environment())); }
public void Analyze_RecognizeShorthandMultiplicationInsideIdentiferWithOneVariable_ReturnsOperatorNode() { SyntaxNode root = new IdentifierNode("xx"); Environment environment = new Environment(); environment.AddSymbol("x"); root = SemanticAnalyzer.Analyze(root, environment); Assert.AreEqual("x * x", root.ToString()); }
public void Analyze_VariableSymbol_ReturnsIdentifierNode() { SyntaxNode node = new IdentifierNode("x"); Environment environment = new Environment(); environment.AddSymbol("x"); node = SemanticAnalyzer.Analyze(node, environment); Assert.AreEqual("x", node.ToString()); }
public void Analyze_RecognizeShorthandMultiplicationInsideIdentifierWithPredefinedSymbols_ReturnsIdentifierNode() { SyntaxNode root = new IdentifierNode("xe"); Environment environment = new Environment(); environment.AddSymbol("x"); root = SemanticAnalyzer.Analyze(root, environment); Assert.AreEqual("x * e", root.ToString()); }
private bool Analyze(string[] s) { bool initOk = InitAnalyzer(s); if (!initOk) { return(false); } sa.Analyze(); return(true); }
public void Analyze_Parentheses_ReturnsParenthesesNode() { Environment environment = new Environment(); environment.AddSymbol("x"); SyntaxNode root = new ParenthesesNode(new IdentifierNode("x")); root = SemanticAnalyzer.Analyze(root, environment); Assert.AreEqual("(x)", root.ToString()); }
public void Analyze_Function_ReturnsFunctionNode() { SyntaxNode root = new FunctionNode(new IdentifierNode("ln"), new List <SyntaxNode> { new IdentifierNode("e") }); root = SemanticAnalyzer.Analyze(root, new Environment()); Assert.AreEqual("ln(e)", root.ToString()); }
public void Analyze_Operator_ReturnsOperatorNode() { SyntaxNode node = new OperatorNode(Operator.Addition, new List <SyntaxNode> { new NumberNode(2), new NumberNode(2) }); node = SemanticAnalyzer.Analyze(node, new Environment()); Assert.AreEqual("2 + 2", node.ToString()); }
public void Analyze_NegativeNumber_ReturnsNumberNode() { SyntaxNode node = new OperatorNode(Operator.Multiplication, new List <SyntaxNode> { new NumberNode(-1), new NumberNode(2) }); node = SemanticAnalyzer.Analyze(node, new Environment()); Assert.AreEqual("-2", node.ToString()); }
public void Analyze_Identifier_ThrowsUndefinedIdentifier() { SyntaxNode node = new IdentifierNode("x"); Environment environment = new Environment(); UndefinedSymbolException exception = Assert.Throws <UndefinedSymbolException>(() => { SemanticAnalyzer.Analyze(node, environment); }); Assert.NotNull(exception); Assert.AreEqual("Undefined symbol 'x'", exception.Message); }
public void Analyze_AmbigiousSymbolDistribution_ReturnsOperatorNode() { IdentifierNode left = new IdentifierNode("x"); SyntaxNode right = new NumberNode(1); SyntaxNode root = new FunctionOrDistributionNode(left, right); Environment environment = new Environment(); environment.AddSymbol("x"); root = SemanticAnalyzer.Analyze(root, environment); Assert.AreEqual("x * 1", root.ToString()); }
private static void Process(string text) { var lexer = new Lexer(text); var parser = new Parser(lexer); var tree = parser.Parse(); var semanticAnalyzer = new SemanticAnalyzer(); semanticAnalyzer.Analyze(tree); var interpreter = new InterpreterService.Interpreter(); interpreter.Interpret(tree); }
public void Analyze_AmbiguousVariable_ThrowsException() { IdentifierNode symbol = new IdentifierNode("xyz"); Environment environment = new Environment(); environment.AddSymbol("x"); environment.AddSymbol("y"); environment.AddSymbol("z"); environment.AddSymbol("xy"); environment.AddSymbol("yz"); AmbiguousIdentifierException exception = Assert.Throws <AmbiguousIdentifierException>(() => { SemanticAnalyzer.Analyze(symbol, environment); }); Assert.NotNull(exception); Assert.AreEqual("Ambiguous identifier 'xyz' can be made from 'x, y, z', 'x, yz', 'xy, z'", exception.Message); }
public Package CompilePackage( string name, IEnumerable <CodeFile> files, FixedDictionary <string, Package> references) { var lexer = new Lexer(); var parser = new CompilationUnitParser(); var compilationUnits = files .Select(file => { var context = new ParseContext(file, new Diagnostics()); var tokens = lexer.Lex(context).WhereNotTrivia(); return(parser.Parse(tokens)); }) .ToFixedList(); var packageSyntax = new PackageSyntax(name, compilationUnits); var analyzer = new SemanticAnalyzer(); return(analyzer.Analyze(packageSyntax, references)); }
public string CompileString(string source) { var sw = new Stopwatch(); Console.WriteLine("Parsing sources into tokens..."); sw.Start(); var tks = _tokenizer.Parse(source); sw.Stop(); Console.WriteLine("Parsed to tokens in {0}ms", sw.ElapsedMilliseconds); var ts = new TokenStream(tks); Console.WriteLine("Parsing tokens into AST..."); sw.Restart(); Ast = AstParser.Parse(ts); sw.Stop(); Console.WriteLine("Parsed to AST in {0}ms", sw.ElapsedMilliseconds); SemanticAnalyzer.Analyze(Ast); TypeChecker.Check(Ast); _program.AppendAst(Ast); return(_program.CompileToC()); }
private bool InitInterpreter(string[] s, IReader reader) { Dictionary <string, IProperty> ids = new Dictionary <string, IProperty> (); this.s = new Scanner(s); this.p = new Parser(ids); this.p.Scanner = this.s; SyntaxTree tree = this.p.Parse(); if (!this.p.SyntaxTreeBuilt) { return(false); } this.sa = new SemanticAnalyzer(tree, ids); sa.Analyze(); if (this.sa.getErrors().Count > 0) { return(false); } this.printer = new MockPrinter(); this.interpreter = new Interpreter(tree, this.printer, reader); return(true); }
public static void Compile(string[] files) { //Stopwatch sw = new Stopwatch(); //sw.Start(); Lexer lexer = new Lexer(); lexer.Scan(files); Parser parser = new Parser(); parser.Parse(files[0], lexer); SemanticAnalyzer analyzer = new SemanticAnalyzer(); analyzer.Analyze(); //sw.Stop(); //Console.WriteLine(sw.ElapsedMilliseconds); //Lexer.Next(); //while (Lexer.NextToken.Type != TokenType.EOF) //{ // Console.WriteLine(Lexer.NextToken); // Lexer.Next(); //} Console.ReadKey(); }
public void Analyze_Parentheses_ThrowsException() { ParenthesesNode node = new ParenthesesNode(new IdentifierNode("x")); Assert.Throws <UndefinedSymbolException>(() => SemanticAnalyzer.Analyze(node, new Environment())); }
private static void Main(string[] args) { var program = @"program MutualRecursion; function F (n : integer) : integer; begin if n = 0 then return 1 else return n - M (F (n-1)); end; function M (n : integer) : integer; begin if n = 0 then return 0 else return n - F (M (n-1)); end; {* comment still comment *} begin var i : integer; i := 0; while i <= 19 do begin writeln (F (i)); i := i + 1 end; i := 0; while i <= 19 do begin writeln (M (i)); i := i + 1 end; end. "; var program2 = @"program SwapAndSumThem; function Sum (data : array [] of integer) : integer; begin var i, sum : integer; i := 0; sum := 0; while i < data.size do begin sum := sum + data [i]; i := i + 1; end; return sum; end; procedure Swap (var i : integer, var j : integer); begin var tmp : integer; tmp := i; i := j; j := tmp; end; begin var A : array [2] of integer; read (A [0], A [1]); Swap (A[0], A [1]); writeln (A [0], A [1]); writeln (""Sum is "", sum (A)); end."; var program3 = @"program A; begin if (1 < 2) then if (2 < 3) then writeln(""jes"") else if (3 < 4) then writeln(""nou"") else writeln(""fwoop"") else writeln(""noh""); end."; var program4 = @"program GCD; begin var i, j : integer; read (i, j); while i <> j do if (i > j) then i := i - j else j := j - i; writeln (i); end."; var program5 = @"program StringArray; begin var A : array[3] of string; var i : integer; var c : string; while i < A.size do begin writeln(""string"", i); read(A[i]); i := i + 1; end; i := 0; while i < A.size do begin writeln(A[i]); i := i + 1 end; end."; var program6 = @"program Recursive; procedure A(depth : integer); begin writeln(""A"", depth); A(depth + 2); if depth > 0 then B(depth - 1); end; procedure B(depth : integer); begin writeln(""B"", depth); if depth > 0 then A(depth - 1); end; begin A(50); end. "; var program7 = @"program ArrayReturn; function reverse(data : array[] of integer): array[] of integer; begin var i : integer; i := 0; var B : array[data.size] of integer; while i < data.size do begin B[(data.size - 1) - i] := data[i]; i := i + 1; end; return B; end; begin var A : array[100] of integer; var i : integer; i := 0; while i < A.size do begin A[i] := i * 2; i := i + 1; end; var B : array[A.size] of integer; B := reverse(A); i := 0; while i < B.size do begin writeln(B[i]); i := i + 1; end end. "; var program8 = @"program BoolArray; begin var A : array[] of boolean; var B : array[] of integer; var C : array[10] of integer; var D : integer; D := 2 * (1 + 3); C[D] := 2; A[B[C[D]]] := true; read(B[0], C[0]); if (D < 6) or (C[D] > 1) then writeln(""yes"") end."; var program9 = @"program A; begin var a : string; a := +""kissa""; end. "; Context.ErrorService = new ErrorService(); Context.Source = Text.Of(program9); var s = new Scanner(); var p = new Parser(s); var v = (ProgramNode)p.BuildTree(); if (v == null || Context.ErrorService.HasErrors()) { Context.ErrorService.Throw(); } /* * TODO: * - check array sizes where the expression is possible to evaluate * - check for array type compatibility where array size is known */ var cfg = SemanticAnalyzer.Analyze(v); if (Context.ErrorService.HasErrors()) { Context.ErrorService.Throw(); } Console.WriteLine(v.AST()); /*Console.WriteLine(JsonConvert.SerializeObject(v, Formatting.Indented, new JsonSerializerSettings * { * ReferenceLoopHandling = ReferenceLoopHandling.Ignore * }));*/ Console.WriteLine(new Generator(cfg).Generate()); // Console.WriteLine(v.AST()); }