import specs.stdapi as stdapi
-import specs.glapi as glapi
class UnsupportedType(Exception):
pass
-def lookupHandle(handle, value):
+def lookupHandle(handle, value, lval=False):
if handle.key is None:
return "_%s_map[%s]" % (handle.name, value)
else:
key_name, key_type = handle.key
- return "_%s_map[%s][%s]" % (handle.name, key_name, value)
+ if handle.name == "location" and lval == False:
+ return "_location_map[%s].lookupUniformLocation(%s)" % (key_name, value)
+ else:
+ return "_%s_map[%s][%s]" % (handle.name, key_name, value)
class ValueAllocator(stdapi.Visitor):
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)
self.seq += 1
print ' if (%s) {' % (lvalue,)
- print ' const trace::Array *%s = dynamic_cast<const trace::Array *>(&%s);' % (tmp, rvalue)
+ print ' const trace::Array *%s = (%s).toArray();' % (tmp, rvalue)
length = '%s->values.size()' % (tmp,)
index = '_j' + array.tag
print ' for (size_t {i} = 0; {i} < {length}; ++{i}) {{'.format(i = index, length = length)
self.seq += 1
print ' if (%s) {' % (lvalue,)
- print ' const trace::Array *%s = dynamic_cast<const trace::Array *>(&%s);' % (tmp, rvalue)
+ print ' const trace::Array *%s = (%s).toArray();' % (tmp, rvalue)
try:
self.visit(pointer.type, '%s[0]' % (lvalue,), '*%s->values[0]' % (tmp,))
finally:
print ' %s = static_cast<%s>((%s).toPointer());' % (lvalue, pointer, rvalue)
def visitObjPointer(self, pointer, lvalue, rvalue):
- print ' %s = static_cast<%s>(retrace::toObjPointer(%s));' % (lvalue, pointer, rvalue)
+ 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)
tmp = '_s_' + struct.tag + '_' + str(self.seq)
self.seq += 1
- print ' const trace::Struct *%s = dynamic_cast<const trace::Struct *>(&%s);' % (tmp, rvalue)
+ print ' const trace::Struct *%s = (%s).toStruct();' % (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 visitArray(self, array, lvalue, rvalue):
- print ' const trace::Array *_a%s = dynamic_cast<const trace::Array *>(&%s);' % (array.tag, rvalue)
+ 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 ' }'
def visitPointer(self, pointer, lvalue, rvalue):
- print ' const trace::Array *_a%s = dynamic_cast<const trace::Array *>(&%s);' % (pointer.tag, rvalue)
+ 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,))
pass
def visitObjPointer(self, pointer, lvalue, rvalue):
- print r' retrace::addObj(%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
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, 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 '}'
+ else:
+ print " %s = %s;" % (entry, lvalue)
print ' if (retrace::verbosity >= 2) {'
print ' std::cout << "{handle.name} " << {rvalue} << " -> " << {lvalue} << "\\n";'.format(**locals())
print ' }'
tmp = '_s_' + struct.tag + '_' + str(self.seq)
self.seq += 1
- print ' const trace::Struct *%s = dynamic_cast<const trace::Struct *>(&%s);' % (tmp, rvalue)
+ 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_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 *>(retrace::toObjPointer(call.arg(0)));' % (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 ' retrace::delObj(call.arg(0));'
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
- 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)
projects / apitrace / blobdiff