241 lines
8.1 KiB
Python
Executable file
241 lines
8.1 KiB
Python
Executable file
#!/usr/bin/env python
|
|
#
|
|
# Copyright (C) 2016 The Android Open Source Project
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
#
|
|
"""Clobbers all the per-API level headers with the current unified headers.
|
|
|
|
This is just for testing purposes. Having unified headers isn't worth as much
|
|
if we're still shipping N copies of them :)
|
|
"""
|
|
from __future__ import absolute_import
|
|
from __future__ import print_function
|
|
|
|
import logging
|
|
import os
|
|
import shutil
|
|
|
|
|
|
THIS_DIR = os.path.realpath(os.path.dirname(__file__))
|
|
ANDROID_ROOT = os.path.dirname(os.path.dirname(THIS_DIR))
|
|
|
|
|
|
ALL_ARCHITECTURES = (
|
|
'arm',
|
|
'arm64',
|
|
'mips',
|
|
'mips64',
|
|
'x86',
|
|
'x86_64',
|
|
)
|
|
|
|
|
|
def logger():
|
|
"""Return the main logger for this module."""
|
|
return logging.getLogger(__name__)
|
|
|
|
|
|
def android_path(*args):
|
|
"""Returns a full path from the base of the Android source tree."""
|
|
return os.path.join(ANDROID_ROOT, *args)
|
|
|
|
|
|
def copy_directory_contents(src, dst):
|
|
"""Copies the contents of a directory, merging with the destination.
|
|
|
|
shutil.copytree requires that the destination does not exist. This function
|
|
behaves like `cp -r`. That is, it merges the source and destination
|
|
directories if appropriate.
|
|
"""
|
|
for root, dirs, files in os.walk(src):
|
|
subdir = os.path.relpath(root, src)
|
|
dst_dir = os.path.join(dst, subdir)
|
|
if not os.path.exists(dst_dir):
|
|
os.makedirs(dst_dir)
|
|
|
|
# This makes sure we copy even empty directories. We don't actually
|
|
# need it, but for now it lets us diff between our result and the
|
|
# legacy tool.
|
|
for d in dirs: # pylint: disable=invalid-name
|
|
d_path = os.path.join(root, d)
|
|
if os.path.islink(d_path):
|
|
linkto = os.readlink(d_path)
|
|
dst_file = os.path.join(dst_dir, d)
|
|
logger().debug('Symlinking %s to %s', dst_file, linkto)
|
|
os.symlink(linkto, dst_file)
|
|
else:
|
|
new_dir = os.path.join(dst_dir, d)
|
|
if not os.path.exists(new_dir):
|
|
logger().debug('Making directory %s', new_dir)
|
|
os.makedirs(new_dir)
|
|
|
|
for f in files: # pylint: disable=invalid-name
|
|
src_file = os.path.join(root, f)
|
|
if os.path.islink(src_file):
|
|
linkto = os.readlink(src_file)
|
|
dst_file = os.path.join(dst_dir, f)
|
|
logger().debug('Symlinking %s to %s', dst_file, linkto)
|
|
os.symlink(linkto, dst_file)
|
|
else:
|
|
logger().debug('Copying %s', src_file)
|
|
shutil.copy2(src_file, dst_dir)
|
|
|
|
|
|
def get_preserve_path(platform_dir):
|
|
"""Returns the path used for preserving headers."""
|
|
return os.path.join(platform_dir, 'preserve')
|
|
|
|
|
|
def preserve_headers(keep_list, platform_dir):
|
|
"""Preserves a list of headers to be restored after the copy."""
|
|
install_path = os.path.join(platform_dir, 'include')
|
|
preserve_root = get_preserve_path(platform_dir)
|
|
if os.path.exists(preserve_root):
|
|
shutil.rmtree(preserve_root)
|
|
for preserve in keep_list:
|
|
path = os.path.join(install_path, preserve)
|
|
if os.path.isdir(path):
|
|
shutil.copytree(path, os.path.join(preserve_root, preserve))
|
|
elif os.path.isfile(path):
|
|
shutil.copy2(path, preserve_root)
|
|
|
|
|
|
def restore_headers(keep_list, platform_dir):
|
|
"""Restores headers preserved by preserve_headers."""
|
|
install_path = os.path.join(platform_dir, 'include')
|
|
preserve_root = get_preserve_path(platform_dir)
|
|
for preserve in keep_list:
|
|
path = os.path.join(preserve_root, preserve)
|
|
if os.path.isdir(path):
|
|
# Bionic does have include/android, so we need to merge directories
|
|
# here.
|
|
copy_directory_contents(
|
|
path, os.path.join(install_path, preserve))
|
|
elif os.path.isfile(path):
|
|
shutil.copy2(path, install_path)
|
|
|
|
|
|
def platform_path_to_api_level(platform_path):
|
|
"""Returns the API level for a platform path."""
|
|
basename = os.path.split(platform_path)[-1]
|
|
# android-\d+
|
|
return int(basename.split('-')[1])
|
|
|
|
|
|
def fixup_api_level_h(platform_dir):
|
|
"""Rewrites api-level.h for the correct platform."""
|
|
api_level = platform_path_to_api_level(platform_dir)
|
|
header = os.path.join(platform_dir, 'include/android/api-level.h')
|
|
with open(header, 'w') as header_file:
|
|
header_file.write(
|
|
'#ifndef ANDROID_API_LEVEL_H\n'
|
|
'#define ANDROID_API_LEVEL_H\n'
|
|
'#ifndef __ANDROID_API__\n'
|
|
'#define __ANDROID_API__ {}\n'
|
|
'#endif /* __ANDROID_API__ */\n'
|
|
'#endif /* ANDROID_API_LEVEL_H */\n'.format(api_level))
|
|
|
|
|
|
def copy_current_headers(platform_dir):
|
|
"""Copies the unified headers into a per-API directory."""
|
|
libc_path = android_path('bionic/libc')
|
|
install_path = os.path.join(platform_dir, 'include')
|
|
|
|
# None of the platform APIs have unified headers yet. Copy those out of the
|
|
# way of the purge and copy them back in afterward.
|
|
keep_list = (
|
|
'EGL',
|
|
'GLES',
|
|
'GLES2',
|
|
'GLES3',
|
|
'KHR',
|
|
'OMXAL',
|
|
'SLES',
|
|
'android',
|
|
'camera',
|
|
'jni.h',
|
|
'media',
|
|
'vulkan',
|
|
'zlib.h',
|
|
'zconf.h',
|
|
)
|
|
preserve_headers(keep_list, platform_dir)
|
|
|
|
if os.path.exists(install_path):
|
|
shutil.rmtree(install_path)
|
|
|
|
shutil.copytree(os.path.join(libc_path, 'include'), install_path)
|
|
shutil.copytree(os.path.join(libc_path, 'kernel/uapi/linux'),
|
|
os.path.join(install_path, 'linux'))
|
|
shutil.copytree(os.path.join(libc_path, 'kernel/uapi/asm-generic'),
|
|
os.path.join(install_path, 'asm-generic'))
|
|
shutil.copy2(os.path.join(libc_path, 'NOTICE'), install_path)
|
|
|
|
restore_headers(keep_list, platform_dir)
|
|
|
|
if os.path.exists(get_preserve_path(platform_dir)):
|
|
shutil.rmtree(get_preserve_path(platform_dir))
|
|
|
|
fixup_api_level_h(platform_dir)
|
|
|
|
api_level = platform_path_to_api_level(platform_dir)
|
|
for arch in ALL_ARCHITECTURES:
|
|
if arch in ('arm64', 'mips64', 'x86_64') and api_level < 21:
|
|
continue
|
|
|
|
# For multilib architectures we need to copy the 32-bit headers into
|
|
# the 64-bit directory. For MIPS this is true of asm and machine, for
|
|
# Intel it's only for asm.
|
|
asm_arch = arch
|
|
machine_arch = arch
|
|
if arch == 'mips64':
|
|
asm_arch = 'mips'
|
|
machine_arch = 'mips'
|
|
elif arch == 'x86_64':
|
|
asm_arch = 'x86'
|
|
|
|
arch_install_path = os.path.join(
|
|
platform_dir, 'arch-' + arch, 'include')
|
|
if os.path.exists(arch_install_path):
|
|
shutil.rmtree(arch_install_path)
|
|
|
|
machine_path = os.path.join(
|
|
libc_path, 'arch-' + machine_arch, 'include/machine')
|
|
asm_path = os.path.join(
|
|
libc_path, 'kernel/uapi/asm-' + asm_arch, 'asm')
|
|
|
|
if os.path.exists(arch_install_path):
|
|
shutil.rmtree(arch_install_path)
|
|
os.makedirs(arch_install_path)
|
|
|
|
shutil.copytree(
|
|
machine_path, os.path.join(arch_install_path, 'machine'))
|
|
shutil.copytree(asm_path, os.path.join(arch_install_path, 'asm'))
|
|
|
|
|
|
def main():
|
|
"""Program entry point."""
|
|
platforms_dir = os.path.join(THIS_DIR, 'platforms')
|
|
for platform_dir in os.listdir(platforms_dir):
|
|
path = os.path.join(platforms_dir, platform_dir)
|
|
if not os.path.isdir(path):
|
|
continue
|
|
if platform_dir == 'common':
|
|
# Just contains crtbrand.
|
|
continue
|
|
copy_current_headers(path)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|