X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=glretrace.py;h=d91c8a25fe2ec2e68d39c89c15a2ada41e1b5f90;hb=452d3256a3ba7f249222ef857d69c8caaaa753f3;hp=759e9d9984ed802626d76ec6b10faa08915bb494;hpb=b77286911784c3f8ae32ca256f749c31a276ee34;p=apitrace diff --git a/glretrace.py b/glretrace.py index 759e9d9..d91c8a2 100644 --- a/glretrace.py +++ b/glretrace.py @@ -27,15 +27,18 @@ """GL retracer generator.""" -import stdapi -import glapi +import specs.stdapi as stdapi +import specs.glapi as glapi +import specs.glesapi as glesapi from retrace import Retracer class GlRetracer(Retracer): - def retrace_function(self, function): - Retracer.retrace_function(self, function) + table_name = 'glretrace::gl_callbacks' + + def retraceFunction(self, function): + Retracer.retraceFunction(self, function) array_pointer_function_names = set(( "glVertexPointer", @@ -49,18 +52,20 @@ class GlRetracer(Retracer): "glInterleavedArrays", - #"glVertexPointerEXT", - #"glNormalPointerEXT", - #"glColorPointerEXT", - #"glIndexPointerEXT", - #"glTexCoordPointerEXT", - #"glEdgeFlagPointerEXT", - #"glFogCoordPointerEXT", - #"glSecondaryColorPointerEXT", + "glVertexPointerEXT", + "glNormalPointerEXT", + "glColorPointerEXT", + "glIndexPointerEXT", + "glTexCoordPointerEXT", + "glEdgeFlagPointerEXT", + "glFogCoordPointerEXT", + "glSecondaryColorPointerEXT", "glVertexAttribPointer", "glVertexAttribPointerARB", "glVertexAttribPointerNV", + "glVertexAttribIPointer", + "glVertexAttribIPointerEXT", "glVertexAttribLPointer", "glVertexAttribLPointerEXT", @@ -74,6 +79,7 @@ class GlRetracer(Retracer): "glDrawArraysInstanced", "glDrawArraysInstancedARB", "glDrawArraysInstancedEXT", + "glDrawArraysInstancedBaseInstance", "glDrawMeshArraysSUN", "glMultiDrawArrays", "glMultiDrawArraysEXT", @@ -86,355 +92,347 @@ class GlRetracer(Retracer): "glDrawElementsIndirect", "glDrawElementsInstanced", "glDrawElementsInstancedARB", - "glDrawElementsInstancedBaseVertex", "glDrawElementsInstancedEXT", + "glDrawElementsInstancedBaseVertex", + "glDrawElementsInstancedBaseInstance", + "glDrawElementsInstancedBaseVertexBaseInstance", "glDrawRangeElements", - "glDrawRangeElementsBaseVertex", "glDrawRangeElementsEXT", - #"glMultiDrawElements", - #"glMultiDrawElementsBaseVertex", - #"glMultiDrawElementsEXT", - #"glMultiModeDrawElementsIBM", + "glDrawRangeElementsBaseVertex", + "glMultiDrawElements", + "glMultiDrawElementsBaseVertex", + "glMultiDrawElementsEXT", + "glMultiModeDrawElementsIBM", + ]) + + draw_indirect_function_names = set([ + "glDrawArraysIndirect", + "glDrawElementsIndirect", + ]) + + misc_draw_function_names = set([ + "glCallList", + "glCallLists", + "glClear", + "glEnd", + "glDrawPixels", + "glBlitFramebuffer", + "glBlitFramebufferEXT", + ]) + + bind_framebuffer_function_names = set([ + "glBindFramebuffer", + "glBindFramebufferEXT", + "glBindFramebufferOES", + ]) + + # Names of the functions that can pack into the current pixel buffer + # object. See also the ARB_pixel_buffer_object specification. + pack_function_names = set([ + 'glGetCompressedTexImage', + 'glGetConvolutionFilter', + 'glGetHistogram', + 'glGetMinmax', + 'glGetPixelMapfv', + 'glGetPixelMapuiv', + 'glGetPixelMapusv', + 'glGetPolygonStipple', + 'glGetSeparableFilter', + 'glGetTexImage', + 'glReadPixels', + 'glGetnCompressedTexImageARB', + 'glGetnConvolutionFilterARB', + 'glGetnHistogramARB', + 'glGetnMinmaxARB', + 'glGetnPixelMapfvARB', + 'glGetnPixelMapuivARB', + 'glGetnPixelMapusvARB', + 'glGetnPolygonStippleARB', + 'glGetnSeparableFilterARB', + 'glGetnTexImageARB', + 'glReadnPixelsARB', ]) - def retrace_function_body(self, function): + map_function_names = set([ + 'glMapBuffer', + 'glMapBufferARB', + 'glMapBufferOES', + 'glMapBufferRange', + 'glMapNamedBufferEXT', + 'glMapNamedBufferRangeEXT', + 'glMapObjectBufferATI', + ]) + + unmap_function_names = set([ + 'glUnmapBuffer', + 'glUnmapBufferARB', + 'glUnmapBufferOES', + 'glUnmapNamedBufferEXT', + 'glUnmapObjectBufferATI', + ]) + + def retraceFunctionBody(self, function): is_array_pointer = function.name in self.array_pointer_function_names is_draw_array = function.name in self.draw_array_function_names is_draw_elements = function.name in self.draw_elements_function_names + is_misc_draw = function.name in self.misc_draw_function_names if is_array_pointer or is_draw_array or is_draw_elements: - print ' if (Trace::Parser::version < 1) {' + print ' if (retrace::parser.version < 1) {' if is_array_pointer or is_draw_array: print ' GLint __array_buffer = 0;' print ' glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &__array_buffer);' print ' if (!__array_buffer) {' - self.fail_function(function) + self.failFunction(function) print ' }' if is_draw_elements: print ' GLint __element_array_buffer = 0;' print ' glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &__element_array_buffer);' print ' if (!__element_array_buffer) {' - self.fail_function(function) + self.failFunction(function) print ' }' print ' }' - Retracer.retrace_function_body(self, function) + # When no pack buffer object is bound, the pack functions are no-ops. + if function.name in self.pack_function_names: + print ' GLint __pack_buffer = 0;' + print ' glGetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING, &__pack_buffer);' + print ' if (!__pack_buffer) {' + print ' return;' + print ' }' - def call_function(self, function): + # Pre-snapshots + if function.name in self.bind_framebuffer_function_names: + print ' assert(call.flags & trace::CALL_FLAG_SWAP_RENDERTARGET);' + if function.name == 'glFrameTerminatorGREMEDY': + print ' glretrace::frame_complete(call);' + return + + Retracer.retraceFunctionBody(self, function) + + # Post-snapshots + if function.name in ('glFlush', 'glFinish'): + print ' if (!glretrace::double_buffer) {' + print ' glretrace::frame_complete(call);' + print ' }' + if is_draw_array or is_draw_elements or is_misc_draw: + print ' assert(call.flags & trace::CALL_FLAG_RENDER);' + + + def invokeFunction(self, function): + # Infer the drawable size from GL calls if function.name == "glViewport": - print ' if (x + width > __window_width) {' - print ' __window_width = x + width;' - print ' __reshape_window = true;' + print ' glretrace::updateDrawable(x + width, y + height);' + if function.name == "glViewportArray": + # We are concerned about drawables so only care for the first viewport + print ' if (first == 0 && count > 0) {' + print ' GLfloat x = v[0], y = v[1], w = v[2], h = v[3];' + print ' glretrace::updateDrawable(x + w, y + h);' + print ' }' + if function.name == "glViewportIndexedf": + print ' if (index == 0) {' + print ' glretrace::updateDrawable(x + w, y + h);' print ' }' - print ' if (y + height > __window_height) {' - print ' __window_height = y + height;' - print ' __reshape_window = true;' + if function.name == "glViewportIndexedfv": + print ' if (index == 0) {' + print ' GLfloat x = v[0], y = v[1], w = v[2], h = v[3];' + print ' glretrace::updateDrawable(x + w, y + h);' print ' }' + if function.name in ('glBlitFramebuffer', 'glBlitFramebufferEXT'): + # Some applications do all their rendering in a framebuffer, and + # then just blit to the drawable without ever calling glViewport. + print ' glretrace::updateDrawable(std::max(dstX0, dstX1), std::max(dstY0, dstY1));' if function.name == "glEnd": - print ' insideGlBeginEnd = false;' + print ' glretrace::insideGlBeginEnd = false;' + + if function.name.startswith('gl') and not function.name.startswith('glX'): + print r' if (!glretrace::context && !glretrace::benchmark && !retrace::profiling) {' + print r' retrace::warning(call) << "no current context\n";' + print r' }' + + if function.name == 'memcpy': + print ' if (!dest || !src || !n) return;' + + # Destroy the buffer mapping + if function.name in self.unmap_function_names: + print r' GLvoid *ptr = NULL;' + if function.name == 'glUnmapBuffer': + print r' glGetBufferPointerv(target, GL_BUFFER_MAP_POINTER, &ptr);' + elif function.name == 'glUnmapBufferARB': + print r' glGetBufferPointervARB(target, GL_BUFFER_MAP_POINTER_ARB, &ptr);' + elif function.name == 'glUnmapBufferOES': + print r' glGetBufferPointervOES(target, GL_BUFFER_MAP_POINTER_OES, &ptr);' + elif function.name == 'glUnmapNamedBufferEXT': + print r' glGetNamedBufferPointervEXT(buffer, GL_BUFFER_MAP_POINTER, &ptr);' + elif function.name == 'glUnmapObjectBufferATI': + # TODO + pass + else: + assert False + print r' if (ptr) {' + print r' retrace::delRegionByPointer(ptr);' + print r' } else {' + print r' retrace::warning(call) << "no current context\n";' + print r' }' - Retracer.call_function(self, function) + Retracer.invokeFunction(self, function) + # Error checking if function.name == "glBegin": - print ' insideGlBeginEnd = true;' - else: + print ' glretrace::insideGlBeginEnd = true;' + elif function.name.startswith('gl'): # glGetError is not allowed inside glBegin/glEnd - print ' checkGlError();' + print ' if (!glretrace::benchmark && !retrace::profiling && !glretrace::insideGlBeginEnd) {' + print ' glretrace::checkGlError(call);' + if function.name in ('glProgramStringARB', 'glProgramStringNV'): + print r' GLint error_position = -1;' + print r' glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &error_position);' + print r' if (error_position != -1) {' + print r' const char *error_string = (const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB);' + print r' retrace::warning(call) << error_string << "\n";' + print r' }' + if function.name == 'glCompileShader': + print r' GLint compile_status = 0;' + print r' glGetShaderiv(shader, GL_COMPILE_STATUS, &compile_status);' + print r' if (!compile_status) {' + print r' GLint info_log_length = 0;' + print r' glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &info_log_length);' + print r' GLchar *infoLog = new GLchar[info_log_length];' + print r' glGetShaderInfoLog(shader, info_log_length, NULL, infoLog);' + print r' retrace::warning(call) << infoLog << "\n";' + print r' delete [] infoLog;' + print r' }' + if function.name == 'glLinkProgram': + print r' GLint link_status = 0;' + print r' glGetProgramiv(program, GL_LINK_STATUS, &link_status);' + print r' if (!link_status) {' + print r' GLint info_log_length = 0;' + print r' glGetProgramiv(program, GL_INFO_LOG_LENGTH, &info_log_length);' + print r' GLchar *infoLog = new GLchar[info_log_length];' + print r' glGetProgramInfoLog(program, info_log_length, NULL, infoLog);' + print r' retrace::warning(call) << infoLog << "\n";' + print r' delete [] infoLog;' + print r' }' + if function.name == 'glCompileShaderARB': + print r' GLint compile_status = 0;' + print r' glGetObjectParameterivARB(shaderObj, GL_OBJECT_COMPILE_STATUS_ARB, &compile_status);' + print r' if (!compile_status) {' + print r' GLint info_log_length = 0;' + print r' glGetObjectParameterivARB(shaderObj, GL_OBJECT_INFO_LOG_LENGTH_ARB, &info_log_length);' + print r' GLchar *infoLog = new GLchar[info_log_length];' + print r' glGetInfoLogARB(shaderObj, info_log_length, NULL, infoLog);' + print r' retrace::warning(call) << infoLog << "\n";' + print r' delete [] infoLog;' + print r' }' + if function.name == 'glLinkProgramARB': + print r' GLint link_status = 0;' + print r' glGetObjectParameterivARB(programObj, GL_OBJECT_LINK_STATUS_ARB, &link_status);' + print r' if (!link_status) {' + print r' GLint info_log_length = 0;' + print r' glGetObjectParameterivARB(programObj, GL_OBJECT_INFO_LOG_LENGTH_ARB, &info_log_length);' + print r' GLchar *infoLog = new GLchar[info_log_length];' + print r' glGetInfoLogARB(programObj, info_log_length, NULL, infoLog);' + print r' retrace::warning(call) << infoLog << "\n";' + print r' delete [] infoLog;' + print r' }' + if function.name in self.map_function_names: + print r' if (!__result) {' + print r' retrace::warning(call) << "failed to map buffer\n";' + print r' }' + if function.name in self.unmap_function_names and function.type is not stdapi.Void: + print r' if (!__result) {' + print r' retrace::warning(call) << "failed to unmap buffer\n";' + print r' }' + if function.name in ('glGetAttribLocation', 'glGetAttribLocationARB'): + print r' GLint __orig_result = call.ret->toSInt();' + print r' if (__result != __orig_result) {' + print r' retrace::warning(call) << "vertex attrib location mismatch " << __orig_result << " -> " << __result << "\n";' + print r' }' + if function.name in ('glCheckFramebufferStatus', 'glCheckFramebufferStatusEXT', 'glCheckNamedFramebufferStatusEXT'): + print r' GLint __orig_result = call.ret->toSInt();' + print r' if (__orig_result == GL_FRAMEBUFFER_COMPLETE &&' + print r' __result != GL_FRAMEBUFFER_COMPLETE) {' + print r' retrace::warning(call) << "incomplete framebuffer (" << glstate::enumToString(__result) << ")\n";' + print r' }' + print ' }' - def extract_arg(self, function, arg, arg_type, lvalue, rvalue): + # Query the buffer length for whole buffer mappings + if function.name in self.map_function_names: + if 'length' in function.argNames(): + assert 'BufferRange' in function.name + else: + assert 'BufferRange' not in function.name + print r' GLint length = 0;' + if function.name in ('glMapBuffer', 'glMapBufferOES'): + print r' glGetBufferParameteriv(target, GL_BUFFER_SIZE, &length);' + elif function.name == 'glMapBufferARB': + print r' glGetBufferParameterivARB(target, GL_BUFFER_SIZE_ARB, &length);' + elif function.name == 'glMapNamedBufferEXT': + print r' glGetNamedBufferParameterivEXT(buffer, GL_BUFFER_SIZE, &length);' + elif function.name == 'glMapObjectBufferATI': + print r' glGetObjectBufferivATI(buffer, GL_OBJECT_BUFFER_SIZE_ATI, &length);' + else: + assert False + + def extractArg(self, function, arg, arg_type, lvalue, rvalue): if function.name in self.array_pointer_function_names and arg.name == 'pointer': - print ' %s = %s.blob();' % (lvalue, rvalue) + print ' %s = static_cast<%s>(retrace::toPointer(%s, true));' % (lvalue, arg_type, rvalue) + return + + if function.name in self.draw_elements_function_names and arg.name == 'indices' or\ + function.name in self.draw_indirect_function_names and arg.name == 'indirect': + self.extractOpaqueArg(function, arg, arg_type, lvalue, rvalue) return - if function.name in self.draw_elements_function_names and arg.name == 'indices': - print ' %s = %s.blob();' % (lvalue, rvalue) + # Handle pointer with offsets into the current pack pixel buffer + # object. + if function.name in self.pack_function_names and arg.output: + assert isinstance(arg_type, (stdapi.Pointer, stdapi.Array, stdapi.Blob, stdapi.Opaque)) + print ' %s = static_cast<%s>((%s).toPointer());' % (lvalue, arg_type, rvalue) return - if function.name.startswith('glUniform') and function.args[0].name == arg.name == 'location': + if arg.type is glapi.GLlocation \ + and 'program' not in function.argNames(): print ' GLint program = -1;' print ' glGetIntegerv(GL_CURRENT_PROGRAM, &program);' + + if arg.type is glapi.GLlocationARB \ + and 'programObj' not in function.argNames(): + print ' GLhandleARB programObj = glGetHandleARB(GL_PROGRAM_OBJECT_ARB);' + + Retracer.extractArg(self, function, arg, arg_type, lvalue, rvalue) + + # Don't try to use more samples than the implementation supports + if arg.name == 'samples': + assert arg.type is glapi.GLsizei + print ' GLint max_samples = 0;' + print ' glGetIntegerv(GL_MAX_SAMPLES, &max_samples);' + print ' if (samples > max_samples) {' + print ' samples = max_samples;' + print ' }' + + # These parameters are referred beyond the call life-time + # TODO: Replace ad-hoc solution for bindable parameters with general one + if function.name in ('glFeedbackBuffer', 'glSelectBuffer') and arg.output: + print ' _allocator.bind(%s);' % arg.name - Retracer.extract_arg(self, function, arg, arg_type, lvalue, rvalue) if __name__ == '__main__': print r''' #include -#include -#include #include "glproc.hpp" +#include "glretrace.hpp" #include "glstate.hpp" -#include "glws.hpp" - -static bool double_buffer = false; -static bool insideGlBeginEnd = false; - -static int __window_width = 256, __window_height = 256; -bool __reshape_window = false; - -unsigned __frame = 0; -long long __startTime = 0; -bool __wait = false; - -bool __benchmark = false; -const char *__compare_prefix = NULL; -const char *__snapshot_prefix = NULL; - -unsigned __dump_state = ~0; - - -static void -checkGlError(void) { - if (__benchmark || 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 + api.addApi(glesapi.glesapi) retracer = GlRetracer() - retracer.retrace_api(glapi.glapi) - print r''' - -static Trace::Parser parser; -static glws::WindowSystem *__ws = NULL; -static glws::Visual *__visual = NULL; -static glws::Drawable *__drawable = NULL; -static glws::Context *__context = NULL; - -#include "image.hpp" - -static void snapshot(Image::Image &image) { - GLint drawbuffer = double_buffer ? GL_BACK : GL_FRONT; - GLint readbuffer = double_buffer ? GL_BACK : GL_FRONT; - glGetIntegerv(GL_READ_BUFFER, &drawbuffer); - glGetIntegerv(GL_READ_BUFFER, &readbuffer); - glReadBuffer(drawbuffer); - glReadPixels(0, 0, image.width, image.height, GL_RGBA, GL_UNSIGNED_BYTE, image.pixels); - checkGlError(); - glReadBuffer(readbuffer); -} - -static void frame_complete(void) { - ++__frame; - - if (!__reshape_window && (__snapshot_prefix || __compare_prefix)) { - Image::Image *ref = NULL; - if (__compare_prefix) { - char filename[PATH_MAX]; - snprintf(filename, sizeof filename, "%s%04u.png", __compare_prefix, __frame); - ref = Image::readPNG(filename); - if (!ref) { - return; - } - if (verbosity >= 0) - std::cout << "Read " << filename << "\n"; - } - - Image::Image src(__window_width, __window_height, true); - snapshot(src); - - if (__snapshot_prefix) { - char filename[PATH_MAX]; - snprintf(filename, sizeof filename, "%s%04u.png", __snapshot_prefix, __frame); - if (src.writePNG(filename) && verbosity >= 0) { - std::cout << "Wrote " << filename << "\n"; - } - } - - if (ref) { - std::cout << "Frame " << __frame << " average precision of " << src.compare(*ref) << " bits\n"; - delete ref; - } - } - - if (__reshape_window) { - // XXX: doesn't quite work - __drawable->resize(__window_width, __window_height); - __reshape_window = false; - } - - __ws->processEvents(); -} - -static void display(void) { - Trace::Call *call; - - while ((call = parser.parse_call())) { - const std::string &name = call->name(); - - if ((name[0] == 'w' && name[1] == 'g' && name[2] == 'l') || - (name[0] == 'g' && name[1] == 'l' && name[2] == 'X')) { - // XXX: We ignore the majority of the OS-specific calls for now - if (name == "glXSwapBuffers" || - name == "wglSwapBuffers") { - if (verbosity >= 1) { - std::cout << *call; - std::cout.flush(); - }; - frame_complete(); - if (double_buffer) - __drawable->swapBuffers(); - else - glFlush(); - } else if (name == "glXMakeCurrent" || - name == "wglMakeCurrent") { - glFlush(); - if (!double_buffer) { - frame_complete(); - } - } else { - continue; - } - } - - if (name == "glFlush") { - glFlush(); - if (!double_buffer) { - frame_complete(); - } - } - - retrace_call(*call); - - if (!insideGlBeginEnd && call->no >= __dump_state) { - state_dump(std::cout); - exit(0); - } - - delete call; - } - - // Reached the end of trace - glFlush(); - - long long endTime = OS::GetTime(); - float timeInterval = (endTime - __startTime) * 1.0E-6; - - if (verbosity >= -1) { - std::cout << - "Rendered " << __frame << " frames" - " in " << timeInterval << " secs," - " average of " << (__frame/timeInterval) << " fps\n"; - } - - if (__wait) { - while (__ws->processEvents()) {} - } else { - exit(0); - } -} - -static void usage(void) { - std::cout << - "Usage: glretrace [OPTION] TRACE\n" - "Replay TRACE.\n" - "\n" - " -b benchmark (no glgeterror; no messages)\n" - " -c PREFIX compare against snapshots\n" - " -db use a double buffer visual\n" - " -s PREFIX take snapshots\n" - " -v verbose output\n" - " -D CALLNO dump state at specific call no\n" - " -w wait on final frame\n"; -} - -int main(int argc, char **argv) -{ - - 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, "-b")) { - __benchmark = true; - verbosity = -1; - } else if (!strcmp(arg, "-c")) { - __compare_prefix = argv[++i]; - } else if (!strcmp(arg, "-D")) { - __dump_state = atoi(argv[++i]); - verbosity = -2; - } else if (!strcmp(arg, "-db")) { - double_buffer = true; - } else if (!strcmp(arg, "--help")) { - usage(); - return 0; - } else if (!strcmp(arg, "-s")) { - __snapshot_prefix = argv[++i]; - } else if (!strcmp(arg, "-v")) { - ++verbosity; - } else if (!strcmp(arg, "-w")) { - __wait = true; - } else { - std::cerr << "error: unknown option " << arg << "\n"; - usage(); - return 1; - } - } - - __ws = glws::createNativeWindowSystem(); - __visual = __ws->createVisual(double_buffer); - __drawable = __ws->createDrawable(__visual); - __drawable->resize(__window_width, __window_height); - __context = __ws->createContext(__visual); - __ws->makeCurrent(__drawable, __context); - - for ( ; i < argc; ++i) { - if (parser.open(argv[i])) { - __startTime = OS::GetTime(); - display(); - parser.close(); - } - } - - return 0; -} - -''' + retracer.retraceApi(api)