generate_stubs: Add a new option --export-macro.

tools/generate_stubs/generate_stubs.py

 #!/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 windows and posix stub files for a given set of signatures.
 
 For libraries that need to be loaded outside of the standard executable startup
 path mechanism, stub files need to be generated for the wanted functions.  In
 windows, this is done via "def" files and the delay load mechanism.  On a posix
@@ skipping 67 matching lines @@
 # Constants defning the supported file types options.
 FILE_TYPE_WIN_X86 = 'windows_lib'
 FILE_TYPE_WIN_X64 = 'windows_lib_x64'
 FILE_TYPE_POSIX_STUB = 'posix_stubs'
 FILE_TYPE_WIN_DEF = 'windows_def'
 
 # Template for generating a stub function definition.  Includes a forward
 # declaration marking the symbol as weak.  This template takes the following
 # named parameters.
 #   return_type: The return type.
+#   export: The macro used to alter the stub's visibility.
 #   name: The name of the function.
 #   params: The parameters to the function.
 #   return_prefix: 'return ' if this function is not void. '' otherwise.
 #   arg_list: The arguments used to call the stub function.
 STUB_FUNCTION_DEFINITION = (
     """extern %(return_type)s %(name)s(%(params)s) __attribute__((weak));
-%(return_type)s %(name)s(%(params)s) {
+%(return_type)s %(export)s %(name)s(%(params)s) {
   %(return_prefix)s%(name)s_ptr(%(arg_list)s);
 }""")
 
 # Template for generating a variadic stub function definition with return
 # value.
 # Includes a forward declaration marking the symbol as weak.
 # This template takes the following named parameters.
 #   return_type: The return type.
+#   export: The macro used to alter the stub's visibility.
 #   name: The name of the function.
 #   params: The parameters to the function.
 #   arg_list: The arguments used to call the stub function without the
 #             variadic argument.
 #   last_named_arg: Name of the last named argument before the variadic
 #                   argument.
 VARIADIC_STUB_FUNCTION_DEFINITION = (
     """extern %(return_type)s %(name)s(%(params)s) __attribute__((weak));
-%(return_type)s %(name)s(%(params)s) {
+%(return_type)s %(export)s %(name)s(%(params)s) {
   va_list args___;
   va_start(args___, %(last_named_arg)s);
   %(return_type)s ret___ = %(name)s_ptr(%(arg_list)s, va_arg(args___, void*));
   va_end(args___);
   return ret___;
 }""")
 
 # Template for generating a variadic stub function definition without
 # return value.
 # Includes a forward declaration marking the symbol as weak.
 # This template takes the following named parameters.
 #   name: The name of the function.
 #   params: The parameters to the function.
+#   export: The macro used to alter the stub's visibility.
 #   arg_list: The arguments used to call the stub function without the
 #             variadic argument.
 #   last_named_arg: Name of the last named argument before the variadic
 #                   argument.
 VOID_VARIADIC_STUB_FUNCTION_DEFINITION = (
     """extern void %(name)s(%(params)s) __attribute__((weak));
-void %(name)s(%(params)s) {
+void %(export)s %(name)s(%(params)s) {
   va_list args___;
   va_start(args___, %(last_named_arg)s);
   %(name)s_ptr(%(arg_list)s, va_arg(args___, void*));
   va_end(args___);
 }""")
 
 # Template for the preamble for the stub header file with the header guards,
 # standard set of includes, and namespace opener.  This template takes the
 # following named parameters:
 #   guard_name: The macro to use as the header guard.
@@ skipping 368 matching lines @@
   first usage, the DSO must be present at load time of the main binary.
 
   To simulate the windows delay load procedure, we need to create a set of
   stub functions that allow for correct linkage of the main binary, but
   dispatch to the dynamically resolved symbol when the module is initialized.
 
   This class takes a list of function signatures, and generates a set of stub
   functions plus initialization code for them.
   """
 
-  def __init__(self, module_name, signatures):
+  def __init__(self, module_name, export_macro, signatures):
     """Initializes PosixStubWriter for this set of signatures and module_name.
 
     Args:
       module_name: The name of the module we are writing a stub for.
+      export_macro: A preprocessor macro used to annotate stub symbols with
+                    an EXPORT marking, to control visibility.
       signatures: The list of signature hashes, as produced by ParseSignatures,
                   to create stubs for.
     """
     self.signatures = signatures
     self.module_name = module_name
+    self.export_macro = export_macro
 
   @classmethod
   def CStyleIdentifier(cls, identifier):
     """Generates a C style identifier.
 
     The module_name has all invalid identifier characters removed (anything
     that's not [_a-zA-Z0-9]) and is run through string.capwords to try
     and approximate camel case.
 
     Args:
@@ skipping 107 matching lines @@
       arg_list = ''
 
     if arg_list != '' and len(arguments) > 1 and arguments[-1] == '...':
       # If the last argment is ... then this is a variadic function.
       if return_prefix != '':
         return VARIADIC_STUB_FUNCTION_DEFINITION % {
             'return_type': signature['return_type'],
             'name': signature['name'],
             'params': ', '.join(signature['params']),
             'arg_list': ', '.join(arguments[0:-1]),
-            'last_named_arg': arguments[-2]}
+            'last_named_arg': arguments[-2],
+            'export': signature.get('export', '')}
       else:
         return VOID_VARIADIC_STUB_FUNCTION_DEFINITION % {
             'name': signature['name'],
             'params': ', '.join(signature['params']),
             'arg_list': ', '.join(arguments[0:-1]),
-            'last_named_arg': arguments[-2]}
+            'last_named_arg': arguments[-2],
+            'export': signature.get('export', '')}
     else:
       # This is a regular function.
       return STUB_FUNCTION_DEFINITION % {
           'return_type': signature['return_type'],
           'name': signature['name'],
           'params': ', '.join(signature['params']),
           'return_prefix': return_prefix,
-          'arg_list': arg_list}
+          'arg_list': arg_list,
+          'export': signature.get('export', '')}
 
   @classmethod
   def WriteImplementationPreamble(cls, header_path, outfile):
     """Write the necessary includes for the implementation file.
 
     Args:
       header_path: The path to the header file.
       outfile: The file handle to populate.
     """
     outfile.write(IMPLEMENTATION_PREAMBLE % header_path)
@@ skipping 127 matching lines @@
 
       void FunctionName(A a) {
         FunctionName_ptr(a);
       }
 
     Args:
       outfile: The file handle to populate.
     """
     outfile.write('// Stubs that dispatch to the real implementations.\n')
     for sig in self.signatures:
+      sig['export'] = self.export_macro
       outfile.write('%s\n' % PosixStubWriter.StubFunction(sig))
 
   def WriteModuleInitializeFunctions(self, outfile):
     """Write functions to initialize/query initlialization of the module.
 
     This creates 2 functions IsModuleInitialized and InitializeModule where
     "Module" is replaced with the module name, first letter capitalized.
 
     The InitializeModule function takes a handle that is retrieved from dlopen
     and attempts to assign each function pointer above via dlsym.
@@ skipping 86 matching lines @@
                     help=('File to insert after the system includes in the '
                           'generated stub implemenation file. Ignored for '
                           '%s and %s types.' %
                           (FILE_TYPE_WIN_X86, FILE_TYPE_WIN_X64)))
   parser.add_option('-m',
                     '--module_name',
                     dest='module_name',
                     default=None,
                     help=('Name of output DLL or LIB for DEF creation using '
                           '%s type.' % FILE_TYPE_WIN_DEF))
+  parser.add_option('-x',
+                    '--export_macro',
+                    dest='export_macro',
+                    default='',
+                    help=('A macro to place between the return type and '
+                          'function name, e.g. MODULE_EXPORT, to control the '
+                          'visbility of the stub functions.'))
 
   return parser
 
 
 def ParseOptions():
   """Parses the options and terminates program if they are not sane.
 
   Returns:
     The pair (optparse.OptionValues, [string]), that is the output of
     a successful call to parser.parse_args().
@@ skipping 54 matching lines @@
   intermediate_dir = os.path.normpath(options.intermediate_dir)
   if intermediate_dir is None:
     intermediate_dir = out_dir
 
   EnsureDirExists(out_dir)
   EnsureDirExists(intermediate_dir)
 
   return out_dir, intermediate_dir
 
 
-def CreateWindowsLibForSigFiles(sig_files, out_dir, intermediate_dir, machine):
+def CreateWindowsLibForSigFiles(sig_files, out_dir, intermediate_dir, machine,
+                                export_macro):
   """For each signature file, create a windows lib.
 
   Args:
     sig_files: Array of strings with the paths to each signature file.
     out_dir: String holding path to directory where the generated libs go.
     intermediate_dir: String holding path to directory generated intermdiate
                       artifacts.
     machine: String holding the machine type, 'X86' or 'X64'.
+    export_macro: A preprocessor macro used to annotate stub symbols with
+                  an EXPORT marking, to control visibility.
   """
   for input_path in sig_files:
     infile = open(input_path, 'r')
     try:
       signatures = ParseSignatures(infile)
       module_name = ExtractModuleName(os.path.basename(input_path))
+      for sig in signatures:
+        sig['export'] = export_macro
       CreateWindowsLib(module_name, signatures, intermediate_dir, out_dir,
                        machine)
     finally:
       infile.close()
 
 
 def CreateWindowsDefForSigFiles(sig_files, out_dir, module_name):
   """For all signature files, create a single windows def file.
 
   Args:
@@ skipping 14 matching lines @@
   outfile = open(def_file_path, 'w')
 
   try:
     WriteWindowsDefFile(module_name, signatures, outfile)
   finally:
     outfile.close()
 
 
 def CreatePosixStubsForSigFiles(sig_files, stub_name, out_dir,
                                 intermediate_dir, path_from_source,
-                                extra_stub_header):
+                                extra_stub_header, export_macro):
   """Create a posix stub library with a module for each signature file.
 
   Args:
     sig_files: Array of strings with the paths to each signature file.
     stub_name: String with the basename of the generated stub file.
     out_dir: String holding path to directory for the .h files.
     intermediate_dir: String holding path to directory for the .cc files.
     path_from_source: String with relative path of generated files from the
                       project root.
     extra_stub_header: String with path to file of extra lines to insert
                        into the generated header for the stub library.
+    export_macro: A preprocessor macro used to annotate stub symbols with
+                  an EXPORT marking, to control visibility.
   """
   header_base_name = stub_name + '.h'
   header_path = os.path.join(out_dir, header_base_name)
   impl_path = os.path.join(intermediate_dir, stub_name + '.cc')
 
   module_names = [ExtractModuleName(path) for path in sig_files]
   namespace = path_from_source.replace('/', '_').lower()
   header_guard = '%s_' % namespace.upper()
   header_include_path = os.path.join(path_from_source, header_base_name)
 
@@ skipping 16 matching lines @@
 
     # For each signature file, generate the stub population functions
     # for that file.  Each file represents one module.
     for input_path in sig_files:
       name = ExtractModuleName(input_path)
       infile = open(input_path, 'r')
       try:
         signatures = ParseSignatures(infile)
       finally:
         infile.close()
-      writer = PosixStubWriter(name, signatures)
+      writer = PosixStubWriter(name, export_macro, signatures)
       writer.WriteImplementationContents(namespace, impl_file)
 
     # Lastly, output the umbrella function for the file.
     PosixStubWriter.WriteUmbrellaInitializer(module_names, namespace,
                                              impl_file)
   finally:
     impl_file.close()
 
   # Then create the associated header file.
   header_file = open(header_path, 'w')
   try:
     PosixStubWriter.WriteHeaderContents(module_names, namespace,
                                         header_guard, header_file)
   finally:
     header_file.close()
 
 
 def main():
   options, args = ParseOptions()
   out_dir, intermediate_dir = CreateOutputDirectories(options)
 
   if options.type == FILE_TYPE_WIN_X86:
-    CreateWindowsLibForSigFiles(args, out_dir, intermediate_dir, 'X86')
+    CreateWindowsLibForSigFiles(args, out_dir, intermediate_dir, 'X86',
+                                options.export_macro)
   elif options.type == FILE_TYPE_WIN_X64:
-    CreateWindowsLibForSigFiles(args, out_dir, intermediate_dir, 'X64')
+    CreateWindowsLibForSigFiles(args, out_dir, intermediate_dir, 'X64',
+                                options.export_macro)
   elif options.type == FILE_TYPE_POSIX_STUB:
     CreatePosixStubsForSigFiles(args, options.stubfile_name, out_dir,
                                 intermediate_dir, options.path_from_source,
-                                options.extra_stub_header)
+                                options.extra_stub_header, options.export_macro)
   elif options.type == FILE_TYPE_WIN_DEF:
     CreateWindowsDefForSigFiles(args, out_dir, options.module_name)
 
 
 if __name__ == '__main__':
   main()