318 lines
10 KiB
Python
Executable File
318 lines
10 KiB
Python
Executable File
#!/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 re
|
|
import sys
|
|
import argparse
|
|
|
|
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: %s" % banner_command(sys.argv)
|
|
print "// DO NOT EDIT THIS FILE"
|
|
print ""
|
|
print "#ifndef %s_FUNCTIONS_H" % prefix_name
|
|
print "#define %s_FUNCTIONS_H" % prefix_name
|
|
print ""
|
|
for line in verbatim:
|
|
print line
|
|
|
|
print "#define LIST_%s_FUNCTIONS(X) \\" % prefix_name
|
|
for entry in entries:
|
|
if with_args:
|
|
print " X(%s, %s, (%s), (%s)) \\" % \
|
|
(entry.return_type, entry.func_name, entry.parameters,
|
|
entry.call)
|
|
else:
|
|
print " X(%s, %s, (%s)) \\" % \
|
|
(entry.return_type, entry.func_name, entry.parameters)
|
|
|
|
print ""
|
|
print ""
|
|
print "#endif // %s_FUNCTIONS_H" % prefix_name
|
|
|
|
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: %s" % 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 "static %s (*%s)(%s) = 0;" % \
|
|
(entry.return_type, ptr_name, entry.parameters)
|
|
|
|
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 "%s %s(%s) {" % \
|
|
(entry.return_type, entry.func_name, entry.parameters)
|
|
ptr_name = ENTRY_PREFIX + entry.func_name
|
|
if entry.return_type != "void":
|
|
print " return %s(%s);" % (ptr_name, entry.call)
|
|
else:
|
|
print " %s(%s);" % (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 "int %s_dynlink_init(void* lib) {" % prefix_name
|
|
for entry in entries:
|
|
ptr_name = ENTRY_PREFIX + entry.func_name
|
|
print " %s = (%s(*)(%s))dlsym(lib, \"%s\");" % \
|
|
(ptr_name,
|
|
entry.return_type,
|
|
entry.parameters,
|
|
entry.func_name)
|
|
print " if (!%s) return -1;" % ptr_name
|
|
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 " %s" % 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 "\t\t%s;" % 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 "%s%s" % (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 >> sys.stderr, "ERROR: %s:%s" % (filename, error)
|
|
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 >> sys.stderr, "ERROR: Please use --mode=<name>, see --help."
|
|
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)
|