Clarify function info object usage in the command buffer generator

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 1195 matching lines @@
   {'name': '', 'dev': False},
   {'name': 'InstancedArrays', 'dev': False},
   {'name': 'FramebufferBlit', 'dev': False},
   {'name': 'FramebufferMultisample', 'dev': False},
   {'name': 'ChromiumEnableFeature', 'dev': False},
   {'name': 'ChromiumMapSub', 'dev': False},
   {'name': 'Query', 'dev': False},
   {'name': 'DrawBuffers', 'dev': True},
 ]
 
-# This table specifies types and other special data for the commands that
-# will be generated.
+# A function info object specifies the type and other special data for the
+# command that will be generated. A base function info object is generated by
+# parsing the "cmd_buffer_functions.txt", one for each function in the
+# file. These function info objects can be augmented and their values can be
+# overridden by adding an object to the table below.
 #
 # Must match function names specified in "cmd_buffer_functions.txt".
 #
 # cmd_comment:  A comment added to the cmd format.
 # type:         defines which handler will be used to generate code.
 # decoder_func: defines which function to call in the decoder to execute the
 #               corresponding GL command. If not specified the GL command will
 #               be called directly.
 # gl_test_func: GL function that is expected to be called when testing.
 # cmd_args:     The arguments to use for the command. This overrides generating
@@ skipping 3596 matching lines @@
     self.WriteInvalidUnitTest(func, file, invalid_test, extra)
 
   def WriteGetDataSizeCode(self, func, file):
     """Overrriden from TypeHandler."""
     code = """  uint32_t data_size;
   if (!ComputeDataSize(1, sizeof(%s), %d, &data_size)) {
     return error::kOutOfBounds;
   }
 """
     file.Write(code % (self.GetArrayType(func), self.GetArrayCount(func)))
-    if func.is_immediate:
+    if func.IsImmediate():
       file.Write("  if (data_size > immediate_data_size) {\n")
       file.Write("    return error::kOutOfBounds;\n")
       file.Write("  }\n")
 
   def WriteGLES2Implementation(self, func, file):
     """Overrriden from TypeHandler."""
     impl_func = func.GetInfo('impl_func')
     if (impl_func != None and impl_func != True):
       return;
     file.Write("%s GLES2Implementation::%s(%s) {\n" %
@@ skipping 247 matching lines @@
     self.WriteInvalidUnitTest(func, file, invalid_test, extra)
 
   def WriteGetDataSizeCode(self, func, file):
     """Overrriden from TypeHandler."""
     code = """  uint32_t data_size;
   if (!ComputeDataSize(count, sizeof(%s), %d, &data_size)) {
     return error::kOutOfBounds;
   }
 """
     file.Write(code % (self.GetArrayType(func), self.GetArrayCount(func)))
-    if func.is_immediate:
+    if func.IsImmediate():
       file.Write("  if (data_size > immediate_data_size) {\n")
       file.Write("    return error::kOutOfBounds;\n")
       file.Write("  }\n")
 
   def WriteGLES2Implementation(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("%s GLES2Implementation::%s(%s) {\n" %
                (func.return_type, func.original_name,
                 func.MakeTypedOriginalArgString("")))
     file.Write("  GPU_CLIENT_SINGLE_THREAD_CHECK();\n")
@@ skipping 653 matching lines @@
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 """
     self.WriteValidUnitTest(func, file, invalid_test)
 
   def WriteServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     pass
 
-
-class FunctionInfo(object):
-  """Holds info about a function."""
-
-  def __init__(self, info, type_handler):
-    for key in info:
-      setattr(self, key, info[key])
-    self.type_handler = type_handler
-    if not 'type' in info:
-      self.type = ''
-
-
 class Argument(object):
   """A class that represents a function argument."""
 
   cmd_type_map_ = {
     'GLenum': 'uint32_t',
     'GLint': 'int32_t',
     'GLintptr': 'int32_t',
     'GLsizei': 'int32_t',
     'GLsizeiptr': 'int32_t',
     'GLfloat': 'float',
@@ skipping 155 matching lines @@
 
 
 class SizeArgument(Argument):
   """class for GLsizei and GLsizeiptr."""
 
   def __init__(self, name, type):
     Argument.__init__(self, name, type)
 
   def GetNumInvalidValues(self, func):
     """overridden from Argument."""
-    if func.is_immediate:
+    if func.IsImmediate():
       return 0
     return 1
 
   def GetInvalidArg(self, offset, index):
     """overridden from Argument."""
     return ("-1", "kNoError", "GL_INVALID_VALUE")
 
   def WriteValidationCode(self, file, func):
     """overridden from Argument."""
     file.Write("  if (%s < 0) {\n" % self.name)
@@ skipping 408 matching lines @@
     return 1
 
   def GetInvalidArg(self, offset, index):
     """returns an invalid value by index."""
     return ("kInvalidClientId", "kNoError", "GL_INVALID_VALUE")
 
 
 class Function(object):
   """A class that represents a function."""
 
-  def __init__(self, original_name, name, info, return_type, original_args,
-               args_for_cmds, cmd_args, init_args, num_pointer_args):
+  type_handlers = {
+    '': TypeHandler(),
+    'Bind': BindHandler(),
+    'Create': CreateHandler(),
+    'Custom': CustomHandler(),
+    'Data': DataHandler(),
+    'Delete': DeleteHandler(),
+    'DELn': DELnHandler(),
+    'GENn': GENnHandler(),
+    'GETn': GETnHandler(),
+    'GLchar': GLcharHandler(),
+    'GLcharN': GLcharNHandler(),
+    'HandWritten': HandWrittenHandler(),
+    'Is': IsHandler(),
+    'Manual': ManualHandler(),
+    'PUT': PUTHandler(),
+    'PUTn': PUTnHandler(),
+    'PUTXn': PUTXnHandler(),
+    'StateSet': StateSetHandler(),
+    'StateSetRGBAlpha': StateSetRGBAlphaHandler(),
+    'StateSetFrontBack': StateSetFrontBackHandler(),
+    'StateSetFrontBackSeparate': StateSetFrontBackSeparateHandler(),
+    'StateSetNamedParameter': StateSetNamedParameter(),
+    'STRn': STRnHandler(),
+    'Todo': TodoHandler(),
+  }
+
+  def __init__(self, name, info):
     self.name = name
-    self.original_name = original_name
+    self.original_name = info['original_name']
+
+    self.original_args = self.ParseArgs(info['original_args'])
+
+    if 'cmd_args' in info:
+      self.args_for_cmds = self.ParseArgs(info['cmd_args'])
+    else:
+      self.args_for_cmds = self.original_args[:]
+
+    self.return_type = info['return_type']
+    if self.return_type != 'void':
+      self.return_arg = CreateArg(info['return_type'] + " result")
+    else:
+      self.return_arg = None
+
+    self.num_pointer_args = sum(
+      [1 for arg in self.args_for_cmds if arg.IsPointer()])
     self.info = info
-    self.type_handler = info.type_handler
-    self.return_type = return_type
-    self.original_args = original_args
-    self.num_pointer_args = num_pointer_args
-    self.can_auto_generate = num_pointer_args == 0 and return_type == "void"
-    self.cmd_args = cmd_args
-    self.init_args = init_args
+    self.type_handler = self.type_handlers[info['type']]
+    self.can_auto_generate = (self.num_pointer_args == 0 and
+                              info['return_type'] == "void")
     self.InitFunction()
-    self.args_for_cmds = args_for_cmds
-    self.is_immediate = False
+
+  def ParseArgs(self, arg_string):
+    """Parses a function arg string."""
+    args = []
+    parts = arg_string.split(',')
+    for arg_string in parts:
+      arg = CreateArg(arg_string)
+      if arg:
+        args.append(arg)
+    return args
 
   def IsType(self, type_name):
     """Returns true if function is a certain type."""
-    return self.info.type == type_name
+    return self.info['type'] == type_name
 
   def InitFunction(self):
-    """Calls the init function for the type handler."""
+    """Creates command args and calls the init function for the type handler.
+
+    Creates argument lists for command buffer commands, eg. self.cmd_args and
+    self.init_args.
+    Calls the type function initialization.
+    Override to create different kind of command buffer command argument lists.
+    """
+    self.cmd_args = []
+    for arg in self.args_for_cmds:
+      arg.AddCmdArgs(self.cmd_args)
+
+    self.init_args = []
+    for arg in self.args_for_cmds:
+      arg.AddInitArgs(self.init_args)
+
+    if self.return_arg:
+      self.init_args.append(self.return_arg)
+
     self.type_handler.InitFunction(self)
 
-  def GetInfo(self, name):
+  def IsImmediate(self):
+    """Returns whether the function is immediate data function or not."""
+    return False
+
+  def GetInfo(self, name, default = None):
     """Returns a value from the function info for this function."""
-    if hasattr(self.info, name):
-      return getattr(self.info, name)
-    return None
+    if name in self.info:
+      return self.info[name]
+    return default
 
   def GetValidArg(self, index):
     """Gets a valid arg from the function info if one exists."""
     valid_args = self.GetInfo('valid_args')
     if valid_args and str(index) in valid_args:
       return valid_args[str(index)]
     return None
 
   def AddInfo(self, name, value):
     """Adds an info."""
-    setattr(self.info, name, value)
+    self.info[name] = value
 
   def IsCoreGLFunction(self):
     return (not self.GetInfo('extension') and
             not self.GetInfo('pepper_interface'))
 
   def InPepperInterface(self, interface):
     ext = self.GetInfo('pepper_interface')
     if not interface.GetName():
       return self.IsCoreGLFunction()
     return ext == interface.GetName()
@@ skipping 121 matching lines @@
     """Writes the handler implementation for this command."""
     self.type_handler.WriteHandlerImplementation(self, file)
 
   def WriteValidationCode(self, file):
     """Writes the validation code for a command."""
     pass
 
   def WriteCmdFlag(self, file):
     """Writes the cmd cmd_flags constant."""
     flags = []
-    trace_level = 3  # By default trace only at the highest level
-    if hasattr(self.info, 'trace_level'):
-      if (self.info.trace_level < 0) or (self.info.trace_level > 3):
-        raise KeyError("Unhandled trace_level: %d" % self.info.trace_level)
-      trace_level = self.info.trace_level
+    # By default trace only at the highest level 3.
+    trace_level = int(self.GetInfo('trace_level', default = 3))
+    if trace_level not in xrange(0, 4):
+      raise KeyError("Unhandled trace_level: %d" % trace_level)
 
     flags.append('CMD_FLAG_SET_TRACE_LEVEL(%d)' % trace_level)
 
     if len(flags) > 0:
       cmd_flags = ' | '.join(flags)
     else:
       cmd_flags = 0
 
     file.Write("  static const uint8 cmd_flags = %s;\n" % cmd_flags)
 
@@ skipping 133 matching lines @@
     dev = ""
     if self.dev:
       dev = "_Dev"
     return "PPB_OpenGLES2%s%s" % (self.name, dev)
 
 
 class ImmediateFunction(Function):
   """A class that represnets an immediate function command."""
 
   def __init__(self, func):
-    new_args = []
-    for arg in func.GetOriginalArgs():
+    Function.__init__(
+        self,
+        "%sImmediate" % func.name,
+        func.info)
+
+  def InitFunction(self):
+    # Override args in original_args and args_for_cmds with immediate versions
+    # of the args.
+
+    new_original_args = []
+    for arg in self.original_args:
       new_arg = arg.GetImmediateVersion()
       if new_arg:
-        new_args.append(new_arg)
+        new_original_args.append(new_arg)
+    self.original_args = new_original_args
 
-    cmd_args = []
     new_args_for_cmds = []
-    for arg in func.args_for_cmds:
+    for arg in self.args_for_cmds:
       new_arg = arg.GetImmediateVersion()
       if new_arg:
         new_args_for_cmds.append(new_arg)
-        new_arg.AddCmdArgs(cmd_args)
 
-    new_init_args = []
-    for arg in new_args_for_cmds:
-      arg.AddInitArgs(new_init_args)
+    self.args_for_cmds = new_args_for_cmds
 
-    Function.__init__(
-        self,
-        func.original_name,
-        "%sImmediate" % func.name,
-        func.info,
-        func.return_type,
-        new_args,
-        new_args_for_cmds,
-        cmd_args,
-        new_init_args,
-        0)
-    self.is_immediate = True
+    Function.InitFunction(self)
+
+  def IsImmediate(self):
+    return True
 
   def WriteCommandDescription(self, file):
     """Overridden from Function"""
     file.Write("//! Immediate version of command that corresponds to gl%s.\n" %
         self.original_name)
 
   def WriteServiceImplementation(self, file):
     """Overridden from Function"""
     self.type_handler.WriteImmediateServiceImplementation(self, file)
 
@@ skipping 35 matching lines @@
 
   def WriteFormatTest(self, file):
     """Overridden from Function"""
     self.type_handler.WriteImmediateFormatTest(self, file)
 
 
 class BucketFunction(Function):
   """A class that represnets a bucket version of a function command."""
 
   def __init__(self, func):
-    new_args = []
-    for arg in func.GetOriginalArgs():
+    Function.__init__(
+      self,
+      "%sBucket" % func.name,
+      func.info)
+
+  def InitFunction(self):
+    # Override args in original_args and args_for_cmds with bucket versions
+    # of the args.
+
+    new_original_args = []
+    for arg in self.original_args:
       new_arg = arg.GetBucketVersion()
       if new_arg:
-        new_args.append(new_arg)
+        new_original_args.append(new_arg)
+    self.original_args = new_original_args
 
-    cmd_args = []
     new_args_for_cmds = []
-    for arg in func.args_for_cmds:
+    for arg in self.args_for_cmds:
       new_arg = arg.GetBucketVersion()
       if new_arg:
         new_args_for_cmds.append(new_arg)
-        new_arg.AddCmdArgs(cmd_args)
 
-    new_init_args = []
-    for arg in new_args_for_cmds:
-      arg.AddInitArgs(new_init_args)
+    self.args_for_cmds = new_args_for_cmds
 
-    Function.__init__(
-        self,
-        func.original_name,
-        "%sBucket" % func.name,
-        func.info,
-        func.return_type,
-        new_args,
-        new_args_for_cmds,
-        cmd_args,
-        new_init_args,
-        0)
-
-#  def InitFunction(self):
-#    """Overridden from Function"""
-#    pass
+    Function.InitFunction(self)
 
   def WriteCommandDescription(self, file):
     """Overridden from Function"""
     file.Write("//! Bucket version of command that corresponds to gl%s.\n" %
         self.original_name)
 
   def WriteServiceImplementation(self, file):
     """Overridden from Function"""
     self.type_handler.WriteBucketServiceImplementation(self, file)
 
@@ skipping 53 matching lines @@
 class GLGenerator(object):
   """A class to generate GL command buffers."""
 
   _function_re = re.compile(r'GL_APICALL(.*?)GL_APIENTRY (.*?) \((.*?)\);')
 
   def __init__(self, verbose):
     self.original_functions = []
     self.functions = []
     self.verbose = verbose
     self.errors = 0
-    self._function_info = {}
-    self._empty_type_handler = TypeHandler()
-    self._empty_function_info = FunctionInfo({}, self._empty_type_handler)
     self.pepper_interfaces = []
     self.interface_info = {}
 
-    self._type_handlers = {
-      'Bind': BindHandler(),
-      'Create': CreateHandler(),
-      'Custom': CustomHandler(),
-      'Data': DataHandler(),
-      'Delete': DeleteHandler(),
-      'DELn': DELnHandler(),
-      'GENn': GENnHandler(),
-      'GETn': GETnHandler(),
-      'GLchar': GLcharHandler(),
-      'GLcharN': GLcharNHandler(),
-      'HandWritten': HandWrittenHandler(),
-      'Is': IsHandler(),
-      'Manual': ManualHandler(),
-      'PUT': PUTHandler(),
-      'PUTn': PUTnHandler(),
-      'PUTXn': PUTXnHandler(),
-      'StateSet': StateSetHandler(),
-      'StateSetRGBAlpha': StateSetRGBAlphaHandler(),
-      'StateSetFrontBack': StateSetFrontBackHandler(),
-      'StateSetFrontBackSeparate': StateSetFrontBackSeparateHandler(),
-      'StateSetNamedParameter': StateSetNamedParameter(),
-      'STRn': STRnHandler(),
-      'Todo': TodoHandler(),
-    }
-
-    for func_name in _FUNCTION_INFO:
-      info = _FUNCTION_INFO[func_name]
-      type = ''
-      if 'type' in info:
-        type = info['type']
-      self._function_info[func_name] = FunctionInfo(info,
-                                                    self.GetTypeHandler(type))
     for interface in _PEPPER_INTERFACES:
       interface = PepperInterface(interface)
       self.pepper_interfaces.append(interface)
       self.interface_info[interface.GetName()] = interface
 
   def AddFunction(self, func):
     """Adds a function."""
     self.functions.append(func)
 
-  def GetTypeHandler(self, name):
-    """Gets a type info for the given type."""
-    if len(name):
-      if name in self._type_handlers:
-        return self._type_handlers[name]
-      else:
-        raise KeyError("no such type handler: %s" % name)
-    return self._empty_type_handler
-
   def GetFunctionInfo(self, name):
     """Gets a type info for the given function name."""
-    if name in self._function_info:
-      return self._function_info[name]
-    return self._empty_function_info
+    if name in _FUNCTION_INFO:
+      func_info = _FUNCTION_INFO[name].copy()
+    else:
+      func_info = {}
+
+    if not 'type' in func_info:
+      func_info['type'] = ''
+
+    return func_info
 
   def Log(self, msg):
     """Prints something if verbose is true."""
     if self.verbose:
       print msg
 
   def Error(self, msg):
     """Prints an error."""
     print "Error: %s" % msg
     self.errors += 1
 
   def WriteLicense(self, file):
     """Writes the license."""
     file.Write(_LICENSE)
 
   def WriteNamespaceOpen(self, file):
     """Writes the code for the namespace."""
     file.Write("namespace gpu {\n")
     file.Write("namespace gles2 {\n")
     file.Write("\n")
 
   def WriteNamespaceClose(self, file):
     """Writes the code to close the namespace."""
     file.Write("}  // namespace gles2\n")
     file.Write("}  // namespace gpu\n")
     file.Write("\n")
 
-  def ParseArgs(self, arg_string):
-    """Parses a function arg string."""
-    args = []
-    num_pointer_args = 0
-    parts = arg_string.split(',')
-    is_gl_enum = False
-    for arg_string in parts:
-      if arg_string.startswith('GLenum '):
-        is_gl_enum = True
-      arg = CreateArg(arg_string)
-      if arg:
-        args.append(arg)
-        if arg.IsPointer():
-          num_pointer_args += 1
-    return (args, num_pointer_args, is_gl_enum)
-
   def ParseGLH(self, filename):
     """Parses the cmd_buffer_functions.txt file and extracts the functions"""
     f = open(filename, "r")
     functions = f.read()
     f.close()
     for line in functions.splitlines():
       match = self._function_re.match(line)
       if match:
         func_name = match.group(2)[2:]
         func_info = self.GetFunctionInfo(func_name)
-        if func_info.type != 'Noop':
-          return_type = match.group(1).strip()
-          arg_string = match.group(3)
-          (args, num_pointer_args, is_gl_enum) = self.ParseArgs(arg_string)
-          # comment in to find out which functions use bare enums.
-          # if is_gl_enum:
-          #   self.Log("%s uses bare GLenum" % func_name)
-          args_for_cmds = args
-          if hasattr(func_info, 'cmd_args'):
-            (args_for_cmds, num_pointer_args, is_gl_enum) = (
-                self.ParseArgs(getattr(func_info, 'cmd_args')))
-          cmd_args = []
-          for arg in args_for_cmds:
-            arg.AddCmdArgs(cmd_args)
-          init_args = []
-          for arg in args_for_cmds:
-            arg.AddInitArgs(init_args)
-          return_arg = CreateArg(return_type + " result")
-          if return_arg:
-            init_args.append(return_arg)
-          f = Function(func_name, func_name, func_info, return_type, args,
-                       args_for_cmds, cmd_args, init_args, num_pointer_args)
-          self.original_functions.append(f)
-          gen_cmd = f.GetInfo('gen_cmd')
-          if gen_cmd == True or gen_cmd == None:
-            self.AddFunction(f)
-            f.type_handler.AddImmediateFunction(self, f)
-            f.type_handler.AddBucketFunction(self, f)
+        if func_info['type'] == 'Noop':
+          continue
+
+        parsed_func_info = {
+          'original_name': func_name,
+          'original_args': match.group(3),
+          'return_type': match.group(1).strip(),
+        }
+
+        for k in parsed_func_info.keys():
+          if not k in func_info:
+            func_info[k] = parsed_func_info[k]
+
+        f = Function(func_name, func_info)
+        self.original_functions.append(f)
+
+        #for arg in f.GetOriginalArgs():
+        #  if not isinstance(arg, EnumArgument) and arg.type == 'GLenum':
+        #    self.Log("%s uses bare GLenum %s." % (func_name, arg.name))
+
+        gen_cmd = f.GetInfo('gen_cmd')
+        if gen_cmd == True or gen_cmd == None:
+          self.AddFunction(f)
+          f.type_handler.AddImmediateFunction(self, f)
+          f.type_handler.AddBucketFunction(self, f)
 
     self.Log("Auto Generated Functions    : %d" %
              len([f for f in self.functions if f.can_auto_generate or
                   (not f.IsType('') and not f.IsType('Custom') and
                    not f.IsType('Todo'))]))
 
     funcs = [f for f in self.functions if not f.can_auto_generate and
              (f.IsType('') or f.IsType('Custom') or f.IsType('Todo'))]
     self.Log("Non Auto Generated Functions: %d" % len(funcs))
 
     for f in funcs:
-      self.Log("  %-10s %-20s gl%s" % (f.info.type, f.return_type, f.name))
+      self.Log("  %-10s %-20s gl%s" % (f.info['type'], f.return_type, f.name))
 
   def WriteCommandIds(self, filename):
     """Writes the command buffer format"""
     file = CHeaderWriter(filename)
     file.Write("#define GLES2_COMMAND_LIST(OP) \\\n")
     id = 256
     for func in self.functions:
       file.Write("  %-60s /* %d */ \\\n" %
                  ("OP(%s)" % func.name, id))
       id += 1
@@ skipping 994 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:]))