sql_string.cc 25.6 KB
Newer Older
unknown's avatar
unknown committed
1 2 3 4
/* 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
unknown's avatar
unknown committed
5
   the Free Software Foundation; version 2 of the License.
unknown's avatar
unknown committed
6 7

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

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

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

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

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

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

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

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

110
bool String::set_real(double num,uint decimals, CHARSET_INFO *cs)
unknown's avatar
unknown committed
111 112
{
  char buff[331];
113
  uint dummy_errors;
114 115

  str_charset=cs;
unknown's avatar
unknown committed
116 117
  if (decimals >= NOT_FIXED_DEC)
  {
unknown's avatar
unknown committed
118
    uint32 len= my_sprintf(buff,(buff, "%.14g",num));// Enough for a DATETIME
119
    return copy(buff, len, &my_charset_latin1, cs, &dummy_errors);
unknown's avatar
unknown committed
120 121 122 123 124 125
  }
#ifdef HAVE_FCONVERT
  int decpt,sign;
  char *pos,*to;

  VOID(fconvert(num,(int) decimals,&decpt,&sign,buff+1));
unknown's avatar
unknown committed
126
  if (!my_isdigit(&my_charset_latin1, buff[1]))
unknown's avatar
unknown committed
127 128 129 130 131 132 133
  {						// Nan or Inf
    pos=buff+1;
    if (sign)
    {
      buff[0]='-';
      pos=buff;
    }
134 135
    uint dummy_errors;
    return copy(pos,(uint32) strlen(pos), &my_charset_latin1, cs, &dummy_errors);
unknown's avatar
unknown committed
136 137 138 139 140 141 142 143 144 145 146 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
  }
  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
179
#ifdef HAVE_SNPRINTF
unknown's avatar
unknown committed
180 181
  buff[sizeof(buff)-1]=0;			// Safety
  snprintf(buff,sizeof(buff)-1, "%.*f",(int) decimals,num);
unknown's avatar
unknown committed
182 183 184
#else
  sprintf(buff,"%.*f",(int) decimals,num);
#endif
185 186
  return copy(buff,(uint32) strlen(buff), &my_charset_latin1, cs,
              &dummy_errors);
unknown's avatar
unknown committed
187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
#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;
208
  str_charset=str.str_charset;
unknown's avatar
unknown committed
209 210 211
  return FALSE;
}

212
bool String::copy(const char *str,uint32 arg_length, CHARSET_INFO *cs)
unknown's avatar
unknown committed
213 214 215
{
  if (alloc(arg_length))
    return TRUE;
216 217
  if ((str_length=arg_length))
    memcpy(Ptr,str,arg_length);
unknown's avatar
unknown committed
218
  Ptr[arg_length]=0;
219
  str_charset=cs;
unknown's avatar
unknown committed
220 221 222
  return FALSE;
}

223 224

/*
unknown's avatar
unknown committed
225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
  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
240 241 242 243

  NOTE
  to_cs may be NULL for "no conversion" if the system variable
  character_set_results is NULL.
244
*/
unknown's avatar
unknown committed
245 246 247 248 249

bool String::needs_conversion(uint32 arg_length,
			      CHARSET_INFO *from_cs,
			      CHARSET_INFO *to_cs,
			      uint32 *offset)
250
{
unknown's avatar
unknown committed
251
  *offset= 0;
252 253
  if (!to_cs ||
      (to_cs == &my_charset_bin) || 
unknown's avatar
unknown committed
254 255
      (to_cs == from_cs) ||
      my_charset_same(from_cs, to_cs) ||
unknown's avatar
unknown committed
256 257
      ((from_cs == &my_charset_bin) &&
       (!(*offset=(arg_length % to_cs->mbminlen)))))
258 259 260 261
    return FALSE;
  return TRUE;
}

unknown's avatar
unknown committed
262

unknown's avatar
unknown committed
263
/*
unknown's avatar
unknown committed
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285
  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
286 287
*/

unknown's avatar
unknown committed
288
bool String::copy_aligned(const char *str,uint32 arg_length, uint32 offset,
289
			  CHARSET_INFO *cs)
unknown's avatar
unknown committed
290 291
{
  /* How many bytes are in incomplete character */
unknown's avatar
unknown committed
292 293
  offset= cs->mbmaxlen - offset; /* How many zeros we should prepend */
  DBUG_ASSERT(offset && offset != cs->mbmaxlen);
unknown's avatar
unknown committed
294

unknown's avatar
unknown committed
295
  uint32 aligned_length= arg_length + offset;
unknown's avatar
unknown committed
296 297 298 299
  if (alloc(aligned_length))
    return TRUE;
  
  /*
unknown's avatar
unknown committed
300 301
    Note, this is only safe for big-endian UCS-2.
    If we add little-endian UCS-2 sometimes, this code
unknown's avatar
unknown committed
302
    will be more complicated. But it's OK for now.
unknown's avatar
unknown committed
303
  */
unknown's avatar
unknown committed
304 305
  bzero((char*) Ptr, offset);
  memcpy(Ptr + offset, str, arg_length);
unknown's avatar
unknown committed
306
  Ptr[aligned_length]=0;
unknown's avatar
unknown committed
307 308 309
  /* str_length is always >= 0 as arg_length is != 0 */
  str_length= aligned_length;
  str_charset= cs;
unknown's avatar
unknown committed
310 311 312
  return FALSE;
}

313 314 315 316 317

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
318
  uint32 offset= (arg_length % cs->mbminlen); 
319
  
unknown's avatar
unknown committed
320
  if (!offset) /* All characters are complete, just copy */
321 322 323 324
  {
    set(str, arg_length, cs);
    return FALSE;
  }
unknown's avatar
unknown committed
325
  return copy_aligned(str, arg_length, offset, cs);
326 327
}

328
	/* Copy with charset conversion */
329

330
bool String::copy(const char *str, uint32 arg_length,
331
		  CHARSET_INFO *from_cs, CHARSET_INFO *to_cs, uint *errors)
332
{
unknown's avatar
unknown committed
333 334
  uint32 offset;
  if (!needs_conversion(arg_length, from_cs, to_cs, &offset))
335
  {
336
    *errors= 0;
337
    return copy(str, arg_length, to_cs);
338
  }
unknown's avatar
unknown committed
339
  if ((from_cs == &my_charset_bin) && offset)
340
  {
341
    *errors= 0;
unknown's avatar
unknown committed
342
    return copy_aligned(str, arg_length, offset, to_cs);
343
  }
344
  uint32 new_length= to_cs->mbmaxlen*arg_length;
345 346
  if (alloc(new_length))
    return TRUE;
347
  str_length=copy_and_convert((char*) Ptr, new_length, to_cs,
348
                              str, arg_length, from_cs, errors);
349 350 351
  str_charset=to_cs;
  return FALSE;
}
352

353 354 355

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

362 363 364 365 366 367 368 369 370 371 372
  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

*/

373
bool String::set_ascii(const char *str, uint32 arg_length)
374
{
unknown's avatar
unknown committed
375
  if (str_charset->mbminlen == 1)
376 377 378
  {
    set(str, arg_length, str_charset);
    return 0;
379
  }
380 381
  uint dummy_errors;
  return copy(str, arg_length, &my_charset_latin1, str_charset, &dummy_errors);
382 383
}

384

unknown's avatar
unknown committed
385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402
/* 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()
{
403
   while (str_length && my_isspace(str_charset,Ptr[str_length-1]))
unknown's avatar
unknown committed
404 405 406 407 408
    str_length--;
}

bool String::append(const String &s)
{
409 410 411 412 413 414 415
  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
416 417 418
  return FALSE;
}

419 420

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

unknown's avatar
unknown committed
424 425
bool String::append(const char *s,uint32 arg_length)
{
426 427 428 429 430 431 432
  if (!arg_length)
    return FALSE;

  /*
    For an ASCII incompatible string, e.g. UCS-2, we need to convert
  */
  if (str_charset->mbminlen > 1)
433 434
  {
    uint32 add_length=arg_length * str_charset->mbmaxlen;
435
    uint dummy_errors;
436 437 438
    if (realloc(str_length+ add_length))
      return TRUE;
    str_length+= copy_and_convert(Ptr+str_length, add_length, str_charset,
439 440
				  s, arg_length, &my_charset_latin1,
                                  &dummy_errors);
441 442
    return FALSE;
  }
443 444 445 446

  /*
    For an ASCII compatinble string we can just append.
  */
unknown's avatar
unknown committed
447 448 449 450 451 452 453
  if (realloc(str_length+arg_length))
    return TRUE;
  memcpy(Ptr+str_length,s,arg_length);
  str_length+=arg_length;
  return FALSE;
}

454

455 456 457 458 459 460 461 462 463 464
/*
  Append a 0-terminated ASCII string
*/

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


465 466 467 468 469 470 471
/*
  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)
{
472
  uint32 dummy_offset;
473
  
474
  if (needs_conversion(arg_length, cs, str_charset, &dummy_offset))
475
  {
476
    uint32 add_length= arg_length / cs->mbminlen * str_charset->mbmaxlen;
477
    uint dummy_errors;
478
    if (realloc(str_length + add_length)) 
479 480
      return TRUE;
    str_length+= copy_and_convert(Ptr+str_length, add_length, str_charset,
481
				  s, arg_length, cs, &dummy_errors);
482
  }
483 484
  else
  {
485 486
    if (realloc(str_length + arg_length)) 
      return TRUE;
487 488 489
    memcpy(Ptr + str_length, s, arg_length);
    str_length+= arg_length;
  }
490 491 492 493
  return FALSE;
}


494
#ifdef TO_BE_REMOVED
unknown's avatar
unknown committed
495 496 497 498
bool String::append(FILE* file, uint32 arg_length, myf my_flags)
{
  if (realloc(str_length+arg_length))
    return TRUE;
499
  if (my_fread(file, (uchar*) Ptr + str_length, arg_length, my_flags))
unknown's avatar
unknown committed
500 501 502 503 504 505 506
  {
    shrink(str_length);
    return TRUE;
  }
  str_length+=arg_length;
  return FALSE;
}
507 508 509 510 511 512
#endif

bool String::append(IO_CACHE* file, uint32 arg_length)
{
  if (realloc(str_length+arg_length))
    return TRUE;
513
  if (my_b_read(file, (uchar*) Ptr + str_length, arg_length))
514 515 516 517 518 519 520
  {
    shrink(str_length);
    return TRUE;
  }
  str_length+=arg_length;
  return FALSE;
}
unknown's avatar
unknown committed
521

unknown's avatar
unknown committed
522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538
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
539 540
uint32 String::numchars()
{
541
  return str_charset->cset->numchars(str_charset, Ptr, Ptr+str_length);
unknown's avatar
unknown committed
542 543 544 545
}

int String::charpos(int i,uint32 offset)
{
546 547
  if (i <= 0)
    return i;
548
  return str_charset->cset->charpos(str_charset,Ptr+offset,Ptr+str_length,i);
unknown's avatar
unknown committed
549 550 551 552 553 554 555
}

int String::strstr(const String &s,uint32 offset)
{
  if (s.length()+offset <= str_length)
  {
    if (!s.length())
unknown's avatar
unknown committed
556
      return ((int) offset);	// Empty string is always found
unknown's avatar
unknown committed
557 558 559 560 561

    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();
562
skip:
unknown's avatar
unknown committed
563 564 565 566 567 568 569
    while (str != end)
    {
      if (*str++ == *search)
      {
	register char *i,*j;
	i=(char*) str; j=(char*) search+1;
	while (j != search_end)
570
	  if (*i++ != *j++) goto skip;
unknown's avatar
unknown committed
571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592
	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;
593
skip:
unknown's avatar
unknown committed
594 595 596 597 598 599 600
    while (str != end)
    {
      if (*str-- == *search)
      {
	register char *i,*j;
	i=(char*) str; j=(char*) search-1;
	while (j != search_end)
601
	  if (*i-- != *j--) goto skip;
unknown's avatar
unknown committed
602 603 604 605 606 607 608 609
	return (int) (i-Ptr) +1;
      }
    }
  }
  return -1;
}

/*
610 611
  Replace substring with string
  If wrong parameter or not enough memory, do nothing
unknown's avatar
unknown committed
612 613 614 615
*/

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

bool String::replace(uint32 offset,uint32 arg_length,
620
                     const char *to, uint32 to_length)
621
{
622
  long diff = (long) to_length-(long) arg_length;
unknown's avatar
unknown committed
623 624 625 626
  if (offset+arg_length <= str_length)
  {
    if (diff < 0)
    {
627 628 629
      if (to_length)
	memcpy(Ptr+offset,to,to_length);
      bmove(Ptr+offset+to_length,Ptr+offset+arg_length,
unknown's avatar
unknown committed
630 631 632 633 634 635 636 637
	    str_length-offset-arg_length);
    }
    else
    {
      if (diff)
      {
	if (realloc(str_length+(uint32) diff))
	  return TRUE;
638
	bmove_upp((uchar*) Ptr+str_length+diff, (uchar*) Ptr+str_length,
unknown's avatar
unknown committed
639 640
		  str_length-offset-arg_length);
      }
641 642
      if (to_length)
	memcpy(Ptr+offset,to,to_length);
unknown's avatar
unknown committed
643 644 645 646 647 648
    }
    str_length+=(uint32) diff;
  }
  return FALSE;
}

649

unknown's avatar
unknown committed
650 651 652 653 654 655 656 657 658 659 660
// 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
661
void String::qs_append(const char *str, uint32 len)
unknown's avatar
unknown committed
662 663 664 665 666 667 668 669
{
  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
670
  str_length+= my_sprintf(buff, (buff, "%.14g", d));
unknown's avatar
unknown committed
671 672 673 674 675
}

void String::qs_append(double *d)
{
  double ld;
unknown's avatar
unknown committed
676
  float8get(ld, (char*) d);
unknown's avatar
unknown committed
677 678 679
  qs_append(ld);
}

680 681
void String::qs_append(int i)
{
unknown's avatar
unknown committed
682 683 684
  char *buff= Ptr + str_length;
  char *end= int10_to_str(i, buff, -10);
  str_length+= (int) (end-buff);
685 686 687 688
}

void String::qs_append(uint i)
{
unknown's avatar
unknown committed
689 690 691
  char *buff= Ptr + str_length;
  char *end= int10_to_str(i, buff, 10);
  str_length+= (int) (end-buff);
692 693
}

unknown's avatar
unknown committed
694 695 696 697 698 699 700 701 702 703 704
/*
  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
705

unknown's avatar
unknown committed
706 707 708 709 710 711 712 713
  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
714
{
unknown's avatar
unknown committed
715
 return cs->coll->strnncollsp(cs,
unknown's avatar
unknown committed
716 717
                              (uchar *) s->ptr(),s->length(),
                              (uchar *) t->ptr(),t->length(), 0);
unknown's avatar
unknown committed
718 719 720 721 722 723 724 725 726 727 728 729
}


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

  SYNOPSIS
    stringcmp()
    s		First string
    t		Second string

  NOTE:
unknown's avatar
unknown committed
730
    Strings are compared as a stream of uchars
unknown's avatar
unknown committed
731 732 733 734 735 736 737 738 739

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


int stringcmp(const String *s,const String *t)
unknown's avatar
unknown committed
740
{
unknown's avatar
unknown committed
741 742 743
  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
744 745 746 747 748 749 750 751 752 753 754 755 756 757
}


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
758 759
  if ((to->str_length=min(from->str_length,from_length)))
    memcpy(to->Ptr,from->Ptr,to->str_length);
760
  to->str_charset=from->str_charset;
unknown's avatar
unknown committed
761 762 763 764
  return to;
}


765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786
/****************************************************************************
  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
787

unknown's avatar
unknown committed
788
uint32
789
copy_and_convert(char *to, uint32 to_length, CHARSET_INFO *to_cs, 
790 791
                 const char *from, uint32 from_length, CHARSET_INFO *from_cs,
                 uint *errors)
792 793 794 795 796 797
{
  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;
798 799
  my_charset_conv_mb_wc mb_wc= from_cs->cset->mb_wc;
  my_charset_conv_wc_mb wc_mb= to_cs->cset->wc_mb;
800
  uint error_count= 0;
801

802
  while (1)
803
  {
804
    if ((cnvres= (*mb_wc)(from_cs, &wc, (uchar*) from,
unknown's avatar
unknown committed
805
				      from_end)) > 0)
806 807 808
      from+= cnvres;
    else if (cnvres == MY_CS_ILSEQ)
    {
809
      error_count++;
810 811 812
      from++;
      wc= '?';
    }
813 814 815 816 817 818 819 820 821 822
    else if (cnvres > MY_CS_TOOSMALL)
    {
      /*
        A correct multibyte sequence detected
        But it doesn't have Unicode mapping.
      */
      error_count++;
      from+= (-cnvres);
      wc= '?';
    }
823
    else
824
      break;  // Not enough characters
825 826

outp:
827
    if ((cnvres= (*wc_mb)(to_cs, wc, (uchar*) to, to_end)) > 0)
828 829 830
      to+= cnvres;
    else if (cnvres == MY_CS_ILUNI && wc != '?')
    {
831
      error_count++;
832 833 834 835 836 837
      wc= '?';
      goto outp;
    }
    else
      break;
  }
838
  *errors= error_count;
839 840
  return (uint32) (to - to_start);
}
unknown's avatar
unknown committed
841

842

843 844 845 846 847 848 849 850 851 852 853 854 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
/**
  Copy string with HEX-encoding of "bad" characters.

  @details This functions copies the string pointed by "src"
  to the string pointed by "dst". Not more than "srclen" bytes
  are read from "src". Any sequences of bytes representing
  a not-well-formed substring (according to cs) are hex-encoded,
  and all well-formed substrings (according to cs) are copied as is.
  Not more than "dstlen" bytes are written to "dst". The number 
  of bytes written to "dst" is returned.
  
   @param      cs       character set pointer of the destination string
   @param[out] dst      destination string
   @param      dstlen   size of dst
   @param      src      source string
   @param      srclen   length of src

   @retval     result length
*/

size_t
my_copy_with_hex_escaping(CHARSET_INFO *cs,
                          char *dst, size_t dstlen,
                          const char *src, size_t srclen)
{
  const char *srcend= src + srclen;
  char *dst0= dst;

  for ( ; src < srcend ; )
  {
    size_t chlen;
    if ((chlen= my_ismbchar(cs, src, srcend)))
    {
      if (dstlen < chlen)
        break; /* purecov: inspected */
      memcpy(dst, src, chlen);
      src+= chlen;
      dst+= chlen;
      dstlen-= chlen;
    }
    else if (*src & 0x80)
    {
      if (dstlen < 4)
        break; /* purecov: inspected */
      *dst++= '\\';
      *dst++= 'x';
      *dst++= _dig_vec_upper[((unsigned char) *src) >> 4];
      *dst++= _dig_vec_upper[((unsigned char) *src) & 15];
      src++;
      dstlen-= 4;
    }
    else
    {
      if (dstlen < 1)
        break; /* purecov: inspected */
      *dst++= *src++;
      dstlen--;
    }
  }
  return dst - dst0;
}

905 906 907 908 909 910
/*
  copy a string,
  with optional character set conversion,
  with optional left padding (for binary -> UCS2 conversion)
  
  SYNOPSIS
911
    well_formed_copy_nchars()
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
    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;
1003 1004
    my_charset_conv_mb_wc mb_wc= from_cs->cset->mb_wc;
    my_charset_conv_wc_mb wc_mb= to_cs->cset->wc_mb;
1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047
    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
1048 1049
      {
        from= from_prev;
1050
        break;
1051
      }
1052 1053 1054 1055 1056 1057 1058 1059 1060 1061
    }
    *from_end_pos= from;
    res= to - to_start;
  }
  return (uint32) res;
}




unknown's avatar
unknown committed
1062 1063 1064
void String::print(String *str)
{
  char *st= (char*)Ptr, *end= st+str_length;
1065
  for (; st < end; st++)
unknown's avatar
unknown committed
1066 1067 1068 1069 1070
  {
    uchar c= *st;
    switch (c)
    {
    case '\\':
1071
      str->append(STRING_WITH_LEN("\\\\"));
unknown's avatar
unknown committed
1072 1073
      break;
    case '\0':
1074
      str->append(STRING_WITH_LEN("\\0"));
unknown's avatar
unknown committed
1075 1076
      break;
    case '\'':
1077
      str->append(STRING_WITH_LEN("\\'"));
unknown's avatar
unknown committed
1078 1079
      break;
    case '\n':
1080
      str->append(STRING_WITH_LEN("\\n"));
unknown's avatar
unknown committed
1081 1082
      break;
    case '\r':
1083
      str->append(STRING_WITH_LEN("\\r"));
unknown's avatar
unknown committed
1084
      break;
1085 1086
    case '\032': // Ctrl-Z
      str->append(STRING_WITH_LEN("\\Z"));
unknown's avatar
unknown committed
1087 1088 1089 1090 1091 1092
      break;
    default:
      str->append(c);
    }
  }
}
1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112


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