static_libs.py - mozsearch

Enable keyboard shortcuts

#!/usr/bin/env python3

# This Source Code Form is subject to the terms of the Mozilla Public

# License, v. 2.0. If a copy of the MPL was not distributed with this file,

# You can obtain one at http://mozilla.org/MPL/2.0/.

# Print the linker flags for a static link against this build of NSS, in

# dependency order, for build.sh to substitute into nss-static.pc.

# The list is derived rather than written down: gyp's dump_dependency_json

# generator emits the dependency graph for the configuration that was just

# built, with all conditions resolved, and this walks that graph from the

# libraries that make up NSS's public interface. Anything the internals pull

# in comes along, so moving code between gyp targets - as freebl did with

# kyber.c and ml_dsa.c - doesn't leave consumers with a stale list.

from __future__ import print_function

import json

import os

import sys

# The static counterpart of the 'Libs:' line in nss.pc. Every other archive

# is reached from these through the dependency graph.

ROOTS = [

    'ssl',

    'smime',

    'nss_static',

    'pk11wrap_static',

    'cryptohi',

    'certhi',

    'certdb',

    'nsspki',

    'nssdev',

    'nssb',

    'sqlite',

    'nssutil',

def target_name(qualified):

    """Reduce '/path/to/freebl.gyp:freebl_static#target' to 'freebl_static'."""

    return qualified.rsplit(':', 1)[-1].split('#', 1)[0]

def load_graph(dump):

    with open(dump) as f:

        edges = json.load(f)

    return dict((target_name(target), [target_name(d) for d in deps])

                for target, deps in edges.items())

def link_order(edges):

    """The roots and everything they depend on, dependents before dependencies."""

    ordered = []

    seen = set()

    def visit(target, out):

        if target in seen:

            return

        seen.add(target)

        for dep in edges.get(target, []):

            visit(dep, out)

        out.append(target)

    for root in ROOTS:

        subtree = []

        visit(root, subtree)

        # A post-order walk lists dependencies first; a link wants them last.

        subtree.reverse()

        ordered.extend(subtree)

    return ordered

def is_built(lib_dir, target):

    """Whether this build produced an archive for a target.

    Targets that are for another architecture, that a --disable- flag turned

    off, or that aren't libraries at all are filtered out this way, so that

    the walk above doesn't have to reason about any of that.

"""

    return any(os.path.exists(os.path.join(lib_dir, name))

               for name in ('lib%s.a' % target, '%s.lib' % target))

def main():

    dump, lib_dir = sys.argv[1], sys.argv[2]

    edges = load_graph(dump)

    libs = [t for t in link_order(edges) if is_built(lib_dir, t)]

    if not libs:

        raise SystemExit('%s: no static libraries found in %s' % (sys.argv[0], lib_dir))

    print(' '.join('-l' + lib for lib in libs))

if __name__ == '__main__':

    main()