← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to strings/ctype-ucs2.c

  • Committer: Brian Aker
  • Date: 2008-07-18 20:10:26 UTC
  • mfrom: (51.3.29 remove-dbug)
  • Revision ID: brian@tangent.org-20080718201026-tto5golt0xhwqe4a
Merging in Jay's final patch on dbug.

Show diffs side-by-side

added added

removed removed

Lines of Context:
strings/ctype-ucs2.c
66
66
my_caseup_str_mb2_or_mb4(CHARSET_INFO * cs  __attribute__((unused)), 
67
67
                         char * s __attribute__((unused)))
68
68
{
69
 
  DBUG_ASSERT(0);
 
69
  assert(0);
70
70
  return 0;
71
71
}
72
72
 
75
75
my_casedn_str_mb2_or_mb4(CHARSET_INFO *cs __attribute__((unused)), 
76
76
                         char * s __attribute__((unused)))
77
77
{
78
 
  DBUG_ASSERT(0);
 
78
  assert(0);
79
79
  return 0;
80
80
}
81
81
 
85
85
                         const char *s __attribute__((unused)),
86
86
                         const char *t __attribute__((unused)))
87
87
{
88
 
  DBUG_ASSERT(0);
 
88
  assert(0);
89
89
  return 0;
90
90
}
91
91
 
997
997
    *dst++= '%';                            /* % used as % or unknown code */
998
998
  }
999
999
  
1000
 
  DBUG_ASSERT(dst <= end);
 
1000
  assert(dst <= end);
1001
1001
  *dst='\0';                                /* End of errmessage */
1002
1002
  return (size_t) (dst - start);
1003
1003
}
1153
1153
  int res;
1154
1154
  char *srcend= src + srclen;
1155
1155
  MY_UNICASE_INFO **uni_plane= cs->caseinfo;
1156
 
  DBUG_ASSERT(src == dst && srclen == dstlen);
 
1156
  assert(src == dst && srclen == dstlen);
1157
1157
  
1158
1158
  while ((src < srcend) &&
1159
1159
         (res= my_utf16_uni(cs, &wc, (uchar *)src, (uchar*) srcend)) > 0)
1200
1200
  int res;
1201
1201
  char *srcend= src + srclen;
1202
1202
  MY_UNICASE_INFO **uni_plane= cs->caseinfo;
1203
 
  DBUG_ASSERT(src == dst && srclen == dstlen);
 
1203
  assert(src == dst && srclen == dstlen);
1204
1204
 
1205
1205
  while ((src < srcend) &&
1206
1206
         (res= my_utf16_uni(cs, &wc, (uchar*) src, (uchar*) srcend)) > 0)
1289
1289
  const uchar *se= s + slen, *te= t + tlen;
1290
1290
  MY_UNICASE_INFO **uni_plane= cs->caseinfo;
1291
1291
 
1292
 
  DBUG_ASSERT((slen % 2) == 0);
1293
 
  DBUG_ASSERT((tlen % 2) == 0);
 
1292
  assert((slen % 2) == 0);
 
1293
  assert((tlen % 2) == 0);
1294
1294
 
1295
1295
#ifndef VARCHAR_WITH_DIFF_ENDSPACE_ARE_DIFFERENT_FOR_UNIQUE
1296
1296
  diff_if_only_endspace_difference= FALSE;
1341
1341
    {
1342
1342
      if ((s_res= my_utf16_uni(cs, &s_wc, s, se)) < 0)
1343
1343
      {
1344
 
        DBUG_ASSERT(0);
 
1344
        assert(0);
1345
1345
        return 0;
1346
1346
      }
1347
1347
      if (s_wc != ' ')
1532
1532
  my_wc_t s_wc= 0, t_wc= 0;
1533
1533
  const uchar *se= s + slen, *te= t + tlen;
1534
1534
 
1535
 
  DBUG_ASSERT((slen % 2) == 0);
1536
 
  DBUG_ASSERT((tlen % 2) == 0);
 
1535
  assert((slen % 2) == 0);
 
1536
  assert((tlen % 2) == 0);
1537
1537
 
1538
1538
#ifndef VARCHAR_WITH_DIFF_ENDSPACE_ARE_DIFFERENT_FOR_UNIQUE
1539
1539
  diff_if_only_endspace_difference= FALSE;
1581
1581
    {
1582
1582
      if ((s_res= my_utf16_uni(cs, &s_wc, s, se)) < 0)
1583
1583
      {
1584
 
        DBUG_ASSERT(0);
 
1584
        assert(0);
1585
1585
        return 0;
1586
1586
      }
1587
1587
      if (s_wc != ' ')
1927
1927
  int res;
1928
1928
  char *srcend= src + srclen;
1929
1929
  MY_UNICASE_INFO **uni_plane= cs->caseinfo;
1930
 
  DBUG_ASSERT(src == dst && srclen == dstlen);
 
1930
  assert(src == dst && srclen == dstlen);
1931
1931
  
1932
1932
  while ((src < srcend) &&
1933
1933
         (res= my_utf32_uni(cs, &wc, (uchar *)src, (uchar*) srcend)) > 0)
1983
1983
  int res;
1984
1984
  char *srcend= src + srclen;
1985
1985
  MY_UNICASE_INFO **uni_plane= cs->caseinfo;
1986
 
  DBUG_ASSERT(src == dst && srclen == dstlen);
 
1986
  assert(src == dst && srclen == dstlen);
1987
1987
 
1988
1988
  while ((res= my_utf32_uni(cs, &wc, (uchar*) src, (uchar*) srcend)) > 0)
1989
1989
  {
2071
2071
  const uchar *se= s + slen, *te= t + tlen;
2072
2072
  MY_UNICASE_INFO **uni_plane= cs->caseinfo;
2073
2073
 
2074
 
  DBUG_ASSERT((slen % 4) == 0);
2075
 
  DBUG_ASSERT((tlen % 4) == 0);
 
2074
  assert((slen % 4) == 0);
 
2075
  assert((tlen % 4) == 0);
2076
2076
 
2077
2077
#ifndef VARCHAR_WITH_DIFF_ENDSPACE_ARE_DIFFERENT_FOR_UNIQUE
2078
2078
  diff_if_only_endspace_difference= FALSE;
2123
2123
    {
2124
2124
      if ((s_res= my_utf32_uni(cs, &s_wc, s, se)) < 0)
2125
2125
      {
2126
 
        DBUG_ASSERT(0);
 
2126
        assert(0);
2127
2127
        return 0;
2128
2128
      }
2129
2129
      if (s_wc != ' ')
2145
2145
my_fill_utf32_for_strxfrm(CHARSET_INFO *cs __attribute__((unused)),
2146
2146
                          char *s, size_t slen, int fill)
2147
2147
{
2148
 
  DBUG_ASSERT(fill <= 0xFFFF);
 
2148
  assert(fill <= 0xFFFF);
2149
2149
  
2150
2150
  for ( ; slen > 1; slen-= 2)
2151
2151
  {
2227
2227
my_vsnprintf_utf32(char *dst, size_t n, const char* fmt, va_list ap)
2228
2228
{
2229
2229
  char *start= dst, *end= dst + n;
2230
 
  DBUG_ASSERT((n % 4) == 0);
 
2230
  assert((n % 4) == 0);
2231
2231
  for (; *fmt ; fmt++)
2232
2232
  {
2233
2233
    if (fmt[0] != '%')
2303
2303
    *dst++= '%';    /* % used as % or unknown code */
2304
2304
  }
2305
2305
  
2306
 
  DBUG_ASSERT(dst < end);
 
2306
  assert(dst < end);
2307
2307
  *dst++= '\0';
2308
2308
  *dst++= '\0';
2309
2309
  *dst++= '\0';
2517
2517
  /* Ensure string length is divisible by 4 */
2518
2518
  const char *b0= b;
2519
2519
  size_t length= e - b;
2520
 
  DBUG_ASSERT((length % 4) == 0);
 
2520
  assert((length % 4) == 0);
2521
2521
  *error= 0;
2522
2522
  nchars*= 4;
2523
2523
  if (length > nchars)
2545
2545
  uint buflen;
2546
2546
  char *e= s + slen;
2547
2547
  
2548
 
  DBUG_ASSERT((slen % 4) == 0);
 
2548
  assert((slen % 4) == 0);
2549
2549
 
2550
2550
  buflen= cs->cset->wc_mb(cs, (my_wc_t) fill, (uchar*) buf,
2551
2551
                          (uchar*) buf + sizeof(buf));
2552
 
  DBUG_ASSERT(buflen == 4);
 
2552
  assert(buflen == 4);
2553
2553
  while (s < e)
2554
2554
  {
2555
2555
    memcpy(s, buf, 4);
2563
2563
                  const char *ptr, size_t length)
2564
2564
{
2565
2565
  const char *end= ptr + length;
2566
 
  DBUG_ASSERT((length % 4) == 0);
 
2566
  assert((length % 4) == 0);
2567
2567
  while (end > ptr + 3 && end[-1] == ' ' && !end[-2] && !end[-3] && !end[-4])
2568
2568
    end-= 4;
2569
2569
  return (size_t) (end - ptr);
2646
2646
  const uchar *se, *te;
2647
2647
  size_t minlen;
2648
2648
 
2649
 
  DBUG_ASSERT((slen % 4) == 0);
2650
 
  DBUG_ASSERT((tlen % 4) == 0);
 
2649
  assert((slen % 4) == 0);
 
2650
  assert((tlen % 4) == 0);
2651
2651
 
2652
2652
  se= s + slen;
2653
2653
  te= t + tlen;
2717
2717
  char *max_end= max_str + res_length;
2718
2718
  size_t charlen= res_length / cs->mbmaxlen;
2719
2719
  
2720
 
  DBUG_ASSERT((res_length % 4) == 0);
 
2720
  assert((res_length % 4) == 0);
2721
2721
  
2722
2722
  for ( ; charlen > 0; ptr+= 4, charlen--)
2723
2723
  {
3043
3043
  int res;
3044
3044
  char *srcend= src + srclen;
3045
3045
  MY_UNICASE_INFO **uni_plane= cs->caseinfo;
3046
 
  DBUG_ASSERT(src == dst && srclen == dstlen);
 
3046
  assert(src == dst && srclen == dstlen);
3047
3047
  
3048
3048
  while ((src < srcend) &&
3049
3049
         (res= my_ucs2_uni(cs, &wc, (uchar *)src, (uchar*) srcend)) > 0)
3090
3090
  int res;
3091
3091
  char *srcend= src + srclen;
3092
3092
  MY_UNICASE_INFO **uni_plane= cs->caseinfo;
3093
 
  DBUG_ASSERT(src == dst && srclen == dstlen);
 
3093
  assert(src == dst && srclen == dstlen);
3094
3094
 
3095
3095
  while ((src < srcend) &&
3096
3096
         (res= my_ucs2_uni(cs, &wc, (uchar*) src, (uchar*) srcend)) > 0)