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)
# 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