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 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 execute(self, context):
scope = context.scope
variable = self.variable
if variable in scope:
return
scope[variable] = py_eval_bytecode(self.expr, locals=scope)
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):
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()
