Allows us to implement different compression, decompression algos.
endif (WIN32)
add_library (common
+ trace_file.cpp
trace_model.cpp
trace_parser.cpp
trace_writer.cpp
--- /dev/null
+#include "trace_file.hpp"
+
+#include <zlib.h>
+
+using namespace Trace;
+
+File::File(const std::string &filename,
+ File::Mode mode)
+ : m_filename(filename),
+ m_mode(mode),
+ m_isOpened(false)
+{
+ if (!m_filename.empty()) {
+ open(m_filename, m_mode);
+ }
+}
+
+File::~File()
+{
+ close();
+}
+
+bool File::isOpened() const
+{
+ return m_isOpened;
+}
+
+File::Mode File::mode() const
+{
+ return m_mode;
+}
+
+std::string File::filename() const
+{
+ return m_filename;
+}
+
+bool File::open(const std::string &filename, File::Mode mode)
+{
+ if (m_isOpened) {
+ close();
+ }
+ m_isOpened = rawOpen(filename, mode);
+ return m_isOpened;
+}
+
+bool File::write(const void *buffer, int length)
+{
+ if (!m_isOpened || m_mode != File::Write) {
+ return false;
+ }
+ return rawWrite(buffer, length);
+}
+
+bool File::read(void *buffer, int length)
+{
+ if (!m_isOpened || m_mode != File::Read) {
+ return false;
+ }
+ return rawRead(buffer, length);
+}
+
+void File::close()
+{
+ if (m_isOpened) {
+ rawClose();
+ m_isOpened = false;
+ }
+}
+
+void File::flush()
+{
+ rawFlush();
+}
+
+char File::getc()
+{
+ if (!m_isOpened || m_mode != File::Read) {
+ return 0;
+ }
+ return rawGetc();
+}
+
+ZLibFile::ZLibFile(const std::string &filename,
+ File::Mode mode)
+ : File(filename, mode),
+ m_gzFile(NULL)
+{
+}
+
+ZLibFile::~ZLibFile()
+{
+}
+
+bool ZLibFile::rawOpen(const std::string &filename, File::Mode mode)
+{
+ m_gzFile = gzopen(filename.c_str(),
+ (mode == File::Write) ? "wb" : "rb");
+ return m_gzFile != NULL;
+}
+
+bool ZLibFile::rawWrite(const void *buffer, int length)
+{
+ return gzwrite(m_gzFile, buffer, length);
+}
+
+bool ZLibFile::rawRead(void *buffer, int length)
+{
+ return gzread(m_gzFile, buffer, length);
+}
+
+char ZLibFile::rawGetc()
+{
+ return gzgetc(m_gzFile);
+}
+
+void ZLibFile::rawClose()
+{
+ if (m_gzFile) {
+ gzclose(m_gzFile);
+ m_gzFile = NULL;
+ }
+}
+
+void ZLibFile::rawFlush()
+{
+ gzflush(m_gzFile, Z_SYNC_FLUSH);
+}
--- /dev/null
+#ifndef TRACE_FILE_HPP
+#define TRACE_FILE_HPP
+
+#include <string>
+
+namespace Trace {
+
+class File {
+public:
+ enum Mode {
+ Read,
+ Write
+ };
+public:
+ File(const std::string &filename = std::string(),
+ File::Mode mode = File::Read);
+ virtual ~File();
+
+ bool isOpened() const;
+ File::Mode mode() const;
+ std::string filename() const;
+
+ bool open(const std::string &filename, File::Mode mode);
+ bool write(const void *buffer, int length);
+ bool read(void *buffer, int length);
+ void close();
+ void flush();
+ char getc();
+
+protected:
+ virtual bool rawOpen(const std::string &filename, File::Mode mode) = 0;
+ virtual bool rawWrite(const void *buffer, int length) = 0;
+ virtual bool rawRead(void *buffer, int length) = 0;
+ virtual char rawGetc() = 0;
+ virtual void rawClose() = 0;
+ virtual void rawFlush() = 0;
+
+protected:
+ std::string m_filename;
+ File::Mode m_mode;
+ bool m_isOpened;
+};
+
+class ZLibFile : public File {
+public:
+ ZLibFile(const std::string &filename = std::string(),
+ File::Mode mode = File::Read);
+ virtual ~ZLibFile();
+
+protected:
+ virtual bool rawOpen(const std::string &filename, File::Mode mode);
+ virtual bool rawWrite(const void *buffer, int length);
+ virtual bool rawRead(void *buffer, int length);
+ virtual char rawGetc();
+ virtual void rawClose();
+ virtual void rawFlush();
+private:
+ void *m_gzFile;
+};
+
+}
+
+#endif
#include <assert.h>
#include <stdlib.h>
-#include <zlib.h>
-
+#include "trace_file.hpp"
#include "trace_parser.hpp"
Parser::Parser() {
- file = NULL;
+ file = new Trace::ZLibFile;
next_call_no = 0;
version = 0;
}
Parser::~Parser() {
close();
+ delete file;
}
bool Parser::open(const char *filename) {
- file = gzopen(filename, "rb");
- if (!file) {
+ if (!file->open(filename, File::Read)) {
return false;
}
}
void Parser::close(void) {
- if (file) {
- gzclose(file);
- file = NULL;
- }
+ file->close();
deleteAll(calls);
deleteAll(functions);
Value *Parser::parse_float() {
float value;
- gzread(file, &value, sizeof value);
+ file->read(&value, sizeof value);
return new Float(value);
}
Value *Parser::parse_double() {
double value;
- gzread(file, &value, sizeof value);
+ file->read(&value, sizeof value);
return new Float(value);
}
size_t size = read_uint();
Blob *blob = new Blob(size);
if (size) {
- gzread(file, blob->buf, (unsigned)size);
+ file->read(blob->buf, (unsigned)size);
}
return blob;
}
size_t len = read_uint();
char * value = new char[len + 1];
if (len) {
- gzread(file, value, (unsigned)len);
+ file->read(value, (unsigned)len);
}
value[len] = 0;
#if TRACE_VERBOSE
int c;
unsigned shift = 0;
do {
- c = gzgetc(file);
+ c = file->getc();
if (c == -1) {
break;
}
inline int Parser::read_byte(void) {
- int c = gzgetc(file);
+ int c = file->getc();
#if TRACE_VERBOSE
if (c < 0)
std::cerr << "\tEOF" << "\n";
namespace Trace {
+class File;
class Parser
{
protected:
- void *file;
+ File *file;
typedef std::list<Call *> CallList;
CallList calls;
#include <stdlib.h>
#include <string.h>
-#include <zlib.h>
-
#include "os.hpp"
#include "trace_writer.hpp"
+#include "trace_file.hpp"
#include "trace_format.hpp"
Writer::Writer() :
- g_gzFile(NULL),
call_no(0)
{
+ m_file = new Trace::ZLibFile;
close();
-};
+}
-Writer::~Writer() {
+Writer::~Writer()
+{
close();
-};
+ delete m_file;
+ m_file = NULL;
+}
void
Writer::close(void) {
- if (g_gzFile != NULL) {
- gzclose(g_gzFile);
- g_gzFile = NULL;
- }
+ m_file->close();
}
bool
Writer::open(const char *filename) {
close();
- g_gzFile = gzopen(filename, "wb");
- if (!g_gzFile) {
+ if (!m_file->open(filename, File::Write)) {
return false;
}
void inline
Writer::_write(const void *sBuffer, size_t dwBytesToWrite) {
- if (g_gzFile == NULL)
- return;
-
- gzwrite(g_gzFile, sBuffer, dwBytesToWrite);
+ m_file->write(sBuffer, dwBytesToWrite);
}
void inline
unsigned Writer::beginEnter(const FunctionSig *sig) {
OS::AcquireMutex();
- if (!g_gzFile) {
+ if (!m_file->isOpened()) {
open();
}
void Writer::endEnter(void) {
_writeByte(Trace::CALL_END);
- gzflush(g_gzFile, Z_SYNC_FLUSH);
+ m_file->flush();
OS::ReleaseMutex();
}
void Writer::endLeave(void) {
_writeByte(Trace::CALL_END);
- gzflush(g_gzFile, Z_SYNC_FLUSH);
+ m_file->flush();
OS::ReleaseMutex();
}
namespace Trace {
+ class File;
class Writer {
protected:
- void *g_gzFile;
+ File *m_file;
unsigned call_no;
std::vector<bool> functions;