EST_String.cc

Go to the documentation of this file.

 /*************************************************************************/
 /*                                                                       */
 /*                Centre for Speech Technology Research                  */
 /*                     University of Edinburgh, UK                       */
 /*                        Copyright (c) 1997                             */
 /*                        All Rights Reserved.                           */
 /*                                                                       */
 /*  Permission is hereby granted, free of charge, to use and distribute */
 /*  this software and its documentation without restriction, including  */
 /*  without limitation the rights to use, copy, modify, merge, publish, */
 /*  distribute, sublicense, and/or sell copies of this work, and to     */
 /*  permit persons to whom this work is furnished to do so, subject to  */
 /*  the following conditions:                                           */
 /*   1. The code must retain the above copyright notice, this list of   */
 /*      conditions and the following disclaimer.                        */
 /*   2. Any modifications must be clearly marked as such.               */
 /*   3. Original authors' names are not deleted.                        */
 /*   4. The authors' names are not used to endorse or promote products  */
 /*      derived from this software without specific prior written       */
 /*      permission.                                                     */
 /*                                                                       */
 /*  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        */
 /*  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      */
 /*  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   */
 /*  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     */
 /*  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    */
 /*  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   */
 /*  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          */
 /*  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       */
 /*  THIS SOFTWARE.                                                       */
 /*                                                                       */
 /*************************************************************************/
 /*               Authors :  Alan W Black (awb@cstr.ed.ac.uk)             */
 /*                Date   :  January, February 1997                       */
 /*  -------------------------------------------------------------------- */
 /*                                                                       */
 /*  A non-GNU implementation of a EST_String class to use with non-G++   */
 /*  compilers.                                                           */
 /*                                                                       */
 /*  Note this is not a full implementation of libg++'s EST_String class  */
 /*  just the bits we need                                                */
 /*                                                                       */
 /*************************************************************************/


#include <iostream>
#include <cstring>
#include <cstdio>
#include <cctype>
#include "EST_String.h"
// #include "EST_error.h"
#include "string_version.h"
#include "EST_math.h"

extern "C" {
#include "regexp.h"
}

const char *EST_String::version = "CSTR String Class " STRING_VERSION " " STRING_DATE;

const EST_String EST_String::Empty("");

EST_String EST_String_nullString = "";

struct subst {
  EST_String::EST_string_size start, end;
  char *s;
  int slen;
} ;

#if !__GSUB_REENTRANT__
static struct subst *substitutions=NULL;
size_t num_substitutions=0;
#endif
  

 /********************************************************************\
 *                                                                    *
 * Locate is the basic utility method behind many of the              *
 * manipulations, it finds something in a EST_String, returns a       *
 * success or failure flag and sets start and end to where it was.    *
 *                                                                    *
 \********************************************************************/

size_t EST_String::locate(const char *s, size_t len, ssize_t from, size_t &start, size_t &end) const
{
  CHECK_STRING_ARG(s);
      
  const char *sub=NULL;

  if (!s)
    return 0;

  if (from < 0 && -from < (ssize_t) size)
    {
      size_t endpos=size+from+1;
      size_t p=0;
      const char *nextsub;

      while ((nextsub=strstr(str()+p, s)))
    {
      p=nextsub-str()+1;
      if (p > endpos)
        break;
      sub=nextsub;
    }
    }
  else if (from>=0 && from <= (ssize_t) size)
    sub= strstr(str()+from, s);
  
  if (sub != NULL)
    {
      start = sub-str();
      end = start + len;
      return 1;
    }
  else
    {
      return 0;
    }

}

size_t EST_String::locate(EST_Regex &ex, ssize_t from, size_t &start, size_t &end, size_t *starts, size_t *ends) const
{
  size_t match_start, match_end;

  if (from < 0 && -from < (ssize_t) size)
    {
      size_t endpos=size+from+1;
      size_t p=0;
      int found=0;

      while (ex.run(str(), p, match_start, match_end, starts, ends))
    {
      found++;
      start=match_start;
      end=match_end;
      p = match_start+1;
      if (p > endpos)
        break;
    }
      return found >0;
    }
  else if (from >=0 && from <= (ssize_t) size)
    {
      if (ex.run(str(), from, match_start, match_end, starts, ends))
    {
      start = match_start;
      end=match_end;
      return 1;
    }
      else
    return 0;
    }
  else
    return 0;
}

int EST_String::extract(const char *s, size_t len, ssize_t pos, size_t &start, size_t &end) const
{
  CHECK_STRING_ARG(s);
      
  if (!s)
    return 0;

  if (pos < 0)
    return locate(s, len, 0, start, end);

  if (pos <= (ssize_t) (size-len) && memcmp(str()+pos, s, len)==0)
    {
      start = pos;
      end = pos + len;
      return 1;
    }
  else
      return 0;
}

int EST_String::extract(EST_Regex &ex, ssize_t pos, size_t &start, size_t &end) const
{
  size_t match_start, match_end;

  if (pos < 0)
    return locate(ex, 0, start, end);

  if (pos < (ssize_t) size && ex.run(str(), pos, match_start, match_end) && match_start == (size_t)pos)
    {
      start = match_start;
      end = match_end;
      return 1;
    }
  else
      return 0;
}

EST_String EST_String::chop_internal(ssize_t from, size_t len, EST_chop_direction mode) const
{
  size_t start, end;

  if (from < 0)
    {
      start = size+from;
    }
  else
    {
      start = from;
    }

  end=start+len;

  if (end <=size && size > 0)
    switch (mode)
      {
      case Chop_Before:
    return EST_String(str(), size, 0, start); break;
      case Chop_At:
    return EST_String(str(), size, start, end-start); break;
      case Chop_After:
    return EST_String(str(), size, end, -1);
      }
  return EST_String();

}

EST_String EST_String::chop_internal(const char *it, size_t len, ssize_t from, EST_chop_direction mode) const
{
  CHECK_STRING_ARG(it);
      
  size_t start, end;
  
  if (it && locate(it, len, from, start, end))
    switch (mode)
      {
      case Chop_Before:
    return EST_String(str(), size, 0, start); break;
      case Chop_At:
    return EST_String(str(), size, start, end-start); break;
      case Chop_After:
    return EST_String(str(), size, end, -1);
      }
  return EST_String();

}

EST_String EST_String::chop_internal (EST_Regex &it, ssize_t from, EST_chop_direction mode) const
{
  size_t start=0, end=0;
  
  if (locate(it, from, start, end))
    switch (mode)
      {
      case Chop_Before:
    return EST_String(str(), size, 0, start); break;
      case Chop_At:
    return EST_String(str(), size, start, end-start); break;
      case Chop_After:
    return EST_String(str(), size, end, -1);
      }
  return EST_String();

}


int EST_String::gsub_internal (const char *os, int olength, const char *s, int length)
{
  CHECK_STRING_ARG(os);
  CHECK_STRING_ARG(s);
      
  int pos=0, n=0, change=0;
  EST_ChunkPtr new_memory;

  const char *from;
  char *to;
  
#if __GSUB_REENTRANT__
  struct subst {
    EST_String::EST_string_size start, end;
  } *substitutions=NULL;

  int num_substitutions=0;
#endif

  from = (const char *)memory;
  if (s && os && size > 0 && *os != '\0' && from)
    {
      {
    size_t start, end;
    while (locate(os, olength, pos, start, end))
      {
        if (num_substitutions <= n)
          substitutions = wrealloc(substitutions, struct subst, (num_substitutions +=10));
        
        substitutions[n].start = start;
        substitutions[n].end = end;
        
        change += length - (end-start);
        
        n++;
        pos=end;
      }
      }

      // dubious dealings with the inside of the string

      if (change > 0)
    {
      // Spurious braces make temporary ref to chunk go away
      {new_memory = chunk_allocate(size+change+1);}
      to = new_memory;
    }
      else
    {
      cp_make_updatable(memory, size);
      to = memory;
    }

      int i, at=0;
      char *p=to;
      
      for(i=0; i<n; i++)
    {
      int start = substitutions[i].start;
      int end = substitutions[i].end;
      memcpy(p, from+at, start-at);
      p += start-at;
      memcpy(p, s, length);
      p += length;
      at=end;
    }
   if (p != from+at)
      memcpy(p, from+at, size-at);

      p += size-at;
      *p = '\0';
  
      if (change > 0)
    memory = new_memory; 
      

      size += change;
    }

  //  cout << "gsub n=" << memory.count() << "\n";

#if __GSUB_REENTRANT__
  if (substitutions)
    wfree(substitutions);
#endif

  return n;

}

int EST_String::gsub_internal (EST_Regex &ex, const char *s, int length)
{

  int bracket_num=-1;

  if (s==NULL)
    bracket_num = length;
      
  int pos=0, n=0, change=0;
  EST_ChunkPtr new_memory;

  const char *from = (const char*)memory;
  char *to;
  
#if __GSUB_REENTRANT__
  struct subst *substitutions=NULL;

  int num_substitutions=0;
#endif

  // printf("match '%s'\n", (const char *)(*this));

  if (size > 0 && from != NULL)
    {
      {
    size_t start, starts[EST_Regex_max_subexpressions], ends[EST_Regex_max_subexpressions], mlen;
    while ((start = search(ex, mlen, pos, starts, ends)) != EST_STRING_ERR_IDX)
      {
        // printf("match %d-%d, %d-%d, %d-%d\n", start, start+mlen, starts[0], ends[0], starts[1], ends[1]);
        if (num_substitutions <= n)
          substitutions = wrealloc(substitutions, struct subst, (num_substitutions +=10));
        
        substitutions[n].start = start;
        substitutions[n].end = start+mlen;
        
        if (s)
          change += length - mlen;
        else
          {
        int slen = ends[bracket_num]-starts[bracket_num];
        change += slen - mlen;
        substitutions[n].slen = slen;
        substitutions[n].s = walloc(char, slen);
        memcpy(substitutions[n].s, (const char *)memory+starts[bracket_num], slen);
          
          }
        
        n++;
        pos=start+mlen;
      }
      }

      // dubious dealings with the inside of the string

      if (change > 0)
    {
      // Spurious braces make temporary ref to chunk go away
      {new_memory = chunk_allocate(size+change+1);}
      to = new_memory;
    }
      else
    {
      cp_make_updatable(memory, size);
      to = memory;
    }

      int i, at=0;
      char *p=to;
      
      for(i=0; i<n; i++)
    {
      int start = substitutions[i].start;
      int end = substitutions[i].end;
      memcpy(p, from+at, start-at);
      p += start-at;
      if (s)
        {
          memcpy(p, s, length);
          p += length;
        }
      else
        {
          memcpy(p, substitutions[i].s, substitutions[i].slen);
          wfree(substitutions[i].s);
          substitutions[i].s=NULL;
          p += substitutions[i].slen;
        }
      at=end;
    }
    if ( (from + at) != p) /* Do not copy if source == destination */
       memcpy(p, from+at, size-at);

      p += size-at;
      *p = '\0';
  
      if (change > 0)
    memory = new_memory; 
      
      size += change;
    }

#if __GSUB_REENTRANT__
  if (substitutions)
    wfree(substitutions);
#endif

  return n;

}

int EST_String::subst(EST_String source, 
              size_t (&starts)[EST_Regex_max_subexpressions], 
              size_t (&ends)[EST_Regex_max_subexpressions])
{
  size_t n=0;
  ssize_t change=0;
  EST_ChunkPtr new_memory;

  const char *from;
  char *to;
  
#if __GSUB_REENTRANT__
  struct subst *substitutions=NULL;

  size_t num_substitutions=0;
#endif

  // printf("match '%s'\n", (const char *)(*this));

  size_t i;
  if (size > 0)
    {
    int escaped=0;

      for(i=0; i<size; i++)
    {
      if (escaped)
        {
          if (memory[i] >= '0' &&memory[i] <= '9')
        {
          int snum = memory[i] - '0';
          if (ends[snum] != EST_STRING_ERR_IDX && starts[snum] != EST_STRING_ERR_IDX)
            {
              if (num_substitutions <= n)
            substitutions = wrealloc(substitutions, struct subst, (num_substitutions +=10));
        
              substitutions[n].start = i-1;
              substitutions[n].end = i+1;
              substitutions[n].s = ((char *)(void *)(const char *)source.memory) + starts[snum];
              substitutions[n].slen = ends[snum] - starts[snum];
              change += substitutions[n].slen - 2;

              n++;
            }
        }
          escaped=0;
        }
      else if (memory[i] == '\\')
        escaped=1;
    }


      // dubious dealings with the inside of the string

      from = (const char *)memory;

      if (change > 0)
    {
      // Spurious braces make temporary ref to chunk go away
      {new_memory = chunk_allocate(size+change+1);}
      to = new_memory;
    }
      else
    {
      cp_make_updatable(memory, size);
      to = memory;
    }

      int at=0;
      char *p=to;
      
      for(i=0; i<n; i++)
    {
      int start = substitutions[i].start;
      int end = substitutions[i].end;
      memcpy(p, from+at, start-at);
      p += start-at;

      memcpy(p, substitutions[i].s, substitutions[i].slen);
      substitutions[i].s=NULL;
      p += substitutions[i].slen;
      at=end;
    }
      memcpy(p, from+at, size-at);

      p += size-at;
      *p = '\0';
  
      if (change > 0)
    memory = new_memory; 
      
      size += change;
    }

#if __GSUB_REENTRANT__
  if (substitutions)
    wfree(substitutions);
#endif

  return n;
}

// Pass in the two possible separators as pointers so we don't have to
// duplicate all the code. Inline definitions of the friend functions
// takes care of the pretty interface.

int EST_String::split_internal(EST_String result[], int max, 
                   const char *s_seperator, size_t slen,
                   EST_Regex *re_seperator, 
                   char quote) const
{
  int n=0;
  size_t pos=0;
  size_t start, end;
  size_t lastspace=0;

  if (size>0)
    {
      while (pos < length())
    {
      start= -1;
      end= -1;
      if ((*this)(pos) == quote)
        {
          start=pos;
          pos++;
          while (pos < length())
        {
          if ((*this)(pos) == quote)
            {
              pos++;
              if ((*this)(pos) != quote)
            break;
              else
            pos++;
            }
          else
            pos++;
        }
          end=pos;
        }
      else
        {
          size_t mstart, mend, matched;
          if (s_seperator)
        matched = locate(s_seperator, slen, pos, mstart, mend);
          else
        matched = locate(*re_seperator, pos, mstart, mend);
          
          if (matched)
        if (mstart != pos)
          {
            start=pos;
            end=mstart;
            pos=mend;
            lastspace=mend;
          }
        else if (pos ==lastspace)
          {
            start=pos;
            end=pos;
            pos=mend;
            lastspace=mend;
          }
        else
          {
            pos=mend;
            lastspace=mend;
          }
          else
        {
          start=pos;
          end=length();
          pos=end;
        }
        }
      if (start!= EST_STRING_ERR_IDX)
        result[n++] = EST_String(*this, start, end-start);
      if (n==max)
        break;
    }
    }

  return n;
}

int EST_String::matches(const char *s, ssize_t pos) const
{
  CHECK_STRING_ARG(s);
      
  size_t start, end;

  if (!s)
    return 0;

  size_t len=safe_strlen(s);

  if (extract(s, len, pos, start, end))
      return ((ssize_t)start)==pos && end==len;
  else
      return 0;
}

int EST_String::matches(const EST_String &s, ssize_t pos) const
{
  size_t start, end;

  if (extract(s.str(), s.size, pos, start, end))
      return ((ssize_t)start)==pos && end==s.size;
  else
      return 0;
}

int EST_String::matches(EST_Regex &e, ssize_t pos, size_t *starts, size_t *ends) const
{
  if (size==0)
    return e.run_match("", pos, starts, ends) >0;
  else
    return e.run_match(str(), pos, starts, ends) >0; 
}


EST_String operator + (const EST_String &a, const char *b)
{
  CHECK_STRING_ARG(b);

    int al = a.size;
    int bl = safe_strlen(b);

    if (al == 0)
      return EST_String(b, 0, bl);
    if (bl == 0)
      return EST_String(a);

    EST_ChunkPtr c = chunk_allocate(al+bl+1, a.str(), al);

    if (bl>0)
      memmove((char *)c + al, b, bl);
    c(al+bl)='\0';

    return EST_String(al+bl, c);
}

EST_String operator + (const EST_String &a, const EST_String &b)
{
    int al = a.size;
    int bl = b.size;

    if (al == 0)
      return EST_String(b);
    if (bl == 0)
      return EST_String(a);

    EST_ChunkPtr c = chunk_allocate(al+bl+1, a.str(), al);

    memmove((char *)c+al,b.str(),bl);
    c(al+bl)='\0';

    return EST_String(al+bl, c);
}

EST_String operator + (const char *a, const EST_String &b)
{
  CHECK_STRING_ARG(a);

    int al = safe_strlen(a);
    int bl = b.size;

    if (bl == 0)
      return EST_String(a, 0, al);
    if (al == 0)
      return EST_String(b);

    EST_ChunkPtr c = chunk_allocate(al+bl+1, a, al);

    memmove((char *)c + al, b.str(), bl);

    c(al+bl)='\0';

    return EST_String(al+bl, c);
}

EST_String operator * (const EST_String &s, int n)
{

  if (n<1)
    return "";
  int j;
  int l = s.length();
  int sz = n * l;
  char *dest;
  const char *src;
  EST_String it(NULL, 0, sz);
  src = (const char *)s;
  dest = (char*)it;
  if (src== NULL || dest == NULL) return "";

  /* If s is an empty string, then return an empty string */
  if (l <= 0) return it;
  
  for(j=0; j<n; j++)
    memcpy(dest+j*l, src, l);
  dest[n*l]='\0';

  return it;
}

EST_String &EST_String::operator +=(const char *b) 

{
  CHECK_STRING_ARG(b);
      
    int bl = safe_strlen(b);

    if (size == 0)
      {
    memory = chunk_allocate(bl+1, b, bl);
    size = bl;
    return *this;
      }

    grow_chunk(memory, size, size+bl+1);
    
    memmove((char *)memory + size,b,bl);
    memory(size+bl)='\0';
    size += bl;

    return *this;
}

EST_String &EST_String::operator += (const EST_String b) 

{
    int bl = b.size;

    if (size == 0)
      {
    memory = NON_CONST_CHUNKPTR(b.memory);
    size = b.size;
    return *this;
      }

    grow_chunk(memory, size, size+bl+1);

    if (bl >0)
      memmove((char *)memory + size,b.str(),bl);

    memory(size+bl)='\0';
    size += bl;

    return *this;
}

EST_String::EST_String(const char *s) 
{
      CHECK_STRING_ARG(s);
      
      size=safe_strlen(s);

       if (size != 0)
     memory = chunk_allocate(size+1, s, size); 
       else 
     memory=NULL;
    }


EST_String::EST_String(const char *s, int start_or_fill, ssize_t len) 
{

  if (s)
    {
      int start= start_or_fill;
      if (len <0)
    len=safe_strlen(s)-start;
      
      size=len;
      if (size != 0)
    memory = chunk_allocate(len+1, s+start, len);
      else
    memory=NULL;
    }
  else
    {
      char fill = start_or_fill;
      if (len<0) len=0;
      size=len;
      if (size != 0)
    {
      memory = chunk_allocate(len+1);
      char *p = memory;
      for(int j=0; j<len;j++)
        p[j] = fill;
      p[len]='\0';
    }
      else
    memory=NULL;
    }
}

EST_String::EST_String(const char *s, size_t s_size, size_t start, ssize_t len) 
{
  CHECK_STRING_ARG(s);
      
  if (len <0)
    len=s_size-start;

  size=len;
  if (size != 0)
    memory = chunk_allocate(len+1, s+start, len);
  else
    memory=NULL;
}

EST_String::EST_String(const EST_String &s, size_t start, ssize_t len) 
{
  size_t actual_len;
  if (len <0)
    actual_len = s.size-start;
  else
    actual_len = len;
      
  size=len;

  if (start == 0 && actual_len == s.size)
    memory = NON_CONST_CHUNKPTR(s.memory);
  else if (size != 0)
    memory = chunk_allocate(len+1, s.memory, start, actual_len);
  else
    memory = NULL;
}

/*
EST_String::EST_String(const EST_String &s) 
{
#if 1
  static EST_ChunkPtr hack = NON_CONST_CHUNKPTR(s.memory);
  memory = NON_CONST_CHUNKPTR(s.memory);
  size = s.size;
#else
    *(struct EST_dumb_string *)this = *(struct EST_dumb_string *)(&s);
#endif
}
*/

EST_String &EST_String::operator = (const char *str) 
{
      CHECK_STRING_ARG(str);
      size_t len = safe_strlen(str);
      if (!len)
    memory = NULL;
      else if (!shareing() && len < size)
    memcpy((char *)memory, str, len+1);
      else if (len)
    memory = chunk_allocate(len+1, str, len);
      size=len;
      return *this;
}

EST_String &EST_String::operator = (const char c)
{
      memory = chunk_allocate(2, &c, 1);
      size=1;
      return *this;
}

EST_String &EST_String::operator = (const EST_String &s) 
{
#if 1
/*  static EST_ChunkPtr hack = s.memory;  */
  memory = NON_CONST_CHUNKPTR(s.memory);
  size = s.size;
#else
      *(struct EST_dumb_string *)this = *(struct EST_dumb_string *)(&s);
#endif
      return *this;
}
    
EST_String downcase(const EST_String &s)
{
    EST_String t = EST_String(s.size, chunk_allocate(s.size+1, s.str(), s.size));
    size_t i;

    for (i=0; i < s.length(); i++)
    if (isupper(s(i)))
        t[i] = tolower(s(i));
    else
        t[i] = s(i);
    return t;
}   

EST_String upcase(const EST_String &s)
{
    EST_String t = EST_String(s.size, chunk_allocate(s.size+1, s.str(), s.size));
    size_t i;

    for (i=0; i < s.length(); i++)
    if (islower(s(i)))
        t[i] = toupper(s(i));
    else
        t[i] = s(i);
    return t;
}   


size_t
EST_String::freq(const EST_String &s) const
{
  ssize_t pos=0;
  size_t n=0;
  size_t start, end;

  while (locate(s, pos, start, end))
    {
      n++;
      pos=end;
    }
  return n;
}

size_t
EST_String::freq(const char *s) const
{
  CHECK_STRING_ARG(s);
      
  ssize_t pos=0;
  size_t n=0;
  size_t start, end;
  size_t len=safe_strlen(s);

  while (locate(s, len, pos, start, end))
    {
      n++;
      pos=end;
    }
  return n;
}

size_t
EST_String::freq(EST_Regex &ex) const
{
  ssize_t pos=0;
  size_t n=0;
  size_t start, end=0;

  while (locate(ex, pos, start, end))
    {
      n++;
      pos=end;
    }
  return n;
}

EST_String EST_String::quote(const char quotec) const
{

  const char quotequote[3] = {quotec, quotec, '\0'};

  EST_String result(*this);

  result.gsub(quotequote+1, quotequote+0);

  return EST_String::cat(quotequote+1, result, quotequote+1);   
}

EST_String EST_String::unquote(const char quotec) const
{

  const char quotequote[3] = {quotec, quotec, '\0'};

  EST_String result(*this);

  // cout << "before unqote '" << result << "'\n";

  result.gsub(quotequote+0, quotequote+1);

  //  cout << "after unqote '" << result << "'\n";

  if (result[0] == quotec && result[result.length()-1] == quotec )
    {
#if 1
      /* Spurious local variable to get arounf SunCC 4.0 being broken */
      EST_String res= result.at(1, result.length()-2);
      return res;
#else
      return result.at(1, result.length()-2);
#endif
    }
  else
    return result;
}

EST_String EST_String::quote_if_needed(const char quotec) const
{

  if (contains(RXwhite) || contains(quotec))
    return quote(quotec);

  return *this;
}


EST_String EST_String::unquote_if_needed(const char quotec) const
{

  if ((*this)(0) == quotec && (*this)(length()-1) == quotec )
    return unquote(quotec);

  return *this;
}

ostream &operator << (ostream &s, const EST_String &str)

{
  if (str.size > 0)
    return (s << str.str());
  else
    return (s << "");
}

EST_String EST_String::cat(const EST_String s1, 
               const EST_String s2, 
               const EST_String s3, 
               const EST_String s4, 
               const EST_String s5,
               const EST_String s6,
               const EST_String s7,
               const EST_String s8,
               const EST_String s9
               )
{
  int   len=(s1.length()+s2.length()+s3.length()+s4.length()+s5.length() +
         s6.length()+s7.length()+s8.length()+s9.length());

  EST_String result;

  result.size=len;
  result.memory= chunk_allocate(len+1, (const char *)s1, s1.length());

  int p = s1.length();
  if (s2.length())
    { strncpy((char *)result.memory + p, (const char *)s2, s2.length()); p += s2.length(); }
  if (s3.length())
    { strncpy((char *)result.memory + p, (const char *)s3, s3.length()); p += s3.length(); }
  if (s4.length())
    { strncpy((char *)result.memory + p, (const char *)s4, s4.length()); p += s4.length(); }
  if (s5.length())
    { strncpy((char *)result.memory + p, (const char *)s5, s5.length()); p += s5.length(); }
  if (s6.length())
    { strncpy((char *)result.memory + p, (const char *)s6, s6.length()); p += s6.length(); }
  if (s7.length())
    { strncpy((char *)result.memory + p, (const char *)s7, s7.length()); p += s7.length(); }
  if (s8.length())
    { strncpy((char *)result.memory + p, (const char *)s8, s8.length()); p += s8.length(); }
  if (s9.length())
    { strncpy((char *)result.memory + p, (const char *)s9, s9.length()); p += s9.length(); }

    result.memory(p) = '\0';

  return result;
}

int compare(const EST_String &a, const EST_String &b)
{
    if (a.size == 0 && b.size == 0)
    return 0;
    else if (a.size == 0)
    return -1;
    else if (b.size == 0)
    return 1;
    else 
    return strcmp(a.str(), b.str());
}

int compare(const EST_String &a, const char *b)
{
    if (a.size == 0 && (b==NULL || *b == '\0'))
    return 0;
    else if (a.size == 0)
    return -1;
    else if (b == NULL || *b == '\0')
    return 1;
    else 
    return strcmp(a.str(), b);
}

int fcompare(const EST_String &a, const EST_String &b, 
                const unsigned char *table) 
{
    if (a.size == 0 && b.size == 0)
    return 0;
    else if (a.size == 0)
    return -1;
    else if (b.size == 0)
    return 1;
    else 
    return EST_strcasecmp(a.str(), b.str(), table);
}

int fcompare(const EST_String &a, const char *b, 
                const unsigned char *table) 
{
    int bsize = (b ? strlen((const char *)b) : 0);
    if (a.size == 0 && bsize == 0)
    return 0;
    else if (a.size == 0)
    return -1;
    else if (bsize == 0)
    return 1;
    else 
    return EST_strcasecmp(a.str(), (const char *)b, table);
}

int operator == (const char *a, const EST_String &b)
{
    CHECK_STRING_ARG(a);
      
    if (!a)
    return 0;
    else if (b.size==0)
    return *a == '\0';
    else 
    return (*a == b(0)) && strcmp(a, b.str())==0;
}

int operator == (const EST_String &a, const EST_String &b)
{
    if (a.size==0)
    return b.size == 0;
    else if (b.size == 0)
    return 0;
    else 
    return a.size == b.size && a(0) == b(0) && memcmp(a.str(),b.str(),a.size)==0;
}

EST_String EST_String::Number(int i, int b)
{
  char buf[64];
  const char *format;

  switch (b)
    {
    case 8:
      format="0%o";
      break;
    case 10:
      format="%d";
      break;
    case 16:
      format="0x%x";
      break;
    default:
      format="??%d??";
      break;
    }
  sprintf(buf, format, i);

  return EST_String(buf);
}

EST_String EST_String::Number(long i, int b)
{
  char buf[64];
  const char *format;

  switch (b)
    {
    case 8:
      format="0%lo";
      break;
    case 10:
      format="%ld";
      break;
    case 16:
      format="0x%lx";
      break;
    default:
      format="??%ld??";
      break;
    }
  sprintf(buf, format, i);

  return EST_String(buf);
}

EST_String EST_String::Number(float f)
{
  char buf[64];

  sprintf(buf, "%f", f);

  return EST_String(buf);
}

EST_String EST_String::Number(double d)
{
  char buf[64];

  sprintf(buf, "%f", d);

  return EST_String(buf);
}

long EST_String::Long(bool *valid) const
{
  char *end;

  long val = strtol(str(), &end, 10);

  if (end==NULL|| *end != '\0')
  {
    if (valid != NULL)
      {
    *valid=0;
    return 0L;
      }
    else
      {
    printf("bad integer number format '%s'\n",
        (const char *)str());
    exit(0);
      }
  }

  if (valid)
    *valid=1;
  
  return val;
}

int EST_String::Int(bool *valid) const
{
  long val = Long(valid);

  if (valid && !*valid)
    return 0L;

  if (val > INT_MAX || val < INT_MIN)
  {
    if (valid != NULL)
      {
    *valid=0;
    return 0L;
      }
    else
      {
    printf("number out of range for integer %ld",
           val);
    exit(0);
      }
  }

  return val;
}

double EST_String::Double(bool *valid) const
{
  char *end;

  double val = strtod(str(), &end);

  if (end==NULL|| *end != '\0')
  {
    if (valid != NULL)
      {
    *valid=0;
    return 0.0;
      }
    else
      {
    printf("bad decimal number format '%s'",
        (const char *)str());
    exit(0);
      }
  }

  if (valid)
    *valid=1;
  
  return val;
}

float EST_String::Float(bool *valid) const
{
  double val = Double(valid);

  if (valid && !*valid)
    return 0.0;

  if (val > FLT_MAX || val < -FLT_MAX) 
  {
    if (valid != NULL)
      {
    *valid=0;
    return 0.0;
      }
    else
      {
    printf("number out of range for float %f",
           val);
    exit(0);
      }
  }

  return val;
}