def execute(self, context): # Evaluate the positional arguments. positional_values = self.positional_values positional_exprs = self.positional_exprs if positional_values and positional_exprs: values = py_eval_bytecode(positional_exprs, context.scope) positional = [ b if (a is use_expression) else a for a, b in zip(positional_values, values) ] elif positional_values: positional = positional_values elif positional_exprs: positional = py_eval_bytecode(positional_exprs, locals=context.scope) else: positional = [ ] # Create the context. ctx = SLContext(context) keywords = ctx.keywords = { } ctx.children = [ ] # Evaluate keywords and children. SLBlock.execute(self, ctx) # Pass the context if self.pass_context: positional.insert(0, ctx) # If we don't know the style, figure it out. if ("style" not in keywords) and self.style: keywords["style"] = renpy.style.get_style(ctx.style_prefix + self.style) # @UndefinedVariable if self.scope: keywords["scope"] = ctx.scope # Get the widget id and transform, if any. widget_id = keywords.pop("id", None) transform = keywords.pop("at", None) # Create and add the displayables. screen = renpy.ui.screen if widget_id in screen.widget_properties: keywords.update(screen.widget_properties[widget_id]) d = self.displayable(*positional, **keywords) for i in ctx.children: d.add(i) if widget_id is not None: screen.widgets[widget_id] = d if transform is not None: d = transform(d) context.children.append(d)
def execute(self, context): variable = self.variable expr = self.expression_expr if expr is not None: value = py_eval_bytecode(expr, locals=context.scope) else: value = self.expression_value newcaches = collections.defaultdict(dict) oldcaches = context.cache.get(self.serial, newcaches) ctx = SLContext(context) for i, v in enumerate(value): ctx.scope[variable] = v # TODO: use indexes of id(v) to get the cache. cache = oldcaches[i] newcaches[i] = cache ctx.cache = cache SLBlock.execute(self, ctx)
def prepare(self): SLBlock.prepare(self) # Prepare the positional arguments. exprs = [ ] values = [ ] has_exprs = False has_values = False for a in self.positional: node = py_compile(a, 'eval', ast_node=True) if is_constant(node): values.append(py_eval_bytecode(compile_expr(node))) exprs.append(ast.Num(n=0)) has_values = True else: values.append(use_expression) exprs.append(node) has_exprs = True if has_values: self.positional_values = values else: self.positional_values = None if has_exprs: t = ast.Tuple(elts=exprs, ctx=ast.Load()) ast.copy_location(t, exprs[0]) self.positional_exprs = compile_expr(t) else: self.positional_exprs = None
def prepare(self): for i in self.children: i.prepare() # Compile the keywords. keyword_values = { } keyword_keys = [ ] keyword_exprs = [ ] for k, expr in self.keyword: node = py_compile(expr, 'eval', ast_node=True) if is_constant(node): keyword_values[k] = py_eval_bytecode(compile_expr(node)) else: keyword_keys.append(ast.Str(s=k)) keyword_exprs.append(node) if keyword_values: self.keyword_values = keyword_values else: self.keyword_values = None if keyword_keys: node = ast.Dict(keys=keyword_keys, values=keyword_exprs) ast.copy_location(node, keyword_exprs[0]) self.keyword_exprs = compile_expr(node) else: self.keyword_exprs = None
def prepare(self): SLBlock.prepare(self) # Prepare the positional arguments. exprs = [] values = [] has_exprs = False has_values = False for a in self.positional: node = py_compile(a, 'eval', ast_node=True) if is_constant(node): values.append(py_eval_bytecode(compile_expr(node))) exprs.append(ast.Num(n=0)) has_values = True else: values.append(use_expression) exprs.append(node) has_exprs = True if has_values: self.positional_values = values else: self.positional_values = None if has_exprs: t = ast.Tuple(elts=exprs, ctx=ast.Load()) ast.copy_location(t, exprs[0]) self.positional_exprs = compile_expr(t) else: self.positional_exprs = None
def prepare(self): for i in self.children: i.prepare() # Compile the keywords. keyword_values = {} keyword_keys = [] keyword_exprs = [] for k, expr in self.keyword: node = py_compile(expr, 'eval', ast_node=True) if is_constant(node): keyword_values[k] = py_eval_bytecode(compile_expr(node)) else: keyword_keys.append(ast.Str(s=k)) keyword_exprs.append(node) if keyword_values: self.keyword_values = keyword_values else: self.keyword_values = None if keyword_keys: node = ast.Dict(keys=keyword_keys, values=keyword_exprs) ast.copy_location(node, keyword_exprs[0]) self.keyword_exprs = compile_expr(node) else: self.keyword_exprs = None
def execute(self, context): scope = context.scope variable = self.variable if variable in scope: return scope[variable] = py_eval_bytecode(self.expr, locals=scope)
def prepare(self): node = py_compile(self.expression, 'eval', ast_node=True) if is_constant(node): self.expression_value = py_eval_bytecode(compile_expr(node)) self.expression_expr = None else: self.expression_value = None self.expression_expr = compile_expr(node) SLBlock.prepare(self)
def prepare(self, analysis): keywords = dict(self.keyword) event_node = py_compile(self.event, 'eval', ast_node=True) action_node = py_compile(keywords.get('action', None), 'eval', ast_node=True) self.event_expr = compile_expr(event_node) self.action_expr = compile_expr(action_node) if analysis.is_constant(event_node): self.event_value = py_eval_bytecode(self.event_expr) else: self.event_value = None if analysis.is_constant(action_node): self.action_value = py_eval_bytecode(self.action_expr) else: self.action_value = None self.constant = False
def prepare(self, analysis): node = py_compile(self.expression, 'eval', ast_node=True) if analysis.is_constant(node): self.expression_value = py_eval_bytecode(compile_expr(node)) self.expression_expr = None else: self.expression_value = None self.expression_expr = compile_expr(node) self.constant = False SLBlock.prepare(self, analysis)
def prepare(self, analysis): keywords = dict(self.keyword) event_node = py_compile(self.event, 'eval', ast_node=True) action_node = py_compile(keywords.get('action', None), 'eval', ast_node=True) self.event_expr = compile_expr(event_node) self.action_expr = compile_expr(action_node) if analysis.is_constant(event_node): self.event_value = py_eval_bytecode(self.event_expr) else: self.event_value = None if analysis.is_constant(action_node): self.action_value = py_eval_bytecode(self.action_expr) else: self.action_value = None self.constant = NOT_CONST self.last_keyword = True
def prepare(self, analysis): SLBlock.prepare(self, analysis) # Prepare the positional arguments. exprs = [] values = [] has_exprs = False has_values = False for a in self.positional: node = py_compile(a, 'eval', ast_node=True) const = analysis.is_constant(node) if const == GLOBAL_CONST: values.append(py_eval_bytecode(compile_expr(node))) exprs.append(ast.Num(n=0)) has_values = True else: values.append(use_expression) exprs.append(node) # Will be compiled as part of the tuple. has_exprs = True self.constant = min(self.constant, const) if has_values: self.positional_values = values else: self.positional_values = None if has_exprs: t = ast.Tuple(elts=exprs, ctx=ast.Load()) ast.copy_location(t, exprs[0]) self.positional_exprs = compile_expr(t) else: self.positional_exprs = None # We do not pass keywords to our parents. self.has_keyword = False # We want to preserve last_keyword, however, in case we run a # python block. # If we have the id property, we're not constant - since we may get # additional keywords via id. (It's unlikely, but id should be pretty # rare.) for k, _expr in self.keyword: if k == "id": self.constant = NOT_CONST
def prepare(self, analysis): SLBlock.prepare(self, analysis) # Prepare the positional arguments. exprs = [ ] values = [ ] has_exprs = False has_values = False for a in self.positional: node = py_compile(a, 'eval', ast_node=True) const = analysis.is_constant(node) if const == GLOBAL_CONST: values.append(py_eval_bytecode(compile_expr(node))) exprs.append(ast.Num(n=0)) has_values = True else: values.append(use_expression) exprs.append(node) # Will be compiled as part of the tuple. has_exprs = True self.constant = min(self.constant, const) if has_values: self.positional_values = values else: self.positional_values = None if has_exprs: t = ast.Tuple(elts=exprs, ctx=ast.Load()) ast.copy_location(t, exprs[0]) self.positional_exprs = compile_expr(t) else: self.positional_exprs = None # We do not pass keywords to our parents. self.has_keyword = False # We want to preserve last_keyword, however, in case we run a # python block. # If we have the id property, we're not constant - since we may get # additional keywords via id. (It's unlikely, but id should be pretty # rare.) for k, _expr in self.keyword: if k == "id": self.constant = NOT_CONST
def execute(self, context): variable = self.variable expr = self.expression_expr if expr is not None: value = py_eval_bytecode(expr, locals=context.scope) else: value = self.expression_value for i in value: context.scope[variable] = i SLBlock.execute(self, context)
def prepare(self, analysis): for i in self.children: i.prepare(analysis) self.constant = min(self.constant, i.constant) # Compile the keywords. keyword_values = {} keyword_keys = [] keyword_exprs = [] for k, expr in self.keyword: node = py_compile(expr, 'eval', ast_node=True) const = analysis.is_constant(node) if const == GLOBAL_CONST: keyword_values[k] = py_eval_bytecode(compile_expr(node)) else: keyword_keys.append(ast.Str(s=k)) keyword_exprs.append( node) # Will be compiled as part of ast.Dict below. self.constant = min(self.constant, const) if keyword_values: self.keyword_values = keyword_values else: self.keyword_values = None if keyword_keys: node = ast.Dict(keys=keyword_keys, values=keyword_exprs) ast.copy_location(node, keyword_exprs[0]) self.keyword_exprs = compile_expr(node) else: self.keyword_exprs = None self.has_keyword = bool(self.keyword) self.keyword_children = [] for i in self.children: if i.has_keyword: self.keyword_children.append(i) self.has_keyword = True if i.last_keyword: self.last_keyword = True break
def prepare(self, analysis): for i in self.children: i.prepare(analysis) self.constant = min(self.constant, i.constant) # Compile the keywords. keyword_values = { } keyword_keys = [ ] keyword_exprs = [ ] for k, expr in self.keyword: node = py_compile(expr, 'eval', ast_node=True) const = analysis.is_constant(node) if const == GLOBAL_CONST: keyword_values[k] = py_eval_bytecode(compile_expr(node)) else: keyword_keys.append(ast.Str(s=k)) keyword_exprs.append(node) # Will be compiled as part of ast.Dict below. self.constant = min(self.constant, const) if keyword_values: self.keyword_values = keyword_values else: self.keyword_values = None if keyword_keys: node = ast.Dict(keys=keyword_keys, values=keyword_exprs) ast.copy_location(node, keyword_exprs[0]) self.keyword_exprs = compile_expr(node) else: self.keyword_exprs = None self.has_keyword = bool(self.keyword) self.keyword_children = [ ] for i in self.children: if i.has_keyword: self.keyword_children.append(i) self.has_keyword = True if i.last_keyword: self.last_keyword = True break
def prepare(self, analysis): node = py_compile(self.expression, 'eval', ast_node=True) const = analysis.is_constant(node) if const == GLOBAL_CONST: self.expression_value = py_eval_bytecode(compile_expr(node)) self.expression_expr = None else: self.expression_value = None self.expression_expr = compile_expr(node) self.constant = min(self.constant, const) SLBlock.prepare(self, analysis) self.last_keyword = True
def prepare(self, analysis): SLBlock.prepare(self, analysis) # Prepare the positional arguments. exprs = [ ] values = [ ] has_exprs = False has_values = False for a in self.positional: node = py_compile(a, 'eval', ast_node=True) const = analysis.is_constant(node) if const == GLOBAL_CONST: values.append(py_eval_bytecode(compile_expr(node))) exprs.append(ast.Num(n=0)) has_values = True else: values.append(use_expression) exprs.append(node) # Will be compiled as part of the tuple. has_exprs = True self.constant = min(self.constant, const) if has_values: self.positional_values = values else: self.positional_values = None if has_exprs: t = ast.Tuple(elts=exprs, ctx=ast.Load()) ast.copy_location(t, exprs[0]) self.positional_exprs = compile_expr(t) else: self.positional_exprs = None # We do not pass keywords to our parents. self.has_keyword = False
def execute(self, context): keyword_values = self.keyword_values if keyword_values is not None: context.keywords.update(keyword_values) keyword_exprs = self.keyword_exprs if keyword_exprs is not None: context.keywords.update(py_eval_bytecode(keyword_exprs)) style_group = context.keywords.pop("style_group", NotGiven) if style_group is not NotGiven: if style_group is not None: context.style_prefix = style_group + "_" else: context.style_prefix = "" for i in self.children: i.execute(context)
def keywords(self, context): keyword_values = self.keyword_values if keyword_values is not None: context.keywords.update(keyword_values) keyword_exprs = self.keyword_exprs if keyword_exprs is not None: context.keywords.update(py_eval_bytecode(keyword_exprs, locals=context.scope)) style_group = context.keywords.pop("style_group", NotGiven) if style_group is not NotGiven: if style_group is not None: context.style_prefix = style_group + "_" else: context.style_prefix = "" for i in self.children: i.keywords(context)
def prepare(self, analysis): for i in self.children: i.prepare(analysis) if not i.constant: self.constant = False # Compile the keywords. keyword_values = { } keyword_keys = [ ] keyword_exprs = [ ] for k, expr in self.keyword: node = py_compile(expr, 'eval', ast_node=True) if analysis.is_constant(node): keyword_values[k] = py_eval_bytecode(compile_expr(node)) else: keyword_keys.append(ast.Str(s=k)) keyword_exprs.append(node) # Will be compiled as part of ast.Dict below. if keyword_values: self.keyword_values = keyword_values else: self.keyword_values = None if keyword_keys: node = ast.Dict(keys=keyword_keys, values=keyword_exprs) ast.copy_location(node, keyword_exprs[0]) self.keyword_exprs = compile_expr(node) self.constant = False else: self.keyword_exprs = None
def keywords(self, context): for cond, block in self.prepared_entries: if cond is None or py_eval_bytecode(cond, locals=context.scope): block.keywords(context) return
def execute(self, context): for cond, block in self.prepared_entries: if cond is None or py_eval_bytecode(cond, locals=context.scope): block.execute(context) return
def execute(self, context): cache = context.cache.get(self.serial, None) if cache is None: context.cache[self.serial] = cache = SLCache() # Evaluate the positional arguments. positional_values = self.positional_values positional_exprs = self.positional_exprs if positional_values and positional_exprs: values = py_eval_bytecode(positional_exprs, context.scope) positional = [ b if (a is use_expression) else a for a, b in zip(positional_values, values) ] elif positional_values: positional = positional_values elif positional_exprs: positional = py_eval_bytecode(positional_exprs, locals=context.scope) else: positional = [] # Create the context. ctx = SLContext(context) keywords = ctx.keywords = {} SLBlock.keywords(self, ctx) # Pass the context if self.pass_context: positional.insert(0, ctx) # Get the widget id and transform, if any. widget_id = keywords.pop("id", None) transform = keywords.pop("at", None) # If we don't know the style, figure it out. if ("style" not in keywords) and self.style: keywords["style"] = renpy.style.get_style( ctx.style_prefix + self.style) # @UndefinedVariable # Create and add the displayables. screen = renpy.ui.screen if widget_id in screen.widget_properties: keywords.update(screen.widget_properties[widget_id]) if (positional == cache.positional) and (keywords == cache.keywords): d = cache.displayable reused = True print "REUSED", d if cache.imagemap is not None: renpy.ui.imagemap_stack.append(cache.imagemap) else: cache.positional = positional cache.keywords = keywords.copy() if self.scope: keywords["scope"] = ctx.scope if self.replaces: keywords['replaces'] = cache.displayable d = self.displayable(*positional, **keywords) reused = False if d is not None: ctx.children = [] renpy.ui.stack.append( renpy.ui.ChildList(ctx.children, ctx.style_prefix)) # Evaluate children. SLBlock.execute(self, ctx) # If we didn't create a displayable, exit early. if d is None: return renpy.ui.stack.pop() if self.imagemap: cache.imagemap = renpy.ui.imagemap_stack.pop() if ctx.children != cache.children: if reused: d._clear() if self.child_or_fixed and len(self.children) != 1: f = renpy.display.layout.Fixed() for i in ctx.children: f.add(i) d.add(f) else: for i in ctx.children: d.add(i) cache.displayable = d if widget_id is not None: screen.widgets[widget_id] = d if transform is not None: if transform is not cache.raw_transform: cache.raw_transform = transform d = transform(d) if cache.transform is not None: d.take_state(cache.transform) d.take_execution_state(cache.transform) cache.transform = d context.children.append(d)
def execute(self, context): cache = context.cache.get(self.serial, None) if cache is None: context.cache[self.serial] = cache = SLCache() # Evaluate the positional arguments. positional_values = self.positional_values positional_exprs = self.positional_exprs if positional_values and positional_exprs: values = py_eval_bytecode(positional_exprs, context.scope) positional = [ b if (a is use_expression) else a for a, b in zip(positional_values, values) ] elif positional_values: positional = positional_values elif positional_exprs: positional = py_eval_bytecode(positional_exprs, locals=context.scope) else: positional = [ ] # Create the context. ctx = SLContext(context) keywords = ctx.keywords = { } ctx.children = [ ] SLBlock.keywords(self, ctx) # Pass the context if self.pass_context: positional.insert(0, ctx) # If we don't know the style, figure it out. if ("style" not in keywords) and self.style: keywords["style"] = renpy.style.get_style(ctx.style_prefix + self.style) # @UndefinedVariable if self.scope: keywords["scope"] = ctx.scope # Get the widget id and transform, if any. widget_id = keywords.pop("id", None) transform = keywords.pop("at", None) # Create and add the displayables. screen = renpy.ui.screen if widget_id in screen.widget_properties: keywords.update(screen.widget_properties[widget_id]) if self.replaces: keywords['replaces'] = cache.displayable d = self.displayable(*positional, **keywords) # Evaluate children. SLBlock.execute(self, ctx) # If we didn't create a displayable, exit early. if d is None: return if self.child_or_fixed and len(self.children) != 1: f = renpy.display.layout.Fixed() for i in ctx.children: f.add(i) d.add(f) else: for i in ctx.children: d.add(i) cache.displayable = d if widget_id is not None: screen.widgets[widget_id] = d if transform is not None: d = transform(d) if isinstance(d, renpy.display.motion.Transform): if cache.transform is not None: d.take_state(cache.transform) d.take_execution_state(cache.transform) context.children.append(d) if self.imagemap: renpy.ui.imagemap_stack.pop()