public void AstWithNestedExpressions()
{
var test = @"(3 + ((1 + 2) + 1));";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
var expr = (ast.ScopedStatements[0] as Expr);
}
public void AstWithExpressionFailure()
{
var test = @"int z = 1;
{
int y = 5 + 4{;
}
x = 1 + 2 ^ (5-7);";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse();
}
public void AstWithExpression()
{
var test = @"x = 1 + 2;";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
var expr = (ast.ScopedStatements[0] as Expr);
Assert.IsTrue(expr.Left.Token.TokenType == TokenType.Word);
Assert.IsTrue((expr.Right as Expr).Left.Token.TokenValue == "1");
Assert.IsTrue((expr.Right as Expr).Right.Token.TokenValue == "2");
Assert.IsTrue((expr.Right as Expr).Token.TokenValue == "+");
Assert.IsTrue((expr.Right as Expr).Token.TokenType == TokenType.Plus);
}
static void Main(string[] args)
{
var files = new List<string> (args).Where (File.Exists);
var str = files.Select (File.ReadAllText)
.Aggregate (string.Empty, (acc, item) => acc + Environment.NewLine + item);
if (String.IsNullOrWhiteSpace (str)) {
Console.WriteLine ("No available files for compilation");
return;
}
var ast = new LanguageParser(new Lexer(str)).Parse();
new InterpretorVisitor().Start(ast);
}
public void AstWithExpression2()
{
var test = @"int z = 1;
{
int y = 5 + 4;
}
x = 1 + 2 ^ (5-7);";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
Assert.IsTrue(ast.ScopedStatements.Count == 3);
Assert.IsTrue(ast.ScopedStatements[0] is VarDeclrAst);
Assert.IsTrue(ast.ScopedStatements[1].Token.TokenType == TokenType.ScopeStart);
Assert.IsTrue(ast.ScopedStatements[2] is Expr);
Console.WriteLine(ast);
}
public void TestExpressionInterpreterUndeclaredVar()
{
var test = @"
int x = 100 + 1;
z = 4;
print (x + 2 + (3 + 4));";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse();
new InterpretorVisitor().Start(ast);
}
public void TestExpressionInterpreterFunctionArguments()
{
var test = @"
void foo(int x){
if(x > 2){
print ((x + 1) + 2);
}
else{
print (x);
}
}
foo(1);
foo(100);";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse();
new InterpretorVisitor().Start(ast);
}
public void InvalidForwardReferences()
{
var test = @"
int x = y;
int y = 0;
";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void TestLambdaAssignments()
{
var test = @"
int arg = 5;
var x = fun(int arg) -> {
int g = arg;
while(g > 0){
print g;
g = g - 1;
}
print ""done!"";
}
var y = x;
var z = y;
z(5);
print ""lambda assignments work!"";
z(3);
int a = 1;
int b = a;
int c = b;
print c;
print arg;";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void TestInvalidReturnTypes()
{
var test = @"
int foo(string t){
var x = ""test"";
return x + t;
}
print foo(""pong"");";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void TestFunctionInvalidTypeParamters()
{
var test = @"
var func(string printer, int x){
print printer;
print x;
}
func(""asdf"", ""asdf"");
";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void TestForwardReferences3()
{
var test = @"
print item;
string item = func(""test"");
var func(string printer){
return ""yes"";
}
";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void TestBools()
{
var test = @"
var x = true & false || true;
while(x){
print x;
x = 1 > 2;
}
print x;";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void TestArgumentInferWithLambdasAsMethodPassing()
{
var test = @"
var func(method printer, method printer2){
print printer();
printer2();
}
var x = fun() -> { print 'test'; return 1; };
func(x,x);
";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void TestAssingingVariableToVariable()
{
var test = @"
var x = true;
var y = x;
print y;
print x;
y = false;
print y;
print x;
";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void TestArgumentInferInvalid()
{
var test = @"
var func(method printer, method printer1){
printer(1);
printer1();
}
var x = fun() -> { print 'test'; };
var curry = func(x);
curry(x);
";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void TestArgumentInferAndTypeCheckWithLambdasAsMethods()
{
var test = @"
var func(method printer, method printer2){
print printer();
printer2();
}
var x = fun() -> { print 'x'; return 1; };
var two = fun() -> { print 'two function'; };
var three = fun() -> { print 'three function'; };
var z = func(x);
z(two);
z(three);
";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void WhileTest()
{
var test = @"while(1 + 1){
var x = fun () ->{
test = 0;
};
}
";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse();
var topScope = (ast as ScopeDeclr).ScopedStatements[0];
var conditional = topScope as WhileLoop;
Assert.IsTrue(conditional != null);
Assert.IsTrue(conditional.Body != null);
Assert.IsTrue(conditional.Predicate.Token.TokenType == TokenType.Plus);
Assert.IsTrue(conditional.Body.ScopedStatements.Count == 1);
Assert.IsTrue(conditional.Body.ScopedStatements.First() is VarDeclrAst);
Assert.IsTrue((conditional.Body.ScopedStatements.First() as VarDeclrAst).VariableValue is MethodDeclr);
}
public void TestForLoop()
{
var test = @"
for(int i = 0;i < 10; i = i + 1){
i = 15;
print i;
}";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void TestWhileLoop()
{
var test = @"
int x = 5;
while(x > 0){
print x;
x = x - 1;
}
print ""done!"";";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void ConditionalTest()
{
var test = @"if(foo){
var x = 1;
}
else if(faa){
var y = 2;
var z = 3;
}
else{
}
";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse();
var topScope = (ast as ScopeDeclr).ScopedStatements[0];
var conditional = topScope as Conditional;
Assert.IsTrue(conditional != null);
Assert.IsTrue(conditional.Alternate != null);
Assert.IsTrue(conditional.Predicate.Token.TokenValue == "foo");
Assert.IsTrue(conditional.Alternate.Body.ScopedStatements.Count == 2);
Assert.IsTrue(conditional.Alternate.Alternate != null);
}
public void TestCurrying()
{
var test = @"
void func(string printer, int y){
print printer;
print y;
}
var curry = func('guy');
int x = 1;
curry(x);
curry(2);
var otherCurry = func('girl');
otherCurry(3);
";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void TestFunctionInternalsBeingForwardReferences()
{
var test = @"
var func(string printer){
return foo(printer);
}
var foo(string printer){
return printer + ""foo"";
}
print func(""zing"");
";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void TestVisitor()
{
var test = @"while(1 + 1){
var x = fun () ->{
test = 0;
return 1;
};
}
if(foo){
var x = 1;
}
else if(faa){
var y = 2;
var z = 3;
}
else{
for(int i = 0; i < 10; i = i + 1){
var x = z;
}
}
";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse();
new PrintAstVisitor().Start(ast);
}
public void TestInvalidAssignment2()
{
var test = @"
int x = func();
string func(){
return ""test"";
}
";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void TestCurryingInvalidArguments()
{
var test = @"
var func(string printer, int x){
print printer;
print x;
}
var curry = func(1);
curry(1);
curry(2);
var otherCurry = func(""test"");
otherCurry(3);
";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void TestInvalidTypeAssignment()
{
var test = @"
int x = 1.0;
";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
new InterpretorVisitor().Start(ast);
}
public void TestExpressionInterpreter()
{
var test = @"
int x = 100 + 1;
void foo(){
print (1 + 1);
}
print (x + 2 + (3 + 4));
foo();
foo();";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse();
new InterpretorVisitor().Start(ast);
}
public void TestTypeResolutionUserDefined()
{
var test = @"
int x = 100 + 1;
T y;
var z = 1 > 2;";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse() as ScopeDeclr;
var scopeBuilder = new ScopeBuilderVisitor();
scopeBuilder.Start(ast);
var typeResolver = new ScopeBuilderVisitor(true);
typeResolver.Start(ast);
Assert.IsTrue(ast.ScopedStatements[0].AstSymbolType is BuiltInType);
Assert.IsTrue(ast.ScopedStatements[1].AstSymbolType is UserDefinedType);
Assert.IsTrue(ast.ScopedStatements[2].AstSymbolType is BuiltInType);
Assert.IsTrue((ast.ScopedStatements[2].AstSymbolType as BuiltInType).ExpressionType == ExpressionTypes.Boolean);
}
public void InvalidConditionalTest()
{
var test = @"else(foo){
var x = 1;
}";
var ast = new LanguageParser(new Lexers.Lexer(test)).Parse();
}
