| #!/usr/bin/env python | |
| # Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| # Use of this source code is governed by a BSD-style license that can be | |
| # found in the LICENSE file. | |
| # | |
| """Creates an import library from an import description file.""" | |
| import ast | |
| import logging | |
| import optparse | |
| import os | |
| import os.path | |
| import shutil | |
| import subprocess | |
| import sys | |
| import tempfile | |
| _USAGE = """\ | |
| Usage: %prog [options] [imports-file] | |
| Creates an import library from imports-file. | |
| Note: this script uses the microsoft assembler (ml.exe) and the library tool | |
| (lib.exe), both of which must be in path. | |
| """ | |
| _ASM_STUB_HEADER = """\ | |
| ; This file is autogenerated by create_importlib_win.py, do not edit. | |
| .386 | |
| .MODEL FLAT, C | |
| .CODE | |
| ; Stubs to provide mangled names to lib.exe for the | |
| ; correct generation of import libs. | |
| """ | |
| _DEF_STUB_HEADER = """\ | |
| ; This file is autogenerated by create_importlib_win.py, do not edit. | |
| ; Export declarations for generating import libs. | |
| """ | |
| _LOGGER = logging.getLogger() | |
| class _Error(Exception): | |
| pass | |
| class _ImportLibraryGenerator(object): | |
| def __init__(self, temp_dir): | |
| self._temp_dir = temp_dir | |
| def _Shell(self, cmd, **kw): | |
| ret = subprocess.call(cmd, **kw) | |
| _LOGGER.info('Running "%s" returned %d.', cmd, ret) | |
| if ret != 0: | |
| raise _Error('Command "%s" returned %d.' % (cmd, ret)) | |
| def _ReadImportsFile(self, imports_file): | |
| # Slurp the imports file. | |
| return ast.literal_eval(open(imports_file).read()) | |
| def _WriteStubsFile(self, import_names, output_file): | |
| output_file.write(_ASM_STUB_HEADER) | |
| for name in import_names: | |
| output_file.write('%s PROC\n' % name) | |
| output_file.write('%s ENDP\n' % name) | |
| output_file.write('END\n') | |
| def _WriteDefFile(self, dll_name, import_names, output_file): | |
| output_file.write(_DEF_STUB_HEADER) | |
| output_file.write('NAME %s\n' % dll_name) | |
| output_file.write('EXPORTS\n') | |
| for name in import_names: | |
| name = name.split('@')[0] | |
| output_file.write(' %s\n' % name) | |
| def _CreateObj(self, dll_name, imports): | |
| """Writes an assembly file containing empty declarations. | |
| For each imported function of the form: | |
| AddClipboardFormatListener@4 PROC | |
| AddClipboardFormatListener@4 ENDP | |
| The resulting object file is then supplied to lib.exe with a .def file | |
| declaring the corresponding non-adorned exports as they appear on the | |
| exporting DLL, e.g. | |
| EXPORTS | |
| AddClipboardFormatListener | |
| In combination, the .def file and the .obj file cause lib.exe to generate | |
| an x86 import lib with public symbols named like | |
| "__imp__AddClipboardFormatListener@4", binding to exports named like | |
| "AddClipboardFormatListener". | |
| All of this is perpetrated in a temporary directory, as the intermediate | |
| artifacts are quick and easy to produce, and of no interest to anyone | |
| after the fact.""" | |
| # Create an .asm file to provide stdcall-like stub names to lib.exe. | |
| asm_name = dll_name + '.asm' | |
| _LOGGER.info('Writing asm file "%s".', asm_name) | |
| with open(os.path.join(self._temp_dir, asm_name), 'wb') as stubs_file: | |
| self._WriteStubsFile(imports, stubs_file) | |
| # Invoke on the assembler to compile it to .obj. | |
| obj_name = dll_name + '.obj' | |
| cmdline = ['ml.exe', '/nologo', '/c', asm_name, '/Fo', obj_name] | |
| self._Shell(cmdline, cwd=self._temp_dir, stdout=open(os.devnull)) | |
| return obj_name | |
| def _CreateImportLib(self, dll_name, imports, architecture, output_file): | |
| """Creates an import lib binding imports to dll_name for architecture. | |
| On success, writes the import library to output file. | |
| """ | |
| obj_file = None | |
| # For x86 architecture we have to provide an object file for correct | |
| # name mangling between the import stubs and the exported functions. | |
| if architecture == 'x86': | |
| obj_file = self._CreateObj(dll_name, imports) | |
| # Create the corresponding .def file. This file has the non stdcall-adorned | |
| # names, as exported by the destination DLL. | |
| def_name = dll_name + '.def' | |
| _LOGGER.info('Writing def file "%s".', def_name) | |
| with open(os.path.join(self._temp_dir, def_name), 'wb') as def_file: | |
| self._WriteDefFile(dll_name, imports, def_file) | |
| # Invoke on lib.exe to create the import library. | |
| # We generate everything into the temporary directory, as the .exp export | |
| # files will be generated at the same path as the import library, and we | |
| # don't want those files potentially gunking the works. | |
| dll_base_name, ext = os.path.splitext(dll_name) | |
| lib_name = dll_base_name + '.lib' | |
| cmdline = ['lib.exe', | |
| '/machine:%s' % architecture, | |
| '/def:%s' % def_name, | |
| '/out:%s' % lib_name] | |
| if obj_file: | |
| cmdline.append(obj_file) | |
| self._Shell(cmdline, cwd=self._temp_dir, stdout=open(os.devnull)) | |
| # Copy the .lib file to the output directory. | |
| shutil.copyfile(os.path.join(self._temp_dir, lib_name), output_file) | |
| _LOGGER.info('Created "%s".', output_file) | |
| def CreateImportLib(self, imports_file, output_file): | |
| # Read the imports file. | |
| imports = self._ReadImportsFile(imports_file) | |
| # Creates the requested import library in the output directory. | |
| self._CreateImportLib(imports['dll_name'], | |
| imports['imports'], | |
| imports.get('architecture', 'x86'), | |
| output_file) | |
| def main(): | |
| parser = optparse.OptionParser(usage=_USAGE) | |
| parser.add_option('-o', '--output-file', | |
| help='Specifies the output file path.') | |
| parser.add_option('-k', '--keep-temp-dir', | |
| action='store_true', | |
| help='Keep the temporary directory.') | |
| parser.add_option('-v', '--verbose', | |
| action='store_true', | |
| help='Verbose logging.') | |
| options, args = parser.parse_args() | |
| if len(args) != 1: | |
| parser.error('You must provide an imports file.') | |
| if not options.output_file: | |
| parser.error('You must provide an output file.') | |
| options.output_file = os.path.abspath(options.output_file) | |
| if options.verbose: | |
| logging.basicConfig(level=logging.INFO) | |
| else: | |
| logging.basicConfig(level=logging.WARN) | |
| temp_dir = tempfile.mkdtemp() | |
| _LOGGER.info('Created temporary directory "%s."', temp_dir) | |
| try: | |
| # Create a generator and create the import lib. | |
| generator = _ImportLibraryGenerator(temp_dir) | |
| ret = generator.CreateImportLib(args[0], options.output_file) | |
| except Exception, e: | |
| _LOGGER.exception('Failed to create import lib.') | |
| ret = 1 | |
| finally: | |
| if not options.keep_temp_dir: | |
| shutil.rmtree(temp_dir) | |
| _LOGGER.info('Deleted temporary directory "%s."', temp_dir) | |
| return ret | |
| if __name__ == '__main__': | |
| sys.exit(main()) |