def buildDirEmptyCase(source_ref):
if node.getParentVariableProvider().isCompiledPythonModule():
source = ExpressionBuiltinGlobals(
source_ref = source_ref
)
else:
source = ExpressionBuiltinLocals(
source_ref = source_ref
)
result = ExpressionCallEmpty(
called = ExpressionAttributeLookup(
source = source,
attribute_name = "keys",
source_ref = source_ref
),
source_ref = source_ref
)
# For Python3, keys doesn't really return values, but instead a handle
# only.
if python_version >= 300:
result = ExpressionBuiltinList(
value = result,
source_ref = source_ref
)
return result
def buildImportModulesNode(provider, node, source_ref):
# Import modules statement. As described in the Developer Manual, these
# statements can be treated as several ones.
import_names = [(import_desc.name, import_desc.asname)
for import_desc in node.names]
import_nodes = []
for import_desc in import_names:
module_name, local_name = import_desc
module_topname = module_name.split(".")[0]
# Note: The "level" of import is influenced by the future absolute
# imports.
level = (makeConstantRefNode(0, source_ref, True)
if _future_specs[-1].isAbsoluteImport() else None)
import_node = ExpressionBuiltinImport(
name=makeConstantRefNode(module_name, source_ref, True),
globals_arg=ExpressionBuiltinGlobals(source_ref),
locals_arg=makeConstantRefNode(None, source_ref, True),
fromlist=makeConstantRefNode(None, source_ref, True),
level=level,
source_ref=source_ref,
)
if local_name:
# If is gets a local name, the real name must be used as a
# temporary value only, being looked up recursively.
for import_name in module_name.split(".")[1:]:
import_node = ExpressionImportName(
module=import_node,
import_name=import_name,
# TODO: Does level make sense at all, should be removed.
level=0,
source_ref=source_ref,
)
# If a name was given, use the one provided, otherwise the import gives
# the top level package name given for assignment of the imported
# module.
import_nodes.append(
StatementAssignmentVariableName(
provider=provider,
variable_name=mangleName(
local_name if local_name is not None else module_topname,
provider),
source=import_node,
source_ref=source_ref,
))
# Note: Each import is sequential. It will potentially succeed, and the
# failure of a later one is not changing that one bit . We can therefore
# have a sequence of imports that only import one thing therefore.
return makeStatementsSequenceOrStatement(statements=import_nodes,
source_ref=source_ref)
def selectVarsEmptyClass(source_ref):
if node.getParentVariableProvider().isCompiledPythonModule():
return ExpressionBuiltinGlobals(
source_ref = source_ref
)
else:
return ExpressionBuiltinLocals(
source_ref = source_ref
)
def wrapEvalGlobalsAndLocals(provider, globals_node, locals_node, temp_scope,
source_ref):
""" Wrap the locals and globals arguments for "eval".
This is called from the outside, and when the node tree
already exists.
"""
globals_keeper_variable = provider.allocateTempVariable(
temp_scope=temp_scope, name="globals")
locals_keeper_variable = provider.allocateTempVariable(
temp_scope=temp_scope, name="locals")
if locals_node is None:
locals_node = ExpressionConstantNoneRef(source_ref=source_ref)
if globals_node is None:
globals_node = ExpressionConstantNoneRef(source_ref=source_ref)
post_statements = []
if provider.isExpressionClassBody():
post_statements.append(
StatementLocalsDictSync(
locals_arg=ExpressionTempVariableRef(
variable=locals_keeper_variable, source_ref=source_ref),
source_ref=source_ref.atInternal(),
))
post_statements += [
StatementReleaseVariable(variable=globals_keeper_variable,
source_ref=source_ref),
StatementReleaseVariable(variable=locals_keeper_variable,
source_ref=source_ref),
]
# The locals default is dependent on exec_mode, globals or locals.
locals_default = ExpressionConditional(
condition=ExpressionComparisonIs(
left=ExpressionTempVariableRef(variable=globals_keeper_variable,
source_ref=source_ref),
right=ExpressionConstantNoneRef(source_ref=source_ref),
source_ref=source_ref,
),
expression_no=ExpressionTempVariableRef(
variable=globals_keeper_variable, source_ref=source_ref),
expression_yes=makeExpressionBuiltinLocals(provider=provider,
source_ref=source_ref),
source_ref=source_ref,
)
pre_statements = [
# First assign globals and locals temporary the values given.
StatementAssignmentVariable(variable=globals_keeper_variable,
source=globals_node,
source_ref=source_ref),
StatementAssignmentVariable(variable=locals_keeper_variable,
source=locals_node,
source_ref=source_ref),
makeStatementConditional(
condition=ExpressionComparisonIs(
left=ExpressionTempVariableRef(variable=locals_keeper_variable,
source_ref=source_ref),
right=ExpressionConstantNoneRef(source_ref=source_ref),
source_ref=source_ref,
),
yes_branch=StatementAssignmentVariable(
variable=locals_keeper_variable,
source=locals_default,
source_ref=source_ref,
),
no_branch=None,
source_ref=source_ref,
),
makeStatementConditional(
condition=ExpressionComparisonIs(
left=ExpressionTempVariableRef(
variable=globals_keeper_variable, source_ref=source_ref),
right=ExpressionConstantNoneRef(source_ref=source_ref),
source_ref=source_ref,
),
yes_branch=StatementAssignmentVariable(
variable=globals_keeper_variable,
source=ExpressionBuiltinGlobals(source_ref=source_ref),
source_ref=source_ref,
),
no_branch=None,
source_ref=source_ref,
),
]
return (
ExpressionTempVariableRef(
variable=globals_keeper_variable,
source_ref=source_ref
if globals_node is None else globals_node.getSourceReference(),
),
ExpressionTempVariableRef(
variable=locals_keeper_variable,
source_ref=source_ref
if locals_node is None else locals_node.getSourceReference(),
),
makeStatementsSequence(pre_statements, False, source_ref),
makeStatementsSequence(post_statements, False, source_ref),
)
def buildExecNode(provider, node, source_ref):
# "exec" statements, should only occur with Python2.
# This is using many variables, due to the many details this is
# dealing with. The locals and globals need to be dealt with in
# temporary variables, and we need handling of indicators, so
# that is just the complexity, pylint: disable=too-many-locals
exec_globals = node.globals
exec_locals = node.locals
body = node.body
# Handle exec(a,b,c) to be same as exec a, b, c
if exec_locals is None and exec_globals is None and getKind(
body) == "Tuple":
parts = body.elts
body = parts[0]
if len(parts) > 1:
exec_globals = parts[1]
if len(parts) > 2:
exec_locals = parts[2]
else:
return StatementRaiseException(
exception_type=ExpressionBuiltinExceptionRef(
exception_name="TypeError", source_ref=source_ref),
exception_value=makeConstantRefNode(
constant="""\
exec: arg 1 must be a string, file, or code object""",
source_ref=source_ref,
),
exception_trace=None,
exception_cause=None,
source_ref=source_ref,
)
temp_scope = provider.allocateTempScope("exec")
locals_value = buildNode(provider, exec_locals, source_ref, True)
if locals_value is None:
locals_value = ExpressionConstantNoneRef(source_ref=source_ref)
globals_value = buildNode(provider, exec_globals, source_ref, True)
if globals_value is None:
globals_value = ExpressionConstantNoneRef(source_ref=source_ref)
source_code = buildNode(provider, body, source_ref)
source_variable = provider.allocateTempVariable(temp_scope=temp_scope,
name="exec_source")
globals_keeper_variable = provider.allocateTempVariable(
temp_scope=temp_scope, name="globals")
locals_keeper_variable = provider.allocateTempVariable(
temp_scope=temp_scope, name="locals")
plain_indicator_variable = provider.allocateTempVariable(
temp_scope=temp_scope, name="plain")
tried = (
# First evaluate the source code expressions.
StatementAssignmentVariable(variable=source_variable,
source=source_code,
source_ref=source_ref),
# Assign globals and locals temporary the values given, then fix it
# up, taking note in the "plain" temporary variable, if it was an
# "exec" statement with None arguments, in which case the copy back
# will be necessary.
StatementAssignmentVariable(
variable=globals_keeper_variable,
source=globals_value,
source_ref=source_ref,
),
StatementAssignmentVariable(variable=locals_keeper_variable,
source=locals_value,
source_ref=source_ref),
StatementAssignmentVariable(
variable=plain_indicator_variable,
source=makeConstantRefNode(constant=False, source_ref=source_ref),
source_ref=source_ref,
),
makeStatementConditional(
condition=ExpressionComparisonIs(
left=ExpressionTempVariableRef(
variable=globals_keeper_variable, source_ref=source_ref),
right=ExpressionConstantNoneRef(source_ref=source_ref),
source_ref=source_ref,
),
yes_branch=makeStatementsSequenceFromStatements(
StatementAssignmentVariable(
variable=globals_keeper_variable,
source=ExpressionBuiltinGlobals(source_ref=source_ref),
source_ref=source_ref,
),
makeStatementConditional(
condition=ExpressionComparisonIs(
left=ExpressionTempVariableRef(
variable=locals_keeper_variable,
source_ref=source_ref),
right=ExpressionConstantNoneRef(source_ref=source_ref),
source_ref=source_ref,
),
yes_branch=makeStatementsSequenceFromStatements(
StatementAssignmentVariable(
variable=locals_keeper_variable,
source=makeExpressionBuiltinLocals(
provider=provider, source_ref=source_ref),
source_ref=source_ref,
),
StatementAssignmentVariable(
variable=plain_indicator_variable,
source=makeConstantRefNode(constant=True,
source_ref=source_ref),
source_ref=source_ref,
),
),
no_branch=None,
source_ref=source_ref,
),
),
no_branch=makeStatementsSequenceFromStatements(
makeStatementConditional(
condition=ExpressionComparisonIs(
left=ExpressionTempVariableRef(
variable=locals_keeper_variable,
source_ref=source_ref),
right=ExpressionConstantNoneRef(source_ref=source_ref),
source_ref=source_ref,
),
yes_branch=makeStatementsSequenceFromStatement(
statement=StatementAssignmentVariable(
variable=locals_keeper_variable,
source=ExpressionTempVariableRef(
variable=globals_keeper_variable,
source_ref=source_ref),
source_ref=source_ref,
)),
no_branch=None,
source_ref=source_ref,
)),
source_ref=source_ref,
),
makeTryFinallyStatement(
provider=provider,
tried=StatementExec(
source_code=ExpressionTempVariableRef(variable=source_variable,
source_ref=source_ref),
globals_arg=ExpressionTempVariableRef(
variable=globals_keeper_variable, source_ref=source_ref),
locals_arg=ExpressionTempVariableRef(
variable=locals_keeper_variable, source_ref=source_ref),
source_ref=source_ref,
),
final=makeStatementConditional(
condition=ExpressionComparisonIs(
left=ExpressionTempVariableRef(
variable=plain_indicator_variable,
source_ref=source_ref),
right=makeConstantRefNode(constant=True,
source_ref=source_ref),
source_ref=source_ref,
),
yes_branch=StatementLocalsDictSync(
locals_arg=ExpressionTempVariableRef(
variable=locals_keeper_variable,
source_ref=source_ref),
source_ref=source_ref,
),
no_branch=None,
source_ref=source_ref,
),
source_ref=source_ref,
),
)
final = (
StatementReleaseVariable(variable=source_variable,
source_ref=source_ref),
StatementReleaseVariable(variable=globals_keeper_variable,
source_ref=source_ref),
StatementReleaseVariable(variable=locals_keeper_variable,
source_ref=source_ref),
StatementReleaseVariable(variable=plain_indicator_variable,
source_ref=source_ref),
)
return makeTryFinallyStatement(provider=provider,
tried=tried,
final=final,
source_ref=source_ref)
def wrapEvalGlobalsAndLocals(provider, globals_node, locals_node, temp_scope,
source_ref):
""" Wrap the locals and globals arguments for eval and exec.
For eval, this is called from the outside, and when the node tree
already exists.
"""
globals_keeper_variable = provider.allocateTempVariable(
temp_scope=temp_scope, name="globals")
locals_keeper_variable = provider.allocateTempVariable(
temp_scope=temp_scope, name="locals")
if locals_node is None:
locals_node = ExpressionConstantRef(constant=None,
source_ref=source_ref)
if globals_node is None:
globals_node = ExpressionConstantRef(constant=None,
source_ref=source_ref)
post_statements = [
StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=globals_keeper_variable.makeReference(provider),
source_ref=globals_node.getSourceReference()),
tolerant=False,
source_ref=source_ref),
StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=locals_keeper_variable.makeReference(provider),
source_ref=locals_node.getSourceReference()),
tolerant=False,
source_ref=source_ref)
]
# The locals default is dependant on exec_mode, globals or locals.
locals_default = ExpressionConditional(
condition=ExpressionComparisonIs(left=ExpressionTempVariableRef(
variable=globals_keeper_variable.makeReference(provider),
source_ref=source_ref),
right=ExpressionConstantRef(
constant=None,
source_ref=source_ref),
source_ref=source_ref),
no_expression=ExpressionTempVariableRef(
variable=globals_keeper_variable.makeReference(provider),
source_ref=source_ref),
yes_expression=ExpressionBuiltinLocals(source_ref=source_ref),
source_ref=source_ref)
pre_statements = [
# First assign globals and locals temporary the values given.
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=globals_keeper_variable.makeReference(provider),
source_ref=source_ref),
source=globals_node,
source_ref=source_ref,
),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=locals_keeper_variable.makeReference(provider),
source_ref=source_ref),
source=locals_node,
source_ref=source_ref,
),
StatementConditional(
condition=ExpressionComparisonIs(left=ExpressionTempVariableRef(
variable=locals_keeper_variable.makeReference(provider),
source_ref=source_ref),
right=ExpressionConstantRef(
constant=None,
source_ref=source_ref),
source_ref=source_ref),
yes_branch=makeStatementsSequenceFromStatement(
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=locals_keeper_variable.makeReference(
provider),
source_ref=source_ref),
source=locals_default,
source_ref=source_ref,
)),
no_branch=None,
source_ref=source_ref),
StatementConditional(
condition=ExpressionComparisonIs(left=ExpressionTempVariableRef(
variable=globals_keeper_variable.makeReference(provider),
source_ref=source_ref),
right=ExpressionConstantRef(
constant=None,
source_ref=source_ref),
source_ref=source_ref),
yes_branch=makeStatementsSequenceFromStatement(
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=globals_keeper_variable.makeReference(
provider),
source_ref=source_ref),
source=ExpressionBuiltinGlobals(source_ref=source_ref),
source_ref=source_ref,
)),
no_branch=None,
source_ref=source_ref)
]
return (ExpressionTempVariableRef(
variable=globals_keeper_variable.makeReference(provider),
source_ref=source_ref
if globals_node is None else globals_node.getSourceReference()),
ExpressionTempVariableRef(
variable=locals_keeper_variable.makeReference(provider),
source_ref=source_ref
if locals_node is None else locals_node.getSourceReference()),
makeStatementsSequence(pre_statements, False, source_ref),
makeStatementsSequence(post_statements, False, source_ref))
def wrapEvalGlobalsAndLocals(provider, globals, locals, exec_mode, source_ref):
if globals is not None:
global_keeper_variable = provider.getTempKeeperVariable()
tmp_global_assign = ExpressionAssignmentTempKeeper(
variable=global_keeper_variable.makeReference(provider),
source=globals,
source_ref=source_ref)
globals_wrap = ExpressionConditional(
condition=ExpressionComparisonIs(left=tmp_global_assign,
right=ExpressionConstantRef(
constant=None,
source_ref=source_ref),
source_ref=source_ref),
no_expression=ExpressionTempKeeperRef(
variable=global_keeper_variable.makeReference(provider),
source_ref=source_ref),
yes_expression=ExpressionBuiltinGlobals(source_ref=source_ref),
source_ref=source_ref)
else:
globals_wrap = ExpressionBuiltinGlobals(source_ref=source_ref)
if locals is not None:
local_keeper_variable = provider.getTempKeeperVariable()
tmp_local_assign = ExpressionAssignmentTempKeeper(
variable=local_keeper_variable.makeReference(provider),
source=locals,
source_ref=source_ref)
if exec_mode:
locals_fallback = ExpressionBuiltinLocals(source_ref=source_ref)
else:
locals_fallback = ExpressionConditional(
condition=ExpressionComparisonIs(left=ExpressionTempKeeperRef(
variable=global_keeper_variable.makeReference(provider),
source_ref=source_ref),
right=ExpressionConstantRef(
constant=None,
source_ref=source_ref),
source_ref=source_ref),
no_expression=ExpressionTempKeeperRef(
variable=global_keeper_variable.makeReference(provider),
source_ref=source_ref),
yes_expression=ExpressionBuiltinLocals(source_ref=source_ref),
source_ref=source_ref)
locals_wrap = ExpressionConditional(
condition=ExpressionComparisonIs(left=tmp_local_assign,
right=ExpressionConstantRef(
constant=None,
source_ref=source_ref),
source_ref=source_ref),
no_expression=ExpressionTempKeeperRef(
variable=local_keeper_variable.makeReference(provider),
source_ref=source_ref),
yes_expression=locals_fallback,
source_ref=source_ref)
else:
if globals is None:
locals_wrap = ExpressionBuiltinLocals(source_ref=source_ref)
else:
locals_wrap = ExpressionTempKeeperRef(
variable=global_keeper_variable.makeReference(provider),
source_ref=source_ref)
return globals_wrap, locals_wrap
def buildImportFromNode(provider, node, source_ref):
# "from .. import .." statements. This may trigger a star import, or
# multiple names being looked up from the given module variable name.
# This is pretty complex.
# pylint: disable=too-many-branches,too-many-locals,too-many-statements
module_name = node.module if node.module is not None else ""
level = node.level
# Use default level under some circumstances.
if level == -1:
level = None
elif level == 0 and not _future_specs[-1].isAbsoluteImport():
level = None
if level is not None:
level_obj = makeConstantRefNode(level, source_ref, True)
else:
level_obj = None
# Importing from "__future__" module may enable flags to the parser,
# that we need to know about, handle that.
if module_name == "__future__":
_handleFutureImport(provider, node, source_ref)
target_names = []
import_names = []
# Mapping imported "fromlist" to assigned "fromlist" if any, handling the
# star case as well.
for import_desc in node.names:
object_name, local_name = import_desc.name, import_desc.asname
if object_name == "*":
target_names.append(None)
assert local_name is None
else:
target_names.append(
local_name if local_name is not None else object_name)
import_names.append(object_name)
# Star imports get special treatment.
if None in target_names:
# More than "*" is a syntax error in Python, need not care about this at
# all, it's only allowed value for import list in this case.
assert target_names == [None]
# Python3 made it so that these can only occur on the module level,
# so this a syntax error if not there. For Python2 it is OK to
# occur everywhere though.
if not provider.isCompiledPythonModule() and python_version >= 0x300:
raiseSyntaxError(
"import * only allowed at module level",
source_ref.atColumnNumber(node.col_offset),
)
if provider.isCompiledPythonModule():
import_globals = ExpressionBuiltinGlobals(source_ref)
import_locals = ExpressionBuiltinGlobals(source_ref)
else:
import_globals = ExpressionBuiltinGlobals(source_ref)
import_locals = makeConstantRefNode({}, source_ref, True)
return StatementImportStar(
target_scope=provider.getLocalsScope(),
module_import=ExpressionBuiltinImport(
name=makeConstantRefNode(module_name, source_ref, True),
globals_arg=import_globals,
locals_arg=import_locals,
fromlist=makeConstantRefNode(("*", ), source_ref, True),
level=level_obj,
source_ref=source_ref,
),
source_ref=source_ref,
)
else:
if module_name == "__future__":
imported_from_module = ExpressionImportModuleHard(
module_name="__future__", source_ref=source_ref)
else:
imported_from_module = ExpressionBuiltinImport(
name=makeConstantRefNode(module_name, source_ref, True),
globals_arg=ExpressionBuiltinGlobals(source_ref),
locals_arg=makeConstantRefNode(None, source_ref, True),
fromlist=makeConstantRefNode(tuple(import_names), source_ref,
True),
level=level_obj,
source_ref=source_ref,
)
# If we have multiple names to import, consider each.
multi_names = len(target_names) > 1
statements = []
if multi_names:
tmp_import_from = provider.allocateTempVariable(
temp_scope=provider.allocateTempScope("import_from"),
name="module")
statements.append(
StatementAssignmentVariable(
variable=tmp_import_from,
source=imported_from_module,
source_ref=source_ref,
))
imported_from_module = ExpressionTempVariableRef(
variable=tmp_import_from, source_ref=source_ref)
import_statements = []
first = True
for target_name, import_name in zip(target_names, import_names):
# Make a clone of the variable reference, if we are going to use
# another one.
if not first:
imported_from_module = imported_from_module.makeClone()
first = False
import_statements.append(
StatementAssignmentVariableName(
provider=provider,
variable_name=mangleName(target_name, provider),
source=ExpressionImportName(
module=imported_from_module,
import_name=import_name,
level=0,
source_ref=source_ref,
),
source_ref=source_ref,
))
# Release the temporary module value as well.
if multi_names:
statements.append(
makeTryFinallyStatement(
provider=provider,
tried=import_statements,
final=(StatementReleaseVariable(variable=tmp_import_from,
source_ref=source_ref), ),
source_ref=source_ref,
))
else:
statements.extend(import_statements)
# Note: Each import is sequential. It can succeed, and the failure of a
# later one is not undoing previous ones. We can therefore have a
# sequence of imports that each only import one thing therefore.
return StatementsSequence(statements=mergeStatements(statements),
source_ref=source_ref)
def buildExecNode(provider, node, source_ref):
# "exec" statements, should only occur with Python2.
# This is using many variables, due to the many details this is
# dealing with. The locals and globals need to be dealt with in
# temporary variables, and we need handling of indicators, so
# that is just the complexity, pylint: disable=R0914
exec_globals = node.globals
exec_locals = node.locals
body = node.body
orig_globals = exec_globals
# Handle exec(a,b,c) to be same as exec a, b, c
if exec_locals is None and exec_globals is None and \
getKind(body) == "Tuple":
parts = body.elts
body = parts[0]
if len(parts) > 1:
exec_globals = parts[1]
if len(parts) > 2:
exec_locals = parts[2]
else:
return StatementRaiseException(
exception_type=ExpressionBuiltinExceptionRef(
exception_name="TypeError", source_ref=source_ref),
exception_value=ExpressionConstantRef(constant="""\
exec: arg 1 must be a string, file, or code object""",
source_ref=source_ref),
exception_trace=None,
exception_cause=None,
source_ref=source_ref)
if provider.isExpressionFunctionBody():
provider.markAsExecContaining()
if orig_globals is None:
provider.markAsUnqualifiedExecContaining(source_ref)
temp_scope = provider.allocateTempScope("exec")
locals_value = buildNode(provider, exec_locals, source_ref, True)
if locals_value is None:
locals_value = ExpressionConstantRef(constant=None,
source_ref=source_ref)
globals_value = buildNode(provider, exec_globals, source_ref, True)
if globals_value is None:
globals_value = ExpressionConstantRef(constant=None,
source_ref=source_ref)
source_code = buildNode(provider, body, source_ref)
source_variable = provider.allocateTempVariable(temp_scope=temp_scope,
name="exec_source")
globals_keeper_variable = provider.allocateTempVariable(
temp_scope=temp_scope, name="globals")
locals_keeper_variable = provider.allocateTempVariable(
temp_scope=temp_scope, name="locals")
plain_indicator_variable = provider.allocateTempVariable(
temp_scope=temp_scope, name="plain")
tried = makeStatementsSequenceFromStatements(
# First evaluate the source code expressions.
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=source_variable, source_ref=source_ref),
source=source_code,
source_ref=source_ref),
# Assign globals and locals temporary the values given, then fix it
# up, taking note in the "plain" temporary variable, if it was an
# "exec" statement with None arguments, in which case the copy back
# will be necessary.
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=globals_keeper_variable, source_ref=source_ref),
source=globals_value,
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=locals_keeper_variable, source_ref=source_ref),
source=locals_value,
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=plain_indicator_variable, source_ref=source_ref),
source=ExpressionConstantRef(constant=False,
source_ref=source_ref),
source_ref=source_ref),
StatementConditional(
condition=ExpressionComparisonIs(left=ExpressionTempVariableRef(
variable=globals_keeper_variable, source_ref=source_ref),
right=ExpressionConstantRef(
constant=None,
source_ref=source_ref),
source_ref=source_ref),
yes_branch=makeStatementsSequenceFromStatements(
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=globals_keeper_variable,
source_ref=source_ref),
source=ExpressionBuiltinGlobals(source_ref=source_ref),
source_ref=source_ref,
),
StatementConditional(
condition=ExpressionComparisonIs(
left=ExpressionTempVariableRef(
variable=locals_keeper_variable,
source_ref=source_ref),
right=ExpressionConstantRef(constant=None,
source_ref=source_ref),
source_ref=source_ref),
yes_branch=makeStatementsSequenceFromStatements(
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=locals_keeper_variable,
source_ref=source_ref),
source=ExpressionBuiltinLocals(
source_ref=source_ref),
source_ref=source_ref,
),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=plain_indicator_variable,
source_ref=source_ref),
source=ExpressionConstantRef(
constant=True, source_ref=source_ref),
source_ref=source_ref,
)),
no_branch=None,
source_ref=source_ref),
),
no_branch=makeStatementsSequenceFromStatements(
StatementConditional(
condition=ExpressionComparisonIs(
left=ExpressionTempVariableRef(
variable=locals_keeper_variable,
source_ref=source_ref),
right=ExpressionConstantRef(constant=None,
source_ref=source_ref),
source_ref=source_ref),
yes_branch=makeStatementsSequenceFromStatement(
statement=StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=locals_keeper_variable,
source_ref=source_ref),
source=ExpressionTempVariableRef(
variable=globals_keeper_variable,
source_ref=source_ref),
source_ref=source_ref,
)),
no_branch=None,
source_ref=source_ref)),
source_ref=source_ref),
# Source needs some special treatment for not done for "eval", if it's a
# file object, then must be read.
StatementConditional(
condition=ExpressionBuiltinIsinstance(
instance=ExpressionTempVariableRef(variable=source_variable,
source_ref=source_ref),
classes=ExpressionBuiltinAnonymousRef(
builtin_name="file",
source_ref=source_ref,
),
source_ref=source_ref),
yes_branch=makeStatementsSequenceFromStatement(
statement=StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=source_variable, source_ref=source_ref),
source=ExpressionCallEmpty(
called=ExpressionAttributeLookup(
source=ExpressionTempVariableRef(
variable=source_variable,
source_ref=source_ref),
attribute_name="read",
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref)),
no_branch=None,
source_ref=source_ref),
StatementTryFinally(
tried=makeStatementsSequenceFromStatement(statement=StatementExec(
source_code=ExpressionTempVariableRef(variable=source_variable,
source_ref=source_ref),
globals_arg=ExpressionTempVariableRef(
variable=globals_keeper_variable, source_ref=source_ref),
locals_arg=ExpressionTempVariableRef(
variable=locals_keeper_variable, source_ref=source_ref),
source_ref=source_ref)),
final=makeStatementsSequenceFromStatements(
StatementConditional(
condition=ExpressionComparisonIs(
left=ExpressionTempVariableRef(
variable=plain_indicator_variable,
source_ref=source_ref),
right=ExpressionConstantRef(constant=True,
source_ref=source_ref),
source_ref=source_ref),
yes_branch=makeStatementsSequenceFromStatement(
statement=StatementLocalsDictSync(
locals_arg=ExpressionTempVariableRef(
variable=locals_keeper_variable,
source_ref=source_ref,
),
source_ref=source_ref.atInternal())),
no_branch=None,
source_ref=source_ref), ),
public_exc=False,
source_ref=source_ref))
final = makeStatementsSequenceFromStatements(
StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=source_variable, source_ref=source_ref),
tolerant=True,
source_ref=source_ref),
StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=globals_keeper_variable, source_ref=source_ref),
tolerant=True,
source_ref=source_ref),
StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=locals_keeper_variable, source_ref=source_ref),
tolerant=True,
source_ref=source_ref),
StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=plain_indicator_variable, source_ref=source_ref),
tolerant=True,
source_ref=source_ref),
)
return StatementTryFinally(tried=tried,
final=final,
public_exc=False,
source_ref=source_ref)
def wrapEvalGlobalsAndLocals(provider, globals_node, locals_node, exec_mode,
source_ref):
""" Wrap the locals and globals arguments for eval and exec.
For eval, this is called from the outside, and when the node tree
already exists.
"""
if globals_node is not None:
global_keeper_variable = provider.allocateTempKeeperVariable()
tmp_global_assign = ExpressionAssignmentTempKeeper(
variable=global_keeper_variable.makeReference(provider),
source=globals_node,
source_ref=source_ref)
globals_wrap = ExpressionConditional(
condition=ExpressionComparisonIs(left=tmp_global_assign,
right=ExpressionConstantRef(
constant=None,
source_ref=source_ref),
source_ref=source_ref),
no_expression=ExpressionTempKeeperRef(
variable=global_keeper_variable.makeReference(provider),
source_ref=source_ref),
yes_expression=ExpressionBuiltinGlobals(source_ref=source_ref),
source_ref=source_ref)
else:
globals_wrap = ExpressionBuiltinGlobals(source_ref=source_ref)
if locals_node is not None:
local_keeper_variable = provider.allocateTempKeeperVariable()
tmp_local_assign = ExpressionAssignmentTempKeeper(
variable=local_keeper_variable.makeReference(provider),
source=locals_node,
source_ref=source_ref)
if exec_mode:
locals_fallback = ExpressionBuiltinLocals(source_ref=source_ref)
else:
locals_fallback = ExpressionConditional(
condition=ExpressionComparisonIs(left=ExpressionTempKeeperRef(
variable=global_keeper_variable.makeReference(provider),
source_ref=source_ref),
right=ExpressionConstantRef(
constant=None,
source_ref=source_ref),
source_ref=source_ref),
no_expression=ExpressionTempKeeperRef(
variable=global_keeper_variable.makeReference(provider),
source_ref=source_ref),
yes_expression=ExpressionBuiltinLocals(source_ref=source_ref),
source_ref=source_ref)
locals_wrap = ExpressionConditional(
condition=ExpressionComparisonIs(left=tmp_local_assign,
right=ExpressionConstantRef(
constant=None,
source_ref=source_ref),
source_ref=source_ref),
no_expression=ExpressionTempKeeperRef(
variable=local_keeper_variable.makeReference(provider),
source_ref=source_ref),
yes_expression=locals_fallback,
source_ref=source_ref)
else:
if globals_node is None:
locals_wrap = ExpressionBuiltinLocals(source_ref=source_ref)
else:
locals_wrap = ExpressionTempKeeperRef(
variable=global_keeper_variable.makeReference(provider),
source_ref=source_ref)
return globals_wrap, locals_wrap