diff options
Diffstat (limited to 'bsp/meta-freescale/recipes-graphics/imx-gpu-apitrace/imx-gpu-apitrace/0001-switch-from-python2-to-python3.patch')
| -rw-r--r-- | bsp/meta-freescale/recipes-graphics/imx-gpu-apitrace/imx-gpu-apitrace/0001-switch-from-python2-to-python3.patch | 10004 |
1 files changed, 10004 insertions, 0 deletions
diff --git a/bsp/meta-freescale/recipes-graphics/imx-gpu-apitrace/imx-gpu-apitrace/0001-switch-from-python2-to-python3.patch b/bsp/meta-freescale/recipes-graphics/imx-gpu-apitrace/imx-gpu-apitrace/0001-switch-from-python2-to-python3.patch new file mode 100644 index 00000000..27382c34 --- /dev/null +++ b/bsp/meta-freescale/recipes-graphics/imx-gpu-apitrace/imx-gpu-apitrace/0001-switch-from-python2-to-python3.patch @@ -0,0 +1,10004 @@ +From bfa1b7c7e675f198f4573325f1252e91f80f0b4d Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Piotr=20Podsiad=C5=82y?= <ppodsiadly@mykolab.com> +Date: Thu, 3 Jan 2019 20:39:55 +0100 +Subject: [PATCH 1/4] switch from python2 to python3 + +Upstream-Status: Backport [https://github.com/apitrace/apitrace/commit/0b8b019952f2668a5e8786cc2d331062b958f02e] + +(cherry picked from commit 0b8b019952f2668a5e8786cc2d331062b958f02e) +Signed-off-by: Andrey Zhizhikin <andrey.zhizhikin@leica-geosystems.com> +--- + CMakeLists.txt | 7 +- + cli/CMakeLists.txt | 2 +- + dispatch/CMakeLists.txt | 2 +- + dispatch/__init__.py | 2 +- + dispatch/dispatch.py | 56 +- + dispatch/glproc.py | 204 +++---- + retrace/CMakeLists.txt | 14 +- + retrace/d3d9retrace.py | 248 ++++---- + retrace/ddrawretrace.py | 102 ++-- + retrace/dllretrace.py | 46 +- + retrace/dxgiretrace.py | 370 +++++------ + retrace/dxgistate_so.py | 98 +-- + retrace/glretrace.py | 660 ++++++++++---------- + retrace/glstate_params.py | 556 ++++++++--------- + retrace/retrace.py | 300 ++++----- + scripts/convert.py | 4 +- + scripts/jsondiff.py | 16 +- + scripts/jsonextractimages.py | 2 +- + scripts/leaks.py | 163 +++++ + scripts/profileshader.py | 18 +- + scripts/retracediff.py | 6 +- + scripts/snapdiff.py | 7 +- + scripts/tracediff.py | 16 +- + scripts/unpickle.py | 16 +- + specs/cglapi.py | 6 +- + specs/d2d1.py | 6 +- + specs/d3d.py | 8 +- + specs/d3d10.py | 4 +- + specs/d3d10sdklayers.py | 2 +- + specs/d3d11.py | 4 +- + specs/d3d11sdklayers.py | 2 +- + specs/d3d8.py | 6 +- + specs/d3d8caps.py | 4 +- + specs/d3d8types.py | 2 +- + specs/d3d9.py | 6 +- + specs/d3d9caps.py | 4 +- + specs/d3d9types.py | 2 +- + specs/d3dcaps.py | 4 +- + specs/d3dtypes.py | 2 +- + specs/dcommon.py | 2 +- + specs/dcomp.py | 303 +++++++++ + specs/ddraw.py | 2 +- + specs/debug.py | 2 +- + specs/dwrite.py | 4 +- + specs/dxgi.py | 2 +- + specs/dxva2.py | 2 +- + specs/eglapi.py | 6 +- + specs/eglenum.py | 2 +- + specs/glapi.py | 6 +- + specs/glparams.py | 4 +- + specs/gltypes.py | 2 +- + specs/glxapi.py | 4 +- + specs/scripts/c2api.py | 40 +- + specs/scripts/cxx2api.py | 488 +++++++++++++++ + specs/scripts/spec2api.py | 6 +- + specs/scripts/txt2api.py | 8 +- + specs/scripts/xml2api.py | 6 +- + specs/scripts/xml2enum.py | 4 +- + specs/scripts/xml2glparams.py | 4 +- + specs/stdapi.py | 43 +- + specs/wglapi.py | 6 +- + specs/wglenum.py | 2 +- + specs/winapi.py | 2 +- + wrappers/CMakeLists.txt | 18 +- + wrappers/cgltrace.py | 74 +-- + wrappers/d2d1trace.py | 18 +- + wrappers/d3d8trace.py | 36 +- + wrappers/d3d9trace.py | 62 +- + wrappers/ddrawtrace.py | 12 +- + wrappers/dlltrace.py | 36 +- + wrappers/dxgitrace.py | 98 +-- + wrappers/egltrace.py | 420 ++++++------- + wrappers/gltrace.py | 1080 ++++++++++++++++----------------- + wrappers/glxtrace.py | 54 +- + wrappers/trace.py | 707 ++++++++++----------- + wrappers/wgltrace.py | 86 +-- + 76 files changed, 3803 insertions(+), 2825 deletions(-) + create mode 100755 scripts/leaks.py + create mode 100644 specs/dcomp.py + create mode 100755 specs/scripts/cxx2api.py + +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 900028c6..03ffd07c 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -104,10 +104,7 @@ else () + endmacro() + endif () + +-find_host_package (PythonInterp 2.7 REQUIRED) +-if (NOT PYTHON_VERSION_MAJOR EQUAL 2) +- message (FATAL_ERROR "Python 2.x required and requested, but Python ${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR} found.") +-endif () ++find_host_package(Python3 COMPONENTS Interpreter REQUIRED) + + find_package (Threads) + +@@ -591,7 +588,7 @@ set (CPACK_PACKAGE_VERSION_MINOR "0") + + # Use current date in YYYYMMDD format as patch number + execute_process ( +- COMMAND ${PYTHON_EXECUTABLE} -c "import time, sys; sys.stdout.write(time.strftime('%Y%m%d'))" ++ COMMAND ${Python3_EXECUTABLE} -c "import time, sys; sys.stdout.write(time.strftime('%Y%m%d'))" + OUTPUT_VARIABLE CPACK_PACKAGE_VERSION_PATCH + ) + +diff --git a/cli/CMakeLists.txt b/cli/CMakeLists.txt +index 9b621bb1..eb5d485d 100644 +--- a/cli/CMakeLists.txt ++++ b/cli/CMakeLists.txt +@@ -13,7 +13,7 @@ add_definitions( + if (WIN32) + add_definitions (-DAPITRACE_PYTHON_EXECUTABLE="python") + else () +- add_definitions (-DAPITRACE_PYTHON_EXECUTABLE="${PYTHON_EXECUTABLE}") ++ add_definitions (-DAPITRACE_PYTHON_EXECUTABLE="${Python3_EXECUTABLE}") + endif () + + add_executable (apitrace +diff --git a/dispatch/CMakeLists.txt b/dispatch/CMakeLists.txt +index d023e6e9..e51eec48 100644 +--- a/dispatch/CMakeLists.txt ++++ b/dispatch/CMakeLists.txt +@@ -7,7 +7,7 @@ add_custom_command ( + OUTPUT + ${CMAKE_CURRENT_BINARY_DIR}/glproc.hpp + ${CMAKE_CURRENT_BINARY_DIR}/glproc.cpp +- COMMAND ${PYTHON_EXECUTABLE} ++ COMMAND ${Python3_EXECUTABLE} + ${CMAKE_CURRENT_SOURCE_DIR}/glproc.py + ${CMAKE_CURRENT_BINARY_DIR}/glproc.hpp + ${CMAKE_CURRENT_BINARY_DIR}/glproc.cpp +diff --git a/dispatch/__init__.py b/dispatch/__init__.py +index b872135e..d8e8596e 100644 +--- a/dispatch/__init__.py ++++ b/dispatch/__init__.py +@@ -1 +1 @@ +-from dispatch import * ++from .dispatch import * +diff --git a/dispatch/dispatch.py b/dispatch/dispatch.py +index 9e778561..e1dd8bc9 100644 +--- a/dispatch/dispatch.py ++++ b/dispatch/dispatch.py +@@ -58,18 +58,18 @@ class Dispatcher: + # define standard name aliases for convenience, but only when not + # tracing, as that would cause symbol clashing with the tracing + # functions +- print '#ifdef RETRACE' ++ print('#ifdef RETRACE') + for function in module.functions: +- print '#define %s _%s' % (function.name, function.name) +- print '#endif /* RETRACE */' +- print ++ print('#define %s _%s' % (function.name, function.name)) ++ print('#endif /* RETRACE */') ++ print() + + def dispatchFunctionDecl(self, module, function): + ptype = function_pointer_type(function) + pvalue = function_pointer_value(function) +- print 'typedef ' + function.prototype('* %s' % ptype) + ';' +- print 'extern %s %s;' % (ptype, pvalue) +- print ++ print('typedef ' + function.prototype('* %s' % ptype) + ';') ++ print('extern %s %s;' % (ptype, pvalue)) ++ print() + + def dispatchModuleImpl(self, module): + for function in module.functions: +@@ -84,19 +84,19 @@ class Dispatcher: + else: + ret = 'return ' + +- print 'static ' + function.prototype('_fail_' + function.name) + ' {' ++ print('static ' + function.prototype('_fail_' + function.name) + ' {') + self.failFunction(function) +- print '}' +- print ++ print('}') ++ print() + +- print 'static ' + function.prototype('_get_' + function.name) + ' {' ++ print('static ' + function.prototype('_get_' + function.name) + ' {') + self.invokeGetProcAddress(module, function) +- print ' %s%s(%s);' % (ret, pvalue, ', '.join([str(arg.name) for arg in function.args])) +- print '}' +- print ++ print(' %s%s(%s);' % (ret, pvalue, ', '.join([str(arg.name) for arg in function.args]))) ++ print('}') ++ print() + +- print '%s %s = &%s;' % (ptype, pvalue, '_get_' + function.name) +- print ++ print('%s %s = &%s;' % (ptype, pvalue, '_get_' + function.name)) ++ print() + + def getProcAddressName(self, module, function): + raise NotImplementedError +@@ -105,25 +105,25 @@ class Dispatcher: + ptype = function_pointer_type(function) + pvalue = function_pointer_value(function) + getProcAddressName = self.getProcAddressName(module, function) +- print ' %s _ptr;' % (ptype,) +- print ' _ptr = (%s)%s("%s");' % (ptype, getProcAddressName, function.name) +- print ' if (!_ptr) {' +- print ' _ptr = &%s;' % ('_fail_' + function.name) +- print ' }' +- print ' %s = _ptr;' % (pvalue,) ++ print(' %s _ptr;' % (ptype,)) ++ print(' _ptr = (%s)%s("%s");' % (ptype, getProcAddressName, function.name)) ++ print(' if (!_ptr) {') ++ print(' _ptr = &%s;' % ('_fail_' + function.name)) ++ print(' }') ++ print(' %s = _ptr;' % (pvalue,)) + + def failFunction(self, function): +- print r' const char *_name = "%s";' % function.name ++ print(r' const char *_name = "%s";' % function.name) + if function.type is stdapi.Void or function.fail is not None: +- print r' os::log("warning: ignoring call to unavailable function %s\n", _name);' ++ print(r' os::log("warning: ignoring call to unavailable function %s\n", _name);') + if function.type is stdapi.Void: + assert function.fail is None +- print ' return;' ++ print(' return;') + else: + assert function.fail is not None +- print ' return %s;' % function.fail ++ print(' return %s;' % function.fail) + else: +- print r' os::log("error: unavailable function %s\n", _name);' +- print r' os::abort();' ++ print(r' os::log("error: unavailable function %s\n", _name);') ++ print(r' os::abort();') + + +diff --git a/dispatch/glproc.py b/dispatch/glproc.py +index f26a4f7d..93bba232 100644 +--- a/dispatch/glproc.py ++++ b/dispatch/glproc.py +@@ -506,15 +506,15 @@ class GlDispatcher(Dispatcher): + if sys.platform == 'darwin': + # Fallback to EXT_debug_label on MacOSX, some enums need to be translated. + if function.name in ('glObjectLabel', 'glObjectLabelKHR'): +- print r' if (translateDebugLabelIdentifier(identifier)) {' +- print r' _glLabelObjectEXT(identifier, name, length < 0 ? 0 : length, length == 0 ? "" : label);' +- print r' return;' +- print r' }' ++ print(r' if (translateDebugLabelIdentifier(identifier)) {') ++ print(r' _glLabelObjectEXT(identifier, name, length < 0 ? 0 : length, length == 0 ? "" : label);') ++ print(r' return;') ++ print(r' }') + if function.name in ('glGetObjectLabel', 'glGetObjectLabelKHR'): +- print r' if (translateDebugLabelIdentifier(identifier)) {' +- print r' _glGetObjectLabelEXT(identifier, name, bufSize, length, label);' +- print r' return;' +- print r' }' ++ print(r' if (translateDebugLabelIdentifier(identifier)) {') ++ print(r' _glGetObjectLabelEXT(identifier, name, bufSize, length, label);') ++ print(r' return;') ++ print(r' }') + if function.name in ( + # GL_KHR_debug + 'glDebugMessageControl', +@@ -549,25 +549,25 @@ class GlDispatcher(Dispatcher): + ): + return + if function.name.startswith('glGetObjectLabel'): +- print r' if (length != 0) *length = 0;' +- print r' if (label != 0 && bufSize > 0) *label = 0;' ++ print(r' if (length != 0) *length = 0;') ++ print(r' if (label != 0 && bufSize > 0) *label = 0;') + return + if function.name == 'glGetDebugMessageLogAMD': +- print r' if (categories != 0) *categories = 0;' +- print r' if (ids != 0) *ids = 0;' +- print r' if (severities != 0) *severities = 0;' +- print r' if (lengths != 0) *lengths = 0;' +- print r' if (message != 0 && bufsize > 0) *message = 0;' +- print r' return 0;' ++ print(r' if (categories != 0) *categories = 0;') ++ print(r' if (ids != 0) *ids = 0;') ++ print(r' if (severities != 0) *severities = 0;') ++ print(r' if (lengths != 0) *lengths = 0;') ++ print(r' if (message != 0 && bufsize > 0) *message = 0;') ++ print(r' return 0;') + return + if function.name.startswith('glGetDebugMessageLog'): +- print r' if (sources != 0) *sources = 0;' +- print r' if (types != 0) *types = 0;' +- print r' if (ids != 0) *ids = 0;' +- print r' if (severities != 0) *severities = 0;' +- print r' if (lengths != 0) *lengths = 0;' +- print r' if (messageLog != 0 && bufsize > 0) *messageLog = 0;' +- print r' return 0;' ++ print(r' if (sources != 0) *sources = 0;') ++ print(r' if (types != 0) *types = 0;') ++ print(r' if (ids != 0) *ids = 0;') ++ print(r' if (severities != 0) *severities = 0;') ++ print(r' if (lengths != 0) *lengths = 0;') ++ print(r' if (messageLog != 0 && bufsize > 0) *messageLog = 0;') ++ print(r' return 0;') + return + + Dispatcher.failFunction(self, function) +@@ -577,96 +577,96 @@ if __name__ == '__main__': + decl, impl = sys.argv[1:] + + sys.stdout = open(decl, 'wt') +- print +- print '#pragma once' +- print +- print '#include "glimports.hpp"' +- print +- print '#if defined(_WIN32)' +- print 'extern HMODULE _libGlHandle;' +- print '#else' +- print 'extern void * _libGlHandle;' +- print '#endif' +- print +- print 'void * _getPublicProcAddress(const char *procName);' +- print 'void * _getPrivateProcAddress(const char *procName);' +- print ++ print() ++ print('#pragma once') ++ print() ++ print('#include "glimports.hpp"') ++ print() ++ print('#if defined(_WIN32)') ++ print('extern HMODULE _libGlHandle;') ++ print('#else') ++ print('extern void * _libGlHandle;') ++ print('#endif') ++ print() ++ print('void * _getPublicProcAddress(const char *procName);') ++ print('void * _getPrivateProcAddress(const char *procName);') ++ print() + dispatcher = GlDispatcher() +- print ++ print() + dispatcher.dispatchModuleDecl(eglapi) +- print +- print '#if defined(_WIN32)' +- print ++ print() ++ print('#if defined(_WIN32)') ++ print() + dispatcher.dispatchModuleDecl(wglapi) +- print +- print '#elif defined(__APPLE__)' +- print ++ print() ++ print('#elif defined(__APPLE__)') ++ print() + dispatcher.dispatchModuleDecl(cglapi) +- print +- print '#elif defined(HAVE_X11)' +- print ++ print() ++ print('#elif defined(HAVE_X11)') ++ print() + dispatcher.dispatchModuleDecl(glxapi) +- print +- print '#endif' +- print ++ print() ++ print('#endif') ++ print() + dispatcher.dispatchModuleDecl(glapi) +- print ++ print() + + sys.stdout = open(impl, 'wt') +- print +- print '#include "glproc.hpp"' +- print '#include "os.hpp"' +- print ++ print() ++ print('#include "glproc.hpp"') ++ print('#include "os.hpp"') ++ print() + dispatcher = GlDispatcher() +- print ++ print() + dispatcher.dispatchModuleImpl(eglapi) +- print +- print '#if defined(_WIN32)' +- print ++ print() ++ print('#if defined(_WIN32)') ++ print() + dispatcher.dispatchModuleImpl(wglapi) +- print +- print '#elif defined(__APPLE__)' +- print +- print 'static inline bool' +- print 'translateDebugLabelIdentifier(GLenum & identifier)' +- print '{' +- print ' switch (identifier) {' +- print ' case GL_TEXTURE:' +- print ' case GL_FRAMEBUFFER:' +- print ' case GL_RENDERBUFFER:' +- print ' case GL_SAMPLER:' +- print ' case GL_TRANSFORM_FEEDBACK:' +- print ' return true;' +- print ' case GL_BUFFER:' +- print ' identifier = GL_BUFFER_OBJECT_EXT;' +- print ' return true;' +- print ' case GL_SHADER:' +- print ' identifier = GL_SHADER_OBJECT_EXT;' +- print ' return true;' +- print ' case GL_PROGRAM:' +- print ' identifier = GL_PROGRAM_OBJECT_EXT;' +- print ' return true;' +- print ' case GL_VERTEX_ARRAY:' +- print ' identifier = GL_VERTEX_ARRAY_OBJECT_EXT;' +- print ' return true;' +- print ' case GL_QUERY:' +- print ' identifier = GL_QUERY_OBJECT_EXT;' +- print ' return true;' +- print ' case GL_PROGRAM_PIPELINE:' +- print ' identifier = GL_PROGRAM_PIPELINE_OBJECT_EXT;' +- print ' return true;' +- print ' default:' +- print ' return false;' +- print ' }' +- print '}' +- print ++ print() ++ print('#elif defined(__APPLE__)') ++ print() ++ print('static inline bool') ++ print('translateDebugLabelIdentifier(GLenum & identifier)') ++ print('{') ++ print(' switch (identifier) {') ++ print(' case GL_TEXTURE:') ++ print(' case GL_FRAMEBUFFER:') ++ print(' case GL_RENDERBUFFER:') ++ print(' case GL_SAMPLER:') ++ print(' case GL_TRANSFORM_FEEDBACK:') ++ print(' return true;') ++ print(' case GL_BUFFER:') ++ print(' identifier = GL_BUFFER_OBJECT_EXT;') ++ print(' return true;') ++ print(' case GL_SHADER:') ++ print(' identifier = GL_SHADER_OBJECT_EXT;') ++ print(' return true;') ++ print(' case GL_PROGRAM:') ++ print(' identifier = GL_PROGRAM_OBJECT_EXT;') ++ print(' return true;') ++ print(' case GL_VERTEX_ARRAY:') ++ print(' identifier = GL_VERTEX_ARRAY_OBJECT_EXT;') ++ print(' return true;') ++ print(' case GL_QUERY:') ++ print(' identifier = GL_QUERY_OBJECT_EXT;') ++ print(' return true;') ++ print(' case GL_PROGRAM_PIPELINE:') ++ print(' identifier = GL_PROGRAM_PIPELINE_OBJECT_EXT;') ++ print(' return true;') ++ print(' default:') ++ print(' return false;') ++ print(' }') ++ print('}') ++ print() + dispatcher.dispatchModuleImpl(cglapi) +- print +- print '#elif defined(HAVE_X11)' +- print ++ print() ++ print('#elif defined(HAVE_X11)') ++ print() + dispatcher.dispatchModuleImpl(glxapi) +- print +- print '#endif' +- print ++ print() ++ print('#endif') ++ print() + dispatcher.dispatchModuleImpl(glapi) +- print ++ print() +diff --git a/retrace/CMakeLists.txt b/retrace/CMakeLists.txt +index c0c4f316..2475abb8 100644 +--- a/retrace/CMakeLists.txt ++++ b/retrace/CMakeLists.txt +@@ -14,7 +14,7 @@ add_definitions (-DRETRACE) + + add_custom_command ( + OUTPUT glretrace_gl.cpp +- COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/glretrace.py > ${CMAKE_CURRENT_BINARY_DIR}/glretrace_gl.cpp ++ COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/glretrace.py > ${CMAKE_CURRENT_BINARY_DIR}/glretrace_gl.cpp + DEPENDS + glretrace.py + retrace.py +@@ -25,7 +25,7 @@ add_custom_command ( + + add_custom_command ( + OUTPUT glstate_params.cpp +- COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/glstate_params.py > ${CMAKE_CURRENT_BINARY_DIR}/glstate_params.cpp ++ COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/glstate_params.py > ${CMAKE_CURRENT_BINARY_DIR}/glstate_params.cpp + DEPENDS + glstate_params.py + ${CMAKE_SOURCE_DIR}/specs/glparams.py +@@ -273,7 +273,7 @@ if (WIN32) + include_directories (BEFORE SYSTEM ${DirectX_D3D_INCLUDE_DIR}) + add_custom_command ( + OUTPUT d3dretrace_ddraw.cpp +- COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/ddrawretrace.py > ${CMAKE_CURRENT_BINARY_DIR}/d3dretrace_ddraw.cpp ++ COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/ddrawretrace.py > ${CMAKE_CURRENT_BINARY_DIR}/d3dretrace_ddraw.cpp + DEPENDS + ddrawretrace.py + dllretrace.py +@@ -306,7 +306,7 @@ if (WIN32) + endif () + add_custom_command ( + OUTPUT d3dretrace_d3d8.cpp +- COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3d9retrace.py d3d8 ${HAVE_D3D8} > ${CMAKE_CURRENT_BINARY_DIR}/d3dretrace_d3d8.cpp ++ COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3d9retrace.py d3d8 ${HAVE_D3D8} > ${CMAKE_CURRENT_BINARY_DIR}/d3dretrace_d3d8.cpp + DEPENDS + d3d9retrace.py + dllretrace.py +@@ -327,7 +327,7 @@ if (WIN32) + endif () + add_custom_command ( + OUTPUT d3dretrace_d3d9.cpp +- COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3d9retrace.py d3d9 ${HAVE_D3D9} > ${CMAKE_CURRENT_BINARY_DIR}/d3dretrace_d3d9.cpp ++ COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3d9retrace.py d3d9 ${HAVE_D3D9} > ${CMAKE_CURRENT_BINARY_DIR}/d3dretrace_d3d9.cpp + DEPENDS + d3d9retrace.py + dllretrace.py +@@ -359,7 +359,7 @@ if (WIN32) + ) + add_custom_command ( + OUTPUT dxgistate_so.cpp +- COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/dxgistate_so.py > ${CMAKE_CURRENT_BINARY_DIR}/dxgistate_so.cpp ++ COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/dxgistate_so.py > ${CMAKE_CURRENT_BINARY_DIR}/dxgistate_so.cpp + DEPENDS + ${CMAKE_CURRENT_SOURCE_DIR}/dxgistate_so.py + ${CMAKE_SOURCE_DIR}/specs/d3d11.py +@@ -372,7 +372,7 @@ if (WIN32) + ) + add_custom_command ( + OUTPUT d3dretrace_dxgi.cpp +- COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/dxgiretrace.py > ${CMAKE_CURRENT_BINARY_DIR}/d3dretrace_dxgi.cpp ++ COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/dxgiretrace.py > ${CMAKE_CURRENT_BINARY_DIR}/d3dretrace_dxgi.cpp + DEPENDS + dxgiretrace.py + dllretrace.py +diff --git a/retrace/d3d9retrace.py b/retrace/d3d9retrace.py +index 7313acc9..22364476 100644 +--- a/retrace/d3d9retrace.py ++++ b/retrace/d3d9retrace.py +@@ -35,32 +35,32 @@ from specs.stdapi import API + class D3DRetracer(Retracer): + + def retraceApi(self, api): +- print '// Swizzling mapping for lock addresses' +- print 'typedef std::pair<void *, UINT> MappingKey;' +- print 'static std::map<MappingKey, void *> _maps;' +- print ++ print('// Swizzling mapping for lock addresses') ++ print('typedef std::pair<void *, UINT> MappingKey;') ++ print('static std::map<MappingKey, void *> _maps;') ++ print() + + Retracer.retraceApi(self, api) + + def invokeFunction(self, function): + if function.name in ('Direct3DCreate9', 'Direct3DCreate9Ex'): +- print 'if (retrace::debug >= 2 && !g_szD3D9DllName && LoadLibraryA("d3d9d.dll")) {' +- print ' /*' +- print ' * D3D9D only works for simple applications, it will often report bogus errors' +- print ' * on complex traces, or traces which use unofficial D3D9 features.' +- print ' */' +- print ' g_szD3D9DllName = "d3d9d.dll";' +- print ' SDKVersion |= 0x80000000;' +- print '} else {' +- print ' SDKVersion &= ~0x80000000;' +- print '}' ++ print('if (retrace::debug >= 2 && !g_szD3D9DllName && LoadLibraryA("d3d9d.dll")) {') ++ print(' /*') ++ print(' * D3D9D only works for simple applications, it will often report bogus errors') ++ print(' * on complex traces, or traces which use unofficial D3D9 features.') ++ print(' */') ++ print(' g_szD3D9DllName = "d3d9d.dll";') ++ print(' SDKVersion |= 0x80000000;') ++ print('} else {') ++ print(' SDKVersion &= ~0x80000000;') ++ print('}') + + # d3d8d.dll can be found in the Aug 2007 DXSDK. It works on XP, but + # not on Windows 7. + if function.name in ('Direct3DCreate8'): +- print 'if (retrace::debug >= 2 && !g_szD3D8DllName && LoadLibraryA("d3d8d.dll")) {' +- print ' g_szD3D8DllName = "d3d8d.dll";' +- print '}' ++ print('if (retrace::debug >= 2 && !g_szD3D8DllName && LoadLibraryA("d3d8d.dll")) {') ++ print(' g_szD3D8DllName = "d3d8d.dll";') ++ print('}') + + Retracer.invokeFunction(self, function) + +@@ -73,37 +73,37 @@ class D3DRetracer(Retracer): + # keep track of the last used device for state dumping + if interface.name in ('IDirect3DDevice9', 'IDirect3DDevice9Ex'): + if method.name == 'Release': +- print r' if (call.ret->toUInt() == 0) {' +- print r' d3d9Dumper.unbindDevice(_this);' +- print r' }' ++ print(r' if (call.ret->toUInt() == 0) {') ++ print(r' d3d9Dumper.unbindDevice(_this);') ++ print(r' }') + else: +- print r' d3d9Dumper.bindDevice(_this);' ++ print(r' d3d9Dumper.bindDevice(_this);') + if interface.name in ('IDirect3DDevice8', 'IDirect3DDevice8Ex'): + if method.name == 'Release': +- print r' if (call.ret->toUInt() == 0) {' +- print r' d3d8Dumper.unbindDevice(_this);' +- print r' }' ++ print(r' if (call.ret->toUInt() == 0) {') ++ print(r' d3d8Dumper.unbindDevice(_this);') ++ print(r' }') + else: +- print r' d3d8Dumper.bindDevice(_this);' ++ print(r' d3d8Dumper.bindDevice(_this);') + + # create windows as neccessary + if method.name in ('CreateDevice', 'CreateDeviceEx', 'CreateAdditionalSwapChain'): +- print r' HWND hWnd = d3dretrace::createWindow(pPresentationParameters->BackBufferWidth, pPresentationParameters->BackBufferHeight);' +- print r' pPresentationParameters->hDeviceWindow = hWnd;' ++ print(r' HWND hWnd = d3dretrace::createWindow(pPresentationParameters->BackBufferWidth, pPresentationParameters->BackBufferHeight);') ++ print(r' pPresentationParameters->hDeviceWindow = hWnd;') + if 'hFocusWindow' in method.argNames(): +- print r' hFocusWindow = hWnd;' ++ print(r' hFocusWindow = hWnd;') + + # force windowed mode +- print r' if (retrace::forceWindowed) {' +- print r' pPresentationParameters->Windowed = TRUE;' +- print r' pPresentationParameters->FullScreen_RefreshRateInHz = 0;' ++ print(r' if (retrace::forceWindowed) {') ++ print(r' pPresentationParameters->Windowed = TRUE;') ++ print(r' pPresentationParameters->FullScreen_RefreshRateInHz = 0;') + if interface.name.startswith('IDirect3D8'): +- print r' pPresentationParameters->FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;' +- print r' }' ++ print(r' pPresentationParameters->FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;') ++ print(r' }') + if 'BehaviorFlags' in method.argNames(): +- print r' if (retrace::dumpingState) {' +- print r' BehaviorFlags &= ~D3DCREATE_PUREDEVICE;' +- print r' }' ++ print(r' if (retrace::dumpingState) {') ++ print(r' BehaviorFlags &= ~D3DCREATE_PUREDEVICE;') ++ print(r' }') + + # On D3D8, ensure we use BackBufferFormat compatible with the + # current DisplayFormat. +@@ -113,76 +113,76 @@ class D3DRetracer(Retracer): + # valid values for BackBufferFormat include D3DFMT_X1R5G5B5 and + # D3DFMT_A1R5G5B5, but exclude D3DFMT_R5G6B5. + if interface.name.startswith('IDirect3D8'): +- print r' if (pPresentationParameters->Windowed) {' +- print r' D3DDISPLAYMODE Mode;' +- print r' HRESULT hr;' +- print r' hr = _this->GetAdapterDisplayMode(Adapter, &Mode);' +- print r' assert(SUCCEEDED(hr));' +- print r' hr = _this->CheckDeviceType(Adapter, DeviceType, Mode.Format, pPresentationParameters->BackBufferFormat, pPresentationParameters->Windowed);' +- print r' if (hr == D3DERR_NOTAVAILABLE) {' +- print r' retrace::warning(call) << "forcing back buffer format to match display mode format\n";' +- print r' pPresentationParameters->BackBufferFormat = Mode.Format;' +- print r' }' +- print r' }' ++ print(r' if (pPresentationParameters->Windowed) {') ++ print(r' D3DDISPLAYMODE Mode;') ++ print(r' HRESULT hr;') ++ print(r' hr = _this->GetAdapterDisplayMode(Adapter, &Mode);') ++ print(r' assert(SUCCEEDED(hr));') ++ print(r' hr = _this->CheckDeviceType(Adapter, DeviceType, Mode.Format, pPresentationParameters->BackBufferFormat, pPresentationParameters->Windowed);') ++ print(r' if (hr == D3DERR_NOTAVAILABLE) {') ++ print(r' retrace::warning(call) << "forcing back buffer format to match display mode format\n";') ++ print(r' pPresentationParameters->BackBufferFormat = Mode.Format;') ++ print(r' }') ++ print(r' }') + + if method.name in self.createDeviceMethodNames: + # override the device type +- print r' switch (retrace::driver) {' +- print r' case retrace::DRIVER_HARDWARE:' +- print r' DeviceType = D3DDEVTYPE_HAL;' +- print r' break;' +- print r' case retrace::DRIVER_SOFTWARE:' +- print r' case retrace::DRIVER_REFERENCE:' +- print r' DeviceType = D3DDEVTYPE_REF;' +- print r' break;' +- print r' case retrace::DRIVER_NULL:' ++ print(r' switch (retrace::driver) {') ++ print(r' case retrace::DRIVER_HARDWARE:') ++ print(r' DeviceType = D3DDEVTYPE_HAL;') ++ print(r' break;') ++ print(r' case retrace::DRIVER_SOFTWARE:') ++ print(r' case retrace::DRIVER_REFERENCE:') ++ print(r' DeviceType = D3DDEVTYPE_REF;') ++ print(r' break;') ++ print(r' case retrace::DRIVER_NULL:') + if interface.name.startswith('IDirect3D9'): +- print r' DeviceType = D3DDEVTYPE_NULLREF;' ++ print(r' DeviceType = D3DDEVTYPE_NULLREF;') + else: +- print r' retrace::warning(call) << "null driver not supported\n";' +- print r' break;' +- print r' case retrace::DRIVER_MODULE:' +- print r' retrace::warning(call) << "driver module not supported\n";' +- print r' break;' +- print r' default:' +- print r' assert(0);' +- print r' /* fall-through */' +- print r' case retrace::DRIVER_DEFAULT:' +- print r' break;' +- print r' }' ++ print(r' retrace::warning(call) << "null driver not supported\n";') ++ print(r' break;') ++ print(r' case retrace::DRIVER_MODULE:') ++ print(r' retrace::warning(call) << "driver module not supported\n";') ++ print(r' break;') ++ print(r' default:') ++ print(r' assert(0);') ++ print(r' /* fall-through */') ++ print(r' case retrace::DRIVER_DEFAULT:') ++ print(r' break;') ++ print(r' }') + + if method.name in ('Reset', 'ResetEx'): + # force windowed mode +- print r' if (retrace::forceWindowed) {' +- print r' pPresentationParameters->Windowed = TRUE;' +- print r' pPresentationParameters->FullScreen_RefreshRateInHz = 0;' +- print r' }' ++ print(r' if (retrace::forceWindowed) {') ++ print(r' pPresentationParameters->Windowed = TRUE;') ++ print(r' pPresentationParameters->FullScreen_RefreshRateInHz = 0;') ++ print(r' }') + # resize window +- print r' if (pPresentationParameters->Windowed) {' +- print r' d3dretrace::resizeWindow(pPresentationParameters->hDeviceWindow, pPresentationParameters->BackBufferWidth, pPresentationParameters->BackBufferHeight);' +- print r' }' ++ print(r' if (pPresentationParameters->Windowed) {') ++ print(r' d3dretrace::resizeWindow(pPresentationParameters->hDeviceWindow, pPresentationParameters->BackBufferWidth, pPresentationParameters->BackBufferHeight);') ++ print(r' }') + + # notify frame has been completed + if method.name in ('Present', 'PresentEx'): + if interface.name.startswith('IDirect3DSwapChain9'): +- print r' d3d9scDumper.bindDevice(_this);' +- print r' retrace::frameComplete(call);' +- print r' hDestWindowOverride = NULL;' ++ print(r' d3d9scDumper.bindDevice(_this);') ++ print(r' retrace::frameComplete(call);') ++ print(r' hDestWindowOverride = NULL;') + + # Ensure textures can be locked when dumping + # TODO: Pre-check with CheckDeviceFormat + if method.name in ('CreateTexture', 'CreateCubeTexture', 'CreateVolumeTexture'): +- print r' if (retrace::dumpingState &&' +- print r' Pool == D3DPOOL_DEFAULT &&' +- print r' !(Usage & (D3DUSAGE_RENDERTARGET|D3DUSAGE_DEPTHSTENCIL))) {' +- print r' Usage |= D3DUSAGE_DYNAMIC;' +- print r' }' ++ print(r' if (retrace::dumpingState &&') ++ print(r' Pool == D3DPOOL_DEFAULT &&') ++ print(r' !(Usage & (D3DUSAGE_RENDERTARGET|D3DUSAGE_DEPTHSTENCIL))) {') ++ print(r' Usage |= D3DUSAGE_DYNAMIC;') ++ print(r' }') + + if 'pSharedHandle' in method.argNames(): +- print r' if (pSharedHandle) {' +- print r' retrace::warning(call) << "shared surfaces unsupported\n";' +- print r' pSharedHandle = NULL;' +- print r' }' ++ print(r' if (pSharedHandle) {') ++ print(r' retrace::warning(call) << "shared surfaces unsupported\n";') ++ print(r' pSharedHandle = NULL;') ++ print(r' }') + + if method.name in ('Lock', 'LockRect', 'LockBox'): + # Reset _DONOTWAIT flags. Otherwise they may fail, and we have no +@@ -190,7 +190,7 @@ class D3DRetracer(Retracer): + mapFlagsArg = method.getArgByName('Flags') + for flag in mapFlagsArg.type.values: + if flag.endswith('_DONOTWAIT'): +- print r' Flags &= ~%s;' % flag ++ print(r' Flags &= ~%s;' % flag) + + Retracer.invokeInterfaceMethod(self, interface, method) + +@@ -201,7 +201,7 @@ class D3DRetracer(Retracer): + + # process events after presents + if method.name == 'Present': +- print r' d3dretrace::processEvents();' ++ print(r' d3dretrace::processEvents();') + + def mapping_subkey(): + if 'Level' in method.argNames(): +@@ -210,35 +210,35 @@ class D3DRetracer(Retracer): + return ('0',) + + if method.name in ('Lock', 'LockRect', 'LockBox'): +- print ' VOID *_pbData = NULL;' +- print ' size_t _MappedSize = 0;' +- print ' if (!(Flags & D3DLOCK_READONLY)) {' +- print ' _getMapInfo(_this, %s, _pbData, _MappedSize);' % ', '.join(method.argNames()[:-1]) +- print ' }' +- print ' if (_MappedSize) {' +- print ' _maps[MappingKey(_this, %s)] = _pbData;' % mapping_subkey() ++ print(' VOID *_pbData = NULL;') ++ print(' size_t _MappedSize = 0;') ++ print(' if (!(Flags & D3DLOCK_READONLY)) {') ++ print(' _getMapInfo(_this, %s, _pbData, _MappedSize);' % ', '.join(method.argNames()[:-1])) ++ print(' }') ++ print(' if (_MappedSize) {') ++ print(' _maps[MappingKey(_this, %s)] = _pbData;' % mapping_subkey()) + self.checkPitchMismatch(method) +- print ' } else {' +- print ' return;' +- print ' }' ++ print(' } else {') ++ print(' return;') ++ print(' }') + + if method.name in ('Unlock', 'UnlockRect', 'UnlockBox'): +- print ' VOID *_pbData = 0;' +- print ' MappingKey _mappingKey(_this, %s);' % mapping_subkey() +- print ' _pbData = _maps[_mappingKey];' +- print ' if (_pbData) {' +- print ' retrace::delRegionByPointer(_pbData);' +- print ' _maps[_mappingKey] = 0;' +- print ' }' ++ print(' VOID *_pbData = 0;') ++ print(' MappingKey _mappingKey(_this, %s);' % mapping_subkey()) ++ print(' _pbData = _maps[_mappingKey];') ++ print(' if (_pbData) {') ++ print(' retrace::delRegionByPointer(_pbData);') ++ print(' _maps[_mappingKey] = 0;') ++ print(' }') + + + def main(): +- print r'#include <string.h>' +- print +- print r'#include <iostream>' +- print +- print r'#include "d3dretrace.hpp"' +- print ++ print(r'#include <string.h>') ++ print() ++ print(r'#include <iostream>') ++ print() ++ print(r'#include "d3dretrace.hpp"') ++ print() + + moduleName = sys.argv[1] + support = int(sys.argv[2]) +@@ -249,24 +249,24 @@ def main(): + if moduleName == 'd3d9': + from specs.d3d9 import d3d9, d3dperf + from specs.dxva2 import dxva2 +- print r'#include "d3d9imports.hpp"' +- print r'#include "d3d9size.hpp"' +- print r'#include "dxva2imports.hpp"' ++ print(r'#include "d3d9imports.hpp"') ++ print(r'#include "d3d9size.hpp"') ++ print(r'#include "dxva2imports.hpp"') + d3d9.mergeModule(d3dperf) + api.addModule(d3d9) + api.addModule(dxva2) +- print +- print '''static d3dretrace::D3DDumper<IDirect3DDevice9> d3d9Dumper;''' +- print '''static d3dretrace::D3DDumper<IDirect3DSwapChain9> d3d9scDumper;''' +- print ++ print() ++ print('''static d3dretrace::D3DDumper<IDirect3DDevice9> d3d9Dumper;''') ++ print('''static d3dretrace::D3DDumper<IDirect3DSwapChain9> d3d9scDumper;''') ++ print() + elif moduleName == 'd3d8': + from specs.d3d8 import d3d8 +- print r'#include "d3d8imports.hpp"' +- print r'#include "d3d8size.hpp"' ++ print(r'#include "d3d8imports.hpp"') ++ print(r'#include "d3d8size.hpp"') + api.addModule(d3d8) +- print +- print '''static d3dretrace::D3DDumper<IDirect3DDevice8> d3d8Dumper;''' +- print ++ print() ++ print('''static d3dretrace::D3DDumper<IDirect3DDevice8> d3d8Dumper;''') ++ print() + else: + assert False + +diff --git a/retrace/ddrawretrace.py b/retrace/ddrawretrace.py +index 4f2ff944..863283fd 100644 +--- a/retrace/ddrawretrace.py ++++ b/retrace/ddrawretrace.py +@@ -37,12 +37,12 @@ from specs.ddraw import DDCREATE_LPGUID + class D3DRetracer(Retracer): + + def retraceApi(self, api): +- print '// Swizzling mapping for lock addresses' +- print 'static std::map<void *, void *> _maps;' +- print ++ print('// Swizzling mapping for lock addresses') ++ print('static std::map<void *, void *> _maps;') ++ print() + # TODO: Keep a table of windows +- print 'static HWND g_hWnd;' +- print ++ print('static HWND g_hWnd;') ++ print() + + Retracer.retraceApi(self, api) + +@@ -50,20 +50,20 @@ class D3DRetracer(Retracer): + # keep track of the last used device for state dumping + if interface.name in ('IDirect3DDevice7',): + if method.name == 'Release': +- print r' if (call.ret->toUInt() == 0) {' +- print r' d3d7Dumper.unbindDevice(_this);' +- print r' }' ++ print(r' if (call.ret->toUInt() == 0) {') ++ print(r' d3d7Dumper.unbindDevice(_this);') ++ print(r' }') + else: +- print r' d3d7Dumper.bindDevice(_this);' ++ print(r' d3d7Dumper.bindDevice(_this);') + + # create windows as neccessary + hWndArg = method.getArgByType(HWND) + if hWndArg is not None: + # FIXME: Try to guess the window size (e.g., from IDirectDrawSurface7::Blt) +- print r' if (!g_hWnd) {' +- print r' g_hWnd = d3dretrace::createWindow(512, 512);' +- print r' }' +- print r' %s = g_hWnd;' % hWndArg.name ++ print(r' if (!g_hWnd) {') ++ print(r' g_hWnd = d3dretrace::createWindow(512, 512);') ++ print(r' }') ++ print(r' %s = g_hWnd;' % hWndArg.name) + + + if method.name == 'Lock': +@@ -71,74 +71,74 @@ class D3DRetracer(Retracer): + # way to cope with it (other than retry). + mapFlagsArg = method.getArgByName('dwFlags') + if mapFlagsArg is not None: +- print r' dwFlags &= DDLOCK_DONOTWAIT;' +- print r' dwFlags |= DDLOCK_WAIT;' ++ print(r' dwFlags &= DDLOCK_DONOTWAIT;') ++ print(r' dwFlags |= DDLOCK_WAIT;') + + Retracer.invokeInterfaceMethod(self, interface, method) + + if method.name == 'CreateDevice': +- print r' if (FAILED(_result)) {' +- print r' exit(1);' +- print r' }' ++ print(r' if (FAILED(_result)) {') ++ print(r' exit(1);') ++ print(r' }') + + # notify frame has been completed + # process events after presents + if interface.name == 'IDirectDrawSurface7' and method.name == 'Blt': +- print r' DDSCAPS2 ddsCaps;' +- print r' if (SUCCEEDED(_this->GetCaps(&ddsCaps)) &&' +- print r' (ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)) {' +- print r' retrace::frameComplete(call);' +- print r' d3dretrace::processEvents();' +- print r' }' ++ print(r' DDSCAPS2 ddsCaps;') ++ print(r' if (SUCCEEDED(_this->GetCaps(&ddsCaps)) &&') ++ print(r' (ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)) {') ++ print(r' retrace::frameComplete(call);') ++ print(r' d3dretrace::processEvents();') ++ print(r' }') + + if method.name == 'Lock': +- print ' VOID *_pbData = NULL;' +- print ' size_t _MappedSize = 0;' ++ print(' VOID *_pbData = NULL;') ++ print(' size_t _MappedSize = 0;') + # FIXME: determine the mapping size + #print ' _getMapInfo(_this, %s, _pbData, _MappedSize);' % ', '.join(method.argNames()[:-1]) +- print ' if (_MappedSize) {' +- print ' _maps[_this] = _pbData;' ++ print(' if (_MappedSize) {') ++ print(' _maps[_this] = _pbData;') + # TODO: check pitches match +- print ' } else {' +- print ' return;' +- print ' }' ++ print(' } else {') ++ print(' return;') ++ print(' }') + + if method.name == 'Unlock': +- print ' VOID *_pbData = 0;' +- print ' _pbData = _maps[_this];' +- print ' if (_pbData) {' +- print ' retrace::delRegionByPointer(_pbData);' +- print ' _maps[_this] = 0;' +- print ' }' ++ print(' VOID *_pbData = 0;') ++ print(' _pbData = _maps[_this];') ++ print(' if (_pbData) {') ++ print(' retrace::delRegionByPointer(_pbData);') ++ print(' _maps[_this] = 0;') ++ print(' }') + + def extractArg(self, function, arg, arg_type, lvalue, rvalue): + # Handle DDCREATE_* flags + if arg.type is DDCREATE_LPGUID: +- print ' if (%s.toArray()) {' % rvalue ++ print(' if (%s.toArray()) {' % rvalue) + Retracer.extractArg(self, function, arg, arg_type, lvalue, rvalue) +- print ' } else {' +- print ' %s = static_cast<%s>(%s.toPointer());' % (lvalue, arg_type, rvalue) +- print ' }' ++ print(' } else {') ++ print(' %s = static_cast<%s>(%s.toPointer());' % (lvalue, arg_type, rvalue)) ++ print(' }') + return + + Retracer.extractArg(self, function, arg, arg_type, lvalue, rvalue) + + + def main(): +- print r'#include <string.h>' +- print +- print r'#include <iostream>' +- print +- print r'#include "d3dretrace.hpp"' +- print ++ print(r'#include <string.h>') ++ print() ++ print(r'#include <iostream>') ++ print() ++ print(r'#include "d3dretrace.hpp"') ++ print() + + api = API() + +- print r'#include "d3dimports.hpp"' ++ print(r'#include "d3dimports.hpp"') + api.addModule(ddraw) +- print +- print '''static d3dretrace::D3DDumper<IDirect3DDevice7> d3d7Dumper;''' +- print ++ print() ++ print('''static d3dretrace::D3DDumper<IDirect3DDevice7> d3d7Dumper;''') ++ print() + + retracer = D3DRetracer() + retracer.table_name = 'd3dretrace::ddraw_callbacks' +diff --git a/retrace/dllretrace.py b/retrace/dllretrace.py +index c818b0a9..ad9db9a4 100644 +--- a/retrace/dllretrace.py ++++ b/retrace/dllretrace.py +@@ -33,29 +33,29 @@ class DllDispatcher(Dispatcher): + + def dispatchModule(self, module): + tag = module.name.upper() +- print r'const char *g_sz%sDllName = NULL;' % (tag,) +- print r'HMODULE g_h%sModule = NULL;' % (tag,) +- print r'' +- print r'static PROC' +- print r'_get%sProcAddress(LPCSTR lpProcName) {' % tag +- print r' if (!g_h%sModule) {' % tag +- print r' if (g_sz%sDllName) {' % tag +- print r' g_h%sModule = LoadLibraryA(g_sz%sDllName);' % (tag, tag) +- print r' if (!g_h%sModule) {' % tag +- print r' os::log("warning: failed to load %%s\n", g_sz%sDllName);' % tag +- print r' }' +- print r' }' +- print r' if (!g_h%sModule) {' % tag +- print r' g_h%sModule = LoadLibraryA("%s.dll");' % (tag, module.name) +- print r' }' +- print r' if (!g_h%sModule) {' % tag +- print r' os::log("error: failed to load %s.dll\n");' % module.name +- print r' exit(1);' +- print r' }' +- print r' }' +- print r' return GetProcAddress(g_h%sModule, lpProcName);' % tag +- print r'}' +- print r'' ++ print(r'const char *g_sz%sDllName = NULL;' % (tag,)) ++ print(r'HMODULE g_h%sModule = NULL;' % (tag,)) ++ print(r'') ++ print(r'static PROC') ++ print(r'_get%sProcAddress(LPCSTR lpProcName) {' % tag) ++ print(r' if (!g_h%sModule) {' % tag) ++ print(r' if (g_sz%sDllName) {' % tag) ++ print(r' g_h%sModule = LoadLibraryA(g_sz%sDllName);' % (tag, tag)) ++ print(r' if (!g_h%sModule) {' % tag) ++ print(r' os::log("warning: failed to load %%s\n", g_sz%sDllName);' % tag) ++ print(r' }') ++ print(r' }') ++ print(r' if (!g_h%sModule) {' % tag) ++ print(r' g_h%sModule = LoadLibraryA("%s.dll");' % (tag, module.name)) ++ print(r' }') ++ print(r' if (!g_h%sModule) {' % tag) ++ print(r' os::log("error: failed to load %s.dll\n");' % module.name) ++ print(r' exit(1);') ++ print(r' }') ++ print(r' }') ++ print(r' return GetProcAddress(g_h%sModule, lpProcName);' % tag) ++ print(r'}') ++ print(r'') + + Dispatcher.dispatchModule(self, module) + +diff --git a/retrace/dxgiretrace.py b/retrace/dxgiretrace.py +index 799e3df9..8986a767 100755 +--- a/retrace/dxgiretrace.py ++++ b/retrace/dxgiretrace.py +@@ -40,10 +40,10 @@ from specs.d3d11 import d3d11 + class D3DRetracer(Retracer): + + def retraceApi(self, api): +- print '// Swizzling mapping for lock addresses, mapping a (pDeviceContext, pResource, Subresource) -> void *' +- print 'typedef std::pair< IUnknown *, UINT > SubresourceKey;' +- print 'static std::map< IUnknown *, std::map< SubresourceKey, void * > > g_Maps;' +- print ++ print('// Swizzling mapping for lock addresses, mapping a (pDeviceContext, pResource, Subresource) -> void *') ++ print('typedef std::pair< IUnknown *, UINT > SubresourceKey;') ++ print('static std::map< IUnknown *, std::map< SubresourceKey, void * > > g_Maps;') ++ print() + self.table_name = 'd3dretrace::dxgi_callbacks' + + Retracer.retraceApi(self, api) +@@ -61,41 +61,41 @@ class D3DRetracer(Retracer): + if function.name in self.createDeviceFunctionNames: + # create windows as neccessary + if 'pSwapChainDesc' in function.argNames(): +- print r' d3dretrace::createWindowForSwapChain(pSwapChainDesc);' ++ print(r' d3dretrace::createWindowForSwapChain(pSwapChainDesc);') + + # Compensate for the fact we don't trace DXGI object creation + if function.name.startswith('D3D11CreateDevice'): +- print r' if (DriverType == D3D_DRIVER_TYPE_UNKNOWN && !pAdapter) {' +- print r' DriverType = D3D_DRIVER_TYPE_HARDWARE;' +- print r' }' ++ print(r' if (DriverType == D3D_DRIVER_TYPE_UNKNOWN && !pAdapter) {') ++ print(r' DriverType = D3D_DRIVER_TYPE_HARDWARE;') ++ print(r' }') + + if function.name.startswith('D3D10CreateDevice'): + # Toggle debugging +- print r' Flags &= ~D3D10_CREATE_DEVICE_DEBUG;' +- print r' if (retrace::debug) {' +- print r' HMODULE hD3d10SdkLayers = LoadLibraryA("d3d10sdklayers");' +- print r' if (hD3d10SdkLayers) {' +- print r' FreeLibrary(hD3d10SdkLayers);' +- print r' Flags |= D3D10_CREATE_DEVICE_DEBUG;' +- print r' } else {' +- print r' retrace::warning(call) << "Direct3D 10.x SDK Debug Layer (d3d10sdklayers.dll) not available, continuing without debug output\n";' +- print r' }' +- print r' }' ++ print(r' Flags &= ~D3D10_CREATE_DEVICE_DEBUG;') ++ print(r' if (retrace::debug) {') ++ print(r' HMODULE hD3d10SdkLayers = LoadLibraryA("d3d10sdklayers");') ++ print(r' if (hD3d10SdkLayers) {') ++ print(r' FreeLibrary(hD3d10SdkLayers);') ++ print(r' Flags |= D3D10_CREATE_DEVICE_DEBUG;') ++ print(r' } else {') ++ print(r' retrace::warning(call) << "Direct3D 10.x SDK Debug Layer (d3d10sdklayers.dll) not available, continuing without debug output\n";') ++ print(r' }') ++ print(r' }') + + # Force driver + self.forceDriver('D3D10_DRIVER_TYPE') + + if function.name.startswith('D3D11CreateDevice'): + # Toggle debugging +- print r' Flags &= ~D3D11_CREATE_DEVICE_DEBUG;' +- print r' if (retrace::debug) {' +- print r' HRESULT hr = D3D11CreateDevice(NULL, D3D_DRIVER_TYPE_NULL, 0, D3D11_CREATE_DEVICE_DEBUG, NULL, 0, D3D11_SDK_VERSION, NULL, NULL, NULL);' +- print r' if (SUCCEEDED(hr)) {' +- print r' Flags |= D3D11_CREATE_DEVICE_DEBUG;' +- print r' } else {' +- print r' retrace::warning(call) << "Direct3D 11.x SDK Debug Layer (d3d11*sdklayers.dll) not available, continuing without debug output\n";' +- print r' }' +- print r' }' ++ print(r' Flags &= ~D3D11_CREATE_DEVICE_DEBUG;') ++ print(r' if (retrace::debug) {') ++ print(r' HRESULT hr = D3D11CreateDevice(NULL, D3D_DRIVER_TYPE_NULL, 0, D3D11_CREATE_DEVICE_DEBUG, NULL, 0, D3D11_SDK_VERSION, NULL, NULL, NULL);') ++ print(r' if (SUCCEEDED(hr)) {') ++ print(r' Flags |= D3D11_CREATE_DEVICE_DEBUG;') ++ print(r' } else {') ++ print(r' retrace::warning(call) << "Direct3D 11.x SDK Debug Layer (d3d11*sdklayers.dll) not available, continuing without debug output\n";') ++ print(r' }') ++ print(r' }') + + # Force driver + self.forceDriver('D3D_DRIVER_TYPE') +@@ -108,15 +108,15 @@ class D3DRetracer(Retracer): + if interface is not None: + getDeviceRemovedReasonMethod = interface.getMethodByName("GetDeviceRemovedReason") + if getDeviceRemovedReasonMethod is not None: +- print r' if (FAILED(_result)) {' +- print r' retrace::failed(call, _result);' +- print r' if (_result == DXGI_ERROR_DEVICE_REMOVED) {' +- print r' HRESULT _reason = _this->GetDeviceRemovedReason();' +- print r' retrace::failed(call, _reason);' +- print r' exit(1);' +- print r' }' +- print r' return;' +- print r' }' ++ print(r' if (FAILED(_result)) {') ++ print(r' retrace::failed(call, _result);') ++ print(r' if (_result == DXGI_ERROR_DEVICE_REMOVED) {') ++ print(r' HRESULT _reason = _this->GetDeviceRemovedReason();') ++ print(r' retrace::failed(call, _reason);') ++ print(r' exit(1);') ++ print(r' }') ++ print(r' return;') ++ print(r' }') + return + + Retracer.checkResult(self, interface, methodOrFunction) +@@ -124,112 +124,112 @@ class D3DRetracer(Retracer): + def forceDriver(self, enum): + # This can only work when pAdapter is NULL. For non-NULL pAdapter we + # need to override inside the EnumAdapters call below +- print r' if (pAdapter == NULL) {' +- print r' switch (retrace::driver) {' +- print r' case retrace::DRIVER_HARDWARE:' +- print r' DriverType = %s_HARDWARE;' % enum +- print r' Software = NULL;' +- print r' break;' +- print r' case retrace::DRIVER_SOFTWARE:' +- print r' DriverType = %s_WARP;' % enum +- print r' Software = NULL;' +- print r' break;' +- print r' case retrace::DRIVER_REFERENCE:' +- print r' DriverType = %s_REFERENCE;' % enum +- print r' Software = NULL;' +- print r' break;' +- print r' case retrace::DRIVER_NULL:' +- print r' DriverType = %s_NULL;' % enum +- print r' Software = NULL;' +- print r' break;' +- print r' case retrace::DRIVER_MODULE:' +- print r' DriverType = %s_SOFTWARE;' % enum +- print r' Software = LoadLibraryA(retrace::driverModule);' +- print r' if (!Software) {' +- print r' retrace::warning(call) << "failed to load " << retrace::driverModule << "\n";' +- print r' }' +- print r' break;' +- print r' default:' +- print r' assert(0);' +- print r' /* fall-through */' +- print r' case retrace::DRIVER_DEFAULT:' +- print r' if (DriverType == %s_SOFTWARE) {' % enum +- print r' Software = LoadLibraryA("d3d10warp");' +- print r' if (!Software) {' +- print r' retrace::warning(call) << "failed to load d3d10warp.dll\n";' +- print r' }' +- print r' }' +- print r' break;' +- print r' }' +- print r' } else {' +- print r' Software = NULL;' +- print r' }' ++ print(r' if (pAdapter == NULL) {') ++ print(r' switch (retrace::driver) {') ++ print(r' case retrace::DRIVER_HARDWARE:') ++ print(r' DriverType = %s_HARDWARE;' % enum) ++ print(r' Software = NULL;') ++ print(r' break;') ++ print(r' case retrace::DRIVER_SOFTWARE:') ++ print(r' DriverType = %s_WARP;' % enum) ++ print(r' Software = NULL;') ++ print(r' break;') ++ print(r' case retrace::DRIVER_REFERENCE:') ++ print(r' DriverType = %s_REFERENCE;' % enum) ++ print(r' Software = NULL;') ++ print(r' break;') ++ print(r' case retrace::DRIVER_NULL:') ++ print(r' DriverType = %s_NULL;' % enum) ++ print(r' Software = NULL;') ++ print(r' break;') ++ print(r' case retrace::DRIVER_MODULE:') ++ print(r' DriverType = %s_SOFTWARE;' % enum) ++ print(r' Software = LoadLibraryA(retrace::driverModule);') ++ print(r' if (!Software) {') ++ print(r' retrace::warning(call) << "failed to load " << retrace::driverModule << "\n";') ++ print(r' }') ++ print(r' break;') ++ print(r' default:') ++ print(r' assert(0);') ++ print(r' /* fall-through */') ++ print(r' case retrace::DRIVER_DEFAULT:') ++ print(r' if (DriverType == %s_SOFTWARE) {' % enum) ++ print(r' Software = LoadLibraryA("d3d10warp");') ++ print(r' if (!Software) {') ++ print(r' retrace::warning(call) << "failed to load d3d10warp.dll\n";') ++ print(r' }') ++ print(r' }') ++ print(r' break;') ++ print(r' }') ++ print(r' } else {') ++ print(r' Software = NULL;') ++ print(r' }') + + def invokeInterfaceMethod(self, interface, method): + # keep track of the last used device for state dumping + if interface.name in ('ID3D10Device', 'ID3D10Device1'): + if method.name == 'Release': +- print r' if (call.ret->toUInt() == 0) {' +- print r' d3d10Dumper.unbindDevice(_this);' +- print r' }' ++ print(r' if (call.ret->toUInt() == 0) {') ++ print(r' d3d10Dumper.unbindDevice(_this);') ++ print(r' }') + else: +- print r' d3d10Dumper.bindDevice(_this);' ++ print(r' d3d10Dumper.bindDevice(_this);') + if interface.name.startswith('ID3D11DeviceContext'): + if method.name == 'Release': +- print r' if (call.ret->toUInt() == 0) {' +- print r' d3d11Dumper.unbindDevice(_this);' +- print r' }' ++ print(r' if (call.ret->toUInt() == 0) {') ++ print(r' d3d11Dumper.unbindDevice(_this);') ++ print(r' }') + else: +- print r' if (_this->GetType() == D3D11_DEVICE_CONTEXT_IMMEDIATE) {' +- print r' d3d11Dumper.bindDevice(_this);' +- print r' }' ++ print(r' if (_this->GetType() == D3D11_DEVICE_CONTEXT_IMMEDIATE) {') ++ print(r' d3d11Dumper.bindDevice(_this);') ++ print(r' }') + + # intercept private interfaces + if method.name == 'QueryInterface': +- print r' if (!d3dretrace::overrideQueryInterface(_this, riid, ppvObj, &_result)) {' ++ print(r' if (!d3dretrace::overrideQueryInterface(_this, riid, ppvObj, &_result)) {') + Retracer.invokeInterfaceMethod(self, interface, method) +- print r' }' ++ print(r' }') + return + + # create windows as neccessary + if method.name == 'CreateSwapChain': +- print r' d3dretrace::createWindowForSwapChain(pDesc);' ++ print(r' d3dretrace::createWindowForSwapChain(pDesc);') + if method.name == 'CreateSwapChainForHwnd': +- print r' WindowHandle = d3dretrace::createWindow(pDesc->Width, pDesc->Height);' +- print r' // DXGI_SCALING_NONE is only supported on Win8 and beyond' +- print r' if (pDesc->Scaling == DXGI_SCALING_NONE && !IsWindows8OrGreater()) {' +- print r' pDesc->Scaling = DXGI_SCALING_STRETCH;' +- print r' }' ++ print(r' WindowHandle = d3dretrace::createWindow(pDesc->Width, pDesc->Height);') ++ print(r' // DXGI_SCALING_NONE is only supported on Win8 and beyond') ++ print(r' if (pDesc->Scaling == DXGI_SCALING_NONE && !IsWindows8OrGreater()) {') ++ print(r' pDesc->Scaling = DXGI_SCALING_STRETCH;') ++ print(r' }') + if method.name == 'CreateSwapChainForComposition': +- print r' HWND hWnd = d3dretrace::createWindow(pDesc->Width, pDesc->Height);' +- print r' _result = _this->CreateSwapChainForHwnd(pDevice, hWnd, pDesc, NULL, pRestrictToOutput, ppSwapChain);' ++ print(r' HWND hWnd = d3dretrace::createWindow(pDesc->Width, pDesc->Height);') ++ print(r' _result = _this->CreateSwapChainForHwnd(pDevice, hWnd, pDesc, NULL, pRestrictToOutput, ppSwapChain);') + self.checkResult(interface, method) + return + + if method.name == 'SetFullscreenState': +- print r' if (retrace::forceWindowed) {' +- print r' Fullscreen = FALSE;' +- print r' pTarget = NULL;' +- print r' }' ++ print(r' if (retrace::forceWindowed) {') ++ print(r' Fullscreen = FALSE;') ++ print(r' pTarget = NULL;') ++ print(r' }') + + # notify frame has been completed + if interface.name.startswith('IDXGISwapChain') and method.name.startswith('Present'): + if interface.name.startswith('IDXGISwapChainDWM'): +- print r' com_ptr<IDXGISwapChain> pSwapChain;' +- print r' if (SUCCEEDED(_this->QueryInterface(IID_IDXGISwapChain, (void **) &pSwapChain))) {' +- print r' dxgiDumper.bindDevice(pSwapChain);' +- print r' } else {' +- print r' assert(0);' +- print r' }' ++ print(r' com_ptr<IDXGISwapChain> pSwapChain;') ++ print(r' if (SUCCEEDED(_this->QueryInterface(IID_IDXGISwapChain, (void **) &pSwapChain))) {') ++ print(r' dxgiDumper.bindDevice(pSwapChain);') ++ print(r' } else {') ++ print(r' assert(0);') ++ print(r' }') + else: +- print r' dxgiDumper.bindDevice(_this);' +- print r' retrace::frameComplete(call);' ++ print(r' dxgiDumper.bindDevice(_this);') ++ print(r' retrace::frameComplete(call);') + + if 'pSharedResource' in method.argNames(): +- print r' if (pSharedResource) {' +- print r' retrace::warning(call) << "shared surfaces unsupported\n";' +- print r' pSharedResource = NULL;' +- print r' }' ++ print(r' if (pSharedResource) {') ++ print(r' retrace::warning(call) << "shared surfaces unsupported\n";') ++ print(r' pSharedResource = NULL;') ++ print(r' }') + + # Force driver + if interface.name.startswith('IDXGIFactory') and method.name.startswith('EnumAdapters'): +@@ -260,31 +260,31 @@ class D3DRetracer(Retracer): + return + + if interface.name.startswith('ID3D10Device') and method.name.startswith('OpenSharedResource'): +- print r' retrace::warning(call) << "replacing shared resource with checker pattern\n";' +- print r' _result = d3dretrace::createSharedResource(_this, ReturnedInterface, ppResource);' ++ print(r' retrace::warning(call) << "replacing shared resource with checker pattern\n";') ++ print(r' _result = d3dretrace::createSharedResource(_this, ReturnedInterface, ppResource);') + self.checkResult(interface, method) + return + if interface.name.startswith('ID3D11Device') and method.name == 'OpenSharedResource': + # Some applications (e.g., video playing in IE11) create shared resources within the same process. + # TODO: Generalize to other OpenSharedResource variants +- print r' retrace::map<HANDLE>::const_iterator it = _shared_handle_map.find(hResource);' +- print r' if (it == _shared_handle_map.end()) {' +- print r' retrace::warning(call) << "replacing shared resource with checker pattern\n";' +- print r' _result = d3dretrace::createSharedResource(_this, ReturnedInterface, ppResource);' ++ print(r' retrace::map<HANDLE>::const_iterator it = _shared_handle_map.find(hResource);') ++ print(r' if (it == _shared_handle_map.end()) {') ++ print(r' retrace::warning(call) << "replacing shared resource with checker pattern\n";') ++ print(r' _result = d3dretrace::createSharedResource(_this, ReturnedInterface, ppResource);') + self.checkResult(interface, method) +- print r' } else {' +- print r' hResource = it->second;' ++ print(r' } else {') ++ print(r' hResource = it->second;') + Retracer.invokeInterfaceMethod(self, interface, method) +- print r' }' ++ print(r' }') + return + if interface.name.startswith('ID3D11Device') and method.name.startswith('OpenSharedResource'): +- print r' retrace::warning(call) << "replacing shared resource with checker pattern\n";' +- print r' _result = d3dretrace::createSharedResource(_this, ReturnedInterface, ppResource);' ++ print(r' retrace::warning(call) << "replacing shared resource with checker pattern\n";') ++ print(r' _result = d3dretrace::createSharedResource(_this, ReturnedInterface, ppResource);') + if method.name == 'OpenSharedResourceByName': +- print r' (void)lpName;' +- print r' (void)dwDesiredAccess;' ++ print(r' (void)lpName;') ++ print(r' (void)dwDesiredAccess;') + else: +- print r' (void)hResource;' ++ print(r' (void)hResource;') + self.checkResult(interface, method) + return + +@@ -294,7 +294,7 @@ class D3DRetracer(Retracer): + mapFlagsArg = method.getArgByName('MapFlags') + for flag in mapFlagsArg.type.values: + if flag.endswith('_MAP_FLAG_DO_NOT_WAIT'): +- print r' MapFlags &= ~%s;' % flag ++ print(r' MapFlags &= ~%s;' % flag) + + if method.name.startswith('UpdateSubresource'): + # The D3D10 debug layer is buggy (or at least inconsistent with the +@@ -303,108 +303,108 @@ class D3DRetracer(Retracer): + # SrcDepthPitch is garbagge for non 3D textures. + # XXX: It also seems to expect padding bytes at the end of the last + # row, but we never record (or allocate) those... +- print r' if (retrace::debug && pDstBox && pDstBox->front == 0 && pDstBox->back == 1) {' +- print r' SrcDepthPitch = 0;' +- print r' }' ++ print(r' if (retrace::debug && pDstBox && pDstBox->front == 0 && pDstBox->back == 1) {') ++ print(r' SrcDepthPitch = 0;') ++ print(r' }') + + if method.name == 'SetGammaControl': + # This method is only supported while in full-screen mode +- print r' if (retrace::forceWindowed) {' +- print r' return;' +- print r' }' ++ print(r' if (retrace::forceWindowed) {') ++ print(r' return;') ++ print(r' }') + + Retracer.invokeInterfaceMethod(self, interface, method) + + if method.name in ('AcquireSync', 'ReleaseSync'): +- print r' if (SUCCEEDED(_result) && _result != S_OK) {' +- print r' retrace::warning(call) << " returned " << _result << "\n";' +- print r' }' ++ print(r' if (SUCCEEDED(_result) && _result != S_OK) {') ++ print(r' retrace::warning(call) << " returned " << _result << "\n";') ++ print(r' }') + + # process events after presents + if interface.name.startswith('IDXGISwapChain') and method.name.startswith('Present'): +- print r' d3dretrace::processEvents();' ++ print(r' d3dretrace::processEvents();') + + if method.name in ('Map', 'Unmap'): + if interface.name.startswith('ID3D11DeviceContext'): +- print ' void * & _pbData = g_Maps[_this][SubresourceKey(pResource, Subresource)];' ++ print(' void * & _pbData = g_Maps[_this][SubresourceKey(pResource, Subresource)];') + else: + subresourceArg = method.getArgByName('Subresource') + if subresourceArg is None: +- print ' UINT Subresource = 0;' +- print ' void * & _pbData = g_Maps[0][SubresourceKey(_this, Subresource)];' ++ print(' UINT Subresource = 0;') ++ print(' void * & _pbData = g_Maps[0][SubresourceKey(_this, Subresource)];') + + if method.name == 'Map': +- print ' _MAP_DESC _MapDesc;' +- print ' _getMapDesc(_this, %s, _MapDesc);' % ', '.join(method.argNames()) +- print ' size_t _MappedSize = _MapDesc.Size;' +- print ' if (_MapDesc.Size) {' +- print ' _pbData = _MapDesc.pData;' ++ print(' _MAP_DESC _MapDesc;') ++ print(' _getMapDesc(_this, %s, _MapDesc);' % ', '.join(method.argNames())) ++ print(' size_t _MappedSize = _MapDesc.Size;') ++ print(' if (_MapDesc.Size) {') ++ print(' _pbData = _MapDesc.pData;') + if interface.name.startswith('ID3D11DeviceContext'): + # Prevent false warnings on 1D and 2D resources, since the + # pitches are often junk there... +- print ' _normalizeMap(pResource, pMappedResource);' ++ print(' _normalizeMap(pResource, pMappedResource);') + self.checkPitchMismatch(method) + else: +- print ' _pbData = _MapDesc.pData;' ++ print(' _pbData = _MapDesc.pData;') + self.checkPitchMismatch(method) +- print ' } else {' +- print ' return;' +- print ' }' ++ print(' } else {') ++ print(' return;') ++ print(' }') + + if method.name == 'Unmap': +- print ' if (_pbData) {' +- print ' retrace::delRegionByPointer(_pbData);' +- print ' _pbData = 0;' +- print ' }' ++ print(' if (_pbData) {') ++ print(' retrace::delRegionByPointer(_pbData);') ++ print(' _pbData = 0;') ++ print(' }') + + # Attach shader byte code for lookup + if 'pShaderBytecode' in method.argNames(): + ppShader = method.args[-1] + assert ppShader.output +- print r' if (retrace::dumpingState && SUCCEEDED(_result)) {' +- print r' (*%s)->SetPrivateData(d3dstate::GUID_D3DSTATE, BytecodeLength, pShaderBytecode);' % ppShader.name +- print r' }' ++ print(r' if (retrace::dumpingState && SUCCEEDED(_result)) {') ++ print(r' (*%s)->SetPrivateData(d3dstate::GUID_D3DSTATE, BytecodeLength, pShaderBytecode);' % ppShader.name) ++ print(r' }') + + def extractArg(self, function, arg, arg_type, lvalue, rvalue): + # Set object names + if function.name == 'SetPrivateData' and arg.name == 'pData': + iid = function.args[0].name +- print r' if (%s != WKPDID_D3DDebugObjectName) {' % iid +- print r' return;' +- print r' }' ++ print(r' if (%s != WKPDID_D3DDebugObjectName) {' % iid) ++ print(r' return;') ++ print(r' }') + # Interpret argument as string + Retracer.extractArg(self, function, arg, LPCSTR, lvalue, rvalue) +- print r' assert(pData);' +- print r' assert(DataSize >= strlen((const char *)pData));' +- print r' // Some applications include the trailing zero terminator in the data' +- print r' DataSize = strlen((const char *)pData);' ++ print(r' assert(pData);') ++ print(r' assert(DataSize >= strlen((const char *)pData));') ++ print(r' // Some applications include the trailing zero terminator in the data') ++ print(r' DataSize = strlen((const char *)pData);') + return + + Retracer.extractArg(self, function, arg, arg_type, lvalue, rvalue) + + + def main(): +- print r'#define INITGUID' +- print +- print r'#include <string.h>' +- print +- print r'#include <iostream>' +- print +- print r'#include "d3dretrace.hpp"' +- print r'#include "os_version.hpp"' +- print +- print r'#include "d3dretrace_dxgi.hpp"' +- print r'#include "d3d10imports.hpp"' +- print r'#include "d3d10size.hpp"' +- print r'#include "d3d10state.hpp"' +- print r'#include "d3d11imports.hpp"' +- print r'#include "d3d11size.hpp"' +- print r'#include "d3dstate.hpp"' +- print +- print '''static d3dretrace::D3DDumper<IDXGISwapChain> dxgiDumper;''' +- print '''static d3dretrace::D3DDumper<ID3D10Device> d3d10Dumper;''' +- print '''static d3dretrace::D3DDumper<ID3D11DeviceContext> d3d11Dumper;''' +- print ++ print(r'#define INITGUID') ++ print() ++ print(r'#include <string.h>') ++ print() ++ print(r'#include <iostream>') ++ print() ++ print(r'#include "d3dretrace.hpp"') ++ print(r'#include "os_version.hpp"') ++ print() ++ print(r'#include "d3dretrace_dxgi.hpp"') ++ print(r'#include "d3d10imports.hpp"') ++ print(r'#include "d3d10size.hpp"') ++ print(r'#include "d3d10state.hpp"') ++ print(r'#include "d3d11imports.hpp"') ++ print(r'#include "d3d11size.hpp"') ++ print(r'#include "d3dstate.hpp"') ++ print() ++ print('''static d3dretrace::D3DDumper<IDXGISwapChain> dxgiDumper;''') ++ print('''static d3dretrace::D3DDumper<ID3D10Device> d3d10Dumper;''') ++ print('''static d3dretrace::D3DDumper<ID3D11DeviceContext> d3d11Dumper;''') ++ print() + + api = API() + api.addModule(dxgi) +diff --git a/retrace/dxgistate_so.py b/retrace/dxgistate_so.py +index 86f6db57..33745c8f 100644 +--- a/retrace/dxgistate_so.py ++++ b/retrace/dxgistate_so.py +@@ -48,9 +48,9 @@ class ValueDumper(stdapi.Visitor, stdapi.ExpanderMixin): + + def visitLiteral(self, literal, instance): + if literal.kind in ('SInt', 'UInt'): +- print ' writer.writeInt(%s);' % (instance) ++ print(' writer.writeInt(%s);' % (instance)) + elif literal.kind in ('Float',): +- print ' writer.writeFloat(%s);' % (instance) ++ print(' writer.writeFloat(%s);' % (instance)) + else: + raise NotImplementedError + +@@ -66,36 +66,36 @@ class ValueDumper(stdapi.Visitor, stdapi.ExpanderMixin): + # reinterpret_cast is necessary for GLubyte * <=> char * + instance = 'reinterpret_cast<%s>(%s)' % (cast, instance) + assert string.length is None +- print ' writer.write%s(%s);' % (suffix, instance) ++ print(' writer.write%s(%s);' % (suffix, instance)) + + def visitConst(self, const, instance): + self.visit(const.type, instance) + + def visitStruct(self, struct, instance): +- print ' writer.beginObject();' ++ print(' writer.beginObject();') + for member in struct.members: + memberType, memberName = member + if memberName is not None: +- print ' writer.beginMember("%s");' % memberName ++ print(' writer.beginMember("%s");' % memberName) + self.visitMember(member, instance) + if memberName is not None: +- print ' writer.endMember(); // %s' % memberName +- print ' writer.endObject();' ++ print(' writer.endMember(); // %s' % memberName) ++ print(' writer.endObject();') + + def visitArray(self, array, instance): + length = '_c' + array.type.tag + index = '_i' + array.type.tag + array_length = self.expand(array.length) +- print ' if (%s) {' % instance +- print ' size_t %s = %s > 0 ? %s : 0;' % (length, array_length, array_length) +- print ' writer.beginArray();' +- print ' for (size_t %s = 0; %s < %s; ++%s) {' % (index, index, length, index) ++ print(' if (%s) {' % instance) ++ print(' size_t %s = %s > 0 ? %s : 0;' % (length, array_length, array_length)) ++ print(' writer.beginArray();') ++ print(' for (size_t %s = 0; %s < %s; ++%s) {' % (index, index, length, index)) + self.visitElement(index, array.type, '(%s)[%s]' % (instance, index)) +- print ' }' +- print ' writer.endArray();' +- print ' } else {' +- print ' writer.writeNull();' +- print ' }' ++ print(' }') ++ print(' writer.endArray();') ++ print(' } else {') ++ print(' writer.writeNull();') ++ print(' }') + + def visitAttribArray(self, array, instance): + raise NotImplementedError +@@ -104,37 +104,37 @@ class ValueDumper(stdapi.Visitor, stdapi.ExpanderMixin): + raise NotImplementedError + + def visitEnum(self, enum, instance): +- print ' switch (%s) {' % instance ++ print(' switch (%s) {' % instance) + for value in enum.values: +- print ' case %s:' % value +- print ' writer.writeString("%s");' % value +- print ' break;' +- print ' default:' +- print ' writer.writeInt(%s);' % instance +- print ' break;' +- print ' }' ++ print(' case %s:' % value) ++ print(' writer.writeString("%s");' % value) ++ print(' break;') ++ print(' default:') ++ print(' writer.writeInt(%s);' % instance) ++ print(' break;') ++ print(' }') + + def visitBitmask(self, bitmask, instance): + # TODO + self.visit(bitmask.type, instance) + + def visitPointer(self, pointer, instance): +- print ' if (%s) {' % instance +- print ' writer.beginArray();' ++ print(' if (%s) {' % instance) ++ print(' writer.beginArray();') + self.visit(pointer.type, "*" + instance) +- print ' writer.endArray();' +- print ' } else {' +- print ' writer.writeNull();' +- print ' }' ++ print(' writer.endArray();') ++ print(' } else {') ++ print(' writer.writeNull();') ++ print(' }') + + def visitIntPointer(self, pointer, instance): +- print ' writer.writeInt((uintptr_t)%s);' % instance ++ print(' writer.writeInt((uintptr_t)%s);' % instance) + + def visitObjPointer(self, pointer, instance): +- print ' writer.writeInt((uintptr_t)%s);' % instance ++ print(' writer.writeInt((uintptr_t)%s);' % instance) + + def visitLinearPointer(self, pointer, instance): +- print ' writer.writeInt((uintptr_t)%s);' % instance ++ print(' writer.writeInt((uintptr_t)%s);' % instance) + + def visitReference(self, reference, instance): + self.visit(reference.type, instance) +@@ -146,23 +146,23 @@ class ValueDumper(stdapi.Visitor, stdapi.ExpanderMixin): + self.visit(alias.type, instance) + + def visitOpaque(self, opaque, instance): +- print ' writer.writeInt((uintptr_t)%s);' % instance ++ print(' writer.writeInt((uintptr_t)%s);' % instance) + + def visitInterface(self, interface, instance): + assert False + + def visitPolymorphic(self, polymorphic, instance): + switchExpr = self.expand(polymorphic.switchExpr) +- print ' switch (static_cast<int>(%s)) {' % switchExpr ++ print(' switch (static_cast<int>(%s)) {' % switchExpr) + for cases, type in polymorphic.iterSwitch(): + for case in cases: +- print ' %s:' % case ++ print(' %s:' % case) + caseInstance = instance + if type.expr is not None: + caseInstance = 'static_cast<%s>(%s)' % (type, caseInstance) + self.visit(type, caseInstance) +- print ' break;' +- print ' }' ++ print(' break;') ++ print(' }') + + + class Dumper: +@@ -187,8 +187,8 @@ class Dumper: + # Includes + for module in api.modules: + for header in module.headers: +- print header +- print ++ print(header) ++ print() + + # Generate the dumper functions + types = api.getAllTypes() +@@ -196,13 +196,13 @@ class Dumper: + self.dumpType(type) + + def dumpType(self, type): +- print r'void' +- print r'dumpStateObject(StateWriter &writer, const %s & so)' % type +- print r'{' ++ print(r'void') ++ print(r'dumpStateObject(StateWriter &writer, const %s & so)' % type) ++ print(r'{') + visitor = self.dumperFactory() + visitor.visit(type, 'so') +- print r'}' +- print ++ print(r'}') ++ print() + + def header(self): + pass +@@ -212,10 +212,10 @@ class Dumper: + + + if __name__ == '__main__': +- print r'#include "dxgistate_so.hpp"' +- print +- print r'#include "state_writer.hpp"' +- print ++ print(r'#include "dxgistate_so.hpp"') ++ print() ++ print(r'#include "state_writer.hpp"') ++ print() + + api = stdapi.API() + api.addModule(dxgi.dxgi) +diff --git a/retrace/glretrace.py b/retrace/glretrace.py +index 2ead195d..0dfe5c5b 100644 +--- a/retrace/glretrace.py ++++ b/retrace/glretrace.py +@@ -127,190 +127,190 @@ class GlRetracer(Retracer): + + # For backwards compatibility with old traces where non VBO drawing was supported + if (is_array_pointer or is_draw_arrays or is_draw_elements) and not is_draw_indirect: +- print ' if (retrace::parser->getVersion() < 1) {' ++ print(' if (retrace::parser->getVersion() < 1) {') + + if is_array_pointer or is_draw_arrays: +- print ' GLint _array_buffer = 0;' +- print ' glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &_array_buffer);' +- print ' if (!_array_buffer) {' ++ print(' GLint _array_buffer = 0;') ++ print(' glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &_array_buffer);') ++ print(' if (!_array_buffer) {') + self.failFunction(function) +- print ' }' ++ 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) {' ++ print(' GLint _element_array_buffer = 0;') ++ print(' glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &_element_array_buffer);') ++ print(' if (!_element_array_buffer) {') + self.failFunction(function) +- print ' }' ++ print(' }') + +- print ' }' ++ print(' }') + + # When no pack buffer object is bound, the pack functions are no-ops. + if self.pack_function_regex.match(function.name): +- print ' GLint _pack_buffer = 0;' +- print ' glGetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING, &_pack_buffer);' +- print ' if (!_pack_buffer) {' +- print ' return;' +- print ' }' ++ print(' GLint _pack_buffer = 0;') ++ print(' glGetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING, &_pack_buffer);') ++ print(' if (!_pack_buffer) {') ++ print(' return;') ++ print(' }') + + # Pre-snapshots + if self.bind_framebuffer_function_regex.match(function.name): +- print ' assert(call.flags & trace::CALL_FLAG_SWAP_RENDERTARGET);' ++ print(' assert(call.flags & trace::CALL_FLAG_SWAP_RENDERTARGET);') + if function.name == 'glStringMarkerGREMEDY': + return + if function.name == 'glFrameTerminatorGREMEDY': +- print ' glretrace::frame_complete(call);' ++ print(' glretrace::frame_complete(call);') + return + + Retracer.retraceFunctionBody(self, function) + + # Post-snapshots + if function.name in ('glFlush', 'glFinish'): +- print ' if (!retrace::doubleBuffer) {' +- print ' glretrace::frame_complete(call);' +- print ' }' ++ print(' if (!retrace::doubleBuffer) {') ++ print(' glretrace::frame_complete(call);') ++ print(' }') + if is_draw_arrays or is_draw_elements or is_misc_draw: +- print ' assert(call.flags & trace::CALL_FLAG_RENDER);' ++ print(' assert(call.flags & trace::CALL_FLAG_RENDER);') + + + def invokeFunction(self, function): + if function.name == "glTexDirectVIVMap" or function.name == "glTexDirectMapVIV" or function.name == "glTexDirectTiledMapVIV": +- print '#if defined(HAVE_VIVANTE_G2D)' +- print ' GLint tex;' +- print ' glGetIntegerv(GL_TEXTURE_BINDING_2D, &tex);' +- print ' int32_t size = 0;' +- print ' switch(format){' +- print ' case GL_VIV_YV12:' +- print ' case GL_VIV_I420:' +- print ' case GL_VIV_NV12:' +- print ' case GL_VIV_NV21:' +- print ' size=width * height * 3 / 2;' +- print ' break;' +- print ' case GL_RGBA:' +- print ' case GL_BGRA_EXT:' +- print ' size=width * height * 4;' +- print ' break;' +- print ' case GL_RGB:' +- print ' size=width * height *3;' +- print ' break;' +- print ' case GL_VIV_YUY2:' +- print ' case GL_VIV_UYVY:' +- print ' case GL_RGB565_OES:' +- print ' case GL_LUMINANCE8_ALPHA8_EXT:' +- print ' size=width * height *2;' +- print ' break;' +- print ' case GL_ALPHA:' +- print ' size=width * height;' +- print ' break;' +- print ' default:' +- print ' break;' +- print ' }' +- print ' if(tex != 0)' +- print ' {' +- print ' GLuint pindex = *(GLuint*)Logical;' +- print ' TEXDIRECTVIVDATA &data = _directTextureDataMap[tex];' +- print ' if(data.privateData == 0) // new entry' +- print ' {' +- print ' data.privateData = alloc_dma_buffer(size, (uintptr_t*)&data.logical, &data.physical);' +- print ' data.index = pindex;' +- print ' data.size = size;' +- print ' retrace::addRegion(call,data.index,data.logical,size);' +- print ' }' +- print ' else // already have one; check size and index' +- print ' {' +- print ' if((size!=data.size)||(pindex!=data.index))' +- print ' {' +- print ' retrace::delRegionByPointer(data.logical);' +- print ' free_dma_buffer(data.privateData);' +- print ' data.privateData = alloc_dma_buffer(size, (uintptr_t*)&data.logical, &data.physical);' +- print ' data.index = pindex;' +- print ' data.size = size;' +- print ' retrace::addRegion(call,data.index,data.logical,size);' +- print ' }' +- print ' }' +- print ' *Logical = data.logical;' +- print ' *Physical = data.physical;' +- print ' }' +- print '#endif /* HAVE_VIVANTE_G2D */' ++ print('#if defined(HAVE_VIVANTE_G2D)') ++ print(' GLint tex;') ++ print(' glGetIntegerv(GL_TEXTURE_BINDING_2D, &tex);') ++ print(' int32_t size = 0;') ++ print(' switch(format){') ++ print(' case GL_VIV_YV12:') ++ print(' case GL_VIV_I420:') ++ print(' case GL_VIV_NV12:') ++ print(' case GL_VIV_NV21:') ++ print(' size=width * height * 3 / 2;') ++ print(' break;') ++ print(' case GL_RGBA:') ++ print(' case GL_BGRA_EXT:') ++ print(' size=width * height * 4;') ++ print(' break;') ++ print(' case GL_RGB:') ++ print(' size=width * height *3;') ++ print(' break;') ++ print(' case GL_VIV_YUY2:') ++ print(' case GL_VIV_UYVY:') ++ print(' case GL_RGB565_OES:') ++ print(' case GL_LUMINANCE8_ALPHA8_EXT:') ++ print(' size=width * height *2;') ++ print(' break;') ++ print(' case GL_ALPHA:') ++ print(' size=width * height;') ++ print(' break;') ++ print(' default:') ++ print(' break;') ++ print(' }') ++ print(' if(tex != 0)') ++ print(' {') ++ print(' GLuint pindex = *(GLuint*)Logical;') ++ print(' TEXDIRECTVIVDATA &data = _directTextureDataMap[tex];') ++ print(' if(data.privateData == 0) // new entry') ++ print(' {') ++ print(' data.privateData = alloc_dma_buffer(size, (uintptr_t*)&data.logical, &data.physical);') ++ print(' data.index = pindex;') ++ print(' data.size = size;') ++ print(' retrace::addRegion(call,data.index,data.logical,size);') ++ print(' }') ++ print(' else // already have one; check size and index') ++ print(' {') ++ print(' if((size!=data.size)||(pindex!=data.index))') ++ print(' {') ++ print(' retrace::delRegionByPointer(data.logical);') ++ print(' free_dma_buffer(data.privateData);') ++ print(' data.privateData = alloc_dma_buffer(size, (uintptr_t*)&data.logical, &data.physical);') ++ print(' data.index = pindex;') ++ print(' data.size = size;') ++ print(' retrace::addRegion(call,data.index,data.logical,size);') ++ print(' }') ++ print(' }') ++ print(' *Logical = data.logical;') ++ print(' *Physical = data.physical;') ++ print(' }') ++ print('#endif /* HAVE_VIVANTE_G2D */') + # Infer the drawable size from GL calls + if function.name == "glViewport": +- print ' glretrace::updateDrawable(x + width, y + height);' ++ 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 ' }' ++ 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 (index == 0) {') ++ print(' glretrace::updateDrawable(x + w, y + h);') ++ print(' }') + 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 ' }' ++ 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));' ++ print(' glretrace::updateDrawable(std::max(dstX0, dstX1), std::max(dstY0, dstY1));') + + if function.name.startswith('gl') and not function.name.startswith('glX'): + # The Windows OpenGL runtime will skip calls when there's no + # context bound to the current context, but this might cause + # crashes on other systems, particularly with NVIDIA Linux drivers. +- print r' glretrace::Context *currentContext = glretrace::getCurrentContext();' +- print r' if (!currentContext) {' +- print r' if (retrace::debug) {' +- print r' retrace::warning(call) << "no current context\n";' +- print r' }' +- print r'#ifndef _WIN32' +- print r' return;' +- print r'#endif' +- print r' }' ++ print(r' glretrace::Context *currentContext = glretrace::getCurrentContext();') ++ print(r' if (!currentContext) {') ++ print(r' if (retrace::debug) {') ++ print(r' retrace::warning(call) << "no current context\n";') ++ print(r' }') ++ print(r'#ifndef _WIN32') ++ print(r' return;') ++ print(r'#endif') ++ print(r' }') + + if function.name == "glEnd": +- print r' if (currentContext) {' +- print r' currentContext->insideBeginEnd = false;' +- print r' }' ++ print(r' if (currentContext) {') ++ print(r' currentContext->insideBeginEnd = false;') ++ print(r' }') + + if function.name == 'memcpy': +- print ' if (!dest || !src || !n) return;' ++ print(' if (!dest || !src || !n) return;') + + # Skip glEnable/Disable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB) as we don't + # faithfully set the CONTEXT_DEBUG_BIT_ARB flags on context creation. + if function.name in ('glEnable', 'glDisable'): +- print ' if (cap == GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB) return;' ++ print(' if (cap == GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB) return;') + + # Destroy the buffer mapping + if self.unmap_function_regex.match(function.name): +- print r' GLvoid *ptr = NULL;' ++ print(r' GLvoid *ptr = NULL;') + if function.name == 'glUnmapBuffer': +- print r' glGetBufferPointerv(target, GL_BUFFER_MAP_POINTER, &ptr);' ++ print(r' glGetBufferPointerv(target, GL_BUFFER_MAP_POINTER, &ptr);') + elif function.name == 'glUnmapBufferARB': +- print r' glGetBufferPointervARB(target, GL_BUFFER_MAP_POINTER_ARB, &ptr);' ++ print(r' glGetBufferPointervARB(target, GL_BUFFER_MAP_POINTER_ARB, &ptr);') + elif function.name == 'glUnmapBufferOES': +- print r' glGetBufferPointervOES(target, GL_BUFFER_MAP_POINTER_OES, &ptr);' ++ print(r' glGetBufferPointervOES(target, GL_BUFFER_MAP_POINTER_OES, &ptr);') + elif function.name == 'glUnmapNamedBuffer': +- print r' glGetNamedBufferPointerv(buffer, GL_BUFFER_MAP_POINTER, &ptr);' ++ print(r' glGetNamedBufferPointerv(buffer, GL_BUFFER_MAP_POINTER, &ptr);') + elif function.name == 'glUnmapNamedBufferEXT': +- print r' glGetNamedBufferPointervEXT(buffer, GL_BUFFER_MAP_POINTER, &ptr);' ++ 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) << "failed to get mapped pointer\n";' +- print r' }' ++ print(r' if (ptr) {') ++ print(r' retrace::delRegionByPointer(ptr);') ++ print(r' } else {') ++ print(r' retrace::warning(call) << "failed to get mapped pointer\n";') ++ print(r' }') + + if function.name in ('glBindProgramPipeline', 'glBindProgramPipelineEXT'): + # Note if glBindProgramPipeline has ever been called +- print r' if (pipeline) {' +- print r' _pipelineHasBeenBound = true;' +- print r' }' ++ print(r' if (pipeline) {') ++ print(r' _pipelineHasBeenBound = true;') ++ print(r' }') + + is_draw_arrays = self.draw_arrays_function_regex.match(function.name) is not None + is_draw_elements = self.draw_elements_function_regex.match(function.name) is not None +@@ -325,240 +325,240 @@ class GlRetracer(Retracer): + + # Keep track of active program for call lists + if function.name in ('glUseProgram', 'glUseProgramObjectARB'): +- print r' if (currentContext) {' +- print r' currentContext->activeProgram = call.arg(0).toUInt();' +- print r' }' ++ print(r' if (currentContext) {') ++ print(r' currentContext->activeProgram = call.arg(0).toUInt();') ++ print(r' }') + + # Only profile if not inside a list as the queries get inserted into list + if function.name == 'glNewList': +- print r' if (currentContext) {' +- print r' currentContext->insideList = true;' +- print r' }' ++ print(r' if (currentContext) {') ++ print(r' currentContext->insideList = true;') ++ print(r' }') + + if function.name == 'glEndList': +- print r' if (currentContext) {' +- print r' currentContext->insideList = false;' +- print r' }' ++ print(r' if (currentContext) {') ++ print(r' currentContext->insideList = false;') ++ print(r' }') + + if function.name == 'glBegin' or \ + is_draw_arrays or \ + is_draw_elements or \ + function.name.startswith('glBeginTransformFeedback'): +- print r' if (retrace::debug) {' +- print r' _validateActiveProgram(call);' +- print r' }' ++ print(r' if (retrace::debug) {') ++ print(r' _validateActiveProgram(call);') ++ print(r' }') + + if function.name != 'glEnd': +- print r' if (currentContext && !currentContext->insideList && !currentContext->insideBeginEnd && retrace::profiling) {' ++ print(r' if (currentContext && !currentContext->insideList && !currentContext->insideBeginEnd && retrace::profiling) {') + if profileDraw: +- print r' glretrace::beginProfile(call, true);' ++ print(r' glretrace::beginProfile(call, true);') + else: +- print r' glretrace::beginProfile(call, false);' +- print r' }' ++ print(r' glretrace::beginProfile(call, false);') ++ print(r' }') + + if function.name in ('glCreateShaderProgramv', 'glCreateShaderProgramEXT', 'glCreateShaderProgramvEXT'): + # When dumping state, break down glCreateShaderProgram* so that the + # shader source can be recovered. +- print r' if (retrace::dumpingState) {' +- print r' GLuint _shader = glCreateShader(type);' +- print r' if (_shader) {' ++ print(r' if (retrace::dumpingState) {') ++ print(r' GLuint _shader = glCreateShader(type);') ++ print(r' if (_shader) {') + if not function.name.startswith('glCreateShaderProgramv'): +- print r' GLsizei count = 1;' +- print r' const GLchar **strings = &string;' +- print r' glShaderSource(_shader, count, strings, NULL);' +- print r' glCompileShader(_shader);' +- print r' const GLuint _program = glCreateProgram();' +- print r' if (_program) {' +- print r' GLint compiled = GL_FALSE;' +- print r' glGetShaderiv(_shader, GL_COMPILE_STATUS, &compiled);' ++ print(r' GLsizei count = 1;') ++ print(r' const GLchar **strings = &string;') ++ print(r' glShaderSource(_shader, count, strings, NULL);') ++ print(r' glCompileShader(_shader);') ++ print(r' const GLuint _program = glCreateProgram();') ++ print(r' if (_program) {') ++ print(r' GLint compiled = GL_FALSE;') ++ print(r' glGetShaderiv(_shader, GL_COMPILE_STATUS, &compiled);') + if function.name == 'glCreateShaderProgramvEXT': +- print r' glProgramParameteriEXT(_program, GL_PROGRAM_SEPARABLE, GL_TRUE);' ++ print(r' glProgramParameteriEXT(_program, GL_PROGRAM_SEPARABLE, GL_TRUE);') + else: +- print r' glProgramParameteri(_program, GL_PROGRAM_SEPARABLE, GL_TRUE);' +- print r' if (compiled) {' +- print r' glAttachShader(_program, _shader);' +- print r' glLinkProgram(_program);' +- print r' if (false) glDetachShader(_program, _shader);' +- print r' }' +- print r' // TODO: append shader info log to program info log' +- print r' }' +- print r' glDeleteShader(_shader);' +- print r' _result = _program;' +- print r' } else {' +- print r' _result = 0;' +- print r' }' +- print r' } else {' ++ print(r' glProgramParameteri(_program, GL_PROGRAM_SEPARABLE, GL_TRUE);') ++ print(r' if (compiled) {') ++ print(r' glAttachShader(_program, _shader);') ++ print(r' glLinkProgram(_program);') ++ print(r' if (false) glDetachShader(_program, _shader);') ++ print(r' }') ++ print(r' // TODO: append shader info log to program info log') ++ print(r' }') ++ print(r' glDeleteShader(_shader);') ++ print(r' _result = _program;') ++ print(r' } else {') ++ print(r' _result = 0;') ++ print(r' }') ++ print(r' } else {') + Retracer.invokeFunction(self, function) +- print r' }' ++ print(r' }') + elif function.name in ('glDetachShader', 'glDetachObjectARB'): +- print r' if (!retrace::dumpingState) {' ++ print(r' if (!retrace::dumpingState) {') + Retracer.invokeFunction(self, function) +- print r' }' ++ print(r' }') + elif function.name == 'glClientWaitSync': +- print r' _result = glretrace::clientWaitSync(call, sync, flags, timeout);' +- print r' (void)_result;' ++ print(r' _result = glretrace::clientWaitSync(call, sync, flags, timeout);') ++ print(r' (void)_result;') + elif function.name == 'glGetSynciv': +- print r' if (pname == GL_SYNC_STATUS &&' +- print r' bufSize >= 1 &&' +- print r' values != NULL &&' +- print r' call.arg(4)[0].toSInt() == GL_SIGNALED) {' +- print r' // Fence was signalled, so ensure it happened here' +- print r' glretrace::blockOnFence(call, sync, GL_SYNC_FLUSH_COMMANDS_BIT);' +- print r' (void)length;' +- print r' }' ++ print(r' if (pname == GL_SYNC_STATUS &&') ++ print(r' bufSize >= 1 &&') ++ print(r' values != NULL &&') ++ print(r' call.arg(4)[0].toSInt() == GL_SIGNALED) {') ++ print(r' // Fence was signalled, so ensure it happened here') ++ print(r' glretrace::blockOnFence(call, sync, GL_SYNC_FLUSH_COMMANDS_BIT);') ++ print(r' (void)length;') ++ print(r' }') + else: + Retracer.invokeFunction(self, function) + + if function.name == "glBegin": +- print ' if (currentContext) {' +- print ' currentContext->insideBeginEnd = true;' +- print ' }' ++ print(' if (currentContext) {') ++ print(' currentContext->insideBeginEnd = true;') ++ print(' }') + + if function.name == "glTexDirectVIV": +- print '#if defined(HAVE_VIVANTE_G2D)' +- print ' int32_t ysize = 0;' +- print ' int32_t usize = 0;' +- print ' int32_t vsize = 0;' +- print ' switch(format){' +- print ' case GL_VIV_YV12:' +- print ' case GL_VIV_I420:' +- print ' ysize=width * height;' +- print ' usize=ysize/4;' +- print ' vsize=usize;' +- print ' break;' +- print ' case GL_VIV_NV12:' +- print ' case GL_VIV_NV21:' +- print ' ysize=width * height;' +- print ' usize=ysize/2;' +- print ' vsize=0;' +- print ' break;' +- print ' case GL_RGBA:' +- print ' case GL_BGRA_EXT:' +- print ' ysize=width * height *4;' +- print ' usize=0;' +- print ' vsize=0;' +- print ' break;' +- print ' case GL_RGB:' +- print ' ysize=width * height *3;' +- print ' usize=0;' +- print ' vsize=0;' +- print ' break;' +- print ' case GL_VIV_YUY2:' +- print ' case GL_VIV_UYVY:' +- print ' case GL_RGB565_OES:' +- print ' ysize=width * height *2;' +- print ' usize=0;' +- print ' vsize=0;' +- print ' break;' +- print ' default:' +- print ' break;' +- print ' }' +- print ' const trace::Array * arrayGLvoid = (call.arg(4)).toArray();' +- print ' if(ysize > 0)' +- print ' retrace::addRegion(call,(*arrayGLvoid->values[0]).toUInt(),(GLvoid*)pixels[0], ysize);' +- print ' if(usize > 0)' +- print ' retrace::addRegion(call,(*arrayGLvoid->values[1]).toUInt(),(GLvoid*)pixels[1], usize);' +- print ' if(vsize > 0)' +- print ' retrace::addRegion(call,(*arrayGLvoid->values[2]).toUInt(),(GLvoid*)pixels[2], vsize);' +- print '#endif /* HAVE_VIVANTE_G2D */' +- +- print r' if (currentContext && !currentContext->insideList && !currentContext->insideBeginEnd && retrace::profiling) {' ++ print('#if defined(HAVE_VIVANTE_G2D)') ++ print(' int32_t ysize = 0;') ++ print(' int32_t usize = 0;') ++ print(' int32_t vsize = 0;') ++ print(' switch(format){') ++ print(' case GL_VIV_YV12:') ++ print(' case GL_VIV_I420:') ++ print(' ysize=width * height;') ++ print(' usize=ysize/4;') ++ print(' vsize=usize;') ++ print(' break;') ++ print(' case GL_VIV_NV12:') ++ print(' case GL_VIV_NV21:') ++ print(' ysize=width * height;') ++ print(' usize=ysize/2;') ++ print(' vsize=0;') ++ print(' break;') ++ print(' case GL_RGBA:') ++ print(' case GL_BGRA_EXT:') ++ print(' ysize=width * height *4;') ++ print(' usize=0;') ++ print(' vsize=0;') ++ print(' break;') ++ print(' case GL_RGB:') ++ print(' ysize=width * height *3;') ++ print(' usize=0;') ++ print(' vsize=0;') ++ print(' break;') ++ print(' case GL_VIV_YUY2:') ++ print(' case GL_VIV_UYVY:') ++ print(' case GL_RGB565_OES:') ++ print(' ysize=width * height *2;') ++ print(' usize=0;') ++ print(' vsize=0;') ++ print(' break;') ++ print(' default:') ++ print(' break;') ++ print(' }') ++ print(' const trace::Array * arrayGLvoid = (call.arg(4)).toArray();') ++ print(' if(ysize > 0)') ++ print(' retrace::addRegion(call,(*arrayGLvoid->values[0]).toUInt(),(GLvoid*)pixels[0], ysize);') ++ print(' if(usize > 0)') ++ print(' retrace::addRegion(call,(*arrayGLvoid->values[1]).toUInt(),(GLvoid*)pixels[1], usize);') ++ print(' if(vsize > 0)') ++ print(' retrace::addRegion(call,(*arrayGLvoid->values[2]).toUInt(),(GLvoid*)pixels[2], vsize);') ++ print('#endif /* HAVE_VIVANTE_G2D */') ++ ++ print(r' if (currentContext && !currentContext->insideList && !currentContext->insideBeginEnd && retrace::profiling) {') + if profileDraw: +- print r' glretrace::endProfile(call, true);' ++ print(r' glretrace::endProfile(call, true);') + else: +- print r' glretrace::endProfile(call, false);' +- print r' }' ++ print(r' glretrace::endProfile(call, false);') ++ print(r' }') + + # Error checking + if function.name.startswith('gl'): + # glGetError is not allowed inside glBegin/glEnd +- print ' if (retrace::debug && currentContext && !currentContext->insideBeginEnd) {' +- print ' glretrace::checkGlError(call);' ++ print(' if (retrace::debug && currentContext && !currentContext->insideBeginEnd) {') ++ print(' glretrace::checkGlError(call);') + if function.name in ('glProgramStringARB', 'glLoadProgramNV'): +- 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 in position " << error_position << ": " << error_string << "\n";' +- print r' }' ++ 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 in position " << error_position << ": " << 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' retrace::warning(call) << "compilation failed\n";' +- print r' }' +- print r' GLint info_log_length = 0;' +- print r' glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &info_log_length);' +- print r' if (info_log_length > 1) {' +- 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' }' ++ print(r' GLint compile_status = 0;') ++ print(r' glGetShaderiv(shader, GL_COMPILE_STATUS, &compile_status);') ++ print(r' if (!compile_status) {') ++ print(r' retrace::warning(call) << "compilation failed\n";') ++ print(r' }') ++ print(r' GLint info_log_length = 0;') ++ print(r' glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &info_log_length);') ++ print(r' if (info_log_length > 1) {') ++ 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 in ('glLinkProgram', 'glCreateShaderProgramv', 'glCreateShaderProgramEXT', 'glCreateShaderProgramvEXT', 'glProgramBinary', 'glProgramBinaryOES'): + if function.name.startswith('glCreateShaderProgram'): +- print r' GLuint program = _result;' +- print r' GLint link_status = 0;' +- print r' glGetProgramiv(program, GL_LINK_STATUS, &link_status);' +- print r' if (!link_status) {' +- print r' retrace::warning(call) << "link failed\n";' +- print r' }' +- print r' GLint info_log_length = 0;' +- print r' glGetProgramiv(program, GL_INFO_LOG_LENGTH, &info_log_length);' +- print r' if (info_log_length > 1) {' +- 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' }' ++ print(r' GLuint program = _result;') ++ print(r' GLint link_status = 0;') ++ print(r' glGetProgramiv(program, GL_LINK_STATUS, &link_status);') ++ print(r' if (!link_status) {') ++ print(r' retrace::warning(call) << "link failed\n";') ++ print(r' }') ++ print(r' GLint info_log_length = 0;') ++ print(r' glGetProgramiv(program, GL_INFO_LOG_LENGTH, &info_log_length);') ++ print(r' if (info_log_length > 1) {') ++ 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' retrace::warning(call) << "compilation failed\n";' +- print r' }' +- print r' GLint info_log_length = 0;' +- print r' glGetObjectParameterivARB(shaderObj, GL_OBJECT_INFO_LOG_LENGTH_ARB, &info_log_length);' +- print r' if (info_log_length > 1) {' +- 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' }' ++ print(r' GLint compile_status = 0;') ++ print(r' glGetObjectParameterivARB(shaderObj, GL_OBJECT_COMPILE_STATUS_ARB, &compile_status);') ++ print(r' if (!compile_status) {') ++ print(r' retrace::warning(call) << "compilation failed\n";') ++ print(r' }') ++ print(r' GLint info_log_length = 0;') ++ print(r' glGetObjectParameterivARB(shaderObj, GL_OBJECT_INFO_LOG_LENGTH_ARB, &info_log_length);') ++ print(r' if (info_log_length > 1) {') ++ 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' retrace::warning(call) << "link failed\n";' +- print r' }' +- print r' GLint info_log_length = 0;' +- print r' glGetObjectParameterivARB(programObj, GL_OBJECT_INFO_LOG_LENGTH_ARB, &info_log_length);' +- print r' if (info_log_length > 1) {' +- 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' }' ++ print(r' GLint link_status = 0;') ++ print(r' glGetObjectParameterivARB(programObj, GL_OBJECT_LINK_STATUS_ARB, &link_status);') ++ print(r' if (!link_status) {') ++ print(r' retrace::warning(call) << "link failed\n";') ++ print(r' }') ++ print(r' GLint info_log_length = 0;') ++ print(r' glGetObjectParameterivARB(programObj, GL_OBJECT_INFO_LOG_LENGTH_ARB, &info_log_length);') ++ print(r' if (info_log_length > 1) {') ++ 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 self.map_function_regex.match(function.name): +- print r' if (!_result) {' +- print r' retrace::warning(call) << "failed to map buffer\n";' +- print r' }' ++ print(r' if (!_result) {') ++ print(r' retrace::warning(call) << "failed to map buffer\n";') ++ print(r' }') + if self.unmap_function_regex.match(function.name) and function.type is not stdapi.Void: +- print r' if (!_result) {' +- print r' retrace::warning(call) << "failed to unmap buffer\n";' +- print r' }' ++ 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 _origResult = call.ret->toSInt();' +- print r' if (_result != _origResult) {' +- print r' retrace::warning(call) << "vertex attrib location mismatch " << _origResult << " -> " << _result << "\n";' +- print r' }' ++ print(r' GLint _origResult = call.ret->toSInt();') ++ print(r' if (_result != _origResult) {') ++ print(r' retrace::warning(call) << "vertex attrib location mismatch " << _origResult << " -> " << _result << "\n";') ++ print(r' }') + if function.name in ('glCheckFramebufferStatus', 'glCheckFramebufferStatusEXT', 'glCheckNamedFramebufferStatus', 'glCheckNamedFramebufferStatusEXT'): +- print r' GLint _origResult = call.ret->toSInt();' +- print r' if (_origResult == GL_FRAMEBUFFER_COMPLETE &&' +- print r' _result != GL_FRAMEBUFFER_COMPLETE) {' +- print r' retrace::warning(call) << "incomplete framebuffer (" << glstate::enumToString(_result) << ")\n";' +- print r' }' +- print ' }' ++ print(r' GLint _origResult = call.ret->toSInt();') ++ print(r' if (_origResult == GL_FRAMEBUFFER_COMPLETE &&') ++ print(r' _result != GL_FRAMEBUFFER_COMPLETE) {') ++ print(r' retrace::warning(call) << "incomplete framebuffer (" << glstate::enumToString(_result) << ")\n";') ++ print(r' }') ++ print(' }') + + # Query the buffer length for whole buffer mappings + if self.map_function_regex.match(function.name): +@@ -566,23 +566,23 @@ class GlRetracer(Retracer): + assert 'BufferRange' in function.name + else: + assert 'BufferRange' not in function.name +- print r' GLint length = 0;' ++ print(r' GLint length = 0;') + if function.name in ('glMapBuffer', 'glMapBufferOES'): +- print r' glGetBufferParameteriv(target, GL_BUFFER_SIZE, &length);' ++ print(r' glGetBufferParameteriv(target, GL_BUFFER_SIZE, &length);') + elif function.name == 'glMapBufferARB': +- print r' glGetBufferParameterivARB(target, GL_BUFFER_SIZE_ARB, &length);' ++ print(r' glGetBufferParameterivARB(target, GL_BUFFER_SIZE_ARB, &length);') + elif function.name == 'glMapNamedBuffer': +- print r' glGetNamedBufferParameteriv(buffer, GL_BUFFER_SIZE, &length);' ++ print(r' glGetNamedBufferParameteriv(buffer, GL_BUFFER_SIZE, &length);') + elif function.name == 'glMapNamedBufferEXT': +- print r' glGetNamedBufferParameterivEXT(buffer, GL_BUFFER_SIZE, &length);' ++ print(r' glGetNamedBufferParameterivEXT(buffer, GL_BUFFER_SIZE, &length);') + elif function.name == 'glMapObjectBufferATI': +- print r' glGetObjectBufferivATI(buffer, GL_OBJECT_BUFFER_SIZE_ATI, &length);' ++ 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 = static_cast<%s>(retrace::toPointer(%s, true));' % (lvalue, arg_type, rvalue) ++ print(' %s = static_cast<%s>(retrace::toPointer(%s, true));' % (lvalue, arg_type, rvalue)) + return + + if self.draw_elements_function_regex.match(function.name) and arg.name == 'indices' or\ +@@ -594,18 +594,18 @@ class GlRetracer(Retracer): + # object. + if self.pack_function_regex.match(function.name) 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) ++ print(' %s = static_cast<%s>((%s).toPointer());' % (lvalue, arg_type, rvalue)) + return + + if (arg.type.depends(glapi.GLlocation) or \ + arg.type.depends(glapi.GLsubroutine)) \ + and 'program' not in function.argNames(): + # Determine the active program for uniforms swizzling +- print ' GLint program = _getActiveProgram();' ++ print(' GLint program = _getActiveProgram();') + + if arg.type is glapi.GLlocationARB \ + and 'programObj' not in function.argNames(): +- print ' GLhandleARB programObj = glGetHandleARB(GL_PROGRAM_OBJECT_ARB);' ++ print(' GLhandleARB programObj = glGetHandleARB(GL_PROGRAM_OBJECT_ARB);') + + Retracer.extractArg(self, function, arg, arg_type, lvalue, rvalue) + +@@ -613,28 +613,28 @@ class GlRetracer(Retracer): + if arg.name == 'samples': + if function.name == 'glRasterSamplesEXT': + assert arg.type is glapi.GLuint +- print ' GLint max_samples = 0;' +- print ' glGetIntegerv(GL_MAX_RASTER_SAMPLES_EXT, &max_samples);' +- print ' if (samples > static_cast<GLuint>(max_samples)) {' +- print ' samples = static_cast<GLuint>(max_samples);' +- print ' }' ++ print(' GLint max_samples = 0;') ++ print(' glGetIntegerv(GL_MAX_RASTER_SAMPLES_EXT, &max_samples);') ++ print(' if (samples > static_cast<GLuint>(max_samples)) {') ++ print(' samples = static_cast<GLuint>(max_samples);') ++ print(' }') + else: + 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 ' }' ++ 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 ++ print(' _allocator.bind(%s);' % arg.name) + + + + if __name__ == '__main__': +- print r''' ++ print(r''' + #include <string.h> + + #include "glproc.hpp" +@@ -692,13 +692,13 @@ static void free_dma_buffer(void *buf) + + #endif /* HAVE_VIVANTE_G2D */ + +-''' ++''') + api = stdapi.API() + api.addModule(glapi.glapi) + retracer = GlRetracer() + retracer.retraceApi(api) + +- print r''' ++ print(r''' + static GLint + _getActiveProgram(void) + { +@@ -771,4 +771,4 @@ _validateActiveProgram(trace::Call &call) + } + } + +-''' ++''') +diff --git a/retrace/glstate_params.py b/retrace/glstate_params.py +index fb49ff9a..bc90f66b 100755 +--- a/retrace/glstate_params.py ++++ b/retrace/glstate_params.py +@@ -134,17 +134,17 @@ class StateGetter(Visitor): + elem_type = self.inflector.reduced_type(type) + inflection = self.inflector.inflect(type) + if inflection.endswith('v' + self.inflector.suffix): +- print ' %s %s = 0;' % (elem_type, temp_name) +- print ' %s(%s, &%s);' % (inflection, ', '.join(args), temp_name) ++ print(' %s %s = 0;' % (elem_type, temp_name)) ++ print(' %s(%s, &%s);' % (inflection, ', '.join(args), temp_name)) + else: +- print ' %s %s = %s(%s);' % (elem_type, temp_name, inflection, ', '.join(args)) ++ print(' %s %s = %s(%s);' % (elem_type, temp_name, inflection, ', '.join(args))) + return temp_name + + def visitString(self, string, args): + temp_name = self.temp_name(args) + inflection = self.inflector.inflect(string) + assert not inflection.endswith('v' + self.inflector.suffix) +- print ' %s %s = (%s)%s(%s);' % (string, temp_name, string, inflection, ', '.join(args)) ++ print(' %s %s = (%s)%s(%s);' % (string, temp_name, string, inflection, ', '.join(args))) + return temp_name + + def visitAlias(self, alias, args): +@@ -166,28 +166,28 @@ class StateGetter(Visitor): + array_length = array.length + if isinstance(array_length, int): + # Static integer length +- print ' %s %s[%s + 1];' % (elem_type, temp_name, array_length) ++ print(' %s %s[%s + 1];' % (elem_type, temp_name, array_length)) + else: + # Put the length in a variable to avoid recomputing it every time +- print ' size_t _%s_length = %s;' % (temp_name, array_length) ++ print(' size_t _%s_length = %s;' % (temp_name, array_length)) + array_length = '_%s_length' % temp_name + # Allocate a dynamic sized array +- print ' %s *%s = _allocator.alloc<%s>(%s + 1);' % (elem_type, temp_name, elem_type, array_length) +- print ' memset(%s, 0, %s * sizeof *%s);' % (temp_name, array_length, temp_name) +- print ' %s[%s] = (%s)0xdeadc0de;' % (temp_name, array_length, elem_type) +- print ' if (%s) {' % array_length +- print ' %s(%s, %s);' % (inflection, ', '.join(args), temp_name) +- print ' }' ++ print(' %s *%s = _allocator.alloc<%s>(%s + 1);' % (elem_type, temp_name, elem_type, array_length)) ++ print(' memset(%s, 0, %s * sizeof *%s);' % (temp_name, array_length, temp_name)) ++ print(' %s[%s] = (%s)0xdeadc0de;' % (temp_name, array_length, elem_type)) ++ print(' if (%s) {' % array_length) ++ print(' %s(%s, %s);' % (inflection, ', '.join(args), temp_name)) ++ print(' }') + # Simple buffer overflow detection +- print ' assert(%s[%s] == (%s)0xdeadc0de);' % (temp_name, array_length, elem_type) ++ print(' assert(%s[%s] == (%s)0xdeadc0de);' % (temp_name, array_length, elem_type)) + return temp_name + + def visitOpaque(self, pointer, args): + temp_name = self.temp_name(args) + inflection = self.inflector.inflect(pointer) + assert inflection.endswith('v' + self.inflector.suffix) +- print ' GLvoid *%s;' % temp_name +- print ' %s(%s, &%s);' % (inflection, ', '.join(args), temp_name) ++ print(' GLvoid *%s;' % temp_name) ++ print(' %s(%s, &%s);' % (inflection, ', '.join(args), temp_name)) + return temp_name + + +@@ -236,26 +236,26 @@ class JsonWriter(Visitor): + + def visitLiteral(self, literal, instance): + if literal.kind == 'Bool': +- print ' writer.writeBool(%s);' % instance ++ print(' writer.writeBool(%s);' % instance) + elif literal.kind in ('SInt', 'Uint'): +- print ' writer.writeInt(%s);' % instance ++ print(' writer.writeInt(%s);' % instance) + elif literal.kind in ('Float', 'Double'): +- print ' writer.writeFloat(%s);' % instance ++ print(' writer.writeFloat(%s);' % instance) + else: + raise NotImplementedError + + def visitString(self, string, instance): + assert string.length is None +- print ' writer.writeString((const char *)%s);' % instance ++ print(' writer.writeString((const char *)%s);' % instance) + + def visitEnum(self, enum, instance): + if enum is GLboolean: +- print ' dumpBoolean(writer, %s);' % instance ++ print(' dumpBoolean(writer, %s);' % instance) + elif enum is GLenum: +- print ' dumpEnum(writer, %s);' % instance ++ print(' dumpEnum(writer, %s);' % instance) + else: + assert False +- print ' writer.writeInt(%s);' % instance ++ print(' writer.writeInt(%s);' % instance) + + def visitBitmask(self, bitmask, instance): + raise NotImplementedError +@@ -264,18 +264,18 @@ class JsonWriter(Visitor): + self.visit(alias.type, instance) + + def visitOpaque(self, opaque, instance): +- print ' writer.writeInt((size_t)%s);' % instance ++ print(' writer.writeInt((size_t)%s);' % instance) + + __index = 0 + + def visitArray(self, array, instance): + index = '_i%u' % JsonWriter.__index + JsonWriter.__index += 1 +- print ' writer.beginArray();' +- print ' for (unsigned %s = 0; %s < %s; ++%s) {' % (index, index, array.length, index) ++ print(' writer.beginArray();') ++ print(' for (unsigned %s = 0; %s < %s; ++%s) {' % (index, index, array.length, index)) + self.visit(array.type, '%s[%s]' % (instance, index)) +- print ' }' +- print ' writer.endArray();' ++ print(' }') ++ print(' writer.endArray();') + + + +@@ -287,75 +287,75 @@ class StateDumper: + pass + + def dump(self): +- print '#include <assert.h>' +- print '#include <string.h>' +- print +- print '#include "state_writer.hpp"' +- print '#include "scoped_allocator.hpp"' +- print '#include "glproc.hpp"' +- print '#include "glsize.hpp"' +- print '#include "glstate.hpp"' +- print '#include "glstate_internal.hpp"' +- print +- print 'namespace glstate {' +- print +- +- print 'const char *' +- print 'enumToString(GLenum pname)' +- print '{' +- print ' switch (pname) {' ++ print('#include <assert.h>') ++ print('#include <string.h>') ++ print() ++ print('#include "state_writer.hpp"') ++ print('#include "scoped_allocator.hpp"') ++ print('#include "glproc.hpp"') ++ print('#include "glsize.hpp"') ++ print('#include "glstate.hpp"') ++ print('#include "glstate_internal.hpp"') ++ print() ++ print('namespace glstate {') ++ print() ++ ++ print('const char *') ++ print('enumToString(GLenum pname)') ++ print('{') ++ print(' switch (pname) {') + for name in GLenum.values: +- print ' case %s:' % name +- print ' return "%s";' % name +- print ' default:' +- print ' return NULL;' +- print ' }' +- print '}' +- print +- +- print 'static void' +- print 'dumpTextureTargetParameters(StateWriter &writer, Context &context, GLenum target, GLuint texture)' +- print '{' +- print ' writer.beginMember(enumToString(target));' +- print ' writer.beginObject();' +- print ' dumpObjectLabel(writer, context, GL_TEXTURE, texture, "GL_TEXTURE_LABEL");' ++ print(' case %s:' % name) ++ print(' return "%s";' % name) ++ print(' default:') ++ print(' return NULL;') ++ print(' }') ++ print('}') ++ print() ++ ++ print('static void') ++ print('dumpTextureTargetParameters(StateWriter &writer, Context &context, GLenum target, GLuint texture)') ++ print('{') ++ print(' writer.beginMember(enumToString(target));') ++ print(' writer.beginObject();') ++ print(' dumpObjectLabel(writer, context, GL_TEXTURE, texture, "GL_TEXTURE_LABEL");') + # ARB_texture_buffer forbids glGetTexParameter and + # glGetTexLevelParameter for TEXTURE_BUFFER, but + # ARB_texture_buffer_range introduced parameters which can be queries + # with glGetTexLevelParameter... +- print ' if (target != GL_TEXTURE_BUFFER) {' ++ print(' if (target != GL_TEXTURE_BUFFER) {') + self.dump_atoms(glGetTexParameter, 'target') +- print ' }' +- print ' if (!context.ES) {' +- print ' GLenum levelTarget;' +- print ' if (target == GL_TEXTURE_CUBE_MAP ||' +- print ' target == GL_TEXTURE_CUBE_MAP_ARRAY) {' +- print ' // Must pick a face' +- print ' levelTarget = GL_TEXTURE_CUBE_MAP_POSITIVE_X;' +- print ' } else {' +- print ' levelTarget = target;' +- print ' }' ++ print(' }') ++ print(' if (!context.ES) {') ++ print(' GLenum levelTarget;') ++ print(' if (target == GL_TEXTURE_CUBE_MAP ||') ++ print(' target == GL_TEXTURE_CUBE_MAP_ARRAY) {') ++ print(' // Must pick a face') ++ print(' levelTarget = GL_TEXTURE_CUBE_MAP_POSITIVE_X;') ++ print(' } else {') ++ print(' levelTarget = target;') ++ print(' }') + self.dump_atoms(glGetTexLevelParameter, 'levelTarget', '0') +- print ' }' +- print ' writer.endObject();' +- print ' writer.endMember(); // target' +- print '}' +- print +- +- print 'static void' +- print 'dumpFramebufferAttachementParameters(StateWriter &writer, Context &context, GLenum target, GLenum attachment)' +- print '{' ++ print(' }') ++ print(' writer.endObject();') ++ print(' writer.endMember(); // target') ++ print('}') ++ print() ++ ++ print('static void') ++ print('dumpFramebufferAttachementParameters(StateWriter &writer, Context &context, GLenum target, GLenum attachment)') ++ print('{') + self.dump_attachment_parameters('target', 'attachment') +- print '}' +- print +- +- print 'void dumpParameters(StateWriter &writer, Context &context)' +- print '{' +- print ' ScopedAllocator _allocator;' +- print ' (void)_allocator;' +- print +- print ' writer.beginMember("parameters");' +- print ' writer.beginObject();' ++ print('}') ++ print() ++ ++ print('void dumpParameters(StateWriter &writer, Context &context)') ++ print('{') ++ print(' ScopedAllocator _allocator;') ++ print(' (void)_allocator;') ++ print() ++ print(' writer.beginMember("parameters");') ++ print(' writer.beginObject();') + + self.dump_atoms(glGet) + +@@ -368,58 +368,58 @@ class StateDumper: + self.dump_framebuffer_parameters() + self.dump_labels() + +- print ' writer.endObject();' +- print ' writer.endMember(); // parameters' +- print '}' +- print ++ print(' writer.endObject();') ++ print(' writer.endMember(); // parameters') ++ print('}') ++ print() + +- print '} /*namespace glstate */' ++ print('} /*namespace glstate */') + + def dump_material_params(self): +- print ' if (!context.ES) {' ++ print(' if (!context.ES) {') + for face in ['GL_FRONT', 'GL_BACK']: +- print ' writer.beginMember("%s");' % face +- print ' writer.beginObject();' ++ print(' writer.beginMember("%s");' % face) ++ print(' writer.beginObject();') + self.dump_atoms(glGetMaterial, face) +- print ' writer.endObject();' +- print ' }' +- print ++ print(' writer.endObject();') ++ print(' }') ++ print() + + def dump_light_params(self): +- print ' GLint max_lights = 0;' +- print ' _glGetIntegerv(GL_MAX_LIGHTS, &max_lights);' +- print ' for (GLint index = 0; index < max_lights; ++index) {' +- print ' GLenum light = GL_LIGHT0 + index;' +- print ' if (glIsEnabled(light)) {' +- print ' char name[32];' +- print ' snprintf(name, sizeof name, "GL_LIGHT%i", index);' +- print ' writer.beginMember(name);' +- print ' writer.beginObject();' ++ print(' GLint max_lights = 0;') ++ print(' _glGetIntegerv(GL_MAX_LIGHTS, &max_lights);') ++ print(' for (GLint index = 0; index < max_lights; ++index) {') ++ print(' GLenum light = GL_LIGHT0 + index;') ++ print(' if (glIsEnabled(light)) {') ++ print(' char name[32];') ++ print(' snprintf(name, sizeof name, "GL_LIGHT%i", index);') ++ print(' writer.beginMember(name);') ++ print(' writer.beginObject();') + self.dump_atoms(glGetLight, ' GL_LIGHT0 + index') +- print ' writer.endObject();' +- print ' writer.endMember(); // GL_LIGHTi' +- print ' }' +- print ' }' +- print ++ print(' writer.endObject();') ++ print(' writer.endMember(); // GL_LIGHTi') ++ print(' }') ++ print(' }') ++ print() + + def dump_sampler_params(self): +- print ' // GL_SAMPLER_BINDING' +- print ' if (context.ARB_sampler_objects) {' +- print ' GLint sampler_binding = 0;' +- print ' glGetIntegerv(GL_SAMPLER_BINDING, &sampler_binding);' +- print ' writer.beginMember("GL_SAMPLER_BINDING");' +- print ' writer.writeInt(sampler_binding);' +- print ' writer.endMember();' +- print ' if (sampler_binding) {' +- print ' writer.beginMember("GL_SAMPLER");' +- print ' writer.beginObject();' +- print ' dumpObjectLabel(writer, context, GL_SAMPLER, sampler_binding, "GL_SAMPLER_LABEL");' ++ print(' // GL_SAMPLER_BINDING') ++ print(' if (context.ARB_sampler_objects) {') ++ print(' GLint sampler_binding = 0;') ++ print(' glGetIntegerv(GL_SAMPLER_BINDING, &sampler_binding);') ++ print(' writer.beginMember("GL_SAMPLER_BINDING");') ++ print(' writer.writeInt(sampler_binding);') ++ print(' writer.endMember();') ++ print(' if (sampler_binding) {') ++ print(' writer.beginMember("GL_SAMPLER");') ++ print(' writer.beginObject();') ++ print(' dumpObjectLabel(writer, context, GL_SAMPLER, sampler_binding, "GL_SAMPLER_LABEL");') + for _, _, name in glGetSamplerParameter.iter(): + self.dump_atom(glGetSamplerParameter, 'sampler_binding', name) +- print ' writer.endObject();' +- print ' writer.endMember(); // GL_SAMPLER' +- print ' }' +- print ' }' ++ print(' writer.endObject();') ++ print(' writer.endMember(); // GL_SAMPLER') ++ print(' }') ++ print(' }') + + def texenv_param_target(self, name): + if name == 'GL_TEXTURE_LOD_BIAS': +@@ -431,34 +431,34 @@ class StateDumper: + + def dump_texenv_params(self): + for target in ['GL_TEXTURE_ENV', 'GL_TEXTURE_FILTER_CONTROL', 'GL_POINT_SPRITE']: +- print ' if (!context.ES) {' +- print ' writer.beginMember("%s");' % target +- print ' writer.beginObject();' ++ print(' if (!context.ES) {') ++ print(' writer.beginMember("%s");' % target) ++ print(' writer.beginObject();') + for _, _, name in glGetTexEnv.iter(): + if self.texenv_param_target(name) == target: + self.dump_atom(glGetTexEnv, target, name) +- print ' writer.endObject();' +- print ' }' ++ print(' writer.endObject();') ++ print(' }') + + def dump_vertex_attribs(self): +- print ' GLint max_vertex_attribs = 0;' +- print ' _glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &max_vertex_attribs);' +- print ' for (GLint index = 0; index < max_vertex_attribs; ++index) {' +- print ' char name[32];' +- print ' snprintf(name, sizeof name, "GL_VERTEX_ATTRIB_ARRAY%i", index);' +- print ' writer.beginMember(name);' +- print ' writer.beginObject();' ++ print(' GLint max_vertex_attribs = 0;') ++ print(' _glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &max_vertex_attribs);') ++ print(' for (GLint index = 0; index < max_vertex_attribs; ++index) {') ++ print(' char name[32];') ++ print(' snprintf(name, sizeof name, "GL_VERTEX_ATTRIB_ARRAY%i", index);') ++ print(' writer.beginMember(name);') ++ print(' writer.beginObject();') + self.dump_atoms(glGetVertexAttrib, 'index') + + # Dump vertex attrib buffer label +- print ' GLint buffer_binding = 0;' +- print ' glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &buffer_binding);' +- print ' dumpObjectLabel(writer, context, GL_BUFFER, buffer_binding, "GL_VERTEX_ATTRIB_ARRAY_BUFFER_LABEL");' ++ print(' GLint buffer_binding = 0;') ++ print(' glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &buffer_binding);') ++ print(' dumpObjectLabel(writer, context, GL_BUFFER, buffer_binding, "GL_VERTEX_ATTRIB_ARRAY_BUFFER_LABEL");') + +- print ' writer.endObject();' +- print ' writer.endMember(); // GL_VERTEX_ATTRIB_ARRAYi' +- print ' }' +- print ++ print(' writer.endObject();') ++ print(' writer.endMember(); // GL_VERTEX_ATTRIB_ARRAYi') ++ print(' }') ++ print() + + object_bindings = [ + ('GL_BUFFER', 'GL_ARRAY_BUFFER_BINDING'), +@@ -488,11 +488,11 @@ class StateDumper: + member_name = object_binding.replace('BINDING', 'LABEL') + if member_name == object_binding: + member_name += '_LABEL' +- print ' {' +- print ' GLint binding = 0;' +- print ' glGetIntegerv(%s, &binding);' % object_binding +- print ' dumpObjectLabel(writer, context, %s, binding, "%s");' % (object_type, member_name) +- print ' }' ++ print(' {') ++ print(' GLint binding = 0;') ++ print(' glGetIntegerv(%s, &binding);' % object_binding) ++ print(' dumpObjectLabel(writer, context, %s, binding, "%s");' % (object_type, member_name)) ++ print(' }') + + program_targets = [ + 'GL_FRAGMENT_PROGRAM_ARB', +@@ -501,12 +501,12 @@ class StateDumper: + + def dump_program_params(self): + for target in self.program_targets: +- print ' if (glIsEnabled(%s)) {' % target +- print ' writer.beginMember("%s");' % target +- print ' writer.beginObject();' ++ print(' if (glIsEnabled(%s)) {' % target) ++ print(' writer.beginMember("%s");' % target) ++ print(' writer.beginObject();') + self.dump_atoms(glGetProgramARB, target) +- print ' writer.endObject();' +- print ' }' ++ print(' writer.endObject();') ++ print(' }') + + buffer_targets = [ + ('GL_ARRAY_BUFFER', 'GL_ARRAY_BUFFER_BINDING', None), +@@ -529,135 +529,135 @@ class StateDumper: + def dump_buffer_parameters(self): + # general binding points + for target, binding, max_bindings in self.buffer_targets: +- print ' // %s' % target +- print ' {' +- print ' writer.beginMember("%s");' % target +- print ' writer.beginObject();' +- print ' GLint buffer = 0;' +- print ' glGetIntegerv(%s, &buffer);' % binding +- print ' if (buffer) {' ++ print(' // %s' % target) ++ print(' {') ++ print(' writer.beginMember("%s");' % target) ++ print(' writer.beginObject();') ++ print(' GLint buffer = 0;') ++ print(' glGetIntegerv(%s, &buffer);' % binding) ++ print(' if (buffer) {') + self.dump_atoms(glGetBufferParameter, target) +- print ' }' ++ print(' }') + if max_bindings is not None: + # indexed binding points + start = target + '_START' + size = target + '_SIZE' +- print ' GLint max_bindings = 0;' +- print ' glGetIntegerv(%s, &max_bindings);' % max_bindings +- print ' if (max_bindings) {' +- print ' writer.beginMember("i");' +- print ' writer.beginArray();' +- print ' for (GLint i = 0; i < max_bindings; ++i) {' +- print ' writer.beginObject();' ++ print(' GLint max_bindings = 0;') ++ print(' glGetIntegerv(%s, &max_bindings);' % max_bindings) ++ print(' if (max_bindings) {') ++ print(' writer.beginMember("i");') ++ print(' writer.beginArray();') ++ print(' for (GLint i = 0; i < max_bindings; ++i) {') ++ print(' writer.beginObject();') + for pname in [binding, start, size]: + self.dump_atom(glGet_i, pname, 'i') +- print ' writer.endObject();' +- print ' }' +- print ' writer.endArray();' +- print ' writer.endMember();' +- print ' }' ++ print(' writer.endObject();') ++ print(' }') ++ print(' writer.endArray();') ++ print(' writer.endMember();') ++ print(' }') + +- print ' writer.endObject();' +- print ' writer.endMember();' +- print ' }' +- print ++ print(' writer.endObject();') ++ print(' writer.endMember();') ++ print(' }') ++ print() + + def dump_texture_parameters(self): +- print ' {' +- print ' GLint active_texture = GL_TEXTURE0;' +- print ' glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture);' +- print ' GLint max_texture_coords = 0;' +- print ' if (!context.core) {' +- print ' glGetIntegerv(GL_MAX_TEXTURE_COORDS, &max_texture_coords);' +- print ' }' +- print ' GLint max_combined_texture_image_units = 0;' +- print ' glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &max_combined_texture_image_units);' +- print ' max_combined_texture_image_units = std::max(max_combined_texture_image_units, 2);' +- print ' GLint max_units = std::max(max_combined_texture_image_units, max_texture_coords);' +- print ' for (GLint unit = 0; unit < max_units; ++unit) {' +- print ' char name[32];' +- print ' snprintf(name, sizeof name, "GL_TEXTURE%i", unit);' +- print ' writer.beginMember(name);' +- print ' glActiveTexture(GL_TEXTURE0 + unit);' +- print ' writer.beginObject();' +- print ++ print(' {') ++ print(' GLint active_texture = GL_TEXTURE0;') ++ print(' glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture);') ++ print(' GLint max_texture_coords = 0;') ++ print(' if (!context.core) {') ++ print(' glGetIntegerv(GL_MAX_TEXTURE_COORDS, &max_texture_coords);') ++ print(' }') ++ print(' GLint max_combined_texture_image_units = 0;') ++ print(' glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &max_combined_texture_image_units);') ++ print(' max_combined_texture_image_units = std::max(max_combined_texture_image_units, 2);') ++ print(' GLint max_units = std::max(max_combined_texture_image_units, max_texture_coords);') ++ print(' for (GLint unit = 0; unit < max_units; ++unit) {') ++ print(' char name[32];') ++ print(' snprintf(name, sizeof name, "GL_TEXTURE%i", unit);') ++ print(' writer.beginMember(name);') ++ print(' glActiveTexture(GL_TEXTURE0 + unit);') ++ print(' writer.beginObject();') ++ print() + self.dump_atoms(glGet_texture) +- print +- print ' for (unsigned i = 0; i < numTextureTargets; ++i) {' +- print ' GLenum target = textureTargets[i];' +- print ' GLboolean enabled = GL_FALSE;' +- print ' if (unit < max_texture_coords &&' +- print ' (target == GL_TEXTURE_1D ||' +- print ' target == GL_TEXTURE_2D ||' +- print ' target == GL_TEXTURE_3D ||' +- print ' target == GL_TEXTURE_CUBE_MAP ||' +- print ' target == GL_TEXTURE_RECTANGLE)) {' +- print ' glGetBooleanv(target, &enabled);' +- print ' writer.beginMember(enumToString(target));' +- print ' dumpBoolean(writer, enabled);' +- print ' writer.endMember();' +- print ' }' +- print ' GLint texture = 0;' +- print ' GLenum binding = getTextureBinding(target);' +- print ' glGetIntegerv(binding, &texture);' +- print ' if (enabled || texture) {' +- print ' dumpTextureTargetParameters(writer, context, target, texture);' +- print ' }' +- print ' }' +- print ++ print() ++ print(' for (unsigned i = 0; i < numTextureTargets; ++i) {') ++ print(' GLenum target = textureTargets[i];') ++ print(' GLboolean enabled = GL_FALSE;') ++ print(' if (unit < max_texture_coords &&') ++ print(' (target == GL_TEXTURE_1D ||') ++ print(' target == GL_TEXTURE_2D ||') ++ print(' target == GL_TEXTURE_3D ||') ++ print(' target == GL_TEXTURE_CUBE_MAP ||') ++ print(' target == GL_TEXTURE_RECTANGLE)) {') ++ print(' glGetBooleanv(target, &enabled);') ++ print(' writer.beginMember(enumToString(target));') ++ print(' dumpBoolean(writer, enabled);') ++ print(' writer.endMember();') ++ print(' }') ++ print(' GLint texture = 0;') ++ print(' GLenum binding = getTextureBinding(target);') ++ print(' glGetIntegerv(binding, &texture);') ++ print(' if (enabled || texture) {') ++ print(' dumpTextureTargetParameters(writer, context, target, texture);') ++ print(' }') ++ print(' }') ++ print() + self.dump_sampler_params() +- print +- print ' if (unit < max_texture_coords) {' ++ print() ++ print(' if (unit < max_texture_coords) {') + self.dump_texenv_params() +- print ' }' +- print ' writer.endObject();' +- print ' writer.endMember(); // GL_TEXTUREi' +- print ' }' +- print ' glActiveTexture(active_texture);' +- print ' }' +- print ++ print(' }') ++ print(' writer.endObject();') ++ print(' writer.endMember(); // GL_TEXTUREi') ++ print(' }') ++ print(' glActiveTexture(active_texture);') ++ print(' }') ++ print() + + def dump_framebuffer_parameters(self): +- print ' {' +- print ' GLint max_color_attachments = 0;' +- print ' glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &max_color_attachments);' +- print ' GLint framebuffer;' ++ print(' {') ++ print(' GLint max_color_attachments = 0;') ++ print(' glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &max_color_attachments);') ++ print(' GLint framebuffer;') + for target, binding in framebuffer_targets: +- print ' // %s' % target +- print ' framebuffer = 0;' +- print ' glGetIntegerv(%s, &framebuffer);' % binding +- print ' if (framebuffer) {' +- print ' writer.beginMember("%s");' % target +- print ' writer.beginObject();' +- print ' dumpObjectLabel(writer, context, GL_FRAMEBUFFER, framebuffer, "GL_FRAMEBUFFER_LABEL");' +- print ' for (GLint i = 0; i < max_color_attachments; ++i) {' +- print ' GLint color_attachment = GL_COLOR_ATTACHMENT0 + i;' +- print ' dumpFramebufferAttachementParameters(writer, context, %s, color_attachment);' % target +- print ' }' +- print ' dumpFramebufferAttachementParameters(writer, context, %s, GL_DEPTH_ATTACHMENT);' % target +- print ' dumpFramebufferAttachementParameters(writer, context, %s, GL_STENCIL_ATTACHMENT);' % target +- print ' writer.endObject();' +- print ' writer.endMember(); // %s' % target +- print ' }' +- print +- print ' }' +- print ++ print(' // %s' % target) ++ print(' framebuffer = 0;') ++ print(' glGetIntegerv(%s, &framebuffer);' % binding) ++ print(' if (framebuffer) {') ++ print(' writer.beginMember("%s");' % target) ++ print(' writer.beginObject();') ++ print(' dumpObjectLabel(writer, context, GL_FRAMEBUFFER, framebuffer, "GL_FRAMEBUFFER_LABEL");') ++ print(' for (GLint i = 0; i < max_color_attachments; ++i) {') ++ print(' GLint color_attachment = GL_COLOR_ATTACHMENT0 + i;') ++ print(' dumpFramebufferAttachementParameters(writer, context, %s, color_attachment);' % target) ++ print(' }') ++ print(' dumpFramebufferAttachementParameters(writer, context, %s, GL_DEPTH_ATTACHMENT);' % target) ++ print(' dumpFramebufferAttachementParameters(writer, context, %s, GL_STENCIL_ATTACHMENT);' % target) ++ print(' writer.endObject();') ++ print(' writer.endMember(); // %s' % target) ++ print(' }') ++ print() ++ print(' }') ++ print() + + def dump_attachment_parameters(self, target, attachment): +- print ' {' +- print ' GLint object_type = GL_NONE;' +- print ' glGetFramebufferAttachmentParameteriv(%s, %s, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &object_type);' % (target, attachment) +- print ' if (object_type != GL_NONE) {' +- print ' writer.beginMember(enumToString(%s));' % attachment +- print ' writer.beginObject();' ++ print(' {') ++ print(' GLint object_type = GL_NONE;') ++ print(' glGetFramebufferAttachmentParameteriv(%s, %s, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &object_type);' % (target, attachment)) ++ print(' if (object_type != GL_NONE) {') ++ print(' writer.beginMember(enumToString(%s));' % attachment) ++ print(' writer.beginObject();') + self.dump_atoms(glGetFramebufferAttachmentParameter, target, attachment) +- print ' GLint object_name = 0;' +- print ' glGetFramebufferAttachmentParameteriv(%s, %s, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &object_name);' % (target, attachment) +- print ' dumpObjectLabel(writer, context, object_type, object_name, "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_LABEL");' +- print ' writer.endObject();' +- print ' writer.endMember(); // GL_x_ATTACHMENT' +- print ' }' +- print ' }' ++ print(' GLint object_name = 0;') ++ print(' glGetFramebufferAttachmentParameteriv(%s, %s, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &object_name);' % (target, attachment)) ++ print(' dumpObjectLabel(writer, context, object_type, object_name, "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_LABEL");') ++ print(' writer.endObject();') ++ print(' writer.endMember(); // GL_x_ATTACHMENT') ++ print(' }') ++ print(' }') + + def dump_atoms(self, getter, *args): + for _, _, name in getter.iter(): +@@ -666,20 +666,20 @@ class StateDumper: + def dump_atom(self, getter, *args): + name = args[getter.pnameIdx] + +- print ' // %s' % name +- print ' {' +- print ' flushErrors();' ++ print(' // %s' % name) ++ print(' {') ++ print(' flushErrors();') + type, value = getter(*args) +- print ' if (glGetError() != GL_NO_ERROR) {' ++ print(' if (glGetError() != GL_NO_ERROR) {') + #print ' std::cerr << "warning: %s(%s) failed\\n";' % (inflection, name) +- print ' flushErrors();' +- print ' } else {' +- print ' writer.beginMember("%s");' % name ++ print(' flushErrors();') ++ print(' } else {') ++ print(' writer.beginMember("%s");' % name) + JsonWriter().visit(type, value) +- print ' writer.endMember();' +- print ' }' +- print ' }' +- print ++ print(' writer.endMember();') ++ print(' }') ++ print(' }') ++ print() + + + if __name__ == '__main__': +diff --git a/retrace/retrace.py b/retrace/retrace.py +index 164944ed..0149817c 100644 +--- a/retrace/retrace.py ++++ b/retrace/retrace.py +@@ -69,10 +69,10 @@ class ValueAllocator(stdapi.Visitor): + pass + + def visitArray(self, array, lvalue, rvalue): +- print ' %s = _allocator.allocArray<%s>(&%s);' % (lvalue, array.type, rvalue) ++ print(' %s = _allocator.allocArray<%s>(&%s);' % (lvalue, array.type, rvalue)) + + def visitPointer(self, pointer, lvalue, rvalue): +- print ' %s = _allocator.allocArray<%s>(&%s);' % (lvalue, pointer.type, rvalue) ++ print(' %s = _allocator.allocArray<%s>(&%s);' % (lvalue, pointer.type, rvalue)) + + def visitIntPointer(self, pointer, lvalue, rvalue): + pass +@@ -109,7 +109,7 @@ class ValueAllocator(stdapi.Visitor): + class ValueDeserializer(stdapi.Visitor, stdapi.ExpanderMixin): + + def visitLiteral(self, literal, lvalue, rvalue): +- print ' %s = (%s).to%s();' % (lvalue, rvalue, literal.kind) ++ print(' %s = (%s).to%s();' % (lvalue, rvalue, literal.kind)) + + def visitConst(self, const, lvalue, rvalue): + self.visit(const.type, lvalue, rvalue) +@@ -118,7 +118,7 @@ class ValueDeserializer(stdapi.Visitor, stdapi.ExpanderMixin): + self.visit(alias.type, lvalue, rvalue) + + def visitEnum(self, enum, lvalue, rvalue): +- print ' %s = static_cast<%s>((%s).toSInt());' % (lvalue, enum, rvalue) ++ print(' %s = static_cast<%s>((%s).toSInt());' % (lvalue, enum, rvalue)) + + def visitBitmask(self, bitmask, lvalue, rvalue): + self.visit(bitmask.type, lvalue, rvalue) +@@ -127,50 +127,50 @@ class ValueDeserializer(stdapi.Visitor, stdapi.ExpanderMixin): + tmp = '_a_' + array.tag + '_' + str(self.seq) + self.seq += 1 + +- print ' const trace::Array *%s = (%s).toArray();' % (tmp, rvalue) +- print ' if (%s) {' % (tmp,) ++ print(' const trace::Array *%s = (%s).toArray();' % (tmp, rvalue)) ++ print(' if (%s) {' % (tmp,)) + + length = '%s->values.size()' % (tmp,) + if self.insideStruct: + if isinstance(array.length, int): + # Member is an array +- print r' static_assert( std::is_array< std::remove_reference< decltype( %s ) >::type >::value , "lvalue must be an array" );' % lvalue +- print r' static_assert( std::extent< std::remove_reference< decltype( %s ) >::type >::value == %s, "array size mismatch" );' % (lvalue, array.length) +- print r' assert( %s );' % (tmp,) +- print r' assert( %s->size() == %s );' % (tmp, array.length) ++ print(r' static_assert( std::is_array< std::remove_reference< decltype( %s ) >::type >::value , "lvalue must be an array" );' % lvalue) ++ print(r' static_assert( std::extent< std::remove_reference< decltype( %s ) >::type >::value == %s, "array size mismatch" );' % (lvalue, array.length)) ++ print(r' assert( %s );' % (tmp,)) ++ print(r' assert( %s->size() == %s );' % (tmp, array.length)) + length = str(array.length) + else: + # Member is a pointer to an array, hence must be allocated +- print r' static_assert( std::is_pointer< std::remove_reference< decltype( %s ) >::type >::value , "lvalue must be a pointer" );' % lvalue +- print r' %s = _allocator.allocArray<%s>(&%s);' % (lvalue, array.type, rvalue) ++ print(r' static_assert( std::is_pointer< std::remove_reference< decltype( %s ) >::type >::value , "lvalue must be a pointer" );' % lvalue) ++ print(r' %s = _allocator.allocArray<%s>(&%s);' % (lvalue, array.type, rvalue)) + + index = '_j' + array.tag +- print ' for (size_t {i} = 0; {i} < {length}; ++{i}) {{'.format(i = index, length = length) ++ print(' for (size_t {i} = 0; {i} < {length}; ++{i}) {{'.format(i = index, length = length)) + try: + self.visit(array.type, '%s[%s]' % (lvalue, index), '*%s->values[%s]' % (tmp, index)) + finally: +- print ' }' +- print ' }' ++ print(' }') ++ print(' }') + + def visitPointer(self, pointer, lvalue, rvalue): + tmp = '_a_' + pointer.tag + '_' + str(self.seq) + self.seq += 1 + +- print ' if (%s) {' % (lvalue,) +- print ' const trace::Array *%s = (%s).toArray();' % (tmp, rvalue) ++ print(' if (%s) {' % (lvalue,)) ++ print(' const trace::Array *%s = (%s).toArray();' % (tmp, rvalue)) + try: + self.visit(pointer.type, '%s[0]' % (lvalue,), '*%s->values[0]' % (tmp,)) + finally: +- print ' }' ++ print(' }') + + def visitIntPointer(self, pointer, lvalue, rvalue): +- print ' %s = static_cast<%s>((%s).toPointer());' % (lvalue, pointer, rvalue) ++ print(' %s = static_cast<%s>((%s).toPointer());' % (lvalue, pointer, rvalue)) + + def visitObjPointer(self, pointer, lvalue, rvalue): +- print ' %s = retrace::asObjPointer<%s>(call, %s);' % (lvalue, pointer.type, rvalue) ++ print(' %s = retrace::asObjPointer<%s>(call, %s);' % (lvalue, pointer.type, rvalue)) + + def visitLinearPointer(self, pointer, lvalue, rvalue): +- print ' %s = static_cast<%s>(retrace::toPointer(%s));' % (lvalue, pointer, rvalue) ++ print(' %s = static_cast<%s>(retrace::toPointer(%s));' % (lvalue, pointer, rvalue)) + + def visitReference(self, reference, lvalue, rvalue): + self.visit(reference.type, lvalue, rvalue); +@@ -179,23 +179,23 @@ class ValueDeserializer(stdapi.Visitor, stdapi.ExpanderMixin): + #OpaqueValueDeserializer().visit(handle.type, lvalue, rvalue); + self.visit(handle.type, lvalue, rvalue); + new_lvalue = lookupHandle(handle, lvalue) +- print ' if (retrace::verbosity >= 2) {' +- print ' std::cout << "%s " << size_t(%s) << " <- " << size_t(%s) << "\\n";' % (handle.name, lvalue, new_lvalue) +- print ' }' ++ print(' if (retrace::verbosity >= 2) {') ++ print(' std::cout << "%s " << size_t(%s) << " <- " << size_t(%s) << "\\n";' % (handle.name, lvalue, new_lvalue)) ++ print(' }') + if (new_lvalue.startswith('_program_map') or new_lvalue.startswith('_shader_map')): +- print 'if (glretrace::supportsARBShaderObjects) {' +- print ' %s = _handleARB_map[%s];' % (lvalue, lvalue) +- print '} else {' +- print ' %s = %s;' % (lvalue, new_lvalue) +- print '}' ++ print('if (glretrace::supportsARBShaderObjects) {') ++ print(' %s = _handleARB_map[%s];' % (lvalue, lvalue)) ++ print('} else {') ++ print(' %s = %s;' % (lvalue, new_lvalue)) ++ print('}') + else: +- print ' %s = %s;' % (lvalue, new_lvalue) ++ print(' %s = %s;' % (lvalue, new_lvalue)) + + def visitBlob(self, blob, lvalue, rvalue): +- print ' %s = static_cast<%s>((%s).toPointer());' % (lvalue, blob, rvalue) ++ print(' %s = static_cast<%s>((%s).toPointer());' % (lvalue, blob, rvalue)) + + def visitString(self, string, lvalue, rvalue): +- print ' %s = (%s)((%s).toString());' % (lvalue, string.expr, rvalue) ++ print(' %s = (%s)((%s).toString());' % (lvalue, string.expr, rvalue)) + + seq = 0 + +@@ -207,8 +207,8 @@ class ValueDeserializer(stdapi.Visitor, stdapi.ExpanderMixin): + + self.insideStruct += 1 + +- print ' const trace::Struct *%s = (%s).toStruct();' % (tmp, rvalue) +- print ' assert(%s);' % (tmp) ++ print(' const trace::Struct *%s = (%s).toStruct();' % (tmp, rvalue)) ++ print(' assert(%s);' % (tmp)) + for i in range(len(struct.members)): + member = struct.members[i] + self.visitMember(member, lvalue, '*%s->members[%s]' % (tmp, i)) +@@ -218,24 +218,24 @@ class ValueDeserializer(stdapi.Visitor, stdapi.ExpanderMixin): + def visitPolymorphic(self, polymorphic, lvalue, rvalue): + if polymorphic.defaultType is None: + switchExpr = self.expand(polymorphic.switchExpr) +- print r' switch (%s) {' % switchExpr ++ print(r' switch (%s) {' % switchExpr) + for cases, type in polymorphic.iterSwitch(): + for case in cases: +- print r' %s:' % case ++ print(r' %s:' % case) + caseLvalue = lvalue + if type.expr is not None: + caseLvalue = 'static_cast<%s>(%s)' % (type, caseLvalue) +- print r' {' ++ print(r' {') + try: + self.visit(type, caseLvalue, rvalue) + finally: +- print r' }' +- print r' break;' ++ print(r' }') ++ print(r' break;') + if polymorphic.defaultType is None: +- print r' default:' +- print r' retrace::warning(call) << "unexpected polymorphic case" << %s << "\n";' % (switchExpr,) +- print r' break;' +- print r' }' ++ print(r' default:') ++ print(r' retrace::warning(call) << "unexpected polymorphic case" << %s << "\n";' % (switchExpr,)) ++ print(r' break;') ++ print(r' }') + else: + self.visit(polymorphic.defaultType, lvalue, rvalue) + +@@ -250,7 +250,7 @@ class OpaqueValueDeserializer(ValueDeserializer): + in the context of handles.''' + + def visitOpaque(self, opaque, lvalue, rvalue): +- print ' %s = static_cast<%s>(retrace::toPointer(%s));' % (lvalue, opaque, rvalue) ++ print(' %s = static_cast<%s>(retrace::toPointer(%s));' % (lvalue, opaque, rvalue)) + + + class SwizzledValueRegistrator(stdapi.Visitor, stdapi.ExpanderMixin): +@@ -270,67 +270,67 @@ class SwizzledValueRegistrator(stdapi.Visitor, stdapi.ExpanderMixin): + pass + + def visitArray(self, array, lvalue, rvalue): +- print ' const trace::Array *_a%s = (%s).toArray();' % (array.tag, rvalue) +- print ' if (_a%s) {' % (array.tag) ++ print(' const trace::Array *_a%s = (%s).toArray();' % (array.tag, rvalue)) ++ print(' if (_a%s) {' % (array.tag)) + length = '_a%s->values.size()' % array.tag + index = '_j' + array.tag +- print ' for (size_t {i} = 0; {i} < {length}; ++{i}) {{'.format(i = index, length = length) ++ 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.tag, index)) + finally: +- print ' }' +- print ' }' ++ print(' }') ++ print(' }') + + def visitPointer(self, pointer, lvalue, rvalue): +- print ' const trace::Array *_a%s = (%s).toArray();' % (pointer.tag, rvalue) +- print ' if (_a%s) {' % (pointer.tag) ++ print(' const trace::Array *_a%s = (%s).toArray();' % (pointer.tag, rvalue)) ++ print(' if (_a%s) {' % (pointer.tag)) + try: + self.visit(pointer.type, '%s[0]' % (lvalue,), '*_a%s->values[0]' % (pointer.tag,)) + finally: +- print ' }' ++ print(' }') + + def visitIntPointer(self, pointer, lvalue, rvalue): + pass + + def visitObjPointer(self, pointer, lvalue, rvalue): +- print r' retrace::addObj(call, %s, %s);' % (rvalue, lvalue) ++ print(r' retrace::addObj(call, %s, %s);' % (rvalue, lvalue)) + + def visitLinearPointer(self, pointer, lvalue, rvalue): + assert pointer.size is not None + if pointer.size is not None: +- print r' retrace::addRegion(call, (%s).toUIntPtr(), %s, %s);' % (rvalue, lvalue, pointer.size) ++ print(r' retrace::addRegion(call, (%s).toUIntPtr(), %s, %s);' % (rvalue, lvalue, pointer.size)) + + def visitReference(self, reference, lvalue, rvalue): + pass + + def visitHandle(self, handle, lvalue, rvalue): +- print ' %s _origResult;' % handle.type ++ print(' %s _origResult;' % handle.type) + OpaqueValueDeserializer().visit(handle.type, '_origResult', rvalue); + if handle.range is None: + rvalue = "_origResult" + entry = lookupHandle(handle, rvalue, True) + if (entry.startswith('_program_map') or entry.startswith('_shader_map')): +- print 'if (glretrace::supportsARBShaderObjects) {' +- print ' _handleARB_map[%s] = %s;' % (rvalue, lvalue) +- print '} else {' +- print ' %s = %s;' % (entry, lvalue) +- print '}' ++ print('if (glretrace::supportsARBShaderObjects) {') ++ print(' _handleARB_map[%s] = %s;' % (rvalue, lvalue)) ++ print('} else {') ++ print(' %s = %s;' % (entry, lvalue)) ++ print('}') + else: +- print " %s = %s;" % (entry, lvalue) +- print ' if (retrace::verbosity >= 2) {' +- print ' std::cout << "{handle.name} " << {rvalue} << " -> " << {lvalue} << "\\n";'.format(**locals()) +- print ' }' ++ print(" %s = %s;" % (entry, lvalue)) ++ print(' if (retrace::verbosity >= 2) {') ++ print(' std::cout << "{handle.name} " << {rvalue} << " -> " << {lvalue} << "\\n";'.format(**locals())) ++ print(' }') + else: + i = '_h' + handle.tag + lvalue = "%s + %s" % (lvalue, i) + rvalue = "_origResult + %s" % (i,) + entry = lookupHandle(handle, rvalue) +- print ' for ({handle.type} {i} = 0; {i} < {handle.range}; ++{i}) {{'.format(**locals()) +- print ' {entry} = {lvalue};'.format(**locals()) +- print ' if (retrace::verbosity >= 2) {' +- print ' std::cout << "{handle.name} " << ({rvalue}) << " -> " << ({lvalue}) << "\\n";'.format(**locals()) +- print ' }' +- print ' }' ++ print(' for ({handle.type} {i} = 0; {i} < {handle.range}; ++{i}) {{'.format(**locals())) ++ print(' {entry} = {lvalue};'.format(**locals())) ++ print(' if (retrace::verbosity >= 2) {') ++ print(' std::cout << "{handle.name} " << ({rvalue}) << " -> " << ({lvalue}) << "\\n";'.format(**locals())) ++ print(' }') ++ print(' }') + + def visitBlob(self, blob, lvalue, rvalue): + pass +@@ -344,9 +344,9 @@ class SwizzledValueRegistrator(stdapi.Visitor, stdapi.ExpanderMixin): + tmp = '_s_' + struct.tag + '_' + str(self.seq) + self.seq += 1 + +- print ' const trace::Struct *%s = (%s).toStruct();' % (tmp, rvalue) +- print ' assert(%s);' % (tmp,) +- print ' (void)%s;' % (tmp,) ++ print(' const trace::Struct *%s = (%s).toStruct();' % (tmp, rvalue)) ++ print(' assert(%s);' % (tmp,)) ++ print(' (void)%s;' % (tmp,)) + for i in range(len(struct.members)): + member = struct.members[i] + self.visitMember(member, lvalue, '*%s->members[%s]' % (tmp, i)) +@@ -362,16 +362,16 @@ class SwizzledValueRegistrator(stdapi.Visitor, stdapi.ExpanderMixin): + class Retracer: + + def retraceFunction(self, function): +- print 'static void retrace_%s(trace::Call &call) {' % function.name ++ print('static void retrace_%s(trace::Call &call) {' % function.name) + self.retraceFunctionBody(function) +- print '}' +- print ++ print('}') ++ print() + + def retraceInterfaceMethod(self, interface, method): +- print 'static void retrace_%s__%s(trace::Call &call) {' % (interface.name, method.name) ++ print('static void retrace_%s__%s(trace::Call &call) {' % (interface.name, method.name)) + self.retraceInterfaceMethodBody(interface, method) +- print '}' +- print ++ print('}') ++ print() + + def retraceFunctionBody(self, function): + assert function.sideeffects +@@ -409,38 +409,38 @@ class Retracer: + assert function.type is not stdapi.Void + + if str(function.type) == 'HRESULT': +- print r' if (call.ret && FAILED(call.ret->toSInt())) {' +- print r' return;' +- print r' }' ++ print(r' if (call.ret && FAILED(call.ret->toSInt())) {') ++ print(r' return;') ++ print(r' }') + + def deserializeThisPointer(self, interface): +- print r' %s *_this;' % (interface.name,) +- print r' _this = retrace::asObjPointer<%s>(call, call.arg(0));' % (interface.name,) +- print r' if (!_this) {' +- print r' return;' +- print r' }' ++ print(r' %s *_this;' % (interface.name,)) ++ print(r' _this = retrace::asObjPointer<%s>(call, call.arg(0));' % (interface.name,)) ++ print(r' if (!_this) {') ++ print(r' return;') ++ print(r' }') + + def deserializeArgs(self, function): +- print ' retrace::ScopedAllocator _allocator;' +- print ' (void)_allocator;' ++ print(' retrace::ScopedAllocator _allocator;') ++ print(' (void)_allocator;') + success = True + for arg in function.args: + arg_type = arg.type.mutable() +- print ' %s %s;' % (arg_type, arg.name) ++ print(' %s %s;' % (arg_type, arg.name)) + rvalue = 'call.arg(%u)' % (arg.index,) + lvalue = arg.name + try: + self.extractArg(function, arg, arg_type, lvalue, rvalue) + except UnsupportedType: + success = False +- print ' memset(&%s, 0, sizeof %s); // FIXME' % (arg.name, arg.name) +- print ++ print(' memset(&%s, 0, sizeof %s); // FIXME' % (arg.name, arg.name)) ++ print() + + if not success: +- print ' if (1) {' ++ print(' if (1) {') + self.failFunction(function) + sys.stderr.write('warning: unsupported %s call\n' % function.name) +- print ' }' ++ print(' }') + + def swizzleValues(self, function): + for arg in function.args: +@@ -451,7 +451,7 @@ class Retracer: + try: + self.regiterSwizzledValue(arg_type, lvalue, rvalue) + except UnsupportedType: +- print ' // XXX: %s' % arg.name ++ print(' // XXX: %s' % arg.name) + if function.type is not stdapi.Void: + rvalue = '*call.ret' + lvalue = '_result' +@@ -459,15 +459,15 @@ class Retracer: + self.regiterSwizzledValue(function.type, lvalue, rvalue) + except UnsupportedType: + raise +- print ' // XXX: result' ++ print(' // XXX: result') + + def failFunction(self, function): +- print ' if (retrace::verbosity >= 0) {' +- print ' retrace::unsupported(call);' +- print ' }' ++ print(' if (retrace::verbosity >= 0) {') ++ print(' retrace::unsupported(call);') ++ print(' }') + # MGS-469: GPU hangs when retracing OGLESParticles on mx6sx + # Workaround: do not `return` +- #print ' return;' ++ #print(' return;') + + def extractArg(self, function, arg, arg_type, lvalue, rvalue): + ValueAllocator().visit(arg_type, lvalue, rvalue) +@@ -487,22 +487,22 @@ class Retracer: + + def declareRet(self, function): + if function.type is not stdapi.Void: +- print ' %s _result;' % (function.type) ++ print(' %s _result;' % (function.type)) + + def invokeFunction(self, function): + arg_names = ", ".join(function.argNames()) + if function.type is not stdapi.Void: +- print ' _result = %s(%s);' % (function.name, arg_names) ++ print(' _result = %s(%s);' % (function.name, arg_names)) + self.checkResult(None, function) + else: +- print ' %s(%s);' % (function.name, arg_names) ++ print(' %s(%s);' % (function.name, arg_names)) + + def invokeInterfaceMethod(self, interface, method): + arg_names = ", ".join(method.argNames()) + if method.type is not stdapi.Void: +- print ' _result = _this->%s(%s);' % (method.name, arg_names) ++ print(' _result = _this->%s(%s);' % (method.name, arg_names)) + else: +- print ' _this->%s(%s);' % (method.name, arg_names) ++ print(' _this->%s(%s);' % (method.name, arg_names)) + + # Adjust reference count when QueryInterface fails. This is + # particularly useful when replaying traces on older Direct3D runtimes +@@ -511,12 +511,12 @@ class Retracer: + # + # TODO: Generalize to other methods that return interfaces + if method.name == 'QueryInterface': +- print r' if (FAILED(_result)) {' +- print r' IUnknown *pObj = retrace::asObjPointer<IUnknown>(call, *call.arg(2).toArray()->values[0]);' +- print r' if (pObj) {' +- print r' pObj->AddRef();' +- print r' }' +- print r' }' ++ print(r' if (FAILED(_result)) {') ++ print(r' IUnknown *pObj = retrace::asObjPointer<IUnknown>(call, *call.arg(2).toArray()->values[0]);') ++ print(r' if (pObj) {') ++ print(r' pObj->AddRef();') ++ print(r' }') ++ print(r' }') + + if method.type is not stdapi.Void: + self.checkResult(interface, method) +@@ -524,28 +524,28 @@ class Retracer: + # Debug COM reference counting. Disabled by default as reported + # reference counts depend on internal implementation details. + if method.name in ('AddRef', 'Release'): +- print r' if (0) retrace::checkMismatch(call, "cRef", call.ret, _result);' ++ print(r' if (0) retrace::checkMismatch(call, "cRef", call.ret, _result);') + + # On release our reference when we reach Release() == 0 call in the + # trace. + if method.name == 'Release': +- print r' ULONG _orig_result = call.ret->toUInt();' +- print r' if (_orig_result == 0 || _result == 0) {' +- print r' if (_orig_result != 0) {' +- print r' retrace::warning(call) << "unexpected object destruction\n";' +- print r' }' +- print r' retrace::delObj(call.arg(0));' +- print r' }' ++ print(r' ULONG _orig_result = call.ret->toUInt();') ++ print(r' if (_orig_result == 0 || _result == 0) {') ++ print(r' if (_orig_result != 0) {') ++ print(r' retrace::warning(call) << "unexpected object destruction\n";') ++ print(r' }') ++ print(r' retrace::delObj(call.arg(0));') ++ print(r' }') + + def checkResult(self, interface, methodOrFunction): + assert methodOrFunction.type is not stdapi.Void + if str(methodOrFunction.type) == 'HRESULT': +- print r' if (FAILED(_result)) {' +- print r' retrace::failed(call, _result);' +- print r' return;' +- print r' }' ++ print(r' if (FAILED(_result)) {') ++ print(r' retrace::failed(call, _result);') ++ print(r' return;') ++ print(r' }') + else: +- print r' (void)_result;' ++ print(r' (void)_result;') + + def checkPitchMismatch(self, method): + # Warn for mismatches in 2D/3D mappings. +@@ -554,19 +554,19 @@ class Retracer: + if outArg.output \ + and isinstance(outArg.type, stdapi.Pointer) \ + and isinstance(outArg.type.type, stdapi.Struct): +- print r' const trace::Array *_%s = call.arg(%u).toArray();' % (outArg.name, outArg.index) +- print r' if (%s) {' % outArg.name +- print r' const trace::Struct *_struct = _%s->values[0]->toStruct();' % (outArg.name) +- print r' if (_struct) {' ++ print(r' const trace::Array *_%s = call.arg(%u).toArray();' % (outArg.name, outArg.index)) ++ print(r' if (%s) {' % outArg.name) ++ print(r' const trace::Struct *_struct = _%s->values[0]->toStruct();' % (outArg.name)) ++ print(r' if (_struct) {') + struct = outArg.type.type + for memberIndex in range(len(struct.members)): + memberType, memberName = struct.members[memberIndex] + if memberName.endswith('Pitch'): +- print r' if (%s->%s) {' % (outArg.name, memberName) +- print r' retrace::checkMismatch(call, "%s", _struct->members[%u], %s->%s);' % (memberName, memberIndex, outArg.name, memberName) +- print r' }' +- print r' }' +- print r' }' ++ print(r' if (%s->%s) {' % (outArg.name, memberName)) ++ print(r' retrace::checkMismatch(call, "%s", _struct->members[%u], %s->%s);' % (memberName, memberIndex, outArg.name, memberName)) ++ print(r' }') ++ print(r' }') ++ print(r' }') + + def filterFunction(self, function): + return True +@@ -575,11 +575,11 @@ class Retracer: + + def retraceApi(self, api): + +- print '#include "os_time.hpp"' +- print '#include "trace_parser.hpp"' +- print '#include "retrace.hpp"' +- print '#include "retrace_swizzle.hpp"' +- print ++ print('#include "os_time.hpp"') ++ print('#include "trace_parser.hpp"') ++ print('#include "retrace.hpp"') ++ print('#include "retrace_swizzle.hpp"') ++ print() + + types = api.getAllTypes() + handles = [type for type in types if isinstance(type, stdapi.Handle)] +@@ -587,14 +587,14 @@ class Retracer: + for handle in handles: + if handle.name not in handle_names: + if handle.key is None: +- print 'static retrace::map<%s> _%s_map;' % (handle.type, handle.name) ++ print('static retrace::map<%s> _%s_map;' % (handle.type, handle.name)) + else: + key_name, key_type = handle.key +- print 'static std::map<%s, retrace::map<%s> > _%s_map;' % (key_type, handle.type, handle.name) ++ print('static std::map<%s, retrace::map<%s> > _%s_map;' % (key_type, handle.type, handle.name)) + handle_names.add(handle.name) +- print ++ print() + +- functions = filter(self.filterFunction, api.getAllFunctions()) ++ functions = list(filter(self.filterFunction, api.getAllFunctions())) + for function in functions: + if function.sideeffects and not function.internal: + self.retraceFunction(function) +@@ -604,20 +604,20 @@ class Retracer: + if method.sideeffects and not method.internal: + self.retraceInterfaceMethod(interface, method) + +- print 'const retrace::Entry %s[] = {' % self.table_name ++ print('const retrace::Entry %s[] = {' % self.table_name) + for function in functions: + if not function.internal: + if function.sideeffects: +- print ' {"%s", &retrace_%s},' % (function.name, function.name) ++ print(' {"%s", &retrace_%s},' % (function.name, function.name)) + else: +- print ' {"%s", &retrace::ignore},' % (function.name,) ++ print(' {"%s", &retrace::ignore},' % (function.name,)) + for interface in interfaces: + for base, method in interface.iterBaseMethods(): + if method.sideeffects: +- print ' {"%s::%s", &retrace_%s__%s},' % (interface.name, method.name, base.name, method.name) ++ print(' {"%s::%s", &retrace_%s__%s},' % (interface.name, method.name, base.name, method.name)) + else: +- print ' {"%s::%s", &retrace::ignore},' % (interface.name, method.name) +- print ' {NULL, NULL}' +- print '};' +- print ++ print(' {"%s::%s", &retrace::ignore},' % (interface.name, method.name)) ++ print(' {NULL, NULL}') ++ print('};') ++ print() + +diff --git a/scripts/convert.py b/scripts/convert.py +index 5f338d80..83df70ce 100755 +--- a/scripts/convert.py ++++ b/scripts/convert.py +@@ -100,9 +100,9 @@ def detectApiFromCsv(inCsv): + import csv + csvReader = csv.reader(open(inCsv, 'rt'), ) + for row in csvReader: +- print row ++ print(row) + event = row[2] +- print event ++ print(event) + if event.startswith("Direct3DCreate9"): + return "d3d9" + if event.startswith("CreateDXGIFactory"): +diff --git a/scripts/jsondiff.py b/scripts/jsondiff.py +index 3b1f9110..25c4840e 100755 +--- a/scripts/jsondiff.py ++++ b/scripts/jsondiff.py +@@ -36,7 +36,7 @@ import sys + def strip_object_hook(obj): + if '__class__' in obj: + return None +- for name in obj.keys(): ++ for name in list(obj.keys()): + if name.startswith('__') and name.endswith('__'): + del obj[name] + return obj +@@ -80,7 +80,7 @@ class Dumper(Visitor): + def visitObject(self, node): + self.enter_object() + +- members = node.keys() ++ members = list(node.keys()) + members.sort() + for i in range(len(members)): + name = members[i] +@@ -148,8 +148,8 @@ class Comparer(Visitor): + return False + if len(a) != len(b) and not self.ignore_added: + return False +- ak = a.keys() +- bk = b.keys() ++ ak = list(a.keys()) ++ bk = list(b.keys()) + ak.sort() + bk.sort() + if ak != bk and not self.ignore_added: +@@ -175,8 +175,8 @@ class Comparer(Visitor): + return True + + def visitValue(self, a, b): +- if isinstance(a, float) and isinstance(b, (int, long, float)) or \ +- isinstance(b, float) and isinstance(a, (int, long, float)): ++ if isinstance(a, float) and isinstance(b, (int, float)) or \ ++ isinstance(b, float) and isinstance(a, (int, float)): + if a is b: + # NaNs take this path + return True +@@ -208,7 +208,7 @@ class Differ(Visitor): + self.dumper.enter_object() + names = set(a.keys()) + if not self.comparer.ignore_added: +- names.update(b.keys()) ++ names.update(list(b.keys())) + names = list(names) + names.sort() + +@@ -284,7 +284,7 @@ class Differ(Visitor): + self.dumper.visit(b) + + def isMultilineString(self, value): +- return isinstance(value, basestring) and '\n' in value ++ return isinstance(value, str) and '\n' in value + + + # +diff --git a/scripts/jsonextractimages.py b/scripts/jsonextractimages.py +index ea1c927d..917ee7e4 100755 +--- a/scripts/jsonextractimages.py ++++ b/scripts/jsonextractimages.py +@@ -38,7 +38,7 @@ pngSignature = "\x89\x50\x4E\x47\x0D\x0A\x1A\x0A" + + + def dumpSurfaces(state, memberName): +- for name, imageObj in state[memberName].iteritems(): ++ for name, imageObj in state[memberName].items(): + data = imageObj['__data__'] + data = base64.b64decode(data) + +diff --git a/scripts/leaks.py b/scripts/leaks.py +new file mode 100755 +index 00000000..325af1e2 +--- /dev/null ++++ b/scripts/leaks.py +@@ -0,0 +1,163 @@ ++#!/usr/bin/env python ++########################################################################## ++# ++# Copyright 2014-2016 VMware, Inc. ++# All Rights Reserved. ++# ++# Permission is hereby granted, free of charge, to any person obtaining a copy ++# of this software and associated documentation files (the "Software"), to deal ++# in the Software without restriction, including without limitation the rights ++# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell ++# copies of the Software, and to permit persons to whom the Software is ++# furnished to do so, subject to the following conditions: ++# ++# The above copyright notice and this permission notice shall be included in ++# all copies or substantial portions of the Software. ++# ++# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE ++# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER ++# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ++# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN ++# THE SOFTWARE. ++# ++##########################################################################/ ++ ++ ++import subprocess ++import sys ++import os.path ++import optparse ++import re ++ ++import unpickle ++ ++ ++class LeakDetector(unpickle.Unpickler): ++ ++ def __init__(self, apitrace, trace): ++ ++ cmd = [apitrace, 'pickle', '--symbolic', trace] ++ p = subprocess.Popen(args = cmd, stdout = subprocess.PIPE) ++ ++ unpickle.Unpickler.__init__(self, p.stdout) ++ ++ self.numContexts = 0 ++ ++ # a map of maps ++ self.objectDicts = {} ++ ++ def parse(self): ++ unpickle.Unpickler.parse(self) ++ ++ # Reached the end of the trace -- dump any live objects ++ self.dumpLeaks("<EOF>") ++ ++ genDelRegExp = re.compile('^gl(Gen|Delete)(Buffers|Textures|FrameBuffers|RenderBuffers)[A-Z]*$') ++ ++ def handleCall(self, call): ++ # Ignore calls without side effects ++ if call.flags & unpickle.CALL_FLAG_NO_SIDE_EFFECTS: ++ return ++ ++ # Dump call for debugging: ++ if 0: ++ sys.stderr.write('%s\n' % call) ++ ++ mo = self.genDelRegExp.match(call.functionName) ++ if mo: ++ verb = mo.group(1) ++ subject = mo.group(2) ++ ++ subject = subject.lower().rstrip('s') ++ objectDict = self.objectDicts.setdefault(subject, {}) ++ ++ if verb == 'Gen': ++ self.handleGenerate(call, objectDict) ++ elif verb == 'Delete': ++ self.handleDelete(call, objectDict) ++ else: ++ assert 0 ++ ++ # TODO: Track labels via glObjectLabel* calls ++ ++ if call.functionName in [ ++ 'CGLCreateContext', ++ 'eglCreateContext', ++ 'glXCreateContext', ++ 'glXCreateNewContext', ++ 'glXCreateContextAttribsARB', ++ 'glXCreateContextWithConfigSGIX', ++ 'wglCreateContext', ++ 'wglCreateContextAttribsARB', ++ ]: ++ # FIXME: Ignore failing context creation calls ++ self.numContexts += 1 ++ ++ if call.functionName in [ ++ 'CGLDestroyContext', ++ 'glXDestroyContext', ++ 'eglDestroyContext', ++ 'wglDeleteContext', ++ ]: ++ assert self.numContexts > 0 ++ self.numContexts -= 1 ++ if self.numContexts == 0: ++ self.dumpLeaks(call.no) ++ ++ def handleGenerate(self, call, objectDict): ++ n, names = call.argValues() ++ for i in range(n): ++ name = names[i] ++ objectDict[name] = call.no ++ # TODO: Keep track of call stack backtrace too ++ ++ def handleDelete(self, call, objectDict): ++ n, names = call.argValues() ++ for i in range(n): ++ name = names[i] ++ try: ++ del objectDict[name] ++ except KeyError: ++ # Ignore if texture name was never generated ++ pass ++ ++ def dumpLeaks(self, currentCallNo): ++ for kind, objectDict in self.objectDicts.items(): ++ self.dumpNamespaceLeaks(currentCallNo, objectDict, kind) ++ ++ def dumpNamespaceLeaks(self, currentCallNo, objectDict, kind): ++ for name, creationCallNo in (sorted(iter(objectDict.items()),key=lambda t: t[1])): ++ sys.stderr.write('%u: error: %s %u was not destroyed until %s\n' % (creationCallNo, kind, name, currentCallNo)) ++ objectDict.clear() ++ ++ ++def main(): ++ '''Main program. ++ ''' ++ ++ # Parse command line options ++ optparser = optparse.OptionParser( ++ usage='\n\t%prog [options] TRACE', ++ version='%%prog') ++ optparser.add_option( ++ '-a', '--apitrace', metavar='PROGRAM', ++ type='string', dest='apitrace', default='apitrace', ++ help='apitrace command [default: %default]') ++ ++ options, args = optparser.parse_args(sys.argv[1:]) ++ if len(args) != 1: ++ optparser.error("incorrect number of arguments") ++ ++ inTrace = args[0] ++ if not os.path.isfile(inTrace): ++ sys.stderr.write("error: `%s` does not exist\n" % inTrace) ++ sys.exit(1) ++ ++ detector = LeakDetector(options.apitrace, inTrace) ++ detector.parse() ++ ++ ++if __name__ == '__main__': ++ main() +diff --git a/scripts/profileshader.py b/scripts/profileshader.py +index 3c490a0e..5c2a58fb 100755 +--- a/scripts/profileshader.py ++++ b/scripts/profileshader.py +@@ -58,13 +58,13 @@ def process(stream, groupField): + continue + + if fields[callCol] == 'call': +- callId = long(fields[callIdCol]) +- duration = long(fields[gpuDuraCol]) ++ callId = int(fields[callIdCol]) ++ duration = int(fields[gpuDuraCol]) + group = fields[groupCol] + + maxGroupLen = max(maxGroupLen, len(group)) + +- if times.has_key(group): ++ if group in times: + times[group]['draws'] += 1 + times[group]['duration'] += duration + +@@ -74,7 +74,7 @@ def process(stream, groupField): + else: + times[group] = {'draws': 1, 'duration': duration, 'longest': callId, 'longestDuration': duration} + +- times = sorted(times.items(), key=lambda x: x[1]['duration'], reverse=True) ++ times = sorted(list(times.items()), key=lambda x: x[1]['duration'], reverse=True) + + if groupField == 'program': + groupTitle = 'Shader[id]' +@@ -84,9 +84,9 @@ def process(stream, groupField): + groupTitle = groupField.center(maxGroupLen) + groupLine = '-' * maxGroupLen + +- print '+-%s-+--------------+--------------------+--------------+-------------+' % groupLine +- print '| %s | Draws [#] | Duration [ns] v | Per Call[ns] | Longest[id] |' % groupTitle +- print '+-%s-+--------------+--------------------+--------------+-------------+' % groupLine ++ print('+-%s-+--------------+--------------------+--------------+-------------+' % groupLine) ++ print('| %s | Draws [#] | Duration [ns] v | Per Call[ns] | Longest[id] |' % groupTitle) ++ print('+-%s-+--------------+--------------------+--------------+-------------+' % groupLine) + + for group in times: + id = str(group[0]).rjust(maxGroupLen) +@@ -94,9 +94,9 @@ def process(stream, groupField): + dura = str(group[1]['duration']).rjust(18) + perCall = str(group[1]['duration'] / group[1]['draws']).rjust(12) + longest = str(group[1]['longest']).rjust(11) +- print "| %s | %s | %s | %s | %s |" % (id, draw, dura, perCall, longest) ++ print("| %s | %s | %s | %s | %s |" % (id, draw, dura, perCall, longest)) + +- print '+-%s-+--------------+--------------------+--------------+-------------+' % groupLine ++ print('+-%s-+--------------+--------------------+--------------+-------------+' % groupLine) + + + def main(): +diff --git a/scripts/retracediff.py b/scripts/retracediff.py +index bb5aa7f5..8105f536 100755 +--- a/scripts/retracediff.py ++++ b/scripts/retracediff.py +@@ -83,12 +83,12 @@ class Retracer: + self.retraceExe, + ] + args + self.args + if self.env: +- for name, value in self.env.iteritems(): ++ for name, value in self.env.items(): + sys.stderr.write('%s=%s ' % (name, value)) + sys.stderr.write(' '.join(cmd) + '\n') + try: + return subprocess.Popen(cmd, env=self.env, stdout=stdout, stderr=NULL) +- except OSError, ex: ++ except OSError as ex: + sys.stderr.write('error: failed to execute %s: %s\n' % (cmd[0], ex.strerror)) + sys.exit(1) + +@@ -160,7 +160,7 @@ def read_pnm(stream): + while line.startswith('#'): + comment += line[1:] + line = stream.readline() +- width, height = map(int, line.strip().split()) ++ width, height = list(map(int, line.strip().split())) + maximum = int(stream.readline().strip()) + if bytesPerChannel == 1: + assert maximum == 255 +diff --git a/scripts/snapdiff.py b/scripts/snapdiff.py +index 59ec870e..b0d5f757 100755 +--- a/scripts/snapdiff.py ++++ b/scripts/snapdiff.py +@@ -40,6 +40,7 @@ from PIL import Image + from PIL import ImageChops + from PIL import ImageEnhance + from PIL import ImageFilter ++from functools import reduce + + + thumbSize = 320 +@@ -50,12 +51,12 @@ class Comparer: + '''Image comparer.''' + + def __init__(self, ref_image, src_image, alpha = False): +- if isinstance(ref_image, basestring): ++ if isinstance(ref_image, str): + self.ref_im = Image.open(ref_image) + else: + self.ref_im = ref_image + +- if isinstance(src_image, basestring): ++ if isinstance(src_image, str): + self.src_im = Image.open(src_image) + else: + self.src_im = src_image +@@ -106,7 +107,7 @@ class Comparer: + # Compute absolute error + + if self.size_mismatch(): +- return sys.maxint ++ return sys.maxsize + + # TODO: this is approximate due to the grayscale conversion + h = self.diff.convert('L').histogram() +diff --git a/scripts/tracediff.py b/scripts/tracediff.py +index f111322a..0cd9c8c6 100755 +--- a/scripts/tracediff.py ++++ b/scripts/tracediff.py +@@ -237,7 +237,7 @@ class BlobReplacer(Rebuilder): + return Blob(len(obj), hash(str(obj))) + + def visitCall(self, call): +- call.args = map(self.visit, call.args) ++ call.args = list(map(self.visit, call.args)) + call.ret = self.visit(call.ret) + + +@@ -312,7 +312,7 @@ class PythonDiffer(Differ): + elif tag == 'equal': + self.equal(alo, ahi, blo, bhi) + else: +- raise ValueError, 'unknown tag %s' % (tag,) ++ raise ValueError('unknown tag %s' % (tag,)) + + def isjunk(self, call): + return call.functionName == 'glGetError' and call.ret in ('GL_NO_ERROR', 0) +@@ -338,12 +338,12 @@ class PythonDiffer(Differ): + elif tag == 'equal': + self.replace_similar(_alo, _ahi, _blo, _bhi) + else: +- raise ValueError, 'unknown tag %s' % (tag,) ++ raise ValueError('unknown tag %s' % (tag,)) + + def replace_similar(self, alo, ahi, blo, bhi): + assert alo < ahi and blo < bhi + assert ahi - alo == bhi - blo +- for i in xrange(0, bhi - blo): ++ for i in range(0, bhi - blo): + self.highlighter.write('| ') + a_call = self.a[alo + i] + b_call = self.b[blo + i] +@@ -355,7 +355,7 @@ class PythonDiffer(Differ): + self.highlighter.write('(') + sep = '' + numArgs = max(len(a_call.args), len(b_call.args)) +- for j in xrange(numArgs): ++ for j in range(numArgs): + self.highlighter.write(sep) + try: + a_argName, a_argVal = a_call.args[j] +@@ -402,7 +402,7 @@ class PythonDiffer(Differ): + def delete(self, alo, ahi, blo, bhi): + assert alo < ahi + assert blo == bhi +- for i in xrange(alo, ahi): ++ for i in range(alo, ahi): + call = self.a[i] + self.highlighter.write('- ') + self.dumpCallNos(call.no, None) +@@ -413,7 +413,7 @@ class PythonDiffer(Differ): + def insert(self, alo, ahi, blo, bhi): + assert alo == ahi + assert blo < bhi +- for i in xrange(blo, bhi): ++ for i in range(blo, bhi): + call = self.b[i] + self.highlighter.write('+ ') + self.dumpCallNos(None, call.no) +@@ -425,7 +425,7 @@ class PythonDiffer(Differ): + return + assert alo < ahi and blo < bhi + assert ahi - alo == bhi - blo +- for i in xrange(0, bhi - blo): ++ for i in range(0, bhi - blo): + self.highlighter.write(' ') + a_call = self.a[alo + i] + b_call = self.b[blo + i] +diff --git a/scripts/unpickle.py b/scripts/unpickle.py +index 334c1a01..86891d29 100755 +--- a/scripts/unpickle.py ++++ b/scripts/unpickle.py +@@ -38,7 +38,7 @@ import optparse + import sys + import time + import re +-import cPickle as pickle ++import pickle as pickle + + + # Same as trace_model.hpp's call flags +@@ -58,7 +58,7 @@ CALL_FLAG_MARKER_POP = (1 << 10) + class Pointer(long): + + def __str__(self): +- if self == 0L: ++ if self == 0: + return 'NULL' + else: + return hex(self).rstrip('L') +@@ -73,7 +73,7 @@ class Visitor: + self.dispatch[type(None)] = self.visitNone + self.dispatch[bool] = self.visitBool + self.dispatch[int] = self.visitInt +- self.dispatch[long] = self.visitInt ++ self.dispatch[int] = self.visitInt + self.dispatch[float] = self.visitFloat + self.dispatch[str] = self.visitStr + self.dispatch[tuple] = self.visitTuple +@@ -140,18 +140,18 @@ class Dumper(Visitor): + return repr(obj) + + def visitTuple(self, obj): +- return '(' + ', '.join(itertools.imap(self.visit, obj)) + ')' ++ return '(' + ', '.join(map(self.visit, obj)) + ')' + + def visitList(self, obj): + if len(obj) == 1: + return '&' + self.visit(obj[0]) +- return '{' + ', '.join(itertools.imap(self.visit, obj)) + '}' ++ return '{' + ', '.join(map(self.visit, obj)) + '}' + + def visitItems(self, items): + return ', '.join(['%s = %s' % (name, self.visit(value)) for name, value in items]) + + def visitDict(self, obj): +- return '{' + self.visitItems(obj.iteritems()) + '}' ++ return '{' + self.visitItems(iter(obj.items())) + '}' + + def visitByteArray(self, obj): + return 'blob(%u)' % len(obj) +@@ -167,7 +167,7 @@ class Hasher(Visitor): + return obj + + def visitIterable(self, obj): +- return tuple(itertools.imap(self.visit, obj)) ++ return tuple(map(self.visit, obj)) + + def visitByteArray(self, obj): + return str(obj) +@@ -268,7 +268,7 @@ class Counter(Unpickler): + def parse(self): + Unpickler.parse(self) + +- functionFrequencies = self.functionFrequencies.items() ++ functionFrequencies = list(self.functionFrequencies.items()) + functionFrequencies.sort(lambda (name1, freq1), (name2, freq2): cmp(freq1, freq2)) + for name, frequency in functionFrequencies: + sys.stdout.write('%8u %s\n' % (frequency, name)) +diff --git a/specs/cglapi.py b/specs/cglapi.py +index 69faeeb4..5d61886f 100644 +--- a/specs/cglapi.py ++++ b/specs/cglapi.py +@@ -29,9 +29,9 @@ http://developer.apple.com/library/mac/#documentation/GraphicsImaging/Reference/ + """ + + +-from stdapi import * +-from glapi import * +-from glapi import glapi ++from .stdapi import * ++from .glapi import * ++from .glapi import glapi + + IOSurfaceRef = Opaque("IOSurfaceRef") + CGLContextObj = Opaque("CGLContextObj") +diff --git a/specs/d2d1.py b/specs/d2d1.py +index dacbea69..9bae43c5 100644 +--- a/specs/d2d1.py ++++ b/specs/d2d1.py +@@ -25,9 +25,9 @@ + ##########################################################################/ + + +-from winapi import * +-from dxgi import DXGI_FORMAT, IDXGISurface +-from dwrite import * ++from .winapi import * ++from .dxgi import DXGI_FORMAT, IDXGISurface ++from .dwrite import * + + + +diff --git a/specs/d3d.py b/specs/d3d.py +index 0dde09f4..4b7244b2 100644 +--- a/specs/d3d.py ++++ b/specs/d3d.py +@@ -25,10 +25,10 @@ + + """d3d.h""" + +-from winapi import * +-from ddraw import * +-from d3dtypes import * +-from d3dcaps import * ++from .winapi import * ++from .ddraw import * ++from .d3dtypes import * ++from .d3dcaps import * + + d3dnextFlags = Flags(DWORD, [ + "D3DNEXT_NEXT", +diff --git a/specs/d3d10.py b/specs/d3d10.py +index 2161a5fd..e22bc230 100644 +--- a/specs/d3d10.py ++++ b/specs/d3d10.py +@@ -24,8 +24,8 @@ + ##########################################################################/ + + +-from dxgi import * +-from d3d10sdklayers import * ++from .dxgi import * ++from .d3d10sdklayers import * + + + HRESULT = MAKE_HRESULT([ +diff --git a/specs/d3d10sdklayers.py b/specs/d3d10sdklayers.py +index aad53f04..82beb721 100644 +--- a/specs/d3d10sdklayers.py ++++ b/specs/d3d10sdklayers.py +@@ -24,7 +24,7 @@ + ##########################################################################/ + + +-from dxgi import * ++from .dxgi import * + + + D3D10_DEBUG_FEATURE = Flags(UINT, [ +diff --git a/specs/d3d11.py b/specs/d3d11.py +index f704b062..0a28caa3 100644 +--- a/specs/d3d11.py ++++ b/specs/d3d11.py +@@ -24,8 +24,8 @@ + ##########################################################################/ + + +-from dxgi import * +-from d3d11sdklayers import * ++from .dxgi import * ++from .d3d11sdklayers import * + + + HRESULT = MAKE_HRESULT([ +diff --git a/specs/d3d11sdklayers.py b/specs/d3d11sdklayers.py +index 907c4b09..97d07750 100644 +--- a/specs/d3d11sdklayers.py ++++ b/specs/d3d11sdklayers.py +@@ -24,7 +24,7 @@ + ##########################################################################/ + + +-from dxgi import * ++from .dxgi import * + + + ID3D11DeviceChild = Interface("ID3D11DeviceChild", IUnknown) +diff --git a/specs/d3d8.py b/specs/d3d8.py +index 2dbf1140..400af498 100644 +--- a/specs/d3d8.py ++++ b/specs/d3d8.py +@@ -25,9 +25,9 @@ + + """d3d8.h""" + +-from winapi import * +-from d3d8types import * +-from d3d8caps import * ++from .winapi import * ++from .d3d8types import * ++from .d3d8caps import * + + + D3DSHADER8 = Blob(Const(DWORD), "_shaderSize(pFunction)") +diff --git a/specs/d3d8caps.py b/specs/d3d8caps.py +index 1af1a19f..b7ee5873 100644 +--- a/specs/d3d8caps.py ++++ b/specs/d3d8caps.py +@@ -25,8 +25,8 @@ + + """d3d8caps.h""" + +-from winapi import * +-from d3d8types import * ++from .winapi import * ++from .d3d8types import * + + D3DCAPS = Flags(DWORD, [ + "D3DCAPS_READ_SCANLINE", +diff --git a/specs/d3d8types.py b/specs/d3d8types.py +index fe58a0cd..a2482328 100644 +--- a/specs/d3d8types.py ++++ b/specs/d3d8types.py +@@ -25,7 +25,7 @@ + + """d3d8types.h""" + +-from winapi import * ++from .winapi import * + + D3DCOLOR = Alias("D3DCOLOR", DWORD) + +diff --git a/specs/d3d9.py b/specs/d3d9.py +index 21015149..68dcaca2 100644 +--- a/specs/d3d9.py ++++ b/specs/d3d9.py +@@ -25,9 +25,9 @@ + + """d3d9.h""" + +-from winapi import * +-from d3d9types import * +-from d3d9caps import * ++from .winapi import * ++from .d3d9types import * ++from .d3d9caps import * + + + D3DSHADER9 = Blob(Const(DWORD), "_shaderSize(pFunction)") +diff --git a/specs/d3d9caps.py b/specs/d3d9caps.py +index b3582879..541263b6 100644 +--- a/specs/d3d9caps.py ++++ b/specs/d3d9caps.py +@@ -25,8 +25,8 @@ + + """d3d9caps.h""" + +-from winapi import * +-from d3d9types import * ++from .winapi import * ++from .d3d9types import * + + D3DVS20CAPS = Flags(DWORD, [ + "D3DVS20CAPS_PREDICATION", +diff --git a/specs/d3d9types.py b/specs/d3d9types.py +index 2545a767..c9847030 100644 +--- a/specs/d3d9types.py ++++ b/specs/d3d9types.py +@@ -26,7 +26,7 @@ + + """d3d9types.h""" + +-from winapi import * ++from .winapi import * + + D3DCOLOR = Alias("D3DCOLOR", DWORD) + +diff --git a/specs/d3dcaps.py b/specs/d3dcaps.py +index 0fa9f1cc..88725067 100644 +--- a/specs/d3dcaps.py ++++ b/specs/d3dcaps.py +@@ -25,8 +25,8 @@ + + """d3dcaps.h""" + +-from winapi import * +-from d3dtypes import * ++from .winapi import * ++from .d3dtypes import * + + D3DTRANSFORMCAPS = Flags(DWORD, [ + "D3DTRANSFORMCAPS_CLIP", +diff --git a/specs/d3dtypes.py b/specs/d3dtypes.py +index e1507975..ba460022 100644 +--- a/specs/d3dtypes.py ++++ b/specs/d3dtypes.py +@@ -25,7 +25,7 @@ + + """d3dtypes.h""" + +-from winapi import * ++from .winapi import * + + D3DVALUE = Float + LPD3DVALUE = Pointer(D3DVALUE) +diff --git a/specs/dcommon.py b/specs/dcommon.py +index 21659a5e..6324db3a 100644 +--- a/specs/dcommon.py ++++ b/specs/dcommon.py +@@ -24,7 +24,7 @@ + ##########################################################################/ + + +-from winapi import * ++from .winapi import * + + + DWRITE_MEASURING_MODE = Enum("DWRITE_MEASURING_MODE", [ +diff --git a/specs/dcomp.py b/specs/dcomp.py +new file mode 100644 +index 00000000..b139a89e +--- /dev/null ++++ b/specs/dcomp.py +@@ -0,0 +1,303 @@ ++########################################################################## ++# ++# Copyright 2009-2016 VMware, Inc. ++# All Rights Reserved. ++# ++# Permission is hereby granted, free of charge, to any person obtaining a copy ++# of this software and associated documentation files (the "Software"), to deal ++# in the Software without restriction, including without limitation the rights ++# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell ++# copies of the Software, and to permit persons to whom the Software is ++# furnished to do so, subject to the following conditions: ++# ++# The above copyright notice and this permission notice shall be included in ++# all copies or substantial portions of the Software. ++# ++# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE ++# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER ++# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ++# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN ++# THE SOFTWARE. ++# ++##########################################################################/ ++ ++ ++from .dxgi import * ++from .d2d1 import D2D_MATRIX_3X2_F, D2D_RECT_F ++from .d3d9types import D3DMATRIX ++from .d2d1 import D2D1_COMPOSITE_MODE ++ ++DCOMPOSITION_BITMAP_INTERPOLATION_MODE = Enum('DCOMPOSITION_BITMAP_INTERPOLATION_MODE', [ ++ 'DCOMPOSITION_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR', ++ 'DCOMPOSITION_BITMAP_INTERPOLATION_MODE_LINEAR', ++ 'DCOMPOSITION_BITMAP_INTERPOLATION_MODE_INHERIT', ++]) ++ ++DCOMPOSITION_BORDER_MODE = Enum('DCOMPOSITION_BORDER_MODE', [ ++ 'DCOMPOSITION_BORDER_MODE_SOFT', ++ 'DCOMPOSITION_BORDER_MODE_HARD', ++ 'DCOMPOSITION_BORDER_MODE_INHERIT', ++]) ++ ++DCOMPOSITION_COMPOSITE_MODE = Enum('DCOMPOSITION_COMPOSITE_MODE', [ ++ 'DCOMPOSITION_COMPOSITE_MODE_SOURCE_OVER', ++ 'DCOMPOSITION_COMPOSITE_MODE_DESTINATION_INVERT', ++ 'DCOMPOSITION_COMPOSITE_MODE_INHERIT', ++]) ++ ++DCOMPOSITION_FRAME_STATISTICS = Struct('DCOMPOSITION_FRAME_STATISTICS', [ ++ (LARGE_INTEGER, 'lastFrameTime'), ++ (DXGI_RATIONAL, 'currentCompositionRate'), ++ (LARGE_INTEGER, 'currentTime'), ++ (LARGE_INTEGER, 'timeFrequency'), ++ (LARGE_INTEGER, 'nextEstimatedFrameTime'), ++]) ++ ++COMPOSITIONOBJECT = Flags(DWORD, [ ++ 'COMPOSITIONOBJECT_ALL_ACCESS', # 0x0003 ++ 'COMPOSITIONOBJECT_READ', # 0x0001 ++ 'COMPOSITIONOBJECT_WRITE', # 0x0002 ++]) ++ ++IDCompositionAnimation = Interface('IDCompositionAnimation', IUnknown) ++IDCompositionDevice = Interface('IDCompositionDevice', IUnknown) ++IDCompositionTarget = Interface('IDCompositionTarget', IUnknown) ++IDCompositionVisual = Interface('IDCompositionVisual', IUnknown) ++IDCompositionEffect = Interface('IDCompositionEffect', IUnknown) ++IDCompositionEffectGroup = Interface('IDCompositionEffectGroup', IDCompositionEffect) ++IDCompositionTransform3D = Interface('IDCompositionTransform3D', IDCompositionEffect) ++IDCompositionTransform = Interface('IDCompositionTransform', IDCompositionTransform3D) ++IDCompositionTranslateTransform = Interface('IDCompositionTranslateTransform', IDCompositionTransform) ++IDCompositionTranslateTransform3D = Interface('IDCompositionTranslateTransform3D', IDCompositionTransform3D) ++IDCompositionScaleTransform = Interface('IDCompositionScaleTransform', IDCompositionTransform) ++IDCompositionScaleTransform3D = Interface('IDCompositionScaleTransform3D', IDCompositionTransform3D) ++IDCompositionRotateTransform = Interface('IDCompositionRotateTransform', IDCompositionTransform) ++IDCompositionRotateTransform3D = Interface('IDCompositionRotateTransform3D', IDCompositionTransform3D) ++IDCompositionSkewTransform = Interface('IDCompositionSkewTransform', IDCompositionTransform) ++IDCompositionMatrixTransform = Interface('IDCompositionMatrixTransform', IDCompositionTransform) ++IDCompositionMatrixTransform3D = Interface('IDCompositionMatrixTransform3D', IDCompositionTransform3D) ++IDCompositionClip = Interface('IDCompositionClip', IUnknown) ++IDCompositionRectangleClip = Interface('IDCompositionRectangleClip', IDCompositionClip) ++IDCompositionSurface = Interface('IDCompositionSurface', IUnknown) ++IDCompositionVirtualSurface = Interface('IDCompositionVirtualSurface', IDCompositionSurface) ++ ++IDCompositionAnimation.methods += [ ++ StdMethod(HRESULT, 'Reset', []), ++ StdMethod(HRESULT, 'SetAbsoluteBeginTime', [(LARGE_INTEGER, 'beginTime')]), ++ StdMethod(HRESULT, 'AddCubic', [(Double, 'beginOffset'), (Float, 'constantCoefficient'), (Float, 'linearCoefficient'), (Float, 'quadraticCoefficient'), (Float, 'cubicCoefficient')]), ++ StdMethod(HRESULT, 'AddSinusoidal', [(Double, 'beginOffset'), (Float, 'bias'), (Float, 'amplitude'), (Float, 'frequency'), (Float, 'phase')]), ++ StdMethod(HRESULT, 'AddRepeat', [(Double, 'beginOffset'), (Double, 'durationToRepeat')]), ++ StdMethod(HRESULT, 'End', [(Double, 'endOffset'), (Float, 'endValue')]), ++] ++ ++IDCompositionDevice.methods += [ ++ StdMethod(HRESULT, 'Commit', []), ++ StdMethod(HRESULT, 'WaitForCommitCompletion', []), ++ StdMethod(HRESULT, 'GetFrameStatistics', [Out(Pointer(DCOMPOSITION_FRAME_STATISTICS), 'statistics')]), ++ StdMethod(HRESULT, 'CreateTargetForHwnd', [(HWND, 'hwnd'), (BOOL, 'topmost'), Out(Pointer(ObjPointer(IDCompositionTarget)), 'target')]), ++ StdMethod(HRESULT, 'CreateVisual', [Out(Pointer(ObjPointer(IDCompositionVisual)), 'visual')]), ++ StdMethod(HRESULT, 'CreateSurface', [(UINT, 'width'), (UINT, 'height'), (DXGI_FORMAT, 'pixelFormat'), (DXGI_ALPHA_MODE, 'alphaMode'), Out(Pointer(ObjPointer(IDCompositionSurface)), 'surface')]), ++ StdMethod(HRESULT, 'CreateVirtualSurface', [(UINT, 'initialWidth'), (UINT, 'initialHeight'), (DXGI_FORMAT, 'pixelFormat'), (DXGI_ALPHA_MODE, 'alphaMode'), Out(Pointer(ObjPointer(IDCompositionVirtualSurface)), 'virtualSurface')]), ++ StdMethod(HRESULT, 'CreateSurfaceFromHandle', [(HANDLE, 'handle'), Out(Pointer(ObjPointer(IUnknown)), 'surface')]), ++ StdMethod(HRESULT, 'CreateSurfaceFromHwnd', [(HWND, 'hwnd'), Out(Pointer(ObjPointer(IUnknown)), 'surface')]), ++ StdMethod(HRESULT, 'CreateTranslateTransform', [Out(Pointer(ObjPointer(IDCompositionTranslateTransform)), 'translateTransform')]), ++ StdMethod(HRESULT, 'CreateScaleTransform', [Out(Pointer(ObjPointer(IDCompositionScaleTransform)), 'scaleTransform')]), ++ StdMethod(HRESULT, 'CreateRotateTransform', [Out(Pointer(ObjPointer(IDCompositionRotateTransform)), 'rotateTransform')]), ++ StdMethod(HRESULT, 'CreateSkewTransform', [Out(Pointer(ObjPointer(IDCompositionSkewTransform)), 'skewTransform')]), ++ StdMethod(HRESULT, 'CreateMatrixTransform', [Out(Pointer(ObjPointer(IDCompositionMatrixTransform)), 'matrixTransform')]), ++ StdMethod(HRESULT, 'CreateTransformGroup', [(Array(ObjPointer(IDCompositionTransform), 'elements'), 'transforms'), (UINT, 'elements'), Out(Pointer(ObjPointer(IDCompositionTransform)), 'transformGroup')]), ++ StdMethod(HRESULT, 'CreateTranslateTransform3D', [Out(Pointer(ObjPointer(IDCompositionTranslateTransform3D)), 'translateTransform3D')]), ++ StdMethod(HRESULT, 'CreateScaleTransform3D', [Out(Pointer(ObjPointer(IDCompositionScaleTransform3D)), 'scaleTransform3D')]), ++ StdMethod(HRESULT, 'CreateRotateTransform3D', [Out(Pointer(ObjPointer(IDCompositionRotateTransform3D)), 'rotateTransform3D')]), ++ StdMethod(HRESULT, 'CreateMatrixTransform3D', [Out(Pointer(ObjPointer(IDCompositionMatrixTransform3D)), 'matrixTransform3D')]), ++ StdMethod(HRESULT, 'CreateTransform3DGroup', [(Array(ObjPointer(IDCompositionTransform3D), 'elements'), 'transforms3D'), (UINT, 'elements'), Out(Pointer(ObjPointer(IDCompositionTransform3D)), 'transform3DGroup')]), ++ StdMethod(HRESULT, 'CreateEffectGroup', [Out(Pointer(ObjPointer(IDCompositionEffectGroup)), 'effectGroup')]), ++ StdMethod(HRESULT, 'CreateRectangleClip', [Out(Pointer(ObjPointer(IDCompositionRectangleClip)), 'clip')]), ++ StdMethod(HRESULT, 'CreateAnimation', [Out(Pointer(ObjPointer(IDCompositionAnimation)), 'animation')]), ++ StdMethod(HRESULT, 'CheckDeviceState', [Out(Pointer(BOOL), 'pfValid')]), ++] ++ ++IDCompositionTarget.methods += [ ++ StdMethod(HRESULT, 'SetRoot', [(ObjPointer(IDCompositionVisual), 'visual')]), ++] ++ ++IDCompositionVisual.methods += [ ++ StdMethod(HRESULT, 'SetOffsetX', [(Float, 'offsetX')], overloaded=True), ++ StdMethod(HRESULT, 'SetOffsetX', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetOffsetY', [(Float, 'offsetY')], overloaded=True), ++ StdMethod(HRESULT, 'SetOffsetY', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetTransform', [(Reference(Const(D2D_MATRIX_3X2_F)), 'matrix')], overloaded=True), ++ StdMethod(HRESULT, 'SetTransform', [(ObjPointer(IDCompositionTransform), 'transform')], overloaded=True), ++ StdMethod(HRESULT, 'SetTransformParent', [(ObjPointer(IDCompositionVisual), 'visual')]), ++ StdMethod(HRESULT, 'SetEffect', [(ObjPointer(IDCompositionEffect), 'effect')]), ++ StdMethod(HRESULT, 'SetBitmapInterpolationMode', [(DCOMPOSITION_BITMAP_INTERPOLATION_MODE, 'interpolationMode')]), ++ StdMethod(HRESULT, 'SetBorderMode', [(DCOMPOSITION_BORDER_MODE, 'borderMode')]), ++ StdMethod(HRESULT, 'SetClip', [(Reference(Const(D2D_RECT_F)), 'rect')], overloaded=True), ++ StdMethod(HRESULT, 'SetClip', [(ObjPointer(IDCompositionClip), 'clip')], overloaded=True), ++ StdMethod(HRESULT, 'SetContent', [(ObjPointer(IUnknown), 'content')]), ++ StdMethod(HRESULT, 'AddVisual', [(ObjPointer(IDCompositionVisual), 'visual'), (BOOL, 'insertAbove'), (ObjPointer(IDCompositionVisual), 'referenceVisual')]), ++ StdMethod(HRESULT, 'RemoveVisual', [(ObjPointer(IDCompositionVisual), 'visual')]), ++ StdMethod(HRESULT, 'RemoveAllVisuals', []), ++ StdMethod(HRESULT, 'SetCompositeMode', [(DCOMPOSITION_COMPOSITE_MODE, 'compositeMode')]), ++] ++ ++IDCompositionTransform.methods += [ ++] ++ ++IDCompositionTransform3D.methods += [ ++] ++ ++IDCompositionTranslateTransform.methods += [ ++ StdMethod(HRESULT, 'SetOffsetX', [(Float, 'offsetX')], overloaded=True), ++ StdMethod(HRESULT, 'SetOffsetX', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetOffsetY', [(Float, 'offsetY')], overloaded=True), ++ StdMethod(HRESULT, 'SetOffsetY', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++] ++ ++IDCompositionTranslateTransform3D.methods += [ ++ StdMethod(HRESULT, 'SetOffsetX', [(Float, 'offsetX')], overloaded=True), ++ StdMethod(HRESULT, 'SetOffsetX', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetOffsetY', [(Float, 'offsetY')], overloaded=True), ++ StdMethod(HRESULT, 'SetOffsetY', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetOffsetZ', [(Float, 'offsetZ')], overloaded=True), ++ StdMethod(HRESULT, 'SetOffsetZ', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++] ++ ++IDCompositionScaleTransform.methods += [ ++ StdMethod(HRESULT, 'SetScaleX', [(Float, 'scaleX')], overloaded=True), ++ StdMethod(HRESULT, 'SetScaleX', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetScaleY', [(Float, 'scaleY')], overloaded=True), ++ StdMethod(HRESULT, 'SetScaleY', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterX', [(Float, 'centerX')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterX', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterY', [(Float, 'centerY')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterY', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++] ++ ++IDCompositionScaleTransform3D.methods += [ ++ StdMethod(HRESULT, 'SetScaleX', [(Float, 'scaleX')], overloaded=True), ++ StdMethod(HRESULT, 'SetScaleX', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetScaleY', [(Float, 'scaleY')], overloaded=True), ++ StdMethod(HRESULT, 'SetScaleY', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetScaleZ', [(Float, 'scaleZ')], overloaded=True), ++ StdMethod(HRESULT, 'SetScaleZ', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterX', [(Float, 'centerX')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterX', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterY', [(Float, 'centerY')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterY', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterZ', [(Float, 'centerZ')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterZ', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++] ++ ++IDCompositionRotateTransform.methods += [ ++ StdMethod(HRESULT, 'SetAngle', [(Float, 'angle')], overloaded=True), ++ StdMethod(HRESULT, 'SetAngle', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterX', [(Float, 'centerX')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterX', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterY', [(Float, 'centerY')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterY', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++] ++ ++IDCompositionRotateTransform3D.methods += [ ++ StdMethod(HRESULT, 'SetAngle', [(Float, 'angle')], overloaded=True), ++ StdMethod(HRESULT, 'SetAngle', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetAxisX', [(Float, 'axisX')], overloaded=True), ++ StdMethod(HRESULT, 'SetAxisX', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetAxisY', [(Float, 'axisY')], overloaded=True), ++ StdMethod(HRESULT, 'SetAxisY', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetAxisZ', [(Float, 'axisZ')], overloaded=True), ++ StdMethod(HRESULT, 'SetAxisZ', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterX', [(Float, 'centerX')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterX', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterY', [(Float, 'centerY')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterY', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterZ', [(Float, 'centerZ')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterZ', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++] ++ ++IDCompositionSkewTransform.methods += [ ++ StdMethod(HRESULT, 'SetAngleX', [(Float, 'angleX')], overloaded=True), ++ StdMethod(HRESULT, 'SetAngleX', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetAngleY', [(Float, 'angleY')], overloaded=True), ++ StdMethod(HRESULT, 'SetAngleY', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterX', [(Float, 'centerX')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterX', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterY', [(Float, 'centerY')], overloaded=True), ++ StdMethod(HRESULT, 'SetCenterY', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++] ++ ++IDCompositionMatrixTransform.methods += [ ++ StdMethod(HRESULT, 'SetMatrix', [(Reference(Const(D2D_MATRIX_3X2_F)), 'matrix')]), ++ StdMethod(HRESULT, 'SetMatrixElement', [(Int, 'row'), (Int, 'column'), (Float, 'value')], overloaded=True), ++ StdMethod(HRESULT, 'SetMatrixElement', [(Int, 'row'), (Int, 'column'), (ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++] ++ ++IDCompositionMatrixTransform3D.methods += [ ++ StdMethod(HRESULT, 'SetMatrix', [(Reference(Const(D3DMATRIX)), 'matrix')]), ++ StdMethod(HRESULT, 'SetMatrixElement', [(Int, 'row'), (Int, 'column'), (Float, 'value')], overloaded=True), ++ StdMethod(HRESULT, 'SetMatrixElement', [(Int, 'row'), (Int, 'column'), (ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++] ++ ++IDCompositionEffect.methods += [ ++] ++ ++IDCompositionEffectGroup.methods += [ ++ StdMethod(HRESULT, 'SetOpacity', [(Float, 'opacity')], overloaded=True), ++ StdMethod(HRESULT, 'SetOpacity', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetTransform3D', [(ObjPointer(IDCompositionTransform3D), 'transform3D')]), ++] ++ ++IDCompositionClip.methods += [ ++] ++ ++IDCompositionRectangleClip.methods += [ ++ StdMethod(HRESULT, 'SetLeft', [(Float, 'left')], overloaded=True), ++ StdMethod(HRESULT, 'SetLeft', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetTop', [(Float, 'top')], overloaded=True), ++ StdMethod(HRESULT, 'SetTop', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetRight', [(Float, 'right')], overloaded=True), ++ StdMethod(HRESULT, 'SetRight', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetBottom', [(Float, 'bottom')], overloaded=True), ++ StdMethod(HRESULT, 'SetBottom', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetTopLeftRadiusX', [(Float, 'radius')], overloaded=True), ++ StdMethod(HRESULT, 'SetTopLeftRadiusX', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetTopLeftRadiusY', [(Float, 'radius')], overloaded=True), ++ StdMethod(HRESULT, 'SetTopLeftRadiusY', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetTopRightRadiusX', [(Float, 'radius')], overloaded=True), ++ StdMethod(HRESULT, 'SetTopRightRadiusX', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetTopRightRadiusY', [(Float, 'radius')], overloaded=True), ++ StdMethod(HRESULT, 'SetTopRightRadiusY', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetBottomLeftRadiusX', [(Float, 'radius')], overloaded=True), ++ StdMethod(HRESULT, 'SetBottomLeftRadiusX', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetBottomLeftRadiusY', [(Float, 'radius')], overloaded=True), ++ StdMethod(HRESULT, 'SetBottomLeftRadiusY', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetBottomRightRadiusX', [(Float, 'radius')], overloaded=True), ++ StdMethod(HRESULT, 'SetBottomRightRadiusX', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++ StdMethod(HRESULT, 'SetBottomRightRadiusY', [(Float, 'radius')], overloaded=True), ++ StdMethod(HRESULT, 'SetBottomRightRadiusY', [(ObjPointer(IDCompositionAnimation), 'animation')], overloaded=True), ++] ++ ++IDCompositionSurface.methods += [ ++ # XXX: riid might be ID2D1DeviceContext ++ StdMethod(HRESULT, 'BeginDraw', [(Pointer(Const(RECT)), 'updateRect'), (REFIID, 'iid'), Out(Pointer(ObjPointer(Void)), 'updateObject'), Out(Pointer(POINT), 'updateOffset')]), ++ StdMethod(HRESULT, 'EndDraw', []), ++ StdMethod(HRESULT, 'SuspendDraw', []), ++ StdMethod(HRESULT, 'ResumeDraw', []), ++ StdMethod(HRESULT, 'Scroll', [(Pointer(Const(RECT)), 'scrollRect'), (Pointer(Const(RECT)), 'clipRect'), (Int, 'offsetX'), (Int, 'offsetY')]), ++] ++ ++IDCompositionVirtualSurface.methods += [ ++ StdMethod(HRESULT, 'Resize', [(UINT, 'width'), (UINT, 'height')]), ++ StdMethod(HRESULT, 'Trim', [(Array(Const(RECT), 'count'), 'rectangles'), (UINT, 'count')]), ++] ++ ++dcomp = Module('dcomp') ++dcomp.addFunctions([ ++ StdFunction(HRESULT, 'DCompositionCreateDevice', [(ObjPointer(IDXGIDevice), 'dxgiDevice'), (REFIID, 'iid'), Out(Pointer(ObjPointer(Void)), 'dcompositionDevice')]), ++ StdFunction(HRESULT, 'DCompositionCreateSurfaceHandle', [(COMPOSITIONOBJECT, 'desiredAccess'), (Pointer(SECURITY_ATTRIBUTES), 'securityAttributes'), Out(Pointer(HANDLE), 'surfaceHandle')]), ++]) ++dcomp.addInterfaces([ ++ IDCompositionDevice, ++]) +diff --git a/specs/ddraw.py b/specs/ddraw.py +index 99f542fe..5df48be0 100644 +--- a/specs/ddraw.py ++++ b/specs/ddraw.py +@@ -25,7 +25,7 @@ + + """ddraw.h""" + +-from winapi import * ++from .winapi import * + + DirectDrawOptSurfaceDescFlags = Flags(DWORD, [ + "DDOSD_GUID", +diff --git a/specs/debug.py b/specs/debug.py +index 0a004741..6ef80f64 100644 +--- a/specs/debug.py ++++ b/specs/debug.py +@@ -49,7 +49,7 @@ def excepthook(type, value, tb): + import traceback, pdb + # we are NOT in interactive mode, print the exception... + traceback.print_exception(type, value, tb) +- print ++ print() + # ...then start the debugger in post-mortem mode. + pdb.pm() + +diff --git a/specs/dwrite.py b/specs/dwrite.py +index 60e5034c..be273f81 100644 +--- a/specs/dwrite.py ++++ b/specs/dwrite.py +@@ -24,8 +24,8 @@ + ##########################################################################/ + + +-from winapi import * +-from dcommon import * ++from .winapi import * ++from .dcommon import * + + + ID2D1SimplifiedGeometrySink = Interface("ID2D1SimplifiedGeometrySink", IUnknown) +diff --git a/specs/dxgi.py b/specs/dxgi.py +index 0e880548..040f3bc4 100644 +--- a/specs/dxgi.py ++++ b/specs/dxgi.py +@@ -25,7 +25,7 @@ + ##########################################################################/ + + +-from winapi import * ++from .winapi import * + + + DXGI_FORMAT = Enum("DXGI_FORMAT", [ +diff --git a/specs/dxva2.py b/specs/dxva2.py +index 3936afac..65f5f0c0 100644 +--- a/specs/dxva2.py ++++ b/specs/dxva2.py +@@ -24,7 +24,7 @@ + ##########################################################################/ + + +-from d3d9 import * ++from .d3d9 import * + + + HRESULT = MAKE_HRESULT(errors = [ +diff --git a/specs/eglapi.py b/specs/eglapi.py +index 8379e45e..e1edff06 100644 +--- a/specs/eglapi.py ++++ b/specs/eglapi.py +@@ -26,9 +26,9 @@ + """EGL API description.""" + + +-from stdapi import * +-from gltypes import * +-from eglenum import * ++from .stdapi import * ++from .gltypes import * ++from .eglenum import * + + EGLNativeDisplayType = Opaque("EGLNativeDisplayType") + EGLNativeWindowType = Opaque("EGLNativeWindowType") +diff --git a/specs/eglenum.py b/specs/eglenum.py +index 8b10868d..e6290fb2 100644 +--- a/specs/eglenum.py ++++ b/specs/eglenum.py +@@ -28,7 +28,7 @@ + """EGL enum description""" + + +-from stdapi import * ++from .stdapi import * + + # Most of the following content was produced in a semi-automated fashion by + # the scripts/eglenum.sed sed script. +diff --git a/specs/glapi.py b/specs/glapi.py +index c0e92b3c..8d20052e 100644 +--- a/specs/glapi.py ++++ b/specs/glapi.py +@@ -34,9 +34,9 @@ corner cases correctly. + """ + + +-from stdapi import * +-from gltypes import * +-import glparams ++from .stdapi import * ++from .gltypes import * ++from . import glparams + + + def GlFunction(*args, **kwargs): +diff --git a/specs/glparams.py b/specs/glparams.py +index 1bed8a6b..5a036975 100644 +--- a/specs/glparams.py ++++ b/specs/glparams.py +@@ -27,9 +27,9 @@ + '''Describe GL parameters.''' + + +-from stdapi import * ++from .stdapi import * + +-from gltypes import * ++from .gltypes import * + + + # Shorthands for the types +diff --git a/specs/gltypes.py b/specs/gltypes.py +index a9ffc4a1..631eb868 100644 +--- a/specs/gltypes.py ++++ b/specs/gltypes.py +@@ -29,7 +29,7 @@ + + import platform + +-from stdapi import * ++from .stdapi import * + + + GLboolean = Enum("GLboolean", [ +diff --git a/specs/glxapi.py b/specs/glxapi.py +index 0d3cd969..f4182799 100644 +--- a/specs/glxapi.py ++++ b/specs/glxapi.py +@@ -26,8 +26,8 @@ + """GLX API description.""" + + +-from stdapi import * +-from glapi import * ++from .stdapi import * ++from .glapi import * + + VisualID = Alias("VisualID", UInt32) + Display = Opaque("Display *") +diff --git a/specs/scripts/c2api.py b/specs/scripts/c2api.py +index 7deb2955..b8aaa81d 100755 +--- a/specs/scripts/c2api.py ++++ b/specs/scripts/c2api.py +@@ -122,7 +122,7 @@ class DeclParser: + self.consume() + type = 'Pointer(%s)' % type + name = self.consume() +- print '%s = Alias("%s", %s)' % (name, name, type) ++ print('%s = Alias("%s", %s)' % (name, name, type)) + if self.match(','): + self.consume() + else: +@@ -136,7 +136,7 @@ class DeclParser: + name = self.consume() + self.consume('{') + +- print '%s = Enum("%s", [' % (name, name) ++ print('%s = Enum("%s", [' % (name, name)) + + #value = 0 + while self.lookahead() != '}': +@@ -148,12 +148,12 @@ class DeclParser: + self.consume(',') + tags = self.parse_tags() + #print ' "%s",\t# %s' % (name, value) +- print ' "%s",' % (name,) ++ print(' "%s",' % (name,)) + #value += 1 + self.consume('}') + +- print '])' +- print ++ print('])') ++ print() + + def parse_value(self, ref_token, constructor): + self.consume(ref_token) +@@ -161,14 +161,14 @@ class DeclParser: + name = self.consume() + self.consume('{') + +- print '%s = %s(%s, [' % (name, constructor, type) ++ print('%s = %s(%s, [' % (name, constructor, type)) + + while self.lookahead() != '}': + name, value = self.parse_define() + self.consume('}') + +- print '])' +- print ++ print('])') ++ print() + + def parse_define(self): + self.consume('#') +@@ -176,18 +176,18 @@ class DeclParser: + name = self.consume() + value = self.consume() + #print ' "%s",\t# %s' % (name, value) +- print ' "%s",' % (name,) ++ print(' "%s",' % (name,)) + return name, value + + def parse_struct(self): + self.consume('struct') + name = self.consume() + +- print '%s = Struct("%s", [' % (name, name) ++ print('%s = Struct("%s", [' % (name, name)) + for type, name in self.parse_members(): +- print ' (%s, "%s"),' % (type, name) +- print '])' +- print ++ print(' (%s, "%s"),' % (type, name)) ++ print('])') ++ print() + + def parse_union(self): + self.consume('union') +@@ -226,8 +226,8 @@ class DeclParser: + base = self.consume() + self.consume('{') + +- print '%s = Interface("%s", %s)' % (name, name, base) +- print '%s.methods += [' % (name,) ++ print('%s = Interface("%s", %s)' % (name, name, base)) ++ print('%s.methods += [' % (name,)) + + while self.lookahead() != '}': + if self.lookahead() in ('public', 'private'): +@@ -238,8 +238,8 @@ class DeclParser: + self.consume(';') + self.consume('}') + +- print ']' +- print ++ print(']') ++ print() + + def parse_prototype(self, creator = 'Function'): + if self.match('extern', 'virtual'): +@@ -275,7 +275,7 @@ class DeclParser: + self.consume() + self.consume('0') + +- print ' %s(%s, "%s", [%s]%s),' % (creator, ret, name, ', '.join(args), extra) ++ print(' %s(%s, "%s", [%s]%s),' % (creator, ret, name, ', '.join(args), extra)) + + def parse_arg(self): + tags = self.parse_tags() +@@ -404,8 +404,8 @@ class DeclParser: + type = 'S' + type + elif short: + type = 'Short' +- elif long: +- type = 'Long' * long ++ elif int: ++ type = 'Long' * int + else: + type = 'Int' + if unsigned: +diff --git a/specs/scripts/cxx2api.py b/specs/scripts/cxx2api.py +new file mode 100755 +index 00000000..9720615d +--- /dev/null ++++ b/specs/scripts/cxx2api.py +@@ -0,0 +1,488 @@ ++#!/usr/bin/env python ++ ++ ++ ++copyright = ''' ++########################################################################## ++# ++# Copyright 2009-2016 VMware, Inc. ++# All Rights Reserved. ++# ++# Permission is hereby granted, free of charge, to any person obtaining a copy ++# of this software and associated documentation files (the "Software"), to deal ++# in the Software without restriction, including without limitation the rights ++# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell ++# copies of the Software, and to permit persons to whom the Software is ++# furnished to do so, subject to the following conditions: ++# ++# The above copyright notice and this permission notice shall be included in ++# all copies or substantial portions of the Software. ++# ++# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE ++# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER ++# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ++# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN ++# THE SOFTWARE. ++# ++##########################################################################/ ++''' ++ ++ ++# ++# Generates API specs from headers using castxml/pygccxml. ++# ++# Usage: ++# ++# sudo apt-get install castxml mingw-w64-i686-dev ++# pip install 'pygccxml==1.9.1' ++# python specs/scripts/cxx2api.py -Idxsdk/Include -DD2D_USE_C_DEFINITIONS dcomp.h dcomptypes.h dcompanimation.h ++# ++# See also: ++# - http://pygccxml.readthedocs.org/en/develop/index.html ++# - https://github.com/CastXML/CastXML/blob/master/doc/manual/castxml.1.rst ++# ++ ++import os.path ++import sys ++import io as StringIO ++import subprocess ++ ++from pygccxml import utils ++from pygccxml import parser ++from pygccxml import declarations ++ ++from pygccxml.declarations import algorithm ++from pygccxml.declarations import decl_visitor ++from pygccxml.declarations import type_traits ++from pygccxml.declarations import type_visitor ++ ++ ++class decl_dumper_t(decl_visitor.decl_visitor_t): ++ ++ def __init__(self, decl = None): ++ decl_visitor.decl_visitor_t.__init__(self) ++ self.decl = decl ++ self.result = None ++ ++ def clone(self): ++ return decl_dumper_t(self.decl) ++ ++ def visit_class(self): ++ class_ = self.decl ++ assert class_.class_type in ('struct', 'union') ++ self.result = class_.name ++ ++ def visit_class_declaration(self): ++ class_ = self.decl ++ self.result = class_.name ++ ++ def visit_typedef(self): ++ typedef = self.decl ++ self.result = typedef.name ++ ++ def visit_enumeration(self): ++ self.result = self.decl.name ++ ++ ++def dump_decl(decl): ++ visitor = decl_dumper_t(decl) ++ algorithm.apply_visitor(visitor, decl) ++ return visitor.result ++ ++ ++class type_dumper_t(type_visitor.type_visitor_t): ++ ++ def __init__(self, type): ++ type_visitor.type_visitor_t.__init__(self) ++ self.type = type ++ self.result = None ++ ++ def clone(self): ++ return type_dumper_t(self.type) ++ ++ def visit_void(self): ++ self.result = 'Void' ++ ++ def visit_char(self): ++ self.result = 'Char' ++ ++ def visit_unsigned_char(self): ++ self.result = 'UChar' ++ ++ def visit_signed_char(self): ++ self.result = 'SChar' ++ ++ def visit_wchar(self): ++ raise NotImplementedError ++ ++ def visit_short_int(self): ++ self.result = 'Short' ++ ++ def visit_short_unsigned_int(self): ++ self.result = 'UShort' ++ ++ def visit_bool(self): ++ raise NotImplementedError ++ ++ def visit_int(self): ++ self.result = 'Int' ++ ++ def visit_unsigned_int(self): ++ self.result = 'UInt' ++ ++ def visit_long_int(self): ++ self.result = 'Long' ++ ++ def visit_long_unsigned_int(self): ++ self.result = 'ULong' ++ ++ def visit_long_long_int(self): ++ self.result = 'LongLong' ++ ++ def visit_long_long_unsigned_int(self): ++ self.result = 'ULongLong' ++ ++ def visit_float(self): ++ self.result = "Float" ++ ++ def visit_double(self): ++ self.result = "Double" ++ ++ def visit_array(self): ++ base_type = dump_type(self.type.base) ++ length = self.type.size ++ try: ++ int(length) ++ except ValueError: ++ length = '"%s"' % length ++ self.result = 'Array(%s, %s)' % (base_type, length) ++ ++ def visit_pointer(self): ++ base_type = dump_type(self.type.base) ++ # TODO: Use ObjPointer where appropriate ++ #if isinstance(self.type.base, declarations.cpptypes.declarated_t): ++ # decl = self.type.base.declaration ++ # if isinstance(decl, declarations.typedef.typedef_t): ++ # print(decl.type, type(decl.type)) ++ # if isinstance(decl, declarations.class_declaration.class_t): ++ # if decl.public_members: ++ # self.result = 'ObjPointer(%s)' % decl.name ++ # return ++ # if isinstance(decl, declarations.class_declaration.class_declaration_t): ++ # if decl.public_members: ++ # self.result = 'ObjPointer(%s)' % decl.name ++ # return ++ if base_type.startswith('IDComposition') or \ ++ base_type.startswith('IDXGI') or \ ++ base_type == 'IUnknown': ++ self.result = 'ObjPointer(%s)' % base_type ++ return ++ self.result = 'Pointer(%s)' % base_type ++ ++ def visit_reference(self): ++ base_type = dump_type(self.type.base) ++ if base_type == 'Const(IID)': ++ self.result = 'REFIID' ++ elif base_type == 'Const(GUID)': ++ self.result = 'REFGUID' ++ else: ++ self.result = 'Reference(%s)' % base_type ++ ++ def visit_const(self): ++ self.result = 'Const(%s)' % dump_type(self.type.base) ++ ++ def visit_declarated(self): ++ decl = self.type.declaration ++ self.result = dump_decl(decl) ++ ++ def visit_free_function_type(self): ++ self.result = 'Opaque("%s")' % self.type ++ ++ ++def dump_type(type): ++ visitor = type_dumper_t(type) ++ algorithm.apply_visitor(visitor, type) ++ # XXX: RECT becomes tagRECT somehow ++ if visitor.result == 'tagRECT': ++ return 'RECT' ++ return visitor.result ++ ++ ++def is_interface(class_): ++ if not class_.name.startswith('I'): ++ return ++ if len(class_.bases) != 1: ++ return False ++ # TODO: Ensure interface derives from IUnknown ++ return True ++ ++ ++class decl2_dumper_t(decl_visitor.decl_visitor_t): ++ ++ def __init__(self, name): ++ decl_visitor.decl_visitor_t.__init__(self) ++ ++ self.name = name ++ ++ # The current declaration ++ self.decl = None ++ ++ self.interfaces = StringIO.StringIO() ++ self.methods = StringIO.StringIO() ++ self.functions = StringIO.StringIO() ++ ++ def start(self): ++ print(copyright.strip()) ++ print() ++ print() ++ print(r'from winapi import *') ++ print() ++ ++ def finish(self): ++ sys.stdout.write(self.interfaces.getvalue()) ++ sys.stdout.write('\n') ++ sys.stdout.write(self.methods.getvalue()) ++ ++ name = self.name ++ sys.stdout.write('%s = Module(%r)\n' % (name, name)) ++ sys.stdout.write('%s.addFunctions([\n' % (name,)) ++ sys.stdout.write(self.functions.getvalue()) ++ sys.stdout.write('])\n\n') ++ ++ def clone(self): ++ return decl_dumper_t(self.decl) ++ ++ def visit_class(self): ++ class_ = self.decl ++ assert class_.class_type in ('struct', 'union') ++ ++ if is_interface(class_): ++ self.visit_interface() ++ elif class_.name != '': ++ self.visit_struct(class_.name, class_) ++ ++ def visit_struct(self, decl_name, decl): ++ struct = decl ++ print(r'%s = Struct(%r, [' % (decl_name, decl_name)) ++ for variable in struct.variables(allow_empty=True): ++ var_type = dump_type(variable.decl_type) ++ print(r' (%s, %r),' % (var_type, variable.name)) ++ print(r'])') ++ print() ++ ++ def visit_interface(self): ++ class_ = self.decl ++ assert len(class_.bases) == 1 ++ base = class_.bases[0] ++ ++ s = self.interfaces ++ s.write('%s = Interface(%r, %s)\n' % (class_.name, class_.name, base.related_class.name)) ++ ++ s = self.methods ++ s.write('%s.methods += [\n' % (class_.name,)) ++ for member in class_.public_members: ++ if member.virtuality != 'pure virtual': ++ continue ++ ret_type = dump_type(member.return_type) ++ arg_types = self.convert_args(member.arguments) ++ s.write(' StdMethod(%s, %r, [%s]),\n' % (ret_type, member.name, arg_types)) ++ s.write(']\n\n') ++ ++ def convert_args(self, args): ++ # TODO: use __attribute__ ((annotate ("out"))) ++ # See also: ++ # - https://github.com/CastXML/CastXML/issues/25 ++ # XXX: Requires a castxml version newer than the one in Ubuntu 15.10 ++ arg_types = [] ++ for arg in args: ++ if arg.attributes is not None: ++ sys.stderr.write('warning: found %s attribute %r\n' % (arg.name, arg.attributes)) ++ res_arg_type = dump_type(arg.decl_type) ++ res_arg = '(%s, %r)' % (res_arg_type, arg.name) ++ ++ # Infer output arguments ++ if res_arg_type.startswith('Pointer(') and \ ++ not res_arg_type.startswith('Pointer(Const('): ++ res_arg = 'Out' + res_arg ++ ++ arg_types.append(res_arg) ++ ++ arg_types = ', '.join(arg_types) ++ return arg_types ++ ++ def visit_class_declaration(self): ++ pass ++ ++ def visit_typedef(self): ++ typedef = self.decl ++ base_type = dump_type(typedef.decl_type) ++ if base_type == typedef.name: ++ # Ignore `typedef struct Foo Foo;` ++ return ++ if base_type == '': ++ if isinstance(typedef.decl_type, declarations.cpptypes.declarated_t): ++ base_decl = typedef.decl_type.declaration ++ self.visit_struct(typedef.name, base_decl) ++ return ++ print(r'%s = Alias(%r, %s)' % (typedef.name, typedef.name, base_type)) ++ print() ++ ++ def visit_enumeration(self): ++ enum = self.decl ++ print(r'%s = Enum(%r, [' % (enum.name, enum.name)) ++ for name, value in enum.values: ++ print(r' %r,' % (name,)) ++ print(r'])') ++ print() ++ ++ def visit_variable(self): ++ pass ++ ++ def visit_free_function(self): ++ function = self.decl ++ if function.has_inline: ++ return ++ ++ s = self.functions ++ ret_type = dump_type(function.return_type) ++ arg_types = self.convert_args(function.arguments) ++ s.write(' StdFunction(%s, %r, [%s]),\n' % (ret_type, function.name, arg_types)) ++ ++ def visit_free_operator(self): ++ pass ++ ++ ++def main(): ++ defines = [] ++ includes = [] ++ cxxflags = [ ++ '-Wno-unknown-attributes', ++ '-Wno-unused-value', ++ '-Wno-macro-redefined', ++ ] ++ compiler = 'g++' ++ ++ args = sys.argv[1:] ++ while args and args[0].startswith('-'): ++ arg = args.pop(0) ++ if arg.startswith('-I'): ++ include = arg[2:] ++ includes.append(include) ++ elif arg.startswith('-D'): ++ define = arg[2:] ++ defines.append(define) ++ else: ++ sys.stderr.write('error: unknown option %r\n' % arg) ++ sys.exit(1) ++ ++ winsdk = True ++ if winsdk: ++ # Set up Clang compiler flags to use MinGW runtime ++ # http://stackoverflow.com/a/19839946 ++ p = subprocess.Popen( ++ ["x86_64-w64-mingw32-g++", "-x", "c++", "-E", "-Wp,-v", '-', '-fsyntax-only'], ++ stdin=open(os.devnull, 'rt'), ++ stdout=open(os.devnull, 'wt'), ++ stderr=subprocess.PIPE) ++ includes.append('/usr/share/castxml/clang/include') ++ for line in p.stderr: ++ if line.startswith(' '): ++ include = line.strip() ++ if os.path.isdir(include): ++ if os.path.exists(os.path.join(include, 'ia32intrin.h')): ++ # XXX: We must use Clang's intrinsic headers ++ continue ++ includes.append(os.path.normpath(include)) ++ ++ winver = 0x0602 ++ ++ defines += [ ++ # emulate MinGW ++ '__MINGW32__', ++ '_WIN32', ++ '_WIN64', ++ '__declspec(x)=', ++ # Avoid namespace pollution when including windows.h ++ # http://support.microsoft.com/kb/166474 ++ 'WIN32_LEAN_AND_MEAN', ++ # Set Windows version to 8.1 ++ '_WIN32_WINNT=0x%04X' % winver, ++ 'WINVER=0x%04X' % winver, ++ 'NTDDI_VERSION=0x%04X0000' % winver, ++ # Prevent headers from requiring a rpcndr.h version beyond MinGW's ++ '__REQUIRED_RPCNDR_H_VERSION__=475', ++ # Avoid C++ helper classes ++ 'D3D10_NO_HELPERS', ++ 'D3D11_NO_HELPERS', ++ 'D3D11_VIDEO_NO_HELPERS', ++ ] ++ ++ # XXX: Change compiler? ++ #compiler = 'cl' ++ ++ # XXX: This doesn't seem to work well ++ cxxflags += [ ++ #'-m32', ++ #'-target', 'x86_64-pc-mingw32', ++ ] ++ ++ sys.stderr.write('Include path:\n') ++ for include in includes: ++ sys.stderr.write(' %s\n' % include) ++ sys.stderr.write('Definitions:\n') ++ for define in defines: ++ sys.stderr.write(' %s\n' % define) ++ ++ import logging ++ utils.loggers.set_level(logging.DEBUG) ++ ++ # Find the location of the xml generator (castxml or gccxml) ++ generator_path, generator_name = utils.find_xml_generator("castxml") ++ ++ # Configure the xml generator ++ config = parser.xml_generator_configuration_t( ++ xml_generator_path=generator_path, ++ xml_generator=generator_name, ++ define_symbols = defines, ++ include_paths = includes, ++ cflags = ' '.join(cxxflags), ++ compiler = compiler, ++ #keep_xml = True, ++ ) ++ ++ script_dir = os.path.dirname(__file__) ++ headers = [ ++ os.path.join(script_dir, '..', '..', 'compat', 'winsdk_compat.h'), ++ os.path.join(script_dir, 'cxx2api.h'), ++ ] ++ main_header = args[0] ++ headers.append(main_header) ++ ++ decls = parser.parse(headers, config, parser.COMPILATION_MODE.ALL_AT_ONCE) ++ global_ns = declarations.get_global_namespace(decls) ++ ++ def decl_filter(decl): ++ location = decl.location ++ if location is None: ++ return False ++ return os.path.basename(location.file_name) in list(map(os.path.basename, args)) ++ ++ module, _ = os.path.splitext(main_header) ++ visitor = decl2_dumper_t(module) ++ visitor.start() ++ for decl in global_ns.declarations: ++ if not decl_filter(decl): ++ continue ++ ++ if sys.stdout.isatty(): ++ print('# ' + str(decl)) ++ ++ visitor.decl = decl ++ algorithm.apply_visitor(visitor, decl) ++ visitor.finish() ++ ++ ++if __name__ == '__main__': ++ main() +diff --git a/specs/scripts/spec2api.py b/specs/scripts/spec2api.py +index f21b08d5..7fb395a4 100755 +--- a/specs/scripts/spec2api.py ++++ b/specs/scripts/spec2api.py +@@ -181,8 +181,8 @@ class SpecParser(LineParser): + category = self.prefix.upper() + '_' + category + if category != self.category: + if self.category is not None: +- print +- print ' # %s' % category ++ print() ++ print(' # %s' % category) + self.category = category + + if self.prefix == 'wgl': +@@ -190,7 +190,7 @@ class SpecParser(LineParser): + else: + constructor = 'GlFunction' + +- print ' %s(%s, "%s", [%s]%s),' % (constructor, ret_type, function_name, ', '.join(args), extra) ++ print(' %s(%s, "%s", [%s]%s),' % (constructor, ret_type, function_name, ', '.join(args), extra)) + + array_re = re.compile(r'^array\s+\[(.*)\]$') + +diff --git a/specs/scripts/txt2api.py b/specs/scripts/txt2api.py +index 6cd99dd9..e9469d3c 100755 +--- a/specs/scripts/txt2api.py ++++ b/specs/scripts/txt2api.py +@@ -31,7 +31,7 @@ + import sys + import re + import optparse +-from urllib2 import urlopen ++from urllib.request import urlopen + + + def stderr(x): +@@ -116,7 +116,7 @@ class TxtParser(LineParser): + self.consume() + line = self.consume() + self.parse_section(line) +- print ++ print() + + def parse_section(self, name): + if name == 'Name Strings': +@@ -136,7 +136,7 @@ class TxtParser(LineParser): + name = line.strip() + if name.startswith('EGL_'): + self.prefix = '' +- print ' # %s' % name ++ print(' # %s' % name) + + def skip_c_comments(self): + while not self.eof(): +@@ -192,7 +192,7 @@ class TxtParser(LineParser): + args.append(arg) + if self.tokens[0] == ',': + self.tokens.pop(0) +- print ' GlFunction(%s, "%s", [%s]%s),' % (ret, name, ', '.join(args), extra) ++ print(' GlFunction(%s, "%s", [%s]%s),' % (ret, name, ', '.join(args), extra)) + + def parse_arg(self): + type = self.parse_type() +diff --git a/specs/scripts/xml2api.py b/specs/scripts/xml2api.py +index e3820e09..f09fe0bf 100755 +--- a/specs/scripts/xml2api.py ++++ b/specs/scripts/xml2api.py +@@ -126,7 +126,7 @@ def processRequire(node, filterName): + + + def printPrototypes(prototypes, extensionName, functionNames, skip=set()): +- print ' # %s' % extensionName ++ print(' # %s' % extensionName) + + if extensionName == 'GL_EXT_direct_state_access': + functionNames.sort() +@@ -134,9 +134,9 @@ def printPrototypes(prototypes, extensionName, functionNames, skip=set()): + for functionName in functionNames: + if functionName not in skip: + prototype = prototypes[functionName] +- print ' %s,' % prototype ++ print(' %s,' % prototype) + +- print ++ print() + + + def main(): +diff --git a/specs/scripts/xml2enum.py b/specs/scripts/xml2enum.py +index 6d49e11c..cb2c4ae9 100755 +--- a/specs/scripts/xml2enum.py ++++ b/specs/scripts/xml2enum.py +@@ -58,8 +58,8 @@ for arg in sys.argv[1:]: + params.setdefault(value, name) + + +- values = params.keys() ++ values = list(params.keys()) + values.sort() + for value in values: + name = params[value] +- print ' "%s",\t\t# 0x%04X' % (name, value) ++ print(' "%s",\t\t# 0x%04X' % (name, value)) +diff --git a/specs/scripts/xml2glparams.py b/specs/scripts/xml2glparams.py +index 7e2bc351..805aac86 100755 +--- a/specs/scripts/xml2glparams.py ++++ b/specs/scripts/xml2glparams.py +@@ -58,8 +58,8 @@ for arg in sys.argv[1:]: + params.setdefault(value, name) + + +- values = params.keys() ++ values = list(params.keys()) + values.sort() + for value in values: + name = params[value] +- print ' ("",\tX,\t1,\t"%s"),\t# 0x%04X' % (name, value) ++ print(' ("",\tX,\t1,\t"%s"),\t# 0x%04X' % (name, value)) +diff --git a/specs/stdapi.py b/specs/stdapi.py +index c72c264b..487b6c1e 100644 +--- a/specs/stdapi.py ++++ b/specs/stdapi.py +@@ -26,7 +26,9 @@ + """C basic types""" + + +-import debug ++import sys ++ ++from . import debug + + + class Type: +@@ -266,6 +268,10 @@ class Bitmask(Type): + Flags = Bitmask + + ++def EnumFlags(name, values): ++ return Flags(Alias(name, UInt), values) ++ ++ + class Array(Type): + + def __init__(self, type_, length): +@@ -273,7 +279,7 @@ class Array(Type): + self.type = type_ + self.length = length + if not isinstance(length, int): +- assert isinstance(length, basestring) ++ assert isinstance(length, str) + # Check if length is actually a valid constant expression + try: + eval(length, {}, {}) +@@ -329,6 +335,10 @@ class Struct(Type): + def visit(self, visitor, *args, **kwargs): + return visitor.visitStruct(self, *args, **kwargs) + ++ def getMemberByName(self, name): ++ memberNames = [memberName for memberType, memberName in self.members] ++ return memberNames.index(name) ++ + + def Union(kindExpr, kindTypes, contextLess=True): + switchTypes = [] +@@ -372,7 +382,7 @@ def InOut(type, name): + + class Function: + +- def __init__(self, type, name, args, call = '', fail = None, sideeffects=True, internal=False): ++ def __init__(self, type, name, args, call = '', fail = None, sideeffects=True, internal=False, overloaded=False): + self.type = type + self.name = name + +@@ -394,6 +404,7 @@ class Function: + self.fail = fail + self.sideeffects = sideeffects + self.internal = internal ++ self.overloaded = overloaded + + def prototype(self, name=None): + if name is not None: +@@ -414,6 +425,17 @@ class Function: + s += ")" + return s + ++ def sigName(self): ++ name = self.name ++ if self.overloaded: ++ # suffix used to make overloaded functions/methods unique ++ suffix = ','.join([str(arg.type) for arg in self.args]) ++ suffix = suffix.replace(' *', '*') ++ suffix = suffix.replace(' &', '&') ++ suffix = '(' + suffix + ')' ++ name += suffix ++ return name ++ + def argNames(self): + return [arg.name for arg in self.args] + +@@ -463,14 +485,12 @@ class Interface(Type): + yield method + for method in self.methods: + yield method +- raise StopIteration + + def iterBases(self): + iface = self + while iface is not None: + yield iface + iface = iface.base +- raise StopIteration + + def hasBase(self, *bases): + for iface in self.iterBases(): +@@ -484,14 +504,13 @@ class Interface(Type): + yield iface, method + for method in self.methods: + yield self, method +- raise StopIteration + + + class Method(Function): + +- def __init__(self, type, name, args, call = '', const=False, sideeffects=True): ++ def __init__(self, type, name, args, call = '', const=False, sideeffects=True, overloaded=False): + assert call == '__stdcall' +- Function.__init__(self, type, name, args, call = call, sideeffects=sideeffects) ++ Function.__init__(self, type, name, args, call = call, sideeffects=sideeffects, overloaded=overloaded) + for index in range(len(self.args)): + self.args[index].index = index + 1 + self.const = const +@@ -576,7 +595,7 @@ class Polymorphic(Type): + else: + cases[i].append(case) + +- return zip(cases, types) ++ return list(zip(cases, types)) + + + def EnumPolymorphic(enumName, switchExpr, switchTypes, defaultType, contextLess=True): +@@ -734,7 +753,7 @@ class Rebuilder(Visitor): + if pointer_type is pointer.type: + return pointer + else: +- return LinearPointer(pointer_type) ++ return LinearPointer(pointer_type, self.size) + + def visitReference(self, reference): + reference_type = self.visit(reference.type) +@@ -792,7 +811,7 @@ class MutableRebuilder(Rebuilder): + + def visitReference(self, reference): + # Strip out references +- return reference.type ++ return self.visit(reference.type) + + + class Traverser(Visitor): +@@ -894,7 +913,7 @@ class ExpanderMixin: + + def expand(self, expr): + # Expand a C expression, replacing certain variables +- if not isinstance(expr, basestring): ++ if not isinstance(expr, str): + return expr + variables = {} + +diff --git a/specs/wglapi.py b/specs/wglapi.py +index f24a8d21..563f0269 100644 +--- a/specs/wglapi.py ++++ b/specs/wglapi.py +@@ -27,9 +27,9 @@ + """WGL API description""" + + +-from glapi import * +-from winapi import * +-from wglenum import * ++from .glapi import * ++from .winapi import * ++from .wglenum import * + + + wglapi = Module("WGL") +diff --git a/specs/wglenum.py b/specs/wglenum.py +index ad9bbccf..6bc4e74d 100644 +--- a/specs/wglenum.py ++++ b/specs/wglenum.py +@@ -27,7 +27,7 @@ + """WGL enum description""" + + +-from stdapi import * ++from .stdapi import * + + WGLenum = FakeEnum(Int, [ + "WGL_GPU_VENDOR_AMD", # 0x1F00 +diff --git a/specs/winapi.py b/specs/winapi.py +index 445039ff..e66d063a 100644 +--- a/specs/winapi.py ++++ b/specs/winapi.py +@@ -26,7 +26,7 @@ + """Win32 API type description.""" + + +-from stdapi import * ++from .stdapi import * + + + SHORT = Alias("SHORT", Short) +diff --git a/wrappers/CMakeLists.txt b/wrappers/CMakeLists.txt +index 2ceac332..7a452ed4 100644 +--- a/wrappers/CMakeLists.txt ++++ b/wrappers/CMakeLists.txt +@@ -79,7 +79,7 @@ if (WIN32) + include_directories (BEFORE SYSTEM ${DirectX_D3D_INCLUDE_DIR}) + add_custom_command ( + OUTPUT ddrawtrace.cpp +- COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/ddrawtrace.py > ${CMAKE_CURRENT_BINARY_DIR}/ddrawtrace.cpp ++ COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/ddrawtrace.py > ${CMAKE_CURRENT_BINARY_DIR}/ddrawtrace.cpp + DEPENDS + ddrawtrace.py + dlltrace.py +@@ -109,7 +109,7 @@ if (WIN32) + include_directories (BEFORE SYSTEM ${DirectX_D3D9_INCLUDE_DIR} ${DirectX_D3D8_INCLUDE_DIR}) + add_custom_command ( + OUTPUT d3d8trace.cpp +- COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3d8trace.py > ${CMAKE_CURRENT_BINARY_DIR}/d3d8trace.cpp ++ COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3d8trace.py > ${CMAKE_CURRENT_BINARY_DIR}/d3d8trace.cpp + DEPENDS + d3d8trace.py + dlltrace.py +@@ -143,7 +143,7 @@ if (WIN32) + include_directories (BEFORE SYSTEM ${DirectX_D3D9_INCLUDE_DIR}) + add_custom_command ( + OUTPUT d3d9trace.cpp +- COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3d9trace.py > ${CMAKE_CURRENT_BINARY_DIR}/d3d9trace.cpp ++ COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d3d9trace.py > ${CMAKE_CURRENT_BINARY_DIR}/d3d9trace.cpp + DEPENDS + d3d9trace.py + dlltrace.py +@@ -179,7 +179,7 @@ if (WIN32) + + add_custom_command ( + OUTPUT dxgitrace.cpp +- COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/dxgitrace.py > ${CMAKE_CURRENT_BINARY_DIR}/dxgitrace.cpp ++ COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/dxgitrace.py > ${CMAKE_CURRENT_BINARY_DIR}/dxgitrace.cpp + DEPENDS + dxgitrace.py + dlltrace.py +@@ -216,7 +216,7 @@ if (WIN32) + + add_custom_command ( + OUTPUT d2d1trace.cpp +- COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d2d1trace.py > ${CMAKE_CURRENT_BINARY_DIR}/d2d1trace.cpp ++ COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/d2d1trace.py > ${CMAKE_CURRENT_BINARY_DIR}/d2d1trace.cpp + DEPENDS + d2d1trace.py + trace.py +@@ -241,7 +241,7 @@ if (WIN32) + # opengl32.dll + add_custom_command ( + OUTPUT wgltrace.cpp +- COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/wgltrace.py > ${CMAKE_CURRENT_BINARY_DIR}/wgltrace.cpp ++ COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/wgltrace.py > ${CMAKE_CURRENT_BINARY_DIR}/wgltrace.cpp + DEPENDS + wgltrace.py + gltrace.py +@@ -278,7 +278,7 @@ elseif (APPLE) + # OpenGL framework + add_custom_command ( + OUTPUT cgltrace.cpp +- COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/cgltrace.py > ${CMAKE_CURRENT_BINARY_DIR}/cgltrace.cpp ++ COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/cgltrace.py > ${CMAKE_CURRENT_BINARY_DIR}/cgltrace.cpp + DEPENDS + cgltrace.py + gltrace.py +@@ -322,7 +322,7 @@ elseif (X11_FOUND) + # libGL.so + add_custom_command ( + OUTPUT glxtrace.cpp +- COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/glxtrace.py > ${CMAKE_CURRENT_BINARY_DIR}/glxtrace.cpp ++ COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/glxtrace.py > ${CMAKE_CURRENT_BINARY_DIR}/glxtrace.cpp + DEPENDS + glxtrace.py + gltrace.py +@@ -372,7 +372,7 @@ if (ENABLE_EGL AND NOT WIN32 AND NOT APPLE) + # libEGL.so/libGL.so + add_custom_command ( + OUTPUT egltrace.cpp +- COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/egltrace.py > ${CMAKE_CURRENT_BINARY_DIR}/egltrace.cpp ++ COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/egltrace.py > ${CMAKE_CURRENT_BINARY_DIR}/egltrace.cpp + DEPENDS + egltrace.py + gltrace.py +diff --git a/wrappers/cgltrace.py b/wrappers/cgltrace.py +index 6c72f696..02b3c518 100644 +--- a/wrappers/cgltrace.py ++++ b/wrappers/cgltrace.py +@@ -43,55 +43,55 @@ class CglTracer(GlTracer): + if function.name == 'CGLReleaseContext': + # Unlike other GL APIs like EGL or GLX, CGL will make the context + # not current if it's the current context. +- print ' if (_CGLGetContextRetainCount(ctx) == 1) {' +- print ' if (gltrace::releaseContext((uintptr_t)ctx)) {' +- print ' if (_CGLGetCurrentContext() == ctx) {' +- print ' gltrace::clearContext();' +- print ' }' +- print ' }' +- print ' }' ++ print(' if (_CGLGetContextRetainCount(ctx) == 1) {') ++ print(' if (gltrace::releaseContext((uintptr_t)ctx)) {') ++ print(' if (_CGLGetCurrentContext() == ctx) {') ++ print(' gltrace::clearContext();') ++ print(' }') ++ print(' }') ++ print(' }') + + if function.name == 'CGLDestroyContext': + # The same rule applies here about the as for CGLReleaseContext. +- print ' if (gltrace::releaseContext((uintptr_t)ctx)) {' +- print ' if (_CGLGetCurrentContext() == ctx) {' +- print ' gltrace::clearContext();' +- print ' }' +- print ' }' ++ print(' if (gltrace::releaseContext((uintptr_t)ctx)) {') ++ print(' if (_CGLGetCurrentContext() == ctx) {') ++ print(' gltrace::clearContext();') ++ print(' }') ++ print(' }') + + GlTracer.traceFunctionImplBody(self, function) + + if function.name == 'CGLCreateContext': +- print ' if (_result == kCGLNoError) {' +- print ' gltrace::createContext((uintptr_t)*ctx);' +- print ' }' ++ print(' if (_result == kCGLNoError) {') ++ print(' gltrace::createContext((uintptr_t)*ctx);') ++ print(' }') + + if function.name == 'CGLSetCurrentContext': +- print ' if (_result == kCGLNoError) {' +- print ' if (ctx != NULL) {' +- print ' gltrace::setContext((uintptr_t)ctx);' +- print ' } else {' +- print ' gltrace::clearContext();' +- print ' }' +- print ' }' ++ print(' if (_result == kCGLNoError) {') ++ print(' if (ctx != NULL) {') ++ print(' gltrace::setContext((uintptr_t)ctx);') ++ print(' } else {') ++ print(' gltrace::clearContext();') ++ print(' }') ++ print(' }') + + if function.name == 'CGLRetainContext': +- print ' gltrace::retainContext((uintptr_t)ctx);' ++ print(' gltrace::retainContext((uintptr_t)ctx);') + + + if __name__ == '__main__': +- print +- print '#include <stdlib.h>' +- print '#include <string.h>' +- print +- print '#include "trace_writer_local.hpp"' +- print +- print '// To validate our prototypes' +- print '#define GL_GLEXT_PROTOTYPES' +- print +- print '#include "glproc.hpp"' +- print '#include "glsize.hpp"' +- print ++ print() ++ print('#include <stdlib.h>') ++ print('#include <string.h>') ++ print() ++ print('#include "trace_writer_local.hpp"') ++ print() ++ print('// To validate our prototypes') ++ print('#define GL_GLEXT_PROTOTYPES') ++ print() ++ print('#include "glproc.hpp"') ++ print('#include "glsize.hpp"') ++ print() + + module = Module() + module.mergeModule(cglapi) +@@ -101,7 +101,7 @@ if __name__ == '__main__': + tracer = CglTracer() + tracer.traceApi(api) + +- print r''' ++ print(r''' + + PUBLIC + void * gll_noop = 0; +@@ -130,4 +130,4 @@ _init(void) { + setenv("SDL_OPENGL_LIBRARY", "/System/Library/Frameworks/OpenGL.framework/OpenGL", 1); + } + +-''' ++''') +diff --git a/wrappers/d2d1trace.py b/wrappers/d2d1trace.py +index 26223005..2176341f 100644 +--- a/wrappers/d2d1trace.py ++++ b/wrappers/d2d1trace.py +@@ -31,15 +31,15 @@ from specs.d2d1 import d2d1 + + + if __name__ == '__main__': +- print '#include "guids_defs.hpp"' +- print +- print '#include "trace_writer_local.hpp"' +- print '#include "os.hpp"' +- print +- print '#define DWRITE_EXPORT WINAPI' +- print +- print '#include "d2dimports.hpp"' +- print ++ print('#include "guids_defs.hpp"') ++ print() ++ print('#include "trace_writer_local.hpp"') ++ print('#include "os.hpp"') ++ print() ++ print('#define DWRITE_EXPORT WINAPI') ++ print() ++ print('#include "d2dimports.hpp"') ++ print() + + api = API() + api.addModule(d2d1) +diff --git a/wrappers/d3d8trace.py b/wrappers/d3d8trace.py +index 2903c48f..11afbca5 100644 +--- a/wrappers/d3d8trace.py ++++ b/wrappers/d3d8trace.py +@@ -34,7 +34,7 @@ class D3D8Tracer(DllTracer): + def serializeArgValue(self, function, arg): + # Dump shaders as strings + if arg.type is D3DSHADER8: +- print ' DumpShader(trace::localWriter, %s);' % (arg.name) ++ print(' DumpShader(trace::localWriter, %s);' % (arg.name)) + return + + DllTracer.serializeArgValue(self, function, arg) +@@ -55,32 +55,32 @@ class D3D8Tracer(DllTracer): + + def implementWrapperInterfaceMethodBody(self, interface, base, method): + if method.name in ('Unlock', 'UnlockRect', 'UnlockBox'): +- print ' if (_MappedSize && m_pbData) {' ++ print(' if (_MappedSize && m_pbData) {') + self.emit_memcpy('(LPBYTE)m_pbData', '_MappedSize') +- print ' }' ++ print(' }') + + DllTracer.implementWrapperInterfaceMethodBody(self, interface, base, method) + + if method.name in ('Lock', 'LockRect', 'LockBox'): + # FIXME: handle recursive locks +- print ' if (SUCCEEDED(_result) && !(Flags & D3DLOCK_READONLY)) {' +- print ' _getMapInfo(_this, %s, m_pbData, _MappedSize);' % ', '.join(method.argNames()[:-1]) +- print ' } else {' +- print ' m_pbData = NULL;' +- print ' _MappedSize = 0;' +- print ' }' ++ print(' if (SUCCEEDED(_result) && !(Flags & D3DLOCK_READONLY)) {') ++ print(' _getMapInfo(_this, %s, m_pbData, _MappedSize);' % ', '.join(method.argNames()[:-1])) ++ print(' } else {') ++ print(' m_pbData = NULL;') ++ print(' _MappedSize = 0;') ++ print(' }') + + + if __name__ == '__main__': +- print '#define INITGUID' +- print +- print '#include "trace_writer_local.hpp"' +- print '#include "os.hpp"' +- print +- print '#include "d3d8imports.hpp"' +- print '#include "d3d8size.hpp"' +- print '#include "d3d9shader.hpp"' +- print ++ print('#define INITGUID') ++ print() ++ print('#include "trace_writer_local.hpp"') ++ print('#include "os.hpp"') ++ print() ++ print('#include "d3d8imports.hpp"') ++ print('#include "d3d8size.hpp"') ++ print('#include "d3d9shader.hpp"') ++ print() + + api = API() + api.addModule(d3d8) +diff --git a/wrappers/d3d9trace.py b/wrappers/d3d9trace.py +index 0850ba3e..53d5152f 100644 +--- a/wrappers/d3d9trace.py ++++ b/wrappers/d3d9trace.py +@@ -35,7 +35,7 @@ class D3D9Tracer(DllTracer): + def serializeArgValue(self, function, arg): + # Dump shaders as strings + if arg.type is D3DSHADER9: +- print ' DumpShader(trace::localWriter, %s);' % (arg.name) ++ print(' DumpShader(trace::localWriter, %s);' % (arg.name)) + return + + DllTracer.serializeArgValue(self, function, arg) +@@ -72,49 +72,49 @@ class D3D9Tracer(DllTracer): + def implementWrapperInterfaceMethodBody(self, interface, base, method): + if method.name in ('Unlock', 'UnlockRect', 'UnlockBox'): + if interface.name in ['IDirect3DTexture9']: +- print ' std::map<UINT, std::pair<size_t, VOID *> >::iterator it = _MappedData.find(Level);' +- print ' if (it != _MappedData.end()) {' ++ print(' std::map<UINT, std::pair<size_t, VOID *> >::iterator it = _MappedData.find(Level);') ++ print(' if (it != _MappedData.end()) {') + self.emit_memcpy('(LPBYTE)it->second.second', 'it->second.first') +- print ' _MappedData.erase(it);' +- print ' }' ++ print(' _MappedData.erase(it);') ++ print(' }') + else: +- print ' if (_MappedSize && m_pbData) {' ++ print(' if (_MappedSize && m_pbData) {') + self.emit_memcpy('(LPBYTE)m_pbData', '_MappedSize') +- print ' }' ++ print(' }') + + DllTracer.implementWrapperInterfaceMethodBody(self, interface, base, method) + + if method.name in ('Lock', 'LockRect', 'LockBox'): + if interface.name in ['IDirect3DTexture9']: +- print ' if (SUCCEEDED(_result) && !(Flags & D3DLOCK_READONLY)) {' +- print ' size_t mappedSize;' +- print ' VOID * pbData;' +- print ' _getMapInfo(_this, %s, pbData, mappedSize);' % ', '.join(method.argNames()[:-1]) +- print ' _MappedData[Level] = std::make_pair(mappedSize, pbData);' +- print ' } else {' +- print ' _MappedData.erase(Level);' +- print ' }' ++ print(' if (SUCCEEDED(_result) && !(Flags & D3DLOCK_READONLY)) {') ++ print(' size_t mappedSize;') ++ print(' VOID * pbData;') ++ print(' _getMapInfo(_this, %s, pbData, mappedSize);' % ', '.join(method.argNames()[:-1])) ++ print(' _MappedData[Level] = std::make_pair(mappedSize, pbData);') ++ print(' } else {') ++ print(' _MappedData.erase(Level);') ++ print(' }') + else: + # FIXME: handle recursive locks +- print ' if (SUCCEEDED(_result) && !(Flags & D3DLOCK_READONLY)) {' +- print ' _getMapInfo(_this, %s, m_pbData, _MappedSize);' % ', '.join(method.argNames()[:-1]) +- print ' } else {' +- print ' m_pbData = NULL;' +- print ' _MappedSize = 0;' +- print ' }' ++ print(' if (SUCCEEDED(_result) && !(Flags & D3DLOCK_READONLY)) {') ++ print(' _getMapInfo(_this, %s, m_pbData, _MappedSize);' % ', '.join(method.argNames()[:-1])) ++ print(' } else {') ++ print(' m_pbData = NULL;') ++ print(' _MappedSize = 0;') ++ print(' }') + + + if __name__ == '__main__': +- print '#define INITGUID' +- print +- print '#include "trace_writer_local.hpp"' +- print '#include "os.hpp"' +- print +- print '#include "d3d9imports.hpp"' +- print '#include "d3d9size.hpp"' +- print '#include "d3d9shader.hpp"' +- print '#include "dxva2imports.hpp"' +- print ++ print('#define INITGUID') ++ print() ++ print('#include "trace_writer_local.hpp"') ++ print('#include "os.hpp"') ++ print() ++ print('#include "d3d9imports.hpp"') ++ print('#include "d3d9size.hpp"') ++ print('#include "d3d9shader.hpp"') ++ print('#include "dxva2imports.hpp"') ++ print() + + d3d9.mergeModule(d3dperf) + +diff --git a/wrappers/ddrawtrace.py b/wrappers/ddrawtrace.py +index 96602d21..da7ffbe7 100644 +--- a/wrappers/ddrawtrace.py ++++ b/wrappers/ddrawtrace.py +@@ -41,12 +41,12 @@ class DDrawTracer(DllTracer): + + + if __name__ == '__main__': +- print '#define INITGUID' +- print '#include "d3dimports.hpp"' +- print '#include "trace_writer_local.hpp"' +- print '#include "d3d7size.hpp"' +- print '#include "os.hpp"' +- print ++ print('#define INITGUID') ++ print('#include "d3dimports.hpp"') ++ print('#include "trace_writer_local.hpp"') ++ print('#include "d3d7size.hpp"') ++ print('#include "os.hpp"') ++ print() + + api = API() + api.addModule(ddraw) +diff --git a/wrappers/dlltrace.py b/wrappers/dlltrace.py +index 26962216..8ac18b0c 100644 +--- a/wrappers/dlltrace.py ++++ b/wrappers/dlltrace.py +@@ -37,24 +37,24 @@ class DllDispatcher(Dispatcher): + + def dispatchModule(self, module): + tag = module.name.upper() +- print r'HMODULE g_h%sModule = NULL;' % (tag,) +- print r'' +- print r'static PROC' +- print r'_get%sProcAddress(LPCSTR lpProcName) {' % tag +- print r' if (!g_h%sModule) {' % tag +- print r' char szDll[MAX_PATH] = {0};' +- print r' if (!GetSystemDirectoryA(szDll, MAX_PATH)) {' +- print r' return NULL;' +- print r' }' +- print r' strcat(szDll, "\\%s.dll");' % module.name +- print r' g_h%sModule = LoadLibraryA(szDll);' % tag +- print r' if (!g_h%sModule) {' % tag +- print r' return NULL;' +- print r' }' +- print r' }' +- print r' return GetProcAddress(g_h%sModule, lpProcName);' % tag +- print r'}' +- print r'' ++ print(r'HMODULE g_h%sModule = NULL;' % (tag,)) ++ print(r'') ++ print(r'static PROC') ++ print(r'_get%sProcAddress(LPCSTR lpProcName) {' % tag) ++ print(r' if (!g_h%sModule) {' % tag) ++ print(r' char szDll[MAX_PATH] = {0};') ++ print(r' if (!GetSystemDirectoryA(szDll, MAX_PATH)) {') ++ print(r' return NULL;') ++ print(r' }') ++ print(r' strcat(szDll, "\\%s.dll");' % module.name) ++ print(r' g_h%sModule = LoadLibraryA(szDll);' % tag) ++ print(r' if (!g_h%sModule) {' % tag) ++ print(r' return NULL;') ++ print(r' }') ++ print(r' }') ++ print(r' return GetProcAddress(g_h%sModule, lpProcName);' % tag) ++ print(r'}') ++ print(r'') + + Dispatcher.dispatchModule(self, module) + +diff --git a/wrappers/dxgitrace.py b/wrappers/dxgitrace.py +index 3edda2c2..134f45d7 100644 +--- a/wrappers/dxgitrace.py ++++ b/wrappers/dxgitrace.py +@@ -40,47 +40,47 @@ class D3DCommonTracer(DllTracer): + def serializeArgValue(self, function, arg): + # Dump shaders as strings + if isinstance(arg.type, stdapi.Blob) and arg.name.startswith('pShaderBytecode'): +- print ' DumpShader(trace::localWriter, %s, %s);' % (arg.name, arg.type.size) ++ print(' DumpShader(trace::localWriter, %s, %s);' % (arg.name, arg.type.size)) + return + + # Serialize the swapchain dimensions + if function.name == 'CreateSwapChain' and arg.name == 'pDesc' \ + or arg.name == 'pSwapChainDesc': +- print r' DXGI_SWAP_CHAIN_DESC *_pSwapChainDesc = NULL;' +- print r' DXGI_SWAP_CHAIN_DESC _SwapChainDesc;' +- print r' if (%s) {' % arg.name +- print r' _SwapChainDesc = *%s;' % arg.name ++ print(r' DXGI_SWAP_CHAIN_DESC *_pSwapChainDesc = NULL;') ++ print(r' DXGI_SWAP_CHAIN_DESC _SwapChainDesc;') ++ print(r' if (%s) {' % arg.name) ++ print(r' _SwapChainDesc = *%s;' % arg.name) + if function.name != 'CreateSwapChain' or not self.interface.name.endswith('DWM'): + # Obtain size from the window +- print r' RECT _rect;' +- print r' if (GetClientRect(%s->OutputWindow, &_rect)) {' % arg.name +- print r' if (%s->BufferDesc.Width == 0) {' % arg.name +- print r' _SwapChainDesc.BufferDesc.Width = _rect.right - _rect.left;' +- print r' }' +- print r' if (%s->BufferDesc.Height == 0) {' % arg.name +- print r' _SwapChainDesc.BufferDesc.Height = _rect.bottom - _rect.top;' +- print r' }' +- print r' }' ++ print(r' RECT _rect;') ++ print(r' if (GetClientRect(%s->OutputWindow, &_rect)) {' % arg.name) ++ print(r' if (%s->BufferDesc.Width == 0) {' % arg.name) ++ print(r' _SwapChainDesc.BufferDesc.Width = _rect.right - _rect.left;') ++ print(r' }') ++ print(r' if (%s->BufferDesc.Height == 0) {' % arg.name) ++ print(r' _SwapChainDesc.BufferDesc.Height = _rect.bottom - _rect.top;') ++ print(r' }') ++ print(r' }') + else: + # Obtain size from the output +- print r' DXGI_OUTPUT_DESC _OutputDesc;' +- print r' if (SUCCEEDED(pOutput->GetDesc(&_OutputDesc))) {' +- print r' _SwapChainDesc.BufferDesc.Width = _OutputDesc.DesktopCoordinates.right - _OutputDesc.DesktopCoordinates.left;' +- print r' _SwapChainDesc.BufferDesc.Height = _OutputDesc.DesktopCoordinates.bottom - _OutputDesc.DesktopCoordinates.top;' +- print r' }' +- print r' _pSwapChainDesc = &_SwapChainDesc;' +- print r' }' ++ print(r' DXGI_OUTPUT_DESC _OutputDesc;') ++ print(r' if (SUCCEEDED(pOutput->GetDesc(&_OutputDesc))) {') ++ print(r' _SwapChainDesc.BufferDesc.Width = _OutputDesc.DesktopCoordinates.right - _OutputDesc.DesktopCoordinates.left;') ++ print(r' _SwapChainDesc.BufferDesc.Height = _OutputDesc.DesktopCoordinates.bottom - _OutputDesc.DesktopCoordinates.top;') ++ print(r' }') ++ print(r' _pSwapChainDesc = &_SwapChainDesc;') ++ print(r' }') + self.serializeValue(arg.type, '_pSwapChainDesc') + return + + # Serialize object names + if function.name == 'SetPrivateData' and arg.name == 'pData': + iid = function.args[0].name +- print r' if (%s == WKPDID_D3DDebugObjectName) {' % iid +- print r' trace::localWriter.writeString(static_cast<const char *>(pData), DataSize);' +- print r' } else {' ++ print(r' if (%s == WKPDID_D3DDebugObjectName) {' % iid) ++ print(r' trace::localWriter.writeString(static_cast<const char *>(pData), DataSize);') ++ print(r' } else {') + DllTracer.serializeArgValue(self, function, arg) +- print r' }' ++ print(r' }') + return + + DllTracer.serializeArgValue(self, function, arg) +@@ -110,47 +110,47 @@ class D3DCommonTracer(DllTracer): + if method.getArgByName('pInitialData'): + pDesc1 = method.getArgByName('pDesc1') + if pDesc1 is not None: +- print r' %s pDesc = pDesc1;' % (pDesc1.type,) ++ print(r' %s pDesc = pDesc1;' % (pDesc1.type,)) + + if method.name in ('Map', 'Unmap'): + # On D3D11 Map/Unmap is not a resource method, but a context method instead. + resourceArg = method.getArgByName('pResource') + if resourceArg is None: +- print ' _MAP_DESC & _MapDesc = m_MapDesc;' ++ print(' _MAP_DESC & _MapDesc = m_MapDesc;') + else: +- print ' _MAP_DESC & _MapDesc = m_MapDescs[std::pair<%s, UINT>(pResource, Subresource)];' % resourceArg.type ++ print(' _MAP_DESC & _MapDesc = m_MapDescs[std::pair<%s, UINT>(pResource, Subresource)];' % resourceArg.type) + + if method.name == 'Unmap': +- print ' if (_MapDesc.Size && _MapDesc.pData) {' ++ print(' if (_MapDesc.Size && _MapDesc.pData) {') + self.emit_memcpy('_MapDesc.pData', '_MapDesc.Size') +- print ' }' ++ print(' }') + + DllTracer.implementWrapperInterfaceMethodBody(self, interface, base, method) + + if method.name == 'Map': + # NOTE: recursive locks are explicitely forbidden +- print ' if (SUCCEEDED(_result)) {' +- print ' _getMapDesc(_this, %s, _MapDesc);' % ', '.join(method.argNames()) +- print ' } else {' +- print ' _MapDesc.pData = NULL;' +- print ' _MapDesc.Size = 0;' +- print ' }' ++ print(' if (SUCCEEDED(_result)) {') ++ print(' _getMapDesc(_this, %s, _MapDesc);' % ', '.join(method.argNames())) ++ print(' } else {') ++ print(' _MapDesc.pData = NULL;') ++ print(' _MapDesc.Size = 0;') ++ print(' }') + + + if __name__ == '__main__': +- print r'#define INITGUID' +- print +- print r'#include "trace_writer_local.hpp"' +- print r'#include "os.hpp"' +- print +- print r'#include "d3dcommonshader.hpp"' +- print +- print r'#include "d3d10imports.hpp"' +- print r'#include "d3d10size.hpp"' +- print r'#include "d3d11imports.hpp"' +- print r'#include "d3d11size.hpp"' +- print r'#include "d3d9imports.hpp" // D3DPERF_*' +- print ++ print(r'#define INITGUID') ++ print() ++ print(r'#include "trace_writer_local.hpp"') ++ print(r'#include "os.hpp"') ++ print() ++ print(r'#include "d3dcommonshader.hpp"') ++ print() ++ print(r'#include "d3d10imports.hpp"') ++ print(r'#include "d3d10size.hpp"') ++ print(r'#include "d3d11imports.hpp"') ++ print(r'#include "d3d11size.hpp"') ++ print(r'#include "d3d9imports.hpp" // D3DPERF_*') ++ print() + + api = API() + api.addModule(dxgi.dxgi) +diff --git a/wrappers/egltrace.py b/wrappers/egltrace.py +index 1fcb0fd6..f5b61c0c 100644 +--- a/wrappers/egltrace.py ++++ b/wrappers/egltrace.py +@@ -50,239 +50,239 @@ class EglTracer(GlTracer): + + def traceFunctionImplBody(self, function): + if function.name == 'glTexDirectMapVIV': +- print ' // prevent loop call' +- print ' glTexDirectVIVMap(target, width, height, format, Logical, Physical);' ++ print(' // prevent loop call') ++ print(' glTexDirectVIVMap(target, width, height, format, Logical, Physical);') + return + + if function.name == 'glTexDirectInvalidateVIV': +- print ' // get current texture' +- print ' GLint tex = 0;' +- print ' int32_t size = 0;' +- print ' int32_t ysize = 0;' +- print ' int32_t usize = 0;' +- print ' int32_t vsize = 0;' +- print ' _glGetIntegerv(GL_TEXTURE_BINDING_2D, &tex);' +- print ' if(tex == 0)' +- print ' {' +- print ' return;' +- print ' }' +- print ' TEXDIRECTVIVDATA &data = _directTextureDataMap[tex];' +- print ' switch(data.format){' +- print ' case GL_VIV_YV12:' +- print ' case GL_VIV_I420:' +- print ' ysize=data.width * data.height;' +- print ' usize=ysize/4;' +- print ' vsize=usize;' +- print ' break;' +- print ' case GL_VIV_NV12:' +- print ' case GL_VIV_NV21:' +- print ' ysize=data.width * data.height;' +- print ' usize=ysize/2;' +- print ' vsize=0;' +- print ' break;' +- print ' case GL_RGBA:' +- print ' case GL_BGRA_EXT:' +- print ' ysize=data.width * data.height *4;' +- print ' usize=0;' +- print ' vsize=0;' +- print ' break;' +- print ' case GL_RGB:' +- print ' ysize=data.width * data.height *3;' +- print ' usize=0;' +- print ' vsize=0;' +- print ' break;' +- print ' case GL_VIV_YUY2:' +- print ' case GL_VIV_UYVY:' +- print ' case GL_RGB565_OES:' +- print ' case GL_LUMINANCE8_ALPHA8_EXT:' +- print ' ysize=data.width * data.height *2;' +- print ' usize=0;' +- print ' vsize=0;' +- print ' break;' +- print ' case GL_ALPHA:' +- print ' ysize=data.width * data.height;' +- print ' usize=0;' +- print ' vsize=0;' +- print ' break;' +- print ' default:' +- print ' return;' +- print ' }' +- print ' if (NULL==(GLvoid*)data.logical) {' +- print ' if (ysize > 0) {' ++ print(' // get current texture') ++ print(' GLint tex = 0;') ++ print(' int32_t size = 0;') ++ print(' int32_t ysize = 0;') ++ print(' int32_t usize = 0;') ++ print(' int32_t vsize = 0;') ++ print(' _glGetIntegerv(GL_TEXTURE_BINDING_2D, &tex);') ++ print(' if(tex == 0)') ++ print(' {') ++ print(' return;') ++ print(' }') ++ print(' TEXDIRECTVIVDATA &data = _directTextureDataMap[tex];') ++ print(' switch(data.format){') ++ print(' case GL_VIV_YV12:') ++ print(' case GL_VIV_I420:') ++ print(' ysize=data.width * data.height;') ++ print(' usize=ysize/4;') ++ print(' vsize=usize;') ++ print(' break;') ++ print(' case GL_VIV_NV12:') ++ print(' case GL_VIV_NV21:') ++ print(' ysize=data.width * data.height;') ++ print(' usize=ysize/2;') ++ print(' vsize=0;') ++ print(' break;') ++ print(' case GL_RGBA:') ++ print(' case GL_BGRA_EXT:') ++ print(' ysize=data.width * data.height *4;') ++ print(' usize=0;') ++ print(' vsize=0;') ++ print(' break;') ++ print(' case GL_RGB:') ++ print(' ysize=data.width * data.height *3;') ++ print(' usize=0;') ++ print(' vsize=0;') ++ print(' break;') ++ print(' case GL_VIV_YUY2:') ++ print(' case GL_VIV_UYVY:') ++ print(' case GL_RGB565_OES:') ++ print(' case GL_LUMINANCE8_ALPHA8_EXT:') ++ print(' ysize=data.width * data.height *2;') ++ print(' usize=0;') ++ print(' vsize=0;') ++ print(' break;') ++ print(' case GL_ALPHA:') ++ print(' ysize=data.width * data.height;') ++ print(' usize=0;') ++ print(' vsize=0;') ++ print(' break;') ++ print(' default:') ++ print(' return;') ++ print(' }') ++ print(' if (NULL==(GLvoid*)data.logical) {') ++ print(' if (ysize > 0) {') + self.emit_memcpy_opt('(GLvoid*)data.planes[0]', 'ysize') +- print ' }' +- print ' if (usize > 0) {' ++ print(' }') ++ print(' if (usize > 0) {') + self.emit_memcpy_opt('(GLvoid*)data.planes[1]', 'usize') +- print ' }' +- print ' if (vsize > 0) {' ++ print(' }') ++ print(' if (vsize > 0) {') + self.emit_memcpy_opt('(GLvoid*)data.planes[2]', 'vsize') +- print ' }' +- print ' } else {' +- print ' size = ysize + usize + vsize;' +- print ' if (size > 0) {' ++ print(' }') ++ print(' } else {') ++ print(' size = ysize + usize + vsize;') ++ print(' if (size > 0) {') + self.emit_memcpy_opt('(GLvoid*)data.logical', 'size') +- print ' }' +- print ' }' ++ print(' }') ++ print(' }') + + if function.name == 'eglGetProcAddress': +- print ' procname = __get_alias_func_name(procname);' ++ print(' procname = __get_alias_func_name(procname);') + + GlTracer.traceFunctionImplBody(self, function) + + if function.name == 'glTexDirectVIV': +- print ' // get current texture' +- print ' GLint tex = 0;' +- print ' _glGetIntegerv(GL_TEXTURE_BINDING_2D, &tex);' +- print ' if(tex != 0)' +- print ' {' +- print ' TEXDIRECTVIVDATA &data = _directTextureDataMap[tex];' +- print ' data.width = width;' +- print ' data.height = height;' +- print ' data.format = format;' +- print ' data.planes[0] = pixels[0];' +- print ' data.planes[1] = pixels[1];' +- print ' data.planes[2] = pixels[2];' +- print ' }' ++ print(' // get current texture') ++ print(' GLint tex = 0;') ++ print(' _glGetIntegerv(GL_TEXTURE_BINDING_2D, &tex);') ++ print(' if(tex != 0)') ++ print(' {') ++ print(' TEXDIRECTVIVDATA &data = _directTextureDataMap[tex];') ++ print(' data.width = width;') ++ print(' data.height = height;') ++ print(' data.format = format;') ++ print(' data.planes[0] = pixels[0];') ++ print(' data.planes[1] = pixels[1];') ++ print(' data.planes[2] = pixels[2];') ++ print(' }') + + if function.name == 'glTexDirectVIVMap' or function.name == 'glTexDirectTiledMapVIV': +- print ' // get current texture' +- print ' GLint tex = 0;' +- print ' _glGetIntegerv(GL_TEXTURE_BINDING_2D, &tex);' +- print ' if(tex != 0)' +- print ' {' +- print ' TEXDIRECTVIVDATA &data = _directTextureDataMap[tex];' +- print ' data.width = width;' +- print ' data.height = height;' +- print ' data.format = format;' +- print ' data.logical = *Logical; // Logical != NULL' +- print ' data.physical = *Physical;' +- print ' }' ++ print(' // get current texture') ++ print(' GLint tex = 0;') ++ print(' _glGetIntegerv(GL_TEXTURE_BINDING_2D, &tex);') ++ print(' if(tex != 0)') ++ print(' {') ++ print(' TEXDIRECTVIVDATA &data = _directTextureDataMap[tex];') ++ print(' data.width = width;') ++ print(' data.height = height;') ++ print(' data.format = format;') ++ print(' data.logical = *Logical; // Logical != NULL') ++ print(' data.physical = *Physical;') ++ print(' }') + + if function.name == 'eglCreateContext': +- print ' if (_result != EGL_NO_CONTEXT)' +- print ' gltrace::createContext((uintptr_t)_result);' ++ print(' if (_result != EGL_NO_CONTEXT)') ++ print(' gltrace::createContext((uintptr_t)_result);') + + if function.name == 'eglMakeCurrent': +- print r' if (_result) {' +- print r' // update the profile' +- print r' if (ctx != EGL_NO_CONTEXT) {' +- print r' gltrace::setContext((uintptr_t)ctx);' +- print r' gltrace::Context *tr = gltrace::getContext();' +- print r' EGLint api = EGL_OPENGL_ES_API;' +- print r' _eglQueryContext(dpy, ctx, EGL_CONTEXT_CLIENT_TYPE, &api);' +- print r' if (api == EGL_OPENGL_API) {' +- print r' assert(tr->profile.api == glprofile::API_GL);' +- print r' } else if (api == EGL_OPENGL_ES_API) {' +- print r' EGLint client_version = 1;' +- print r' _eglQueryContext(dpy, ctx, EGL_CONTEXT_CLIENT_VERSION, &client_version);' +- print r' if (tr->profile.api != glprofile::API_GLES ||' +- print r' tr->profile.major < client_version) {' +- print r' std::string version = tr->profile.str();' +- print r' os::log("apitrace: warning: eglMakeCurrent: expected OpenGL ES %i.x context, but got %s\n",' +- print r' client_version, version.c_str());' +- print r' }' +- print r' } else {' +- print r' assert(0);' +- print r' }' +- print r' } else {' +- print r' gltrace::clearContext();' +- print r' }' +- print r' }' ++ print(r' if (_result) {') ++ print(r' // update the profile') ++ print(r' if (ctx != EGL_NO_CONTEXT) {') ++ print(r' gltrace::setContext((uintptr_t)ctx);') ++ print(r' gltrace::Context *tr = gltrace::getContext();') ++ print(r' EGLint api = EGL_OPENGL_ES_API;') ++ print(r' _eglQueryContext(dpy, ctx, EGL_CONTEXT_CLIENT_TYPE, &api);') ++ print(r' if (api == EGL_OPENGL_API) {') ++ print(r' assert(tr->profile.api == glprofile::API_GL);') ++ print(r' } else if (api == EGL_OPENGL_ES_API) {') ++ print(r' EGLint client_version = 1;') ++ print(r' _eglQueryContext(dpy, ctx, EGL_CONTEXT_CLIENT_VERSION, &client_version);') ++ print(r' if (tr->profile.api != glprofile::API_GLES ||') ++ print(r' tr->profile.major < client_version) {') ++ print(r' std::string version = tr->profile.str();') ++ print(r' os::log("apitrace: warning: eglMakeCurrent: expected OpenGL ES %i.x context, but got %s\n",') ++ print(r' client_version, version.c_str());') ++ print(r' }') ++ print(r' } else {') ++ print(r' assert(0);') ++ print(r' }') ++ print(r' } else {') ++ print(r' gltrace::clearContext();') ++ print(r' }') ++ print(r' }') + + if function.name == 'eglDestroyContext': +- print ' if (_result) {' +- print ' gltrace::releaseContext((uintptr_t)ctx);' +- print ' }' ++ print(' if (_result) {') ++ print(' gltrace::releaseContext((uintptr_t)ctx);') ++ print(' }') + + if function.name == 'glEGLImageTargetTexture2DOES': +- print ' image_info *info = _EGLImageKHR_get_image_info(target, image);' +- print ' if (info) {' +- print ' GLint level = 0;' +- print ' GLint internalformat = info->internalformat;' +- print ' GLsizei width = info->width;' +- print ' GLsizei height = info->height;' +- print ' GLint border = 0;' +- print ' GLenum format = info->format;' +- print ' GLenum type = info->type;' +- print ' const GLvoid * pixels = info->pixels;' ++ print(' image_info *info = _EGLImageKHR_get_image_info(target, image);') ++ print(' if (info) {') ++ print(' GLint level = 0;') ++ print(' GLint internalformat = info->internalformat;') ++ print(' GLsizei width = info->width;') ++ print(' GLsizei height = info->height;') ++ print(' GLint border = 0;') ++ print(' GLenum format = info->format;') ++ print(' GLenum type = info->type;') ++ print(' const GLvoid * pixels = info->pixels;') + self.emitFakeTexture2D() +- print ' _EGLImageKHR_free_image_info(info);' +- print ' }' ++ print(' _EGLImageKHR_free_image_info(info);') ++ print(' }') + + + if __name__ == '__main__': +- print '#include <stdlib.h>' +- print '#include <string.h>' +- print +- print '#include "trace_writer_local.hpp"' +- print +- print '// To validate our prototypes' +- print '#define GL_GLEXT_PROTOTYPES' +- print '#define EGL_EGLEXT_PROTOTYPES' +- print +- print '#include "dlopen.hpp"' +- print '#include "glproc.hpp"' +- print '#include "glsize.hpp"' +- print '#include "eglsize.hpp"' +- print +- print 'static const char *__get_alias_func_name(const char *origFunName)' +- print '{' +- print ' /* Vivante driver uses alias name for following OES/EXT functions, that means dlsym for thoese functions will fail */' +- print ' static const char * __glExtProcAlias[][2] =' +- print ' {' +- print ' /* Extension API alias for GL_OES_texture_3D */' +- print ' {"glTexImage3DOES", "glTexImage3D"},' +- print ' {"glTexSubImage3DOES", "glTexSubImage3D"},' +- print ' {"glCopyTexSubImage3DOES", "glCopyTexSubImage3D"},' +- print ' {"glCompressedTexImage3DOES", "glCompressedTexImage3D"},' +- print ' {"glCompressedTexSubImage3DOES", "glCompressedTexSubImage3D"},' +- print +- print ' /* Extension API alias for GL_OES_get_program_binary */' +- print ' {"glGetProgramBinaryOES", "glGetProgramBinary"},' +- print ' {"glProgramBinaryOES", "glProgramBinary"},' +- print +- print ' /* Extension API alias for GL_OES_vertex_array_object */' +- print ' {"glBindVertexArrayOES", "glBindVertexArray"},' +- print ' {"glDeleteVertexArraysOES", "glDeleteVertexArrays"},' +- print ' {"glGenVertexArraysOES", "glGenVertexArrays"},' +- print ' {"glIsVertexArrayOES", "glIsVertexArray"},' +- print +- print ' /* Extension API alias for GL_OES_blend_minmax */' +- print ' {"glBlendEquationEXT", "glBlendEquation"}' +- print ' };' +- print +- print ' int count = sizeof(__glExtProcAlias) / sizeof(__glExtProcAlias[0]);' +- print ' int i;' +- print +- print ' for(i=0; i<count; i++)' +- print ' {' +- print ' if(strcmp(__glExtProcAlias[i][0], origFunName) == 0)' +- print ' return __glExtProcAlias[i][1];' +- print ' }' +- print +- print ' return origFunName;' +- print '}' +- +- print +- print 'typedef struct TexDirectVivData' +- print '{' +- print ' int width;' +- print ' int height;' +- print ' GLenum format;' +- print ' GLvoid*planes[3]; // used for glTexDirectVIV' +- print ' GLvoid*logical; // used for glTexDirectVIVMap/glTexDirectMapVIV/glTexDirectTiledMapVIV' +- print ' GLuint physical;' +- print '}TEXDIRECTVIVDATA;' +- print +- print 'static std::map<GLint, TEXDIRECTVIVDATA> _directTextureDataMap;' +- print +- print '#define GL_VIV_YV12 0x8FC0' +- print '#define GL_VIV_NV12 0x8FC1' +- print '#define GL_VIV_YUY2 0x8FC2' +- print '#define GL_VIV_UYVY 0x8FC3' +- print '#define GL_VIV_NV21 0x8FC4' +- print '#define GL_VIV_I420 0x8FC5' +- print ++ print('#include <stdlib.h>') ++ print('#include <string.h>') ++ print() ++ print('#include "trace_writer_local.hpp"') ++ print() ++ print('// To validate our prototypes') ++ print('#define GL_GLEXT_PROTOTYPES') ++ print('#define EGL_EGLEXT_PROTOTYPES') ++ print() ++ print('#include "dlopen.hpp"') ++ print('#include "glproc.hpp"') ++ print('#include "glsize.hpp"') ++ print('#include "eglsize.hpp"') ++ print() ++ print('static const char *__get_alias_func_name(const char *origFunName)') ++ print('{') ++ print(' /* Vivante driver uses alias name for following OES/EXT functions, that means dlsym for thoese functions will fail */') ++ print(' static const char * __glExtProcAlias[][2] =') ++ print(' {') ++ print(' /* Extension API alias for GL_OES_texture_3D */') ++ print(' {"glTexImage3DOES", "glTexImage3D"},') ++ print(' {"glTexSubImage3DOES", "glTexSubImage3D"},') ++ print(' {"glCopyTexSubImage3DOES", "glCopyTexSubImage3D"},') ++ print(' {"glCompressedTexImage3DOES", "glCompressedTexImage3D"},') ++ print(' {"glCompressedTexSubImage3DOES", "glCompressedTexSubImage3D"},') ++ print() ++ print(' /* Extension API alias for GL_OES_get_program_binary */') ++ print(' {"glGetProgramBinaryOES", "glGetProgramBinary"},') ++ print(' {"glProgramBinaryOES", "glProgramBinary"},') ++ print() ++ print(' /* Extension API alias for GL_OES_vertex_array_object */') ++ print(' {"glBindVertexArrayOES", "glBindVertexArray"},') ++ print(' {"glDeleteVertexArraysOES", "glDeleteVertexArrays"},') ++ print(' {"glGenVertexArraysOES", "glGenVertexArrays"},') ++ print(' {"glIsVertexArrayOES", "glIsVertexArray"},') ++ print() ++ print(' /* Extension API alias for GL_OES_blend_minmax */') ++ print(' {"glBlendEquationEXT", "glBlendEquation"}') ++ print(' };') ++ print() ++ print(' int count = sizeof(__glExtProcAlias) / sizeof(__glExtProcAlias[0]);') ++ print(' int i;') ++ print() ++ print(' for(i=0; i<count; i++)') ++ print(' {') ++ print(' if(strcmp(__glExtProcAlias[i][0], origFunName) == 0)') ++ print(' return __glExtProcAlias[i][1];') ++ print(' }') ++ print() ++ print(' return origFunName;') ++ print('}') ++ ++ print() ++ print('typedef struct TexDirectVivData') ++ print('{') ++ print(' int width;') ++ print(' int height;') ++ print(' GLenum format;') ++ print(' GLvoid*planes[3]; // used for glTexDirectVIV') ++ print(' GLvoid*logical; // used for glTexDirectVIVMap/glTexDirectMapVIV/glTexDirectTiledMapVIV') ++ print(' GLuint physical;') ++ print('}TEXDIRECTVIVDATA;') ++ print() ++ print('static std::map<GLint, TEXDIRECTVIVDATA> _directTextureDataMap;') ++ print() ++ print('#define GL_VIV_YV12 0x8FC0') ++ print('#define GL_VIV_NV12 0x8FC1') ++ print('#define GL_VIV_YUY2 0x8FC2') ++ print('#define GL_VIV_UYVY 0x8FC3') ++ print('#define GL_VIV_NV21 0x8FC4') ++ print('#define GL_VIV_I420 0x8FC5') ++ print() + + module = Module() + module.mergeModule(eglapi) +@@ -292,7 +292,7 @@ if __name__ == '__main__': + tracer = EglTracer() + tracer.traceApi(api) + +- print r''' ++ print(r''' + + + +@@ -453,8 +453,8 @@ void APIENTRY glWeightPointerOESBounds(GLint size, GLenum type, GLsizei stride, + #endif /* ANDROID */ + + +-''' +- print r''' ++''') ++ print(r''' + /* + * let the GPU driver know that we are in apitrace + */ +@@ -464,4 +464,4 @@ int APIENTRY ApiTraceEnabled(void) { + return 1; + } + +-''' ++''') +diff --git a/wrappers/gltrace.py b/wrappers/gltrace.py +index cf13ae18..02504148 100644 +--- a/wrappers/gltrace.py ++++ b/wrappers/gltrace.py +@@ -79,7 +79,7 @@ class TypeGetter(stdapi.Visitor): + suffix = 'iv' + arg_type = 'GLint' + else: +- print alias.expr ++ print(alias.expr) + assert False + function_name = self.prefix + suffix + self.ext_suffix + return function_name, arg_type +@@ -114,48 +114,48 @@ class GlTracer(Tracer): + def header(self, api): + Tracer.header(self, api) + +- print '#include <algorithm>' +- print +- print '#include "gltrace.hpp"' +- print ++ print('#include <algorithm>') ++ print() ++ print('#include "gltrace.hpp"') ++ print() + + # Which glVertexAttrib* variant to use +- print 'enum vertex_attrib {' +- print ' VERTEX_ATTRIB,' +- print ' VERTEX_ATTRIB_NV,' +- print '};' +- print +- print 'static vertex_attrib _get_vertex_attrib(void) {' +- print ' gltrace::Context *ctx = gltrace::getContext();' +- print ' if (ctx->user_arrays_nv) {' +- print ' GLboolean _vertex_program = GL_FALSE;' +- print ' _glGetBooleanv(GL_VERTEX_PROGRAM_ARB, &_vertex_program);' +- print ' if (_vertex_program) {' +- print ' if (ctx->user_arrays_nv) {' +- print ' GLint _vertex_program_binding_nv = _glGetInteger(GL_VERTEX_PROGRAM_BINDING_NV);' +- print ' if (_vertex_program_binding_nv) {' +- print ' return VERTEX_ATTRIB_NV;' +- print ' }' +- print ' }' +- print ' }' +- print ' }' +- print ' return VERTEX_ATTRIB;' +- print '}' +- print ++ print('enum vertex_attrib {') ++ print(' VERTEX_ATTRIB,') ++ print(' VERTEX_ATTRIB_NV,') ++ print('};') ++ print() ++ print('static vertex_attrib _get_vertex_attrib(void) {') ++ print(' gltrace::Context *ctx = gltrace::getContext();') ++ print(' if (ctx->user_arrays_nv) {') ++ print(' GLboolean _vertex_program = GL_FALSE;') ++ print(' _glGetBooleanv(GL_VERTEX_PROGRAM_ARB, &_vertex_program);') ++ print(' if (_vertex_program) {') ++ print(' if (ctx->user_arrays_nv) {') ++ print(' GLint _vertex_program_binding_nv = _glGetInteger(GL_VERTEX_PROGRAM_BINDING_NV);') ++ print(' if (_vertex_program_binding_nv) {') ++ print(' return VERTEX_ATTRIB_NV;') ++ print(' }') ++ print(' }') ++ print(' }') ++ print(' }') ++ print(' return VERTEX_ATTRIB;') ++ print('}') ++ print() + + self.defineShadowBufferHelper() + + # Whether we need user arrays +- print 'static inline bool _need_user_arrays(void)' +- print '{' +- print ' gltrace::Context *ctx = gltrace::getContext();' +- print ' if (!ctx->user_arrays) {' +- print ' return false;' +- print ' }' +- print +- print ' glprofile::Profile profile = ctx->profile;' +- print ' bool es1 = profile.es() && profile.major == 1;' +- print ++ print('static inline bool _need_user_arrays(void)') ++ print('{') ++ print(' gltrace::Context *ctx = gltrace::getContext();') ++ print(' if (!ctx->user_arrays) {') ++ print(' return false;') ++ print(' }') ++ print() ++ print(' glprofile::Profile profile = ctx->profile;') ++ print(' bool es1 = profile.es() && profile.major == 1;') ++ print() + + for camelcase_name, uppercase_name in self.arrays: + # in which profile is the array available? +@@ -166,120 +166,120 @@ class GlTracer(Tracer): + function_name = 'gl%sPointer' % camelcase_name + enable_name = 'GL_%s_ARRAY' % uppercase_name + binding_name = 'GL_%s_ARRAY_BUFFER_BINDING' % uppercase_name +- print ' // %s' % function_name +- print ' if (%s) {' % profile_check ++ print(' // %s' % function_name) ++ print(' if (%s) {' % profile_check) + self.array_prolog(api, uppercase_name) +- print ' if (_glIsEnabled(%s) &&' % enable_name +- print ' _glGetInteger(%s) == 0) {' % binding_name ++ print(' if (_glIsEnabled(%s) &&' % enable_name) ++ print(' _glGetInteger(%s) == 0) {' % binding_name) + self.array_cleanup(api, uppercase_name) +- print ' return true;' +- print ' }' ++ print(' return true;') ++ print(' }') + self.array_epilog(api, uppercase_name) +- print ' }' +- print +- +- print ' // ES1 does not support generic vertex attributes' +- print ' if (es1)' +- print ' return false;' +- print +- print ' vertex_attrib _vertex_attrib = _get_vertex_attrib();' +- print +- print ' // glVertexAttribPointer' +- print ' if (_vertex_attrib == VERTEX_ATTRIB) {' +- print ' GLint _max_vertex_attribs = _glGetInteger(GL_MAX_VERTEX_ATTRIBS);' +- print ' for (GLint index = 0; index < _max_vertex_attribs; ++index) {' +- print ' if (_glGetVertexAttribi(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED) &&' +- print ' _glGetVertexAttribi(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) == 0) {' +- print ' return true;' +- print ' }' +- print ' }' +- print ' }' +- print +- print ' // glVertexAttribPointerNV' +- print ' if (_vertex_attrib == VERTEX_ATTRIB_NV) {' +- print ' for (GLint index = 0; index < 16; ++index) {' +- print ' if (_glIsEnabled(GL_VERTEX_ATTRIB_ARRAY0_NV + index)) {' +- print ' return true;' +- print ' }' +- print ' }' +- print ' }' +- print +- +- print ' return false;' +- print '}' +- print +- +- print 'static void _trace_user_arrays(GLuint count);' +- print +- +- print '// whether glLockArraysEXT() has ever been called' +- print 'static bool _checkLockArraysEXT = false;' +- print ++ print(' }') ++ print() ++ ++ print(' // ES1 does not support generic vertex attributes') ++ print(' if (es1)') ++ print(' return false;') ++ print() ++ print(' vertex_attrib _vertex_attrib = _get_vertex_attrib();') ++ print() ++ print(' // glVertexAttribPointer') ++ print(' if (_vertex_attrib == VERTEX_ATTRIB) {') ++ print(' GLint _max_vertex_attribs = _glGetInteger(GL_MAX_VERTEX_ATTRIBS);') ++ print(' for (GLint index = 0; index < _max_vertex_attribs; ++index) {') ++ print(' if (_glGetVertexAttribi(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED) &&') ++ print(' _glGetVertexAttribi(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING) == 0) {') ++ print(' return true;') ++ print(' }') ++ print(' }') ++ print(' }') ++ print() ++ print(' // glVertexAttribPointerNV') ++ print(' if (_vertex_attrib == VERTEX_ATTRIB_NV) {') ++ print(' for (GLint index = 0; index < 16; ++index) {') ++ print(' if (_glIsEnabled(GL_VERTEX_ATTRIB_ARRAY0_NV + index)) {') ++ print(' return true;') ++ print(' }') ++ print(' }') ++ print(' }') ++ print() ++ ++ print(' return false;') ++ print('}') ++ print() ++ ++ print('static void _trace_user_arrays(GLuint count);') ++ print() ++ ++ print('// whether glLockArraysEXT() has ever been called') ++ print('static bool _checkLockArraysEXT = false;') ++ print() + + # Buffer mappings +- print '// whether glMapBufferRange(GL_MAP_WRITE_BIT) has ever been called' +- print 'static bool _checkBufferMapRange = false;' +- print +- print '// whether glBufferParameteriAPPLE(GL_BUFFER_FLUSHING_UNMAP_APPLE, GL_FALSE) has ever been called' +- print 'static bool _checkBufferFlushingUnmapAPPLE = false;' +- print ++ print('// whether glMapBufferRange(GL_MAP_WRITE_BIT) has ever been called') ++ print('static bool _checkBufferMapRange = false;') ++ print() ++ print('// whether glBufferParameteriAPPLE(GL_BUFFER_FLUSHING_UNMAP_APPLE, GL_FALSE) has ever been called') ++ print('static bool _checkBufferFlushingUnmapAPPLE = false;') ++ print() + + # Generate a helper function to determine whether a parameter name + # refers to a symbolic value or not +- print 'static bool' +- print 'is_symbolic_pname(GLenum pname) {' +- print ' switch (pname) {' ++ print('static bool') ++ print('is_symbolic_pname(GLenum pname) {') ++ print(' switch (pname) {') + for function, type, count, name in glparams.parameters: + if type is glapi.GLenum: +- print ' case %s:' % name +- print ' return true;' +- print ' default:' +- print ' return false;' +- print ' }' +- print '}' +- print ++ print(' case %s:' % name) ++ print(' return true;') ++ print(' default:') ++ print(' return false;') ++ print(' }') ++ print('}') ++ print() + + # Generate a helper function to determine whether a parameter value is + # potentially symbolic or not; i.e., if the value can be represented in + # an enum or not +- print 'template<class T>' +- print 'static inline bool' +- print 'is_symbolic_param(T param) {' +- print ' return static_cast<T>(static_cast<GLenum>(param)) == param;' +- print '}' +- print ++ print('template<class T>') ++ print('static inline bool') ++ print('is_symbolic_param(T param) {') ++ print(' return static_cast<T>(static_cast<GLenum>(param)) == param;') ++ print('}') ++ print() + + # Generate a helper function to know how many elements a parameter has +- print 'static size_t' +- print '_gl_param_size(GLenum pname) {' +- print ' switch (pname) {' ++ print('static size_t') ++ print('_gl_param_size(GLenum pname) {') ++ print(' switch (pname) {') + for function, type, count, name in glparams.parameters: + if name == 'GL_PROGRAM_BINARY_FORMATS': + count = 0 + if type is not None: +- print ' case %s: return %s;' % (name, count) +- print ' default:' +- print r' os::log("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, pname);' +- print ' return 1;' +- print ' }' +- print '}' +- print ++ print(' case %s: return %s;' % (name, count)) ++ print(' default:') ++ print(r' os::log("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, pname);') ++ print(' return 1;') ++ print(' }') ++ print('}') ++ print() + + # states such as GL_UNPACK_ROW_LENGTH are not available in GLES +- print 'static inline bool' +- print 'can_unpack_subimage(void) {' +- print ' gltrace::Context *ctx = gltrace::getContext();' +- print ' return ctx->profile.desktop();' +- print '}' +- print ++ print('static inline bool') ++ print('can_unpack_subimage(void) {') ++ print(' gltrace::Context *ctx = gltrace::getContext();') ++ print(' return ctx->profile.desktop();') ++ print('}') ++ print() + + # VMWX_map_buffer_debug +- print r'extern "C" PUBLIC' +- print r'void APIENTRY' +- print r'glNotifyMappedBufferRangeVMWX(const void * start, GLsizeiptr length) {' ++ print(r'extern "C" PUBLIC') ++ print(r'void APIENTRY') ++ print(r'glNotifyMappedBufferRangeVMWX(const void * start, GLsizeiptr length) {') + self.emit_memcpy('start', 'length') +- print r'}' +- print ++ print(r'}') ++ print() + + getProcAddressFunctionNames = [] + +@@ -290,70 +290,70 @@ class GlTracer(Tracer): + argType = getProcAddressFunction.args[0].type + retType = getProcAddressFunction.type + +- print 'static %s _wrapProcAddress(%s procName, %s procPtr);' % (retType, argType, retType) +- print ++ print('static %s _wrapProcAddress(%s procName, %s procPtr);' % (retType, argType, retType)) ++ print() + + Tracer.traceApi(self, api) + +- print 'static %s _wrapProcAddress(%s procName, %s procPtr) {' % (retType, argType, retType) ++ print('static %s _wrapProcAddress(%s procName, %s procPtr) {' % (retType, argType, retType)) + + # Provide fallback functions to missing debug functions +- print ' if (!procPtr) {' ++ print(' if (!procPtr) {') + else_ = '' + for function_name in self.debug_functions: + if self.api.getFunctionByName(function_name): +- print ' %sif (strcmp("%s", (const char *)procName) == 0) {' % (else_, function_name) +- print ' return (%s)&%s;' % (retType, function_name) +- print ' }' ++ print(' %sif (strcmp("%s", (const char *)procName) == 0) {' % (else_, function_name)) ++ print(' return (%s)&%s;' % (retType, function_name)) ++ print(' }') + else_ = 'else ' +- print ' %s{' % else_ +- print ' return NULL;' +- print ' }' +- print ' }' ++ print(' %s{' % else_) ++ print(' return NULL;') ++ print(' }') ++ print(' }') + + for function in api.getAllFunctions(): + ptype = function_pointer_type(function) + pvalue = function_pointer_value(function) +- print ' if (strcmp("%s", (const char *)procName) == 0) {' % function.name +- print ' assert(procPtr != (%s)&%s);' % (retType, function.name) +- print ' %s = (%s)procPtr;' % (pvalue, ptype) +- print ' return (%s)&%s;' % (retType, function.name,) +- print ' }' +- print ' os::log("apitrace: warning: unknown function \\"%s\\"\\n", (const char *)procName);' +- print ' return procPtr;' +- print '}' +- print ++ print(' if (strcmp("%s", (const char *)procName) == 0) {' % function.name) ++ print(' assert(procPtr != (%s)&%s);' % (retType, function.name)) ++ print(' %s = (%s)procPtr;' % (pvalue, ptype)) ++ print(' return (%s)&%s;' % (retType, function.name,)) ++ print(' }') ++ print(' os::log("apitrace: warning: unknown function \\"%s\\"\\n", (const char *)procName);') ++ print(' return procPtr;') ++ print('}') ++ print() + else: + Tracer.traceApi(self, api) + + def defineShadowBufferHelper(self): +- print 'void _shadow_glGetBufferSubData(GLenum target, GLintptr offset,' +- print ' GLsizeiptr size, GLvoid *data)' +- print '{' +- print ' gltrace::Context *ctx = gltrace::getContext();' +- print ' if (!ctx->needsShadowBuffers() || target != GL_ELEMENT_ARRAY_BUFFER) {' +- print ' _glGetBufferSubData(target, offset, size, data);' +- print ' return;' +- print ' }' +- print +- print ' GLint buffer_binding = _glGetInteger(GL_ELEMENT_ARRAY_BUFFER_BINDING);' +- print ' if (buffer_binding > 0) {' +- print ' gltrace::Buffer & buf = ctx->buffers[buffer_binding];' +- print ' buf.getSubData(offset, size, data);' +- print ' }' +- print '}' ++ print('void _shadow_glGetBufferSubData(GLenum target, GLintptr offset,') ++ print(' GLsizeiptr size, GLvoid *data)') ++ print('{') ++ print(' gltrace::Context *ctx = gltrace::getContext();') ++ print(' if (!ctx->needsShadowBuffers() || target != GL_ELEMENT_ARRAY_BUFFER) {') ++ print(' _glGetBufferSubData(target, offset, size, data);') ++ print(' return;') ++ print(' }') ++ print() ++ print(' GLint buffer_binding = _glGetInteger(GL_ELEMENT_ARRAY_BUFFER_BINDING);') ++ print(' if (buffer_binding > 0) {') ++ print(' gltrace::Buffer & buf = ctx->buffers[buffer_binding];') ++ print(' buf.getSubData(offset, size, data);') ++ print(' }') ++ print('}') + + def shadowBufferMethod(self, method): + # Emit code to fetch the shadow buffer, and invoke a method +- print ' gltrace::Context *ctx = gltrace::getContext();' +- print ' if (ctx->needsShadowBuffers() && target == GL_ELEMENT_ARRAY_BUFFER) {' +- print ' GLint buffer_binding = _glGetInteger(GL_ELEMENT_ARRAY_BUFFER_BINDING);' +- print ' if (buffer_binding > 0) {' +- print ' gltrace::Buffer & buf = ctx->buffers[buffer_binding];' +- print ' buf.' + method + ';' +- print ' }' +- print ' }' +- print ++ print(' gltrace::Context *ctx = gltrace::getContext();') ++ print(' if (ctx->needsShadowBuffers() && target == GL_ELEMENT_ARRAY_BUFFER) {') ++ print(' GLint buffer_binding = _glGetInteger(GL_ELEMENT_ARRAY_BUFFER_BINDING);') ++ print(' if (buffer_binding > 0) {') ++ print(' gltrace::Buffer & buf = ctx->buffers[buffer_binding];') ++ print(' buf.' + method + ';') ++ print(' }') ++ print(' }') ++ print() + + def shadowBufferProlog(self, function): + if function.name == 'glBufferData': +@@ -363,12 +363,12 @@ class GlTracer(Tracer): + self.shadowBufferMethod('bufferSubData(offset, size, data)') + + if function.name == 'glDeleteBuffers': +- print ' gltrace::Context *ctx = gltrace::getContext();' +- print ' if (ctx->needsShadowBuffers()) {' +- print ' for (GLsizei i = 0; i < n; i++) {' +- print ' ctx->buffers.erase(buffer[i]);' +- print ' }' +- print ' }' ++ print(' gltrace::Context *ctx = gltrace::getContext();') ++ print(' if (ctx->needsShadowBuffers()) {') ++ print(' for (GLsizei i = 0; i < n; i++) {') ++ print(' ctx->buffers.erase(buffer[i]);') ++ print(' }') ++ print(' }') + + array_pointer_function_names = set(( + "glVertexPointer", +@@ -426,42 +426,42 @@ class GlTracer(Tracer): + def traceFunctionImplBody(self, function): + # Defer tracing of user array pointers... + if function.name in self.array_pointer_function_names: +- print ' GLint _array_buffer = _glGetInteger(GL_ARRAY_BUFFER_BINDING);' +- print ' if (!_array_buffer) {' +- print ' static bool warned = false;' +- print ' if (!warned) {' +- print ' warned = true;' +- print ' os::log("apitrace: warning: %s: call will be faked due to pointer to user memory (https://github.com/apitrace/apitrace/blob/master/docs/BUGS.markdown#tracing)\\n", __FUNCTION__);' +- print ' }' +- print ' gltrace::Context *ctx = gltrace::getContext();' +- print ' ctx->user_arrays = true;' ++ print(' GLint _array_buffer = _glGetInteger(GL_ARRAY_BUFFER_BINDING);') ++ print(' if (!_array_buffer) {') ++ print(' static bool warned = false;') ++ print(' if (!warned) {') ++ print(' warned = true;') ++ print(' os::log("apitrace: warning: %s: call will be faked due to pointer to user memory (https://github.com/apitrace/apitrace/blob/master/docs/BUGS.markdown#tracing)\\n", __FUNCTION__);') ++ print(' }') ++ print(' gltrace::Context *ctx = gltrace::getContext();') ++ print(' ctx->user_arrays = true;') + if function.name == "glVertexAttribPointerNV": +- print ' ctx->user_arrays_nv = true;' ++ print(' ctx->user_arrays_nv = true;') + self.invokeFunction(function) + + # And also break down glInterleavedArrays into the individual calls + if function.name == 'glInterleavedArrays': +- print ++ print() + + # Initialize the enable flags + for camelcase_name, uppercase_name in self.arrays: + flag_name = '_' + uppercase_name.lower() +- print ' GLboolean %s = GL_FALSE;' % flag_name +- print ++ print(' GLboolean %s = GL_FALSE;' % flag_name) ++ print() + + # Switch for the interleaved formats +- print ' switch (format) {' ++ print(' switch (format) {') + for format in self.interleaved_formats: +- print ' case %s:' % format ++ print(' case %s:' % format) + for camelcase_name, uppercase_name in self.arrays: + flag_name = '_' + uppercase_name.lower() + if format.find('_' + uppercase_name[0]) >= 0: +- print ' %s = GL_TRUE;' % flag_name +- print ' break;' +- print ' default:' +- print ' return;' +- print ' }' +- print ++ print(' %s = GL_TRUE;' % flag_name) ++ print(' break;') ++ print(' default:') ++ print(' return;') ++ print(' }') ++ print() + + # Emit fake glEnableClientState/glDisableClientState flags + for camelcase_name, uppercase_name in self.arrays: +@@ -469,16 +469,16 @@ class GlTracer(Tracer): + enable_name = 'GL_%s_ARRAY' % uppercase_name + + # Emit a fake function +- print ' {' +- print ' static const trace::FunctionSig &_sig = %s ? _glEnableClientState_sig : _glDisableClientState_sig;' % flag_name +- print ' unsigned _call = trace::localWriter.beginEnter(&_sig, true);' +- print ' trace::localWriter.beginArg(0);' ++ print(' {') ++ print(' static const trace::FunctionSig &_sig = %s ? _glEnableClientState_sig : _glDisableClientState_sig;' % flag_name) ++ print(' unsigned _call = trace::localWriter.beginEnter(&_sig, true);') ++ print(' trace::localWriter.beginArg(0);') + self.serializeValue(glapi.GLenum, enable_name) +- print ' trace::localWriter.endArg();' +- print ' trace::localWriter.endEnter();' +- print ' trace::localWriter.beginLeave(_call);' +- print ' trace::localWriter.endLeave();' +- print ' }' ++ print(' trace::localWriter.endArg();') ++ print(' trace::localWriter.endEnter();') ++ print(' trace::localWriter.beginLeave(_call);') ++ print(' trace::localWriter.endLeave();') ++ print(' }') + + # Warn about buggy glGet(GL_*ARRAY_SIZE) not returning GL_BGRA + buggyFunctions = { +@@ -489,224 +489,224 @@ class GlTracer(Tracer): + } + if function.name in buggyFunctions: + getter, extraArg, pname = buggyFunctions[function.name] +- print r' static bool _checked = false;' +- print r' if (!_checked && size == GL_BGRA) {' +- print r' GLint _size = 0;' +- print r' _%s(%s%s, &_size);' % (getter, extraArg, pname) +- print r' if (_size != GL_BGRA) {' +- print r' os::log("apitrace: warning: %s(%s) does not return GL_BGRA; trace will be incorrect (https://github.com/apitrace/apitrace/issues/261)\n");' % (getter, pname) +- print r' }' +- print r' _checked = true;' +- print r' }' +- +- print ' return;' +- print ' }' ++ print(r' static bool _checked = false;') ++ print(r' if (!_checked && size == GL_BGRA) {') ++ print(r' GLint _size = 0;') ++ print(r' _%s(%s%s, &_size);' % (getter, extraArg, pname)) ++ print(r' if (_size != GL_BGRA) {') ++ print(r' os::log("apitrace: warning: %s(%s) does not return GL_BGRA; trace will be incorrect (https://github.com/apitrace/apitrace/issues/261)\n");' % (getter, pname)) ++ print(r' }') ++ print(r' _checked = true;') ++ print(r' }') ++ ++ print(' return;') ++ print(' }') + + # ... to the draw calls + if self.draw_function_regex.match(function.name): + if not self.multi_draw_function_regex.match(function.name): +- print ' if (trace::localWriter.isIgnored()) {' ++ print(' if (trace::localWriter.isIgnored()) {') + self.invokeFunction(function) +- print ' return;' +- print ' }' +- print ' if (_need_user_arrays()) {' ++ print(' return;') ++ print(' }') ++ print(' if (_need_user_arrays()) {') + if 'Indirect' in function.name: +- print r' os::log("apitrace: warning: %s: indirect user arrays not supported\n");' % (function.name,) ++ print(r' os::log("apitrace: warning: %s: indirect user arrays not supported\n");' % (function.name,)) + else: + arg_names = ', '.join([arg.name for arg in function.args[1:]]) +- print ' GLuint _count = _%s_count(%s);' % (function.name, arg_names) ++ print(' GLuint _count = _%s_count(%s);' % (function.name, arg_names)) + # Some apps, in particular Quake3, can tell the driver to lock more + # vertices than those actually required for the draw call. +- print ' if (_checkLockArraysEXT) {' +- print ' GLuint _locked_count = _glGetInteger(GL_ARRAY_ELEMENT_LOCK_FIRST_EXT)' +- print ' + _glGetInteger(GL_ARRAY_ELEMENT_LOCK_COUNT_EXT);' +- print ' _count = std::max(_count, _locked_count);' +- print ' }' +- print ' _trace_user_arrays(_count);' +- print ' }' ++ print(' if (_checkLockArraysEXT) {') ++ print(' GLuint _locked_count = _glGetInteger(GL_ARRAY_ELEMENT_LOCK_FIRST_EXT)') ++ print(' + _glGetInteger(GL_ARRAY_ELEMENT_LOCK_COUNT_EXT);') ++ print(' _count = std::max(_count, _locked_count);') ++ print(' }') ++ print(' _trace_user_arrays(_count);') ++ print(' }') + if function.name == 'glLockArraysEXT': +- print ' _checkLockArraysEXT = true;' ++ print(' _checkLockArraysEXT = true;') + + # Warn if user arrays are used with glBegin/glArrayElement/glEnd. + if function.name == 'glBegin': +- print r' gltrace::Context *ctx = gltrace::getContext();' +- print r' ctx->userArraysOnBegin = _need_user_arrays();' ++ print(r' gltrace::Context *ctx = gltrace::getContext();') ++ print(r' ctx->userArraysOnBegin = _need_user_arrays();') + if function.name.startswith('glArrayElement'): +- print r' gltrace::Context *ctx = gltrace::getContext();' +- print r' if (ctx->userArraysOnBegin) {' +- print r' os::log("apitrace: warning: user arrays with glArrayElement not supported (https://github.com/apitrace/apitrace/issues/276)\n");' +- print r' ctx->userArraysOnBegin = false;' +- print r' }' ++ print(r' gltrace::Context *ctx = gltrace::getContext();') ++ print(r' if (ctx->userArraysOnBegin) {') ++ print(r' os::log("apitrace: warning: user arrays with glArrayElement not supported (https://github.com/apitrace/apitrace/issues/276)\n");') ++ print(r' ctx->userArraysOnBegin = false;') ++ print(r' }') + + # Emit a fake memcpy on buffer uploads + if function.name == 'glBufferParameteriAPPLE': +- print ' if (pname == GL_BUFFER_FLUSHING_UNMAP_APPLE && param == GL_FALSE) {' +- print ' _checkBufferFlushingUnmapAPPLE = true;' +- print ' }' ++ print(' if (pname == GL_BUFFER_FLUSHING_UNMAP_APPLE && param == GL_FALSE) {') ++ print(' _checkBufferFlushingUnmapAPPLE = true;') ++ print(' }') + if function.name in ('glUnmapBuffer', 'glUnmapBufferARB'): + if function.name.endswith('ARB'): + suffix = 'ARB' + else: + suffix = '' +- print ' GLint access_flags = 0;' +- print ' GLint access = 0;' +- print ' bool flush;' +- print ' // GLES3 does not have GL_BUFFER_ACCESS;' +- print ' if (_checkBufferMapRange) {' +- print ' _glGetBufferParameteriv%s(target, GL_BUFFER_ACCESS_FLAGS, &access_flags);' % suffix +- print ' flush = (access_flags & GL_MAP_WRITE_BIT) && !(access_flags & (GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_PERSISTENT_BIT));' +- print ' } else {' +- print ' _glGetBufferParameteriv%s(target, GL_BUFFER_ACCESS, &access);' % suffix +- print ' flush = access != GL_READ_ONLY;' +- print ' }' +- print ' if (flush) {' +- print ' GLvoid *map = NULL;' +- print ' _glGetBufferPointerv%s(target, GL_BUFFER_MAP_POINTER, &map);' % suffix +- print ' if (map) {' +- print ' GLint length = -1;' +- print ' if (_checkBufferMapRange) {' +- print ' _glGetBufferParameteriv%s(target, GL_BUFFER_MAP_LENGTH, &length);' % suffix +- print ' if (length == -1) {' +- print ' // Mesa drivers refuse GL_BUFFER_MAP_LENGTH without GL 3.0 up-to' +- print ' // http://cgit.freedesktop.org/mesa/mesa/commit/?id=ffee498fb848b253a7833373fe5430f8c7ca0c5f' +- print ' static bool warned = false;' +- print ' if (!warned) {' +- print ' os::log("apitrace: warning: glGetBufferParameteriv%s(GL_BUFFER_MAP_LENGTH) failed\\n");' % suffix +- print ' warned = true;' +- print ' }' +- print ' }' +- print ' } else {' +- print ' length = 0;' +- print ' _glGetBufferParameteriv%s(target, GL_BUFFER_SIZE, &length);' % suffix +- print ' }' +- print ' if (_checkBufferFlushingUnmapAPPLE) {' +- print ' GLint flushing_unmap = GL_TRUE;' +- print ' _glGetBufferParameteriv%s(target, GL_BUFFER_FLUSHING_UNMAP_APPLE, &flushing_unmap);' % suffix +- print ' flush = flush && flushing_unmap;' +- print ' }' +- print ' if (flush && length > 0) {' ++ print(' GLint access_flags = 0;') ++ print(' GLint access = 0;') ++ print(' bool flush;') ++ print(' // GLES3 does not have GL_BUFFER_ACCESS;') ++ print(' if (_checkBufferMapRange) {') ++ print(' _glGetBufferParameteriv%s(target, GL_BUFFER_ACCESS_FLAGS, &access_flags);' % suffix) ++ print(' flush = (access_flags & GL_MAP_WRITE_BIT) && !(access_flags & (GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_PERSISTENT_BIT));') ++ print(' } else {') ++ print(' _glGetBufferParameteriv%s(target, GL_BUFFER_ACCESS, &access);' % suffix) ++ print(' flush = access != GL_READ_ONLY;') ++ print(' }') ++ print(' if (flush) {') ++ print(' GLvoid *map = NULL;') ++ print(' _glGetBufferPointerv%s(target, GL_BUFFER_MAP_POINTER, &map);' % suffix) ++ print(' if (map) {') ++ print(' GLint length = -1;') ++ print(' if (_checkBufferMapRange) {') ++ print(' _glGetBufferParameteriv%s(target, GL_BUFFER_MAP_LENGTH, &length);' % suffix) ++ print(' if (length == -1) {') ++ print(' // Mesa drivers refuse GL_BUFFER_MAP_LENGTH without GL 3.0 up-to') ++ print(' // http://cgit.freedesktop.org/mesa/mesa/commit/?id=ffee498fb848b253a7833373fe5430f8c7ca0c5f') ++ print(' static bool warned = false;') ++ print(' if (!warned) {') ++ print(' os::log("apitrace: warning: glGetBufferParameteriv%s(GL_BUFFER_MAP_LENGTH) failed\\n");' % suffix) ++ print(' warned = true;') ++ print(' }') ++ print(' }') ++ print(' } else {') ++ print(' length = 0;') ++ print(' _glGetBufferParameteriv%s(target, GL_BUFFER_SIZE, &length);' % suffix) ++ print(' }') ++ print(' if (_checkBufferFlushingUnmapAPPLE) {') ++ print(' GLint flushing_unmap = GL_TRUE;') ++ print(' _glGetBufferParameteriv%s(target, GL_BUFFER_FLUSHING_UNMAP_APPLE, &flushing_unmap);' % suffix) ++ print(' flush = flush && flushing_unmap;') ++ print(' }') ++ print(' if (flush && length > 0) {') + self.emit_memcpy('map', 'length') +- print ' }' +- print ' }' +- print ' }' ++ print(' }') ++ print(' }') ++ print(' }') + if function.name == 'glUnmapBufferOES': +- print ' GLint access_flags = 0;' +- print ' GLint access = 0;' +- print ' bool flush;' +- print ' // GLES3 does not have GL_BUFFER_ACCESS;' +- print ' if (_checkBufferMapRange) {' +- print ' _glGetBufferParameteriv(target, GL_BUFFER_ACCESS_FLAGS, &access_flags);' +- print ' flush = (access_flags & GL_MAP_WRITE_BIT) && !(access_flags & (GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_PERSISTENT_BIT));' +- print ' } else {' +- print ' _glGetBufferParameteriv(target, GL_BUFFER_ACCESS, &access);' +- print ' flush = access != GL_READ_ONLY;' +- print ' }' +- print ' if (flush) {' +- print ' GLvoid *map = NULL;' +- print ' _glGetBufferPointervOES(target, GL_BUFFER_MAP_POINTER, &map);' +- print ' if (map) {' +- print ' GLint length = 0;' +- print ' GLint offset = 0;' +- print ' if (_checkBufferMapRange) {' +- print ' _glGetBufferParameteriv(target, GL_BUFFER_MAP_LENGTH, &length);' +- print ' _glGetBufferParameteriv(target, GL_BUFFER_MAP_OFFSET, &offset);' +- print ' } else {' +- print ' _glGetBufferParameteriv(target, GL_BUFFER_SIZE, &length);' +- print ' }' +- print ' if (flush && length > 0) {' ++ print(' GLint access_flags = 0;') ++ print(' GLint access = 0;') ++ print(' bool flush;') ++ print(' // GLES3 does not have GL_BUFFER_ACCESS;') ++ print(' if (_checkBufferMapRange) {') ++ print(' _glGetBufferParameteriv(target, GL_BUFFER_ACCESS_FLAGS, &access_flags);') ++ print(' flush = (access_flags & GL_MAP_WRITE_BIT) && !(access_flags & (GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_PERSISTENT_BIT));') ++ print(' } else {') ++ print(' _glGetBufferParameteriv(target, GL_BUFFER_ACCESS, &access);') ++ print(' flush = access != GL_READ_ONLY;') ++ print(' }') ++ print(' if (flush) {') ++ print(' GLvoid *map = NULL;') ++ print(' _glGetBufferPointervOES(target, GL_BUFFER_MAP_POINTER, &map);') ++ print(' if (map) {') ++ print(' GLint length = 0;') ++ print(' GLint offset = 0;') ++ print(' if (_checkBufferMapRange) {') ++ print(' _glGetBufferParameteriv(target, GL_BUFFER_MAP_LENGTH, &length);') ++ print(' _glGetBufferParameteriv(target, GL_BUFFER_MAP_OFFSET, &offset);') ++ print(' } else {') ++ print(' _glGetBufferParameteriv(target, GL_BUFFER_SIZE, &length);') ++ print(' }') ++ print(' if (flush && length > 0) {') + self.emit_memcpy('map', 'length') + self.shadowBufferMethod('bufferSubData(offset, length, map)') +- print ' }' +- print ' }' +- print ' }' ++ print(' }') ++ print(' }') ++ print(' }') + if function.name == 'glUnmapNamedBuffer': +- print ' GLint access_flags = 0;' +- print ' _glGetNamedBufferParameteriv(buffer, GL_BUFFER_ACCESS_FLAGS, &access_flags);' +- print ' if ((access_flags & GL_MAP_WRITE_BIT) &&' +- print ' !(access_flags & (GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_PERSISTENT_BIT))) {' +- print ' GLvoid *map = NULL;' +- print ' _glGetNamedBufferPointerv(buffer, GL_BUFFER_MAP_POINTER, &map);' +- print ' GLint length = 0;' +- print ' _glGetNamedBufferParameteriv(buffer, GL_BUFFER_MAP_LENGTH, &length);' +- print ' if (map && length > 0) {' ++ print(' GLint access_flags = 0;') ++ print(' _glGetNamedBufferParameteriv(buffer, GL_BUFFER_ACCESS_FLAGS, &access_flags);') ++ print(' if ((access_flags & GL_MAP_WRITE_BIT) &&') ++ print(' !(access_flags & (GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_PERSISTENT_BIT))) {') ++ print(' GLvoid *map = NULL;') ++ print(' _glGetNamedBufferPointerv(buffer, GL_BUFFER_MAP_POINTER, &map);') ++ print(' GLint length = 0;') ++ print(' _glGetNamedBufferParameteriv(buffer, GL_BUFFER_MAP_LENGTH, &length);') ++ print(' if (map && length > 0) {') + self.emit_memcpy('map', 'length') +- print ' }' +- print ' }' ++ print(' }') ++ print(' }') + if function.name == 'glUnmapNamedBufferEXT': +- print ' GLint access_flags = 0;' +- print ' _glGetNamedBufferParameterivEXT(buffer, GL_BUFFER_ACCESS_FLAGS, &access_flags);' +- print ' if ((access_flags & GL_MAP_WRITE_BIT) &&' +- print ' !(access_flags & (GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_PERSISTENT_BIT))) {' +- print ' GLvoid *map = NULL;' +- print ' _glGetNamedBufferPointervEXT(buffer, GL_BUFFER_MAP_POINTER, &map);' +- print ' GLint length = 0;' +- print ' _glGetNamedBufferParameterivEXT(buffer, GL_BUFFER_MAP_LENGTH, &length);' +- print ' if (map && length > 0) {' ++ print(' GLint access_flags = 0;') ++ print(' _glGetNamedBufferParameterivEXT(buffer, GL_BUFFER_ACCESS_FLAGS, &access_flags);') ++ print(' if ((access_flags & GL_MAP_WRITE_BIT) &&') ++ print(' !(access_flags & (GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_PERSISTENT_BIT))) {') ++ print(' GLvoid *map = NULL;') ++ print(' _glGetNamedBufferPointervEXT(buffer, GL_BUFFER_MAP_POINTER, &map);') ++ print(' GLint length = 0;') ++ print(' _glGetNamedBufferParameterivEXT(buffer, GL_BUFFER_MAP_LENGTH, &length);') ++ print(' if (map && length > 0) {') + self.emit_memcpy('map', 'length') +- print ' }' +- print ' }' ++ print(' }') ++ print(' }') + if function.name == 'glFlushMappedBufferRange': +- print ' GLvoid *map = NULL;' +- print ' _glGetBufferPointerv(target, GL_BUFFER_MAP_POINTER, &map);' +- print ' if (map && length > 0) {' ++ print(' GLvoid *map = NULL;') ++ print(' _glGetBufferPointerv(target, GL_BUFFER_MAP_POINTER, &map);') ++ print(' if (map && length > 0) {') + self.emit_memcpy('(const char *)map + offset', 'length') +- print ' }' ++ print(' }') + if function.name == 'glFlushMappedBufferRangeEXT': +- print ' GLvoid *map = NULL;' +- print ' _glGetBufferPointervOES(target, GL_BUFFER_MAP_POINTER_OES, &map);' +- print ' if (map && length > 0) {' ++ print(' GLvoid *map = NULL;') ++ print(' _glGetBufferPointervOES(target, GL_BUFFER_MAP_POINTER_OES, &map);') ++ print(' if (map && length > 0) {') + self.emit_memcpy('(const char *)map + offset', 'length') +- print ' }' ++ print(' }') + if function.name == 'glFlushMappedBufferRangeAPPLE': +- print ' GLvoid *map = NULL;' +- print ' _glGetBufferPointerv(target, GL_BUFFER_MAP_POINTER, &map);' +- print ' if (map && size > 0) {' ++ print(' GLvoid *map = NULL;') ++ print(' _glGetBufferPointerv(target, GL_BUFFER_MAP_POINTER, &map);') ++ print(' if (map && size > 0) {') + self.emit_memcpy('(const char *)map + offset', 'size') +- print ' }' ++ print(' }') + if function.name == 'glFlushMappedNamedBufferRange': +- print ' GLvoid *map = NULL;' +- print ' _glGetNamedBufferPointerv(buffer, GL_BUFFER_MAP_POINTER, &map);' +- print ' if (map && length > 0) {' ++ print(' GLvoid *map = NULL;') ++ print(' _glGetNamedBufferPointerv(buffer, GL_BUFFER_MAP_POINTER, &map);') ++ print(' if (map && length > 0) {') + self.emit_memcpy('(const char *)map + offset', 'length') +- print ' }' ++ print(' }') + if function.name == 'glFlushMappedNamedBufferRangeEXT': +- print ' GLvoid *map = NULL;' +- print ' _glGetNamedBufferPointervEXT(buffer, GL_BUFFER_MAP_POINTER, &map);' +- print ' if (map && length > 0) {' ++ print(' GLvoid *map = NULL;') ++ print(' _glGetNamedBufferPointervEXT(buffer, GL_BUFFER_MAP_POINTER, &map);') ++ print(' if (map && length > 0) {') + self.emit_memcpy('(const char *)map + offset', 'length') +- print ' }' ++ print(' }') + + # FIXME: We don't support coherent/pinned memory mappings + if function.name in ('glBufferStorage', 'glNamedBufferStorage', 'glNamedBufferStorageEXT'): +- print r' if (!(flags & GL_MAP_PERSISTENT_BIT)) {' +- print r' os::log("apitrace: warning: %s: MAP_NOTIFY_EXPLICIT_BIT_VMWX set w/o MAP_PERSISTENT_BIT\n", __FUNCTION__);' +- print r' }' +- print r' flags &= ~GL_MAP_NOTIFY_EXPLICIT_BIT_VMWX;' ++ print(r' if (!(flags & GL_MAP_PERSISTENT_BIT)) {') ++ print(r' os::log("apitrace: warning: %s: MAP_NOTIFY_EXPLICIT_BIT_VMWX set w/o MAP_PERSISTENT_BIT\n", __FUNCTION__);') ++ print(r' }') ++ print(r' flags &= ~GL_MAP_NOTIFY_EXPLICIT_BIT_VMWX;') + if function.name in ('glMapBufferRange', 'glMapBufferRangeEXT', 'glMapNamedBufferRange', 'glMapNamedBufferRangeEXT'): +- print r' if (access & GL_MAP_NOTIFY_EXPLICIT_BIT_VMWX) {' +- print r' if (!(access & GL_MAP_PERSISTENT_BIT)) {' +- print r' os::log("apitrace: warning: %s: MAP_NOTIFY_EXPLICIT_BIT_VMWX set w/o MAP_PERSISTENT_BIT\n", __FUNCTION__);' +- print r' }' +- print r' if (access & GL_MAP_FLUSH_EXPLICIT_BIT) {' +- print r' os::log("apitrace: warning: %s: MAP_NOTIFY_EXPLICIT_BIT_VMWX set w/ MAP_FLUSH_EXPLICIT_BIT\n", __FUNCTION__);' +- print r' }' +- print r' access &= ~GL_MAP_NOTIFY_EXPLICIT_BIT_VMWX;' +- print r' } else if (access & GL_MAP_COHERENT_BIT) {' +- print r' os::log("apitrace: warning: %s: MAP_COHERENT_BIT unsupported (https://github.com/apitrace/apitrace/issues/232)\n", __FUNCTION__);' +- print r' } else if ((access & GL_MAP_PERSISTENT_BIT) &&' +- print r' !(access & GL_MAP_FLUSH_EXPLICIT_BIT)) {' +- print r' os::log("apitrace: warning: %s: MAP_PERSISTENT_BIT w/o FLUSH_EXPLICIT_BIT unsupported (https://github.com/apitrace/apitrace/issues/232)\n", __FUNCTION__);' +- print r' }' ++ print(r' if (access & GL_MAP_NOTIFY_EXPLICIT_BIT_VMWX) {') ++ print(r' if (!(access & GL_MAP_PERSISTENT_BIT)) {') ++ print(r' os::log("apitrace: warning: %s: MAP_NOTIFY_EXPLICIT_BIT_VMWX set w/o MAP_PERSISTENT_BIT\n", __FUNCTION__);') ++ print(r' }') ++ print(r' if (access & GL_MAP_FLUSH_EXPLICIT_BIT) {') ++ print(r' os::log("apitrace: warning: %s: MAP_NOTIFY_EXPLICIT_BIT_VMWX set w/ MAP_FLUSH_EXPLICIT_BIT\n", __FUNCTION__);') ++ print(r' }') ++ print(r' access &= ~GL_MAP_NOTIFY_EXPLICIT_BIT_VMWX;') ++ print(r' } else if (access & GL_MAP_COHERENT_BIT) {') ++ print(r' os::log("apitrace: warning: %s: MAP_COHERENT_BIT unsupported (https://github.com/apitrace/apitrace/issues/232)\n", __FUNCTION__);') ++ print(r' } else if ((access & GL_MAP_PERSISTENT_BIT) &&') ++ print(r' !(access & GL_MAP_FLUSH_EXPLICIT_BIT)) {') ++ print(r' os::log("apitrace: warning: %s: MAP_PERSISTENT_BIT w/o FLUSH_EXPLICIT_BIT unsupported (https://github.com/apitrace/apitrace/issues/232)\n", __FUNCTION__);') ++ print(r' }') + if function.name in ('glBufferData', 'glBufferDataARB'): +- print r' if (target == GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD) {' +- print r' os::log("apitrace: warning: GL_AMD_pinned_memory not fully supported\n");' +- print r' }' ++ print(r' if (target == GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD) {') ++ print(r' os::log("apitrace: warning: GL_AMD_pinned_memory not fully supported\n");') ++ print(r' }') + + # TODO: We don't track GL_INTEL_map_texture mappings + if function.name == 'glMapTexture2DINTEL': +- print r' if (access & GL_MAP_WRITE_BIT) {' +- print r' os::log("apitrace: warning: GL_INTEL_map_texture not fully supported\n");' +- print r' }' ++ print(r' if (access & GL_MAP_WRITE_BIT) {') ++ print(r' os::log("apitrace: warning: GL_INTEL_map_texture not fully supported\n");') ++ print(r' }') + + # Don't leave vertex attrib locations to chance. Instead emit fake + # glBindAttribLocation calls to ensure that the same locations will be +@@ -715,40 +715,40 @@ class GlTracer(Tracer): + # many entry-points, including non-shader related ones. + if function.name == 'glLinkProgram': + Tracer.invokeFunction(self, function) +- print ' GLint active_attributes = 0;' +- print ' _glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &active_attributes);' +- print ' for (GLint attrib = 0; attrib < active_attributes; ++attrib) {' +- print ' GLint size = 0;' +- print ' GLenum type = 0;' +- print ' GLchar name[256];' ++ print(' GLint active_attributes = 0;') ++ print(' _glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &active_attributes);') ++ print(' for (GLint attrib = 0; attrib < active_attributes; ++attrib) {') ++ print(' GLint size = 0;') ++ print(' GLenum type = 0;') ++ print(' GLchar name[256];') + # TODO: Use ACTIVE_ATTRIBUTE_MAX_LENGTH instead of 256 +- print ' _glGetActiveAttrib(program, attrib, sizeof name, NULL, &size, &type, name);' +- print " if (name[0] != 'g' || name[1] != 'l' || name[2] != '_') {" +- print ' GLint location = _glGetAttribLocation(program, name);' +- print ' if (location >= 0) {' ++ print(' _glGetActiveAttrib(program, attrib, sizeof name, NULL, &size, &type, name);') ++ print(" if (name[0] != 'g' || name[1] != 'l' || name[2] != '_') {") ++ print(' GLint location = _glGetAttribLocation(program, name);') ++ print(' if (location >= 0) {') + bind_function = glapi.glapi.getFunctionByName('glBindAttribLocation') + self.fake_call(bind_function, ['program', 'location', 'name']) +- print ' }' +- print ' }' +- print ' }' ++ print(' }') ++ print(' }') ++ print(' }') + if function.name == 'glLinkProgramARB': + Tracer.invokeFunction(self, function) +- print ' GLint active_attributes = 0;' +- print ' _glGetObjectParameterivARB(programObj, GL_OBJECT_ACTIVE_ATTRIBUTES_ARB, &active_attributes);' +- print ' for (GLint attrib = 0; attrib < active_attributes; ++attrib) {' +- print ' GLint size = 0;' +- print ' GLenum type = 0;' +- print ' GLcharARB name[256];' ++ print(' GLint active_attributes = 0;') ++ print(' _glGetObjectParameterivARB(programObj, GL_OBJECT_ACTIVE_ATTRIBUTES_ARB, &active_attributes);') ++ print(' for (GLint attrib = 0; attrib < active_attributes; ++attrib) {') ++ print(' GLint size = 0;') ++ print(' GLenum type = 0;') ++ print(' GLcharARB name[256];') + # TODO: Use ACTIVE_ATTRIBUTE_MAX_LENGTH instead of 256 +- print ' _glGetActiveAttribARB(programObj, attrib, sizeof name, NULL, &size, &type, name);' +- print " if (name[0] != 'g' || name[1] != 'l' || name[2] != '_') {" +- print ' GLint location = _glGetAttribLocationARB(programObj, name);' +- print ' if (location >= 0) {' ++ print(' _glGetActiveAttribARB(programObj, attrib, sizeof name, NULL, &size, &type, name);') ++ print(" if (name[0] != 'g' || name[1] != 'l' || name[2] != '_') {") ++ print(' GLint location = _glGetAttribLocationARB(programObj, name);') ++ print(' if (location >= 0) {') + bind_function = glapi.glapi.getFunctionByName('glBindAttribLocationARB') + self.fake_call(bind_function, ['programObj', 'location', 'name']) +- print ' }' +- print ' }' +- print ' }' ++ print(' }') ++ print(' }') ++ print(' }') + + self.shadowBufferProlog(function) + +@@ -815,9 +815,9 @@ class GlTracer(Tracer): + # Force glProgramBinary to fail. Per ARB_get_program_binary this + # should signal the app that it needs to recompile. + if function.name in ('glProgramBinary', 'glProgramBinaryOES'): +- print r' binaryFormat = 0xDEADDEAD;' +- print r' binary = &binaryFormat;' +- print r' length = sizeof binaryFormat;' ++ print(r' binaryFormat = 0xDEADDEAD;') ++ print(r' binary = &binaryFormat;') ++ print(r' length = sizeof binaryFormat;') + + Tracer.invokeFunction(self, function) + +@@ -838,25 +838,25 @@ class GlTracer(Tracer): + # We may be faking KHR_debug, so ensure the pointer queries result is + # always zeroed to prevent dereference of unitialized pointers + if function.name == 'glGetPointerv': +- print ' if (params &&' +- print ' (pname == GL_DEBUG_CALLBACK_FUNCTION ||' +- print ' pname == GL_DEBUG_CALLBACK_USER_PARAM)) {' +- print ' *params = NULL;' +- print ' }' ++ print(' if (params &&') ++ print(' (pname == GL_DEBUG_CALLBACK_FUNCTION ||') ++ print(' pname == GL_DEBUG_CALLBACK_USER_PARAM)) {') ++ print(' *params = NULL;') ++ print(' }') + + if function.name in self.getProcAddressFunctionNames: + nameArg = function.args[0].name +- print ' if (strcmp("glNotifyMappedBufferRangeVMWX", (const char *)%s) == 0) {' % (nameArg,) +- print ' _result = (%s)&glNotifyMappedBufferRangeVMWX;' % (function.type,) +- print ' } else if (strcmp("glTexDirectVIV", (const char *)%s) == 0) {' % (nameArg,) +- print ' _result = (%s)&glTexDirectVIV;' % (function.type,) +- print ' } else if (strcmp("glTexDirectInvalidateVIV", (const char *)%s) == 0) {' % (nameArg,) +- print ' _result = (%s)&glTexDirectInvalidateVIV;' % (function.type,) ++ print(' if (strcmp("glNotifyMappedBufferRangeVMWX", (const char *)%s) == 0) {' % (nameArg,)) ++ print(' _result = (%s)&glNotifyMappedBufferRangeVMWX;' % (function.type,)) ++ print(' } else if (strcmp("glTexDirectVIV", (const char *)%s) == 0) {' % (nameArg,)) ++ print(' _result = (%s)&glTexDirectVIV;' % (function.type,)) ++ print(' } else if (strcmp("glTexDirectInvalidateVIV", (const char *)%s) == 0) {' % (nameArg,)) ++ print(' _result = (%s)&glTexDirectInvalidateVIV;' % (function.type,)) + for marker_function in self.marker_functions: + if self.api.getFunctionByName(marker_function): +- print ' } else if (strcmp("%s", (const char *)%s) == 0) {' % (marker_function, nameArg) +- print ' _result = (%s)&%s;' % (function.type, marker_function) +- print ' } else {' ++ print(' } else if (strcmp("%s", (const char *)%s) == 0) {' % (marker_function, nameArg)) ++ print(' _result = (%s)&%s;' % (function.type, marker_function)) ++ print(' } else {') + Tracer.doInvokeFunction(self, function) + + # Replace function addresses with ours +@@ -864,24 +864,24 @@ class GlTracer(Tracer): + # contain the addresses of the wrapper functions, and not the real + # functions, but in practice this should make no difference. + if function.name in self.getProcAddressFunctionNames: +- print ' _result = _wrapProcAddress(%s, _result);' % (nameArg,) ++ print(' _result = _wrapProcAddress(%s, _result);' % (nameArg,)) + +- print ' }' ++ print(' }') + return + + if function.name in ('glGetProgramBinary', 'glGetProgramBinaryOES'): +- print r' bufSize = 0;' ++ print(r' bufSize = 0;') + + Tracer.doInvokeFunction(self, function) + + if function.name == 'glGetProgramiv': +- print r' if (params && pname == GL_PROGRAM_BINARY_LENGTH) {' +- print r' *params = 0;' +- print r' }' ++ print(r' if (params && pname == GL_PROGRAM_BINARY_LENGTH) {') ++ print(r' *params = 0;') ++ print(r' }') + if function.name in ('glGetProgramBinary', 'glGetProgramBinaryOES'): +- print r' if (length) {' +- print r' *length = 0;' +- print r' }' ++ print(r' if (length) {') ++ print(r' *length = 0;') ++ print(r' }') + + buffer_targets = [ + 'ARRAY_BUFFER', +@@ -902,9 +902,9 @@ class GlTracer(Tracer): + + # Keep track of buffer mappings + if function.name in ('glMapBufferRange', 'glMapBufferRangeEXT'): +- print ' if (access & GL_MAP_WRITE_BIT) {' +- print ' _checkBufferMapRange = true;' +- print ' }' ++ print(' if (access & GL_MAP_WRITE_BIT) {') ++ print(' _checkBufferMapRange = true;') ++ print(' }') + + boolean_names = [ + 'GL_FALSE', +@@ -932,17 +932,17 @@ class GlTracer(Tracer): + and (isinstance(arg.type, stdapi.Blob) \ + or (isinstance(arg.type, stdapi.Const) \ + and isinstance(arg.type.type, stdapi.Blob))): +- print ' {' +- print ' gltrace::Context *ctx = gltrace::getContext();' +- print ' GLint _unpack_buffer = 0;' +- print ' if (ctx->profile.desktop())' +- print ' _glGetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, &_unpack_buffer);' +- print ' if (_unpack_buffer) {' +- print ' trace::localWriter.writePointer((uintptr_t)%s);' % arg.name +- print ' } else {' ++ print(' {') ++ print(' gltrace::Context *ctx = gltrace::getContext();') ++ print(' GLint _unpack_buffer = 0;') ++ print(' if (ctx->profile.desktop())') ++ print(' _glGetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, &_unpack_buffer);') ++ print(' if (_unpack_buffer) {') ++ print(' trace::localWriter.writePointer((uintptr_t)%s);' % arg.name) ++ print(' } else {') + Tracer.serializeArgValue(self, function, arg) +- print ' }' +- print ' }' ++ print(' }') ++ print(' }') + return + + # Several GL state functions take GLenum symbolic names as +@@ -953,11 +953,11 @@ class GlTracer(Tracer): + assert arg.index > 0 + assert function.args[arg.index - 1].name == 'pname' + assert function.args[arg.index - 1].type == glapi.GLenum +- print ' if (is_symbolic_pname(pname) && is_symbolic_param(%s)) {' % arg.name ++ print(' if (is_symbolic_pname(pname) && is_symbolic_param(%s)) {' % arg.name) + self.serializeValue(glapi.GLenum, arg.name) +- print ' } else {' ++ print(' } else {') + Tracer.serializeArgValue(self, function, arg) +- print ' }' ++ print(' }') + return + + Tracer.serializeArgValue(self, function, arg) +@@ -967,20 +967,20 @@ class GlTracer(Tracer): + + # A simple state tracker to track the pointer values + # update the state +- print 'static void _trace_user_arrays(GLuint count)' +- print '{' +- print ' gltrace::Context *ctx = gltrace::getContext();' +- print +- print ' glprofile::Profile profile = ctx->profile;' +- print ' bool es1 = profile.es() && profile.major == 1;' +- print ++ print('static void _trace_user_arrays(GLuint count)') ++ print('{') ++ print(' gltrace::Context *ctx = gltrace::getContext();') ++ print() ++ print(' glprofile::Profile profile = ctx->profile;') ++ print(' bool es1 = profile.es() && profile.major == 1;') ++ print() + + # Temporarily unbind the array buffer +- print ' GLint _array_buffer = _glGetInteger(GL_ARRAY_BUFFER_BINDING);' +- print ' if (_array_buffer) {' ++ print(' GLint _array_buffer = _glGetInteger(GL_ARRAY_BUFFER_BINDING);') ++ print(' if (_array_buffer) {') + self.fake_glBindBuffer(api, 'GL_ARRAY_BUFFER', '0') +- print ' }' +- print ++ print(' }') ++ print() + + for camelcase_name, uppercase_name in self.arrays: + # in which profile is the array available? +@@ -993,45 +993,45 @@ class GlTracer(Tracer): + binding_name = 'GL_%s_ARRAY_BUFFER_BINDING' % uppercase_name + function = api.getFunctionByName(function_name) + +- print ' // %s' % function.prototype() +- print ' if (%s) {' % profile_check ++ print(' // %s' % function.prototype()) ++ print(' if (%s) {' % profile_check) + self.array_trace_prolog(api, uppercase_name) + self.array_prolog(api, uppercase_name) +- print ' if (_glIsEnabled(%s)) {' % enable_name +- print ' GLint _binding = _glGetInteger(%s);' % binding_name +- print ' if (!_binding) {' ++ print(' if (_glIsEnabled(%s)) {' % enable_name) ++ print(' GLint _binding = _glGetInteger(%s);' % binding_name) ++ print(' if (!_binding) {') + + # Get the arguments via glGet* + for arg in function.args: + arg_get_enum = 'GL_%s_ARRAY_%s' % (uppercase_name, arg.name.upper()) + arg_get_function, arg_type = TypeGetter().visit(arg.type) +- print ' %s %s = 0;' % (arg_type, arg.name) +- print ' _%s(%s, &%s);' % (arg_get_function, arg_get_enum, arg.name) ++ print(' %s %s = 0;' % (arg_type, arg.name)) ++ print(' _%s(%s, &%s);' % (arg_get_function, arg_get_enum, arg.name)) + + arg_names = ', '.join([arg.name for arg in function.args[:-1]]) +- print ' size_t _size = _%s_size(%s, count);' % (function.name, arg_names) ++ print(' size_t _size = _%s_size(%s, count);' % (function.name, arg_names)) + + # Emit a fake function + self.array_trace_intermezzo(api, uppercase_name) +- print ' unsigned _call = trace::localWriter.beginEnter(&_%s_sig, true);' % (function.name,) ++ print(' unsigned _call = trace::localWriter.beginEnter(&_%s_sig, true);' % (function.name,)) + for arg in function.args: + assert not arg.output +- print ' trace::localWriter.beginArg(%u);' % (arg.index,) ++ print(' trace::localWriter.beginArg(%u);' % (arg.index,)) + if arg.name != 'pointer': + self.serializeValue(arg.type, arg.name) + else: +- print ' trace::localWriter.writeBlob((const void *)%s, _size);' % (arg.name) +- print ' trace::localWriter.endArg();' ++ print(' trace::localWriter.writeBlob((const void *)%s, _size);' % (arg.name)) ++ print(' trace::localWriter.endArg();') + +- print ' trace::localWriter.endEnter();' +- print ' trace::localWriter.beginLeave(_call);' +- print ' trace::localWriter.endLeave();' +- print ' }' +- print ' }' ++ print(' trace::localWriter.endEnter();') ++ print(' trace::localWriter.beginLeave(_call);') ++ print(' trace::localWriter.endLeave();') ++ print(' }') ++ print(' }') + self.array_epilog(api, uppercase_name) + self.array_trace_epilog(api, uppercase_name) +- print ' }' +- print ++ print(' }') ++ print() + + # Samething, but for glVertexAttribPointer* + # +@@ -1043,12 +1043,12 @@ class GlTracer(Tracer): + # This means that the implementations of these functions do not always + # alias, and they need to be considered independently. + # +- print ' // ES1 does not support generic vertex attributes' +- print ' if (es1)' +- print ' return;' +- print +- print ' vertex_attrib _vertex_attrib = _get_vertex_attrib();' +- print ++ print(' // ES1 does not support generic vertex attributes') ++ print(' if (es1)') ++ print(' return;') ++ print() ++ print(' vertex_attrib _vertex_attrib = _get_vertex_attrib();') ++ print() + for suffix in ['', 'NV']: + if suffix: + SUFFIX = '_' + suffix +@@ -1057,24 +1057,24 @@ class GlTracer(Tracer): + function_name = 'glVertexAttribPointer' + suffix + function = api.getFunctionByName(function_name) + +- print ' // %s' % function.prototype() +- print ' if (_vertex_attrib == VERTEX_ATTRIB%s) {' % SUFFIX ++ print(' // %s' % function.prototype()) ++ print(' if (_vertex_attrib == VERTEX_ATTRIB%s) {' % SUFFIX) + if suffix == 'NV': +- print ' GLint _max_vertex_attribs = 16;' ++ print(' GLint _max_vertex_attribs = 16;') + else: +- print ' GLint _max_vertex_attribs = _glGetInteger(GL_MAX_VERTEX_ATTRIBS);' +- print ' for (GLint index = 0; index < _max_vertex_attribs; ++index) {' +- print ' GLint _enabled = 0;' ++ print(' GLint _max_vertex_attribs = _glGetInteger(GL_MAX_VERTEX_ATTRIBS);') ++ print(' for (GLint index = 0; index < _max_vertex_attribs; ++index) {') ++ print(' GLint _enabled = 0;') + if suffix == 'NV': +- print ' _glGetIntegerv(GL_VERTEX_ATTRIB_ARRAY0_NV + index, &_enabled);' ++ print(' _glGetIntegerv(GL_VERTEX_ATTRIB_ARRAY0_NV + index, &_enabled);') + else: +- print ' _glGetVertexAttribiv%s(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED%s, &_enabled);' % (suffix, SUFFIX) +- print ' if (_enabled) {' +- print ' GLint _binding = 0;' ++ print(' _glGetVertexAttribiv%s(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED%s, &_enabled);' % (suffix, SUFFIX)) ++ print(' if (_enabled) {') ++ print(' GLint _binding = 0;') + if suffix != 'NV': + # It doesn't seem possible to use VBOs with NV_vertex_program. +- print ' _glGetVertexAttribiv%s(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING%s, &_binding);' % (suffix, SUFFIX) +- print ' if (!_binding) {' ++ print(' _glGetVertexAttribiv%s(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING%s, &_binding);' % (suffix, SUFFIX)) ++ print(' if (!_binding) {') + + # Get the arguments via glGet* + for arg in function.args[1:]: +@@ -1083,40 +1083,40 @@ class GlTracer(Tracer): + else: + arg_get_enum = 'GL_VERTEX_ATTRIB_ARRAY_%s%s' % (arg.name.upper(), SUFFIX) + arg_get_function, arg_type = TypeGetter('glGetVertexAttrib', False, suffix).visit(arg.type) +- print ' %s %s = 0;' % (arg_type, arg.name) +- print ' _%s(index, %s, &%s);' % (arg_get_function, arg_get_enum, arg.name) ++ print(' %s %s = 0;' % (arg_type, arg.name)) ++ print(' _%s(index, %s, &%s);' % (arg_get_function, arg_get_enum, arg.name)) + + arg_names = ', '.join([arg.name for arg in function.args[1:-1]]) +- print ' size_t _size = _%s_size(%s, count);' % (function.name, arg_names) ++ print(' size_t _size = _%s_size(%s, count);' % (function.name, arg_names)) + + # Emit a fake function +- print ' unsigned _call = trace::localWriter.beginEnter(&_%s_sig, true);' % (function.name,) ++ print(' unsigned _call = trace::localWriter.beginEnter(&_%s_sig, true);' % (function.name,)) + for arg in function.args: + assert not arg.output +- print ' trace::localWriter.beginArg(%u);' % (arg.index,) ++ print(' trace::localWriter.beginArg(%u);' % (arg.index,)) + if arg.name != 'pointer': + self.serializeValue(arg.type, arg.name) + else: +- print ' trace::localWriter.writeBlob((const void *)%s, _size);' % (arg.name) +- print ' trace::localWriter.endArg();' ++ print(' trace::localWriter.writeBlob((const void *)%s, _size);' % (arg.name)) ++ print(' trace::localWriter.endArg();') + +- print ' trace::localWriter.endEnter();' +- print ' trace::localWriter.beginLeave(_call);' +- print ' trace::localWriter.endLeave();' +- print ' }' +- print ' }' +- print ' }' +- print ' }' +- print ++ print(' trace::localWriter.endEnter();') ++ print(' trace::localWriter.beginLeave(_call);') ++ print(' trace::localWriter.endLeave();') ++ print(' }') ++ print(' }') ++ print(' }') ++ print(' }') ++ print() + + # Restore the original array_buffer +- print ' if (_array_buffer) {' ++ print(' if (_array_buffer) {') + self.fake_glBindBuffer(api, 'GL_ARRAY_BUFFER', '_array_buffer') +- print ' }' +- print ++ print(' }') ++ print() + +- print '}' +- print ++ print('}') ++ print() + + # + # Hooks for glTexCoordPointer, which is identical to the other array +@@ -1125,49 +1125,49 @@ class GlTracer(Tracer): + + def array_prolog(self, api, uppercase_name): + if uppercase_name == 'TEXTURE_COORD': +- print ' GLint max_units = 0;' +- print ' if (ctx->profile.desktop())' +- print ' _glGetIntegerv(GL_MAX_TEXTURE_COORDS, &max_units);' +- print ' else' +- print ' _glGetIntegerv(GL_MAX_TEXTURE_UNITS, &max_units);' +- print ' GLint client_active_texture = GL_TEXTURE0;' +- print ' if (max_units > 0) {' +- print ' _glGetIntegerv(GL_CLIENT_ACTIVE_TEXTURE, &client_active_texture);' +- print ' }' +- print ' GLint unit = 0;' +- print ' do {' +- print ' GLint texture = GL_TEXTURE0 + unit;' +- print ' if (max_units > 0) {' +- print ' _glClientActiveTexture(texture);' +- print ' }' ++ print(' GLint max_units = 0;') ++ print(' if (ctx->profile.desktop())') ++ print(' _glGetIntegerv(GL_MAX_TEXTURE_COORDS, &max_units);') ++ print(' else') ++ print(' _glGetIntegerv(GL_MAX_TEXTURE_UNITS, &max_units);') ++ print(' GLint client_active_texture = GL_TEXTURE0;') ++ print(' if (max_units > 0) {') ++ print(' _glGetIntegerv(GL_CLIENT_ACTIVE_TEXTURE, &client_active_texture);') ++ print(' }') ++ print(' GLint unit = 0;') ++ print(' do {') ++ print(' GLint texture = GL_TEXTURE0 + unit;') ++ print(' if (max_units > 0) {') ++ print(' _glClientActiveTexture(texture);') ++ print(' }') + + def array_trace_prolog(self, api, uppercase_name): + if uppercase_name == 'TEXTURE_COORD': +- print ' bool client_active_texture_dirty = false;' ++ print(' bool client_active_texture_dirty = false;') + + def array_epilog(self, api, uppercase_name): + if uppercase_name == 'TEXTURE_COORD': +- print ' } while (++unit < max_units);' ++ print(' } while (++unit < max_units);') + self.array_cleanup(api, uppercase_name) + + def array_cleanup(self, api, uppercase_name): + if uppercase_name == 'TEXTURE_COORD': +- print ' if (max_units > 0) {' +- print ' _glClientActiveTexture(client_active_texture);' +- print ' }' ++ print(' if (max_units > 0) {') ++ print(' _glClientActiveTexture(client_active_texture);') ++ print(' }') + + def array_trace_intermezzo(self, api, uppercase_name): + if uppercase_name == 'TEXTURE_COORD': +- print ' if (texture != client_active_texture || client_active_texture_dirty) {' +- print ' client_active_texture_dirty = true;' ++ print(' if (texture != client_active_texture || client_active_texture_dirty) {') ++ print(' client_active_texture_dirty = true;') + self.fake_glClientActiveTexture_call(api, "texture"); +- print ' }' ++ print(' }') + + def array_trace_epilog(self, api, uppercase_name): + if uppercase_name == 'TEXTURE_COORD': +- print ' if (client_active_texture_dirty) {' ++ print(' if (client_active_texture_dirty) {') + self.fake_glClientActiveTexture_call(api, "client_active_texture"); +- print ' }' ++ print(' }') + + def fake_glBindBuffer(self, api, target, buffer): + function = api.getFunctionByName('glBindBuffer') +@@ -1180,13 +1180,13 @@ class GlTracer(Tracer): + def emitFakeTexture2D(self): + function = glapi.glapi.getFunctionByName('glTexImage2D') + instances = function.argNames() +- print ' unsigned _fake_call = trace::localWriter.beginEnter(&_%s_sig, true);' % (function.name,) ++ print(' unsigned _fake_call = trace::localWriter.beginEnter(&_%s_sig, true);' % (function.name,)) + for arg in function.args: + assert not arg.output + self.serializeArg(function, arg) +- print ' trace::localWriter.endEnter();' +- print ' trace::localWriter.beginLeave(_fake_call);' +- print ' trace::localWriter.endLeave();' ++ print(' trace::localWriter.endEnter();') ++ print(' trace::localWriter.beginLeave(_fake_call);') ++ print(' trace::localWriter.endLeave();') + + + +diff --git a/wrappers/glxtrace.py b/wrappers/glxtrace.py +index f35d1fe9..b05028e2 100644 +--- a/wrappers/glxtrace.py ++++ b/wrappers/glxtrace.py +@@ -64,7 +64,7 @@ class GlxTracer(GlTracer): + + def traceFunctionImplBody(self, function): + if function.name in self.destroyContextFunctionNames: +- print ' gltrace::releaseContext((uintptr_t)ctx);' ++ print(' gltrace::releaseContext((uintptr_t)ctx);') + + if function.name == 'glXGetCurrentDisplay': + print ' if(_glXGetCurrentDisplay == &glXGetCurrentDisplay ){' +@@ -74,16 +74,16 @@ class GlxTracer(GlTracer): + GlTracer.traceFunctionImplBody(self, function) + + if function.name in self.createContextFunctionNames: +- print ' if (_result != NULL)' +- print ' gltrace::createContext((uintptr_t)_result);' ++ print(' if (_result != NULL)') ++ print(' gltrace::createContext((uintptr_t)_result);') + + if function.name in self.makeCurrentFunctionNames: +- print ' if (_result) {' +- print ' if (ctx != NULL)' +- print ' gltrace::setContext((uintptr_t)ctx);' +- print ' else' +- print ' gltrace::clearContext();' +- print ' }' ++ print(' if (_result) {') ++ print(' if (ctx != NULL)') ++ print(' gltrace::setContext((uintptr_t)ctx);') ++ print(' else') ++ print(' gltrace::clearContext();') ++ print(' }') + + if function.name == 'glXBindTexImageEXT': + # FIXME: glXBindTexImageEXT gets called frequently, so we should +@@ -92,7 +92,7 @@ class GlxTracer(GlTracer): + # emit emitFakeTexture2D when it changes + # - keep a global hash of the pixels + # FIXME: Handle mipmaps +- print r''' ++ print(r''' + unsigned glx_target = 0; + _glXQueryDrawable(display, drawable, GLX_TEXTURE_TARGET_EXT, &glx_target); + GLenum target; +@@ -152,29 +152,29 @@ class GlxTracer(GlTracer): + GLint row_stride = _align(width * 4, alignment); + GLvoid * pixels = malloc(height * row_stride); + _glGetTexImage(target, level, format, type, pixels); +- ''' ++ ''') + self.emitFakeTexture2D() +- print r''' ++ print(r''' + free(pixels); + } +- ''' ++ ''') + + + if __name__ == '__main__': +- print +- print '#include <stdlib.h>' +- print '#include <string.h>' +- print +- print '#include "trace_writer_local.hpp"' +- print +- print '// To validate our prototypes' +- print '#define GL_GLEXT_PROTOTYPES' +- print '#define GLX_GLXEXT_PROTOTYPES' +- print +- print '#include "dlopen.hpp"' +- print '#include "glproc.hpp"' +- print '#include "glsize.hpp"' +- print ++ print() ++ print('#include <stdlib.h>') ++ print('#include <string.h>') ++ print() ++ print('#include "trace_writer_local.hpp"') ++ print() ++ print('// To validate our prototypes') ++ print('#define GL_GLEXT_PROTOTYPES') ++ print('#define GLX_GLXEXT_PROTOTYPES') ++ print() ++ print('#include "dlopen.hpp"') ++ print('#include "glproc.hpp"') ++ print('#include "glsize.hpp"') ++ print() + + module = Module() + module.mergeModule(glxapi) +diff --git a/wrappers/trace.py b/wrappers/trace.py +index 7d1baa10..318f0990 100644 +--- a/wrappers/trace.py ++++ b/wrappers/trace.py +@@ -69,21 +69,21 @@ class ComplexValueSerializer(stdapi.OnceVisitor): + + def visitStruct(self, struct): + # Ensure member array has nonzero length to avoid MSVC error C2466 +- print 'static const char * _struct%s_members[%u] = {' % (struct.tag, max(len(struct.members), 1)) ++ print('static const char * _struct%s_members[%u] = {' % (struct.tag, max(len(struct.members), 1))) + for type, name, in struct.members: + if name is None: +- print ' "",' ++ print(' "",') + else: +- print ' "%s",' % (name,) +- print '};' +- print 'static const trace::StructSig _struct%s_sig = {' % (struct.tag,) ++ print(' "%s",' % (name,)) ++ print('};') ++ print('static const trace::StructSig _struct%s_sig = {' % (struct.tag,)) + if struct.name is None: + structName = '""' + else: + structName = '"%s"' % struct.name +- print ' %u, %s, %u, _struct%s_members' % (struct.id, structName, len(struct.members), struct.tag) +- print '};' +- print ++ print(' %u, %s, %u, _struct%s_members' % (struct.id, structName, len(struct.members), struct.tag)) ++ print('};') ++ print() + + def visitArray(self, array): + self.visit(array.type) +@@ -95,26 +95,26 @@ class ComplexValueSerializer(stdapi.OnceVisitor): + pass + + def visitEnum(self, enum): +- print 'static const trace::EnumValue _enum%s_values[] = {' % (enum.tag) ++ print('static const trace::EnumValue _enum%s_values[] = {' % (enum.tag)) + for value in enum.values: +- print ' {"%s", %s},' % (value, value) +- print '};' +- print +- print 'static const trace::EnumSig _enum%s_sig = {' % (enum.tag) +- print ' %u, %u, _enum%s_values' % (enum.id, len(enum.values), enum.tag) +- print '};' +- print ++ print(' {"%s", %s},' % (value, value)) ++ print('};') ++ print() ++ print('static const trace::EnumSig _enum%s_sig = {' % (enum.tag)) ++ print(' %u, %u, _enum%s_values' % (enum.id, len(enum.values), enum.tag)) ++ print('};') ++ print() + + def visitBitmask(self, bitmask): +- print 'static const trace::BitmaskFlag _bitmask%s_flags[] = {' % (bitmask.tag) ++ print('static const trace::BitmaskFlag _bitmask%s_flags[] = {' % (bitmask.tag)) + for value in bitmask.values: +- print ' {"%s", %s},' % (value, value) +- print '};' +- print +- print 'static const trace::BitmaskSig _bitmask%s_sig = {' % (bitmask.tag) +- print ' %u, %u, _bitmask%s_flags' % (bitmask.id, len(bitmask.values), bitmask.tag) +- print '};' +- print ++ print(' {"%s", %s},' % (value, value)) ++ print('};') ++ print() ++ print('static const trace::BitmaskSig _bitmask%s_sig = {' % (bitmask.tag)) ++ print(' %u, %u, _bitmask%s_flags' % (bitmask.id, len(bitmask.values), bitmask.tag)) ++ print('};') ++ print() + + def visitPointer(self, pointer): + self.visit(pointer.type) +@@ -146,16 +146,16 @@ class ComplexValueSerializer(stdapi.OnceVisitor): + def visitPolymorphic(self, polymorphic): + if not polymorphic.contextLess: + return +- print 'static void _write__%s(int selector, %s const & value) {' % (polymorphic.tag, polymorphic.expr) +- print ' switch (selector) {' ++ print('static void _write__%s(int selector, %s const & value) {' % (polymorphic.tag, polymorphic.expr)) ++ print(' switch (selector) {') + for cases, type in polymorphic.iterSwitch(): + for case in cases: +- print ' %s:' % case ++ print(' %s:' % case) + self.serializer.visit(type, '(%s)(value)' % (type,)) +- print ' break;' +- print ' }' +- print '}' +- print ++ print(' break;') ++ print(' }') ++ print('}') ++ print() + + + class ValueSerializer(stdapi.Visitor, stdapi.ExpanderMixin): +@@ -167,7 +167,7 @@ class ValueSerializer(stdapi.Visitor, stdapi.ExpanderMixin): + ''' + + def visitLiteral(self, literal, instance): +- print ' trace::localWriter.write%s(%s);' % (literal.kind, instance) ++ print(' trace::localWriter.write%s(%s);' % (literal.kind, instance)) + + def visitString(self, string, instance): + if not string.wide: +@@ -183,33 +183,33 @@ class ValueSerializer(stdapi.Visitor, stdapi.ExpanderMixin): + length = ', %s' % self.expand(string.length) + else: + length = '' +- print ' trace::localWriter.write%s(%s%s);' % (suffix, instance, length) ++ print(' trace::localWriter.write%s(%s%s);' % (suffix, instance, length)) + + def visitConst(self, const, instance): + self.visit(const.type, instance) + + def visitStruct(self, struct, instance): +- print ' trace::localWriter.beginStruct(&_struct%s_sig);' % (struct.tag,) ++ print(' trace::localWriter.beginStruct(&_struct%s_sig);' % (struct.tag,)) + for member in struct.members: + self.visitMember(member, instance) +- print ' trace::localWriter.endStruct();' ++ print(' trace::localWriter.endStruct();') + + def visitArray(self, array, instance): + length = '_c' + array.type.tag + index = '_i' + array.type.tag + array_length = self.expand(array.length) +- print ' if (%s) {' % instance +- print ' size_t %s = %s > 0 ? %s : 0;' % (length, array_length, array_length) +- print ' trace::localWriter.beginArray(%s);' % length +- print ' for (size_t %s = 0; %s < %s; ++%s) {' % (index, index, length, index) +- print ' trace::localWriter.beginElement();' ++ print(' if (%s) {' % instance) ++ print(' size_t %s = %s > 0 ? %s : 0;' % (length, array_length, array_length)) ++ print(' trace::localWriter.beginArray(%s);' % length) ++ print(' for (size_t %s = 0; %s < %s; ++%s) {' % (index, index, length, index)) ++ print(' trace::localWriter.beginElement();') + self.visitElement(index, array.type, '(%s)[%s]' % (instance, index)) +- print ' trace::localWriter.endElement();' +- print ' }' +- print ' trace::localWriter.endArray();' +- print ' } else {' +- print ' trace::localWriter.writeNull();' +- print ' }' ++ print(' trace::localWriter.endElement();') ++ print(' }') ++ print(' trace::localWriter.endArray();') ++ print(' } else {') ++ print(' trace::localWriter.writeNull();') ++ print(' }') + + def visitAttribArray(self, array, instance): + # For each element, decide if it is a key or a value (which depends on the previous key). +@@ -218,90 +218,90 @@ class ValueSerializer(stdapi.Visitor, stdapi.ExpanderMixin): + + # determine the array length which must be passed to writeArray() up front + count = '_c' + array.baseType.tag +- print ' {' +- print ' int %s;' % count +- print ' for (%(c)s = 0; %(array)s && %(array)s[%(c)s] != %(terminator)s; %(c)s += 2) {' \ +- % {'c': count, 'array': instance, 'terminator': array.terminator} ++ print(' {') ++ print(' int %s;' % count) ++ print(' for (%(c)s = 0; %(array)s && %(array)s[%(c)s] != %(terminator)s; %(c)s += 2) {' \ ++ % {'c': count, 'array': instance, 'terminator': array.terminator}) + if array.hasKeysWithoutValues: +- print ' switch (int(%(array)s[%(c)s])) {' % {'array': instance, 'c': count} ++ print(' switch (int(%(array)s[%(c)s])) {' % {'array': instance, 'c': count}) + for key, valueType in array.valueTypes: + if valueType is None: +- print ' case %s:' % key +- print ' %s--;' % count # the next value is a key again and checked if it's the terminator +- print ' break;' +- print ' }' +- print ' }' +- print ' %(c)s += %(array)s ? 1 : 0;' % {'c': count, 'array': instance} +- print ' trace::localWriter.beginArray(%s);' % count ++ print(' case %s:' % key) ++ print(' %s--;' % count) # the next value is a key again and checked if it's the terminator ++ print(' break;') ++ print(' }') ++ print(' }') ++ print(' %(c)s += %(array)s ? 1 : 0;' % {'c': count, 'array': instance}) ++ print(' trace::localWriter.beginArray(%s);' % count) + + # for each key / key-value pair write the key and the value, if the key requires one + + index = '_i' + array.baseType.tag +- print ' for (int %(i)s = 0; %(i)s < %(count)s; %(i)s++) {' % {'i': index, 'count': count} +- print ' trace::localWriter.beginElement();' ++ print(' for (int %(i)s = 0; %(i)s < %(count)s; %(i)s++) {' % {'i': index, 'count': count}) ++ print(' trace::localWriter.beginElement();') + self.visit(array.baseType, "%(array)s[%(i)s]" % {'array': instance, 'i': index}) +- print ' trace::localWriter.endElement();' +- print ' if (%(i)s + 1 >= %(count)s) {' % {'i': index, 'count': count} +- print ' break;' +- print ' }' +- print ' switch (int(%(array)s[%(i)s++])) {' % {'array': instance, 'i': index} ++ print(' trace::localWriter.endElement();') ++ print(' if (%(i)s + 1 >= %(count)s) {' % {'i': index, 'count': count}) ++ print(' break;') ++ print(' }') ++ print(' switch (int(%(array)s[%(i)s++])) {' % {'array': instance, 'i': index}) + # write generic value the usual way + for key, valueType in array.valueTypes: + if valueType is not None: +- print ' case %s:' % key +- print ' trace::localWriter.beginElement();' ++ print(' case %s:' % key) ++ print(' trace::localWriter.beginElement();') + self.visitElement(index, valueType, '(%(array)s)[%(i)s]' % {'array': instance, 'i': index}) +- print ' trace::localWriter.endElement();' +- print ' break;' ++ print(' trace::localWriter.endElement();') ++ print(' break;') + # known key with no value, just decrease the index so we treat the next value as a key + if array.hasKeysWithoutValues: + for key, valueType in array.valueTypes: + if valueType is None: +- print ' case %s:' % key +- print ' %s--;' % index +- print ' break;' ++ print(' case %s:' % key) ++ print(' %s--;' % index) ++ print(' break;') + # unknown key, write an int value +- print ' default:' +- print ' trace::localWriter.beginElement();' +- print ' os::log("apitrace: warning: %s: unknown key 0x%04X, interpreting value as int\\n", ' + \ +- '__FUNCTION__, int(%(array)s[%(i)s - 1]));' % {'array': instance, 'i': index} +- print ' trace::localWriter.writeSInt(%(array)s[%(i)s]);' % {'array': instance, 'i': index} +- print ' trace::localWriter.endElement();' +- print ' break;' +- print ' }' +- print ' }' +- print ' trace::localWriter.endArray();' +- print ' }' ++ print(' default:') ++ print(' trace::localWriter.beginElement();') ++ print(' os::log("apitrace: warning: %s: unknown key 0x%04X, interpreting value as int\\n", ' + \ ++ '__FUNCTION__, int(%(array)s[%(i)s - 1]));' % {'array': instance, 'i': index}) ++ print(' trace::localWriter.writeSInt(%(array)s[%(i)s]);' % {'array': instance, 'i': index}) ++ print(' trace::localWriter.endElement();') ++ print(' break;') ++ print(' }') ++ print(' }') ++ print(' trace::localWriter.endArray();') ++ print(' }') + + + def visitBlob(self, blob, instance): +- print ' trace::localWriter.writeBlob(%s, %s);' % (instance, self.expand(blob.size)) ++ print(' trace::localWriter.writeBlob(%s, %s);' % (instance, self.expand(blob.size))) + + def visitEnum(self, enum, instance): +- print ' trace::localWriter.writeEnum(&_enum%s_sig, %s);' % (enum.tag, instance) ++ print(' trace::localWriter.writeEnum(&_enum%s_sig, %s);' % (enum.tag, instance)) + + def visitBitmask(self, bitmask, instance): +- print ' trace::localWriter.writeBitmask(&_bitmask%s_sig, %s);' % (bitmask.tag, instance) ++ print(' trace::localWriter.writeBitmask(&_bitmask%s_sig, %s);' % (bitmask.tag, instance)) + + def visitPointer(self, pointer, instance): +- print ' if (%s) {' % instance +- print ' trace::localWriter.beginArray(1);' +- print ' trace::localWriter.beginElement();' ++ print(' if (%s) {' % instance) ++ print(' trace::localWriter.beginArray(1);') ++ print(' trace::localWriter.beginElement();') + self.visit(pointer.type, "*" + instance) +- print ' trace::localWriter.endElement();' +- print ' trace::localWriter.endArray();' +- print ' } else {' +- print ' trace::localWriter.writeNull();' +- print ' }' ++ print(' trace::localWriter.endElement();') ++ print(' trace::localWriter.endArray();') ++ print(' } else {') ++ print(' trace::localWriter.writeNull();') ++ print(' }') + + def visitIntPointer(self, pointer, instance): +- print ' trace::localWriter.writePointer((uintptr_t)%s);' % instance ++ print(' trace::localWriter.writePointer((uintptr_t)%s);' % instance) + + def visitObjPointer(self, pointer, instance): +- print ' trace::localWriter.writePointer((uintptr_t)%s);' % instance ++ print(' trace::localWriter.writePointer((uintptr_t)%s);' % instance) + + def visitLinearPointer(self, pointer, instance): +- print ' trace::localWriter.writePointer((uintptr_t)%s);' % instance ++ print(' trace::localWriter.writePointer((uintptr_t)%s);' % instance) + + def visitReference(self, reference, instance): + self.visit(reference.type, instance) +@@ -313,31 +313,31 @@ class ValueSerializer(stdapi.Visitor, stdapi.ExpanderMixin): + self.visit(alias.type, instance) + + def visitOpaque(self, opaque, instance): +- print ' trace::localWriter.writePointer((uintptr_t)%s);' % instance ++ print(' trace::localWriter.writePointer((uintptr_t)%s);' % instance) + + def visitInterface(self, interface, instance): + assert False + + def visitPolymorphic(self, polymorphic, instance): + if polymorphic.contextLess: +- print ' _write__%s(%s, %s);' % (polymorphic.tag, polymorphic.switchExpr, instance) ++ print(' _write__%s(%s, %s);' % (polymorphic.tag, polymorphic.switchExpr, instance)) + else: + switchExpr = self.expand(polymorphic.switchExpr) +- print ' switch (%s) {' % switchExpr ++ print(' switch (%s) {' % switchExpr) + for cases, type in polymorphic.iterSwitch(): + for case in cases: +- print ' %s:' % case ++ print(' %s:' % case) + caseInstance = instance + if type.expr is not None: + caseInstance = 'static_cast<%s>(%s)' % (type, caseInstance) + self.visit(type, caseInstance) +- print ' break;' ++ print(' break;') + if polymorphic.defaultType is None: +- print r' default:' +- print r' os::log("apitrace: warning: %%s: unexpected polymorphic case %%i\n", __FUNCTION__, (int)%s);' % (switchExpr,) +- print r' trace::localWriter.writeNull();' +- print r' break;' +- print ' }' ++ print(r' default:') ++ print(r' os::log("apitrace: warning: %%s: unexpected polymorphic case %%i\n", __FUNCTION__, (int)%s);' % (switchExpr,)) ++ print(r' trace::localWriter.writeNull();') ++ print(r' break;') ++ print(' }') + + + class WrapDecider(stdapi.Traverser): +@@ -369,16 +369,16 @@ class ValueWrapper(stdapi.Traverser, stdapi.ExpanderMixin): + + def visitArray(self, array, instance): + array_length = self.expand(array.length) +- print " if (%s) {" % instance +- print " for (size_t _i = 0, _s = %s; _i < _s; ++_i) {" % array_length ++ print(" if (%s) {" % instance) ++ print(" for (size_t _i = 0, _s = %s; _i < _s; ++_i) {" % array_length) + self.visitElement('_i', array.type, instance + "[_i]") +- print " }" +- print " }" ++ print(" }") ++ print(" }") + + def visitPointer(self, pointer, instance): +- print " if (%s) {" % instance ++ print(" if (%s) {" % instance) + self.visit(pointer.type, "*" + instance) +- print " }" ++ print(" }") + + def visitObjPointer(self, pointer, instance): + elem_type = pointer.type.mutable() +@@ -388,13 +388,13 @@ class ValueWrapper(stdapi.Traverser, stdapi.ExpanderMixin): + self.visitInterfacePointer(elem_type.type, instance) + else: + # All interfaces should at least implement IUnknown +- print " WrapIUnknown::_wrap(__FUNCTION__, (IUnknown **) &%s);" % (instance,) ++ print(" WrapIUnknown::_wrap(__FUNCTION__, (IUnknown **) &%s);" % (instance,)) + + def visitInterface(self, interface, instance): + raise NotImplementedError + + def visitInterfacePointer(self, interface, instance): +- print " Wrap%s::_wrap(__FUNCTION__, &%s);" % (interface.name, instance) ++ print(" Wrap%s::_wrap(__FUNCTION__, &%s);" % (interface.name, instance)) + + def visitPolymorphic(self, type, instance): + # XXX: There might be polymorphic values that need wrapping in the future +@@ -409,17 +409,17 @@ class ValueUnwrapper(ValueWrapper): + def visitStruct(self, struct, instance): + if not self.allocated: + # Argument is constant. We need to create a non const +- print ' {' +- print " %s * _t = static_cast<%s *>(alloca(sizeof *_t));" % (struct, struct) +- print ' *_t = %s;' % (instance,) ++ print(' {') ++ print(" %s * _t = static_cast<%s *>(alloca(sizeof *_t));" % (struct, struct)) ++ print(' *_t = %s;' % (instance,)) + assert instance.startswith('*') +- print ' %s = _t;' % (instance[1:],) ++ print(' %s = _t;' % (instance[1:],)) + instance = '*_t' + self.allocated = True + try: + return ValueWrapper.visitStruct(self, struct, instance) + finally: +- print ' }' ++ print(' }') + else: + return ValueWrapper.visitStruct(self, struct, instance) + +@@ -428,18 +428,18 @@ class ValueUnwrapper(ValueWrapper): + return ValueWrapper.visitArray(self, array, instance) + array_length = self.expand(array.length) + elem_type = array.type.mutable() +- print " if (%s && %s) {" % (instance, array_length) +- print " %s * _t = static_cast<%s *>(alloca(%s * sizeof *_t));" % (elem_type, elem_type, array_length) +- print " for (size_t _i = 0, _s = %s; _i < _s; ++_i) {" % array_length +- print " _t[_i] = %s[_i];" % instance ++ print(" if (%s && %s) {" % (instance, array_length)) ++ print(" %s * _t = static_cast<%s *>(alloca(%s * sizeof *_t));" % (elem_type, elem_type, array_length)) ++ print(" for (size_t _i = 0, _s = %s; _i < _s; ++_i) {" % array_length) ++ print(" _t[_i] = %s[_i];" % instance) + self.allocated = True + self.visit(array.type, "_t[_i]") +- print " }" +- print " %s = _t;" % instance +- print " }" ++ print(" }") ++ print(" %s = _t;" % instance) ++ print(" }") + + def visitInterfacePointer(self, interface, instance): +- print r' Wrap%s::_unwrap(__FUNCTION__, &%s);' % (interface.name, instance) ++ print(r' Wrap%s::_unwrap(__FUNCTION__, &%s);' % (interface.name, instance)) + + + def _getInterfaceHierarchy(allIfaces, baseIface, result): +@@ -479,14 +479,17 @@ class Tracer: + # Includes + for module in api.modules: + for header in module.headers: +- print header +- print ++ print(header) ++ print() + + # Generate the serializer functions + types = api.getAllTypes() + visitor = ComplexValueSerializer(self.serializerFactory()) +- map(visitor.visit, types) +- print ++ ++ for tp in types: ++ visitor.visit(tp) ++ ++ print() + + # Interfaces wrapers + self.traceInterfaces(api) +@@ -498,22 +501,22 @@ class Tracer: + self.traceFunctionDecl(function) + for function in api.getAllFunctions(): + self.traceFunctionImpl(function) +- print ++ print() + + self.footer(api) + + def header(self, api): +- print '#ifdef _WIN32' +- print '# include <malloc.h> // alloca' +- print '# ifndef alloca' +- print '# define alloca _alloca' +- print '# endif' +- print '#else' +- print '# include <alloca.h> // alloca' +- print '#endif' +- print +- print +- print 'static std::map<void *, void *> g_WrappedObjects;' ++ print('#ifdef _WIN32') ++ print('# include <malloc.h> // alloca') ++ print('# ifndef alloca') ++ print('# define alloca _alloca') ++ print('# endif') ++ print('#else') ++ print('# include <alloca.h> // alloca') ++ print('#endif') ++ print() ++ print() ++ print('static std::map<void *, void *> g_WrappedObjects;') + + def footer(self, api): + pass +@@ -523,11 +526,11 @@ class Tracer: + + if not function.internal: + if function.args: +- print 'static const char * _%s_args[%u] = {%s};' % (function.name, len(function.args), ', '.join(['"%s"' % arg.name for arg in function.args])) ++ print('static const char * _%s_args[%u] = {%s};' % (function.name, len(function.args), ', '.join(['"%s"' % arg.name for arg in function.args]))) + else: +- print 'static const char ** _%s_args = NULL;' % (function.name,) +- print 'static const trace::FunctionSig _%s_sig = {%u, "%s", %u, _%s_args};' % (function.name, self.getFunctionSigId(), function.name, len(function.args), function.name) +- print ++ print('static const char ** _%s_args = NULL;' % (function.name,)) ++ print('static const trace::FunctionSig _%s_sig = {%u, "%s", %u, _%s_args};' % (function.name, self.getFunctionSigId(), function.sigName(), len(function.args), function.name)) ++ print() + + def getFunctionSigId(self): + id = Tracer.__id +@@ -539,12 +542,12 @@ class Tracer: + + def traceFunctionImpl(self, function): + if self.isFunctionPublic(function): +- print 'extern "C" PUBLIC' ++ print('extern "C" PUBLIC') + else: +- print 'extern "C" PRIVATE' +- print function.prototype() + ' {' ++ print('extern "C" PRIVATE') ++ print(function.prototype() + ' {') + if function.type is not stdapi.Void: +- print ' %s _result;' % function.type ++ print(' %s _result;' % function.type) + + for arg in function.args: + if not arg.output: +@@ -555,43 +558,43 @@ class Tracer: + # XXX: wrapping should go here, but before we can do that we'll need to protect g_WrappedObjects with its own mutex + + if function.type is not stdapi.Void: +- print ' return _result;' ++ print(' return _result;') + +- print '}' +- print ++ print('}') ++ print() + + def traceFunctionImplBody(self, function): + multi_draw_function_regex = re.compile(r'^glMultiDraw(Arrays|Elements)([A-Z][a-zA-Z]*)?$' ) + if not function.internal: +- print ' unsigned _call = trace::localWriter.beginEnter(&_%s_sig);' % (function.name,) ++ print(' unsigned _call = trace::localWriter.beginEnter(&_%s_sig);' % (function.name,)) + for arg in function.args: + if not arg.output: + self.serializeArg(function, arg) +- print ' trace::localWriter.endEnter();' ++ print(' trace::localWriter.endEnter();') + + if self.multi_draw_function_regex.match(function.name): +- print ' trace::localWriter.beginIgnore();' +- print ' trace::localWriter.endIgnore();' ++ print(' trace::localWriter.beginIgnore();') ++ print(' trace::localWriter.endEnter();') + + self.invokeFunction(function) + + if self.multi_draw_function_regex.match(function.name): +- print ' trace::localWriter.beginTrace();' +- print ' trace::localWriter.endTrace();' ++ print(' trace::localWriter.beginTrace();') ++ print(' trace::localWriter.endTrace();') + + if not function.internal: +- print ' trace::localWriter.beginLeave(_call);' +- print ' if (%s) {' % self.wasFunctionSuccessful(function) ++ print(' trace::localWriter.beginLeave(_call);') ++ print(' if (%s) {' % self.wasFunctionSuccessful(function)) + for arg in function.args: + if arg.output: + self.serializeArg(function, arg) + self.wrapArg(function, arg) +- print ' }' ++ print(' }') + if function.type is not stdapi.Void: + self.serializeRet(function, "_result") + if function.type is not stdapi.Void: + self.wrapRet(function, "_result") +- print ' trace::localWriter.endLeave();' ++ print(' trace::localWriter.endLeave();') + + def invokeFunction(self, function): + self.doInvokeFunction(function) +@@ -603,7 +606,7 @@ class Tracer: + else: + result = '_result = ' + dispatch = prefix + function.name + suffix +- print ' %s%s(%s);' % (result, dispatch, ', '.join([str(arg.name) for arg in function.args])) ++ print(' %s%s(%s);' % (result, dispatch, ', '.join([str(arg.name) for arg in function.args]))) + + def wasFunctionSuccessful(self, function): + if function.type is stdapi.Void: +@@ -613,9 +616,9 @@ class Tracer: + return 'true' + + def serializeArg(self, function, arg): +- print ' trace::localWriter.beginArg(%u);' % (arg.index,) ++ print(' trace::localWriter.beginArg(%u);' % (arg.index,)) + self.serializeArgValue(function, arg) +- print ' trace::localWriter.endArg();' ++ print(' trace::localWriter.endArg();') + + def serializeArgValue(self, function, arg): + self.serializeValue(arg.type, arg.name) +@@ -641,9 +644,9 @@ class Tracer: + self.unwrapValue(arg.type, arg.name) + + def serializeRet(self, function, instance): +- print ' trace::localWriter.beginReturn();' ++ print(' trace::localWriter.beginReturn();') + self.serializeValue(function.type, instance) +- print ' trace::localWriter.endReturn();' ++ print(' trace::localWriter.endReturn();') + + def serializeValue(self, type, instance): + serializer = self.serializerFactory() +@@ -672,70 +675,72 @@ class Tracer: + if not interfaces: + return + +- print r'#include "guids.hpp"' +- print ++ print(r'#include "guids.hpp"') ++ print() + + map(self.declareWrapperInterface, interfaces) + + # Helper functions to wrap/unwrap interface pointers +- print r'static inline bool' +- print r'hasChildInterface(REFIID riid, IUnknown *pUnknown) {' +- print r' IUnknown *pObj = NULL;' +- print r' HRESULT hr = pUnknown->QueryInterface(riid, (VOID **)&pObj);' +- print r' if (FAILED(hr)) {' +- print r' return false;' +- print r' }' +- print r' assert(pObj);' +- print r' pObj->Release();' +- print r' return pUnknown == pObj;' +- print r'}' +- print +- print r'static inline const void *' +- print r'getVtbl(const void *pvObj) {' +- print r' return pvObj ? *(const void **)pvObj : NULL;' +- print r'}' +- print ++ print(r'static inline bool') ++ print(r'hasChildInterface(REFIID riid, IUnknown *pUnknown) {') ++ print(r' IUnknown *pObj = NULL;') ++ print(r' HRESULT hr = pUnknown->QueryInterface(riid, (VOID **)&pObj);') ++ print(r' if (FAILED(hr)) {') ++ print(r' return false;') ++ print(r' }') ++ print(r' assert(pObj);') ++ print(r' pObj->Release();') ++ print(r' return pUnknown == pObj;') ++ print(r'}') ++ print() ++ print(r'static inline const void *') ++ print(r'getVtbl(const void *pvObj) {') ++ print(r' return pvObj ? *(const void **)pvObj : NULL;') ++ print(r'}') ++ print() + + self.implementIidWrapper(api) + +- map(self.implementWrapperInterface, interfaces) +- print ++ for iface in interfaces: ++ self.implementWrapperInterface(iface) ++ ++ print() + + def declareWrapperInterface(self, interface): + wrapperInterfaceName = getWrapperInterfaceName(interface) +- print "class %s : public %s " % (wrapperInterfaceName, interface.name) +- print "{" +- print "private:" +- print " %s(%s * pInstance);" % (wrapperInterfaceName, interface.name) +- print " virtual ~%s();" % wrapperInterfaceName +- print "public:" +- print " static %s* _create(const char *entryName, %s * pInstance);" % (wrapperInterfaceName, interface.name) +- print " static void _wrap(const char *entryName, %s ** ppInstance);" % (interface.name,) +- print " static void _unwrap(const char *entryName, %s ** pInstance);" % (interface.name,) +- print ++ print("class %s : public %s " % (wrapperInterfaceName, interface.name)) ++ print("{") ++ print("private:") ++ print(" %s(%s * pInstance);" % (wrapperInterfaceName, interface.name)) ++ print(" virtual ~%s();" % wrapperInterfaceName) ++ print("public:") ++ print(" static %s* _create(const char *entryName, %s * pInstance);" % (wrapperInterfaceName, interface.name)) ++ print(" static void _wrap(const char *entryName, %s ** ppInstance);" % (interface.name,)) ++ print(" static void _unwrap(const char *entryName, %s ** pInstance);" % (interface.name,)) ++ print() + + methods = list(interface.iterMethods()) + for method in methods: +- print " " + method.prototype() + ";" ++ print(" " + method.prototype() + ";") + print + + for type, name, value in self.enumWrapperInterfaceVariables(interface): +- print ' %s %s;' % (type, name) +- print +- +- print r'private:' +- print r' void _dummy(unsigned i) const {' +- print r' os::log("error: %%s: unexpected virtual method %%i of instance pWrapper=%%p pvObj=%%p pVtbl=%%p\n", "%s", i, this, m_pInstance, m_pVtbl);' % interface.name +- print r' trace::localWriter.flush();' +- print r' os::abort();' +- print r' }' +- print ++ print(' %s %s;' % (type, name)) ++ print() ++ ++ print(r'private:') ++ print(r' void _dummy(unsigned i) const {') ++ print(r' os::log("error: %%s: unexpected virtual method %%i of instance pWrapper=%%p pvObj=%%p pVtbl=%%p\n", "%s", i, this, m_pInstance, m_pVtbl);' % interface.name) ++ print(r' trace::localWriter.flush();') ++ print(r' os::abort();') ++ print(r' }') ++ print() + for i in range(len(methods), 64): +- print r' virtual void _dummy%i(void) const { _dummy(%i); }' % (i, i) +- print ++ print(r' virtual void _dummy%i(void) const { _dummy(%i); }' % (i, i)) ++ print() + +- print "};" +- print ++ print("};") ++ print() + + def enumWrapperInterfaceVariables(self, interface): + return [ +@@ -751,101 +756,101 @@ class Tracer: + wrapperInterfaceName = getWrapperInterfaceName(iface) + + # Private constructor +- print '%s::%s(%s * pInstance) {' % (wrapperInterfaceName, wrapperInterfaceName, iface.name) ++ print('%s::%s(%s * pInstance) {' % (wrapperInterfaceName, wrapperInterfaceName, iface.name)) + for type, name, value in self.enumWrapperInterfaceVariables(iface): + if value is not None: +- print ' %s = %s;' % (name, value) +- print '}' +- print ++ print(' %s = %s;' % (name, value)) ++ print('}') ++ print() + + # Public constructor +- print '%s *%s::_create(const char *entryName, %s * pInstance) {' % (wrapperInterfaceName, wrapperInterfaceName, iface.name) +- print r' Wrap%s *pWrapper = new Wrap%s(pInstance);' % (iface.name, iface.name) ++ print('%s *%s::_create(const char *entryName, %s * pInstance) {' % (wrapperInterfaceName, wrapperInterfaceName, iface.name)) ++ print(r' Wrap%s *pWrapper = new Wrap%s(pInstance);' % (iface.name, iface.name)) + if debug: +- print r' os::log("%%s: created %s pvObj=%%p pWrapper=%%p pVtbl=%%p\n", entryName, pInstance, pWrapper, pWrapper->m_pVtbl);' % iface.name +- print r' g_WrappedObjects[pInstance] = pWrapper;' +- print r' return pWrapper;' +- print '}' +- print ++ print(r' os::log("%%s: created %s pvObj=%%p pWrapper=%%p pVtbl=%%p\n", entryName, pInstance, pWrapper, pWrapper->m_pVtbl);' % iface.name) ++ print(r' g_WrappedObjects[pInstance] = pWrapper;') ++ print(r' return pWrapper;') ++ print('}') ++ print() + + # Destructor +- print '%s::~%s() {' % (wrapperInterfaceName, wrapperInterfaceName) ++ print('%s::~%s() {' % (wrapperInterfaceName, wrapperInterfaceName)) + if debug: +- print r' os::log("%s::Release: deleted pvObj=%%p pWrapper=%%p pVtbl=%%p\n", m_pInstance, this, m_pVtbl);' % iface.name +- print r' g_WrappedObjects.erase(m_pInstance);' +- print '}' +- print ++ print(r' os::log("%s::Release: deleted pvObj=%%p pWrapper=%%p pVtbl=%%p\n", m_pInstance, this, m_pVtbl);' % iface.name) ++ print(r' g_WrappedObjects.erase(m_pInstance);') ++ print('}') ++ print() + + baseMethods = list(iface.iterBaseMethods()) + for base, method in baseMethods: + self.base = base + self.implementWrapperInterfaceMethod(iface, base, method) + +- print ++ print() + + # Wrap pointer + ifaces = self.api.getAllInterfaces() +- print r'void' +- print r'%s::_wrap(const char *entryName, %s **ppObj) {' % (wrapperInterfaceName, iface.name) +- print r' if (!ppObj) {' +- print r' return;' +- print r' }' +- print r' %s *pObj = *ppObj;' % (iface.name,) +- print r' if (!pObj) {' +- print r' return;' +- print r' }' +- print r' assert(hasChildInterface(IID_%s, pObj));' % iface.name +- print r' std::map<void *, void *>::const_iterator it = g_WrappedObjects.find(pObj);' +- print r' if (it != g_WrappedObjects.end()) {' +- print r' Wrap%s *pWrapper = (Wrap%s *)it->second;' % (iface.name, iface.name) +- print r' assert(pWrapper);' +- print r' assert(pWrapper->m_dwMagic == 0xd8365d6c);' +- print r' assert(pWrapper->m_pInstance == pObj);' +- print r' if (pWrapper->m_pVtbl == getVtbl(pObj) &&' +- print r' pWrapper->m_NumMethods >= %s) {' % len(baseMethods) ++ print(r'void') ++ print(r'%s::_wrap(const char *entryName, %s **ppObj) {' % (wrapperInterfaceName, iface.name)) ++ print(r' if (!ppObj) {') ++ print(r' return;') ++ print(r' }') ++ print(r' %s *pObj = *ppObj;' % (iface.name,)) ++ print(r' if (!pObj) {') ++ print(r' return;') ++ print(r' }') ++ print(r' assert(hasChildInterface(IID_%s, pObj));' % iface.name) ++ print(r' std::map<void *, void *>::const_iterator it = g_WrappedObjects.find(pObj);') ++ print(r' if (it != g_WrappedObjects.end()) {') ++ print(r' Wrap%s *pWrapper = (Wrap%s *)it->second;' % (iface.name, iface.name)) ++ print(r' assert(pWrapper);') ++ print(r' assert(pWrapper->m_dwMagic == 0xd8365d6c);') ++ print(r' assert(pWrapper->m_pInstance == pObj);') ++ print(r' if (pWrapper->m_pVtbl == getVtbl(pObj) &&') ++ print(r' pWrapper->m_NumMethods >= %s) {' % len(baseMethods)) + if debug: +- print r' os::log("%s: fetched pvObj=%p pWrapper=%p pVtbl=%p\n", entryName, pObj, pWrapper, pWrapper->m_pVtbl);' +- print r' *ppObj = pWrapper;' +- print r' return;' +- print r' }' +- print r' }' ++ print(r' os::log("%s: fetched pvObj=%p pWrapper=%p pVtbl=%p\n", entryName, pObj, pWrapper, pWrapper->m_pVtbl);') ++ print(r' *ppObj = pWrapper;') ++ print(r' return;') ++ print(r' }') ++ print(r' }') + for childIface in getInterfaceHierarchy(ifaces, iface): +- print r' if (hasChildInterface(IID_%s, pObj)) {' % (childIface.name,) +- print r' *ppObj = Wrap%s::_create(entryName, static_cast<%s *>(pObj));' % (childIface.name, childIface.name) +- print r' return;' +- print r' }' +- print r' *ppObj = Wrap%s::_create(entryName, pObj);' % iface.name +- print r'}' +- print ++ print(r' if (hasChildInterface(IID_%s, pObj)) {' % (childIface.name,)) ++ print(r' *ppObj = Wrap%s::_create(entryName, static_cast<%s *>(pObj));' % (childIface.name, childIface.name)) ++ print(r' return;') ++ print(r' }') ++ print(r' *ppObj = Wrap%s::_create(entryName, pObj);' % iface.name) ++ print(r'}') ++ print() + + # Unwrap pointer +- print r'void' +- print r'%s::_unwrap(const char *entryName, %s **ppObj) {' % (wrapperInterfaceName, iface.name) +- print r' if (!ppObj || !*ppObj) {' +- print r' return;' +- print r' }' +- print r' const %s *pWrapper = static_cast<const %s*>(*ppObj);' % (wrapperInterfaceName, getWrapperInterfaceName(iface)) +- print r' if (pWrapper && pWrapper->m_dwMagic == 0xd8365d6c) {' +- print r' *ppObj = pWrapper->m_pInstance;' +- print r' } else {' +- print r' os::log("apitrace: warning: %%s: unexpected %%s pointer %%p\n", entryName, "%s", *ppObj);' % iface.name +- print r' trace::localWriter.flush();' +- print r' }' +- print r'}' +- print ++ print(r'void') ++ print(r'%s::_unwrap(const char *entryName, %s **ppObj) {' % (wrapperInterfaceName, iface.name)) ++ print(r' if (!ppObj || !*ppObj) {') ++ print(r' return;') ++ print(r' }') ++ print(r' const %s *pWrapper = static_cast<const %s*>(*ppObj);' % (wrapperInterfaceName, getWrapperInterfaceName(iface))) ++ print(r' if (pWrapper && pWrapper->m_dwMagic == 0xd8365d6c) {') ++ print(r' *ppObj = pWrapper->m_pInstance;') ++ print(r' } else {') ++ print(r' os::log("apitrace: warning: %%s: unexpected %%s pointer %%p\n", entryName, "%s", *ppObj);' % iface.name) ++ print(r' trace::localWriter.flush();') ++ print(r' }') ++ print(r'}') ++ print() + + def implementWrapperInterfaceMethod(self, interface, base, method): + wrapperInterfaceName = getWrapperInterfaceName(interface) + +- print method.prototype(wrapperInterfaceName + '::' + method.name) + ' {' ++ print(method.prototype(wrapperInterfaceName + '::' + method.name) + ' {') + + if False: +- print r' os::log("%%s(%%p -> %%p)\n", "%s", this, m_pInstance);' % (wrapperInterfaceName + '::' + method.name) ++ print(r' os::log("%%s(%%p -> %%p)\n", "%s", this, m_pInstance);' % (wrapperInterfaceName + '::' + method.name)) + + if method.type is not stdapi.Void: +- print ' %s _result;' % method.type ++ print(' %s _result;' % method.type) + +- print ' %s *_this = static_cast<%s *>(m_pInstance);' % (base, base) ++ print(' %s *_this = static_cast<%s *>(m_pInstance);' % (base, base)) + for arg in method.args: + if not arg.output: + self.unwrapArg(method, arg) +@@ -855,36 +860,36 @@ class Tracer: + # XXX: wrapping should go here, but before we can do that we'll need to protect g_WrappedObjects with its own mutex + + if method.type is not stdapi.Void: +- print ' return _result;' ++ print(' return _result;') + +- print '}' +- print ++ print('}') ++ print() + + def implementWrapperInterfaceMethodBody(self, interface, base, method): + assert not method.internal + +- print ' static const char * _args[%u] = {%s};' % (len(method.args) + 1, ', '.join(['"this"'] + ['"%s"' % arg.name for arg in method.args])) +- print ' static const trace::FunctionSig _sig = {%u, "%s", %u, _args};' % (self.getFunctionSigId(), interface.name + '::' + method.name, len(method.args) + 1) ++ print(' static const char * _args[%u] = {%s};' % (len(method.args) + 1, ', '.join(['"this"'] + ['"%s"' % arg.name for arg in method.args]))) ++ print(' static const trace::FunctionSig _sig = {%u, "%s", %u, _args};' % (self.getFunctionSigId(), interface.name + '::' + method.name, len(method.args) + 1)) + +- print ' unsigned _call = trace::localWriter.beginEnter(&_sig);' +- print ' trace::localWriter.beginArg(0);' +- print ' trace::localWriter.writePointer((uintptr_t)m_pInstance);' +- print ' trace::localWriter.endArg();' ++ print(' unsigned _call = trace::localWriter.beginEnter(&_sig);') ++ print(' trace::localWriter.beginArg(0);') ++ print(' trace::localWriter.writePointer((uintptr_t)m_pInstance);') ++ print(' trace::localWriter.endArg();') + for arg in method.args: + if not arg.output: + self.serializeArg(method, arg) +- print ' trace::localWriter.endEnter();' ++ print(' trace::localWriter.endEnter();') + + self.invokeMethod(interface, base, method) + +- print ' trace::localWriter.beginLeave(_call);' ++ print(' trace::localWriter.beginLeave(_call);') + +- print ' if (%s) {' % self.wasFunctionSuccessful(method) ++ print(' if (%s) {' % self.wasFunctionSuccessful(method)) + for arg in method.args: + if arg.output: + self.serializeArg(method, arg) + self.wrapArg(method, arg) +- print ' }' ++ print(' }') + + if method.type is not stdapi.Void: + self.serializeRet(method, '_result') +@@ -893,51 +898,51 @@ class Tracer: + + if method.name == 'Release': + assert method.type is not stdapi.Void +- print r' if (!_result) {' +- print r' delete this;' +- print r' }' ++ print(r' if (!_result) {') ++ print(r' delete this;') ++ print(r' }') + +- print ' trace::localWriter.endLeave();' ++ print(' trace::localWriter.endLeave();') + + def implementIidWrapper(self, api): + ifaces = api.getAllInterfaces() + +- print r'static void' +- print r'warnIID(const char *entryName, REFIID riid, void *pvObj, const char *reason) {' +- print r' os::log("apitrace: warning: %s: %s IID %s\n",' +- print r' entryName, reason,' +- print r' getGuidName(riid));' +- print r' void * pVtbl = *(void **)pvObj;' +- print r' HMODULE hModule = 0;' +- print r' BOOL bRet = GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |' +- print r' GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,' +- print r' (LPCTSTR)pVtbl,' +- print r' &hModule);' +- print r' assert(bRet);' +- print r' if (bRet) {' +- print r' char szModule[MAX_PATH];' +- print r' DWORD dwRet = GetModuleFileNameA(hModule, szModule, sizeof szModule);' +- print r' assert(dwRet);' +- print r' if (dwRet) {' +- print r' DWORD dwOffset = (UINT_PTR)pVtbl - (UINT_PTR)hModule;' +- print r' os::log("apitrace: warning: pVtbl = %p (%s!+0x%0lx)\n", pVtbl, szModule, dwOffset);' +- print r' }' +- print r' }' +- print r'}' +- print +- print r'static void' +- print r'wrapIID(const char *entryName, REFIID riid, void * * ppvObj) {' +- print r' if (!ppvObj || !*ppvObj) {' +- print r' return;' +- print r' }' ++ print(r'static void') ++ print(r'warnIID(const char *entryName, REFIID riid, void *pvObj, const char *reason) {') ++ print(r' os::log("apitrace: warning: %s: %s IID %s\n",') ++ print(r' entryName, reason,') ++ print(r' getGuidName(riid));') ++ print(r' void * pVtbl = *(void **)pvObj;') ++ print(r' HMODULE hModule = 0;') ++ print(r' BOOL bRet = GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |') ++ print(r' GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,') ++ print(r' (LPCTSTR)pVtbl,') ++ print(r' &hModule);') ++ print(r' assert(bRet);') ++ print(r' if (bRet) {') ++ print(r' char szModule[MAX_PATH];') ++ print(r' DWORD dwRet = GetModuleFileNameA(hModule, szModule, sizeof szModule);') ++ print(r' assert(dwRet);') ++ print(r' if (dwRet) {') ++ print(r' DWORD dwOffset = (UINT_PTR)pVtbl - (UINT_PTR)hModule;') ++ print(r' os::log("apitrace: warning: pVtbl = %p (%s!+0x%0lx)\n", pVtbl, szModule, dwOffset);') ++ print(r' }') ++ print(r' }') ++ print(r'}') ++ print() ++ print(r'static void') ++ print(r'wrapIID(const char *entryName, REFIID riid, void * * ppvObj) {') ++ print(r' if (!ppvObj || !*ppvObj) {') ++ print(r' return;') ++ print(r' }') + for iface in ifaces: +- print r' if (riid == IID_%s) {' % (iface.name,) +- print r' Wrap%s::_wrap(entryName, (%s **) ppvObj);' % (iface.name, iface.name) +- print r' return;' +- print r' }' +- print r' warnIID(entryName, riid, *ppvObj, "unsupported");' +- print r'}' +- print ++ print(r' if (riid == IID_%s) {' % (iface.name,)) ++ print(r' Wrap%s::_wrap(entryName, (%s **) ppvObj);' % (iface.name, iface.name)) ++ print(r' return;') ++ print(r' }') ++ print(r' warnIID(entryName, riid, *ppvObj, "unsupported");') ++ print(r'}') ++ print() + + def wrapIid(self, function, riid, out): + # Cast output arg to `void **` if necessary +@@ -947,42 +952,42 @@ class Tracer: + assert isinstance(obj_type, stdapi.Interface) + out_name = 'reinterpret_cast<void * *>(%s)' % out_name + +- print r' if (%s && *%s) {' % (out.name, out.name) ++ print(r' if (%s && *%s) {' % (out.name, out.name)) + functionName = function.name + else_ = '' + if self.interface is not None: + functionName = self.interface.name + '::' + functionName +- print r' if (*%s == m_pInstance &&' % (out_name,) +- print r' (%s)) {' % ' || '.join('%s == IID_%s' % (riid.name, iface.name) for iface in self.interface.iterBases()) +- print r' *%s = this;' % (out_name,) +- print r' }' ++ print(r' if (*%s == m_pInstance &&' % (out_name,)) ++ print(r' (%s)) {' % ' || '.join('%s == IID_%s' % (riid.name, iface.name) for iface in self.interface.iterBases())) ++ print(r' *%s = this;' % (out_name,)) ++ print(r' }') + else_ = 'else ' +- print r' %s{' % else_ +- print r' wrapIID("%s", %s, %s);' % (functionName, riid.name, out_name) +- print r' }' +- print r' }' ++ print(r' %s{' % else_) ++ print(r' wrapIID("%s", %s, %s);' % (functionName, riid.name, out_name)) ++ print(r' }') ++ print(r' }') + + def invokeMethod(self, interface, base, method): + if method.type is stdapi.Void: + result = '' + else: + result = '_result = ' +- print ' %s_this->%s(%s);' % (result, method.name, ', '.join([str(arg.name) for arg in method.args])) ++ print(' %s_this->%s(%s);' % (result, method.name, ', '.join([str(arg.name) for arg in method.args]))) + + def emit_memcpy(self, ptr, size): +- print ' trace::fakeMemcpy(%s, %s);' % (ptr, size) ++ print(' trace::fakeMemcpy(%s, %s);' % (ptr, size)) + + def emit_memcpy_opt(self, ptr, size): +- print ' trace::fakeMemcpyOpt(%s, %s);' % (ptr, size) ++ print(' trace::fakeMemcpyOpt(%s, %s);' % (ptr, size)) + + def fake_call(self, function, args): +- print ' unsigned _fake_call = trace::localWriter.beginEnter(&_%s_sig, true);' % (function.name,) ++ print(' unsigned _fake_call = trace::localWriter.beginEnter(&_%s_sig, true);' % (function.name,)) + for arg, instance in zip(function.args, args): + assert not arg.output +- print ' trace::localWriter.beginArg(%u);' % (arg.index,) ++ print(' trace::localWriter.beginArg(%u);' % (arg.index,)) + self.serializeValue(arg.type, instance) +- print ' trace::localWriter.endArg();' +- print ' trace::localWriter.endEnter();' +- print ' trace::localWriter.beginLeave(_fake_call);' +- print ' trace::localWriter.endLeave();' ++ print(' trace::localWriter.endArg();') ++ print(' trace::localWriter.endEnter();') ++ print(' trace::localWriter.beginLeave(_fake_call);') ++ print(' trace::localWriter.endLeave();') + +diff --git a/wrappers/wgltrace.py b/wrappers/wgltrace.py +index bc79d774..be86c36e 100644 +--- a/wrappers/wgltrace.py ++++ b/wrappers/wgltrace.py +@@ -66,63 +66,65 @@ class WglTracer(GlTracer): + # wglCreateContext/wglCreateLayerContext to obtain a HGLRC that's + # recognizable by OPENGL32.DLL. Therefore we need to detect and + # dispatch internal calls, without further ado. +- print r' if (_reentrant) {' ++ print(r' if (_reentrant) {') + self.invokeFunction(function) + if function.type is not Void: +- print ' return _result;' +- print r' }' +- print r' ReentryScope _reentry;' +- print r' (void)_reentry;' +- print ++ print(' return _result;') ++ print(r' }') ++ print(r' ReentryScope _reentry;') ++ print(r' (void)_reentry;') ++ print() + + if function.name in self.destroyContextFunctionNames: + # Unlike other GL APIs like EGL or GLX, WGL will make the context + # inactive if it's currently the active context. +- print ' if (_wglGetCurrentContext() == hglrc) {' +- print ' gltrace::clearContext();' +- print ' }' +- print ' gltrace::releaseContext((uintptr_t)hglrc);' ++ print(' if (_wglGetCurrentContext() == hglrc) {') ++ print(' gltrace::clearContext();') ++ print(' }') ++ print(' gltrace::releaseContext((uintptr_t)hglrc);') + + GlTracer.traceFunctionImplBody(self, function) + + if function.name in self.createContextFunctionNames: +- print ' if (_result)' +- print ' gltrace::createContext((uintptr_t)_result);' ++ print(' if (_result)') ++ print(' gltrace::createContext((uintptr_t)_result);') + + if function.name in self.makeCurrentFunctionNames: +- print ' if (_result) {' +- print ' if (hglrc != NULL)' +- print ' gltrace::setContext((uintptr_t)hglrc);' +- print ' else' +- print ' gltrace::clearContext();' +- print ' }' ++ print(' if (_result) {') ++ print(' if (hglrc != NULL)') ++ print(' gltrace::setContext((uintptr_t)hglrc);') ++ print(' else') ++ print(' gltrace::clearContext();') ++ print(' }') + + + if __name__ == '__main__': +- print +- print '#define _GDI32_' +- print +- print '#include <string.h>' +- print '#include <windows.h>' +- print +- print '#include "trace_writer_local.hpp"' +- print '#include "os.hpp"' +- print +- print '// To validate our prototypes' +- print '#define GL_GLEXT_PROTOTYPES' +- print '#define WGL_GLXEXT_PROTOTYPES' +- print +- print '#include "glproc.hpp"' +- print '#include "glsize.hpp"' +- print +- print 'static OS_THREAD_SPECIFIC(uintptr_t) _reentrant;' +- print +- print '// Helper class to track reentries in function scope.' +- print 'struct ReentryScope {' +- print 'inline ReentryScope() { _reentrant = 1; }' +- print 'inline ~ReentryScope() { _reentrant = 0; }' +- print '};' +- print ++ print() ++ print('#define _GDI32_') ++ print() ++ print('#include <string.h>') ++ print('#include <windows.h>') ++ print() ++ print('#include <sstream>') ++ print() ++ print('#include "trace_writer_local.hpp"') ++ print('#include "os.hpp"') ++ print() ++ print('// To validate our prototypes') ++ print('#define GL_GLEXT_PROTOTYPES') ++ print('#define WGL_GLXEXT_PROTOTYPES') ++ print() ++ print('#include "glproc.hpp"') ++ print('#include "glsize.hpp"') ++ print() ++ print('static OS_THREAD_LOCAL uintptr_t _reentrant;') ++ print() ++ print('// Helper class to track reentries in function scope.') ++ print('struct ReentryScope {') ++ print('inline ReentryScope() { _reentrant = 1; }') ++ print('inline ~ReentryScope() { _reentrant = 0; }') ++ print('};') ++ print() + module = Module() + module.mergeModule(glapi) + module.mergeModule(wglapi) +-- +2.17.1 + |