Esempio n. 1
0
def test_function_call_unknown_arguments_1(): #IGNORE:C01111
    msg = 'Test expression evaluation (calling built in functions), unknown arguments'
    #skip_test(msg)
    print msg
    
    from freeode.interpreter import (IModule, ExecutionEnvironment, 
                                     Interpreter, signature, 
                                     IFloat, RoleVariable, istype, test_allknown)
    from freeode.ast import NodeFuncCall, NodeIdentifier
    from freeode.util import aa_make_tree
    import math
    
    #create module where the function lives
    mod = IModule()
    #create sqrt function that can be called from Siml
    @signature([IFloat], IFloat)
    def sqrt(x): 
        test_allknown(x)
        return IFloat(math.sqrt(x.value))
    #put function into module
    mod.sqrt = sqrt
    print
    print 'Module where function is located: --------------------------------------------'
    #print aa_make_tree(mod)
    
    #create environment for lookup of variables (stack frame)
    env = ExecutionEnvironment()
    env.global_scope = mod
    #create visitor for evaluating the expression
    intp = Interpreter()
    intp.push_environment(env) 
    
    #create a Siml value as function argument
    val_1 = IFloat()    
    val_1.__siml_role__ = RoleVariable
    #create function call with unkown argument
    call = NodeFuncCall(NodeIdentifier('sqrt'), [val_1], {})
    
    #evaluate the function call
    ret_val = intp.eval(call)
    print
    print 'Result object: --------------------------------------------------------------'
    print aa_make_tree(ret_val)
    #evaluating a function call with unknown arguments must return a function call
    assert isinstance(ret_val, NodeFuncCall)
    assert istype(ret_val, IFloat)
Esempio n. 2
0
def test_expression_evaluation_5(): #IGNORE:C01111
    msg = \
    '''
    Test expression evaluation (returning of partially evaluated expression 
    when accessing variables)
    '''
    #skip_test(msg)
    print msg

    from freeode.ast import RoleVariable, NodeFuncCall
    from freeode.interpreter import (IModule, IFloat, ExecutionEnvironment, 
                                     Interpreter, istype)
    import freeode.simlparser as simlparser
    from freeode.util import func #, aa_make_tree
    
    #parse the expression
    ps = simlparser.Parser()
    ex = ps.parseExpressionStr('a + 2*2')
#    print
#    print 'AST (parser output): -----------------------------------------------------------'
#    print aa_make_tree(ex)
    
    #create module where name lives
    mod = IModule()
    #create attribute 'a' with no value
    val_2 = IFloat()
    val_2.__siml_role__ = RoleVariable
    mod.a = val_2
#    print
#    print 'Module where variable is located: --------------------------------------------'
#    print aa_make_tree(mod)
    
    #create environment for lookup of variables (stack frame)
    env = ExecutionEnvironment()
    env.global_scope = mod
    
    #interpret the expression
    intp = Interpreter()
    intp.environment = env
    res = intp.eval(ex)
#    print
#    print 'Result object - should be an unevaluated expression: --------------------------------------------------------------'
#    print aa_make_tree(res)
    assert isinstance(res, NodeFuncCall)
    assert res.function is func(IFloat.__add__)
    assert istype(res, IFloat)
Esempio n. 3
0
def test_expression_evaluation_4(): #IGNORE:C01111
    msg = 'Test expression evaluation (calling built in functions)'
    #skip_test(msg)
    print msg

    from freeode.interpreter import (IModule, ExecutionEnvironment,
                                     Interpreter, signature, IFloat)
    from freeode.util import aa_make_tree
    import freeode.simlparser as simlparser
    
    import math
    
    #parse the expression
    ps = simlparser.Parser()
    ex = ps.parseExpressionStr('sqrt(2)')
    print
    print 'AST (parser output): -----------------------------------------------'
    #print aa_make_tree(ex) 
    
    #create module where names live
    mod = IModule()
    #create sqrt function that can be called from Siml
    @signature([IFloat], IFloat)
    def sqrt(x): 
        return IFloat(math.sqrt(x.value))
    #put function into module
    mod.sqrt = sqrt
    print
    print 'Module where function is located: ----------------------------------'
    #print aa_make_tree(mod) 
    
    #create environment for lookup of variables (stack frame)
    env = ExecutionEnvironment()
    env.global_scope = mod
    #create visitor for evaluating the expression
    intp = Interpreter()
    intp.push_environment(env)
    #evaluate the expression
    res = intp.eval(ex)
    print
    print 'Result object: -----------------------------------------------------'
    print aa_make_tree(res)  
    assert res.value == math.sqrt(2)
Esempio n. 4
0
def test_SimlFunction_3(): #IGNORE:C01111
    msg = \
'''
Test SimlFunction: storage of local variables during code collection.
User defined functions are created without parser.
'''
    #skip_test(msg)
    print msg
    
    from freeode.interpreter import (Interpreter, SimlFunction, IModule,
                                     Signature, IFloat)
    from freeode.ast import NodeFuncArg
    from freeode.util import DotName #, aa_make_tree 
    

    #create the interpreter 
    intp = Interpreter()        
    
    #create a Siml value as function argument
    val_1 = IFloat(1)

    #create a function without statements (impossible in Siml)
    # func test(a:Float):
    #     ** nothing **
    f1 = SimlFunction('test', Signature([NodeFuncArg('a', IFloat)]), 
                      statements=[], global_scope=intp.built_in_lib, loc=None,
                      dot_name=DotName('test_module.test'))
    #create module where the function lives
    mod1 = IModule()
    mod1.test = f1
    
    #call with existing value
    # and set interpreter up to collect code. In this mode local variables of all 
    # functions must become algebraic variables of the simulation object.
    intp.start_collect_code()
    intp.apply(f1, (val_1,))
    _stmts, fn_locals = intp.stop_collect_code()
    
    #print aa_make_tree(fn_locals)
    
    #The function argument 'a' must appear in the storage for local variables
    assert fn_locals.test.i1.a is val_1
Esempio n. 5
0
def test_expression_evaluation_3(): #IGNORE:C01111
    msg = 'Test expression evaluation (access to variables)'
    #skip_test(msg)
    print msg

    from freeode.interpreter import (IModule, IFloat,  
                                     Interpreter, ExecutionEnvironment)
    import freeode.simlparser as simlparser
    
    #parse the expression
    ps = simlparser.Parser()
    ex = ps.parseExpressionStr('1 + a * 2')
    print
    print 'AST (parser output): -----------------------------------------------------------'
    print ex
    
    #create module where name lives
    mod = IModule()
    val_2 = IFloat(2.0)
    mod.a = val_2
    print
    print 'Module where variable is located: --------------------------------------------'
    print mod
    
    #create environment for lookup of variables (stack frame)
    env = ExecutionEnvironment()
    env.global_scope = mod
    
    #interpret the expression
    intp = Interpreter()
    intp.push_environment(env)
    res = intp.eval(ex)
    print
    print 'Result object: --------------------------------------------------------------'
    print res 
    assert res.value == 5.0