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; }
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; }
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] ); }
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); }
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)); }
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! }
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() ) ); }
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; }
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; }
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] ); }
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 ); }
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 ); }
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; }
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 ) ); }
public virtual SchemeObject evaluate(ref SchemeAST currentAST, SchemeEvaluator evaluator) { Debug.Assert( false, "Should never be called!" ); return null; }
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] ); }
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)); }
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]); }
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)); }
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 }
/* 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 );