This commit was manufactured by cvs2svn to create tag 'REL-0_10'.
This commit is contained in:
Marc Wäckerlin
50
configure.in
50
configure.in
@@ -1,50 +0,0 @@
|
|||||||
AC_INIT([mrw/mrw.hpp])
|
|
||||||
PACKAGENAME=mrw-c++
|
|
||||||
MAJOR=0
|
|
||||||
MINOR=01
|
|
||||||
SUPPORT=alfa
|
|
||||||
AM_INIT_AUTOMAKE(@PACKAGENAME@, @MAJOR@.@MINOR@)
|
|
||||||
|
|
||||||
# languages
|
|
||||||
AC_LANG(C++)
|
|
||||||
|
|
||||||
# programs
|
|
||||||
AC_PROG_CXX
|
|
||||||
AC_PROG_CPP
|
|
||||||
AC_PROG_INSTALL
|
|
||||||
AC_PROG_LN_S
|
|
||||||
AC_PROG_MAKE_SET
|
|
||||||
AC_PROG_LIBTOOL
|
|
||||||
AC_CHECK_PROG(have_doxygen, doxygen, yes, no)
|
|
||||||
AC_CHECK_PROG(have_dot, dot, yes, no)
|
|
||||||
|
|
||||||
# libraries
|
|
||||||
#AC_SEARCH_LIBS(demangle, iberty)
|
|
||||||
#AC_SEARCH_LIBS(, bfd)
|
|
||||||
|
|
||||||
# Arguments
|
|
||||||
AM_MAINTAINER_MODE
|
|
||||||
AC_ARG_ENABLE(dot,
|
|
||||||
[ --disable-dot disable dot graphic tools for documentation],
|
|
||||||
[have_dot="$enableval"])
|
|
||||||
test "$enableval" = "yes" && HAVE_DOT="YES" || HAVE_DOT="NO";
|
|
||||||
|
|
||||||
# export macros
|
|
||||||
AC_SUBST(HAVE_DOT)
|
|
||||||
AC_SUBST(MAJOR)
|
|
||||||
AC_SUBST(MINOR)
|
|
||||||
AC_SUBST(SUPPORT)
|
|
||||||
AC_SUBST(PACKAGENAME)
|
|
||||||
|
|
||||||
# create output
|
|
||||||
AC_CONFIG_FILES([makefile mrw/makefile mrw/doxyfile])
|
|
||||||
|
|
||||||
# infos and warnings
|
|
||||||
if test "$have_doxygen" = "no"; then
|
|
||||||
AC_MSG_WARN([Missing program doxygen!
|
|
||||||
- you cannot rebuild the documentation with make doc
|
|
||||||
- there are precompiled derieved files in the distribution]); fi
|
|
||||||
if test "$have_dot" = "no"; then
|
|
||||||
AC_MSG_WARN([Missing program dot!
|
|
||||||
- when you rebild documentation with make doc, there are no generated images
|
|
||||||
- there are precompiled derieved files in the distribution]); fi
|
|
||||||
@@ -1 +0,0 @@
|
|||||||
SUBDIRS = mrw
|
|
||||||
139
mrw/auto.hpp
139
mrw/auto.hpp
@@ -1,139 +0,0 @@
|
|||||||
#ifndef __MRW_AUTO_HPP__
|
|
||||||
#define __MRW_AUTO_HPP__
|
|
||||||
|
|
||||||
#include <sys/types.h> // size_t
|
|
||||||
#include <sys/mman.h> // PROT_READ, MAP_SHARED
|
|
||||||
#include <bfd.h> // bfd*
|
|
||||||
|
|
||||||
namespace mrw {
|
|
||||||
|
|
||||||
/** @defgroup AutoTools Classes for Automated Resource Handling
|
|
||||||
|
|
||||||
For pointers that have been allocated with @c new, you can use
|
|
||||||
std::auto_ptr to automatically free them when you leave the
|
|
||||||
context. Unfortunately there is no such thing for @c malloc
|
|
||||||
(except @c malloca that only works for a subset of problems: if
|
|
||||||
you and not a system call allocates memory), @c open and so on.
|
|
||||||
These classes can take over the resource ownership.
|
|
||||||
*/
|
|
||||||
//@{
|
|
||||||
|
|
||||||
/** @brief Automatically closes a file when destructed.
|
|
||||||
|
|
||||||
AutoFile works exactly like std::auto_ptr, but not for files
|
|
||||||
instead of pointers. Whenever the context of AutoFile is left,
|
|
||||||
the opened file is close. This way, resources are freed even in
|
|
||||||
case of exceptions.
|
|
||||||
*/
|
|
||||||
class AutoFile {
|
|
||||||
public:
|
|
||||||
/// @brief Construct from an opened file.
|
|
||||||
/// @note Don't close @c fd
|
|
||||||
explicit AutoFile(int fd = -1) throw(): _fd(fd) {}
|
|
||||||
/// @brief Takeover ownership from another AutoFile.
|
|
||||||
AutoFile(AutoFile& o) throw(): _fd(o.release()) {}
|
|
||||||
/// @brief Closes file if open.
|
|
||||||
~AutoFile() throw() {reset();}
|
|
||||||
/// @brief Assign new file descriptor.
|
|
||||||
/// The old file of @c this is closed if open.
|
|
||||||
AutoFile& operator=(int fd) throw() {return reset(fd);}
|
|
||||||
/// @brief Takeover ownership from another AutoFile.
|
|
||||||
/// The old file of @c this is closed if open.
|
|
||||||
AutoFile& operator=(AutoFile& other) throw() {
|
|
||||||
return reset(other.release());
|
|
||||||
}
|
|
||||||
/// @brief get the file descriptor @return file descriptor
|
|
||||||
operator const int() const throw() {
|
|
||||||
return _fd;
|
|
||||||
}
|
|
||||||
/// @brief Give away ownership of the file. @return old file descriptor
|
|
||||||
int release() throw() {
|
|
||||||
int ret(_fd); _fd=-1;
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
/// @brief assign a new file descriptor
|
|
||||||
/** The old file of @c this is closed if open. */
|
|
||||||
AutoFile& reset(int = -1) throw();
|
|
||||||
private:
|
|
||||||
int _fd; ///< the file descriptor
|
|
||||||
};
|
|
||||||
|
|
||||||
/** @brief Automatically call @c munmap for mmaped files on destruction.
|
|
||||||
|
|
||||||
It's the same as std::auto_ptr, but for @c mmap instead of @c
|
|
||||||
new. When the context of @c AutoMapper is left, @c munmap is
|
|
||||||
called.
|
|
||||||
*/
|
|
||||||
class AutoMapper {
|
|
||||||
public:
|
|
||||||
AutoMapper(void* cont = 0, size_t sz = 0) throw():
|
|
||||||
_cont(cont), _sz(sz) {}
|
|
||||||
AutoMapper(int, size_t=0, void* = 0,
|
|
||||||
int = PROT_READ, int = MAP_SHARED, off_t = 0) throw();
|
|
||||||
~AutoMapper() throw();
|
|
||||||
operator const void*() const throw() {return _cont;}
|
|
||||||
AutoMapper& set(void* cont, size_t sz) throw() {
|
|
||||||
_cont=cont; _sz=sz;
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
void* release() throw() {
|
|
||||||
void* ret(_cont); _cont=0; _sz=0;
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
const void* last() const throw() {
|
|
||||||
return _cont && _sz ? (void*)((size_t)_cont+_sz-1) : 0;
|
|
||||||
}
|
|
||||||
private:
|
|
||||||
void* _cont;
|
|
||||||
size_t _sz;
|
|
||||||
};
|
|
||||||
|
|
||||||
/** @brief Automatically call @c bfd_close for @c bfd*.
|
|
||||||
|
|
||||||
It acts like a @c std::auto_ptr, but for @c bfd*, that means it
|
|
||||||
calls @c bfd_close whenever the context is left.
|
|
||||||
*/
|
|
||||||
class AutoBfd {
|
|
||||||
public:
|
|
||||||
AutoBfd(bfd* p=0) throw(): _bfd(p) {}
|
|
||||||
~AutoBfd() throw() {if (_bfd) bfd_close(_bfd);}
|
|
||||||
AutoBfd& operator=(bfd* p) throw() {
|
|
||||||
release(); _bfd=p; return *this;
|
|
||||||
}
|
|
||||||
AutoBfd& operator=(AutoBfd& o) throw() {
|
|
||||||
release(); _bfd=o.release(); return *this;
|
|
||||||
}
|
|
||||||
operator bfd*() throw() {return _bfd;}
|
|
||||||
bfd* operator->() throw() {return _bfd;}
|
|
||||||
bfd* release() throw() {bfd* res(_bfd); _bfd = 0; return res;}
|
|
||||||
private:
|
|
||||||
bfd* _bfd;
|
|
||||||
};
|
|
||||||
|
|
||||||
/** @brief Automatically calls @c free for @c malloc allocated memory.
|
|
||||||
|
|
||||||
It works like a @c std::auto_ptr, but for memory that was
|
|
||||||
allocated with @c malloc, not @c new. Memory is freed, whenever
|
|
||||||
the context od @c AutoFree is left.
|
|
||||||
*/
|
|
||||||
template <class T> class AutoFree {
|
|
||||||
public:
|
|
||||||
AutoFree(T* p=0) throw(): _p(p) {}
|
|
||||||
AutoFree(AutoFree& o) throw(): _p(o.release()) {}
|
|
||||||
~AutoFree() throw() {if (_p) free(_p);}
|
|
||||||
AutoFree& operator=(T* p) throw() {
|
|
||||||
release(); _p=p; return *this;
|
|
||||||
}
|
|
||||||
AutoFree& operator=(AutoFree& o) throw() {
|
|
||||||
release(); _p=o.release(); return *this;
|
|
||||||
}
|
|
||||||
operator T*() {return _p;}
|
|
||||||
operator T**() {return &_p;}
|
|
||||||
operator bool() {return _p;}
|
|
||||||
T* release() throw() {T* r(_p); _p=0; return r;}
|
|
||||||
private:
|
|
||||||
T* _p;
|
|
||||||
};
|
|
||||||
//@}
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
@@ -1,46 +0,0 @@
|
|||||||
#include <mrw/auto.hpp>
|
|
||||||
#include <cppunit/TestFixture.h>
|
|
||||||
#include <cppunit/ui/text/TestRunner.h>
|
|
||||||
#include <cppunit/extensions/HelperMacros.h>
|
|
||||||
#include <cppunit/extensions/TestFactoryRegistry.h>
|
|
||||||
#include <fcntl.h> // open
|
|
||||||
|
|
||||||
class AutoTest: public CppUnit::TestFixture {
|
|
||||||
public:
|
|
||||||
void AutoFile() {
|
|
||||||
char c(0);
|
|
||||||
int i(-1);
|
|
||||||
{
|
|
||||||
mrw::AutoFile a;
|
|
||||||
CPPUNIT_ASSERT(a==-1); // init as -1
|
|
||||||
i = a = open("test.dat", O_RDONLY);
|
|
||||||
CPPUNIT_ASSERT(i==a && a>0); // file is now open
|
|
||||||
mrw::AutoFile b(a);
|
|
||||||
CPPUNIT_ASSERT(a==-1 && i==b); // b has taken ownership
|
|
||||||
CPPUNIT_ASSERT(read(b, &c, 1)==1 && c=='H'); // file is good
|
|
||||||
mrw::AutoFile c(i);
|
|
||||||
CPPUNIT_ASSERT(i==b && b==c); // ooops, two owner!
|
|
||||||
c.release();
|
|
||||||
CPPUNIT_ASSERT(i==b && c==-1); // it's ok now
|
|
||||||
b = open("test.dat", O_RDONLY);
|
|
||||||
//close(i);
|
|
||||||
CPPUNIT_ASSERT(read(i, &c, 1)==-1); // old file is closed
|
|
||||||
i = b.reset();
|
|
||||||
CPPUNIT_ASSERT(read(i, &c, 1)==-1); // new file is closed
|
|
||||||
i = a = open("test.dat", O_RDONLY);
|
|
||||||
}
|
|
||||||
CPPUNIT_ASSERT(read(i, &c, 1)==-1); // file is closed now
|
|
||||||
}
|
|
||||||
CPPUNIT_TEST_SUITE(AutoTest);
|
|
||||||
CPPUNIT_TEST(AutoFile);
|
|
||||||
CPPUNIT_TEST_SUITE_END();
|
|
||||||
};
|
|
||||||
CPPUNIT_TEST_SUITE_REGISTRATION(AutoTest);
|
|
||||||
|
|
||||||
int main() {
|
|
||||||
CppUnit::TextUi::TestRunner runner;
|
|
||||||
runner.addTest(CppUnit::TestFactoryRegistry::getRegistry().makeTest());
|
|
||||||
return runner.run() ? 0 : 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
static char* c = new char[100];
|
|
||||||
@@ -1,41 +0,0 @@
|
|||||||
#include <mrw/stacktrace.hpp>
|
|
||||||
#include <mrw/exception.hpp>
|
|
||||||
#include <exception>
|
|
||||||
#include <iostream>
|
|
||||||
|
|
||||||
namespace mrw {
|
|
||||||
|
|
||||||
/// @todo integrate it into the distribution and document it
|
|
||||||
void unexpected() {
|
|
||||||
std::cerr<<"UNEXPECTED EXCEPTION: ----------------------------"<<std::endl;
|
|
||||||
try {
|
|
||||||
throw;
|
|
||||||
} catch (const mrw::exception& x) {
|
|
||||||
StackTrace::createSymtable();
|
|
||||||
std::cerr<<"---------- Reason:"<<std::endl
|
|
||||||
<<x.what()<<std::endl
|
|
||||||
<<"---------- Stack:"<<std::endl
|
|
||||||
<<x.stacktrace()<<std::endl;
|
|
||||||
} catch (const std::exception& x) {
|
|
||||||
std::cerr<<"---------- Reason:"<<std::endl
|
|
||||||
<<x.what()<<std::endl
|
|
||||||
<<"---------- Stack: **** not available ****"<<std::endl;
|
|
||||||
} catch (...) {
|
|
||||||
std::cerr<<"---------- Reason: **** not available ****"<<std::endl
|
|
||||||
<<"---------- Stack: **** not available ****"<<std::endl;
|
|
||||||
}
|
|
||||||
std::cerr<<"-------------------------------------------------"<<std::endl;
|
|
||||||
throw std::bad_exception();
|
|
||||||
}
|
|
||||||
|
|
||||||
class AutoStackTrace {
|
|
||||||
public:
|
|
||||||
AutoStackTrace() {
|
|
||||||
std::set_unexpected(&mrw::unexpected);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
// initialize stack traces (load symbols)
|
|
||||||
static AutoStackTrace _autoStackTrace;
|
|
||||||
|
|
||||||
}
|
|
||||||
1101
mrw/doxyfile.in
1101
mrw/doxyfile.in
@@ -1,1101 +0,0 @@
|
|||||||
# Doxyfile 1.3.2
|
|
||||||
|
|
||||||
# This file describes the settings to be used by the documentation system
|
|
||||||
# doxygen (www.doxygen.org) for a project
|
|
||||||
#
|
|
||||||
# All text after a hash (#) is considered a comment and will be ignored
|
|
||||||
# The format is:
|
|
||||||
# TAG = value [value, ...]
|
|
||||||
# For lists items can also be appended using:
|
|
||||||
# TAG += value [value, ...]
|
|
||||||
# Values that contain spaces should be placed between quotes (" ")
|
|
||||||
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
# General configuration options
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
|
|
||||||
# The PROJECT_NAME tag is a single word (or a sequence of words surrounded
|
|
||||||
# by quotes) that should identify the project.
|
|
||||||
|
|
||||||
PROJECT_NAME = "MRW C++ Library"
|
|
||||||
|
|
||||||
# The PROJECT_NUMBER tag can be used to enter a project or revision number.
|
|
||||||
# This could be handy for archiving the generated documentation or
|
|
||||||
# if some version control system is used.
|
|
||||||
|
|
||||||
PROJECT_NUMBER = experimental
|
|
||||||
|
|
||||||
# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
|
|
||||||
# base path where the generated documentation will be put.
|
|
||||||
# If a relative path is entered, it will be relative to the location
|
|
||||||
# where doxygen was started. If left blank the current directory will be used.
|
|
||||||
|
|
||||||
OUTPUT_DIRECTORY = doc
|
|
||||||
|
|
||||||
# The OUTPUT_LANGUAGE tag is used to specify the language in which all
|
|
||||||
# documentation generated by doxygen is written. Doxygen will use this
|
|
||||||
# information to generate all constant output in the proper language.
|
|
||||||
# The default language is English, other supported languages are:
|
|
||||||
# Brazilian, Catalan, Chinese, Chinese-Traditional, Croatian, Czech, Danish, Dutch,
|
|
||||||
# Finnish, French, German, Greek, Hungarian, Italian, Japanese, Japanese-en
|
|
||||||
# (Japanese with English messages), Korean, Norwegian, Polish, Portuguese,
|
|
||||||
# Romanian, Russian, Serbian, Slovak, Slovene, Spanish, Swedish, and Ukrainian.
|
|
||||||
|
|
||||||
OUTPUT_LANGUAGE = English
|
|
||||||
|
|
||||||
# This tag can be used to specify the encoding used in the generated output.
|
|
||||||
# The encoding is not always determined by the language that is chosen,
|
|
||||||
# but also whether or not the output is meant for Windows or non-Windows users.
|
|
||||||
# In case there is a difference, setting the USE_WINDOWS_ENCODING tag to YES
|
|
||||||
# forces the Windows encoding (this is the default for the Windows binary),
|
|
||||||
# whereas setting the tag to NO uses a Unix-style encoding (the default for
|
|
||||||
# all platforms other than Windows).
|
|
||||||
|
|
||||||
USE_WINDOWS_ENCODING = NO
|
|
||||||
|
|
||||||
# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
|
|
||||||
# documentation are documented, even if no documentation was available.
|
|
||||||
# Private class members and static file members will be hidden unless
|
|
||||||
# the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
|
|
||||||
|
|
||||||
EXTRACT_ALL = NO
|
|
||||||
|
|
||||||
# If the EXTRACT_PRIVATE tag is set to YES all private members of a class
|
|
||||||
# will be included in the documentation.
|
|
||||||
|
|
||||||
EXTRACT_PRIVATE = NO
|
|
||||||
|
|
||||||
# If the EXTRACT_STATIC tag is set to YES all static members of a file
|
|
||||||
# will be included in the documentation.
|
|
||||||
|
|
||||||
EXTRACT_STATIC = NO
|
|
||||||
|
|
||||||
# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
|
|
||||||
# defined locally in source files will be included in the documentation.
|
|
||||||
# If set to NO only classes defined in header files are included.
|
|
||||||
|
|
||||||
EXTRACT_LOCAL_CLASSES = NO
|
|
||||||
|
|
||||||
# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
|
|
||||||
# undocumented members of documented classes, files or namespaces.
|
|
||||||
# If set to NO (the default) these members will be included in the
|
|
||||||
# various overviews, but no documentation section is generated.
|
|
||||||
# This option has no effect if EXTRACT_ALL is enabled.
|
|
||||||
|
|
||||||
HIDE_UNDOC_MEMBERS = NO
|
|
||||||
|
|
||||||
# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
|
|
||||||
# undocumented classes that are normally visible in the class hierarchy.
|
|
||||||
# If set to NO (the default) these classes will be included in the various
|
|
||||||
# overviews. This option has no effect if EXTRACT_ALL is enabled.
|
|
||||||
|
|
||||||
HIDE_UNDOC_CLASSES = NO
|
|
||||||
|
|
||||||
# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
|
|
||||||
# friend (class|struct|union) declarations.
|
|
||||||
# If set to NO (the default) these declarations will be included in the
|
|
||||||
# documentation.
|
|
||||||
|
|
||||||
HIDE_FRIEND_COMPOUNDS = NO
|
|
||||||
|
|
||||||
# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
|
|
||||||
# documentation blocks found inside the body of a function.
|
|
||||||
# If set to NO (the default) these blocks will be appended to the
|
|
||||||
# function's detailed documentation block.
|
|
||||||
|
|
||||||
HIDE_IN_BODY_DOCS = NO
|
|
||||||
|
|
||||||
# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
|
|
||||||
# include brief member descriptions after the members that are listed in
|
|
||||||
# the file and class documentation (similar to JavaDoc).
|
|
||||||
# Set to NO to disable this.
|
|
||||||
|
|
||||||
BRIEF_MEMBER_DESC = YES
|
|
||||||
|
|
||||||
# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
|
|
||||||
# the brief description of a member or function before the detailed description.
|
|
||||||
# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
|
|
||||||
# brief descriptions will be completely suppressed.
|
|
||||||
|
|
||||||
REPEAT_BRIEF = YES
|
|
||||||
|
|
||||||
# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
|
|
||||||
# Doxygen will generate a detailed section even if there is only a brief
|
|
||||||
# description.
|
|
||||||
|
|
||||||
ALWAYS_DETAILED_SEC = NO
|
|
||||||
|
|
||||||
# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all inherited
|
|
||||||
# members of a class in the documentation of that class as if those members were
|
|
||||||
# ordinary class members. Constructors, destructors and assignment operators of
|
|
||||||
# the base classes will not be shown.
|
|
||||||
|
|
||||||
INLINE_INHERITED_MEMB = NO
|
|
||||||
|
|
||||||
# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
|
|
||||||
# path before files name in the file list and in the header files. If set
|
|
||||||
# to NO the shortest path that makes the file name unique will be used.
|
|
||||||
|
|
||||||
FULL_PATH_NAMES = YES
|
|
||||||
|
|
||||||
# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
|
|
||||||
# can be used to strip a user-defined part of the path. Stripping is
|
|
||||||
# only done if one of the specified strings matches the left-hand part of
|
|
||||||
# the path. It is allowed to use relative paths in the argument list.
|
|
||||||
|
|
||||||
STRIP_FROM_PATH = ../
|
|
||||||
|
|
||||||
# The INTERNAL_DOCS tag determines if documentation
|
|
||||||
# that is typed after a \internal command is included. If the tag is set
|
|
||||||
# to NO (the default) then the documentation will be excluded.
|
|
||||||
# Set it to YES to include the internal documentation.
|
|
||||||
|
|
||||||
INTERNAL_DOCS = NO
|
|
||||||
|
|
||||||
# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
|
|
||||||
# file names in lower-case letters. If set to YES upper-case letters are also
|
|
||||||
# allowed. This is useful if you have classes or files whose names only differ
|
|
||||||
# in case and if your file system supports case sensitive file names. Windows
|
|
||||||
# users are advised to set this option to NO.
|
|
||||||
|
|
||||||
CASE_SENSE_NAMES = YES
|
|
||||||
|
|
||||||
# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
|
|
||||||
# (but less readable) file names. This can be useful is your file systems
|
|
||||||
# doesn't support long names like on DOS, Mac, or CD-ROM.
|
|
||||||
|
|
||||||
SHORT_NAMES = NO
|
|
||||||
|
|
||||||
# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
|
|
||||||
# will show members with their full class and namespace scopes in the
|
|
||||||
# documentation. If set to YES the scope will be hidden.
|
|
||||||
|
|
||||||
HIDE_SCOPE_NAMES = NO
|
|
||||||
|
|
||||||
# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
|
|
||||||
# will put a list of the files that are included by a file in the documentation
|
|
||||||
# of that file.
|
|
||||||
|
|
||||||
SHOW_INCLUDE_FILES = YES
|
|
||||||
|
|
||||||
# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
|
|
||||||
# will interpret the first line (until the first dot) of a JavaDoc-style
|
|
||||||
# comment as the brief description. If set to NO, the JavaDoc
|
|
||||||
# comments will behave just like the Qt-style comments (thus requiring an
|
|
||||||
# explict @brief command for a brief description.
|
|
||||||
|
|
||||||
JAVADOC_AUTOBRIEF = NO
|
|
||||||
|
|
||||||
# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
|
|
||||||
# treat a multi-line C++ special comment block (i.e. a block of //! or ///
|
|
||||||
# comments) as a brief description. This used to be the default behaviour.
|
|
||||||
# The new default is to treat a multi-line C++ comment block as a detailed
|
|
||||||
# description. Set this tag to YES if you prefer the old behaviour instead.
|
|
||||||
|
|
||||||
MULTILINE_CPP_IS_BRIEF = NO
|
|
||||||
|
|
||||||
# If the DETAILS_AT_TOP tag is set to YES then Doxygen
|
|
||||||
# will output the detailed description near the top, like JavaDoc.
|
|
||||||
# If set to NO, the detailed description appears after the member
|
|
||||||
# documentation.
|
|
||||||
|
|
||||||
DETAILS_AT_TOP = YES
|
|
||||||
|
|
||||||
# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
|
|
||||||
# member inherits the documentation from any documented member that it
|
|
||||||
# reimplements.
|
|
||||||
|
|
||||||
INHERIT_DOCS = YES
|
|
||||||
|
|
||||||
# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
|
|
||||||
# is inserted in the documentation for inline members.
|
|
||||||
|
|
||||||
INLINE_INFO = YES
|
|
||||||
|
|
||||||
# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
|
|
||||||
# will sort the (detailed) documentation of file and class members
|
|
||||||
# alphabetically by member name. If set to NO the members will appear in
|
|
||||||
# declaration order.
|
|
||||||
|
|
||||||
SORT_MEMBER_DOCS = YES
|
|
||||||
|
|
||||||
# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
|
|
||||||
# tag is set to YES, then doxygen will reuse the documentation of the first
|
|
||||||
# member in the group (if any) for the other members of the group. By default
|
|
||||||
# all members of a group must be documented explicitly.
|
|
||||||
|
|
||||||
DISTRIBUTE_GROUP_DOC = NO
|
|
||||||
|
|
||||||
# The TAB_SIZE tag can be used to set the number of spaces in a tab.
|
|
||||||
# Doxygen uses this value to replace tabs by spaces in code fragments.
|
|
||||||
|
|
||||||
TAB_SIZE = 8
|
|
||||||
|
|
||||||
# The GENERATE_TODOLIST tag can be used to enable (YES) or
|
|
||||||
# disable (NO) the todo list. This list is created by putting \todo
|
|
||||||
# commands in the documentation.
|
|
||||||
|
|
||||||
GENERATE_TODOLIST = YES
|
|
||||||
|
|
||||||
# The GENERATE_TESTLIST tag can be used to enable (YES) or
|
|
||||||
# disable (NO) the test list. This list is created by putting \test
|
|
||||||
# commands in the documentation.
|
|
||||||
|
|
||||||
GENERATE_TESTLIST = YES
|
|
||||||
|
|
||||||
# The GENERATE_BUGLIST tag can be used to enable (YES) or
|
|
||||||
# disable (NO) the bug list. This list is created by putting \bug
|
|
||||||
# commands in the documentation.
|
|
||||||
|
|
||||||
GENERATE_BUGLIST = YES
|
|
||||||
|
|
||||||
# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
|
|
||||||
# disable (NO) the deprecated list. This list is created by putting
|
|
||||||
# \deprecated commands in the documentation.
|
|
||||||
|
|
||||||
GENERATE_DEPRECATEDLIST= YES
|
|
||||||
|
|
||||||
# This tag can be used to specify a number of aliases that acts
|
|
||||||
# as commands in the documentation. An alias has the form "name=value".
|
|
||||||
# For example adding "sideeffect=\par Side Effects:\n" will allow you to
|
|
||||||
# put the command \sideeffect (or @sideeffect) in the documentation, which
|
|
||||||
# will result in a user-defined paragraph with heading "Side Effects:".
|
|
||||||
# You can put \n's in the value part of an alias to insert newlines.
|
|
||||||
|
|
||||||
ALIASES =
|
|
||||||
|
|
||||||
# The ENABLED_SECTIONS tag can be used to enable conditional
|
|
||||||
# documentation sections, marked by \if sectionname ... \endif.
|
|
||||||
|
|
||||||
ENABLED_SECTIONS =
|
|
||||||
|
|
||||||
# The MAX_INITIALIZER_LINES tag determines the maximum number of lines
|
|
||||||
# the initial value of a variable or define consists of for it to appear in
|
|
||||||
# the documentation. If the initializer consists of more lines than specified
|
|
||||||
# here it will be hidden. Use a value of 0 to hide initializers completely.
|
|
||||||
# The appearance of the initializer of individual variables and defines in the
|
|
||||||
# documentation can be controlled using \showinitializer or \hideinitializer
|
|
||||||
# command in the documentation regardless of this setting.
|
|
||||||
|
|
||||||
MAX_INITIALIZER_LINES = 30
|
|
||||||
|
|
||||||
# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
|
|
||||||
# only. Doxygen will then generate output that is more tailored for C.
|
|
||||||
# For instance, some of the names that are used will be different. The list
|
|
||||||
# of all members will be omitted, etc.
|
|
||||||
|
|
||||||
OPTIMIZE_OUTPUT_FOR_C = NO
|
|
||||||
|
|
||||||
# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java sources
|
|
||||||
# only. Doxygen will then generate output that is more tailored for Java.
|
|
||||||
# For instance, namespaces will be presented as packages, qualified scopes
|
|
||||||
# will look different, etc.
|
|
||||||
|
|
||||||
OPTIMIZE_OUTPUT_JAVA = NO
|
|
||||||
|
|
||||||
# Set the SHOW_USED_FILES tag to NO to disable the list of files generated
|
|
||||||
# at the bottom of the documentation of classes and structs. If set to YES the
|
|
||||||
# list will mention the files that were used to generate the documentation.
|
|
||||||
|
|
||||||
SHOW_USED_FILES = YES
|
|
||||||
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
# configuration options related to warning and progress messages
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
|
|
||||||
# The QUIET tag can be used to turn on/off the messages that are generated
|
|
||||||
# by doxygen. Possible values are YES and NO. If left blank NO is used.
|
|
||||||
|
|
||||||
QUIET = NO
|
|
||||||
|
|
||||||
# The WARNINGS tag can be used to turn on/off the warning messages that are
|
|
||||||
# generated by doxygen. Possible values are YES and NO. If left blank
|
|
||||||
# NO is used.
|
|
||||||
|
|
||||||
WARNINGS = YES
|
|
||||||
|
|
||||||
# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
|
|
||||||
# for undocumented members. If EXTRACT_ALL is set to YES then this flag will
|
|
||||||
# automatically be disabled.
|
|
||||||
|
|
||||||
WARN_IF_UNDOCUMENTED = NO
|
|
||||||
|
|
||||||
# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
|
|
||||||
# potential errors in the documentation, such as not documenting some
|
|
||||||
# parameters in a documented function, or documenting parameters that
|
|
||||||
# don't exist or using markup commands wrongly.
|
|
||||||
|
|
||||||
WARN_IF_DOC_ERROR = YES
|
|
||||||
|
|
||||||
# The WARN_FORMAT tag determines the format of the warning messages that
|
|
||||||
# doxygen can produce. The string should contain the $file, $line, and $text
|
|
||||||
# tags, which will be replaced by the file and line number from which the
|
|
||||||
# warning originated and the warning text.
|
|
||||||
|
|
||||||
WARN_FORMAT = "$file:$line: $text"
|
|
||||||
|
|
||||||
# The WARN_LOGFILE tag can be used to specify a file to which warning
|
|
||||||
# and error messages should be written. If left blank the output is written
|
|
||||||
# to stderr.
|
|
||||||
|
|
||||||
WARN_LOGFILE = doxygen.errors
|
|
||||||
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
# configuration options related to the input files
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
|
|
||||||
# The INPUT tag can be used to specify the files and/or directories that contain
|
|
||||||
# documented source files. You may enter file names like "myfile.cpp" or
|
|
||||||
# directories like "/usr/src/myproject". Separate the files or directories
|
|
||||||
# with spaces.
|
|
||||||
|
|
||||||
INPUT = ../mrw
|
|
||||||
|
|
||||||
# If the value of the INPUT tag contains directories, you can use the
|
|
||||||
# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
|
|
||||||
# and *.h) to filter out the source-files in the directories. If left
|
|
||||||
# blank the following patterns are tested:
|
|
||||||
# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx *.hpp
|
|
||||||
# *.h++ *.idl *.odl *.cs
|
|
||||||
|
|
||||||
FILE_PATTERNS =
|
|
||||||
|
|
||||||
# The RECURSIVE tag can be used to turn specify whether or not subdirectories
|
|
||||||
# should be searched for input files as well. Possible values are YES and NO.
|
|
||||||
# If left blank NO is used.
|
|
||||||
|
|
||||||
RECURSIVE = NO
|
|
||||||
|
|
||||||
# The EXCLUDE tag can be used to specify files and/or directories that should
|
|
||||||
# excluded from the INPUT source files. This way you can easily exclude a
|
|
||||||
# subdirectory from a directory tree whose root is specified with the INPUT tag.
|
|
||||||
|
|
||||||
EXCLUDE =
|
|
||||||
|
|
||||||
# The EXCLUDE_SYMLINKS tag can be used select whether or not files or directories
|
|
||||||
# that are symbolic links (a Unix filesystem feature) are excluded from the input.
|
|
||||||
|
|
||||||
EXCLUDE_SYMLINKS = NO
|
|
||||||
|
|
||||||
# If the value of the INPUT tag contains directories, you can use the
|
|
||||||
# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
|
|
||||||
# certain files from those directories.
|
|
||||||
|
|
||||||
EXCLUDE_PATTERNS =
|
|
||||||
|
|
||||||
# The EXAMPLE_PATH tag can be used to specify one or more files or
|
|
||||||
# directories that contain example code fragments that are included (see
|
|
||||||
# the \include command).
|
|
||||||
|
|
||||||
EXAMPLE_PATH = examples
|
|
||||||
|
|
||||||
# If the value of the EXAMPLE_PATH tag contains directories, you can use the
|
|
||||||
# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
|
|
||||||
# and *.h) to filter out the source-files in the directories. If left
|
|
||||||
# blank all files are included.
|
|
||||||
|
|
||||||
EXAMPLE_PATTERNS =
|
|
||||||
|
|
||||||
# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
|
|
||||||
# searched for input files to be used with the \include or \dontinclude
|
|
||||||
# commands irrespective of the value of the RECURSIVE tag.
|
|
||||||
# Possible values are YES and NO. If left blank NO is used.
|
|
||||||
|
|
||||||
EXAMPLE_RECURSIVE = NO
|
|
||||||
|
|
||||||
# The IMAGE_PATH tag can be used to specify one or more files or
|
|
||||||
# directories that contain image that are included in the documentation (see
|
|
||||||
# the \image command).
|
|
||||||
|
|
||||||
IMAGE_PATH =
|
|
||||||
|
|
||||||
# The INPUT_FILTER tag can be used to specify a program that doxygen should
|
|
||||||
# invoke to filter for each input file. Doxygen will invoke the filter program
|
|
||||||
# by executing (via popen()) the command <filter> <input-file>, where <filter>
|
|
||||||
# is the value of the INPUT_FILTER tag, and <input-file> is the name of an
|
|
||||||
# input file. Doxygen will then use the output that the filter program writes
|
|
||||||
# to standard output.
|
|
||||||
|
|
||||||
INPUT_FILTER =
|
|
||||||
|
|
||||||
# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
|
|
||||||
# INPUT_FILTER) will be used to filter the input files when producing source
|
|
||||||
# files to browse (i.e. when SOURCE_BROWSER is set to YES).
|
|
||||||
|
|
||||||
FILTER_SOURCE_FILES = NO
|
|
||||||
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
# configuration options related to source browsing
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
|
|
||||||
# If the SOURCE_BROWSER tag is set to YES then a list of source files will
|
|
||||||
# be generated. Documented entities will be cross-referenced with these sources.
|
|
||||||
|
|
||||||
SOURCE_BROWSER = NO
|
|
||||||
|
|
||||||
# Setting the INLINE_SOURCES tag to YES will include the body
|
|
||||||
# of functions and classes directly in the documentation.
|
|
||||||
|
|
||||||
INLINE_SOURCES = NO
|
|
||||||
|
|
||||||
# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
|
|
||||||
# doxygen to hide any special comment blocks from generated source code
|
|
||||||
# fragments. Normal C and C++ comments will always remain visible.
|
|
||||||
|
|
||||||
STRIP_CODE_COMMENTS = YES
|
|
||||||
|
|
||||||
# If the REFERENCED_BY_RELATION tag is set to YES (the default)
|
|
||||||
# then for each documented function all documented
|
|
||||||
# functions referencing it will be listed.
|
|
||||||
|
|
||||||
REFERENCED_BY_RELATION = YES
|
|
||||||
|
|
||||||
# If the REFERENCES_RELATION tag is set to YES (the default)
|
|
||||||
# then for each documented function all documented entities
|
|
||||||
# called/used by that function will be listed.
|
|
||||||
|
|
||||||
REFERENCES_RELATION = YES
|
|
||||||
|
|
||||||
# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
|
|
||||||
# will generate a verbatim copy of the header file for each class for
|
|
||||||
# which an include is specified. Set to NO to disable this.
|
|
||||||
|
|
||||||
VERBATIM_HEADERS = YES
|
|
||||||
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
# configuration options related to the alphabetical class index
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
|
|
||||||
# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
|
|
||||||
# of all compounds will be generated. Enable this if the project
|
|
||||||
# contains a lot of classes, structs, unions or interfaces.
|
|
||||||
|
|
||||||
ALPHABETICAL_INDEX = YES
|
|
||||||
|
|
||||||
# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
|
|
||||||
# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
|
|
||||||
# in which this list will be split (can be a number in the range [1..20])
|
|
||||||
|
|
||||||
COLS_IN_ALPHA_INDEX = 5
|
|
||||||
|
|
||||||
# In case all classes in a project start with a common prefix, all
|
|
||||||
# classes will be put under the same header in the alphabetical index.
|
|
||||||
# The IGNORE_PREFIX tag can be used to specify one or more prefixes that
|
|
||||||
# should be ignored while generating the index headers.
|
|
||||||
|
|
||||||
IGNORE_PREFIX =
|
|
||||||
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
# configuration options related to the HTML output
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
|
|
||||||
# If the GENERATE_HTML tag is set to YES (the default) Doxygen will
|
|
||||||
# generate HTML output.
|
|
||||||
|
|
||||||
GENERATE_HTML = YES
|
|
||||||
|
|
||||||
# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
|
|
||||||
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
|
|
||||||
# put in front of it. If left blank `html' will be used as the default path.
|
|
||||||
|
|
||||||
HTML_OUTPUT = html
|
|
||||||
|
|
||||||
# The HTML_FILE_EXTENSION tag can be used to specify the file extension for
|
|
||||||
# each generated HTML page (for example: .htm,.php,.asp). If it is left blank
|
|
||||||
# doxygen will generate files with .html extension.
|
|
||||||
|
|
||||||
HTML_FILE_EXTENSION = .html
|
|
||||||
|
|
||||||
# The HTML_HEADER tag can be used to specify a personal HTML header for
|
|
||||||
# each generated HTML page. If it is left blank doxygen will generate a
|
|
||||||
# standard header.
|
|
||||||
|
|
||||||
HTML_HEADER =
|
|
||||||
|
|
||||||
# The HTML_FOOTER tag can be used to specify a personal HTML footer for
|
|
||||||
# each generated HTML page. If it is left blank doxygen will generate a
|
|
||||||
# standard footer.
|
|
||||||
|
|
||||||
HTML_FOOTER =
|
|
||||||
|
|
||||||
# The HTML_STYLESHEET tag can be used to specify a user-defined cascading
|
|
||||||
# style sheet that is used by each HTML page. It can be used to
|
|
||||||
# fine-tune the look of the HTML output. If the tag is left blank doxygen
|
|
||||||
# will generate a default style sheet
|
|
||||||
|
|
||||||
HTML_STYLESHEET =
|
|
||||||
|
|
||||||
# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes,
|
|
||||||
# files or namespaces will be aligned in HTML using tables. If set to
|
|
||||||
# NO a bullet list will be used.
|
|
||||||
|
|
||||||
HTML_ALIGN_MEMBERS = YES
|
|
||||||
|
|
||||||
# If the GENERATE_HTMLHELP tag is set to YES, additional index files
|
|
||||||
# will be generated that can be used as input for tools like the
|
|
||||||
# Microsoft HTML help workshop to generate a compressed HTML help file (.chm)
|
|
||||||
# of the generated HTML documentation.
|
|
||||||
|
|
||||||
GENERATE_HTMLHELP = NO
|
|
||||||
|
|
||||||
# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
|
|
||||||
# be used to specify the file name of the resulting .chm file. You
|
|
||||||
# can add a path in front of the file if the result should not be
|
|
||||||
# written to the html output dir.
|
|
||||||
|
|
||||||
CHM_FILE =
|
|
||||||
|
|
||||||
# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
|
|
||||||
# be used to specify the location (absolute path including file name) of
|
|
||||||
# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
|
|
||||||
# the HTML help compiler on the generated index.hhp.
|
|
||||||
|
|
||||||
HHC_LOCATION =
|
|
||||||
|
|
||||||
# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
|
|
||||||
# controls if a separate .chi index file is generated (YES) or that
|
|
||||||
# it should be included in the master .chm file (NO).
|
|
||||||
|
|
||||||
GENERATE_CHI = NO
|
|
||||||
|
|
||||||
# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
|
|
||||||
# controls whether a binary table of contents is generated (YES) or a
|
|
||||||
# normal table of contents (NO) in the .chm file.
|
|
||||||
|
|
||||||
BINARY_TOC = NO
|
|
||||||
|
|
||||||
# The TOC_EXPAND flag can be set to YES to add extra items for group members
|
|
||||||
# to the contents of the HTML help documentation and to the tree view.
|
|
||||||
|
|
||||||
TOC_EXPAND = NO
|
|
||||||
|
|
||||||
# The DISABLE_INDEX tag can be used to turn on/off the condensed index at
|
|
||||||
# top of each HTML page. The value NO (the default) enables the index and
|
|
||||||
# the value YES disables it.
|
|
||||||
|
|
||||||
DISABLE_INDEX = NO
|
|
||||||
|
|
||||||
# This tag can be used to set the number of enum values (range [1..20])
|
|
||||||
# that doxygen will group on one line in the generated HTML documentation.
|
|
||||||
|
|
||||||
ENUM_VALUES_PER_LINE = 4
|
|
||||||
|
|
||||||
# If the GENERATE_TREEVIEW tag is set to YES, a side panel will be
|
|
||||||
# generated containing a tree-like index structure (just like the one that
|
|
||||||
# is generated for HTML Help). For this to work a browser that supports
|
|
||||||
# JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+,
|
|
||||||
# Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are
|
|
||||||
# probably better off using the HTML help feature.
|
|
||||||
|
|
||||||
GENERATE_TREEVIEW = NO
|
|
||||||
|
|
||||||
# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
|
|
||||||
# used to set the initial width (in pixels) of the frame in which the tree
|
|
||||||
# is shown.
|
|
||||||
|
|
||||||
TREEVIEW_WIDTH = 250
|
|
||||||
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
# configuration options related to the LaTeX output
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
|
|
||||||
# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
|
|
||||||
# generate Latex output.
|
|
||||||
|
|
||||||
GENERATE_LATEX = NO
|
|
||||||
|
|
||||||
# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
|
|
||||||
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
|
|
||||||
# put in front of it. If left blank `latex' will be used as the default path.
|
|
||||||
|
|
||||||
LATEX_OUTPUT = latex
|
|
||||||
|
|
||||||
# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
|
|
||||||
# invoked. If left blank `latex' will be used as the default command name.
|
|
||||||
|
|
||||||
LATEX_CMD_NAME = latex
|
|
||||||
|
|
||||||
# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
|
|
||||||
# generate index for LaTeX. If left blank `makeindex' will be used as the
|
|
||||||
# default command name.
|
|
||||||
|
|
||||||
MAKEINDEX_CMD_NAME = makeindex
|
|
||||||
|
|
||||||
# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
|
|
||||||
# LaTeX documents. This may be useful for small projects and may help to
|
|
||||||
# save some trees in general.
|
|
||||||
|
|
||||||
COMPACT_LATEX = NO
|
|
||||||
|
|
||||||
# The PAPER_TYPE tag can be used to set the paper type that is used
|
|
||||||
# by the printer. Possible values are: a4, a4wide, letter, legal and
|
|
||||||
# executive. If left blank a4wide will be used.
|
|
||||||
|
|
||||||
PAPER_TYPE = a4wide
|
|
||||||
|
|
||||||
# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
|
|
||||||
# packages that should be included in the LaTeX output.
|
|
||||||
|
|
||||||
EXTRA_PACKAGES =
|
|
||||||
|
|
||||||
# The LATEX_HEADER tag can be used to specify a personal LaTeX header for
|
|
||||||
# the generated latex document. The header should contain everything until
|
|
||||||
# the first chapter. If it is left blank doxygen will generate a
|
|
||||||
# standard header. Notice: only use this tag if you know what you are doing!
|
|
||||||
|
|
||||||
LATEX_HEADER =
|
|
||||||
|
|
||||||
# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
|
|
||||||
# is prepared for conversion to pdf (using ps2pdf). The pdf file will
|
|
||||||
# contain links (just like the HTML output) instead of page references
|
|
||||||
# This makes the output suitable for online browsing using a pdf viewer.
|
|
||||||
|
|
||||||
PDF_HYPERLINKS = NO
|
|
||||||
|
|
||||||
# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
|
|
||||||
# plain latex in the generated Makefile. Set this option to YES to get a
|
|
||||||
# higher quality PDF documentation.
|
|
||||||
|
|
||||||
USE_PDFLATEX = NO
|
|
||||||
|
|
||||||
# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
|
|
||||||
# command to the generated LaTeX files. This will instruct LaTeX to keep
|
|
||||||
# running if errors occur, instead of asking the user for help.
|
|
||||||
# This option is also used when generating formulas in HTML.
|
|
||||||
|
|
||||||
LATEX_BATCHMODE = NO
|
|
||||||
|
|
||||||
# If LATEX_HIDE_INDICES is set to YES then doxygen will not
|
|
||||||
# include the index chapters (such as File Index, Compound Index, etc.)
|
|
||||||
# in the output.
|
|
||||||
|
|
||||||
LATEX_HIDE_INDICES = NO
|
|
||||||
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
# configuration options related to the RTF output
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
|
|
||||||
# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
|
|
||||||
# The RTF output is optimised for Word 97 and may not look very pretty with
|
|
||||||
# other RTF readers or editors.
|
|
||||||
|
|
||||||
GENERATE_RTF = NO
|
|
||||||
|
|
||||||
# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
|
|
||||||
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
|
|
||||||
# put in front of it. If left blank `rtf' will be used as the default path.
|
|
||||||
|
|
||||||
RTF_OUTPUT = rtf
|
|
||||||
|
|
||||||
# If the COMPACT_RTF tag is set to YES Doxygen generates more compact
|
|
||||||
# RTF documents. This may be useful for small projects and may help to
|
|
||||||
# save some trees in general.
|
|
||||||
|
|
||||||
COMPACT_RTF = NO
|
|
||||||
|
|
||||||
# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
|
|
||||||
# will contain hyperlink fields. The RTF file will
|
|
||||||
# contain links (just like the HTML output) instead of page references.
|
|
||||||
# This makes the output suitable for online browsing using WORD or other
|
|
||||||
# programs which support those fields.
|
|
||||||
# Note: wordpad (write) and others do not support links.
|
|
||||||
|
|
||||||
RTF_HYPERLINKS = NO
|
|
||||||
|
|
||||||
# Load stylesheet definitions from file. Syntax is similar to doxygen's
|
|
||||||
# config file, i.e. a series of assigments. You only have to provide
|
|
||||||
# replacements, missing definitions are set to their default value.
|
|
||||||
|
|
||||||
RTF_STYLESHEET_FILE =
|
|
||||||
|
|
||||||
# Set optional variables used in the generation of an rtf document.
|
|
||||||
# Syntax is similar to doxygen's config file.
|
|
||||||
|
|
||||||
RTF_EXTENSIONS_FILE =
|
|
||||||
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
# configuration options related to the man page output
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
|
|
||||||
# If the GENERATE_MAN tag is set to YES (the default) Doxygen will
|
|
||||||
# generate man pages
|
|
||||||
|
|
||||||
GENERATE_MAN = NO
|
|
||||||
|
|
||||||
# The MAN_OUTPUT tag is used to specify where the man pages will be put.
|
|
||||||
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
|
|
||||||
# put in front of it. If left blank `man' will be used as the default path.
|
|
||||||
|
|
||||||
MAN_OUTPUT = man
|
|
||||||
|
|
||||||
# The MAN_EXTENSION tag determines the extension that is added to
|
|
||||||
# the generated man pages (default is the subroutine's section .3)
|
|
||||||
|
|
||||||
MAN_EXTENSION = .3
|
|
||||||
|
|
||||||
# If the MAN_LINKS tag is set to YES and Doxygen generates man output,
|
|
||||||
# then it will generate one additional man file for each entity
|
|
||||||
# documented in the real man page(s). These additional files
|
|
||||||
# only source the real man page, but without them the man command
|
|
||||||
# would be unable to find the correct page. The default is NO.
|
|
||||||
|
|
||||||
MAN_LINKS = NO
|
|
||||||
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
# configuration options related to the XML output
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
|
|
||||||
# If the GENERATE_XML tag is set to YES Doxygen will
|
|
||||||
# generate an XML file that captures the structure of
|
|
||||||
# the code including all documentation. Note that this
|
|
||||||
# feature is still experimental and incomplete at the
|
|
||||||
# moment.
|
|
||||||
|
|
||||||
GENERATE_XML = NO
|
|
||||||
|
|
||||||
# The XML_OUTPUT tag is used to specify where the XML pages will be put.
|
|
||||||
# If a relative path is entered the value of OUTPUT_DIRECTORY will be
|
|
||||||
# put in front of it. If left blank `xml' will be used as the default path.
|
|
||||||
|
|
||||||
XML_OUTPUT = xml
|
|
||||||
|
|
||||||
# The XML_SCHEMA tag can be used to specify an XML schema,
|
|
||||||
# which can be used by a validating XML parser to check the
|
|
||||||
# syntax of the XML files.
|
|
||||||
|
|
||||||
XML_SCHEMA =
|
|
||||||
|
|
||||||
# The XML_DTD tag can be used to specify an XML DTD,
|
|
||||||
# which can be used by a validating XML parser to check the
|
|
||||||
# syntax of the XML files.
|
|
||||||
|
|
||||||
XML_DTD =
|
|
||||||
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
# configuration options for the AutoGen Definitions output
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
|
|
||||||
# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
|
|
||||||
# generate an AutoGen Definitions (see autogen.sf.net) file
|
|
||||||
# that captures the structure of the code including all
|
|
||||||
# documentation. Note that this feature is still experimental
|
|
||||||
# and incomplete at the moment.
|
|
||||||
|
|
||||||
GENERATE_AUTOGEN_DEF = NO
|
|
||||||
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
# configuration options related to the Perl module output
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
|
|
||||||
# If the GENERATE_PERLMOD tag is set to YES Doxygen will
|
|
||||||
# generate a Perl module file that captures the structure of
|
|
||||||
# the code including all documentation. Note that this
|
|
||||||
# feature is still experimental and incomplete at the
|
|
||||||
# moment.
|
|
||||||
|
|
||||||
GENERATE_PERLMOD = NO
|
|
||||||
|
|
||||||
# If the PERLMOD_LATEX tag is set to YES Doxygen will generate
|
|
||||||
# the necessary Makefile rules, Perl scripts and LaTeX code to be able
|
|
||||||
# to generate PDF and DVI output from the Perl module output.
|
|
||||||
|
|
||||||
PERLMOD_LATEX = NO
|
|
||||||
|
|
||||||
# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
|
|
||||||
# nicely formatted so it can be parsed by a human reader. This is useful
|
|
||||||
# if you want to understand what is going on. On the other hand, if this
|
|
||||||
# tag is set to NO the size of the Perl module output will be much smaller
|
|
||||||
# and Perl will parse it just the same.
|
|
||||||
|
|
||||||
PERLMOD_PRETTY = YES
|
|
||||||
|
|
||||||
# The names of the make variables in the generated doxyrules.make file
|
|
||||||
# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
|
|
||||||
# This is useful so different doxyrules.make files included by the same
|
|
||||||
# Makefile don't overwrite each other's variables.
|
|
||||||
|
|
||||||
PERLMOD_MAKEVAR_PREFIX =
|
|
||||||
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
# Configuration options related to the preprocessor
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
|
|
||||||
# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
|
|
||||||
# evaluate all C-preprocessor directives found in the sources and include
|
|
||||||
# files.
|
|
||||||
|
|
||||||
ENABLE_PREPROCESSING = YES
|
|
||||||
|
|
||||||
# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
|
|
||||||
# names in the source code. If set to NO (the default) only conditional
|
|
||||||
# compilation will be performed. Macro expansion can be done in a controlled
|
|
||||||
# way by setting EXPAND_ONLY_PREDEF to YES.
|
|
||||||
|
|
||||||
MACRO_EXPANSION = NO
|
|
||||||
|
|
||||||
# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
|
|
||||||
# then the macro expansion is limited to the macros specified with the
|
|
||||||
# PREDEFINED and EXPAND_AS_PREDEFINED tags.
|
|
||||||
|
|
||||||
EXPAND_ONLY_PREDEF = NO
|
|
||||||
|
|
||||||
# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
|
|
||||||
# in the INCLUDE_PATH (see below) will be search if a #include is found.
|
|
||||||
|
|
||||||
SEARCH_INCLUDES = YES
|
|
||||||
|
|
||||||
# The INCLUDE_PATH tag can be used to specify one or more directories that
|
|
||||||
# contain include files that are not input files but should be processed by
|
|
||||||
# the preprocessor.
|
|
||||||
|
|
||||||
INCLUDE_PATH =
|
|
||||||
|
|
||||||
# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
|
|
||||||
# patterns (like *.h and *.hpp) to filter out the header-files in the
|
|
||||||
# directories. If left blank, the patterns specified with FILE_PATTERNS will
|
|
||||||
# be used.
|
|
||||||
|
|
||||||
INCLUDE_FILE_PATTERNS =
|
|
||||||
|
|
||||||
# The PREDEFINED tag can be used to specify one or more macro names that
|
|
||||||
# are defined before the preprocessor is started (similar to the -D option of
|
|
||||||
# gcc). The argument of the tag is a list of macros of the form: name
|
|
||||||
# or name=definition (no spaces). If the definition and the = are
|
|
||||||
# omitted =1 is assumed.
|
|
||||||
|
|
||||||
PREDEFINED =
|
|
||||||
|
|
||||||
# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
|
|
||||||
# this tag can be used to specify a list of macro names that should be expanded.
|
|
||||||
# The macro definition that is found in the sources will be used.
|
|
||||||
# Use the PREDEFINED tag if you want to use a different macro definition.
|
|
||||||
|
|
||||||
EXPAND_AS_DEFINED =
|
|
||||||
|
|
||||||
# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
|
|
||||||
# doxygen's preprocessor will remove all function-like macros that are alone
|
|
||||||
# on a line, have an all uppercase name, and do not end with a semicolon. Such
|
|
||||||
# function macros are typically used for boiler-plate code, and will confuse the
|
|
||||||
# parser if not removed.
|
|
||||||
|
|
||||||
SKIP_FUNCTION_MACROS = YES
|
|
||||||
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
# Configuration::addtions related to external references
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
|
|
||||||
# The TAGFILES option can be used to specify one or more tagfiles.
|
|
||||||
# Optionally an initial location of the external documentation
|
|
||||||
# can be added for each tagfile. The format of a tag file without
|
|
||||||
# this location is as follows:
|
|
||||||
# TAGFILES = file1 file2 ...
|
|
||||||
# Adding location for the tag files is done as follows:
|
|
||||||
# TAGFILES = file1=loc1 "file2 = loc2" ...
|
|
||||||
# where "loc1" and "loc2" can be relative or absolute paths or
|
|
||||||
# URLs. If a location is present for each tag, the installdox tool
|
|
||||||
# does not have to be run to correct the links.
|
|
||||||
# Note that each tag file must have a unique name
|
|
||||||
# (where the name does NOT include the path)
|
|
||||||
# If a tag file is not located in the directory in which doxygen
|
|
||||||
# is run, you must also specify the path to the tagfile here.
|
|
||||||
|
|
||||||
TAGFILES =
|
|
||||||
|
|
||||||
# When a file name is specified after GENERATE_TAGFILE, doxygen will create
|
|
||||||
# a tag file that is based on the input files it reads.
|
|
||||||
|
|
||||||
GENERATE_TAGFILE =
|
|
||||||
|
|
||||||
# If the ALLEXTERNALS tag is set to YES all external classes will be listed
|
|
||||||
# in the class index. If set to NO only the inherited external classes
|
|
||||||
# will be listed.
|
|
||||||
|
|
||||||
ALLEXTERNALS = NO
|
|
||||||
|
|
||||||
# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
|
|
||||||
# in the modules index. If set to NO, only the current project's groups will
|
|
||||||
# be listed.
|
|
||||||
|
|
||||||
EXTERNAL_GROUPS = YES
|
|
||||||
|
|
||||||
# The PERL_PATH should be the absolute path and name of the perl script
|
|
||||||
# interpreter (i.e. the result of `which perl').
|
|
||||||
|
|
||||||
PERL_PATH = /usr/bin/perl
|
|
||||||
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
# Configuration options related to the dot tool
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
|
|
||||||
# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
|
|
||||||
# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base or
|
|
||||||
# super classes. Setting the tag to NO turns the diagrams off. Note that this
|
|
||||||
# option is superceded by the HAVE_DOT option below. This is only a fallback. It is
|
|
||||||
# recommended to install and use dot, since it yields more powerful graphs.
|
|
||||||
|
|
||||||
CLASS_DIAGRAMS = YES
|
|
||||||
|
|
||||||
# If set to YES, the inheritance and collaboration graphs will hide
|
|
||||||
# inheritance and usage relations if the target is undocumented
|
|
||||||
# or is not a class.
|
|
||||||
|
|
||||||
HIDE_UNDOC_RELATIONS = NO
|
|
||||||
|
|
||||||
# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
|
|
||||||
# available from the path. This tool is part of Graphviz, a graph visualization
|
|
||||||
# toolkit from AT&T and Lucent Bell Labs. The other options in this section
|
|
||||||
# have no effect if this option is set to NO (the default)
|
|
||||||
|
|
||||||
HAVE_DOT = @HAVE_DOT@
|
|
||||||
|
|
||||||
# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
|
|
||||||
# will generate a graph for each documented class showing the direct and
|
|
||||||
# indirect inheritance relations. Setting this tag to YES will force the
|
|
||||||
# the CLASS_DIAGRAMS tag to NO.
|
|
||||||
|
|
||||||
CLASS_GRAPH = YES
|
|
||||||
|
|
||||||
# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
|
|
||||||
# will generate a graph for each documented class showing the direct and
|
|
||||||
# indirect implementation dependencies (inheritance, containment, and
|
|
||||||
# class references variables) of the class with other documented classes.
|
|
||||||
|
|
||||||
COLLABORATION_GRAPH = NO
|
|
||||||
|
|
||||||
# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
|
|
||||||
# colloborations diagrams in a style similiar to the OMG's Unified Modeling
|
|
||||||
# Language.
|
|
||||||
|
|
||||||
UML_LOOK = NO
|
|
||||||
|
|
||||||
# If set to YES, the inheritance and collaboration graphs will show the
|
|
||||||
# relations between templates and their instances.
|
|
||||||
|
|
||||||
TEMPLATE_RELATIONS = YES
|
|
||||||
|
|
||||||
# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
|
|
||||||
# tags are set to YES then doxygen will generate a graph for each documented
|
|
||||||
# file showing the direct and indirect include dependencies of the file with
|
|
||||||
# other documented files.
|
|
||||||
|
|
||||||
INCLUDE_GRAPH = NO
|
|
||||||
|
|
||||||
# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
|
|
||||||
# HAVE_DOT tags are set to YES then doxygen will generate a graph for each
|
|
||||||
# documented header file showing the documented files that directly or
|
|
||||||
# indirectly include this file.
|
|
||||||
|
|
||||||
INCLUDED_BY_GRAPH = NO
|
|
||||||
|
|
||||||
# If the CALL_GRAPH and HAVE_DOT tags are set to YES then doxygen will
|
|
||||||
# generate a call dependency graph for every global function or class method.
|
|
||||||
# Note that enabling this option will significantly increase the time of a run.
|
|
||||||
# So in most cases it will be better to enable call graphs for selected
|
|
||||||
# functions only using the \callgraph command.
|
|
||||||
|
|
||||||
CALL_GRAPH = NO
|
|
||||||
|
|
||||||
# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
|
|
||||||
# will graphical hierarchy of all classes instead of a textual one.
|
|
||||||
|
|
||||||
GRAPHICAL_HIERARCHY = YES
|
|
||||||
|
|
||||||
# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
|
|
||||||
# generated by dot. Possible values are png, jpg, or gif
|
|
||||||
# If left blank png will be used.
|
|
||||||
|
|
||||||
DOT_IMAGE_FORMAT = png
|
|
||||||
|
|
||||||
# The tag DOT_PATH can be used to specify the path where the dot tool can be
|
|
||||||
# found. If left blank, it is assumed the dot tool can be found on the path.
|
|
||||||
|
|
||||||
DOT_PATH =
|
|
||||||
|
|
||||||
# The DOTFILE_DIRS tag can be used to specify one or more directories that
|
|
||||||
# contain dot files that are included in the documentation (see the
|
|
||||||
# \dotfile command).
|
|
||||||
|
|
||||||
DOTFILE_DIRS =
|
|
||||||
|
|
||||||
# The MAX_DOT_GRAPH_WIDTH tag can be used to set the maximum allowed width
|
|
||||||
# (in pixels) of the graphs generated by dot. If a graph becomes larger than
|
|
||||||
# this value, doxygen will try to truncate the graph, so that it fits within
|
|
||||||
# the specified constraint. Beware that most browsers cannot cope with very
|
|
||||||
# large images.
|
|
||||||
|
|
||||||
MAX_DOT_GRAPH_WIDTH = 800
|
|
||||||
|
|
||||||
# The MAX_DOT_GRAPH_HEIGHT tag can be used to set the maximum allows height
|
|
||||||
# (in pixels) of the graphs generated by dot. If a graph becomes larger than
|
|
||||||
# this value, doxygen will try to truncate the graph, so that it fits within
|
|
||||||
# the specified constraint. Beware that most browsers cannot cope with very
|
|
||||||
# large images.
|
|
||||||
|
|
||||||
MAX_DOT_GRAPH_HEIGHT = 800
|
|
||||||
|
|
||||||
# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
|
|
||||||
# graphs generated by dot. A depth value of 3 means that only nodes reachable
|
|
||||||
# from the root by following a path via at most 3 edges will be shown. Nodes that
|
|
||||||
# lay further from the root node will be omitted. Note that setting this option to
|
|
||||||
# 1 or 2 may greatly reduce the computation time needed for large code bases. Also
|
|
||||||
# note that a graph may be further truncated if the graph's image dimensions are
|
|
||||||
# not sufficient to fit the graph (see MAX_DOT_GRAPH_WIDTH and MAX_DOT_GRAPH_HEIGHT).
|
|
||||||
# If 0 is used for the depth value (the default), the graph is not depth-constrained.
|
|
||||||
|
|
||||||
MAX_DOT_GRAPH_DEPTH = 0
|
|
||||||
|
|
||||||
# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
|
|
||||||
# generate a legend page explaining the meaning of the various boxes and
|
|
||||||
# arrows in the dot generated graphs.
|
|
||||||
|
|
||||||
GENERATE_LEGEND = YES
|
|
||||||
|
|
||||||
# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
|
|
||||||
# remove the intermediate dot files that are used to generate
|
|
||||||
# the various graphs.
|
|
||||||
|
|
||||||
DOT_CLEANUP = YES
|
|
||||||
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
# Configuration::addtions related to the search engine
|
|
||||||
#---------------------------------------------------------------------------
|
|
||||||
|
|
||||||
# The SEARCHENGINE tag specifies whether or not a search engine should be
|
|
||||||
# used. If set to NO the values of all tags below this one will be ignored.
|
|
||||||
|
|
||||||
SEARCHENGINE = NO
|
|
||||||
|
|
||||||
# The CGI_NAME tag should be the name of the CGI script that
|
|
||||||
# starts the search engine (doxysearch) with the correct parameters.
|
|
||||||
# A script with this name will be generated by doxygen.
|
|
||||||
|
|
||||||
CGI_NAME = search.cgi
|
|
||||||
|
|
||||||
# The CGI_URL tag should be the absolute URL to the directory where the
|
|
||||||
# cgi binaries are located. See the documentation of your http daemon for
|
|
||||||
# details.
|
|
||||||
|
|
||||||
CGI_URL =
|
|
||||||
|
|
||||||
# The DOC_URL tag should be the absolute URL to the directory where the
|
|
||||||
# documentation is located. If left blank the absolute path to the
|
|
||||||
# documentation, with file:// prepended to it, will be used.
|
|
||||||
|
|
||||||
DOC_URL =
|
|
||||||
|
|
||||||
# The DOC_ABSPATH tag should be the absolute path to the directory where the
|
|
||||||
# documentation is located. If left blank the directory on the local machine
|
|
||||||
# will be used.
|
|
||||||
|
|
||||||
DOC_ABSPATH =
|
|
||||||
|
|
||||||
# The BIN_ABSPATH tag must point to the directory where the doxysearch binary
|
|
||||||
# is installed.
|
|
||||||
|
|
||||||
BIN_ABSPATH = /usr/local/bin/
|
|
||||||
|
|
||||||
# The EXT_DOC_PATHS tag can be used to specify one or more paths to
|
|
||||||
# documentation generated for other projects. This allows doxysearch to search
|
|
||||||
# the documentation for these projects as well.
|
|
||||||
|
|
||||||
EXT_DOC_PATHS =
|
|
||||||
@@ -1,15 +0,0 @@
|
|||||||
#include <mrw/exception.hpp>
|
|
||||||
#include <mrw/stacktrace.hpp>
|
|
||||||
|
|
||||||
namespace mrw {
|
|
||||||
exception::exception() throw(std::bad_exception):
|
|
||||||
_stacktrace(new StackTrace) {
|
|
||||||
}
|
|
||||||
exception::~exception() throw() {
|
|
||||||
delete _stacktrace;
|
|
||||||
}
|
|
||||||
const std::string& exception::stacktrace() const throw(std::bad_exception) {
|
|
||||||
static const std::string st(*_stacktrace);
|
|
||||||
return st;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,170 +0,0 @@
|
|||||||
#ifndef __MRW_EXCEPTION_HPP__
|
|
||||||
#define __MRW_EXCEPTION_HPP__
|
|
||||||
|
|
||||||
#include <exception>
|
|
||||||
#include <string>
|
|
||||||
|
|
||||||
namespace mrw {
|
|
||||||
|
|
||||||
class StackTrace;
|
|
||||||
|
|
||||||
/** @addtogroup StackTrace
|
|
||||||
|
|
||||||
@section exc Exception Handling with Stack Trace
|
|
||||||
|
|
||||||
One of the main reasons for the mrw::StackTrace class is, to be
|
|
||||||
able to store a trace where an exception is thrown. This trace
|
|
||||||
is then stored as exception information, but not yet evaluated,
|
|
||||||
symbols are calculated only if necessary, upon request. So the
|
|
||||||
exception is still relatively cheap.
|
|
||||||
|
|
||||||
There is a class named mrw::exception that derieves from and
|
|
||||||
behaves as @c std::exception, but it stores a mrw::StackTrace on
|
|
||||||
construction and offers a method @c mrw::exception::stacktrace()
|
|
||||||
that returns a well formatted stack trace of the point, where
|
|
||||||
the exception was created.
|
|
||||||
|
|
||||||
@subsection excprob Common Problems with Exception Handling
|
|
||||||
|
|
||||||
Exceptions are very handy: When you have a problem, you throw an
|
|
||||||
exception and when you call a method and reach the next line,
|
|
||||||
everything was fine. You don't have to care about error handling
|
|
||||||
unless you are able to handle it. Otherwise you simply let pass
|
|
||||||
any exception up in the stack.
|
|
||||||
|
|
||||||
The big disadvantage is, when you catch an exception, you don't
|
|
||||||
know where it was thrown. That's the stack trace for. Another
|
|
||||||
problem is, the exception specification problem: When you don't
|
|
||||||
write exception specifications, you don't know what a specific
|
|
||||||
method throws. If you do write exception specifications, they
|
|
||||||
are not checked at compile time, but enforced at run time. If a
|
|
||||||
wrong exception is thrown, the program stops, calls an
|
|
||||||
unexpected handler that by default aborts the program. Since the
|
|
||||||
unexpected handler must not return, the problem cannot be
|
|
||||||
recovered from. But the unexpected handler can rethrow and catch
|
|
||||||
the bad exception and it is allowed to throw a new
|
|
||||||
exception. This is what my suggested exception handling concept
|
|
||||||
makes use of.
|
|
||||||
|
|
||||||
@subsection excsug Suggested Exception Handling Rules
|
|
||||||
|
|
||||||
-# derieve all your exceptions from mrw::exception
|
|
||||||
-# write exception specifications as follows:
|
|
||||||
- if any exception is thrown, specify @c throw(mrw::exception)
|
|
||||||
- if no exception is thrown, specify @c throw(std::bad_exception)
|
|
||||||
-# document the exact exception thrown with Doxygen's \@throw tag
|
|
||||||
-# write an unexpected handler as follows:
|
|
||||||
|
|
||||||
@code
|
|
||||||
void unexpectedHandler() {
|
|
||||||
try {
|
|
||||||
throw;
|
|
||||||
} catch (mrw::exception& x) {
|
|
||||||
// trace x.stacktrace() and x.what()
|
|
||||||
} catch (std::exception& x) {
|
|
||||||
// trace x.what()
|
|
||||||
} catch (...) {
|
|
||||||
// trace unknown unexpected
|
|
||||||
}
|
|
||||||
throw std::bad_exception(); // try to recover
|
|
||||||
}
|
|
||||||
@endcode
|
|
||||||
|
|
||||||
What happens:
|
|
||||||
- If you throw an exception in a method that declares not to
|
|
||||||
throw an exception, the unexpected handler is called.
|
|
||||||
- It writes a stack trace for you to be able to find your bug.
|
|
||||||
- Then it throws a @c std::bad_exception, which is allowed to pass.
|
|
||||||
- Your program does not abort, but continues running.
|
|
||||||
- If higher in the stack you catch the exception, you may be
|
|
||||||
able to recover.
|
|
||||||
- If you throw an exception where you are allowed to, you only need to
|
|
||||||
catch mrw::exception and you can access @c what() and @c stacktrace().
|
|
||||||
|
|
||||||
For a proof of concept refer to
|
|
||||||
@ref exceptionhandling.cpp "the example exceptionhandling.cpp".
|
|
||||||
*/
|
|
||||||
//@{
|
|
||||||
|
|
||||||
/** @example exceptionhandling.cpp
|
|
||||||
|
|
||||||
It is possible to recover from an unexpected exception! A stack
|
|
||||||
trace helps you to find the source of a problem, here function
|
|
||||||
@c fn2() in file @c /privat/home/marc/pro/mrw-c++/mrw/test.cpp
|
|
||||||
on line @c 25. This example produces the following output:
|
|
||||||
|
|
||||||
@verbatim
|
|
||||||
call fn0
|
|
||||||
enter fn0
|
|
||||||
enter fn1
|
|
||||||
enter fn2
|
|
||||||
UNEXPECTED:N3mrw9exceptionE
|
|
||||||
---------------------------Stack:
|
|
||||||
[0x8049e51] ../sysdeps/i386/elf/start.S:105 _start
|
|
||||||
[0x401cfd3e] ????:0 ????
|
|
||||||
[0x804a3d0] examples/exceptionhandling.cpp:50 main
|
|
||||||
[0x804a2a3] examples/exceptionhandling.cpp:38 fn0()
|
|
||||||
[0x804a227] examples/exceptionhandling.cpp:32 fn1()
|
|
||||||
[0x804a1c1] examples/exceptionhandling.cpp:25 fn2()
|
|
||||||
[0x804fdda] ../mrw/exception.cpp:6 mrw::exception::exception()
|
|
||||||
[0x804a8f5] ../mrw/stacktrace.cpp:54 mrw::StackTrace::StackTrace()
|
|
||||||
---------------------------------
|
|
||||||
EXCEPTION caught in fn0:St13bad_exception
|
|
||||||
leave fn0
|
|
||||||
call of fn0 successful
|
|
||||||
@endverbatim
|
|
||||||
|
|
||||||
Please note, that without the exception concept and without the
|
|
||||||
unexpected handler, the program would abort in function fn2 on
|
|
||||||
line 25. The output was produced by the following code:
|
|
||||||
*/
|
|
||||||
|
|
||||||
/** @brief replacement for @c std::exception, that collects a stack trace
|
|
||||||
|
|
||||||
This exception class behaves exactely like @c std::exception,
|
|
||||||
but it collects a stack trace in the constructor and offers a
|
|
||||||
method to return the formatted stack trace for logging.
|
|
||||||
|
|
||||||
It is recommended, to inherit all the exceptions you ever throw
|
|
||||||
from this class. This way you can always access the stack trace
|
|
||||||
if you run into troubles. It is fursther recommended, to write a
|
|
||||||
unexpected handler, that rethrows, catches this exception, then
|
|
||||||
throws a @c std::bad_exception to try to continue. This is the
|
|
||||||
reason, why all the exception specifications in the MRW C++
|
|
||||||
Library declar @c throw(std::bad_exception) instead of @c
|
|
||||||
throw(), when they throw nothing.
|
|
||||||
|
|
||||||
@code
|
|
||||||
namespace myProject {
|
|
||||||
void unexpectedHandler() {
|
|
||||||
try {
|
|
||||||
throw;
|
|
||||||
} catch (mrw::exception& x) {
|
|
||||||
// trace x.stacktrace() and x.what()
|
|
||||||
} catch (std::exception& x) {
|
|
||||||
// trace x.what()
|
|
||||||
} catch (...) {
|
|
||||||
// trace unknown unexpected
|
|
||||||
}
|
|
||||||
throw std::bad_exception(); // try to recover
|
|
||||||
}
|
|
||||||
}
|
|
||||||
int main() {
|
|
||||||
std::set_unexpected(&myProject::unexpectedHandler);
|
|
||||||
...
|
|
||||||
}
|
|
||||||
@endcode
|
|
||||||
*/
|
|
||||||
class exception: public std::exception {
|
|
||||||
public:
|
|
||||||
exception() throw(std::bad_exception);
|
|
||||||
virtual ~exception() throw();
|
|
||||||
const std::string& stacktrace() const throw(std::bad_exception);
|
|
||||||
private:
|
|
||||||
StackTrace* _stacktrace;
|
|
||||||
};
|
|
||||||
|
|
||||||
//@}
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif
|
|
||||||
163
mrw/exec.cpp
163
mrw/exec.cpp
@@ -1,163 +0,0 @@
|
|||||||
#include <mrw/exec.hpp>
|
|
||||||
#include <mrw/unistd.hpp>
|
|
||||||
#include <sys/wait.h> // waitpid
|
|
||||||
#include <unistd.h> // fork, exec
|
|
||||||
#include <string.h> // memcpy
|
|
||||||
|
|
||||||
#include <iostream>
|
|
||||||
|
|
||||||
mrw::ExecutionFailedExc::ExecutionFailedExc(const std::string& w,
|
|
||||||
const std::string& c)
|
|
||||||
throw(std::bad_exception):
|
|
||||||
_what(std::string("mrw::Exec: command execution failed\n")+
|
|
||||||
std::string(" failed command was: \""+c+"\"\n")+
|
|
||||||
std::string(" error was: \"")+w+'"') {
|
|
||||||
/**
|
|
||||||
@c what looks like:
|
|
||||||
@verbatim
|
|
||||||
mrw::Exec: command execution failed
|
|
||||||
failed command was: "/bin/OOOOPS -v -q --crash"
|
|
||||||
error was: "execution failed"
|
|
||||||
@endverbatim
|
|
||||||
*/
|
|
||||||
}
|
|
||||||
|
|
||||||
mrw::Cmd::Cmd(const std::string& c) throw(std::bad_exception) {
|
|
||||||
_cmd.push_back(c);
|
|
||||||
}
|
|
||||||
|
|
||||||
mrw::Cmd& mrw::Cmd::operator,(const std::string& arg)
|
|
||||||
throw(std::bad_exception) {
|
|
||||||
_cmd.push_back(arg);
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
|
|
||||||
mrw::Cmd& mrw::Cmd::operator<<(const std::string& arg)
|
|
||||||
throw(std::bad_exception) {
|
|
||||||
_cmd.push_back(arg);
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
|
|
||||||
mrw::Cmd::operator std::string() const throw(std::bad_exception) {
|
|
||||||
ArgList::const_iterator it(_cmd.begin());
|
|
||||||
std::string c(*it);
|
|
||||||
while (++it!=_cmd.end()) c+=' '+*it;
|
|
||||||
return c;
|
|
||||||
}
|
|
||||||
|
|
||||||
mrw::Cmd::operator mrw::Exec() const throw(std::bad_exception) {
|
|
||||||
return mrw::Exec(*this);
|
|
||||||
}
|
|
||||||
|
|
||||||
mrw::Exec mrw::Cmd::execute(bool throwExc) const throw(mrw::exception) {
|
|
||||||
return mrw::Exec(*this).execute(throwExc);
|
|
||||||
}
|
|
||||||
|
|
||||||
const char* mrw::Cmd::path() const throw(std::bad_exception) {
|
|
||||||
return _cmd.front().c_str();
|
|
||||||
}
|
|
||||||
char** mrw::Cmd::args() const throw(std::bad_exception) {
|
|
||||||
if (_cmd.size()==0) return 0;
|
|
||||||
char** array = new char*[_cmd.size()+1];
|
|
||||||
int i(0);
|
|
||||||
for (ArgList::const_iterator it(_cmd.begin()); it!=_cmd.end(); ++it)
|
|
||||||
memcpy(array[i++]=new char[it->size()+1], it->c_str(), it->size()+1);
|
|
||||||
array[i] = 0;
|
|
||||||
return array;
|
|
||||||
}
|
|
||||||
|
|
||||||
mrw::Exec::Exec(const mrw::Cmd& c) throw(std::bad_exception):
|
|
||||||
_cmd(new mrw::Cmd(c)), _success(false) {
|
|
||||||
}
|
|
||||||
|
|
||||||
mrw::Exec::Exec(const mrw::Exec& e) throw(std::bad_exception):
|
|
||||||
_cmd(new mrw::Cmd(*e._cmd)),
|
|
||||||
_res(e._res), _err(e._err), _success(e._success) {
|
|
||||||
}
|
|
||||||
|
|
||||||
mrw::Exec::~Exec() throw() {
|
|
||||||
delete _cmd;
|
|
||||||
}
|
|
||||||
|
|
||||||
mrw::Exec& mrw::Exec::operator=(const mrw::Exec& e) throw(std::bad_exception) {
|
|
||||||
if (this==&e) return *this;
|
|
||||||
*_cmd=*e._cmd; _res=e._res; _err=e._err; _success=e._success;
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
|
|
||||||
mrw::Exec& mrw::Exec::execute(bool throwExc) throw(mrw::exception) {
|
|
||||||
/** This method calls @c fork, sets up a pipe connection to pass @c
|
|
||||||
stdot and @c stderr from the child process to the parent process
|
|
||||||
using mrw::pipe and calls @c execvp to execute the program. */
|
|
||||||
_success = false;
|
|
||||||
_res = _err = "";
|
|
||||||
mrw::pipe stdout, stderr;
|
|
||||||
if (!stdout || !stderr)
|
|
||||||
throw mrw::ExecutionFailedExc("cannot create pipe", *_cmd);
|
|
||||||
pid_t pid(fork());
|
|
||||||
if (pid<0)
|
|
||||||
throw ExecutionFailedExc("cannot fork", *_cmd);
|
|
||||||
if (pid) { // parent
|
|
||||||
stdout.close_out();
|
|
||||||
stderr.close_out();
|
|
||||||
if (!stdout || !stderr)
|
|
||||||
throw ExecutionFailedExc("cannot close pipe", *_cmd);
|
|
||||||
int num1(0), num2(0);
|
|
||||||
for (char buf1[4096], buf2[4096];
|
|
||||||
(num1=read(stdout.istream(), buf1, sizeof(buf1)))>0 ||
|
|
||||||
num1==-1 && errno==EINTR ||
|
|
||||||
(num2=read(stderr.istream(), buf2, sizeof(buf2)))>0 ||
|
|
||||||
num2==-1 && errno==EINTR;
|
|
||||||
_res += std::string(buf1, num1), _err += std::string(buf2, num2));
|
|
||||||
if (num1==-1 || num2==-1)
|
|
||||||
throw ExecutionFailedExc("cannot_ read pipe", *_cmd);
|
|
||||||
// wait for child to get return code
|
|
||||||
int s(0);
|
|
||||||
if (waitpid(pid, &s, 0)!=pid || WIFEXITED(s)!=0 && WEXITSTATUS(s)!=0) {
|
|
||||||
if (throwExc) {
|
|
||||||
throw ExecutionFailedExc("execution failed", *_cmd);
|
|
||||||
} else {
|
|
||||||
_success = false;
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} else { // child
|
|
||||||
stdout.close_in();
|
|
||||||
stderr.close_in();
|
|
||||||
stdout.connect_cout();
|
|
||||||
stderr.connect_cerr();
|
|
||||||
execvp(_cmd->path(), _cmd->args());
|
|
||||||
exit(1); // execute failed
|
|
||||||
}
|
|
||||||
_success = true;
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
|
|
||||||
mrw::Exec& mrw::Exec::operator>>(std::string& res) throw(mrw::exception) {
|
|
||||||
execute();
|
|
||||||
res += _res;
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
|
|
||||||
mrw::Exec::operator std::string&() throw(mrw::exception) {
|
|
||||||
if (!_success) execute();
|
|
||||||
return _res;
|
|
||||||
}
|
|
||||||
|
|
||||||
mrw::Exec::operator bool() throw(std::bad_exception) {
|
|
||||||
return _success;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::string& mrw::Exec::result() throw(mrw::exception) {
|
|
||||||
if (!_success) execute();
|
|
||||||
return _res;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::string& mrw::Exec::error() throw(mrw::exception) {
|
|
||||||
if (!_success) execute();
|
|
||||||
return _err;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool mrw::Exec::success() throw(std::bad_exception) {
|
|
||||||
return _success;
|
|
||||||
}
|
|
||||||
266
mrw/exec.hpp
266
mrw/exec.hpp
@@ -1,266 +0,0 @@
|
|||||||
#ifndef __MRW_EXEC_HPP__
|
|
||||||
#define __MRW_EXEC_HPP__
|
|
||||||
|
|
||||||
#include <string>
|
|
||||||
#include <list>
|
|
||||||
#include <mrw/exception.hpp>
|
|
||||||
|
|
||||||
namespace mrw {
|
|
||||||
|
|
||||||
/** @defgroup CmdExec Execute UNIX Commands
|
|
||||||
|
|
||||||
There is no easy way to safely execute UNIX commands and to
|
|
||||||
return the output of the callee to the caller. @c system ist
|
|
||||||
first of all known to be unsafe, because it opens a shell, and
|
|
||||||
second there is no way to transfer the output back to the
|
|
||||||
caller. On the other hand, starting a new process with @c fork
|
|
||||||
and @c exec and passing the output of the callee to the caller
|
|
||||||
using pipes is quite complex and needs much more than one simple
|
|
||||||
line of code. This is the gap that is filled with this command
|
|
||||||
execution classes. There's a class for the command to be
|
|
||||||
executed and a class for the execution of the command.
|
|
||||||
|
|
||||||
Forking a subprocess and evaluating the result becomes so easy:
|
|
||||||
|
|
||||||
@code
|
|
||||||
try {
|
|
||||||
// execute the command: /bin/ls -l /tmp
|
|
||||||
mrw::Exec ls =
|
|
||||||
(mrw::Cmd("/bin/ls"), "-l", "/tmp").execute(false);
|
|
||||||
// evaluate the result
|
|
||||||
if (ls.success())
|
|
||||||
std::cout<<"Execution successful, result was:"<<std::endl;
|
|
||||||
else
|
|
||||||
std::cerr<<"Error in execution, error was:"<<std::endl;
|
|
||||||
std::cout<<ls.result()<<std::endl;
|
|
||||||
std::cerr<<ls.error()<<std::endl;
|
|
||||||
} catch (ExecutionFailedExc& x) {
|
|
||||||
// a fatal execution error occurred
|
|
||||||
// you can trace x.what() and x.stacktrace()
|
|
||||||
}
|
|
||||||
@endcode
|
|
||||||
*/
|
|
||||||
//@{
|
|
||||||
|
|
||||||
class Cmd;
|
|
||||||
|
|
||||||
/** @brief Exception: Execution of command failed.
|
|
||||||
|
|
||||||
This exception is thrown, if the exection of a command in
|
|
||||||
mrw::Exec is failed. That means, it was not possible to fork or
|
|
||||||
to create the necessary pipes, or the command executing process
|
|
||||||
terminated with an error. In the last case, you can access the
|
|
||||||
error stream from @c stderr respectively @c cerr with method
|
|
||||||
mrw::Exec::error().
|
|
||||||
*/
|
|
||||||
class ExecutionFailedExc: public mrw::exception {
|
|
||||||
public:
|
|
||||||
ExecutionFailedExc(const std::string&, const std::string&)
|
|
||||||
throw(std::bad_exception);
|
|
||||||
virtual ~ExecutionFailedExc() throw() {}
|
|
||||||
virtual const char* what() const throw() {return _what.c_str();}
|
|
||||||
private:
|
|
||||||
std::string _what;
|
|
||||||
};
|
|
||||||
|
|
||||||
/** @brief Execute a command in a new process.
|
|
||||||
|
|
||||||
This class handles the execution of a command in a new process
|
|
||||||
and returns the two streams @c cout and @cerr, also known as @c
|
|
||||||
stderr and @stdout.
|
|
||||||
|
|
||||||
There are different ways of usage for this class. A simple way,
|
|
||||||
one line of code, to get only the resulting stream (no error)
|
|
||||||
is:
|
|
||||||
|
|
||||||
@code
|
|
||||||
string stdout =
|
|
||||||
(mrw::Cmd("/bin/ls"), "-l", "/tmp").execute(false).result();
|
|
||||||
@endcode
|
|
||||||
|
|
||||||
If you need not only the resulting @c stdout stream, but also
|
|
||||||
the error stream @c stderr, then you need to store the result:
|
|
||||||
|
|
||||||
@code
|
|
||||||
mrw::Exec ls =
|
|
||||||
(mrw::Cmd("/bin/ls"), "-l", "/tmp").execute(false);
|
|
||||||
if (!ls) ...; // command termianted with error
|
|
||||||
// ls.result() contains stdout
|
|
||||||
// ls.error() contains stderr
|
|
||||||
@endcode
|
|
||||||
|
|
||||||
@note Please note that the command execution may throw an exception.
|
|
||||||
*/
|
|
||||||
class Exec {
|
|
||||||
public:
|
|
||||||
|
|
||||||
/** @brief Create an executor given a command.
|
|
||||||
Construction without passing a command is not possible. */
|
|
||||||
Exec(const mrw::Cmd&) throw(std::bad_exception);
|
|
||||||
|
|
||||||
Exec(const mrw::Exec&) throw(std::bad_exception);
|
|
||||||
~Exec() throw();
|
|
||||||
Exec& operator=(const mrw::Exec&) throw(std::bad_exception);
|
|
||||||
|
|
||||||
/** @brief Execute the command.
|
|
||||||
|
|
||||||
@param bool
|
|
||||||
- @c true throw an exception if return status is not zero
|
|
||||||
- @c false throw only an exception in case of a fatal error
|
|
||||||
|
|
||||||
@throw ExecutionFailedExc is thrown if
|
|
||||||
- fork fails
|
|
||||||
- creation or setup of pipes failed
|
|
||||||
- if given parameter is @c true (the default) also if the
|
|
||||||
executed program terminates with an error
|
|
||||||
*/
|
|
||||||
Exec& execute(bool=true) throw(mrw::exception);
|
|
||||||
|
|
||||||
/** @brief Executes the command if not done, streams @c stdout into a string
|
|
||||||
|
|
||||||
If the command has not yet been executed successfully, it is
|
|
||||||
first executed, then the @c stdout output of the called
|
|
||||||
program is appended to the string.
|
|
||||||
|
|
||||||
@throw ExecutionFailedExc in case of any failure or if the
|
|
||||||
executed program does not return a zero exit status.
|
|
||||||
*/
|
|
||||||
Exec& operator>>(std::string&) throw(mrw::exception);
|
|
||||||
|
|
||||||
/** @brief Executes the command if not done, returns @c stdout as string
|
|
||||||
|
|
||||||
If the command has not yet been executed successfully, it is
|
|
||||||
first executed, then the @c stdout output of the called
|
|
||||||
program is returned.
|
|
||||||
|
|
||||||
@return @c stdout of the called program
|
|
||||||
|
|
||||||
@throw ExecutionFailedExc in case of any failure or if the
|
|
||||||
executed program does not return a zero exit status.
|
|
||||||
*/
|
|
||||||
operator std::string&() throw(mrw::exception);
|
|
||||||
|
|
||||||
/** @return
|
|
||||||
- @c true if the last execution was successful
|
|
||||||
- @c false if the last execution failed or the command was
|
|
||||||
never executed
|
|
||||||
*/
|
|
||||||
operator bool() throw(std::bad_exception);
|
|
||||||
|
|
||||||
/** @brief Executes the command if not done, returns @c stdout as string
|
|
||||||
|
|
||||||
If the command has not yet been executed successfully, it is
|
|
||||||
first executed, then the @c stdout output of the called
|
|
||||||
program is returned.
|
|
||||||
|
|
||||||
@return @c stdout of the called program
|
|
||||||
|
|
||||||
@throw ExecutionFailedExc in case of any failure or if the
|
|
||||||
executed program does not return a zero exit status.
|
|
||||||
*/
|
|
||||||
std::string& result() throw(mrw::exception);
|
|
||||||
|
|
||||||
/** @brief Executes the command if not done, returns @c stderr as string
|
|
||||||
|
|
||||||
If the command has not yet been executed successfully, it is
|
|
||||||
first executed, then the @c stderr error output of the called
|
|
||||||
program is returned.
|
|
||||||
|
|
||||||
@return @c stderr of the called program
|
|
||||||
|
|
||||||
@throw ExecutionFailedExc in case of any failure or if the
|
|
||||||
executed program does not return a zero exit status.
|
|
||||||
*/
|
|
||||||
std::string& error() throw(mrw::exception);
|
|
||||||
|
|
||||||
/** @return
|
|
||||||
- @c true if the last execution was successful
|
|
||||||
- @c false if the last execution failed or the command was
|
|
||||||
never executed
|
|
||||||
*/
|
|
||||||
bool success() throw(std::bad_exception);
|
|
||||||
|
|
||||||
private:
|
|
||||||
Exec(); // no default constructor
|
|
||||||
mrw::Cmd* _cmd;
|
|
||||||
std::string _res, _err;
|
|
||||||
bool _success;
|
|
||||||
};
|
|
||||||
|
|
||||||
/** @brief A system command to be executed
|
|
||||||
|
|
||||||
This class is used in conjunction with mrw::Exec. It mus be
|
|
||||||
initialized with the command name, then the command parameters
|
|
||||||
are appended either with commas, or by streaming them into the
|
|
||||||
command, whatever you like.
|
|
||||||
|
|
||||||
You can stream the data into the class:
|
|
||||||
|
|
||||||
@code
|
|
||||||
mrw::Cmd ls("/bin/ls"); // the command to execute is: /bin/ls
|
|
||||||
ls<<"-l"<<"/tmp"; // the command is now: /bin/ls -l /tmp
|
|
||||||
@endcode
|
|
||||||
|
|
||||||
Or you can setup your command with commas:
|
|
||||||
|
|
||||||
@code
|
|
||||||
mrw::Cmd ls = (mrw::Cmd(/bin/ls), "-l", "/tmp");
|
|
||||||
@endcode
|
|
||||||
*/
|
|
||||||
class Cmd {
|
|
||||||
public:
|
|
||||||
/** @brief Create a command given the name of the executable
|
|
||||||
@param std::string the name of the program to execute (no parameter)
|
|
||||||
@note There is no default constructor. */
|
|
||||||
Cmd(const std::string&) throw(std::bad_exception);
|
|
||||||
|
|
||||||
/** @brief Append a parameter to a command
|
|
||||||
@param std::string a parameter / commandline argument
|
|
||||||
to append to the command */
|
|
||||||
Cmd& operator,(const std::string&) throw(std::bad_exception);
|
|
||||||
|
|
||||||
/** @brief Append a parameter to a command
|
|
||||||
@param std::string a parameter / commandline argument
|
|
||||||
to append to the command */
|
|
||||||
Cmd& operator<<(const std::string&) throw(std::bad_exception);
|
|
||||||
|
|
||||||
/** @return the command including parameter */
|
|
||||||
operator std::string() const throw(std::bad_exception);
|
|
||||||
|
|
||||||
/** @return a mrw::Exec that's constructed with this class */
|
|
||||||
operator Exec() const throw(std::bad_exception);
|
|
||||||
|
|
||||||
/** @brief Create a mrw::Exec and execute the command
|
|
||||||
|
|
||||||
Creates a mrw::Exec, executes the command, passes the flag to
|
|
||||||
mrw::Exec::execute() and returns the created mrw::Exec. The
|
|
||||||
result of the execution can be retrieved through the returned
|
|
||||||
mrw::Exec object: The methods mrw::Exec::success(),
|
|
||||||
mrw::Exec::result() and mrw::Exec::error() provide the
|
|
||||||
necessary information.
|
|
||||||
|
|
||||||
@param bool
|
|
||||||
- @c true throw an exception if return status is not zero
|
|
||||||
- @c false throw only an exception in case of a fatal error
|
|
||||||
|
|
||||||
@return the mrw::Exec that has executed the command
|
|
||||||
|
|
||||||
@throw ExecutionFailedExc is thrown if
|
|
||||||
- fork fails
|
|
||||||
- creation or setup of pipes failed
|
|
||||||
- if given parameter is @c true (the default) also if the
|
|
||||||
executed program terminates with an error
|
|
||||||
*/
|
|
||||||
Exec execute(bool=true) const throw(mrw::exception);
|
|
||||||
|
|
||||||
private:
|
|
||||||
friend class Exec; // is allowed to call path() and args()
|
|
||||||
Cmd(); // no default constructor
|
|
||||||
const char* path() const throw(std::bad_exception);
|
|
||||||
char** args() const throw(std::bad_exception);
|
|
||||||
typedef std::list<std::string> ArgList;
|
|
||||||
ArgList _cmd;
|
|
||||||
};
|
|
||||||
//@}
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
@@ -1,22 +0,0 @@
|
|||||||
#include <mrw/exec.hpp>
|
|
||||||
#include <mrw/stacktrace.hpp>
|
|
||||||
#include <iostream>
|
|
||||||
|
|
||||||
int main() {
|
|
||||||
// std::cout<<"RESULT: "
|
|
||||||
// <<(mrw::Cmd("/bin/ls"), "-l", "/tmp").execute().result()
|
|
||||||
// <<std::endl;
|
|
||||||
try {
|
|
||||||
std::cout<<"RESULT: "
|
|
||||||
<<(mrw::Cmd("/bin/false")).execute().result()
|
|
||||||
<<std::endl;
|
|
||||||
} catch (const mrw::exception &x) {
|
|
||||||
mrw::StackTrace::createSymtable();
|
|
||||||
std::cout<<"EXCEPTION: ----------------------------------------"<<std::endl
|
|
||||||
<<"---------- Reason:"<<std::endl
|
|
||||||
<<x.what()<<std::endl
|
|
||||||
<<"---------- Stack:"<<std::endl
|
|
||||||
<<x.stacktrace()<<std::endl
|
|
||||||
<<"---------------------------------------------------"<<std::endl;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -1,18 +0,0 @@
|
|||||||
EXTRA_DIST = doc examples
|
|
||||||
CLEANFILES = doxygen.err
|
|
||||||
|
|
||||||
lib_LTLIBRARIES = libmrw.la libautostacktracestderr.la
|
|
||||||
|
|
||||||
libmrw_la_SOURCES = mrw.hpp \
|
|
||||||
auto.hpp auto.cpp unistd.hpp \
|
|
||||||
stacktrace.hpp stacktrace.cpp exception.hpp \
|
|
||||||
exec.hpp exec.cpp
|
|
||||||
libmrw_la_LDFLAGS = -version-info @MAJOR@:@MINOR@:@SUPPORT@
|
|
||||||
|
|
||||||
libautostacktracestderr_la_SOURCES = autostacktracestderr.cpp
|
|
||||||
libautostacktracestderr_la_LDFLAGS = -version-info @MAJOR@:@MINOR@:@SUPPORT@
|
|
||||||
|
|
||||||
|
|
||||||
doc: doc/html/index.html
|
|
||||||
doc/html/index.html: doxyfile *.[ch]pp
|
|
||||||
doxygen doxyfile
|
|
||||||
41
mrw/mrw.hpp
41
mrw/mrw.hpp
@@ -1,41 +0,0 @@
|
|||||||
/** @mainpage
|
|
||||||
|
|
||||||
@section license License and Copyright
|
|
||||||
|
|
||||||
- All files are under GNU LGPL license.
|
|
||||||
- All files are copyrighted by Marc Wäckerlin.
|
|
||||||
- There is no warranty.
|
|
||||||
- For details, read the file LICENSE in your distribution.
|
|
||||||
|
|
||||||
@section intro Introduction
|
|
||||||
|
|
||||||
This library cares a about:
|
|
||||||
- resource management
|
|
||||||
- execution of UNIX sub processes
|
|
||||||
- stack trace
|
|
||||||
- exception handling
|
|
||||||
|
|
||||||
For details, see the modules page.
|
|
||||||
|
|
||||||
@section link Compile and Link Options
|
|
||||||
|
|
||||||
To be able to get the source file name / line number
|
|
||||||
information in stack trace, you need the debug information compile
|
|
||||||
option @c -g. For compilation on Solaris, you may need the option
|
|
||||||
@c -D__solaris__. You must link to the MRW C++ Library. For this
|
|
||||||
you need the link option @c -lmrw.
|
|
||||||
|
|
||||||
@section download Download and Installation
|
|
||||||
|
|
||||||
Download the latest version from:
|
|
||||||
- http://marc.waeckerlin.org/c++/libmrw
|
|
||||||
|
|
||||||
Install it with:
|
|
||||||
|
|
||||||
@verbatim
|
|
||||||
tar xzvf mrw-c++-<VERSION>.tar.gz
|
|
||||||
cd mrw-c++-<VERSION>
|
|
||||||
./configure
|
|
||||||
make all check install
|
|
||||||
@endverbatim
|
|
||||||
*/
|
|
||||||
@@ -1,189 +0,0 @@
|
|||||||
#include <mrw/stacktrace.hpp>
|
|
||||||
#include <sstream>
|
|
||||||
#include <unistd.h>
|
|
||||||
#include <sys/types.h>
|
|
||||||
#include <sys/stat.h>
|
|
||||||
#include <sys/mman.h>
|
|
||||||
#include <fcntl.h>
|
|
||||||
#include <assert.h>
|
|
||||||
#include <math.h>
|
|
||||||
#include <algorithm>
|
|
||||||
#include <list>
|
|
||||||
#if defined(__solaris__)
|
|
||||||
#include <sys/old_procfs.h>
|
|
||||||
#endif
|
|
||||||
#if defined (__GLIBC__)
|
|
||||||
#include <execinfo.h>
|
|
||||||
#endif
|
|
||||||
#include <bfd.h>
|
|
||||||
extern "C" {
|
|
||||||
#include <demangle.h>
|
|
||||||
}
|
|
||||||
#include <iomanip>
|
|
||||||
|
|
||||||
namespace mrw {
|
|
||||||
|
|
||||||
//----------------------------------------------------------------------------
|
|
||||||
std::string demangle(bfd* abfd, const char* name) {
|
|
||||||
if (bfd_get_symbol_leading_char(abfd) == name[0]) ++name;
|
|
||||||
|
|
||||||
/* This is a hack for better error reporting on XCOFF, PowerPC64-ELF
|
|
||||||
or the MS PE format. These formats have a number of leading '.'s
|
|
||||||
on at least some symbols, so we remove all dots to avoid
|
|
||||||
confusing the demangler. */
|
|
||||||
const char* p (name);
|
|
||||||
while (p && *p == '.') ++p;
|
|
||||||
|
|
||||||
mrw::AutoFree<char> res(cplus_demangle(p, DMGL_ANSI | DMGL_PARAMS));
|
|
||||||
if (res) {
|
|
||||||
/* Now put back any stripped dots. */
|
|
||||||
if (p==name) return (char*)res;
|
|
||||||
std::string add_dots('.', p-name);
|
|
||||||
return add_dots+=(char*)res;
|
|
||||||
}
|
|
||||||
return name;
|
|
||||||
}
|
|
||||||
|
|
||||||
//----------------------------------------------------------------------------
|
|
||||||
StackTrace::StackTrace() throw(std::bad_exception) {
|
|
||||||
// maximum trace level is limited here to 50, see below why
|
|
||||||
# if defined(__GLIBC__)
|
|
||||||
{
|
|
||||||
const int TRACE_LEVEL(50);
|
|
||||||
void* ba[TRACE_LEVEL];
|
|
||||||
for (int n(backtrace(ba, TRACE_LEVEL)), i(0); i<n; ++i)
|
|
||||||
_trace.push_back(ba[i]);
|
|
||||||
}
|
|
||||||
# elif defined(__GNUG__)
|
|
||||||
{
|
|
||||||
# define push(i) \
|
|
||||||
(__builtin_return_address(i) ? \
|
|
||||||
(_trace.push_back(__builtin_return_address(i)), true) : false)
|
|
||||||
push(0) && push(1) && push(2) && push(3) && push(4) && push(5) &&
|
|
||||||
push(6) && push(7) && push(8) && push(9) && push(10) && push(11) &&
|
|
||||||
push(12) && push(13) && push(14) && push(15) && push(16) && push(17)
|
|
||||||
&& push(18) && push(19) && push(20) && push(21) && push(22) &&
|
|
||||||
push(23) && push(24) && push(25) && push(26) && push(27) && push(28)
|
|
||||||
&& push(29) && push(30) && push(31) && push(32) && push(33) &&
|
|
||||||
push(34) && push(35) && push(36) && push(37) && push(38) && push(39)
|
|
||||||
&& push(40) && push(41) && push(42) && push(43) && push(44) &&
|
|
||||||
push(45) && push(46) && push(47) && push(48) && push(49);
|
|
||||||
# undef push
|
|
||||||
}
|
|
||||||
# else
|
|
||||||
# warning "You need GNU gcc or GNU glibc to be able to use mrw::StackTrace"
|
|
||||||
# endif
|
|
||||||
}
|
|
||||||
|
|
||||||
//----------------------------------------------------------------------------
|
|
||||||
StackTrace::operator std::string() const throw(std::bad_exception) {
|
|
||||||
static const double LN10(log(10));
|
|
||||||
std::stringstream s;
|
|
||||||
bool first(true);
|
|
||||||
unsigned int lisz(0), fisz(0);
|
|
||||||
std::list<CodePos> l;
|
|
||||||
for (AddressTrace::const_reverse_iterator it(_trace.rbegin());
|
|
||||||
it!=_trace.rend(); ++it, first=false) {
|
|
||||||
CodePos c(translate(*it));
|
|
||||||
if (log(c.line+1)/LN10 > lisz) lisz = (unsigned int)(log(c.line+1)/LN10);
|
|
||||||
if (c.file.size() > fisz) fisz = c.file.size();
|
|
||||||
l.push_back(c);
|
|
||||||
}
|
|
||||||
for (std::list<CodePos>::iterator it(l.begin()); it!=l.end(); ++it)
|
|
||||||
s<<"["<<it->address<<"] "
|
|
||||||
<<it->file<<':'<<it->line
|
|
||||||
<<std::setw(fisz+lisz-it->file.size()-
|
|
||||||
(unsigned int)(log(it->line+1)/LN10)-1)
|
|
||||||
<<" "<<it->function<<std::endl;
|
|
||||||
return s.str();
|
|
||||||
}
|
|
||||||
|
|
||||||
//----------------------------------------------------------------------------
|
|
||||||
const StackTrace& StackTrace::print(std::ostream& os) const
|
|
||||||
throw(std::bad_exception) {
|
|
||||||
os<<(std::string)*this;
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
|
|
||||||
//----------------------------------------------------------------------------
|
|
||||||
StackTrace::CodePos StackTrace::translate(void* addr)
|
|
||||||
throw(std::bad_exception) {
|
|
||||||
assert(sizeof(bfd_vma)>=sizeof(void*));
|
|
||||||
bfd_vma vma_addr(reinterpret_cast<bfd_vma>(addr));
|
|
||||||
if (!_dic.get()) return CodePos(addr, "????", "????", 0);
|
|
||||||
std::vector<Translator::key_type>::iterator
|
|
||||||
it(std::lower_bound(_addrs.begin(), _addrs.end(), vma_addr));
|
|
||||||
if (it--==_addrs.begin() || *it > vma_addr ||
|
|
||||||
(*_dic)[*it].first <= vma_addr) return CodePos(addr, "????", "????", 0);
|
|
||||||
static const char* file(0);
|
|
||||||
static const char* function(0);
|
|
||||||
unsigned int line;
|
|
||||||
if (!bfd_find_nearest_line(_bfd, (*_dic)[*it].second, _syms.get(),
|
|
||||||
vma_addr-*it, &file, &function, &line))
|
|
||||||
return CodePos(addr, "????", "????", 0);
|
|
||||||
return CodePos(addr, mrw::demangle(_bfd, function), file?file:"????", line);
|
|
||||||
}
|
|
||||||
|
|
||||||
//----------------------------------------------------------------------------
|
|
||||||
bool StackTrace::createSymtable(std::string fname) throw(std::bad_exception) {
|
|
||||||
if (_dic.get()) return true;
|
|
||||||
AutoBfd abfd(bfd_openr((fname!="" ? fname : filename()).c_str(), 0));
|
|
||||||
long memsz(-1);
|
|
||||||
AutoFree<char*> m(0);
|
|
||||||
if (!abfd || bfd_check_format(abfd, bfd_archive) ||
|
|
||||||
!bfd_check_format_matches(abfd, bfd_object, m) ||
|
|
||||||
!(bfd_get_file_flags(abfd)&HAS_SYMS) ||
|
|
||||||
(memsz=bfd_get_symtab_upper_bound(abfd))<0) return false;
|
|
||||||
std::auto_ptr<asymbol*> syms(new asymbol*[memsz]);
|
|
||||||
if (bfd_canonicalize_symtab(abfd, syms.get())<0) return false;
|
|
||||||
_bfd = abfd;
|
|
||||||
_syms = syms;
|
|
||||||
_dic = std::auto_ptr<Translator>(new Translator());
|
|
||||||
bfd_map_over_sections(_bfd, buildSectionMap, 0);
|
|
||||||
std::sort(_addrs.begin(), _addrs.end());
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
//----------------------------------------------------------------------------
|
|
||||||
std::string StackTrace::filename() throw(std::bad_exception) {
|
|
||||||
std::stringstream s;
|
|
||||||
s<<"/proc/"<<getpid();
|
|
||||||
# if defined(__solaris__)
|
|
||||||
{
|
|
||||||
std::string res;
|
|
||||||
AutoFile fd(open(s.str().c_str(), O_RDONLY));
|
|
||||||
prpsinfo_t status;
|
|
||||||
if (fd==-1 || ioctl(fd, PIOCPSINFO, &status)==-1) return res;
|
|
||||||
res = status.pr_psargs;
|
|
||||||
res = res.substr(0, res.find(' '));
|
|
||||||
return res;
|
|
||||||
}
|
|
||||||
# elif defined(__linux__)
|
|
||||||
{
|
|
||||||
s<<"/exe";
|
|
||||||
return s.str();
|
|
||||||
}
|
|
||||||
# else
|
|
||||||
# warning "Don't know how to get executable file name in your system!"
|
|
||||||
# warning "Impossible to get function names in stack trace!"
|
|
||||||
# warning "Give the path to the executable to StackTrace::createSymtable!"
|
|
||||||
# endif
|
|
||||||
}
|
|
||||||
|
|
||||||
//----------------------------------------------------------------------------
|
|
||||||
void StackTrace::buildSectionMap(bfd* abfd, asection* section, void*)
|
|
||||||
throw(std::bad_exception) {
|
|
||||||
if (!(bfd_get_section_flags(abfd, section)&SEC_ALLOC)) return;
|
|
||||||
bfd_vma vma(bfd_get_section_vma(abfd, section));
|
|
||||||
bfd_size_type sz(bfd_get_section_size_before_reloc(section));
|
|
||||||
(*_dic)[vma] = Translator::mapped_type(vma+sz, section);
|
|
||||||
_addrs.push_back(vma);
|
|
||||||
}
|
|
||||||
|
|
||||||
//----------------------------------------------------------------------------
|
|
||||||
std::auto_ptr<StackTrace::Translator> StackTrace::_dic;
|
|
||||||
std::vector<StackTrace::Translator::key_type> StackTrace::_addrs;
|
|
||||||
AutoBfd StackTrace::_bfd;
|
|
||||||
std::auto_ptr<asymbol*> StackTrace::_syms;
|
|
||||||
|
|
||||||
}
|
|
||||||
@@ -1,158 +0,0 @@
|
|||||||
// g++ -Wall -D__SOLARIS__ -g -I /home/public/freeware/include -L /home/public/freeware/lib -I . stacktrace.cxx -lbfd -liberty
|
|
||||||
#ifndef __MRW_STACKTRACE_HPP__
|
|
||||||
#define __MRW_STACKTRACE_HPP__
|
|
||||||
#include <mrw/auto.hpp>
|
|
||||||
#include <vector>
|
|
||||||
#include <map>
|
|
||||||
#include <string>
|
|
||||||
#include <memory>
|
|
||||||
#include <sys/mman.h>
|
|
||||||
#include <bfd.h>
|
|
||||||
|
|
||||||
#ifdef __REENTRANT
|
|
||||||
#warning "mrw::StackTrace is not thread safe yet!"
|
|
||||||
#warning "It should work, but is at least untested..."
|
|
||||||
#endif
|
|
||||||
|
|
||||||
namespace mrw {
|
|
||||||
|
|
||||||
/** @defgroup StackTrace Collect and Format a Stack Trace
|
|
||||||
|
|
||||||
Somewhere in a program, there is a fatal error, e.g. an
|
|
||||||
unexpected exception is thrown. How is it possible to debug the
|
|
||||||
problem in such a case? Sometimes you can start a debugger and
|
|
||||||
trace the execution of your program. But what if it occurs only
|
|
||||||
once a week, or if you cannot set a breakpoint, because you
|
|
||||||
don't know where the problem is located, or because only the
|
|
||||||
1000th run of a method causes a problem, or what if the problem
|
|
||||||
occurs only at your customers installation?
|
|
||||||
|
|
||||||
One way to solve these problems is to do logging, or even
|
|
||||||
function tracing, so you can narrow down the lines of code,
|
|
||||||
where the problem occurs. But sometimes this is not enough,
|
|
||||||
especially with exceptions. One of the worst things with
|
|
||||||
exceptions is, you can catch an exception somewhere, but you
|
|
||||||
don't know where it was thrown. Here it is very handy, to be
|
|
||||||
able to write a stacktrace to a logging device.
|
|
||||||
|
|
||||||
For logging, I recommend log4cxx on page:
|
|
||||||
- http://logging.apache.org/log4cxx
|
|
||||||
|
|
||||||
These classes are for collecting a stack trace and later for
|
|
||||||
formatting with source code file name, line number and the
|
|
||||||
method name.
|
|
||||||
|
|
||||||
For collecting the stack trace (the addresses):
|
|
||||||
- either the GNU gcc compiler is required
|
|
||||||
- or the GNU glibc library function @c backtrace
|
|
||||||
|
|
||||||
For extracting information from an address, the ELF library is required.
|
|
||||||
|
|
||||||
@note For all features and full operation, this class requires:
|
|
||||||
- either a GNU glibc bases system (LINUX), or the GNU gcc compiler
|
|
||||||
- a system with ELF binaries (LINUX, Solaris, ...)
|
|
||||||
- debug information, compile option @c -g
|
|
||||||
- it must be linked with @c -libery and @c -lbfd
|
|
||||||
*/
|
|
||||||
//@{
|
|
||||||
|
|
||||||
/** @brief store and print a stack trace of the actual position in code
|
|
||||||
|
|
||||||
In the constructor, a stack trace is stored, but not yet
|
|
||||||
evaluated. Therefore storing a stack trace is relatively
|
|
||||||
fast. The evaluation is done when the stack trace is printed on
|
|
||||||
a stream or converted to a string. "Evaluation" means, that the
|
|
||||||
addresses are mapped to the correspoding symbols, the method
|
|
||||||
names, sorce file names and line numbers are evaluated.
|
|
||||||
|
|
||||||
@note Method StackTrace::createSymtable must be called exactely
|
|
||||||
once, before evaluating the first stack trace.Best place is the
|
|
||||||
first line of the @c main function.
|
|
||||||
|
|
||||||
@note This class requires libbfd an libiberty. Debug information
|
|
||||||
is required for compiling. You nee the compile option @c -g, or
|
|
||||||
even better @c -ggdb3. To link, you need @c -lmrw, @c -lbfd and
|
|
||||||
@c -liberty.
|
|
||||||
|
|
||||||
@note The stack trace is known to work perfectly on Linux and
|
|
||||||
Solaris both with GNU gcc compiler. But it should work with the
|
|
||||||
GNU compiler on all systems, or wherever there is a glibc
|
|
||||||
library.
|
|
||||||
|
|
||||||
@note Symbol evaluation requires the ELF library and an ELF system.
|
|
||||||
*/
|
|
||||||
class StackTrace {
|
|
||||||
public:
|
|
||||||
//............................................................... typedefs
|
|
||||||
typedef std::vector<void*> AddressTrace; ///< container for the adresses
|
|
||||||
/// structure to store all evaluated information
|
|
||||||
struct CodePos {
|
|
||||||
CodePos(void* a, std::string fn, std::string fi, unsigned int l)
|
|
||||||
throw(std::bad_exception):
|
|
||||||
address(a), function(fn), file(fi), line(l) {
|
|
||||||
}
|
|
||||||
void* address; ///< the address pointer
|
|
||||||
std::string function; ///< function/method name
|
|
||||||
std::string file; ///< code file name
|
|
||||||
unsigned int line; ///< code line number
|
|
||||||
};
|
|
||||||
//................................................................ methods
|
|
||||||
/// the constructor stores the actual stack trace
|
|
||||||
StackTrace() throw(std::bad_exception);
|
|
||||||
/// evaluates the symbol table and returns the formatted stack trace
|
|
||||||
operator std::string() const throw(std::bad_exception);
|
|
||||||
/// @return list of raw stack addresses
|
|
||||||
operator const AddressTrace&() const throw(std::bad_exception) {
|
|
||||||
return _trace;
|
|
||||||
}
|
|
||||||
/// evaluate the stack trace and print it to a stream
|
|
||||||
const StackTrace& print(std::ostream& os) const throw(std::bad_exception);
|
|
||||||
/// evaluates and returns all information from a raw address
|
|
||||||
static CodePos translate(void* addr) throw(std::bad_exception);
|
|
||||||
|
|
||||||
/** @brief read the symbol table from the executable file
|
|
||||||
|
|
||||||
@param std::string The file name of the executable. On Linux
|
|
||||||
and Solaris, this can be evaluated automatically, so the
|
|
||||||
parameter is optional.
|
|
||||||
|
|
||||||
@return @c true in case of success. If @c false is returned,
|
|
||||||
the symbol table was not read and the evaluation cannot be
|
|
||||||
done. Printing then only prints the raw addresses, without
|
|
||||||
file, line nmber information and method names.
|
|
||||||
|
|
||||||
@note This method must be executed once before a stack trace
|
|
||||||
is printed the very first time. For storing a stack trace
|
|
||||||
(that means for the creation of a mrw::StackTrace object) a
|
|
||||||
call to this method is not yet needed.
|
|
||||||
|
|
||||||
@note If this method is called more than once, the symbols
|
|
||||||
are created only the first time, so you don't loose too much
|
|
||||||
time.
|
|
||||||
*/
|
|
||||||
static bool createSymtable(std::string = "") throw(std::bad_exception);
|
|
||||||
private:
|
|
||||||
//............................................................... typedefs
|
|
||||||
typedef std::map<bfd_vma, std::pair<bfd_vma, asection*> >
|
|
||||||
Translator;
|
|
||||||
//.............................................................. variables
|
|
||||||
AddressTrace _trace;
|
|
||||||
static std::auto_ptr<Translator> _dic;
|
|
||||||
static std::vector<Translator::key_type> _addrs;
|
|
||||||
static AutoBfd _bfd;
|
|
||||||
static std::auto_ptr<asymbol*> _syms;
|
|
||||||
//................................................................ methods
|
|
||||||
static std::string filename() throw(std::bad_exception);
|
|
||||||
static void buildSectionMap(bfd*, asection*, void*)
|
|
||||||
throw(std::bad_exception);
|
|
||||||
};
|
|
||||||
|
|
||||||
/// evaluate a stack trace and shift it on a stream
|
|
||||||
inline std::ostream& operator<<(std::ostream& os, const StackTrace& st)
|
|
||||||
throw(std::bad_exception) {
|
|
||||||
return os<<(std::string)st;
|
|
||||||
}
|
|
||||||
|
|
||||||
//@}
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
@@ -1,32 +0,0 @@
|
|||||||
#include <mrw/stacktrace.hpp>
|
|
||||||
#include <cppunit/TestFixture.h>
|
|
||||||
#include <cppunit/ui/text/TestRunner.h>
|
|
||||||
#include <cppunit/extensions/HelperMacros.h>
|
|
||||||
#include <cppunit/extensions/TestFactoryRegistry.h>
|
|
||||||
#include <iostream>
|
|
||||||
|
|
||||||
class StackTraceTest: public CppUnit::TestFixture {
|
|
||||||
public:
|
|
||||||
/// test if symbols are correctely evaluated
|
|
||||||
void StackTrace() {
|
|
||||||
mrw::StackTrace::createSymtable();
|
|
||||||
mrw::StackTrace s; int l(__LINE__); std::string f(__FILE__);
|
|
||||||
std::stringstream ss;
|
|
||||||
ss<<f<<':'<<l;
|
|
||||||
std::string st(s);
|
|
||||||
int pos(st.find(ss.str()));
|
|
||||||
std::cout<<st<<std::endl;
|
|
||||||
CPPUNIT_ASSERT(pos<st.size());
|
|
||||||
CPPUNIT_ASSERT(st.find("mrw::StackTrace::StackTrace()", pos)<st.size());
|
|
||||||
}
|
|
||||||
CPPUNIT_TEST_SUITE(StackTraceTest);
|
|
||||||
CPPUNIT_TEST(StackTrace);
|
|
||||||
CPPUNIT_TEST_SUITE_END();
|
|
||||||
};
|
|
||||||
CPPUNIT_TEST_SUITE_REGISTRATION(StackTraceTest);
|
|
||||||
|
|
||||||
int main() {
|
|
||||||
CppUnit::TextUi::TestRunner runner;
|
|
||||||
runner.addTest(CppUnit::TestFactoryRegistry::getRegistry().makeTest());
|
|
||||||
return runner.run() ? 0 : 1;
|
|
||||||
}
|
|
||||||
@@ -1 +0,0 @@
|
|||||||
Hallo Welt
|
|
||||||
@@ -1,93 +0,0 @@
|
|||||||
#ifndef __MRW_UNISTD_HPP__
|
|
||||||
#define __MRW_UNISTD_HPP__
|
|
||||||
|
|
||||||
#include <unistd.h> // pipe, close
|
|
||||||
#include <errno.h> // errno
|
|
||||||
|
|
||||||
namespace mrw {
|
|
||||||
/** @addtogroup AutoTools */
|
|
||||||
//@{
|
|
||||||
|
|
||||||
/// class that implements an unnamed UNIX pipe
|
|
||||||
/** Implements a UNIX pipe that is automatically closed in
|
|
||||||
destructor and offers some facilities. */
|
|
||||||
class pipe {
|
|
||||||
private:
|
|
||||||
/// the filedescriptor, [0] to read and [1] to write
|
|
||||||
int _fd[2];
|
|
||||||
int _lastError;
|
|
||||||
public:
|
|
||||||
/// creates a unix pipe
|
|
||||||
pipe(): _lastError(-1) {
|
|
||||||
_fd[0] = -1;
|
|
||||||
_fd[1] = -1;
|
|
||||||
if (::pipe(_fd)==-1)
|
|
||||||
{
|
|
||||||
_lastError=errno;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
/// destructor closes pipe if still open
|
|
||||||
~pipe() {
|
|
||||||
close();
|
|
||||||
}
|
|
||||||
/// closes pipe if open
|
|
||||||
void close() {
|
|
||||||
close_in();
|
|
||||||
close_out();
|
|
||||||
}
|
|
||||||
/// closes input pipe if open
|
|
||||||
void close_in() {
|
|
||||||
if (_fd[0]!=-1) while (::close(_fd[0])==-1) if (errno!=EINTR) {
|
|
||||||
_lastError = errno;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
_fd[0] = -1;
|
|
||||||
}
|
|
||||||
/// closes output pipe if open
|
|
||||||
void close_out() {
|
|
||||||
if (_fd[1]!=-1) while (::close(_fd[1])==-1) if (errno!=EINTR) {
|
|
||||||
_lastError = errno;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
_fd[1] = -1;
|
|
||||||
}
|
|
||||||
/// @return true if no error occured
|
|
||||||
operator bool() {
|
|
||||||
return _lastError == -1;
|
|
||||||
}
|
|
||||||
/// @return last error code, -1 if no error
|
|
||||||
int error() {
|
|
||||||
return _lastError;
|
|
||||||
}
|
|
||||||
/// connect output stream to @c stdout
|
|
||||||
void connect_cout() {
|
|
||||||
while (::dup2(_fd[1], 1)==-1) if (errno!=EINTR) {
|
|
||||||
_lastError = errno;
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
/// connect output stream to @c stderr
|
|
||||||
void connect_cerr() {
|
|
||||||
while (::dup2(_fd[1], 2)==-1) if (errno!=EINTR) {
|
|
||||||
_lastError = errno;
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
/// get an input stream
|
|
||||||
/** @return stream to read from
|
|
||||||
@note invalid after destruction or @c close or @c close_in */
|
|
||||||
int istream() {
|
|
||||||
return _fd[0];
|
|
||||||
}
|
|
||||||
/// get an output stream
|
|
||||||
/** @return stream to write to
|
|
||||||
@note invalid after destruction or @c close or @c close_out */
|
|
||||||
int ostream() {
|
|
||||||
return _fd[1];
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
//@}
|
|
||||||
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
Reference in New Issue
Block a user