X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=trace_parser.hpp;h=3aaa6d3a93f16cb71c85116185cee0d4d9cba14e;hb=c592957de1083b4e32ee58c0ea2e5feaa9085b47;hp=b77fc3ec68853709dc42cdcdacacee9919f79205;hpb=d35973cb47a75034dbbb64e9b0a91fcb4cc971d6;p=apitrace

diff --git a/trace_parser.hpp b/trace_parser.hpp
index b77fc3e..3aaa6d3 100644
--- a/trace_parser.hpp
+++ b/trace_parser.hpp
@@ -27,335 +27,168 @@
 #define _TRACE_PARSER_HPP_
 
 
-#include <cassert>
-
 #include <iostream>
-#include <map>
-#include <string>
-
-#include <zlib.h>
+#include <list>
 
+#include "trace_file.hpp"
 #include "trace_format.hpp"
 #include "trace_model.hpp"
 
 
-#define TRACE_VERBOSE 0
+namespace Trace {
 
 
-namespace Trace {
+struct ParseBookmark
+{
+    File::Offset offset;
+    unsigned next_call_no;
+};
 
 
 class Parser
 {
 protected:
-   gzFile file;
+    File *file;
+
+    enum Mode {
+        FULL = 0,
+        SCAN,
+        SKIP
+    };
+
+    typedef std::list<Call *> CallList;
+    CallList calls;
+
+    // Helper template that extends a base signature structure, with additional
+    // parsing information.
+    template< class T >
+    struct SigState : public T {
+        // Offset in the file of where signature was defined.  It is used when
+        // reparsing to determine whether the signature definition is to be
+        // expected next or not.
+        File::Offset offset;
+    };
+
+    typedef SigState<FunctionSig> FunctionSigState;
+    typedef SigState<StructSig> StructSigState;
+    typedef SigState<EnumSig> EnumSigState;
+    typedef SigState<BitmaskSig> BitmaskSigState;
+
+    typedef std::vector<FunctionSigState *> FunctionMap;
+    typedef std::vector<StructSigState *> StructMap;
+    typedef std::vector<EnumSigState *> EnumMap;
+    typedef std::vector<BitmaskSigState *> BitmaskMap;
+
+    FunctionMap functions;
+    StructMap structs;
+    EnumMap enums;
+    BitmaskMap bitmasks;
+
+    unsigned next_call_no;
+
+public:
+    unsigned long long version;
 
-   typedef std::map<size_t, std::string> namemap;
-   namemap names;
+    Parser();
 
-   typedef std::map<unsigned, Call *> callmap;
-   callmap calls;
+    ~Parser();
 
-   typedef std::map<size_t, Bitmask::Signature *> BitmaskMap;
-   BitmaskMap bitmasks;
+    bool open(const char *filename);
 
-   unsigned next_call_no;
+    void close(void);
 
-public:
-   Parser() {
-      file = NULL;
-      next_call_no = 0;
-   }
-
-   ~Parser() {
-      close();
-   }
-
-   bool open(const char *filename) {
-      unsigned long long version;
-
-      file = gzopen(filename, "rb");
-      if (!file) {
-         return false;
-      }
-
-      version = read_uint();
-      if (version != TRACE_VERSION) {
-         std::cerr << "error: unsupported format version" << version << "\n";
-         return false;
-      }
-
-      return true;
-   }
-
-   void close(void) {
-      if (file) {
-         gzclose(file);
-         file = NULL;
-      }
-   }
-
-   Call *parse_call(void) {
-      do {
-         int c = read_byte();
-         switch(c) {
-         case Trace::EVENT_ENTER:
-            parse_enter();
-            break;
-         case Trace::EVENT_LEAVE:
-            return parse_leave();
-         case Trace::EVENT_MESSAGE:
-            std::cerr << "message: " << read_string() << "\n";
-            break;
-         default:
-            std::cerr << "error: unknown call detail " << c << "\n";
-            assert(0);
-            /* fallthrough */
-         case -1:
+    Call *parse_call(void) {
+        return parse_call(FULL);
+    }
+
+    bool supportsOffsets() const
+    {
+        return file->supportsOffsets();
+    }
+
+    void getBookmark(ParseBookmark &bookmark);
+
+    void setBookmark(const ParseBookmark &bookmark);
+
+    int percentRead()
+    {
+        return file->percentRead();
+    }
+
+    Call *scan_call() {
+        return parse_call(SCAN);
+    }
+
+protected:
+    Call *parse_call(Mode mode);
+
+    FunctionSig *parse_function_sig(void);
+    StructSig *parse_struct_sig();
+    EnumSig *parse_enum_sig();
+    BitmaskSig *parse_bitmask_sig();
+    
+    Call *parse_Call(Mode mode);
+
+    void parse_enter(Mode mode);
+
+    Call *parse_leave(Mode mode);
+
+    bool parse_call_details(Call *call, Mode mode);
+
+    void parse_arg(Call *call, Mode mode);
+
+    Value *parse_value(void);
+    void scan_value(void);
+    inline Value *parse_value(Mode mode) {
+        if (mode == FULL) {
+            return parse_value();
+        } else {
+            scan_value();
             return NULL;
-         }
-      } while(true);
-   }
-   
-   void parse_enter(void) {
-      Call *call = new Call;
-      call->no = next_call_no++;
-      call->name = read_name();
-      parse_call_details(call);
-      calls[call->no] = call;
-   }
-   
-   Call *parse_leave(void) {
-      unsigned call_no = read_uint();
-      Call *call = calls[call_no];
-      assert(call);
-      if (!call) {
-          return NULL;
-      }
-      parse_call_details(call);
-      return call;
-   }
-   
-   void parse_call_details(Call *call) {
-      do {
-         int c = read_byte();
-         switch(c) {
-         case Trace::CALL_END:
-            return;
-         case Trace::CALL_ARG:
-            parse_arg(call);
-            break;
-         case Trace::CALL_RET:
-            call->ret = parse_value();
-            break;
-         default:
-            std::cerr << "error: unknown call detail " << c << "\n";
-            assert(0);
-            /* fallthrough */
-         case -1:
-            return;
-         }
-      } while(true);
-   }
-   
-   void parse_arg(Call *call) {
-      unsigned index = read_uint();
-      std::string name = read_name();
-      Value *value = parse_value();
-      if (index >= call->args.size()) {
-          call->args.resize(index + 1);
-      }
-      call->args[index] = Arg(name, value);
-   }
-   
-   Value *parse_value(void) {
-      int c;
-      c = read_byte();
-      switch(c) {
-      case Trace::TYPE_NULL:
-         return new Null;
-      case Trace::TYPE_FALSE:
-         return new Bool(false);
-      case Trace::TYPE_TRUE:
-         return new Bool(true);
-      case Trace::TYPE_SINT:
-         return parse_sint();
-      case Trace::TYPE_UINT:
-         return parse_uint();
-      case Trace::TYPE_FLOAT:
-         return parse_float();
-      case Trace::TYPE_DOUBLE:
-         return parse_double();
-      case Trace::TYPE_STRING:
-         return parse_string();
-      case Trace::TYPE_CONST:
-         return parse_const();
-      case Trace::TYPE_BITMASK:
-         return parse_bitmask();
-      case Trace::TYPE_ARRAY:
-         return parse_array();
-      case Trace::TYPE_STRUCT:
-         return parse_struct();
-      case Trace::TYPE_BLOB:
-         return parse_blob();
-      case Trace::TYPE_OPAQUE:
-         return parse_opaque();
-      default:
-         std::cerr << "error: unknown type " << c << "\n";
-         assert(0);
-         return NULL;
-      }
-   }
-
-   Value *parse_sint() {
-      return new SInt(-(signed long long)read_uint());
-   }
-   
-   Value *parse_uint() {
-      return new UInt(read_uint());
-   }
-   
-   Value *parse_float() {
-      float value;
-      gzread(file, &value, sizeof value);
-      return new Float(value);
-   }
-   
-   Value *parse_double() {
-      double value;
-      gzread(file, &value, sizeof value);
-      return new Float(value);
-   }
-   
-   Value *parse_string() {
-      return new String(read_string());
-   }
-   
-   Value *parse_const() {
-      std::string name = read_name();
-      Value *value = parse_value();
-      return new Const(name, value);
-   }
-   
-   Value *parse_bitmask() {
-      size_t id = read_uint();
-      Bitmask::Signature *sig;
-      BitmaskMap::const_iterator it = bitmasks.find(id);
-      if (it == bitmasks.end()) {
-          size_t size = read_uint();
-          sig = new Bitmask::Signature(size);
-          for (Bitmask::Signature::iterator it = sig->begin(); it != sig->end(); ++it) {
-              it->first = read_string();
-              it->second = read_uint();
-              assert(it->second);
-          }
-          bitmasks[id] = sig;
-      } else {
-          sig = it->second;
-      }
-      assert(sig);
-
-      unsigned long long value = read_uint();
-
-      return new Bitmask(sig, value);
-   }
-
-   Value *parse_array(void) {
-      size_t len = read_uint();
-      Array *array = new Array(len);
-      for (size_t i = 0; i < len; ++i) {
-         array->values[i] = parse_value();
-      }
-      return array;
-   }
-   
-   Value *parse_blob(void) {
-      size_t size = read_uint();
-      Blob *blob = new Blob(size);
-      if (size) {
-          gzread(file, blob->buf, size);
-      }
-      return blob;
-   }
-   
-   Value *parse_struct() {
-      size_t length = read_uint();
-      /* XXX */
-      for (size_t i = 0; i < length; ++i) {
-         std::string name = read_name();
-         Value *value = parse_value();
-         std::cout << "  " << name << " = " << value << "\n";
-      }
-      return NULL;
-   }
-   
-   Value *parse_opaque() {
-      unsigned long long addr;
-      addr = read_uint();
-      /* XXX */
-      return new UInt(addr);
-   }
-
-   std::string read_name(void) {
-       std::string name;
-       size_t id = read_uint();
-       if (id >= names.size()) {
-           assert(id == names.size());
-           name = read_string();
-           names[id] = name;
-           return name;
-       } else {
-           name = names[id];
-       }
-#if TRACE_VERBOSE
-       std::cerr << "\tNAME " << id << " " << name << "\n";
-#endif
-       return name;
-   }
-   
-   std::string read_string(void) {
-      size_t len = read_uint();
-      if (!len) {
-         return std::string();
-      }
-      char * buf = new char[len];
-      gzread(file, buf, len);
-      std::string value(buf, len);
-      delete [] buf;
-#if TRACE_VERBOSE
-      std::cerr << "\tSTRING \"" << value << "\"\n";
-#endif
-      return value;
-   }
-
-   unsigned long long read_uint(void) {
-      unsigned long long value = 0;
-      int c;
-      unsigned shift = 0;
-      do {
-         c = gzgetc(file);
-         if (c == -1) {
-            break;
-         }
-         value |= (unsigned long long)(c & 0x7f) << shift;
-         shift += 7;
-      } while(c & 0x80);
-#if TRACE_VERBOSE
-      std::cerr << "\tUINT " << value << "\n";
-#endif
-      return value;
-   }
-
-   int read_byte(void) {
-      int c = gzgetc(file);
-#if TRACE_VERBOSE
-      if (c < 0)
-         std::cerr << "\tEOF" << "\n";
-      else
-         std::cerr << "\tBYTE 0x" << std::hex << c << std::dec << "\n";
-#endif
-      return c;
-   }
+        }
+    }
+
+    Value *parse_sint();
+    void scan_sint();
+
+    Value *parse_uint();
+    void scan_uint();
+
+    Value *parse_float();
+    void scan_float();
+
+    Value *parse_double();
+    void scan_double();
+
+    Value *parse_string();
+    void scan_string();
+
+    Value *parse_enum();
+    void scan_enum();
+
+    Value *parse_bitmask();
+    void scan_bitmask();
+
+    Value *parse_array(void);
+    void scan_array(void);
+
+    Value *parse_blob(void);
+    void scan_blob(void);
+
+    Value *parse_struct();
+    void scan_struct();
+
+    Value *parse_opaque();
+    void scan_opaque();
+
+    const char * read_string(void);
+    void skip_string(void);
+
+    unsigned long long read_uint(void);
+    void skip_uint(void);
+
+    inline int read_byte(void);
+    inline void skip_byte(void);
 };