192 lines
6.6 KiB
Python
192 lines
6.6 KiB
Python
def runstrip(arg):
|
|
# Function to strip a single file, called from split_and_strip_files below
|
|
# A working 'file' (one which works on the target architecture)
|
|
#
|
|
# The elftype is a bit pattern (explained in split_and_strip_files) to tell
|
|
# us what type of file we're processing...
|
|
# 4 - executable
|
|
# 8 - shared library
|
|
# 16 - kernel module
|
|
|
|
import stat, subprocess
|
|
|
|
(file, elftype, strip) = arg
|
|
|
|
newmode = None
|
|
if not os.access(file, os.W_OK) or os.access(file, os.R_OK):
|
|
origmode = os.stat(file)[stat.ST_MODE]
|
|
newmode = origmode | stat.S_IWRITE | stat.S_IREAD
|
|
os.chmod(file, newmode)
|
|
|
|
stripcmd = [strip]
|
|
|
|
# kernel module
|
|
if elftype & 16:
|
|
stripcmd.extend(["--strip-debug", "--remove-section=.comment",
|
|
"--remove-section=.note", "--preserve-dates"])
|
|
# .so and shared library
|
|
elif ".so" in file and elftype & 8:
|
|
stripcmd.extend(["--remove-section=.comment", "--remove-section=.note", "--strip-unneeded"])
|
|
# shared or executable:
|
|
elif elftype & 8 or elftype & 4:
|
|
stripcmd.extend(["--remove-section=.comment", "--remove-section=.note"])
|
|
|
|
stripcmd.append(file)
|
|
bb.debug(1, "runstrip: %s" % stripcmd)
|
|
|
|
try:
|
|
output = subprocess.check_output(stripcmd, stderr=subprocess.STDOUT)
|
|
except subprocess.CalledProcessError as e:
|
|
bb.error("runstrip: '%s' strip command failed with %s (%s)" % (stripcmd, e.returncode, e.output))
|
|
|
|
if newmode:
|
|
os.chmod(file, origmode)
|
|
|
|
return
|
|
|
|
|
|
def file_translate(file):
|
|
ft = file.replace("@", "@at@")
|
|
ft = ft.replace(" ", "@space@")
|
|
ft = ft.replace("\t", "@tab@")
|
|
ft = ft.replace("[", "@openbrace@")
|
|
ft = ft.replace("]", "@closebrace@")
|
|
ft = ft.replace("_", "@underscore@")
|
|
return ft
|
|
|
|
def filedeprunner(arg):
|
|
import re, subprocess, shlex
|
|
|
|
(pkg, pkgfiles, rpmdeps, pkgdest) = arg
|
|
provides = {}
|
|
requires = {}
|
|
|
|
file_re = re.compile(r'\s+\d+\s(.*)')
|
|
dep_re = re.compile(r'\s+(\S)\s+(.*)')
|
|
r = re.compile(r'[<>=]+\s+\S*')
|
|
|
|
def process_deps(pipe, pkg, pkgdest, provides, requires):
|
|
file = None
|
|
for line in pipe:
|
|
line = line.decode("utf-8")
|
|
|
|
m = file_re.match(line)
|
|
if m:
|
|
file = m.group(1)
|
|
file = file.replace(pkgdest + "/" + pkg, "")
|
|
file = file_translate(file)
|
|
continue
|
|
|
|
m = dep_re.match(line)
|
|
if not m or not file:
|
|
continue
|
|
|
|
type, dep = m.groups()
|
|
|
|
if type == 'R':
|
|
i = requires
|
|
elif type == 'P':
|
|
i = provides
|
|
else:
|
|
continue
|
|
|
|
if dep.startswith("python("):
|
|
continue
|
|
|
|
# Ignore all perl(VMS::...) and perl(Mac::...) dependencies. These
|
|
# are typically used conditionally from the Perl code, but are
|
|
# generated as unconditional dependencies.
|
|
if dep.startswith('perl(VMS::') or dep.startswith('perl(Mac::'):
|
|
continue
|
|
|
|
# Ignore perl dependencies on .pl files.
|
|
if dep.startswith('perl(') and dep.endswith('.pl)'):
|
|
continue
|
|
|
|
# Remove perl versions and perl module versions since they typically
|
|
# do not make sense when used as package versions.
|
|
if dep.startswith('perl') and r.search(dep):
|
|
dep = dep.split()[0]
|
|
|
|
# Put parentheses around any version specifications.
|
|
dep = r.sub(r'(\g<0>)',dep)
|
|
|
|
if file not in i:
|
|
i[file] = []
|
|
i[file].append(dep)
|
|
|
|
return provides, requires
|
|
|
|
try:
|
|
dep_popen = subprocess.Popen(shlex.split(rpmdeps) + pkgfiles, stdout=subprocess.PIPE)
|
|
provides, requires = process_deps(dep_popen.stdout, pkg, pkgdest, provides, requires)
|
|
except OSError as e:
|
|
bb.error("rpmdeps: '%s' command failed, '%s'" % (shlex.split(rpmdeps) + pkgfiles, e))
|
|
raise e
|
|
|
|
return (pkg, provides, requires)
|
|
|
|
|
|
def read_shlib_providers(d):
|
|
import re
|
|
|
|
shlib_provider = {}
|
|
shlibs_dirs = d.getVar('SHLIBSDIRS').split()
|
|
list_re = re.compile('^(.*)\.list$')
|
|
# Go from least to most specific since the last one found wins
|
|
for dir in reversed(shlibs_dirs):
|
|
bb.debug(2, "Reading shlib providers in %s" % (dir))
|
|
if not os.path.exists(dir):
|
|
continue
|
|
for file in os.listdir(dir):
|
|
m = list_re.match(file)
|
|
if m:
|
|
dep_pkg = m.group(1)
|
|
try:
|
|
fd = open(os.path.join(dir, file))
|
|
except IOError:
|
|
# During a build unrelated shlib files may be deleted, so
|
|
# handle files disappearing between the listdirs and open.
|
|
continue
|
|
lines = fd.readlines()
|
|
fd.close()
|
|
for l in lines:
|
|
s = l.strip().split(":")
|
|
if s[0] not in shlib_provider:
|
|
shlib_provider[s[0]] = {}
|
|
shlib_provider[s[0]][s[1]] = (dep_pkg, s[2])
|
|
return shlib_provider
|
|
|
|
|
|
def npm_split_package_dirs(pkgdir):
|
|
"""
|
|
Work out the packages fetched and unpacked by BitBake's npm fetcher
|
|
Returns a dict of packagename -> (relpath, package.json) ordered
|
|
such that it is suitable for use in PACKAGES and FILES
|
|
"""
|
|
from collections import OrderedDict
|
|
import json
|
|
packages = {}
|
|
for root, dirs, files in os.walk(pkgdir):
|
|
if os.path.basename(root) == 'node_modules':
|
|
for dn in dirs:
|
|
relpth = os.path.relpath(os.path.join(root, dn), pkgdir)
|
|
pkgitems = ['${PN}']
|
|
for pathitem in relpth.split('/'):
|
|
if pathitem == 'node_modules':
|
|
continue
|
|
pkgitems.append(pathitem)
|
|
pkgname = '-'.join(pkgitems).replace('_', '-')
|
|
pkgname = pkgname.replace('@', '')
|
|
pkgfile = os.path.join(root, dn, 'package.json')
|
|
data = None
|
|
if os.path.exists(pkgfile):
|
|
with open(pkgfile, 'r') as f:
|
|
data = json.loads(f.read())
|
|
packages[pkgname] = (relpth, data)
|
|
# We want the main package for a module sorted *after* its subpackages
|
|
# (so that it doesn't otherwise steal the files for the subpackage), so
|
|
# this is a cheap way to do that whilst still having an otherwise
|
|
# alphabetical sort
|
|
return OrderedDict((key, packages[key]) for key in sorted(packages, key=lambda pkg: pkg + '~'))
|