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());
}
