def _buildInplaceAssignVariableNode(variable_ref, tmp_variable1, tmp_variable2,
operator, expression, source_ref):
assert variable_ref.isExpressionTargetVariableRef(), variable_ref
# First assign the target value to a temporary variable.
preserve_to_tmp = StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(variable=tmp_variable1,
source_ref=source_ref),
source=ExpressionVariableRef(
variable_name=variable_ref.getVariableName(),
source_ref=source_ref),
source_ref=source_ref)
# Second assign the inplace result to a temporary variable
inplace_to_tmp = StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(variable=tmp_variable2,
source_ref=source_ref),
source=ExpressionOperationBinaryInplace(operator=operator,
left=ExpressionTempVariableRef(
variable=tmp_variable1,
source_ref=source_ref),
right=expression,
source_ref=source_ref),
source_ref=source_ref)
# Third, copy it over, if the reference values change, i.e. IsNot is true.
copy_back_from_tmp = StatementConditional(
condition=ExpressionComparisonIsNOT(
left=ExpressionTempVariableRef(variable=tmp_variable1,
source_ref=source_ref),
right=ExpressionTempVariableRef(variable=tmp_variable2,
source_ref=source_ref),
source_ref=source_ref),
yes_branch=makeStatementsSequenceFromStatement(
statement=StatementAssignmentVariable(
variable_ref=variable_ref.makeCloneAt(source_ref),
source=ExpressionTempVariableRef(variable=tmp_variable2,
source_ref=source_ref),
source_ref=source_ref)),
no_branch=None,
source_ref=source_ref)
return (
preserve_to_tmp,
# making sure the above temporary variable is deleted in any case.
makeTryFinallyStatement(
tried=(inplace_to_tmp, copy_back_from_tmp),
final=(
StatementDelVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_variable1, source_ref=source_ref),
tolerant=False,
source_ref=source_ref),
StatementDelVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_variable2, source_ref=source_ref),
tolerant=True,
source_ref=source_ref),
),
source_ref=source_ref))
def buildOrNode(provider, values, source_ref):
values = list(values)
result = values[-1]
del values[-1]
temp_scope = None
count = 1
while values:
if temp_scope is None:
temp_scope = provider.allocateTempScope(name="or")
keeper_variable = provider.allocateTempVariable(temp_scope=temp_scope,
name="value_%d" %
count)
count += 1
tried = StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=keeper_variable, source_ref=source_ref),
source=values[-1],
source_ref=source_ref,
)
result = makeTryFinallyExpression(
tried=tried,
final=None,
expression=ExpressionConditional(
condition=ExpressionTempVariableRef(variable=keeper_variable,
source_ref=source_ref),
yes_expression=ExpressionTempVariableRef(
variable=keeper_variable, source_ref=source_ref),
no_expression=makeTryFinallyExpression(
expression=result,
final=None,
tried=StatementDelVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=keeper_variable, source_ref=source_ref),
tolerant=False,
source_ref=source_ref,
),
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref)
wrapTryFinallyLater(
result,
StatementDelVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=keeper_variable, source_ref=source_ref),
tolerant=True,
source_ref=source_ref,
))
del values[-1]
return result
def makeTryExceptNoRaise(provider, temp_scope, tried, handling, no_raise,
public_exc, source_ref):
# This helper executes the core re-formulation of "no_raise" blocks, which
# are the "else" blocks of "try"/"except" statements. In order to limit the
# execution, we use an indicator variable instead, which will signal that
# the tried block executed up to the end. And then we make the else block be
# a conditional statement checking that.
assert no_raise is not None
tmp_handler_indicator_variable = provider.allocateTempVariable(
temp_scope=temp_scope, name="unhandled_indicator")
statements = mergeStatements((StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_handler_indicator_variable.makeReference(provider),
source_ref=source_ref.atInternal()),
source=ExpressionConstantRef(constant=False, source_ref=source_ref),
source_ref=no_raise.getSourceReference().atInternal()), handling),
allow_none=True)
handling = StatementsSequence(statements=statements, source_ref=source_ref)
tried = (StatementTryExcept(tried=tried,
handling=handling,
public_exc=public_exc,
source_ref=source_ref),
StatementConditional(condition=ExpressionComparisonIs(
left=ExpressionTempVariableRef(
variable=tmp_handler_indicator_variable.makeReference(
provider),
source_ref=source_ref),
right=ExpressionConstantRef(constant=True,
source_ref=source_ref),
source_ref=source_ref),
yes_branch=no_raise,
no_branch=None,
source_ref=source_ref))
final = StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_handler_indicator_variable.makeReference(provider),
source_ref=source_ref.atInternal()),
tolerant=False,
source_ref=source_ref.atInternal()),
return StatementsSequence(statements=(StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_handler_indicator_variable.makeReference(provider),
source_ref=source_ref.atInternal()),
source=ExpressionConstantRef(constant=True, source_ref=source_ref),
source_ref=source_ref.atInternal()),
makeTryFinallyStatement(
tried=tried,
final=final,
source_ref=source_ref)),
source_ref=source_ref)
def makeTryExceptNoRaise(provider, temp_scope, tried, handlers, no_raise,
source_ref):
# This helper executes the core re-formulation of "no_raise" blocks, which
# are the "else" blocks of "try"/"except" statements. In order to limit the
# execution, we use an indicator variable instead, which will signal that
# the tried block executed up to the end. And then we make the else block be
# a conditional statement checking that.
# This is a separate function, so it can be re-used in other
# re-formulations, e.g. with statements.
assert no_raise is not None
assert len(handlers) > 0
tmp_handler_indicator_variable = provider.allocateTempVariable(
temp_scope=temp_scope, name="unhandled_indicator")
for handler in handlers:
statements = (StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_handler_indicator_variable.makeReference(
provider),
source_ref=source_ref.atInternal()),
source=ExpressionConstantRef(constant=False,
source_ref=source_ref),
source_ref=no_raise.getSourceReference().atInternal()),
handler.getExceptionBranch())
handler.setExceptionBranch(
makeStatementsSequence(statements=statements,
allow_none=True,
source_ref=source_ref))
statements = (StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_handler_indicator_variable.makeReference(provider),
source_ref=source_ref.atInternal()),
source=ExpressionConstantRef(constant=True, source_ref=source_ref),
source_ref=source_ref),
StatementTryExcept(tried=tried,
handlers=handlers,
source_ref=source_ref),
StatementConditional(condition=ExpressionComparisonIs(
left=ExpressionTempVariableRef(
variable=tmp_handler_indicator_variable.
makeReference(provider),
source_ref=source_ref),
right=ExpressionConstantRef(constant=True,
source_ref=source_ref),
source_ref=source_ref),
yes_branch=no_raise,
no_branch=None,
source_ref=source_ref))
return StatementsSequence(statements=statements, source_ref=source_ref)
def _buildInplaceAssignSubscriptNode(subscribed, subscript, tmp_variable1,
tmp_variable2, operator, expression,
source_ref):
# First assign the subscribed value to a temporary variable.
preserve_to_tmp1 = StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(variable=tmp_variable1,
source_ref=source_ref),
source=subscribed,
source_ref=source_ref)
# Second assign the subscript value to a temporary variable
preserve_to_tmp2 = StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(variable=tmp_variable2,
source_ref=source_ref),
source=subscript,
source_ref=source_ref)
execute_in_place = StatementAssignmentSubscript(
expression=ExpressionTempVariableRef(variable=tmp_variable1,
source_ref=source_ref),
subscript=ExpressionTempVariableRef(variable=tmp_variable2,
source_ref=source_ref),
source=ExpressionOperationBinaryInplace(
operator=operator,
left=ExpressionSubscriptLookup(
subscribed=ExpressionTempVariableRef(variable=tmp_variable1,
source_ref=source_ref),
subscript=ExpressionTempVariableRef(variable=tmp_variable2,
source_ref=source_ref),
source_ref=source_ref),
right=expression,
source_ref=source_ref),
source_ref=source_ref)
# Note: No copy back is happening, for subscripts that is implied.
return (preserve_to_tmp1,
makeTryFinallyStatement(
tried=(
preserve_to_tmp2,
execute_in_place,
),
final=(StatementDelVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_variable1, source_ref=source_ref),
tolerant=False,
source_ref=source_ref),
StatementDelVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_variable2, source_ref=source_ref),
tolerant=True,
source_ref=source_ref)),
source_ref=source_ref))
def buildAssignNode(provider, node, source_ref):
assert len(node.targets) >= 1, source_ref
# Evaluate the right hand side first, so it can get names provided
# before the left hand side exists.
source = buildNode(provider, node.value, source_ref)
if len(node.targets) == 1:
# Simple assignment case, one source, one target.
return buildAssignmentStatements(provider=provider,
node=node.targets[0],
source=source,
source_ref=source_ref)
else:
# Complex assignment case, one source, but multiple targets. We keep the
# source in a temporary variable, and then assign from it multiple
# times.
temp_scope = provider.allocateTempScope("assign_unpack")
tmp_source = provider.allocateTempVariable(temp_scope=temp_scope,
name="assign_source")
statements = [
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_source.makeReference(provider),
source_ref=source_ref),
source=source,
source_ref=source_ref)
]
for target in node.targets:
statements.append(
buildAssignmentStatements(
provider=provider,
node=target,
source=ExpressionTempVariableRef(
variable=tmp_source.makeReference(provider),
source_ref=source_ref),
source_ref=source_ref))
statements.append(
StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_source.makeReference(provider),
source_ref=source_ref),
tolerant=False,
source_ref=source_ref))
return StatementsSequence(statements=statements, source_ref=source_ref)
def makeTryFinallyIndicator(statement, is_loop_exit):
statements = []
indicator_variables = getIndicatorVariables()
source_ref = statement.getSourceReference()
indicator_value = True
for indicator_variable in reversed(indicator_variables):
if indicator_variable is Ellipsis:
break
elif indicator_variable is not None:
statements.append(
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=indicator_variable,
source_ref=source_ref.atInternal()),
source=ExpressionConstantRef(constant=indicator_value,
source_ref=source_ref),
source_ref=source_ref.atInternal()))
elif is_loop_exit:
indicator_value = False
statements.append(statement)
return makeStatementsSequenceOrStatement(statements=statements,
source_ref=source_ref)
def _buildInplaceAssignAttributeNode(provider, lookup_source, attribute_name,
tmp_variable1, tmp_variable2, operator,
expression, source_ref):
return (
# First assign the target value to a temporary variable.
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_variable1.makeReference(provider),
source_ref=source_ref),
source=ExpressionAttributeLookup(
expression=lookup_source.makeCloneAt(source_ref),
attribute_name=attribute_name,
source_ref=source_ref),
source_ref=source_ref),
# Second assign the inplace result to a temporary variable.
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_variable2.makeReference(provider),
source_ref=source_ref),
source=ExpressionOperationBinaryInplace(
operator=operator,
left=ExpressionTempVariableRef(
variable=tmp_variable1.makeReference(provider),
source_ref=source_ref),
right=expression,
source_ref=source_ref),
source_ref=source_ref),
# Copy it over, if the reference values change, i.e. IsNot is true.
StatementConditional(
condition=ExpressionComparisonIsNOT(
left=ExpressionTempVariableRef(
variable=tmp_variable1.makeReference(provider),
source_ref=source_ref),
right=ExpressionTempVariableRef(
variable=tmp_variable2.makeReference(provider),
source_ref=source_ref),
source_ref=source_ref),
yes_branch=makeStatementsSequenceFromStatement(
statement=StatementAssignmentAttribute(
expression=lookup_source.makeCloneAt(source_ref),
attribute_name=attribute_name,
source=ExpressionTempVariableRef(
variable=tmp_variable2.makeReference(provider),
source_ref=source_ref),
source_ref=source_ref)),
no_branch=None,
source_ref=source_ref))
def _buildInplaceAssignVariableNode(result, variable_ref, tmp_variable1,
tmp_variable2, operator, expression,
source_ref):
assert variable_ref.isExpressionTargetVariableRef(), variable_ref
return (
# First assign the target value to a temporary variable.
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_variable1.makeReference(result),
source_ref=source_ref),
source=ExpressionVariableRef(
variable_name=variable_ref.getVariableName(),
source_ref=source_ref),
source_ref=source_ref),
# Second assign the inplace result to a temporary variable.
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_variable2.makeReference(result),
source_ref=source_ref),
source=ExpressionOperationBinaryInplace(
operator=operator,
left=ExpressionTempVariableRef(
variable=tmp_variable1.makeReference(result),
source_ref=source_ref),
right=expression,
source_ref=source_ref),
source_ref=source_ref),
# Copy it over, if the reference values change, i.e. IsNot is true.
StatementConditional(
condition=ExpressionComparisonIsNOT(
left=ExpressionTempVariableRef(
variable=tmp_variable1.makeReference(result),
source_ref=source_ref),
right=ExpressionTempVariableRef(
variable=tmp_variable2.makeReference(result),
source_ref=source_ref),
source_ref=source_ref),
yes_branch=makeStatementsSequenceFromStatement(
statement=StatementAssignmentVariable(
variable_ref=variable_ref.makeCloneAt(source_ref),
source=ExpressionTempVariableRef(
variable=tmp_variable2.makeReference(result),
source_ref=source_ref),
source_ref=source_ref)),
no_branch=None,
source_ref=source_ref))
def _buildInplaceAssignSubscriptNode(provider, subscribed, subscript,
tmp_variable1, tmp_variable2, operator,
expression, source_ref):
return (
# First assign the target value and subscript to temporary variables.
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_variable1.makeReference(provider),
source_ref=source_ref),
source=subscribed,
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_variable2.makeReference(provider),
source_ref=source_ref),
source=subscript,
source_ref=source_ref),
# Second assign the inplace result over the original value.
StatementAssignmentSubscript(
expression=ExpressionTempVariableRef(
variable=tmp_variable1.makeReference(provider),
source_ref=source_ref),
subscript=ExpressionTempVariableRef(
variable=tmp_variable2.makeReference(provider),
source_ref=source_ref),
source=ExpressionOperationBinaryInplace(
operator=operator,
left=ExpressionSubscriptLookup(
expression=ExpressionTempVariableRef(
variable=tmp_variable1.makeReference(provider),
source_ref=source_ref),
subscript=ExpressionTempVariableRef(
variable=tmp_variable2.makeReference(provider),
source_ref=source_ref),
source_ref=source_ref),
right=expression,
source_ref=source_ref),
source_ref=source_ref))
def buildAssignNode(provider, node, source_ref):
assert len(node.targets) >= 1, source_ref
# Evaluate the right hand side first, so it can get names provided
# before the left hand side exists.
source = buildNode(provider, node.value, source_ref)
if len(node.targets) == 1:
# Simple assignment case, one source, one target.
return buildAssignmentStatements(provider=provider,
node=node.targets[0],
source=source,
source_ref=source_ref)
else:
# Complex assignment case, one source, but multiple targets. We keep the source in
# a temporary variable, and then assign from it multiple times.
result = StatementTempBlock(source_ref=source_ref)
tmp_source = result.getTempVariable("assign_source")
statements = [
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_source.makeReference(result),
source_ref=source_ref),
source=source,
source_ref=source_ref)
]
for target in node.targets:
statements.append(
buildAssignmentStatements(
provider=provider,
node=target,
source=ExpressionTempVariableRef(
variable=tmp_source.makeReference(result),
source_ref=source_ref),
source_ref=source_ref))
result.setBody(
StatementsSequence(statements=statements, source_ref=source_ref))
return result
def makeTryFinallyIndicatorStatements(is_loop_exit, source_ref):
statements = []
indicator_variables = getIndicatorVariables()
indicator_value = True
for indicator_variable in reversed(indicator_variables):
if indicator_variable is Ellipsis:
break
elif indicator_variable is not None:
statements.append(
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=indicator_variable,
source_ref=source_ref.atInternal()),
source=ExpressionConstantRef(constant=indicator_value,
source_ref=source_ref),
source_ref=source_ref.atInternal().atLineNumber(55)))
elif is_loop_exit:
indicator_value = False
return statements
def buildTryFinallyNode(provider, build_tried, node, source_ref):
if Utils.python_version < 300:
# Prevent "continue" statements in the final blocks
pushBuildContext("finally")
final = buildStatementsNode(provider=provider,
nodes=node.finalbody,
source_ref=source_ref)
popBuildContext()
return StatementTryFinally(
tried=build_tried(),
final=final,
public_exc=Utils.python_version >= 300, # TODO: Use below code
source_ref=source_ref)
else:
temp_scope = provider.allocateTempScope("try_finally")
tmp_indicator_var = provider.allocateTempVariable(
temp_scope=temp_scope, name="unhandled_indicator")
# This makes sure, we set the indicator variables for "break",
# "continue" and "return" exits as well to true, so we can
# know if an exception occurred or not.
pushIndicatorVariable(tmp_indicator_var)
statements = (StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_indicator_var,
source_ref=source_ref.atInternal()),
source=ExpressionConstantRef(constant=False,
source_ref=source_ref),
source_ref=source_ref.atInternal()), build_tried(),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_indicator_var,
source_ref=source_ref.atInternal()),
source=ExpressionConstantRef(
constant=True,
source_ref=source_ref.atLineNumber(99)),
source_ref=source_ref.atInternal()))
# Prevent "continue" statements in the final blocks, these have to
# become "SyntaxError".
pushBuildContext("finally")
final = buildStatementsNode(provider=provider,
nodes=node.finalbody,
source_ref=source_ref)
popBuildContext()
popIndicatorVariable()
tried = StatementsSequence(statements=mergeStatements(statements,
allow_none=True),
source_ref=source_ref)
prelude = StatementConditional(
condition=ExpressionComparisonIs(
left=ExpressionTempVariableRef(
variable=tmp_indicator_var,
source_ref=source_ref.atInternal()),
right=ExpressionConstantRef(constant=False,
source_ref=source_ref),
source_ref=source_ref),
yes_branch=StatementsSequence(
statements=(StatementPreserveFrameException(
source_ref=source_ref.atInternal()),
StatementPublishException(
source_ref=source_ref.atInternal())),
source_ref=source_ref.atInternal()),
no_branch=None,
source_ref=source_ref.atInternal())
postlude = (StatementConditional(
condition=ExpressionComparisonIs(
left=ExpressionTempVariableRef(
variable=tmp_indicator_var,
source_ref=source_ref.atInternal()),
right=ExpressionConstantRef(constant=False,
source_ref=source_ref),
source_ref=source_ref),
yes_branch=StatementsSequence(statements=(
StatementReleaseVariable(variable=tmp_indicator_var,
tolerant=False,
source_ref=source_ref.atInternal()),
StatementReraiseFrameException(
source_ref=source_ref.atInternal()),
),
source_ref=source_ref.atInternal()),
no_branch=StatementsSequence(statements=(StatementReleaseVariable(
variable=tmp_indicator_var,
tolerant=False,
source_ref=source_ref.atInternal()), ),
source_ref=source_ref.atInternal()),
source_ref=source_ref.atInternal()), )
final = StatementsSequence(statements=mergeStatements((
prelude,
makeTryFinallyStatement(tried=final,
final=postlude,
source_ref=source_ref.atInternal()),
)),
source_ref=source_ref.atInternal())
return StatementTryFinally(tried=tried,
final=final,
public_exc=True,
source_ref=source_ref)
def buildTryFinallyNode(provider, build_tried, node, source_ref):
if Utils.python_version < 300:
# Prevent "continue" statements in the final blocks
pushBuildContext("finally")
final = buildStatementsNode(
provider = provider,
nodes = node.finalbody,
source_ref = source_ref
)
popBuildContext()
return StatementTryFinally(
tried = build_tried(),
final = final,
public_exc = Utils.python_version >= 300, # TODO: Use below code
source_ref = source_ref
)
else:
temp_scope = provider.allocateTempScope("try_finally")
tmp_indicator_var = provider.allocateTempVariable(
temp_scope = temp_scope,
name = "unhandled_indicator"
)
pushIndicatorVariable(tmp_indicator_var)
statements = (
StatementAssignmentVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_indicator_var.makeReference(
provider
),
source_ref = source_ref.atInternal()
),
source = ExpressionConstantRef(
constant = False,
source_ref = source_ref
),
source_ref = source_ref.atInternal()
),
build_tried(),
StatementAssignmentVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_indicator_var.makeReference(
provider
),
source_ref = source_ref.atInternal()
),
source = ExpressionConstantRef(
constant = True,
source_ref = source_ref
),
source_ref = source_ref.atInternal()
)
)
# Prevent "continue" statements in the final blocks
pushBuildContext("finally")
final = buildStatementsNode(
provider = provider,
nodes = node.finalbody,
source_ref = source_ref
)
popBuildContext()
popIndicatorVariable()
tried = StatementsSequence(
statements = mergeStatements(statements, allow_none = True),
source_ref = source_ref
)
prelude = StatementConditional(
condition = ExpressionComparisonIs(
left = ExpressionTempVariableRef(
variable = tmp_indicator_var.makeReference(
provider
),
source_ref = source_ref.atInternal()
),
right = ExpressionConstantRef(
constant = False,
source_ref = source_ref
),
source_ref = source_ref
),
yes_branch = StatementsSequence(
statements = (
StatementPreserveFrameException(
source_ref = source_ref.atInternal()
),
StatementPublishException(
source_ref = source_ref.atInternal()
)
),
source_ref = source_ref.atInternal()
),
no_branch = None,
source_ref = source_ref.atInternal()
)
postlude = (
StatementConditional(
condition = ExpressionComparisonIs(
left = ExpressionTempVariableRef(
variable = tmp_indicator_var.makeReference(
provider
),
source_ref = source_ref.atInternal()
),
right = ExpressionConstantRef(
constant = False,
source_ref = source_ref
),
source_ref = source_ref
),
yes_branch = StatementsSequence(
statements = (
StatementDelVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_indicator_var.makeReference(
provider
),
source_ref = source_ref.atInternal()
),
tolerant = False,
source_ref = source_ref.atInternal()
),
StatementReraiseFrameException(
source_ref = source_ref.atInternal()
),
),
source_ref = source_ref.atInternal()
),
no_branch = StatementsSequence(
statements = (
StatementDelVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_indicator_var.makeReference(
provider
),
source_ref = source_ref.atInternal()
),
tolerant = False,
source_ref = source_ref.atInternal()
),
),
source_ref = source_ref.atInternal()
),
source_ref = source_ref.atInternal()
),
)
final = StatementsSequence(
statements = mergeStatements(
(
prelude,
makeTryFinallyStatement(
tried = final,
final = postlude,
source_ref = source_ref.atInternal()
),
)
),
source_ref = source_ref.atInternal()
)
return StatementTryFinally(
tried = tried,
final = final,
public_exc = True,
source_ref = source_ref
)
def buildLambdaNode(provider, node, source_ref):
assert getKind(node) == "Lambda"
parameters = buildParameterSpec(provider, "<lambda>", node, source_ref)
function_body = ExpressionFunctionBody(
provider=provider,
name="<lambda>",
doc=None,
parameters=parameters,
source_ref=source_ref,
)
defaults = buildNodeList(provider, node.args.defaults, source_ref)
kw_defaults = buildParameterKwDefaults(provider=provider,
node=node,
function_body=function_body,
source_ref=source_ref)
body = buildNode(
provider=function_body,
node=node.body,
source_ref=source_ref,
)
if function_body.isGenerator():
if Utils.python_version < 270:
tmp_return_value = function_body.allocateTempVariable(
temp_scope=None, name="yield_return")
statements = (StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_return_value,
source_ref=source_ref,
),
source=body,
source_ref=source_ref),
StatementConditional(
condition=ExpressionComparisonIsNOT(
left=ExpressionTempVariableRef(
variable=tmp_return_value,
source_ref=source_ref,
),
right=ExpressionConstantRef(
constant=None, source_ref=source_ref),
source_ref=source_ref),
yes_branch=makeStatementsSequenceFromStatement(
statement=StatementExpressionOnly(
expression=ExpressionYield(
expression=ExpressionTempVariableRef(
variable=tmp_return_value,
source_ref=source_ref,
),
source_ref=source_ref),
source_ref=source_ref)),
no_branch=None,
source_ref=source_ref))
body = makeTryFinallyStatement(tried=statements,
final=StatementReleaseVariable(
variable=tmp_return_value,
tolerant=True,
source_ref=source_ref),
source_ref=source_ref)
else:
body = StatementExpressionOnly(expression=body,
source_ref=source_ref)
else:
body = StatementReturn(expression=body, source_ref=source_ref)
body = StatementsFrame(
statements=mergeStatements((body, )),
guard_mode="generator" if function_body.isGenerator() else "full",
var_names=parameters.getCoArgNames(),
arg_count=parameters.getArgumentCount(),
kw_only_count=parameters.getKwOnlyParameterCount(),
has_starlist=parameters.getStarListArgumentName() is not None,
has_stardict=parameters.getStarDictArgumentName() is not None,
code_name="<lambda>",
source_ref=body.getSourceReference())
body = makeStatementsSequenceFromStatement(statement=body, )
function_body.setBody(body)
annotations = buildParameterAnnotations(provider, node, source_ref)
return ExpressionFunctionCreation(function_ref=ExpressionFunctionRef(
function_body=function_body, source_ref=source_ref),
defaults=defaults,
kw_defaults=kw_defaults,
annotations=annotations,
source_ref=source_ref)
def buildExecNode(provider, node, source_ref):
# "exec" statements, should only occur with Python2.
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")
globals_ref, locals_ref, tried, final = wrapEvalGlobalsAndLocals(
provider=provider,
globals_node=buildNode(provider, exec_globals, source_ref, True),
locals_node=buildNode(provider, exec_locals, source_ref, True),
temp_scope=temp_scope,
source_ref=source_ref)
source_code = buildNode(provider, body, source_ref)
source_variable = provider.allocateTempVariable(temp_scope=temp_scope,
name="source")
# Source needs some special treatment for eval, if it's a string, it
# must be stripped.
file_fixup = [
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=source_variable.makeReference(provider),
source_ref=source_ref),
source=ExpressionCallEmpty(called=ExpressionAttributeLookup(
expression=ExpressionTempVariableRef(
variable=source_variable.makeReference(provider),
source_ref=source_ref),
attribute_name="read",
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref)
]
statements = (StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=source_variable.makeReference(provider),
source_ref=source_ref),
source=source_code,
source_ref=source_ref,
),
StatementConditional(condition=ExpressionBuiltinIsinstance(
cls=ExpressionBuiltinAnonymousRef(
builtin_name="file",
source_ref=source_ref,
),
instance=ExpressionTempVariableRef(
variable=source_variable.makeReference(provider),
source_ref=source_ref),
source_ref=source_ref),
yes_branch=StatementsSequence(
statements=file_fixup,
source_ref=source_ref),
no_branch=None,
source_ref=source_ref),
StatementExec(source_code=ExpressionTempVariableRef(
variable=source_variable.makeReference(provider),
source_ref=source_ref),
globals_arg=globals_ref,
locals_arg=locals_ref,
source_ref=source_ref))
tried.setChild("statements", tried.getStatements() + statements)
final.setStatements(final.getStatements() + (
StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=source_variable.makeReference(provider),
source_ref=source_ref),
tolerant=True,
source_ref=source_ref), ))
return StatementTryFinally(tried=tried,
final=final,
public_exc=False,
source_ref=source_ref)
def _buildWithNode(provider, context_expr, assign_target, body, source_ref):
with_source = buildNode(provider, context_expr, source_ref)
temp_scope = provider.allocateTempScope("with")
tmp_source_variable = provider.allocateTempVariable(temp_scope=temp_scope,
name="source")
tmp_exit_variable = provider.allocateTempVariable(temp_scope=temp_scope,
name="exit")
tmp_enter_variable = provider.allocateTempVariable(temp_scope=temp_scope,
name="enter")
tmp_indicator_variable = provider.allocateTempVariable(
temp_scope=temp_scope, name="indicator")
statements = (buildAssignmentStatements(provider=provider,
node=assign_target,
allow_none=True,
source=ExpressionTempVariableRef(
variable=tmp_enter_variable,
source_ref=source_ref),
source_ref=source_ref), body)
with_body = makeStatementsSequence(statements=statements,
allow_none=True,
source_ref=source_ref)
if Options.isFullCompat() and with_body is not None:
with_exit_source_ref = with_body.getStatements()[-1].\
getSourceReference()
else:
with_exit_source_ref = source_ref
# The "__enter__" and "__exit__" were normal attribute lookups under
# CPython2.6, but that changed with CPython2.7.
if Utils.python_version < 270:
attribute_lookup_class = ExpressionAttributeLookup
else:
attribute_lookup_class = ExpressionSpecialAttributeLookup
statements = [
# First assign the with context to a temporary variable.
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_source_variable, source_ref=source_ref),
source=with_source,
source_ref=source_ref),
# Next, assign "__enter__" and "__exit__" attributes to temporary
# variables.
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_exit_variable, source_ref=source_ref),
source=attribute_lookup_class(source=ExpressionTempVariableRef(
variable=tmp_source_variable, source_ref=source_ref),
attribute_name="__exit__",
source_ref=source_ref),
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_enter_variable, source_ref=source_ref),
source=ExpressionCallEmpty(called=attribute_lookup_class(
source=ExpressionTempVariableRef(variable=tmp_source_variable,
source_ref=source_ref),
attribute_name="__enter__",
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref),
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_indicator_variable, source_ref=source_ref),
source=ExpressionConstantRef(constant=True, source_ref=source_ref),
source_ref=source_ref),
]
source_ref = source_ref.atInternal()
statements += [
makeTryFinallyStatement(
tried=makeTryExceptSingleHandlerNode(
tried=with_body,
exception_name="BaseException",
handler_body=StatementsSequence(
statements=(
# Prevents final block from calling __exit__ as
# well.
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_indicator_variable,
source_ref=source_ref),
source=ExpressionConstantRef(
constant=False, source_ref=source_ref),
source_ref=source_ref),
StatementConditional(
condition=ExpressionCallNoKeywords(
called=ExpressionTempVariableRef(
variable=tmp_exit_variable,
source_ref=source_ref),
args=ExpressionMakeTuple(
elements=(
ExpressionCaughtExceptionTypeRef(
source_ref=source_ref),
ExpressionCaughtExceptionValueRef(
source_ref=source_ref),
ExpressionCaughtExceptionTracebackRef(
source_ref=source_ref),
),
source_ref=source_ref),
source_ref=source_ref),
no_branch=makeStatementsSequenceFromStatement(
statement=StatementRaiseException(
exception_type=None,
exception_value=None,
exception_trace=None,
exception_cause=None,
source_ref=source_ref)),
yes_branch=None,
source_ref=source_ref),
),
source_ref=source_ref),
public_exc=Utils.python_version >= 270,
source_ref=source_ref),
final=StatementConditional(
condition=ExpressionComparisonIs(
left=ExpressionTempVariableRef(
variable=tmp_indicator_variable,
source_ref=source_ref),
right=ExpressionConstantRef(constant=True,
source_ref=source_ref),
source_ref=source_ref),
yes_branch=makeStatementsSequenceFromStatement(
statement=StatementExpressionOnly(
expression=ExpressionCallNoKeywords(
called=ExpressionTempVariableRef(
variable=tmp_exit_variable,
source_ref=source_ref),
args=ExpressionConstantRef(constant=(None, None,
None),
source_ref=source_ref),
source_ref=with_exit_source_ref),
source_ref=source_ref)),
no_branch=None,
source_ref=source_ref),
source_ref=source_ref)
]
return makeTryFinallyStatement(
tried=statements,
final=(
StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_source_variable, source_ref=source_ref),
tolerant=True,
source_ref=source_ref),
StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_enter_variable, source_ref=source_ref),
tolerant=True,
source_ref=source_ref),
StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_exit_variable, source_ref=source_ref),
tolerant=True,
source_ref=source_ref),
StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_indicator_variable, source_ref=source_ref),
tolerant=True,
source_ref=source_ref),
),
source_ref=source_ref)
def _buildContractionBodyNode(provider, node, emit_class, start_value,
container_tmp, outer_iter_ref, temp_scope,
assign_provider, source_ref, function_body):
if start_value is not None:
statements = [
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=container_tmp.makeReference(function_body),
source_ref=source_ref),
source=start_value,
source_ref=source_ref.atInternal())
]
if assign_provider:
tmp_variables = []
else:
tmp_variables = [container_tmp]
else:
statements = []
tmp_variables = []
if hasattr(node, "elt"):
if start_value is not None:
current_body = emit_class(ExpressionTempVariableRef(
variable=container_tmp.makeReference(function_body),
source_ref=source_ref),
buildNode(provider=function_body,
node=node.elt,
source_ref=source_ref),
source_ref=source_ref)
else:
assert emit_class is ExpressionYield
function_body.markAsGenerator()
current_body = emit_class(buildNode(provider=function_body,
node=node.elt,
source_ref=source_ref),
source_ref=source_ref)
else:
assert emit_class is ExpressionDictOperationSet
current_body = emit_class(ExpressionTempVariableRef(
variable=container_tmp.makeReference(function_body),
source_ref=source_ref),
key=buildNode(
provider=function_body,
node=node.key,
source_ref=source_ref,
),
value=buildNode(
provider=function_body,
node=node.value,
source_ref=source_ref,
),
source_ref=source_ref)
current_body = StatementExpressionOnly(expression=current_body,
source_ref=source_ref)
for count, qual in enumerate(reversed(node.generators)):
tmp_value_variable = function_body.allocateTempVariable(
temp_scope=temp_scope, name="iter_value_%d" % count)
tmp_variables.append(tmp_value_variable)
# The first iterated value is to be calculated outside of the function
# and will be given as a parameter "_iterated", the others are built
# inside the function.
if qual is node.generators[0]:
def makeIteratorRef():
return outer_iter_ref.makeCloneAt(source_ref)
tmp_iter_variable = None
nested_statements = []
else:
# First create the iterator and store it, next should be loop body
value_iterator = ExpressionBuiltinIter1(value=buildNode(
provider=function_body, node=qual.iter, source_ref=source_ref),
source_ref=source_ref)
tmp_iter_variable = function_body.allocateTempVariable(
temp_scope=temp_scope, name="contraction_iter_%d" % count)
tmp_variables.append(tmp_iter_variable)
nested_statements = [
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_iter_variable.makeReference(
function_body),
source_ref=source_ref),
source=value_iterator,
source_ref=source_ref)
]
def makeIteratorRef():
return ExpressionTempVariableRef(
variable=tmp_iter_variable.makeReference(function_body),
source_ref=source_ref)
loop_statements = [
makeTryExceptSingleHandlerNode(
tried=makeStatementsSequenceFromStatement(
statement=StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_value_variable.makeReference(
function_body),
source_ref=source_ref),
source=ExpressionBuiltinNext1(value=makeIteratorRef(),
source_ref=source_ref),
source_ref=source_ref)),
exception_name="StopIteration",
handler_body=makeStatementsSequenceFromStatement(
statement=StatementBreakLoop(
source_ref=source_ref.atInternal())),
public_exc=False,
source_ref=source_ref),
buildAssignmentStatements(
provider=provider if assign_provider else function_body,
temp_provider=function_body,
node=qual.target,
source=ExpressionTempVariableRef(
variable=tmp_value_variable.makeReference(function_body),
source_ref=source_ref),
source_ref=source_ref)
]
conditions = buildNodeList(provider=function_body,
nodes=qual.ifs,
source_ref=source_ref)
if len(conditions) == 1:
loop_statements.append(
StatementConditional(
condition=conditions[0],
yes_branch=makeStatementsSequenceFromStatement(
statement=current_body),
no_branch=None,
source_ref=source_ref))
elif len(conditions) > 1:
loop_statements.append(
StatementConditional(
condition=buildAndNode(provider=function_body,
values=conditions,
source_ref=source_ref),
yes_branch=makeStatementsSequenceFromStatement(
statement=current_body),
no_branch=None,
source_ref=source_ref))
else:
loop_statements.append(current_body)
nested_statements.append(
StatementLoop(body=StatementsSequence(
statements=mergeStatements(loop_statements),
source_ref=source_ref),
source_ref=source_ref))
if tmp_iter_variable is not None:
nested_statements.append(
StatementDelVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_iter_variable.makeReference(
function_body),
source_ref=source_ref),
tolerant=False,
source_ref=source_ref))
current_body = StatementsSequence(statements=nested_statements,
source_ref=source_ref)
statements.append(current_body)
statements = mergeStatements(statements)
if emit_class is ExpressionYield:
statements.insert(0, StatementGeneratorEntry(source_ref=source_ref))
del_statements = []
for tmp_variable in tmp_variables:
del_statements.append(
StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_variable.makeReference(function_body),
source_ref=source_ref),
tolerant=True,
source_ref=source_ref.atInternal()))
return statements, del_statements
def _buildClassNode3(provider, node, source_ref):
# Many variables, due to the huge re-formulation that is going on here,
# which just has the complexity, pylint: disable=R0914
# This function is the Python3 special case with special re-formulation as
# according to developer manual.
class_statements, class_doc = extractDocFromBody(node)
# We need a scope for the temporary variables, and they might be closured.
temp_scope = provider.allocateTempScope(
name = "class_creation",
allow_closure = True
)
tmp_bases = provider.allocateTempVariable(
temp_scope = temp_scope,
name = "bases"
)
tmp_class_decl_dict = provider.allocateTempVariable(
temp_scope = temp_scope,
name = "class_decl_dict"
)
tmp_metaclass = provider.allocateTempVariable(
temp_scope = temp_scope,
name = "metaclass"
)
tmp_prepared = provider.allocateTempVariable(
temp_scope = temp_scope,
name = "prepared"
)
class_creation_function = ExpressionFunctionBody(
provider = provider,
is_class = True,
parameters = make_class_parameters,
name = node.name,
doc = class_doc,
source_ref = source_ref
)
# Hack: This allows some APIs to work although this is not yet officially a
# child yet.
class_creation_function.parent = provider
body = buildStatementsNode(
provider = class_creation_function,
nodes = class_statements,
frame = True,
source_ref = source_ref
)
source_ref_orig = source_ref
if body is not None:
# The frame guard has nothing to tell its line number to.
body.source_ref = source_ref
module_variable = class_creation_function.getVariableForAssignment(
"__module__"
)
statements = [
StatementSetLocals(
new_locals = ExpressionTempVariableRef(
variable = tmp_prepared,
source_ref = source_ref
),
source_ref = source_ref
),
StatementAssignmentVariable(
variable_ref = ExpressionTargetVariableRef(
variable_name = "__module__",
variable = module_variable,
source_ref = source_ref
),
source = ExpressionConstantRef(
constant = provider.getParentModule().getFullName(),
source_ref = source_ref,
user_provided = True
),
source_ref = source_ref
)
]
if class_doc is not None:
doc_variable = class_creation_function.getVariableForAssignment(
"__doc__"
)
statements.append(
StatementAssignmentVariable(
variable_ref = ExpressionTargetVariableRef(
variable_name = "__doc__",
variable = doc_variable,
source_ref = source_ref
),
source = ExpressionConstantRef(
constant = class_doc,
source_ref = source_ref,
user_provided = True
),
source_ref = source_ref
)
)
# The "__qualname__" attribute is new in Python 3.3.
if Utils.python_version >= 330:
qualname = class_creation_function.getFunctionQualname()
qualname_variable = class_creation_function.getVariableForAssignment(
"__qualname__"
)
if Utils.python_version < 340:
qualname_ref = ExpressionConstantRef(
constant = qualname,
source_ref = source_ref,
user_provided = True
)
else:
qualname_ref = ExpressionFunctionQualnameRef(
function_body = class_creation_function,
source_ref = source_ref,
)
statements.append(
StatementAssignmentVariable(
variable_ref = ExpressionTargetVariableRef(
variable_name = "__qualname__",
variable = qualname_variable,
source_ref = source_ref
),
source = qualname_ref,
source_ref = source_ref
)
)
if Utils.python_version >= 340:
qualname_assign = statements[-1]
if Utils.python_version >= 340 and False: # TODO: Temporarily reverted:
tmp_class = class_creation_function.allocateTempVariable(
temp_scope = None,
name = "__class__"
)
class_target_variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_class,
source_ref = source_ref
)
class_variable_ref = ExpressionTempVariableRef(
variable = tmp_class,
source_ref = source_ref
)
else:
class_variable = class_creation_function.getVariableForAssignment(
"__class__"
)
class_target_variable_ref = ExpressionTargetVariableRef(
variable_name = "__class__",
variable = class_variable,
source_ref = source_ref
)
class_variable_ref = ExpressionVariableRef(
variable_name = "__class__",
variable = class_variable,
source_ref = source_ref
)
statements += [
body,
StatementAssignmentVariable(
variable_ref = class_target_variable_ref,
source = ExpressionCall(
called = ExpressionTempVariableRef(
variable = tmp_metaclass,
source_ref = source_ref
),
args = makeSequenceCreationOrConstant(
sequence_kind = "tuple",
elements = (
ExpressionConstantRef(
constant = node.name,
source_ref = source_ref,
user_provided = True
),
ExpressionTempVariableRef(
variable = tmp_bases,
source_ref = source_ref
),
ExpressionBuiltinLocals(
source_ref = source_ref
)
),
source_ref = source_ref
),
kw = ExpressionTempVariableRef(
variable = tmp_class_decl_dict,
source_ref = source_ref
),
source_ref = source_ref
),
source_ref = source_ref
),
StatementReturn(
expression = class_variable_ref,
source_ref = source_ref
)
]
body = makeStatementsSequence(
statements = statements,
allow_none = True,
source_ref = source_ref
)
# The class body is basically a function that implicitly, at the end
# returns its locals and cannot have other return statements contained.
class_creation_function.setBody(body)
# The class body is basically a function that implicitly, at the end
# returns its created class and cannot have other return statements
# contained.
decorated_body = ExpressionFunctionCall(
function = ExpressionFunctionCreation(
function_ref = ExpressionFunctionRef(
function_body = class_creation_function,
source_ref = source_ref
),
defaults = (),
kw_defaults = None,
annotations = None,
source_ref = source_ref
),
values = (),
source_ref = source_ref
)
for decorator in buildNodeList(
provider,
reversed(node.decorator_list),
source_ref
):
decorated_body = ExpressionCallNoKeywords(
called = decorator,
args = ExpressionMakeTuple(
elements = (
decorated_body,
),
source_ref = source_ref
),
source_ref = decorator.getSourceReference()
)
statements = (
StatementAssignmentVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_bases,
source_ref = source_ref
),
source = makeSequenceCreationOrConstant(
sequence_kind = "tuple",
elements = buildNodeList(
provider, node.bases, source_ref
),
source_ref = source_ref
),
source_ref = source_ref
),
StatementAssignmentVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_class_decl_dict,
source_ref = source_ref
),
source = makeDictCreationOrConstant(
keys = [
ExpressionConstantRef(
constant = keyword.arg,
source_ref = source_ref,
user_provided = True
)
for keyword in
node.keywords
],
values = [
buildNode(provider, keyword.value, source_ref)
for keyword in
node.keywords
],
lazy_order = False,
source_ref = source_ref
),
source_ref = source_ref
),
StatementAssignmentVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_metaclass,
source_ref = source_ref
),
source = ExpressionSelectMetaclass(
metaclass = ExpressionConditional(
condition = ExpressionComparison(
comparator = "In",
left = ExpressionConstantRef(
constant = "metaclass",
source_ref = source_ref,
user_provided = True
),
right = ExpressionTempVariableRef(
variable = tmp_class_decl_dict,
source_ref = source_ref
),
source_ref = source_ref
),
yes_expression = ExpressionDictOperationGet(
dicte = ExpressionTempVariableRef(
variable = tmp_class_decl_dict,
source_ref = source_ref
),
key = ExpressionConstantRef(
constant = "metaclass",
source_ref = source_ref,
user_provided = True
),
source_ref = source_ref
),
no_expression = ExpressionConditional(
condition = ExpressionTempVariableRef(
variable = tmp_bases,
source_ref = source_ref
),
no_expression = ExpressionBuiltinRef(
builtin_name = "type",
source_ref = source_ref
),
yes_expression = ExpressionBuiltinType1(
value = ExpressionSubscriptLookup(
subscribed = ExpressionTempVariableRef(
variable = tmp_bases,
source_ref = source_ref
),
subscript = ExpressionConstantRef(
constant = 0,
source_ref = source_ref,
user_provided = True
),
source_ref = source_ref
),
source_ref = source_ref
),
source_ref = source_ref
),
source_ref = source_ref
),
bases = ExpressionTempVariableRef(
variable = tmp_bases,
source_ref = source_ref
),
source_ref = source_ref
),
source_ref = source_ref_orig
),
StatementConditional(
condition = ExpressionComparison(
comparator = "In",
left = ExpressionConstantRef(
constant = "metaclass",
source_ref = source_ref,
user_provided = True
),
right = ExpressionTempVariableRef(
variable = tmp_class_decl_dict,
source_ref = source_ref
),
source_ref = source_ref
),
no_branch = None,
yes_branch = makeStatementsSequenceFromStatement(
statement = StatementDictOperationRemove(
dicte = ExpressionTempVariableRef(
variable = tmp_class_decl_dict,
source_ref = source_ref
),
key = ExpressionConstantRef(
constant = "metaclass",
source_ref = source_ref,
user_provided = True
),
source_ref = source_ref
)
),
source_ref = source_ref
),
StatementAssignmentVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_prepared,
source_ref = source_ref
),
source = ExpressionConditional(
condition = ExpressionBuiltinHasattr(
object = ExpressionTempVariableRef(
variable = tmp_metaclass,
source_ref = source_ref
),
name = ExpressionConstantRef(
constant = "__prepare__",
source_ref = source_ref,
user_provided = True
),
source_ref = source_ref
),
no_expression = ExpressionConstantRef(
constant = {},
source_ref = source_ref,
user_provided = True
),
yes_expression = ExpressionCall(
called = ExpressionAttributeLookup(
source = ExpressionTempVariableRef(
variable = tmp_metaclass,
source_ref = source_ref
),
attribute_name = "__prepare__",
source_ref = source_ref
),
args = ExpressionMakeTuple(
elements = (
ExpressionConstantRef(
constant = node.name,
source_ref = source_ref,
user_provided = True
),
ExpressionTempVariableRef(
variable = tmp_bases,
source_ref = source_ref
)
),
source_ref = source_ref
),
kw = ExpressionTempVariableRef(
variable = tmp_class_decl_dict,
source_ref = source_ref
),
source_ref = source_ref
),
source_ref = source_ref
),
source_ref = source_ref
),
StatementAssignmentVariable(
variable_ref = ExpressionTargetVariableRef(
variable_name = node.name,
source_ref = source_ref
),
source = decorated_body,
source_ref = source_ref
),
)
if Utils.python_version >= 340:
class_assign = statements[-1]
# assert False, class_creation_function
class_creation_function.qualname_setup = class_assign, qualname_assign
final = (
StatementDelVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_bases,
source_ref = source_ref
),
tolerant = True,
source_ref = source_ref
),
StatementDelVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_class_decl_dict,
source_ref = source_ref
),
tolerant = True,
source_ref = source_ref
),
StatementDelVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_metaclass,
source_ref = source_ref
),
tolerant = True,
source_ref = source_ref
),
StatementDelVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_prepared,
source_ref = source_ref
),
tolerant = True,
source_ref = source_ref
)
)
return makeTryFinallyStatement(
tried = statements,
final = final,
source_ref = source_ref
)
def wrapEvalBuiltin(source, globals, locals, source_ref):
provider = node.getParentVariableProvider()
temp_scope = provider.allocateTempScope("eval")
globals_ref, locals_ref, tried, final = wrapEvalGlobalsAndLocals(
provider = provider,
globals_node = globals,
locals_node = locals,
temp_scope = temp_scope,
source_ref = source_ref
)
# The wrapping should not relocate to the "source_ref".
assert globals is None or \
globals_ref.getSourceReference() == globals.getSourceReference()
assert locals is None or \
locals_ref.getSourceReference() == locals.getSourceReference()
source_variable = provider.allocateTempVariable(
temp_scope = temp_scope,
name = "source"
)
final.setStatements(
final.getStatements() + (
StatementDelVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = source_variable.makeReference(
provider
),
source_ref = source_ref
),
tolerant = True,
source_ref = source_ref
),
)
)
strip_choice = ExpressionConstantRef(
constant = (" \t",),
source_ref = source_ref
)
if python_version >= 300:
strip_choice = ExpressionConditional(
condition = ExpressionComparisonIs(
left = ExpressionBuiltinType1(
value = ExpressionTempVariableRef(
variable = source_variable.makeReference(
provider
),
source_ref = source_ref
),
source_ref = source_ref
),
right = ExpressionBuiltinRef(
builtin_name = "bytes",
source_ref = source_ref
),
source_ref = source_ref
),
yes_expression = ExpressionConstantRef(
constant = (b" \t",),
source_ref = source_ref
),
no_expression = strip_choice,
source_ref = source_ref
)
# Source needs some special treatment for eval, if it's a string, it
# must be stripped.
string_fixup = [
StatementAssignmentVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = source_variable.makeReference(
provider
),
source_ref = source_ref
),
source = ExpressionCallNoKeywords(
called = ExpressionAttributeLookup(
expression = ExpressionTempVariableRef(
variable = source_variable.makeReference(
provider
),
source_ref = source_ref
),
attribute_name = "strip",
source_ref = source_ref
),
args = strip_choice,
source_ref = source_ref
),
source_ref = source_ref
)
]
statements = (
StatementAssignmentVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = source_variable.makeReference(
provider
),
source_ref = source_ref
),
source = source,
source_ref = source_ref,
),
StatementConditional(
condition = ExpressionOperationNOT(
operand = ExpressionBuiltinIsinstance(
cls = ExpressionBuiltinAnonymousRef(
builtin_name = "code",
source_ref = source_ref,
),
instance = ExpressionTempVariableRef(
variable = source_variable.makeReference(
provider
),
source_ref = source_ref
),
source_ref = source_ref
),
source_ref = source_ref
),
yes_branch = StatementsSequence(
statements = string_fixup,
source_ref = source_ref
),
no_branch = None,
source_ref = source_ref
)
)
tried.setStatements(
tried.getStatements() + statements
)
return ExpressionTryFinally(
tried = tried,
expression = ExpressionBuiltinEval(
source_code = ExpressionTempVariableRef(
variable = source_variable.makeReference(
provider
),
source_ref = source_ref
),
globals_arg = globals_ref,
locals_arg = locals_ref,
source_ref = source_ref
),
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 buildLambdaNode(provider, node, source_ref):
assert getKind(node) == "Lambda"
function_body = ExpressionFunctionBody(
provider=provider,
name="<lambda>",
doc=None,
parameters=buildParameterSpec("<lambda>", node, source_ref),
source_ref=source_ref,
)
defaults = buildNodeList(provider, node.args.defaults, source_ref)
kw_defaults = buildParameterKwDefaults(provider, node, function_body,
source_ref)
body = buildNode(
provider=function_body,
node=node.body,
source_ref=source_ref,
)
if function_body.isGenerator():
if Utils.python_version < 270:
temp_block = StatementTempBlock(source_ref=source_ref, )
tmp_return_value = temp_block.getTempVariable("yield_return")
statements = (StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_return_value.makeReference(temp_block),
source_ref=source_ref,
),
source=body,
source_ref=source_ref),
StatementConditional(
condition=ExpressionComparisonIsNOT(
left=ExpressionTempVariableRef(
variable=tmp_return_value.makeReference(
temp_block),
source_ref=source_ref,
),
right=ExpressionConstantRef(
constant=None, source_ref=source_ref),
source_ref=source_ref),
yes_branch=makeStatementsSequenceFromStatement(
statement=StatementExpressionOnly(
expression=ExpressionYield(
expression=ExpressionTempVariableRef(
variable=tmp_return_value.
makeReference(temp_block),
source_ref=source_ref,
),
source_ref=source_ref),
source_ref=source_ref)),
no_branch=None,
source_ref=source_ref))
temp_block.setBody(
StatementsSequence(statements=statements,
source_ref=source_ref))
body = temp_block
else:
body = StatementExpressionOnly(expression=body,
source_ref=source_ref)
else:
body = StatementReturn(expression=body, source_ref=source_ref)
body = StatementsFrame(
statements=(body, ),
guard_mode="generator" if function_body.isGenerator() else "full",
arg_names=function_body.getParameters().getCoArgNames(),
kw_only_count=function_body.getParameters().getKwOnlyParameterCount(),
code_name="<lambda>",
source_ref=body.getSourceReference())
function_body.setBody(body)
annotations = buildParameterAnnotations(provider, node, source_ref)
return ExpressionFunctionCreation(function_ref=ExpressionFunctionRef(
function_body=function_body, source_ref=source_ref),
defaults=defaults,
kw_defaults=kw_defaults,
annotations=annotations,
source_ref=source_ref)
def _buildClassNode2(provider, node, source_ref):
class_statements, class_doc = extractDocFromBody(node)
# This function is the Python2 special case with special re-formulation as
# according to developer manual.
function_body = ExpressionFunctionBody(
provider = provider,
is_class = True,
parameters = make_class_parameters,
name = node.name,
doc = class_doc,
source_ref = source_ref
)
body = buildStatementsNode(
provider = function_body,
nodes = class_statements,
frame = True,
source_ref = source_ref
)
if body is not None:
# The frame guard has nothing to tell its line number to.
body.source_ref = source_ref.atInternal()
# The class body is basically a function that implicitly, at the end
# returns its locals and cannot have other return statements contained, and
# starts out with a variables "__module__" and potentially "__doc__" set.
statements = [
StatementAssignmentVariable(
variable_ref = ExpressionTargetVariableRef(
variable_name = "__module__",
source_ref = source_ref
),
source = ExpressionConstantRef(
constant = provider.getParentModule().getFullName(),
source_ref = source_ref,
user_provided = True
),
source_ref = source_ref.atInternal()
)
]
if class_doc is not None:
statements.append(
StatementAssignmentVariable(
variable_ref = ExpressionTargetVariableRef(
variable_name = "__doc__",
source_ref = source_ref
),
source = ExpressionConstantRef(
constant = class_doc,
source_ref = source_ref,
user_provided = True
),
source_ref = source_ref.atInternal()
)
)
statements += [
body,
StatementReturn(
expression = ExpressionBuiltinLocals(
source_ref = source_ref
),
source_ref = source_ref.atInternal()
)
]
body = makeStatementsSequence(
statements = statements,
allow_none = True,
source_ref = source_ref
)
# The class body is basically a function that implicitly, at the end
# returns its locals and cannot have other return statements contained.
function_body.setBody(body)
temp_scope = provider.allocateTempScope("class_creation")
tmp_bases = provider.allocateTempVariable(temp_scope, "bases")
tmp_class_dict = provider.allocateTempVariable(temp_scope, "class_dict")
tmp_metaclass = provider.allocateTempVariable(temp_scope, "metaclass")
tmp_class = provider.allocateTempVariable(temp_scope, "class")
statements = [
StatementAssignmentVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_bases,
source_ref = source_ref
),
source = makeSequenceCreationOrConstant(
sequence_kind = "tuple",
elements = buildNodeList(
provider, node.bases, source_ref
),
source_ref = source_ref
),
source_ref = source_ref
),
StatementAssignmentVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_class_dict,
source_ref = source_ref
),
source = ExpressionFunctionCall(
function = ExpressionFunctionCreation(
function_ref = ExpressionFunctionRef(
function_body = function_body,
source_ref = source_ref
),
defaults = (),
kw_defaults = None,
annotations = None,
source_ref = source_ref
),
values = (),
source_ref = source_ref
),
source_ref = source_ref
),
StatementAssignmentVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_metaclass,
source_ref = source_ref
),
source = ExpressionConditional(
condition = ExpressionComparison(
comparator = "In",
left = ExpressionConstantRef(
constant = "__metaclass__",
source_ref = source_ref,
user_provided = True
),
right = ExpressionTempVariableRef(
variable = tmp_class_dict,
source_ref = source_ref
),
source_ref = source_ref
),
yes_expression = ExpressionDictOperationGet(
dicte = ExpressionTempVariableRef(
variable = tmp_class_dict,
source_ref = source_ref
),
key = ExpressionConstantRef(
constant = "__metaclass__",
source_ref = source_ref,
user_provided = True
),
source_ref = source_ref
),
no_expression = ExpressionSelectMetaclass(
metaclass = None,
bases = ExpressionTempVariableRef(
variable = tmp_bases,
source_ref = source_ref
),
source_ref = source_ref
),
source_ref = source_ref
),
source_ref = source_ref
),
StatementAssignmentVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_class,
source_ref = source_ref
),
source = ExpressionCallNoKeywords(
called = ExpressionTempVariableRef(
variable = tmp_metaclass,
source_ref = source_ref
),
args = ExpressionMakeTuple(
elements = (
ExpressionConstantRef(
constant = node.name,
source_ref = source_ref,
user_provided = True
),
ExpressionTempVariableRef(
variable = tmp_bases,
source_ref = source_ref
),
ExpressionTempVariableRef(
variable = tmp_class_dict,
source_ref = source_ref
)
),
source_ref = source_ref
),
source_ref = source_ref
),
source_ref = source_ref
),
]
for decorator in buildNodeList(
provider,
reversed(node.decorator_list),
source_ref
):
statements.append(
StatementAssignmentVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_class,
source_ref = source_ref
),
source = ExpressionCallNoKeywords(
called = decorator,
args = ExpressionMakeTuple(
elements = (
ExpressionTempVariableRef(
variable = tmp_class,
source_ref = source_ref
),
),
source_ref = source_ref
),
source_ref = decorator.getSourceReference()
),
source_ref = decorator.getSourceReference()
)
)
statements.append(
StatementAssignmentVariable(
variable_ref = ExpressionTargetVariableRef(
variable_name = node.name,
source_ref = source_ref
),
source = ExpressionTempVariableRef(
variable = tmp_class,
source_ref = source_ref
),
source_ref = source_ref
)
)
final = (
StatementDelVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_class,
source_ref = source_ref
),
tolerant = True,
source_ref = source_ref
),
StatementDelVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_bases,
source_ref = source_ref
),
tolerant = True,
source_ref = source_ref
),
StatementDelVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_class_dict,
source_ref = source_ref
),
tolerant = True,
source_ref = source_ref
),
StatementDelVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_metaclass,
source_ref = source_ref
),
tolerant = True,
source_ref = source_ref
)
)
return makeTryFinallyStatement(
tried = statements,
final = final,
source_ref = source_ref
)
def buildComparisonNode(provider, node, source_ref):
from nuitka.nodes.NodeMakingHelpers import makeComparisonNode
assert len(node.comparators) == len(node.ops)
# Comparisons are re-formulated as described in the developer manual. When
# having multiple compators, things require assignment expressions and
# references of them to work properly. Then they can become normal "and"
# code.
# The operands are split out
left = buildNode(provider, node.left, source_ref)
rights = [
buildNode(provider, comparator, source_ref)
for comparator in node.comparators
]
# Only the first comparison has as left operands as the real thing, the
# others must reference the previous comparison right one temp variable ref.
values = []
# For PyLint to like it, this will hold the previous one, normally.
keeper_variable = None
temp_scope = None
final = []
for comparator, right in zip(node.ops, rights):
if values:
# Now we know it's not the only one, so we change the "left" to be a
# reference to the previously saved right side.
left = ExpressionTempVariableRef(
variable=keeper_variable.makeReference(provider),
source_ref=source_ref)
keeper_variable = None
if right is not rights[-1]:
# Now we know it's not the last one, so we ought to preseve the
# "right" so it can be referenced by the next part that will
# come. We do it by assining it to a temp variable to be shared with
# the next part.
if temp_scope is None:
temp_scope = provider.allocateTempScope(name="comparison")
keeper_variable = provider.allocateTempVariable(
temp_scope=temp_scope,
name="value_%d" % (rights.index(right) + 2),
)
tried = StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=keeper_variable.makeReference(provider),
source_ref=source_ref),
source=right,
source_ref=source_ref,
)
# TODO: The delete must be placed later.
final.append(
StatementDelVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=keeper_variable.makeReference(provider),
source_ref=source_ref),
tolerant=True,
source_ref=source_ref,
))
right = makeTryFinallyExpression(
tried=tried,
final=None,
expression=ExpressionTempVariableRef(
variable=keeper_variable.makeReference(provider),
source_ref=source_ref),
source_ref=source_ref)
comparator = getKind(comparator)
values.append(
makeComparisonNode(left=left,
right=right,
comparator=comparator,
source_ref=source_ref))
assert keeper_variable is None
result = buildAndNode(provider=provider,
values=values,
source_ref=source_ref)
if final:
return makeTryFinallyExpression(tried=None,
expression=result,
final=final,
source_ref=source_ref)
else:
return result
def buildReturnNode(provider, node, source_ref):
if not provider.isExpressionFunctionBody() or \
provider.isClassDictCreation():
SyntaxErrors.raiseSyntaxError(
"'return' outside function",
source_ref,
None if Utils.python_version < 300 else (
node.col_offset
if provider.isPythonModule() else
node.col_offset+4
)
)
expression = buildNode(provider, node.value, source_ref, allow_none = True)
if expression is None:
expression = ExpressionConstantRef(
constant = None,
source_ref = source_ref,
user_provided = True
)
# Indicate exceptions to potentially try/finally structures.
indicator_statements = makeTryFinallyIndicatorStatements(
is_loop_exit = False,
source_ref = source_ref
)
if indicator_statements and expression.mayRaiseException(BaseException):
tmp_variable = provider.allocateTempVariable(
temp_scope = provider.allocateTempScope("return"),
name = "value"
)
statements = [
StatementAssignmentVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_variable,
source_ref = expression.getSourceReference()
),
source = expression,
source_ref = source_ref
)
] + indicator_statements + [
StatementReturn(
expression = ExpressionTempVariableRef(
variable = tmp_variable,
source_ref = expression.getSourceReference()
),
source_ref = source_ref
)
]
return makeTryFinallyStatement(
tried = statements,
final = StatementReleaseVariable(
variable = tmp_variable,
tolerant = True,
source_ref = source_ref
),
source_ref = source_ref
)
else:
return makeStatementsSequenceOrStatement(
statements = indicator_statements + [
StatementReturn(
expression = expression,
source_ref = source_ref
)
],
source_ref = source_ref
)
def buildWhileLoopNode(provider, node, source_ref):
# The while loop is re-formulated according to developer manual. The
# condition becomes an early condition to break the loop. The else block is
# taken if a while loop exits normally, i.e. because of condition not being
# true. We do this by introducing an indicator variable.
else_block = buildStatementsNode(
provider = provider,
nodes = node.orelse if node.orelse else None,
source_ref = source_ref
)
if else_block is not None:
temp_scope = provider.allocateTempScope("while_loop")
tmp_break_indicator = provider.allocateTempVariable(
temp_scope = temp_scope,
name = "break_indicator"
)
statements = (
StatementAssignmentVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_break_indicator,
source_ref = source_ref
),
source = ExpressionConstantRef(
constant = True,
source_ref = source_ref
),
source_ref = source_ref
),
StatementBreakLoop(
source_ref = source_ref
)
)
else:
statements = (
StatementBreakLoop(
source_ref = source_ref
),
)
pushBuildContext("loop_body")
pushIndicatorVariable(None)
loop_statements = buildStatementsNode(
provider = provider,
nodes = node.body,
source_ref = source_ref
)
popIndicatorVariable()
popBuildContext()
# The loop body contains a conditional statement at the start that breaks
# the loop if it fails.
loop_body = makeStatementsSequence(
statements = (
StatementConditional(
condition = buildNode(provider, node.test, source_ref),
no_branch = StatementsSequence(
statements = statements,
source_ref = source_ref
),
yes_branch = None,
source_ref = source_ref
),
loop_statements
),
allow_none = True,
source_ref = source_ref
)
loop_statement = StatementLoop(
body = loop_body,
source_ref = source_ref
)
if else_block is None:
return loop_statement
else:
statements = (
StatementAssignmentVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_break_indicator,
source_ref = source_ref
),
source = ExpressionConstantRef(
constant = False,
source_ref = source_ref
),
source_ref = source_ref
),
loop_statement,
StatementConditional(
condition = ExpressionComparisonIs(
left = ExpressionTempVariableRef(
variable = tmp_break_indicator,
source_ref = source_ref
),
right = ExpressionConstantRef(
constant = True,
source_ref = source_ref
),
source_ref = source_ref
),
yes_branch = else_block,
no_branch = None,
source_ref = source_ref
)
)
statements = (
makeTryFinallyStatement(
tried = statements,
final = StatementDelVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_break_indicator,
source_ref = source_ref
),
tolerant = False,
source_ref = source_ref
),
source_ref = source_ref
),
)
return StatementsSequence(
statements = statements,
source_ref = source_ref
)
def buildListContractionNode(provider, node, source_ref):
# List contractions are dealt with by general code.
if Utils.python_version < 300:
temp_scope = provider.allocateTempScope("listcontr")
outer_iter_var = provider.allocateTempVariable(temp_scope=temp_scope,
name="listcontr_iter")
outer_iter_ref = ExpressionTempVariableRef(
variable=outer_iter_var.makeReference(provider),
source_ref=source_ref)
container_tmp = provider.allocateTempVariable(temp_scope=temp_scope,
name="listcontr_result")
statements, del_statements = _buildContractionBodyNode(
provider=provider,
node=node,
emit_class=ExpressionListOperationAppend,
start_value=ExpressionConstantRef(constant=[],
source_ref=source_ref),
outer_iter_ref=outer_iter_ref,
container_tmp=container_tmp,
temp_scope=temp_scope,
assign_provider=True,
source_ref=source_ref,
function_body=provider)
statements.insert(
0,
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=outer_iter_var.makeReference(provider),
source_ref=source_ref),
source=ExpressionBuiltinIter1(value=buildNode(
provider=provider,
node=node.generators[0].iter,
source_ref=source_ref),
source_ref=source_ref),
source_ref=source_ref))
result = makeTryFinallyExpression(expression=ExpressionTempVariableRef(
variable=container_tmp.makeReference(provider),
source_ref=source_ref),
tried=statements,
final=del_statements,
source_ref=source_ref)
final = StatementsSequence(statements=(
StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=container_tmp.makeReference(provider),
source_ref=source_ref),
tolerant=True,
source_ref=source_ref),
StatementDelVariable(variable_ref=ExpressionTargetTempVariableRef(
variable=outer_iter_var.makeReference(provider),
source_ref=source_ref),
tolerant=True,
source_ref=source_ref),
),
source_ref=source_ref)
wrapTryFinallyLater(node=result, final=final)
return result
return _buildContractionNode(
provider=provider,
node=node,
name="<listcontraction>",
emit_class=ExpressionListOperationAppend,
start_value=ExpressionConstantRef(constant=[], source_ref=source_ref),
# Note: For Python3, the list contractions no longer assign to the outer
# scope.
assign_provider=Utils.python_version < 300,
source_ref=source_ref)
def buildForLoopNode(provider, node, source_ref):
# The for loop is re-formulated according to developer manual. An iterator
# is created, and looped until it gives StopIteration. The else block is
# taken if a for loop exits normally, i.e. because of iterator
# exhaustion. We do this by introducing an indicator variable.
source = buildNode(provider, node.iter, source_ref)
temp_scope = provider.allocateTempScope("for_loop")
tmp_iter_variable = provider.allocateTempVariable(
temp_scope = temp_scope,
name = "for_iterator"
)
tmp_value_variable = provider.allocateTempVariable(
temp_scope = temp_scope,
name = "iter_value"
)
else_block = buildStatementsNode(
provider = provider,
nodes = node.orelse if node.orelse else None,
source_ref = source_ref
)
if else_block is not None:
tmp_break_indicator = provider.allocateTempVariable(
temp_scope = temp_scope,
name = "break_indicator"
)
statements = [
StatementAssignmentVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_break_indicator,
source_ref = source_ref
),
source = ExpressionConstantRef(
constant = True,
source_ref = source_ref
),
source_ref = source_ref
)
]
else:
statements = []
statements.append(
StatementBreakLoop(
source_ref = source_ref
)
)
handler_body = makeStatementsSequence(
statements = statements,
allow_none = False,
source_ref = source_ref
)
statements = (
makeTryExceptSingleHandlerNode(
tried = makeStatementsSequenceFromStatement(
statement = StatementAssignmentVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_value_variable,
source_ref = source_ref
),
source = ExpressionBuiltinNext1(
value = ExpressionTempVariableRef(
variable = tmp_iter_variable,
source_ref = source_ref
),
source_ref = source_ref
),
source_ref = source_ref
)
),
exception_name = "StopIteration",
handler_body = handler_body,
public_exc = False,
source_ref = source_ref
),
buildAssignmentStatements(
provider = provider,
node = node.target,
source = ExpressionTempVariableRef(
variable = tmp_value_variable,
source_ref = source_ref
),
source_ref = source_ref
)
)
pushBuildContext("loop_body")
pushIndicatorVariable(None)
statements += (
buildStatementsNode(
provider = provider,
nodes = node.body,
source_ref = source_ref
),
)
popIndicatorVariable()
popBuildContext()
loop_body = makeStatementsSequence(
statements = statements,
allow_none = True,
source_ref = source_ref
)
cleanup_statements = [
StatementDelVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_value_variable,
source_ref = source_ref
),
tolerant = True,
source_ref = source_ref
),
StatementDelVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_iter_variable,
source_ref = source_ref
),
tolerant = True,
source_ref = source_ref
)
]
if else_block is not None:
statements = [
StatementAssignmentVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_break_indicator,
source_ref = source_ref
),
source = ExpressionConstantRef(
constant = False,
source_ref = source_ref
),
source_ref = source_ref
)
]
else:
statements = []
statements += [
# First create the iterator and store it.
StatementAssignmentVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_iter_variable,
source_ref = source_ref
),
source = ExpressionBuiltinIter1(
value = source,
source_ref = source.getSourceReference()
),
source_ref = source_ref
),
makeTryFinallyStatement(
tried = StatementLoop(
body = loop_body,
source_ref = source_ref
),
final = StatementsSequence(
statements = cleanup_statements,
source_ref = source_ref
),
source_ref = source_ref
)
]
if else_block is not None:
statements += [
StatementConditional(
condition = ExpressionComparisonIs(
left = ExpressionTempVariableRef(
variable = tmp_break_indicator,
source_ref = source_ref
),
right = ExpressionConstantRef(
constant = True,
source_ref = source_ref
),
source_ref = source_ref
),
yes_branch = else_block,
no_branch = None,
source_ref = source_ref
)
]
statements = (
makeTryFinallyStatement(
tried = statements,
final = StatementDelVariable(
variable_ref = ExpressionTargetTempVariableRef(
variable = tmp_break_indicator,
source_ref = source_ref
),
tolerant = False,
source_ref = source_ref
),
source_ref = source_ref
),
)
return StatementsSequence(
statements = statements,
source_ref = source_ref
)
def buildPrintNode(provider, node, source_ref):
# "print" statements, should only occur with Python2.
def wrapValue(value):
if value.isExpressionConstantRef():
str_value = value.getStrValue()
if str_value is not None:
return str_value
return ExpressionBuiltinStr(value=value,
source_ref=value.getSourceReference())
if node.dest is not None:
temp_scope = provider.allocateTempScope("print")
tmp_target_variable = provider.allocateTempVariable(
temp_scope=temp_scope, name="target")
target_default_statement = StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_target_variable, source_ref=source_ref),
source=ExpressionImportModuleHard(module_name="sys",
import_name="stdout",
source_ref=source_ref),
source_ref=source_ref)
statements = [
StatementAssignmentVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_target_variable, source_ref=source_ref),
source=buildNode(provider=provider,
node=node.dest,
source_ref=source_ref),
source_ref=source_ref),
StatementConditional(
condition=ExpressionComparisonIs(
left=ExpressionTempVariableRef(
variable=tmp_target_variable, source_ref=source_ref),
right=ExpressionConstantRef(constant=None,
source_ref=source_ref),
source_ref=source_ref),
yes_branch=makeStatementsSequenceFromStatement(
statement=target_default_statement),
no_branch=None,
source_ref=source_ref)
]
values = buildNodeList(provider=provider,
nodes=node.values,
source_ref=source_ref)
values = [wrapValue(value) for value in values]
if node.dest is not None:
print_statements = [
StatementPrintValue(dest=ExpressionTempVariableRef(
variable=tmp_target_variable, source_ref=source_ref),
value=value,
source_ref=source_ref) for value in values
]
if node.nl:
print_statements.append(
StatementPrintNewline(dest=ExpressionTempVariableRef(
variable=tmp_target_variable, source_ref=source_ref),
source_ref=source_ref))
statements.append(
makeTryFinallyStatement(
tried=print_statements,
final=StatementDelVariable(
variable_ref=ExpressionTargetTempVariableRef(
variable=tmp_target_variable, source_ref=source_ref),
tolerant=False,
source_ref=source_ref),
source_ref=source_ref))
else:
statements = [
StatementPrintValue(dest=None, value=value, source_ref=source_ref)
for value in values
]
if node.nl:
statements.append(
StatementPrintNewline(dest=None, source_ref=source_ref))
return StatementsSequence(statements=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)