Merged in recent changes to command buffer code.

gpu/command_buffer/build_gles2_cmd_buffer.py

 #!/usr/bin/python
 #
 # Copyright (c) 2006-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.
 
 """code generator for GL command buffers."""
 
 import os
 import os.path
@@ skipping 77 matching lines @@
 GL_APICALL void         GL_APIENTRY glFramebufferTexture2D (GLenum target, GLenum attachment, GLenum textarget, GLResourceId texture, GLint level);
 GL_APICALL void         GL_APIENTRY glFrontFace (GLenum mode);
 GL_APICALL void         GL_APIENTRY glGenBuffers (GLsizei n, GLuint* buffers);
 GL_APICALL void         GL_APIENTRY glGenerateMipmap (GLenum target);
 GL_APICALL void         GL_APIENTRY glGenFramebuffers (GLsizei n, GLuint* framebuffers);
 GL_APICALL void         GL_APIENTRY glGenRenderbuffers (GLsizei n, GLuint* renderbuffers);
 GL_APICALL void         GL_APIENTRY glGenTextures (GLsizei n, GLuint* textures);
 GL_APICALL void         GL_APIENTRY glGetActiveAttrib (GLResourceId program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name);
 GL_APICALL void         GL_APIENTRY glGetActiveUniform (GLResourceId program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name);
 GL_APICALL void         GL_APIENTRY glGetAttachedShaders (GLResourceId program, GLsizei maxcount, GLsizei* count, GLuint* shaders);
-GL_APICALL int          GL_APIENTRY glGetAttribLocation (GLResourceId program, const char* name);
+GL_APICALL GLint        GL_APIENTRY glGetAttribLocation (GLResourceId program, const char* name);
 GL_APICALL void         GL_APIENTRY glGetBooleanv (GLenum pname, GLboolean* params);
 GL_APICALL void         GL_APIENTRY glGetBufferParameteriv (GLenum target, GLenum pname, GLint* params);
 GL_APICALL GLenum       GL_APIENTRY glGetError (void);
 GL_APICALL void         GL_APIENTRY glGetFloatv (GLenum pname, GLfloat* params);
 GL_APICALL void         GL_APIENTRY glGetFramebufferAttachmentParameteriv (GLenum target, GLenum attachment, GLenum pname, GLint* params);
 GL_APICALL void         GL_APIENTRY glGetIntegerv (GLenum pname, GLint* params);
 GL_APICALL void         GL_APIENTRY glGetProgramiv (GLResourceId program, GLenum pname, GLint* params);
 GL_APICALL void         GL_APIENTRY glGetProgramInfoLog (GLResourceId program, GLsizei bufsize, GLsizei* length, char* infolog);
 GL_APICALL void         GL_APIENTRY glGetRenderbufferParameteriv (GLenum target, GLenum pname, GLint* params);
 GL_APICALL void         GL_APIENTRY glGetShaderiv (GLResourceId shader, GLenum pname, GLint* params);
 GL_APICALL void         GL_APIENTRY glGetShaderInfoLog (GLResourceId shader, GLsizei bufsize, GLsizei* length, char* infolog);
 GL_APICALL void         GL_APIENTRY glGetShaderPrecisionFormat (GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision);
 GL_APICALL void         GL_APIENTRY glGetShaderSource (GLResourceId shader, GLsizei bufsize, GLsizei* length, char* source);
 GL_APICALL const GLubyte* GL_APIENTRY glGetString (GLenum name);
 GL_APICALL void         GL_APIENTRY glGetTexParameterfv (GLenum target, GLenum pname, GLfloat* params);
 GL_APICALL void         GL_APIENTRY glGetTexParameteriv (GLenum target, GLenum pname, GLint* params);
 GL_APICALL void         GL_APIENTRY glGetUniformfv (GLResourceId program, GLint location, GLfloat* params);
 GL_APICALL void         GL_APIENTRY glGetUniformiv (GLResourceId program, GLint location, GLint* params);
-GL_APICALL int          GL_APIENTRY glGetUniformLocation (GLResourceId program, const char* name);
+GL_APICALL GLint        GL_APIENTRY glGetUniformLocation (GLResourceId program, const char* name);
 GL_APICALL void         GL_APIENTRY glGetVertexAttribfv (GLuint index, GLenum pname, GLfloat* params);
 GL_APICALL void         GL_APIENTRY glGetVertexAttribiv (GLuint index, GLenum pname, GLint* params);
 GL_APICALL void         GL_APIENTRY glGetVertexAttribPointerv (GLuint index, GLenum pname, void** pointer);
 GL_APICALL void         GL_APIENTRY glHint (GLenum target, GLenum mode);
 GL_APICALL GLboolean    GL_APIENTRY glIsBuffer (GLResourceId buffer);
 GL_APICALL GLboolean    GL_APIENTRY glIsEnabled (GLenum cap);
 GL_APICALL GLboolean    GL_APIENTRY glIsFramebuffer (GLResourceId framebuffer);
 GL_APICALL GLboolean    GL_APIENTRY glIsProgram (GLResourceId program);
 GL_APICALL GLboolean    GL_APIENTRY glIsRenderbuffer (GLResourceId renderbuffer);
 GL_APICALL GLboolean    GL_APIENTRY glIsShader (GLResourceId shader);
@@ skipping 58 matching lines @@
 
 # This table specifies types and other special data for the commands that
 # will be generated.
 #
 # type:        defines which handler will be used to generate code.
 # DecoderFunc: defines which function to call in the decoder to execute the
 #              corresponding GL command. If not specified the GL command will
 #              be called directly.
 # cmd_args:    The arguments to use for the command. This overrides generating
 #              them based on the GL function arguments.
+#              a NonImmediate type is a type that stays a pointer even in
+#              and immediate version of acommand.
 # immediate:   Whether or not to generate an immediate command for the GL
 #              function. The default is if there is exactly 1 pointer argument
 #              in the GL function an immediate command is generated.
 # needs_size:  If true a data_size field is added to the command.
 # data_type:   The type of data the command uses. For PUTn or PUT types.
 # count:       The number of units per element. For PUTn or PUT types.
 
 _FUNCTION_INFO = {
   'BindAttribLocation': {'type': 'GLchar'},
   'BindBuffer': {'DecoderFunc': 'DoBindBuffer'},
   'BindFramebuffer': {'DecoderFunc': 'glBindFramebufferEXT'},
   'BindRenderbuffer': {'DecoderFunc': 'glBindRenderbufferEXT'},
-  'BufferData': {'type': 'Data'},
+  'BufferData': {'type': 'Manual', 'immediate': True,},
   'BufferSubData': {'type': 'Data'},
   'CheckFramebufferStatus': {'DecoderFunc': 'glCheckFramebufferStatusEXT'},
   'ClearDepthf': {'DecoderFunc': 'glClearDepth'},
-  'CompressedTexImage2D': {'type': 'Data'},
+  'CompressedTexImage2D': {'type': 'Manual', 'immediate': True,},
   'CompressedTexSubImage2D': {'type': 'Data'},
   'CreateProgram': {'type': 'Create'},
   'CreateShader': {'type': 'Create'},
   'DeleteBuffers': {'type': 'DELn'},
   'DeleteFramebuffers': {'type': 'DELn'},
   'DeleteProgram': {'DecoderFunc': 'DoDeleteProgram'},
   'DeleteRenderbuffers': {'type': 'DELn'},
   'DeleteShader': {'DecoderFunc': 'DoDeleteShader'},
   'DeleteTextures': {'type': 'DELn'},
   'DepthRangef': {'DecoderFunc': 'glDepthRange'},
   'DrawElements': {
     'type': 'Manual',
     'cmd_args': 'GLenum mode, GLsizei count, GLenum type, GLuint index_offset',
   },
   'FramebufferRenderbuffer': {'DecoderFunc': 'glFramebufferRenderbufferEXT'},
   'FramebufferTexture2D': {'DecoderFunc': 'glFramebufferTexture2DEXT'},
   'GenerateMipmap': {'DecoderFunc': 'glGenerateMipmapEXT'},
   'GenBuffers': {'type': 'GENn'},
   'GenFramebuffers': {'type': 'GENn'},
   'GenRenderbuffers': {'type': 'GENn'},
   'GenTextures': {'type': 'GENn'},
   'GetActiveAttrib': {'type': 'Custom'},
   'GetActiveUniform': {'type': 'Custom'},
   'GetAttachedShaders': {'type': 'Custom'},
-  'GetAttribLocation': {'type': 'GetGLchar'},
+  'GetAttribLocation': {
+    'type': 'HandWritten',
+    'immediate': True,
+    'needs_size': True,
+    'cmd_args':
+        'GLResourceId program, const char* name, NonImmediate GLint* location',
+  },
   'GetBooleanv': {'type': 'GETn'},
   'GetBufferParameteriv': {'type': 'GETn'},
-  'GetError': {'type': 'Is'},
+  'GetError': {'type': 'Is', 'DecoderFunc': 'GetGLError'},
   'GetFloatv': {'type': 'GETn'},
   'GetFramebufferAttachmentParameteriv': {
     'type': 'GETn',
     'DecoderFunc': 'glGetFramebufferAttachmentParameterivEXT',
   },
   'GetIntegerv': {'type': 'GETn'},
   'GetProgramiv': {'type': 'GETn'},
   'GetProgramInfoLog': {'type': 'STRn'},
   'GetRenderbufferParameteriv': {
     'type': 'GETn',
     'DecoderFunc': 'glGetRenderbufferParameterivEXT',
   },
   'GetShaderiv': {'type': 'GETn'},
   'GetShaderInfoLog': {'type': 'STRn'},
   'GetShaderPrecisionFormat': {'type': 'Custom'},
   'GetShaderSource': {'type': 'STRn'},
   'GetTexParameterfv': {'type': 'GETn'},
   'GetTexParameteriv': {'type': 'GETn'},
   'GetUniformfv': {'type': 'Custom', 'immediate': False},
   'GetUniformiv': {'type': 'Custom', 'immediate': False},
-  'GetUniformLocation': {'type': 'GetGLchar'},
+  'GetUniformLocation': {
+    'type': 'HandWritten',
+    'immediate': True,
+    'needs_size': True,
+    'cmd_args':
+        'GLResourceId program, const char* name, NonImmediate GLint* location',
+  },
   'GetVertexAttribfv': {'type': 'GETn'},
   'GetVertexAttribiv': {'type': 'GETn'},
   'GetVertexAttribPointerv': {'type': 'Custom', 'immediate': False},
   'IsBuffer': {'type': 'Is'},
   'IsEnabled': {'type': 'Is'},
   'IsFramebuffer': {'type': 'Is', 'DecoderFunc': 'glIsFramebufferEXT'},
   'IsProgram': {'type': 'Is'},
   'IsRenderbuffer': {'type': 'Is', 'DecoderFunc': 'glIsRenderbufferEXT'},
   'IsShader': {'type': 'Is'},
   'IsTexture': {'type': 'Is'},
-  'PixelStorei': {'type': 'Custom'},
+  'PixelStorei': {'type': 'Manual'},
   'RenderbufferStorage': {'DecoderFunc': 'glRenderbufferStorageEXT'},
   'ReadPixels': {'type': 'Custom', 'immediate': False},
   'ReleaseShaderCompiler': {'type': 'Noop'},
   'ShaderBinary': {'type': 'Noop'},
   'ShaderSource': {
     'type': 'Manual',
     'immediate': True,
     'needs_size': True,
     'cmd_args':
         'GLuint shader, GLsizei count, const char* data',
   },
-  'TexImage2D': {'type': 'Data'},
+  'TexImage2D': {'type': 'Manual', 'immediate': True},
   'TexParameterfv': {'type': 'PUT', 'data_type': 'GLfloat', 'count': 1},
   'TexParameteriv': {'type': 'PUT', 'data_type': 'GLint', 'count': 1},
   'TexSubImage2D': {'type': 'Data'},
   'Uniform1fv': {'type': 'PUTn', 'data_type': 'GLfloat', 'count': 1},
   'Uniform1iv': {'type': 'PUTn', 'data_type': 'GLint', 'count': 1},
   'Uniform2fv': {'type': 'PUTn', 'data_type': 'GLfloat', 'count': 2},
   'Uniform2iv': {'type': 'PUTn', 'data_type': 'GLint', 'count': 2},
   'Uniform3fv': {'type': 'PUTn', 'data_type': 'GLfloat', 'count': 3},
   'Uniform3iv': {'type': 'PUTn', 'data_type': 'GLint', 'count': 3},
   'Uniform4fv': {'type': 'PUTn', 'data_type': 'GLfloat', 'count': 4},
@@ skipping 79 matching lines @@
 
 class TypeHandler(object):
   """This class emits code for a particular type of function."""
 
   def __init__(self):
     pass
 
   def InitFunction(self, func):
     """Add or adjust anything type specific for this function."""
     if func.GetInfo('needs_size'):
-      func.AddCmdArg(CmdArg('data_size', 'uint32'))
+      func.AddCmdArg(Argument('data_size', 'uint32'))
 
   def AddImmediateFunction(self, generator, func):
     """Adds an immediate version of a function."""
     # Generate an immediate command if there is only 1 pointer arg.
     immediate = func.GetInfo('immediate')  # can be True, False or None
     if immediate == True or immediate == None:
       if func.num_pointer_args == 1 or immediate:
         generator.AddFunction(ImmediateFunction(func))
 
+  def WriteStruct(self, func, file):
+    """Writes a structure that matches the arguments to a function."""
+    file.Write("struct %s {\n" % func.name)
+    file.Write("  typedef %s ValueType;\n" % func.name)
+    file.Write("  static const CommandId kCmdId = k%s;\n" % func.name)
+    func.WriteCmdArgFlag(file)
+    file.Write("\n")
+
+    func.WriteCmdComputeSize(file)
+    func.WriteCmdSetHeader(file)
+    func.WriteCmdInit(file)
+    func.WriteCmdSet(file)
+
+    file.Write("  command_buffer::CommandHeader header;\n")
+    args = func.GetCmdArgs()
+    for arg in args:
+      file.Write("  %s %s;\n" % (arg.cmd_type, arg.name))
+    file.Write("};\n")
+    file.Write("\n")
+
+    size = len(args) * _SIZE_OF_UINT32 + _SIZE_OF_COMMAND_HEADER
+    file.Write("COMPILE_ASSERT(sizeof(%s) == %d,\n" % (func.name, size))
+    file.Write("               Sizeof_%s_is_not_%d);\n" % (func.name, size))
+    file.Write("COMPILE_ASSERT(offsetof(%s, header) == 0,\n" % func.name)
+    file.Write("               OffsetOf_%s_header_not_0);\n" % func.name)
+    offset = _SIZE_OF_COMMAND_HEADER
+    for arg in args:
+      file.Write("COMPILE_ASSERT(offsetof(%s, %s) == %d,\n" %
+                 (func.name, arg.name, offset))
+      file.Write("               OffsetOf_%s_%s_not_%d);\n" %
+                 (func.name, arg.name, offset))
+      offset += _SIZE_OF_UINT32
+    file.Write("\n")
+
   def WriteHandlerImplementation(self, func, file):
     """Writes the handler implementation for this command."""
     file.Write("  parse_error::ParseError result =\n")
-    file.Write("      Validate%s(this, arg_count%s);\n" %
+    file.Write("      Validate%s(this, immediate_data_size%s);\n" %
                (func.name, func.MakeOriginalArgString("", True)))
     file.Write("  if (result != parse_error::kParseNoError) {\n")
     file.Write("    return result;\n")
     file.Write("  }\n")
     file.Write("  %s(%s);\n" %
                (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
 
   def WriteCmdSizeTest(self, func, file):
     """Writes the size test for a command."""
     file.Write("  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4);  // NOLINT\n")
@@ skipping 46 matching lines @@
 
   def WriteImmediateCmdSizeTest(self, func, file):
     """Writes a size test for an immediate version of a command."""
     file.Write("  // TODO(gman): Compute correct size.\n")
     file.Write("  EXPECT_EQ(sizeof(cmd), cmd.header.size * 4);\n")
 
   def WriteImmediateHandlerImplementation (self, func, file):
     """Writes the handler impl for the immediate version of a command."""
     file.Write("  // Immediate version.\n")
     file.Write("  parse_error::ParseError result =\n")
-    file.Write("      Validate%s(this, arg_count%s);\n" %
+    file.Write("      Validate%s(this, immediate_data_size%s);\n" %
                (func.name, func.MakeOriginalArgString("", True)))
     file.Write("  if (result != parse_error::kParseNoError) {\n")
     file.Write("    return result;\n")
     file.Write("  }\n")
     file.Write("  %s(%s);\n" %
                (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
 
   def WriteServiceImplementation(self, func, file):
     """Writes the service implementation for a command."""
     file.Write(
         "parse_error::ParseError GLES2DecoderImpl::Handle%s(\n" % func.name)
     file.Write(
-        "    unsigned int arg_count, const gles2::%s& c) {\n" % func.name)
+        "    uint32 immediate_data_size, const gles2::%s& c) {\n" % func.name)
     for arg in func.GetOriginalArgs():
       arg.WriteGetCode(file)
     func.WriteHandlerImplementation(file)
     file.Write("  return parse_error::kParseNoError;\n")
     file.Write("}\n")
     file.Write("\n")
 
   def WriteImmediateServiceImplementation(self, func, file):
     """Writes the service implementation for an immediate version of command."""
     file.Write(
         "parse_error::ParseError GLES2DecoderImpl::Handle%s(\n" % func.name)
     file.Write(
-        "    unsigned int arg_count, const gles2::%s& c) {\n" % func.name)
+        "    uint32 immediate_data_size, const gles2::%s& c) {\n" % func.name)
     for arg in func.GetOriginalArgs():
       arg.WriteGetCode(file)
     func.WriteHandlerImplementation(file)
     file.Write("  return parse_error::kParseNoError;\n")
     file.Write("}\n")
     file.Write("\n")
 
   def WriteImmediateValidationCode(self, func, file):
     """Writes the validation code for an immediate version of a command."""
     pass
@@ skipping 57 matching lines @@
     file.Write("  void* Set(void* cmd%s) {\n" %
                func.MakeTypedCmdArgString("_", True))
     file.Write("    // TODO(gman): compute correct size.\n")
     file.Write("    const uint32 size = ComputeSize(0);\n")
     file.Write("    static_cast<ValueType*>(cmd)->Init(%s);\n" % copy_args)
     file.Write("    return NextImmediateCmdAddressTotalSize<ValueType>("
                "cmd, size);\n")
     file.Write("  }\n")
     file.Write("\n")
 
+  def WriteCmdHelper(self, func, file):
+    """Writes the cmd helper definition for a cmd."""
+    args = func.MakeCmdArgString("")
+    file.Write("  void %s(%s) {\n" %
+               (func.name, func.MakeTypedCmdArgString("")))
+    file.Write("    gles2::%s& c = GetCmdSpace<gles2::%s>();\n" %
+               (func.name, func.name))
+    file.Write("    c.Init(%s);\n" % args)
+    file.Write("  }\n\n")
+
   def WriteImmediateCmdHelper(self, func, file):
     """Writes the cmd helper definition for the immediate version of a cmd."""
     args = func.MakeCmdArgString("")
     file.Write("  void %s(%s) {\n" %
                (func.name, func.MakeTypedCmdArgString("")))
     file.Write("    const uint32 s = 0;  // TODO(gman): compute correct size\n")
     file.Write("    gles2::%s& c = "
                "GetImmediateCmdSpaceTotalSize<gles2::%s>(s);\n" %
                (func.name, func.name))
     file.Write("    c.Init(%s);\n" % args)
     file.Write("  }\n\n")
 
 
 class CustomHandler(TypeHandler):
   """Handler for commands that are auto-generated but require minor tweaks."""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
   def WriteServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     pass
 
   def WriteImmediateCmdGetTotalSize(self, func, file):
     """Overrriden from TypeHandler."""
-    file.Write("    uint32 total_size = 0;  // TODO(gman): get correct size.")
+    file.Write("    uint32 total_size = 0;  // TODO(gman): get correct size.\n")
 
   def WriteImmediateCmdInit(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("  void Init(%s) {\n" % func.MakeTypedCmdArgString("_"))
     self.WriteImmediateCmdGetTotalSize(func, file)
     file.Write("    SetHeader(total_size);\n")
     args = func.GetCmdArgs()
     for arg in args:
       file.Write("    %s = _%s;\n" % (arg.name, arg.name))
     file.Write("  }\n")
@@ skipping 13 matching lines @@
 
 
 class TodoHandler(CustomHandler):
   """Handle for commands that are not yet implemented."""
 
   def WriteImmediateFormatTest(self, func, file):
     """Overrriden from TypeHandler."""
     pass
 
 
+class HandWrittenHandler(CustomHandler):
+  """Handler for comands where everything must be written by hand."""
+
+  def InitFunction(self, func):
+    """Add or adjust anything type specific for this function."""
+    CustomHandler.InitFunction(self, func)
+    func.can_auto_generate = False
+
+  def WriteStruct(self, func, file):
+    """Overrriden from TypeHandler."""
+    pass
+
+  def WriteServiceImplementation(self, func, file):
+    """Overrriden from TypeHandler."""
+    pass
+
+  def WriteImmediateServiceImplementation(self, func, file):
+    """Overrriden from TypeHandler."""
+    pass
+
+  def WriteGLES2ImplementationImpl(self, func, file):
+    """Overrriden from TypeHandler."""
+    pass
+
+  def WriteImmediateCmdHelper(self, func, file):
+    """Overrriden from TypeHandler."""
+    pass
+
+  def WriteCmdHelper(self, func, file):
+    """Overrriden from TypeHandler."""
+    pass
+
+  def WriteFormatTest(self, func, file):
+    """Overrriden from TypeHandler."""
+    file.Write("// TODO(gman): Write test for %s\n" % func.name)
+
+  def WriteImmediateFormatTest(self, func, file):
+    """Overrriden from TypeHandler."""
+    file.Write("// TODO(gman): Write test for %s\n" % func.name)
+
+
 class ManualHandler(CustomHandler):
-  """Handler for commands that must be written by hand."""
+  """Handler for commands who's handlers must be written by hand."""
 
   def __init__(self):
     CustomHandler.__init__(self)
 
   def WriteServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     pass
 
   def WriteImmediateServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
@@ skipping 27 matching lines @@
   """Handler for glBufferData, glBufferSubData, glTexImage2D, glTexSubImage2D,
      glCompressedTexImage2D, glCompressedTexImageSub2D."""
   def __init__(self):
     CustomHandler.__init__(self)
 
   def WriteServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write(
         "parse_error::ParseError GLES2DecoderImpl::Handle%s(\n" % func.name)
     file.Write(
-        "    unsigned int arg_count, const gles2::%s& c) {\n" % func.name)
+        "    uint32 immediate_data_size, const gles2::%s& c) {\n" % func.name)
     for arg in func.GetCmdArgs():
       arg.WriteGetCode(file)
 
     # TODO(gman): Move this data to _FUNCTION_INFO?
     if func.name == 'BufferData':
       file.Write("  uint32 data_size = size;\n")
     elif func.name == 'BufferSubData':
       file.Write("  uint32 data_size = size;\n")
     elif func.name == 'CompressedTexImage2D':
       file.Write("  uint32 data_size = imageSize;\n")
@@ skipping 69 matching lines @@
   def __init__(self):
     TypeHandler.__init__(self)
 
   def InitFunction(self, func):
     """Overrriden from TypeHandler."""
     pass
 
   def WriteHandlerImplementation (self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("  parse_error::ParseError result =\n")
-    file.Write("      Validate%s(this, arg_count%s);\n" %
+    file.Write("      Validate%s(this, immediate_data_size%s);\n" %
                (func.name, func.MakeOriginalArgString("", True)))
     file.Write("  if (result != parse_error::kParseNoError) {\n")
     file.Write("    return result;\n")
     file.Write("  }\n")
     file.Write("  GenGLObjects<GL%sHelper>(n, %s);\n" %
                (func.name, func.GetLastOriginalArg().name))
 
   def WriteImmediateHandlerImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("  parse_error::ParseError result =\n")
-    file.Write("      Validate%s(this, arg_count%s);\n" %
+    file.Write("      Validate%s(this, immediate_data_size%s);\n" %
                (func.name, func.MakeOriginalArgString("", True)))
     file.Write("  if (result != parse_error::kParseNoError) {\n")
     file.Write("    return result;\n")
     file.Write("  }\n")
     file.Write("  GenGLObjects<GL%sHelper>(n, %s);\n" %
                (func.original_name, func.GetLastOriginalArg().name))
 
   def WriteGLES2ImplementationHeader(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("%s %s(%s) {\n" %
@@ skipping 103 matching lines @@
 
 
 class CreateHandler(TypeHandler):
   """Handler for glCreate___ type functions."""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
   def InitFunction(self, func):
     """Overrriden from TypeHandler."""
-    func.AddCmdArg(CmdArg("client_id", 'uint32'))
+    func.AddCmdArg(Argument("client_id", 'uint32'))
 
   def WriteHandlerImplementation (self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("  uint32 client_id = c.client_id;\n")
     file.Write("  parse_error::ParseError result =\n")
-    file.Write("      Validate%s(this, arg_count%s);\n" %
+    file.Write("      Validate%s(this, immediate_data_size%s);\n" %
                (func.name, func.MakeOriginalArgString("", True)))
     file.Write("  if (result != parse_error::kParseNoError) {\n")
     file.Write("    return result;\n")
     file.Write("  }\n")
     file.Write("  %sHelper(%s);\n" %
                (func.name, func.MakeCmdArgString("")))
 
   def WriteGLES2ImplementationHeader(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("%s %s(%s) {\n" %
@@ skipping 14 matching lines @@
 
 class DELnHandler(TypeHandler):
   """Handler for glDelete___ type functions."""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
   def WriteHandlerImplementation (self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("  parse_error::ParseError result =\n")
-    file.Write("      Validate%s(this, arg_count%s);\n" %
+    file.Write("      Validate%s(this, immediate_data_size%s);\n" %
                (func.name, func.MakeOriginalArgString("", True)))
     file.Write("  if (result != parse_error::kParseNoError) {\n")
     file.Write("    return result;\n")
     file.Write("  }\n")
     file.Write("  DeleteGLObjects<GL%sHelper>(n, %s);\n" %
                (func.name, func.GetLastOriginalArg().name))
 
   def WriteImmediateHandlerImplementation (self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("  parse_error::ParseError result =\n")
-    file.Write("      Validate%s(this, arg_count%s);\n" %
+    file.Write("      Validate%s(this, immediate_data_size%s);\n" %
                (func.name, func.MakeOriginalArgString("", True)))
     file.Write("  if (result != parse_error::kParseNoError) {\n")
     file.Write("    return result;\n")
     file.Write("  }\n")
     file.Write("  DeleteGLObjects<GL%sHelper>(n, %s);\n" %
                (func.original_name, func.GetLastOriginalArg().name))
 
   def WriteGLES2ImplementationHeader(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("%s %s(%s) {\n" %
@@ skipping 110 matching lines @@
 
   def AddImmediateFunction(self, generator, func):
     """Overrriden from TypeHandler."""
     pass
 
   def WriteServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write(
         "parse_error::ParseError GLES2DecoderImpl::Handle%s(\n" % func.name)
     file.Write(
-        "    unsigned int arg_count, const gles2::%s& c) {\n" % func.name)
+        "    uint32 immediate_data_size, const gles2::%s& c) {\n" % func.name)
     last_arg = func.GetLastOriginalArg()
 
     all_but_last_args = func.GetOriginalArgs()[:-1]
     for arg in all_but_last_args:
       arg.WriteGetCode(file)
 
     file.Write("  %s params;\n" % last_arg.type)
     file.Write("  GLsizei num_values = util_.GLGetNumValuesReturned(pname);\n")
     file.Write("  uint32 params_size = num_values * sizeof(*params);\n")
     file.Write("  params = GetSharedMemoryAs<%s>(\n" % last_arg.type)
     file.Write("      c.params_shm_id, c.params_shm_offset, params_size);\n")
     func.WriteHandlerImplementation(file)
     file.Write("  return parse_error::kParseNoError;\n")
     file.Write("}\n")
     file.Write("\n")
 
   def WriteGLES2ImplementationHeader(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("%s %s(%s) {\n" %
                (func.return_type, func.original_name,
                 func.MakeTypedOriginalArgString("")))
     all_but_last_args = func.GetOriginalArgs()[:-1]
     arg_string = (
         ", ".join(["%s" % arg.name for arg in all_but_last_args]))
-    file.Write("  helper_->%s(%s, shared_memory_.GetId(), 0);\n" %
+    file.Write("  helper_->%s(%s, result_shm_id(), result_shm_offset());\n" %
                (func.name, arg_string))
-    file.Write("  int32 token = helper_->InsertToken();\n")
-    file.Write("  helper_->WaitForToken(token);\n")
+    file.Write("  WaitForCmd();\n")
     file.Write("  GLsizei num_values = util_.GLGetNumValuesReturned(pname);\n")
-    file.Write("  memcpy(params, shared_memory_.GetAddress(0),\n")
-    file.Write("         num_values * sizeof(*params));\n")
+    file.Write(
+        "  DCHECK_LE(num_values * sizeof(*params), kMaxSizeOfSimpleResult);\n")
+    file.Write(
+        "  memcpy(params, result_buffer_, num_values * sizeof(*params));\n")
     file.Write("}\n")
     file.Write("\n")
 
   def WriteGLES2ImplementationImpl(self, func, file):
     """Overrriden from TypeHandler."""
     pass
 
 
 class PUTHandler(TypeHandler):
   """Handler for glTexParameter_v, glVertexAttrib_v functions."""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
   def WriteImmediateValidationCode(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("  if (!CheckImmediateDataSize<%s>("
-               "arg_count, 1, sizeof(%s), %d)) {\n" %
+               "immediate_data_size, 1, sizeof(%s), %d)) {\n" %
                (func.name, func.info.data_type, func.info.count))
     file.Write("    return parse_error::kParseOutOfBounds;\n")
     file.Write("  }\n")
 
   def WriteGLES2ImplementationHeader(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("%s %s(%s) {\n" %
                (func.return_type, func.original_name,
                 func.MakeTypedOriginalArgString("")))
     file.Write("  helper_->%sImmediate(%s);\n" %
@@ skipping 108 matching lines @@
 
 class PUTnHandler(TypeHandler):
   """Handler for PUTn 'glUniform__v' type functions."""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
   def WriteImmediateValidationCode(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("  if (!CheckImmediateDataSize<%s>("
-               "arg_count, count, sizeof(%s), %d)) {\n" %
+               "immediate_data_size, count, sizeof(%s), %d)) {\n" %
                (func.name, func.info.data_type, func.info.count))
     file.Write("    return parse_error::kParseOutOfBounds;\n")
     file.Write("  }\n")
 
   def WriteGLES2ImplementationHeader(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("%s %s(%s) {\n" %
                (func.return_type, func.original_name,
                 func.MakeTypedOriginalArgString("")))
     file.Write("  helper_->%sImmediate(%s);\n" %
@@ skipping 107 matching lines @@
 
 
 class GLcharHandler(TypeHandler):
   """Handler for functions that pass a single string ."""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
   def InitFunction(self, func):
     """Overrriden from TypeHandler."""
-    func.AddCmdArg(CmdArg('data_size', 'uint32'))
+    func.AddCmdArg(Argument('data_size', 'uint32'))
 
   def WriteServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write(
         "parse_error::ParseError GLES2DecoderImpl::Handle%s(\n" % func.name)
     file.Write(
-        "    unsigned int arg_count, const gles2::%s& c) {\n" % func.name)
+        "    uint32 immediate_data_size, const gles2::%s& c) {\n" % func.name)
     last_arg = func.GetLastOriginalArg()
 
     all_but_last_arg = func.GetOriginalArgs()[:-1]
     for arg in all_but_last_arg:
       arg.WriteGetCode(file)
 
     file.Write("  uint32 name_size = c.data_size;\n")
     file.Write("  const char* name = GetSharedMemoryAs<%s>(\n" %
                last_arg.type)
     file.Write("      c.%s_shm_id, c.%s_shm_offset, name_size);\n" %
                (last_arg.name, last_arg.name))
     file.Write("  parse_error::ParseError result =\n")
-    file.Write("      Validate%s(this, arg_count%s);\n" %
+    file.Write("      Validate%s(this, immediate_data_size%s);\n" %
                (func.name, func.MakeOriginalArgString("", True)))
     file.Write("  if (result != parse_error::kParseNoError) {\n")
     file.Write("    return result;\n")
     file.Write("  }\n")
     arg_string = ", ".join(["%s" % arg.name for arg in all_but_last_arg])
     file.Write("  String name_str(name, name_size);\n")
     file.Write("  %s(%s, name_str.c_str());\n" %
                (func.GetGLFunctionName(), arg_string))
     file.Write("  return parse_error::kParseNoError;\n")
     file.Write("}\n")
     file.Write("\n")
 
   def WriteImmediateServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write(
         "parse_error::ParseError GLES2DecoderImpl::Handle%s(\n" % func.name)
     file.Write(
-        "    unsigned int arg_count, const gles2::%s& c) {\n" % func.name)
+        "    uint32 immediate_data_size, const gles2::%s& c) {\n" % func.name)
     last_arg = func.GetLastOriginalArg()
 
     all_but_last_arg = func.GetOriginalArgs()[:-1]
     for arg in all_but_last_arg:
       arg.WriteGetCode(file)
 
     file.Write("  uint32 name_size = c.data_size;\n")
     file.Write(
         "  const char* name = GetImmediateDataAs<const char*>(c);\n")
-    file.Write("  // TODO(gman): Make sure validate checks arg_count\n")
-    file.Write("  //     covers data_size.\n")
+    file.Write("  // TODO(gman): Make sure validate checks\n")
+    file.Write("  //     immediate_data_size covers data_size.\n")
     file.Write("  parse_error::ParseError result =\n")
-    file.Write("      Validate%s(this, arg_count%s);\n" %
+    file.Write("      Validate%s(this, immediate_data_size%s);\n" %
                (func.name, func.MakeOriginalArgString("", True)))
     file.Write("  if (result != parse_error::kParseNoError) {\n")
     file.Write("    return result;\n")
     file.Write("  }\n")
     arg_string = ", ".join(["%s" % arg.name for arg in all_but_last_arg])
     file.Write("  String name_str(name, name_size);\n")
     file.Write("  %s(%s, name_str.c_str());\n" %
               (func.GetGLFunctionName(), arg_string))
     file.Write("  return parse_error::kParseNoError;\n")
     file.Write("}\n")
@@ skipping 106 matching lines @@
   """Handler for glGetAttibLoc, glGetUniformLoc."""
 
   def __init__(self):
     GLcharHandler.__init__(self)
 
   def WriteServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write(
         "parse_error::ParseError GLES2DecoderImpl::Handle%s(\n" % func.name)
     file.Write(
-        "    unsigned int arg_count, const gles2::%s& c) {\n" % func.name)
+        "    uint32 immediate_data_size, const gles2::%s& c) {\n" % func.name)
     last_arg = func.GetLastOriginalArg()
 
-    all_but_last_arg = func.GetOriginalArgs()[:-1]
+    all_but_last_arg = func.GetOriginalArgs()
     for arg in all_but_last_arg:
       arg.WriteGetCode(file)
 
     file.Write("  uint32 name_size = c.data_size;\n")
     file.Write("  const char* name = GetSharedMemoryAs<%s>(\n" %
                last_arg.type)
     file.Write("      c.%s_shm_id, c.%s_shm_offset, name_size);\n" %
                (last_arg.name, last_arg.name))
+    file.Write("  GLint* location = GetSharedMemoryAs<GLint*>(\n")
+    file.Write(
+        "      c.location_shm_id, c.location_shm_offset, sizeof(*location));\n")
+    file.Write("  // TODO(gman): Validate location.\n")
     file.Write("  parse_error::ParseError result =\n")
-    file.Write("      Validate%s(this, arg_count%s);\n" %
+    file.Write("      Validate%s(this, immediate_data_size%s);\n" %
                (func.name, func.MakeOriginalArgString("", True)))
     file.Write("  if (result != parse_error::kParseNoError) {\n")
     file.Write("    return result;\n")
     file.Write("  }\n")
     arg_string = ", ".join(["%s" % arg.name for arg in all_but_last_arg])
     file.Write("  String name_str(name, name_size);\n")
-    file.Write("  GLint location = %s(%s, name_str.c_str());\n" %
+    file.Write("  *location = %s(%s, name_str.c_str());\n" %
                (func.GetGLFunctionName(), arg_string))
-    file.Write("  DCHECK(false);  // TODO: return result.\n")
     file.Write("  return parse_error::kParseNoError;\n")
     file.Write("}\n")
     file.Write("\n")
 
   def WriteImmediateServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write(
         "parse_error::ParseError GLES2DecoderImpl::Handle%s(\n" % func.name)
     file.Write(
-        "    unsigned int arg_count, const gles2::%s& c) {\n" % func.name)
+        "    uint32 immediate_data_size, const gles2::%s& c) {\n" % func.name)
     last_arg = func.GetLastOriginalArg()
 
     all_but_last_arg = func.GetOriginalArgs()[:-1]
     for arg in all_but_last_arg:
       arg.WriteGetCode(file)
 
     file.Write("  uint32 name_size = c.data_size;\n")
     file.Write(
         "  const char* name = GetImmediateDataAs<const char*>(c);\n")
-    file.Write("  // TODO(gman): Make sure validate checks arg_count\n")
-    file.Write("  //     covers data_size.\n")
+    file.Write("  // TODO(gman): Make sure validate checks\n")
+    file.Write("  //     immediate_data_size covers data_size.\n")
+    file.Write("  GLint* location = GetSharedMemoryAs<GLint*>(\n")
+    file.Write(
+        "      c.location_shm_id, c.location_shm_offset, sizeof(*location));\n")
+    file.Write("  // TODO(gman): Validate location.\n")
     file.Write("  parse_error::ParseError result =\n")
-    file.Write("      Validate%s(this, arg_count%s);\n" %
+    file.Write("      Validate%s(this, immediate_data_size%s);\n" %
                (func.name, func.MakeOriginalArgString("", True)))
     file.Write("  if (result != parse_error::kParseNoError) {\n")
     file.Write("    return result;\n")
     file.Write("  }\n")
     arg_string = ", ".join(["%s" % arg.name for arg in all_but_last_arg])
     file.Write("  String name_str(name, name_size);\n")
-    file.Write("  GLint location = %s(%s, name_str.c_str());\n" %
+    file.Write("  *location = %s(%s, name_str.c_str());\n" %
               (func.GetGLFunctionName(), arg_string))
-    file.Write("  DCHECK(false);  // TODO: return result.\n")
     file.Write("  return parse_error::kParseNoError;\n")
     file.Write("}\n")
     file.Write("\n")
 
   def WriteGLES2ImplementationHeader(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("%s %s(%s) {\n" %
                (func.return_type, func.original_name,
                 func.MakeTypedOriginalArgString("")))
     file.Write("  // TODO(gman): This needs to change to use SendString.\n")
@@ skipping 25 matching lines @@
 
   def WriteImmediateCmdSetHeader(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("  void SetHeader(const char* s) {\n")
     file.Write("    header.SetCmdByTotalSize<ValueType>(ComputeSize(s));\n")
     file.Write("  }\n")
     file.Write("\n")
 
   def WriteImmediateCmdInit(self, func, file):
     """Overrriden from TypeHandler."""
-    last_arg = func.GetLastOriginalArg()
-    file.Write("  void Init(%s) {\n" % func.MakeTypedOriginalArgString("_"))
-    file.Write("    SetHeader(_%s);\n" % last_arg.name)
-    args = func.GetCmdArgs()[:-1]
+    file.Write("  void Init(%s) {\n" % func.MakeTypedInitString("_"))
+    file.Write("    SetHeader(_name);\n")
+    args = func.GetInitArgs()
     for arg in args:
       file.Write("    %s = _%s;\n" % (arg.name, arg.name))
-    file.Write("    data_size = strlen(_%s);\n" % last_arg.name)
-    file.Write("    memcpy(ImmediateDataAddress(this), _%s, data_size);\n" %
-               last_arg.name)
+    file.Write("    data_size = ComputeDataSize(_name);\n")
+    file.Write("    memcpy(ImmediateDataAddress(this), _name, data_size);\n")
     file.Write("  }\n")
     file.Write("\n")
 
   def WriteImmediateCmdSet(self, func, file):
     """Overrriden from TypeHandler."""
-    last_arg = func.GetLastOriginalArg()
     file.Write("  void* Set(void* cmd%s) {\n" %
-               func.MakeTypedOriginalArgString("_", True))
+               func.MakeTypedInitString("_", True))
     file.Write("    static_cast<ValueType*>(cmd)->Init(%s);\n" %
-               func.MakeOriginalArgString("_"))
-    file.Write("    const uint32 size = ComputeSize(_%s);\n" % last_arg.name)
+               func.MakeInitString("_"))
+    file.Write("    const uint32 size = ComputeSize(_name);\n")
     file.Write("    return NextImmediateCmdAddressTotalSize<ValueType>("
                "cmd, size);\n")
     file.Write("  }\n")
     file.Write("\n")
 
   def WriteImmediateCmdHelper(self, func, file):
     """Overrriden from TypeHandler."""
-    args = func.MakeOriginalArgString("")
-    last_arg = func.GetLastOriginalArg()
     file.Write("  void %s(%s) {\n" %
-               (func.name, func.MakeTypedOriginalArgString("")))
-    file.Write("    const uint32 size = gles2::%s::ComputeSize(%s);\n" %
-               (func.name, last_arg.name))
+               (func.name, func.MakeTypedCmdArgString("")))
+    file.Write("    const uint32 size = gles2::%s::ComputeSize(name);\n" %
+               func.name)
     file.Write("    gles2::%s& c = GetImmediateCmdSpaceTotalSize<gles2::%s>("
                "size);\n" %
                (func.name, func.name))
-    file.Write("    c.Init(%s);\n" % args)
+    file.Write("    c.Init(%s);\n" % func.MakeCmdArgString(""))
     file.Write("  }\n\n")
 
   def WriteImmediateFormatTest(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("TEST(GLES2FormatTest, %s) {\n" % func.name)
     file.Write("  int8 buf[256] = { 0, };\n")
     file.Write("  %s& cmd = *static_cast<%s*>(static_cast<void*>(&buf));\n" %
                (func.name, func.name))
     file.Write("  static const char* const test_str = \"test string\";\n")
     file.Write("  void* next_cmd = cmd.Set(\n")
@@ skipping 19 matching lines @@
 
 
 class IsHandler(TypeHandler):
   """Handler for glIs____ type and glGetError functions."""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
   def InitFunction(self, func):
     """Overrriden from TypeHandler."""
-    func.AddCmdArg(CmdArg("result_shm_id", 'uint32'))
-    func.AddCmdArg(CmdArg("result_shm_offset", 'uint32'))
+    func.AddCmdArg(Argument("result_shm_id", 'uint32'))
+    func.AddCmdArg(Argument("result_shm_offset", 'uint32'))
 
   def WriteServiceImplementation(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write(
         "parse_error::ParseError GLES2DecoderImpl::Handle%s(\n" % func.name)
     file.Write(
-        "    unsigned int arg_count, const gles2::%s& c) {\n" % func.name)
+        "    uint32 immediate_data_size, const gles2::%s& c) {\n" % func.name)
     args = func.GetOriginalArgs()
     for arg in args:
       arg.WriteGetCode(file)
 
     file.Write("  %s* result_dst = GetSharedMemoryAs<%s*>(\n" %
                (func.return_type, func.return_type))
     file.Write(
         "      c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));\n")
     file.Write("  parse_error::ParseError result =\n")
-    file.Write("      Validate%s(this, arg_count%s);\n" %
+    file.Write("      Validate%s(this, immediate_data_size%s);\n" %
                (func.name, func.MakeOriginalArgString("", True)))
     file.Write("  if (result != parse_error::kParseNoError) {\n")
     file.Write("    return result;\n")
     file.Write("  }\n")
     file.Write("  *result_dst = %s(%s);\n" %
                (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
     file.Write("  return parse_error::kParseNoError;\n")
     file.Write("}\n")
     file.Write("\n")
 
   def WriteGLES2ImplementationHeader(self, func, file):
     """Overrriden from TypeHandler."""
     file.Write("%s %s(%s) {\n" %
                (func.return_type, func.original_name,
                 func.MakeTypedOriginalArgString("")))
     arg_string = func.MakeOriginalArgString("")
     comma = ""
     if len(arg_string) > 0:
       comma = ", "
-    file.Write("  helper_->%s(%s%sshared_memory_.GetId(), 0);\n" %
+    file.Write("  helper_->%s(%s%sresult_shm_id(), result_shm_offset());\n" %
                (func.name, arg_string, comma))
-    file.Write("  int32 token = helper_->InsertToken();\n")
-    file.Write("  helper_->WaitForToken(token);\n")
-    file.Write("  return *shared_memory_.GetAddressAs<%s*>(0);\n" %
+    file.Write("  WaitForCmd();\n")
+    file.Write("  return GetResultAs<%s>();\n" %
                func.return_type)
     file.Write("}\n")
     file.Write("\n")
 
   def WriteGLES2ImplementationImpl(self, func, file):
     """Overrriden from TypeHandler."""
     pass
 
 
 class STRnHandler(TypeHandler):
@@ skipping 12 matching lines @@
   """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 CmdArg(object):
-  """A class used to represent arguments at the command buffer level."""
+class Argument(object):
+  """A class that represents a function argument."""
+
   cmd_type_map_ = {
     'GLfloat': 'float',
     'GLclampf': 'float',
   }
 
   def __init__(self, name, type):
     self.name = name
     self.type = type
 
     if type in self.cmd_type_map_:
       self.cmd_type = self.cmd_type_map_[type]
     else:
       self.cmd_type = 'uint32'
 
-  def WriteGetCode(self, file):
-    file.Write("  %s %s = static_cast<%s>(c.%s);\n" %
-               (self.type, self.name, self.type, self.name))
-
-
-class Argument(object):
-  """A class that represents a function argument."""
-
-  def __init__(self, name, type):
-    self.name = name
-    self.type = type
+  def IsPointer(self):
+    """Returns true if argument is a pointer."""
+    return False
 
   def AddCmdArgs(self, args):
     """Adds command arguments for this argument to the given list."""
-    return args.append(CmdArg(self.name, self.type))
+    return args.append(self)
+
+  def AddInitArgs(self, args):
+    """Adds init arguments for this argument to the given list."""
+    return args.append(self)
 
   def WriteGetCode(self, file):
     """Writes the code to get an argument from a command structure."""
     file.Write("  %s %s = static_cast<%s>(c.%s);\n" %
                (self.type, self.name, self.type, self.name))
 
   def WriteValidationCode(self, file):
     """Writes the validation code for an argument."""
     pass
 
@@ skipping 35 matching lines @@
     """Overridden from Argument."""
     return None
 
 
 class PointerArgument(Argument):
   """A class that represents a pointer argument to a function."""
 
   def __init__(self, name, type):
     Argument.__init__(self, name, type)
 
+  def IsPointer(self):
+    """Returns true if argument is a pointer."""
+    return True
+
   def AddCmdArgs(self, args):
     """Overridden from Argument."""
-    args.append(CmdArg("%s_shm_id" % self.name, 'uint32'))
-    args.append(CmdArg("%s_shm_offset" % self.name, 'uint32'))
+    args.append(Argument("%s_shm_id" % self.name, 'uint32'))
+    args.append(Argument("%s_shm_offset" % self.name, 'uint32'))
 
   def WriteGetCode(self, file):
     """Overridden from Argument."""
     file.Write(
         "  %s %s = GetSharedMemoryAs<%s>(\n" %
         (self.type, self.name, self.type))
     file.Write(
         "      c.%s_shm_id, c.%s_shm_offset, 0 /* TODO(gman): size */);\n" %
         (self.name, self.name))
 
@@ skipping 10 matching lines @@
     """Overridden from Argument."""
     file.Write("  if (%s == NULL) {\n" % self.name)
     file.Write("    return parse_error::kParseOutOfBounds;\n")
     file.Write("  }\n")
 
   def GetImmediateVersion(self):
     """Overridden from Argument."""
     return ImmediatePointerArgument(self.name, self.type)
 
 
+class NonImmediatePointerArgument(PointerArgument):
+  """A pointer argument that stays a pointer even in an immediate cmd."""
+
+  def __init__(self, name, type):
+    PointerArgument.__init__(self, name, type)
+
+  def IsPointer(self):
+    """Returns true if argument is a pointer."""
+    return False
+
+  def GetImmediateVersion(self):
+    """Overridden from Argument."""
+    return self
+
+
 class ResourceIdArgument(Argument):
   """A class that represents a resource id argument to a function."""
 
   def __init__(self, name, type):
     type = type.replace("GLResourceId", "GLuint")
     Argument.__init__(self, name, type)
 
   def WriteGetCode(self, file):
     """Overridden from Argument."""
     file.Write("  %s %s;\n" % (self.type, self.name))
     file.Write("  if (!id_map_.GetServiceId(c.%s, &%s)) {\n" %
                (self.name, self.name))
     file.Write("    SetGLError(GL_INVALID_VALUE);\n")
     file.Write("    return parse_error::kParseNoError;\n")
     file.Write("  }\n")
 
 
 class Function(object):
   """A class that represents a function."""
 
   def __init__(self, name, info, return_type, original_args, args_for_cmds,
-               cmd_args, num_pointer_args):
+               cmd_args, init_args, num_pointer_args):
     self.name = name
     self.original_name = name
     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.args_for_cmds = args_for_cmds
     self.type_handler.InitFunction(self)
 
   def IsType(self, type_name):
     """Returns true if function is a certain type."""
     return self.info.type == type_name
 
   def GetInfo(self, name):
     """Returns a value from the function info for this function."""
     if hasattr(self.info, name):
       return getattr(self.info, name)
     return None
 
   def GetGLFunctionName(self):
     """Gets the function to call to execute GL for this command."""
     if self.GetInfo('DecoderFunc'):
       return self.GetInfo('DecoderFunc')
     return "gl%s" % self.original_name
 
   def AddCmdArg(self, arg):
     """Adds a cmd argument to this function."""
     self.cmd_args.append(arg)
 
   def GetCmdArgs(self):
     """Gets the command args for this function."""
     return self.cmd_args
 
+  def GetInitArgs(self):
+    """Gets the init args for this function."""
+    return self.init_args
+
   def GetOriginalArgs(self):
     """Gets the original arguments to this function."""
     return self.original_args
 
   def GetLastOriginalArg(self):
     """Gets the last original argument to this function."""
     return self.original_args[len(self.original_args) - 1]
 
   def __GetArgList(self, arg_string, add_comma):
     """Adds a comma if arg_string is not empty and add_comma is true."""
@@ skipping 23 matching lines @@
         ["%s %s%s" % (arg.type, prefix, arg.name) for arg in args])
     return self.__GetArgList(arg_string, add_comma)
 
   def MakeCmdArgString(self, prefix, add_comma = False):
     """Gets the list of arguments as they need to be for command buffers."""
     args = self.GetCmdArgs()
     arg_string = ", ".join(
         ["%s%s" % (prefix, arg.name) for arg in args])
     return self.__GetArgList(arg_string, add_comma)
 
+  def MakeTypedInitString(self, prefix, add_comma = False):
+    """Gets a typed list of arguments as they need to be for cmd Init/Set."""
+    args = self.GetInitArgs()
+    arg_string = ", ".join(
+        ["%s %s%s" % (arg.type, prefix, arg.name) for arg in args])
+    return self.__GetArgList(arg_string, add_comma)
+
+  def MakeInitString(self, prefix, add_comma = False):
+    """Gets the list of arguments as they need to be for cmd Init/Set."""
+    args = self.GetInitArgs()
+    arg_string = ", ".join(
+        ["%s%s" % (prefix, arg.name) for arg in args])
+    return self.__GetArgList(arg_string, add_comma)
+
   def WriteHandlerImplementation(self, file):
     """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 WriteCmdArgFlag(self, file):
     """Writes the cmd kArgFlags constant."""
@@ skipping 28 matching lines @@
     """Writes the cmd's Set function."""
     copy_args = self.MakeCmdArgString("_", False)
     file.Write("  void* Set(void* cmd%s) {\n" %
                self.MakeTypedCmdArgString("_", True))
     file.Write("    static_cast<ValueType*>(cmd)->Init(%s);\n" % copy_args)
     file.Write("    return NextCmdAddress<ValueType>(cmd);\n")
     file.Write("  }\n")
     file.Write("\n")
 
   def WriteStruct(self, file):
-    """Writes a structure that matched the arguments to the function."""
-    file.Write("struct %s {\n" % self.name)
-    file.Write("  typedef %s ValueType;\n" % self.name)
-    file.Write("  static const CommandId kCmdId = k%s;\n" % self.name)
-    self.WriteCmdArgFlag(file)
-    file.Write("\n")
-
-    self.WriteCmdComputeSize(file)
-    self.WriteCmdSetHeader(file)
-    self.WriteCmdInit(file)
-    self.WriteCmdSet(file)
-
-    file.Write("  command_buffer::CommandHeader header;\n")
-    args = self.GetCmdArgs()
-    for arg in args:
-      file.Write("  %s %s;\n" % (arg.cmd_type, arg.name))
-    file.Write("};\n")
-    file.Write("\n")
-
-    size = len(args) * _SIZE_OF_UINT32 + _SIZE_OF_COMMAND_HEADER
-    file.Write("COMPILE_ASSERT(sizeof(%s) == %d,\n" % (self.name, size))
-    file.Write("               Sizeof_%s_is_not_%d);\n" % (self.name, size))
-    file.Write("COMPILE_ASSERT(offsetof(%s, header) == 0,\n" % self.name)
-    file.Write("               OffsetOf_%s_header_not_0);\n" % self.name)
-    offset = _SIZE_OF_COMMAND_HEADER
-    for arg in args:
-      file.Write("COMPILE_ASSERT(offsetof(%s, %s) == %d,\n" %
-                 (self.name, arg.name, offset))
-      file.Write("               OffsetOf_%s_%s_not_%d);\n" %
-                 (self.name, arg.name, offset))
-      offset += _SIZE_OF_UINT32
-    file.Write("\n")
+    self.type_handler.WriteStruct(self, file)
 
   def WriteCmdHelper(self, file):
     """Writes the cmd's helper."""
-    args = self.MakeCmdArgString("")
-    file.Write("  void %s(%s) {\n" %
-               (self.name, self.MakeTypedCmdArgString("")))
-    file.Write("    gles2::%s& c = GetCmdSpace<gles2::%s>();\n" %
-               (self.name, self.name))
-    file.Write("    c.Init(%s);\n" % args)
-    file.Write("  }\n\n")
+    self.type_handler.WriteCmdHelper(self, file)
 
   def WriteServiceImplementation(self, file):
     """Writes the service implementation for a command."""
     self.type_handler.WriteServiceImplementation(self, file)
 
   def WriteGLES2ImplementationHeader(self, file):
     """Writes the GLES2 Implemention declaration."""
     self.type_handler.WriteGLES2ImplementationHeader(self, file)
 
   def WriteGLES2ImplementationImpl(self, file):
@@ skipping 16 matching lines @@
         new_args.append(new_arg)
 
     cmd_args = []
     new_args_for_cmds = []
     for arg in func.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)
+
     Function.__init__(
         self,
         "%sImmediate" % func.name,
         func.info,
         func.return_type,
         new_args,
         new_args_for_cmds,
         cmd_args,
+        new_init_args,
         0)
     self.original_name = func.name
 
   def WriteServiceImplementation(self, file):
     """Overridden from Function"""
     self.type_handler.WriteImmediateServiceImplementation(self, file)
 
   def WriteHandlerImplementation(self, file):
     """Overridden from Function"""
     self.type_handler.WriteImmediateHandlerImplementation(self, file)
@@ skipping 24 matching lines @@
 
   def WriteCmdHelper(self, file):
     """Overridden from Function"""
     self.type_handler.WriteImmediateCmdHelper(self, file)
 
   def WriteFormatTest(self, file):
     """Overridden from Function"""
     self.type_handler.WriteImmediateFormatTest(self, file)
 
 
+def CreateArg(arg_string):
+  """Creates an Argument."""
+  arg_parts = arg_string.split()
+  if len(arg_parts) == 1 and arg_parts[0] == 'void':
+    return None
+  # Is this a pointer argument?
+  elif arg_string.find('*') >= 0:
+    if arg_parts[0] == 'NonImmediate':
+      return NonImmediatePointerArgument(
+          arg_parts[-1],
+          " ".join(arg_parts[1:-1]))
+    else:
+      return PointerArgument(
+          arg_parts[-1],
+          " ".join(arg_parts[0:-1]))
+  # Is this a resource argument? Must come after pointer check.
+  elif arg_parts[0] == 'GLResourceId':
+    return ResourceIdArgument(
+        arg_parts[-1],
+        " ".join(arg_parts[0:-1]))
+  else:
+    return Argument(
+        arg_parts[-1],
+        " ".join(arg_parts[0:-1]))
+
+
 class GLGenerator(object):
   """A class to generate GL command buffers."""
 
   _function_re = re.compile(r'GL_APICALL(.*?)GL_APIENTRY (.*?) \((.*?)\);')
   _non_alnum_re = re.compile(r'[^a-zA-Z0-9]')
 
   def __init__(self, verbose):
     self.original_functions = []
     self.functions = []
     self.verbose = verbose
     self._function_info = {}
     self._empty_type_handler = TypeHandler()
     self._empty_function_info = FunctionInfo({}, self._empty_type_handler)
 
     self._type_handlers = {
       'Create': CreateHandler(),
       'Custom': CustomHandler(),
       'Data': DataHandler(),
       'DELn': DELnHandler(),
       'GENn': GENnHandler(),
       'GETn': GETnHandler(),
       'GetGLchar': GetGLcharHandler(),
       'GLchar': GLcharHandler(),
+      'HandWritten': HandWrittenHandler(),
       'Is': IsHandler(),
       'Manual': ManualHandler(),
       'PUT': PUTHandler(),
       'PUTn': PUTnHandler(),
       'STRn': STRnHandler(),
       'Todo': TodoHandler(),
     }
 
     for func_name in _FUNCTION_INFO:
       info = _FUNCTION_INFO[func_name]
@@ skipping 51 matching lines @@
     base = os.path.dirname(os.path.dirname(os.path.dirname(
         os.path.dirname(os.path.dirname(os.path.abspath(__file__))))))
     hpath = os.path.abspath(filename)[len(base) + 1:]
     return self._non_alnum_re.sub('_', hpath).upper()
 
   def ParseArgs(self, arg_string):
     """Parses a function arg string."""
     args = []
     num_pointer_args = 0
     parts = arg_string.split(',')
-    for arg in parts:
-      arg_parts = arg.split()
-      if len(arg_parts) == 1 and arg_parts[0] == 'void':
-        pass
-      # Is this a pointer argument?
-      elif arg.find('*') >= 0:
-        num_pointer_args += 1
-        args.append(PointerArgument(
-            arg_parts[-1],
-            " ".join(arg_parts[0:-1])))
-      # Is this a resource argument? Must come after pointer check.
-      elif arg_parts[0] == 'GLResourceId':
-        args.append(ResourceIdArgument(
-            arg_parts[-1],
-            " ".join(arg_parts[0:-1])))
-      else:
-        args.append(Argument(
-            arg_parts[-1],
-            " ".join(arg_parts[0:-1])))
+    for arg_string in parts:
+      arg = CreateArg(arg_string)
+      if arg:
+        args.append(arg)
+        if arg.IsPointer():
+          num_pointer_args += 1
     return (args, num_pointer_args)
 
   def ParseGLH(self, filename):
     """Parses the GL2.h file and extracts the functions"""
     for line in _GL_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) = self.ParseArgs(arg_string)
           args_for_cmds = args
           if hasattr(func_info, 'cmd_args'):
             (args_for_cmds, num_pointer_args) = (
                 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_info, return_type, args, args_for_cmds,
-                       cmd_args, num_pointer_args)
+                       cmd_args, init_args, num_pointer_args)
           self.original_functions.append(f)
           self.AddFunction(f)
           f.type_handler.AddImmediateFunction(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
@@ skipping 103 matching lines @@
 
   def WriteServiceValidation(self, filename):
     file = CWriter(filename)
     self.WriteLicense(file)
     file.Write("\n")
     self.WriteNamespaceOpen(file)
     file.Write("namespace {\n")
     file.Write("\n")
     for func in self.functions:
       file.Write("parse_error::ParseError Validate%s(\n" % func.name)
-      file.Write("    GLES2Decoder* decoder, unsigned int arg_count%s) {\n" %
-                 func.MakeTypedOriginalArgString("", True))
+      file.Write(
+          "    GLES2Decoder* decoder, uint32 immediate_data_size%s) {\n" %
+          func.MakeTypedOriginalArgString("", True))
       for arg in func.GetOriginalArgs():
         arg.WriteValidationCode(file)
       func.WriteValidationCode(file)
       file.Write("  return parse_error::kParseNoError;\n")
       file.Write("}\n")
     file.Write("}  // anonymous namespace\n")
     self.WriteNamespaceClose(file)
     file.Close()
 
   def WriteGLES2CLibImplementation(self, filename):
@@ skipping 80 matching lines @@
     gen.WriteGLES2ImplementationImpl("client/gles2_implementation_gen.h")
     gen.WriteServiceValidation("service/gles2_cmd_decoder_validate.h")
 
   if options.generate_command_id_tests:
     gen.WriteCommandIdTest("common/gles2_cmd_id_test.cc")
 
 
 if __name__ == '__main__':
   main(sys.argv[1:])