sql_string.cc 13.7 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 19 20 21 22

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

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

unknown's avatar
unknown committed
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
CHARSET_INFO *system_charset_info= &my_charset_latin1;
unknown's avatar
unknown committed
32 33
extern gptr sql_alloc(unsigned size);
extern void sql_element_free(void *ptr);
34 35 36
static uint32
copy_and_convert(char *to, uint32 to_length, CHARSET_INFO *to_cs, 
		 const char *from, uint32 from_length, CHARSET_INFO *from_cs);
unknown's avatar
unknown committed
37 38 39 40 41 42 43 44 45 46

#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 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
  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))))
    {
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(longlong num, CHARSET_INFO *cs)
unknown's avatar
unknown committed
99
{
100 101 102
  uint l=20*cs->mbmaxlen+1;

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

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

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

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

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

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

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

230
	/* Copy with charset convertion */
231

232 233 234 235
bool String::copy(const char *str, uint32 arg_length,
		  CHARSET_INFO *from_cs, CHARSET_INFO *to_cs)
{
  uint32 new_length= to_cs->mbmaxlen*arg_length;
236 237
  if (alloc(new_length))
    return TRUE;
238 239 240 241 242
  str_length=copy_and_convert((char*) Ptr, new_length, to_cs,
			      str, arg_length, from_cs);
  str_charset=to_cs;
  return FALSE;
}
243

244 245 246

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

253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269
  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_latin1(const char *str, uint32 arg_length)
{
  if (str_charset->mbmaxlen == 1)
  {
    set(str, arg_length, str_charset);
    return 0;
270
  }
unknown's avatar
unknown committed
271
  return copy(str, arg_length, &my_charset_latin1, str_charset);
272 273
}

274

unknown's avatar
unknown committed
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292
/* 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()
{
293
   while (str_length && my_isspace(str_charset,Ptr[str_length-1]))
unknown's avatar
unknown committed
294 295 296 297 298
    str_length--;
}

bool String::append(const String &s)
{
299 300 301 302 303 304 305
  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
306 307 308
  return FALSE;
}

309 310 311 312 313 314

/*
  Append a latin1 string to the a string of the current character set
*/


unknown's avatar
unknown committed
315 316 317
bool String::append(const char *s,uint32 arg_length)
{
  if (!arg_length)				// Default argument
318 319
    if (!(arg_length= (uint32) strlen(s)))
      return FALSE;
320 321 322 323 324 325
  if (str_charset->mbmaxlen > 1)
  {
    uint32 add_length=arg_length * str_charset->mbmaxlen;
    if (realloc(str_length+ add_length))
      return TRUE;
    str_length+= copy_and_convert(Ptr+str_length, add_length, str_charset,
unknown's avatar
unknown committed
326
				  s, arg_length, &my_charset_latin1);
327 328
    return FALSE;
  }
unknown's avatar
unknown committed
329 330 331 332 333 334 335
  if (realloc(str_length+arg_length))
    return TRUE;
  memcpy(Ptr+str_length,s,arg_length);
  str_length+=arg_length;
  return FALSE;
}

336

337
#ifdef TO_BE_REMOVED
unknown's avatar
unknown committed
338 339 340 341 342 343 344 345 346 347 348 349
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;
}
350 351 352 353 354 355 356 357 358 359 360 361 362 363
#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
364 365 366

uint32 String::numchars()
{
367
  return str_charset->numchars(str_charset, Ptr, Ptr+str_length);
unknown's avatar
unknown committed
368 369 370 371
}

int String::charpos(int i,uint32 offset)
{
372 373
  if (i<0) return i;
  return str_charset->charpos(str_charset,Ptr+offset,Ptr+str_length,i);
unknown's avatar
unknown committed
374 375 376 377 378 379 380
}

int String::strstr(const String &s,uint32 offset)
{
  if (s.length()+offset <= str_length)
  {
    if (!s.length())
unknown's avatar
unknown committed
381
      return ((int) offset);	// Empty string is always found
unknown's avatar
unknown committed
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402

    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();
skipp:
    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 skipp;
	return (int) (str-Ptr) -1;
      }
    }
  }
  return -1;
}

403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421
/*
  Search after a string without regarding to case
  This needs to be replaced when we have character sets per string
*/

int String::strstr_case(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();
skipp:
    while (str != end)
    {
422
      if (str_charset->sort_order[*str++] == str_charset->sort_order[*search])
423 424 425 426
      {
	register char *i,*j;
	i=(char*) str; j=(char*) search+1;
	while (j != search_end)
427 428 429
	  if (str_charset->sort_order[*i++] != 
              str_charset->sort_order[*j++]) 
            goto skipp;
430 431 432 433 434 435
	return (int) (str-Ptr) -1;
      }
    }
  }
  return -1;
}
unknown's avatar
unknown committed
436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480

/*
** 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;
skipp:
    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 skipp;
	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)
{
  long diff = (long) to.length()-(long) arg_length;
  if (offset+arg_length <= str_length)
  {
    if (diff < 0)
    {
481 482
      if (to.length())
	memcpy(Ptr+offset,to.ptr(),to.length());
unknown's avatar
unknown committed
483 484 485 486 487 488 489 490 491 492 493 494
      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(Ptr+str_length+diff,Ptr+str_length,
		  str_length-offset-arg_length);
      }
495 496
      if (to.length())
	memcpy(Ptr+offset,to.ptr(),to.length());
unknown's avatar
unknown committed
497 498 499 500 501 502
    }
    str_length+=(uint32) diff;
  }
  return FALSE;
}

unknown's avatar
unknown committed
503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530
// 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)
{
  int len = strlen(str);
  memcpy(Ptr + str_length, str, len + 1);
  str_length += len;
}

void String::qs_append(double d)
{
  char *buff = Ptr + str_length;
  sprintf(buff,"%.14g", d);
  str_length += strlen(buff);
}

void String::qs_append(double *d)
{
  double ld;
unknown's avatar
unknown committed
531
  float8get(ld, (char*) d);
unknown's avatar
unknown committed
532 533 534 535 536 537 538 539 540
  qs_append(ld);
}

void String::qs_append(const char &c)
{
  Ptr[str_length] = c;
  str_length += sizeof(c);
}

unknown's avatar
unknown committed
541

542
int sortcmp(const String *x,const String *y, CHARSET_INFO *cs)
unknown's avatar
unknown committed
543
{
unknown's avatar
unknown committed
544 545 546
  return cs->strnncollsp(cs,
                        (unsigned char *) x->ptr(),x->length(),
			(unsigned char *) y->ptr(),y->length());
unknown's avatar
unknown committed
547 548 549 550 551 552 553 554 555 556 557 558 559 560
}


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
561 562
  if ((to->str_length=min(from->str_length,from_length)))
    memcpy(to->Ptr,from->Ptr,to->str_length);
563
  to->str_charset=from->str_charset;
unknown's avatar
unknown committed
564 565 566 567
  return to;
}


568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589
/****************************************************************************
  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
590

591 592 593 594 595 596 597 598 599 600
static uint32
copy_and_convert(char *to, uint32 to_length, CHARSET_INFO *to_cs, 
		 const char *from, uint32 from_length, CHARSET_INFO *from_cs)
{
  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;

601
  while (1)
602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625
  {
    if ((cnvres=from_cs->mb_wc(from_cs, &wc, (uchar*) from, from_end)) > 0)
      from+= cnvres;
    else if (cnvres == MY_CS_ILSEQ)
    {
      from++;
      wc= '?';
    }
    else
      break;					// Impossible char.

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