ExceptionBase.cpp

Go to the documentation of this file.

#include "wibmod/WIB1/BUException/ExceptionBase.hh"
 
// Error string for bad allocation of description
static const char descriptionError[] = "Description allocation failed.\n";
 
BUException::exBase::exBase() throw()
  : 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();
}
 
BUException::exBase::~exBase() throw()
{
  if (stackBuffer != NULL)
    free(stackBuffer);
  if (descriptionBuffer != NULL)
    free(descriptionBuffer);
}
 
void
BUException::exBase::Copy(const exBase& rh) throw()
{
  // 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;
}
 
void
BUException::exBase::Append(const char* buffer) throw()
{
  // 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';
}
 
const char*
BUException::exBase::Description() const throw()
{
  if (descriptionBuffer == NULL) // If there was a bad alloc, return an error string
    return descriptionError;
  return descriptionBuffer;
}