tools/glesv2debugger/generate_MessageParser_java.py - platform/development - Git at Google

 #!/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

 if __name__ == "__main__":
     externs = []
     lines = open("../../../frameworks/base/opengl/libs/GLES2_dbg/gl2_api_annotated.in").readlines()
     output = open("src/com/android/glesv2debugger/MessageParser.java", "w")

     i = 0
     output.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_MessageParser_java.py,
 //  which also prints skeleton code for MessageParserEx.java

 package com.android.glesv2debugger;

 import com.android.glesv2debugger.DebuggerMessage.Message;
 import com.android.glesv2debugger.DebuggerMessage.Message.Function;
 import com.google.protobuf.ByteString;

 import java.nio.ByteBuffer;

 public abstract class MessageParser {

     String args;

     String[] getList()
     {
         String arg = args;
         args = args.substring(args.lastIndexOf('}') + 1);
         final int comma = args.indexOf(',');
         if (comma >= 0)
             args = args.substring(comma + 1).trim();
         else
             args = null;

         final int comment = arg.indexOf('=');
         if (comment >= 0)
             arg = arg.substring(comment + 1);
         arg = arg.trim();
         assert arg.charAt(0) == '{';
         arg = arg.substring(1, arg.lastIndexOf('}')).trim();
         return arg.split("\\s*,\\s*");
     }

     ByteString parseFloats(int count) {
         ByteBuffer buffer = ByteBuffer.allocate(count * 4);
         buffer.order(SampleView.targetByteOrder);
         String [] arg = getList();
         for (int i = 0; i < count; i++)
             buffer.putFloat(Float.parseFloat(arg[i].trim()));
         buffer.rewind();
         return ByteString.copyFrom(buffer);
     }

     ByteString parseInts(int count) {
         ByteBuffer buffer = ByteBuffer.allocate(count * 4);
         buffer.order(SampleView.targetByteOrder);
         String [] arg = getList();
         for (int i = 0; i < count; i++)
             buffer.putInt(Integer.parseInt(arg[i].trim()));
         buffer.rewind();
         return ByteString.copyFrom(buffer);
     }

     ByteString parseUInts(int count) {
         ByteBuffer buffer = ByteBuffer.allocate(count * 4);
         buffer.order(SampleView.targetByteOrder);
         String [] arg = getList();
         for (int i = 0; i < count; i++)
             buffer.putInt((int)(Long.parseLong(arg[i].trim()) & 0xffffffff));
         buffer.rewind();
         return ByteString.copyFrom(buffer);
     }

     ByteString parseMatrix(int columns, int count) {
         return parseFloats(columns * columns * count);
     }

     ByteString parseString() {
         // TODO: escape sequence and proper string literal
         String arg = args.substring(args.indexOf('"') + 1, args.lastIndexOf('"'));
         args = args.substring(args.lastIndexOf('"'));
         int comma = args.indexOf(',');
         if (comma >= 0)
             args = args.substring(comma + 1).trim();
         else
             args = null;
         return ByteString.copyFromUtf8(arg);
     }

     String getArgument()
     {
         final int comma = args.indexOf(',');
         String arg = null;
         if (comma >= 0)
         {
             arg = args.substring(0, comma);
             args = args.substring(comma + 1);
         }
         else
         {
             arg = args;
             args = null;
         }
         final int comment = arg.indexOf('=');
         if (comment >= 0)
             arg = arg.substring(comment + 1);
         return arg.trim();
     }

     int parseArgument()
     {
         String arg = getArgument();
         if (arg.startsWith("GL_"))
             return GLEnum.valueOf(arg).value;
         else if (arg.toLowerCase().startsWith("0x"))
             return Integer.parseInt(arg.substring(2), 16);
         else
             return Integer.parseInt(arg);
     }

     int parseFloat()
     {
         String arg = getArgument();
         return Float.floatToRawIntBits(Float.parseFloat(arg));
     }

     public void parse(final Message.Builder builder, String string) {
         int lparen = string.indexOf("("), rparen = string.lastIndexOf(")");
         String s = string.substring(0, lparen).trim();
         args = string.substring(lparen + 1, rparen);
         String[] t = s.split(" ");
         Function function = Function.valueOf(t[t.length - 1]);
         builder.setFunction(function);
         switch (function) {
 """)

     abstractParsers = ""

     for line in lines:
         if line.find("API_ENTRY(") >= 0: # a function prototype
             returnType = line[0: line.find(" API_ENTRY(")].replace("const ", "")
             functionName = line[line.find("(") + 1: line.find(")")] #extract GL function name
             parameterList = line[line.find(")(") + 2: line.find(") {")]

             parameters = parameterList.split(',')
             paramIndex = 0

             #if returnType != "void":
             #else:

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

             paramNames = []
             abstract = False
             argumentSetters = ""
             output.write("\
             case %s:\n" % (functionName))

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

                 argumentParser = ""

                 if parameter.find(":") >= 0:
                     dataSetter = ""
                     assert inout == "" # only one parameter should be annotated
                     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 = annotation
                     else:
                         count = int(annotation)

                     if paramType == "GLfloat":
                         argumentParser = "parseFloats"
                     elif paramType == "GLint":
                         argumentParser = "parseInts"
                     elif paramType == "GLuint":
                         argumentParser = "parseUInts"
                     elif annotation == "GLstring":
                         assert paramType == 'GLchar'
                     elif paramType.find("void") >= 0:
                         assert 1
                     else:
                         assert 0

                     if functionName.find('Matrix') >= 0:
                         columns = int(functionName[functionName.find("fv") - 1: functionName.find("fv")])
                         assert columns * columns == count
                         assert countArg != ""
                         assert paramType == "GLfloat"
                         dataSetter = "builder.setData(parseMatrix(%d, builder.getArg%d()));" % (
                             columns, paramNames.index(countArg))
                     elif annotation == "GLstring":
                         dataSetter = "builder.setData(parseString());"
                     elif paramType.find("void") >= 0:
                         dataSetter = "// TODO"
                         abstract = True
                     elif countArg == "":
                         dataSetter = "builder.setData(%s(%d));" % (argumentParser, count)
                     else:
                         dataSetter = "builder.setData(%s(%d * builder.getArg%d()));" % (
                             argumentParser, count, paramNames.index(countArg))
                     argumentSetters += "\
                 %s // %s %s\n" % (dataSetter, paramType, paramName)
                 else:
                     if paramType == "GLfloat" or paramType == "GLclampf":
                         argumentSetters += "\
                 builder.setArg%d(parseFloat()); // %s %s\n" % (
                     paramIndex, paramType, paramName)
                     elif paramType.find("*") >= 0:
                         argumentSetters += "\
                 // TODO: %s %s\n" % (paramType, paramName)
                         abstract = True
                     else:
                         argumentSetters += "\
                 builder.setArg%d(parseArgument()); // %s %s\n" % (
                     paramIndex, paramType, paramName)
                 paramNames.append(paramName)
                 paramIndex += 1

             if not abstract:
                 output.write("%s" % argumentSetters)
             else:
                 output.write("\
                 parse_%s(builder);\n" % functionName)
                 abstractParsers += "\
     abstract void parse_%s(Message.Builder builder);\n" % functionName
                 print """\
     @Override
     void parse_%s(Message.Builder builder) {
 %s    }
 """ % (functionName, argumentSetters) # print skeleton code for MessageParserEx

             output.write("\
                 break;\n")
     output.write("""\
             default:
                 assert false;
         }
     }
 """)
     output.write(abstractParsers)
     output.write("\
 }""")
	#!/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

	if __name__ == "__main__":
	externs = []
	lines = open("../../../frameworks/base/opengl/libs/GLES2_dbg/gl2_api_annotated.in").readlines()
	output = open("src/com/android/glesv2debugger/MessageParser.java", "w")

	i = 0
	output.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_MessageParser_java.py,
	// which also prints skeleton code for MessageParserEx.java

	package com.android.glesv2debugger;

	import com.android.glesv2debugger.DebuggerMessage.Message;
	import com.android.glesv2debugger.DebuggerMessage.Message.Function;
	import com.google.protobuf.ByteString;

	import java.nio.ByteBuffer;

	public abstract class MessageParser {

	String args;

	String[] getList()
	{
	String arg = args;
	args = args.substring(args.lastIndexOf('}') + 1);
	final int comma = args.indexOf(',');
	if (comma >= 0)
	args = args.substring(comma + 1).trim();
	else
	args = null;

	final int comment = arg.indexOf('=');
	if (comment >= 0)
	arg = arg.substring(comment + 1);
	arg = arg.trim();
	assert arg.charAt(0) == '{';
	arg = arg.substring(1, arg.lastIndexOf('}')).trim();
	return arg.split("\\s,\\s");
	}

	ByteString parseFloats(int count) {
	ByteBuffer buffer = ByteBuffer.allocate(count * 4);
	buffer.order(SampleView.targetByteOrder);
	String [] arg = getList();
	for (int i = 0; i < count; i++)
	buffer.putFloat(Float.parseFloat(arg[i].trim()));
	buffer.rewind();
	return ByteString.copyFrom(buffer);
	}

	ByteString parseInts(int count) {
	ByteBuffer buffer = ByteBuffer.allocate(count * 4);
	buffer.order(SampleView.targetByteOrder);
	String [] arg = getList();
	for (int i = 0; i < count; i++)
	buffer.putInt(Integer.parseInt(arg[i].trim()));
	buffer.rewind();
	return ByteString.copyFrom(buffer);
	}

	ByteString parseUInts(int count) {
	ByteBuffer buffer = ByteBuffer.allocate(count * 4);
	buffer.order(SampleView.targetByteOrder);
	String [] arg = getList();
	for (int i = 0; i < count; i++)
	buffer.putInt((int)(Long.parseLong(arg[i].trim()) & 0xffffffff));
	buffer.rewind();
	return ByteString.copyFrom(buffer);
	}

	ByteString parseMatrix(int columns, int count) {
	return parseFloats(columns * columns * count);
	}

	ByteString parseString() {
	// TODO: escape sequence and proper string literal
	String arg = args.substring(args.indexOf('"') + 1, args.lastIndexOf('"'));
	args = args.substring(args.lastIndexOf('"'));
	int comma = args.indexOf(',');
	if (comma >= 0)
	args = args.substring(comma + 1).trim();
	else
	args = null;
	return ByteString.copyFromUtf8(arg);
	}

	String getArgument()
	{
	final int comma = args.indexOf(',');
	String arg = null;
	if (comma >= 0)
	{
	arg = args.substring(0, comma);
	args = args.substring(comma + 1);
	}
	else
	{
	arg = args;
	args = null;
	}
	final int comment = arg.indexOf('=');
	if (comment >= 0)
	arg = arg.substring(comment + 1);
	return arg.trim();
	}

	int parseArgument()
	{
	String arg = getArgument();
	if (arg.startsWith("GL_"))
	return GLEnum.valueOf(arg).value;
	else if (arg.toLowerCase().startsWith("0x"))
	return Integer.parseInt(arg.substring(2), 16);
	else
	return Integer.parseInt(arg);
	}

	int parseFloat()
	{
	String arg = getArgument();
	return Float.floatToRawIntBits(Float.parseFloat(arg));
	}

	public void parse(final Message.Builder builder, String string) {
	int lparen = string.indexOf("("), rparen = string.lastIndexOf(")");
	String s = string.substring(0, lparen).trim();
	args = string.substring(lparen + 1, rparen);
	String[] t = s.split(" ");
	Function function = Function.valueOf(t[t.length - 1]);
	builder.setFunction(function);
	switch (function) {
	""")

	abstractParsers = ""

	for line in lines:
	if line.find("API_ENTRY(") >= 0: # a function prototype
	returnType = line[0: line.find(" API_ENTRY(")].replace("const ", "")
	functionName = line[line.find("(") + 1: line.find(")")] #extract GL function name
	parameterList = line[line.find(")(") + 2: line.find(") {")]

	parameters = parameterList.split(',')
	paramIndex = 0

	#if returnType != "void":
	#else:

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

	paramNames = []
	abstract = False
	argumentSetters = ""
	output.write("\
	case %s:\n" % (functionName))

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

	argumentParser = ""

	if parameter.find(":") >= 0:
	dataSetter = ""
	assert inout == "" # only one parameter should be annotated
	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 = annotation
	else:
	count = int(annotation)

	if paramType == "GLfloat":
	argumentParser = "parseFloats"
	elif paramType == "GLint":
	argumentParser = "parseInts"
	elif paramType == "GLuint":
	argumentParser = "parseUInts"
	elif annotation == "GLstring":
	assert paramType == 'GLchar'
	elif paramType.find("void") >= 0:
	assert 1
	else:
	assert 0

	if functionName.find('Matrix') >= 0:
	columns = int(functionName[functionName.find("fv") - 1: functionName.find("fv")])
	assert columns * columns == count
	assert countArg != ""
	assert paramType == "GLfloat"
	dataSetter = "builder.setData(parseMatrix(%d, builder.getArg%d()));" % (
	columns, paramNames.index(countArg))
	elif annotation == "GLstring":
	dataSetter = "builder.setData(parseString());"
	elif paramType.find("void") >= 0:
	dataSetter = "// TODO"
	abstract = True
	elif countArg == "":
	dataSetter = "builder.setData(%s(%d));" % (argumentParser, count)
	else:
	dataSetter = "builder.setData(%s(%d * builder.getArg%d()));" % (
	argumentParser, count, paramNames.index(countArg))
	argumentSetters += "\
	%s // %s %s\n" % (dataSetter, paramType, paramName)
	else:
	if paramType == "GLfloat" or paramType == "GLclampf":
	argumentSetters += "\
	builder.setArg%d(parseFloat()); // %s %s\n" % (
	paramIndex, paramType, paramName)
	elif paramType.find("*") >= 0:
	argumentSetters += "\
	// TODO: %s %s\n" % (paramType, paramName)
	abstract = True
	else:
	argumentSetters += "\
	builder.setArg%d(parseArgument()); // %s %s\n" % (
	paramIndex, paramType, paramName)
	paramNames.append(paramName)
	paramIndex += 1

	if not abstract:
	output.write("%s" % argumentSetters)
	else:
	output.write("\
	parse_%s(builder);\n" % functionName)
	abstractParsers += "\
	abstract void parse_%s(Message.Builder builder);\n" % functionName
	print """\
	@Override
	void parse_%s(Message.Builder builder) {
	%s }
	""" % (functionName, argumentSetters) # print skeleton code for MessageParserEx

	output.write("\
	break;\n")
	output.write("""\
	default:
	assert false;
	}
	}
	""")
	output.write(abstractParsers)
	output.write("\
	}""")