| #!/usr/bin/env python3 |
| |
| """ |
| Command to print info about makefiles remaining to be converted to soong. |
| |
| See usage / argument parsing below for commandline options. |
| """ |
| |
| import argparse |
| import csv |
| import itertools |
| import json |
| import os |
| import re |
| import sys |
| |
| DIRECTORY_PATTERNS = [x.split("/") for x in ( |
| "device/*", |
| "frameworks/*", |
| "hardware/*", |
| "packages/*", |
| "vendor/*", |
| "*", |
| )] |
| |
| def match_directory_group(pattern, filename): |
| match = [] |
| filename = filename.split("/") |
| if len(filename) < len(pattern): |
| return None |
| for i in range(len(pattern)): |
| pattern_segment = pattern[i] |
| filename_segment = filename[i] |
| if pattern_segment == "*" or pattern_segment == filename_segment: |
| match.append(filename_segment) |
| else: |
| return None |
| if match: |
| return os.path.sep.join(match) |
| else: |
| return None |
| |
| def directory_group(filename): |
| for pattern in DIRECTORY_PATTERNS: |
| match = match_directory_group(pattern, filename) |
| if match: |
| return match |
| return os.path.dirname(filename) |
| |
| class Analysis(object): |
| def __init__(self, filename, line_matches): |
| self.filename = filename; |
| self.line_matches = line_matches |
| |
| def analyze_lines(filename, lines, func): |
| line_matches = [] |
| for i in range(len(lines)): |
| line = lines[i] |
| stripped = line.strip() |
| if stripped.startswith("#"): |
| continue |
| if func(stripped): |
| line_matches.append((i+1, line)) |
| if line_matches: |
| return Analysis(filename, line_matches); |
| |
| def analyze_has_conditional(line): |
| return (line.startswith("ifeq") or line.startswith("ifneq") |
| or line.startswith("ifdef") or line.startswith("ifndef")) |
| |
| NORMAL_INCLUDES = [re.compile(pattern) for pattern in ( |
| "include \$+\(CLEAR_VARS\)", # These are in defines which are tagged separately |
| "include \$+\(BUILD_.*\)", |
| "include \$\(call first-makefiles-under, *\$\(LOCAL_PATH\)\)", |
| "include \$\(call all-subdir-makefiles\)", |
| "include \$\(all-subdir-makefiles\)", |
| "include \$\(call all-makefiles-under, *\$\(LOCAL_PATH\)\)", |
| "include \$\(call all-makefiles-under, *\$\(call my-dir\).*\)", |
| "include \$\(BUILD_SYSTEM\)/base_rules.mk", # called out separately |
| "include \$\(call all-named-subdir-makefiles,.*\)", |
| "include \$\(subdirs\)", |
| )] |
| def analyze_has_wacky_include(line): |
| if not (line.startswith("include") or line.startswith("-include") |
| or line.startswith("sinclude")): |
| return False |
| for matcher in NORMAL_INCLUDES: |
| if matcher.fullmatch(line): |
| return False |
| return True |
| |
| BASE_RULES_RE = re.compile("include \$\(BUILD_SYSTEM\)/base_rules.mk") |
| |
| class Analyzer(object): |
| def __init__(self, title, func): |
| self.title = title; |
| self.func = func |
| |
| |
| ANALYZERS = ( |
| Analyzer("ifeq / ifneq", analyze_has_conditional), |
| Analyzer("Wacky Includes", analyze_has_wacky_include), |
| Analyzer("Calls base_rules", lambda line: BASE_RULES_RE.fullmatch(line)), |
| Analyzer("Calls define", lambda line: line.startswith("define ")), |
| Analyzer("Has ../", lambda line: "../" in line), |
| Analyzer("dist-for-​goals", lambda line: "dist-for-goals" in line), |
| Analyzer(".PHONY", lambda line: ".PHONY" in line), |
| Analyzer("render-​script", lambda line: ".rscript" in line), |
| Analyzer("vts src", lambda line: ".vts" in line), |
| Analyzer("COPY_​HEADERS", lambda line: "LOCAL_COPY_HEADERS" in line), |
| ) |
| |
| class Summary(object): |
| def __init__(self): |
| self.makefiles = dict() |
| self.directories = dict() |
| |
| def Add(self, makefile): |
| self.makefiles[makefile.filename] = makefile |
| self.directories.setdefault(directory_group(makefile.filename), []).append(makefile) |
| |
| class Makefile(object): |
| def __init__(self, filename): |
| self.filename = filename |
| |
| # Analyze the file |
| with open(filename, "r", errors="ignore") as f: |
| try: |
| lines = f.readlines() |
| except UnicodeDecodeError as ex: |
| sys.stderr.write("Filename: %s\n" % filename) |
| raise ex |
| lines = [line.strip() for line in lines] |
| |
| self.analyses = dict([(analyzer, analyze_lines(filename, lines, analyzer.func)) for analyzer |
| in ANALYZERS]) |
| |
| def find_android_mk(): |
| cwd = os.getcwd() |
| for root, dirs, files in os.walk(cwd): |
| for filename in files: |
| if filename == "Android.mk": |
| yield os.path.join(root, filename)[len(cwd) + 1:] |
| for ignore in (".git", ".repo"): |
| if ignore in dirs: |
| dirs.remove(ignore) |
| |
| def is_aosp(dirname): |
| for d in ("device/sample", "hardware/interfaces", "hardware/libhardware", |
| "hardware/ril"): |
| if dirname.startswith(d): |
| return True |
| for d in ("device/", "hardware/", "vendor/"): |
| if dirname.startswith(d): |
| return False |
| return True |
| |
| def is_google(dirname): |
| for d in ("device/google", |
| "hardware/google", |
| "test/sts", |
| "vendor/auto", |
| "vendor/google", |
| "vendor/unbundled_google", |
| "vendor/widevine", |
| "vendor/xts"): |
| if dirname.startswith(d): |
| return True |
| return False |
| |
| def is_clean(makefile): |
| for analysis in makefile.analyses.values(): |
| if analysis: |
| return False |
| return True |
| |
| def clean_and_only_blocked_by_clean(soong, all_makefiles, makefile): |
| if not is_clean(makefile): |
| return False |
| modules = soong.reverse_makefiles[makefile.filename] |
| for module in modules: |
| for dep in soong.transitive_deps(module): |
| for filename in soong.makefiles.get(dep, []): |
| m = all_makefiles.get(filename) |
| if m and not is_clean(m): |
| return False |
| return True |
| |
| class Annotations(object): |
| def __init__(self): |
| self.entries = [] |
| self.count = 0 |
| |
| def Add(self, makefiles, modules): |
| self.entries.append((makefiles, modules)) |
| self.count += 1 |
| return self.count-1 |
| |
| class SoongData(object): |
| def __init__(self, reader): |
| """Read the input file and store the modules and dependency mappings. |
| """ |
| self.problems = dict() |
| self.deps = dict() |
| self.reverse_deps = dict() |
| self.module_types = dict() |
| self.makefiles = dict() |
| self.reverse_makefiles = dict() |
| self.installed = dict() |
| self.reverse_installed = dict() |
| self.modules = set() |
| |
| for (module, module_type, problem, dependencies, makefiles, installed) in reader: |
| self.modules.add(module) |
| makefiles = [f for f in makefiles.strip().split(' ') if f != ""] |
| self.module_types[module] = module_type |
| self.problems[module] = problem |
| self.deps[module] = [d for d in dependencies.strip().split(' ') if d != ""] |
| for dep in self.deps[module]: |
| if not dep in self.reverse_deps: |
| self.reverse_deps[dep] = [] |
| self.reverse_deps[dep].append(module) |
| self.makefiles[module] = makefiles |
| for f in makefiles: |
| self.reverse_makefiles.setdefault(f, []).append(module) |
| for f in installed.strip().split(' '): |
| self.installed[f] = module |
| self.reverse_installed.setdefault(module, []).append(f) |
| |
| def transitive_deps(self, module): |
| results = set() |
| def traverse(module): |
| for dep in self.deps.get(module, []): |
| if not dep in results: |
| results.add(dep) |
| traverse(module) |
| traverse(module) |
| return results |
| |
| def contains_unblocked_modules(self, filename): |
| for m in self.reverse_makefiles[filename]: |
| if len(self.deps[m]) == 0: |
| return True |
| return False |
| |
| def contains_blocked_modules(self, filename): |
| for m in self.reverse_makefiles[filename]: |
| if len(self.deps[m]) > 0: |
| return True |
| return False |
| |
| def count_deps(depsdb, module, seen): |
| """Based on the depsdb, count the number of transitive dependencies. |
| |
| You can pass in an reversed dependency graph to count the number of |
| modules that depend on the module.""" |
| count = 0 |
| seen.append(module) |
| if module in depsdb: |
| for dep in depsdb[module]: |
| if dep in seen: |
| continue |
| count += 1 + count_deps(depsdb, dep, seen) |
| return count |
| |
| OTHER_PARTITON = "_other" |
| HOST_PARTITON = "_host" |
| |
| def get_partition_from_installed(HOST_OUT_ROOT, PRODUCT_OUT, filename): |
| host_prefix = HOST_OUT_ROOT + "/" |
| device_prefix = PRODUCT_OUT + "/" |
| |
| if filename.startswith(host_prefix): |
| return HOST_PARTITON |
| |
| elif filename.startswith(device_prefix): |
| index = filename.find("/", len(device_prefix)) |
| if index < 0: |
| return OTHER_PARTITON |
| return filename[len(device_prefix):index] |
| |
| return OTHER_PARTITON |
| |
| def format_module_link(module): |
| return "<a class='ModuleLink' href='#module_%s'>%s</a>" % (module, module) |
| |
| def format_module_list(modules): |
| return "".join(["<div>%s</div>" % format_module_link(m) for m in modules]) |
| |
| def print_analysis_header(link, title): |
| print(""" |
| <a name="%(link)s"></a> |
| <h2>%(title)s</h2> |
| <table> |
| <tr> |
| <th class="RowTitle">Directory</th> |
| <th class="Count">Total</th> |
| <th class="Count Clean">Easy</th> |
| <th class="Count Clean">Unblocked Clean</th> |
| <th class="Count Unblocked">Unblocked</th> |
| <th class="Count Blocked">Blocked</th> |
| <th class="Count Clean">Clean</th> |
| """ % { |
| "link": link, |
| "title": title |
| }) |
| for analyzer in ANALYZERS: |
| print("""<th class="Count Warning">%s</th>""" % analyzer.title) |
| print(" </tr>") |
| |
| # get all modules in $(PRODUCT_PACKAGE) and the corresponding deps |
| def get_module_product_packages_plus_deps(initial_modules, result, soong_data): |
| for module in initial_modules: |
| if module in result: |
| continue |
| result.add(module) |
| if module in soong_data.deps: |
| get_module_product_packages_plus_deps(soong_data.deps[module], result, soong_data) |
| |
| def main(): |
| parser = argparse.ArgumentParser(description="Info about remaining Android.mk files.") |
| parser.add_argument("--device", type=str, required=True, |
| help="TARGET_DEVICE") |
| parser.add_argument("--product-packages", type=argparse.FileType('r'), |
| default=None, |
| help="PRODUCT_PACKAGES") |
| parser.add_argument("--title", type=str, |
| help="page title") |
| parser.add_argument("--codesearch", type=str, |
| default="https://cs.android.com/android/platform/superproject/+/master:", |
| help="page title") |
| parser.add_argument("--out-dir", type=str, |
| default=None, |
| help="Equivalent of $OUT_DIR, which will also be checked if" |
| + " --out-dir is unset. If neither is set, default is" |
| + " 'out'.") |
| parser.add_argument("--mode", type=str, |
| default="html", |
| help="output format: csv or html") |
| |
| args = parser.parse_args() |
| |
| # Guess out directory name |
| if not args.out_dir: |
| args.out_dir = os.getenv("OUT_DIR", "out") |
| while args.out_dir.endswith("/") and len(args.out_dir) > 1: |
| args.out_dir = args.out_dir[:-1] |
| |
| TARGET_DEVICE = args.device |
| global HOST_OUT_ROOT |
| HOST_OUT_ROOT = args.out_dir + "/host" |
| global PRODUCT_OUT |
| PRODUCT_OUT = args.out_dir + "/target/product/%s" % TARGET_DEVICE |
| |
| # Read target information |
| # TODO: Pull from configurable location. This is also slightly different because it's |
| # only a single build, where as the tree scanning we do below is all Android.mk files. |
| with open("%s/obj/PACKAGING/soong_conversion_intermediates/soong_conv_data" |
| % PRODUCT_OUT, "r", errors="ignore") as csvfile: |
| soong = SoongData(csv.reader(csvfile)) |
| |
| # Read the makefiles |
| all_makefiles = dict() |
| for filename, modules in soong.reverse_makefiles.items(): |
| if filename.startswith(args.out_dir + "/"): |
| continue |
| all_makefiles[filename] = Makefile(filename) |
| |
| # Get all the modules in $(PRODUCT_PACKAGES) and the correspoding deps |
| product_package_modules_plus_deps = set() |
| if args.product_packages: |
| product_package_top_modules = args.product_packages.read().strip().split('\n') |
| get_module_product_packages_plus_deps(product_package_top_modules, product_package_modules_plus_deps, soong) |
| |
| if args.mode == "html": |
| HtmlProcessor(args=args, soong=soong, all_makefiles=all_makefiles, |
| product_packages_modules=product_package_modules_plus_deps).execute() |
| elif args.mode == "csv": |
| CsvProcessor(args=args, soong=soong, all_makefiles=all_makefiles, |
| product_packages_modules=product_package_modules_plus_deps).execute() |
| |
| class HtmlProcessor(object): |
| def __init__(self, args, soong, all_makefiles, product_packages_modules): |
| self.args = args |
| self.soong = soong |
| self.all_makefiles = all_makefiles |
| self.product_packages_modules = product_packages_modules |
| self.annotations = Annotations() |
| |
| def execute(self): |
| if self.args.title: |
| page_title = self.args.title |
| else: |
| page_title = "Remaining Android.mk files" |
| |
| # Which modules are installed where |
| modules_by_partition = dict() |
| partitions = set() |
| for installed, module in self.soong.installed.items(): |
| if len(self.product_packages_modules) > 0 and module not in self.product_packages_modules: |
| continue |
| partition = get_partition_from_installed(HOST_OUT_ROOT, PRODUCT_OUT, installed) |
| modules_by_partition.setdefault(partition, []).append(module) |
| partitions.add(partition) |
| |
| print(""" |
| <html> |
| <head> |
| <title>%(page_title)s</title> |
| <style type="text/css"> |
| body, table { |
| font-family: Roboto, sans-serif; |
| font-size: 9pt; |
| } |
| body { |
| margin: 0; |
| padding: 0; |
| display: flex; |
| flex-direction: column; |
| height: 100vh; |
| } |
| #container { |
| flex: 1; |
| display: flex; |
| flex-direction: row; |
| overflow: hidden; |
| } |
| #tables { |
| padding: 0 20px 40px 20px; |
| overflow: scroll; |
| flex: 2 2 600px; |
| } |
| #details { |
| display: none; |
| overflow: scroll; |
| flex: 1 1 650px; |
| padding: 0 20px 0 20px; |
| } |
| h1 { |
| margin: 16px 0 16px 20px; |
| } |
| h2 { |
| margin: 12px 0 4px 0; |
| } |
| .RowTitle { |
| text-align: left; |
| width: 200px; |
| min-width: 200px; |
| } |
| .Count { |
| text-align: center; |
| width: 60px; |
| min-width: 60px; |
| max-width: 60px; |
| } |
| th.Clean, |
| th.Unblocked { |
| background-color: #1e8e3e; |
| } |
| th.Blocked { |
| background-color: #d93025; |
| } |
| th.Warning { |
| background-color: #e8710a; |
| } |
| th { |
| background-color: #1a73e8; |
| color: white; |
| font-weight: bold; |
| } |
| td.Unblocked { |
| background-color: #81c995; |
| } |
| td.Blocked { |
| background-color: #f28b82; |
| } |
| td, th { |
| padding: 2px 4px; |
| border-right: 2px solid white; |
| } |
| tr.TotalRow td { |
| background-color: white; |
| border-right-color: white; |
| } |
| tr.AospDir td { |
| background-color: #e6f4ea; |
| border-right-color: #e6f4ea; |
| } |
| tr.GoogleDir td { |
| background-color: #e8f0fe; |
| border-right-color: #e8f0fe; |
| } |
| tr.PartnerDir td { |
| background-color: #fce8e6; |
| border-right-color: #fce8e6; |
| } |
| table { |
| border-spacing: 0; |
| border-collapse: collapse; |
| } |
| div.Makefile { |
| margin: 12px 0 0 0; |
| } |
| div.Makefile:first { |
| margin-top: 0; |
| } |
| div.FileModules { |
| padding: 4px 0 0 20px; |
| } |
| td.LineNo { |
| vertical-align: baseline; |
| padding: 6px 0 0 20px; |
| width: 50px; |
| vertical-align: baseline; |
| } |
| td.LineText { |
| vertical-align: baseline; |
| font-family: monospace; |
| padding: 6px 0 0 0; |
| } |
| a.CsLink { |
| font-family: monospace; |
| } |
| div.Help { |
| width: 550px; |
| } |
| table.HelpColumns tr { |
| border-bottom: 2px solid white; |
| } |
| .ModuleName { |
| vertical-align: baseline; |
| padding: 6px 0 0 20px; |
| width: 275px; |
| } |
| .ModuleDeps { |
| vertical-align: baseline; |
| padding: 6px 0 0 0; |
| } |
| table#Modules td { |
| vertical-align: baseline; |
| } |
| tr.Alt { |
| background-color: #ececec; |
| } |
| tr.Alt td { |
| border-right-color: #ececec; |
| } |
| .AnalysisCol { |
| width: 300px; |
| padding: 2px; |
| line-height: 21px; |
| } |
| .Analysis { |
| color: white; |
| font-weight: bold; |
| background-color: #e8710a; |
| border-radius: 6px; |
| margin: 4px; |
| padding: 2px 6px; |
| white-space: nowrap; |
| } |
| .Nav { |
| margin: 4px 0 16px 20px; |
| } |
| .NavSpacer { |
| display: inline-block; |
| width: 6px; |
| } |
| .ModuleDetails { |
| margin-top: 20px; |
| } |
| .ModuleDetails td { |
| vertical-align: baseline; |
| } |
| </style> |
| </head> |
| <body> |
| <h1>%(page_title)s</h1> |
| <div class="Nav"> |
| <a href='#help'>Help</a> |
| <span class='NavSpacer'></span><span class='NavSpacer'> </span> |
| Partitions: |
| """ % { |
| "page_title": page_title, |
| }) |
| for partition in sorted(partitions): |
| print("<a href='#partition_%s'>%s</a><span class='NavSpacer'></span>" % (partition, partition)) |
| |
| print(""" |
| <span class='NavSpacer'></span><span class='NavSpacer'> </span> |
| <a href='#summary'>Overall Summary</a> |
| </div> |
| <div id="container"> |
| <div id="tables"> |
| <a name="help"></a> |
| <div class="Help"> |
| <p> |
| This page analyzes the remaining Android.mk files in the Android Source tree. |
| <p> |
| The modules are first broken down by which of the device filesystem partitions |
| they are installed to. This also includes host tools and testcases which don't |
| actually reside in their own partition but convenitely group together. |
| <p> |
| The makefiles for each partition are further are grouped into a set of directories |
| aritrarily picked to break down the problem size by owners. |
| <ul style="width: 300px"> |
| <li style="background-color: #e6f4ea">AOSP directories are colored green.</li> |
| <li style="background-color: #e8f0fe">Google directories are colored blue.</li> |
| <li style="background-color: #fce8e6">Other partner directories are colored red.</li> |
| </ul> |
| Each of the makefiles are scanned for issues that are likely to come up during |
| conversion to soong. Clicking the number in each cell shows additional information, |
| including the line that triggered the warning. |
| <p> |
| <table class="HelpColumns"> |
| <tr> |
| <th>Total</th> |
| <td>The total number of makefiles in this each directory.</td> |
| </tr> |
| <tr> |
| <th class="Clean">Easy</th> |
| <td>The number of makefiles that have no warnings themselves, and also |
| none of their dependencies have warnings either.</td> |
| </tr> |
| <tr> |
| <th class="Clean">Unblocked Clean</th> |
| <td>The number of makefiles that are both Unblocked and Clean.</td> |
| </tr> |
| |
| <tr> |
| <th class="Unblocked">Unblocked</th> |
| <td>Makefiles containing one or more modules that don't have any |
| additional dependencies pending before conversion.</td> |
| </tr> |
| <tr> |
| <th class="Blocked">Blocked</th> |
| <td>Makefiles containiong one or more modules which <i>do</i> have |
| additional prerequesite depenedencies that are not yet converted.</td> |
| </tr> |
| <tr> |
| <th class="Clean">Clean</th> |
| <td>The number of makefiles that have none of the following warnings.</td> |
| </tr> |
| <tr> |
| <th class="Warning">ifeq / ifneq</th> |
| <td>Makefiles that use <code>ifeq</code> or <code>ifneq</code>. i.e. |
| conditionals.</td> |
| </tr> |
| <tr> |
| <th class="Warning">Wacky Includes</th> |
| <td>Makefiles that <code>include</code> files other than the standard build-system |
| defined template and macros.</td> |
| </tr> |
| <tr> |
| <th class="Warning">Calls base_rules</th> |
| <td>Makefiles that include base_rules.mk directly.</td> |
| </tr> |
| <tr> |
| <th class="Warning">Calls define</th> |
| <td>Makefiles that define their own macros. Some of these are easy to convert |
| to soong <code>defaults</code>, but others are complex.</td> |
| </tr> |
| <tr> |
| <th class="Warning">Has ../</th> |
| <td>Makefiles containing the string "../" outside of a comment. These likely |
| access files outside their directories.</td> |
| </tr> |
| <tr> |
| <th class="Warning">dist-for-goals</th> |
| <td>Makefiles that call <code>dist-for-goals</code> directly.</td> |
| </tr> |
| <tr> |
| <th class="Warning">.PHONY</th> |
| <td>Makefiles that declare .PHONY targets.</td> |
| </tr> |
| <tr> |
| <th class="Warning">renderscript</th> |
| <td>Makefiles defining targets that depend on <code>.rscript</code> source files.</td> |
| </tr> |
| <tr> |
| <th class="Warning">vts src</th> |
| <td>Makefiles defining targets that depend on <code>.vts</code> source files.</td> |
| </tr> |
| <tr> |
| <th class="Warning">COPY_HEADERS</th> |
| <td>Makefiles using LOCAL_COPY_HEADERS.</td> |
| </tr> |
| </table> |
| <p> |
| Following the list of directories is a list of the modules that are installed on |
| each partition. Potential issues from their makefiles are listed, as well as the |
| total number of dependencies (both blocking that module and blocked by that module) |
| and the list of direct dependencies. Note: The number is the number of all transitive |
| dependencies and the list of modules is only the direct dependencies. |
| </div> |
| """) |
| |
| overall_summary = Summary() |
| |
| # For each partition |
| for partition in sorted(partitions): |
| modules = modules_by_partition[partition] |
| |
| makefiles = set(itertools.chain.from_iterable( |
| [self.soong.makefiles[module] for module in modules])) |
| |
| # Read makefiles |
| summary = Summary() |
| for filename in makefiles: |
| makefile = self.all_makefiles.get(filename) |
| if makefile: |
| summary.Add(makefile) |
| overall_summary.Add(makefile) |
| |
| # Categorize directories by who is responsible |
| aosp_dirs = [] |
| google_dirs = [] |
| partner_dirs = [] |
| for dirname in sorted(summary.directories.keys()): |
| if is_aosp(dirname): |
| aosp_dirs.append(dirname) |
| elif is_google(dirname): |
| google_dirs.append(dirname) |
| else: |
| partner_dirs.append(dirname) |
| |
| print_analysis_header("partition_" + partition, partition) |
| |
| for dirgroup, rowclass in [(aosp_dirs, "AospDir"), |
| (google_dirs, "GoogleDir"), |
| (partner_dirs, "PartnerDir"),]: |
| for dirname in dirgroup: |
| self.print_analysis_row(summary, modules, |
| dirname, rowclass, summary.directories[dirname]) |
| |
| self.print_analysis_row(summary, modules, |
| "Total", "TotalRow", |
| set(itertools.chain.from_iterable(summary.directories.values()))) |
| print(""" |
| </table> |
| """) |
| |
| module_details = [(count_deps(self.soong.deps, m, []), |
| -count_deps(self.soong.reverse_deps, m, []), m) |
| for m in modules] |
| module_details.sort() |
| module_details = [m[2] for m in module_details] |
| print(""" |
| <table class="ModuleDetails">""") |
| print("<tr>") |
| print(" <th>Module Name</th>") |
| print(" <th>Issues</th>") |
| print(" <th colspan='2'>Blocked By</th>") |
| print(" <th colspan='2'>Blocking</th>") |
| print("</tr>") |
| altRow = True |
| for module in module_details: |
| analyses = set() |
| for filename in self.soong.makefiles[module]: |
| makefile = summary.makefiles.get(filename) |
| if makefile: |
| for analyzer, analysis in makefile.analyses.items(): |
| if analysis: |
| analyses.add(analyzer.title) |
| |
| altRow = not altRow |
| print("<tr class='%s'>" % ("Alt" if altRow else "",)) |
| print(" <td><a name='module_%s'></a>%s</td>" % (module, module)) |
| print(" <td class='AnalysisCol'>%s</td>" % " ".join(["<span class='Analysis'>%s</span>" % title |
| for title in analyses])) |
| print(" <td>%s</td>" % count_deps(self.soong.deps, module, [])) |
| print(" <td>%s</td>" % format_module_list(self.soong.deps.get(module, []))) |
| print(" <td>%s</td>" % count_deps(self.soong.reverse_deps, module, [])) |
| print(" <td>%s</td>" % format_module_list(self.soong.reverse_deps.get(module, []))) |
| print("</tr>") |
| print("""</table>""") |
| |
| print_analysis_header("summary", "Overall Summary") |
| |
| modules = [module for installed, module in self.soong.installed.items()] |
| self.print_analysis_row(overall_summary, modules, |
| "All Makefiles", "TotalRow", |
| set(itertools.chain.from_iterable(overall_summary.directories.values()))) |
| print(""" |
| </table> |
| """) |
| |
| print(""" |
| <script type="text/javascript"> |
| function close_details() { |
| document.getElementById('details').style.display = 'none'; |
| } |
| |
| class LineMatch { |
| constructor(lineno, text) { |
| this.lineno = lineno; |
| this.text = text; |
| } |
| } |
| |
| class Analysis { |
| constructor(filename, modules, line_matches) { |
| this.filename = filename; |
| this.modules = modules; |
| this.line_matches = line_matches; |
| } |
| } |
| |
| class Module { |
| constructor(deps) { |
| this.deps = deps; |
| } |
| } |
| |
| function make_module_link(module) { |
| var a = document.createElement('a'); |
| a.className = 'ModuleLink'; |
| a.innerText = module; |
| a.href = '#module_' + module; |
| return a; |
| } |
| |
| function update_details(id) { |
| document.getElementById('details').style.display = 'block'; |
| |
| var analyses = ANALYSIS[id]; |
| |
| var details = document.getElementById("details_data"); |
| while (details.firstChild) { |
| details.removeChild(details.firstChild); |
| } |
| |
| for (var i=0; i<analyses.length; i++) { |
| var analysis = analyses[i]; |
| |
| var makefileDiv = document.createElement('div'); |
| makefileDiv.className = 'Makefile'; |
| details.appendChild(makefileDiv); |
| |
| var fileA = document.createElement('a'); |
| makefileDiv.appendChild(fileA); |
| fileA.className = 'CsLink'; |
| fileA.href = '%(codesearch)s' + analysis.filename; |
| fileA.innerText = analysis.filename; |
| fileA.target = "_blank"; |
| |
| if (analysis.modules.length > 0) { |
| var moduleTable = document.createElement('table'); |
| details.appendChild(moduleTable); |
| |
| for (var j=0; j<analysis.modules.length; j++) { |
| var moduleRow = document.createElement('tr'); |
| moduleTable.appendChild(moduleRow); |
| |
| var moduleNameCell = document.createElement('td'); |
| moduleRow.appendChild(moduleNameCell); |
| moduleNameCell.className = 'ModuleName'; |
| moduleNameCell.appendChild(make_module_link(analysis.modules[j])); |
| |
| var moduleData = MODULE_DATA[analysis.modules[j]]; |
| console.log(moduleData); |
| |
| var depCell = document.createElement('td'); |
| moduleRow.appendChild(depCell); |
| |
| if (moduleData.deps.length == 0) { |
| depCell.className = 'ModuleDeps Unblocked'; |
| depCell.innerText = 'UNBLOCKED'; |
| } else { |
| depCell.className = 'ModuleDeps Blocked'; |
| |
| for (var k=0; k<moduleData.deps.length; k++) { |
| depCell.appendChild(make_module_link(moduleData.deps[k])); |
| depCell.appendChild(document.createElement('br')); |
| } |
| } |
| } |
| } |
| |
| if (analysis.line_matches.length > 0) { |
| var lineTable = document.createElement('table'); |
| details.appendChild(lineTable); |
| |
| for (var j=0; j<analysis.line_matches.length; j++) { |
| var line_match = analysis.line_matches[j]; |
| |
| var lineRow = document.createElement('tr'); |
| lineTable.appendChild(lineRow); |
| |
| var linenoCell = document.createElement('td'); |
| lineRow.appendChild(linenoCell); |
| linenoCell.className = 'LineNo'; |
| |
| var linenoA = document.createElement('a'); |
| linenoCell.appendChild(linenoA); |
| linenoA.className = 'CsLink'; |
| linenoA.href = '%(codesearch)s' + analysis.filename |
| + ';l=' + line_match.lineno; |
| linenoA.innerText = line_match.lineno; |
| linenoA.target = "_blank"; |
| |
| var textCell = document.createElement('td'); |
| lineRow.appendChild(textCell); |
| textCell.className = 'LineText'; |
| textCell.innerText = line_match.text; |
| } |
| } |
| } |
| } |
| |
| var ANALYSIS = [ |
| """ % { |
| "codesearch": self.args.codesearch, |
| }) |
| for entry, mods in self.annotations.entries: |
| print(" [") |
| for analysis in entry: |
| print(" new Analysis('%(filename)s', %(modules)s, [%(line_matches)s])," % { |
| "filename": analysis.filename, |
| #"modules": json.dumps([m for m in mods if m in filename in self.soong.makefiles[m]]), |
| "modules": json.dumps( |
| [m for m in self.soong.reverse_makefiles[analysis.filename] if m in mods]), |
| "line_matches": ", ".join([ |
| "new LineMatch(%d, %s)" % (lineno, json.dumps(text)) |
| for lineno, text in analysis.line_matches]), |
| }) |
| print(" ],") |
| print(""" |
| ]; |
| var MODULE_DATA = { |
| """) |
| for module in self.soong.modules: |
| print(" '%(name)s': new Module(%(deps)s)," % { |
| "name": module, |
| "deps": json.dumps(self.soong.deps[module]), |
| }) |
| print(""" |
| }; |
| </script> |
| |
| """) |
| |
| print(""" |
| </div> <!-- id=tables --> |
| <div id="details"> |
| <div style="text-align: right;"> |
| <a href="javascript:close_details();"> |
| <svg xmlns="http://www.w3.org/2000/svg" height="24" viewBox="0 0 24 24" width="24"><path d="M0 0h24v24H0z" fill="none"/><path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"/></svg> |
| </a> |
| </div> |
| <div id="details_data"></div> |
| </div> |
| </body> |
| </html> |
| """) |
| |
| def traverse_ready_makefiles(self, summary, makefiles): |
| return [Analysis(makefile.filename, []) for makefile in makefiles |
| if clean_and_only_blocked_by_clean(self.soong, self.all_makefiles, makefile)] |
| |
| def print_analysis_row(self, summary, modules, rowtitle, rowclass, makefiles): |
| all_makefiles = [Analysis(makefile.filename, []) for makefile in makefiles] |
| clean_makefiles = [Analysis(makefile.filename, []) for makefile in makefiles |
| if is_clean(makefile)] |
| easy_makefiles = self.traverse_ready_makefiles(summary, makefiles) |
| unblocked_clean_makefiles = [Analysis(makefile.filename, []) for makefile in makefiles |
| if (self.soong.contains_unblocked_modules(makefile.filename) |
| and is_clean(makefile))] |
| unblocked_makefiles = [Analysis(makefile.filename, []) for makefile in makefiles |
| if self.soong.contains_unblocked_modules(makefile.filename)] |
| blocked_makefiles = [Analysis(makefile.filename, []) for makefile in makefiles |
| if self.soong.contains_blocked_modules(makefile.filename)] |
| |
| print(""" |
| <tr class="%(rowclass)s"> |
| <td class="RowTitle">%(rowtitle)s</td> |
| <td class="Count">%(makefiles)s</td> |
| <td class="Count">%(easy)s</td> |
| <td class="Count">%(unblocked_clean)s</td> |
| <td class="Count">%(unblocked)s</td> |
| <td class="Count">%(blocked)s</td> |
| <td class="Count">%(clean)s</td> |
| """ % { |
| "rowclass": rowclass, |
| "rowtitle": rowtitle, |
| "makefiles": self.make_annotation_link(all_makefiles, modules), |
| "unblocked": self.make_annotation_link(unblocked_makefiles, modules), |
| "blocked": self.make_annotation_link(blocked_makefiles, modules), |
| "clean": self.make_annotation_link(clean_makefiles, modules), |
| "unblocked_clean": self.make_annotation_link(unblocked_clean_makefiles, modules), |
| "easy": self.make_annotation_link(easy_makefiles, modules), |
| }) |
| |
| for analyzer in ANALYZERS: |
| analyses = [m.analyses.get(analyzer) for m in makefiles if m.analyses.get(analyzer)] |
| print("""<td class="Count">%s</td>""" |
| % self.make_annotation_link(analyses, modules)) |
| |
| print(" </tr>") |
| |
| def make_annotation_link(self, analysis, modules): |
| if analysis: |
| return "<a href='javascript:update_details(%d)'>%s</a>" % ( |
| self.annotations.Add(analysis, modules), |
| len(analysis) |
| ) |
| else: |
| return ""; |
| |
| class CsvProcessor(object): |
| def __init__(self, args, soong, all_makefiles, product_packages_modules): |
| self.args = args |
| self.soong = soong |
| self.all_makefiles = all_makefiles |
| self.product_packages_modules = product_packages_modules |
| |
| def execute(self): |
| csvout = csv.writer(sys.stdout) |
| |
| # Title row |
| row = ["Filename", "Module", "Partitions", "Easy", "Unblocked Clean", "Unblocked", |
| "Blocked", "Clean"] |
| for analyzer in ANALYZERS: |
| row.append(analyzer.title) |
| csvout.writerow(row) |
| |
| # Makefile & module data |
| for filename in sorted(self.all_makefiles.keys()): |
| makefile = self.all_makefiles[filename] |
| for module in self.soong.reverse_makefiles[filename]: |
| if len(self.product_packages_modules) > 0 and module not in self.product_packages_modules: |
| continue |
| row = [filename, module] |
| # Partitions |
| row.append(";".join(sorted(set([get_partition_from_installed(HOST_OUT_ROOT, PRODUCT_OUT, |
| installed) |
| for installed |
| in self.soong.reverse_installed.get(module, [])])))) |
| # Easy |
| row.append(1 |
| if clean_and_only_blocked_by_clean(self.soong, self.all_makefiles, makefile) |
| else "") |
| # Unblocked Clean |
| row.append(1 |
| if (self.soong.contains_unblocked_modules(makefile.filename) and is_clean(makefile)) |
| else "") |
| # Unblocked |
| row.append(1 if self.soong.contains_unblocked_modules(makefile.filename) else "") |
| # Blocked |
| row.append(1 if self.soong.contains_blocked_modules(makefile.filename) else "") |
| # Clean |
| row.append(1 if is_clean(makefile) else "") |
| # Analysis |
| for analyzer in ANALYZERS: |
| row.append(1 if makefile.analyses.get(analyzer) else "") |
| # Write results |
| csvout.writerow(row) |
| |
| if __name__ == "__main__": |
| main() |
| |
