def getComputationResult(node, computation, description):
""" With a computation function, execute it and return constant result or
exception node.
"""
# Try and turn raised exceptions into static raises. pylint: disable=W0703
try:
result = computation()
except Exception as e:
new_node = makeRaiseExceptionReplacementExpressionFromInstance(
expression = node,
exception = e
)
change_tags = "new_raise"
change_desc = description + " Was predicted to raise an exception."
else:
new_node = makeCompileTimeConstantReplacementNode(
value = result,
node = node
)
if isDebug():
assert new_node is not node, ( node, result )
if new_node is not node:
change_tags = "new_constant"
change_desc = description + " Was predicted to constant result."
else:
change_tags = None
change_desc = None
return new_node, change_tags, change_desc
def generateRaiseExpressionCode(to_name, expression, emit, context):
arg_names = generateChildExpressionsCode(
expression=expression, emit=emit, context=context
)
# Missed optimization opportunity, please report it, this should not
# normally happen. We are supposed to propagate this upwards.
if isDebug():
# TODO: Need to optimize ExpressionLocalsVariableRefORFallback once we know
# it handles cases where the value is not in locals dict properly.
parent = expression.parent
assert (
parent.isExpressionSideEffects()
or parent.isExpressionConditional()
or parent.isExpressionLocalsVariableRefORFallback()
), (expression, expression.parent, expression.asXmlText())
with withObjectCodeTemporaryAssignment(
to_name, "raise_exception_result", expression, emit, context
) as value_name:
# That's how we indicate exception to the surrounding world.
emit("%s = NULL;" % value_name)
_getRaiseExceptionWithValueCode(
raise_type_name=arg_names[0],
raise_value_name=arg_names[1],
implicit=True,
emit=emit,
context=context,
)
def __init__(self, constant, source_ref, user_provided = False):
NodeBase.__init__( self, source_ref = source_ref )
CompileTimeConstantExpressionMixin.__init__( self )
assert isConstant( constant ), constant
self.constant = constant
self.user_provided = user_provided
if not user_provided and isDebug():
try:
size = len( constant )
if type( constant ) in ( str, unicode ):
max_size = 1000
else:
max_size = 256
if size > max_size:
warning(
"Too large constant (%s %d) encountered at %s.",
type( constant ),
size,
source_ref.getAsString()
)
except TypeError:
pass
def generateRaiseExpressionCode(to_name, expression, emit, context):
arg_names = generateChildExpressionsCode(
expression = expression,
emit = emit,
context = context
)
# Missed optimization opportunity, please report it, this should not
# normally happen. We are supposed to propagate this upwards.
if isDebug():
parent = expression.parent
assert parent.isExpressionSideEffects() or \
parent.isExpressionConditional(), \
(expression, expression.parent)
# That's how we indicate exception to the surrounding world.
emit("%s = NULL;" % to_name)
getRaiseExceptionWithValueCode(
raise_type_name = arg_names[0],
raise_value_name = arg_names[1],
implicit = True,
emit = emit,
context = context
)
def getComputationResult(node, computation, description):
""" With a computation function, execute it and return constant result or
exception node.
"""
# Try and turn raised exceptions into static raises. pylint: disable=broad-except
try:
result = computation()
except Exception as e:
new_node = makeRaiseExceptionReplacementExpressionFromInstance(
expression=node, exception=e)
change_tags = "new_raise"
change_desc = description + " Predicted to raise an exception."
else:
new_node = makeCompileTimeConstantReplacementNode(value=result,
node=node)
if isDebug():
assert new_node is not node, (node, result)
if new_node is not node:
change_tags = "new_constant"
change_desc = description + " Predicted constant result."
else:
change_tags = None
change_desc = None
return new_node, change_tags, change_desc
def __init__(self, constant, source_ref, user_provided=False):
NodeBase.__init__(self, source_ref=source_ref)
CompileTimeConstantExpressionMixin.__init__(self)
assert isConstant(constant), constant
self.constant = constant
if user_provided:
self.user_provided = user_provided
if not user_provided and isDebug():
try:
size = len(constant)
if type(constant) in (str, unicode):
max_size = 1000
else:
max_size = 256
if size > max_size:
warning("Too large constant (%s %d) encountered at %s.",
type(constant), size, source_ref.getAsString())
except TypeError:
pass
def __init__(self, constant, source_ref, user_provided=False):
CompileTimeConstantExpressionBase.__init__(self, source_ref=source_ref)
assert isConstant(constant), repr(constant)
self.constant = constant
# Memory saving method, have the attribute only where necessary.
self.user_provided = user_provided
if not user_provided and isDebug():
try:
if type(constant) in (str, unicode, bytes):
max_size = 1000
elif type(constant) is xrange:
max_size = None
else:
max_size = 256
if max_size is not None and len(constant) > max_size:
warning(
"Too large constant (%s %d) encountered at %s.",
type(constant),
len(constant),
source_ref.getAsString(),
)
except TypeError:
pass
def generateRaiseExpressionCode(to_name, expression, emit, context):
arg_names = generateChildExpressionsCode(
expression = expression,
emit = emit,
context = context
)
# Missed optimization opportunity, please report it, this should not
# normally happen. We are supposed to propagate this upwards.
if isDebug():
parent = expression.parent
assert parent.isExpressionSideEffects() or \
parent.isExpressionConditional(), \
(expression, expression.parent)
# That's how we indicate exception to the surrounding world.
emit("%s = NULL;" % to_name)
getRaiseExceptionWithValueCode(
raise_type_name = arg_names[0],
raise_value_name = arg_names[1],
implicit = True,
emit = emit,
context = context
)
def __init__(self, constant, source_ref, user_provided=False):
CompileTimeConstantExpressionBase.__init__(self, source_ref=source_ref)
assert isConstant(constant), repr(constant)
self.constant = constant
# Memory saving method, have the attribute only where necessary.
self.user_provided = user_provided
if not user_provided and isDebug():
try:
if type(constant) in (str, unicode, bytes):
max_size = 1000
elif type(constant) is xrange:
max_size = None
else:
max_size = 256
if max_size is not None and len(constant) > max_size:
warning("Too large constant (%s %d) encountered at %s.",
type(constant), len(constant),
source_ref.getAsString())
except TypeError:
pass
def generateRaiseExpressionCode(to_name, expression, emit, context):
arg_names = generateChildExpressionsCode(
expression = expression,
emit = emit,
context = context
)
# Missed optimization opportunity, please report it, this should not
# normally happen. We are supposed to propagate this upwards.
if isDebug():
# TODO: Need to optimize ExpressionLocalsVariableRefORFallback once we know
# it handles cases where the value is not in locals dict properly.
parent = expression.parent
assert parent.isExpressionSideEffects() or \
parent.isExpressionConditional() or \
parent.isExpressionLocalsVariableRefORFallback(), \
(expression, expression.parent, expression.asXmlText())
# That's how we indicate exception to the surrounding world.
emit("%s = NULL;" % to_name)
getRaiseExceptionWithValueCode(
raise_type_name = arg_names[0],
raise_value_name = arg_names[1],
implicit = True,
emit = emit,
context = context
)
def computeBuiltinCall(call_node, called):
# There is some dispatching for how to output various types of changes,
# with lots of cases, pylint: disable=R0912
builtin_name = called.getBuiltinName()
if builtin_name in _dispatch_dict:
new_node = _dispatch_dict[builtin_name](call_node)
# Lets just have this contract to return "None" when no change is meant
# to be done.
assert new_node is not call_node
if new_node is None:
return call_node, None, None
# For traces, we are going to ignore side effects, and output traces
# only based on the basis of it.
inspect_node = new_node
if inspect_node.isExpressionSideEffects():
inspect_node = inspect_node.getExpression()
if inspect_node.isExpressionBuiltinImport():
tags = "new_import"
message = """\
Replaced dynamic __import__ %s with static module import.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionBuiltin() or \
inspect_node.isStatementExec():
tags = "new_builtin"
message = "Replaced call to built-in '%s' with built-in call '%s'." % (
builtin_name,
inspect_node.kind,
)
elif inspect_node.isExpressionRaiseException():
tags = "new_raise"
message = """\
Replaced call to built-in '%s' with exception raising call.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionOperationUnary():
tags = "new_expression"
message = """\
Replaced call to built-in '%s' with unary operation '%s'.""" % (
inspect_node.kind,
inspect_node.getOperator()
)
elif inspect_node.isExpressionCall():
tags = "new_expression"
message = """\
Replaced call to built-in '%s' with call.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionOutlineBody():
tags = "new_expression"
message = """\
Replaced call to built-in '%s' with outlined call.""" % builtin_name
else:
assert False, (builtin_name, "->", inspect_node)
# TODO: One day, this should be enabled by default and call either the
# original built-in or the optimized above one. That should be done,
# once we can eliminate the condition for most cases.
if False and isDebug() and not shallMakeModule() and builtin_name:
source_ref = called.getSourceReference()
new_node = ExpressionConditional(
condition = ExpressionComparisonIs(
left = ExpressionBuiltinRef(
builtin_name = builtin_name,
source_ref = source_ref
),
right = ExpressionBuiltinOriginalRef(
builtin_name = builtin_name,
source_ref = source_ref
),
source_ref = source_ref
),
expression_yes = new_node,
expression_no = makeRaiseExceptionReplacementExpression(
exception_type = "RuntimeError",
exception_value = "Built-in '%s' cannot be replaced." % (
builtin_name
),
expression = call_node
),
source_ref = source_ref
)
assert tags != ""
return new_node, tags, message
else:
if False and isDebug() and builtin_name not in _builtin_white_list:
warning(
"Not handling built-in '%s', consider support." % builtin_name
)
return call_node, None, None
def makeTryFinallyStatement(provider, tried, final, source_ref, public_exc = False):
# Complex handling, due to the many variants, pylint: disable=too-many-branches,too-many-locals
if type(tried) in (tuple, list):
tried = makeStatementsSequenceFromStatements(
*tried
)
if type(final) in (tuple, list):
final = StatementsSequence(
statements = mergeStatements(final, False),
source_ref = source_ref
)
if tried is not None and not tried.isStatementsSequence():
tried = makeStatementsSequenceFromStatement(tried)
if final is not None and not final.isStatementsSequence():
final = makeStatementsSequenceFromStatement(final)
if tried is None:
return final
if final is None:
return tried
if provider is not None:
tried.parent = provider
final.parent = provider
assert tried is not None, source_ref
assert final is not None, source_ref
# TODO: Currently it's not possible anymore to get at XML for all codes
# during the building phase. So this error catcher cannot work currently.
if False and isDebug():
final2 = final.makeClone()
final2.parent = provider
import nuitka.TreeXML
if nuitka.TreeXML.Element is not None:
f1 = final.asXml()
f2 = final2.asXml()
def compare(a, b):
for c1, c2 in zip(a, b):
compare(c1, c2)
assert a.attrib == b.attrib, (a.attrib, b.attrib)
compare(f1, f2)
def getFinal():
# Make a clone of "final" only if necessary.
if hasattr(getFinal, "used"):
return final.makeClone()
else:
getFinal.used = True
return final
if tried.mayRaiseException(BaseException):
except_handler = getStatementsAppended(
statement_sequence = getFinal(),
statements = makeReraiseExceptionStatement(
source_ref = source_ref
)
)
if public_exc:
preserver_id = provider.allocatePreserverId()
except_handler = getStatementsPrepended(
statement_sequence = except_handler,
statements = (
StatementPreserveFrameException(
preserver_id = preserver_id,
source_ref = source_ref.atInternal()
),
StatementPublishException(
source_ref = source_ref
)
)
)
except_handler = makeTryFinallyStatement(
provider = provider,
tried = except_handler,
final = StatementRestoreFrameException(
preserver_id = preserver_id,
source_ref = source_ref.atInternal()
),
public_exc = False,
source_ref = source_ref,
)
except_handler = makeStatementsSequenceFromStatement(
statement = except_handler
)
except_handler.parent = provider
else:
except_handler = None
if tried.mayBreak():
break_handler = getStatementsAppended(
statement_sequence = getFinal(),
statements = StatementLoopBreak(
source_ref = source_ref
)
)
break_handler.parent = provider
else:
break_handler = None
if tried.mayContinue():
continue_handler = getStatementsAppended(
statement_sequence = getFinal(),
statements = StatementLoopContinue(
source_ref = source_ref
)
)
continue_handler.parent = provider
else:
continue_handler = None
if tried.mayReturn():
return_handler = getStatementsAppended(
statement_sequence = getFinal(),
statements = StatementReturn(
expression = ExpressionReturnedValueRef(
source_ref = source_ref
),
source_ref = source_ref
)
)
return_handler.parent = provider
else:
return_handler = None
result = StatementTry(
tried = tried,
except_handler = except_handler,
break_handler = break_handler,
continue_handler = continue_handler,
return_handler = return_handler,
source_ref = source_ref
)
if result.isStatementAborting():
return result
else:
return makeStatementsSequence(
statements = (
result,
getFinal()
),
allow_none = False,
source_ref = source_ref
)
def computeBuiltinCall(call_node, called):
builtin_name = called.getBuiltinName()
if builtin_name in _dispatch_dict:
new_node = _dispatch_dict[builtin_name](call_node)
# Lets just have this contract to return "None" when no change is meant
# to be done.
assert new_node is not call_node
if new_node is None:
return call_node, None, None
# For traces, we are going to ignore side effects, and output traces
# only based on the basis of it.
inspect_node = new_node
if inspect_node.isExpressionSideEffects():
inspect_node = inspect_node.getExpression()
if inspect_node.isExpressionBuiltinImport():
tags = "new_import"
message = """\
Replaced dynamic __import__ %s with static module import.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionBuiltin() or \
inspect_node.isStatementExec():
tags = "new_builtin"
message = "Replaced call to builtin %s with builtin call %s." % (
builtin_name,
inspect_node.kind,
)
elif inspect_node.isExpressionRaiseException():
tags = "new_raise"
message = """\
Replaced call to builtin %s with exception raising call.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionOperationUnary():
tags = "new_expression"
message = """\
Replaced call to builtin %s with unary operation %s.""" % (
inspect_node.kind,
inspect_node.getOperator()
)
elif inspect_node.isExpressionCall():
tags = "new_expression"
message = """\
Replaced call to builtin %s with call.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionTryFinally():
tags = "new_expression"
message = """\
Replaced call to builtin %s with try/finally guarded call.""" % (
inspect_node.getExpression().kind,
)
else:
assert False, ( builtin_name, "->", inspect_node )
# TODO: One day, this should be enabled by default and call either the
# original built-in or the optimized above one. That should be done,
# once we can eliminate the condition for most cases.
if False and isDebug() and not shallMakeModule() and builtin_name:
from nuitka.nodes.NodeMakingHelpers import \
makeRaiseExceptionReplacementExpression
source_ref = called.getSourceReference()
new_node = ExpressionConditional(
condition = ExpressionComparisonIs(
left = ExpressionBuiltinRef(
builtin_name = builtin_name,
source_ref = source_ref
),
right = ExpressionBuiltinOriginalRef(
builtin_name = builtin_name,
source_ref = source_ref
),
source_ref = source_ref
),
yes_expression = new_node,
no_expression = makeRaiseExceptionReplacementExpression(
exception_type = "RuntimeError",
exception_value = "Builtin '%s' was overloaded'" % (
builtin_name
),
expression = call_node
),
source_ref = source_ref
)
assert tags != ""
return new_node, tags, message
else:
# TODO: Consider giving warnings, whitelisted potentially
return call_node, None, None
def makeTryFinallyStatement(provider, tried, final, source_ref, public_exc = False):
# Complex handling, due to the many variants, pylint: disable=R0912,R0914
if type(tried) in (tuple, list):
tried = makeStatementsSequenceFromStatements(
*tried
)
if type(final) in (tuple, list):
final = StatementsSequence(
statements = mergeStatements(final, False),
source_ref = source_ref
)
if tried is not None and not tried.isStatementsSequence():
tried = makeStatementsSequenceFromStatement(tried)
if final is not None and not final.isStatementsSequence():
final = makeStatementsSequenceFromStatement(final)
if tried is None:
return final
if final is None:
return tried
if provider is not None:
tried.parent = provider
final.parent = provider
assert tried is not None, source_ref
assert final is not None, source_ref
if isDebug():
final2 = final.makeClone()
final2.parent = provider
import nuitka.TreeXML
if nuitka.TreeXML.Element is not None:
f1 = final.asXml()
f2 = final2.asXml()
def compare(a, b):
for c1, c2 in zip(a, b):
compare(c1, c2)
assert a.attrib == b.attrib, (a.attrib, b.attrib)
compare(f1, f2)
if tried.mayRaiseException(BaseException):
except_handler = final.makeClone()
except_handler = getStatementsAppended(
statement_sequence = except_handler,
statements = makeReraiseExceptionStatement(
source_ref = source_ref
)
)
if public_exc:
preserver_id = provider.allocatePreserverId()
except_handler = getStatementsPrepended(
statement_sequence = except_handler,
statements = (
StatementPreserveFrameException(
preserver_id = preserver_id,
source_ref = source_ref.atInternal()
),
StatementPublishException(
source_ref = source_ref
)
)
)
except_handler = makeTryFinallyStatement(
provider = provider,
tried = except_handler,
final = StatementRestoreFrameException(
preserver_id = preserver_id,
source_ref = source_ref.atInternal()
),
public_exc = False,
source_ref = source_ref,
)
except_handler = makeStatementsSequenceFromStatement(
statement = except_handler
)
except_handler.parent = provider
else:
except_handler = None
if tried.mayBreak():
break_handler = getStatementsAppended(
statement_sequence = final.makeClone(),
statements = StatementLoopBreak(
source_ref = source_ref
)
)
break_handler.parent = provider
else:
break_handler = None
if tried.mayContinue():
continue_handler = getStatementsAppended(
statement_sequence = final.makeClone(),
statements = StatementLoopContinue(
source_ref = source_ref
)
)
continue_handler.parent = provider
else:
continue_handler = None
if tried.mayReturn():
return_handler = getStatementsAppended(
statement_sequence = final.makeClone(),
statements = StatementReturn(
expression = ExpressionReturnedValueRef(
source_ref = source_ref
),
source_ref = source_ref
)
)
else:
return_handler = None
result = StatementTry(
tried = tried,
except_handler = except_handler,
break_handler = break_handler,
continue_handler = continue_handler,
return_handler = return_handler,
source_ref = source_ref
)
if result.isStatementAborting():
return result
else:
return makeStatementsSequence(
statements = (
result,
final
),
allow_none = False,
source_ref = source_ref
)
from logging import warning
warning(
"Extra value '%s' provided to template '%s'.",
key,
self.name
)
return self.value % other
def split(self, sep):
return self.value.split(sep)
from nuitka.__past__ import iterItems
for template_name, template_value in iterItems(templates):
# Ignore internal attribute like "__name__" that the module will also
# have of course.
if template_name.startswith('_'):
continue
if type(template_value) is str:
globals()[template_name] = TemplateWrapper(
template_name,
template_value
)
if isDebug():
enableDebug()
def checkDebug(globals_dict):
if isDebug():
enableDebug(globals_dict)
def makeTryFinallyStatement(provider, tried, final, source_ref, public_exc=False):
# Complex handling, due to the many variants, pylint: disable=too-many-branches
if type(tried) in (tuple, list):
if tried:
tried = makeStatementsSequenceFromStatements(*tried)
else:
tried = None
if type(final) in (tuple, list):
if final:
final = StatementsSequence(
statements=mergeStatements(final, False), source_ref=source_ref
)
else:
final = None
if tried is not None and not tried.isStatementsSequence():
tried = makeStatementsSequenceFromStatement(tried)
if final is not None and not final.isStatementsSequence():
final = makeStatementsSequenceFromStatement(final)
# Trivial case, nothing tried needs only do the final stuff.
if tried is None:
return final
# Trivial case, nothing final needs nothing but the tried stuff.
if final is None:
return tried
# Parent them to us already.
if provider is not None:
tried.parent = provider
final.parent = provider
# TODO: Currently it's not possible anymore to get at XML for all codes
# during the building phase. So this error catcher cannot work currently.
if False and isDebug():
_checkCloning(final, provider)
def getFinal():
# Make a clone of "final" only if necessary.
if hasattr(getFinal, "used"):
return final.makeClone()
else:
getFinal.used = True
return final
if tried.mayRaiseException(BaseException):
except_handler = getStatementsAppended(
statement_sequence=getFinal(),
statements=makeReraiseExceptionStatement(source_ref=source_ref),
)
if public_exc:
preserver_id = provider.allocatePreserverId()
except_handler = getStatementsPrepended(
statement_sequence=except_handler,
statements=(
StatementPreserveFrameException(
preserver_id=preserver_id, source_ref=source_ref.atInternal()
),
StatementPublishException(source_ref=source_ref),
),
)
except_handler = makeTryFinallyStatement(
provider=provider,
tried=except_handler,
final=StatementRestoreFrameException(
preserver_id=preserver_id, source_ref=source_ref.atInternal()
),
public_exc=False,
source_ref=source_ref,
)
except_handler = makeStatementsSequenceFromStatement(
statement=except_handler
)
else:
except_handler = None
if tried.mayBreak():
break_handler = getStatementsAppended(
statement_sequence=getFinal(),
statements=StatementLoopBreak(source_ref=source_ref),
)
else:
break_handler = None
if tried.mayContinue():
continue_handler = getStatementsAppended(
statement_sequence=getFinal(),
statements=StatementLoopContinue(source_ref=source_ref),
)
else:
continue_handler = None
if tried.mayReturn():
return_handler = getStatementsAppended(
statement_sequence=getFinal(),
statements=StatementReturn(
expression=ExpressionReturnedValueRef(source_ref=source_ref),
source_ref=source_ref,
),
)
else:
return_handler = None
result = StatementTry(
tried=tried,
except_handler=except_handler,
break_handler=break_handler,
continue_handler=continue_handler,
return_handler=return_handler,
source_ref=source_ref,
)
if result.isStatementAborting():
return result
else:
return makeStatementsSequence(
statements=(result, getFinal()), allow_none=False, source_ref=source_ref
)
def checkDebug(globals_dict):
if isDebug():
enableDebug(globals_dict)
for key in other.keys():
if "%%(%s)" % key not in self.value:
from logging import warning
warning("Extra value '%s' provided to template '%s'.", key,
self.name)
return self.value % other
def split(self, sep):
return self.value.split(sep)
from nuitka.__past__ import iterItems
for template_name, template_value in iterItems(templates):
# Ignore internal attribute like "__name__" that the module will also
# have of course.
if template_name.startswith("_"):
continue
if type(template_value) is str:
globals()[template_name] = TemplateWrapper(template_name,
template_value)
from nuitka.Options import isDebug
if isDebug():
enableDebug()
def makeTryFinallyStatement(provider,
tried,
final,
source_ref,
public_exc=False):
# Complex handling, due to the many variants, pylint: disable=R0912,R0914
if type(tried) in (tuple, list):
tried = makeStatementsSequenceFromStatements(*tried)
if type(final) in (tuple, list):
final = StatementsSequence(statements=mergeStatements(final, False),
source_ref=source_ref)
if tried is not None and not tried.isStatementsSequence():
tried = makeStatementsSequenceFromStatement(tried)
if final is not None and not final.isStatementsSequence():
final = makeStatementsSequenceFromStatement(final)
if tried is None:
return final
if final is None:
return tried
if provider is not None:
tried.parent = provider
final.parent = provider
assert tried is not None, source_ref
assert final is not None, source_ref
if isDebug():
final2 = final.makeClone()
final2.parent = provider
import nuitka.TreeXML
if nuitka.TreeXML.Element is not None:
f1 = final.asXml()
f2 = final2.asXml()
def compare(a, b):
for c1, c2 in zip(a, b):
compare(c1, c2)
assert a.attrib == b.attrib, (a.attrib, b.attrib)
compare(f1, f2)
if tried.mayRaiseException(BaseException):
except_handler = final.makeClone()
except_handler = getStatementsAppended(
statement_sequence=except_handler,
statements=makeReraiseExceptionStatement(source_ref=source_ref))
if public_exc:
preserver_id = provider.allocatePreserverId()
except_handler = getStatementsPrepended(
statement_sequence=except_handler,
statements=(StatementPreserveFrameException(
preserver_id=preserver_id,
source_ref=source_ref.atInternal()),
StatementPublishException(source_ref=source_ref)))
except_handler = makeTryFinallyStatement(
provider=provider,
tried=except_handler,
final=StatementRestoreFrameException(
preserver_id=preserver_id,
source_ref=source_ref.atInternal()),
public_exc=False,
source_ref=source_ref,
)
except_handler = makeStatementsSequenceFromStatement(
statement=except_handler)
except_handler.parent = provider
else:
except_handler = None
if tried.mayBreak():
break_handler = getStatementsAppended(
statement_sequence=final.makeClone(),
statements=StatementLoopBreak(source_ref=source_ref))
break_handler.parent = provider
else:
break_handler = None
if tried.mayContinue():
continue_handler = getStatementsAppended(
statement_sequence=final.makeClone(),
statements=StatementLoopContinue(source_ref=source_ref))
continue_handler.parent = provider
else:
continue_handler = None
if tried.mayReturn():
return_handler = getStatementsAppended(
statement_sequence=final.makeClone(),
statements=StatementReturn(
expression=ExpressionReturnedValueRef(source_ref=source_ref),
source_ref=source_ref))
else:
return_handler = None
result = StatementTry(tried=tried,
except_handler=except_handler,
break_handler=break_handler,
continue_handler=continue_handler,
return_handler=return_handler,
source_ref=source_ref)
if result.isStatementAborting():
return result
else:
return makeStatementsSequence(statements=(result, final),
allow_none=False,
source_ref=source_ref)
def computeBuiltinCall(call_node, called):
# There is some dispatching for how to output various types of changes,
# with lots of cases, pylint: disable=R0912
builtin_name = called.getBuiltinName()
if builtin_name in _dispatch_dict:
new_node = _dispatch_dict[builtin_name](call_node)
# Lets just have this contract to return "None" when no change is meant
# to be done.
assert new_node is not call_node
if new_node is None:
return call_node, None, None
# For traces, we are going to ignore side effects, and output traces
# only based on the basis of it.
inspect_node = new_node
if inspect_node.isExpressionSideEffects():
inspect_node = inspect_node.getExpression()
if inspect_node.isExpressionBuiltinImport():
tags = "new_import"
message = """\
Replaced dynamic __import__ %s with static module import.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionBuiltin() or inspect_node.isStatementExec():
tags = "new_builtin"
message = "Replaced call to built-in '%s' with built-in call '%s'." % (builtin_name, inspect_node.kind)
elif inspect_node.isExpressionRaiseException():
tags = "new_raise"
message = """\
Replaced call to built-in '%s' with exception raising call.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionOperationUnary():
tags = "new_expression"
message = """\
Replaced call to built-in '%s' with unary operation '%s'.""" % (
inspect_node.kind,
inspect_node.getOperator(),
)
elif inspect_node.isExpressionCall():
tags = "new_expression"
message = """\
Replaced call to built-in '%s' with call.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionOutlineBody():
tags = "new_expression"
message = (
"""\
Replaced call to built-in '%s' with outlined call."""
% builtin_name
)
else:
assert False, (builtin_name, "->", inspect_node)
# TODO: One day, this should be enabled by default and call either the
# original built-in or the optimized above one. That should be done,
# once we can eliminate the condition for most cases.
if False and isDebug() and not shallMakeModule() and builtin_name:
source_ref = called.getSourceReference()
new_node = ExpressionConditional(
condition=ExpressionComparisonIs(
left=ExpressionBuiltinRef(builtin_name=builtin_name, source_ref=source_ref),
right=ExpressionBuiltinOriginalRef(builtin_name=builtin_name, source_ref=source_ref),
source_ref=source_ref,
),
expression_yes=new_node,
expression_no=makeRaiseExceptionReplacementExpression(
exception_type="RuntimeError",
exception_value="Built-in '%s' cannot be replaced." % (builtin_name),
expression=call_node,
),
source_ref=source_ref,
)
assert tags != ""
return new_node, tags, message
else:
if False and isDebug() and builtin_name not in _builtin_white_list:
warning("Not handling built-in '%s', consider support." % builtin_name)
return call_node, None, None
def computeBuiltinCall( call_node, called ):
builtin_name = called.getBuiltinName()
if builtin_name in _dispatch_dict:
new_node = _dispatch_dict[ builtin_name ]( call_node )
if new_node is None:
return call_node, None, None
inspect_node = new_node
if inspect_node.isExpressionSideEffects():
inspect_node = inspect_node.getExpression()
if inspect_node.isExpressionBuiltinImport():
tags = "new_import"
message = "Replaced dynamic builtin import %s with static module import." % inspect_node.kind
elif inspect_node.isExpressionBuiltin() or inspect_node.isStatementExec():
tags = "new_builtin"
message = "Replaced call to builtin with builtin call %s." % inspect_node.kind
elif inspect_node.isExpressionRaiseException():
tags = "new_raise"
message = "Replaced call to builtin %s with exception raising call." % inspect_node.kind
elif inspect_node.isExpressionOperationUnary():
tags = "new_expression"
message = "Replaced call to builtin %s with unary operation %s." % ( inspect_node.kind, inspect_node.getOperator() )
else:
assert False, ( builtin_name, "->", inspect_node )
# TODO: One day, this should be enabled by default and call either the original
# built-in or the optimized above one. That should be done, once we can eliminate
# the condition for most cases.
if False and isDebug() and not shallMakeModule() and builtin_name:
from nuitka.nodes.ConditionalNodes import ExpressionConditional
from nuitka.nodes.ComparisonNodes import ExpressionComparisonIs
from nuitka.nodes.BuiltinRefNodes import (
ExpressionBuiltinExceptionRef,
ExpressionBuiltinOriginalRef,
ExpressionBuiltinRef,
)
from nuitka.nodes.ExceptionNodes import ExpressionRaiseException
source_ref = called.getSourceReference()
new_node = ExpressionConditional(
condition = ExpressionComparisonIs(
left = ExpressionBuiltinRef(
builtin_name = builtin_name,
source_ref = source_ref
),
right = ExpressionBuiltinOriginalRef(
builtin_name = builtin_name,
source_ref = source_ref
),
source_ref = source_ref
),
yes_expression = new_node,
no_expression = makeRaiseExceptionReplacementExpression(
exception_type = "RuntimeError",
exception_value = "Builtin '%s' was overloaded'" % builtin_name,
expression = call_node
),
source_ref = source_ref
)
return new_node, tags, message
else:
# TODO: Consider giving warnings, whitelisted potentially
return call_node, None, None
def computeBuiltinCall(call_node, called):
builtin_name = called.getBuiltinName()
if builtin_name in _dispatch_dict:
new_node = _dispatch_dict[builtin_name](call_node)
if new_node is None:
return call_node, None, None
inspect_node = new_node
if inspect_node.isExpressionSideEffects():
inspect_node = inspect_node.getExpression()
if inspect_node.isExpressionBuiltinImport():
tags = "new_import"
message = "Replaced dynamic builtin import %s with static module import." % inspect_node.kind
elif inspect_node.isExpressionBuiltin(
) or inspect_node.isStatementExec():
tags = "new_builtin"
message = "Replaced call to builtin with builtin call %s." % inspect_node.kind
elif inspect_node.isExpressionRaiseException():
tags = "new_raise"
message = "Replaced call to builtin %s with exception raising call." % inspect_node.kind
elif inspect_node.isExpressionOperationUnary():
tags = "new_expression"
message = "Replaced call to builtin %s with unary operation %s." % (
inspect_node.kind, inspect_node.getOperator())
else:
assert False, (builtin_name, "->", inspect_node)
# TODO: One day, this should be enabled by default and call either the original
# built-in or the optimized above one. That should be done, once we can eliminate
# the condition for most cases.
if False and isDebug() and not shallMakeModule() and builtin_name:
from nuitka.nodes.ConditionalNodes import ExpressionConditional
from nuitka.nodes.ComparisonNodes import ExpressionComparisonIs
from nuitka.nodes.BuiltinRefNodes import (
ExpressionBuiltinExceptionRef,
ExpressionBuiltinOriginalRef,
ExpressionBuiltinRef,
)
from nuitka.nodes.ExceptionNodes import ExpressionRaiseException
source_ref = called.getSourceReference()
new_node = ExpressionConditional(
condition=ExpressionComparisonIs(
left=ExpressionBuiltinRef(builtin_name=builtin_name,
source_ref=source_ref),
right=ExpressionBuiltinOriginalRef(
builtin_name=builtin_name, source_ref=source_ref),
source_ref=source_ref),
yes_expression=new_node,
no_expression=makeRaiseExceptionReplacementExpression(
exception_type="RuntimeError",
exception_value="Builtin '%s' was overloaded'" %
builtin_name,
expression=call_node),
source_ref=source_ref)
return new_node, tags, message
else:
# TODO: Consider giving warnings, whitelisted potentially
return call_node, None, None
def computeBuiltinCall(call_node, called):
builtin_name = called.getBuiltinName()
if builtin_name in _dispatch_dict:
new_node = _dispatch_dict[builtin_name](call_node)
# Lets just have this contract to return "None" when no change is meant
# to be done.
assert new_node is not call_node
if new_node is None:
return call_node, None, None
# For traces, we are going to ignore side effects, and output traces
# only based on the basis of it.
inspect_node = new_node
if inspect_node.isExpressionSideEffects():
inspect_node = inspect_node.getExpression()
if inspect_node.isExpressionBuiltinImport():
tags = "new_import"
message = """\
Replaced dynamic __import__ %s with static module import.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionBuiltin() or \
inspect_node.isStatementExec():
tags = "new_builtin"
message = "Replaced call to builtin %s with builtin call %s." % (
builtin_name,
inspect_node.kind,
)
elif inspect_node.isExpressionRaiseException():
tags = "new_raise"
message = """\
Replaced call to builtin %s with exception raising call.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionOperationUnary():
tags = "new_expression"
message = """\
Replaced call to builtin %s with unary operation %s.""" % (
inspect_node.kind,
inspect_node.getOperator()
)
elif inspect_node.isExpressionCall():
tags = "new_expression"
message = """\
Replaced call to builtin %s with call.""" % (
inspect_node.kind,
)
elif inspect_node.isExpressionTryFinally():
tags = "new_expression"
message = """\
Replaced call to builtin %s with try/finally guarded call.""" % (
inspect_node.getExpression().kind,
)
else:
assert False, ( builtin_name, "->", inspect_node )
# TODO: One day, this should be enabled by default and call either the
# original built-in or the optimized above one. That should be done,
# once we can eliminate the condition for most cases.
if False and isDebug() and not shallMakeModule() and builtin_name:
from nuitka.nodes.NodeMakingHelpers import \
makeRaiseExceptionReplacementExpression
source_ref = called.getSourceReference()
new_node = ExpressionConditional(
condition = ExpressionComparisonIs(
left = ExpressionBuiltinRef(
builtin_name = builtin_name,
source_ref = source_ref
),
right = ExpressionBuiltinOriginalRef(
builtin_name = builtin_name,
source_ref = source_ref
),
source_ref = source_ref
),
yes_expression = new_node,
no_expression = makeRaiseExceptionReplacementExpression(
exception_type = "RuntimeError",
exception_value = "Builtin '%s' was overloaded'" % (
builtin_name
),
expression = call_node
),
source_ref = source_ref
)
assert tags != ""
return new_node, tags, message
else:
# TODO: Consider giving warnings, whitelisted potentially
return call_node, None, None