Beispiel #1
0
    def execute(self, context):

        ast = self.ast

        # If self.ast is not an SL2 screen, run it using renpy.display.screen.use_screen.
        if ast is None:
            self.execute_use_screen(context)
            return

        # Otherwise, run it directly.

        ctx = SLContext(context)

        try:
            if self.args:
                args, kwargs = self.args.evaluate(context.scope)
            else:
                args = [ ]
                kwargs = { }
        except:
            if not context.predicting:
                raise

            args = [ ]
            kwargs = { }

        if ast.parameters is not None:
            scope = ast.parameters.apply(args, kwargs, ignore_errors=context.predicting)
        else:
            if args:
                raise Exception("Screen {} does not take positional arguments. ({} given)".format(self.target, len(args)))

            scope = context.scope.copy()
            scope.update(kwargs)

        scope["_scope"] = scope

        ctx.scope = scope

        # Use a call-site specific cache. (Otherwise, two uses of the same screen would
        # be sharing cache locations.

        cache = context.cache.get(self.serial, None)

        if cache is None:
            context.cache[self.serial] = cache = { }

        ctx.cache = cache

        # Run the child screen.
        ast.execute(ctx)

@addToClass(ast.OpNode)
def execute(self):
    args = [c.execute() for c in self.children]
    if len(args) == 1:
        args.insert(0, 0)
    return reduce(ops[self.op], args)


@addToClass(ast.AssignNode)
def execute(self):
    vars[self.children[0].tok] = self.children[1].execute()


@addToClass(ast.PrintNode)
def execute(self):
    print(self.children[0].execute())


@addToClass(ast.WhileNode)
def execute(self):
    while (self.children[0].execute()):
        self.children[1].execute()


if __name__ == "__main__":
    prog = open(sys.argv[1]).read()
    ast = parse(prog)
    ast.execute()
    def execute(self, context):

        ast = self.ast

        # If self.ast is not an SL2 screen, run it using renpy.display.screen.use_screen.
        if ast is None:
            self.execute_use_screen(context)
            return

        # Otherwise, run the use statement directly.

        # Figure out the cache to use.

        # True if we want to force-mark this as an update.
        update = False

        if (not context.predicting) and self.id:

            # If we have an id, look it up in the current screen's use_cache.

            current_screen = renpy.display.screen.current_screen()
            use_id = (self.target, eval(self.id, context.globals,
                                        context.scope))

            cache = current_screen.use_cache.get(use_id, None)

            if cache is not None:
                update = True

            else:

                if cache is None:
                    cache = context.cache.get(self.serial, None)

                if cache is None:
                    cache = {}

            context.cache[self.serial] = cache
            current_screen.use_cache[use_id] = cache

        else:

            # Otherwise, look up the cache based on the statement's location.

            cache = context.cache.get(self.serial, None)

            if cache is None:
                context.cache[self.serial] = cache = {}

        # Evaluate the arguments.
        try:
            if self.args:
                args, kwargs = self.args.evaluate(context.scope)
            else:
                args = []
                kwargs = {}
        except:
            if not context.predicting:
                raise

            args = []
            kwargs = {}

        # Apply the arguments to the parameters (if present) or to the scope of the used screen.
        if ast.parameters is not None:
            new_scope = ast.parameters.apply(args,
                                             kwargs,
                                             ignore_errors=context.predicting)

            scope = cache.get("scope", None)

            if scope is None:
                scope = cache["scope"] = new_scope
            else:
                scope.update(new_scope)

        else:

            if args:
                raise Exception(
                    "Screen {} does not take positional arguments. ({} given)".
                    format(self.target, len(args)))

            scope = context.scope.copy()
            scope.update(kwargs)

        scope["_scope"] = scope

        # Run the child screen.
        ctx = SLContext(context)
        ctx.scope = scope
        ctx.cache = cache

        if update:
            ctx.updating = True

        ast.execute(ctx)
Beispiel #4
0
    def execute(self, context):

        ast = self.ast

        # If self.ast is not an SL2 screen, run it using renpy.display.screen.use_screen.
        if ast is None:
            self.execute_use_screen(context)
            return

        # Otherwise, run the use statement directly.

        # Figure out the cache to use.

        # True if we want to force-mark this as an update.
        update = False

        if (not context.predicting) and self.id:

            # If we have an id, look it up in the current screen's use_cache.

            current_screen = renpy.display.screen.current_screen()
            use_id = (self.target, eval(self.id, context.globals, context.scope))

            cache = current_screen.use_cache.get(use_id, None)

            if cache is not None:
                update = True

            else:

                if cache is None:
                    cache = context.cache.get(self.serial, None)

                if cache is None:
                    cache = { }

            context.cache[self.serial] = cache
            current_screen.use_cache[use_id] = cache

        else:

            # Otherwise, look up the cache based on the statement's location.

            cache = context.cache.get(self.serial, None)

            if cache is None:
                context.cache[self.serial] = cache = { }


        # Evaluate the arguments.
        try:
            if self.args:
                args, kwargs = self.args.evaluate(context.scope)
            else:
                args = [ ]
                kwargs = { }
        except:
            if not context.predicting:
                raise

            args = [ ]
            kwargs = { }

        # Apply the arguments to the parameters (if present) or to the scope of the used screen.
        if ast.parameters is not None:
            new_scope = ast.parameters.apply(args, kwargs, ignore_errors=context.predicting)

            scope = cache.get("scope", None)

            if scope is None:
                scope = cache["scope"] = new_scope
            else:
                scope.update(new_scope)

        else:

            if args:
                raise Exception("Screen {} does not take positional arguments. ({} given)".format(self.target, len(args)))

            scope = context.scope.copy()
            scope.update(kwargs)

        scope["_scope"] = scope

        # Run the child screen.
        ctx = SLContext(context)
        ctx.scope = scope
        ctx.cache = cache

        if update:
            ctx.updating = True

        ast.execute(ctx)