More compact struct representation.

[apitrace] / trace_model.hpp

diff --git a/trace_model.hpp b/trace_model.hpp
index 8a87e0f65ed8443eef840252ce4dee7627817586..c65fa03f97be60352d41eb8d87a8f4811e1a04cd 100644 (file)
--- a/trace_model.hpp
+++ b/trace_model.hpp
@@ -159,10 +159,10 @@ public:
 };
 
 
-class Const : public Value
+class Enum : public Value
 {
 public:
-   Const(std::string _name, Value *_value) : name(_name), value(_value) {}
+   Enum(std::string &_name, Value *_value) : name(_name), value(_value) {}
 
    void visit(Visitor &visitor);
 
@@ -171,6 +171,37 @@ public:
 };
 
 
+class Bitmask : public UInt
+{
+public:
+   typedef std::pair<std::string, unsigned long long> Pair;
+   typedef std::vector<Pair> Signature;
+
+   Bitmask(const Signature *_sig, unsigned long long _value) : UInt(_value), sig(_sig) {}
+
+   void visit(Visitor &visitor);
+
+   const Signature *sig;
+};
+
+
+class Struct : public Value
+{
+public:
+   struct Signature {
+      std::string name;
+      std::vector<std::string> member_names;
+   };
+
+   Struct(Signature *_sig) : sig(_sig), members(_sig->member_names.size()) { }
+
+   void visit(Visitor &visitor);
+
+   const Signature *sig;
+   std::vector<Value *> members;
+};
+
+
 class Array : public Value
 {
 public:
@@ -210,7 +241,9 @@ public:
    virtual void visit(UInt *) {assert(0);}
    virtual void visit(Float *) {assert(0);}
    virtual void visit(String *) {assert(0);}
-   virtual void visit(Const *) {assert(0);}
+   virtual void visit(Enum *) {assert(0);}
+   virtual void visit(Bitmask *bitmask) {visit(static_cast<UInt *>(bitmask));}
+   virtual void visit(Struct *) {assert(0);}
    virtual void visit(Array *) {assert(0);}
    virtual void visit(Blob *) {assert(0);}
 
@@ -231,25 +264,31 @@ unsigned long long asUInt(const Value &node);
 double asFloat(const Value &node);
 
 
-typedef std::pair<std::string, Value *> Arg;
-
 class Call
 {
 public:
+   struct Signature {
+      std::string name;
+      std::vector<std::string> arg_names;
+   };
+
    unsigned no;
-   std::string name;
-   std::vector<Arg> args;
+   const Signature *sig;
+   std::vector<Value *> args;
    Value *ret;
 
-   Call() : ret(0) { }
+   Call(Signature *_sig) : sig(_sig), ret(0) { }
+
+   inline const std::string name(void) const {
+       return sig->name;
+   }
 
    inline Value & arg(unsigned index) {
-       return *(args[index].second);
+       return *(args[index]);
    }
 };
 
 
-
 std::ostream & operator <<(std::ostream &os, Call &call);