Esempio n. 1
0
    def test_load_procedure(self):
        from serval.lexer import Lexer
        from serval.parser import Parser
        from serval.interpreter import Interpreter
        from serval.expression.util import load

        interp = Interpreter()
        filepath = os.path.join(
            os.path.dirname(os.path.abspath(__file__)), 'data', 'test.ss')
        expr = Parser(Lexer('(load "%s")' % filepath)).parse()[0]
        load(interp, expr)

        expr = Parser(Lexer('c')).parse()[0]
        result = interp.interpret(expr)
        self.assertEquals(str(result), '(1 2 3)')
Esempio n. 2
0
    def test_load_procedure(self):
        from serval.lexer import Lexer
        from serval.parser import Parser
        from serval.interpreter import Interpreter
        from serval.expression.util import load

        interp = Interpreter()
        filepath = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                                'data', 'test.ss')
        expr = Parser(Lexer('(load "%s")' % filepath)).parse()[0]
        load(interp, expr)

        expr = Parser(Lexer('c')).parse()[0]
        result = interp.interpret(expr)
        self.assertEquals(str(result), '(1 2 3)')
    def _get_interpreter(self):
        from serval.interpreter import Interpreter

        interpreter = Interpreter()
        self._interpret(self.TEXT, interpreter=interpreter)

        return interpreter
Esempio n. 4
0
    def _interpret(self, text, interpreter=None):
        from serval.lexer import Lexer
        from serval.parser import Parser
        from serval.interpreter import Interpreter
        from serval.expression.procedure import (
            is_compound_procedure, get_procedure_repr)

        if interpreter is None:
            interpreter = Interpreter()

        expressions = Parser(Lexer(text)).parse()
        for expr in expressions:
            result_expr = interpreter.interpret(expr)
            if is_compound_procedure(result_expr):
                result = get_procedure_repr(result_expr)
            else:
                result = str(result_expr)

        return result
    def _interpret(self, text, interpreter=None):
        from serval.lexer import Lexer
        from serval.parser import Parser
        from serval.interpreter import Interpreter
        from serval.expression.procedure import (is_compound_procedure,
                                                 get_procedure_repr)

        if interpreter is None:
            interpreter = Interpreter()

        expressions = Parser(Lexer(text)).parse()
        for expr in expressions:
            result_expr = interpreter.interpret(expr)
            if is_compound_procedure(result_expr):
                result = get_procedure_repr(result_expr)
            else:
                result = str(result_expr)

        return result