Example #1
0
        public override SchemeObject evaluate(ref SchemeAST currentAST, SchemeEvaluator evaluator)
        {
            var list = lookupSymbolsFromEnv(ref currentAST, evaluator.currentEnvironment);
            Debug.Assert(list[0].GetType() == typeof(SchemeBuiltinOr));

            if (list.Count < 3)
            {
                throw new SchemeWrongNumberOfArguments(String.Format("Too few arguments! and need at least 2 arguments. You specified: {0}", list.Count - 1));
            }

            try
            {
                foreach (SchemeBool value in list.GetRange(1, list.Count - 1))
                {
                    if (value == SchemeTrue.instance)
                    {
                        return SchemeTrue.instance;
                    }
                }
            }
            catch (InvalidCastException)
            {
                throw new SchemeInvalidArgumentException("Builtin Function OR expects SchemeInteger or SchemeFloat as parameter. Got something else.");
            }

            return SchemeFalse.instance;
        }
Example #2
0
        public override SchemeObject evaluate( ref SchemeAST currentAST, SchemeEvaluator evaluator )
        {
            var list = lookupSymbolsFromEnv( ref currentAST, evaluator.currentEnvironment );
            Debug.Assert( list[0].GetType() == typeof( SchemeBuiltinEquals ) );

            if( list.Count < 3 )
            {
                throw new SchemeWrongNumberOfArguments(String.Format("Too few arguments! SchemeEquals need at least 2 arguments. You specified: {0}", list.Count -1));
            }

            var firstVal = list[1];
            if( firstVal.GetType() != typeof( SchemeInteger ) )
            {
                throw new SchemeInvalidArgumentException( String.Format( "Invalid Argument Exception! SchemeEquals expects numbers as arugments. You provided: {0}", firstVal.GetType().ToString() ) );
            }

            try
            {
                foreach( SchemeInteger value in list.GetRange( 2, list.Count - 2 ) )
                {
                   if (! firstVal.Equals(value) )
                   {
                   return SchemeFalse.instance;
                   }
                }
            }
            catch( InvalidCastException )
            {
                throw new SchemeInvalidArgumentException( "Builtin Function Equals expects SchemeInteger or SchemeFloat as parameter. Got something else." );
            }

            return SchemeTrue.instance;
        }
Example #3
0
        public override SchemeObject evaluate( ref SchemeAST currentAST, SchemeEvaluator evaluator )
        {
            if( currentAST.children.Count != 2 )
            {
            throw new SchemeWrongNumberOfArguments(String.Format("Scheme Cons expects exactly 2  arguments. You have given me: {0}", currentAST.children.Count -1));
            }
            var objects = lookupSymbolsFromEnv( ref currentAST, evaluator.currentEnvironment );

            return new SchemeList( objects[1], objects[2] );
        }
Example #4
0
        public void schemeBuiltInEqualsTest()
        {
            SchemeReader reader = new SchemeReader();
            SchemeEvaluator eval = new SchemeEvaluator();

            var ast = reader.parseString("(= 1 2)");
            Assert.AreEqual(eval.evaluate(ast)[0], SchemeFalse.instance);

            ast = reader.parseString("(= 1 1)");
            Assert.AreEqual(eval.evaluate(ast)[0], SchemeTrue.instance);
        }
Example #5
0
        public void schemeBuiltinConsTest()
        {
            SchemeReader reader = new SchemeReader();
            SchemeEvaluator eval = new SchemeEvaluator();

            var ast = reader.parseString("(car (cons 10 11))");
            Assert.AreEqual(eval.evaluate(ast)[0], new SchemeInteger(10));

            ast = reader.parseString("(cdr (cons 10 11))");
            Assert.AreEqual(eval.evaluate(ast)[0], new SchemeInteger(11));
        }
Example #6
0
        public override SchemeObject evaluate( ref SchemeAST currentAST, SchemeEvaluator evaluator )
        {
            evaluator.currentEnvironment = _lambdaEnv;

            for( int i = 0; i < _params.Count; i++ )
            {
                var child = currentAST.children[i];
                if( child.currentObject.GetType() == typeof( SchemeSymbol ) )
                {
                    var val = evaluator.currentEnvironment.get( (SchemeSymbol) child.currentObject );

                    if( val == null )
                    {

                        val = evaluator.currentEnvironment.get( (SchemeSymbol) child.currentObject );

                        if( val == null )
                        {
                            throw new SchemeUndefinedSymbolException( String.Format( "Undefined Symbol!: {0}", child.currentObject ) );
                        }
                    }
                    evaluator.currentEnvironment.set( _params[i], val );
                }
                else
                {
                    evaluator.currentEnvironment.set( _params[i], (SchemeType) child.currentObject );
                }

            }

            var clonedImplementation = (SchemeAST) _implementation.Clone();

            var oldParent = currentAST.parent;
            var index = currentAST.parent.children.IndexOf( currentAST );
            currentAST.parent.children.Remove( currentAST );

            for( int i = 0; i < clonedImplementation.children.Count; i++ )
            {
                currentAST.parent.children.Insert( i + index, clonedImplementation.children[i] );
                clonedImplementation.children[i].parent = oldParent;

                if( i == clonedImplementation.children.Count - 1 )   // the last one being added
                {
                    currentAST.parent.children[i + index].hasOwnEnviornment = true; // set flag for enviornment switch
                }
            }

            currentAST = currentAST.parent.children[index];

            return null; //so ugly, but null means: to be evaluated again!
        }
Example #7
0
        public override SchemeObject evaluate( ref SchemeAST currentAST, SchemeEvaluator evaluator )
        {
            if( currentAST.children.Count < 2 || currentAST.children.Count > 3 )
            {
                throw new SchemeWrongNumberOfArguments( String.Format( "The If-statement expects 2 or 3 arguments (condition, branch1, branch2). You provided {0}", currentAST.children.Count - 1 ) );
            }

            _condition = currentAST.children[0];
            _trueBranch = currentAST.children[1];

            if( currentAST.children.Count == 3 )
            {
                _falseBranch = currentAST.children[2];
            }

            if( _condition.currentObject == SchemeTrue.instance )
            {
                var old_parent = currentAST.parent;
                _trueBranch.parent = currentAST.parent;

                int postition = currentAST.parent.children.IndexOf( currentAST );
                currentAST.parent.children.Remove( currentAST );
                currentAST.parent.children.Add( _trueBranch );

                currentAST = _trueBranch;
                return null;
            }

            if( _condition.currentObject == SchemeFalse.instance )
            {
                if( _falseBranch != null )
                {
                    var old_parent = currentAST.parent;
                    _falseBranch.parent = currentAST.parent;
                    int postition = currentAST.parent.children.IndexOf( currentAST );
                    currentAST.parent.children.Remove( currentAST );
                    currentAST.parent.children.Add( _falseBranch );
                    currentAST = _falseBranch;
                    return null;
                }
                else
                {
                    return SchemeVoid.instance;
                }
            }

            throw new SchemeInvalidArgumentException( String.Format( "Invalid Argument in If-condition: Your condtion has to evalue to either #t or #f, but it evaluated to {0}", _condition.ToString() ) );
        }
Example #8
0
        public override SchemeObject evaluate( ref SchemeAST currentAST, SchemeEvaluator evaluator )
        {
            if( currentAST.children.Count != 1 )
            {
                throw new SchemeWrongNumberOfArguments( String.Format( "Scheme cdr expects exactly on argument of type scheme cons. You have provided: {0}", currentAST.children.Count ) );
            }

            if( ! ( currentAST.children[0].currentObject.GetType() ==  typeof(SchemeList) ) )
            {
              throw new SchemeInvalidArgumentException( String.Format("Scheme cdr epects an arguement of type scheme cons. Your argument was: {0} of type{1}" , currentAST.children[0].ToString(), currentAST.children[0].GetType().ToString()));
            }

            var cons = (SchemeList) currentAST.children[0].currentObject;

            return cons.cdr;
        }
Example #9
0
        public override SchemeObject evaluate( ref SchemeAST currentAST, SchemeEvaluator evaluator )
        {
            if( currentAST.children.Count != _params.Count )
            {
                throw new SchemeWrongNumberOfArguments( String.Format( "Lambda expects exactly two arguments. You have given me: {0}", currentAST.children.Count ) );
            }

                    var tmp = _lambdaEnv.getClonedEnv(evaluator.currentEnvironment);
                    //_lambdaEnv.setParent(evaluator.currentEnvironment);
                       //evaluator.currentEnvironment = _lambdaEnv;

                    SchemeLambda lambda = new SchemeLambdaImpl(_implementation, _params, new SchemeEnvironment(tmp) );

            lambda.evaluate(ref currentAST, evaluator);
            return null;
        }
Example #10
0
        public void schemeHigherOrderFunctionTest()
        {
            SchemeReader reader = new SchemeReader();
            SchemeEvaluator eval = new SchemeEvaluator();

            var ast = reader.parseString( "(define scons (lambda (x y) (lambda (m) (m x y))))" );
            eval.evaluate( ast );
            ast = reader.parseString( "(define scar (lambda (z) (z (lambda (p q) p))))" );
            eval.evaluate( ast );
            ast = reader.parseString( "(scar (scons 10 11))" );

            Assert.AreEqual( new SchemeInteger( 10 ), eval.evaluate( ast )[0] );

            //Double evaluation Bug
            ast = reader.parseString( "(scar (scons 10 11))" );

            Assert.AreEqual( new SchemeInteger( 10 ), eval.evaluate( ast )[0] );
        }
Example #11
0
 public override SchemeObject evaluate( ref SchemeAST currentAST, SchemeEvaluator evaluator )
 {
     var list = lookupSymbolsFromEnv( ref currentAST, evaluator.currentEnvironment );
     Debug.Assert(list[0].GetType() == typeof(SchemeBuiltInPlus));
     int sum = 0;
     try
     {
         foreach( SchemeInteger summand in list.GetRange( 1, list.Count - 1 ) ) //all args, but not the current method object
         {
             sum += summand.value;
         }
     }
     catch( InvalidCastException )
     {
         throw new SchemeInvalidArgumentException("Builtin Function + expects SchemeInteger or SchemeFloat as parameter. Got something else.");
     }
     return new SchemeInteger( sum );
 }
Example #12
0
        public override SchemeObject evaluate( ref SchemeAST currentAST, SchemeEvaluator evaluator )
        {
            var list = lookupSymbolsFromEnv( ref currentAST, evaluator.currentEnvironment );
            Debug.Assert( list[0].GetType() == typeof( ScehemBuiltinModulo ) );

            if( list.Count != 3 )
            {
            throw new SchemeWrongNumberOfArguments(String.Format("Invalid number of Arguments specified! Builtinfunction modulo expects exactly two parametrs. you specified: {0}", list.Count -1));
            }
            int mod = 0;
            try
            {
              mod = ((SchemeInteger) list[1]).value % ((SchemeInteger) list[2]).value;
            }
            catch( InvalidCastException )
            {
                throw new SchemeInvalidArgumentException( "Builtin Function + expects SchemeInteger or SchemeFloat as parameter. Got something else." );
            }
            return new SchemeInteger( mod );
        }
Example #13
0
        public override SchemeObject evaluate( ref SchemeAST currentAST, SchemeEvaluator evaluator )
        {
            if( currentAST.children.Count != 2 )
            {
                throw new SchemeWrongNumberOfArguments( String.Format( "Wrong number of arguments!'define' expects exactly two arguments. You provided: {0}", currentAST.children.Count ) );
            }

                var param = currentAST.children[1];

                SchemeObject value;
            if( param.currentObject.GetType() == typeof( SchemeSymbol ) )
            {
                 value = lookupSymbolsFromEnv( ref param, evaluator.currentEnvironment )[0];
            }
            else
            {
                 value = param.currentObject;
            }

            evaluator.currentEnvironment.set( (SchemeSymbol) currentAST.children[0].currentObject, (SchemeType) value );

            return SchemeVoid.instance;
        }
Example #14
0
        public void schemeBuiltInLambdaTest()
        {
            SchemeReader reader = new SchemeReader();
            SchemeEvaluator eval = new SchemeEvaluator();

            var ast = reader.parseString( "(define add (lambda (num1 num2)(+ num1 num2)))" );
            eval.evaluate( ast );
            ast = reader.parseString( "(add 1 2)" );

            Assert.AreEqual( eval.evaluate( ast )[0], new SchemeInteger( 3 ) );

            ast = reader.parseString( "(define foo (lambda () (+ 1 2))) " );
            eval.evaluate( ast );
            ast = reader.parseString( "(foo)" );
            Assert.AreEqual( eval.evaluate( ast )[0], new SchemeInteger( 3 ) );

            ast = reader.parseString( "(define bar (lambda (a b) (add a b))" );
            eval.evaluate( ast );

            ast = reader.parseString( "(bar 1 2)" );
            Assert.AreEqual( eval.evaluate( ast )[0], new SchemeInteger( 3 ) );

            ast = reader.parseString( "(bar (+ 1 2) 2)" );
            Assert.AreEqual( eval.evaluate( ast )[0], new SchemeInteger( 5 ) );

            ast = reader.parseString( "(define bar (lambda (a) (if (= a 10) a (+ (bar (+ a 1)) 1 ))))" );
            eval.evaluate( ast );

            ast = reader.parseString( "(bar 1)" );
            Assert.AreEqual( eval.evaluate( ast )[0], new SchemeInteger( 19 ) );
            ast = reader.parseString( "(define foo (lambda (a) (if (= a 10) a (foo (+ a 1)))))" );
            eval.evaluate( ast );

            ast = reader.parseString( "(foo 1)" );
            Assert.AreEqual( eval.evaluate( ast )[0], new SchemeInteger( 10 ) );
        }
Example #15
0
 public virtual SchemeObject evaluate(ref SchemeAST currentAST, SchemeEvaluator evaluator)
 {
     Debug.Assert( false, "Should never be called!" );
     return null;
 }
Example #16
0
        public void schemeSetTest()
        {
            SchemeReader reader = new SchemeReader();
            SchemeEvaluator eval = new SchemeEvaluator();

            var defineSingletonSet = reader.parseString( "(define singletonSet (lambda (x) (lambda (y) (= y x))))" );
            var defineContains = reader.parseString( "(define contains (lambda (set_ y) (set_ y)))" );
            var defineTestSets = reader.parseString( "(define s1 (singletonSet 1)) (define s2 (singletonSet 2))" +
                   "(define s1 (singletonSet 1)) " +
                    "(define s2 (singletonSet 2)) "  +
                    "(define s3 (lambda (x) (and (>= x 5) (<= x 15))))" +
                    "(define s4 (lambda (x) (and (<= x -5) (>= x -15))))" +
                  ")");

            var test1 = reader.parseString("(contains s1 1)");
            var test2 = reader.parseString("(contains s2 2)");
            var test3 = reader.parseString("(contains s3 5)");
            var test4 = reader.parseString("(contains s4 -5)");
            var test5 = reader.parseString("(contains s4 -22)");

            eval.evaluate( defineSingletonSet );
            eval.evaluate( defineContains );
            eval.evaluate( defineTestSets );

            Assert.AreEqual( SchemeTrue.instance, eval.evaluate( test1 )[0] );
            Assert.AreEqual( SchemeTrue.instance, eval.evaluate( test2 )[0] );
            Assert.AreEqual( SchemeTrue.instance, eval.evaluate( test3 )[0] );
            Assert.AreEqual( SchemeTrue.instance, eval.evaluate( test4 )[0] );
            Assert.AreEqual( SchemeFalse.instance, eval.evaluate( test5 )[0] );
        }
Example #17
0
        public void schemeBuiltinIfTest()
        {
            SchemeReader reader = new SchemeReader();
            SchemeEvaluator eval = new SchemeEvaluator();

            var ast = reader.parseString("(if (= 1 1) 1 2)");
            Assert.AreEqual(eval.evaluate(ast)[0], new SchemeInteger(1));

            ast = reader.parseString("(if (= 1 2) 1 2)");
            Assert.AreEqual(eval.evaluate(ast)[0], new SchemeInteger(2));
        }
Example #18
0
        public void schemeBuiltInPlusTest()
        {
            SchemeReader reader = new SchemeReader();
            SchemeEvaluator eval = new SchemeEvaluator();

            var ast = reader.parseString("(+ 32 8)");
            Assert.AreEqual(new SchemeInteger(40), eval.evaluate(ast)[0]);
        }
Example #19
0
        public void schemeBuiltinModuloTest()
        {
            SchemeReader reader = new SchemeReader();
            SchemeEvaluator eval = new SchemeEvaluator();

            var ast = reader.parseString("(modulo 7 3");
            Assert.AreEqual(eval.evaluate(ast)[0], new SchemeInteger(1));
        }
Example #20
0
 public override SchemeObject evaluate( ref SchemeAST currentAST, SchemeEvaluator evaluator )
 {
     return new SchemeLambdaTemplate( currentAST, evaluator.currentEnvironment );     // The current class is only a wrapper for the lambda keyword. This call creates the new SchemeLambda Object
 }
Example #21
0
        /*  public SchemeObject evaluate( ref SchemeAST currentAST, ISchemeEnvironment env )
        {
            this.currentAST = currentAST;
            this.environment = env;

            //syntax like define is a special case where we don't want the expresisons to be evaluated!
            if( handleSyntax() )
            {
                return SchemeVoid.instance;
            }
            else
            {
                var methodObjects = lookupSymbolsFromEnv();
                return evaluateInternal( methodObjects.GetRange( 1, methodObjects.Count - 1 ) );
            }

        }   */
        public abstract SchemeObject evaluate(ref SchemeAST currentAST, SchemeEvaluator evaluator );