generate_stubs.py to support varidiac functions

tools/generate_stubs/generate_stubs.py

 #!/usr/bin/python
 #
 # Copyright (c) 2009 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
@@ skipping 26 matching lines @@
 class SubprocessError(Error):
   def __init__(self, message, error_code):
     Error.__init__(self)
     self.message = message
     self.error_code = error_code
 
   def __str__(self):
     return 'Failed with code %s: %s' % (self.message, repr(self.error_code))
 
 
-# Regular expression used to parse signatures in the input files. The regex
-# is built around identifying the "identifier" for the function name.  We
-# consider the identifier to be the string that follows these constraints:
+# Regular expression used to parse function signatures in the input files.
+# The regex is built around identifying the "identifier" for the function name.
+# We consider the identifier to be the string that follows these constraints:
 #
 #   1) Starts with [_a-ZA-Z] (C++ spec 2.10).
 #   2) Continues with [_a-ZA-Z0-9] (C++ spec 2.10).
 #   3) Preceeds an opening parenthesis by 0 or more whitespace chars.
 #
 # From that, all preceeding characters are considered the return value.
 # Trailing characters should have a substring matching the form (.*).  That
 # is considered the arguments.
 SIGNATURE_REGEX = re.compile('(?P<return_type>.+?)'
                              '(?P<name>[_a-zA-Z][_a-zA-Z0-9]+)\s*'
@@ skipping 13 matching lines @@
 #   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_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.
+#   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) {
+  va_list args___;
+  va_start(args___, %(last_named_arg)s);
+  %(return_type)s ret___ = %(name)s_ptr(%(arg_list)s, args___);
+  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.
+#   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) {
+  va_list args___;
+  va_start(args___, %(last_named_arg)s);
+  %(name)s_ptr(%(arg_list)s, args___);
+  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.
 #   namespace: The namespace for the stub functions.
 STUB_HEADER_PREAMBLE = """// This is generated file. Do not modify directly.
 
 #ifndef %(guard_name)s
 #define %(guard_name)s
 
@@ skipping 460 matching lines @@
     if signature['return_type'] != 'void':
       return_prefix = 'return '
 
     # Generate the argument list.
     arguments = [re.split('[\*& ]', arg)[-1].strip() for arg in
                  signature['params']]
     arg_list = ', '.join(arguments)
     if arg_list == 'void':
       arg_list = ''
 
-    return STUB_FUNCTION_DEFINITION % {
-        'return_type': signature['return_type'],
-        'name': signature['name'],
-        'params': ', '.join(signature['params']),
-        'return_prefix': return_prefix,
-        'arg_list': 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]}
+      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]}
+    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}
 
   @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 380 matching lines @@
   if options.type == FILE_TYPE_WIN:
     CreateWindowsLibForSigFiles(args, out_dir, intermediate_dir)
   elif options.type == FILE_TYPE_POSIX_STUB:
     CreatePosixStubsForSigFiles(args, options.stubfile_name, out_dir,
                                 intermediate_dir, options.path_from_source,
                                 options.extra_stub_header)
 
 
 if __name__ == '__main__':
   main()