ndk/tools/headers-diff-bionic-vs-ndk.py

#!/usr/bin/python
#
# This tool is used to compare headers between Bionic and NDK
# script should be in development/ndk/tools for correct roots autodetection
#

import sys, os, os.path
import subprocess
import argparse, textwrap

class FileCollector:
    """Collect headers from Bionic and sysroot

    sysincludes data format:
    sysincludes                     -- dict with arch as key
    sysincludes[arch]               -- dict with includes root as key
    sysincludes[arch][root]         -- dict with header name as key
    sysincludes[arch][root][header] -- list [last_platform, ..., first_platform]
    """

    def __init__(self, platforms_root, archs):
        """Init platform roots and structures before collecting"""
        self.platforms = []
        self.archs = archs
        self.sysincludes = {}
        for arch in self.archs:
            self.sysincludes[arch] = {}

        ## scaning available platforms ##
        for dirname in os.listdir(platforms_root):
            path = os.path.join(platforms_root, dirname)
            if os.path.isdir(path) and ('android' in dirname):
                self.platforms.append(dirname)
        try:
            self.platforms.sort(key = lambda s: int(s.split('-')[1]))
            self.root = platforms_root
        except Exception:
            print 'Wrong platforms list \n{0}'.format(str(self.platforms))

    def scan_dir(self, root):
        """Non-recursive file scan in directory"""
        files = []
        for filename in os.listdir(root):
            if os.path.isfile(os.path.join(root, filename)):
                files.append(filename)
        return files

    def scan_includes(self, root):
        """Recursive includes scan in given root"""
        includes = []
        includes_root = os.path.join(root, 'include')
        if not os.path.isdir(includes_root):
            return includes

        ## recursive scanning ##
        includes.append(('', self.scan_dir(includes_root)))
        for dirname, dirnames, filenames in os.walk(includes_root):
            for subdirname in dirnames:
                path = os.path.join(dirname, subdirname)
                relpath = os.path.relpath(path, includes_root)
                includes.append((relpath, self.scan_dir(path)))

        return includes

    def scan_archs_includes(self, root):
        """Scan includes for all defined archs in given root"""
        includes = {}
        includes['common'] = self.scan_includes(root)

        for arch in [a for a in self.archs if a != 'common']:
            arch_root = os.path.join(root, arch)
            includes[arch] = self.scan_includes(arch_root)

        return includes

    def scan_platform_includes(self, platform):
        """Scan all platform includes of one layer"""
        platform_root = os.path.join(self.root, platform)
        return self.scan_archs_includes(platform_root)

    def scan_bionic_includes(self, bionic_root):
        """Scan Bionic's libc includes"""
        self.bionic_root = bionic_root
        self.bionic_includes = self.scan_archs_includes(bionic_root)

    def append_sysincludes(self, arch, root, headers, platform):
        """Merge new platform includes layer with current sysincludes"""
        if not (root in self.sysincludes[arch]):
            self.sysincludes[arch][root] = {}

        for include in headers:
            if include in self.sysincludes[arch][root]:
                last_platform = self.sysincludes[arch][root][include][0]
                if platform != last_platform:
                    self.sysincludes[arch][root][include].insert(0, platform)
            else:
                self.sysincludes[arch][root][include] = [platform]

    def update_to_platform(self, platform):
        """Update sysincludes state by applying new platform layer"""
        new_includes = self.scan_platform_includes(platform)
        for arch in self.archs:
            for pack in new_includes[arch]:
                self.append_sysincludes(arch, pack[0], pack[1], platform)

    def scan_sysincludes(self, target_platform):
        """Fully automated sysincludes collector upto specified platform"""
        version = int(target_platform.split('-')[1])
        layers = filter(lambda s: int(s.split('-')[1]) <= version, self.platforms)
        for platform in layers:
            self.update_to_platform(platform)


class BionicSysincludes:
    def set_roots(self):
        """Automated roots initialization (AOSP oriented)"""
        script_root = os.path.dirname(os.path.realpath(__file__))
        self.aosp_root      = os.path.normpath(os.path.join(script_root, '../../..'))
        self.platforms_root = os.path.join(self.aosp_root, 'development/ndk/platforms')
        self.bionic_root    = os.path.join(self.aosp_root, 'bionic/libc')

    def scan_includes(self):
        """Scan all required includes"""
        self.collector = FileCollector(self.platforms_root, self.archs)
        ## detecting latest platform ##
        self.platforms = self.collector.platforms
        latest_platform = self.platforms[-1:][0]
        ## scanning both includes repositories ##
        self.collector.scan_sysincludes(latest_platform)
        self.collector.scan_bionic_includes(self.bionic_root)
        ## scan results ##
        self.sysincludes     = self.collector.sysincludes
        self.bionic_includes = self.collector.bionic_includes

    def git_diff(self, file_origin, file_probe):
        """Difference routine based on git diff"""
        try:
            subprocess.check_output(['git', 'diff', '--no-index', file_origin, file_probe])
        except subprocess.CalledProcessError as error:
            return error.output
        return None

    def match_with_bionic_includes(self):
        """Compare headers between Bionic and sysroot"""
        self.diffs = {}
        ## for every arch ##
        for arch in self.archs:
            arch_root = (lambda s: s if s != 'common' else '')(arch)
            ## for every includes directory ##
            for pack in self.bionic_includes[arch]:
                root = pack[0]
                path_bionic = os.path.join(self.bionic_root, arch_root, 'include', root)
                ## for every header that both in Bionic and sysroot ##
                for include in pack[1]:
                    if (root in self.sysincludes[arch]) and \
                    (include in self.sysincludes[arch][root]):
                        ## completing paths ##
                        platform = self.sysincludes[arch][root][include][0]
                        file_origin = os.path.join(path_bionic, include)
                        file_probe  = os.path.join(self.platforms_root, platform, arch_root, 'include', root, include)
                        ## comparison by git diff ##
                        output = self.git_diff(file_origin, file_probe)
                        if output is not None:
                            if arch not in self.diffs:
                                self.diffs[arch] = {}
                            if root not in self.diffs[arch]:
                                self.diffs[arch][root] = {}
                            ## storing git diff ##
                            self.diffs[arch][root][include] = output

    def print_history(self, arch, root, header):
        """Print human-readable list header updates across platforms"""
        history = self.sysincludes[arch][root][header]
        for platform in self.platforms:
            entry = (lambda s: s.split('-')[1] if s in history else '-')(platform)
            print '{0:3}'.format(entry),
        print ''

    def show_and_store_results(self):
        """Print summary list of headers and write diff-report to file"""
        try:
            diff_fd = open(self.diff_file, 'w')
            for arch in self.archs:
                if arch not in self.diffs:
                    continue
                print '{0}/'.format(arch)
                roots = self.diffs[arch].keys()
                roots.sort()
                for root in roots:
                    print '    {0}/'.format((lambda s: s if s != '' else '../include')(root))
                    includes = self.diffs[arch][root].keys()
                    includes.sort()
                    for include in includes:
                        print '        {0:32}'.format(include),
                        self.print_history(arch, root, include)
                        diff = self.diffs[arch][root][include]
                        diff_fd.write(diff)
                        diff_fd.write('\n\n')
                    print ''
                print ''

        finally:
            diff_fd.close()

    def main(self):
        self.set_roots()
        self.scan_includes()
        self.match_with_bionic_includes()
        self.show_and_store_results()

if __name__ == '__main__':
    ## configuring command line parser ##
    parser = argparse.ArgumentParser(formatter_class = argparse.RawTextHelpFormatter,
                                     description = 'Headers comparison tool between bionic and NDK platforms')
    parser.epilog = textwrap.dedent('''
    output format:
    {architecture}/
        {directory}/
            {header name}.h  {platforms history}

    platforms history format:
        number X means header has been changed in android-X
        `-\' means it is the same

    diff-report format:
        git diff output for all headers
        use --diff option to specify filename
    ''')

    parser.add_argument('--archs', metavar = 'A', nargs = '+',
                        default = ['common', 'arm', 'x86', 'mips'],
                        help = 'list of architectures\n(default: common arm x86 mips)')
    parser.add_argument('--diff', metavar = 'FILE', nargs = 1,
                        default = ['headers-diff-bionic-vs-ndk.diff'],
                        help = 'diff-report filename\n(default: `bionic-vs-sysincludes_report.diff\')')

    ## parsing arguments ##
    args = parser.parse_args()

    ## doing work ##
    app = BionicSysincludes()
    app.archs = map((lambda s: 'arch-{0}'.format(s) if s != 'common' else s), args.archs)
    app.diff_file = args.diff[0]
    app.main()

    print 'Headers listed above are DIFFERENT in Bionic and NDK platforms'
    print 'See `{0}\' for details'.format(app.diff_file)
    print 'See --help for format description.'
    print ''