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 41 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 94 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 13 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 49 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 120 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 40 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 6 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