X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=glretrace.py;h=c5ec3aee463b8638b733e743a680707ef4d34873;hb=cdb574a380a229e491dc977d490af880687f6768;hp=a9fb82cb341f79fc291f03044df749d423df861d;hpb=e6a50bd11a981afdb13501cb739b1666bbf444eb;p=apitrace diff --git a/glretrace.py b/glretrace.py index a9fb82c..c5ec3ae 100644 --- a/glretrace.py +++ b/glretrace.py @@ -24,293 +24,214 @@ ##########################################################################/ -import base +import stdapi import glapi +from retrace import Retracer +class GlRetracer(Retracer): -class ConstRemover(base.Rebuilder): + def retrace_function(self, function): + Retracer.retrace_function(self, function) - def visit_const(self, const): - return const.type - - def visit_opaque(self, opaque): - expr = opaque.expr - if expr.startswith('const '): - expr = expr[6:] - return base.Opaque(expr) - - -class ValueExtractor(base.Visitor): - - def visit_literal(self, literal, lvalue, rvalue): - print ' %s = %s;' % (lvalue, rvalue) - - def visit_alias(self, alias, lvalue, rvalue): - self.visit(alias.type, lvalue, rvalue) - - def visit_enum(self, enum, lvalue, rvalue): - print ' %s = %s;' % (lvalue, rvalue) - - def visit_bitmask(self, bitmask, lvalue, rvalue): - self.visit(bitmask.type, lvalue, rvalue) - - def visit_array(self, array, lvalue, rvalue): - print ' const Trace::Array *__a%s = dynamic_cast(&%s);' % (array.id, rvalue) - print ' if (__a%s) {' % (array.id) - length = '__a%s->values.size()' % array.id - print ' %s = new %s[%s];' % (lvalue, array.type, length) - index = '__i' + array.id - print ' for(size_t {i} = 0; {i} < {length}; ++{i}) {{'.format(i = index, length = length) - try: - self.visit(array.type, '%s[%s]' % (lvalue, index), '*__a%s->values[%s]' % (array.id, index)) - finally: - print ' }' - print ' } else {' - print ' %s = NULL;' % lvalue + def call_function(self, function): + if function.name in ("glDrawArrays", "glDrawElements", "glDrawRangeElements", "glMultiDrawElements"): + print ' GLint __array_buffer = 0;' + print ' glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &__array_buffer);' + print ' if (!__array_buffer) {' + self.fail_function(function) print ' }' - - def visit_pointer(self, pointer, lvalue, rvalue): - # FIXME - raise NotImplementedError - - def visit_handle(self, handle, lvalue, rvalue): - self.visit(handle.type, lvalue, "__%s_map[%s]" %(handle.name, rvalue)); - print ' std::cout << "%s " << static_cast<%s>(%s) << " <- " << %s << "\\n";' % (handle.name, handle.type, rvalue, lvalue) - - def visit_blob(self, blob, lvalue, rvalue): - print ' %s = static_cast<%s>((%s).blob());' % (lvalue, blob, rvalue) - - def visit_string(self, string, lvalue, rvalue): - print ' %s = (%s)((%s).string());' % (lvalue, string.expr, rvalue) - - -class ValueWrapper(base.Visitor): - - def visit_literal(self, literal, lvalue, rvalue): - pass - - def visit_alias(self, alias, lvalue, rvalue): - self.visit(alias.type, lvalue, rvalue) - - def visit_enum(self, enum, lvalue, rvalue): - pass - - def visit_bitmask(self, bitmask, lvalue, rvalue): - pass - - def visit_array(self, array, lvalue, rvalue): - print ' const Trace::Array *__a%s = dynamic_cast(&%s);' % (array.id, rvalue) - print ' if (__a%s) {' % (array.id) - length = '__a%s->values.size()' % array.id - index = '__i' + array.id - print ' for(size_t {i} = 0; {i} < {length}; ++{i}) {{'.format(i = index, length = length) - try: - self.visit(array.type, '%s[%s]' % (lvalue, index), '*__a%s->values[%s]' % (array.id, index)) - finally: - print ' }' + if function.name == "glViewport": + print ' if (x + width > __window_width) {' + print ' __window_width = x + width;' + print ' __reshape_window = true;' print ' }' - - def visit_pointer(self, pointer, lvalue, rvalue): - # FIXME - raise NotImplementedError - - def visit_handle(self, handle, lvalue, rvalue): - print " __%s_map[static_cast<%s>(%s)] = %s;" % (handle.name, handle.type, rvalue, lvalue) - print ' std::cout << "%s " << static_cast<%s>(%s) << " -> " << %s << "\\n";' % (handle.name, handle.type, rvalue, lvalue) - - def visit_blob(self, blob, lvalue, rvalue): - pass - - def visit_string(self, string, lvalue, rvalue): - pass - - - -def retrace_function(function): - print 'static void retrace_%s(Trace::Call &call) {' % function.name - success = True - for arg in function.args: - arg.type = ConstRemover().visit(arg.type) - print ' %s %s;' % (arg.type, arg.name) - rvalue = 'call.arg("%s")' % (arg.name,) - lvalue = arg.name - try: - ValueExtractor().visit(arg.type, lvalue, rvalue) - except NotImplementedError: - success = False - print ' %s = 0; // FIXME' % arg.name - if not success: - print ' std::cerr << "warning: unsupported call %s\\n";' % function.name - print ' return;' - arg_names = ", ".join([arg.name for arg in function.args]) - if function.type is not base.Void: - print ' %s __result;' % (function.type) - print ' __result = %s(%s);' % (function.name, arg_names) - else: - print ' %s(%s);' % (function.name, arg_names) - for arg in function.args: - if arg.output: - arg.type = ConstRemover().visit(arg.type) - rvalue = 'call.arg("%s")' % (arg.name,) - lvalue = arg.name - try: - ValueWrapper().visit(arg.type, lvalue, rvalue) - except NotImplementedError: - print ' // FIXME: %s' % arg.name - if function.type is not base.Void: - rvalue = '*call.ret' - lvalue = '__result' - try: - ValueWrapper().visit(function.type, lvalue, rvalue) - except NotImplementedError: - print ' // FIXME: result' - print '}' - print - - -def retrace_functions(functions): - for function in functions: - if function.sideeffects: - retrace_function(function) - - print 'static bool retrace_call(Trace::Call &call) {' - for function in functions: - if not function.sideeffects: - print ' if (call.name == "%s") {' % function.name - print ' return true;' - print ' }' - print - print ' std::cout << call;' - print ' std::cout.flush();' - print - for function in functions: - if function.sideeffects: - print ' if (call.name == "%s") {' % function.name - print ' retrace_%s(call);' % function.name - print ' return true;' + print ' if (y + height > __window_height) {' + print ' __window_height = y + height;' + print ' __reshape_window = true;' print ' }' - print ' std::cerr << "warning: unsupported call " << call.name << "\\n";' - print ' return false;' - print '}' - print - - -def retrace_api(api): - types = api.all_types() - - handles = [type for type in types if isinstance(type, base.Handle)] - for handle in handles: - print 'static std::map<%s, %s> __%s_map;' % (handle.type, handle.type, handle.name) - print - retrace_functions(api.functions) + if function.name == "glEnd": + print ' insideGlBeginEnd = false;' + + Retracer.call_function(self, function) + + if function.name == "glBegin": + print ' insideGlBeginEnd = true;' + else: + # glGetError is not allowed inside glBegin/glEnd + print ' checkGlError();' + + + def extract_arg(self, function, arg, arg_type, lvalue, rvalue): + if function.name in [ + "glColorPointer", + "glEdgeFlagPointer", + "glIndexPointer", + "glNormalPointer", + "glTexCoordPointer", + "glVertexPointer", + "glFogCoordPointer", + "glSecondaryColorPointer", + "glVertexAttribPointer", + ] and arg.name == 'pointer': + self.extract_pointer(function, arg, arg_type, lvalue, rvalue) + else: + Retracer.extract_arg(self, function, arg, arg_type, lvalue, rvalue) + + def extract_pointer(self, function, arg, arg_type, lvalue, rvalue): + print ' if (dynamic_cast(&%s)) {' % rvalue + print ' %s = 0;' % (lvalue) + print ' } else {' + print ' %s = (%s)(uintptr_t)(%s);' % (lvalue, arg_type, rvalue) + print ' }' if __name__ == '__main__': print - print '#include ' print '#include ' - print '#include ' + print '#include ' + print + print '#include "glproc.hpp"' print '#include ' print - print '#include "trace_parser.hpp"' + print 'static bool double_buffer = false;' + print 'static bool insideGlBeginEnd = false;' + print 'static int __window_width = 256, __window_height = 256;' + print 'bool __reshape_window = false;' print - retrace_api(glapi.glapi) + print ''' +static void +checkGlError(void) { + if (insideGlBeginEnd) { + return; + } + + GLenum error = glGetError(); + if (error == GL_NO_ERROR) { + return; + } + + std::cerr << "warning: glGetError() = "; + switch (error) { + case GL_INVALID_ENUM: + std::cerr << "GL_INVALID_ENUM"; + break; + case GL_INVALID_VALUE: + std::cerr << "GL_INVALID_VALUE"; + break; + case GL_INVALID_OPERATION: + std::cerr << "GL_INVALID_OPERATION"; + break; + case GL_STACK_OVERFLOW: + std::cerr << "GL_STACK_OVERFLOW"; + break; + case GL_STACK_UNDERFLOW: + std::cerr << "GL_STACK_UNDERFLOW"; + break; + case GL_OUT_OF_MEMORY: + std::cerr << "GL_OUT_OF_MEMORY"; + break; + case GL_INVALID_FRAMEBUFFER_OPERATION: + std::cerr << "GL_INVALID_FRAMEBUFFER_OPERATION"; + break; + case GL_TABLE_TOO_LARGE: + std::cerr << "GL_TABLE_TOO_LARGE"; + break; + default: + std::cerr << error; + break; + } + std::cerr << "\\n"; +} +''' + api = glapi.glapi + retracer = GlRetracer() + retracer.retrace_api(glapi.glapi) print ''' -Trace::Parser parser; - -static bool insideGlBeginEnd; +static Trace::Parser parser; static void display(void) { - Trace::Call *call; - - while ((call = parser.parse_call())) { - if (call->name == "glFlush" || - call->name == "glXSwapBuffers" || - call->name == "wglSwapBuffers") { - glFlush(); - return; - } - - retrace_call(*call); - - if (call->name == "glBegin") { - insideGlBeginEnd = true; - } - - if (call->name == "glEnd") { - insideGlBeginEnd = false; - } - - if (!insideGlBeginEnd) { - GLenum error = glGetError(); - if (error != GL_NO_ERROR) { - std::cerr << "warning: glGetError() = "; - switch (error) { - case GL_INVALID_ENUM: - std::cerr << "GL_INVALID_ENUM"; - break; - case GL_INVALID_VALUE: - std::cerr << "GL_INVALID_VALUE"; - break; - case GL_INVALID_OPERATION: - std::cerr << "GL_INVALID_OPERATION"; - break; - case GL_STACK_OVERFLOW: - std::cerr << "GL_STACK_OVERFLOW"; - break; - case GL_STACK_UNDERFLOW: - std::cerr << "GL_STACK_UNDERFLOW"; - break; - case GL_OUT_OF_MEMORY: - std::cerr << "GL_OUT_OF_MEMORY"; - break; - case GL_INVALID_FRAMEBUFFER_OPERATION: - std::cerr << "GL_INVALID_FRAMEBUFFER_OPERATION"; - break; - case GL_TABLE_TOO_LARGE: - std::cerr << "GL_TABLE_TOO_LARGE"; - break; - default: - std::cerr << error; - break; + Trace::Call *call; + + while ((call = parser.parse_call())) { + if (call->name() == "glFlush") { + glFlush(); + return; + } + + if (!retrace_call(*call)) { + if (call->name() == "glXSwapBuffers" || + call->name() == "wglSwapBuffers") { + if (double_buffer) + glutSwapBuffers(); + else + glFlush(); + return; } - std::cerr << "\\n"; - } - } - } + } + } - glFlush(); - glutIdleFunc(NULL); + glFlush(); + glutIdleFunc(NULL); } static void idle(void) { - glutPostRedisplay(); + if (__reshape_window) { + // XXX: doesn't quite work + glutReshapeWindow(__window_width, __window_height); + __reshape_window = false; + } + glutPostRedisplay(); } int main(int argc, char **argv) { - glutInit(&argc, argv); - glutInitWindowPosition(0, 0); - glutInitWindowSize(800, 600); - glutInitDisplayMode(GLUT_DEPTH | GLUT_RGB | GLUT_SINGLE); - glutCreateWindow(argv[0]); - glewInit(); - - glutDisplayFunc(&display); - glutIdleFunc(&idle); - - for (int i = 1; i < argc; ++i) { - if (parser.open(argv[i])) { - glutMainLoop(); - parser.close(); - } - } - return 0; + int i; + for (i = 1; i < argc; ++i) { + const char *arg = argv[i]; + + if (arg[0] != '-') { + break; + } + + if (!strcmp(arg, "--")) { + break; + } + else if (!strcmp(arg, "-db")) { + double_buffer = true; + } else if (!strcmp(arg, "-v")) { + ++verbosity; + } else { + std::cerr << "error: unknown option " << arg << "\\n"; + return 1; + } + } + + glutInit(&argc, argv); + glutInitWindowPosition(0, 0); + glutInitWindowSize(__window_width, __window_height); + glutInitDisplayMode(GLUT_DEPTH | GLUT_RGB | (double_buffer ? GLUT_DOUBLE : GLUT_SINGLE)); + glutCreateWindow(argv[0]); + + glutDisplayFunc(&display); + glutIdleFunc(&idle); + + for (GLuint h = 0; h < 1024; ++h) { + __list_map[h] = h; + } + + for ( ; i < argc; ++i) { + if (parser.open(argv[i])) { + glutMainLoop(); + parser.close(); + } + } + + return 0; } -''' +'''