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