public void TestEqualsExpressions()
        {
            Program prog;

            string app = "var i : bool := true = false;";
            SemanticAnalyser semanticAnalyser = new SemanticAnalyser (new Parser (new Scanner (app)).Parse ());
            semanticAnalyser.Run ();
            Assert.AreEqual (0, semanticAnalyser.Errors.Count);

            app = "var i : bool := \"a\" = \"b\";";
            semanticAnalyser = new SemanticAnalyser (new Parser (new Scanner (app)).Parse ());
            semanticAnalyser.Run ();
            Assert.AreEqual (0, semanticAnalyser.Errors.Count);

            app = "var i : bool := 1 = 1;";
            semanticAnalyser = new SemanticAnalyser (new Parser (new Scanner (app)).Parse ());
            semanticAnalyser.Run ();
            Assert.AreEqual (0, semanticAnalyser.Errors.Count);

            app = "var i : bool := \"this fails\" = true;";
            prog = new Parser (new Scanner (app)).Parse ();
            semanticAnalyser = new SemanticAnalyser (prog);
            semanticAnalyser.Run ();

            Assert.AreEqual (1, semanticAnalyser.Errors.Count);
        }
 public void TestAssignWrongTypeOfValue()
 {
     // X is string, can't assign int value to it
     string app = "var X : string := 4 + (2 * 2);\n" +
         "print X;";
     Parser parser = new Parser (new Scanner (app));
     SemanticAnalyser semanticAnalyser = new SemanticAnalyser (parser.Parse ());
     semanticAnalyser.Run ();
     Assert.AreEqual (1, semanticAnalyser.Errors.Count);
 }
 public void TestAssignWrongTypeOfValueForAlreadyDeclaredVar()
 {
     // X is string, can't assign int value to it
     string app = "var X : int := 4;\n" +
         "X := \"ERROR\";";
     Parser parser = new Parser (new Scanner (app));
     SemanticAnalyser semanticAnalyser = new SemanticAnalyser (parser.Parse ());
     semanticAnalyser.Run ();
     Assert.AreEqual (1, semanticAnalyser.Errors.Count);
 }
 public void TestArithmeticOperationOnBoolAndInt()
 {
     // can't do Bool * Int
     string app = "var X : int := 4 + (true * 2);\n" +
         "print X;";
     Parser parser = new Parser (new Scanner (app));
     SemanticAnalyser semanticAnalyser = new SemanticAnalyser (parser.Parse ());
     semanticAnalyser.Run ();
     Assert.AreEqual (1, semanticAnalyser.Errors.Count);
 }
        public void TestAndExpressions()
        {
            Program prog;

            string app = "var i : bool := true & false;";
            prog = new Parser (new Scanner (app)).Parse ();
            SemanticAnalyser semanticAnalyser = new SemanticAnalyser (prog);
            semanticAnalyser.Run ();
            Assert.AreEqual (0, semanticAnalyser.TypeStack.Count);

            app = "var i : bool := true & 2;";
            semanticAnalyser = new SemanticAnalyser (new Parser (new Scanner (app)).Parse ());

            semanticAnalyser.Run ();
            Assert.AreEqual (0, semanticAnalyser.TypeStack.Count);
            Assert.AreEqual (1, semanticAnalyser.Errors.Count);
        }
        public static void Main(string[] args)
        {
            StreamReader charStream;
            string filePath;

            try {
                filePath = args [0];
            } catch (IndexOutOfRangeException) {
                Console.WriteLine ("Please give the file path as the first argument, such as ~/code.txt");
                return;
            }

            try {
                charStream = File.OpenText (filePath);
            } catch (System.IO.FileNotFoundException) {
                Console.WriteLine("File \"" + filePath + "\" was not found. Make sure to give a proper file path as the argument.");
                return;
            }

            Parser parser = new Parser (new Scanner (charStream));
            Program program = parser.Parse ();
            SemanticAnalyser semanticAnalyser = new SemanticAnalyser (program);
            semanticAnalyser.Run ();
            InterpreterVisitor interpreterVisitor = new InterpreterVisitor (program);

            if (parser.Errors.Count == 0 && semanticAnalyser.Errors.Count == 0) {
                interpreterVisitor.Run ();
            } else {
                // Combine the lists of errors, sort them by row and column and print them to Console
                List<Error> errors = parser.Errors;
                errors.AddRange (semanticAnalyser.Errors);
                errors = errors.OrderBy (e => e.Row).ThenBy (e => e.Column).ToList ();

                foreach (Error e in errors) {
                    System.Console.WriteLine (e.Print ());
                }
            }
        }
 public void TestReadVariableMustBeDeclared()
 {
     string app =
         "read n;";
     Parser parser = new Parser (new Scanner (app));
     SemanticAnalyser semanticAnalyser = new SemanticAnalyser (parser.Parse ());
     semanticAnalyser.Run ();
     Assert.AreEqual (1, semanticAnalyser.Errors.Count);
 }
 public void TestTypestackEmptyAfterFor()
 {
     string app =
         "var n : int := 3;\n" +
         "var v : int := 1;\n" +
         "var i : int;\n" +
         "for i in 1..n do\n" +
         "v := v * i;\n" +
         "end for;\n";
     Parser parser = new Parser (new Scanner (app));
     SemanticAnalyser semanticAnalyser = new SemanticAnalyser (parser.Parse ());
     semanticAnalyser.Run ();
     Assert.AreEqual (0, semanticAnalyser.TypeStack.Count);
 }
 public void TestSymbolAlreadyExists()
 {
     // can't declare other variable named X
     string app = "var X : int := 4 + (2 * 2);\n" +
         "var X : int := 4;";
     Parser parser = new Parser (new Scanner (app));
     SemanticAnalyser semanticAnalyser = new SemanticAnalyser (parser.Parse ());
     semanticAnalyser.Run ();
     Assert.AreEqual (1, semanticAnalyser.Errors.Count);
 }
 public void TestRelationalExpressionOnlyForIntValues()
 {
     // if relational expression, then both of the operands must be integers
     string app = "print \"error\" < 5;";
     Parser parser = new Parser (new Scanner (app));
     SemanticAnalyser semanticAnalyser = new SemanticAnalyser (parser.Parse ());
         semanticAnalyser.Run ();
     Assert.AreEqual (1, semanticAnalyser.Errors.Count);
 }
 public void TestTypestackEmptyAfterRead()
 {
     string app =
         "var n : int;\n" +
         "read n;";
     Parser parser = new Parser (new Scanner (app));
     SemanticAnalyser semanticAnalyser = new SemanticAnalyser (parser.Parse ());
     semanticAnalyser.Run ();
     Assert.AreEqual (0, semanticAnalyser.TypeStack.Count);
     Assert.AreEqual (0, semanticAnalyser.Errors.Count);
 }
 public void TestTypestackEmptyForExampleApp()
 {
     string app =
         "print \"Give a number\";\n" +
         "var n : int;\n" +
         "read n;\n" +
         "var v : int := 1;\n" +
         "var i : int;\n" +
         "for i in 1..n do\n" +
         "v := v * i;\n" +
         "end for;\n" +
         "print \"The result is: \";\n" +
         "print v;";
     Parser parser = new Parser (new Scanner (app));
     SemanticAnalyser semanticAnalyser = new SemanticAnalyser (parser.Parse ());
     semanticAnalyser.Run ();
     Assert.AreEqual (0, semanticAnalyser.TypeStack.Count);
 }
 public void TestTypestackEmptyAfterPrints()
 {
     string app =
         "var v : int := 1;\n" +
         "print \"Give a number\";\n" +
         "print \"The result is: \";\n" +
         "print v;";
     Parser parser = new Parser (new Scanner (app));
     SemanticAnalyser semanticAnalyser = new SemanticAnalyser (parser.Parse ());
     semanticAnalyser.Run ();
     Assert.AreEqual (0, semanticAnalyser.TypeStack.Count);
 }
        public void TestRangeContainsString()
        {
            // if relational expression, then both of the operands must be integers
            string app =
                "var n : string := \"SEMANTIC ERROR\";\n" +
                "var v : int := 1;\n" +
                "var i : int;\n" +
                "for i in 1..n do\n" +
                "v := v * i;\n" +
                "end for;\n";
            Parser parser = new Parser (new Scanner (app));
            SemanticAnalyser semanticAnalyser = new SemanticAnalyser (parser.Parse ());

                semanticAnalyser.Run ();
            Assert.AreEqual (1, semanticAnalyser.Errors.Count);
        }
 public void TestNoKeyNotFoundException()
 {
     string app = "print \"test\";" +
                  "var x : int = \"lol\";" +
                  "var y : int = x;" +
                  "print y;";
     SemanticAnalyser semanticAnalyser = new SemanticAnalyser (new Parser (new Scanner (app)).Parse ());
     semanticAnalyser.Run ();
 }
 public void TestTypestackEmptyAfterExpression()
 {
     string app =
         "var X : int := 1 * 2 + 3 * 4 + 5 * 6;";
     Parser parser = new Parser (new Scanner (app));
     SemanticAnalyser semanticAnalyser = new SemanticAnalyser (parser.Parse ());
     semanticAnalyser.Run ();
     Assert.AreEqual (0, semanticAnalyser.TypeStack.Count);
     Assert.AreEqual (0, semanticAnalyser.Errors.Count);
 }
 public void TestTypestackEmptyAfterDeclarations()
 {
     string app =
         "var v : int := 1;\n" +
         "var i : int;\n";
     Parser parser = new Parser (new Scanner (app));
     SemanticAnalyser semanticAnalyser = new SemanticAnalyser (parser.Parse ());
     semanticAnalyser.Run ();
     Assert.AreEqual (0, semanticAnalyser.TypeStack.Count);
 }
 public void TestTypestackEmptyAfterPrint()
 {
     string app =
         "print \"Give a number\";";
     Parser parser = new Parser (new Scanner (app));
     SemanticAnalyser semanticAnalyser = new SemanticAnalyser (parser.Parse ());
     semanticAnalyser.Run ();
     Assert.AreEqual (0, semanticAnalyser.TypeStack.Count);
     Assert.AreEqual (0, semanticAnalyser.Errors.Count);
 }
        public void TestNotExpressions()
        {
            string app = "var i : bool := !true;";
            SemanticAnalyser semanticAnalyser = new SemanticAnalyser (new Parser (new Scanner (app)).Parse ());
            semanticAnalyser.Run ();
            Assert.AreEqual (0, semanticAnalyser.Errors.Count);

            app = "var i : bool := !(2 = 2);";
            semanticAnalyser = new SemanticAnalyser (new Parser (new Scanner (app)).Parse ());
            semanticAnalyser.Run ();
            Assert.AreEqual (0, semanticAnalyser.Errors.Count);

            app = "var i : bool := !2;";
            semanticAnalyser = new SemanticAnalyser (new Parser (new Scanner (app)).Parse ());
            semanticAnalyser.Run ();
            Assert.AreEqual (1, semanticAnalyser.Errors.Count);
        }