See what's going on with flipcode!




This section of the archives stores flipcode's complete Developer Toolbox collection, featuring a variety of mini-articles and source code contributions from our readers.

 

  Java Style Call Stack Printing In C++
  Submitted by



This small C++ library implements "Java-style" call stack printing using stack frames and map files. Makes for example assertions more useful as you can see the context where the assertion failed. The library is very easy to use (you need only one function, printStackTrace) and the library can be freely used in any applications. Regards,
Jani Kajala
Email: jani@sumea.com
Homepage: http://www.helsinki.fi/~kajala/



Editor's note: See /doc/printStackTrace.html within the zip file, for more information about the library.


Currently browsing [stacktrace.zip] (38,843 bytes) - [internal/Array.h] - (2,394 bytes)

#ifndef _DEV_ARRAY_H
#define _DEV_ARRAY_H

namespace dev {

/** Very simple dynamic array. */ template <class T> class Array { public: /** Creates an empty array. */ Array() : m_data(0), m_len(0), m_cap(0) { }

/** Creates an array of specified size. */ explicit Array( int size ) : m_data(0), m_len(0), m_cap(0) { setSize( size ); }

/// ~Array() { delete[] m_data; }

/** Appends an item at the end of the array. */ void add( const T& item ) { if ( m_len+1 > m_cap ) setCapacity( m_len + 1 ); m_data[m_len++] = item; }

/** Resizes the array. */ void setSize( int size ) { if ( size > m_cap ) setCapacity( size ); m_len = size; }

/** Returns ith item. */ T& operator[]( int i ) { return m_data[i]; }

/** Returns pointer to the first element in the vector. */ T* begin() { return m_data; }

/** Returns pointer to one beyond the last element in the vector. */ T* end() { return m_data + m_len; }

/** Returns number of items in the array. */ int size() const { return m_len; }

/** Returns ith item. */ const T& operator[]( int i ) const { return m_data[i]; }

/** Returns pointer to the first element in the vector. */ const T* begin() const { return m_data; }

/** Returns pointer to one beyond the last element in the vector. */ const T* end() const { return m_data + m_len; }

private: T* m_data; int m_len; int m_cap;

void setCapacity( int cap ) { ++cap; if ( cap < 8 ) cap = 8; else if ( cap < m_cap*2 ) cap = m_cap*2; m_cap = cap;

T* data = new T[cap]; for ( int i = 0 ; i < m_len ; ++i ) data[i] = m_data[i]; delete[] m_data; m_data = data; } };

} // dev

#endif // _DEV_ARRAY_H /* * Copyright (c) 2001 Jani Kajala * * Permission to use, copy, modify, distribute and sell this * software and its documentation for any purpose is hereby * granted without fee, provided that the above copyright notice * appear in all copies and that both that copyright notice and * this permission notice appear in supporting documentation. * Jani Kajala makes no representations about the suitability * of this software for any purpose. It is provided "as is" * without express or implied warranty. */

Currently browsing [stacktrace.zip] (38,843 bytes) - [internal/MapFile.cpp] - (6,832 bytes)

#include "MapFile.h"
#include "MapFileEntry.h"
#include "TextFile.h"
#include "Array.h"
#include <algorithm>
#include <string.h>
#include <ctype.h>
#ifdef WIN32
#include <windows.h>
#endif

//----------------------------------------------------------------------------- namespace dev {

class MapFile::MapFileImpl { public: long loadAddr; char name[256]; Array<MapFileEntry> segments; Array<MapFileEntry> entries;

MapFileImpl( const char* filename ) : loadAddr(0), m_file( filename ), m_err( MapFile::ERROR_NONE ) { m_file.readString( name, sizeof(name) );

char buf[1024]; while ( m_file.readString(buf,sizeof(buf)) ) { if ( !strcmp("Preferred",buf) ) parseLoadAddress(); else if ( !strcmp("Start",buf) ) parseSegments(); else if ( !strcmp("Address",buf) ) parseEntries(); else m_file.skipLine(); }

std::sort( segments.begin(), segments.end() ); std::sort( entries.begin(), entries.end() ); }

~MapFileImpl() { }

ErrorType error() const { if ( m_err != MapFile::ERROR_NONE ) return m_err;

switch ( m_file.error() ) { case TextFile::ERROR_OPEN: return MapFile::ERROR_OPEN; case TextFile::ERROR_READ: return MapFile::ERROR_READ; case TextFile::ERROR_PARSE: return MapFile::ERROR_PARSE; default: return MapFile::ERROR_NONE; } }

int line() const { if ( m_err != MapFile::ERROR_NONE ) return m_errLine;

return m_file.line(); } private: TextFile m_file; MapFile::ErrorType m_err; int m_errLine;

/** * Returns true if the next line is empty. */ bool nextLineEmpty() { m_file.skipLine(); char ch; while ( m_file.peekChar(&ch) && isspace(ch) && ch != '\n' ) m_file.readChar( &ch ); if ( m_file.peekChar(&ch) && ch == '\n' ) return true; return false; }

/** * Parses specified string. * Sets error if parsed string doesnt match. */ void parse( const char* str ) { char buf[256]; m_file.readString( buf, sizeof(buf) ); if ( strcmp(str,buf) ) { m_err = MapFile::ERROR_PARSE; m_errLine = m_file.line(); } }

/** * Parses specified character. * Sets error if parsed character doesnt match. */ void parse( char ch ) { char ch2; if ( !m_file.readChar(&ch2) || ch2 != ch ) { m_err = MapFile::ERROR_PARSE; m_errLine = m_file.line(); } }

/** * Example: * (Preferred) load address is 00400000 */ void parseLoadAddress() { parse( "load" ); parse( "address" ); parse( "is" ); loadAddr = m_file.readHex(); }

/** * Example: * (Start) Length Name Class * 0001:00000000 00002c05H .text CODE */ void parseSegments() { parse( "Length" ); parse( "Name" ); parse( "Class" ); m_file.skipWhitespace(); while ( !error() ) { int seg = m_file.readHex(); parse( ':' ); int offs = m_file.readHex(); int len = m_file.readHex(); parse( 'H' ); char buf[256]; m_file.readString( buf, sizeof(buf) ); segments.add( MapFileEntry(seg,offs,len,buf) );

// break at empty line if ( nextLineEmpty() ) break; } }

/** * Example: * (Address) Publics by Value Rva+Base Lib:Object * 0001:000001a0 ?stackTrace@@YAXXZ 004011a0 f main.obj */ void parseEntries() { parse( "Publics" ); parse( "by" ); parse( "Value" ); parse( "Rva+Base" ); parse( "Lib:Object" ); m_file.skipWhitespace(); while ( !error() ) { int seg = m_file.readHex(); parse( ':' ); int offs = m_file.readHex(); char buf[256]; m_file.readString( buf, sizeof(buf) ); char* entryname = buf;

// chop entry name at @@ char* end = strstr( entryname, "@@" ); if ( end ) *end = 0; // skip preceding ?01.. while ( isdigit(*entryname) || *entryname == '?' || *entryname == '$' ) ++entryname; // conv @ -> . for ( char* str = entryname ; *str ; ++str ) if ( *str == '@' ) *str = '.';

entries.add( MapFileEntry(seg,offs,0,entryname) );

// break at empty line if ( nextLineEmpty() ) break; } } };

//----------------------------------------------------------------------------- MapFile::MapFile( const char* filename ) { m_this = new MapFileImpl( filename ); }

MapFile::~MapFile() { delete m_this; }

long MapFile::loadAddress() const { return m_this->loadAddr; }

const MapFileEntry& MapFile::getSegment( int i ) const { return m_this->segments[i]; }

const MapFileEntry& MapFile::getEntry( int i ) const { return m_this->entries[i]; }

int MapFile::segments() const { return m_this->segments.size(); }

int MapFile::entries() const { return m_this->entries.size(); }

MapFile::ErrorType MapFile::error() const { return m_this->error(); }

int MapFile::line() const { return m_this->line(); }

int MapFile::findEntry( long addr ) const { for ( int j = 0 ; j < segments() ; ++j ) { const MapFileEntry& segment = getSegment( j ); long section = segment.section(); long segmentBegin = loadAddress() + (segment.section() << 12) + segment.offset(); long segmentEnd = segmentBegin + segment.length();

if ( addr >= segmentBegin && addr < segmentEnd ) { for ( int i = entries()-1 ; i >= 0 ; --i ) { const MapFileEntry entry = getEntry( i ); if ( entry.section() == section ) { long entryAddr = loadAddress() + (entry.section() << 12) + entry.offset(); if ( entryAddr <= addr ) return i; } } } } return -1; }

void MapFile::getModuleMapFilename( char* buffer, int bufferSize ) { int len = 0; buffer[len] = 0;

#ifdef WIN32 // get name of the exe/dll len = GetModuleFileName( GetModuleHandle(0), buffer, bufferSize-1 ); buffer[len] = 0; #endif

// remove .exe or .dll extension if ( len > 3 && (!strcmp(buffer+len-4,".exe") || !strcmp(buffer+len-4,".EXE") || !strcmp(buffer+len-4,".DLL") || !strcmp(buffer+len-4,".dll")) ) { buffer[len-4] = 0; }

// append .map extension if ( (int)strlen(buffer)+4 < bufferSize ) { strcat( buffer, ".map" ); } }

} // dev /* * Copyright (c) 2001 Jani Kajala * * Permission to use, copy, modify, distribute and sell this * software and its documentation for any purpose is hereby * granted without fee, provided that the above copyright notice * appear in all copies and that both that copyright notice and * this permission notice appear in supporting documentation. * Jani Kajala makes no representations about the suitability * of this software for any purpose. It is provided "as is" * without express or implied warranty. */

Currently browsing [stacktrace.zip] (38,843 bytes) - [internal/MapFile.h] - (2,144 bytes)

#ifndef _DEV_MAPFILE_H
#define _DEV_MAPFILE_H

namespace dev {

class MapFileEntry;

/** * Linker generated module map file parser. */ class MapFile { public: /** Error code. */ enum ErrorType { /** No error. */ ERROR_NONE, /** File open failed. */ ERROR_OPEN, /** File reading failed. */ ERROR_READ, /** Syntax error. */ ERROR_PARSE };

/** Reads a map file. */ explicit MapFile( const char* filename );

/// ~MapFile();

/** Returns preferred load address. */ long loadAddress() const;

/** Returns ith entry from the map file. */ const MapFileEntry& getEntry( int i ) const;

/** Returns ith segment from the map file. */ const MapFileEntry& getSegment( int i ) const;

/** Returns number of segments in the map file. */ int segments() const;

/** Returns number of entries in the map file. */ int entries() const;

/** Returns error code or 0 (ERROR_NONE) if no error. */ ErrorType error() const;

/** Returns line number of last successful read character. */ int line() const;

/** * Finds entry which contains specified address. * @return Entry index or -1 if not found. */ int findEntry( long addr ) const;

/** * Returns current module name, with map extension. * The output buffer is always 0-terminated. */ static void getModuleMapFilename( char* buffer, int bufferSize );

private: class MapFileImpl; MapFileImpl* m_this;

MapFile( const MapFile& ); MapFile& operator=( const MapFile& ); };

} // dev

#endif // _DEV_MAPFILE_H /* * Copyright (c) 2001 Jani Kajala * * Permission to use, copy, modify, distribute and sell this * software and its documentation for any purpose is hereby * granted without fee, provided that the above copyright notice * appear in all copies and that both that copyright notice and * this permission notice appear in supporting documentation. * Jani Kajala makes no representations about the suitability * of this software for any purpose. It is provided "as is" * without express or implied warranty. */

Currently browsing [stacktrace.zip] (38,843 bytes) - [internal/MapFileEntry.cpp] - (1,451 bytes)

#include "MapFileEntry.h"
#include <string.h>

//----------------------------------------------------------------------------- namespace dev {

MapFileEntry::MapFileEntry() { m_sec = 0; m_addr = 0; m_len = 0; m_name[0] = 0; }

MapFileEntry::MapFileEntry( long section, long offset, long length, const char* name ) { m_sec = section; m_addr = offset; m_len = length;

strncpy( m_name, name, MAX_NAME ); m_name[MAX_NAME] = 0; }

long MapFileEntry::section() const { return m_sec; }

long MapFileEntry::offset() const { return m_addr; }

long MapFileEntry::length() const { return m_len; }

const char* MapFileEntry::name() const { return m_name; }

bool MapFileEntry::operator<( const MapFileEntry& other ) const { if ( m_sec < other.m_sec ) return true; if ( m_sec > other.m_sec ) return false; return m_addr < other.m_addr; }

} // dev /* * Copyright (c) 2001 Jani Kajala * * Permission to use, copy, modify, distribute and sell this * software and its documentation for any purpose is hereby * granted without fee, provided that the above copyright notice * appear in all copies and that both that copyright notice and * this permission notice appear in supporting documentation. * Jani Kajala makes no representations about the suitability * of this software for any purpose. It is provided "as is" * without express or implied warranty. */

Currently browsing [stacktrace.zip] (38,843 bytes) - [internal/MapFileEntry.h] - (1,548 bytes)

#ifndef _DEV_MAPFILEENTRY_H
#define _DEV_MAPFILEENTRY_H

namespace dev {

/** An entry in the map file. */ class MapFileEntry { public: /** Class constants. */ enum Constants { /** Maximum number of characters in map file entry name. */ MAX_NAME = 256 };

/// MapFileEntry();

/** Creates an entry with specified section, offset, length and name. */ MapFileEntry( long section, long offset, long length, const char* name );

/** Returns section of the entry. */ long section() const;

/** Returns offset of the entry. */ long offset() const;

/** Returns length of the entry (only defined for segments). */ long length() const;

/** Returns name of the entry. */ const char* name() const;

/** Returns true if the offset of this entry is before the other one. */ bool operator<( const MapFileEntry& other ) const;

private: long m_sec; long m_addr; long m_len; char m_name[MAX_NAME+1]; };

} // dev

#endif // _DEV_MAPFILEENTRY_H /* * Copyright (c) 2001 Jani Kajala * * Permission to use, copy, modify, distribute and sell this * software and its documentation for any purpose is hereby * granted without fee, provided that the above copyright notice * appear in all copies and that both that copyright notice and * this permission notice appear in supporting documentation. * Jani Kajala makes no representations about the suitability * of this software for any purpose. It is provided "as is" * without express or implied warranty. */

Currently browsing [stacktrace.zip] (38,843 bytes) - [internal/StackTrace.cpp] - (2,945 bytes)

#include "StackTrace.h"
#include "MapFile.h"
#include "MapFileEntry.h"
#include <string.h>
#include <stdio.h>

//----------------------------------------------------------------------------- #define MAX_DEPTH 32

//----------------------------------------------------------------------------- namespace dev {

static long getCaller( int index ) { #if defined(_DEBUG) && defined(_MSC_VER) && defined(_M_IX86)

long caller = 0; __asm { mov ebx, ebp mov ecx, index inc ecx xor eax, eax StackTrace_getCaller_next: mov eax, [ebx+4] mov ebx, [ebx] dec ecx jnz StackTrace_getCaller_next mov caller, eax } return caller;

#else

return 0;

#endif }

int StackTrace::printStackTrace( MapFile** map, int maps, int initLevel, int maxDepth, char* buffer, int bufferSize ) { if ( maxDepth > MAX_DEPTH ) maxDepth = MAX_DEPTH;

// list callers long callersAddr[MAX_DEPTH]; int callers = 0; int i; for ( i = initLevel ; i < maxDepth ; ++i ) { long addr = getCaller( i ); callersAddr[callers++] = addr;

// end tracing here if the entry is not in a map file int entry = -1; for ( int j = 0 ; j < maps ; ++j ) { entry = map[j]->findEntry( addr ); if ( -1 != entry ) break; } if ( -1 == entry ) break; }

// output call stack if ( bufferSize > 0 ) *buffer = 0; int needed = 0; for ( i = initLevel ; i < callers ; ++i ) { long addr = callersAddr[callers-i-1];

// find entry info int entry = -1; const MapFile* entryMap = 0; for ( int j = 0 ; j < maps ; ++j ) { entry = map[j]->findEntry( addr ); if ( -1 != entry ) { entryMap = map[j]; break; } }

// format entry to tempory buf char buf[MapFileEntry::MAX_NAME+MAX_DEPTH+20]; // name + margin + hex number buf[0] = 0; for ( int k = initLevel-1 ; k < i ; ++k ) strcat( buf, " " ); if ( !entryMap ) sprintf( buf+strlen(buf), "0x%x\n", addr ); else sprintf( buf+strlen(buf), "%s (%x)\n", entryMap->getEntry(entry).name(), addr );

// append temporary buf to output buffer if space left needed += strlen( buf ); if ( needed < bufferSize ) strcat( buffer, buf ); }

// terminate output buffer if ( needed < bufferSize ) buffer[needed] = 0; else if ( bufferSize > 0 ) buffer[bufferSize-1] = 0; return needed; }

} // dev /* * Copyright (c) 2001 Jani Kajala * * Permission to use, copy, modify, distribute and sell this * software and its documentation for any purpose is hereby * granted without fee, provided that the above copyright notice * appear in all copies and that both that copyright notice and * this permission notice appear in supporting documentation. * Jani Kajala makes no representations about the suitability * of this software for any purpose. It is provided "as is" * without express or implied warranty. */

Currently browsing [stacktrace.zip] (38,843 bytes) - [internal/StackTrace.h] - (1,373 bytes)

#ifndef _DEV_STACKTRACE_H
#define _DEV_STACKTRACE_H

namespace dev {

class MapFile;

/** Stack tracing utility. */ class StackTrace { public: /** * Prints formatted call stack to the user buffer. * Always terminates the user buffer with 0. * * @param map Array of pointers to map files. * @param maps Number of map files. * @param initLevel Number of functions to skip before starting the tracing. * @param maxDepth Maximum number of levels in the stack trace. * @param buffer [out] Output buffer for the formatted stack trace. * @param bufferSize Size of the output buffer. * @return Needed buffer size. */ static int printStackTrace( MapFile** map, int maps, int initLevel, int maxDepth, char* buffer, int bufferSize ); };

} // dev

#endif // _DEV_STACKTRACE_H /* * Copyright (c) 2001 Jani Kajala * * Permission to use, copy, modify, distribute and sell this * software and its documentation for any purpose is hereby * granted without fee, provided that the above copyright notice * appear in all copies and that both that copyright notice and * this permission notice appear in supporting documentation. * Jani Kajala makes no representations about the suitability * of this software for any purpose. It is provided "as is" * without express or implied warranty. */

Currently browsing [stacktrace.zip] (38,843 bytes) - [internal/TextFile.cpp] - (4,554 bytes)

#include "TextFile.h"
#include <stdio.h>
#include <ctype.h>

//----------------------------------------------------------------------------- namespace dev {

class TextFile::TextFileImpl { public: TextFile::ErrorType err; int line;

explicit TextFileImpl( const char* filename ) { err = TextFile::ERROR_NONE; line = 1; m_peeked = false; m_peekedChar = 0; m_file = fopen( filename, "rt" );

if ( !m_file ) err = TextFile::ERROR_OPEN; }

~TextFileImpl() { if ( m_file ) { fclose( m_file ); m_file = 0; } }

bool eof() const { if ( err ) return true; return 0 != feof(m_file); }

bool peekChar( char* ch ) { if ( err ) return false;

if ( !m_peeked ) { int c = getc( m_file ); if ( EOF != c ) { m_peeked = true; m_peekedChar = (char)c; } else { if ( ferror(m_file) ) err = TextFile::ERROR_READ; } }

if ( m_peeked ) *ch = m_peekedChar; return m_peeked; }

bool readChar( char* ch ) { if ( err ) return false;

bool more = peekChar( ch ); m_peeked = false; if ( more && *ch == '\n' ) ++line; return more; }

bool skipWhitespace() { if ( err ) return false;

char ch; while ( peekChar(&ch) ) { if ( !isspace(ch) ) break; readChar( &ch ); } return !eof(); }

bool readString( char* buf, int size ) { if ( err ) return false;

skipWhitespace();

int count = 0; char ch; while ( peekChar(&ch) ) { if ( isspace(ch) ) break; if ( count+1 < size ) buf[count++] = ch; readChar( &ch ); } if ( size > 0 ) buf[count] = 0; return count > 0; }

void skipLine() { if ( err ) return;

char ch; while ( readChar(&ch) ) { if ( ch == '\n' ) break; } }

long readHex() { if ( err ) return 0;

skipWhitespace();

// hex must start with alphanumeric character char ch; if ( !peekChar(&ch) || !isalnum(ch) ) { err = TextFile::ERROR_PARSE; return 0; }

long x = 0; while ( peekChar(&ch) ) { switch ( ch ) { case '0': x <<= 4; x += 0; break; case '1': x <<= 4; x += 1; break; case '2': x <<= 4; x += 2; break; case '3': x <<= 4; x += 3; break; case '4': x <<= 4; x += 4; break; case '5': x <<= 4; x += 5; break; case '6': x <<= 4; x += 6; break; case '7': x <<= 4; x += 7; break; case '8': x <<= 4; x += 8; break; case '9': x <<= 4; x += 9; break; case 'a': case 'A': x <<= 4; x += 0xA; break; case 'b': case 'B': x <<= 4; x += 0xB; break; case 'c': case 'C': x <<= 4; x += 0xC; break; case 'd': case 'D': x <<= 4; x += 0xD; break; case 'e': case 'E': x <<= 4; x += 0xE; break; case 'f': case 'F': x <<= 4; x += 0xF; break; default: return x; } readChar( &ch ); } return x; }

private: bool m_peeked; char m_peekedChar; FILE* m_file;

TextFileImpl( const TextFileImpl& ); TextFileImpl& operator=( const TextFileImpl& ); };

//----------------------------------------------------------------------------- TextFile::TextFile( const char* filename ) { m_this = new TextFileImpl( filename ); }

TextFile::~TextFile() { delete m_this; }

bool TextFile::readString( char* buf, int size ) { return m_this->readString( buf, size ); }

void TextFile::skipLine() { m_this->skipLine(); }

long TextFile::readHex() { return m_this->readHex(); }

bool TextFile::skipWhitespace() { return m_this->skipWhitespace(); }

TextFile::ErrorType TextFile::error() const { return m_this->err; }

bool TextFile::readChar( char* ch ) { return m_this->readChar( ch ); }

bool TextFile::peekChar( char* ch ) { return m_this->peekChar( ch ); }

bool TextFile::eof() const { return m_this->eof(); }

int TextFile::line() const { return m_this->line; }

} // dev /* * Copyright (c) 2001 Jani Kajala * * Permission to use, copy, modify, distribute and sell this * software and its documentation for any purpose is hereby * granted without fee, provided that the above copyright notice * appear in all copies and that both that copyright notice and * this permission notice appear in supporting documentation. * Jani Kajala makes no representations about the suitability * of this software for any purpose. It is provided "as is" * without express or implied warranty. */

Currently browsing [stacktrace.zip] (38,843 bytes) - [internal/TextFile.h] - (2,316 bytes)

#ifndef _DEV_TEXTFILE_H
#define _DEV_TEXTFILE_H

namespace dev {

/** * ASCII-7 text file parser. Doesnt throw exceptions. */ class TextFile { public: /** Error code. */ enum ErrorType { /** No error. */ ERROR_NONE, /** File open failed. */ ERROR_OPEN, /** File reading failed. */ ERROR_READ, /** Syntax error. */ ERROR_PARSE };

/** Opens a file. */ explicit TextFile( const char* filename );

/// ~TextFile();

/** * Reads a single character. * @return true if read ok. */ bool readChar( char* ch );

/** * Peeks a single character. * @return true if peek ok. */ bool peekChar( char* ch );

/** * Reads whitespace delimited string. * If the string doesnt fit to the buffer then * the rest of the string is skipped. Buffer * is always 0-terminated. * @param buf [out] Pointer to string buffer. * @param size String buffer size. Must be larger than 0. * @return false if end-of-file reached before any characters was read. */ bool readString( char* buf, int size );

/** Skips the rest of the line. */ void skipLine();

/** Reads hex integer. Skips preceding whitespace. */ long readHex();

/** * Skips whitespace characters. * @return false if end-of-file reached. */ bool skipWhitespace();

/** Returns true if end-of-file have been reached. */ bool eof() const;

/** Returns error code or 0 (ERROR_NONE) if no error. */ ErrorType error() const;

/** Returns line number of last successful read character. */ int line() const;

private: class TextFileImpl; TextFileImpl* m_this;

TextFile( const TextFile& ); TextFile& operator=( const TextFile& ); };

} // dev

#endif // _DEV_TEXTFILE_H /* * Copyright (c) 2001 Jani Kajala * * Permission to use, copy, modify, distribute and sell this * software and its documentation for any purpose is hereby * granted without fee, provided that the above copyright notice * appear in all copies and that both that copyright notice and * this permission notice appear in supporting documentation. * Jani Kajala makes no representations about the suitability * of this software for any purpose. It is provided "as is" * without express or implied warranty. */

Currently browsing [stacktrace.zip] (38,843 bytes) - [test/main.cpp] - (937 bytes)

#include "../printStackTrace.h"
#include <stdio.h>

//----------------------------------------------------------------------------- #define testAssert( EXPR ) if (EXPR) {} else {testAssertFailed(__FILE__,__LINE__,#EXPR);}

//----------------------------------------------------------------------------- void testAssertFailed( const char* fname, int line, const char* expr ) { char buf[1000]; printStackTrace( buf, sizeof(buf) );

printf( "Test assertion: %s(%i)\n", fname, line ); printf( "Expression: %s\n", expr ); printf( "Stack trace:\n" ); puts( buf ); }

//----------------------------------------------------------------------------- void testfunc3( int x ) { testAssert( x == 3 ); }

void testfunc2( int arg1 ) { testfunc3( arg1 ); }

void testfunc1( int arg1 ) { testfunc2( arg1 ); }

int main() { testfunc1( 4 ); puts( "Press enter to exit" ); getchar(); return 0; }

Currently browsing [stacktrace.zip] (38,843 bytes) - [printStackTrace.cpp] - (1,835 bytes)

#include "printStackTrace.h"
#include "StackTrace.h"
#include "MapFile.h"
#include <stdio.h>
#include <string.h>

//----------------------------------------------------------------------------- using namespace dev;

//----------------------------------------------------------------------------- /** * Prints stack trace to user defined buffer. * Always terminates the buffer with 0. */ void printStackTrace( char* buffer, int bufferSize ) { // find out map file name char modname[500]; MapFile::getModuleMapFilename( modname, sizeof(modname) );

// parse map file char buf[600]; MapFile map( modname ); switch ( map.error() ) { case MapFile::ERROR_OPEN: sprintf( buf, "Failed to open map file %s\n", modname ); break; case MapFile::ERROR_READ: sprintf( buf, "Error while reading map file %s(%i)\n", modname, map.line() ); break; case MapFile::ERROR_PARSE: sprintf( buf, "Parse error in map file %s(%i)\n", modname, map.line() ); break; default: break; }

// print stack trace to buffer if ( !map.error() ) { MapFile* maps[] = {&map}; StackTrace::printStackTrace( maps, 1, 1, 16, buf, sizeof(buf) ); }

// copy to user buffer if ( bufferSize > 0 ) { strncpy( buffer, buf, bufferSize ); buffer[bufferSize-1] = 0; } }

/* * Copyright (c) 2001 Jani Kajala * * Permission to use, copy, modify, distribute and sell this * software and its documentation for any purpose is hereby * granted without fee, provided that the above copyright notice * appear in all copies and that both that copyright notice and * this permission notice appear in supporting documentation. * Jani Kajala makes no representations about the suitability * of this software for any purpose. It is provided "as is" * without express or implied warranty. */

Currently browsing [stacktrace.zip] (38,843 bytes) - [printStackTrace.h] - (907 bytes)

#ifndef _PRINTSTACKTRACE_H
#define _PRINTSTACKTRACE_H

/** * Prints formatted call stack to the user defined buffer, * always terminating the buffer with 0. * Uses stack frame to find out the caller function address and * the map file to find out the function name. */ void printStackTrace( char* buffer, int bufferSize );

#endif // _PRINTSTACKTRACE_H /* * Copyright (c) 2001 Jani Kajala * * Permission to use, copy, modify, distribute and sell this * software and its documentation for any purpose is hereby * granted without fee, provided that the above copyright notice * appear in all copies and that both that copyright notice and * this permission notice appear in supporting documentation. * Jani Kajala makes no representations about the suitability * of this software for any purpose. It is provided "as is" * without express or implied warranty. */

The zip file viewer built into the Developer Toolbox made use of the zlib library, as well as the zlibdll source additions.

 

Copyright 1999-2008 (C) FLIPCODE.COM and/or the original content author(s). All rights reserved.
Please read our Terms, Conditions, and Privacy information.