commands_to_compilation_database_py

#!/usr/bin/env python3
"""A program to generate a compilation database by parsing build
commands on standard input or an input file.  It assumes that a single
line compiles a single source file and the clang compiler is used as
the compiler.

Note that commands for other compilers can be used here, but there is
no guarantee that the options are understood by tools that use the
database.

"""
import sys
import os
import argparse
import re
import json

if __name__ == '__main__':
    description = 'Generate a Clang compilation database from compiler commands.'

    default_compilers = [
        'cc',
        'c++',

        'clang',
        'clang++',

        'gcc',
        'g++',

        'cl',

        # for now
        '/usr/local/bin/clang-3.4',
        '/usr/local/bin/clang++-3.4'
    ]

    c_extensions = [
        '.c',
        '.h'
    ]

    cxx_extensions = [
        '.cpp',
        '.hpp',
        '.cc',
        '.hh',
        '.cxx',
        '.hxx',
        '.C',
        '.H',
    ]

    objc_extensions = [
        '.m'
    ]

    objcxx_extensions = [
        '.mm'
    ]

    default_extensions = \
        c_extensions + \
        cxx_extensions + \
        objc_extensions + \
        objcxx_extensions

    parser = argparse.ArgumentParser(description=description)
    parser.add_argument('--root-directory',
                        action='store',
                        default='',
                        help='The root directory for the project.')
    parser.add_argument('--compilers',
                        action='store',
                        default=default_compilers,
                        help='A list of additional compilers.')
    parser.add_argument('--extensions',
                        action='store',
                        default=default_extensions,
                        help='A list of additional filename extensions.')
    parser.add_argument('--build-tool',
                        action='store',
                        default='',
                        help='The build tool that generated the input.')
    parser.add_argument('--compile-command-regex',
                        action='store',
                        default='',
                        help='A regular expression to parse the command line into the compiler, flags, and filename.')
    parser.add_argument('--incremental',
                        action='store_true',
                        default=False,
                        help='Incrementally update existing database.')
    parser.add_argument('-o', '--output-filename',
                        action='store',
                        default='compile_commands.json',
                        help='The filename of the compilation database.')

    args = parser.parse_args()

    args.output_filename = os.path.abspath(args.output_filename)

    compile_command_regex = None
    if args.compile_command_regex == '':
        if args.build_tool in ['', 'make']:
            compile_command_regex = re.compile(r'^([^ ]+) .* ([^ ]+) +-o +[^ ]+ *$')
        elif args.build_tool == 'Boost.Build':
            compile_command_regex = re.compile(r'^"([^"]+)" .+ "([^"]+)"$')
    else:
        if args.build_tool != '':
            print('warning: regex overriding build tool option.')

        compile_command_regex = re.compile(args.compile_command_regex)

    assert compile_command_regex is not None

    # create the initial compilation database
    compilation_database = []
    if args.incremental:
        if os.path.exists(args.output_filename):
            with open(args.output_filename, 'r') as inputfp:
                compilation_database = json.load(inputfp)

    # generate a more efficient compilation map by filename
    compilation_map = {}
    for entry in compilation_database:
        f = entry['file']
        if not os.path.isabs(f):
            f = os.path.join(entry['directory'], f)
        compilation_map[f] = entry

    # parse the compilation log and update the compilation database
    for line in sys.stdin:
        line = line.strip()

        if line == '':
            continue

        m = compile_command_regex.match(line)
        if m is None:
            continue
        if len(m.groups()) != 2:
            continue

        compiler = m.group(1)
        filename = m.group(2)

        # check if it is a call to a compiler
        if compiler not in args.compilers:
            continue

        # check if the filename extension is supported
        n, e = os.path.splitext(filename)
        if e not in args.extensions:
            continue

        entry = {
            'directory': args.root_directory if args.root_directory != "" else os.getcwd(),
            'command': line,
            'file': filename
        }

        f = entry['file']
        if not os.path.isabs(f):
            f = os.path.join(entry['directory'], f)

        # check for directory/file already in database
        compilation_map[f] = entry

    # convert the compilation map to a compilation database, sorted by
    # the filename
    compilation_database = []
    for k in sorted(compilation_map.keys()):
        compilation_database.append(compilation_map[k])

    # print as json
    with open(args.output_filename, 'w') as outputfp:
        json.dump(compilation_database,
                  fp=outputfp,
                  indent=2,
                  sort_keys=True)