m_index = call->no;
 
     QString argumentsText;
-    for (int i = 0; i < call->sig->arg_names.size(); ++i) {
+    for (int i = 0; i < call->sig->num_args; ++i) {
         m_argNames +=
             QString::fromStdString(call->sig->arg_names[i]);
     }
 
 
     QStringList args = call->argNames();
     sig->num_args = args.count();
-    sig->args = new const char*[args.count()];
+    sig->arg_names = new const char*[args.count()];
     for (int i = 0; i < args.count(); ++i) {
-        sig->args[i] = qstrdup(args[i].toLocal8Bit());
+        sig->arg_names[i] = qstrdup(args[i].toLocal8Bit());
     }
 
     return sig;
 deleteFunctionSig(Trace::FunctionSig *sig)
 {
     for (int i = 0; i < sig->num_args; ++i) {
-        delete [] sig->args[i];
+        delete [] sig->arg_names[i];
     }
-    delete [] sig->args;
+    delete [] sig->arg_names;
     delete [] sig->name;
     delete sig;
 }
 
 class Call
 {
 public:
-    struct Signature {
-        const char * name;
-        std::vector<const char *> arg_names;
-    };
-
     unsigned no;
-    const Signature *sig;
+    const FunctionSig *sig;
     std::vector<Value *> args;
     Value *ret;
 
-    Call(Signature *_sig) : sig(_sig), args(_sig->arg_names.size()), ret(0) { }
+    Call(FunctionSig *_sig) : sig(_sig), args(_sig->num_args), ret(0) { }
     ~Call();
 
     inline const char * name(void) const {
 
 void Parser::parse_enter(void) {
     size_t id = read_uint();
 
-    Call::Signature *sig = lookup(functions, id);
+    FunctionSig *sig = lookup(functions, id);
     if (!sig) {
-        sig = new Call::Signature;
+        sig = new FunctionSig;
         sig->name = read_string();
-        unsigned size = read_uint();
-        for (unsigned i = 0; i < size; ++i) {
-            sig->arg_names.push_back(read_string());
+        sig->num_args = read_uint();
+        const char **arg_names = new const char *[sig->num_args];
+        for (unsigned i = 0; i < sig->num_args; ++i) {
+            arg_names[i] = read_string();
         }
+        sig->arg_names = arg_names;
         functions[id] = sig;
     }
     assert(sig);
 
     typedef std::list<Call *> CallList;
     CallList calls;
 
-    typedef std::vector<Call::Signature *> FunctionMap;
+    typedef std::vector<FunctionSig *> FunctionMap;
     FunctionMap functions;
 
     typedef std::vector<StructSig *> StructMap;
 
         _writeString(function.name);
         _writeUInt(function.num_args);
         for (unsigned i = 0; i < function.num_args; ++i) {
-            _writeString(function.args[i]);
+            _writeString(function.arg_names[i]);
         }
         functions[function.id] = true;
     }
 
         Id id;
         const char *name;
         unsigned num_args;
-        const char **args;
+        const char **arg_names;
     };
 
     struct StructSig {