replicant-frameworks_native/opengl/libs/GLES2_dbg/generate_api_cpp.py
David Li 65948aa046 GLES2Debugger: Added DbgContext and vertex data capturing.
Send VBO related commands to client, which tracks the state.
Maintain index buffer content and vertex attrib pointer/buffer state on server.
During glDrawArrays/Elements, send user memory data to client.

Change-Id: Ia920e90479329b301ae4b5735e833eeb20293c94
Signed-off-by: David Li <davidxli@google.com>
2011-03-10 16:40:37 -08:00

208 lines
9.3 KiB
Python
Executable File

#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright 2011, The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import os
import sys
def RemoveAnnotation(line):
if line.find(":") >= 0:
annotation = line[line.find(":"): line.find(" ", line.find(":"))]
return line.replace(annotation, "*")
else:
return line
def generate_api(lines):
externs = []
i = 0
# these have been hand written
skipFunctions = ["glTexImage2D", "glTexSubImage2D", "glReadPixels",
"glDrawArrays", "glDrawElements"]
# these have an EXTEND_Debug_* macro for getting data
extendFunctions = ["glCopyTexImage2D", "glCopyTexSubImage2D", "glShaderSource"]
# these also needs to be forwarded to DbgContext
contextFunctions = ["glUseProgram", "glEnableVertexAttribArray", "glDisableVertexAttribArray",
"glVertexAttribPointer", "glBindBuffer", "glBufferData", "glBufferSubData", "glDeleteBuffers",]
for line in lines:
if line.find("API_ENTRY(") >= 0: # a function prototype
returnType = line[0: line.find(" API_ENTRY(")]
functionName = line[line.find("(") + 1: line.find(")")] #extract GL function name
parameterList = line[line.find(")(") + 2: line.find(") {")]
#if line.find("*") >= 0:
# extern = "%s Debug_%s(%s);" % (returnType, functionName, parameterList)
# externs.append(extern)
# continue
if functionName in skipFunctions:
sys.stderr.write("!\n! skipping function '%s'\n!\n" % (functionName))
continue
parameters = parameterList.split(',')
paramIndex = 0
if line.find("*") >= 0 and (line.find("*") < line.find(":") or line.find("*") > line.rfind(":")): # unannotated pointer
if not functionName in extendFunctions:
# add function to list of functions that should be hand written, but generate code anyways
extern = "%s Debug_%s(%s);" % (returnType, functionName, RemoveAnnotation(parameterList))
sys.stderr.write("%s should be hand written\n" % (extern))
print "// FIXME: this function has pointers, it should be hand written"
externs.append(extern)
print "%s Debug_%s(%s)\n{" % (returnType, functionName, RemoveAnnotation(parameterList))
print """ glesv2debugger::Message msg;
const bool expectResponse = false;"""
if parameterList == "void":
parameters = []
arguments = ""
paramNames = []
inout = ""
getData = ""
callerMembers = ""
setCallerMembers = ""
setMsgParameters = ""
for parameter in parameters:
const = parameter.find("const")
parameter = parameter.replace("const", "")
parameter = parameter.strip()
paramType = parameter.split(' ')[0]
paramName = parameter.split(' ')[1]
annotation = ""
arguments += paramName
if parameter.find(":") >= 0: # has annotation
assert inout == "" # only one parameter should be annotated
sys.stderr.write("%s is annotated: %s \n" % (functionName, paramType))
inout = paramType.split(":")[2]
annotation = paramType.split(":")[1]
paramType = paramType.split(":")[0]
count = 1
countArg = ""
if annotation.find("*") >= 0: # [1,n] * param
count = int(annotation.split("*")[0])
countArg = annotation.split("*")[1]
assert countArg in paramNames
elif annotation in paramNames:
count = 1
countArg = annotation
elif annotation == "GLstring":
annotation = "strlen(%s)" % (paramName)
else:
count = int(annotation)
setMsgParameters += " msg.set_arg%d(ToInt(%s));\n" % (paramIndex, paramName)
if paramType.find("void") >= 0:
getData += " msg.mutable_data()->assign(reinterpret_cast<const char *>(%s), %s * sizeof(char));" % (paramName, annotation)
else:
getData += " msg.mutable_data()->assign(reinterpret_cast<const char *>(%s), %s * sizeof(%s));" % (paramName, annotation, paramType)
paramType += "*"
else:
if paramType == "GLfloat" or paramType == "GLclampf" or paramType.find("*") >= 0:
setMsgParameters += " msg.set_arg%d(ToInt(%s));\n" % (paramIndex, paramName)
else:
setMsgParameters += " msg.set_arg%d(%s);\n" % (paramIndex, paramName)
if paramIndex < len(parameters) - 1:
arguments += ', '
if const >= 0:
paramType = "const " + paramType
paramNames.append(paramName)
paramIndex += 1
callerMembers += " %s %s;\n" % (paramType, paramName)
setCallerMembers += " caller.%s = %s;\n" % (paramName, paramName)
print " struct : public FunctionCall {"
print callerMembers
print " const int * operator()(gl_hooks_t::gl_t const * const _c, glesv2debugger::Message & msg) {"
if inout in ["out", "inout"]: # get timing excluding output data copy
print " nsecs_t c0 = systemTime(timeMode);"
if returnType == "void":
print " _c->%s(%s);" % (functionName, arguments)
else:
print " const int * ret = reinterpret_cast<const int *>(_c->%s(%s));" % (functionName, arguments)
print " msg.set_ret(ToInt(ret));"
if inout in ["out", "inout"]:
print " msg.set_time((systemTime(timeMode) - c0) * 1e-6f);"
print " " + getData
if functionName in contextFunctions:
print " getDbgContextThreadSpecific()->%s(%s);" % (functionName, arguments)
if returnType == "void":
print " return 0;"
else:
print " return ret;"
print """ }
} caller;"""
print setCallerMembers
print setMsgParameters
if line.find("*") >= 0 or line.find(":") >= 0:
print " // FIXME: check for pointer usage"
if inout in ["in", "inout"]:
print getData
if functionName in extendFunctions:
print " EXTEND_Debug_%s;" % (functionName)
print " int * ret = MessageLoop(caller, msg, expectResponse,"
print " glesv2debugger::Message_Function_%s);" % (functionName)
if returnType != "void":
if returnType == "GLboolean":
print " return static_cast<GLboolean>(reinterpret_cast<int>(ret));"
else:
print " return reinterpret_cast<%s>(ret);" % (returnType)
print "}\n"
print "// FIXME: the following functions should be written by hand"
for extern in externs:
print extern
if __name__ == "__main__":
print """\
/*
** Copyright 2011, The Android Open Source Project
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/
// auto generated by generate_api_cpp.py
#include "src/header.h"
#include "src/api.h"
template<typename T> static int ToInt(const T & t) { STATIC_ASSERT(sizeof(T) == sizeof(int), bitcast); return (int &)t; }
template<typename T> static T FromInt(const int & t) { STATIC_ASSERT(sizeof(T) == sizeof(int), bitcast); return (T &)t; }
"""
lines = open("gl2_api_annotated.in").readlines()
generate_api(lines)
#lines = open("gl2ext_api.in").readlines()
#generate_api(lines)