← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_string.cc

Merged build changes from Antony.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_string.cc
19
19
#pragma implementation                          // gcc: Class implementation
20
20
#endif
21
21
 
22
 
#include <my_global.h>
23
 
#include <my_sys.h>
24
 
#include <m_string.h>
25
 
#include <m_ctype.h>
 
22
#include "global.h"
 
23
#include <mysys/my_sys.h>
 
24
#include <mystrings/m_string.h>
26
25
 
27
26
/*
28
27
  The following extern declarations are ok as these are interface functions
38
37
** String functions
39
38
*****************************************************************************/
40
39
 
41
 
bool String::real_alloc(uint32 arg_length)
 
40
bool String::real_alloc(uint32_t arg_length)
42
41
{
43
42
  arg_length=ALIGN_SIZE(arg_length+1);
44
43
  str_length=0;
60
59
** (for C functions)
61
60
*/
62
61
 
63
 
bool String::realloc(uint32 alloc_length)
 
62
bool String::realloc(uint32_t alloc_length)
64
63
{
65
 
  uint32 len=ALIGN_SIZE(alloc_length+1);
 
64
  uint32_t len=ALIGN_SIZE(alloc_length+1);
66
65
  if (Alloced_length < len)
67
66
  {
68
67
    char *new_ptr;
99
98
 
100
99
  if (alloc(l))
101
100
    return true;
102
 
  str_length=(uint32) (cs->cset->int64_t10_to_str)(cs,Ptr,l,base,num);
 
101
  str_length=(uint32_t) (cs->cset->int64_t10_to_str)(cs,Ptr,l,base,num);
103
102
  str_charset=cs;
104
103
  return false;
105
104
}
117
116
    return copy(buff, len, &my_charset_latin1, cs, &dummy_errors);
118
117
  }
119
118
  len= my_fcvt(num, decimals, buff, NULL);
120
 
  return copy(buff, (uint32) len, &my_charset_latin1, cs,
 
119
  return copy(buff, (uint32_t) len, &my_charset_latin1, cs,
121
120
              &dummy_errors);
122
121
}
123
122
 
137
136
  if (alloc(str.str_length))
138
137
    return true;
139
138
  str_length=str.str_length;
140
 
  bmove(Ptr,str.Ptr,str_length);                // May be overlapping
 
139
  memmove(Ptr, str.Ptr, str_length);            // May be overlapping
141
140
  Ptr[str_length]=0;
142
141
  str_charset=str.str_charset;
143
142
  return false;
144
143
}
145
144
 
146
 
bool String::copy(const char *str,uint32 arg_length, CHARSET_INFO *cs)
 
145
bool String::copy(const char *str,uint32_t arg_length, CHARSET_INFO *cs)
147
146
{
148
147
  if (alloc(arg_length))
149
148
    return true;
165
164
  arg_length            Length of string to copy.
166
165
  from_cs               Character set to copy from
167
166
  to_cs                 Character set to copy to
168
 
  uint32 *offset        Returns number of unaligned characters.
 
167
  uint32_t *offset      Returns number of unaligned characters.
169
168
 
170
169
  RETURN
171
170
   0  No conversion needed
177
176
  character_set_results is NULL.
178
177
*/
179
178
 
180
 
bool String::needs_conversion(uint32 arg_length,
 
179
bool String::needs_conversion(uint32_t arg_length,
181
180
                              CHARSET_INFO *from_cs,
182
181
                              CHARSET_INFO *to_cs,
183
 
                              uint32 *offset)
 
182
                              uint32_t *offset)
184
183
{
185
184
  *offset= 0;
186
185
  if (!to_cs ||
219
218
    1  error
220
219
*/
221
220
 
222
 
bool String::copy_aligned(const char *str,uint32 arg_length, uint32 offset,
 
221
bool String::copy_aligned(const char *str,uint32_t arg_length, uint32_t offset,
223
222
                          CHARSET_INFO *cs)
224
223
{
225
224
  /* How many bytes are in incomplete character */
226
225
  offset= cs->mbmaxlen - offset; /* How many zeros we should prepend */
227
226
  assert(offset && offset != cs->mbmaxlen);
228
227
 
229
 
  uint32 aligned_length= arg_length + offset;
 
228
  uint32_t aligned_length= arg_length + offset;
230
229
  if (alloc(aligned_length))
231
230
    return true;
232
231
  
235
234
    If we add little-endian UCS-2 sometimes, this code
236
235
    will be more complicated. But it's OK for now.
237
236
  */
238
 
  bzero((char*) Ptr, offset);
 
237
  memset((char*) Ptr, 0, offset);
239
238
  memcpy(Ptr + offset, str, arg_length);
240
239
  Ptr[aligned_length]=0;
241
240
  /* str_length is always >= 0 as arg_length is != 0 */
245
244
}
246
245
 
247
246
 
248
 
bool String::set_or_copy_aligned(const char *str,uint32 arg_length,
 
247
bool String::set_or_copy_aligned(const char *str,uint32_t arg_length,
249
248
                                 CHARSET_INFO *cs)
250
249
{
251
250
  /* How many bytes are in incomplete character */
252
 
  uint32 offset= (arg_length % cs->mbminlen); 
 
251
  uint32_t offset= (arg_length % cs->mbminlen); 
253
252
  
254
253
  if (!offset) /* All characters are complete, just copy */
255
254
  {
261
260
 
262
261
        /* Copy with charset conversion */
263
262
 
264
 
bool String::copy(const char *str, uint32 arg_length,
 
263
bool String::copy(const char *str, uint32_t arg_length,
265
264
                  CHARSET_INFO *from_cs, CHARSET_INFO *to_cs, uint *errors)
266
265
{
267
 
  uint32 offset;
 
266
  uint32_t offset;
268
267
  if (!needs_conversion(arg_length, from_cs, to_cs, &offset))
269
268
  {
270
269
    *errors= 0;
275
274
    *errors= 0;
276
275
    return copy_aligned(str, arg_length, offset, to_cs);
277
276
  }
278
 
  uint32 new_length= to_cs->mbmaxlen*arg_length;
 
277
  uint32_t new_length= to_cs->mbmaxlen*arg_length;
279
278
  if (alloc(new_length))
280
279
    return true;
281
280
  str_length=copy_and_convert((char*) Ptr, new_length, to_cs,
304
303
 
305
304
*/
306
305
 
307
 
bool String::set_ascii(const char *str, uint32 arg_length)
 
306
bool String::set_ascii(const char *str, uint32_t arg_length)
308
307
{
309
308
  if (str_charset->mbminlen == 1)
310
309
  {
318
317
 
319
318
/* This is used by mysql.cc */
320
319
 
321
 
bool String::fill(uint32 max_length,char fill_char)
 
320
bool String::fill(uint32_t max_length,char fill_char)
322
321
{
323
322
  if (str_length > max_length)
324
323
    Ptr[str_length=max_length]=0;
326
325
  {
327
326
    if (realloc(max_length))
328
327
      return true;
329
 
    bfill(Ptr+str_length,max_length-str_length,fill_char);
 
328
    memset(Ptr+str_length, fill_char, max_length-str_length);
330
329
    str_length=max_length;
331
330
  }
332
331
  return false;
355
354
  Append an ASCII string to the a string of the current character set
356
355
*/
357
356
 
358
 
bool String::append(const char *s,uint32 arg_length)
 
357
bool String::append(const char *s,uint32_t arg_length)
359
358
{
360
359
  if (!arg_length)
361
360
    return false;
365
364
  */
366
365
  if (str_charset->mbminlen > 1)
367
366
  {
368
 
    uint32 add_length=arg_length * str_charset->mbmaxlen;
 
367
    uint32_t add_length=arg_length * str_charset->mbmaxlen;
369
368
    uint dummy_errors;
370
369
    if (realloc(str_length+ add_length))
371
370
      return true;
401
400
  with character set recoding
402
401
*/
403
402
 
404
 
bool String::append(const char *s,uint32 arg_length, CHARSET_INFO *cs)
 
403
bool String::append(const char *s,uint32_t arg_length, CHARSET_INFO *cs)
405
404
{
406
 
  uint32 dummy_offset;
 
405
  uint32_t dummy_offset;
407
406
  
408
407
  if (needs_conversion(arg_length, cs, str_charset, &dummy_offset))
409
408
  {
410
 
    uint32 add_length= arg_length / cs->mbminlen * str_charset->mbmaxlen;
 
409
    uint32_t add_length= arg_length / cs->mbminlen * str_charset->mbmaxlen;
411
410
    uint dummy_errors;
412
411
    if (realloc(str_length + add_length)) 
413
412
      return true;
425
424
}
426
425
 
427
426
 
428
 
bool String::append(IO_CACHE* file, uint32 arg_length)
 
427
bool String::append(IO_CACHE* file, uint32_t arg_length)
429
428
{
430
429
  if (realloc(str_length+arg_length))
431
430
    return true;
438
437
  return false;
439
438
}
440
439
 
441
 
bool String::append_with_prefill(const char *s,uint32 arg_length,
442
 
                 uint32 full_length, char fill_char)
 
440
bool String::append_with_prefill(const char *s,uint32_t arg_length,
 
441
                 uint32_t full_length, char fill_char)
443
442
{
444
443
  int t_length= arg_length > full_length ? arg_length : full_length;
445
444
 
448
447
  t_length= full_length - arg_length;
449
448
  if (t_length > 0)
450
449
  {
451
 
    bfill(Ptr+str_length, t_length, fill_char);
 
450
    memset(Ptr+str_length, fill_char, t_length);
452
451
    str_length=str_length + t_length;
453
452
  }
454
453
  append(s, arg_length);
455
454
  return false;
456
455
}
457
456
 
458
 
uint32 String::numchars()
 
457
uint32_t String::numchars()
459
458
{
460
459
  return str_charset->cset->numchars(str_charset, Ptr, Ptr+str_length);
461
460
}
462
461
 
463
 
int String::charpos(int i,uint32 offset)
 
462
int String::charpos(int i,uint32_t offset)
464
463
{
465
464
  if (i <= 0)
466
465
    return i;
467
466
  return str_charset->cset->charpos(str_charset,Ptr+offset,Ptr+str_length,i);
468
467
}
469
468
 
470
 
int String::strstr(const String &s,uint32 offset)
 
469
int String::strstr(const String &s,uint32_t offset)
471
470
{
472
471
  if (s.length()+offset <= str_length)
473
472
  {
498
497
** Search string from end. Offset is offset to the end of string
499
498
*/
500
499
 
501
 
int String::strrstr(const String &s,uint32 offset)
 
500
int String::strrstr(const String &s,uint32_t offset)
502
501
{
503
502
  if (s.length() <= offset && offset <= str_length)
504
503
  {
530
529
  If wrong parameter or not enough memory, do nothing
531
530
*/
532
531
 
533
 
bool String::replace(uint32 offset,uint32 arg_length,const String &to)
 
532
bool String::replace(uint32_t offset,uint32_t arg_length,const String &to)
534
533
{
535
534
  return replace(offset,arg_length,to.ptr(),to.length());
536
535
}
537
536
 
538
 
bool String::replace(uint32 offset,uint32 arg_length,
539
 
                     const char *to, uint32 to_length)
 
537
bool String::replace(uint32_t offset,uint32_t arg_length,
 
538
                     const char *to, uint32_t to_length)
540
539
{
541
540
  long diff = (long) to_length-(long) arg_length;
542
541
  if (offset+arg_length <= str_length)
545
544
    {
546
545
      if (to_length)
547
546
        memcpy(Ptr+offset,to,to_length);
548
 
      bmove(Ptr+offset+to_length,Ptr+offset+arg_length,
549
 
            str_length-offset-arg_length);
 
547
      memcpy(Ptr+offset+to_length, Ptr+offset+arg_length,
 
548
             str_length-offset-arg_length);
550
549
    }
551
550
    else
552
551
    {
553
552
      if (diff)
554
553
      {
555
 
        if (realloc(str_length+(uint32) diff))
 
554
        if (realloc(str_length+(uint32_t) diff))
556
555
          return true;
557
556
        bmove_upp((uchar*) Ptr+str_length+diff, (uchar*) Ptr+str_length,
558
557
                  str_length-offset-arg_length);
560
559
      if (to_length)
561
560
        memcpy(Ptr+offset,to,to_length);
562
561
    }
563
 
    str_length+=(uint32) diff;
 
562
    str_length+=(uint32_t) diff;
564
563
  }
565
564
  return false;
566
565
}
567
566
 
568
567
 
569
568
// added by Holyfoot for "geometry" needs
570
 
int String::reserve(uint32 space_needed, uint32 grow_by)
 
569
int String::reserve(uint32_t space_needed, uint32_t grow_by)
571
570
{
572
571
  if (Alloced_length < str_length + space_needed)
573
572
  {
577
576
  return false;
578
577
}
579
578
 
580
 
void String::qs_append(const char *str, uint32 len)
 
579
void String::qs_append(const char *str, uint32_t len)
581
580
{
582
581
  memcpy(Ptr + str_length, str, len + 1);
583
582
  str_length += len;
657
656
 
658
657
int stringcmp(const String *s,const String *t)
659
658
{
660
 
  uint32 s_len=s->length(),t_len=t->length(),len=min(s_len,t_len);
 
659
  uint32_t s_len=s->length(),t_len=t->length(),len=min(s_len,t_len);
661
660
  int cmp= memcmp(s->ptr(), t->ptr(), len);
662
661
  return (cmp) ? cmp : (int) (s_len - t_len);
663
662
}
664
663
 
665
664
 
666
 
String *copy_if_not_alloced(String *to,String *from,uint32 from_length)
 
665
String *copy_if_not_alloced(String *to,String *from,uint32_t from_length)
667
666
{
668
667
  if (from->Alloced_length >= from_length)
669
668
    return from;
704
703
*/
705
704
 
706
705
 
707
 
static uint32
708
 
copy_and_convert_extended(char *to, uint32 to_length, CHARSET_INFO *to_cs, 
709
 
                          const char *from, uint32 from_length,
 
706
static uint32_t
 
707
copy_and_convert_extended(char *to, uint32_t to_length, CHARSET_INFO *to_cs, 
 
708
                          const char *from, uint32_t from_length,
710
709
                          CHARSET_INFO *from_cs,
711
710
                          uint *errors)
712
711
{
756
755
      break;
757
756
  }
758
757
  *errors= error_count;
759
 
  return (uint32) (to - to_start);
 
758
  return (uint32_t) (to - to_start);
760
759
}
761
760
 
762
761
 
763
762
/*
764
763
  Optimized for quick copying of ASCII characters in the range 0x00..0x7F.
765
764
*/
766
 
uint32
767
 
copy_and_convert(char *to, uint32 to_length, CHARSET_INFO *to_cs, 
768
 
                 const char *from, uint32 from_length, CHARSET_INFO *from_cs,
 
765
uint32_t
 
766
copy_and_convert(char *to, uint32_t to_length, CHARSET_INFO *to_cs, 
 
767
                 const char *from, uint32_t from_length, CHARSET_INFO *from_cs,
769
768
                 uint *errors)
770
769
{
771
770
  /*
776
775
    return copy_and_convert_extended(to, to_length, to_cs,
777
776
                                     from, from_length, from_cs, errors);
778
777
 
779
 
  uint32 length= min(to_length, from_length), length2= length;
 
778
  uint32_t length= min(to_length, from_length), length2= length;
780
779
 
781
780
#if defined(__i386__)
782
781
  /*
788
787
  */
789
788
  for ( ; length >= 4; length-= 4, from+= 4, to+= 4)
790
789
  {
791
 
    if ((*(uint32*)from) & 0x80808080)
 
790
    if ((*(uint32_t*)from) & 0x80808080)
792
791
      break;
793
 
    *((uint32*) to)= *((const uint32*) from);
 
792
    *((uint32_t*) to)= *((const uint32_t*) from);
794
793
  }
795
794
#endif
796
795
 
803
802
    }
804
803
    if (*((unsigned char*) from) > 0x7F) /* A non-ASCII character */
805
804
    {
806
 
      uint32 copied_length= length2 - length;
 
805
      uint32_t copied_length= length2 - length;
807
806
      to_length-= copied_length;
808
807
      from_length-= copied_length;
809
808
      return copied_length + copy_and_convert_extended(to, to_length,
908
907
*/
909
908
 
910
909
 
911
 
uint32
 
910
uint32_t
912
911
well_formed_copy_nchars(CHARSET_INFO *to_cs,
913
912
                        char *to, uint to_length,
914
913
                        CHARSET_INFO *from_cs,
955
954
          0x01 -> 0x0001
956
955
        */
957
956
        uint pad_length= to_cs->mbminlen - from_offset;
958
 
        bzero(to, pad_length);
 
957
        memset(to, 0, pad_length);
959
958
        memmove(to + pad_length, from, from_offset);
960
959
        nchars--;
961
960
        from+= from_offset;
1032
1031
    *from_end_pos= from;
1033
1032
    res= to - to_start;
1034
1033
  }
1035
 
  return (uint32) res;
 
1034
  return (uint32_t) res;
1036
1035
}
1037
1036
 
1038
1037
 
1084
1083
void String::swap(String &s)
1085
1084
{
1086
1085
  swap_variables(char *, Ptr, s.Ptr);
1087
 
  swap_variables(uint32, str_length, s.str_length);
1088
 
  swap_variables(uint32, Alloced_length, s.Alloced_length);
 
1086
  swap_variables(uint32_t, str_length, s.str_length);
 
1087
  swap_variables(uint32_t, Alloced_length, s.Alloced_length);
1089
1088
  swap_variables(bool, alloced, s.alloced);
1090
1089
  swap_variables(CHARSET_INFO*, str_charset, s.str_charset);
1091
1090
}