}
if (!libgl_handle) {
- OS::DebugMessage("apitrace: error: couldn't load %s\n", libgl_filename);
- OS::Abort();
+ os::DebugMessage("apitrace: error: couldn't load %s\n", libgl_filename);
+ os::Abort();
return NULL;
}
}
result = dlsym(libgl_handle, symbol);
if (result == dlsym(RTLD_SELF, symbol)) {
- OS::DebugMessage("apitrace: error: symbol lookup recursion\n");
- OS::Abort();
+ os::DebugMessage("apitrace: error: symbol lookup recursion\n");
+ os::Abort();
return NULL;
}
#include <iostream>
-namespace Formatter {
+namespace formatter {
/*
* See also http://bytes.com/topic/c/answers/63822-design-question-little-c-header-colorizing-text-linux-comments-ideas
}
-} /* namespace Formatter */
+} /* namespace formatter */
#endif /* _FORMATTER_HPP_ */
#include "image.hpp"
-namespace Image {
+namespace image {
double Image::compare(Image &ref)
}
-} /* namespace Image */
+} /* namespace image */
#include <fstream>
-namespace Image {
+namespace image {
class Image {
readPNG(const char *filename);
-} /* namespace Image */
+} /* namespace image */
#endif /* _IMAGE_HPP_ */
#include "image.hpp"
-namespace Image {
+namespace image {
#pragma pack(push,2)
}
-} /* namespace Image */
+} /* namespace image */
#include "image.hpp"
-namespace Image {
+namespace image {
bool
return false;
}
-} /* namespace Image */
+} /* namespace image */
#include "image.hpp"
-namespace Image {
+namespace image {
/**
* http://en.wikipedia.org/wiki/Netpbm_format
}
-} /* namespace Image */
+} /* namespace image */
#define PATH_MAX 1024
#endif
-namespace OS {
+namespace os {
void AcquireMutex(void);
void SetExceptionCallback(void (*callback)(void));
void ResetExceptionCallback(void);
-} /* namespace OS */
+} /* namespace os */
#endif /* _OS_HPP_ */
#include "os.hpp"
-namespace OS {
+namespace os {
static pthread_mutex_t
gCallback = NULL;
}
-} /* namespace OS */
+} /* namespace os */
#include "os.hpp"
-namespace OS {
+namespace os {
/*
}
-} /* namespace OS */
+} /* namespace os */
#include <iostream>
-using namespace Trace;
+using namespace trace;
File::File(const std::string &filename,
#include <fstream>
#include <stdint.h>
-namespace Trace {
+namespace trace {
class File {
public:
#define SNAPPY_BYTE2 't'
-using namespace Trace;
+using namespace trace;
class SnappyFile : public File {
#include <iostream>
-using namespace Trace;
+using namespace trace;
class ZLibFile : public File {
#ifndef _TRACE_FORMAT_HPP_
#define _TRACE_FORMAT_HPP_
-namespace Trace {
+namespace trace {
/*
* Trace file version number.
};
-} /* namespace Trace */
+} /* namespace trace */
#endif /* _TRACE_FORMAT_HPP_ */
#include "trace_loader.hpp"
-using namespace Trace;
+using namespace trace;
Loader::Loader()
: m_frameMarker(FrameMarker_SwapBuffers)
return false;
}
- Trace::Call *call;
+ trace::Call *call;
ParseBookmark startBookmark;
unsigned numOfFrames = 0;
unsigned numOfCalls = 0;
m_parser.close();
}
-bool Loader::isCallAFrameMarker(const Trace::Call *call) const
+bool Loader::isCallAFrameMarker(const trace::Call *call) const
{
std::string name = call->name();
return false;
}
-std::vector<Trace::Call *> Loader::frame(unsigned idx)
+std::vector<trace::Call *> Loader::frame(unsigned idx)
{
unsigned numOfCalls = numberOfCallsInFrame(idx);
if (numOfCalls) {
const FrameBookmark &frameBookmark = m_frameBookmarks[idx];
- std::vector<Trace::Call*> calls(numOfCalls);
+ std::vector<trace::Call*> calls(numOfCalls);
m_parser.setBookmark(frameBookmark.start);
- Trace::Call *call;
+ trace::Call *call;
unsigned parsedCalls = 0;
while ((call = m_parser.parse_call())) {
assert(parsedCalls == numOfCalls);
return calls;
}
- return std::vector<Trace::Call*>();
+ return std::vector<trace::Call*>();
}
#include <queue>
#include <vector>
-namespace Trace {
+namespace trace {
class Frame;
bool open(const char *filename);
void close();
- std::vector<Trace::Call*> frame(unsigned idx);
+ std::vector<trace::Call*> frame(unsigned idx);
private:
struct FrameBookmark {
ParseBookmark start;
unsigned numberOfCalls;
};
- bool isCallAFrameMarker(const Trace::Call *call) const;
+ bool isCallAFrameMarker(const trace::Call *call) const;
private:
- Trace::Parser m_parser;
+ trace::Parser m_parser;
FrameMarker m_frameMarker;
typedef std::map<int, FrameBookmark> FrameBookmarks;
#include "trace_model.hpp"
-namespace Trace {
+namespace trace {
Call::~Call() {
{
protected:
std::ostream &os;
- Formatter::Formatter *formatter;
- Formatter::Attribute *normal;
- Formatter::Attribute *bold;
- Formatter::Attribute *italic;
- Formatter::Attribute *red;
- Formatter::Attribute *pointer;
- Formatter::Attribute *literal;
+ formatter::Formatter *formatter;
+ formatter::Attribute *normal;
+ formatter::Attribute *bold;
+ formatter::Attribute *italic;
+ formatter::Attribute *red;
+ formatter::Attribute *pointer;
+ formatter::Attribute *literal;
public:
Dumper(std::ostream &_os, bool color) : os(_os) {
- formatter = Formatter::defaultFormatter(color);
+ formatter = formatter::defaultFormatter(color);
normal = formatter->normal();
bold = formatter->bold();
italic = formatter->italic();
- red = formatter->color(Formatter::RED);
- pointer = formatter->color(Formatter::GREEN);
- literal = formatter->color(Formatter::BLUE);
+ red = formatter->color(formatter::RED);
+ pointer = formatter->color(formatter::GREEN);
+ literal = formatter->color(formatter::BLUE);
}
~Dumper() {
}
-} /* namespace Trace */
+} /* namespace trace */
#include <iostream>
-namespace Trace {
+namespace trace {
typedef unsigned Id;
}
-} /* namespace Trace */
+} /* namespace trace */
#endif /* _TRACE_MODEL_HPP_ */
#define TRACE_VERBOSE 0
-namespace Trace {
+namespace trace {
Parser::Parser() {
do {
int c = read_byte();
switch (c) {
- case Trace::EVENT_ENTER:
+ case trace::EVENT_ENTER:
parse_enter(mode);
break;
- case Trace::EVENT_LEAVE:
+ case trace::EVENT_LEAVE:
return parse_leave(mode);
default:
std::cerr << "error: unknown event " << c << "\n";
do {
int c = read_byte();
switch (c) {
- case Trace::CALL_END:
+ case trace::CALL_END:
return true;
- case Trace::CALL_ARG:
+ case trace::CALL_ARG:
parse_arg(call, mode);
break;
- case Trace::CALL_RET:
+ case trace::CALL_RET:
call->ret = parse_value(mode);
break;
default:
Value *value;
c = read_byte();
switch (c) {
- case Trace::TYPE_NULL:
+ case trace::TYPE_NULL:
value = new Null;
break;
- case Trace::TYPE_FALSE:
+ case trace::TYPE_FALSE:
value = new Bool(false);
break;
- case Trace::TYPE_TRUE:
+ case trace::TYPE_TRUE:
value = new Bool(true);
break;
- case Trace::TYPE_SINT:
+ case trace::TYPE_SINT:
value = parse_sint();
break;
- case Trace::TYPE_UINT:
+ case trace::TYPE_UINT:
value = parse_uint();
break;
- case Trace::TYPE_FLOAT:
+ case trace::TYPE_FLOAT:
value = parse_float();
break;
- case Trace::TYPE_DOUBLE:
+ case trace::TYPE_DOUBLE:
value = parse_double();
break;
- case Trace::TYPE_STRING:
+ case trace::TYPE_STRING:
value = parse_string();
break;
- case Trace::TYPE_ENUM:
+ case trace::TYPE_ENUM:
value = parse_enum();
break;
- case Trace::TYPE_BITMASK:
+ case trace::TYPE_BITMASK:
value = parse_bitmask();
break;
- case Trace::TYPE_ARRAY:
+ case trace::TYPE_ARRAY:
value = parse_array();
break;
- case Trace::TYPE_STRUCT:
+ case trace::TYPE_STRUCT:
value = parse_struct();
break;
- case Trace::TYPE_BLOB:
+ case trace::TYPE_BLOB:
value = parse_blob();
break;
- case Trace::TYPE_OPAQUE:
+ case trace::TYPE_OPAQUE:
value = parse_opaque();
break;
default:
void Parser::scan_value(void) {
int c = read_byte();
switch (c) {
- case Trace::TYPE_NULL:
- case Trace::TYPE_FALSE:
- case Trace::TYPE_TRUE:
+ case trace::TYPE_NULL:
+ case trace::TYPE_FALSE:
+ case trace::TYPE_TRUE:
break;
- case Trace::TYPE_SINT:
+ case trace::TYPE_SINT:
scan_sint();
break;
- case Trace::TYPE_UINT:
+ case trace::TYPE_UINT:
scan_uint();
break;
- case Trace::TYPE_FLOAT:
+ case trace::TYPE_FLOAT:
scan_float();
break;
- case Trace::TYPE_DOUBLE:
+ case trace::TYPE_DOUBLE:
scan_double();
break;
- case Trace::TYPE_STRING:
+ case trace::TYPE_STRING:
scan_string();
break;
- case Trace::TYPE_ENUM:
+ case trace::TYPE_ENUM:
scan_enum();
break;
- case Trace::TYPE_BITMASK:
+ case trace::TYPE_BITMASK:
scan_bitmask();
break;
- case Trace::TYPE_ARRAY:
+ case trace::TYPE_ARRAY:
scan_array();
break;
- case Trace::TYPE_STRUCT:
+ case trace::TYPE_STRUCT:
scan_struct();
break;
- case Trace::TYPE_BLOB:
+ case trace::TYPE_BLOB:
scan_blob();
break;
- case Trace::TYPE_OPAQUE:
+ case trace::TYPE_OPAQUE:
scan_opaque();
break;
default:
}
-} /* namespace Trace */
+} /* namespace trace */
#include "trace_model.hpp"
-namespace Trace {
+namespace trace {
struct ParseBookmark
};
-} /* namespace Trace */
+} /* namespace trace */
#endif /* _TRACE_PARSER_HPP_ */
#include "trace_format.hpp"
-namespace Trace {
+namespace trace {
Writer::Writer() :
}
unsigned Writer::beginEnter(const FunctionSig *sig) {
- _writeByte(Trace::EVENT_ENTER);
+ _writeByte(trace::EVENT_ENTER);
_writeUInt(sig->id);
if (!lookup(functions, sig->id)) {
_writeString(sig->name);
}
void Writer::endEnter(void) {
- _writeByte(Trace::CALL_END);
+ _writeByte(trace::CALL_END);
}
void Writer::beginLeave(unsigned call) {
- _writeByte(Trace::EVENT_LEAVE);
+ _writeByte(trace::EVENT_LEAVE);
_writeUInt(call);
}
void Writer::endLeave(void) {
- _writeByte(Trace::CALL_END);
+ _writeByte(trace::CALL_END);
}
void Writer::beginArg(unsigned index) {
- _writeByte(Trace::CALL_ARG);
+ _writeByte(trace::CALL_ARG);
_writeUInt(index);
}
void Writer::beginReturn(void) {
- _writeByte(Trace::CALL_RET);
+ _writeByte(trace::CALL_RET);
}
void Writer::beginArray(size_t length) {
- _writeByte(Trace::TYPE_ARRAY);
+ _writeByte(trace::TYPE_ARRAY);
_writeUInt(length);
}
void Writer::beginStruct(const StructSig *sig) {
- _writeByte(Trace::TYPE_STRUCT);
+ _writeByte(trace::TYPE_STRUCT);
_writeUInt(sig->id);
if (!lookup(structs, sig->id)) {
_writeString(sig->name);
}
void Writer::writeBool(bool value) {
- _writeByte(value ? Trace::TYPE_TRUE : Trace::TYPE_FALSE);
+ _writeByte(value ? trace::TYPE_TRUE : trace::TYPE_FALSE);
}
void Writer::writeSInt(signed long long value) {
if (value < 0) {
- _writeByte(Trace::TYPE_SINT);
+ _writeByte(trace::TYPE_SINT);
_writeUInt(-value);
} else {
- _writeByte(Trace::TYPE_UINT);
+ _writeByte(trace::TYPE_UINT);
_writeUInt(value);
}
}
void Writer::writeUInt(unsigned long long value) {
- _writeByte(Trace::TYPE_UINT);
+ _writeByte(trace::TYPE_UINT);
_writeUInt(value);
}
void Writer::writeFloat(float value) {
- _writeByte(Trace::TYPE_FLOAT);
+ _writeByte(trace::TYPE_FLOAT);
_writeFloat(value);
}
void Writer::writeDouble(double value) {
- _writeByte(Trace::TYPE_DOUBLE);
+ _writeByte(trace::TYPE_DOUBLE);
_writeDouble(value);
}
Writer::writeNull();
return;
}
- _writeByte(Trace::TYPE_STRING);
+ _writeByte(trace::TYPE_STRING);
_writeString(str);
}
Writer::writeNull();
return;
}
- _writeByte(Trace::TYPE_STRING);
+ _writeByte(trace::TYPE_STRING);
_writeUInt(len);
_write(str, len);
}
Writer::writeNull();
return;
}
- _writeByte(Trace::TYPE_STRING);
+ _writeByte(trace::TYPE_STRING);
_writeString("<wide-string>");
}
Writer::writeNull();
return;
}
- _writeByte(Trace::TYPE_BLOB);
+ _writeByte(trace::TYPE_BLOB);
_writeUInt(size);
if (size) {
_write(data, size);
}
void Writer::writeEnum(const EnumSig *sig) {
- _writeByte(Trace::TYPE_ENUM);
+ _writeByte(trace::TYPE_ENUM);
_writeUInt(sig->id);
if (!lookup(enums, sig->id)) {
_writeString(sig->name);
}
void Writer::writeBitmask(const BitmaskSig *sig, unsigned long long value) {
- _writeByte(Trace::TYPE_BITMASK);
+ _writeByte(trace::TYPE_BITMASK);
_writeUInt(sig->id);
if (!lookup(bitmasks, sig->id)) {
_writeUInt(sig->num_flags);
for (unsigned i = 0; i < sig->num_flags; ++i) {
if (i != 0 && sig->flags[i].value == 0) {
- OS::DebugMessage("apitrace: warning: sig %s is zero but is not first flag\n", sig->flags[i].name);
+ os::DebugMessage("apitrace: warning: sig %s is zero but is not first flag\n", sig->flags[i].name);
}
_writeString(sig->flags[i].name);
_writeUInt(sig->flags[i].value);
}
void Writer::writeNull(void) {
- _writeByte(Trace::TYPE_NULL);
+ _writeByte(trace::TYPE_NULL);
}
void Writer::writeOpaque(const void *addr) {
Writer::writeNull();
return;
}
- _writeByte(Trace::TYPE_OPAQUE);
+ _writeByte(trace::TYPE_OPAQUE);
_writeUInt((size_t)addr);
}
-} /* namespace Trace */
+} /* namespace trace */
#include "trace_model.hpp"
-namespace Trace {
+namespace trace {
class File;
class Writer {
#include "trace_format.hpp"
-namespace Trace {
+namespace trace {
static const char *memcpy_args[3] = {"dest", "src", "n"};
{
// Install the signal handlers as early as possible, to prevent
// interfering with the application's signal handling.
- OS::SetExceptionCallback(exceptionCallback);
+ os::SetExceptionCallback(exceptionCallback);
}
LocalWriter::~LocalWriter()
{
- OS::ResetExceptionCallback();
+ os::ResetExceptionCallback();
}
void
else {
char szProcessName[PATH_MAX];
char szCurrentDir[PATH_MAX];
- OS::GetProcessName(szProcessName, PATH_MAX);
- OS::GetCurrentDir(szCurrentDir, PATH_MAX);
+ os::GetProcessName(szProcessName, PATH_MAX);
+ os::GetCurrentDir(szCurrentDir, PATH_MAX);
for (;;) {
FILE *file;
}
}
- OS::DebugMessage("apitrace: tracing to %s\n", szFileName);
+ os::DebugMessage("apitrace: tracing to %s\n", szFileName);
Writer::open(szFileName);
}
unsigned LocalWriter::beginEnter(const FunctionSig *sig) {
- OS::AcquireMutex();
+ os::AcquireMutex();
++acquired;
if (!m_file->isOpened()) {
void LocalWriter::endEnter(void) {
Writer::endEnter();
--acquired;
- OS::ReleaseMutex();
+ os::ReleaseMutex();
}
void LocalWriter::beginLeave(unsigned call) {
- OS::AcquireMutex();
+ os::AcquireMutex();
++acquired;
Writer::beginLeave(call);
}
void LocalWriter::endLeave(void) {
Writer::endLeave();
--acquired;
- OS::ReleaseMutex();
+ os::ReleaseMutex();
}
void LocalWriter::flush(void) {
*/
if (!acquired) {
- OS::AcquireMutex();
+ os::AcquireMutex();
if (m_file->isOpened()) {
- OS::DebugMessage("apitrace: flushing trace due to an exception\n");
+ os::DebugMessage("apitrace: flushing trace due to an exception\n");
m_file->flush();
}
- OS::ReleaseMutex();
+ os::ReleaseMutex();
}
}
LocalWriter localWriter;
-} /* namespace Trace */
+} /* namespace trace */
#include "trace_writer.hpp"
-namespace Trace {
+namespace trace {
class ModelWriter : public Visitor
}
-} /* namespace Trace */
+} /* namespace trace */
def dump_arg_instance(self, function, arg):
# Dump shaders as strings
if function.name in ('CreateVertexShader', 'CreatePixelShader') and arg.name == 'pFunction':
- print ' DumpShader(Trace::localWriter, %s);' % (arg.name)
+ print ' DumpShader(trace::localWriter, %s);' % (arg.name)
return
DllTracer.dump_arg_instance(self, function, arg)
def dump_arg_instance(self, function, arg):
# Dump shaders as strings
if function.name in ('CreateVertexShader', 'CreatePixelShader') and arg.name == 'pFunction':
- print ' DumpShader(Trace::localWriter, %s);' % (arg.name)
+ print ' DumpShader(trace::localWriter, %s);' % (arg.name)
return
DllTracer.dump_arg_instance(self, function, arg)
);
-void DumpShader(Trace::Writer &writer, const DWORD *tokens)
+void DumpShader(trace::Writer &writer, const DWORD *tokens)
{
static BOOL firsttime = TRUE;
static HMODULE hD3DXModule = NULL;
#include "trace_writer.hpp"
-void DumpShader(Trace::Writer &writer, const DWORD *tokens);
+void DumpShader(trace::Writer &writer, const DWORD *tokens);
#endif /* _D3DSHADER_HPP_ */
def fail_function(self, function):
if function.type is stdapi.Void or function.fail is not None:
- print r' OS::DebugMessage("warning: ignoring call to unavailable function %s\n", __name);'
+ print r' os::DebugMessage("warning: ignoring call to unavailable function %s\n", __name);'
if function.type is stdapi.Void:
assert function.fail is None
print ' return;'
assert function.fail is not None
print ' return %s;' % function.fail
else:
- print r' OS::DebugMessage("error: unavailable function %s\n", __name);'
- print r' OS::Abort();'
+ print r' os::DebugMessage("error: unavailable function %s\n", __name);'
+ print r' os::Abort();'
#include <GL/glx.h>
#include "glext/glxext.h"
-/* Prevent collision with Trace::Bool */
+/* Prevent collision with trace::Bool */
#undef Bool
#endif
extern bool double_buffer;
extern bool insideGlBeginEnd;
-extern Trace::Parser parser;
+extern trace::Parser parser;
extern glws::Visual *visual;
extern glws::Drawable *drawable;
extern glws::Context *context;
extern unsigned dump_state;
void
-checkGlError(Trace::Call &call);
+checkGlError(trace::Call &call);
extern const retrace::Entry gl_callbacks[];
extern const retrace::Entry cgl_callbacks[];
extern const retrace::Entry wgl_callbacks[];
void snapshot(unsigned call_no);
-void frame_complete(Trace::Call &call);
+void frame_complete(trace::Call &call);
void updateDrawable(int width, int height);
}
-static void retrace_CGLSetCurrentContext(Trace::Call &call) {
+static void retrace_CGLSetCurrentContext(trace::Call &call) {
unsigned long long ctx = call.arg(0).toUIntPtr();
glws::Drawable *new_drawable = getDrawable(ctx);
}
-static void retrace_CGLFlushDrawable(Trace::Call &call) {
+static void retrace_CGLFlushDrawable(trace::Call &call) {
if (drawable && context) {
if (double_buffer) {
drawable->swapBuffers();
return it->second;
}
-static void retrace_glXCreateContext(Trace::Call &call) {
+static void retrace_glXCreateContext(trace::Call &call) {
unsigned long long orig_context = call.ret->toUIntPtr();
glws::Context *share_context = getContext(call.arg(2).toUIntPtr());
context_map[orig_context] = context;
}
-static void retrace_glXCreateContextAttribsARB(Trace::Call &call) {
+static void retrace_glXCreateContextAttribsARB(trace::Call &call) {
unsigned long long orig_context = call.ret->toUIntPtr();
glws::Context *share_context = getContext(call.arg(2).toUIntPtr());
context_map[orig_context] = context;
}
-static void retrace_glXMakeCurrent(Trace::Call &call) {
+static void retrace_glXMakeCurrent(trace::Call &call) {
glws::Drawable *new_drawable = getDrawable(call.arg(1).toUInt());
glws::Context *new_context = getContext(call.arg(2).toUIntPtr());
}
-static void retrace_glXDestroyContext(Trace::Call &call) {
+static void retrace_glXDestroyContext(trace::Call &call) {
glws::Context *context = getContext(call.arg(1).toUIntPtr());
if (!context) {
delete context;
}
-static void retrace_glXSwapBuffers(Trace::Call &call) {
+static void retrace_glXSwapBuffers(trace::Call &call) {
frame_complete(call);
if (double_buffer) {
drawable->swapBuffers();
}
}
-static void retrace_glXCreateNewContext(Trace::Call &call) {
+static void retrace_glXCreateNewContext(trace::Call &call) {
unsigned long long orig_context = call.ret->toUIntPtr();
glws::Context *share_context = getContext(call.arg(3).toUIntPtr());
context_map[orig_context] = context;
}
-static void retrace_glXMakeContextCurrent(Trace::Call &call) {
+static void retrace_glXMakeContextCurrent(trace::Call &call) {
glws::Drawable *new_drawable = getDrawable(call.arg(1).toUInt());
glws::Context *new_context = getContext(call.arg(3).toUIntPtr());
bool double_buffer = true;
bool insideGlBeginEnd = false;
-Trace::Parser parser;
+trace::Parser parser;
glws::Visual *visual = NULL;
glws::Drawable *drawable = NULL;
glws::Context *context = NULL;
unsigned dump_state = ~0;
void
-checkGlError(Trace::Call &call) {
+checkGlError(trace::Call &call) {
GLenum error = glGetError();
if (error == GL_NO_ERROR) {
return;
return;
}
- Image::Image *ref = NULL;
+ image::Image *ref = NULL;
if (compare_prefix) {
char filename[PATH_MAX];
snprintf(filename, sizeof filename, "%s%010u.png", compare_prefix, call_no);
- ref = Image::readPNG(filename);
+ ref = image::readPNG(filename);
if (!ref) {
return;
}
}
}
- Image::Image *src = glstate::getDrawBufferImage(GL_RGBA);
+ image::Image *src = glstate::getDrawBufferImage(GL_RGBA);
if (!src) {
return;
}
}
-void frame_complete(Trace::Call &call) {
+void frame_complete(trace::Call &call) {
++frame;
if (!drawable) {
retracer.addCallbacks(wgl_callbacks);
retracer.addCallbacks(cgl_callbacks);
- startTime = OS::GetTime();
- Trace::Call *call;
+ startTime = os::GetTime();
+ trace::Call *call;
while ((call = parser.parse_call())) {
retracer.retrace(*call);
// Reached the end of trace
glFlush();
- long long endTime = OS::GetTime();
+ long long endTime = os::GetTime();
float timeInterval = (endTime - startTime) * 1.0E-6;
if (retrace::verbosity >= -1) {
return it->second;
}
-static void retrace_wglCreateContext(Trace::Call &call) {
+static void retrace_wglCreateContext(trace::Call &call) {
unsigned long long orig_context = call.ret->toUIntPtr();
glws::Context *context = glws::createContext(glretrace::visual);
context_map[orig_context] = context;
}
-static void retrace_wglDeleteContext(Trace::Call &call) {
+static void retrace_wglDeleteContext(trace::Call &call) {
}
-static void retrace_wglMakeCurrent(Trace::Call &call) {
+static void retrace_wglMakeCurrent(trace::Call &call) {
if (drawable && context) {
glFlush();
if (!double_buffer) {
}
}
-static void retrace_wglCopyContext(Trace::Call &call) {
+static void retrace_wglCopyContext(trace::Call &call) {
}
-static void retrace_wglChoosePixelFormat(Trace::Call &call) {
+static void retrace_wglChoosePixelFormat(trace::Call &call) {
}
-static void retrace_wglDescribePixelFormat(Trace::Call &call) {
+static void retrace_wglDescribePixelFormat(trace::Call &call) {
}
-static void retrace_wglSetPixelFormat(Trace::Call &call) {
+static void retrace_wglSetPixelFormat(trace::Call &call) {
}
-static void retrace_wglSwapBuffers(Trace::Call &call) {
+static void retrace_wglSwapBuffers(trace::Call &call) {
frame_complete(call);
if (double_buffer) {
drawable->swapBuffers();
}
}
-static void retrace_wglShareLists(Trace::Call &call) {
+static void retrace_wglShareLists(trace::Call &call) {
unsigned long long hglrc1 = call.arg(0).toUIntPtr();
unsigned long long hglrc2 = call.arg(1).toUIntPtr();
}
}
-static void retrace_wglCreateLayerContext(Trace::Call &call) {
+static void retrace_wglCreateLayerContext(trace::Call &call) {
retrace_wglCreateContext(call);
}
-static void retrace_wglDescribeLayerPlane(Trace::Call &call) {
+static void retrace_wglDescribeLayerPlane(trace::Call &call) {
}
-static void retrace_wglSetLayerPaletteEntries(Trace::Call &call) {
+static void retrace_wglSetLayerPaletteEntries(trace::Call &call) {
}
-static void retrace_wglRealizeLayerPalette(Trace::Call &call) {
+static void retrace_wglRealizeLayerPalette(trace::Call &call) {
}
-static void retrace_wglSwapLayerBuffers(Trace::Call &call) {
+static void retrace_wglSwapLayerBuffers(trace::Call &call) {
retrace_wglSwapBuffers(call);
}
-static void retrace_wglUseFontBitmapsA(Trace::Call &call) {
+static void retrace_wglUseFontBitmapsA(trace::Call &call) {
}
-static void retrace_wglUseFontBitmapsW(Trace::Call &call) {
+static void retrace_wglUseFontBitmapsW(trace::Call &call) {
}
-static void retrace_wglSwapMultipleBuffers(Trace::Call &call) {
+static void retrace_wglSwapMultipleBuffers(trace::Call &call) {
}
-static void retrace_wglUseFontOutlinesA(Trace::Call &call) {
+static void retrace_wglUseFontOutlinesA(trace::Call &call) {
}
-static void retrace_wglUseFontOutlinesW(Trace::Call &call) {
+static void retrace_wglUseFontOutlinesW(trace::Call &call) {
}
-static void retrace_wglCreateBufferRegionARB(Trace::Call &call) {
+static void retrace_wglCreateBufferRegionARB(trace::Call &call) {
}
-static void retrace_wglDeleteBufferRegionARB(Trace::Call &call) {
+static void retrace_wglDeleteBufferRegionARB(trace::Call &call) {
}
-static void retrace_wglSaveBufferRegionARB(Trace::Call &call) {
+static void retrace_wglSaveBufferRegionARB(trace::Call &call) {
}
-static void retrace_wglRestoreBufferRegionARB(Trace::Call &call) {
+static void retrace_wglRestoreBufferRegionARB(trace::Call &call) {
}
-static void retrace_wglChoosePixelFormatARB(Trace::Call &call) {
+static void retrace_wglChoosePixelFormatARB(trace::Call &call) {
}
-static void retrace_wglMakeContextCurrentARB(Trace::Call &call) {
+static void retrace_wglMakeContextCurrentARB(trace::Call &call) {
}
-static void retrace_wglCreatePbufferARB(Trace::Call &call) {
+static void retrace_wglCreatePbufferARB(trace::Call &call) {
int iWidth = call.arg(2).toUInt();
int iHeight = call.arg(3).toUInt();
pbuffer_map[orig_pbuffer] = drawable;
}
-static void retrace_wglGetPbufferDCARB(Trace::Call &call) {
+static void retrace_wglGetPbufferDCARB(trace::Call &call) {
glws::Drawable *pbuffer = pbuffer_map[call.arg(0).toUIntPtr()];
unsigned long long orig_hdc = call.ret->toUIntPtr();
drawable_map[orig_hdc] = pbuffer;
}
-static void retrace_wglReleasePbufferDCARB(Trace::Call &call) {
+static void retrace_wglReleasePbufferDCARB(trace::Call &call) {
}
-static void retrace_wglDestroyPbufferARB(Trace::Call &call) {
+static void retrace_wglDestroyPbufferARB(trace::Call &call) {
}
-static void retrace_wglQueryPbufferARB(Trace::Call &call) {
+static void retrace_wglQueryPbufferARB(trace::Call &call) {
}
-static void retrace_wglBindTexImageARB(Trace::Call &call) {
+static void retrace_wglBindTexImageARB(trace::Call &call) {
}
-static void retrace_wglReleaseTexImageARB(Trace::Call &call) {
+static void retrace_wglReleaseTexImageARB(trace::Call &call) {
}
-static void retrace_wglSetPbufferAttribARB(Trace::Call &call) {
+static void retrace_wglSetPbufferAttribARB(trace::Call &call) {
}
-static void retrace_wglCreateContextAttribsARB(Trace::Call &call) {
+static void retrace_wglCreateContextAttribsARB(trace::Call &call) {
unsigned long long orig_context = call.ret->toUIntPtr();
glws::Context *share_context = NULL;
context_map[orig_context] = context;
}
-static void retrace_wglMakeContextCurrentEXT(Trace::Call &call) {
+static void retrace_wglMakeContextCurrentEXT(trace::Call &call) {
}
-static void retrace_wglChoosePixelFormatEXT(Trace::Call &call) {
+static void retrace_wglChoosePixelFormatEXT(trace::Call &call) {
}
-static void retrace_wglSwapIntervalEXT(Trace::Call &call) {
+static void retrace_wglSwapIntervalEXT(trace::Call &call) {
}
-static void retrace_wglAllocateMemoryNV(Trace::Call &call) {
+static void retrace_wglAllocateMemoryNV(trace::Call &call) {
}
-static void retrace_wglFreeMemoryNV(Trace::Call &call) {
+static void retrace_wglFreeMemoryNV(trace::Call &call) {
}
-static void retrace_glAddSwapHintRectWIN(Trace::Call &call) {
+static void retrace_glAddSwapHintRectWIN(trace::Call &call) {
}
-static void retrace_wglGetProcAddress(Trace::Call &call) {
+static void retrace_wglGetProcAddress(trace::Call &call) {
}
const retrace::Entry glretrace::wgl_callbacks[] = {
case GL_DOUBLE:
return 8;
default:
- OS::DebugMessage("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, type);
+ os::DebugMessage("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, type);
return 0;
}
}
numElems = 1;
break;
default:
- OS::DebugMessage("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, type);
+ os::DebugMessage("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, type);
elemType = GL_NONE;
numElems = 0;
return;
}
}
} else {
- OS::DebugMessage("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, type);
+ os::DebugMessage("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, type);
}
if (__element_array_buffer) {
static inline GLuint
__glDrawArraysIndirect_maxindex(const GLvoid *indirect) {
- OS::DebugMessage("apitrace: warning: %s: unsupported\n", __FUNCTION__);
+ os::DebugMessage("apitrace: warning: %s: unsupported\n", __FUNCTION__);
return 0;
}
static inline GLuint
__glDrawElementsIndirect_maxindex(GLenum type, const GLvoid *indirect) {
- OS::DebugMessage("apitrace: warning: %s: unsupported\n", __FUNCTION__);
+ os::DebugMessage("apitrace: warning: %s: unsupported\n", __FUNCTION__);
return 0;
}
channels = 4;
break;
default:
- OS::DebugMessage("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, target);
+ os::DebugMessage("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, target);
return 0;
}
channels = 4;
break;
default:
- OS::DebugMessage("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, target);
+ os::DebugMessage("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, target);
return 0;
}
case GL_CMYKA_EXT:
return 5;
default:
- OS::DebugMessage("apitrace: warning: %s: unexpected format GLenum 0x%04X\n", __FUNCTION__, format);
+ os::DebugMessage("apitrace: warning: %s: unexpected format GLenum 0x%04X\n", __FUNCTION__, format);
return 0;
}
}
bits_per_pixel = 64;
break;
default:
- OS::DebugMessage("apitrace: warning: %s: unexpected type GLenum 0x%04X\n", __FUNCTION__, type);
+ os::DebugMessage("apitrace: warning: %s: unexpected type GLenum 0x%04X\n", __FUNCTION__, type);
bits_per_pixel = 0;
break;
}
case GL_STENCIL:
return 1;
default:
- OS::DebugMessage("apitrace: warning: %s: unexpected buffer GLenum 0x%04X\n", __FUNCTION__, buffer);
+ os::DebugMessage("apitrace: warning: %s: unexpected buffer GLenum 0x%04X\n", __FUNCTION__, buffer);
return 0;
}
}
/**
* Get the contents of the current drawable into an image.
*/
-static Image::Image *
+static image::Image *
getDrawableImage(void) {
#if defined(_WIN32)
return NULL;
}
- Image::Image *image = NULL;
+ image::Image *image = NULL;
if (ximage->depth == 24 &&
ximage->bits_per_pixel == 32 &&
ximage->green_mask == 0x0000ff00 &&
ximage->blue_mask == 0x000000ff) {
- image = new Image::Image(w, h, 4);
+ image = new image::Image(w, h, 4);
if (image) {
const uint32_t *src = (const uint32_t *)ximage->data;
}
}
} else {
- OS::DebugMessage("apitrace: unexpected XImage: "
+ os::DebugMessage("apitrace: unexpected XImage: "
"bits_per_pixel = %i, "
"depth = %i, "
"red_mask = 0x%08lx, "
++frame_no;
if (snapshot_prefix) {
- Image::Image *src = getDrawableImage();
+ image::Image *src = getDrawableImage();
if (src) {
char filename[PATH_MAX];
snprintf(filename, sizeof filename, "%s%010u.png", snapshot_prefix, call_no);
if (src->writePNG(filename)) {
- OS::DebugMessage("apitrace: wrote %s\n", filename);
+ os::DebugMessage("apitrace: wrote %s\n", filename);
}
delete src;
class JSONWriter;
-namespace Image {
+namespace image {
class Image;
}
namespace glsnapshot {
-Image::Image *
+image::Image *
getDrawableImage(void);
void snapshot(unsigned call_no);
json.beginMember("__data__");
char *pngBuffer;
int pngBufferSize;
- Image::writePixelsToBuffer(pixels, width, height, 4, true, &pngBuffer, &pngBufferSize);
+ image::writePixelsToBuffer(pixels, width, height, 4, true, &pngBuffer, &pngBufferSize);
json.writeBase64(pngBuffer, pngBufferSize);
free(pngBuffer);
json.endMember(); // __data__
}
-Image::Image *
+image::Image *
getDrawBufferImage(GLenum format) {
GLint channels = __gl_format_channels(format);
if (channels > 4) {
}
}
- Image::Image *image = new Image::Image(width, height, channels, true);
+ image::Image *image = new image::Image(width, height, channels, true);
if (!image) {
return NULL;
}
json.beginMember("__data__");
char *pngBuffer;
int pngBufferSize;
- Image::writePixelsToBuffer(pixels, width, height, channels, true, &pngBuffer, &pngBufferSize);
+ image::writePixelsToBuffer(pixels, width, height, channels, true, &pngBuffer, &pngBufferSize);
//std::cerr <<" Before = "<<(width * height * channels * sizeof *pixels)
// <<", after = "<<pngBufferSize << ", ratio = " << double(width * height * channels * sizeof *pixels)/pngBufferSize;
json.writeBase64(pngBuffer, pngBufferSize);
class JSONWriter;
-namespace Image {
+namespace image {
class Image;
}
void dumpCurrentContext(std::ostream &os);
-Image::Image *
+image::Image *
getDrawBufferImage(GLenum format);
print ' case GL_%s:' % target
print ' return & __%s_mapping;' % target.lower()
print ' default:'
- print ' OS::DebugMessage("apitrace: warning: unknown buffer target 0x%04X\\n", target);'
+ print ' os::DebugMessage("apitrace: warning: unknown buffer target 0x%04X\\n", target);'
print ' return NULL;'
print ' }'
print '}'
print ' return num_compressed_texture_formats;'
print ' }'
print ' default:'
- print r' OS::DebugMessage("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, pname);'
+ print r' os::DebugMessage("apitrace: warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, pname);'
print ' return 1;'
print ' }'
print '}'
# Emit a fake function
print ' {'
- print ' static const Trace::FunctionSig &__sig = %s ? __glEnableClientState_sig : __glDisableClientState_sig;' % flag_name
- print ' unsigned __call = Trace::localWriter.beginEnter(&__sig);'
- print ' Trace::localWriter.beginArg(0);'
+ print ' static const trace::FunctionSig &__sig = %s ? __glEnableClientState_sig : __glDisableClientState_sig;' % flag_name
+ print ' unsigned __call = trace::localWriter.beginEnter(&__sig);'
+ print ' trace::localWriter.beginArg(0);'
dump_instance(glapi.GLenum, enable_name)
- print ' Trace::localWriter.endArg();'
- print ' Trace::localWriter.endEnter();'
- print ' Trace::localWriter.beginLeave(__call);'
- print ' Trace::localWriter.endLeave();'
+ print ' trace::localWriter.endArg();'
+ print ' trace::localWriter.endEnter();'
+ print ' trace::localWriter.beginLeave(__call);'
+ print ' trace::localWriter.endLeave();'
print ' }'
print ' return;'
Tracer.dispatch_function(self, function)
def emit_memcpy(self, dest, src, length):
- print ' unsigned __call = Trace::localWriter.beginEnter(&Trace::memcpy_sig);'
- print ' Trace::localWriter.beginArg(0);'
- print ' Trace::localWriter.writeOpaque(%s);' % dest
- print ' Trace::localWriter.endArg();'
- print ' Trace::localWriter.beginArg(1);'
- print ' Trace::localWriter.writeBlob(%s, %s);' % (src, length)
- print ' Trace::localWriter.endArg();'
- print ' Trace::localWriter.beginArg(2);'
- print ' Trace::localWriter.writeUInt(%s);' % length
- print ' Trace::localWriter.endArg();'
- print ' Trace::localWriter.endEnter();'
- print ' Trace::localWriter.beginLeave(__call);'
- print ' Trace::localWriter.endLeave();'
+ print ' unsigned __call = trace::localWriter.beginEnter(&trace::memcpy_sig);'
+ print ' trace::localWriter.beginArg(0);'
+ print ' trace::localWriter.writeOpaque(%s);' % dest
+ print ' trace::localWriter.endArg();'
+ print ' trace::localWriter.beginArg(1);'
+ print ' trace::localWriter.writeBlob(%s, %s);' % (src, length)
+ print ' trace::localWriter.endArg();'
+ print ' trace::localWriter.beginArg(2);'
+ print ' trace::localWriter.writeUInt(%s);' % length
+ print ' trace::localWriter.endArg();'
+ print ' trace::localWriter.endEnter();'
+ print ' trace::localWriter.beginLeave(__call);'
+ print ' trace::localWriter.endLeave();'
buffer_targets = [
'ARRAY_BUFFER',
print ' __glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &__element_array_buffer);'
print ' if (!__element_array_buffer) {'
if isinstance(arg.type, stdapi.Array):
- print ' Trace::localWriter.beginArray(%s);' % arg.type.length
+ print ' trace::localWriter.beginArray(%s);' % arg.type.length
print ' for(GLsizei i = 0; i < %s; ++i) {' % arg.type.length
- print ' Trace::localWriter.beginElement();'
- print ' Trace::localWriter.writeBlob(%s[i], count[i]*__gl_type_size(type));' % (arg.name)
- print ' Trace::localWriter.endElement();'
+ print ' trace::localWriter.beginElement();'
+ print ' trace::localWriter.writeBlob(%s[i], count[i]*__gl_type_size(type));' % (arg.name)
+ print ' trace::localWriter.endElement();'
print ' }'
- print ' Trace::localWriter.endArray();'
+ print ' trace::localWriter.endArray();'
else:
- print ' Trace::localWriter.writeBlob(%s, count*__gl_type_size(type));' % (arg.name)
+ print ' trace::localWriter.writeBlob(%s, count*__gl_type_size(type));' % (arg.name)
print ' } else {'
Tracer.dump_arg_instance(self, function, arg)
print ' }'
print ' GLint __unpack_buffer = 0;'
print ' __glGetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, &__unpack_buffer);'
print ' if (__unpack_buffer) {'
- print ' Trace::localWriter.writeOpaque(%s);' % arg.name
+ print ' trace::localWriter.writeOpaque(%s);' % arg.name
print ' } else {'
Tracer.dump_arg_instance(self, function, arg)
print ' }'
# Emit a fake function
self.array_trace_intermezzo(api, uppercase_name)
- print ' unsigned __call = Trace::localWriter.beginEnter(&__%s_sig);' % (function.name,)
+ print ' unsigned __call = trace::localWriter.beginEnter(&__%s_sig);' % (function.name,)
for arg in function.args:
assert not arg.output
- print ' Trace::localWriter.beginArg(%u);' % (arg.index,)
+ print ' trace::localWriter.beginArg(%u);' % (arg.index,)
if arg.name != 'pointer':
dump_instance(arg.type, arg.name)
else:
- print ' Trace::localWriter.writeBlob((const void *)%s, __size);' % (arg.name)
- print ' Trace::localWriter.endArg();'
+ print ' trace::localWriter.writeBlob((const void *)%s, __size);' % (arg.name)
+ print ' trace::localWriter.endArg();'
- print ' Trace::localWriter.endEnter();'
- print ' Trace::localWriter.beginLeave(__call);'
- print ' Trace::localWriter.endLeave();'
+ print ' trace::localWriter.endEnter();'
+ print ' trace::localWriter.beginLeave(__call);'
+ print ' trace::localWriter.endLeave();'
print ' }'
print ' }'
self.array_epilog(api, uppercase_name)
print ' size_t __size = __%s_size(%s, maxindex);' % (function.name, arg_names)
# Emit a fake function
- print ' unsigned __call = Trace::localWriter.beginEnter(&__%s_sig);' % (function.name,)
+ print ' unsigned __call = trace::localWriter.beginEnter(&__%s_sig);' % (function.name,)
for arg in function.args:
assert not arg.output
- print ' Trace::localWriter.beginArg(%u);' % (arg.index,)
+ print ' trace::localWriter.beginArg(%u);' % (arg.index,)
if arg.name != 'pointer':
dump_instance(arg.type, arg.name)
else:
- print ' Trace::localWriter.writeBlob((const void *)%s, __size);' % (arg.name)
- print ' Trace::localWriter.endArg();'
+ print ' trace::localWriter.writeBlob((const void *)%s, __size);' % (arg.name)
+ print ' trace::localWriter.endArg();'
- print ' Trace::localWriter.endEnter();'
- print ' Trace::localWriter.beginLeave(__call);'
- print ' Trace::localWriter.endLeave();'
+ print ' trace::localWriter.endEnter();'
+ print ' trace::localWriter.beginLeave(__call);'
+ print ' trace::localWriter.endLeave();'
print ' }'
print ' }'
print ' }'
self.fake_call(function, [texture])
def fake_call(self, function, args):
- print ' unsigned __fake_call = Trace::localWriter.beginEnter(&__%s_sig);' % (function.name,)
+ print ' unsigned __fake_call = trace::localWriter.beginEnter(&__%s_sig);' % (function.name,)
for arg, instance in zip(function.args, args):
assert not arg.output
- print ' Trace::localWriter.beginArg(%u);' % (arg.index,)
+ print ' trace::localWriter.beginArg(%u);' % (arg.index,)
dump_instance(arg.type, instance)
- print ' Trace::localWriter.endArg();'
- print ' Trace::localWriter.endEnter();'
- print ' Trace::localWriter.beginLeave(__fake_call);'
- print ' Trace::localWriter.endLeave();'
+ print ' trace::localWriter.endArg();'
+ print ' trace::localWriter.endEnter();'
+ print ' trace::localWriter.beginLeave(__fake_call);'
+ print ' trace::localWriter.endLeave();'
print ' %s = (%s)procPtr;' % (pvalue, ptype)
print ' return (__GLXextFuncPtr)&%s;' % (f.name,)
print ' }'
- print ' OS::DebugMessage("apitrace: warning: unknown function \\"%s\\"\\n", (const char *)procName);'
+ print ' os::DebugMessage("apitrace: warning: unknown function \\"%s\\"\\n", (const char *)procName);'
print ' return procPtr;'
print '}'
print
if (!dlopen_ptr) {
dlopen_ptr = (PFNDLOPEN)dlsym(RTLD_NEXT, "dlopen");
if (!dlopen_ptr) {
- OS::DebugMessage("apitrace: error: dlsym(RTLD_NEXT, \"dlopen\") failed\n");
+ os::DebugMessage("apitrace: error: dlsym(RTLD_NEXT, \"dlopen\") failed\n");
return NULL;
}
}
if (filename && handle && !libgl_filename) {
if (0) {
- OS::DebugMessage("apitrace: warning: dlopen(\"%s\", 0x%x)\n", filename, flag);
+ os::DebugMessage("apitrace: warning: dlopen(\"%s\", 0x%x)\n", filename, flag);
}
// FIXME: handle absolute paths and other versions
static int dummy = 0xdeedbeef;
Dl_info info;
if (dladdr(&dummy, &info)) {
- OS::DebugMessage("apitrace: redirecting dlopen(\"%s\", 0x%x)\n", filename, flag);
+ os::DebugMessage("apitrace: redirecting dlopen(\"%s\", 0x%x)\n", filename, flag);
handle = __dlopen(info.dli_fname, flag);
} else {
- OS::DebugMessage("apitrace: warning: dladdr() failed\n");
+ os::DebugMessage("apitrace: warning: dladdr() failed\n");
}
}
}
libgl_handle = __dlopen(libgl_filename, RTLD_GLOBAL | RTLD_LAZY);
if (!libgl_handle) {
- OS::DebugMessage("apitrace: error: couldn't find libGL.so\n");
+ os::DebugMessage("apitrace: error: couldn't find libGL.so\n");
return NULL;
}
}
}
-void VariantVisitor::visit(Trace::Null *)
+void VariantVisitor::visit(trace::Null *)
{
m_variant = QVariant::fromValue(ApiPointer(0));
}
-void VariantVisitor::visit(Trace::Bool *node)
+void VariantVisitor::visit(trace::Bool *node)
{
m_variant = QVariant(node->value);
}
-void VariantVisitor::visit(Trace::SInt *node)
+void VariantVisitor::visit(trace::SInt *node)
{
m_variant = QVariant(node->value);
}
-void VariantVisitor::visit(Trace::UInt *node)
+void VariantVisitor::visit(trace::UInt *node)
{
m_variant = QVariant(node->value);
}
-void VariantVisitor::visit(Trace::Float *node)
+void VariantVisitor::visit(trace::Float *node)
{
m_variant = QVariant(node->value);
}
-void VariantVisitor::visit(Trace::String *node)
+void VariantVisitor::visit(trace::String *node)
{
m_variant = QVariant(QString::fromStdString(node->value));
}
-void VariantVisitor::visit(Trace::Enum *e)
+void VariantVisitor::visit(trace::Enum *e)
{
ApiTraceEnumSignature *sig = 0;
m_variant = QVariant::fromValue(ApiEnum(sig));
}
-void VariantVisitor::visit(Trace::Bitmask *bitmask)
+void VariantVisitor::visit(trace::Bitmask *bitmask)
{
m_variant = QVariant::fromValue(ApiBitmask(bitmask));
}
-void VariantVisitor::visit(Trace::Struct *str)
+void VariantVisitor::visit(trace::Struct *str)
{
m_variant = QVariant::fromValue(ApiStruct(str));
}
-void VariantVisitor::visit(Trace::Array *array)
+void VariantVisitor::visit(trace::Array *array)
{
m_variant = QVariant::fromValue(ApiArray(array));
}
-void VariantVisitor::visit(Trace::Blob *blob)
+void VariantVisitor::visit(trace::Blob *blob)
{
QByteArray barray = QByteArray(blob->buf, blob->size);
m_variant = QVariant(barray);
}
-void VariantVisitor::visit(Trace::Pointer *ptr)
+void VariantVisitor::visit(trace::Pointer *ptr)
{
m_variant = QVariant::fromValue(ApiPointer(ptr->value));
}
return QLatin1String("NULL");
}
-ApiBitmask::ApiBitmask(const Trace::Bitmask *bitmask)
+ApiBitmask::ApiBitmask(const trace::Bitmask *bitmask)
: m_value(0)
{
init(bitmask);
}
-void ApiBitmask::init(const Trace::Bitmask *bitmask)
+void ApiBitmask::init(const trace::Bitmask *bitmask)
{
if (!bitmask)
return;
m_value = bitmask->value;
- for (const Trace::BitmaskFlag *it = bitmask->sig->flags;
+ for (const trace::BitmaskFlag *it = bitmask->sig->flags;
it != bitmask->sig->flags + bitmask->sig->num_flags; ++it) {
assert(it->value);
QPair<QString, unsigned long long> pair;
return str;
}
-ApiStruct::ApiStruct(const Trace::Struct *s)
+ApiStruct::ApiStruct(const trace::Struct *s)
{
init(s);
}
return str;
}
-void ApiStruct::init(const Trace::Struct *s)
+void ApiStruct::init(const trace::Struct *s)
{
if (!s)
return;
}
}
-ApiArray::ApiArray(const Trace::Array *arr)
+ApiArray::ApiArray(const trace::Array *arr)
{
init(arr);
}
return str;
}
-void ApiArray::init(const Trace::Array *arr)
+void ApiArray::init(const trace::Array *arr)
{
if (!arr)
return;
ApiTraceCall::ApiTraceCall(ApiTraceFrame *parentFrame,
TraceLoader *loader,
- const Trace::Call *call)
+ const trace::Call *call)
: ApiTraceEvent(ApiTraceEvent::Call),
m_parentFrame(parentFrame)
{
class ApiTrace;
class TraceLoader;
-class VariantVisitor : public Trace::Visitor
+class VariantVisitor : public trace::Visitor
{
public:
VariantVisitor(TraceLoader *loader)
: m_loader(loader)
{}
- virtual void visit(Trace::Null *);
- virtual void visit(Trace::Bool *node);
- virtual void visit(Trace::SInt *node);
- virtual void visit(Trace::UInt *node);
- virtual void visit(Trace::Float *node);
- virtual void visit(Trace::String *node);
- virtual void visit(Trace::Enum *e);
- virtual void visit(Trace::Bitmask *bitmask);
- virtual void visit(Trace::Struct *str);
- virtual void visit(Trace::Array *array);
- virtual void visit(Trace::Blob *blob);
- virtual void visit(Trace::Pointer *ptr);
+ virtual void visit(trace::Null *);
+ virtual void visit(trace::Bool *node);
+ virtual void visit(trace::SInt *node);
+ virtual void visit(trace::UInt *node);
+ virtual void visit(trace::Float *node);
+ virtual void visit(trace::String *node);
+ virtual void visit(trace::Enum *e);
+ virtual void visit(trace::Bitmask *bitmask);
+ virtual void visit(trace::Struct *str);
+ virtual void visit(trace::Array *array);
+ virtual void visit(trace::Blob *blob);
+ virtual void visit(trace::Pointer *ptr);
QVariant variant() const
{
public:
typedef QList<QPair<QString, unsigned long long> > Signature;
- ApiBitmask(const Trace::Bitmask *bitmask = 0);
+ ApiBitmask(const trace::Bitmask *bitmask = 0);
QString toString() const;
Signature signature() const;
private:
- void init(const Trace::Bitmask *bitmask);
+ void init(const trace::Bitmask *bitmask);
private:
Signature m_sig;
unsigned long long m_value;
QStringList memberNames;
};
- ApiStruct(const Trace::Struct *s = 0);
+ ApiStruct(const trace::Struct *s = 0);
QString toString(bool multiLine = false) const;
Signature signature() const;
QList<QVariant> values() const;
private:
- void init(const Trace::Struct *bitmask);
+ void init(const trace::Struct *bitmask);
private:
Signature m_sig;
QList<QVariant> m_members;
class ApiArray
{
public:
- ApiArray(const Trace::Array *arr = 0);
+ ApiArray(const trace::Array *arr = 0);
ApiArray(const QVector<QVariant> &vals);
QString toString(bool multiLine = false) const;
QVector<QVariant> values() const;
private:
- void init(const Trace::Array *arr);
+ void init(const trace::Array *arr);
private:
QVector<QVariant> m_array;
};
{
public:
ApiTraceCall(ApiTraceFrame *parentFrame, TraceLoader *loader,
- const Trace::Call *tcall);
+ const trace::Call *tcall);
~ApiTraceCall();
int index() const;
#include <QDebug>
#if 0
-static Trace::FunctionSig *
+static trace::FunctionSig *
createFunctionSig(ApiTraceCall *call, unsigned id)
{
- Trace::FunctionSig *sig = new Trace::FunctionSig();
+ trace::FunctionSig *sig = new trace::FunctionSig();
sig->id = id;
sig->name = qstrdup(call->name().toLocal8Bit());
}
static void
-deleteFunctionSig(Trace::FunctionSig *sig)
+deleteFunctionSig(trace::FunctionSig *sig)
{
for (int i = 0; i < sig->num_args; ++i) {
delete [] sig->arg_names[i];
delete sig;
}
-static Trace::StructSig *
+static trace::StructSig *
createStructSig(const ApiStruct &str, unsigned id)
{
ApiStruct::Signature aSig = str.signature();
- Trace::StructSig *sig = new Trace::StructSig();
+ trace::StructSig *sig = new trace::StructSig();
sig->id = id;
sig->name = qstrdup(aSig.name.toLocal8Bit());
sig->num_members = aSig.memberNames.count();
}
static void
-deleteStructSig(Trace::StructSig *sig)
+deleteStructSig(trace::StructSig *sig)
{
for (int i = 0; i < sig->num_members; ++i) {
delete [] sig->member_names[i];
delete sig;
}
-static Trace::EnumSig *
+static trace::EnumSig *
createEnumSig(const ApiEnum &en, unsigned id)
{
- Trace::EnumSig *sig = new Trace::EnumSig();
+ trace::EnumSig *sig = new trace::EnumSig();
sig->id = id;
sig->name = qstrdup(en.name().toLocal8Bit());
}
static void
-deleteEnumSig(Trace::EnumSig *sig)
+deleteEnumSig(trace::EnumSig *sig)
{
delete [] sig->name;
delete sig;
}
-static Trace::BitmaskSig *
+static trace::BitmaskSig *
createBitmaskSig(const ApiBitmask &bt, unsigned id)
{
ApiBitmask::Signature bsig = bt.signature();
ApiBitmask::Signature::const_iterator itr;
- Trace::BitmaskSig *sig = new Trace::BitmaskSig();
- Trace::BitmaskFlag *flags = new Trace::BitmaskFlag[bsig.count()];
+ trace::BitmaskSig *sig = new trace::BitmaskSig();
+ trace::BitmaskFlag *flags = new trace::BitmaskFlag[bsig.count()];
sig->id = id;
sig->num_flags = bsig.count();
}
static void
-deleteBitmaskSig(Trace::BitmaskSig *sig)
+deleteBitmaskSig(trace::BitmaskSig *sig)
{
for (int i = 0; i < sig->num_flags; ++i) {
delete [] sig->flags[i].name;
}
static void
-writeValue(Trace::Writer &writer, const QVariant &var, unsigned &id)
+writeValue(trace::Writer &writer, const QVariant &var, unsigned &id)
{
int arrayType = QMetaType::type("ApiArray");
int bitmaskType = QMetaType::type("ApiBitmask");
writer.endArray();
} else if (type == bitmaskType) {
ApiBitmask bm = var.value<ApiBitmask>();
- Trace::BitmaskSig *sig = createBitmaskSig(bm, ++id);
+ trace::BitmaskSig *sig = createBitmaskSig(bm, ++id);
writer.writeBitmask(sig, bm.value());
deleteBitmaskSig(sig);
} else if (type == structType) {
ApiStruct apiStr = var.value<ApiStruct>();
QList<QVariant> vals = apiStr.values();
- Trace::StructSig *str = createStructSig(apiStr, ++id);
+ trace::StructSig *str = createStructSig(apiStr, ++id);
writer.beginStruct(str);
foreach(QVariant val, vals) {
writeValue(writer, val, ++id);
//writer.endArray();
} else if (type == enumType) {
ApiEnum apiEnum = var.value<ApiEnum>();
- Trace::EnumSig *sig = createEnumSig(apiEnum, ++id);
+ trace::EnumSig *sig = createEnumSig(apiEnum, ++id);
writer.writeEnum(sig);
deleteEnumSig(sig);
} else {
}
#endif
-class EditVisitor : public Trace::Visitor
+class EditVisitor : public trace::Visitor
{
public:
EditVisitor(const QVariant &variant)
: m_variant(variant),
m_editedValue(0)
{}
- virtual void visit(Trace::Null *val)
+ virtual void visit(trace::Null *val)
{
m_editedValue = val;
}
- virtual void visit(Trace::Bool *node)
+ virtual void visit(trace::Bool *node)
{
// Q_ASSERT(m_variant.userType() == QVariant::Bool);
bool var = m_variant.toBool();
- m_editedValue = new Trace::Bool(var);
+ m_editedValue = new trace::Bool(var);
}
- virtual void visit(Trace::SInt *node)
+ virtual void visit(trace::SInt *node)
{
// Q_ASSERT(m_variant.userType() == QVariant::Int);
- m_editedValue = new Trace::SInt(m_variant.toInt());
+ m_editedValue = new trace::SInt(m_variant.toInt());
}
- virtual void visit(Trace::UInt *node)
+ virtual void visit(trace::UInt *node)
{
// Q_ASSERT(m_variant.userType() == QVariant::UInt);
- m_editedValue = new Trace::SInt(m_variant.toUInt());
+ m_editedValue = new trace::SInt(m_variant.toUInt());
}
- virtual void visit(Trace::Float *node)
+ virtual void visit(trace::Float *node)
{
- m_editedValue = new Trace::Float(m_variant.toFloat());
+ m_editedValue = new trace::Float(m_variant.toFloat());
}
- virtual void visit(Trace::String *node)
+ virtual void visit(trace::String *node)
{
QString str = m_variant.toString();
- m_editedValue = new Trace::String(str.toLocal8Bit().constData());
+ m_editedValue = new trace::String(str.toLocal8Bit().constData());
}
- virtual void visit(Trace::Enum *e)
+ virtual void visit(trace::Enum *e)
{
m_editedValue = e;
}
- virtual void visit(Trace::Bitmask *bitmask)
+ virtual void visit(trace::Bitmask *bitmask)
{
m_editedValue = bitmask;
}
- virtual void visit(Trace::Struct *str)
+ virtual void visit(trace::Struct *str)
{
m_editedValue = str;
}
- virtual void visit(Trace::Array *array)
+ virtual void visit(trace::Array *array)
{
ApiArray apiArray = m_variant.value<ApiArray>();
QVector<QVariant> vals = apiArray.values();
- Trace::Array *newArray = new Trace::Array(vals.count());
+ trace::Array *newArray = new trace::Array(vals.count());
for (int i = 0; i < vals.count(); ++i) {
EditVisitor visitor(vals[i]);
m_editedValue = newArray;
}
- virtual void visit(Trace::Blob *blob)
+ virtual void visit(trace::Blob *blob)
{
m_editedValue = blob;
}
- virtual void visit(Trace::Pointer *ptr)
+ virtual void visit(trace::Pointer *ptr)
{
m_editedValue = ptr;
}
- Trace::Value *value() const
+ trace::Value *value() const
{
return m_editedValue;
}
private:
QVariant m_variant;
- Trace::Value *m_editedValue;
+ trace::Value *m_editedValue;
};
static void
-overwriteValue(Trace::Call *call, const QVariant &val, int index)
+overwriteValue(trace::Call *call, const QVariant &val, int index)
{
EditVisitor visitor(val);
- Trace::Value *origValue = call->args[index];
+ trace::Value *origValue = call->args[index];
origValue->visit(visitor);
if (visitor.value() && origValue != visitor.value()) {
callIndexMap.insert(call->index(), call);
}
- Trace::Writer writer;
+ trace::Writer writer;
writer.open(m_writeFileName.toLocal8Bit());
- Trace::Parser parser;
+ trace::Parser parser;
parser.open(m_readFileName.toLocal8Bit());
- Trace::Call *call;
+ trace::Call *call;
while ((call = parser.parse_call())) {
if (callIndexMap.contains(call->no)) {
QVector<QVariant> values = callIndexMap[call->no]->editedValues();
#define FRAMES_TO_CACHE 100
static ApiTraceCall *
-apiCallFromTraceCall(const Trace::Call *call,
+apiCallFromTraceCall(const trace::Call *call,
const QHash<QString, QUrl> &helpHash,
ApiTraceFrame *frame,
TraceLoader *loader)
m_frameMarker = marker;
}
-bool TraceLoader::isCallAFrameMarker(const Trace::Call *call) const
+bool TraceLoader::isCallAFrameMarker(const trace::Call *call) const
{
std::string name = call->name();
QList<ApiTraceFrame*> frames;
ApiTraceFrame *currentFrame = 0;
- Trace::Call *call;
- Trace::ParseBookmark startBookmark;
+ trace::Call *call;
+ trace::ParseBookmark startBookmark;
int numOfFrames = 0;
int numOfCalls = 0;
int lastPercentReport = 0;
}
if (numOfCalls) {
- //Trace::File::Bookmark endBookmark = m_parser.currentBookmark();
+ //trace::File::Bookmark endBookmark = m_parser.currentBookmark();
FrameBookmark frameBookmark(startBookmark);
frameBookmark.numberOfCalls = numOfCalls;
int lastPercentReport = 0;
- Trace::Call *call = m_parser.parse_call();
+ trace::Call *call = m_parser.parse_call();
while (call) {
//std::cout << *call;
if (!currentFrame) {
int startFrame = m_createdFrames.indexOf(request.frame);
const FrameBookmark &frameBookmark = m_frameBookmarks[startFrame];
m_parser.setBookmark(frameBookmark.start);
- Trace::Call *call = 0;
+ trace::Call *call = 0;
while ((call = m_parser.parse_call())) {
if (callContains(call, request.text, request.cs)) {
Q_ASSERT(m_parser.supportsOffsets());
if (m_parser.supportsOffsets()) {
int startFrame = m_createdFrames.indexOf(request.frame);
- Trace::Call *call = 0;
- QList<Trace::Call*> frameCalls;
+ trace::Call *call = 0;
+ QList<trace::Call*> frameCalls;
int frameIdx = startFrame;
const FrameBookmark &frameBookmark = m_frameBookmarks[frameIdx];
emit searchResult(request, ApiTrace::SearchResult_NotFound, 0);
}
-bool TraceLoader::searchCallsBackwards(const QList<Trace::Call*> &calls,
+bool TraceLoader::searchCallsBackwards(const QList<trace::Call*> &calls,
int frameIdx,
const ApiTrace::SearchRequest &request)
{
for (int i = calls.count() - 1; i >= 0; --i) {
- Trace::Call *call = calls[i];
+ trace::Call *call = calls[i];
if (callContains(call, request.text, request.cs)) {
ApiTraceFrame *frame = m_createdFrames[frameIdx];
const QVector<ApiTraceCall*> apiCalls =
return 0;
}
-bool TraceLoader::callContains(Trace::Call *call,
+bool TraceLoader::callContains(trace::Call *call,
const QString &str,
Qt::CaseSensitivity sensitivity)
{
/*
- * FIXME: do string comparison directly on Trace::Call
+ * FIXME: do string comparison directly on trace::Call
*/
ApiTraceCall *apiCall = apiCallFromTraceCall(call, m_helpHash,
0, this);
m_parser.setBookmark(frameBookmark.start);
- Trace::Call *call;
+ trace::Call *call;
int parsedCalls = 0;
while ((call = m_parser.parse_call())) {
ApiTraceCall *apiCall =
FrameBookmark()
: numberOfCalls(0)
{}
- FrameBookmark(const Trace::ParseBookmark &s)
+ FrameBookmark(const trace::ParseBookmark &s)
: start(s),
numberOfCalls(0)
{}
- Trace::ParseBookmark start;
+ trace::ParseBookmark start;
int numberOfCalls;
};
- bool isCallAFrameMarker(const Trace::Call *call) const;
+ bool isCallAFrameMarker(const trace::Call *call) const;
int numberOfFrames() const;
int numberOfCallsInFrame(int frameIdx) const;
void searchPrev(const ApiTrace::SearchRequest &request);
int callInFrame(int callIdx) const;
- bool callContains(Trace::Call *call,
+ bool callContains(trace::Call *call,
const QString &str,
Qt::CaseSensitivity sensitivity);
QVector<ApiTraceCall*> fetchFrameContents(ApiTraceFrame *frame);
- bool searchCallsBackwards(const QList<Trace::Call*> &calls,
+ bool searchCallsBackwards(const QList<trace::Call*> &calls,
int frameIdx,
const ApiTrace::SearchRequest &request);
private:
- Trace::Parser m_parser;
+ trace::Parser m_parser;
ApiTrace::FrameMarker m_frameMarker;
typedef QMap<int, FrameBookmark> FrameBookmarks;
static bool call_dumped = false;
-static void dumpCall(Trace::Call &call) {
+static void dumpCall(trace::Call &call) {
if (verbosity >= 0 && !call_dumped) {
std::cout << call;
std::cout.flush();
}
-std::ostream &warning(Trace::Call &call) {
+std::ostream &warning(trace::Call &call) {
dumpCall(call);
std::cerr << call.no << ": ";
}
-void ignore(Trace::Call &call) {
+void ignore(trace::Call &call) {
(void)call;
}
-void unsupported(Trace::Call &call) {
+void unsupported(trace::Call &call) {
warning(call) << "unsupported " << call.name() << " call\n";
}
}
-void Retracer::retrace(Trace::Call &call) {
+void Retracer::retrace(trace::Call &call) {
call_dumped = false;
if (verbosity >= 1) {
Callback callback = 0;
- Trace::Id id = call.sig->id;
+ trace::Id id = call.sig->id;
if (id >= callbacks.size()) {
callbacks.resize(id + 1);
callback = 0;
delRegionByPointer(void *ptr);
void *
-toPointer(Trace::Value &value, bool bind = false);
+toPointer(trace::Value &value, bool bind = false);
/**
extern int verbosity;
-std::ostream &warning(Trace::Call &call);
+std::ostream &warning(trace::Call &call);
-void ignore(Trace::Call &call);
-void unsupported(Trace::Call &call);
+void ignore(trace::Call &call);
+void unsupported(trace::Call &call);
-typedef void (*Callback)(Trace::Call &call);
+typedef void (*Callback)(trace::Call &call);
struct Entry {
const char *name;
void addCallback(const Entry *entry);
void addCallbacks(const Entry *entries);
- void retrace(Trace::Call &call);
+ void retrace(trace::Call &call);
};
self.visit(bitmask.type, lvalue, rvalue)
def visit_array(self, array, lvalue, rvalue):
- print ' const Trace::Array *__a%s = dynamic_cast<const Trace::Array *>(&%s);' % (array.tag, rvalue)
+ print ' const trace::Array *__a%s = dynamic_cast<const trace::Array *>(&%s);' % (array.tag, rvalue)
print ' if (__a%s) {' % (array.tag)
length = '__a%s->values.size()' % array.tag
print ' %s = new %s[%s];' % (lvalue, array.type, length)
print ' }'
def visit_pointer(self, pointer, lvalue, rvalue):
- print ' const Trace::Array *__a%s = dynamic_cast<const Trace::Array *>(&%s);' % (pointer.tag, rvalue)
+ print ' const trace::Array *__a%s = dynamic_cast<const trace::Array *>(&%s);' % (pointer.tag, rvalue)
print ' if (__a%s) {' % (pointer.tag)
print ' %s = new %s;' % (lvalue, pointer.type)
try:
pass
def visit_array(self, array, lvalue, rvalue):
- print ' const Trace::Array *__a%s = dynamic_cast<const Trace::Array *>(&%s);' % (array.tag, rvalue)
+ print ' const trace::Array *__a%s = dynamic_cast<const trace::Array *>(&%s);' % (array.tag, rvalue)
print ' if (__a%s) {' % (array.tag)
length = '__a%s->values.size()' % array.tag
index = '__j' + array.tag
print ' }'
def visit_pointer(self, pointer, lvalue, rvalue):
- print ' const Trace::Array *__a%s = dynamic_cast<const Trace::Array *>(&%s);' % (pointer.tag, rvalue)
+ print ' const trace::Array *__a%s = dynamic_cast<const trace::Array *>(&%s);' % (pointer.tag, rvalue)
print ' if (__a%s) {' % (pointer.tag)
try:
self.visit(pointer.type, '%s[0]' % (lvalue,), '*__a%s->values[0]' % (pointer.tag,))
class Retracer:
def retrace_function(self, function):
- print 'static void retrace_%s(Trace::Call &call) {' % function.name
+ print 'static void retrace_%s(trace::Call &call) {' % function.name
self.retrace_function_body(function)
print '}'
print
}
-class Translator : protected Trace::Visitor
+class Translator : protected trace::Visitor
{
protected:
bool bind;
void *result;
- void visit(Trace::Null *) {
+ void visit(trace::Null *) {
result = NULL;
}
- void visit(Trace::Blob *blob) {
+ void visit(trace::Blob *blob) {
result = blob->toPointer(bind);
}
- void visit(Trace::Pointer *p) {
+ void visit(trace::Pointer *p) {
result = lookupAddress(p->value);
}
result(NULL)
{}
- void * operator() (Trace::Value *node) {
+ void * operator() (trace::Value *node) {
_visit(node);
return result;
}
void *
-toPointer(Trace::Value &value, bool bind) {
+toPointer(trace::Value &value, bool bind) {
return Translator(bind) (&value);
}
-static void retrace_malloc(Trace::Call &call) {
+static void retrace_malloc(trace::Call &call) {
size_t size = call.arg(0).toUInt();
unsigned long long address = call.ret->toUIntPtr();
}
-static void retrace_memcpy(Trace::Call &call) {
+static void retrace_memcpy(trace::Call &call) {
void * dest = toPointer(call.arg(0));
void * src = toPointer(call.arg(1));
size_t n = call.arg(2).toUInt();
for type, name, in struct.members:
print ' "%s",' % (name,)
print ' };'
- print ' static const Trace::StructSig sig = {'
+ print ' static const trace::StructSig sig = {'
print ' %u, "%s", %u, members' % (struct.id, struct.name, len(struct.members))
print ' };'
- print ' Trace::localWriter.beginStruct(&sig);'
+ print ' trace::localWriter.beginStruct(&sig);'
for type, name in struct.members:
dump_instance(type, 'value.%s' % (name,))
- print ' Trace::localWriter.endStruct();'
+ print ' trace::localWriter.endStruct();'
print '}'
print
n = len(enum.values)
for i in range(n):
value = enum.values[i]
- print ' static const Trace::EnumSig sig%u = {%u, "%s", %s};' % (i, DumpDeclarator.__enum_id, value, value)
+ print ' static const trace::EnumSig sig%u = {%u, "%s", %s};' % (i, DumpDeclarator.__enum_id, value, value)
DumpDeclarator.__enum_id += 1
- print ' const Trace::EnumSig *sig;'
+ print ' const trace::EnumSig *sig;'
print ' switch (value) {'
for i in range(n):
value = enum.values[i]
print ' sig = &sig%u;' % i
print ' break;'
print ' default:'
- print ' Trace::localWriter.writeSInt(value);'
+ print ' trace::localWriter.writeSInt(value);'
print ' return;'
print ' }'
- print ' Trace::localWriter.writeEnum(sig);'
+ print ' trace::localWriter.writeEnum(sig);'
print '}'
print
def visit_bitmask(self, bitmask):
- print 'static const Trace::BitmaskFlag __bitmask%s_flags[] = {' % (bitmask.tag)
+ print 'static const trace::BitmaskFlag __bitmask%s_flags[] = {' % (bitmask.tag)
for value in bitmask.values:
print ' {"%s", %s},' % (value, value)
print '};'
print
- print 'static const Trace::BitmaskSig __bitmask%s_sig = {' % (bitmask.tag)
+ print 'static const trace::BitmaskSig __bitmask%s_sig = {' % (bitmask.tag)
print ' %u, %u, __bitmask%s_flags' % (bitmask.id, len(bitmask.values), bitmask.tag)
print '};'
print
'''Dump an instance.'''
def visit_literal(self, literal, instance):
- print ' Trace::localWriter.write%s(%s);' % (literal.kind, instance)
+ print ' trace::localWriter.write%s(%s);' % (literal.kind, instance)
def visit_string(self, string, instance):
if string.length is not None:
- print ' Trace::localWriter.writeString((const char *)%s, %s);' % (instance, string.length)
+ print ' trace::localWriter.writeString((const char *)%s, %s);' % (instance, string.length)
else:
- print ' Trace::localWriter.writeString((const char *)%s);' % instance
+ print ' trace::localWriter.writeString((const char *)%s);' % instance
def visit_const(self, const, instance):
self.visit(const.type, instance)
index = '__i' + array.type.tag
print ' if (%s) {' % instance
print ' size_t %s = %s;' % (length, array.length)
- print ' Trace::localWriter.beginArray(%s);' % length
+ print ' trace::localWriter.beginArray(%s);' % length
print ' for (size_t %s = 0; %s < %s; ++%s) {' % (index, index, length, index)
- print ' Trace::localWriter.beginElement();'
+ print ' trace::localWriter.beginElement();'
self.visit(array.type, '(%s)[%s]' % (instance, index))
- print ' Trace::localWriter.endElement();'
+ print ' trace::localWriter.endElement();'
print ' }'
- print ' Trace::localWriter.endArray();'
+ print ' trace::localWriter.endArray();'
print ' } else {'
- print ' Trace::localWriter.writeNull();'
+ print ' trace::localWriter.writeNull();'
print ' }'
def visit_blob(self, blob, instance):
- print ' Trace::localWriter.writeBlob(%s, %s);' % (instance, blob.size)
+ print ' trace::localWriter.writeBlob(%s, %s);' % (instance, blob.size)
def visit_enum(self, enum, instance):
print ' _write__%s(%s);' % (enum.tag, instance)
def visit_bitmask(self, bitmask, instance):
- print ' Trace::localWriter.writeBitmask(&__bitmask%s_sig, %s);' % (bitmask.tag, instance)
+ print ' trace::localWriter.writeBitmask(&__bitmask%s_sig, %s);' % (bitmask.tag, instance)
def visit_pointer(self, pointer, instance):
print ' if (%s) {' % instance
- print ' Trace::localWriter.beginArray(1);'
- print ' Trace::localWriter.beginElement();'
+ print ' trace::localWriter.beginArray(1);'
+ print ' trace::localWriter.beginElement();'
dump_instance(pointer.type, "*" + instance)
- print ' Trace::localWriter.endElement();'
- print ' Trace::localWriter.endArray();'
+ print ' trace::localWriter.endElement();'
+ print ' trace::localWriter.endArray();'
print ' } else {'
- print ' Trace::localWriter.writeNull();'
+ print ' trace::localWriter.writeNull();'
print ' }'
def visit_handle(self, handle, instance):
self.visit(alias.type, instance)
def visit_opaque(self, opaque, instance):
- print ' Trace::localWriter.writeOpaque((const void *)%s);' % instance
+ print ' trace::localWriter.writeOpaque((const void *)%s);' % instance
def visit_interface(self, interface, instance):
- print ' Trace::localWriter.writeOpaque((const void *)&%s);' % instance
+ print ' trace::localWriter.writeOpaque((const void *)&%s);' % instance
def visit_polymorphic(self, polymorphic, instance):
print ' _write__%s(%s, %s);' % (polymorphic.tag, polymorphic.switch_expr, instance)
print 'static const char * __%s_args[%u] = {%s};' % (function.name, len(function.args), ', '.join(['"%s"' % arg.name for arg in function.args]))
else:
print 'static const char ** __%s_args = NULL;' % (function.name,)
- print 'static const Trace::FunctionSig __%s_sig = {%u, "%s", %u, __%s_args};' % (function.name, function.id, function.name, len(function.args), function.name)
+ print 'static const trace::FunctionSig __%s_sig = {%u, "%s", %u, __%s_args};' % (function.name, function.id, function.name, len(function.args), function.name)
print
def is_public_function(self, function):
print
def trace_function_impl_body(self, function):
- print ' unsigned __call = Trace::localWriter.beginEnter(&__%s_sig);' % (function.name,)
+ print ' unsigned __call = trace::localWriter.beginEnter(&__%s_sig);' % (function.name,)
for arg in function.args:
if not arg.output:
self.unwrap_arg(function, arg)
self.dump_arg(function, arg)
- print ' Trace::localWriter.endEnter();'
+ print ' trace::localWriter.endEnter();'
self.dispatch_function(function)
- print ' Trace::localWriter.beginLeave(__call);'
+ print ' trace::localWriter.beginLeave(__call);'
for arg in function.args:
if arg.output:
self.dump_arg(function, arg)
self.wrap_arg(function, arg)
if function.type is not stdapi.Void:
self.dump_ret(function, "__result")
- print ' Trace::localWriter.endLeave();'
+ print ' trace::localWriter.endLeave();'
def dispatch_function(self, function, prefix='__', suffix=''):
if function.type is stdapi.Void:
print ' %s%s(%s);' % (result, dispatch, ', '.join([str(arg.name) for arg in function.args]))
def dump_arg(self, function, arg):
- print ' Trace::localWriter.beginArg(%u);' % (arg.index,)
+ print ' trace::localWriter.beginArg(%u);' % (arg.index,)
self.dump_arg_instance(function, arg)
- print ' Trace::localWriter.endArg();'
+ print ' trace::localWriter.endArg();'
def dump_arg_instance(self, function, arg):
dump_instance(arg.type, arg.name)
unwrap_instance(arg.type, arg.name)
def dump_ret(self, function, instance):
- print ' Trace::localWriter.beginReturn();'
+ print ' trace::localWriter.beginReturn();'
dump_instance(function.type, instance)
- print ' Trace::localWriter.endReturn();'
+ print ' trace::localWriter.endReturn();'
def wrap_ret(self, function, instance):
wrap_instance(function.type, instance)
def trace_method(self, interface, method):
print method.prototype(interface_wrap_name(interface) + '::' + method.name) + ' {'
print ' static const char * __args[%u] = {%s};' % (len(method.args) + 1, ', '.join(['"this"'] + ['"%s"' % arg.name for arg in method.args]))
- print ' static const Trace::FunctionSig __sig = {%u, "%s", %u, __args};' % (method.id, interface.name + '::' + method.name, len(method.args) + 1)
- print ' unsigned __call = Trace::localWriter.beginEnter(&__sig);'
- print ' Trace::localWriter.beginArg(0);'
- print ' Trace::localWriter.writeOpaque((const void *)m_pInstance);'
- print ' Trace::localWriter.endArg();'
+ print ' static const trace::FunctionSig __sig = {%u, "%s", %u, __args};' % (method.id, interface.name + '::' + method.name, len(method.args) + 1)
+ print ' unsigned __call = trace::localWriter.beginEnter(&__sig);'
+ print ' trace::localWriter.beginArg(0);'
+ print ' trace::localWriter.writeOpaque((const void *)m_pInstance);'
+ print ' trace::localWriter.endArg();'
for arg in method.args:
if not arg.output:
self.unwrap_arg(method, arg)
else:
print ' %s __result;' % method.type
result = '__result = '
- print ' Trace::localWriter.endEnter();'
+ print ' trace::localWriter.endEnter();'
print ' %sm_pInstance->%s(%s);' % (result, method.name, ', '.join([str(arg.name) for arg in method.args]))
- print ' Trace::localWriter.beginLeave(__call);'
+ print ' trace::localWriter.beginLeave(__call);'
for arg in method.args:
if arg.output:
self.dump_arg(method, arg)
self.wrap_arg(method, arg)
if method.type is not stdapi.Void:
- print ' Trace::localWriter.beginReturn();'
+ print ' trace::localWriter.beginReturn();'
dump_instance(method.type, "__result")
- print ' Trace::localWriter.endReturn();'
+ print ' trace::localWriter.endReturn();'
wrap_instance(method.type, '__result')
- print ' Trace::localWriter.endLeave();'
+ print ' trace::localWriter.endLeave();'
if method.name == 'QueryInterface':
print ' if (ppvObj && *ppvObj) {'
print ' if (*ppvObj == m_pInstance) {'
}
for (; i < argc; ++i) {
- Trace::Parser p;
+ trace::Parser p;
if (!p.open(argv[i])) {
std::cerr << "error: failed to open " << argv[i] << "\n";
return 1;
}
- Trace::Call *call;
+ trace::Call *call;
while ((call = p.parse_call())) {
call->dump(std::cout, color);
delete call;
print ' %s = (%s)&%s;' % (instance, function.type, f.name);
def handle_default():
- print ' OS::DebugMessage("apitrace: warning: unknown function \\"%s\\"\\n", lpszProc);'
+ print ' os::DebugMessage("apitrace: warning: unknown function \\"%s\\"\\n", lpszProc);'
string_switch('lpszProc', func_dict.keys(), handle_case, handle_default)
print ' }'
projects / apitrace / commitdiff