ROOT logo
// @(#)root/base:$Id: TString.cxx 31818 2009-12-10 17:09:55Z rdm $
// Author: Fons Rademakers   04/08/95

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TString                                                              //
//                                                                      //
// Basic string class.                                                  //
//                                                                      //
// Cannot be stored in a TCollection... use TObjString instead.         //
//                                                                      //
// The underlying string is stored as a char* that can be accessed via  //
// TString::Data().                                                     //
// TString provides copy-on-write semantics with reference counting     //
// so that multiple TString objects can refer to the same data.         //
// For example:                                                         //
//   root [0] TString orig("foo")                                       //
//   root [1] TString copy(orig)  // 'orig' and 'copy' point to the     //
//                                // same data...                       //
//   root [2] orig.Data()                                               //
//   (const char* 0x98936f8)"foo"                                       //
//   root [3] copy.Data()                                               //
//   (const char* 0x98936f8)"foo"                                       //
//   root [4] copy="bar"          // Editing 'copy' makes it point      //
//                                // elsewhere
//   (class TString)"bar"                                               //
//   root [5] copy.Data()                                               //
//   (const char* 0x98939b8)"bar"                                       //
//                                                                      //
// Substring operations are provided by the TSubString class, which     //
// holds a reference to the original string and its data, along with    //
// the offset and length of the substring. To retrieve the substring    //
// as a TString, construct a TString from it, eg:                       //
//   root [0] TString s("hello world")                                  //
//   root [1] TString s2( s(0,5) )                                      //
//   root [2] s2                                                        //
//   (class TString)"hello"                                             //
//////////////////////////////////////////////////////////////////////////

#include "RConfig.h"
#include <stdlib.h>
#include <ctype.h>
#include <list>

#include "snprintf.h"
#include "Varargs.h"
#include "TString.h"
#include "TBuffer.h"
#include "TError.h"
#include "Bytes.h"
#include "TClass.h"
#include "TObjArray.h"
#include "TObjString.h"
#include "TVirtualMutex.h"

#ifdef R__GLOBALSTL
namespace std { using ::list; }
#endif

// Mutex for string format protection

TVirtualMutex *gStringMutex = 0;

// Amount to shift hash values to avoid clustering

const UInt_t kHashShift = 5;

// This is the global null string representation, shared among all
// empty strings.  The space for it is in "gNullRef" which the
// loader will set to zero

static long gNullRef[(sizeof(TStringRef)+1)/sizeof(long) + 1];
static void *gNullRefTmp = gNullRef;

// Use macro in stead of the following to side-step compilers (e.g. DEC)
// that generate pre-main code for the initialization of address constants.
// static TStringRef* const gNullStringRef = (TStringRef*)gNullRef;

#define gNullStringRef ((TStringRef*)gNullRefTmp)

// ------------------------------------------------------------------------
//
// In what follows, fCapacity is the length of the underlying representation
// vector. Hence, the capacity for a null terminated string held in this
// vector is fCapacity-1.  The variable fNchars is the length of the held
// string, excluding the terminating null.
//
// The algorithms make no assumptions about whether internal strings
// hold embedded nulls. However, they do assume that any string
// passed in as an argument that does not have a length count is null
// terminated and therefore has no embedded nulls.
//
// The internal string is always null terminated.
//
// ------------------------------------------------------------------------
//
//  This class uses a number of protected and private member functions
//  to do memory management. Here are their semantics:
//
//  TString::Cow();
//    Insure that self is a distinct copy. Preserve previous contents.
//
//  TString::Cow(Ssiz_t nc);
//    Insure that self is a distinct copy with capacity of at
//    least nc. Preserve previous contents.
//
//  TString::Clobber(Ssiz_t nc);
//    Insure that the TStringRef is unshared and has a
//    capacity of at least nc. No need to preserve contents.
//
//  TString::Clone();
//    Make self a distinct copy. Preserve previous contents.
//
//  TString::Clone(Ssiz_t);
//    Make self a distinct copy with capacity of at least nc.
//    Preserve previous contents.
//
// ------------------------------------------------------------------------


//////////////////////////////////////////////////////////////////////////
//                                                                      //
//  TStringRef                                                          //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

//______________________________________________________________________________
TStringRef *TStringRef::GetRep(Ssiz_t capacity, Ssiz_t nchar)
{
   // Static member function returning an empty string representation of
   // size capacity and containing nchar characters.

   if ((capacity | nchar) == 0) {
      gNullStringRef->AddReference();
      return gNullStringRef;
   }
   TStringRef *ret = (TStringRef*)new char[capacity + sizeof(TStringRef) + 1];
   ret->fCapacity = capacity;
   ret->SetRefCount(1);
   ret->Data()[ret->fNchars = nchar] = 0; // Terminating null

   return ret;
}

//______________________________________________________________________________
Ssiz_t TStringRef::First(char c) const
{
   // Find first occurrence of a character c.

   const char *f = strchr(Data(), c);
   return f ? f - Data() : kNPOS;
}

//______________________________________________________________________________
Ssiz_t TStringRef::First(const char *cs) const
{
   // Find first occurrence of a character in cs.

   const char *f = strpbrk(Data(), cs);
   return f ? f - Data() : kNPOS;
}

#ifndef R__BYTESWAP
//______________________________________________________________________________
inline static UInt_t SwapInt(UInt_t x)
{
   return (((x & 0x000000ffU) << 24) | ((x & 0x0000ff00U) <<  8) |
           ((x & 0x00ff0000U) >>  8) | ((x & 0xff000000U) >> 24));
}
#endif

//______________________________________________________________________________
inline static void Mash(UInt_t& hash, UInt_t chars)
{
   // Utility used by Hash().

   hash = (chars ^
         ((hash << kHashShift) |
          (hash >> (kBitsPerByte*sizeof(UInt_t) - kHashShift))));
}

//______________________________________________________________________________
UInt_t Hash(const char *str)
{
   // Return a case-sensitive hash value (endian independent).

   UInt_t len = str ? strlen(str) : 0;
   UInt_t hv  = len; // Mix in the string length.
   UInt_t i   = hv*sizeof(char)/sizeof(UInt_t);

   if (((ULong_t)str)%sizeof(UInt_t) == 0) {
      // str is word aligned
      const UInt_t *p = (const UInt_t*)str;

      while (i--) {
#ifndef R__BYTESWAP
         UInt_t h = *p++;
         Mash(hv, SwapInt(h));
#else
         Mash(hv, *p++);                   // XOR in the characters.
#endif
      }

      // XOR in any remaining characters:
      if ((i = len*sizeof(char)%sizeof(UInt_t)) != 0) {
         UInt_t h = 0;
         const char* c = (const char*)p;
         while (i--)
            h = ((h << kBitsPerByte*sizeof(char)) | *c++);
         Mash(hv, h);
      }
   } else {
      // str is not word aligned
      UInt_t h;
      const unsigned char *p = (const unsigned char*)str;

      while (i--) {
         memcpy(&h, p, sizeof(UInt_t));
#ifndef R__BYTESWAP
         Mash(hv, SwapInt(h));
#else
         Mash(hv, h);
#endif
         p += sizeof(UInt_t);
      }

      // XOR in any remaining characters:
      if ((i = len*sizeof(char)%sizeof(UInt_t)) != 0) {
         h = 0;
         const char* c = (const char*)p;
         while (i--)
            h = ((h << kBitsPerByte*sizeof(char)) | *c++);
         Mash(hv, h);
      }
   }
   return hv;
}

//______________________________________________________________________________
UInt_t TStringRef::Hash() const
{
   // Return a case-sensitive hash value (endian independent).

   UInt_t hv       = (UInt_t)Length(); // Mix in the string length.
   UInt_t i        = hv*sizeof(char)/sizeof(UInt_t);
   const UInt_t *p = (const UInt_t*)Data();
   {
      while (i--) {
#ifndef R__BYTESWAP
         UInt_t h = *p++;
         Mash(hv, SwapInt(h));             // XOR in the characters.
#else
         Mash(hv, *p++);                   // XOR in the characters.
#endif
      }
   }
   // XOR in any remaining characters:
   if ((i = Length()*sizeof(char)%sizeof(UInt_t)) != 0) {
      UInt_t h = 0;
      const char* c = (const char*)p;
      while (i--)
         h = ((h << kBitsPerByte*sizeof(char)) | *c++);
      Mash(hv, h);
   }
   return hv;
}

//______________________________________________________________________________
UInt_t TStringRef::HashFoldCase() const
{
   // Return a case-insensitive hash value (endian independent).

   UInt_t hv = (UInt_t)Length();    // Mix in the string length.
   UInt_t i  = hv;
   const unsigned char *p = (const unsigned char*)Data();
   while (i--) {
      Mash(hv, toupper(*p));
      ++p;
   }
   return hv;
}

//______________________________________________________________________________
Ssiz_t TStringRef::Last(char c) const
{
   // Find last occurrence of a character c.

   const char *f = strrchr(Data(), (unsigned char) c);
   return f ? f - Data() : kNPOS;
}


ClassImp(TString)

//////////////////////////////////////////////////////////////////////////
//                                                                      //
//  TString                                                             //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

// ------------------- The static data members access --------------------------
Ssiz_t  TString::GetInitialCapacity()    { return fgInitialCapac; }
Ssiz_t  TString::GetResizeIncrement()    { return fgResizeInc; }
Ssiz_t  TString::GetMaxWaste()           { return fgFreeboard; }

//______________________________________________________________________________
TString::TString()
{
   // TString default ctor.

   fData = gNullStringRef->Data();
   gNullStringRef->AddReference();
}

//______________________________________________________________________________
TString::TString(Ssiz_t ic)
{
   // Create TString able to contain ic characters.

   fData = TStringRef::GetRep(ic, 0)->Data();
}

//______________________________________________________________________________
TString::TString(const char *cs)
{
   // Create TString and initialize it with string cs.

   if (cs) {
      Ssiz_t n = cs ? strlen(cs) : 0;
      fData = TStringRef::GetRep(n, n)->Data();
      memcpy(fData, cs, n);
   } else
      fData = TStringRef::GetRep(0, 0)->Data();
}

//______________________________________________________________________________
TString::TString(const std::string &s)
{
   // Create TString and initialize it with string cs.

   Ssiz_t n = s.length();
   fData = TStringRef::GetRep(n, n)->Data();
   memcpy(fData, s.c_str(), n);
}

//______________________________________________________________________________
TString::TString(const char *cs, Ssiz_t n)
{
   // Create TString and initialize it with the first n characters of cs.

   fData = TStringRef::GetRep(n, n)->Data();
   memcpy(fData, cs, n);
}

//______________________________________________________________________________
void TString::InitChar(char c)
{
   // Initialize a string with a single character.

   fData = TStringRef::GetRep(GetInitialCapacity(), 1)->Data();
   fData[0] = c;
}

//______________________________________________________________________________
TString::TString(char c, Ssiz_t n)
{
   // Initialize the first n locations of a TString with character c.

   fData = TStringRef::GetRep(n, n)->Data();
   while (n--) fData[n] = c;
}

//______________________________________________________________________________
TString::TString(const TSubString& substr)
{
   // Copy a TSubString in a TString.

   Ssiz_t len = substr.IsNull() ? 0 : substr.Length();
   fData = TStringRef::GetRep(AdjustCapacity(len), len)->Data();
   memcpy(fData, substr.Data(), len);
}

//______________________________________________________________________________
TString::~TString()
{
   // Delete a TString. I.e. decrease its reference count. When 0 free space.

   Pref()->UnLink();
}

//______________________________________________________________________________
TString& TString::operator=(char c)
{
   // Assign character c to TString.

   if (!c) {
      Pref()->UnLink();
      gNullStringRef->AddReference();
      fData = gNullStringRef->Data();
      return *this;
   }
   return Replace(0, Length(), &c, 1);
}

//______________________________________________________________________________
TString& TString::operator=(const char *cs)
{
   // Assign string cs to TString.

   if (!cs || !*cs) {
      Pref()->UnLink();
      gNullStringRef->AddReference();
      fData = gNullStringRef->Data();
      return *this;
   }
   return Replace(0, Length(), cs, strlen(cs));
}

//______________________________________________________________________________
TString& TString::operator=(const std::string &s)
{
   // Assign std::string s to TString.

   if (s.length()==0) {
      Pref()->UnLink();
      gNullStringRef->AddReference();
      fData = gNullStringRef->Data();
      return *this;
   }
   return Replace(0, Length(), s.c_str(), s.length());
}

//______________________________________________________________________________
TString& TString::operator=(const TString &str)
{
   // Assignment operator.

   str.Pref()->AddReference();
   Pref()->UnLink();
   fData = str.fData;
   return *this;
}

//______________________________________________________________________________
TString& TString::operator=(const TSubString &substr)
{
   // Assign a TSubString substr to TString.

   Ssiz_t len = substr.IsNull() ? 0 : substr.Length();
   if (!len) {
      Pref()->UnLink();
      gNullStringRef->AddReference();
      fData = gNullStringRef->Data();
      return *this;
   }
   return Replace(0, Length(), substr.Data(), len);
}

//______________________________________________________________________________
TString& TString::Append(char c, Ssiz_t rep)
{
   // Append character c rep times to string.

   Ssiz_t tot;
   Cow(tot = Length() + rep);
   char* p = fData + Length();
   while (rep--)
      *p++ = c;

   fData[Pref()->fNchars = tot] = '\0';

   return *this;
}

//______________________________________________________________________________
Ssiz_t TString::Capacity(Ssiz_t nc)
{
   // Return string capacity. If nc != current capacity Clone() the string
   // in a string with the desired capacity.

   if (nc > Length() && nc != Capacity())
      Clone(nc);

   return Capacity();
}

//______________________________________________________________________________
int TString::CompareTo(const char *cs2, ECaseCompare cmp) const
{
   // Compare a string to char *cs2.

   if (!cs2) return 1;

   const char *cs1 = Data();
   Ssiz_t len = Length();
   Ssiz_t i = 0;
   if (cmp == kExact) {
      for (; cs2[i]; ++i) {
         if (i == len) return -1;
         if (cs1[i] != cs2[i]) return ((cs1[i] > cs2[i]) ? 1 : -1);
      }
   } else {                  // ignore case
      for (; cs2[i]; ++i) {
         if (i == len) return -1;
         char c1 = tolower((unsigned char)cs1[i]);
         char c2 = tolower((unsigned char)cs2[i]);
         if (c1 != c2) return ((c1 > c2) ? 1 : -1);
      }
   }
   return (i < len) ? 1 : 0;
}

//______________________________________________________________________________
int TString::CompareTo(const TString &str, ECaseCompare cmp) const
{
   // Compare a string to another string.

   const char *s1 = Data();
   const char *s2 = str.Data();
   Ssiz_t len = str.Length();
   if (Length() < len) len = Length();
   if (cmp == kExact) {
      int result = memcmp(s1, s2, len);
      if (result != 0) return result;
   } else {
      Ssiz_t i = 0;
      for (; i < len; ++i) {
         char c1 = tolower((unsigned char)s1[i]);
         char c2 = tolower((unsigned char)s2[i]);
         if (c1 != c2) return ((c1 > c2) ? 1 : -1);
      }
   }
   // strings are equal up to the length of the shorter one.
   if (Length() == str.Length()) return 0;
   return (Length() > str.Length()) ? 1 : -1;
}

//______________________________________________________________________________
Int_t TString::CountChar(Int_t c) const
{
   // Return number of times character c occurs in the string.

   Int_t count = 0;
   Int_t len   = Length();
   for (Int_t n = 0; n < len; n++)
      if (fData[n] == c) count++;

   return count;
}

//______________________________________________________________________________
TString TString::Copy() const
{
   // Copy a string.

   TString temp(*this);          // Has increased reference count
   temp.Clone();                 // Distinct copy
   return temp;
}

//______________________________________________________________________________
UInt_t TString::Hash(ECaseCompare cmp) const
{
   // Return hash value.

   return (cmp == kExact) ? Pref()->Hash() : Pref()->HashFoldCase();
}

//______________________________________________________________________________
UInt_t TString::Hash(const void *txt, Int_t ntxt)
{
   // Calculates hash index from any char string. (static function)
   // Based on precalculated table of 256 specially selected numbers.
   // These numbers are selected in such a way, that for string
   // length == 4 (integer number) the hash is unambigous, i.e.
   // from hash value we can recalculate input (no degeneration).
   //
   // The quality of hash method is good enough, that
   // "random" numbers made as R = Hash(1), Hash(2), ...Hash(N)
   // tested by <R>, <R*R>, <Ri*Ri+1> gives the same result
   // as for libc rand().
   //
   // For string:  i = TString::Hash(string,nstring);
   // For int:     i = TString::Hash(&intword,sizeof(int));
   // For pointer: i = TString::Hash(&pointer,sizeof(void*));
   //
   //              V.Perev

   static const UInt_t utab[] = {
      0xdd367647,0x9caf993f,0x3f3cc5ff,0xfde25082,0x4c764b21,0x89affca7,0x5431965c,0xce22eeec,
      0xc61ab4dc,0x59cc93bd,0xed3107e3,0x0b0a287a,0x4712475a,0xce4a4c71,0x352c8403,0x94cb3cee,
      0xc3ac509b,0x09f827a2,0xce02e37e,0x7b20bbba,0x76adcedc,0x18c52663,0x19f74103,0x6f30e47b,
      0x132ea5a1,0xfdd279e0,0xa3d57d00,0xcff9cb40,0x9617f384,0x6411acfa,0xff908678,0x5c796b2c,
      0x4471b62d,0xd38e3275,0xdb57912d,0x26bf953f,0xfc41b2a5,0xe64bcebd,0x190b7839,0x7e8e6a56,
      0x9ca22311,0xef28aa60,0xe6b9208e,0xd257fb65,0x45781c2c,0x9a558ac3,0x2743e74d,0x839417a8,
      0x06b54d5d,0x1a82bcb4,0x06e97a66,0x70abdd03,0xd163f30d,0x222ed322,0x777bfeda,0xab7a2e83,
      0x8494e0cf,0x2dca2d4f,0x78f94278,0x33f04a09,0x402b6452,0x0cd8b709,0xdb72a39e,0x170e00a2,
      0x26354faa,0x80e57453,0xcfe8d4e1,0x19e45254,0x04c291c3,0xeb503738,0x425af3bc,0x67836f2a,
      0xfac22add,0xfafc2b8c,0x59b8c2a0,0x03e806f9,0xcb4938b9,0xccc942af,0xcee3ae2e,0xfbe748fa,
      0xb223a075,0x85c49b5d,0xe4576ac9,0x0fbd46e2,0xb49f9cf5,0xf3e1e86a,0x7d7927fb,0x711afe12,
      0xbf61c346,0x157c9956,0x86b6b046,0x2e402146,0xb2a57d8a,0x0d064bb1,0x30ce390c,0x3a3e1eb1,
      0xbe7f6f8f,0xd8e30f87,0x5be2813c,0x73a3a901,0xa3aaf967,0x59ff092c,0x1705c798,0xf610dd66,
      0xb17da91e,0x8e59534e,0x2211ea5b,0xa804ba03,0xd890efbb,0xb8b48110,0xff390068,0xc8c325b4,
      0xf7289c07,0x787e104f,0x3d0df3d0,0x3526796d,0x10548055,0x1d59a42b,0xed1cc5a3,0xdd45372a,
      0x31c50d57,0x65757cb7,0x3cfb85be,0xa329910d,0x6ad8ce39,0xa2de44de,0x0dd32432,0xd4a5b617,
      0x8f3107fc,0x96485175,0x7f94d4f3,0x35097634,0xdb3ca782,0x2c0290b8,0x2045300b,0xe0f5d15a,
      0x0e8cbffa,0xaa1cc38a,0x84008d6f,0xe9a9e794,0x5c602c25,0xfa3658fa,0x98d9d82b,0x3f1497e7,
      0x84b6f031,0xe381eff9,0xfc7ae252,0xb239e05d,0xe3723d1f,0xcc3bda82,0xe21b1ad3,0x9104f7c8,
      0x4bb2dfcd,0x4d14a8bc,0x6ba7f28c,0x8f89886c,0xad44c97e,0xb30fd975,0x633cdab1,0xf6c2d514,
      0x067a49d2,0xdc461ad9,0xebaf9f3f,0x8dc6cac3,0x7a060f16,0xbab063ad,0xf42e25e6,0x60724ca6,
      0xc7245c2e,0x4e48ea3c,0x9f89a609,0xa1c49890,0x4bb7f116,0xd722865c,0xa8ee3995,0x0ee070b1,
      0xd9bffcc2,0xe55b64f9,0x25507a5a,0xc7a3e2b5,0x5f395f7e,0xe7957652,0x7381ba6a,0xde3d21f1,
      0xdf1708dd,0xad0c9d0c,0x00cbc9e5,0x1160e833,0x6779582c,0x29d5d393,0x3f11d7d7,0x826a6b9b,
      0xe73ff12f,0x8bad3d86,0xee41d3e5,0x7f0c8917,0x8089ef24,0x90c5cb28,0x2f7f8e6b,0x6966418a,
      0x345453fb,0x7a2f8a68,0xf198593d,0xc079a532,0xc1971e81,0x1ab74e26,0x329ef347,0x7423d3d0,
      0x942c510b,0x7f6c6382,0x14ae6acc,0x64b59da7,0x2356fa47,0xb6749d9c,0x499de1bb,0x92ffd191,
      0xe8f2fb75,0x848dc913,0x3e8727d3,0x1dcffe61,0xb6e45245,0x49055738,0x827a6b55,0xb4788887,
      0x7e680125,0xd19ce7ed,0x6b4b8e30,0xa8cadea2,0x216035d8,0x1c63bc3c,0xe1299056,0x1ad3dff4,
      0x0aefd13c,0x0e7b921c,0xca0173c6,0x9995782d,0xcccfd494,0xd4b0ac88,0x53d552b1,0x630dae8b,
      0xa8332dad,0x7139d9a2,0x5d76f2c4,0x7a4f8f1e,0x8d1aef97,0xd1cf285d,0xc8239153,0xce2608a9,
      0x7b562475,0xe4b4bc83,0xf3db0c3a,0x70a65e48,0x6016b302,0xdebd5046,0x707e786a,0x6f10200c
   };

   static const UInt_t msk[] = { 0x11111111, 0x33333333, 0x77777777, 0xffffffff };

   const UChar_t *uc = (const UChar_t *) txt;
   UInt_t uu = 0;
   union {
      UInt_t   u;
      UShort_t s[2];
   } u;
   u.u = 0;
   Int_t i, idx;

   for (i = 0; i < ntxt; i++) {
      idx = (uc[i] ^ i) & 255;
      uu  = (uu << 1) ^ (utab[idx] & msk[i & 3]);
      if ((i & 3) == 3) u.u ^= uu;
   }
   if (i & 3) u.u ^= uu;

   u.u *= 1879048201;      // prime number
   u.s[0] += u.s[1];
   u.u *= 1979048191;      // prime number
   u.s[1] ^= u.s[0];
   u.u *= 2079048197;      // prime number

   return u.u;
}

//______________________________________________________________________________
static int MemIsEqual(const char *p, const char *q, Ssiz_t n)
{
   // Returns false if strings are not equal.

   while (n--)
   {
      if (tolower((unsigned char)*p) != tolower((unsigned char)*q))
         return kFALSE;
      p++; q++;
   }
   return kTRUE;
}

//______________________________________________________________________________
Ssiz_t TString::Index(const char *pattern, Ssiz_t plen, Ssiz_t startIndex,
                      ECaseCompare cmp) const
{
   // Search for a string in the TString. Plen is the length of pattern,
   // startIndex is the index from which to start and cmp selects the type
   // of case-comparison.

   Ssiz_t slen = Length();
   if (slen < startIndex + plen) return kNPOS;
   if (plen == 0) return startIndex;
   slen -= startIndex + plen;
   const char *sp = Data() + startIndex;
   if (cmp == kExact) {
      char first = *pattern;
      for (Ssiz_t i = 0; i <= slen; ++i)
         if (sp[i] == first && memcmp(sp+i+1, pattern+1, plen-1) == 0)
            return i + startIndex;
   } else {
      int first = tolower((unsigned char) *pattern);
      for (Ssiz_t i = 0; i <= slen; ++i)
         if (tolower((unsigned char) sp[i]) == first &&
             MemIsEqual(sp+i+1, pattern+1, plen-1))
            return i + startIndex;
   }
   return kNPOS;
}

//______________________________________________________________________________
Bool_t TString::MaybeRegexp() const
{
   // Returns true if string contains one of the regexp characters "^$.[]*+?".

   const char *specials = "^$.[]*+?";

   if (First(specials) == kNPOS)
      return kFALSE;
   return kTRUE;
}

//______________________________________________________________________________
Bool_t TString::MaybeWildcard() const
{
   // Returns true if string contains one of the wildcard characters "[]*?".

   const char *specials = "[]*?";

   if (First(specials) == kNPOS)
      return kFALSE;
   return kTRUE;
}

//______________________________________________________________________________
TString& TString::Prepend(char c, Ssiz_t rep)
{
   // Prepend characters to self.

   Ssiz_t tot = Length() + rep;  // Final string length

   // Check for shared representation or insufficient capacity
   if ( Pref()->References() > 1 || Capacity() < tot ) {
      TStringRef *temp = TStringRef::GetRep(AdjustCapacity(tot), tot);
      memcpy(temp->Data()+rep, Data(), Length());
      Pref()->UnLink();
      fData = temp->Data();
   } else {
      memmove(fData + rep, Data(), Length());
      fData[Pref()->fNchars = tot] = '\0';
   }

   char *p = fData;
   while (rep--)
      *p++ = c;

   return *this;
}

//______________________________________________________________________________
TString &TString::Replace(Ssiz_t pos, Ssiz_t n1, const char *cs, Ssiz_t n2)
{
   // Remove at most n1 characters from self beginning at pos,
   // and replace them with the first n2 characters of cs.

   if (pos <= kNPOS || pos > Length()) {
      Error("TString::Replace",
            "first argument out of bounds: pos = %d, Length = %d", pos, Length());
      return *this;
   }

   n1 = TMath::Min(n1, Length()-pos);
   if (!cs) n2 = 0;

   Ssiz_t tot = Length()-n1+n2;  // Final string length
   Ssiz_t rem = Length()-n1-pos; // Length of remnant at end of string

   // Check for shared representation, insufficient capacity,
   // excess waste, or overlapping copy
   if (Pref()->References() > 1 ||
       Capacity() < tot ||
       Capacity() - tot > GetMaxWaste() ||
       (cs && (cs >= Data() && cs < Data()+Length())))
   {
      TStringRef *temp = TStringRef::GetRep(AdjustCapacity(tot), tot);
      if (pos) memcpy(temp->Data(), Data(), pos);
      if (n2 ) memcpy(temp->Data()+pos, cs, n2);
      if (rem) memcpy(temp->Data()+pos+n2, Data()+pos+n1, rem);
      Pref()->UnLink();
      fData = temp->Data();
   } else {
      if (rem) memmove(fData+pos+n2, Data()+pos+n1, rem);
      if (n2 ) memmove(fData+pos   , cs, n2);
      fData[Pref()->fNchars = tot] = 0;   // Add terminating null
   }

   return *this;
}

//______________________________________________________________________________
TString& TString::ReplaceAll(const char *s1, Ssiz_t ls1, const char *s2,
                             Ssiz_t ls2)
{
   // Find & Replace ls1 symbols of s1 with ls2 symbols of s2 if any.

   if (s1 && ls1 > 0) {
      Ssiz_t index = 0;
      while ((index = Index(s1,ls1,index, kExact)) != kNPOS) {
         Replace(index,ls1,s2,ls2);
         index += ls2;
      }
   }
   return *this;
}

//______________________________________________________________________________
TString &TString::Remove(EStripType st, char c)
{
   // Remove char c at begin and/or end of string (like Strip() but
   // modifies directly the string.

   Ssiz_t start = 0;             // Index of first character
   Ssiz_t end = Length();        // One beyond last character
   const char *direct = Data();  // Avoid a dereference w dumb compiler
   Ssiz_t send = end;

   if (st & kLeading)
      while (start < end && direct[start] == c)
         ++start;
   if (st & kTrailing)
      while (start < end && direct[end-1] == c)
         --end;
   if (end == start) {
      Pref()->UnLink();
      gNullStringRef->AddReference();
      fData = gNullStringRef->Data();
      return *this;
   }
   if (start)
      Remove(0, start);
   if (send != end)
      Remove(send - start - (send - end), send - end);
   return *this;
}

//______________________________________________________________________________
void TString::Resize(Ssiz_t n)
{
   // Resize the string. Truncate or add blanks as necessary.

   if (n < Length())
      Remove(n);                  // Shrank; truncate the string
   else
      Append(' ', n-Length());    // Grew or staid the same
}

//______________________________________________________________________________
TSubString TString::Strip(EStripType st, char c) const
{
   // Return a substring of self stripped at beginning and/or end.

   Ssiz_t start = 0;             // Index of first character
   Ssiz_t end = Length();        // One beyond last character
   const char *direct = Data();  // Avoid a dereference w dumb compiler

   if (st & kLeading)
      while (start < end && direct[start] == c)
         ++start;
   if (st & kTrailing)
      while (start < end && direct[end-1] == c)
         --end;
   if (end == start) start = end = kNPOS;  // make the null substring
   return TSubString(*this, start, end-start);
}

//______________________________________________________________________________
void TString::ToLower()
{
   // Change string to lower-case.

   Cow();
   register Ssiz_t n = Length();
   register char *p = fData;
   while (n--) {
      *p = tolower((unsigned char)*p);
      p++;
   }
}

//______________________________________________________________________________
void TString::ToUpper()
{
   // Change string to upper case.

   Cow();
   register Ssiz_t n = Length();
   register char *p = fData;
   while (n--) {
      *p = toupper((unsigned char)*p);
      p++;
   }
}

//______________________________________________________________________________
char& TString::operator[](Ssiz_t i)
{
   // Return charcater at location i.

   AssertElement(i);
   Cow();
   return fData[i];
}

//______________________________________________________________________________
void TString::AssertElement(Ssiz_t i) const
{
   // Check to make sure a string index is in range.

   if (i == kNPOS || i > Length())
      Error("TString::AssertElement",
            "out of bounds: i = %d, Length = %d", i, Length());
}

//______________________________________________________________________________
TString::TString(const char *a1, Ssiz_t n1, const char *a2, Ssiz_t n2)
{
   // Special constructor to initialize with the concatenation of a1 and a2.

   if (!a1) n1=0;
   if (!a2) n2=0;
   Ssiz_t tot = n1+n2;
   fData = TStringRef::GetRep(AdjustCapacity(tot), tot)->Data();
   memcpy(fData,    a1, n1);
   memcpy(fData+n1, a2, n2);
}

//______________________________________________________________________________
Ssiz_t TString::AdjustCapacity(Ssiz_t nc)
{
   // Calculate a nice capacity greater than or equal to nc.

   Ssiz_t ic = GetInitialCapacity();
   if (nc <= ic) return ic;
   Ssiz_t rs = GetResizeIncrement();
   return (nc - ic + rs - 1) / rs * rs + ic;
}

//______________________________________________________________________________
void TString::Clear()
{
   // Clear string without changing its capacity.

   Clobber(Capacity());
}

//______________________________________________________________________________
void TString::Clobber(Ssiz_t nc)
{
   // Clear string and make sure it has a capacity of nc.

   if (Pref()->References() > 1 || Capacity() < nc) {
      Pref()->UnLink();
      fData = TStringRef::GetRep(nc, 0)->Data();
   } else
      fData[Pref()->fNchars = 0] = 0;
}

//______________________________________________________________________________
void TString::Clone()
{
   // Make string a distinct copy; preserve previous contents.

   TStringRef *temp = TStringRef::GetRep(Length(), Length());
   memcpy(temp->Data(), Data(), Length());
   Pref()->UnLink();
   fData = temp->Data();
}

//______________________________________________________________________________
void TString::Clone(Ssiz_t nc)
{
   // Make self a distinct copy with capacity of at least nc.
   // Preserve previous contents.

   Ssiz_t len = Length();
   if (len > nc) len = nc;
   TStringRef *temp = TStringRef::GetRep(nc, len);
   memcpy(temp->Data(), Data(), len);
   Pref()->UnLink();
   fData = temp->Data();
}

// ------------------- ROOT I/O ------------------------------------

//______________________________________________________________________________
void TString::FillBuffer(char *&buffer)
{
   // Copy string into I/O buffer.

   UChar_t nwh;
   Int_t   nchars = Length();

   if (nchars > 254) {
      nwh = 255;
      tobuf(buffer, nwh);
      tobuf(buffer, nchars);
   } else {
      nwh = UChar_t(nchars);
      tobuf(buffer, nwh);
   }
   for (int i = 0; i < nchars; i++) buffer[i] = fData[i];
   buffer += nchars;
}

//______________________________________________________________________________
void TString::ReadBuffer(char *&buffer)
{
   // Read string from I/O buffer.

   Pref()->UnLink();

   UChar_t nwh;
   Int_t   nchars;

   frombuf(buffer, &nwh);
   if (nwh == 255)
      frombuf(buffer, &nchars);
   else
      nchars = nwh;

   if (nchars < 0) {
      Printf("Error in TString::ReadBuffer, found case with nwh=%d and nchars=%d", nwh, nchars);
      return;
   }
   fData = TStringRef::GetRep(nchars, nchars)->Data();

   for (int i = 0; i < nchars; i++) frombuf(buffer, &fData[i]);
}

//______________________________________________________________________________
TString *TString::ReadString(TBuffer &b, const TClass *clReq)
{
   // Read TString object from buffer. Simplified version of
   // TBuffer::ReadObject (does not keep track of multiple
   // references to same string).  We need to have it here
   // because TBuffer::ReadObject can only handle descendant
   // of TObject.

   R__ASSERT(b.IsReading());

   // Make sure ReadArray is initialized
   b.InitMap();

   // Before reading object save start position
   UInt_t startpos = UInt_t(b.Length());

   UInt_t tag;
   TClass *clRef = b.ReadClass(clReq, &tag);

   TString *a;
   if (!clRef) {

      a = 0;

   } else {

      a = (TString *) clRef->New();
      if (!a) {
         ::Error("TString::ReadObject", "could not create object of class %s",
                 clRef->GetName());
         // Exception
      }

      a->Streamer(b);

      b.CheckByteCount(startpos, tag, clRef);
   }

   return a;
}

//______________________________________________________________________________
Int_t TString::Sizeof() const
{
   // Returns size string will occupy on I/O buffer.

   if (Length() > 254)
      return Length()+sizeof(UChar_t)+sizeof(Int_t);
   else
      return Length()+sizeof(UChar_t);
}

//_______________________________________________________________________
void TString::Streamer(TBuffer &b)
{
   // Stream a string object.

   Int_t   nbig;
   UChar_t nwh;
   if (b.IsReading()) {
      b >> nwh;
      if (nwh == 255)
         b >> nbig;
      else
         nbig = nwh;
      Pref()->UnLink();
      fData = TStringRef::GetRep(nbig,nbig)->Data();
      b.ReadFastArray(fData,nbig);
      //for (int i = 0; i < nbig; i++) b >> fData[i];
   } else {
      nbig = Length();
      if (nbig > 254) {
         nwh = 255;
         b << nwh;
         b << nbig;
      } else {
         nwh = UChar_t(nbig);
         b << nwh;
      }
      b.WriteFastArray(fData,nbig);
      //for (int i = 0; i < nbig; i++) b << fData[i];
   }
}

//______________________________________________________________________________
void TString::WriteString(TBuffer &b, const TString *a)
{
   // Write TString object to buffer. Simplified version of
   // TBuffer::WriteObject (does not keep track of multiple
   // references to the same string).  We need to have it here
   // because TBuffer::ReadObject can only handle descendant
   // of TObject

   R__ASSERT(b.IsWriting());

   // Make sure WriteMap is initialized
   b.InitMap();

   if (!a) {

      b << (UInt_t) 0;

   } else {

      // Reserve space for leading byte count
      UInt_t cntpos = UInt_t(b.Length());
      b.SetBufferOffset(Int_t(cntpos+sizeof(UInt_t)));

      TClass *cl = a->IsA();
      b.WriteClass(cl);

      ((TString *)a)->Streamer(b);

      // Write byte count
      b.SetByteCount(cntpos);
   }
}

//_______________________________________________________________________
#if defined(R__TEMPLATE_OVERLOAD_BUG)
template <>
#endif
TBuffer &operator>>(TBuffer &buf, TString *&s)
{
   // Read string from TBuffer. Function declared in ClassDef.

   s = (TString *) TString::ReadString(buf, TString::Class());
   return buf;
}

//_______________________________________________________________________
TBuffer &operator<<(TBuffer &buf, const TString *s)
{
   // Write TString or derived to TBuffer.

   TString::WriteString(buf, s);
   return buf;
}

// ------------------- Related global functions --------------------

//______________________________________________________________________________
Bool_t operator==(const TString& s1, const char *s2)
{
   // Compare TString with a char *.

   if (!s2) return kFALSE;

   const char *data = s1.Data();
   Ssiz_t len = s1.Length();
   Ssiz_t i;
   for (i = 0; s2[i]; ++i)
      if (data[i] != s2[i] || i == len) return kFALSE;
   return (i == len);
}

#if defined(R__ALPHA)
//______________________________________________________________________________
Bool_t operator==(const TString &s1, const TString &s2)
{
   // Compare two TStrings.

   return ((s1.Length() == s2.Length()) && !memcmp(s1.Data(), s2.Data(), s1.Length()));
}
#endif

//______________________________________________________________________________
TString ToLower(const TString &str)
{
   // Return a lower-case version of str.

   register Ssiz_t n = str.Length();
   TString temp((char)0, n);
   register const char *uc = str.Data();
   register       char *lc = (char*)temp.Data();
   // Guard against tolower() being a macro
   while (n--) { *lc++ = tolower((unsigned char)*uc); uc++; }
   return temp;
}

//______________________________________________________________________________
TString ToUpper(const TString &str)
{
   // Return an upper-case version of str.

   register Ssiz_t n = str.Length();
   TString temp((char)0, n);
   register const char* uc = str.Data();
   register       char* lc = (char*)temp.Data();
   // Guard against toupper() being a macro
   while (n--) { *lc++ = toupper((unsigned char)*uc); uc++; }
   return temp;
}

//______________________________________________________________________________
TString operator+(const TString &s, const char *cs)
{
   // Use the special concatenation constructor.

   return TString(s.Data(), s.Length(), cs, cs ? strlen(cs) : 0);
}

//______________________________________________________________________________
TString operator+(const char *cs, const TString &s)
{
   // Use the special concatenation constructor.

   return TString(cs, cs ? strlen(cs) : 0, s.Data(), s.Length());
}

//______________________________________________________________________________
TString operator+(const TString &s1, const TString &s2)
{
   // Use the special concatenation constructor.

   return TString(s1.Data(), s1.Length(), s2.Data(), s2.Length());
}

//______________________________________________________________________________
TString operator+(const TString &s, char c)
{
   // Add char to string.

   return TString(s.Data(), s.Length(), &c, 1);
}

//______________________________________________________________________________
TString operator+(const TString &s, Long_t i)
{
   // Add integer to string.

   char si[32];
   sprintf(si, "%ld", i);
   return TString(s.Data(), s.Length(), si, strlen(si));
}

//______________________________________________________________________________
TString operator+(const TString &s, ULong_t i)
{
   // Add integer to string.

   char si[32];
   sprintf(si, "%lu", i);
   return TString(s.Data(), s.Length(), si, strlen(si));
}

//______________________________________________________________________________
TString operator+(const TString &s, Long64_t i)
{
   // Add integer to string.

   char si[32];
   sprintf(si, "%lld", i);
   return TString(s.Data(), s.Length(), si, strlen(si));
}

//______________________________________________________________________________
TString operator+(const TString &s, ULong64_t i)
{
   // Add integer to string.

   char si[32];
   sprintf(si, "%llu", i);
   return TString(s.Data(), s.Length(), si, strlen(si));
}

//______________________________________________________________________________
TString operator+(char c, const TString &s)
{
   // Add string to integer.

   return TString(&c, 1, s.Data(), s.Length());
}

//______________________________________________________________________________
TString operator+(Long_t i, const TString &s)
{
   // Add string to integer.

   char si[32];
   sprintf(si, "%ld", i);
   return TString(si, strlen(si), s.Data(), s.Length());
}

//______________________________________________________________________________
TString operator+(ULong_t i, const TString &s)
{
   // Add string to integer.

   char si[32];
   sprintf(si, "%lu", i);
   return TString(si, strlen(si), s.Data(), s.Length());
}

//______________________________________________________________________________
TString operator+(Long64_t i, const TString &s)
{
   // Add string to integer.

   char si[32];
   sprintf(si, "%lld", i);
   return TString(si, strlen(si), s.Data(), s.Length());
}

//______________________________________________________________________________
TString operator+(ULong64_t i, const TString &s)
{
   // Add string to integer.

   char si[32];
   sprintf(si, "%llu", i);
   return TString(si, strlen(si), s.Data(), s.Length());
}

// -------------------- Static Member Functions ----------------------

// Static member variable initialization:
Ssiz_t TString::fgInitialCapac = 15;
Ssiz_t TString::fgResizeInc    = 16;
Ssiz_t TString::fgFreeboard    = 15;

//______________________________________________________________________________
Ssiz_t TString::InitialCapacity(Ssiz_t ic)
{
   // Set default initial capacity for all TStrings. Default is 15.

   Ssiz_t ret = fgInitialCapac;
   fgInitialCapac = ic;
   return ret;
}

//______________________________________________________________________________
Ssiz_t TString::ResizeIncrement(Ssiz_t ri)
{
   // Set default resize increment for all TStrings. Default is 16.

   Ssiz_t ret = fgResizeInc;
   fgResizeInc = ri;
   return ret;
}

//______________________________________________________________________________
Ssiz_t TString::MaxWaste(Ssiz_t mw)
{
   // Set maximum space that may be wasted in a string before doing a resize.
   // Default is 15.

   Ssiz_t ret = fgFreeboard;
   fgFreeboard = mw;
   return ret;
}


//////////////////////////////////////////////////////////////////////////
//                                                                      //
//  TSubString                                                          //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

//
// A zero lengthed substring is legal. It can start
// at any character. It is considered to be "pointing"
// to just before the character.
//
// A "null" substring is a zero lengthed substring that
// starts with the nonsense index kNPOS. It can
// be detected with the member function IsNull().
//

//______________________________________________________________________________
TSubString::TSubString(const TString &str, Ssiz_t start, Ssiz_t nextent)
   : fStr((TString&)str), fBegin(start), fExtent(nextent)
{
   // Private constructor.
}

//______________________________________________________________________________
TSubString TString::operator()(Ssiz_t start, Ssiz_t len) const
{
   // Return sub-string of string starting at start with length len.

   if (start < Length() && len > 0) {
      if (start+len > Length())
         len = Length() - start;
   } else {
      start = kNPOS;
      len   = 0;
   }
   return TSubString(*this, start, len);
}

//______________________________________________________________________________
TSubString TString::SubString(const char *pattern, Ssiz_t startIndex,
                              ECaseCompare cmp) const
{
   // Returns a substring matching "pattern", or the null substring
   // if there is no such match.  It would be nice if this could be yet another
   // overloaded version of operator(), but this would result in a type
   // conversion ambiguity with operator(Ssiz_t, Ssiz_t).

   Ssiz_t len = pattern ? strlen(pattern) : 0;
   Ssiz_t i = Index(pattern, len, startIndex, cmp);
   return TSubString(*this, i, i == kNPOS ? 0 : len);
}

//______________________________________________________________________________
char& TSubString::operator[](Ssiz_t i)
{
   // Return character at pos i from sub-string. Check validity of i.

   AssertElement(i);
   fStr.Cow();
   return fStr.fData[fBegin+i];
}

//______________________________________________________________________________
char& TSubString::operator()(Ssiz_t i)
{
   // Return character at pos i from sub-string. No check on i.

   fStr.Cow();
   return fStr.fData[fBegin+i];
}

//______________________________________________________________________________
TSubString& TSubString::operator=(const TString &str)
{
   // Assign string to sub-string.

   if (!IsNull())
      fStr.Replace(fBegin, fExtent, str.Data(), str.Length());

   return *this;
}

//______________________________________________________________________________
TSubString& TSubString::operator=(const char *cs)
{
   // Assign char* to sub-string.

   if (!IsNull())
      fStr.Replace(fBegin, fExtent, cs, cs ? strlen(cs) : 0);

   return *this;
}

//______________________________________________________________________________
Bool_t operator==(const TSubString& ss, const char *cs)
{
   // Compare sub-string to char *.

   if (ss.IsNull()) return *cs =='\0'; // Two null strings compare equal

   const char* data = ss.fStr.Data() + ss.fBegin;
   Ssiz_t i;
   for (i = 0; cs[i]; ++i)
      if (cs[i] != data[i] || i == ss.fExtent) return kFALSE;
   return (i == ss.fExtent);
}

//______________________________________________________________________________
Bool_t operator==(const TSubString& ss, const TString &s)
{
   // Compare sub-string to string.

   if (ss.IsNull()) return s.IsNull(); // Two null strings compare equal.
   if (ss.fExtent != s.Length()) return kFALSE;
   return !memcmp(ss.fStr.Data() + ss.fBegin, s.Data(), ss.fExtent);
}

//______________________________________________________________________________
Bool_t operator==(const TSubString &s1, const TSubString &s2)
{
   // Compare two sub-strings.

   if (s1.IsNull()) return s2.IsNull();
   if (s1.fExtent != s2.fExtent) return kFALSE;
   return !memcmp(s1.fStr.Data()+s1.fBegin, s2.fStr.Data()+s2.fBegin,
                  s1.fExtent);
}

//______________________________________________________________________________
void TSubString::ToLower()
{
   // Convert sub-string to lower-case.

   if (!IsNull()) {                             // Ignore null substrings
      fStr.Cow();
      register char *p = (char*)(fStr.Data() + fBegin); // Cast away constness
      Ssiz_t n = fExtent;
      while (n--) { *p = tolower((unsigned char)*p); p++;}
   }
}

//______________________________________________________________________________
void TSubString::ToUpper()
{
   // Convert sub-string to upper-case.
   if (!IsNull()) {                             // Ignore null substrings
      fStr.Cow();
      register char *p = (char*)(fStr.Data() + fBegin); // Cast away constness
      Ssiz_t n = fExtent;
      while (n--) { *p = toupper((unsigned char)*p); p++;}
   }
}

//______________________________________________________________________________
void TSubString::SubStringError(Ssiz_t sr, Ssiz_t start, Ssiz_t n) const
{
   // Output error message.

   Error("TSubString::SubStringError",
         "out of bounds: start = %d, n = %d, sr = %d", start, n, sr);
}

//______________________________________________________________________________
void TSubString::AssertElement(Ssiz_t i) const
{
   // Check to make sure a sub-string index is in range.

   if (i == kNPOS || i >= Length())
      Error("TSubString::AssertElement",
            "out of bounds: i = %d, Length = %d", i, Length());
}

//______________________________________________________________________________
Bool_t TString::IsAscii() const
{
   // Returns true if all characters in string are ascii.

   const char *cp = Data();
   for (Ssiz_t i = 0; i < Length(); ++i)
      if (cp[i] & ~0x7F)
         return kFALSE;
   return kTRUE;
}

//______________________________________________________________________________
Bool_t TString::IsAlpha() const
{
   // Returns true if all characters in string are alphabetic.
   // Returns false in case string length is 0.

   const char *cp = Data();
   Ssiz_t len = Length();
   if (len == 0) return kFALSE;
   for (Ssiz_t i = 0; i < len; ++i)
      if (!isalpha(cp[i]))
         return kFALSE;
   return kTRUE;
}

//______________________________________________________________________________
Bool_t TString::IsAlnum() const
{
   // Returns true if all characters in string are alphanumeric.
   // Returns false in case string length is 0.

   const char *cp = Data();
   Ssiz_t len = Length();
   if (len == 0) return kFALSE;
   for (Ssiz_t i = 0; i < len; ++i)
      if (!isalnum(cp[i]))
         return kFALSE;
   return kTRUE;
}

//______________________________________________________________________________
Bool_t TString::IsDigit() const
{
   // Returns true if all characters in string are digits (0-9) or whitespaces,
   // i.e. "123456" and "123 456" are both valid integer strings.
   // Returns false in case string length is 0 or string contains other
   // characters or only whitespace.

   const char *cp = Data();
   Ssiz_t len = Length();
   if (len == 0) return kFALSE;
   Int_t b = 0, d = 0;
   for (Ssiz_t i = 0; i < len; ++i) {
      if (cp[i] != ' ' && !isdigit(cp[i])) return kFALSE;
      if (cp[i] == ' ') b++;
      if (isdigit(cp[i])) d++;
   }
   if (b && !d)
      return kFALSE;
   return kTRUE;
}

//______________________________________________________________________________
Bool_t TString::IsFloat() const
{
   // Returns kTRUE if string contains a floating point or integer number.
   // Examples of valid formats are:
   //    64320
   //    64 320
   //    6 4 3 2 0
   //    6.4320     6,4320
   //    6.43e20   6.43E20    6,43e20
   //    6.43e-20  6.43E-20   6,43e-20

   //we first check if we have an integer, in this case, IsDigit() will be true straight away
   if (IsDigit()) return kTRUE;

   TString tmp = *this;
   //now we look for occurrences of '.', ',', e', 'E', '+', '-' and replace each
   //with ' '. if it is a floating point, IsDigit() will then return kTRUE
   Int_t i_dot, i_e, i_plus, i_minus, i_comma;
   i_dot = i_e = i_plus = i_minus = i_comma = -1;

   i_dot = tmp.First('.');
   if (i_dot > -1) tmp.Replace(i_dot, 1, " ", 1);
   i_comma = tmp.First(',');
   if (i_comma > -1) tmp.Replace(i_comma, 1, " ", 1);
   i_e = tmp.First('e');
   if (i_e > -1)
      tmp.Replace(i_e, 1, " ", 1);
   else {
      //try for a capital "E"
      i_e = tmp.First('E');
      if (i_e > -1) tmp.Replace(i_e, 1, " ", 1);
   }
   i_plus = tmp.First('+');
   if (i_plus > -1) tmp.ReplaceAll("+", " ");
   i_minus = tmp.First('-');
   if (i_minus > -1) tmp.ReplaceAll("-", " ");

   //test if it is now uniquely composed of numbers
   return tmp.IsDigit();
}

//______________________________________________________________________________
Bool_t TString::IsHex() const
{
   // Returns true if all characters in string are hexidecimal digits
   // (0-9,a-f,A-F). Returns false in case string length is 0.


   const char *cp = Data();
   Ssiz_t len = Length();
   if (len == 0) return kFALSE;
   for (Ssiz_t i = 0; i < len; ++i)
      if (!isxdigit(cp[i]))
         return kFALSE;
   return kTRUE;
}

//______________________________________________________________________________
Int_t TString::Atoi() const
{
   // Return integer value of string.
   // Valid strings include only digits and whitespace (see IsDigit()),
   // i.e. "123456", "123 456" and "1 2 3 4        56" are all valid
   // integer strings whose Atoi() value is 123456.

   //any whitespace ?
   Int_t end = Index(" ");
   //if no whitespaces in string, just use atoi()
   if (end == -1) return atoi(Data());
   //make temporary string, removing whitespace
   Int_t start = 0;
   TString tmp;
   //loop over all whitespace
   while (end > -1) {
      tmp += (*this)(start, end-start);
      start = end+1; end = Index(" ", start);
   }
   //finally add part from last whitespace to end of string
   end = Length();
   tmp += (*this)(start, end-start);
   return atoi(tmp.Data());
}

//______________________________________________________________________________
Long64_t TString::Atoll() const
{
   // Return long long value of string.
   // Valid strings include only digits and whitespace (see IsDigit()),
   // i.e. "123456", "123 456" and "1 2 3 4        56" are all valid
   // integer strings whose Atoll() value is 123456.

   //any whitespace ?
   Int_t end = Index(" ");
   //if no whitespaces in string, just use atoi()
#ifndef R__WIN32
   if (end == -1) return atoll(Data());
#else
   if (end == -1) return _atoi64(Data());
#endif
   //make temporary string, removing whitespace
   Int_t start = 0;
   TString tmp;
   //loop over all whitespace
   while (end > -1) {
      tmp += (*this)(start, end-start);
      start = end+1; end = Index(" ", start);
   }
   //finally add part from last whitespace to end of string
   end = Length();
   tmp += (*this)(start, end-start);
#ifndef R__WIN32
   return atoll(tmp.Data());
#else
   return _atoi64(tmp.Data());
#endif
}

//______________________________________________________________________________
Double_t TString::Atof() const
{
   // Return floating-point value contained in string.
   // Examples of valid strings are:
   //    64320
   //    64 320
   //    6 4 3 2 0
   //    6.4320     6,4320
   //    6.43e20   6.43E20    6,43e20
   //    6.43e-20  6.43E-20   6,43e-20

   //look for a comma and some whitespace
   Int_t comma = Index(",");
   Int_t end = Index(" ");
   //if no commas & no whitespace in string, just use atof()
   if (comma == -1 && end == -1) return atof(Data());
   TString tmp = *this;
   if (comma > -1) {
      //replace comma with decimal point
      tmp.Replace(comma, 1, ".");
   }
   //no whitespace ?
   if (end == -1) return atof(tmp.Data());
   //remove whitespace
   Int_t start = 0;
   TString tmp2;
   while (end > -1) {
      tmp2 += tmp(start, end-start);
      start = end+1; end = tmp.Index(" ", start);
   }
   end = tmp.Length();
   tmp2 += tmp(start, end-start);
   return atof(tmp2.Data());
}

//______________________________________________________________________________
Bool_t TString::EndsWith(const char *s, ECaseCompare cmp) const
{
   // Return true if string ends with the specified string.

   if (!s) return kTRUE;

   Ssiz_t l = strlen(s);
   if (l > Length()) return kFALSE;
   const char *s2 = Data() + Length() - l;

   if (cmp == kExact)
      return strcmp(s, s2) == 0;
   return strcasecmp(s, s2) == 0;
}

//__________________________________________________________________________________
TObjArray *TString::Tokenize(const TString &delim) const
{
   // This function is used to isolate sequential tokens in a TString.
   // These tokens are separated in the string by at least one of the
   // characters in delim. The returned array contains the tokens
   // as TObjString's. The returned array is the owner of the objects,
   // and must be deleted by the user.

   std::list<Int_t> splitIndex;

   Int_t i, start, nrDiff = 0;
   for (i = 0; i < delim.Length(); i++) {
      start = 0;
      while (start < Length()) {
         Int_t pos = Index(delim(i), start);
         if (pos == kNPOS) break;
         splitIndex.push_back(pos);
         start = pos + 1;
      }
      if (start > 0) nrDiff++;
   }
   splitIndex.push_back(Length());

   if (nrDiff > 1)
      splitIndex.sort();

   TObjArray *arr = new TObjArray();
   arr->SetOwner();

   start = -1;
   std::list<Int_t>::const_iterator it;
#ifndef R__HPUX
   for (it = splitIndex.begin(); it != splitIndex.end(); it++) {
#else
   for (it = splitIndex.begin(); it != (std::list<Int_t>::const_iterator) splitIndex.end(); it++) {
#endif
      Int_t stop = *it;
      if (stop - 1 >= start + 1) {
         TString tok = (*this)(start+1, stop-start-1);
         TObjString *objstr = new TObjString(tok);
         arr->Add(objstr);
      }
      start = stop;
   }

   return arr;
}

//______________________________________________________________________________
void TString::FormImp(const char *fmt, va_list ap)
{
   // Formats a string using a printf style format descriptor.
   // Existing string contents will be overwritten.

   Ssiz_t buflen = 20 + 20 * strlen(fmt);    // pick a number, any strictly positive number
   Clobber(buflen);

   va_list sap;
   R__VA_COPY(sap, ap);

   int n;
again:
   n = vsnprintf(fData, buflen, fmt, ap);
   // old vsnprintf's return -1 if string is truncated new ones return
   // total number of characters that would have been written
   if (n == -1 || n >= buflen) {
      if (n == -1)
         buflen *= 2;
      else
         buflen = n+1;
      Clobber(buflen);
      va_end(ap);
      R__VA_COPY(ap, sap);
      goto again;
   }
   va_end(sap);

   Pref()->fNchars = strlen(fData);
}

//______________________________________________________________________________
void TString::Form(const char *va_(fmt), ...)
{
   // Formats a string using a printf style format descriptor.
   // Existing string contents will be overwritten.

   va_list ap;
   va_start(ap, va_(fmt));
   FormImp(va_(fmt), ap);
   va_end(ap);
}

//______________________________________________________________________________
TString TString::Format(const char *va_(fmt), ...)
{
   // Static method which formats a string using a printf style format
   // descriptor and return a TString. Same as TString::Form() but it is
   // not needed to first create a TString.

   va_list ap;
   va_start(ap, va_(fmt));
   TString str;
   str.FormImp(va_(fmt), ap);
   va_end(ap);
   return str;
}

//---- Global String Handling Functions ----------------------------------------

static const int cb_size  = 4096;
static const int fld_size = 2048;

// a circular formating buffer
static char gFormbuf[cb_size];       // some slob for form overflow
static char *gBfree  = gFormbuf;
static char *gEndbuf = &gFormbuf[cb_size-1];

//______________________________________________________________________________
static char *SlowFormat(const char *format, va_list ap, int hint)
{
   // Format a string in a formatting buffer (using a printf style
   // format descriptor).

   static char *slowBuffer  = 0;
   static int   slowBufferSize = 0;

   R__LOCKGUARD2(gStringMutex);

   if (hint == -1) hint = fld_size;
   if (hint > slowBufferSize) {
      delete [] slowBuffer;
      slowBufferSize = 2 * hint;
      if (hint < 0 || slowBufferSize < 0) {
         slowBufferSize = 0;
         slowBuffer = 0;
         return 0;
      }
      slowBuffer = new char[slowBufferSize];
   }

   int n = vsnprintf(slowBuffer, slowBufferSize, format, ap);
   // old vsnprintf's return -1 if string is truncated new ones return
   // total number of characters that would have been written
   if (n == -1 || n >= slowBufferSize) {
      if (n == -1) n = 2 * slowBufferSize;
      if (n == slowBufferSize) n++;
      if (n <= 0) return 0; // int overflow!
      return SlowFormat(format, ap, n);
   }

   return slowBuffer;
}

//______________________________________________________________________________
static char *Format(const char *format, va_list ap)
{
   // Format a string in a circular formatting buffer (using a printf style
   // format descriptor).

   R__LOCKGUARD2(gStringMutex);

   char *buf = gBfree;

   if (buf+fld_size > gEndbuf)
      buf = gFormbuf;

   int n = vsnprintf(buf, fld_size, format, ap);
   // old vsnprintf's return -1 if string is truncated new ones return
   // total number of characters that would have been written
   if (n == -1 || n >= fld_size) {
      return SlowFormat(format, ap, n);
   }

   gBfree = buf+n+1;
   return buf;
}

//______________________________________________________________________________
char *Form(const char *va_(fmt), ...)
{
   // Formats a string in a circular formatting buffer. Removes the need to
   // create and delete short lived strings. Don't pass Form() pointers
   // from user code down to ROOT functions as the circular buffer may
   // be overwritten downstream. Use Form() results immediately or use
   // TString::Format() instead.

   va_list ap;
   va_start(ap,va_(fmt));
   char *b = Format(va_(fmt), ap);
   va_end(ap);
   return b;
}

//______________________________________________________________________________
void Printf(const char *va_(fmt), ...)
{
   // Formats a string in a circular formatting buffer and prints the string.
   // Appends a newline. If gPrintViaErrorHandler is true it will print via the
   // currently active ROOT error handler.

   va_list ap;
   va_start(ap,va_(fmt));
   if (gPrintViaErrorHandler)
      ErrorHandler(kPrint, 0, va_(fmt), ap);
   else {
      char *b = Format(va_(fmt), ap);
      printf("%s\n", b);
      fflush(stdout);
   }
   va_end(ap);
}

//______________________________________________________________________________
char *Strip(const char *s, char c)
{
   // Strip leading and trailing c (blanks by default) from a string.
   // The returned string has to be deleted by the user.

   if (!s) return 0;

   int l = strlen(s);
   char *buf = new char[l+1];

   if (l == 0) {
      *buf = '\0';
      return buf;
   }

   // get rid of leading c's
   const char *t1 = s;
   while (*t1 == c)
      t1++;

   // get rid of trailing c's
   const char *t2 = s + l - 1;
   while (*t2 == c && t2 > s)
      t2--;

   if (t1 > t2) {
      *buf = '\0';
      return buf;
   }
   strncpy(buf, t1, (Ssiz_t) (t2-t1+1));
   *(buf+(t2-t1+1)) = '\0';

   return buf;
}

//______________________________________________________________________________
char *StrDup(const char *str)
{
   // Duplicate the string str. The returned string has to be deleted by
   // the user.

   if (!str) return 0;

   char *s = new char[strlen(str)+1];
   if (s) strcpy(s, str);

   return s;
}

//______________________________________________________________________________
char *Compress(const char *str)
{
   // Remove all blanks from the string str. The returned string has to be
   // deleted by the user.

   if (!str) return 0;

   const char *p = str;
   char *s, *s1 = new char[strlen(str)+1];
   s = s1;

   while (*p) {
      if (*p != ' ')
         *s++ = *p;
      p++;
   }
   *s = '\0';

   return s1;
}

//______________________________________________________________________________
int EscChar(const char *src, char *dst, int dstlen, char *specchars,
            char escchar)
{
   // Escape specchars in src with escchar and copy to dst.

   const char *p;
   char *q, *end = dst+dstlen-1;

   for (p = src, q = dst; *p && q < end; ) {
      if (strchr(specchars, *p)) {
         *q++ = escchar;
         if (q < end)
            *q++ = *p++;
      } else
         *q++ = *p++;
   }
   *q = '\0';

   if (*p != 0)
      return -1;
   return q-dst;
}

//______________________________________________________________________________
int UnEscChar(const char *src, char *dst, int dstlen, char *specchars, char)
{
   // Un-escape specchars in src from escchar and copy to dst.

   const char *p;
   char *q, *end = dst+dstlen-1;

   for (p = src, q = dst; *p && q < end; ) {
      if (strchr(specchars, *p))
         p++;
      else
         *q++ = *p++;
   }
   *q = '\0';

   if (*p != 0)
      return -1;
   return q-dst;
}

#ifdef NEED_STRCASECMP
//______________________________________________________________________________
int strcasecmp(const char *str1, const char *str2)
{
   // Case insensitive string compare.

   return strncasecmp(str1, str2, str2 ? strlen(str2)+1 : 0);
}

//______________________________________________________________________________
int strncasecmp(const char *str1, const char *str2, Ssiz_t n)
{
   // Case insensitive string compare of n characters.

   while (n > 0) {
      int c1 = *str1;
      int c2 = *str2;

      if (isupper(c1))
         c1 = tolower(c1);

      if (isupper(c2))
         c2 = tolower(c2);

      if (c1 != c2)
         return c1 - c2;

      str1++;
      str2++;
      n--;
   }
   return 0;
}
#endif
 TString.cxx:1
 TString.cxx:2
 TString.cxx:3
 TString.cxx:4
 TString.cxx:5
 TString.cxx:6
 TString.cxx:7
 TString.cxx:8
 TString.cxx:9
 TString.cxx:10
 TString.cxx:11
 TString.cxx:12
 TString.cxx:13
 TString.cxx:14
 TString.cxx:15
 TString.cxx:16
 TString.cxx:17
 TString.cxx:18
 TString.cxx:19
 TString.cxx:20
 TString.cxx:21
 TString.cxx:22
 TString.cxx:23
 TString.cxx:24
 TString.cxx:25
 TString.cxx:26
 TString.cxx:27
 TString.cxx:28
 TString.cxx:29
 TString.cxx:30
 TString.cxx:31
 TString.cxx:32
 TString.cxx:33
 TString.cxx:34
 TString.cxx:35
 TString.cxx:36
 TString.cxx:37
 TString.cxx:38
 TString.cxx:39
 TString.cxx:40
 TString.cxx:41
 TString.cxx:42
 TString.cxx:43
 TString.cxx:44
 TString.cxx:45
 TString.cxx:46
 TString.cxx:47
 TString.cxx:48
 TString.cxx:49
 TString.cxx:50
 TString.cxx:51
 TString.cxx:52
 TString.cxx:53
 TString.cxx:54
 TString.cxx:55
 TString.cxx:56
 TString.cxx:57
 TString.cxx:58
 TString.cxx:59
 TString.cxx:60
 TString.cxx:61
 TString.cxx:62
 TString.cxx:63
 TString.cxx:64
 TString.cxx:65
 TString.cxx:66
 TString.cxx:67
 TString.cxx:68
 TString.cxx:69
 TString.cxx:70
 TString.cxx:71
 TString.cxx:72
 TString.cxx:73
 TString.cxx:74
 TString.cxx:75
 TString.cxx:76
 TString.cxx:77
 TString.cxx:78
 TString.cxx:79
 TString.cxx:80
 TString.cxx:81
 TString.cxx:82
 TString.cxx:83
 TString.cxx:84
 TString.cxx:85
 TString.cxx:86
 TString.cxx:87
 TString.cxx:88
 TString.cxx:89
 TString.cxx:90
 TString.cxx:91
 TString.cxx:92
 TString.cxx:93
 TString.cxx:94
 TString.cxx:95
 TString.cxx:96
 TString.cxx:97
 TString.cxx:98
 TString.cxx:99
 TString.cxx:100
 TString.cxx:101
 TString.cxx:102
 TString.cxx:103
 TString.cxx:104
 TString.cxx:105
 TString.cxx:106
 TString.cxx:107
 TString.cxx:108
 TString.cxx:109
 TString.cxx:110
 TString.cxx:111
 TString.cxx:112
 TString.cxx:113
 TString.cxx:114
 TString.cxx:115
 TString.cxx:116
 TString.cxx:117
 TString.cxx:118
 TString.cxx:119
 TString.cxx:120
 TString.cxx:121
 TString.cxx:122
 TString.cxx:123
 TString.cxx:124
 TString.cxx:125
 TString.cxx:126
 TString.cxx:127
 TString.cxx:128
 TString.cxx:129
 TString.cxx:130
 TString.cxx:131
 TString.cxx:132
 TString.cxx:133
 TString.cxx:134
 TString.cxx:135
 TString.cxx:136
 TString.cxx:137
 TString.cxx:138
 TString.cxx:139
 TString.cxx:140
 TString.cxx:141
 TString.cxx:142
 TString.cxx:143
 TString.cxx:144
 TString.cxx:145
 TString.cxx:146
 TString.cxx:147
 TString.cxx:148
 TString.cxx:149
 TString.cxx:150
 TString.cxx:151
 TString.cxx:152
 TString.cxx:153
 TString.cxx:154
 TString.cxx:155
 TString.cxx:156
 TString.cxx:157
 TString.cxx:158
 TString.cxx:159
 TString.cxx:160
 TString.cxx:161
 TString.cxx:162
 TString.cxx:163
 TString.cxx:164
 TString.cxx:165
 TString.cxx:166
 TString.cxx:167
 TString.cxx:168
 TString.cxx:169
 TString.cxx:170
 TString.cxx:171
 TString.cxx:172
 TString.cxx:173
 TString.cxx:174
 TString.cxx:175
 TString.cxx:176
 TString.cxx:177
 TString.cxx:178
 TString.cxx:179
 TString.cxx:180
 TString.cxx:181
 TString.cxx:182
 TString.cxx:183
 TString.cxx:184
 TString.cxx:185
 TString.cxx:186
 TString.cxx:187
 TString.cxx:188
 TString.cxx:189
 TString.cxx:190
 TString.cxx:191
 TString.cxx:192
 TString.cxx:193
 TString.cxx:194
 TString.cxx:195
 TString.cxx:196
 TString.cxx:197
 TString.cxx:198
 TString.cxx:199
 TString.cxx:200
 TString.cxx:201
 TString.cxx:202
 TString.cxx:203
 TString.cxx:204
 TString.cxx:205
 TString.cxx:206
 TString.cxx:207
 TString.cxx:208
 TString.cxx:209
 TString.cxx:210
 TString.cxx:211
 TString.cxx:212
 TString.cxx:213
 TString.cxx:214
 TString.cxx:215
 TString.cxx:216
 TString.cxx:217
 TString.cxx:218
 TString.cxx:219
 TString.cxx:220
 TString.cxx:221
 TString.cxx:222
 TString.cxx:223
 TString.cxx:224
 TString.cxx:225
 TString.cxx:226
 TString.cxx:227
 TString.cxx:228
 TString.cxx:229
 TString.cxx:230
 TString.cxx:231
 TString.cxx:232
 TString.cxx:233
 TString.cxx:234
 TString.cxx:235
 TString.cxx:236
 TString.cxx:237
 TString.cxx:238
 TString.cxx:239
 TString.cxx:240
 TString.cxx:241
 TString.cxx:242
 TString.cxx:243
 TString.cxx:244
 TString.cxx:245
 TString.cxx:246
 TString.cxx:247
 TString.cxx:248
 TString.cxx:249
 TString.cxx:250
 TString.cxx:251
 TString.cxx:252
 TString.cxx:253
 TString.cxx:254
 TString.cxx:255
 TString.cxx:256
 TString.cxx:257
 TString.cxx:258
 TString.cxx:259
 TString.cxx:260
 TString.cxx:261
 TString.cxx:262
 TString.cxx:263
 TString.cxx:264
 TString.cxx:265
 TString.cxx:266
 TString.cxx:267
 TString.cxx:268
 TString.cxx:269
 TString.cxx:270
 TString.cxx:271
 TString.cxx:272
 TString.cxx:273
 TString.cxx:274
 TString.cxx:275
 TString.cxx:276
 TString.cxx:277
 TString.cxx:278
 TString.cxx:279
 TString.cxx:280
 TString.cxx:281
 TString.cxx:282
 TString.cxx:283
 TString.cxx:284
 TString.cxx:285
 TString.cxx:286
 TString.cxx:287
 TString.cxx:288
 TString.cxx:289
 TString.cxx:290
 TString.cxx:291
 TString.cxx:292
 TString.cxx:293
 TString.cxx:294
 TString.cxx:295
 TString.cxx:296
 TString.cxx:297
 TString.cxx:298
 TString.cxx:299
 TString.cxx:300
 TString.cxx:301
 TString.cxx:302
 TString.cxx:303
 TString.cxx:304
 TString.cxx:305
 TString.cxx:306
 TString.cxx:307
 TString.cxx:308
 TString.cxx:309
 TString.cxx:310
 TString.cxx:311
 TString.cxx:312
 TString.cxx:313
 TString.cxx:314
 TString.cxx:315
 TString.cxx:316
 TString.cxx:317
 TString.cxx:318
 TString.cxx:319
 TString.cxx:320
 TString.cxx:321
 TString.cxx:322
 TString.cxx:323
 TString.cxx:324
 TString.cxx:325
 TString.cxx:326
 TString.cxx:327
 TString.cxx:328
 TString.cxx:329
 TString.cxx:330
 TString.cxx:331
 TString.cxx:332
 TString.cxx:333
 TString.cxx:334
 TString.cxx:335
 TString.cxx:336
 TString.cxx:337
 TString.cxx:338
 TString.cxx:339
 TString.cxx:340
 TString.cxx:341
 TString.cxx:342
 TString.cxx:343
 TString.cxx:344
 TString.cxx:345
 TString.cxx:346
 TString.cxx:347
 TString.cxx:348
 TString.cxx:349
 TString.cxx:350
 TString.cxx:351
 TString.cxx:352
 TString.cxx:353
 TString.cxx:354
 TString.cxx:355
 TString.cxx:356
 TString.cxx:357
 TString.cxx:358
 TString.cxx:359
 TString.cxx:360
 TString.cxx:361
 TString.cxx:362
 TString.cxx:363
 TString.cxx:364
 TString.cxx:365
 TString.cxx:366
 TString.cxx:367
 TString.cxx:368
 TString.cxx:369
 TString.cxx:370
 TString.cxx:371
 TString.cxx:372
 TString.cxx:373
 TString.cxx:374
 TString.cxx:375
 TString.cxx:376
 TString.cxx:377
 TString.cxx:378
 TString.cxx:379
 TString.cxx:380
 TString.cxx:381
 TString.cxx:382
 TString.cxx:383
 TString.cxx:384
 TString.cxx:385
 TString.cxx:386
 TString.cxx:387
 TString.cxx:388
 TString.cxx:389
 TString.cxx:390
 TString.cxx:391
 TString.cxx:392
 TString.cxx:393
 TString.cxx:394
 TString.cxx:395
 TString.cxx:396
 TString.cxx:397
 TString.cxx:398
 TString.cxx:399
 TString.cxx:400
 TString.cxx:401
 TString.cxx:402
 TString.cxx:403
 TString.cxx:404
 TString.cxx:405
 TString.cxx:406
 TString.cxx:407
 TString.cxx:408
 TString.cxx:409
 TString.cxx:410
 TString.cxx:411
 TString.cxx:412
 TString.cxx:413
 TString.cxx:414
 TString.cxx:415
 TString.cxx:416
 TString.cxx:417
 TString.cxx:418
 TString.cxx:419
 TString.cxx:420
 TString.cxx:421
 TString.cxx:422
 TString.cxx:423
 TString.cxx:424
 TString.cxx:425
 TString.cxx:426
 TString.cxx:427
 TString.cxx:428
 TString.cxx:429
 TString.cxx:430
 TString.cxx:431
 TString.cxx:432
 TString.cxx:433
 TString.cxx:434
 TString.cxx:435
 TString.cxx:436
 TString.cxx:437
 TString.cxx:438
 TString.cxx:439
 TString.cxx:440
 TString.cxx:441
 TString.cxx:442
 TString.cxx:443
 TString.cxx:444
 TString.cxx:445
 TString.cxx:446
 TString.cxx:447
 TString.cxx:448
 TString.cxx:449
 TString.cxx:450
 TString.cxx:451
 TString.cxx:452
 TString.cxx:453
 TString.cxx:454
 TString.cxx:455
 TString.cxx:456
 TString.cxx:457
 TString.cxx:458
 TString.cxx:459
 TString.cxx:460
 TString.cxx:461
 TString.cxx:462
 TString.cxx:463
 TString.cxx:464
 TString.cxx:465
 TString.cxx:466
 TString.cxx:467
 TString.cxx:468
 TString.cxx:469
 TString.cxx:470
 TString.cxx:471
 TString.cxx:472
 TString.cxx:473
 TString.cxx:474
 TString.cxx:475
 TString.cxx:476
 TString.cxx:477
 TString.cxx:478
 TString.cxx:479
 TString.cxx:480
 TString.cxx:481
 TString.cxx:482
 TString.cxx:483
 TString.cxx:484
 TString.cxx:485
 TString.cxx:486
 TString.cxx:487
 TString.cxx:488
 TString.cxx:489
 TString.cxx:490
 TString.cxx:491
 TString.cxx:492
 TString.cxx:493
 TString.cxx:494
 TString.cxx:495
 TString.cxx:496
 TString.cxx:497
 TString.cxx:498
 TString.cxx:499
 TString.cxx:500
 TString.cxx:501
 TString.cxx:502
 TString.cxx:503
 TString.cxx:504
 TString.cxx:505
 TString.cxx:506
 TString.cxx:507
 TString.cxx:508
 TString.cxx:509
 TString.cxx:510
 TString.cxx:511
 TString.cxx:512
 TString.cxx:513
 TString.cxx:514
 TString.cxx:515
 TString.cxx:516
 TString.cxx:517
 TString.cxx:518
 TString.cxx:519
 TString.cxx:520
 TString.cxx:521
 TString.cxx:522
 TString.cxx:523
 TString.cxx:524
 TString.cxx:525
 TString.cxx:526
 TString.cxx:527
 TString.cxx:528
 TString.cxx:529
 TString.cxx:530
 TString.cxx:531
 TString.cxx:532
 TString.cxx:533
 TString.cxx:534
 TString.cxx:535
 TString.cxx:536
 TString.cxx:537
 TString.cxx:538
 TString.cxx:539
 TString.cxx:540
 TString.cxx:541
 TString.cxx:542
 TString.cxx:543
 TString.cxx:544
 TString.cxx:545
 TString.cxx:546
 TString.cxx:547
 TString.cxx:548
 TString.cxx:549
 TString.cxx:550
 TString.cxx:551
 TString.cxx:552
 TString.cxx:553
 TString.cxx:554
 TString.cxx:555
 TString.cxx:556
 TString.cxx:557
 TString.cxx:558
 TString.cxx:559
 TString.cxx:560
 TString.cxx:561
 TString.cxx:562
 TString.cxx:563
 TString.cxx:564
 TString.cxx:565
 TString.cxx:566
 TString.cxx:567
 TString.cxx:568
 TString.cxx:569
 TString.cxx:570
 TString.cxx:571
 TString.cxx:572
 TString.cxx:573
 TString.cxx:574
 TString.cxx:575
 TString.cxx:576
 TString.cxx:577
 TString.cxx:578
 TString.cxx:579
 TString.cxx:580
 TString.cxx:581
 TString.cxx:582
 TString.cxx:583
 TString.cxx:584
 TString.cxx:585
 TString.cxx:586
 TString.cxx:587
 TString.cxx:588
 TString.cxx:589
 TString.cxx:590
 TString.cxx:591
 TString.cxx:592
 TString.cxx:593
 TString.cxx:594
 TString.cxx:595
 TString.cxx:596
 TString.cxx:597
 TString.cxx:598
 TString.cxx:599
 TString.cxx:600
 TString.cxx:601
 TString.cxx:602
 TString.cxx:603
 TString.cxx:604
 TString.cxx:605
 TString.cxx:606
 TString.cxx:607
 TString.cxx:608
 TString.cxx:609
 TString.cxx:610
 TString.cxx:611
 TString.cxx:612
 TString.cxx:613
 TString.cxx:614
 TString.cxx:615
 TString.cxx:616
 TString.cxx:617
 TString.cxx:618
 TString.cxx:619
 TString.cxx:620
 TString.cxx:621
 TString.cxx:622
 TString.cxx:623
 TString.cxx:624
 TString.cxx:625
 TString.cxx:626
 TString.cxx:627
 TString.cxx:628
 TString.cxx:629
 TString.cxx:630
 TString.cxx:631
 TString.cxx:632
 TString.cxx:633
 TString.cxx:634
 TString.cxx:635
 TString.cxx:636
 TString.cxx:637
 TString.cxx:638
 TString.cxx:639
 TString.cxx:640
 TString.cxx:641
 TString.cxx:642
 TString.cxx:643
 TString.cxx:644
 TString.cxx:645
 TString.cxx:646
 TString.cxx:647
 TString.cxx:648
 TString.cxx:649
 TString.cxx:650
 TString.cxx:651
 TString.cxx:652
 TString.cxx:653
 TString.cxx:654
 TString.cxx:655
 TString.cxx:656
 TString.cxx:657
 TString.cxx:658
 TString.cxx:659
 TString.cxx:660
 TString.cxx:661
 TString.cxx:662
 TString.cxx:663
 TString.cxx:664
 TString.cxx:665
 TString.cxx:666
 TString.cxx:667
 TString.cxx:668
 TString.cxx:669
 TString.cxx:670
 TString.cxx:671
 TString.cxx:672
 TString.cxx:673
 TString.cxx:674
 TString.cxx:675
 TString.cxx:676
 TString.cxx:677
 TString.cxx:678
 TString.cxx:679
 TString.cxx:680
 TString.cxx:681
 TString.cxx:682
 TString.cxx:683
 TString.cxx:684
 TString.cxx:685
 TString.cxx:686
 TString.cxx:687
 TString.cxx:688
 TString.cxx:689
 TString.cxx:690
 TString.cxx:691
 TString.cxx:692
 TString.cxx:693
 TString.cxx:694
 TString.cxx:695
 TString.cxx:696
 TString.cxx:697
 TString.cxx:698
 TString.cxx:699
 TString.cxx:700
 TString.cxx:701
 TString.cxx:702
 TString.cxx:703
 TString.cxx:704
 TString.cxx:705
 TString.cxx:706
 TString.cxx:707
 TString.cxx:708
 TString.cxx:709
 TString.cxx:710
 TString.cxx:711
 TString.cxx:712
 TString.cxx:713
 TString.cxx:714
 TString.cxx:715
 TString.cxx:716
 TString.cxx:717
 TString.cxx:718
 TString.cxx:719
 TString.cxx:720
 TString.cxx:721
 TString.cxx:722
 TString.cxx:723
 TString.cxx:724
 TString.cxx:725
 TString.cxx:726
 TString.cxx:727
 TString.cxx:728
 TString.cxx:729
 TString.cxx:730
 TString.cxx:731
 TString.cxx:732
 TString.cxx:733
 TString.cxx:734
 TString.cxx:735
 TString.cxx:736
 TString.cxx:737
 TString.cxx:738
 TString.cxx:739
 TString.cxx:740
 TString.cxx:741
 TString.cxx:742
 TString.cxx:743
 TString.cxx:744
 TString.cxx:745
 TString.cxx:746
 TString.cxx:747
 TString.cxx:748
 TString.cxx:749
 TString.cxx:750
 TString.cxx:751
 TString.cxx:752
 TString.cxx:753
 TString.cxx:754
 TString.cxx:755
 TString.cxx:756
 TString.cxx:757
 TString.cxx:758
 TString.cxx:759
 TString.cxx:760
 TString.cxx:761
 TString.cxx:762
 TString.cxx:763
 TString.cxx:764
 TString.cxx:765
 TString.cxx:766
 TString.cxx:767
 TString.cxx:768
 TString.cxx:769
 TString.cxx:770
 TString.cxx:771
 TString.cxx:772
 TString.cxx:773
 TString.cxx:774
 TString.cxx:775
 TString.cxx:776
 TString.cxx:777
 TString.cxx:778
 TString.cxx:779
 TString.cxx:780
 TString.cxx:781
 TString.cxx:782
 TString.cxx:783
 TString.cxx:784
 TString.cxx:785
 TString.cxx:786
 TString.cxx:787
 TString.cxx:788
 TString.cxx:789
 TString.cxx:790
 TString.cxx:791
 TString.cxx:792
 TString.cxx:793
 TString.cxx:794
 TString.cxx:795
 TString.cxx:796
 TString.cxx:797
 TString.cxx:798
 TString.cxx:799
 TString.cxx:800
 TString.cxx:801
 TString.cxx:802
 TString.cxx:803
 TString.cxx:804
 TString.cxx:805
 TString.cxx:806
 TString.cxx:807
 TString.cxx:808
 TString.cxx:809
 TString.cxx:810
 TString.cxx:811
 TString.cxx:812
 TString.cxx:813
 TString.cxx:814
 TString.cxx:815
 TString.cxx:816
 TString.cxx:817
 TString.cxx:818
 TString.cxx:819
 TString.cxx:820
 TString.cxx:821
 TString.cxx:822
 TString.cxx:823
 TString.cxx:824
 TString.cxx:825
 TString.cxx:826
 TString.cxx:827
 TString.cxx:828
 TString.cxx:829
 TString.cxx:830
 TString.cxx:831
 TString.cxx:832
 TString.cxx:833
 TString.cxx:834
 TString.cxx:835
 TString.cxx:836
 TString.cxx:837
 TString.cxx:838
 TString.cxx:839
 TString.cxx:840
 TString.cxx:841
 TString.cxx:842
 TString.cxx:843
 TString.cxx:844
 TString.cxx:845
 TString.cxx:846
 TString.cxx:847
 TString.cxx:848
 TString.cxx:849
 TString.cxx:850
 TString.cxx:851
 TString.cxx:852
 TString.cxx:853
 TString.cxx:854
 TString.cxx:855
 TString.cxx:856
 TString.cxx:857
 TString.cxx:858
 TString.cxx:859
 TString.cxx:860
 TString.cxx:861
 TString.cxx:862
 TString.cxx:863
 TString.cxx:864
 TString.cxx:865
 TString.cxx:866
 TString.cxx:867
 TString.cxx:868
 TString.cxx:869
 TString.cxx:870
 TString.cxx:871
 TString.cxx:872
 TString.cxx:873
 TString.cxx:874
 TString.cxx:875
 TString.cxx:876
 TString.cxx:877
 TString.cxx:878
 TString.cxx:879
 TString.cxx:880
 TString.cxx:881
 TString.cxx:882
 TString.cxx:883
 TString.cxx:884
 TString.cxx:885
 TString.cxx:886
 TString.cxx:887
 TString.cxx:888
 TString.cxx:889
 TString.cxx:890
 TString.cxx:891
 TString.cxx:892
 TString.cxx:893
 TString.cxx:894
 TString.cxx:895
 TString.cxx:896
 TString.cxx:897
 TString.cxx:898
 TString.cxx:899
 TString.cxx:900
 TString.cxx:901
 TString.cxx:902
 TString.cxx:903
 TString.cxx:904
 TString.cxx:905
 TString.cxx:906
 TString.cxx:907
 TString.cxx:908
 TString.cxx:909
 TString.cxx:910
 TString.cxx:911
 TString.cxx:912
 TString.cxx:913
 TString.cxx:914
 TString.cxx:915
 TString.cxx:916
 TString.cxx:917
 TString.cxx:918
 TString.cxx:919
 TString.cxx:920
 TString.cxx:921
 TString.cxx:922
 TString.cxx:923
 TString.cxx:924
 TString.cxx:925
 TString.cxx:926
 TString.cxx:927
 TString.cxx:928
 TString.cxx:929
 TString.cxx:930
 TString.cxx:931
 TString.cxx:932
 TString.cxx:933
 TString.cxx:934
 TString.cxx:935
 TString.cxx:936
 TString.cxx:937
 TString.cxx:938
 TString.cxx:939
 TString.cxx:940
 TString.cxx:941
 TString.cxx:942
 TString.cxx:943
 TString.cxx:944
 TString.cxx:945
 TString.cxx:946
 TString.cxx:947
 TString.cxx:948
 TString.cxx:949
 TString.cxx:950
 TString.cxx:951
 TString.cxx:952
 TString.cxx:953
 TString.cxx:954
 TString.cxx:955
 TString.cxx:956
 TString.cxx:957
 TString.cxx:958
 TString.cxx:959
 TString.cxx:960
 TString.cxx:961
 TString.cxx:962
 TString.cxx:963
 TString.cxx:964
 TString.cxx:965
 TString.cxx:966
 TString.cxx:967
 TString.cxx:968
 TString.cxx:969
 TString.cxx:970
 TString.cxx:971
 TString.cxx:972
 TString.cxx:973
 TString.cxx:974
 TString.cxx:975
 TString.cxx:976
 TString.cxx:977
 TString.cxx:978
 TString.cxx:979
 TString.cxx:980
 TString.cxx:981
 TString.cxx:982
 TString.cxx:983
 TString.cxx:984
 TString.cxx:985
 TString.cxx:986
 TString.cxx:987
 TString.cxx:988
 TString.cxx:989
 TString.cxx:990
 TString.cxx:991
 TString.cxx:992
 TString.cxx:993
 TString.cxx:994
 TString.cxx:995
 TString.cxx:996
 TString.cxx:997
 TString.cxx:998
 TString.cxx:999
 TString.cxx:1000
 TString.cxx:1001
 TString.cxx:1002
 TString.cxx:1003
 TString.cxx:1004
 TString.cxx:1005
 TString.cxx:1006
 TString.cxx:1007
 TString.cxx:1008
 TString.cxx:1009
 TString.cxx:1010
 TString.cxx:1011
 TString.cxx:1012
 TString.cxx:1013
 TString.cxx:1014
 TString.cxx:1015
 TString.cxx:1016
 TString.cxx:1017
 TString.cxx:1018
 TString.cxx:1019
 TString.cxx:1020
 TString.cxx:1021
 TString.cxx:1022
 TString.cxx:1023
 TString.cxx:1024
 TString.cxx:1025
 TString.cxx:1026
 TString.cxx:1027
 TString.cxx:1028
 TString.cxx:1029
 TString.cxx:1030
 TString.cxx:1031
 TString.cxx:1032
 TString.cxx:1033
 TString.cxx:1034
 TString.cxx:1035
 TString.cxx:1036
 TString.cxx:1037
 TString.cxx:1038
 TString.cxx:1039
 TString.cxx:1040
 TString.cxx:1041
 TString.cxx:1042
 TString.cxx:1043
 TString.cxx:1044
 TString.cxx:1045
 TString.cxx:1046
 TString.cxx:1047
 TString.cxx:1048
 TString.cxx:1049
 TString.cxx:1050
 TString.cxx:1051
 TString.cxx:1052
 TString.cxx:1053
 TString.cxx:1054
 TString.cxx:1055
 TString.cxx:1056
 TString.cxx:1057
 TString.cxx:1058
 TString.cxx:1059
 TString.cxx:1060
 TString.cxx:1061
 TString.cxx:1062
 TString.cxx:1063
 TString.cxx:1064
 TString.cxx:1065
 TString.cxx:1066
 TString.cxx:1067
 TString.cxx:1068
 TString.cxx:1069
 TString.cxx:1070
 TString.cxx:1071
 TString.cxx:1072
 TString.cxx:1073
 TString.cxx:1074
 TString.cxx:1075
 TString.cxx:1076
 TString.cxx:1077
 TString.cxx:1078
 TString.cxx:1079
 TString.cxx:1080
 TString.cxx:1081
 TString.cxx:1082
 TString.cxx:1083
 TString.cxx:1084
 TString.cxx:1085
 TString.cxx:1086
 TString.cxx:1087
 TString.cxx:1088
 TString.cxx:1089
 TString.cxx:1090
 TString.cxx:1091
 TString.cxx:1092
 TString.cxx:1093
 TString.cxx:1094
 TString.cxx:1095
 TString.cxx:1096
 TString.cxx:1097
 TString.cxx:1098
 TString.cxx:1099
 TString.cxx:1100
 TString.cxx:1101
 TString.cxx:1102
 TString.cxx:1103
 TString.cxx:1104
 TString.cxx:1105
 TString.cxx:1106
 TString.cxx:1107
 TString.cxx:1108
 TString.cxx:1109
 TString.cxx:1110
 TString.cxx:1111
 TString.cxx:1112
 TString.cxx:1113
 TString.cxx:1114
 TString.cxx:1115
 TString.cxx:1116
 TString.cxx:1117
 TString.cxx:1118
 TString.cxx:1119
 TString.cxx:1120
 TString.cxx:1121
 TString.cxx:1122
 TString.cxx:1123
 TString.cxx:1124
 TString.cxx:1125
 TString.cxx:1126
 TString.cxx:1127
 TString.cxx:1128
 TString.cxx:1129
 TString.cxx:1130
 TString.cxx:1131
 TString.cxx:1132
 TString.cxx:1133
 TString.cxx:1134
 TString.cxx:1135
 TString.cxx:1136
 TString.cxx:1137
 TString.cxx:1138
 TString.cxx:1139
 TString.cxx:1140
 TString.cxx:1141
 TString.cxx:1142
 TString.cxx:1143
 TString.cxx:1144
 TString.cxx:1145
 TString.cxx:1146
 TString.cxx:1147
 TString.cxx:1148
 TString.cxx:1149
 TString.cxx:1150
 TString.cxx:1151
 TString.cxx:1152
 TString.cxx:1153
 TString.cxx:1154
 TString.cxx:1155
 TString.cxx:1156
 TString.cxx:1157
 TString.cxx:1158
 TString.cxx:1159
 TString.cxx:1160
 TString.cxx:1161
 TString.cxx:1162
 TString.cxx:1163
 TString.cxx:1164
 TString.cxx:1165
 TString.cxx:1166
 TString.cxx:1167
 TString.cxx:1168
 TString.cxx:1169
 TString.cxx:1170
 TString.cxx:1171
 TString.cxx:1172
 TString.cxx:1173
 TString.cxx:1174
 TString.cxx:1175
 TString.cxx:1176
 TString.cxx:1177
 TString.cxx:1178
 TString.cxx:1179
 TString.cxx:1180
 TString.cxx:1181
 TString.cxx:1182
 TString.cxx:1183
 TString.cxx:1184
 TString.cxx:1185
 TString.cxx:1186
 TString.cxx:1187
 TString.cxx:1188
 TString.cxx:1189
 TString.cxx:1190
 TString.cxx:1191
 TString.cxx:1192
 TString.cxx:1193
 TString.cxx:1194
 TString.cxx:1195
 TString.cxx:1196
 TString.cxx:1197
 TString.cxx:1198
 TString.cxx:1199
 TString.cxx:1200
 TString.cxx:1201
 TString.cxx:1202
 TString.cxx:1203
 TString.cxx:1204
 TString.cxx:1205
 TString.cxx:1206
 TString.cxx:1207
 TString.cxx:1208
 TString.cxx:1209
 TString.cxx:1210
 TString.cxx:1211
 TString.cxx:1212
 TString.cxx:1213
 TString.cxx:1214
 TString.cxx:1215
 TString.cxx:1216
 TString.cxx:1217
 TString.cxx:1218
 TString.cxx:1219
 TString.cxx:1220
 TString.cxx:1221
 TString.cxx:1222
 TString.cxx:1223
 TString.cxx:1224
 TString.cxx:1225
 TString.cxx:1226
 TString.cxx:1227
 TString.cxx:1228
 TString.cxx:1229
 TString.cxx:1230
 TString.cxx:1231
 TString.cxx:1232
 TString.cxx:1233
 TString.cxx:1234
 TString.cxx:1235
 TString.cxx:1236
 TString.cxx:1237
 TString.cxx:1238
 TString.cxx:1239
 TString.cxx:1240
 TString.cxx:1241
 TString.cxx:1242
 TString.cxx:1243
 TString.cxx:1244
 TString.cxx:1245
 TString.cxx:1246
 TString.cxx:1247
 TString.cxx:1248
 TString.cxx:1249
 TString.cxx:1250
 TString.cxx:1251
 TString.cxx:1252
 TString.cxx:1253
 TString.cxx:1254
 TString.cxx:1255
 TString.cxx:1256
 TString.cxx:1257
 TString.cxx:1258
 TString.cxx:1259
 TString.cxx:1260
 TString.cxx:1261
 TString.cxx:1262
 TString.cxx:1263
 TString.cxx:1264
 TString.cxx:1265
 TString.cxx:1266
 TString.cxx:1267
 TString.cxx:1268
 TString.cxx:1269
 TString.cxx:1270
 TString.cxx:1271
 TString.cxx:1272
 TString.cxx:1273
 TString.cxx:1274
 TString.cxx:1275
 TString.cxx:1276
 TString.cxx:1277
 TString.cxx:1278
 TString.cxx:1279
 TString.cxx:1280
 TString.cxx:1281
 TString.cxx:1282
 TString.cxx:1283
 TString.cxx:1284
 TString.cxx:1285
 TString.cxx:1286
 TString.cxx:1287
 TString.cxx:1288
 TString.cxx:1289
 TString.cxx:1290
 TString.cxx:1291
 TString.cxx:1292
 TString.cxx:1293
 TString.cxx:1294
 TString.cxx:1295
 TString.cxx:1296
 TString.cxx:1297
 TString.cxx:1298
 TString.cxx:1299
 TString.cxx:1300
 TString.cxx:1301
 TString.cxx:1302
 TString.cxx:1303
 TString.cxx:1304
 TString.cxx:1305
 TString.cxx:1306
 TString.cxx:1307
 TString.cxx:1308
 TString.cxx:1309
 TString.cxx:1310
 TString.cxx:1311
 TString.cxx:1312
 TString.cxx:1313
 TString.cxx:1314
 TString.cxx:1315
 TString.cxx:1316
 TString.cxx:1317
 TString.cxx:1318
 TString.cxx:1319
 TString.cxx:1320
 TString.cxx:1321
 TString.cxx:1322
 TString.cxx:1323
 TString.cxx:1324
 TString.cxx:1325
 TString.cxx:1326
 TString.cxx:1327
 TString.cxx:1328
 TString.cxx:1329
 TString.cxx:1330
 TString.cxx:1331
 TString.cxx:1332
 TString.cxx:1333
 TString.cxx:1334
 TString.cxx:1335
 TString.cxx:1336
 TString.cxx:1337
 TString.cxx:1338
 TString.cxx:1339
 TString.cxx:1340
 TString.cxx:1341
 TString.cxx:1342
 TString.cxx:1343
 TString.cxx:1344
 TString.cxx:1345
 TString.cxx:1346
 TString.cxx:1347
 TString.cxx:1348
 TString.cxx:1349
 TString.cxx:1350
 TString.cxx:1351
 TString.cxx:1352
 TString.cxx:1353
 TString.cxx:1354
 TString.cxx:1355
 TString.cxx:1356
 TString.cxx:1357
 TString.cxx:1358
 TString.cxx:1359
 TString.cxx:1360
 TString.cxx:1361
 TString.cxx:1362
 TString.cxx:1363
 TString.cxx:1364
 TString.cxx:1365
 TString.cxx:1366
 TString.cxx:1367
 TString.cxx:1368
 TString.cxx:1369
 TString.cxx:1370
 TString.cxx:1371
 TString.cxx:1372
 TString.cxx:1373
 TString.cxx:1374
 TString.cxx:1375
 TString.cxx:1376
 TString.cxx:1377
 TString.cxx:1378
 TString.cxx:1379
 TString.cxx:1380
 TString.cxx:1381
 TString.cxx:1382
 TString.cxx:1383
 TString.cxx:1384
 TString.cxx:1385
 TString.cxx:1386
 TString.cxx:1387
 TString.cxx:1388
 TString.cxx:1389
 TString.cxx:1390
 TString.cxx:1391
 TString.cxx:1392
 TString.cxx:1393
 TString.cxx:1394
 TString.cxx:1395
 TString.cxx:1396
 TString.cxx:1397
 TString.cxx:1398
 TString.cxx:1399
 TString.cxx:1400
 TString.cxx:1401
 TString.cxx:1402
 TString.cxx:1403
 TString.cxx:1404
 TString.cxx:1405
 TString.cxx:1406
 TString.cxx:1407
 TString.cxx:1408
 TString.cxx:1409
 TString.cxx:1410
 TString.cxx:1411
 TString.cxx:1412
 TString.cxx:1413
 TString.cxx:1414
 TString.cxx:1415
 TString.cxx:1416
 TString.cxx:1417
 TString.cxx:1418
 TString.cxx:1419
 TString.cxx:1420
 TString.cxx:1421
 TString.cxx:1422
 TString.cxx:1423
 TString.cxx:1424
 TString.cxx:1425
 TString.cxx:1426
 TString.cxx:1427
 TString.cxx:1428
 TString.cxx:1429
 TString.cxx:1430
 TString.cxx:1431
 TString.cxx:1432
 TString.cxx:1433
 TString.cxx:1434
 TString.cxx:1435
 TString.cxx:1436
 TString.cxx:1437
 TString.cxx:1438
 TString.cxx:1439
 TString.cxx:1440
 TString.cxx:1441
 TString.cxx:1442
 TString.cxx:1443
 TString.cxx:1444
 TString.cxx:1445
 TString.cxx:1446
 TString.cxx:1447
 TString.cxx:1448
 TString.cxx:1449
 TString.cxx:1450
 TString.cxx:1451
 TString.cxx:1452
 TString.cxx:1453
 TString.cxx:1454
 TString.cxx:1455
 TString.cxx:1456
 TString.cxx:1457
 TString.cxx:1458
 TString.cxx:1459
 TString.cxx:1460
 TString.cxx:1461
 TString.cxx:1462
 TString.cxx:1463
 TString.cxx:1464
 TString.cxx:1465
 TString.cxx:1466
 TString.cxx:1467
 TString.cxx:1468
 TString.cxx:1469
 TString.cxx:1470
 TString.cxx:1471
 TString.cxx:1472
 TString.cxx:1473
 TString.cxx:1474
 TString.cxx:1475
 TString.cxx:1476
 TString.cxx:1477
 TString.cxx:1478
 TString.cxx:1479
 TString.cxx:1480
 TString.cxx:1481
 TString.cxx:1482
 TString.cxx:1483
 TString.cxx:1484
 TString.cxx:1485
 TString.cxx:1486
 TString.cxx:1487
 TString.cxx:1488
 TString.cxx:1489
 TString.cxx:1490
 TString.cxx:1491
 TString.cxx:1492
 TString.cxx:1493
 TString.cxx:1494
 TString.cxx:1495
 TString.cxx:1496
 TString.cxx:1497
 TString.cxx:1498
 TString.cxx:1499
 TString.cxx:1500
 TString.cxx:1501
 TString.cxx:1502
 TString.cxx:1503
 TString.cxx:1504
 TString.cxx:1505
 TString.cxx:1506
 TString.cxx:1507
 TString.cxx:1508
 TString.cxx:1509
 TString.cxx:1510
 TString.cxx:1511
 TString.cxx:1512
 TString.cxx:1513
 TString.cxx:1514
 TString.cxx:1515
 TString.cxx:1516
 TString.cxx:1517
 TString.cxx:1518
 TString.cxx:1519
 TString.cxx:1520
 TString.cxx:1521
 TString.cxx:1522
 TString.cxx:1523
 TString.cxx:1524
 TString.cxx:1525
 TString.cxx:1526
 TString.cxx:1527
 TString.cxx:1528
 TString.cxx:1529
 TString.cxx:1530
 TString.cxx:1531
 TString.cxx:1532
 TString.cxx:1533
 TString.cxx:1534
 TString.cxx:1535
 TString.cxx:1536
 TString.cxx:1537
 TString.cxx:1538
 TString.cxx:1539
 TString.cxx:1540
 TString.cxx:1541
 TString.cxx:1542
 TString.cxx:1543
 TString.cxx:1544
 TString.cxx:1545
 TString.cxx:1546
 TString.cxx:1547
 TString.cxx:1548
 TString.cxx:1549
 TString.cxx:1550
 TString.cxx:1551
 TString.cxx:1552
 TString.cxx:1553
 TString.cxx:1554
 TString.cxx:1555
 TString.cxx:1556
 TString.cxx:1557
 TString.cxx:1558
 TString.cxx:1559
 TString.cxx:1560
 TString.cxx:1561
 TString.cxx:1562
 TString.cxx:1563
 TString.cxx:1564
 TString.cxx:1565
 TString.cxx:1566
 TString.cxx:1567
 TString.cxx:1568
 TString.cxx:1569
 TString.cxx:1570
 TString.cxx:1571
 TString.cxx:1572
 TString.cxx:1573
 TString.cxx:1574
 TString.cxx:1575
 TString.cxx:1576
 TString.cxx:1577
 TString.cxx:1578
 TString.cxx:1579
 TString.cxx:1580
 TString.cxx:1581
 TString.cxx:1582
 TString.cxx:1583
 TString.cxx:1584
 TString.cxx:1585
 TString.cxx:1586
 TString.cxx:1587
 TString.cxx:1588
 TString.cxx:1589
 TString.cxx:1590
 TString.cxx:1591
 TString.cxx:1592
 TString.cxx:1593
 TString.cxx:1594
 TString.cxx:1595
 TString.cxx:1596
 TString.cxx:1597
 TString.cxx:1598
 TString.cxx:1599
 TString.cxx:1600
 TString.cxx:1601
 TString.cxx:1602
 TString.cxx:1603
 TString.cxx:1604
 TString.cxx:1605
 TString.cxx:1606
 TString.cxx:1607
 TString.cxx:1608
 TString.cxx:1609
 TString.cxx:1610
 TString.cxx:1611
 TString.cxx:1612
 TString.cxx:1613
 TString.cxx:1614
 TString.cxx:1615
 TString.cxx:1616
 TString.cxx:1617
 TString.cxx:1618
 TString.cxx:1619
 TString.cxx:1620
 TString.cxx:1621
 TString.cxx:1622
 TString.cxx:1623
 TString.cxx:1624
 TString.cxx:1625
 TString.cxx:1626
 TString.cxx:1627
 TString.cxx:1628
 TString.cxx:1629
 TString.cxx:1630
 TString.cxx:1631
 TString.cxx:1632
 TString.cxx:1633
 TString.cxx:1634
 TString.cxx:1635
 TString.cxx:1636
 TString.cxx:1637
 TString.cxx:1638
 TString.cxx:1639
 TString.cxx:1640
 TString.cxx:1641
 TString.cxx:1642
 TString.cxx:1643
 TString.cxx:1644
 TString.cxx:1645
 TString.cxx:1646
 TString.cxx:1647
 TString.cxx:1648
 TString.cxx:1649
 TString.cxx:1650
 TString.cxx:1651
 TString.cxx:1652
 TString.cxx:1653
 TString.cxx:1654
 TString.cxx:1655
 TString.cxx:1656
 TString.cxx:1657
 TString.cxx:1658
 TString.cxx:1659
 TString.cxx:1660
 TString.cxx:1661
 TString.cxx:1662
 TString.cxx:1663
 TString.cxx:1664
 TString.cxx:1665
 TString.cxx:1666
 TString.cxx:1667
 TString.cxx:1668
 TString.cxx:1669
 TString.cxx:1670
 TString.cxx:1671
 TString.cxx:1672
 TString.cxx:1673
 TString.cxx:1674
 TString.cxx:1675
 TString.cxx:1676
 TString.cxx:1677
 TString.cxx:1678
 TString.cxx:1679
 TString.cxx:1680
 TString.cxx:1681
 TString.cxx:1682
 TString.cxx:1683
 TString.cxx:1684
 TString.cxx:1685
 TString.cxx:1686
 TString.cxx:1687
 TString.cxx:1688
 TString.cxx:1689
 TString.cxx:1690
 TString.cxx:1691
 TString.cxx:1692
 TString.cxx:1693
 TString.cxx:1694
 TString.cxx:1695
 TString.cxx:1696
 TString.cxx:1697
 TString.cxx:1698
 TString.cxx:1699
 TString.cxx:1700
 TString.cxx:1701
 TString.cxx:1702
 TString.cxx:1703
 TString.cxx:1704
 TString.cxx:1705
 TString.cxx:1706
 TString.cxx:1707
 TString.cxx:1708
 TString.cxx:1709
 TString.cxx:1710
 TString.cxx:1711
 TString.cxx:1712
 TString.cxx:1713
 TString.cxx:1714
 TString.cxx:1715
 TString.cxx:1716
 TString.cxx:1717
 TString.cxx:1718
 TString.cxx:1719
 TString.cxx:1720
 TString.cxx:1721
 TString.cxx:1722
 TString.cxx:1723
 TString.cxx:1724
 TString.cxx:1725
 TString.cxx:1726
 TString.cxx:1727
 TString.cxx:1728
 TString.cxx:1729
 TString.cxx:1730
 TString.cxx:1731
 TString.cxx:1732
 TString.cxx:1733
 TString.cxx:1734
 TString.cxx:1735
 TString.cxx:1736
 TString.cxx:1737
 TString.cxx:1738
 TString.cxx:1739
 TString.cxx:1740
 TString.cxx:1741
 TString.cxx:1742
 TString.cxx:1743
 TString.cxx:1744
 TString.cxx:1745
 TString.cxx:1746
 TString.cxx:1747
 TString.cxx:1748
 TString.cxx:1749
 TString.cxx:1750
 TString.cxx:1751
 TString.cxx:1752
 TString.cxx:1753
 TString.cxx:1754
 TString.cxx:1755
 TString.cxx:1756
 TString.cxx:1757
 TString.cxx:1758
 TString.cxx:1759
 TString.cxx:1760
 TString.cxx:1761
 TString.cxx:1762
 TString.cxx:1763
 TString.cxx:1764
 TString.cxx:1765
 TString.cxx:1766
 TString.cxx:1767
 TString.cxx:1768
 TString.cxx:1769
 TString.cxx:1770
 TString.cxx:1771
 TString.cxx:1772
 TString.cxx:1773
 TString.cxx:1774
 TString.cxx:1775
 TString.cxx:1776
 TString.cxx:1777
 TString.cxx:1778
 TString.cxx:1779
 TString.cxx:1780
 TString.cxx:1781
 TString.cxx:1782
 TString.cxx:1783
 TString.cxx:1784
 TString.cxx:1785
 TString.cxx:1786
 TString.cxx:1787
 TString.cxx:1788
 TString.cxx:1789
 TString.cxx:1790
 TString.cxx:1791
 TString.cxx:1792
 TString.cxx:1793
 TString.cxx:1794
 TString.cxx:1795
 TString.cxx:1796
 TString.cxx:1797
 TString.cxx:1798
 TString.cxx:1799
 TString.cxx:1800
 TString.cxx:1801
 TString.cxx:1802
 TString.cxx:1803
 TString.cxx:1804
 TString.cxx:1805
 TString.cxx:1806
 TString.cxx:1807
 TString.cxx:1808
 TString.cxx:1809
 TString.cxx:1810
 TString.cxx:1811
 TString.cxx:1812
 TString.cxx:1813
 TString.cxx:1814
 TString.cxx:1815
 TString.cxx:1816
 TString.cxx:1817
 TString.cxx:1818
 TString.cxx:1819
 TString.cxx:1820
 TString.cxx:1821
 TString.cxx:1822
 TString.cxx:1823
 TString.cxx:1824
 TString.cxx:1825
 TString.cxx:1826
 TString.cxx:1827
 TString.cxx:1828
 TString.cxx:1829
 TString.cxx:1830
 TString.cxx:1831
 TString.cxx:1832
 TString.cxx:1833
 TString.cxx:1834
 TString.cxx:1835
 TString.cxx:1836
 TString.cxx:1837
 TString.cxx:1838
 TString.cxx:1839
 TString.cxx:1840
 TString.cxx:1841
 TString.cxx:1842
 TString.cxx:1843
 TString.cxx:1844
 TString.cxx:1845
 TString.cxx:1846
 TString.cxx:1847
 TString.cxx:1848
 TString.cxx:1849
 TString.cxx:1850
 TString.cxx:1851
 TString.cxx:1852
 TString.cxx:1853
 TString.cxx:1854
 TString.cxx:1855
 TString.cxx:1856
 TString.cxx:1857
 TString.cxx:1858
 TString.cxx:1859
 TString.cxx:1860
 TString.cxx:1861
 TString.cxx:1862
 TString.cxx:1863
 TString.cxx:1864
 TString.cxx:1865
 TString.cxx:1866
 TString.cxx:1867
 TString.cxx:1868
 TString.cxx:1869
 TString.cxx:1870
 TString.cxx:1871
 TString.cxx:1872
 TString.cxx:1873
 TString.cxx:1874
 TString.cxx:1875
 TString.cxx:1876
 TString.cxx:1877
 TString.cxx:1878
 TString.cxx:1879
 TString.cxx:1880
 TString.cxx:1881
 TString.cxx:1882
 TString.cxx:1883
 TString.cxx:1884
 TString.cxx:1885
 TString.cxx:1886
 TString.cxx:1887
 TString.cxx:1888
 TString.cxx:1889
 TString.cxx:1890
 TString.cxx:1891
 TString.cxx:1892
 TString.cxx:1893
 TString.cxx:1894
 TString.cxx:1895
 TString.cxx:1896
 TString.cxx:1897
 TString.cxx:1898
 TString.cxx:1899
 TString.cxx:1900
 TString.cxx:1901
 TString.cxx:1902
 TString.cxx:1903
 TString.cxx:1904
 TString.cxx:1905
 TString.cxx:1906
 TString.cxx:1907
 TString.cxx:1908
 TString.cxx:1909
 TString.cxx:1910
 TString.cxx:1911
 TString.cxx:1912
 TString.cxx:1913
 TString.cxx:1914
 TString.cxx:1915
 TString.cxx:1916
 TString.cxx:1917
 TString.cxx:1918
 TString.cxx:1919
 TString.cxx:1920
 TString.cxx:1921
 TString.cxx:1922
 TString.cxx:1923
 TString.cxx:1924
 TString.cxx:1925
 TString.cxx:1926
 TString.cxx:1927
 TString.cxx:1928
 TString.cxx:1929
 TString.cxx:1930
 TString.cxx:1931
 TString.cxx:1932
 TString.cxx:1933
 TString.cxx:1934
 TString.cxx:1935
 TString.cxx:1936
 TString.cxx:1937
 TString.cxx:1938
 TString.cxx:1939
 TString.cxx:1940
 TString.cxx:1941
 TString.cxx:1942
 TString.cxx:1943
 TString.cxx:1944
 TString.cxx:1945
 TString.cxx:1946
 TString.cxx:1947
 TString.cxx:1948
 TString.cxx:1949
 TString.cxx:1950
 TString.cxx:1951
 TString.cxx:1952
 TString.cxx:1953
 TString.cxx:1954
 TString.cxx:1955
 TString.cxx:1956
 TString.cxx:1957
 TString.cxx:1958
 TString.cxx:1959
 TString.cxx:1960
 TString.cxx:1961
 TString.cxx:1962
 TString.cxx:1963
 TString.cxx:1964
 TString.cxx:1965
 TString.cxx:1966
 TString.cxx:1967
 TString.cxx:1968
 TString.cxx:1969
 TString.cxx:1970
 TString.cxx:1971
 TString.cxx:1972
 TString.cxx:1973
 TString.cxx:1974
 TString.cxx:1975
 TString.cxx:1976
 TString.cxx:1977
 TString.cxx:1978
 TString.cxx:1979
 TString.cxx:1980
 TString.cxx:1981
 TString.cxx:1982
 TString.cxx:1983
 TString.cxx:1984
 TString.cxx:1985
 TString.cxx:1986
 TString.cxx:1987
 TString.cxx:1988
 TString.cxx:1989
 TString.cxx:1990
 TString.cxx:1991
 TString.cxx:1992
 TString.cxx:1993
 TString.cxx:1994
 TString.cxx:1995
 TString.cxx:1996
 TString.cxx:1997
 TString.cxx:1998
 TString.cxx:1999
 TString.cxx:2000
 TString.cxx:2001
 TString.cxx:2002
 TString.cxx:2003
 TString.cxx:2004
 TString.cxx:2005
 TString.cxx:2006
 TString.cxx:2007
 TString.cxx:2008
 TString.cxx:2009
 TString.cxx:2010
 TString.cxx:2011
 TString.cxx:2012
 TString.cxx:2013
 TString.cxx:2014
 TString.cxx:2015
 TString.cxx:2016
 TString.cxx:2017
 TString.cxx:2018
 TString.cxx:2019
 TString.cxx:2020
 TString.cxx:2021
 TString.cxx:2022
 TString.cxx:2023
 TString.cxx:2024
 TString.cxx:2025
 TString.cxx:2026
 TString.cxx:2027
 TString.cxx:2028
 TString.cxx:2029
 TString.cxx:2030
 TString.cxx:2031
 TString.cxx:2032
 TString.cxx:2033
 TString.cxx:2034
 TString.cxx:2035
 TString.cxx:2036
 TString.cxx:2037
 TString.cxx:2038
 TString.cxx:2039
 TString.cxx:2040
 TString.cxx:2041
 TString.cxx:2042
 TString.cxx:2043
 TString.cxx:2044
 TString.cxx:2045
 TString.cxx:2046
 TString.cxx:2047
 TString.cxx:2048
 TString.cxx:2049
 TString.cxx:2050
 TString.cxx:2051
 TString.cxx:2052
 TString.cxx:2053
 TString.cxx:2054
 TString.cxx:2055
 TString.cxx:2056
 TString.cxx:2057
 TString.cxx:2058
 TString.cxx:2059
 TString.cxx:2060
 TString.cxx:2061
 TString.cxx:2062
 TString.cxx:2063
 TString.cxx:2064
 TString.cxx:2065
 TString.cxx:2066
 TString.cxx:2067
 TString.cxx:2068
 TString.cxx:2069
 TString.cxx:2070
 TString.cxx:2071
 TString.cxx:2072
 TString.cxx:2073
 TString.cxx:2074
 TString.cxx:2075
 TString.cxx:2076
 TString.cxx:2077
 TString.cxx:2078
 TString.cxx:2079
 TString.cxx:2080
 TString.cxx:2081
 TString.cxx:2082
 TString.cxx:2083
 TString.cxx:2084
 TString.cxx:2085
 TString.cxx:2086
 TString.cxx:2087
 TString.cxx:2088
 TString.cxx:2089
 TString.cxx:2090
 TString.cxx:2091
 TString.cxx:2092
 TString.cxx:2093
 TString.cxx:2094
 TString.cxx:2095
 TString.cxx:2096
 TString.cxx:2097
 TString.cxx:2098
 TString.cxx:2099
 TString.cxx:2100
 TString.cxx:2101
 TString.cxx:2102
 TString.cxx:2103
 TString.cxx:2104
 TString.cxx:2105
 TString.cxx:2106
 TString.cxx:2107
 TString.cxx:2108
 TString.cxx:2109
 TString.cxx:2110
 TString.cxx:2111
 TString.cxx:2112
 TString.cxx:2113
 TString.cxx:2114
 TString.cxx:2115
 TString.cxx:2116
 TString.cxx:2117
 TString.cxx:2118
 TString.cxx:2119
 TString.cxx:2120
 TString.cxx:2121
 TString.cxx:2122
 TString.cxx:2123
 TString.cxx:2124
 TString.cxx:2125
 TString.cxx:2126
 TString.cxx:2127
 TString.cxx:2128
 TString.cxx:2129
 TString.cxx:2130
 TString.cxx:2131
 TString.cxx:2132
 TString.cxx:2133
 TString.cxx:2134
 TString.cxx:2135
 TString.cxx:2136
 TString.cxx:2137
 TString.cxx:2138
 TString.cxx:2139
 TString.cxx:2140
 TString.cxx:2141
 TString.cxx:2142
 TString.cxx:2143
 TString.cxx:2144
 TString.cxx:2145
 TString.cxx:2146
 TString.cxx:2147
 TString.cxx:2148
 TString.cxx:2149
 TString.cxx:2150
 TString.cxx:2151
 TString.cxx:2152
 TString.cxx:2153