sql_string.cc 24.3 KB
Newer Older
unknown's avatar
unknown committed
1 2 3 4 5 6 7 8
/* 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; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
unknown's avatar
unknown committed
9
   but WITHOUT ANY WARRANTY; without even the implied warranty of
unknown's avatar
unknown committed
10 11 12 13 14 15
   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 */
unknown's avatar
unknown committed
16 17 18

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

19
#ifdef USE_PRAGMA_IMPLEMENTATION
unknown's avatar
unknown committed
20 21 22
#pragma implementation				// gcc: Class implementation
#endif

23
#include <my_global.h>
unknown's avatar
unknown committed
24 25 26 27 28 29 30
#include <my_sys.h>
#include <m_string.h>
#include <m_ctype.h>
#ifdef HAVE_FCONVERT
#include <floatingpoint.h>
#endif

31 32 33 34 35
/*
  The following extern declarations are ok as these are interface functions
  required by the string function
*/

unknown's avatar
unknown committed
36 37 38 39 40 41 42 43 44 45 46 47
extern gptr sql_alloc(unsigned 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);
48
  str_length=0;
unknown's avatar
unknown committed
49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
  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))))
    {
85 86
      if (str_length)				// Avoid bugs in memcpy on AIX
	memcpy(new_ptr,Ptr,str_length);
unknown's avatar
unknown committed
87 88 89 90 91 92 93 94 95 96 97 98
      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;
}

99
bool String::set(longlong num, CHARSET_INFO *cs)
unknown's avatar
unknown committed
100
{
101 102 103
  uint l=20*cs->mbmaxlen+1;

  if (alloc(l))
unknown's avatar
unknown committed
104
    return TRUE;
105
  str_length=(uint32) (cs->cset->longlong10_to_str)(cs,Ptr,l,-10,num);
106
  str_charset=cs;
unknown's avatar
unknown committed
107 108 109
  return FALSE;
}

110
bool String::set(ulonglong num, CHARSET_INFO *cs)
unknown's avatar
unknown committed
111
{
112 113 114
  uint l=20*cs->mbmaxlen+1;

  if (alloc(l))
unknown's avatar
unknown committed
115
    return TRUE;
116
  str_length=(uint32) (cs->cset->longlong10_to_str)(cs,Ptr,l,10,num);
117
  str_charset=cs;
unknown's avatar
unknown committed
118 119 120
  return FALSE;
}

121
bool String::set(double num,uint decimals, CHARSET_INFO *cs)
unknown's avatar
unknown committed
122 123
{
  char buff[331];
124
  uint dummy_errors;
125 126

  str_charset=cs;
unknown's avatar
unknown committed
127 128
  if (decimals >= NOT_FIXED_DEC)
  {
unknown's avatar
unknown committed
129
    uint32 len= my_sprintf(buff,(buff, "%.14g",num));// Enough for a DATETIME
130
    return copy(buff, len, &my_charset_latin1, cs, &dummy_errors);
unknown's avatar
unknown committed
131 132 133 134 135 136
  }
#ifdef HAVE_FCONVERT
  int decpt,sign;
  char *pos,*to;

  VOID(fconvert(num,(int) decimals,&decpt,&sign,buff+1));
unknown's avatar
unknown committed
137
  if (!my_isdigit(&my_charset_latin1, buff[1]))
unknown's avatar
unknown committed
138 139 140 141 142 143 144
  {						// Nan or Inf
    pos=buff+1;
    if (sign)
    {
      buff[0]='-';
      pos=buff;
    }
145 146
    uint dummy_errors;
    return copy(pos,(uint32) strlen(pos), &my_charset_latin1, cs, &dummy_errors);
unknown's avatar
unknown committed
147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
  }
  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
unknown's avatar
unknown committed
190
#ifdef HAVE_SNPRINTF
unknown's avatar
unknown committed
191 192
  buff[sizeof(buff)-1]=0;			// Safety
  snprintf(buff,sizeof(buff)-1, "%.*f",(int) decimals,num);
unknown's avatar
unknown committed
193 194 195
#else
  sprintf(buff,"%.*f",(int) decimals,num);
#endif
196 197
  return copy(buff,(uint32) strlen(buff), &my_charset_latin1, cs,
              &dummy_errors);
unknown's avatar
unknown committed
198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
#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;
219
  str_charset=str.str_charset;
unknown's avatar
unknown committed
220 221 222
  return FALSE;
}

223
bool String::copy(const char *str,uint32 arg_length, CHARSET_INFO *cs)
unknown's avatar
unknown committed
224 225 226
{
  if (alloc(arg_length))
    return TRUE;
227 228
  if ((str_length=arg_length))
    memcpy(Ptr,str,arg_length);
unknown's avatar
unknown committed
229
  Ptr[arg_length]=0;
230
  str_charset=cs;
unknown's avatar
unknown committed
231 232 233
  return FALSE;
}

234 235

/*
unknown's avatar
unknown committed
236 237 238 239 240 241 242 243 244 245 246 247 248 249 250
  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
251 252 253 254

  NOTE
  to_cs may be NULL for "no conversion" if the system variable
  character_set_results is NULL.
255
*/
unknown's avatar
unknown committed
256 257 258 259 260

bool String::needs_conversion(uint32 arg_length,
			      CHARSET_INFO *from_cs,
			      CHARSET_INFO *to_cs,
			      uint32 *offset)
261
{
unknown's avatar
unknown committed
262
  *offset= 0;
263 264
  if (!to_cs ||
      (to_cs == &my_charset_bin) || 
unknown's avatar
unknown committed
265 266
      (to_cs == from_cs) ||
      my_charset_same(from_cs, to_cs) ||
unknown's avatar
unknown committed
267 268
      ((from_cs == &my_charset_bin) &&
       (!(*offset=(arg_length % to_cs->mbminlen)))))
269 270 271 272
    return FALSE;
  return TRUE;
}

unknown's avatar
unknown committed
273

unknown's avatar
unknown committed
274
/*
unknown's avatar
unknown committed
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
  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
unknown's avatar
unknown committed
297 298
*/

unknown's avatar
unknown committed
299
bool String::copy_aligned(const char *str,uint32 arg_length, uint32 offset,
300
			  CHARSET_INFO *cs)
unknown's avatar
unknown committed
301 302
{
  /* How many bytes are in incomplete character */
unknown's avatar
unknown committed
303 304
  offset= cs->mbmaxlen - offset; /* How many zeros we should prepend */
  DBUG_ASSERT(offset && offset != cs->mbmaxlen);
unknown's avatar
unknown committed
305

unknown's avatar
unknown committed
306
  uint32 aligned_length= arg_length + offset;
unknown's avatar
unknown committed
307 308 309 310
  if (alloc(aligned_length))
    return TRUE;
  
  /*
unknown's avatar
unknown committed
311 312 313
    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.
unknown's avatar
unknown committed
314
  */
unknown's avatar
unknown committed
315 316
  bzero((char*) Ptr, offset);
  memcpy(Ptr + offset, str, arg_length);
unknown's avatar
unknown committed
317
  Ptr[aligned_length]=0;
unknown's avatar
unknown committed
318 319 320
  /* str_length is always >= 0 as arg_length is != 0 */
  str_length= aligned_length;
  str_charset= cs;
unknown's avatar
unknown committed
321 322 323
  return FALSE;
}

324 325 326 327 328

bool String::set_or_copy_aligned(const char *str,uint32 arg_length,
				 CHARSET_INFO *cs)
{
  /* How many bytes are in incomplete character */
unknown's avatar
unknown committed
329
  uint32 offset= (arg_length % cs->mbminlen); 
330
  
unknown's avatar
unknown committed
331
  if (!offset) /* All characters are complete, just copy */
332 333 334 335
  {
    set(str, arg_length, cs);
    return FALSE;
  }
unknown's avatar
unknown committed
336
  return copy_aligned(str, arg_length, offset, cs);
337 338
}

339
	/* Copy with charset convertion */
340

341
bool String::copy(const char *str, uint32 arg_length,
342
		  CHARSET_INFO *from_cs, CHARSET_INFO *to_cs, uint *errors)
343
{
unknown's avatar
unknown committed
344 345
  uint32 offset;
  if (!needs_conversion(arg_length, from_cs, to_cs, &offset))
346
  {
347
    *errors= 0;
348
    return copy(str, arg_length, to_cs);
349
  }
unknown's avatar
unknown committed
350
  if ((from_cs == &my_charset_bin) && offset)
351
  {
352
    *errors= 0;
unknown's avatar
unknown committed
353
    return copy_aligned(str, arg_length, offset, to_cs);
354
  }
355
  uint32 new_length= to_cs->mbmaxlen*arg_length;
356 357
  if (alloc(new_length))
    return TRUE;
358
  str_length=copy_and_convert((char*) Ptr, new_length, to_cs,
359
                              str, arg_length, from_cs, errors);
360 361 362
  str_charset=to_cs;
  return FALSE;
}
363

364 365 366

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

373 374 375 376 377 378 379 380 381 382 383
  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

*/

384
bool String::set_ascii(const char *str, uint32 arg_length)
385
{
unknown's avatar
unknown committed
386
  if (str_charset->mbminlen == 1)
387 388 389
  {
    set(str, arg_length, str_charset);
    return 0;
390
  }
391 392
  uint dummy_errors;
  return copy(str, arg_length, &my_charset_latin1, str_charset, &dummy_errors);
393 394
}

395

unknown's avatar
unknown committed
396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413
/* 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()
{
414
   while (str_length && my_isspace(str_charset,Ptr[str_length-1]))
unknown's avatar
unknown committed
415 416 417 418 419
    str_length--;
}

bool String::append(const String &s)
{
420 421 422 423 424 425 426
  if (s.length())
  {
    if (realloc(str_length+s.length()))
      return TRUE;
    memcpy(Ptr+str_length,s.ptr(),s.length());
    str_length+=s.length();
  }
unknown's avatar
unknown committed
427 428 429
  return FALSE;
}

430 431

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

unknown's avatar
unknown committed
435 436
bool String::append(const char *s,uint32 arg_length)
{
437 438 439 440 441 442 443
  if (!arg_length)
    return FALSE;

  /*
    For an ASCII incompatible string, e.g. UCS-2, we need to convert
  */
  if (str_charset->mbminlen > 1)
444 445
  {
    uint32 add_length=arg_length * str_charset->mbmaxlen;
446
    uint dummy_errors;
447 448 449
    if (realloc(str_length+ add_length))
      return TRUE;
    str_length+= copy_and_convert(Ptr+str_length, add_length, str_charset,
450 451
				  s, arg_length, &my_charset_latin1,
                                  &dummy_errors);
452 453
    return FALSE;
  }
454 455 456 457

  /*
    For an ASCII compatinble string we can just append.
  */
unknown's avatar
unknown committed
458 459 460 461 462 463 464
  if (realloc(str_length+arg_length))
    return TRUE;
  memcpy(Ptr+str_length,s,arg_length);
  str_length+=arg_length;
  return FALSE;
}

465

466 467 468 469 470 471 472 473 474 475
/*
  Append a 0-terminated ASCII string
*/

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


476 477 478 479 480 481 482
/*
  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)
{
483
  uint32 dummy_offset;
484
  
485
  if (needs_conversion(arg_length, cs, str_charset, &dummy_offset))
486
  {
487
    uint32 add_length= arg_length / cs->mbminlen * str_charset->mbmaxlen;
488
    uint dummy_errors;
489
    if (realloc(str_length + add_length)) 
490 491
      return TRUE;
    str_length+= copy_and_convert(Ptr+str_length, add_length, str_charset,
492
				  s, arg_length, cs, &dummy_errors);
493
  }
494 495
  else
  {
496 497
    if (realloc(str_length + arg_length)) 
      return TRUE;
498 499 500
    memcpy(Ptr + str_length, s, arg_length);
    str_length+= arg_length;
  }
501 502 503 504
  return FALSE;
}


505
#ifdef TO_BE_REMOVED
unknown's avatar
unknown committed
506 507 508 509 510 511 512 513 514 515 516 517
bool String::append(FILE* file, uint32 arg_length, myf my_flags)
{
  if (realloc(str_length+arg_length))
    return TRUE;
  if (my_fread(file, (byte*) Ptr + str_length, arg_length, my_flags))
  {
    shrink(str_length);
    return TRUE;
  }
  str_length+=arg_length;
  return FALSE;
}
518 519 520 521 522 523 524 525 526 527 528 529 530 531
#endif

bool String::append(IO_CACHE* file, uint32 arg_length)
{
  if (realloc(str_length+arg_length))
    return TRUE;
  if (my_b_read(file, (byte*) Ptr + str_length, arg_length))
  {
    shrink(str_length);
    return TRUE;
  }
  str_length+=arg_length;
  return FALSE;
}
unknown's avatar
unknown committed
532

unknown's avatar
unknown committed
533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549
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;
}

unknown's avatar
unknown committed
550 551
uint32 String::numchars()
{
552
  return str_charset->cset->numchars(str_charset, Ptr, Ptr+str_length);
unknown's avatar
unknown committed
553 554 555 556
}

int String::charpos(int i,uint32 offset)
{
557 558
  if (i <= 0)
    return i;
559
  return str_charset->cset->charpos(str_charset,Ptr+offset,Ptr+str_length,i);
unknown's avatar
unknown committed
560 561 562 563 564 565 566
}

int String::strstr(const String &s,uint32 offset)
{
  if (s.length()+offset <= str_length)
  {
    if (!s.length())
unknown's avatar
unknown committed
567
      return ((int) offset);	// Empty string is always found
unknown's avatar
unknown committed
568 569 570 571 572

    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();
573
skip:
unknown's avatar
unknown committed
574 575 576 577 578 579 580
    while (str != end)
    {
      if (*str++ == *search)
      {
	register char *i,*j;
	i=(char*) str; j=(char*) search+1;
	while (j != search_end)
581
	  if (*i++ != *j++) goto skip;
unknown's avatar
unknown committed
582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
	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;
604
skip:
unknown's avatar
unknown committed
605 606 607 608 609 610 611
    while (str != end)
    {
      if (*str-- == *search)
      {
	register char *i,*j;
	i=(char*) str; j=(char*) search-1;
	while (j != search_end)
612
	  if (*i-- != *j--) goto skip;
unknown's avatar
unknown committed
613 614 615 616 617 618 619 620 621 622 623 624 625 626 627
	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)
{
628 629 630 631 632 633 634
  return replace(offset,arg_length,to.ptr(),to.length());
}

bool String::replace(uint32 offset,uint32 arg_length,
                     const char *to,uint32 length)
{
  long diff = (long) length-(long) arg_length;
unknown's avatar
unknown committed
635 636 637 638
  if (offset+arg_length <= str_length)
  {
    if (diff < 0)
    {
639 640 641
      if (length)
	memcpy(Ptr+offset,to,length);
      bmove(Ptr+offset+length,Ptr+offset+arg_length,
unknown's avatar
unknown committed
642 643 644 645 646 647 648 649 650 651 652
	    str_length-offset-arg_length);
    }
    else
    {
      if (diff)
      {
	if (realloc(str_length+(uint32) diff))
	  return TRUE;
	bmove_upp(Ptr+str_length+diff,Ptr+str_length,
		  str_length-offset-arg_length);
      }
653 654
      if (length)
	memcpy(Ptr+offset,to,length);
unknown's avatar
unknown committed
655 656 657 658 659 660
    }
    str_length+=(uint32) diff;
  }
  return FALSE;
}

661

unknown's avatar
unknown committed
662 663 664 665 666 667 668 669 670 671 672
// 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;
}

unknown's avatar
unknown committed
673
void String::qs_append(const char *str, uint32 len)
unknown's avatar
unknown committed
674 675 676 677 678 679 680 681
{
  memcpy(Ptr + str_length, str, len + 1);
  str_length += len;
}

void String::qs_append(double d)
{
  char *buff = Ptr + str_length;
unknown's avatar
unknown committed
682
  str_length+= my_sprintf(buff, (buff, "%.14g", d));
unknown's avatar
unknown committed
683 684 685 686 687
}

void String::qs_append(double *d)
{
  double ld;
unknown's avatar
unknown committed
688
  float8get(ld, (char*) d);
unknown's avatar
unknown committed
689 690 691
  qs_append(ld);
}

692 693
void String::qs_append(int i)
{
unknown's avatar
unknown committed
694 695 696
  char *buff= Ptr + str_length;
  char *end= int10_to_str(i, buff, -10);
  str_length+= (int) (end-buff);
697 698 699 700
}

void String::qs_append(uint i)
{
unknown's avatar
unknown committed
701 702 703
  char *buff= Ptr + str_length;
  char *end= int10_to_str(i, buff, 10);
  str_length+= (int) (end-buff);
704 705
}

unknown's avatar
unknown committed
706 707 708 709 710 711 712 713 714 715 716
/*
  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
unknown's avatar
unknown committed
717

unknown's avatar
unknown committed
718 719 720 721 722 723 724 725
  RETURN
  < 0	s < t
  0	s == t
  > 0	s > t
*/


int sortcmp(const String *s,const String *t, CHARSET_INFO *cs)
unknown's avatar
unknown committed
726
{
unknown's avatar
unknown committed
727
 return cs->coll->strnncollsp(cs,
728 729
                              (unsigned char *) s->ptr(),s->length(),
                              (unsigned char *) t->ptr(),t->length(), 0);
unknown's avatar
unknown committed
730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751
}


/*
  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)
unknown's avatar
unknown committed
752
{
unknown's avatar
unknown committed
753 754 755
  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);
unknown's avatar
unknown committed
756 757 758 759 760 761 762 763 764 765 766 767 768 769
}


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
770 771
  if ((to->str_length=min(from->str_length,from_length)))
    memcpy(to->Ptr,from->Ptr,to->str_length);
772
  to->str_charset=from->str_charset;
unknown's avatar
unknown committed
773 774 775 776
  return to;
}


777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798
/****************************************************************************
  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'
*/

unknown's avatar
unknown committed
799

unknown's avatar
unknown committed
800
uint32
801
copy_and_convert(char *to, uint32 to_length, CHARSET_INFO *to_cs, 
802 803
                 const char *from, uint32 from_length, CHARSET_INFO *from_cs,
                 uint *errors)
804 805 806 807 808 809
{
  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;
810 811 812 813
  int (*mb_wc)(struct charset_info_st *, my_wc_t *, const uchar *,
	       const uchar *) = from_cs->cset->mb_wc;
  int (*wc_mb)(struct charset_info_st *, my_wc_t, uchar *s, uchar *e)=
    to_cs->cset->wc_mb;
814
  uint error_count= 0;
815

816
  while (1)
817
  {
818
    if ((cnvres= (*mb_wc)(from_cs, &wc, (uchar*) from,
unknown's avatar
unknown committed
819
				      from_end)) > 0)
820 821 822
      from+= cnvres;
    else if (cnvres == MY_CS_ILSEQ)
    {
823
      error_count++;
824 825 826
      from++;
      wc= '?';
    }
827 828 829 830 831 832 833 834 835 836
    else if (cnvres > MY_CS_TOOSMALL)
    {
      /*
        A correct multibyte sequence detected
        But it doesn't have Unicode mapping.
      */
      error_count++;
      from+= (-cnvres);
      wc= '?';
    }
837
    else
838
      break;  // Not enough characters
839 840

outp:
841
    if ((cnvres= (*wc_mb)(to_cs, wc, (uchar*) to, to_end)) > 0)
842 843 844
      to+= cnvres;
    else if (cnvres == MY_CS_ILUNI && wc != '?')
    {
845
      error_count++;
846 847 848 849 850 851
      wc= '?';
      goto outp;
    }
    else
      break;
  }
852
  *errors= error_count;
853 854
  return (uint32) (to - to_start);
}
unknown's avatar
unknown committed
855

856

857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012
/*
  copy a string,
  with optional character set conversion,
  with optional left padding (for binary -> UCS2 conversion)
  
  SYNOPSIS
    well_formed_copy_nhars()
    to			     Store result here
    to_length                Maxinum length of "to" string
    to_cs		     Character set of "to" string
    from		     Copy from here
    from_length		     Length of from string
    from_cs		     From character set
    nchars                   Copy not more that nchars characters
    well_formed_error_pos    Return position when "from" is not well formed
                             or NULL otherwise.
    cannot_convert_error_pos Return position where a not convertable
                             character met, or NULL otherwise.
    from_end_pos             Return position where scanning of "from"
                             string stopped.
  NOTES

  RETURN
    length of bytes copied to 'to'
*/


uint32
well_formed_copy_nchars(CHARSET_INFO *to_cs,
                        char *to, uint to_length,
                        CHARSET_INFO *from_cs,
                        const char *from, uint from_length,
                        uint nchars,
                        const char **well_formed_error_pos,
                        const char **cannot_convert_error_pos,
                        const char **from_end_pos)
{
  uint res;

  if ((to_cs == &my_charset_bin) || 
      (from_cs == &my_charset_bin) ||
      (to_cs == from_cs) ||
      my_charset_same(from_cs, to_cs))
  {
    if (to_length < to_cs->mbminlen || !nchars)
    {
      *from_end_pos= from;
      *cannot_convert_error_pos= NULL;
      *well_formed_error_pos= NULL;
      return 0;
    }

    if (to_cs == &my_charset_bin)
    {
      res= min(min(nchars, to_length), from_length);
      memmove(to, from, res);
      *from_end_pos= from + res;
      *well_formed_error_pos= NULL;
      *cannot_convert_error_pos= NULL;
    }
    else
    {
      int well_formed_error;
      uint from_offset;

      if ((from_offset= (from_length % to_cs->mbminlen)) &&
          (from_cs == &my_charset_bin))
      {
        /*
          Copying from BINARY to UCS2 needs to prepend zeros sometimes:
          INSERT INTO t1 (ucs2_column) VALUES (0x01);
          0x01 -> 0x0001
        */
        uint pad_length= to_cs->mbminlen - from_offset;
        bzero(to, pad_length);
        memmove(to + pad_length, from, from_offset);
        nchars--;
        from+= from_offset;
        from_length-= from_offset;
        to+= to_cs->mbminlen;
        to_length-= to_cs->mbminlen;
      }

      set_if_smaller(from_length, to_length);
      res= to_cs->cset->well_formed_len(to_cs, from, from + from_length,
                                        nchars, &well_formed_error);
      memmove(to, from, res);
      *from_end_pos= from + res;
      *well_formed_error_pos= well_formed_error ? from + res : NULL;
      *cannot_convert_error_pos= NULL;
      if (from_offset)
        res+= to_cs->mbminlen;
    }
  }
  else
  {
    int cnvres;
    my_wc_t wc;
    int (*mb_wc)(struct charset_info_st *, my_wc_t *,
                 const uchar *, const uchar *)= from_cs->cset->mb_wc;
    int (*wc_mb)(struct charset_info_st *, my_wc_t,
                 uchar *s, uchar *e)= to_cs->cset->wc_mb;
    const uchar *from_end= (const uchar*) from + from_length;
    uchar *to_end= (uchar*) to + to_length;
    char *to_start= to;
    *well_formed_error_pos= NULL;
    *cannot_convert_error_pos= NULL;

    for ( ; nchars; nchars--)
    {
      const char *from_prev= from;
      if ((cnvres= (*mb_wc)(from_cs, &wc, (uchar*) from, from_end)) > 0)
        from+= cnvres;
      else if (cnvres == MY_CS_ILSEQ)
      {
        if (!*well_formed_error_pos)
          *well_formed_error_pos= from;
        from++;
        wc= '?';
      }
      else if (cnvres > MY_CS_TOOSMALL)
      {
        /*
          A correct multibyte sequence detected
          But it doesn't have Unicode mapping.
        */
        if (!*cannot_convert_error_pos)
          *cannot_convert_error_pos= from;
        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 != '?')
      {
        if (!*cannot_convert_error_pos)
          *cannot_convert_error_pos= from_prev;
        wc= '?';
        goto outp;
      }
      else
        break;
    }
    *from_end_pos= from;
    res= to - to_start;
  }
  return (uint32) res;
}




unknown's avatar
unknown committed
1013 1014 1015
void String::print(String *str)
{
  char *st= (char*)Ptr, *end= st+str_length;
1016
  for (; st < end; st++)
unknown's avatar
unknown committed
1017 1018 1019 1020 1021
  {
    uchar c= *st;
    switch (c)
    {
    case '\\':
1022
      str->append(STRING_WITH_LEN("\\\\"));
unknown's avatar
unknown committed
1023 1024
      break;
    case '\0':
1025
      str->append(STRING_WITH_LEN("\\0"));
unknown's avatar
unknown committed
1026 1027
      break;
    case '\'':
1028
      str->append(STRING_WITH_LEN("\\'"));
unknown's avatar
unknown committed
1029 1030
      break;
    case '\n':
1031
      str->append(STRING_WITH_LEN("\\n"));
unknown's avatar
unknown committed
1032 1033
      break;
    case '\r':
1034
      str->append(STRING_WITH_LEN("\\r"));
unknown's avatar
unknown committed
1035 1036
      break;
    case 26: //Ctrl-Z
1037
      str->append(STRING_WITH_LEN("\\z"));
unknown's avatar
unknown committed
1038 1039 1040 1041 1042 1043
      break;
    default:
      str->append(c);
    }
  }
}
1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063


/*
  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);
}