---

CTBcstringBase.cxx

Go to the documentation of this file.

/*----------------------------------------------------------------------------*/
/* C Tool Box: Designed and implemented by:                                   */
/*    Walter F.J. Mueller   Gesellschaft fuer Schwerionenforschung (GSI)      */
/*                          Planckstrasse 1, D-64291 Darmstadt, Germany       */
/*                  Email:  W.F.J.Mueller@gsi.de                              */
/*                  WWW:    http://www-kp3.gsi.de/www/kp3/people/mueller.html */
/*------------------------------------------+---------------------------------*/

#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <float.h>

#include "CTB.hxx"
#include "CTB_Trace.hxx"
#include "CTBcstringBase.hxx"
#include "CTBnum.hxx"

//------------------------------------------+-----------------------------------

void CTBcstringBase::Copy(char* c_dst, CTBint i_size,
                          const char* c_src)
{
  CTB_Trace("CTBcstringBase::Copy(char*,CTBint,const char*)");

  if (c_src) {
    strncpy(c_dst,c_src,i_size-1);
    c_dst[i_size-1] = 0;
  } else {
    c_dst[0] = 0;
  }
  return;
}

//------------------------------------------+-----------------------------------

void CTBcstringBase::Copy(char* c_dst, CTBint i_size,
                          const char* c_src, CTBint i_offset, CTBint i_length)
{
  CTB_Trace("CTBcstringBase::Copy(char*,CTBint,const char*,CTBint,CTBint)");

  if (c_src) {
    CTBint i_lsrc = CTBmin(i_length,i_size-1);
    strncpy(c_dst,c_src+i_offset,i_lsrc);
    c_dst[i_lsrc] = 0;
  } else {
    c_dst[0] = 0;
  }
  return;
}

//------------------------------------------+-----------------------------------

void CTBcstringBase::Append(char* c_dst, CTBint i_size, 
                            const char* c_src)
{
  CTB_Trace("CTBcstringBase::Append(char*,CTBint,const char*)");

  if (c_src) {
    CTBint i_ldst = strlen(c_dst);
    strncpy(c_dst+i_ldst,c_src,i_size-i_ldst-1);
    c_dst[i_size-1] = 0;
  }
  return;
}

//------------------------------------------+-----------------------------------

void CTBcstringBase::Append(char* c_dst, CTBint i_size,
                            const char* c_src, CTBint i_offset, CTBint i_length)
{
  CTB_Trace("CTBcstringBase::Append(char*,CTBint,const char*,CTBint,CTBint)");

  if (c_src) {
    CTBint i_ldst = strlen(c_dst);
    CTBint i_lsrc;

    if (i_length < 0) i_length = strlen(c_src+i_offset);
    i_lsrc = CTBmin(i_size-i_ldst-1,i_length);
    strncpy(c_dst+i_ldst,c_src+i_offset,i_lsrc);
    c_dst[i_ldst+i_lsrc] = 0;
  }
  return;
}

//------------------------------------------+-----------------------------------

void CTBcstringBase::Trim(char* c_dst, CTBint)
                                            // i_size currently not used ...
{
  CTB_Trace("CTBcstringBase::Trim(char*,CTBint)");

  CTBint i_length = strlen(c_dst);
  char*  pc_cur;
  char*  pc_out = c_dst;

  if (i_length == 0) return;                // nothing to do

  pc_cur = c_dst + i_length -1;             // point to last character
  for ( ; i_length > 0; i_length--) {       // drop trailing white space
    if (!isspace(*pc_cur)) break;
    pc_cur--;
  }
  
  pc_cur = c_dst;
  for ( ; i_length > 0; i_length--) {       // drop leading white space
    if (!isspace(*pc_cur)) break;
    pc_cur++;
  }

  // pc_cur now points to the first non white character,
  // i_length holds the length of the trimmed string

  if (pc_cur == c_dst) {                    // no leading, only trailing ws
    c_dst[i_length] = 0;                    // just truncate
  } else {                                  // otherwise shift
    for ( ; i_length > 0; i_length--) *pc_out++ = *pc_cur++;
    *pc_out = 0;
  }

  return;
}

//------------------------------------------+-----------------------------------

void CTBcstringBase::Toupper(char* c_dst, CTBint i_size)
{
  CTB_Trace("CTBcstringBase::Toupper(char*,CTBint)");

  for (CTBint i = 0; i < i_size; i++) {
    char c = c_dst[i];
    if (c == 0) break;
    c_dst[i] = _toupper(c);
  }
  return;
}

//------------------------------------------+-----------------------------------

void CTBcstringBase::Tolower(char* c_dst, CTBint i_size)
{
  CTB_Trace("CTBcstringBase::Tolower(char*,CTBint)");

  for (CTBint i = 0; i < i_size; i++) {
    char c = c_dst[i];
    if (c == 0) break;
    c_dst[i] = _tolower(c);
  }
}

//------------------------------------------+-----------------------------------

static const char* trim_to_buffer(const char* c_src, CTBint i_size,
                                  char* c_buf, CTBint i_bufsize)
{
  if (i_size < 0) return c_src;             // if zero-terminated string

  const char* pc_cur = c_src + i_size -1;   // point to last character

  for ( ; i_size > 0; i_size--) {           // drop trailing white space
    if (!isspace(*pc_cur)) break;
    pc_cur--;
  }
  
  pc_cur = c_src;
  for ( ; i_size > 0; i_size--) {           // drop leading white space
    if (!isspace(*pc_cur)) break;
    pc_cur++;
  }

  // pc_cur now points to the first non white character,
  // i_size holds the length of the trimmed string

  if (i_size >= i_bufsize) return 0;        // indicate string too long

  strncpy(c_buf,pc_cur,i_size);             // copy trimmed string to buffer
  c_buf[i_size] = 0;                        // zero-terminate
  return c_buf;  
}

//------------------------------------------+-----------------------------------

bool CTBcstringBase::Get(const char* c_src, CTBint i_size,
                         long& i_val, int i_base)
{
  CTB_Trace("CTBcstringBase::Get(const char*,CTBint,long&,int)");

  char   c_buf[256];
  char*  pc_end;                            // NOTE: strtol endptr has no const
  char   c;
  long   i_tmp;

  if (c_src == 0 || i_size == 0) {          // null or empty string
    i_val = 0;                              // convert as 0
    return true;
  }

  c_src = trim_to_buffer(c_src,i_size,c_buf,256); // extract substring ...
  if (c_src == 0) return false;             // check for buffer size error

  errno = 0;
  i_tmp = strtol(c_src,&pc_end,i_base);

  if (errno != 0) return false;
  if (pc_end != 0) {                        // if left overs, check them  
    while ((c = *pc_end++)) {               // check rest
      if (!isspace(c)) return false;        // complain on any non white
    }
  }
  
  i_val = i_tmp;                            // if all o.k., assign value
  return true;                              // and return success
}
  
//------------------------------------------+-----------------------------------
 
bool CTBcstringBase::Get(const char* c_src, CTBint i_size,
                         unsigned long& i_val, int i_base)
{
  CTB_Trace("CTBcstringBase::Get(const char*,CTBint,unsigned long&,int)");

  char          c_buf[256];
  char*         pc_end;                     // NOTE: strtol endptr has no const
  char          c;
  unsigned long i_tmp;  

  if (c_src == 0 || i_size == 0) {          // null or empty string
    i_val = 0;                              // convert as 0
    return true;
  }

  c_src = trim_to_buffer(c_src,i_size,c_buf,256); // extract substring ...
  if (c_src == 0) return false;             // check for buffer size error

  errno = 0;
  i_tmp = strtoul(c_src,&pc_end,i_base);

  if (errno != 0) return false;
  if (pc_end != 0) {                        // if left overs, check them  
    while ((c = *pc_end++)) {               // check rest
      if (!isspace(c)) return false;        // complain on any non white
    }
  }
  
  i_val = i_tmp;                            // if all o.k., assign value
  return true;                              // and return success
}
  
//------------------------------------------+-----------------------------------

bool CTBcstringBase::Get(const char* c_src, CTBint i_size,
                         int& i_val, int i_base)
{
  CTB_Trace("CTBcstringBase::Get(const char*,CTBint,int&,int)");

  long i_tmp;

  if (!Get(c_src,i_size,i_tmp,i_base)) return false;

  if (i_tmp < INT_MIN || i_tmp > INT_MAX) return false;
  i_val = i_tmp;                            // if all o.k., assign value
  return true;                              // and return success
}
  
//------------------------------------------+-----------------------------------

bool CTBcstringBase::Get(const char* c_src, CTBint i_size,
                         unsigned int& i_val, int i_base)
{
  CTB_Trace("CTBcstringBase::Get(const char*,CTBint,unsigned int&,int)");

  unsigned long i_tmp;

  if (!Get(c_src,i_size,i_tmp,i_base)) return false;

  if (i_tmp > UINT_MAX) return false;
  i_val = i_tmp;                            // if all o.k., assign value
  return true;                              // and return success
}
  
//------------------------------------------+-----------------------------------

bool CTBcstringBase::Get(const char* c_src, CTBint i_size, double& d_val)
{
  CTB_Trace("CTBcstringBase::Get(const char*,CTBint,double&)");

  char    c_buf[256];
  char*   pc_end;                           // NOTE: strtol endptr has no const
  char    c;
  double  d_tmp;

  if (c_src == 0 || i_size == 0) {          // null or empty string
    d_val = 0.;                             // convert as 0
    return true;
  }

  c_src = trim_to_buffer(c_src,i_size,c_buf,256); // extract substring ...
  if (c_src == 0) return false;             // check for buffer size error

  errno = 0;
  d_tmp = strtod(c_src,&pc_end);

  if (errno != 0) return false;
  if (pc_end != 0) {                        // if left overs, check them  
    while ((c = *pc_end++)) {               // check rest
      if (!isspace(c)) return false;        // complain on any non white
    }
  }
  
  d_val = d_tmp;                            // if all o.k., assign value
  return true;                              // and return success
}
  
//------------------------------------------+-----------------------------------

bool CTBcstringBase::Get(const char* c_src, CTBint i_size, float& f_val)
{
  CTB_Trace("CTBcstringBase::Get(const char*,CTBint,float&)");

  double d_tmp;

  if (!Get(c_src,i_size,d_tmp)) return false;

  if (d_tmp < -FLT_MAX || d_tmp > FLT_MAX) return false;
  f_val = d_tmp;                            // if all o.k., assign value
  return true;                              // and return success
}
  
//------------------------------------------+-----------------------------------

CTBint CTBcstringBase::Locate(const char* c_src, CTBint, char c_char)
                                            // i_size currently not used
{
  CTB_Trace("CTBcstringBase::Locate(const char*,CTBint,char)");

  const char* pc_char = strchr(c_src,c_char);
  if (pc_char) return pc_char - c_src;      // if found, return offset
  return strlen(c_src);                     // else string length
}

//------------------------------------------+-----------------------------------

int CTBcstringBase::NField(const char* c_src, CTBint,
                           const char* c_delim)
                                            // i_size currently not used
{
  CTB_Trace("CTBcstringBase::NField(const char*,CTBint,const char*)");
  int     i_length = strlen(c_src);

  if (i_length == 0) return 0;              // an empty string has 0 fields

  if (!c_delim || c_delim[0] == 0) {        // if c_delim nul or empty
                                            // --> delimiter is any white space
    const char* pc_cur;
    int   i_cnt = 0;

    pc_cur = c_src + i_length -1;
    for ( ; i_length > 0; i_length--) {     // drop trailing white space
      if (!isspace(*pc_cur)) break;
      pc_cur--;
    }
    pc_cur = c_src;
    for ( ; i_length > 0; i_length--) {     // drop leading white space
      if (!isspace(*pc_cur)) break;
      pc_cur++;
    }
  
    if (i_length == 0) return 0;            // quit on blank string

    for ( ; i_length > 0 ; ) {              // loop over fields
      for ( ; i_length > 0; i_length--) {   // skip over one field 
        if (isspace(*pc_cur)) break;
        pc_cur++;
      }
      for ( ; i_length > 0; i_length--) {   // skip over one delimiter
        if (!isspace(*pc_cur)) break;
        pc_cur++;
      }
      i_cnt++;
    }
    return i_cnt;
  }

  if (c_delim[1] == 0) {                    // delimiter is a single character
    const char* pc_cur = c_src;
    int   i_cnt  = 1;
    char  c_del  = c_delim[0];
    for ( ; i_length > 0; i_length--) if (*pc_cur++ == c_del) i_cnt++;
    return i_cnt;
  } else {                                  // delimiter is character set
    const char* pc_cur = c_src;
    int   i_cnt  = 1;
    for ( ; i_length > 0; i_length--) if (InSet(*pc_cur++,c_delim)) i_cnt++;
    return i_cnt;
  }
  return 0;
}

//------------------------------------------+-----------------------------------

bool CTBcstringBase::LocateField( const char* c_src, CTBint,
                                  CTBint& i_foffset, CTBint& i_flength,
                                  CTBint i_ind, const char* c_delim)
                                            // i_size currently not used
{
  CTB_Trace("CTBcstringBase::LocateField(const char*,CTBint,CTBint&,CTBint&,CTBint,const char*)");
  int i_length = strlen(c_src);

  i_foffset  = i_length;                    // init output (in case of bailout)
  i_flength = 0;

  if (i_ind < 0) return false;              // bad index: return w/ no success
  
  if (!c_delim || c_delim[0] == 0) {        // if c_delim null or empty
                                            // than delimiter is any white space
    const char* pc_cur;
    const char* pc_beg;

    pc_cur = c_src + i_length -1;
    for ( ; i_length > 0; i_length--) {     // drop trailing white space
      if (!isspace(*pc_cur)) break;
      pc_cur--;
    }
    pc_cur = c_src;
    for ( ; i_length > 0; i_length--) {     // drop leading white space
      if (!isspace(*pc_cur)) break;
      pc_cur++;
    }
  
    for ( ; ; i_ind--) {                    // loop over fields
      pc_beg = pc_cur;
      for ( ; i_length > 0; i_length--) {   // skip over one field
        if (isspace(*pc_cur)) break;
        pc_cur++;
      }
      if (i_ind == 0) {                     // field found ? 
        i_foffset = pc_beg - c_src;
        i_flength = pc_cur - pc_beg;
        return true;
      }
      if (i_length == 0) return false;      // end of string ?
      for ( ; i_length > 0; i_length--) {   // skip over one delimiter
        if (!isspace(*pc_cur)) break;
        pc_cur++;
      }
    }
  }

  if (c_delim[1] == 0) {                    // delimiter is a single character
    const char*  pc_cur = c_src;
    const char*  pc_beg;
    char   c = c_delim[0];

    for ( ; ; i_ind--) {                    // loop over fields
      pc_beg = pc_cur;
      for ( ; i_length > 0; i_length--) {   // skip over one field
        if (*pc_cur == c) break;
        pc_cur++;
      }
      if (i_ind == 0) {                     // field found ?
        i_foffset = pc_beg - c_src;
        i_flength = pc_cur - pc_beg;
        return true;
      }
      if (i_length == 0) return false;      // end of string ?
      i_length--; pc_cur++;                 //skip over the delimiter char
    }

  } else {                                  // delimiter is character set
    const char* pc_cur = c_src;
    const char* pc_beg;
    for ( ; ; i_ind--) {                    // loop over fields 
      pc_beg = pc_cur;
      for ( ; i_length > 0; i_length--) {   // skip over one field
        if (InSet(*pc_cur,c_delim)) break;
        pc_cur++;
      }
      if (i_ind == 0) {                     // field found ?
        i_foffset = pc_beg - c_src;
        i_flength = pc_cur - pc_beg;
        return true;
      }
      if (i_length == 0) return false;      // end of string ?
      i_length--; pc_cur++;                 // skip over the delimiter chars
    }
  }
  
  return false;
}

//------------------------------------------+-----------------------------------

bool CTBcstringBase::CopyField(char* c_dst, CTBint i_size,
                               const char* c_src, CTBint i_ind,
                               const char* c_delim)
{
  CTB_Trace("CTBcstringBase::CopyField(const char*,CTBint,const char*,CTBint,const char*)");
  CTBint i_foffset;
  CTBint i_flength;
  bool   b_found = LocateField(c_src,-1,i_foffset,i_flength,i_ind,c_delim);

  if (b_found) {
    Copy(c_dst,i_size,c_src,i_foffset,i_flength);
  } else {
    c_dst[0] = 0;
  }
  return b_found;
}

//------------------------------------------+-----------------------------------

bool CTBcstringBase::GetLine(char* c_dst, CTBint i_size, istream& is)
{
  CTB_Trace("CTBcstringBase::GetLine(const char*,CTBint,istream&)");

  if (c_dst == 0 || i_size == 0) return false;  // bad destination ?
  c_dst[0] = 0;                             // clear string
  if (!is) return false;                    // bad stream
  
  is.getline(c_dst,i_size);
  return !is.fail();
}

//------------------------------------------+-----------------------------------

bool CTBcstringBase::FromStream(char* c_dst, CTBint i_size, istream& is)
{
  CTB_Trace("CTBcstringBase::FromStream(const char*,CTBint,istream&)");
  int i_width = is.width();

  if (c_dst == 0 || i_size == 0) return false;  // bad destination ?
  c_dst[0] = 0;                             // clear string
  if (!is) return false;                    // bad stream
  
  if (i_width == 0) {                       // if no width defined
    i_width = i_size;                       // use string size
  } else {
    if (i_width > i_size) i_width = i_size; // else limit to string size
  }
  is >> setw(i_width) >> c_dst;

  return !is.fail();
}
// Note: reading a field larger than the string size does not put the
//       stream into error state !!???

#if (defined(CTB__OutLine) || defined(CTBcstringBase__OutLine))
#define inline
#include "CTBcstringBase.icc"
#undef  inline
#endif

// Notes:
// 1. re-evaluate usage if i_size
// 2. re-check Get
// 3. add Get's for other types
// 4. GET ALL CALLS, especially Copy and Append, protected agains
//    i_offset larger than length (jumping over terminating zero...)
// 5. Check, whether all functions are tolerant against null string args...
//

---