Generate Pepper IDL for OpenGLES2

gpu/command_buffer/build_gles2_cmd_buffer.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.
 
 """code generator for GLES2 command buffers."""
 
 import itertools
 import os
 import os.path
@@ skipping 6943 matching lines @@
          for arg in args if not arg.IsConstant()])
     return self.__MaybePrependComma(arg_string, add_comma)
 
   def MakeTypedPepperArgString(self, prefix):
     """Gets a list of arguments as they need to be for Pepper."""
     if self.GetInfo("pepper_args"):
       return self.GetInfo("pepper_args")
     else:
       return self.MakeTypedOriginalArgString(prefix, False)
 
+  def MapCTypeToPepperIdlType(self, ctype, is_for_return_type=False):
+    """Converts a C type name to the corresponding Pepper IDL type."""
+    idltype = {
+        'char*': '[out] str_t',
+        'const GLchar* const*': '[out] cstr_t',
+        'const char*': 'cstr_t',
+        'const void*': 'mem_t',
+        'void*': '[out] mem_t',
+        'void**': '[out] mem_ptr_t',
+    }.get(ctype, ctype)
+    # We use "GLxxx_ptr_t" for "GLxxx*".
+    matched = re.match(r'(const )?(GL\w+)\*$', ctype)
+    if matched:
+      idltype = matched.group(2) + '_ptr_t'
+      if not matched.group(1):
+        idltype = '[out] ' + idltype
+    # If an in/out specifier is not specified yet, prepend [in].
+    if idltype[0] != '[':
+      idltype = '[in] ' + idltype
+    # Strip the in/out specifier for a return type.
+    if is_for_return_type:
+      idltype = re.sub(r'\[\w+\] ', '', idltype)
+    return idltype
+
+  def MakeTypedPepperIdlArgStrings(self):
+    """Gets a list of arguments as they need to be for Pepper IDL."""
+    args = self.GetOriginalArgs()
+    return ["%s %s" % (self.MapCTypeToPepperIdlType(arg.type), arg.name)
+            for arg in args]
+
   def GetPepperName(self):
     if self.GetInfo("pepper_name"):
       return self.GetInfo("pepper_name")
     return self.name
 
   def MakeTypedCmdArgString(self, prefix, add_comma = False):
     """Gets a typed list of arguments as they need to be for command buffers."""
     args = self.GetCmdArgs()
     arg_string = ", ".join(
         ["%s %s%s" % (arg.type, prefix, arg.name) for arg in args])
@@ skipping 1286 matching lines @@
         else:
           file.Write("""  return GLES2Util::GetQualifiedEnumString(
       NULL, 0, value);
 }
 
 """)
     file.Close()
 
   def WritePepperGLES2Interface(self, filename, dev):
     """Writes the Pepper OpenGLES interface definition."""
-    file = CHeaderWriter(
-        filename,
-        "// OpenGL ES interface.\n")
+    file = CWriter(filename)
+    file.Write(_LICENSE)
+    file.Write(_DO_NOT_EDIT_WARNING)
 
+    file.Write("label Chrome {\n")
+    file.Write("  M39 = 1.0\n")
+    file.Write("};\n\n")
+
+    if not dev:
+      # Declare GL types.
+      file.Write("[version=1.0]\n")
+      file.Write("describe {\n")
+      for gltype in ['GLbitfield', 'GLboolean', 'GLbyte', 'GLclampf',
+                     'GLclampx', 'GLenum', 'GLfixed', 'GLfloat', 'GLint',
+                     'GLintptr', 'GLshort', 'GLsizei', 'GLsizeiptr',
+                     'GLubyte', 'GLuint', 'GLushort']:
+        file.Write("  %s;\n" % gltype)
+        file.Write("  %s_ptr_t;\n" % gltype)
+      file.Write("};\n\n")
+
+    # C level typedefs.
+    file.Write("#inline c\n")
     file.Write("#include \"ppapi/c/pp_resource.h\"\n")
     if dev:
       file.Write("#include \"ppapi/c/ppb_opengles2.h\"\n\n")
     else:
       file.Write("\n#ifndef __gl2_h_\n")
       for (k, v) in _GL_TYPES.iteritems():
         file.Write("typedef %s %s;\n" % (v, k))
       file.Write("#ifdef _WIN64\n")
       for (k, v) in _GL_TYPES_64.iteritems():
         file.Write("typedef %s %s;\n" % (v, k))
       file.Write("#else\n")
       for (k, v) in _GL_TYPES_32.iteritems():
         file.Write("typedef %s %s;\n" % (v, k))
       file.Write("#endif  // _WIN64\n")
       file.Write("#endif  // __gl2_h_\n\n")
+    file.Write("#endinl\n")
 
     for interface in self.pepper_interfaces:
       if interface.dev != dev:
         continue
-      file.Write("#define %s_1_0 \"%s;1.0\"\n" %
-                 (interface.GetInterfaceName(), interface.GetInterfaceString()))
-      file.Write("#define %s %s_1_0\n" %
-                 (interface.GetInterfaceName(), interface.GetInterfaceName()))
-
-      file.Write("\nstruct %s {\n" % interface.GetStructName())
+      # Historically, we provide OpenGLES2 interfaces with struct
+      # namespace. Not to break code which uses the interface as
+      # "struct OpenGLES2", we put it in struct namespace.
+      file.Write('\n[macro="%s", force_struct_namespace]\n' %
+                 interface.GetInterfaceName())
+      file.Write("interface %s {\n" % interface.GetStructName())
       for func in self.original_functions:
         if not func.InPepperInterface(interface):
           continue
 
-        original_arg = func.MakeTypedPepperArgString("")
-        context_arg = "PP_Resource context"
-        if len(original_arg):
-          arg = context_arg + ", " + original_arg
-        else:
-          arg = context_arg
-        file.Write("  %s (*%s)(%s);\n" %
-                   (func.return_type, func.GetPepperName(), arg))
+        ret_type = func.MapCTypeToPepperIdlType(func.return_type,
+                                                is_for_return_type=True)
+        func_prefix = "  %s %s(" % (ret_type, func.GetPepperName())
+        file.Write(func_prefix)
+        file.Write("[in] PP_Resource context")
+        for arg in func.MakeTypedPepperIdlArgStrings():
+          file.Write(",\n" + " " * len(func_prefix) + arg)
+        file.Write(");\n")
       file.Write("};\n\n")
 
 
     file.Close()
 
   def WritePepperGLES2Implementation(self, filename):
     """Writes the Pepper OpenGLES interface implementation."""
 
     file = CWriter(filename)
     file.Write(_LICENSE)
@@ skipping 184 matching lines @@
   # This script lives under gpu/command_buffer, cd to base directory.
   os.chdir(os.path.dirname(__file__) + "/../..")
 
   gen = GLGenerator(options.verbose)
   gen.ParseGLH("gpu/command_buffer/cmd_buffer_functions.txt")
 
   # Support generating files under gen/
   if options.output_dir != None:
     os.chdir(options.output_dir)
 
-  gen.WritePepperGLES2Interface("ppapi/c/ppb_opengles2.h", False)
-  gen.WritePepperGLES2Interface("ppapi/c/dev/ppb_opengles2ext_dev.h", True)
+  gen.WritePepperGLES2Interface("ppapi/api/ppb_opengles2.idl", False)
+  gen.WritePepperGLES2Interface("ppapi/api/dev/ppb_opengles2ext_dev.idl", True)
   gen.WriteGLES2ToPPAPIBridge("ppapi/lib/gl/gles2/gles2.c")
   gen.WritePepperGLES2Implementation(
       "ppapi/shared_impl/ppb_opengles2_shared.cc")
   os.chdir("gpu/command_buffer")
   gen.WriteCommandIds("common/gles2_cmd_ids_autogen.h")
   gen.WriteFormat("common/gles2_cmd_format_autogen.h")
   gen.WriteFormatTest("common/gles2_cmd_format_test_autogen.h")
   gen.WriteGLES2InterfaceHeader("client/gles2_interface_autogen.h")
   gen.WriteGLES2InterfaceStub("client/gles2_interface_stub_autogen.h")
   gen.WriteGLES2InterfaceStubImpl(
@@ skipping 72 matching lines @@
       "ppapi/shared_impl/ppb_opengles2_shared.cc"])
 
   if gen.errors > 0:
     print "%d errors" % gen.errors
     return 1
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))