BUException::exBase Class Reference

#include <ExceptionBase.hh>

Inheritance diagram for BUException::exBase:

Collaboration diagram for BUException::exBase:

Public Member Functions
virtual	~exBase () throw ()
const char *	StackTrace () const throw ()
void	Append (const char *buffer) throw ()
void	Append (std::string str)
const char *	Description () const throw ()
virtual const char *	what () const throw () =0
pid_t	GetPID ()

Protected Member Functions
	exBase () throw ()
void	Copy (const exBase &rh) throw ()
	exBase (const exBase &rh) throw ()

Private Member Functions
exBase &	operator= (const exBase &rh) throw ()
void	GenerateStackTrace () throw ()
void	AppendStackLine (const char *line) throw ()

Private Attributes
size_t	descriptionSize
size_t	descriptionUsed
char *	descriptionBuffer
size_t	stackSize
size_t	stackUsed
char *	stackBuffer
pid_t	PID

Detailed Description

Definition at line 47 of file ExceptionBase.hh.

Constructor & Destructor Documentation

~exBase()

BUException::exBase::~exBase ( ) throw (  )

virtual

Definition at line 36 of file ExceptionBase.cpp.

{
  if (stackBuffer != NULL)
    free(stackBuffer);
  if (descriptionBuffer != NULL)
    free(descriptionBuffer);
}

exBase() [1/2]

BUException::exBase::exBase ( ) throw (  )

protected

Definition at line 6 of file ExceptionBase.cpp.

  : descriptionSize(255)
  , stackSize(1024)
  , PID(-1)
{
  // Allocate memory (throw if failed)
  stackBuffer = (char*)malloc(stackSize + 1);
  descriptionBuffer = (char*)malloc(descriptionSize + 1);
 
  descriptionUsed = 0;
  stackUsed = 0;
 
  // Null terminate the strings to empty
  // also make the char after the nominal end of string null terminated
  if (descriptionBuffer != NULL) {
    descriptionBuffer[0] = '\0';
    descriptionBuffer[descriptionSize] = '\0';
  } else {
    descriptionSize = 0;
  }
  if (stackBuffer != NULL) {
    stackBuffer[0] = '\0';
    stackBuffer[stackSize] = '\0';
  } else {
    stackSize = 0;
  }
 
  GenerateStackTrace();
}

exBase() [2/2]

BUException::exBase::exBase ( const exBase & rh ) throw (  )

inlineprotected

Definition at line 71 of file ExceptionBase.hh.

{(void) rh;}; // have to cast to void to keep from unused param error

Member Function Documentation

Append() [1/2]

void BUException::exBase::Append	(	const char *	buffer	)
throw	(	)

Definition at line 83 of file ExceptionBase.cpp.

{
  // Compute the appended buffer's size
  size_t appendedSize = strlen(buffer);
 
  // Make sure we stay in the bounds of our buffer
  if (appendedSize > (descriptionSize - descriptionUsed)) {
    appendedSize = (descriptionSize - descriptionUsed);
  }
 
  // Append the new string (n keeps us safe from buffer overflow)
  strncpy(descriptionBuffer + descriptionUsed, buffer, appendedSize);
 
  // update the description size
  descriptionUsed += appendedSize;
 
  // enforce the null terminator
  //(the buffer is one larger than the size so we always have space for a NULL)
  // This is untrue if malloc failed initially, so we watch out for that.
  if (descriptionBuffer != NULL)
    descriptionBuffer[descriptionUsed] = '\0';
}

Append() [2/2]

void BUException::exBase::Append ( std::string str )

inline

Definition at line 57 of file ExceptionBase.hh.

{Append(str.c_str());};

AppendStackLine()

void BUException::exBase::AppendStackLine ( const char * line ) throw (  )

private

Definition at line 15 of file ExceptionBase_stacktrace.cpp.

{
  // Check for NULL line
  if (line == NULL)
    return;
 
  // get raw line size
  size_t lineSize = strlen(line);
  if (lineSize >= (stackSize - stackUsed))
    lineSize = stackSize - stackUsed;
  // copy string
  strncpy(stackBuffer + stackUsed, line, lineSize);
  // update size
  stackUsed += lineSize;
  // Add eol
  if ((stackSize - stackUsed) > 1) {
    stackBuffer[stackUsed] = '\n';
    stackUsed++;
  }
  // add null terminator (there is always room for one(unless NULL))
  if (stackBuffer != NULL) {
    stackBuffer[stackUsed] = '\0';
  }
}

Copy()

void BUException::exBase::Copy ( const exBase & rh ) throw (  )

protected

Definition at line 45 of file ExceptionBase.cpp.

{
  // Copy description buffer
  this->descriptionUsed = 0;
  this->descriptionSize = rh.descriptionSize;
  // Check if the allocation had worked for rh
  if (rh.descriptionBuffer == NULL) {
    // It didn't work, make sure our copy is also NULL
    this->descriptionBuffer = NULL;
  } else {
    // rh has a valid description, build ours
    this->descriptionBuffer = (char*)malloc(descriptionSize + 1);
    if (this->descriptionBuffer != NULL) {
      memcpy(this->descriptionBuffer, rh.descriptionBuffer, descriptionSize);
      this->descriptionUsed = rh.descriptionUsed;
    }
  }
 
  // Copy stack trace buffer
  this->stackUsed = 0;
  this->stackSize = rh.stackSize;
  // Check if the allocation worked for rh
  if (rh.stackBuffer == NULL) {
    // It didn't work, make sure our copy is also NULL
    this->stackBuffer = NULL;
  } else { // rh was valid, so construct ours
    this->stackBuffer = (char*)malloc(stackSize + 1);
    if (this->stackBuffer != NULL) {
      memcpy(this->stackBuffer, rh.stackBuffer, stackSize);
      this->stackUsed = rh.stackUsed;
    }
  }
 
  // Copy PID
  this->PID = rh.PID;
}

Description()

const char * BUException::exBase::Description	(		)	const
throw	(	)

Definition at line 107 of file ExceptionBase.cpp.

{
  if (descriptionBuffer == NULL) // If there was a bad alloc, return an error string
    return descriptionError;
  return descriptionBuffer;
}

GenerateStackTrace()

void BUException::exBase::GenerateStackTrace ( ) throw (  )

private

Definition at line 41 of file ExceptionBase_stacktrace.cpp.

{
  // Get the thread/process ID for this stack trace
  PID = syscall(SYS_gettid);
 
  // Get the stack trace (void *s)
  const size_t maxStackSize = 20;
  void* functionStack[maxStackSize];
  size_t stackSize;
 
  // Fill functionStack with void * pointers to return address of the corresponding stack frame
  // filed up to maxStackSize with most recent calls
  stackSize = backtrace(functionStack, maxStackSize);
 
  // Get the stack trace strings  (we have to free this)
  char** functionNames = backtrace_symbols(functionStack, stackSize);
  if (functionNames == NULL) {
    fprintf(stderr, "Error in exBase::GenerateStackTrace(). backtrace_symbols failed\n");
    return;
  }
 
  char* demangledName = NULL;
  // Start stack trace from 3 to skip the exception class's functions
  for (size_t iFunction = 3; iFunction < stackSize; iFunction++) {
    // based off of http://panthema.net/2008/0901-stacktrace-demangled/
    // Be paranoid about these pointers and make sure they are valid
    if (functionNames[iFunction] == NULL) {
      AppendStackLine("Unknown");
      continue;
    }
 
    char* mangledStart = NULL;
    char* offsetStart = NULL;
    char* offsetEnd = NULL;
 
    // Find mangled and offset start/ends
    char* bufferEnd = functionNames[iFunction] + strlen(functionNames[iFunction]);
    for (char* buffer = functionNames[iFunction]; buffer != bufferEnd; buffer++) {
      // Look for function's opening '('
      if (*buffer == '(')
        mangledStart = buffer;
      // Look for offset in function
      else if (*buffer == '+')
        offsetStart = buffer;
      // Look for closing ')', but only if we've found an opening one
      else if ((*buffer == ')') && (offsetStart != NULL)) {
        offsetEnd = buffer;
        break;
      }
    }
 
    // if the parsing makes sense
    if ((mangledStart != NULL) && (offsetStart != NULL) && (offsetEnd != NULL) && (mangledStart < offsetStart)) {
      // Make manglesStart point to the beginning of the name
      mangledStart++;
      // put in a null terminator at offsetStart to end the mangled name
      *offsetStart = '\0';
 
      // Make offset start point to the beginning of the offset
      offsetStart++;
      // put a null terminator at the end of the offset
      *offsetEnd = '\0';
 
      // demangle
      size_t demangledSize = 0;
      int demangledRet = 0;
      char* retName = abi::__cxa_demangle(mangledStart, demangledName, &demangledSize, &demangledRet);
      // Append demangled line
      if ((demangledRet == 0) && (retName != NULL)) {
        // copy possibly reallocated c-string
        demangledName = retName;
        AppendStackLine(demangledName);
      } else // if ther was an error, append the mangled name
      {
        AppendStackLine(mangledStart);
      }
    } else // Bad parse, just print the line
    {
      AppendStackLine(functionNames[iFunction]);
    }
  }
 
  if (demangledName != NULL)
    free(demangledName);
  free(functionNames);
}

GetPID()

pid_t BUException::exBase::GetPID ( )

inline

Definition at line 64 of file ExceptionBase.hh.

{return PID;};

operator=()

exBase & BUException::exBase::operator= ( const exBase & rh ) throw (  )

private

StackTrace()

const char * BUException::exBase::StackTrace	(		)	const
throw	(	)

Definition at line 7 of file ExceptionBase_stacktrace.cpp.

{
  if (stackBuffer == NULL)
    return stackError;
  return stackBuffer;
}

what()

virtual const char * BUException::exBase::what ( ) const throw (  )

pure virtual

Member Data Documentation

descriptionBuffer

char* BUException::exBase::descriptionBuffer

private

Definition at line 84 of file ExceptionBase.hh.

descriptionSize

size_t BUException::exBase::descriptionSize

private

Definition at line 82 of file ExceptionBase.hh.

descriptionUsed

size_t BUException::exBase::descriptionUsed

private

Definition at line 83 of file ExceptionBase.hh.

PID

pid_t BUException::exBase::PID

private

Definition at line 91 of file ExceptionBase.hh.

stackBuffer

char* BUException::exBase::stackBuffer

private

Definition at line 89 of file ExceptionBase.hh.

stackSize

size_t BUException::exBase::stackSize

private

Definition at line 87 of file ExceptionBase.hh.

stackUsed

size_t BUException::exBase::stackUsed

private

Definition at line 88 of file ExceptionBase.hh.

---

The documentation for this class was generated from the following files:

• /github/workspace/dunedaq/sourcecode/wibmod/src/wibmod/WIB1/BUException/ExceptionBase.hh
• /github/workspace/dunedaq/sourcecode/wibmod/src/WIB1/BUException/ExceptionBase.cpp
• /github/workspace/dunedaq/sourcecode/wibmod/src/WIB1/BUException/ExceptionBase_stacktrace.cpp