← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_string.cc

  • Committer: lbieber
  • Date: 2010-10-07 02:59:11 UTC
  • mfrom: (1818.1.2 build)
  • Revision ID: lbieber@orisndriz08-20101007025911-rz1n8q23hrwxks6v
Merge Brian - Fix a large number of warning issues on ICC. sql_string becomes 64bit
Merge Monty - clean up ICC warnings

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_string.cc
58
58
{ }
59
59
 
60
60
 
61
 
String::String(uint32_t length_arg)
 
61
String::String(size_t length_arg)
62
62
  : Ptr(NULL),
63
63
    str_length(0),
64
64
    Alloced_length(0),
70
70
 
71
71
String::String(const char *str, const CHARSET_INFO * const cs)
72
72
  : Ptr(const_cast<char *>(str)),
73
 
    str_length(static_cast<uint32_t>(strlen(str))),
 
73
    str_length(static_cast<size_t>(strlen(str))),
74
74
    Alloced_length(0),
75
75
    alloced(false),
76
76
    str_charset(cs)
77
77
{ }
78
78
 
79
79
 
80
 
String::String(const char *str, uint32_t len, const CHARSET_INFO * const cs)
 
80
String::String(const char *str, size_t len, const CHARSET_INFO * const cs)
81
81
  : Ptr(const_cast<char *>(str)),
82
82
    str_length(len),
83
83
    Alloced_length(0),
86
86
{ }
87
87
 
88
88
 
89
 
String::String(char *str, uint32_t len, const CHARSET_INFO * const cs)
 
89
String::String(char *str, size_t len, const CHARSET_INFO * const cs)
90
90
  : Ptr(str),
91
91
    str_length(len),
92
92
    Alloced_length(len),
106
106
 
107
107
void *String::operator new(size_t size, memory::Root *mem_root)
108
108
{
109
 
  return mem_root->alloc_root(static_cast<uint32_t>(size));
 
109
  return mem_root->alloc_root(static_cast<size_t>(size));
110
110
}
111
111
 
112
112
String::~String() { free(); }
113
113
 
114
 
bool String::real_alloc(uint32_t arg_length)
 
114
bool String::real_alloc(size_t arg_length)
115
115
{
116
116
  arg_length=ALIGN_SIZE(arg_length+1);
117
117
  str_length=0;
133
133
** (for C functions)
134
134
*/
135
135
 
136
 
bool String::realloc(uint32_t alloc_length)
 
136
bool String::realloc(size_t alloc_length)
137
137
{
138
 
  uint32_t len=ALIGN_SIZE(alloc_length+1);
 
138
  size_t len=ALIGN_SIZE(alloc_length+1);
139
139
  if (Alloced_length < len)
140
140
  {
141
141
    char *new_ptr;
167
167
 
168
168
bool String::set_int(int64_t num, bool unsigned_flag, const CHARSET_INFO * const cs)
169
169
{
170
 
  uint32_t l=20*cs->mbmaxlen+1;
 
170
  size_t l=20*cs->mbmaxlen+1;
171
171
  int base= unsigned_flag ? 10 : -10;
172
172
 
173
173
  if (alloc(l))
174
174
    return true;
175
 
  str_length=(uint32_t) (cs->cset->int64_t10_to_str)(cs,Ptr,l,base,num);
 
175
  str_length=(size_t) (cs->cset->int64_t10_to_str)(cs,Ptr,l,base,num);
176
176
  str_charset=cs;
177
177
  return false;
178
178
}
179
179
 
180
 
bool String::set_real(double num,uint32_t decimals, const CHARSET_INFO * const cs)
 
180
bool String::set_real(double num,size_t decimals, const CHARSET_INFO * const cs)
181
181
{
182
182
  char buff[FLOATING_POINT_BUFFER];
183
 
  uint32_t dummy_errors;
 
183
  size_t dummy_errors;
184
184
  size_t len;
185
185
 
186
186
  str_charset=cs;
192
192
    return copy(buff, len, &my_charset_utf8_general_ci, cs, &dummy_errors);
193
193
  }
194
194
  len= internal::my_fcvt(num, decimals, buff, NULL);
195
 
  return copy(buff, (uint32_t) len, &my_charset_utf8_general_ci, cs,
 
195
  return copy(buff, (size_t) len, &my_charset_utf8_general_ci, cs,
196
196
              &dummy_errors);
197
197
}
198
198
 
218
218
  return false;
219
219
}
220
220
 
221
 
bool String::copy(const char *str,uint32_t arg_length, const CHARSET_INFO * const cs)
 
221
bool String::copy(const char *str,size_t arg_length, const CHARSET_INFO * const cs)
222
222
{
223
223
  if (alloc(arg_length))
224
224
    return true;
240
240
  arg_length            Length of string to copy.
241
241
  from_cs               Character set to copy from
242
242
  to_cs                 Character set to copy to
243
 
  uint32_t *offset      Returns number of unaligned characters.
 
243
  size_t *offset        Returns number of unaligned characters.
244
244
 
245
245
  RETURN
246
246
   0  No conversion needed
252
252
  character_set_results is NULL.
253
253
*/
254
254
 
255
 
bool String::needs_conversion(uint32_t arg_length,
 
255
bool String::needs_conversion(size_t arg_length,
256
256
                              const CHARSET_INFO * const from_cs,
257
257
                              const CHARSET_INFO * const to_cs,
258
 
                              uint32_t *offset)
 
258
                              size_t *offset)
259
259
{
260
260
  *offset= 0;
261
261
  if (!to_cs ||
271
271
 
272
272
 
273
273
 
274
 
bool String::set_or_copy_aligned(const char *str,uint32_t arg_length,
 
274
bool String::set_or_copy_aligned(const char *str,size_t arg_length,
275
275
                                 const CHARSET_INFO * const cs)
276
276
{
277
277
  /* How many bytes are in incomplete character */
278
 
  uint32_t offset= (arg_length % cs->mbminlen);
 
278
  size_t offset= (arg_length % cs->mbminlen);
279
279
 
280
280
  assert(!offset); /* All characters are complete, just copy */
281
281
 
285
285
 
286
286
        /* Copy with charset conversion */
287
287
 
288
 
bool String::copy(const char *str, uint32_t arg_length,
 
288
bool String::copy(const char *str, size_t arg_length,
289
289
                          const CHARSET_INFO * const,
290
 
                                  const CHARSET_INFO * const to_cs, uint32_t *errors)
 
290
                                  const CHARSET_INFO * const to_cs, size_t *errors)
291
291
{
292
292
  *errors= 0;
293
293
  return copy(str, arg_length, to_cs);
313
313
 
314
314
*/
315
315
 
316
 
bool String::set_ascii(const char *str, uint32_t arg_length)
 
316
bool String::set_ascii(const char *str, size_t arg_length)
317
317
{
318
318
  if (str_charset->mbminlen == 1)
319
319
  {
320
320
    set(str, arg_length, str_charset);
321
321
    return 0;
322
322
  }
323
 
  uint32_t dummy_errors;
 
323
  size_t dummy_errors;
324
324
  return copy(str, arg_length, &my_charset_utf8_general_ci, str_charset, &dummy_errors);
325
325
}
326
326
 
341
341
  Append an ASCII string to the a string of the current character set
342
342
*/
343
343
 
344
 
bool String::append(const char *s,uint32_t arg_length)
 
344
bool String::append(const char *s,size_t arg_length)
345
345
{
346
346
  if (!arg_length)
347
347
    return false;
372
372
  with character set recoding
373
373
*/
374
374
 
375
 
bool String::append(const char *s,uint32_t arg_length, const CHARSET_INFO * const)
 
375
bool String::append(const char *s,size_t arg_length, const CHARSET_INFO * const)
376
376
{
377
377
  if (realloc(str_length + arg_length))
378
378
    return true;
383
383
}
384
384
 
385
385
 
386
 
bool String::append_with_prefill(const char *s,uint32_t arg_length,
387
 
                 uint32_t full_length, char fill_char)
 
386
bool String::append_with_prefill(const char *s,size_t arg_length,
 
387
                 size_t full_length, char fill_char)
388
388
{
389
389
  int t_length= arg_length > full_length ? arg_length : full_length;
390
390
 
400
400
  return false;
401
401
}
402
402
 
403
 
uint32_t String::numchars()
 
403
size_t String::numchars()
404
404
{
405
405
  return str_charset->cset->numchars(str_charset, Ptr, Ptr+str_length);
406
406
}
407
407
 
408
 
int String::charpos(int i,uint32_t offset)
 
408
int String::charpos(int i,size_t offset)
409
409
{
410
410
  if (i <= 0)
411
411
    return i;
412
412
  return str_charset->cset->charpos(str_charset,Ptr+offset,Ptr+str_length,i);
413
413
}
414
414
 
415
 
int String::strstr(const String &s,uint32_t offset)
 
415
int String::strstr(const String &s,size_t offset)
416
416
{
417
417
  if (s.length()+offset <= str_length)
418
418
  {
443
443
** Search string from end. Offset is offset to the end of string
444
444
*/
445
445
 
446
 
int String::strrstr(const String &s,uint32_t offset)
 
446
int String::strrstr(const String &s,size_t offset)
447
447
{
448
448
  if (s.length() <= offset && offset <= str_length)
449
449
  {
475
475
  If wrong parameter or not enough memory, do nothing
476
476
*/
477
477
 
478
 
bool String::replace(uint32_t offset,uint32_t arg_length,const String &to)
 
478
bool String::replace(size_t offset,size_t arg_length,const String &to)
479
479
{
480
480
  return replace(offset,arg_length,to.ptr(),to.length());
481
481
}
482
482
 
483
 
bool String::replace(uint32_t offset,uint32_t arg_length,
484
 
                     const char *to, uint32_t to_length)
 
483
bool String::replace(size_t offset,size_t arg_length,
 
484
                     const char *to, size_t to_length)
485
485
{
486
486
  long diff = (long) to_length-(long) arg_length;
487
487
  if (offset+arg_length <= str_length)
497
497
    {
498
498
      if (diff)
499
499
      {
500
 
        if (realloc(str_length+(uint32_t) diff))
 
500
        if (realloc(str_length+(size_t) diff))
501
501
          return true;
502
502
        internal::bmove_upp((unsigned char*) Ptr+str_length+diff,
503
503
                            (unsigned char*) Ptr+str_length,
506
506
      if (to_length)
507
507
        memcpy(Ptr+offset,to,to_length);
508
508
    }
509
 
    str_length+=(uint32_t) diff;
 
509
    str_length+=(size_t) diff;
510
510
  }
511
511
  return false;
512
512
}
560
560
 
561
561
int stringcmp(const String *s,const String *t)
562
562
{
563
 
  uint32_t s_len= s->length(), t_len= t->length(), len= min(s_len,t_len);
 
563
  size_t s_len= s->length(), t_len= t->length(), len= min(s_len,t_len);
564
564
  int cmp= memcmp(s->ptr(), t->ptr(), len);
565
565
  return (cmp) ? cmp : (int) (s_len - t_len);
566
566
}
567
567
 
568
568
 
569
 
String *copy_if_not_alloced(String *to,String *from,uint32_t from_length)
 
569
String *copy_if_not_alloced(String *to,String *from,size_t from_length)
570
570
{
571
571
  if (from->Alloced_length >= from_length)
572
572
    return from;
615
615
*/
616
616
 
617
617
 
618
 
uint32_t
 
618
size_t
619
619
well_formed_copy_nchars(const CHARSET_INFO * const to_cs,
620
 
                        char *to, uint32_t to_length,
 
620
                        char *to, size_t to_length,
621
621
                        const CHARSET_INFO * const from_cs,
622
 
                        const char *from, uint32_t from_length,
623
 
                        uint32_t nchars,
 
622
                        const char *from, size_t from_length,
 
623
                        size_t nchars,
624
624
                        const char **well_formed_error_pos,
625
625
                        const char **cannot_convert_error_pos,
626
626
                        const char **from_end_pos)
627
627
{
628
 
  uint32_t res;
 
628
  size_t res;
629
629
 
630
630
  assert((to_cs == &my_charset_bin) ||
631
631
         (from_cs == &my_charset_bin) ||
651
651
  else
652
652
  {
653
653
    int well_formed_error;
654
 
    uint32_t from_offset;
 
654
    size_t from_offset;
655
655
 
656
656
    if ((from_offset= (from_length % to_cs->mbminlen)) &&
657
657
        (from_cs == &my_charset_bin))
661
661
        INSERT INTO t1 (ucs2_column) VALUES (0x01);
662
662
        0x01 -> 0x0001
663
663
      */
664
 
      uint32_t pad_length= to_cs->mbminlen - from_offset;
 
664
      size_t pad_length= to_cs->mbminlen - from_offset;
665
665
      memset(to, 0, pad_length);
666
666
      memmove(to + pad_length, from, from_offset);
667
667
      nchars--;
733
733
/* Factor the extern out */
734
734
extern const CHARSET_INFO *system_charset_info, *files_charset_info;
735
735
 
736
 
void String::append_identifier(const char *name, uint32_t in_length)
 
736
void String::append_identifier(const char *name, size_t in_length)
737
737
{
738
738
  const char *name_end;
739
739
  char quote_char;
788
788
  std::swap(str_charset, s.str_charset);
789
789
}
790
790
 
791
 
void String::q_append(const uint32_t n)
 
791
void String::q_append(const size_t n)
792
792
{
793
 
  int4store(Ptr + str_length, n);
 
793
  int8store(Ptr + str_length, n);
794
794
  str_length += 4;
795
795
}
796
796
void String::q_append(double d)
803
803
  float8store(Ptr + str_length, *d);
804
804
  str_length += 8;
805
805
}
806
 
void String::q_append(const char *data, uint32_t data_len)
 
806
void String::q_append(const char *data, size_t data_len)
807
807
{
808
808
  memcpy(Ptr + str_length, data, data_len);
809
809
  str_length += data_len;
810
810
}
811
811
 
812
 
void String::write_at_position(int position, uint32_t value)
 
812
void String::write_at_position(int position, size_t value)
813
813
{
814
 
  int4store(Ptr + position,value);
 
814
  int8store(Ptr + position,value);
815
815
}
816
816
bool check_if_only_end_space(const CHARSET_INFO * const cs, char *str,
817
817
                             char *end)