Merge "remove unused code" (6dc813c9) · Commits · e / os / android_frameworks_native-old

opengl/libs/GLES2_dbg/generate_api_cpp.py

deleted100755 → 0

+0 −219

Original line number	Diff line number	Diff line
		#!/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 = ["glDrawArrays", "glDrawElements"]

		# these have an EXTEND_Debug_* macro for getting data
		extendFunctions = ["glCopyTexImage2D", "glCopyTexSubImage2D", "glReadPixels",
		"glShaderSource", "glTexImage2D", "glTexSubImage2D"]

		# 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;"

		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 extendFunctions:
		print "\
		#ifdef EXTEND_AFTER_CALL_Debug_%s\n\
		EXTEND_AFTER_CALL_Debug_%s;\n\
		#endif" % (functionName, functionName)
		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 "\
		#ifdef EXTEND_Debug_%s\n\
		EXTEND_Debug_%s;\n\
		#endif" % (functionName, functionName)
		print " int * ret = MessageLoop(caller, msg, 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 <utils/Debug.h>

		#include "src/header.h"
		#include "src/api.h"

		template<typename T> static int ToInt(const T & t)
		{
		COMPILE_TIME_ASSERT_FUNCTION_SCOPE(sizeof(T) == sizeof(int));
		return (int &)t;
		}
		"""
		lines = open("gl2_api_annotated.in").readlines()
		generate_api(lines)
		#lines = open("gl2ext_api.in").readlines()
		#generate_api(lines)

opengl/libs/GLES2_dbg/generate_caller_cpp.py

deleted100755 → 0

+0 −199

Original line number	Diff line number	Diff line
		#!/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

		externs = []

		def generate_caller(lines):
		i = 0
		output = ""
		skipFunctions = []

		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
		output += "\
		case glesv2debugger::Message_Function_%s:\n" % functionName
		parameters = parameterList.split(',')
		paramIndex = 0
		if line.find("") >= 0 and (line.find("") < line.find(":") or line.find("*") > line.rfind(":")): # unannotated pointer
		# add function to list of functions that should be hand written, but generate code anyways
		externs.append(functionName)
		output += "\
		ret = GenerateCall_%s(dbg, cmd, msg, prevRet);\n\
		break;\n" % (functionName)
		continue
		elif line.find(":out") >= 0 or line.find(":inout") >= 0:
		externs.append(functionName)
		output += "\
		ret = GenerateCall_%s(dbg, cmd, msg, prevRet);\n\
		break; // annotated output pointers\n" % (functionName)
		continue

		if parameterList == "void":
		parameters = []
		arguments = ""
		paramNames = []
		inout = ""
		getData = ""

		callerMembers = ""

		for parameter in parameters:
		const = parameter.find("const")
		parameter = parameter.replace("const", "")
		parameter = parameter.strip()
		paramType = parameter.split(' ')[0]
		paramName = parameter.split(' ')[1]
		annotation = ""
		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)

		paramType += "*"
		arguments += "reinterpret_cast<%s>(const_cast<char *>(cmd.data().data()))" % (paramType)
		elif paramType == "GLboolean":
		arguments += "GLboolean(cmd.arg%d())" % (paramIndex)
		else:
		arguments += "static_cast<%s>(cmd.arg%d())" % (paramType, paramIndex)

		if paramIndex < len(parameters) - 1:
		arguments += ", "
		if len(arguments) - arguments.rfind("\n") > 60 :
		arguments += "\n\
		"
		if const >= 0:
		paramType = "const " + paramType
		paramNames.append(paramName)
		paramIndex += 1

		if returnType == "void":
		output += "\
		dbg->hooks->gl.%s(\n\
		%s);\n\
		break;\n" % (functionName, arguments)
		else:
		output += "\
		msg.set_ret(static_cast<int>(dbg->hooks->gl.%s(\n\
		%s)));\n\
		if (cmd.has_ret())\n\
		ret = reinterpret_cast<int *>(msg.ret());\n\
		break;\n" % (functionName, arguments)
		return output

		if __name__ == "__main__":

		lines = open("gl2_api_annotated.in").readlines()
		output = generate_caller(lines)

		out = open("src/caller.cpp", "w")
		out.write("""\
		/*
		** 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_caller_cpp.py
		// implement declarations in caller.h

		#include "header.h"

		namespace android {

		""")

		for extern in externs:
		out.write("\
		static const int * GenerateCall_%s(DbgContext * const dbg,\n\
		const glesv2debugger::Message & cmd, glesv2debugger::Message & msg, const int * const prevRet);\n" % (extern))
		print("\
		static const int * GenerateCall_%s(DbgContext * const dbg,\n\
		const glesv2debugger::Message & cmd,\n\
		glesv2debugger::Message & msg, const int * const prevRet)\n\
		{ assert(0); return prevRet; }\n" % (extern))

		out.write(
		"""
		#include "caller.h"

		const int * GenerateCall(DbgContext * const dbg, const glesv2debugger::Message & cmd,
		glesv2debugger::Message & msg, const int * const prevRet)
		{
		LOGD("GenerateCall function=%u", cmd.function());
		const int * ret = prevRet; // only some functions have return value
		nsecs_t c0 = systemTime(timeMode);
		switch (cmd.function()) {""")

		out.write(output)

		out.write("""\
		default:
		assert(0);
		}
		msg.set_time((systemTime(timeMode) - c0) * 1e-6f);
		msg.set_context_id(reinterpret_cast<int>(dbg));
		msg.set_function(cmd.function());
		msg.set_type(glesv2debugger::Message_Type_AfterCall);
		return ret;
		}

		}; // name space android {
		""")

opengl/libs/GLES2_dbg/generate_debug_in.py

deleted100755 → 0

+0 −80

Original line number	Diff line number	Diff line
		#!/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 append_functions(functions, lines):
		i = 0
		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(") {")]

		functions.append(functionName)
		#print functionName
		continue

		parameters = parameterList.split(',')
		paramIndex = 0
		if line.find("*") >= 0:
		print "// FIXME: this function has pointers, it should be hand written"
		externs.append("%s Tracing_%s(%s);" % (returnType, functionName, parameterList))
		print "%s Tracing_%s(%s)\n{" % (returnType, functionName, parameterList)

		if parameterList == "void":
		parameters = []

		arguments = ""

		for parameter in parameters:
		parameter = parameter.replace("const", "")
		parameter = parameter.strip()
		paramType = parameter.split(' ')[0]
		paramName = parameter.split(' ')[1]

		paramIndex += 1

		return functions



		if __name__ == "__main__":
		definedFunctions = []
		lines = open("gl2_api_annotated.in").readlines()
		definedFunctions = append_functions(definedFunctions, lines)

		output = open("../debug.in", "w")
		lines = open("../trace.in").readlines()
		output.write("// the following functions are not defined in GLESv2_dbg\n")
		for line in lines:
		functionName = ""
		if line.find("TRACE_GL(") >= 0: # a function prototype
		functionName = line.split(',')[1].strip()
		elif line.find("TRACE_GL_VOID(") >= 0: # a function prototype
		functionName = line[line.find("(") + 1: line.find(",")] #extract GL function name
		else:
		continue
		if functionName in definedFunctions:
		#print functionName
		continue
		else:
		output.write(line)

opengl/libs/GLES2_dbg/generate_debugger_message_proto.py

deleted100755 → 0

+0 −155

Original line number	Diff line number	Diff line
		#!/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

		def generate_egl_entries(output, lines, i):
		for line in lines:
		if line.find("EGL_ENTRY(") >= 0:
		line = line.split(",")[1].strip() #extract EGL function name
		output.write(" %s = %d;\n" % (line, i))
		i += 1
		return i


		def generate_gl_entries(output,lines,i):
		for line in lines:
		if line.find("API_ENTRY(") >= 0:
		line = line[line.find("(") + 1: line.find(")")] #extract GL function name
		output.write(" %s = %d;\n" % (line, i))
		i += 1
		return i


		if __name__ == "__main__":
		output = open("debugger_message.proto",'w')
		output.write("""\
		/*
		* Copyright (C) 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.
		*/

		// do not edit; auto generated by generate_debugger_message_proto.py

		package com.android.glesv2debugger;

		option optimize_for = LITE_RUNTIME;

		message Message
		{
		required int32 context_id = 1; // GL context id
		enum Function
		{
		""")

		i = 0;

		lines = open("gl2_api_annotated.in").readlines()
		i = generate_gl_entries(output, lines, i)
		output.write(" // end of GL functions\n")

		#lines = open("gl2ext_api.in").readlines()
		#i = generate_gl_entries(output, lines, i)
		#output.write(" // end of GL EXT functions\n")

		lines = open("../EGL/egl_entries.in").readlines()
		i = generate_egl_entries(output, lines, i)
		output.write(" // end of GL EXT functions\n")

		output.write(" ACK = %d;\n" % (i))
		i += 1

		output.write(" NEG = %d;\n" % (i))
		i += 1

		output.write(" CONTINUE = %d;\n" % (i))
		i += 1

		output.write(" SKIP = %d;\n" % (i))
		i += 1

		output.write(" SETPROP = %d;\n" % (i))
		i += 1

		output.write(""" }
		required Function function = 2 [default = NEG]; // type/function of message
		enum Type
		{
		BeforeCall = 0;
		AfterCall = 1;
		AfterGeneratedCall = 2;
		Response = 3; // currently used for misc messages
		CompleteCall = 4; // BeforeCall and AfterCall merged
		}
		required Type type = 3;
		required bool expect_response = 4;
		optional int32 ret = 5; // return value from previous GL call
		optional int32 arg0 = 6; // args to GL call
		optional int32 arg1 = 7;
		optional int32 arg2 = 8;
		optional int32 arg3 = 9;
		optional int32 arg4 = 16;
		optional int32 arg5 = 17;
		optional int32 arg6 = 18;
		optional int32 arg7 = 19; // glDrawArrays/Elements sets this to active number of attributes
		optional int32 arg8 = 20;

		optional bytes data = 10; // variable length data used for GL call
		enum DataType
		{
		ReferencedImage = 0; // for image sourced from ReadPixels
		NonreferencedImage = 1; // for image sourced from ReadPixels
		};
		// most data types can be inferred from function
		optional DataType data_type = 23;
		// these are used for image data when they cannot be determined from args
		optional int32 pixel_format = 24;
		optional int32 pixel_type = 25;
		optional int32 image_width = 26;
		optional int32 image_height = 27;

		optional float time = 11; // duration of previous GL call (ms)
		enum Prop
		{
		CaptureDraw = 0; // arg0 = number of glDrawArrays/Elements to glReadPixels
		TimeMode = 1; // arg0 = SYSTEM_TIME_* in utils/Timers.h
		ExpectResponse = 2; // arg0 = enum Function, arg1 = true/false
		CaptureSwap = 3; // arg0 = number of eglSwapBuffers to glReadPixels
		GLConstant = 4; // arg0 = GLenum, arg1 = constant; send GL impl. constants
		};
		optional Prop prop = 21; // used with SETPROP, value in arg0
		optional float clock = 22; // wall clock in seconds
		}
		""")

		output.close()

		os.system("aprotoc --cpp_out=src --java_out=../../../../../development/tools/glesv2debugger/src debugger_message.proto")
		os.system('mv -f "src/debugger_message.pb.cc" "src/debugger_message.pb.cpp"')

opengl/libs/GLES2_dbg/gl2_api_annotated.in

deleted100644 → 0

+0 −426

File deleted.

Preview size limit exceeded, changes collapsed.