Argument names are not very reliable.
self.type = type
self.name = name
self.output = output
+ self.index = None
def __str__(self):
return '%s %s' % (self.type, self.name)
self.name = name
self.args = []
+ index = 0
for arg in args:
if isinstance(arg, tuple):
arg_type, arg_name = arg
arg = Arg(arg_type, arg_name)
+ arg.index = index
+ index += 1
self.args.append(arg)
self.call = call
arg_type = ConstRemover().visit(arg.type)
print ' // %s -> %s' % (arg.type, arg_type)
print ' %s %s;' % (arg_type, arg.name)
- rvalue = 'call.arg("%s")' % (arg.name,)
+ rvalue = 'call.arg(%u)' % (arg.index,)
lvalue = arg.name
try:
ValueExtractor().visit(arg_type, lvalue, rvalue)
for arg in function.args:
if arg.output:
arg_type = ConstRemover().visit(arg.type)
- rvalue = 'call.arg("%s")' % (arg.name,)
+ rvalue = 'call.arg(%u)' % (arg.index,)
lvalue = arg.name
try:
ValueWrapper().visit(arg_type, lvalue, rvalue)
OS::ReleaseMutex();
}
-void BeginArg(const char *name) {
+void BeginArg(unsigned index, const char *name) {
WriteByte(Trace::CALL_ARG);
+ WriteUInt(index);
WriteString(name);
}
void BeginCall(const char *function);
void EndCall(void);
- void BeginArg(const char *name);
+ void BeginArg(unsigned index, const char *name);
inline void EndArg(void) {}
void BeginReturn(void);
print
def dump_arg(self, function, arg):
- print ' Log::BeginArg("%s");' % (arg.name,)
+ print ' Log::BeginArg(%u, "%s");' % (arg.index, arg.name,)
dump_instance(arg.type, arg.name)
print ' Log::EndArg();'
print ' %s __result;' % method.type
result = '__result = '
print ' Log::BeginCall("%s");' % (interface.name + '::' + method.name)
- print ' Log::BeginArg("this");'
+ print ' Log::BeginArg(0, "this");'
print ' Log::LiteralOpaque((const void *)m_pInstance);'
print ' Log::EndArg();'
for arg in method.args:
void visit(Call *call) {
const char *sep = "";
os << bold << call->name << normal << "(";
- for (std::list<Arg>::iterator it = call->args.begin(); it != call->args.end(); ++it) {
+ for (std::vector<Arg>::iterator it = call->args.begin(); it != call->args.end(); ++it) {
os << sep << italic << it->first << normal << " = ";
_visit(it->second);
sep = ", ";
return NULL;
}
-Value & Call::arg(const char *name) {
- for (std::list<Arg>::iterator it = args.begin(); it != args.end(); ++it) {
- if (it->first == name) {
- return *it->second;
- }
- }
- return null;
-}
-
std::ostream & operator <<(std::ostream &os, Call &call) {
Dumper d(os);
d.visit(&call);
{
public:
std::string name;
- std::list<Arg> args;
+ std::vector<Arg> args;
Value *ret;
Call() : ret(0) { }
- Value & arg(const char *name);
+ inline Value & arg(unsigned index) {
+ return *(args[index].second);
+ }
};
case Trace::CALL_END:
return call;
case Trace::CALL_ARG:
- call->args.push_back(parse_arg());
+ parse_arg(call);
break;
case Trace::CALL_RET:
call->ret = parse_value();
} while(true);
}
- Arg parse_arg(void) {
+ void parse_arg(Call *call) {
+ unsigned index = read_uint();
std::string name = read_string();
Value *value = parse_value();
- return Arg(name, value);
+ if (index >= call->args.size()) {
+ call->args.resize(index + 1);
+ }
+ call->args[index] = Arg(name, value);
}
Value *parse_value(void) {