def main():
to_parse, cmd = split_args_to_parse()
# get the module name (if any), then load it
capture_module_name = os.path.basename(cmd[0]) if len(cmd) > 0 else None
mod_name = get_module_name(capture_module_name)
imported_module = None
if mod_name:
# There is module that supports the command
imported_module = load_module(mod_name)
# get the module's argparser and merge it with the global argparser
module_argparser = []
if imported_module:
module_argparser.append(
imported_module.create_argparser(capture_module_name))
global_argparser = create_argparser(module_argparser)
args = global_argparser.parse_args(to_parse)
if imported_module is not None:
utils.configure_logging(args)
try:
logging.info('output of locale.getdefaultlocale(): %s',
str(locale.getdefaultlocale()))
except (locale.Error, ValueError) as e:
logging.info('locale.getdefaultlocale() failed with exception: %s',
str(e))
logging.info('encoding we chose in the end: %s', config.CODESET)
logging.info('Running command %s',
' '.join(map(utils.decode, sys.argv)))
logging.info('Path to infer script %s (%s)', utils.decode(__file__),
os.path.realpath(utils.decode(__file__)))
logging.info('Platform: %s', utils.decode(platform.platform()))
def log_getenv(k):
v = os.getenv(k)
if v is not None:
v = utils.decode(v)
else:
v = '<NOT SET>'
logging.info('%s=%s', k, v)
log_getenv('PATH')
log_getenv('SHELL')
log_getenv('PWD')
capture_exitcode = imported_module.gen_instance(args, cmd).capture()
if capture_exitcode != os.EX_OK:
logging.error('Error during capture phase, exiting')
exit(capture_exitcode)
logging.info('Capture phase was successful')
elif capture_module_name is not None:
# There was a command, but it's not supported
utils.stderr('Command "{cmd}" not recognised'.format(
cmd='' if capture_module_name is None else capture_module_name))
global_argparser.print_help()
sys.exit(1)
else:
global_argparser.print_help()
sys.exit(os.EX_OK)
def parse_command_line(cmd):
cmd_parser = argparse.ArgumentParser()
cmd_parser.add_argument('-jar', type=utils.decode, metavar='Compiler jar')
java_jar, other_args = cmd_parser.parse_known_args(cmd[1:])
if java_jar.jar is None:
utils.stderr('Expects a javac command or jar file for the compiler')
utils.stderr('Example: infer -- java -jar compiler.jar ...\n')
exit(1)
return cmd[0], java_jar.jar, other_args
def parse_command_line(cmd):
cmd_parser = argparse.ArgumentParser()
cmd_parser.add_argument('-jar', type=utils.decode, metavar='Compiler jar')
java_jar, other_args = cmd_parser.parse_known_args(cmd[1:])
if java_jar.jar is None:
utils.stderr('Expects a javac command or jar file for the compiler')
utils.stderr('Example: infer -- java -jar compiler.jar ...\n')
exit(1)
return cmd[0], java_jar.jar, other_args
def get_build_output(build_cmd):
# TODO make it return generator to be able to handle large builds
proc = subprocess.Popen(build_cmd, stdout=subprocess.PIPE)
(verbose_out_chars, _) = proc.communicate()
if proc.returncode != 0:
utils.stderr(
'ERROR: couldn\'t run compilation command `{}`'.format(build_cmd))
return (proc.returncode, None)
out = utils.decode(verbose_out_chars).split('\n')
return (os.EX_OK, out)
def run_compilation_commands(cmds, clean_cmd):
"""runs compilation commands, and suggests a project cleaning command
in case there is nothing to compile.
"""
# TODO call it in parallel
if cmds is None or len(cmds) == 0:
utils.stderr(
'Nothing to compile. Try running `{}` first.'.format(clean_cmd))
return os.EX_NOINPUT
for cmd in cmds:
if cmd.start() != os.EX_OK:
return os.EX_SOFTWARE
return os.EX_OK
def get_build_output(build_cmd):
from inferlib import utils
# TODO make it return generator to be able to handle large builds
proc = subprocess.Popen(build_cmd, stdout=subprocess.PIPE)
(out_chars, err_chars) = proc.communicate()
out = utils.decode(out_chars) if out_chars is not None else ''
err = utils.decode(err_chars) if err_chars is not None else ''
if proc.returncode != os.EX_OK:
utils.stderr(
'ERROR: couldn\'t run compilation command `{}`'.format(build_cmd))
logging.error(
'ERROR: couldn\'t run compilation command `{}`:\n\
*** stdout:\n{}\n*** stderr:\n{}\n'
.format(build_cmd, out, err))
return (proc.returncode, (out, err))
def check_results(errors, patterns):
unexpected = unexpected_errors(errors, patterns)
if unexpected != []:
utils.stderr('\nInfer found the following unexpected errors:')
for e in unexpected:
utils.stderr('\t{}\n'.format(string_of_error(e)))
missing = missing_errors(errors, patterns)
if missing != []:
utils.stderr('\nInfer did not find the following errors:')
for p in missing:
utils.stderr('\t{}\n'.format(string_of_error(p)))
assert unexpected == []
assert missing == []
def check_results(errors, patterns):
unexpected = unexpected_errors(errors, patterns)
if unexpected != []:
utils.stderr('\nInfer found the following unexpected errors:')
for e in unexpected:
utils.stderr('\t{}\n'.format(string_of_error(e)))
missing = missing_errors(errors, patterns)
if missing != []:
utils.stderr('\nInfer did not find the following errors:')
for p in missing:
utils.stderr('\t{}\n'.format(string_of_error(p)))
assert unexpected == []
assert missing == []
def error(self, message):
utils.stderr(message)
utils.stderr('')
exit(22) # in sync with infer.ml
def validate_args(mode, args):
if mode is not None and mode.LANG == ['clang'] and \
args.analyzer == config.ANALYZER_CHECKERS:
utils.stderr('error: checkers are only enabled for Java.')
if not args.debug:
exit(1)
def error(self, message):
utils.stderr(message)
utils.stderr('')
exit(22) # in sync with infer.ml
def main():
to_parse, cmd = split_args_to_parse()
# first pass to see if a capture module is forced
initial_argparser = IgnoreFailuresArgumentParser(
parents=[analyze.infer_parser],
add_help=False,
formatter_class=argparse.RawDescriptionHelpFormatter,
)
initial_args = initial_argparser.parse_args(to_parse)
# get the module name (if any), then load it
capture_module_name = None
if initial_args.force_integration is not None:
capture_module_name = initial_args.force_integration
elif len(cmd) > 0:
capture_module_name = os.path.basename(cmd[0])
mod_name = get_module_name(capture_module_name)
imported_module = None
if mod_name:
# There is module that supports the command
imported_module = load_module(mod_name)
# get the module's argparser and merge it with the global argparser
module_argparser = []
if imported_module:
module_argparser.append(
imported_module.create_argparser(capture_module_name)
)
global_argparser = create_argparser(module_argparser)
args = global_argparser.parse_args(to_parse)
if imported_module is not None:
utils.configure_logging(args)
try:
logging.info('output of locale.getdefaultlocale(): %s',
str(locale.getdefaultlocale()))
except (locale.Error, ValueError) as e:
logging.info('locale.getdefaultlocale() failed with exception: %s',
str(e))
logging.info('encoding we chose in the end: %s',
config.CODESET)
logging.info('Running command %s',
' '.join(map(utils.decode, sys.argv)))
logging.info('Path to infer script %s (%s)', utils.decode(__file__),
os.path.realpath(utils.decode(__file__)))
logging.info('Platform: %s', utils.decode(platform.platform()))
def log_getenv(k):
v = os.getenv(k)
if v is not None:
v = utils.decode(v)
else:
v = '<NOT SET>'
logging.info('%s=%s', k, v)
log_getenv('PATH')
log_getenv('SHELL')
log_getenv('PWD')
capture_exitcode = imported_module.gen_instance(args, cmd).capture()
if capture_exitcode != os.EX_OK:
logging.error('Error during capture phase, exiting')
exit(capture_exitcode)
logging.info('Capture phase was successful')
elif capture_module_name is not None:
# There was a command, but it's not supported
utils.stderr('Command "{cmd}" not recognised'
.format(cmd='' if capture_module_name is None
else capture_module_name))
global_argparser.print_help()
sys.exit(1)
else:
global_argparser.print_help()
sys.exit(os.EX_OK)
def validate_args(mode, args):
if mode is not None and mode.LANG == ['clang'] and \
args.analyzer == config.ANALYZER_CHECKERS:
utils.stderr('error: checkers are only enabled for Java.')
if not args.debug:
exit(1)
