Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit cf701aa9 authored by Mathias Agopian's avatar Mathias Agopian
Browse files

remove unused code 

Change-Id: If900fcc50f9ffc424e270cb6063b16a2d7bc04d3
parent 751ecf24

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.