def doMissingOptimizationReport():
for helper, source_refs in _missing_helpers.items():
message = "Missing C helper code variant, used fallback: %s at %s" % (
",".join(source_ref.getAsString() for source_ref in source_refs),
helper,
)
if _error_for_missing:
codegen_logger.warning(message)
else:
codegen_logger.info(message)
for desc in _missing_operations:
message = "Missing optimization, used fallback: %s" % (desc, )
if _error_for_missing:
optimization_logger.warning(message)
else:
optimization_logger.info(message)
for desc, source_refs in _missing_trust.items():
message = desc[0] % desc[1:]
message += " at %s" % ",".join(source_ref.getAsString()
for source_ref in source_refs)
if _error_for_missing:
optimization_logger.warning(message)
else:
optimization_logger.info(message)
def mySignal(tag, source_ref, change_desc):
if Options.is_verbose:
optimization_logger.info(
"{source_ref} : {tags} : {message}".format(
source_ref=source_ref.getAsString(),
tags=tag,
message=change_desc()
if inspect.isfunction(change_desc) else change_desc,
))
tags.add(tag)
def signalChange(tags, source_ref, message):
"""Indicate a change to the optimization framework."""
if message is not None:
# Try hard to not call a delayed evaluation of node descriptions.
if _is_verbose:
optimization_logger.info(
"{source_ref} : {tags} : {message}".format(
source_ref=source_ref.getAsString(),
tags=tags,
message=message() if inspect.isfunction(message) else message,
)
)
tag_set.onSignal(tags)
def buildNode(provider, node, source_ref, allow_none=False):
if node is None and allow_none:
return None
try:
kind = getKind(node)
if hasattr(node, "lineno"):
source_ref = source_ref.atLineNumber(node.lineno)
if kind in build_nodes_args3:
result = build_nodes_args3[kind](provider=provider,
node=node,
source_ref=source_ref)
elif kind in build_nodes_args2:
result = build_nodes_args2[kind](node=node, source_ref=source_ref)
elif kind in build_nodes_args1:
result = build_nodes_args1[kind](source_ref=source_ref)
elif kind == "Pass":
result = None
else:
assert False, ast.dump(node)
if result is None and allow_none:
return None
assert isinstance(result, NodeBase), result
return result
except SyntaxError:
raise
except RuntimeError:
# Very likely the stack overflow, which we will turn into too complex
# code exception, don't warn about it with a code dump then.
raise
except KeyboardInterrupt:
# User interrupting is not a problem with the source, but tell where
# we got interrupted.
optimization_logger.info("Interrupted at '%s'." % source_ref)
raise
except:
optimization_logger.warning("Problem at '%s' with %s." %
(source_ref.getAsString(), ast.dump(node)))
raise
def decideModuleTree(filename, package, is_shlib, is_top, is_main):
# Many variables, branches, due to the many cases
# pylint: disable=too-many-branches,too-many-locals,too-many-statements
assert package is None or type(package) is ModuleName
assert filename is not None
if is_main and os.path.isdir(filename):
source_filename = os.path.join(filename, "__main__.py")
if not os.path.isfile(source_filename):
sys.stderr.write("%s: can't find '__main__' module in '%s'\n" %
(os.path.basename(sys.argv[0]), filename))
sys.exit(2)
filename = source_filename
main_added = True
else:
main_added = False
if os.path.isfile(filename):
source_filename = filename
source_ref = SourceCodeReferences.fromFilename(filename=filename)
if is_main:
module_name = ModuleName("__main__")
else:
# Derive module name from filename.
module_name = os.path.basename(filename)
if is_shlib:
module_name = module_name.split(".")[0]
elif module_name.endswith(".py"):
module_name = module_name[:-3]
if "." in module_name:
sys.stderr.write(
"Error, '%s' is not a proper python module name.\n" %
(module_name))
sys.exit(2)
module_name = ModuleName.makeModuleNameInPackage(
module_name, package)
if is_shlib:
result = PythonShlibModule(module_name=module_name,
source_ref=source_ref)
source_code = None
else:
source_code = readSourceCodeFromFilename(
module_name=module_name, source_filename=source_filename)
if is_main:
result = PythonMainModule(
main_added=main_added,
mode=decideCompilationMode(False, module_name, source_ref),
future_spec=None,
source_ref=source_ref,
)
checkPythonVersionFromCode(source_code)
else:
mode = decideCompilationMode(is_top, module_name, source_ref)
if (mode == "bytecode" and not is_top
and hasCachedImportedModulesNames(
module_name, source_code)):
optimization_logger.info("%r is included as bytecode." %
(module_name.asString()))
result = UncompiledPythonModule(
module_name=module_name,
filename=filename,
bytecode=demoteSourceCodeToBytecode(
module_name=module_name,
source_code=source_code,
filename=filename,
),
source_ref=source_ref,
user_provided=False,
technical=False,
)
used_modules = OrderedSet()
for used_module_name in getCachedImportedModulesNames(
module_name=module_name, source_code=source_code):
(
_module_package,
module_filename,
_finding,
) = Importing.findModule(
importing=result,
module_name=used_module_name,
parent_package=None,
level=-1,
warn=False,
)
used_modules.add((used_module_name,
os.path.relpath(module_filename)))
result.setUsedModules(used_modules)
# Not used anymore
source_code = None
else:
result = CompiledPythonModule(
module_name=module_name,
is_top=is_top,
mode=mode,
future_spec=None,
source_ref=source_ref,
)
elif Importing.isPackageDir(filename):
if is_top:
module_name = splitPath(filename)[-1]
else:
module_name = os.path.basename(filename)
module_name = ModuleName.makeModuleNameInPackage(module_name, package)
source_filename = os.path.join(filename, "__init__.py")
if not os.path.isfile(source_filename):
source_ref, result = createNamespacePackage(
module_name=module_name,
is_top=is_top,
module_relpath=filename)
source_filename = None
source_code = None
else:
source_ref = SourceCodeReferences.fromFilename(
filename=os.path.abspath(source_filename))
result = CompiledPythonPackage(
module_name=module_name,
is_top=is_top,
mode=decideCompilationMode(is_top, module_name, source_ref),
future_spec=None,
source_ref=source_ref,
)
source_code = readSourceCodeFromFilename(
module_name=module_name, source_filename=source_filename)
else:
sys.stderr.write("%s: can't open file '%s'.\n" %
(os.path.basename(sys.argv[0]), filename))
sys.exit(2)
return result, source_ref, source_code