scripts/opengl/gen_call_log_wrapper.py

   1 # -*- coding: utf-8 -*-
   2
   3 #-------------------------------------------------------------------------
   4 # drawElements Quality Program utilities
   5 # --------------------------------------
   6 #
   7 # Copyright 2015 The Android Open Source Project
   8 #
   9 # Licensed under the Apache License, Version 2.0 (the "License");
  10 # you may not use this file except in compliance with the License.
  11 # You may obtain a copy of the License at
  12 #
  13 #      http://www.apache.org/licenses/LICENSE-2.0
  14 #
  15 # Unless required by applicable law or agreed to in writing, software
  16 # distributed under the License is distributed on an "AS IS" BASIS,
  17 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18 # See the License for the specific language governing permissions and
  19 # limitations under the License.
  20 #
  21 #-------------------------------------------------------------------------
  22
  23 from src_util import *
  24 import re
  25
  26 class LogSpec:
  27         def __init__ (self, argInPrints, argOutPrints = {}, returnPrint = None):
  28                 self.argInPrints        = argInPrints
  29                 self.argOutPrints       = argOutPrints
  30                 self.returnPrint        = returnPrint
  31
  32 def enum (group):
  33         return lambda name: "get%sStr(%s)" % (group, name)
  34
  35 def pointer (size):
  36         return lambda name: "getPointerStr(%s, %s)" % (name, size)
  37
  38 def enumPointer (group, size):
  39         return lambda name: "getEnumPointerStr(%(name)s, %(size)s, %(nameFunc)s)" % {"name": name, "size": size, "nameFunc": ("get%sName" % group)}
  40
  41 def booleanPointer (size):
  42         return lambda name: "getBooleanPointerStr(%s, %s)" % (name, size)
  43
  44 def textureUnit (name):
  45         return "getTextureUnitStr(%s)" % name
  46
  47 def voidPointer (name):
  48         return "static_cast<const void*>(%s)" % name
  49
  50 def fnPointer (name):
  51         return "((const void*)(%s))" % name
  52
  53 stringVal = lambda name: "getStringStr(%s)" % name
  54
  55 # Special rules for printing call arguments
  56 CALL_LOG_SPECS = {
  57         "glActiveTexture":                                              LogSpec({0: textureUnit}),
  58         "glBeginQuery":                                                 LogSpec({0: enum("QueryTarget")}),
  59         "glBeginTransformFeedback":                             LogSpec({0: enum("PrimitiveType")}),
  60         "glBindBuffer":                                                 LogSpec({0: enum("BufferTarget")}),
  61         "glBindBufferBase":                                             LogSpec({0: enum("BufferTarget")}),
  62         "glBindBufferRange":                                    LogSpec({0: enum("BufferTarget")}),
  63         "glBindFramebuffer":                                    LogSpec({0: enum("FramebufferTarget")}),
  64         "glBindRenderbuffer":                                   LogSpec({0: enum("FramebufferTarget")}),
  65         "glBindTexture":                                                LogSpec({0: enum("TextureTarget")}),
  66         "glBindTransformFeedback":                              LogSpec({0: enum("TransformFeedbackTarget")}),
  67         "glBlendEquation":                                              LogSpec({0: enum("BlendEquation")}),
  68         "glBlendEquationSeparate":                              LogSpec({0: enum("BlendEquation"), 1: enum("BlendEquation")}),
  69         "glBlendEquationi":                                             LogSpec({1: enum("BlendEquation")}),
  70         "glBlendEquationSeparatei":                             LogSpec({1: enum("BlendEquation"), 2: enum("BlendEquation")}),
  71         "glBlendFunc":                                                  LogSpec({0: enum("BlendFactor"), 1: enum("BlendFactor")}),
  72         "glBlendFuncSeparate":                                  LogSpec({0: enum("BlendFactor"), 1: enum("BlendFactor"), 2: enum("BlendFactor"), 3: enum("BlendFactor")}),
  73         "glBlitFramebuffer":                                    LogSpec({8: enum("BufferMask"), 9: enum("TextureFilter")}),
  74         "glBufferData":                                                 LogSpec({0: enum("BufferTarget"), 3: enum("Usage")}),
  75         "glBufferSubData":                                              LogSpec({0: enum("BufferTarget")}),
  76         "glCheckFramebufferStatus":                             LogSpec({0: enum("FramebufferTarget")}, returnPrint = enum("FramebufferStatus")),
  77         "glClear":                                                              LogSpec({0: enum("BufferMask")}),
  78         "glClearBufferfv":                                              LogSpec({0: enum("Buffer")}),
  79         "glClearBufferfi":                                              LogSpec({0: enum("Buffer")}),
  80         "glClearBufferiv":                                              LogSpec({0: enum("Buffer")}),
  81         "glClearBufferuiv":                                             LogSpec({0: enum("Buffer")}),
  82         "glCompressedTexImage2D":                               LogSpec({0: enum("TextureTarget"), 2: enum("CompressedTexFormat")}),
  83         "glCompressedTexSubImage2D":                    LogSpec({0: enum("TextureTarget"), 6: enum("CompressedTexFormat")}),
  84         "glCopyTexImage1D":                                             LogSpec({0: enum("TextureTarget"), 2: enum("PixelFormat")}),
  85         "glCopyTexImage2D":                                             LogSpec({0: enum("TextureTarget"), 2: enum("PixelFormat")}),
  86         "glCreateShader":                                               LogSpec({0: enum("ShaderType")}),
  87         "glCullFace":                                                   LogSpec({0: enum("Face")}),
  88         "glDeleteBuffers":                                              LogSpec({1: pointer(size = "n")}),
  89         "glDeleteFramebuffers":                                 LogSpec({1: pointer(size = "n")}),
  90         "glDeleteQueries":                                              LogSpec({1: pointer(size = "n")}),
  91         "glDeleteRenderbuffers":                                LogSpec({1: pointer(size = "n")}),
  92         "glDeleteBuffers":                                              LogSpec({1: pointer(size = "n")}),
  93         "glDeleteTextures":                                             LogSpec({1: pointer(size = "n")}),
  94         "glDeleteVertexArrays":                                 LogSpec({1: pointer(size = "n")}),
  95         "glDeleteProgramPipelines":                             LogSpec({1: pointer(size = "n")}),
  96         "glDepthFunc":                                                  LogSpec({0: enum("CompareFunc")}),
  97         "glDisable":                                                    LogSpec({0: enum("EnableCap")}),
  98         "glDrawArrays":                                                 LogSpec({0: enum("PrimitiveType")}),
  99         "glDrawArraysInstanced":                                LogSpec({0: enum("PrimitiveType")}),
 100         "glDrawBuffers":                                                LogSpec({1: enumPointer("DrawReadBuffer", size = "n")}),
 101         "glDrawElements":                                               LogSpec({0: enum("PrimitiveType"), 2: enum("Type")}),
 102         "glDrawElementsInstanced":                              LogSpec({0: enum("PrimitiveType"), 2: enum("Type")}),
 103         "glDrawRangeElements":                                  LogSpec({0: enum("PrimitiveType"), 4: enum("Type")}),
 104         "glDrawArraysIndirect":                                 LogSpec({0: enum("PrimitiveType")}),
 105         "glDrawElementsIndirect":                               LogSpec({0: enum("PrimitiveType"), 1: enum("Type")}),
 106         "glDrawElementsBaseVertex":                             LogSpec({0: enum("PrimitiveType"), 2: enum("Type")}),
 107         "glDrawElementsInstancedBaseVertex":    LogSpec({0: enum("PrimitiveType"), 2: enum("Type")}),
 108         "glDrawRangeElementsBaseVertex":                LogSpec({0: enum("PrimitiveType"), 4: enum("Type")}),
 109         "glMultiDrawArrays":                                    LogSpec({0: enum("PrimitiveType")}),
 110         "glMultiDrawElements":                                  LogSpec({0: enum("PrimitiveType"), 2: enum("Type")}),
 111         "glMultiDrawElementsBaseVertex":                LogSpec({0: enum("PrimitiveType"), 2: enum("Type")}),
 112         "glEnable":                                                             LogSpec({0: enum("EnableCap")}),
 113         "glEndQuery":                                                   LogSpec({0: enum("QueryTarget")}),
 114         "glFramebufferRenderbuffer":                    LogSpec({0: enum("FramebufferTarget"), 1: enum("FramebufferAttachment"), 2: enum("FramebufferTarget")}),
 115         "glFramebufferTexture2D":                               LogSpec({0: enum("FramebufferTarget"), 1: enum("FramebufferAttachment"), 2: enum("TextureTarget")}),
 116         "glFramebufferTextureLayer":                    LogSpec({0: enum("FramebufferTarget"), 1: enum("FramebufferAttachment")}),
 117         "glFramebufferTexture":                                 LogSpec({0: enum("FramebufferTarget"), 1: enum("FramebufferAttachment")}),
 118         "glFramebufferParameteri":                              LogSpec({0: enum("FramebufferTarget"), 1: enum("FramebufferParameter")}),
 119         "glFrontFace":                                                  LogSpec({0: enum("Winding")}),
 120         "glGenBuffers":                                                 LogSpec({}, argOutPrints = {1: pointer(size = "n")}),
 121         "glGenerateMipmap":                                             LogSpec({0: enum("TextureTarget")}),
 122         "glGenFramebuffers":                                    LogSpec({}, argOutPrints = {1: pointer(size = "n")}),
 123         "glGenQueries":                                                 LogSpec({}, argOutPrints = {1: pointer(size = "n")}),
 124         "glGenRenderbuffers":                                   LogSpec({}, argOutPrints = {1: pointer(size = "n")}),
 125         "glGenTextures":                                                LogSpec({}, argOutPrints = {1: pointer(size = "n")}),
 126         "glGenTransformFeedbacks":                              LogSpec({}, argOutPrints = {1: pointer(size = "n")}),
 127         "glGenVertexArrays":                                    LogSpec({}, argOutPrints = {1: pointer(size = "n")}),
 128         "glGenProgramPipelines":                                LogSpec({}, argOutPrints = {1: pointer(size = "n")}),
 129 #       "glGetActiveAttrib":
 130         "glGetActiveUniform":                                   LogSpec({}, argOutPrints = {3: pointer(size = "1"), 4: pointer(size = "1"), 5: enumPointer("ShaderVarType", size = "1"), 6: stringVal}),
 131         "glGetActiveUniformsiv":                                LogSpec({2: pointer(size = "uniformCount"), 3: enum("UniformParam")}, argOutPrints = {4: pointer(size = "uniformCount")}),
 132 #       "glGetAttachedShaders":
 133         "glGetBooleanv":
 134                 LogSpec(
 135                         {
 136                                 0: enum("GettableState"),
 137                                 1: voidPointer                                  # second argument has type of GLboolean* (aka. char*). Prevent
 138                                                                                                 # wrapper from attempting to print the argument as a C string.
 139                         },
 140                         argOutPrints = {1: booleanPointer(size = "getBasicQueryNumArgsOut(pname)")}),
 141         "glGetBufferParameteriv":                               LogSpec({0: enum("BufferTarget"), 1: enum("BufferQuery")}),
 142         "glGetBufferParameteri64v":                             LogSpec({0: enum("BufferTarget"), 1: enum("BufferQuery")}),
 143         "glGetError":                                                   LogSpec({}, returnPrint = enum("Error")),
 144         "glGetFloatv":                                                  LogSpec({0: enum("GettableState")}, argOutPrints = {1: pointer(size = "getBasicQueryNumArgsOut(pname)")}),
 145         "glGetFramebufferAttachmentParameteriv":
 146                 LogSpec(
 147                         {
 148                                 0: enum("FramebufferTarget"),
 149                                 1: enum("FramebufferAttachment"),
 150                                 2: enum("FramebufferAttachmentParameter")
 151                         },
 152                         argOutPrints = {3: lambda name: "getFramebufferAttachmentParameterValueStr(pname, %s)" % name}),
 153         "glGetFramebufferParameteriv":                  LogSpec({0: enum("FramebufferTarget"), 1: enum("FramebufferParameter")}, argOutPrints = {2: pointer(size = "1")}),
 154         "glGetIntegerv":                                                LogSpec({0: enum("GettableState")}, argOutPrints = {1: pointer(size = "getBasicQueryNumArgsOut(pname)")}),
 155         "glGetInteger64v":                                              LogSpec({0: enum("GettableState")}, argOutPrints = {1: pointer(size = "getBasicQueryNumArgsOut(pname)")}),
 156         "glGetIntegeri_v":                                              LogSpec({0: enum("GettableIndexedState")}, argOutPrints = {2: pointer(size = "1")}),
 157         "glGetInteger64i_v":                                    LogSpec({0: enum("GettableIndexedState")}, argOutPrints = {2: pointer(size = "1")}),
 158         "glGetBooleani_v":
 159                 LogSpec(
 160                         {
 161                                 0: enum("GettableIndexedState"),
 162                                 2: voidPointer                                  # last argument has type of GLboolean* (aka. char*). Prevent
 163                                                                                                 # wrapper from attempting to print the argument as a C string.
 164                         },
 165                         argOutPrints = {2: booleanPointer(size = "1")}),
 166         "glGetInternalformativ":                                LogSpec({0: enum("InternalFormatTarget"), 1: enum("PixelFormat"), 2: enum("InternalFormatParameter")}, argOutPrints = {4: pointer(size = "bufSize")}),
 167         "glGetMultisamplefv":                                   LogSpec({0: enum("MultisampleParameter")}, argOutPrints = {2: pointer(size = "2")}),
 168         "glGetPointerv":                                                LogSpec({0: enum("PointerState")}, argOutPrints = {1: pointer(size = "1")}),
 169         "glGetProgramiv":                                               LogSpec({1: enum("ProgramParam")}, argOutPrints = {2: pointer(size = "getProgramQueryNumArgsOut(pname)")}),
 170         "glGetProgramInfoLog":                                  LogSpec({3: voidPointer}, argOutPrints = {2: pointer(size = "1")}),
 171         "glGetProgramPipelineiv":                               LogSpec({1: enum("PipelineParam")}, argOutPrints = {2: pointer(size = "1")}),
 172         "glGetProgramPipelineInfoLog":                  LogSpec({3: voidPointer}, argOutPrints = {2: pointer(size = "1")}),
 173         "glGetQueryiv":                                                 LogSpec({0: enum("QueryTarget"), 1: enum("QueryParam")}, argOutPrints = {2: pointer(size = "1")}),
 174         "glGetQueryObjectiv":                                   LogSpec({1: enum("QueryObjectParam")}, argOutPrints = {2: pointer(size = "1")}),
 175         "glGetQueryObjectuiv":                                  LogSpec({1: enum("QueryObjectParam")}, argOutPrints = {2: pointer(size = "1")}),
 176         "glGetQueryObjecti64v":                                 LogSpec({1: enum("QueryObjectParam")}, argOutPrints = {2: pointer(size = "1")}),
 177         "glGetQueryObjectui64v":                                LogSpec({1: enum("QueryObjectParam")}, argOutPrints = {2: pointer(size = "1")}),
 178         "glGetRenderbufferParameteriv":                 LogSpec({0: enum("FramebufferTarget"), 1: enum("RenderbufferParameter")}),
 179         "glGetSamplerParameterfv":                              LogSpec({1: enum("TextureParameter")}, argOutPrints = {2: pointer(size = "1")}),
 180         "glGetSamplerParameteriv":                              LogSpec({1: enum("TextureParameter")}, argOutPrints = {2: pointer(size = "1")}),
 181         "glGetSamplerParameterIiv":                             LogSpec({1: enum("TextureParameter")}, argOutPrints = {2: pointer(size = "getTextureParamQueryNumArgsOut(pname)")}),
 182         "glGetSamplerParameterIuiv":                    LogSpec({1: enum("TextureParameter")}, argOutPrints = {2: pointer(size = "getTextureParamQueryNumArgsOut(pname)")}),
 183         "glGetShaderiv":                                                LogSpec({1: enum("ShaderParam")}, argOutPrints = {2: pointer(size = "1")}),
 184         "glGetShaderInfoLog":                                   LogSpec({3: voidPointer}, argOutPrints = {2: pointer(size = "1")}),
 185         "glGetShaderPrecisionFormat":                   LogSpec({0: enum("ShaderType"), 1: enum("PrecisionFormatType")}),
 186 #       "glGetShaderSource":
 187         "glGetString":                                                  LogSpec({0: enum("GettableString")}),
 188         "glGetStringi":                                                 LogSpec({0: enum("GettableString")}),
 189         "glGetTexParameterfv":                                  LogSpec({0: enum("TextureTarget"), 1: enum("TextureParameter")}, argOutPrints = {2: pointer(size = "1")}),
 190         "glGetTexParameteriv":                                  LogSpec({0: enum("TextureTarget"), 1: enum("TextureParameter")}, argOutPrints = {2: pointer(size = "1")}),
 191         "glGetTexParameterIiv":                                 LogSpec({0: enum("TextureTarget"), 1: enum("TextureParameter")}, argOutPrints = {2: pointer(size = "getTextureParamQueryNumArgsOut(pname)")}),
 192         "glGetTexParameterIuiv":                                LogSpec({0: enum("TextureTarget"), 1: enum("TextureParameter")}, argOutPrints = {2: pointer(size = "getTextureParamQueryNumArgsOut(pname)")}),
 193         "glGetTexLevelParameterfv":                             LogSpec({0: enum("TextureTarget"), 2: enum("TextureLevelParameter")}, argOutPrints = {3: pointer(size = "1")}),
 194         "glGetTexLevelParameteriv":                             LogSpec({0: enum("TextureTarget"), 2: enum("TextureLevelParameter")}, argOutPrints = {3: pointer(size = "1")}),
 195 #       "glGetUniformfv":
 196 #       "glGetUniformiv":
 197         "glGetUniformIndices":                                  LogSpec({2: pointer(size = "uniformCount")}, argOutPrints = {3: pointer(size = "uniformCount")}),
 198         "glGetVertexAttribfv":                                  LogSpec({1: enum("VertexAttribParameterName")}, argOutPrints = {2: pointer(size = "getAttributeQueryNumArgsOut(pname)")}),
 199         "glGetVertexAttribiv":                                  LogSpec({1: enum("VertexAttribParameterName")}, argOutPrints = {2: pointer(size = "getAttributeQueryNumArgsOut(pname)")}),
 200         "glGetVertexAttribIiv":                                 LogSpec({1: enum("VertexAttribParameterName")}, argOutPrints = {2: pointer(size = "getAttributeQueryNumArgsOut(pname)")}),
 201         "glGetVertexAttribIuiv":                                LogSpec({1: enum("VertexAttribParameterName")}, argOutPrints = {2: pointer(size = "getAttributeQueryNumArgsOut(pname)")}),
 202 #       "glGetVertexAttribPointerv":
 203         "glHint":                                                               LogSpec({0: enum("Hint"), 1: enum("HintMode")}),
 204         "glIsEnabled":                                                  LogSpec({0: enum("EnableCap")}),
 205         "glPixelStorei":                                                LogSpec({0: enum("PixelStoreParameter")}),
 206         "glReadBuffer":                                                 LogSpec({0: enum("DrawReadBuffer")}),
 207         "glReadPixels":                                                 LogSpec({4: enum("PixelFormat"), 5: enum("Type")}),
 208         "glRenderbufferStorage":                                LogSpec({0: enum("FramebufferTarget"), 1: enum("PixelFormat")}),
 209         "glRenderbufferStorageMultisample":             LogSpec({0: enum("FramebufferTarget"), 2: enum("PixelFormat")}),
 210         "glStencilFunc":                                                LogSpec({0: enum("CompareFunc")}),
 211         "glStencilFuncSeparate":                                LogSpec({0: enum("Face"), 1: enum("CompareFunc")}),
 212         "glStencilMaskSeparate":                                LogSpec({0: enum("Face")}),
 213         "glStencilOp":                                                  LogSpec({0: enum("StencilOp"), 1: enum("StencilOp"), 2: enum("StencilOp")}),
 214         "glStencilOpSeparate":                                  LogSpec({0: enum("Face"), 1: enum("StencilOp"), 2: enum("StencilOp"), 3: enum("StencilOp")}),
 215         "glTexImage1D":                                                 LogSpec({0: enum("TextureTarget"), 2: enum("PixelFormat"), 5: enum("PixelFormat"), 6: enum("Type")}),
 216         "glTexImage2D":                                                 LogSpec({0: enum("TextureTarget"), 2: enum("PixelFormat"), 6: enum("PixelFormat"), 7: enum("Type")}),
 217         "glTexImage2DMultisample":                              LogSpec({0: enum("TextureTarget"), 2: enum("PixelFormat"), 5: enum("Boolean")}),
 218         "glTexImage3D":                                                 LogSpec({0: enum("TextureTarget"), 2: enum("PixelFormat"), 7: enum("PixelFormat"), 8: enum("Type")}),
 219         "glTexStorage2D":                                               LogSpec({0: enum("TextureTarget"), 2: enum("PixelFormat")}),
 220         "glTexStorage3D":                                               LogSpec({0: enum("TextureTarget"), 2: enum("PixelFormat")}),
 221         "glTexStorage2DMultisample":                    LogSpec({0: enum("TextureTarget"), 2: enum("PixelFormat"), 5: enum("Boolean")}),
 222         "glTexStorage3DMultisample":                    LogSpec({0: enum("TextureTarget"), 2: enum("PixelFormat"), 6: enum("Boolean")}),
 223         # \todo [2012-03-08 pyry] Pointer values..
 224         "glTexParameterf":                                              LogSpec({0: enum("TextureTarget"), 1: enum("TextureParameter")}),
 225         "glTexParameterfv":                                             LogSpec({0: enum("TextureTarget"), 1: enum("TextureParameter"), 2: pointer(size = "1")}),
 226         "glTexParameteri":                                              LogSpec({0: enum("TextureTarget"), 1: enum("TextureParameter"), 2: lambda name: "getTextureParameterValueStr(pname, %s)" % name}),
 227         "glTexParameteriv":                                             LogSpec({0: enum("TextureTarget"), 1: enum("TextureParameter"), 2: pointer(size = "1")}),
 228         "glTexParameterIiv":                                    LogSpec({0: enum("TextureTarget"), 1: enum("TextureParameter"), 2: pointer(size = "getTextureParamNumArgs(pname)")}),
 229         "glTexParameterIuiv":                                   LogSpec({0: enum("TextureTarget"), 1: enum("TextureParameter"), 2: pointer(size = "getTextureParamNumArgs(pname)")}),
 230         "glSamplerParameterf":                                  LogSpec({1: enum("TextureParameter")}),
 231         "glSamplerParameterfv":                                 LogSpec({1: enum("TextureParameter"), 2: pointer(size = "1")}),
 232         "glSamplerParameteri":                                  LogSpec({1: enum("TextureParameter"), 2: lambda name: "getTextureParameterValueStr(pname, %s)" % name}),
 233         "glSamplerParameteriv":                                 LogSpec({1: enum("TextureParameter"), 2: pointer(size = "1")}),
 234         "glSamplerParameterIiv":                                LogSpec({1: enum("TextureParameter"), 2: pointer(size = "getTextureParamNumArgs(pname)")}),
 235         "glSamplerParameterIuiv":                               LogSpec({1: enum("TextureParameter"), 2: pointer(size = "getTextureParamNumArgs(pname)")}),
 236         "glTexSubImage1D":                                              LogSpec({0: enum("TextureTarget"), 4: enum("PixelFormat"), 5: enum("Type")}),
 237         "glTexSubImage2D":                                              LogSpec({0: enum("TextureTarget"), 6: enum("PixelFormat"), 7: enum("Type")}),
 238         "glTexSubImage3D":                                              LogSpec({0: enum("TextureTarget"), 8: enum("PixelFormat"), 9: enum("Type")}),
 239         "glUniform1fv":                                                 LogSpec({2: pointer(size = "(count * 1)")}),
 240         "glUniform1iv":                                                 LogSpec({2: pointer(size = "(count * 1)")}),
 241         "glUniform1uiv":                                                LogSpec({2: pointer(size = "(count * 1)")}),
 242         "glUniform2fv":                                                 LogSpec({2: pointer(size = "(count * 2)")}),
 243         "glUniform2iv":                                                 LogSpec({2: pointer(size = "(count * 2)")}),
 244         "glUniform2uiv":                                                LogSpec({2: pointer(size = "(count * 2)")}),
 245         "glUniform3fv":                                                 LogSpec({2: pointer(size = "(count * 3)")}),
 246         "glUniform3iv":                                                 LogSpec({2: pointer(size = "(count * 3)")}),
 247         "glUniform3uiv":                                                LogSpec({2: pointer(size = "(count * 3)")}),
 248         "glUniform4fv":                                                 LogSpec({2: pointer(size = "(count * 4)")}),
 249         "glUniform4iv":                                                 LogSpec({2: pointer(size = "(count * 4)")}),
 250         "glUniform4uiv":                                                LogSpec({2: pointer(size = "(count * 4)")}),
 251         "glUniformMatrix2fv":                                   LogSpec({3: pointer(size = "(count * 2*2)")}),
 252         "glUniformMatrix3fv":                                   LogSpec({3: pointer(size = "(count * 3*3)")}),
 253         "glUniformMatrix4fv":                                   LogSpec({3: pointer(size = "(count * 4*4)")}),
 254         "glUniformMatrix2x3fv":                                 LogSpec({3: pointer(size = "(count * 2*3)")}),
 255         "glUniformMatrix2x4fv":                                 LogSpec({3: pointer(size = "(count * 2*4)")}),
 256         "glUniformMatrix3x2fv":                                 LogSpec({3: pointer(size = "(count * 3*2)")}),
 257         "glUniformMatrix3x4fv":                                 LogSpec({3: pointer(size = "(count * 3*4)")}),
 258         "glUniformMatrix4x2fv":                                 LogSpec({3: pointer(size = "(count * 4*2)")}),
 259         "glUniformMatrix4x3fv":                                 LogSpec({3: pointer(size = "(count * 4*3)")}),
 260         "glUseProgramStages":                                   LogSpec({1: enum("ShaderTypeMask")}),
 261         "glPatchParameteri":                                    LogSpec({0: enum("PatchParam")}),
 262         "glProgramParameteri":                                  LogSpec({1: enum("ProgramParam")}),
 263         "glProgramUniform1fv":                                  LogSpec({3: pointer(size = "(count * 1)")}),
 264         "glProgramUniform1iv":                                  LogSpec({3: pointer(size = "(count * 1)")}),
 265         "glProgramUniform1uiv":                                 LogSpec({3: pointer(size = "(count * 1)")}),
 266         "glProgramUniform2fv":                                  LogSpec({3: pointer(size = "(count * 2)")}),
 267         "glProgramUniform2iv":                                  LogSpec({3: pointer(size = "(count * 2)")}),
 268         "glProgramUniform2uiv":                                 LogSpec({3: pointer(size = "(count * 2)")}),
 269         "glProgramUniform3fv":                                  LogSpec({3: pointer(size = "(count * 3)")}),
 270         "glProgramUniform3iv":                                  LogSpec({3: pointer(size = "(count * 3)")}),
 271         "glProgramUniform3uiv":                                 LogSpec({3: pointer(size = "(count * 3)")}),
 272         "glProgramUniform4fv":                                  LogSpec({3: pointer(size = "(count * 4)")}),
 273         "glProgramUniform4iv":                                  LogSpec({3: pointer(size = "(count * 4)")}),
 274         "glProgramUniform4uiv":                                 LogSpec({3: pointer(size = "(count * 4)")}),
 275         "glProgramUniformMatrix2fv":                    LogSpec({4: pointer(size = "(count * 2*2)")}),
 276         "glProgramUniformMatrix3fv":                    LogSpec({4: pointer(size = "(count * 3*3)")}),
 277         "glProgramUniformMatrix4fv":                    LogSpec({4: pointer(size = "(count * 4*4)")}),
 278         "glProgramUniformMatrix2x3fv":                  LogSpec({4: pointer(size = "(count * 2*3)")}),
 279         "glProgramUniformMatrix2x4fv":                  LogSpec({4: pointer(size = "(count * 2*4)")}),
 280         "glProgramUniformMatrix3x2fv":                  LogSpec({4: pointer(size = "(count * 3*2)")}),
 281         "glProgramUniformMatrix3x4fv":                  LogSpec({4: pointer(size = "(count * 3*4)")}),
 282         "glProgramUniformMatrix4x3fv":                  LogSpec({4: pointer(size = "(count * 4*3)")}),
 283         "glProgramUniformMatrix4x2fv":                  LogSpec({4: pointer(size = "(count * 4*2)")}),
 284         "glProvokingVertex":                                    LogSpec({0: enum("ProvokingVertex")}),
 285         "glVertexAttrib1fv":                                    LogSpec({1: pointer(size = "1")}),
 286         "glVertexAttrib2fv":                                    LogSpec({1: pointer(size = "2")}),
 287         "glVertexAttrib3fv":                                    LogSpec({1: pointer(size = "3")}),
 288         "glVertexAttrib4fv":                                    LogSpec({1: pointer(size = "4")}),
 289         "glVertexAttrib1sv":                                    LogSpec({1: pointer(size = "1")}),
 290         "glVertexAttrib2sv":                                    LogSpec({1: pointer(size = "2")}),
 291         "glVertexAttrib3sv":                                    LogSpec({1: pointer(size = "3")}),
 292         "glVertexAttrib4sv":                                    LogSpec({1: pointer(size = "4")}),
 293         "glVertexAttrib1dv":                                    LogSpec({1: pointer(size = "1")}),
 294         "glVertexAttrib2dv":                                    LogSpec({1: pointer(size = "2")}),
 295         "glVertexAttrib3dv":                                    LogSpec({1: pointer(size = "3")}),
 296         "glVertexAttrib4dv":                                    LogSpec({1: pointer(size = "4")}),
 297         "glVertexAttrib4bv":                                    LogSpec({1: pointer(size = "4")}),
 298         "glVertexAttrib4iv":                                    LogSpec({1: pointer(size = "4")}),
 299         "glVertexAttrib4ubv":                                   LogSpec({1: pointer(size = "4")}),
 300         "glVertexAttrib4usv":                                   LogSpec({1: pointer(size = "4")}),
 301         "glVertexAttrib4uiv":                                   LogSpec({1: pointer(size = "4")}),
 302         "glVertexAttrib4Nbv":                                   LogSpec({1: pointer(size = "4")}),
 303         "glVertexAttrib4Nsv":                                   LogSpec({1: pointer(size = "4")}),
 304         "glVertexAttrib4Niv":                                   LogSpec({1: pointer(size = "4")}),
 305         "glVertexAttrib4Nubv":                                  LogSpec({1: pointer(size = "4")}),
 306         "glVertexAttrib4Nusv":                                  LogSpec({1: pointer(size = "4")}),
 307         "glVertexAttrib4Nuiv":                                  LogSpec({1: pointer(size = "4")}),
 308         "glVertexAttribI1iv":                                   LogSpec({1: pointer(size = "1")}),
 309         "glVertexAttribI2iv":                                   LogSpec({1: pointer(size = "2")}),
 310         "glVertexAttribI3iv":                                   LogSpec({1: pointer(size = "3")}),
 311         "glVertexAttribI4iv":                                   LogSpec({1: pointer(size = "4")}),
 312         "glVertexAttribI1uiv":                                  LogSpec({1: pointer(size = "1")}),
 313         "glVertexAttribI2uiv":                                  LogSpec({1: pointer(size = "2")}),
 314         "glVertexAttribI3uiv":                                  LogSpec({1: pointer(size = "3")}),
 315         "glVertexAttribI4uiv":                                  LogSpec({1: pointer(size = "4")}),
 316         "glVertexAttribI4bv":                                   LogSpec({1: pointer(size = "4")}),
 317         "glVertexAttribI4sv":                                   LogSpec({1: pointer(size = "4")}),
 318         "glVertexAttribI4ubv":                                  LogSpec({1: pointer(size = "4")}),
 319         "glVertexAttribI4usv":                                  LogSpec({1: pointer(size = "4")}),
 320         "glVertexAttribPointer":                                LogSpec({2: enum("Type")}),
 321         "glVertexAttribIPointer":                               LogSpec({2: enum("Type")}),
 322         "glVertexAttribFormat":                                 LogSpec({2: enum("Type")}),
 323         "glVertexAttribIFormat":                                LogSpec({2: enum("Type")}),
 324         "glInvalidateFramebuffer":                              LogSpec({0: enum("FramebufferTarget"), 2: enumPointer("InvalidateAttachment", "numAttachments")}),
 325         "glInvalidateSubFramebuffer":                   LogSpec({0: enum("FramebufferTarget"), 2: enumPointer("InvalidateAttachment", "numAttachments")}),
 326         "glMapBufferRange":                                             LogSpec({0: enum("BufferTarget"), 3: enum("BufferMapFlags")}),
 327         "glUnmapBuffer":                                                LogSpec({0: enum("BufferTarget")}),
 328         "glFlushMappedBufferRange":                             LogSpec({0: enum("BufferTarget")}),
 329         "glMemoryBarrier":                                              LogSpec({0: enum("MemoryBarrierFlags")}),
 330         "glBindImageTexture":                                   LogSpec({5: enum("ImageAccess"), 6: enum("PixelFormat")}),
 331         "glGetProgramResourceIndex":                    LogSpec({1: enum("ProgramInterface")}),
 332         "glGetProgramResourceiv":
 333                 LogSpec(
 334                         {
 335                                 1: enum("ProgramInterface"),
 336                                 4: enumPointer("ProgramResourceProperty", "propCount")
 337                         },
 338                         argOutPrints =
 339                         {
 340                                 6: pointer(size = "1"),
 341                                 7: pointer(size = "((length == DE_NULL) ? (bufSize) : ((bufSize < *length) ? (bufSize) : (*length)))")
 342                         }),
 343         "glDebugMessageInsert":                                 LogSpec({0: enum("DebugMessageSource"), 1: enum("DebugMessageType"), 3: enum("DebugMessageSeverity")}),
 344         "glDebugMessageControl":                                LogSpec({0: enum("DebugMessageSource"), 1: enum("DebugMessageType"), 2: enum("DebugMessageSeverity"), 4: pointer(size = "(count)")}),
 345         "glDebugMessageCallback":                               LogSpec({0: fnPointer, 1: voidPointer}),
 346         "glPushDebugGroup":                                             LogSpec({0: enum("DebugMessageSource")}),
 347         "glTexBuffer":                                                  LogSpec({0: enum("BufferTarget"), 1: enum("PixelFormat")}),
 348         "glTexBufferRange":                                             LogSpec({0: enum("BufferTarget"), 1: enum("PixelFormat")}),
 349 }
 350
 351 def glwPrefix(string):
 352         return re.sub(r'\bGL', 'glw::GL', string)
 353
 354 def prefixedParams(command):
 355         if len(command.params) > 0:
 356                 return ", ".join(glwPrefix(param.declaration) for param in command.params)
 357         else:
 358                 return "void"
 359
 360 def commandLogWrapperMemberDecl (command):
 361         return "%s\t%s\t(%s);" % (glwPrefix(command.type), command.name, prefixedParams(command))
 362
 363 def getVarDefaultPrint (type, varName):
 364         if re.match(r'^const +(GLchar|GLubyte) *\*$', type):
 365                 return "getStringStr(%s)" % varName
 366         elif re.match(r'(GLubyte|GLbyte|GLenum|GLushort|GLbitfield|\*)$', type):
 367                 return "toHex(%s)" % varName
 368         elif type == 'GLboolean':
 369                 return "getBooleanStr(%s)" % varName
 370         else:
 371                 return varName
 372
 373 def commandLogWrapperMemberDef (command):
 374         src = ""
 375         try:
 376                 logSpec = CALL_LOG_SPECS[command.name]
 377         except KeyError:
 378                 logSpec = None
 379
 380         src += "\n"
 381         src += "%s CallLogWrapper::%s (%s)\n{\n" % (glwPrefix(command.type), command.name, prefixedParams(command))
 382
 383         # Append paramemetrs
 384         callPrintItems = ["\"%s(\"" % command.name]
 385         for paramNdx, param in enumerate(command.params):
 386                 if paramNdx > 0:
 387                         callPrintItems.append("\", \"")
 388
 389                 if logSpec and paramNdx in logSpec.argInPrints:
 390                         callPrintItems.append(logSpec.argInPrints[paramNdx](param.name))
 391                 else:
 392                         callPrintItems.append(getVarDefaultPrint(param.type, param.name))
 393
 394         callPrintItems += ["\");\"", "TestLog::EndMessage"]
 395
 396         src += "\tif (m_enableLog)\n"
 397         src += "\t\tm_log << TestLog::Message << %s;\n" % " << ".join(callPrintItems)
 398
 399         callStr = "m_gl.%s(%s)" % (getFunctionMemberName(command.name), ", ".join([p.name for p in command.params]))
 400
 401         isVoid  = command.type == 'void'
 402         if isVoid:
 403                 src += "\t%s;\n" % callStr
 404         else:
 405                 src += "\t%s returnValue = %s;\n" % (glwPrefix(command.type), callStr)
 406
 407         if logSpec and len(logSpec.argOutPrints) > 0:
 408                 # Print values returned in pointers
 409                 src += "\tif (m_enableLog)\n"
 410                 printouts = ""
 411                 numPrintouts = 0
 412
 413                 for paramNdx, param in enumerate(command.params):
 414                         if paramNdx in logSpec.argOutPrints:
 415                                 printouts += "\t\tm_log << TestLog::Message << \"// %s = \" << %s << TestLog::EndMessage;\n" % (param.name, logSpec.argOutPrints[paramNdx](param.name))
 416                                 numPrintouts += 1
 417
 418                 # If print handlers do not match the actual command, that is very likely an error. Check
 419                 # print handlers is a subset of all arguments.
 420                 if numPrintouts == 0 or len(set(logSpec.argOutPrints.keys()) - set(range(len(command.params)))) > 0:
 421                         raise Exception("Invalid print handlers when processing command %s" % command.name)
 422
 423                 if numPrintouts != 1:
 424                         src += "\t{\n"
 425                 src += printouts
 426                 if numPrintouts != 1:
 427                         src += "\t}\n"
 428
 429         if not isVoid:
 430                 # Print return value
 431                 returnPrint = getVarDefaultPrint(command.type, "returnValue")
 432                 if logSpec and logSpec.returnPrint:
 433                         returnPrint = logSpec.returnPrint("returnValue")
 434
 435                 src += "\tif (m_enableLog)\n"
 436                 src += "\t\tm_log << TestLog::Message << \"// \" << %s << \" returned\" << TestLog::EndMessage;\n" % returnPrint
 437                 src += "\treturn returnValue;\n"
 438
 439         src += "}"
 440         return src
 441
 442 def genCallLogWrapper (iface):
 443         genCommandList(iface, commandLogWrapperMemberDecl, OPENGL_DIR, "gluCallLogWrapperApi.inl", True)
 444         genCommandList(iface, commandLogWrapperMemberDef, OPENGL_DIR, "gluCallLogWrapper.inl", False)
 445
 446 if __name__ == "__main__":
 447         genCallLogWrapper(getHybridInterface())