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

Commit 6dc813c9 authored by Mathias Agopian's avatar Mathias Agopian Committed by Android (Google) Code Review
Browse files

Merge "remove unused code"

parents 0f102020 cf701aa9
Loading
Loading
Loading
Loading
+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)

+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 {
""")           
    
            
+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)
	
+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"')
+0 −426

File deleted.

Preview size limit exceeded, changes collapsed.

Loading