import specs.stdapi as stdapi
-import specs.glapi as glapi
class UnsupportedType(Exception):
pass
def visitArray(self, array, lvalue, rvalue):
- print ' %s = _allocator.alloc<%s>(&%s);' % (lvalue, array.type, rvalue)
+ print ' %s = static_cast<%s *>(_allocator.alloc(&%s, sizeof *%s));' % (lvalue, array.type, rvalue, lvalue)
def visitPointer(self, pointer, lvalue, rvalue):
- print ' %s = _allocator.alloc<%s>(&%s);' % (lvalue, pointer.type, rvalue)
+ print ' %s = static_cast<%s *>(_allocator.alloc(&%s, sizeof *%s));' % (lvalue, pointer.type, rvalue, lvalue)
def visitIntPointer(self, pointer, lvalue, rvalue):
pass
pass
def visitPolymorphic(self, polymorphic, lvalue, rvalue):
+ assert polymorphic.defaultType is not None
self.visit(polymorphic.defaultType, lvalue, rvalue)
def visitOpaque(self, opaque, lvalue, rvalue):
pass
-class ValueDeserializer(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 = static_cast<%s>((%s).toPointer());' % (lvalue, pointer, rvalue)
def visitObjPointer(self, pointer, lvalue, rvalue):
- old_lvalue = '(%s).toUIntPtr()' % (rvalue,)
- new_lvalue = '_obj_map[%s]' % (old_lvalue,)
- print ' if (retrace::verbosity >= 2) {'
- print ' std::cout << std::hex << "obj 0x" << size_t(%s) << " <- 0x" << size_t(%s) << std::dec <<"\\n";' % (old_lvalue, new_lvalue)
- print ' }'
- print ' %s = static_cast<%s>(%s);' % (lvalue, pointer, new_lvalue)
+ print ' %s = static_cast<%s>(retrace::toObjPointer(call, %s));' % (lvalue, pointer, rvalue)
def visitLinearPointer(self, pointer, lvalue, rvalue):
print ' %s = static_cast<%s>(retrace::toPointer(%s));' % (lvalue, pointer, rvalue)
print ' if (retrace::verbosity >= 2) {'
print ' std::cout << "%s " << size_t(%s) << " <- " << size_t(%s) << "\\n";' % (handle.name, lvalue, new_lvalue)
print ' }'
- print ' %s = %s;' % (lvalue, new_lvalue)
+ 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 '}'
+ else:
+ print ' %s = %s;' % (lvalue, new_lvalue)
def visitBlob(self, blob, lvalue, rvalue):
print ' %s = static_cast<%s>((%s).toPointer());' % (lvalue, blob, rvalue)
print ' const trace::Struct *%s = dynamic_cast<const trace::Struct *>(&%s);' % (tmp, rvalue)
print ' assert(%s);' % (tmp)
for i in range(len(struct.members)):
- member_type, member_name = struct.members[i]
- self.visit(member_type, '%s.%s' % (lvalue, member_name), '*%s->members[%s]' % (tmp, i))
+ member = struct.members[i]
+ self.visitMember(member, lvalue, '*%s->members[%s]' % (tmp, i))
def visitPolymorphic(self, polymorphic, lvalue, rvalue):
- self.visit(polymorphic.defaultType, lvalue, rvalue)
+ if polymorphic.defaultType is None:
+ switchExpr = self.expand(polymorphic.switchExpr)
+ print r' switch (%s) {' % switchExpr
+ for cases, type in polymorphic.iterSwitch():
+ for case in cases:
+ print r' %s:' % case
+ caseLvalue = lvalue
+ if type.expr is not None:
+ caseLvalue = 'static_cast<%s>(%s)' % (type, caseLvalue)
+ print r' {'
+ try:
+ self.visit(type, caseLvalue, rvalue)
+ finally:
+ 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' }'
+ else:
+ self.visit(polymorphic.defaultType, lvalue, rvalue)
def visitOpaque(self, opaque, lvalue, rvalue):
raise UnsupportedType
print ' %s = static_cast<%s>(retrace::toPointer(%s));' % (lvalue, opaque, rvalue)
-class SwizzledValueRegistrator(stdapi.Visitor):
+class SwizzledValueRegistrator(stdapi.Visitor, stdapi.ExpanderMixin):
'''Type visitor which will register (un)swizzled value pairs, to later be
swizzled.'''
pass
def visitObjPointer(self, pointer, lvalue, rvalue):
- print r' _obj_map[(%s).toUIntPtr()] = %s;' % (rvalue, lvalue)
+ print r' retrace::addObj(call, %s, %s);' % (rvalue, lvalue)
def visitLinearPointer(self, pointer, lvalue, rvalue):
assert pointer.size is not None
OpaqueValueDeserializer().visit(handle.type, '_origResult', rvalue);
if handle.range is None:
rvalue = "_origResult"
- entry = lookupHandle(handle, rvalue)
- print " %s = %s;" % (entry, lvalue)
+ entry = lookupHandle(handle, rvalue)
+ 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 '}'
+ else:
+ print " %s = %s;" % (entry, lvalue)
print ' if (retrace::verbosity >= 2) {'
print ' std::cout << "{handle.name} " << {rvalue} << " -> " << {lvalue} << "\\n";'.format(**locals())
print ' }'
print ' assert(%s);' % (tmp,)
print ' (void)%s;' % (tmp,)
for i in range(len(struct.members)):
- member_type, member_name = struct.members[i]
- self.visit(member_type, '%s.%s' % (lvalue, member_name), '*%s->members[%s]' % (tmp, i))
+ member = struct.members[i]
+ self.visitMember(member, lvalue, '*%s->members[%s]' % (tmp, i))
def visitPolymorphic(self, polymorphic, lvalue, rvalue):
+ assert polymorphic.defaultType is not None
self.visit(polymorphic.defaultType, lvalue, rvalue)
def visitOpaque(self, opaque, lvalue, rvalue):
def deserializeThisPointer(self, interface):
print r' %s *_this;' % (interface.name,)
- print r' _this = static_cast<%s *>(_obj_map[call.arg(0).toUIntPtr()]);' % (interface.name,)
+ print r' _this = static_cast<%s *>(retrace::toObjPointer(call, call.arg(0)));' % (interface.name,)
print r' if (!_this) {'
- print r' retrace::warning(call) << "NULL this pointer\n";'
print r' return;'
print r' }'
if not success:
print ' if (1) {'
self.failFunction(function)
- if function.name[-1].islower():
- sys.stderr.write('warning: unsupported %s call\n' % function.name)
+ sys.stderr.write('warning: unsupported %s call\n' % function.name)
print ' }'
def swizzleValues(self, function):
if function.type is not stdapi.Void:
print ' _result = %s(%s);' % (function.name, arg_names)
print ' (void)_result;'
+ self.checkResult(function.type)
else:
print ' %s(%s);' % (function.name, arg_names)
# On release our reference when we reach Release() == 0 call in the
# trace.
if method.name == 'Release':
- print ' if (call.ret->toUInt()) {'
- print ' return;'
+ print ' if (call.ret->toUInt() == 0) {'
+ print ' retrace::delObj(call.arg(0));'
print ' }'
- print ' _obj_map.erase(call.arg(0).toUIntPtr());'
arg_names = ", ".join(method.argNames())
if method.type is not stdapi.Void:
print ' _result = _this->%s(%s);' % (method.name, arg_names)
print ' (void)_result;'
+ self.checkResult(method.type)
else:
print ' _this->%s(%s);' % (method.name, arg_names)
+ def checkResult(self, resultType):
+ if str(resultType) == 'HRESULT':
+ print r' if (FAILED(_result)) {'
+ print ' static char szMessageBuffer[128];'
+ print r' retrace::warning(call) << "call returned 0x" << std::hex << _result << std::dec << ": " << (FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, _result, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), szMessageBuffer, sizeof szMessageBuffer, NULL) ? szMessageBuffer : "???") << "\n";'
+ print r' }'
+
def filterFunction(self, function):
return True
handle_names.add(handle.name)
print
- print 'static std::map<unsigned long long, void *> _obj_map;'
- print
-
- functions = filter(self.filterFunction, api.functions)
+ functions = filter(self.filterFunction, api.getAllFunctions())
for function in functions:
if function.sideeffects and not function.internal:
self.retraceFunction(function)