320 lines
10 KiB
Python
320 lines
10 KiB
Python
|
#!/usr/bin/env python
|
||
|
|
|
||
|
|
# Copyright 2015 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.
|
||
|
|
|
||
|
|
# Utility functions used to parse a list of DLL entry points.
|
||
|
|
# Expected format:
|
||
|
|
#
|
||
|
|
# <empty-line> -> ignored
|
||
|
|
# #<comment> -> ignored
|
||
|
|
# %<verbatim> -> verbatim output for header files.
|
||
|
|
# !<prefix> -> prefix name for header files.
|
||
|
|
# <return-type> <function-name> <signature> ; -> entry point declaration.
|
||
|
|
#
|
||
|
|
# Anything else is an error.
|
||
|
|
|
||
|
|
import argparse
|
||
|
|
import re
|
||
|
|
import sys
|
||
|
|
|
||
|
|
re_func = re.compile(r"""^(.*[\* ])([A-Za-z_][A-Za-z0-9_]*)\((.*)\);$""")
|
||
|
|
re_param = re.compile(r"""^(.*[\* ])([A-Za-z_][A-Za-z0-9_]*)$""")
|
||
|
|
|
||
|
|
|
||
|
|
class Entry:
|
||
|
|
"""Small class used to model a single DLL entry point."""
|
||
|
|
|
||
|
|
def __init__(self, func_name, return_type, parameters):
|
||
|
|
"""Initialize Entry instance. |func_name| is the function name,
|
||
|
|
|return_type| its return type, and |parameters| is a list of
|
||
|
|
(type,name) tuples from the entry's signature.
|
||
|
|
"""
|
||
|
|
self.func_name = func_name
|
||
|
|
self.return_type = return_type
|
||
|
|
self.parameters = ""
|
||
|
|
self.vartypes = []
|
||
|
|
self.varnames = []
|
||
|
|
self.call = ""
|
||
|
|
comma = ""
|
||
|
|
for param in parameters:
|
||
|
|
self.vartypes.append(param[0])
|
||
|
|
self.varnames.append(param[1])
|
||
|
|
self.parameters += "%s%s %s" % (comma, param[0], param[1])
|
||
|
|
self.call += "%s%s" % (comma, param[1])
|
||
|
|
comma = ", "
|
||
|
|
|
||
|
|
|
||
|
|
def banner_command(argv):
|
||
|
|
"""Return sanitized command-line description.
|
||
|
|
|argv| must be a list of command-line parameters, e.g. sys.argv.
|
||
|
|
Return a string corresponding to the command, with platform-specific
|
||
|
|
paths removed."""
|
||
|
|
|
||
|
|
# Remove path from first parameter
|
||
|
|
argv = argv[:]
|
||
|
|
argv[0] = "host/commands/gen-entries.py"
|
||
|
|
return " ".join(argv)
|
||
|
|
|
||
|
|
|
||
|
|
def parse_entries_file(lines):
|
||
|
|
"""Parse an .entries file and return a tuple of:
|
||
|
|
entries: list of Entry instances from the file.
|
||
|
|
prefix_name: prefix name from the file, or None.
|
||
|
|
verbatim: list of verbatim lines from the file.
|
||
|
|
errors: list of errors in the file, prefixed by line number.
|
||
|
|
"""
|
||
|
|
entries = []
|
||
|
|
verbatim = []
|
||
|
|
errors = []
|
||
|
|
lineno = 0
|
||
|
|
prefix_name = None
|
||
|
|
for line in lines:
|
||
|
|
lineno += 1
|
||
|
|
line = line.strip()
|
||
|
|
if len(line) == 0: # Ignore empty lines
|
||
|
|
continue
|
||
|
|
if line[0] == "#": # Ignore comments
|
||
|
|
continue
|
||
|
|
if line[0] == "!": # Prefix name
|
||
|
|
prefix_name = line[1:]
|
||
|
|
continue
|
||
|
|
if line[0] == "%": # Verbatim line copy
|
||
|
|
verbatim.append(line[1:])
|
||
|
|
continue
|
||
|
|
# Must be a function signature.
|
||
|
|
m = re_func.match(line)
|
||
|
|
if not m:
|
||
|
|
errors.append("%d: '%s'" % (lineno, line))
|
||
|
|
continue
|
||
|
|
|
||
|
|
return_type, func_name, parameters = m.groups()
|
||
|
|
return_type = return_type.strip()
|
||
|
|
parameters = parameters.strip()
|
||
|
|
params = []
|
||
|
|
failure = False
|
||
|
|
if parameters != "void":
|
||
|
|
for parameter in parameters.split(','):
|
||
|
|
parameter = parameter.strip()
|
||
|
|
m = re_param.match(parameter)
|
||
|
|
if not m:
|
||
|
|
errors.append("%d: parameter '%s'" % (lineno, parameter))
|
||
|
|
failure = True
|
||
|
|
break
|
||
|
|
else:
|
||
|
|
param_type, param_name = m.groups()
|
||
|
|
params.append((param_type.strip(), param_name.strip()))
|
||
|
|
|
||
|
|
if not failure:
|
||
|
|
entries.append(Entry(func_name, return_type, params))
|
||
|
|
|
||
|
|
return (entries, prefix_name, verbatim, errors)
|
||
|
|
|
||
|
|
|
||
|
|
def gen_functions_header(entries, prefix_name, verbatim, filename, with_args):
|
||
|
|
"""Generate a C header containing a macro listing all entry points.
|
||
|
|
|entries| is a list of Entry instances.
|
||
|
|
|prefix_name| is a prefix-name, it will be converted to upper-case.
|
||
|
|
|verbatim| is a list of verbatim lines that must appear before the
|
||
|
|
macro declaration. Useful to insert #include <> statements.
|
||
|
|
|filename| is the name of the original file.
|
||
|
|
"""
|
||
|
|
prefix_name = prefix_name.upper()
|
||
|
|
|
||
|
|
print("// Auto-generated with: " + banner_command(sys.argv))
|
||
|
|
print("// DO NOT EDIT THIS FILE")
|
||
|
|
print("")
|
||
|
|
print(f"#ifndef {prefix_name}_FUNCTIONS_H")
|
||
|
|
print(f"#define {prefix_name}_FUNCTIONS_H")
|
||
|
|
print("")
|
||
|
|
for line in verbatim:
|
||
|
|
print(line)
|
||
|
|
|
||
|
|
print(f"#define LIST_{prefix_name}_FUNCTIONS(X) \\")
|
||
|
|
for entry in entries:
|
||
|
|
if with_args:
|
||
|
|
print(f" X({entry.return_type}, {entry.func_name}, "
|
||
|
|
f"({entry.parameters}), ({entry.call})) \\")
|
||
|
|
else:
|
||
|
|
print(f" X({entry.return_type}, {entry.func_name}, "
|
||
|
|
f"({entry.parameters})) \\")
|
||
|
|
|
||
|
|
print("")
|
||
|
|
print("")
|
||
|
|
print(f"#endif // {prefix_name}_FUNCTIONS_H")
|
||
|
|
|
||
|
|
|
||
|
|
def gen_dll_wrapper(entries, prefix_name, verbatim, filename):
|
||
|
|
"""Generate a C source file that contains functions that act as wrappers
|
||
|
|
for entry points located in another shared library. This allows the
|
||
|
|
code that calls these functions to perform lazy-linking to system
|
||
|
|
libraries.
|
||
|
|
|entries|, |prefix_name|, |verbatim| and |filename| are the same as
|
||
|
|
for gen_functions_header() above.
|
||
|
|
"""
|
||
|
|
upper_name = prefix_name.upper()
|
||
|
|
|
||
|
|
ENTRY_PREFIX = "__dll_"
|
||
|
|
|
||
|
|
print("// Auto-generated with: " + banner_command(sys.argv))
|
||
|
|
print("// DO NOT EDIT THIS FILE")
|
||
|
|
print("")
|
||
|
|
print("#include <dlfcn.h>")
|
||
|
|
for line in verbatim:
|
||
|
|
print(line)
|
||
|
|
|
||
|
|
print("")
|
||
|
|
print("///")
|
||
|
|
print("/// W R A P P E R P O I N T E R S")
|
||
|
|
print("///")
|
||
|
|
print("")
|
||
|
|
for entry in entries:
|
||
|
|
ptr_name = ENTRY_PREFIX + entry.func_name
|
||
|
|
print(f"static {entry.return_type} "
|
||
|
|
f"(*{ptr_name})({entry.parameters}) = 0;")
|
||
|
|
|
||
|
|
print("")
|
||
|
|
print("///")
|
||
|
|
print("/// W R A P P E R F U N C T I O N S")
|
||
|
|
print("///")
|
||
|
|
print("")
|
||
|
|
|
||
|
|
for entry in entries:
|
||
|
|
print(f"{entry.return_type} {entry.func_name}({entry.parameters}) {{")
|
||
|
|
ptr_name = ENTRY_PREFIX + entry.func_name
|
||
|
|
if entry.return_type != "void":
|
||
|
|
print(f" return {ptr_name}({entry.call});")
|
||
|
|
else:
|
||
|
|
print(" {ptr_name}({entry.call});")
|
||
|
|
print("}\n")
|
||
|
|
|
||
|
|
print("")
|
||
|
|
print("///")
|
||
|
|
print("/// I N I T I A L I Z A T I O N F U N C T I O N")
|
||
|
|
print("///")
|
||
|
|
print("")
|
||
|
|
|
||
|
|
print(f"int {prefix_name}_dynlink_init(void* lib) {{")
|
||
|
|
for entry in entries:
|
||
|
|
ptr_name = ENTRY_PREFIX + entry.func_name
|
||
|
|
print(f" {ptr_name} = ({entry.return_type}(*)({entry.parameters})) "
|
||
|
|
f"dlsym(lib, \"{entry.func_name}\");")
|
||
|
|
print(f" if (!{ptr_name}) return -1;")
|
||
|
|
print(" return 0;")
|
||
|
|
print("}")
|
||
|
|
|
||
|
|
|
||
|
|
def gen_windows_def_file(entries):
|
||
|
|
"""Generate a windows DLL .def file. |entries| is a list of Entry instances.
|
||
|
|
"""
|
||
|
|
print("EXPORTS")
|
||
|
|
for entry in entries:
|
||
|
|
print(" " + entry.func_name)
|
||
|
|
|
||
|
|
|
||
|
|
def gen_unix_sym_file(entries):
|
||
|
|
"""Generate an ELF linker version file. |entries| is a list of Entry
|
||
|
|
instances.
|
||
|
|
"""
|
||
|
|
print("VERSION {")
|
||
|
|
print("\tglobal:")
|
||
|
|
for entry in entries:
|
||
|
|
print(f"\t\t{entry.func_name};")
|
||
|
|
print("\tlocal:")
|
||
|
|
print("\t\t*;")
|
||
|
|
print("};")
|
||
|
|
|
||
|
|
|
||
|
|
def gen_symbols(entries, underscore):
|
||
|
|
"""Generate a list of symbols from |entries|, a list of Entry instances.
|
||
|
|
|underscore| is a boolean. If True, then prepend an underscore to each
|
||
|
|
symbol name.
|
||
|
|
"""
|
||
|
|
prefix = ""
|
||
|
|
if underscore:
|
||
|
|
prefix = "_"
|
||
|
|
for entry in entries:
|
||
|
|
print(prefix + entry.func_name)
|
||
|
|
|
||
|
|
|
||
|
|
def parse_file(filename, lines, mode):
|
||
|
|
"""Generate one of possible outputs from |filename|. |lines| must be a list
|
||
|
|
of text lines from the file, and |mode| is one of the --mode option
|
||
|
|
values.
|
||
|
|
"""
|
||
|
|
entries, prefix_name, verbatim, errors = parse_entries_file(lines)
|
||
|
|
if errors:
|
||
|
|
for error in errors:
|
||
|
|
print(f"ERROR: {filename}:{error}", file=sys.stderr)
|
||
|
|
sys.exit(1)
|
||
|
|
|
||
|
|
if not prefix_name:
|
||
|
|
prefix_name = "unknown"
|
||
|
|
|
||
|
|
if mode == 'def':
|
||
|
|
gen_windows_def_file(entries)
|
||
|
|
elif mode == 'sym':
|
||
|
|
gen_unix_sym_file(entries)
|
||
|
|
elif mode == 'wrapper':
|
||
|
|
gen_dll_wrapper(entries, prefix_name, verbatim, filename)
|
||
|
|
elif mode == 'symbols':
|
||
|
|
gen_symbols(entries, False)
|
||
|
|
elif mode == '_symbols':
|
||
|
|
gen_symbols(entries, True)
|
||
|
|
elif mode == 'functions':
|
||
|
|
gen_functions_header(entries, prefix_name, verbatim, filename, False)
|
||
|
|
elif mode == 'funcargs':
|
||
|
|
gen_functions_header(entries, prefix_name, verbatim, filename, True)
|
||
|
|
|
||
|
|
|
||
|
|
# List of valid --mode option values.
|
||
|
|
mode_list = [
|
||
|
|
'def', 'sym', 'wrapper', 'symbols', '_symbols', 'functions', 'funcargs'
|
||
|
|
]
|
||
|
|
|
||
|
|
# Argument parsing.
|
||
|
|
parser = argparse.ArgumentParser(
|
||
|
|
formatter_class=argparse.RawDescriptionHelpFormatter,
|
||
|
|
description="""\
|
||
|
|
A script used to parse an .entries input file containing a list of function
|
||
|
|
declarations, and generate various output files depending on the value of
|
||
|
|
the --mode option, which can be:
|
||
|
|
|
||
|
|
def Generate a windows DLL .def file.
|
||
|
|
sym Generate a Unix .so linker script.
|
||
|
|
wrapper Generate a C source file containing wrapper functions.
|
||
|
|
symbols Generate a simple list of symbols, one per line.
|
||
|
|
_symbols Generate a simple list of symbols, prefixed with _.
|
||
|
|
functions Generate a C header containing a macro listing all functions.
|
||
|
|
funcargs Like 'functions', but adds function call arguments to listing.
|
||
|
|
|
||
|
|
""")
|
||
|
|
parser.add_argument("--mode", help="Output mode", choices=mode_list)
|
||
|
|
parser.add_argument("--output", help="output file")
|
||
|
|
parser.add_argument("file", help=".entries file path")
|
||
|
|
|
||
|
|
args = parser.parse_args()
|
||
|
|
|
||
|
|
if not args.mode:
|
||
|
|
print("ERROR: Please use --mode=<name>, see --help.", file=sys.stderr)
|
||
|
|
sys.exit(1)
|
||
|
|
|
||
|
|
if args.output:
|
||
|
|
sys.stdout = open(args.output, "w+")
|
||
|
|
|
||
|
|
if args.file == '--':
|
||
|
|
parse_file("<stdin>", sys.stdin, args.mode)
|
||
|
|
else:
|
||
|
|
parse_file(args.file, open(args.file), args.mode)
|