Added support for glGetString, glGetShaderSource,...

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 821 matching lines @@
 #               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.
 # impl_func:    Whether or not to generate the GLES2Implementation part of this
 #               command.
 # 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.
 # unit_test:    If False no unit test will be generated.
+# expectation:  If False the unit test will have no expected calls.
 
 _FUNCTION_INFO = {
-  'ActiveTexture': {'decoder_func': 'DoActiveTexture'},
+  'ActiveTexture': {'decoder_func': 'DoActiveTexture', 'expection': False},
   'BindAttribLocation': {'type': 'GLchar'},
   'BindBuffer': {'decoder_func': 'DoBindBuffer'},
   'BindFramebuffer': {'decoder_func': 'glBindFramebufferEXT'},
   'BindRenderbuffer': {'decoder_func': 'glBindRenderbufferEXT'},
   'BindTexture': {'decoder_func': 'DoBindTexture'},
   'BufferData': {'type': 'Manual', 'immediate': True},
   'BufferSubData': {'type': 'Data'},
   'CheckFramebufferStatus': {'decoder_func': 'glCheckFramebufferStatusEXT'},
   'ClearDepthf': {'decoder_func': 'glClearDepth'},
   'CompileShader': {'decoder_func': 'DoCompileShader', 'unit_test': False},
@@ skipping 62 matching lines @@
     'immediate': False,
     'cmd_args': 'GLidProgram program, void* result, uint32 result_size',
     'result': ['SizedResult<GLuint>'],
   },
   'GetAttribLocation': {
     'type': 'HandWritten',
     'immediate': True,
     'needs_size': True,
     'cmd_args':
         'GLidProgram program, const char* name, NonImmediate GLint* location',
+    'result': ['GLint'],
   },
   'GetBooleanv': {'type': 'GETn'},
   'GetBufferParameteriv': {'type': 'GETn'},
-  'GetError': {'type': 'Is', 'decoder_func': 'GetGLError'},
+  'GetError': {
+    'type': 'Is',
+    'decoder_func':
+    'GetGLError',
+    'impl_func': False,
+    'result': ['GLenum'],
+  },
   'GetFloatv': {'type': 'GETn'},
   'GetFramebufferAttachmentParameteriv': {
     'type': 'GETn',
     'decoder_func': 'glGetFramebufferAttachmentParameterivEXT',
   },
   'GetIntegerv': {'type': 'GETn'},
   'GetProgramiv': {'type': 'GETn'},
-  'GetProgramInfoLog': {'type': 'STRn'},
+  'GetProgramInfoLog': {
+    'type': 'STRn',
+    'get_len_func': 'glGetProgramiv',
+    'get_len_enum': 'GL_INFO_LOG_LENGTH',
+    },
   'GetRenderbufferParameteriv': {
     'type': 'GETn',
     'decoder_func': 'glGetRenderbufferParameterivEXT',
   },
-  'GetShaderiv': {'type': 'GETn'},
-  'GetShaderInfoLog': {'type': 'STRn'},
+  'GetShaderiv': {'type': 'GETn', 'decoder_func': 'DoGetShaderiv'},
+  'GetShaderInfoLog': {
+    'type': 'STRn',
+    'get_len_func': 'glGetShaderiv',
+    'get_len_enum': 'GL_INFO_LOG_LENGTH',
+    },
   'GetShaderPrecisionFormat': {
     'type': 'Custom',
     'immediate': False,
     'cmd_args':
       'GLenumShaderType shadertype, GLenumShaderPrecision precisiontype, '
       'void* result',
     'result': [
       'int32 success',
       'int32 min_range',
       'int32 max_range',
       'int32 precision',
     ],
   },
-  'GetShaderSource': {'type': 'STRn', 'decoder_func': 'DoGetShaderSource'},
+  'GetShaderSource': {
+    'type': 'STRn',
+    'decoder_func': 'DoGetShaderSource',
+    'get_len_func': 'DoGetShaderiv',
+    'get_len_enum': 'GL_SHADER_SOURCE_LENGTH',
+    'unit_test': False,
+    },
+  'GetString': {
+      'type': 'Custom',
+      'cmd_args': 'GLenumStringType name, uint32 bucket_id',
+  },
   'GetTexParameterfv': {'type': 'GETn'},
   'GetTexParameteriv': {'type': 'GETn'},
   'GetUniformfv': {
     'type': 'Custom',
     'immediate': False,
     'result': ['SizedResult<GLfloat>'],
   },
   'GetUniformiv': {
     'type': 'Custom',
     'immediate': False,
     'result': ['SizedResult<GLint>'],
   },
   'GetUniformLocation': {
     'type': 'HandWritten',
     'immediate': True,
     'needs_size': True,
     'cmd_args':
         'GLidProgram program, const char* name, NonImmediate GLint* location',
+    'result': ['GLint'],
   },
   'GetVertexAttribfv': {'type': 'GETn'},
   'GetVertexAttribiv': {'type': 'GETn'},
   'GetVertexAttribPointerv': {
     'type': 'Custom',
     'immediate': False,
     'result': ['SizedResult<GLuint>'],
   },
   'IsBuffer': {'type': 'Is'},
   'IsEnabled': {'type': 'Is'},
@@ skipping 178 matching lines @@
     self.Write("#ifndef %s\n" % self.guard)
     self.Write("#define %s\n\n" % self.guard)
 
   def Close(self):
     self.Write("#endif  // %s\n\n" % self.guard)
     CWriter.Close(self)
 
 class TypeHandler(object):
   """This class emits code for a particular type of function."""
 
+  _remove_expected_call_re = re.compile(r'  EXPECT_CALL.*?;\n', re.S)
+
   def __init__(self):
     pass
 
   def InitFunction(self, func):
     """Add or adjust anything type specific for this function."""
     if func.GetInfo('needs_size'):
       func.AddCmdArg(Argument('data_size', 'uint32'))
 
   def AddImmediateFunction(self, generator, func):
     """Adds an immediate version of a function."""
@@ skipping 171 matching lines @@
     self.WriteGetDataSizeCode(func, file)
     last_arg.WriteGetCode(file)
     func.WriteHandlerValidation(file)
     func.WriteHandlerImplementation(file)
     file.Write("  return error::kNoError;\n")
     file.Write("}\n")
     file.Write("\n")
 
   def WriteValidUnitTest(self, func, file, test, extra = {}):
     """Writes a valid unit test."""
+    if func.GetInfo('expection') == False:
+      test = self._remove_expected_call_re.sub('', test)
     name = func.name
     arg_strings = []
     count = 0
     for arg in func.GetOriginalArgs():
       arg_strings.append(arg.GetValidArg(count, 0))
       count += 1
     gl_arg_strings = []
     count = 0
     for arg in func.GetOriginalArgs():
       gl_arg_strings.append(arg.GetValidGLArg(count, 0))
       count += 1
     gl_func_name = func.GetGLTestFunctionName()
     vars = {
       'test_name': 'GLES2DecoderTest%d' % file.file_num,
       'name':name,
       'gl_func_name': gl_func_name,
       'args': ", ".join(arg_strings),
       'gl_args': ", ".join(gl_arg_strings),
     }
     vars.update(extra)
     file.Write(test % vars)
 
   def WriteInvalidUnitTest(self, func, file, test, extra = {}):
     """Writes a invalid unit test."""
     arg_index = 0
     for arg in func.GetOriginalArgs():
-      num_invalid_values = arg.GetNumInvalidValues()
+      num_invalid_values = arg.GetNumInvalidValues(func)
       for value_index in range(0, num_invalid_values):
         arg_strings = []
         parse_result = "kNoError"
         gl_error = None
         count = 0
         for arg in func.GetOriginalArgs():
           if count == arg_index:
             (arg_string, parse_result, gl_error) = arg.GetInvalidArg(
                 count, value_index)
           else:
@@ skipping 51 matching lines @@
     self.WriteInvalidUnitTest(func, file, invalid_test)
 
   def WriteImmediateServiceUnitTest(self, func, file):
     """Writes the service unit test for an immediate command."""
     file.Write("// TODO(gman): %s\n" % func.name)
 
   def WriteImmediateValidationCode(self, func, file):
     """Writes the validation code for an immediate version of a command."""
     pass
 
+  def WriteGLES2ImplementationDeclaration(self, func, file):
+    """Writes the GLES2 Implemention declaration."""
+    file.Write("%s %s(%s);\n" %
+               (func.return_type, func.original_name,
+                func.MakeTypedOriginalArgString("")))
+    file.Write("\n")
+
   def WriteGLES2ImplementationHeader(self, func, file):
-    """Writes the GLES2 Implemention declaration."""
+    """Writes the GLES2 Implemention."""
     impl_func = func.GetInfo('impl_func')
     if func.can_auto_generate and (impl_func == None or impl_func == True):
       file.Write("%s %s(%s) {\n" %
                  (func.return_type, func.original_name,
                   func.MakeTypedOriginalArgString("")))
+      for arg in func.GetOriginalArgs():
+        arg.WriteClientSideValidationCode(file)
       file.Write("  helper_->%s(%s);\n" %
                  (func.name, func.MakeOriginalArgString("")))
       file.Write("}\n")
       file.Write("\n")
     else:
-      file.Write("%s %s(%s);\n" %
-                 (func.return_type, func.original_name,
-                  func.MakeTypedOriginalArgString("")))
-      file.Write("\n")
+      self.WriteGLES2ImplementationDeclaration(func, file)
 
   def WriteImmediateCmdComputeSize(self, func, file):
     """Writes the size computation code for the immediate version of a cmd."""
     file.Write("  static uint32 ComputeSize(uint32 size_in_bytes) {\n")
     file.Write("    return static_cast<uint32>(\n")
     file.Write("        sizeof(ValueType) +  // NOLINT\n")
     file.Write("        RoundSizeToMultipleOfEntries(size_in_bytes));\n")
     file.Write("  }\n")
     file.Write("\n")
 
@@ skipping 1492 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(Argument("result_shm_id", 'uint32'))
     func.AddCmdArg(Argument("result_shm_offset", 'uint32'))
+    if func.GetInfo('result') == None:
+      func.AddInfo('result', ['uint32'])
 
   def WriteServiceUnitTest(self, func, file):
     """Overrriden from TypeHandler."""
     valid_test = """
 TEST_F(%(test_name)s, %(name)sValidArgs) {
   EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s));
   SpecializedSetup<%(name)s, 0>();
   %(name)s cmd;
   cmd.Init(%(args)s%(comma)sshared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
@@ skipping 35 matching lines @@
         "      c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));\n")
     func.WriteHandlerValidation(file)
     file.Write("  *result_dst = %s(%s);\n" %
                (func.GetGLFunctionName(), func.MakeOriginalArgString("")))
     file.Write("  return error::kNoError;\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%sresult_shm_id(), result_shm_offset());\n" %
-               (func.name, arg_string, comma))
-    file.Write("  WaitForCmd();\n")
-    file.Write("  return GetResultAs<%s>();\n" %
-               func.return_type)
-    file.Write("}\n")
-    file.Write("\n")
+    impl_func = func.GetInfo('impl_func')
+    if impl_func == None or impl_func == True:
+      file.Write("%s %s(%s) {\n" %
+                 (func.return_type, func.original_name,
+                  func.MakeTypedOriginalArgString("")))
+      file.Write("  typedef %s::Result Result;\n" % func.original_name)
+      file.Write("  Result* result = GetResultAs<Result*>();\n")
+      file.Write("  *result = 0;\n")
+      arg_string = func.MakeOriginalArgString("")
+      comma = ""
+      if len(arg_string) > 0:
+        comma = ", "
+      file.Write("  helper_->%s(%s%sresult_shm_id(), result_shm_offset());\n" %
+                 (func.name, arg_string, comma))
+      file.Write("  WaitForCmd();\n")
+      file.Write("  return *result;\n")
+      file.Write("}\n")
+      file.Write("\n")
+    else:
+      self.WriteGLES2ImplementationDeclaration(func, file)
 
 
 class STRnHandler(TypeHandler):
   """Handler for GetProgramInfoLog, GetShaderInfoLog and GetShaderSource."""
 
   def __init__(self):
     TypeHandler.__init__(self)
 
+  def InitFunction(self, func):
+    """Overrriden from TypeHandler."""
+    # remove all but the first cmd args.
+    cmd_args = func.GetCmdArgs()
+    func.ClearCmdArgs()
+    func.AddCmdArg(cmd_args[0])
+    # add on a bucket id.
+    func.AddCmdArg(Argument('bucket_id', 'uint32'))
+
   def WriteGLES2ImplementationHeader(self, func, file):
     """Overrriden from TypeHandler."""
-    file.Write("// TODO(gman): Implement this\n")
-    TypeHandler.WriteGLES2ImplementationHeader(self, func, file)
+    code = """%(return_type)s %(func_name)s(%(args)s) {
+  helper_->SetBucketSize(kResultBucketId, 0);
+  helper_->%(func_name)s(%(id_name)s, kResultBucketId);
+  std::string str;
+  if (GetBucketAsString(kResultBucketId, &str)) {
+    GLsizei max_size =
+        std::min(static_cast<size_t>(%(bufsize_name)s) - 1, str.size());
+    if (%(length_name)s != NULL) {
+      *%(length_name)s = max_size;
+    }
+    memcpy(%(dest_name)s, str.c_str(), max_size);
+    %(dest_name)s[max_size] = '\\0';
+  }
+}
+"""
+    args = func.GetOriginalArgs()
+    file.Write(code % {
+          'return_type': func.return_type,
+          'func_name': func.original_name,
+          'args': func.MakeTypedOriginalArgString(""),
+          'id_name': args[0].name,
+          'bufsize_name': args[1].name,
+          'length_name': args[2].name,
+          'dest_name': args[3].name,
+        })
 
   def WriteServiceUnitTest(self, func, file):
     """Overrriden from TypeHandler."""
-    file.Write("// TODO(gman): %s\n\n" % func.name)
+    valid_test = """
+TEST_F(%(test_name)s, %(name)sValidArgs) {
+  const char* kInfo = "hello";
+  const uint32 kBucketId = 123;
+  SpecializedSetup<%(name)s, 0>();
+%(expect_len_code)s
+  EXPECT_CALL(*gl_, %(gl_func_name)s(%(gl_args)s))
+      .WillOnce(DoAll(SetArgumentPointee<2>(strlen(kInfo)),
+                      SetArrayArgument<3>(kInfo, kInfo + strlen(kInfo) + 1)));
+  %(name)s cmd;
+  cmd.Init(%(args)s);
+  EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
+  CommonDecoder::Bucket* bucket = decoder_->GetBucket(kBucketId);
+  ASSERT_TRUE(bucket != NULL);
+  EXPECT_EQ(strlen(kInfo) + 1, bucket->size());
+  EXPECT_EQ(0, memcmp(bucket->GetData(0, bucket->size()), kInfo,
+                      bucket->size()));
+}
+"""
+    args = func.GetOriginalArgs()
+    id_name = args[0].GetValidGLArg(0, 0)
+    get_len_func = func.GetInfo('get_len_func')
+    get_len_enum = func.GetInfo('get_len_enum')
+    sub = {
+        'id_name': id_name,
+        'get_len_func': get_len_func,
+        'get_len_enum': get_len_enum,
+        'gl_args': '%s, strlen(kInfo) + 1, _, _' % args[0].GetValidGLArg(0, 0),
+        'args': '%s, kBucketId' % args[0].GetValidArg(0, 0),
+        'expect_len_code': '',
+    }
+    if get_len_func[0:2] == 'gl':
+      sub['expect_len_code'] = (
+        "  EXPECT_CALL(*gl_, %s(%s, %s, _))\n"
+        "      .WillOnce(SetArgumentPointee<2>(strlen(kInfo)));") % (
+            get_len_func[2:], id_name, get_len_enum)
+    self.WriteValidUnitTest(func, file, valid_test, sub)
 
-  def WriteImmediateServiceUnitTest(self, func, file):
-    """Overrriden from TypeHandler."""
-    file.Write("// TODO(gman): %s\n\n" % func.name)
+    invalid_test = """
+TEST_F(%(test_name)s, %(name)sInvalidArgs) {
+  const uint32 kBucketId = 123;
+  EXPECT_CALL(*gl_, %(gl_func_name)s(_, _, _, _))
+      .Times(0);
+  %(name)s cmd;
+  cmd.Init(kInvalidClientId, kBucketId);
+  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."""
     file.Write(
         "error::Error GLES2DecoderImpl::Handle%s(\n" % func.name)
     file.Write(
         "    uint32 immediate_data_size, const gles2::%s& c) {\n" % func.name)
-    args = func.GetOriginalArgs()
-    all_but_last_2_args = args[:-2]
-    for arg in all_but_last_2_args:
-      arg.WriteGetCode(file)
-    self.WriteGetDataSizeCode(func, file)
-    size_arg = args[-2]
-    file.Write("  uint32 size_shm_id = c.%s_shm_id;\n" % size_arg.name)
-    file.Write("  uint32 size_shm_offset = c.%s_shm_offset;\n" % size_arg.name)
-    file.Write("  GLsizei* length = NULL;\n")
-    file.Write("  if (size_shm_id != 0 || size_shm_offset != 0) {\n"
-               "    length = GetSharedMemoryAs<GLsizei*>(\n"
-               "        size_shm_id, size_shm_offset, sizeof(*length));\n"
-               "    if (!length) {\n"
-               "      return error::kOutOfBounds;\n"
-               "    }\n"
-               "  }\n")
-    dest_arg = args[-1]
-    bufsize_arg = args[-3]
+    args = func.GetCmdArgs()
+    id_arg = args[0]
+    bucket_arg = args[1]
+    id_arg.WriteGetCode(file)
+    bucket_arg.WriteGetCode(file)
+    id_arg.WriteValidationCode(file)
+    file.Write("  GLint len = 0;\n")
+    file.Write("  %s(%s, %s, &len);\n" % (
+        func.GetInfo('get_len_func'), id_arg.name,
+        func.GetInfo('get_len_enum')))
+    file.Write("  Bucket* bucket = CreateBucket(%s);\n" % bucket_arg.name)
+    file.Write("  bucket->SetSize(len + 1);\n");
     file.Write(
-        "  %s %s = GetSharedMemoryAs<%s>(\n" %
-        (dest_arg.type, dest_arg.name, dest_arg.type))
-    file.Write(
-        "      c.%s_shm_id, c.%s_shm_offset, %s);\n" %
-        (dest_arg.name, dest_arg.name, bufsize_arg.name))
-    for arg in all_but_last_2_args + [dest_arg]:
-      arg.WriteValidationCode(file)
-    func.WriteValidationCode(file)
-    func.WriteHandlerImplementation(file)
+        "  %s(%s, len + 1, &len, bucket->GetDataAs<GLchar*>(0, len + 1));\n" %
+        (func.GetGLFunctionName(), id_arg.name))
     file.Write("  return error::kNoError;\n")
     file.Write("}\n")
     file.Write("\n")
 
 
 class FunctionInfo(object):
   """Holds info about a function."""
 
   def __init__(self, info, type_handler):
     for key in info:
@@ skipping 36 matching lines @@
   def AddInitArgs(self, args):
     """Adds init arguments for this argument to the given list."""
     return args.append(self)
 
   def GetValidArg(self, offset, index):
     return str(offset + 1)
 
   def GetValidGLArg(self, offset, index):
     return str(offset + 1)
 
-  def GetNumInvalidValues(self):
+  def GetNumInvalidValues(self, func):
     """returns the number of invalid values to be tested."""
     return 0
 
   def GetInvalidArg(self, offset, index):
     """returns an invalid value and expected parse result by index."""
     return ("---ERROR0---", "---ERROR2---", None)
 
   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."""
-    if self.type == 'GLsizei' or self.type == 'GLsizeiptr':
-      file.Write("  if (%s < 0) {\n" % self.name)
-      file.Write("    SetGLError(GL_INVALID_VALUE);\n")
-      file.Write("    return error::kNoError;\n")
-      file.Write("  }\n")
+    pass
+
+  def WriteClientSideValidationCode(self, file):
+    """Writes the validation code for an argument."""
+    pass
 
   def WriteGetAddress(self, file):
     """Writes the code to get the address this argument refers to."""
     pass
 
   def GetImmediateVersion(self):
     """Gets the immediate version of this argument."""
     return self
 
 
 class SizeArgument(Argument):
+  """class for GLsizei and GLsizeiptr."""
 
   def __init__(self, name, type):
     Argument.__init__(self, name, type)
 
-  def GetNumInvalidValues(self):
+  def GetNumInvalidValues(self, func):
     """overridden from Argument."""
+    if func.is_immediate:
+      return 0
     return 1
 
   def GetInvalidArg(self, offset, index):
-    """returns an invalid value and expected parse result by index."""
+    """overridden from Argument."""
     return ("-1", "kNoError", "GL_INVALID_VALUE")
 
+  def WriteValidationCode(self, file):
+    """overridden from Argument."""
+    file.Write("  if (%s < 0) {\n" % self.name)
+    file.Write("    SetGLError(GL_INVALID_VALUE);\n")
+    file.Write("    return error::kNoError;\n")
+    file.Write("  }\n")
+
+  def WriteClientSideValidationCode(self, file):
+    """overridden from Argument."""
+    file.Write("  if (%s < 0) {\n" % self.name)
+    file.Write("    SetGLError(GL_INVALID_VALUE);\n")
+    file.Write("    return;\n")
+    file.Write("  }\n")
 
 class EnumBaseArgument(Argument):
-  """Base calss for EnumArgument, IntArgument and BoolArgument"""
+  """Base class for EnumArgument, IntArgument and BoolArgument"""
 
   def __init__(self, name, gl_type, type, gl_error):
     Argument.__init__(self, name, gl_type)
 
     self.local_type = type
     self.gl_error = gl_error
     name = type[len(gl_type):]
     self.enum_info = _ENUM_LISTS[name]
 
   def WriteValidationCode(self, file):
     file.Write("  if (!Validate%s(%s)) {\n" % (self.local_type, self.name))
     file.Write("    SetGLError(%s);\n" % self.gl_error)
     file.Write("    return error::kNoError;\n")
     file.Write("  }\n")
 
   def GetValidArg(self, offset, index):
     if 'valid' in self.enum_info:
       valid = self.enum_info['valid']
       num_valid = len(valid)
       if index >= num_valid:
         index = num_valid - 1
       return valid[index]
     return str(offset + 1)
 
   def GetValidGLArg(self, offset, index):
     return self.GetValidArg(offset, index)
 
-  def GetNumInvalidValues(self):
+  def GetNumInvalidValues(self, func):
     """returns the number of invalid values to be tested."""
     if 'invalid' in self.enum_info:
       invalid = self.enum_info['invalid']
       return len(invalid)
     return 0
 
   def GetInvalidArg(self, offset, index):
     """returns an invalid value by index."""
     if 'invalid' in self.enum_info:
       invalid = self.enum_info['invalid']
       num_invalid = len(invalid)
       if index >= num_invalid:
         index = num_invalid - 1
-      return (invalid[index], "kNoError", "GL_INVALID_ENUM")
-    return ("---ERROR1---", "kNoError", "GL_INVALID_ENUM")
+      return (invalid[index], "kNoError", self.gl_error)
+    return ("---ERROR1---", "kNoError", self.gl_error)
 
 
 class EnumArgument(EnumBaseArgument):
   """A class that represents a GLenum argument"""
 
   def __init__(self, name, type):
     EnumBaseArgument.__init__(self, name, "GLenum", type, "GL_INVALID_ENUM")
 
 
 class IntArgument(EnumBaseArgument):
@@ skipping 60 matching lines @@
     return True
 
   def GetValidArg(self, offset, index):
     """Overridden from Argument."""
     return "shared_memory_id_, shared_memory_offset_"
 
   def GetValidGLArg(self, offset, index):
     """Overridden from Argument."""
     return "reinterpret_cast<%s>(shared_memory_address_)" % self.type
 
-  def GetNumInvalidValues(self):
+  def GetNumInvalidValues(self, func):
     """Overridden from Argument."""
     return 2
 
   def GetInvalidArg(self, offset, index):
     """Overridden from Argument."""
     if index == 0:
       return ("kInvalidSharedMemoryId, 0", "kOutOfBounds", None)
     else:
       return ("shared_memory_id_, kInvalidSharedMemoryOffset",
               "kOutOfBounds", None)
@@ skipping 81 matching lines @@
     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)
+    self.is_immediate = False
 
   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 AddInfo(self, name, value):
+    """Adds an info."""
+    setattr(self.info, name, value)
+
   def GetGLFunctionName(self):
     """Gets the function to call to execute GL for this command."""
     if self.GetInfo('decoder_func'):
       return self.GetInfo('decoder_func')
     return "gl%s" % self.original_name
 
   def GetGLTestFunctionName(self):
     gl_func_name = self.GetInfo('gl_test_func')
     if gl_func_name == None:
       gl_func_name = self.GetGLFunctionName()
     if gl_func_name.startswith("gl"):
       gl_func_name = gl_func_name[2:]
     else:
       gl_func_name = self.original_name
     return gl_func_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 ClearCmdArgs(self):
+    """Clears the command args for this function."""
+    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."""
@@ skipping 151 matching lines @@
         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
 
   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)
 
   def WriteServiceUnitTest(self, file):
@@ skipping 402 matching lines @@
 
   if options.generate_command_id_tests:
     gen.WriteCommandIdTest("common/gles2_cmd_id_test_autogen.h")
 
   if gen.errors > 0:
     print "%d errors" % gen.errors
     sys.exit(1)
 
 if __name__ == '__main__':
   main(sys.argv[1:])