def copyDataFiles():
"""Copy the data files needed for standalone distribution.
Notes:
This is for data files only, not DLLs or even extension modules,
those must be registered as entry points, and would not go through
necessary handling if provided like this.
"""
for included_datafile in getIncludedDataFiles():
# TODO: directories should be resolved to files.
if (not isinstance(included_datafile, (IncludedDataFile))
or included_datafile.needsCopy()):
if shallMakeModule():
options_logger.sysexit("""\
Error, data files for modules must be done via wheels, or commercial plugins '--embed-*' options."""
)
elif not isStandaloneMode():
options_logger.sysexit("""\
Error, data files cannot be included in accelerated mode unless using commercial plugins '--embed-*' options."""
)
_handleDataFile(included_datafile, )
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):
# 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)
# 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 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)
# 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 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
