Example #1
0
    def fireEvent(self, event, channel=None, target=None):
        """Fire/Push a new Event into the system (queue)

        This will push the given Event, Channel and Target onto the
        Event Queue for later processing.

        if target is None, then target will be set as the Channel of
        the current Component, self.channel (defaulting back to None).

        If this Component's Manager is itself, enqueue on this Component's
        Event Queue, otherwise enqueue on this Component's Manager.

        :param event: The Event Object
        :type  event: Event

        :param channel: The Channel this Event is bound for
        :type  channel: str

        @keyword target: The target Component's channel this Event is bound for
        :type    target: str or Component
        """

        if channel is None and target is None:
            if type(event.channel) is TupleType:
                target, channel = event.channel
            else:
                channel = event.channel or event.name.lower()
                target = event.target or None
        else:
            channel = channel or event.channel or event.name.lower()

        if isinstance(target, Manager):
            target = getattr(target, "channel", "*")
        else:
            target = target or event.target or getattr(self, "channel", "*")

        event.channel = (target, channel)

        event.value = Value(event, self)

        if event.start is not None:
            self.fire(Start(event), *event.start)

        self.root._fire(event, (target, channel))

        return event.value
    def step(self, ctx, pc):
        self = hint(self, access_directly=True)
        ops = hint(self.ops, promote=True)
        lex_env = hint(self.lex_env, promote=True)
        op = getop(ops, pc)

        if op == PushConstantOp:
            idx = getop(ops, pc + 1)
            self.push(lex_env.constants[idx])
            return pc + 2
        elif op == DispatchOp:
            idx = getop(ops, pc + 1)
            argc = getop(ops, pc + 2)
            sym_value = lex_env.constants[idx]
            assert isinstance(sym_value, StringValue)
            sym = sym_value.value
            if sym == '+' and argc == 2:
                rhs = self.pop()
                lhs = self.pop()
                assert isinstance(lhs, IntValue)
                assert isinstance(rhs, IntValue)
                self.push(IntValue(lhs.value + rhs.value))
            elif sym == '-' and argc == 2:
                rhs = self.pop()
                lhs = self.pop()
                assert isinstance(lhs, IntValue)
                assert isinstance(rhs, IntValue)
                self.push(IntValue(lhs.value - rhs.value))
            elif sym == '<' and argc == 2:
                rhs = self.pop()
                lhs = self.pop()
                assert isinstance(lhs, IntValue)
                assert isinstance(rhs, IntValue)
                self.push(BoolValue(lhs.value < rhs.value))
            elif sym == 'print' and argc == 1:
                print(self.pop().__repr__())
                self.push(Value())
            else:
                proc_lex_env = lex_env.get_proc_env(sym)
                if proc_lex_env:
                    overload = proc_lex_env.procs[sym]
                    self.push(ctx.run(
                        overload.lex_env,
                        overload.ops,
                        10,
                        self.pop(),
                    ))
            return pc + 3
        elif op == ReturnOp:
            return -1
        elif op == PopOp:
            self.drop()
            return pc + 1
        elif op == JumpFalseOp:
            cnd = self.pop()
            if isinstance(cnd, BoolValue) and not cnd.value:
                idx = getop(ops, pc + 1)
                return idx
            else:
                return pc + 2
        elif op == GetOp:
            idx = getop(ops, pc + 1)
            self.push(self.get(idx))
            return pc + 2

        return pc
Example #3
0
from lexer import Lexer
from parser_ import Parser
from evaluator import Evaluator
from context import Context
from environment import *
from values import Value

global_env = Environment()
global_env.set("null", Value(0))
global_func_env = FunctionEnvironment()

context = Context("<program>", global_env, global_func_env)

while True:
    text = input(">>> ")
    lexer = Lexer("<stdin>", text)
    tokens, errors = lexer.generate_tokens()
    if errors == None:
        # print(tokens)
        parser = Parser(tokens)
        ast = parser.parse()
        if ast.error == None:
            # print(ast.node)
            evaluator = Evaluator(ast.node, context)
            value = evaluator.evaluate()
            if value.error == None:
                print(value.value)
            else:
                print(value.error.as_string())
        else:
            print(ast.error.as_string())
Example #4
0
def gen_list(size=None):

    if not size:
        size = randint(5, 365)

    return [Value(r, randint(1, 10)) for r in range(size)]