~drizzle-trunk/drizzle/development : contents of client/sql

~drizzle-trunk/drizzle/development : (revision 28.1.20)

/* Copyright (C) 2000 MySQL AB

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

/* This file is originally from the mysql distribution. Coded by monty */

#ifdef USE_PRAGMA_IMPLEMENTATION
#pragma implementation				// gcc: Class implementation
#endif

#include <my_global.h>
#include <my_sys.h>
#include <m_string.h>
#include <m_ctype.h>
#ifdef HAVE_FCONVERT
#include <floatingpoint.h>
#endif

/*
  The following extern declarations are ok as these are interface functions
  required by the string function
*/

extern void sql_alloc(size_t size);
extern void sql_element_free(void *ptr);

#include "sql_string.h"

/*****************************************************************************
** String functions
*****************************************************************************/

bool String::real_alloc(uint32 arg_length)
{
  arg_length=ALIGN_SIZE(arg_length+1);
  str_length=0;
  if (Alloced_length < arg_length)
  {
    free();
    if (!(Ptr=(char*) my_malloc(arg_length,MYF(MY_WME))))
      return TRUE;
    Alloced_length=arg_length;
    alloced=1;
  }
  Ptr[0]=0;
  return FALSE;
}


/*
** Check that string is big enough. Set string[alloc_length] to 0
** (for C functions)
*/

bool String::realloc(uint32 alloc_length)
{
  uint32 len=ALIGN_SIZE(alloc_length+1);
  if (Alloced_length < len)
  {
    char *new_ptr;
    if (alloced)
    {
      if ((new_ptr= (char*) my_realloc(Ptr,len,MYF(MY_WME))))
      {
	Ptr=new_ptr;
	Alloced_length=len;
      }
      else
	return TRUE;				// Signal error
    }
    else if ((new_ptr= (char*) my_malloc(len,MYF(MY_WME))))
    {
      if (str_length)				// Avoid bugs in memcpy on AIX
	memcpy(new_ptr,Ptr,str_length);
      new_ptr[str_length]=0;
      Ptr=new_ptr;
      Alloced_length=len;
      alloced=1;
    }
    else
      return TRUE;			// Signal error
  }
  Ptr[alloc_length]=0;			// This make other funcs shorter
  return FALSE;
}

bool String::set(longlong num, CHARSET_INFO *cs)
{
  uint l=20*cs->mbmaxlen+1;

  if (alloc(l))
    return TRUE;
  str_length=(uint32) (cs->cset->longlong10_to_str)(cs,Ptr,l,-10,num);
  str_charset=cs;
  return FALSE;
}

bool String::set(ulonglong num, CHARSET_INFO *cs)
{
  uint l=20*cs->mbmaxlen+1;

  if (alloc(l))
    return TRUE;
  str_length=(uint32) (cs->cset->longlong10_to_str)(cs,Ptr,l,10,num);
  str_charset=cs;
  return FALSE;
}

bool String::set(double num,uint decimals, CHARSET_INFO *cs)
{
  char buff[331];
  uint dummy_errors;

  str_charset=cs;
  if (decimals >= NOT_FIXED_DEC)
  {
    uint32 len= my_sprintf(buff,(buff, "%.14g",num));// Enough for a DATETIME
    return copy(buff, len, &my_charset_latin1, cs, &dummy_errors);
  }
#ifdef HAVE_FCONVERT
  int decpt,sign;
  char *pos,*to;

  VOID(fconvert(num,(int) decimals,&decpt,&sign,buff+1));
  if (!my_isdigit(&my_charset_latin1, buff[1]))
  {						// Nan or Inf
    pos=buff+1;
    if (sign)
    {
      buff[0]='-';
      pos=buff;
    }
    uint dummy_errors;
    return copy(pos,(uint32) strlen(pos), &my_charset_latin1, cs, &dummy_errors);
  }
  if (alloc((uint32) ((uint32) decpt+3+decimals)))
    return TRUE;
  to=Ptr;
  if (sign)
    *to++='-';

  pos=buff+1;
  if (decpt < 0)
  {					/* value is < 0 */
    *to++='0';
    if (!decimals)
      goto end;
    *to++='.';
    if ((uint32) -decpt > decimals)
      decpt= - (int) decimals;
    decimals=(uint32) ((int) decimals+decpt);
    while (decpt++ < 0)
      *to++='0';
  }
  else if (decpt == 0)
  {
    *to++= '0';
    if (!decimals)
      goto end;
    *to++='.';
  }
  else
  {
    while (decpt-- > 0)
      *to++= *pos++;
    if (!decimals)
      goto end;
    *to++='.';
  }
  while (decimals--)
    *to++= *pos++;

end:
  *to=0;
  str_length=(uint32) (to-Ptr);
  return FALSE;
#else
#ifdef HAVE_SNPRINTF
  buff[sizeof(buff)-1]=0;			// Safety
  snprintf(buff,sizeof(buff)-1, "%.*f",(int) decimals,num);
#else
  sprintf(buff,"%.*f",(int) decimals,num);
#endif
  return copy(buff,(uint32) strlen(buff), &my_charset_latin1, cs,
              &dummy_errors);
#endif
}


bool String::copy()
{
  if (!alloced)
  {
    Alloced_length=0;				// Force realloc
    return realloc(str_length);
  }
  return FALSE;
}

bool String::copy(const String &str)
{
  if (alloc(str.str_length))
    return TRUE;
  str_length=str.str_length;
  bmove(Ptr,str.Ptr,str_length);		// May be overlapping
  Ptr[str_length]=0;
  str_charset=str.str_charset;
  return FALSE;
}

bool String::copy(const char *str,uint32 arg_length, CHARSET_INFO *cs)
{
  if (alloc(arg_length))
    return TRUE;
  if ((str_length=arg_length))
    memcpy(Ptr,str,arg_length);
  Ptr[arg_length]=0;
  str_charset=cs;
  return FALSE;
}


/*
  Checks that the source string can be just copied to the destination string
  without conversion.

  SYNPOSIS

  needs_conversion()
  arg_length		Length of string to copy.
  from_cs		Character set to copy from
  to_cs			Character set to copy to
  uint32 *offset	Returns number of unaligned characters.

  RETURN
   0  No conversion needed
   1  Either character set conversion or adding leading  zeros
      (e.g. for UCS-2) must be done

  NOTE
  to_cs may be NULL for "no conversion" if the system variable
  character_set_results is NULL.
*/

bool String::needs_conversion(uint32 arg_length,
			      CHARSET_INFO *from_cs,
			      CHARSET_INFO *to_cs,
			      uint32 *offset)
{
  *offset= 0;
  if (!to_cs ||
      (to_cs == &my_charset_bin) || 
      (to_cs == from_cs) ||
      my_charset_same(from_cs, to_cs) ||
      ((from_cs == &my_charset_bin) &&
       (!(*offset=(arg_length % to_cs->mbminlen)))))
    return FALSE;
  return TRUE;
}


/*
  Copy a multi-byte character sets with adding leading zeros.

  SYNOPSIS

  copy_aligned()
  str			String to copy
  arg_length		Length of string. This should NOT be dividable with
			cs->mbminlen.
  offset		arg_length % cs->mb_minlength
  cs			Character set for 'str'

  NOTES
    For real multi-byte, ascii incompatible charactser sets,
    like UCS-2, add leading zeros if we have an incomplete character.
    Thus, 
      SELECT _ucs2 0xAA 
    will automatically be converted into
      SELECT _ucs2 0x00AA

  RETURN
    0  ok
    1  error
*/

bool String::copy_aligned(const char *str,uint32 arg_length, uint32 offset,
			  CHARSET_INFO *cs)
{
  /* How many bytes are in incomplete character */
  offset= cs->mbmaxlen - offset; /* How many zeros we should prepend */
  DBUG_ASSERT(offset && offset != cs->mbmaxlen);

  uint32 aligned_length= arg_length + offset;
  if (alloc(aligned_length))
    return TRUE;
  
  /*
    Note, this is only safe for little-endian UCS-2.
    If we add big-endian UCS-2 sometimes, this code
    will be more complicated. But it's OK for now.
  */
  bzero((char*) Ptr, offset);
  memcpy(Ptr + offset, str, arg_length);
  Ptr[aligned_length]=0;
  /* str_length is always >= 0 as arg_length is != 0 */
  str_length= aligned_length;
  str_charset= cs;
  return FALSE;
}


bool String::set_or_copy_aligned(const char *str,uint32 arg_length,
				 CHARSET_INFO *cs)
{
  /* How many bytes are in incomplete character */
  uint32 offset= (arg_length % cs->mbminlen); 
  
  if (!offset) /* All characters are complete, just copy */
  {
    set(str, arg_length, cs);
    return FALSE;
  }
  return copy_aligned(str, arg_length, offset, cs);
}

	/* Copy with charset convertion */

bool String::copy(const char *str, uint32 arg_length,
		  CHARSET_INFO *from_cs, CHARSET_INFO *to_cs, uint *errors)
{
  uint32 offset;
  if (!needs_conversion(arg_length, from_cs, to_cs, &offset))
  {
    *errors= 0;
    return copy(str, arg_length, to_cs);
  }
  if ((from_cs == &my_charset_bin) && offset)
  {
    *errors= 0;
    return copy_aligned(str, arg_length, offset, to_cs);
  }
  uint32 new_length= to_cs->mbmaxlen*arg_length;
  if (alloc(new_length))
    return TRUE;
  str_length=copy_and_convert((char*) Ptr, new_length, to_cs,
                              str, arg_length, from_cs, errors);
  str_charset=to_cs;
  return FALSE;
}


/*
  Set a string to the value of a latin1-string, keeping the original charset
  
  SYNOPSIS
    copy_or_set()
    str			String of a simple charset (latin1)
    arg_length		Length of string

  IMPLEMENTATION
    If string object is of a simple character set, set it to point to the
    given string.
    If not, make a copy and convert it to the new character set.

  RETURN
    0	ok
    1	Could not allocate result buffer

*/

bool String::set_ascii(const char *str, uint32 arg_length)
{
  if (str_charset->mbminlen == 1)
  {
    set(str, arg_length, str_charset);
    return 0;
  }
  uint dummy_errors;
  return copy(str, arg_length, &my_charset_latin1, str_charset, &dummy_errors);
}


/* This is used by mysql.cc */

bool String::fill(uint32 max_length,char fill_char)
{
  if (str_length > max_length)
    Ptr[str_length=max_length]=0;
  else
  {
    if (realloc(max_length))
      return TRUE;
    bfill(Ptr+str_length,max_length-str_length,fill_char);
    str_length=max_length;
  }
  return FALSE;
}

void String::strip_sp()
{
   while (str_length && my_isspace(str_charset,Ptr[str_length-1]))
    str_length--;
}

bool String::append(const String &s)
{
  if (s.length())
  {
    if (realloc(str_length+s.length()))
      return TRUE;
    memcpy(Ptr+str_length,s.ptr(),s.length());
    str_length+=s.length();
  }
  return FALSE;
}


/*
  Append an ASCII string to the a string of the current character set
*/

bool String::append(const char *s,uint32 arg_length)
{
  if (!arg_length)
    return FALSE;

  /*
    For an ASCII incompatible string, e.g. UCS-2, we need to convert
  */
  if (str_charset->mbminlen > 1)
  {
    uint32 add_length=arg_length * str_charset->mbmaxlen;
    uint dummy_errors;
    if (realloc(str_length+ add_length))
      return TRUE;
    str_length+= copy_and_convert(Ptr+str_length, add_length, str_charset,
				  s, arg_length, &my_charset_latin1,
                                  &dummy_errors);
    return FALSE;
  }

  /*
    For an ASCII compatinble string we can just append.
  */
  if (realloc(str_length+arg_length))
    return TRUE;
  memcpy(Ptr+str_length,s,arg_length);
  str_length+=arg_length;
  return FALSE;
}


/*
  Append a 0-terminated ASCII string
*/

bool String::append(const char *s)
{
  return append(s, strlen(s));
}


/*
  Append a string in the given charset to the string
  with character set recoding
*/

bool String::append(const char *s,uint32 arg_length, CHARSET_INFO *cs)
{
  uint32 dummy_offset;
  
  if (needs_conversion(arg_length, cs, str_charset, &dummy_offset))
  {
    uint32 add_length= arg_length / cs->mbminlen * str_charset->mbmaxlen;
    uint dummy_errors;
    if (realloc(str_length + add_length)) 
      return TRUE;
    str_length+= copy_and_convert(Ptr+str_length, add_length, str_charset,
				  s, arg_length, cs, &dummy_errors);
  }
  else
  {
    if (realloc(str_length + arg_length)) 
      return TRUE;
    memcpy(Ptr + str_length, s, arg_length);
    str_length+= arg_length;
  }
  return FALSE;
}


#ifdef TO_BE_REMOVED
bool String::append(FILE* file, uint32 arg_length, myf my_flags)
{
  if (realloc(str_length+arg_length))
    return TRUE;
  if (my_fread(file, (uchar*) Ptr + str_length, arg_length, my_flags))
  {
    shrink(str_length);
    return TRUE;
  }
  str_length+=arg_length;
  return FALSE;
}
#endif

bool String::append(IO_CACHE* file, uint32 arg_length)
{
  if (realloc(str_length+arg_length))
    return TRUE;
  if (my_b_read(file, (uchar*) Ptr + str_length, arg_length))
  {
    shrink(str_length);
    return TRUE;
  }
  str_length+=arg_length;
  return FALSE;
}

bool String::append_with_prefill(const char *s,uint32 arg_length,
		 uint32 full_length, char fill_char)
{
  int t_length= arg_length > full_length ? arg_length : full_length;

  if (realloc(str_length + t_length))
    return TRUE;
  t_length= full_length - arg_length;
  if (t_length > 0)
  {
    bfill(Ptr+str_length, t_length, fill_char);
    str_length=str_length + t_length;
  }
  append(s, arg_length);
  return FALSE;
}

uint32 String::numchars()
{
  return str_charset->cset->numchars(str_charset, Ptr, Ptr+str_length);
}

int String::charpos(int i,uint32 offset)
{
  if (i <= 0)
    return i;
  return str_charset->cset->charpos(str_charset,Ptr+offset,Ptr+str_length,i);
}

int String::strstr(const String &s,uint32 offset)
{
  if (s.length()+offset <= str_length)
  {
    if (!s.length())
      return ((int) offset);	// Empty string is always found

    register const char *str = Ptr+offset;
    register const char *search=s.ptr();
    const char *end=Ptr+str_length-s.length()+1;
    const char *search_end=s.ptr()+s.length();
skip:
    while (str != end)
    {
      if (*str++ == *search)
      {
	register char *i,*j;
	i=(char*) str; j=(char*) search+1;
	while (j != search_end)
	  if (*i++ != *j++) goto skip;
	return (int) (str-Ptr) -1;
      }
    }
  }
  return -1;
}

/*
** Search string from end. Offset is offset to the end of string
*/

int String::strrstr(const String &s,uint32 offset)
{
  if (s.length() <= offset && offset <= str_length)
  {
    if (!s.length())
      return offset;				// Empty string is always found
    register const char *str = Ptr+offset-1;
    register const char *search=s.ptr()+s.length()-1;

    const char *end=Ptr+s.length()-2;
    const char *search_end=s.ptr()-1;
skip:
    while (str != end)
    {
      if (*str-- == *search)
      {
	register char *i,*j;
	i=(char*) str; j=(char*) search-1;
	while (j != search_end)
	  if (*i-- != *j--) goto skip;
	return (int) (i-Ptr) +1;
      }
    }
  }
  return -1;
}

/*
  Replace substring with string
  If wrong parameter or not enough memory, do nothing
*/

bool String::replace(uint32 offset,uint32 arg_length,const String &to)
{
  return replace(offset,arg_length,to.ptr(),to.length());
}

bool String::replace(uint32 offset,uint32 arg_length,
                     const char *to, uint32 to_length)
{
  long diff = (long) to_length-(long) arg_length;
  if (offset+arg_length <= str_length)
  {
    if (diff < 0)
    {
      if (to_length)
	memcpy(Ptr+offset,to,to_length);
      bmove(Ptr+offset+to_length,Ptr+offset+arg_length,
	    str_length-offset-arg_length);
    }
    else
    {
      if (diff)
      {
	if (realloc(str_length+(uint32) diff))
	  return TRUE;
	bmove_upp((uchar*) Ptr+str_length+diff, (uchar*) Ptr+str_length,
		  str_length-offset-arg_length);
      }
      if (to_length)
	memcpy(Ptr+offset,to,to_length);
    }
    str_length+=(uint32) diff;
  }
  return FALSE;
}


// added by Holyfoot for "geometry" needs
int String::reserve(uint32 space_needed, uint32 grow_by)
{
  if (Alloced_length < str_length + space_needed)
  {
    if (realloc(Alloced_length + max(space_needed, grow_by) - 1))
      return TRUE;
  }
  return FALSE;
}

void String::qs_append(const char *str, uint32 len)
{
  memcpy(Ptr + str_length, str, len + 1);
  str_length += len;
}

void String::qs_append(double d)
{
  char *buff = Ptr + str_length;
  str_length+= my_gcvt(d, MY_GCVT_ARG_DOUBLE, FLOATING_POINT_BUFFER - 1, buff, NULL);
}

void String::qs_append(double *d)
{
  double ld;
  float8get(ld, (char*) d);
  qs_append(ld);
}

void String::qs_append(int i)
{
  char *buff= Ptr + str_length;
  char *end= int10_to_str(i, buff, -10);
  str_length+= (int) (end-buff);
}

void String::qs_append(uint i)
{
  char *buff= Ptr + str_length;
  char *end= int10_to_str(i, buff, 10);
  str_length+= (int) (end-buff);
}

/*
  Compare strings according to collation, without end space.

  SYNOPSIS
    sortcmp()
    s		First string
    t		Second string
    cs		Collation

  NOTE:
    Normally this is case sensitive comparison

  RETURN
  < 0	s < t
  0	s == t
  > 0	s > t
*/


int sortcmp(const String *s,const String *t, CHARSET_INFO *cs)
{
 return cs->coll->strnncollsp(cs,
                              (unsigned char *) s->ptr(),s->length(),
                              (unsigned char *) t->ptr(),t->length(), 0);
}


/*
  Compare strings byte by byte. End spaces are also compared.

  SYNOPSIS
    stringcmp()
    s		First string
    t		Second string

  NOTE:
    Strings are compared as a stream of unsigned chars

  RETURN
  < 0	s < t
  0	s == t
  > 0	s > t
*/


int stringcmp(const String *s,const String *t)
{
  uint32 s_len=s->length(),t_len=t->length(),len=min(s_len,t_len);
  int cmp= memcmp(s->ptr(), t->ptr(), len);
  return (cmp) ? cmp : (int) (s_len - t_len);
}


String *copy_if_not_alloced(String *to,String *from,uint32 from_length)
{
  if (from->Alloced_length >= from_length)
    return from;
  if (from->alloced || !to || from == to)
  {
    (void) from->realloc(from_length);
    return from;
  }
  if (to->realloc(from_length))
    return from;				// Actually an error
  if ((to->str_length=min(from->str_length,from_length)))
    memcpy(to->Ptr,from->Ptr,to->str_length);
  to->str_charset=from->str_charset;
  return to;
}


/****************************************************************************
  Help functions
****************************************************************************/

/*
  copy a string from one character set to another
  
  SYNOPSIS
    copy_and_convert()
    to			Store result here
    to_cs		Character set of result string
    from		Copy from here
    from_length		Length of from string
    from_cs		From character set

  NOTES
    'to' must be big enough as form_length * to_cs->mbmaxlen

  RETURN
    length of bytes copied to 'to'
*/


uint32
copy_and_convert(char *to, uint32 to_length, CHARSET_INFO *to_cs, 
                 const char *from, uint32 from_length, CHARSET_INFO *from_cs,
                 uint *errors)
{
  int         cnvres;
  my_wc_t     wc;
  const uchar *from_end= (const uchar*) from+from_length;
  char *to_start= to;
  uchar *to_end= (uchar*) to+to_length;
  my_charset_conv_mb_wc mb_wc= from_cs->cset->mb_wc;
  my_charset_conv_wc_mb wc_mb= to_cs->cset->wc_mb;
  uint error_count= 0;

  while (1)
  {
    if ((cnvres= (*mb_wc)(from_cs, &wc, (uchar*) from,
				      from_end)) > 0)
      from+= cnvres;
    else if (cnvres == MY_CS_ILSEQ)
    {
      error_count++;
      from++;
      wc= '?';
    }
    else if (cnvres > MY_CS_TOOSMALL)
    {
      /*
        A correct multibyte sequence detected
        But it doesn't have Unicode mapping.
      */
      error_count++;
      from+= (-cnvres);
      wc= '?';
    }
    else
      break;  // Not enough characters

outp:
    if ((cnvres= (*wc_mb)(to_cs, wc, (uchar*) to, to_end)) > 0)
      to+= cnvres;
    else if (cnvres == MY_CS_ILUNI && wc != '?')
    {
      error_count++;
      wc= '?';
      goto outp;
    }
    else
      break;
  }
  *errors= error_count;
  return (uint32) (to - to_start);
}


void String::print(String *str)
{
  char *st= (char*)Ptr, *end= st+str_length;
  for (; st < end; st++)
  {
    uchar c= *st;
    switch (c)
    {
    case '\\':
      str->append(STRING_WITH_LEN("\\\\"));
      break;
    case '\0':
      str->append(STRING_WITH_LEN("\\0"));
      break;
    case '\'':
      str->append(STRING_WITH_LEN("\\'"));
      break;
    case '\n':
      str->append(STRING_WITH_LEN("\\n"));
      break;
    case '\r':
      str->append(STRING_WITH_LEN("\\r"));
      break;
    case 26: //Ctrl-Z
      str->append(STRING_WITH_LEN("\\z"));
      break;
    default:
      str->append(c);
    }
  }
}


/*
  Exchange state of this object and argument.

  SYNOPSIS
    String::swap()

  RETURN
    Target string will contain state of this object and vice versa.
*/

void String::swap(String &s)
{
  swap_variables(char *, Ptr, s.Ptr);
  swap_variables(uint32, str_length, s.str_length);
  swap_variables(uint32, Alloced_length, s.Alloced_length);
  swap_variables(bool, alloced, s.alloced);
  swap_variables(CHARSET_INFO*, str_charset, s.str_charset);
}

1 by brian clean slate	1	/* Copyright (C) 2000 MySQL AB
	2
	3	This program is free software; you can redistribute it and/or modify
	4	it under the terms of the GNU General Public License as published by
	5	the Free Software Foundation; version 2 of the License.
	6
	7	This program is distributed in the hope that it will be useful,
	8	but WITHOUT ANY WARRANTY; without even the implied warranty of
	9	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	10	GNU General Public License for more details.
	11
	12	You should have received a copy of the GNU General Public License
	13	along with this program; if not, write to the Free Software
	14	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
	15
	16	/* This file is originally from the mysql distribution. Coded by monty */
	17
	18	#ifdef USE_PRAGMA_IMPLEMENTATION
	19	#pragma implementation // gcc: Class implementation
	20	#endif
	21
	22	#include <my_global.h>
	23	#include <my_sys.h>
	24	#include <m_string.h>
	25	#include <m_ctype.h>
	26	#ifdef HAVE_FCONVERT
	27	#include <floatingpoint.h>
	28	#endif
	29
	30	/*
	31	The following extern declarations are ok as these are interface functions
	32	required by the string function
	33	*/
	34
	35	extern void sql_alloc(size_t size);
	36	extern void sql_element_free(void *ptr);
	37
	38	#include "sql_string.h"
	39
	40	/*****************************************************************************
	41	** String functions
	42	*****************************************************************************/
	43
	44	bool String::real_alloc(uint32 arg_length)
	45	{
	46	arg_length=ALIGN_SIZE(arg_length+1);
	47	str_length=0;
	48	if (Alloced_length < arg_length)
	49	{
	50	free();
	51	if (!(Ptr=(char*) my_malloc(arg_length,MYF(MY_WME))))
	52	return TRUE;
	53	Alloced_length=arg_length;
	54	alloced=1;
	55	}
	56	Ptr[0]=0;
	57	return FALSE;
	58	}
	59
	60
	61	/*
	62	** Check that string is big enough. Set string[alloc_length] to 0
	63	** (for C functions)
	64	*/
65
66	bool String::realloc(uint32 alloc_length)
67	{
68	uint32 len=ALIGN_SIZE(alloc_length+1);
69	if (Alloced_length < len)
70	{
71	char *new_ptr;
72	if (alloced)
73	{
74	if ((new_ptr= (char*) my_realloc(Ptr,len,MYF(MY_WME))))
75	{
76	Ptr=new_ptr;
77	Alloced_length=len;
78	}
79	else
80	return TRUE; // Signal error
81	}
82	else if ((new_ptr= (char*) my_malloc(len,MYF(MY_WME))))
83	{
84	if (str_length) // Avoid bugs in memcpy on AIX
85	memcpy(new_ptr,Ptr,str_length);
86	new_ptr[str_length]=0;
87	Ptr=new_ptr;
88	Alloced_length=len;
89	alloced=1;
90	}
91	else
92	return TRUE; // Signal error
93	}
94	Ptr[alloc_length]=0; // This make other funcs shorter
95	return FALSE;
96	}
97
98	bool String::set(longlong num, CHARSET_INFO *cs)
99	{
100	uint l=20*cs->mbmaxlen+1;
101
102	if (alloc(l))
103	return TRUE;
104	str_length=(uint32) (cs->cset->longlong10_to_str)(cs,Ptr,l,-10,num);
105	str_charset=cs;
106	return FALSE;
107	}
108
109	bool String::set(ulonglong num, CHARSET_INFO *cs)
110	{
111	uint l=20*cs->mbmaxlen+1;
112
113	if (alloc(l))
114	return TRUE;
115	str_length=(uint32) (cs->cset->longlong10_to_str)(cs,Ptr,l,10,num);
116	str_charset=cs;
117	return FALSE;
118	}
119
120	bool String::set(double num,uint decimals, CHARSET_INFO *cs)
121	{
122	char buff[331];
123	uint dummy_errors;
124
125	str_charset=cs;
126	if (decimals >= NOT_FIXED_DEC)
127	{
128	uint32 len= my_sprintf(buff,(buff, "%.14g",num));// Enough for a DATETIME
129	return copy(buff, len, &my_charset_latin1, cs, &dummy_errors);
130	}
131	#ifdef HAVE_FCONVERT
132	int decpt,sign;
133	char pos,to;
134
135	VOID(fconvert(num,(int) decimals,&decpt,&sign,buff+1));
136	if (!my_isdigit(&my_charset_latin1, buff[1]))
137	{ // Nan or Inf
138	pos=buff+1;
139	if (sign)
140	{
141	buff[0]='-';
142	pos=buff;
143	}
144	uint dummy_errors;
145	return copy(pos,(uint32) strlen(pos), &my_charset_latin1, cs, &dummy_errors);
146	}
147	if (alloc((uint32) ((uint32) decpt+3+decimals)))
148	return TRUE;
149	to=Ptr;
150	if (sign)
151	*to++='-';
152
153	pos=buff+1;
154	if (decpt < 0)
155	{ /* value is < 0 */
156	*to++='0';
157	if (!decimals)
158	goto end;
159	*to++='.';
160	if ((uint32) -decpt > decimals)
161	decpt= - (int) decimals;
162	decimals=(uint32) ((int) decimals+decpt);
163	while (decpt++ < 0)
164	*to++='0';
165	}
166	else if (decpt == 0)
167	{
168	*to++= '0';
169	if (!decimals)
170	goto end;
171	*to++='.';
172	}
173	else
174	{
175	while (decpt-- > 0)
176	to++= pos++;
177	if (!decimals)
178	goto end;
179	*to++='.';
180	}
181	while (decimals--)
182	to++= pos++;
183
184	end:
185	*to=0;
186	str_length=(uint32) (to-Ptr);
187	return FALSE;
188	#else
189	#ifdef HAVE_SNPRINTF
190	buff[sizeof(buff)-1]=0; // Safety
191	snprintf(buff,sizeof(buff)-1, "%.*f",(int) decimals,num);
192	#else
193	sprintf(buff,"%.*f",(int) decimals,num);
194	#endif
195	return copy(buff,(uint32) strlen(buff), &my_charset_latin1, cs,
196	&dummy_errors);
197	#endif
198	}
199
200
201	bool String::copy()
202	{
203	if (!alloced)
204	{
205	Alloced_length=0; // Force realloc
206	return realloc(str_length);
207	}
208	return FALSE;
209	}
210
211	bool String::copy(const String &str)
212	{
213	if (alloc(str.str_length))
214	return TRUE;
215	str_length=str.str_length;
216	bmove(Ptr,str.Ptr,str_length); // May be overlapping
217	Ptr[str_length]=0;
218	str_charset=str.str_charset;
219	return FALSE;
220	}
221
222	bool String::copy(const char str,uint32 arg_length, CHARSET_INFO cs)
223	{
224	if (alloc(arg_length))
225	return TRUE;
226	if ((str_length=arg_length))
227	memcpy(Ptr,str,arg_length);
228	Ptr[arg_length]=0;
229	str_charset=cs;
230	return FALSE;
231	}
232
233
234	/*
235	Checks that the source string can be just copied to the destination string
236	without conversion.
237
238	SYNPOSIS
239
240	needs_conversion()
241	arg_length Length of string to copy.
242	from_cs Character set to copy from
243	to_cs Character set to copy to
244	uint32 *offset Returns number of unaligned characters.
245
246	RETURN
247	0 No conversion needed
248	1 Either character set conversion or adding leading zeros
249	(e.g. for UCS-2) must be done
250
251	NOTE
252	to_cs may be NULL for "no conversion" if the system variable
253	character_set_results is NULL.
254	*/
255
256	bool String::needs_conversion(uint32 arg_length,
257	CHARSET_INFO *from_cs,
258	CHARSET_INFO *to_cs,
259	uint32 *offset)
260	{
261	*offset= 0;
262	if (!to_cs \|\|
263	(to_cs == &my_charset_bin) \|\|
264	(to_cs == from_cs) \|\|
265	my_charset_same(from_cs, to_cs) \|\|
266	((from_cs == &my_charset_bin) &&
267	(!(*offset=(arg_length % to_cs->mbminlen)))))
268	return FALSE;
269	return TRUE;
270	}
271
272
273	/*
274	Copy a multi-byte character sets with adding leading zeros.
275
276	SYNOPSIS
277
278	copy_aligned()
279	str String to copy
280	arg_length Length of string. This should NOT be dividable with
281	cs->mbminlen.
282	offset arg_length % cs->mb_minlength
283	cs Character set for 'str'
284
285	NOTES
286	For real multi-byte, ascii incompatible charactser sets,
287	like UCS-2, add leading zeros if we have an incomplete character.
288	Thus,
289	SELECT _ucs2 0xAA
290	will automatically be converted into
291	SELECT _ucs2 0x00AA
292
293	RETURN
294	0 ok
295	1 error
296	*/
297
298	bool String::copy_aligned(const char *str,uint32 arg_length, uint32 offset,
299	CHARSET_INFO *cs)
300	{
301	/* How many bytes are in incomplete character */
302	offset= cs->mbmaxlen - offset; /* How many zeros we should prepend */
303	DBUG_ASSERT(offset && offset != cs->mbmaxlen);
304
305	uint32 aligned_length= arg_length + offset;
306	if (alloc(aligned_length))
307	return TRUE;
308
309	/*
310	Note, this is only safe for little-endian UCS-2.
311	If we add big-endian UCS-2 sometimes, this code
312	will be more complicated. But it's OK for now.
313	*/
314	bzero((char*) Ptr, offset);
315	memcpy(Ptr + offset, str, arg_length);
316	Ptr[aligned_length]=0;
317	/* str_length is always >= 0 as arg_length is != 0 */
318	str_length= aligned_length;
319	str_charset= cs;
320	return FALSE;
321	}
322
323
324	bool String::set_or_copy_aligned(const char *str,uint32 arg_length,
325	CHARSET_INFO *cs)
326	{
327	/* How many bytes are in incomplete character */
328	uint32 offset= (arg_length % cs->mbminlen);
329
330	if (!offset) /* All characters are complete, just copy */
331	{
332	set(str, arg_length, cs);
333	return FALSE;
334	}
335	return copy_aligned(str, arg_length, offset, cs);
336	}
337
338	/* Copy with charset convertion */
339
340	bool String::copy(const char *str, uint32 arg_length,
341	CHARSET_INFO from_cs, CHARSET_INFO to_cs, uint *errors)
342	{
343	uint32 offset;
344	if (!needs_conversion(arg_length, from_cs, to_cs, &offset))
345	{
346	*errors= 0;
347	return copy(str, arg_length, to_cs);
348	}
349	if ((from_cs == &my_charset_bin) && offset)
350	{
351	*errors= 0;
352	return copy_aligned(str, arg_length, offset, to_cs);
353	}
354	uint32 new_length= to_cs->mbmaxlen*arg_length;
355	if (alloc(new_length))
356	return TRUE;
357	str_length=copy_and_convert((char*) Ptr, new_length, to_cs,
358	str, arg_length, from_cs, errors);
359	str_charset=to_cs;
360	return FALSE;
361	}
362
363
364	/*
365	Set a string to the value of a latin1-string, keeping the original charset
366
367	SYNOPSIS
368	copy_or_set()
369	str String of a simple charset (latin1)
370	arg_length Length of string
371
372	IMPLEMENTATION
373	If string object is of a simple character set, set it to point to the
374	given string.
375	If not, make a copy and convert it to the new character set.
376
377	RETURN
378	0 ok
379	1 Could not allocate result buffer
380
381	*/
382
383	bool String::set_ascii(const char *str, uint32 arg_length)
384	{
385	if (str_charset->mbminlen == 1)
386	{
387	set(str, arg_length, str_charset);
388	return 0;
389	}
390	uint dummy_errors;
391	return copy(str, arg_length, &my_charset_latin1, str_charset, &dummy_errors);
392	}
393
394
395	/* This is used by mysql.cc */
396
397	bool String::fill(uint32 max_length,char fill_char)
398	{
399	if (str_length > max_length)
400	Ptr[str_length=max_length]=0;
401	else
402	{
403	if (realloc(max_length))
404	return TRUE;
405	bfill(Ptr+str_length,max_length-str_length,fill_char);
406	str_length=max_length;
407	}
408	return FALSE;
409	}
410
411	void String::strip_sp()
412	{
413	while (str_length && my_isspace(str_charset,Ptr[str_length-1]))
414	str_length--;
415	}
416
417	bool String::append(const String &s)
418	{
419	if (s.length())
420	{
421	if (realloc(str_length+s.length()))
422	return TRUE;
423	memcpy(Ptr+str_length,s.ptr(),s.length());
424	str_length+=s.length();
425	}
426	return FALSE;
427	}
428
429
430	/*
431	Append an ASCII string to the a string of the current character set
432	*/
433
434	bool String::append(const char *s,uint32 arg_length)
435	{
436	if (!arg_length)
437	return FALSE;
438
439	/*
440	For an ASCII incompatible string, e.g. UCS-2, we need to convert
441	*/
442	if (str_charset->mbminlen > 1)
443	{
444	uint32 add_length=arg_length * str_charset->mbmaxlen;
445	uint dummy_errors;
446	if (realloc(str_length+ add_length))
447	return TRUE;
448	str_length+= copy_and_convert(Ptr+str_length, add_length, str_charset,
449	s, arg_length, &my_charset_latin1,
450	&dummy_errors);
451	return FALSE;
452	}
453
454	/*
455	For an ASCII compatinble string we can just append.
456	*/
457	if (realloc(str_length+arg_length))
458	return TRUE;
459	memcpy(Ptr+str_length,s,arg_length);
460	str_length+=arg_length;
461	return FALSE;
462	}
463
464
465	/*
466	Append a 0-terminated ASCII string
467	*/
468
469	bool String::append(const char *s)
470	{
471	return append(s, strlen(s));
472	}
473
474
475	/*
476	Append a string in the given charset to the string
477	with character set recoding
478	*/
479
480	bool String::append(const char s,uint32 arg_length, CHARSET_INFO cs)
481	{
482	uint32 dummy_offset;
483
484	if (needs_conversion(arg_length, cs, str_charset, &dummy_offset))
485	{
486	uint32 add_length= arg_length / cs->mbminlen * str_charset->mbmaxlen;
487	uint dummy_errors;
488	if (realloc(str_length + add_length))
489	return TRUE;
490	str_length+= copy_and_convert(Ptr+str_length, add_length, str_charset,
491	s, arg_length, cs, &dummy_errors);
492	}
493	else
494	{
495	if (realloc(str_length + arg_length))
496	return TRUE;
497	memcpy(Ptr + str_length, s, arg_length);
498	str_length+= arg_length;
499	}
500	return FALSE;
501	}
502
503
504	#ifdef TO_BE_REMOVED
505	bool String::append(FILE* file, uint32 arg_length, myf my_flags)
506	{
507	if (realloc(str_length+arg_length))
508	return TRUE;
509	if (my_fread(file, (uchar*) Ptr + str_length, arg_length, my_flags))
510	{
511	shrink(str_length);
512	return TRUE;
513	}
514	str_length+=arg_length;
515	return FALSE;
516	}
517	#endif
518
519	bool String::append(IO_CACHE* file, uint32 arg_length)
520	{
521	if (realloc(str_length+arg_length))
522	return TRUE;
523	if (my_b_read(file, (uchar*) Ptr + str_length, arg_length))
524	{
525	shrink(str_length);
526	return TRUE;
527	}
528	str_length+=arg_length;
529	return FALSE;
530	}
531
532	bool String::append_with_prefill(const char *s,uint32 arg_length,
533	uint32 full_length, char fill_char)
534	{
535	int t_length= arg_length > full_length ? arg_length : full_length;
536
537	if (realloc(str_length + t_length))
538	return TRUE;
539	t_length= full_length - arg_length;
540	if (t_length > 0)
541	{
542	bfill(Ptr+str_length, t_length, fill_char);
543	str_length=str_length + t_length;
544	}
545	append(s, arg_length);
546	return FALSE;
547	}
548
549	uint32 String::numchars()
550	{
551	return str_charset->cset->numchars(str_charset, Ptr, Ptr+str_length);
552	}
553
554	int String::charpos(int i,uint32 offset)
555	{
556	if (i <= 0)
557	return i;
558	return str_charset->cset->charpos(str_charset,Ptr+offset,Ptr+str_length,i);
559	}
560
561	int String::strstr(const String &s,uint32 offset)
562	{
563	if (s.length()+offset <= str_length)
564	{
565	if (!s.length())
566	return ((int) offset); // Empty string is always found
567
568	register const char *str = Ptr+offset;
569	register const char *search=s.ptr();
570	const char *end=Ptr+str_length-s.length()+1;
571	const char *search_end=s.ptr()+s.length();
572	skip:
573	while (str != end)
574	{
575	if (str++ == search)
576	{
577	register char i,j;
578	i=(char) str; j=(char) search+1;
579	while (j != search_end)
580	if (i++ != j++) goto skip;
581	return (int) (str-Ptr) -1;
582	}
583	}
584	}
585	return -1;
586	}
587
588	/*
589	** Search string from end. Offset is offset to the end of string
590	*/
591
592	int String::strrstr(const String &s,uint32 offset)
593	{
594	if (s.length() <= offset && offset <= str_length)
595	{
596	if (!s.length())
597	return offset; // Empty string is always found
598	register const char *str = Ptr+offset-1;
599	register const char *search=s.ptr()+s.length()-1;
600
601	const char *end=Ptr+s.length()-2;
602	const char *search_end=s.ptr()-1;
603	skip:
604	while (str != end)
605	{
606	if (str-- == search)
607	{
608	register char i,j;
609	i=(char) str; j=(char) search-1;
610	while (j != search_end)
611	if (i-- != j--) goto skip;
612	return (int) (i-Ptr) +1;
613	}
614	}
615	}
616	return -1;
617	}
618
619	/*
620	Replace substring with string
621	If wrong parameter or not enough memory, do nothing
622	*/
623
624	bool String::replace(uint32 offset,uint32 arg_length,const String &to)
625	{
626	return replace(offset,arg_length,to.ptr(),to.length());
627	}
628
629	bool String::replace(uint32 offset,uint32 arg_length,
630	const char *to, uint32 to_length)
631	{
632	long diff = (long) to_length-(long) arg_length;
633	if (offset+arg_length <= str_length)
634	{
635	if (diff < 0)
636	{
637	if (to_length)
638	memcpy(Ptr+offset,to,to_length);
639	bmove(Ptr+offset+to_length,Ptr+offset+arg_length,
640	str_length-offset-arg_length);
641	}
642	else
643	{
644	if (diff)
645	{
646	if (realloc(str_length+(uint32) diff))
647	return TRUE;
648	bmove_upp((uchar) Ptr+str_length+diff, (uchar) Ptr+str_length,
649	str_length-offset-arg_length);
650	}
651	if (to_length)
652	memcpy(Ptr+offset,to,to_length);
653	}
654	str_length+=(uint32) diff;
655	}
656	return FALSE;
657	}
658
659
660	// added by Holyfoot for "geometry" needs
661	int String::reserve(uint32 space_needed, uint32 grow_by)
662	{
663	if (Alloced_length < str_length + space_needed)
664	{
665	if (realloc(Alloced_length + max(space_needed, grow_by) - 1))
666	return TRUE;
667	}
668	return FALSE;
669	}
670
671	void String::qs_append(const char *str, uint32 len)
672	{
673	memcpy(Ptr + str_length, str, len + 1);
674	str_length += len;
675	}
676
677	void String::qs_append(double d)
678	{
679	char *buff = Ptr + str_length;
680	str_length+= my_gcvt(d, MY_GCVT_ARG_DOUBLE, FLOATING_POINT_BUFFER - 1, buff, NULL);
681	}
682
683	void String::qs_append(double *d)
684	{
685	double ld;
686	float8get(ld, (char*) d);
687	qs_append(ld);
688	}
689
690	void String::qs_append(int i)
691	{
692	char *buff= Ptr + str_length;
693	char *end= int10_to_str(i, buff, -10);
694	str_length+= (int) (end-buff);
695	}
696
697	void String::qs_append(uint i)
698	{
699	char *buff= Ptr + str_length;
700	char *end= int10_to_str(i, buff, 10);
701	str_length+= (int) (end-buff);
702	}
703
704	/*
705	Compare strings according to collation, without end space.
706
707	SYNOPSIS
708	sortcmp()
709	s First string
710	t Second string
711	cs Collation
712
713	NOTE:
714	Normally this is case sensitive comparison
715
716	RETURN
717	< 0 s < t
718	0 s == t
719	> 0 s > t
720	*/
721
722
723	int sortcmp(const String s,const String t, CHARSET_INFO *cs)
724	{
725	return cs->coll->strnncollsp(cs,
726	(unsigned char *) s->ptr(),s->length(),
727	(unsigned char *) t->ptr(),t->length(), 0);
728	}
729
730
731	/*
732	Compare strings byte by byte. End spaces are also compared.
733
734	SYNOPSIS
735	stringcmp()
736	s First string
737	t Second string
738
739	NOTE:
740	Strings are compared as a stream of unsigned chars
741
742	RETURN
743	< 0 s < t
744	0 s == t
745	> 0 s > t
746	*/
747
748
749	int stringcmp(const String s,const String t)
750	{
751	uint32 s_len=s->length(),t_len=t->length(),len=min(s_len,t_len);
752	int cmp= memcmp(s->ptr(), t->ptr(), len);
753	return (cmp) ? cmp : (int) (s_len - t_len);
754	}
755
756
757	String copy_if_not_alloced(String to,String *from,uint32 from_length)
758	{
759	if (from->Alloced_length >= from_length)
760	return from;
761	if (from->alloced \|\| !to \|\| from == to)
762	{
763	(void) from->realloc(from_length);
764	return from;
765	}
766	if (to->realloc(from_length))
767	return from; // Actually an error
768	if ((to->str_length=min(from->str_length,from_length)))
769	memcpy(to->Ptr,from->Ptr,to->str_length);
770	to->str_charset=from->str_charset;
771	return to;
772	}
773
774
775	/****************************************************************************
776	Help functions
777	****************************************************************************/
778
779	/*
780	copy a string from one character set to another
781
782	SYNOPSIS
783	copy_and_convert()
784	to Store result here
785	to_cs Character set of result string
786	from Copy from here
787	from_length Length of from string
788	from_cs From character set
789
790	NOTES
791	'to' must be big enough as form_length * to_cs->mbmaxlen
792
793	RETURN
794	length of bytes copied to 'to'
795	*/
796
797
798	uint32
799	copy_and_convert(char to, uint32 to_length, CHARSET_INFO to_cs,
800	const char from, uint32 from_length, CHARSET_INFO from_cs,
801	uint *errors)
802	{
803	int cnvres;
804	my_wc_t wc;
805	const uchar from_end= (const uchar) from+from_length;
806	char *to_start= to;
807	uchar to_end= (uchar) to+to_length;
808	my_charset_conv_mb_wc mb_wc= from_cs->cset->mb_wc;
809	my_charset_conv_wc_mb wc_mb= to_cs->cset->wc_mb;
810	uint error_count= 0;
811
812	while (1)
813	{
814	if ((cnvres= (mb_wc)(from_cs, &wc, (uchar) from,
815	from_end)) > 0)
816	from+= cnvres;
817	else if (cnvres == MY_CS_ILSEQ)
818	{
819	error_count++;
820	from++;
821	wc= '?';
822	}
823	else if (cnvres > MY_CS_TOOSMALL)
824	{
825	/*
826	A correct multibyte sequence detected
827	But it doesn't have Unicode mapping.
828	*/
829	error_count++;
830	from+= (-cnvres);
831	wc= '?';
832	}
833	else
834	break; // Not enough characters
835
836	outp:
837	if ((cnvres= (wc_mb)(to_cs, wc, (uchar) to, to_end)) > 0)
838	to+= cnvres;
839	else if (cnvres == MY_CS_ILUNI && wc != '?')
840	{
841	error_count++;
842	wc= '?';
843	goto outp;
844	}
845	else
846	break;
847	}
848	*errors= error_count;
849	return (uint32) (to - to_start);
850	}
851
852
853	void String::print(String *str)
854	{
855	char st= (char)Ptr, *end= st+str_length;
856	for (; st < end; st++)
857	{
858	uchar c= *st;
859	switch (c)
860	{
861	case '\\':
862	str->append(STRING_WITH_LEN("\\\\"));
863	break;
864	case '\0':
865	str->append(STRING_WITH_LEN("\\0"));
866	break;
867	case '\'':
868	str->append(STRING_WITH_LEN("\\'"));
869	break;
870	case '\n':
871	str->append(STRING_WITH_LEN("\\n"));
872	break;
873	case '\r':
874	str->append(STRING_WITH_LEN("\\r"));
875	break;
876	case 26: //Ctrl-Z
877	str->append(STRING_WITH_LEN("\\z"));
878	break;
879	default:
880	str->append(c);
881	}
882	}
883	}
884
885
886	/*
887	Exchange state of this object and argument.
888
889	SYNOPSIS
890	String::swap()
891
892	RETURN
893	Target string will contain state of this object and vice versa.
894	*/
895
896	void String::swap(String &s)
897	{
898	swap_variables(char *, Ptr, s.Ptr);
899	swap_variables(uint32, str_length, s.str_length);
900	swap_variables(uint32, Alloced_length, s.Alloced_length);
901	swap_variables(bool, alloced, s.alloced);
902	swap_variables(CHARSET_INFO*, str_charset, s.str_charset);
903	}