common/SC_StringBuffer.cpp

   1 // emacs:               -*- c++ -*-
   2 // file:                SC_StringBuffer.cpp
   3 // copyright:   2003 stefan kersten <steve@k-hornz.de>
   4 // cvs:                 $Id$
   5
   6 // This program is free software; you can redistribute it and/or
   7 // modify it under the terms of the GNU General Public License as
   8 // published by the Free Software Foundation; either version 2 of the
   9 // License, or (at your option) any later version.
  10 //
  11 // This program is distributed in the hope that it will be useful, but
  12 // WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software
  18 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
  19 // USA
  20
  21 #include "SC_StringBuffer.h"
  22 #include <assert.h>
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <stdexcept>
  26
  27 #ifdef _WIN32
  28 # define vsnprintf _vsnprintf
  29 # include <stdio.h>
  30 # include <stdarg.h>
  31 #endif
  32
  33 SC_StringBuffer::SC_StringBuffer(size_t initialSize)
  34         : mCapacity(0), mPtr(0), mData(0)
  35 {
  36         growBy(initialSize);
  37 }
  38
  39 SC_StringBuffer::SC_StringBuffer(const SC_StringBuffer& other)
  40         : mCapacity(0), mPtr(0), mData(0)
  41 {
  42         growBy(other.getSize());
  43         append(other.getData(), other.getSize());
  44 }
  45
  46 SC_StringBuffer::~SC_StringBuffer()
  47 {
  48         free(mData);
  49 }
  50
  51 void SC_StringBuffer::append(const char* src, size_t size)
  52 {
  53         if (size > 0) {
  54                 size_t remaining = getRemaining();
  55                 if (size > remaining) {
  56                         growBy(size - remaining);
  57                 }
  58                 memcpy(mPtr, src, size);
  59                 mPtr += size;
  60         }
  61 }
  62
  63 void SC_StringBuffer::append(char c)
  64 {
  65         append(&c, sizeof(c));
  66 }
  67
  68 void SC_StringBuffer::append(const char* str)
  69 {
  70         append(str, strlen(str));
  71 }
  72
  73 void SC_StringBuffer::vappendf(const char* fmt, va_list ap)
  74 {
  75         va_list ap2;
  76         size_t remaining = getRemaining();
  77
  78         // Calling vsnprintf may invalidate vargs, so keep a copy
  79 #ifdef __va_copy
  80         __va_copy(ap2, ap);
  81 #else
  82         ap2 = ap;
  83 #endif
  84
  85         // NOTE: This only works since glibc 2.0.6!
  86         int size = vsnprintf(mPtr, remaining, fmt, ap);
  87         va_end(ap);
  88
  89         // size returned excludes trailing \0
  90         if (size++ > 0) {
  91                 if ((size_t)size > remaining) {
  92                         growBy(size - remaining);
  93                         vsnprintf(mPtr, size, fmt, ap2);
  94                 }
  95                 mPtr += size-1; // omit trailing \0
  96         }
  97
  98         va_end(ap2);
  99 }
 100
 101 void SC_StringBuffer::appendf(const char* fmt, ...)
 102 {
 103         va_list ap;
 104         va_start(ap, fmt);
 105         vappendf(fmt, ap);
 106         va_end(ap);
 107 }
 108
 109 void SC_StringBuffer::growBy(size_t request)
 110 {
 111         size_t oldSize = getSize();
 112         size_t newCapacity = mCapacity + ((request + (size_t)kGrowAlign) & (size_t)~kGrowMask);
 113
 114 //      fprintf(stderr, "%s: mCapacity %u, request %u, newCapacity %u\n",
 115 //                      __PRETTY_FUNCTION__, mCapacity, request, newCapacity);
 116         assert((newCapacity >= (mCapacity + request)) && ((newCapacity & kGrowMask) == 0));
 117
 118         char* newData = (char*)realloc(mData, newCapacity);
 119         if (newData) {
 120                 mData = newData;
 121                 mCapacity = newCapacity;
 122                 mPtr = mData + oldSize;
 123         } else {
 124                 throw std::runtime_error("SC_StringBuffer: memory allocation failure");
 125         }
 126 }
 127
 128 // EOF