开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
sql_string.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：14k
源码类别：

MySQL数据库

开发平台：

Visual C++

sql_string.cpp：源码内容
  1. /* Copyright (C) 2000 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. /* This file is originally from the mysql distribution. Coded by monty */
  19. #ifdef USE_PRAGMA_IMPLEMENTATION
  20. #pragma implementation // gcc: Class implementation
  21. #endif
  23. #include <my_global.h>
  24. #include <my_sys.h>
  25. #include <m_string.h>
  26. #include <m_ctype.h>
  27. #ifdef HAVE_FCONVERT
  28. #include <floatingpoint.h>
  29. #endif
  31. extern gptr sql_alloc(unsigned size);
  32. extern void sql_element_free(void *ptr);
  34. #include "sql_string.h"
  36. /*****************************************************************************
  37. ** String functions
  38. *****************************************************************************/
  40. bool String::real_alloc(uint32 arg_length)
  41. {
  42.   arg_length=ALIGN_SIZE(arg_length+1);
  43.   str_length=0;
  44.   if (Alloced_length < arg_length)
  45.   {
  46.     free();
  47.     if (!(Ptr=(char*) my_malloc(arg_length,MYF(MY_WME))))
  48.       return TRUE;
  49.     Alloced_length=arg_length;
  50.     alloced=1;
  51.   }
  52.   Ptr[0]=0;
  53.   return FALSE;
  54. }
  57. /*
  58. ** Check that string is big enough. Set string[alloc_length] to 0
  59. ** (for C functions)
  60. */
  62. bool String::realloc(uint32 alloc_length)
  63. {
  64.   uint32 len=ALIGN_SIZE(alloc_length+1);
  65.   if (Alloced_length < len)
  66.   {
  67.     char *new_ptr;
  68.     if (alloced)
  69.     {
  70.       if ((new_ptr= (char*) my_realloc(Ptr,len,MYF(MY_WME))))
  71.       {
  72. Ptr=new_ptr;
  73. Alloced_length=len;
  74.       }
  75.       else
  76. return TRUE; // Signal error
  77.     }
  78.     else if ((new_ptr= (char*) my_malloc(len,MYF(MY_WME))))
  79.     {
  80.       if (str_length) // Avoid bugs in memcpy on AIX
  81. memcpy(new_ptr,Ptr,str_length);
  82.       new_ptr[str_length]=0;
  83.       Ptr=new_ptr;
  84.       Alloced_length=len;
  85.       alloced=1;
  86.     }
  87.     else
  88.       return TRUE; // Signal error
  89.   }
  90.   Ptr[alloc_length]=0; // This make other funcs shorter
  91.   return FALSE;
  92. }
  94. bool String::set(longlong num, CHARSET_INFO *cs)
  95. {
  96.   uint l=20*cs->mbmaxlen+1;
  98.   if (alloc(l))
  99.     return TRUE;
  100.   if (cs->cset->snprintf == my_snprintf_8bit)
  101.   {
  102.     str_length=(uint32) (longlong10_to_str(num,Ptr,-10)-Ptr);
  103.   }
  104.   else
  105.   {
  106.     str_length=cs->cset->snprintf(cs,Ptr,l,"%d",num);
  107.   }
  108.   str_charset=cs;
  109.   return FALSE;
  110. }
  112. bool String::set(ulonglong num, CHARSET_INFO *cs)
  113. {
  114.   uint l=20*cs->mbmaxlen+1;
  116.   if (alloc(l))
  117.     return TRUE;
  118.   if (cs->cset->snprintf == my_snprintf_8bit)
  119.   {
  120.     str_length=(uint32) (longlong10_to_str(num,Ptr,10)-Ptr);
  121.   }
  122.   else
  123.   {
  124.     str_length=cs->cset->snprintf(cs,Ptr,l,"%d",num);
  125.   }
  126.   str_charset=cs;
  127.   return FALSE;
  128. }
  130. bool String::set(double num,uint decimals, CHARSET_INFO *cs)
  131. {
  132.   char buff[331];
  134.   str_charset=cs;
  135.   if (decimals >= NOT_FIXED_DEC)
  136.   {
  137.     sprintf(buff,"%.14g",num); // Enough for a DATETIME
  138.     return copy(buff, (uint32) strlen(buff), &my_charset_latin1, cs);
  139.   }
  140. #ifdef HAVE_FCONVERT
  141.   int decpt,sign;
  142.   char *pos,*to;
  144.   VOID(fconvert(num,(int) decimals,&decpt,&sign,buff+1));
  145.   if (!my_isdigit(&my_charset_latin1, buff[1]))
  146.   { // Nan or Inf
  147.     pos=buff+1;
  148.     if (sign)
  149.     {
  150.       buff[0]='-';
  151.       pos=buff;
  152.     }
  153.     return copy(pos,(uint32) strlen(pos), &my_charset_latin1, cs);
  154.   }
  155.   if (alloc((uint32) ((uint32) decpt+3+decimals)))
  156.     return TRUE;
  157.   to=Ptr;
  158.   if (sign)
  159.     *to++='-';
  161.   pos=buff+1;
  162.   if (decpt < 0)
  163.   { /* value is < 0 */
  164.     *to++='0';
  165.     if (!decimals)
  166.       goto end;
  167.     *to++='.';
  168.     if ((uint32) -decpt > decimals)
  169.       decpt= - (int) decimals;
  170.     decimals=(uint32) ((int) decimals+decpt);
  171.     while (decpt++ < 0)
  172.       *to++='0';
  173.   }
  174.   else if (decpt == 0)
  175.   {
  176.     *to++= '0';
  177.     if (!decimals)
  178.       goto end;
  179.     *to++='.';
  180.   }
  181.   else
  182.   {
  183.     while (decpt-- > 0)
  184.       *to++= *pos++;
  185.     if (!decimals)
  186.       goto end;
  187.     *to++='.';
  188.   }
  189.   while (decimals--)
  190.     *to++= *pos++;
  192. end:
  193.   *to=0;
  194.   str_length=(uint32) (to-Ptr);
  195.   return FALSE;
  196. #else
  197. #ifdef HAVE_SNPRINTF
  198.   buff[sizeof(buff)-1]=0; // Safety
  199.   snprintf(buff,sizeof(buff)-1, "%.*f",(int) decimals,num);
  200. #else
  201.   sprintf(buff,"%.*f",(int) decimals,num);
  202. #endif
  203.   return copy(buff,(uint32) strlen(buff), &my_charset_latin1, cs);
  204. #endif
  205. }
  208. bool String::copy()
  209. {
  210.   if (!alloced)
  211.   {
  212.     Alloced_length=0; // Force realloc
  213.     return realloc(str_length);
  214.   }
  215.   return FALSE;
  216. }
  218. bool String::copy(const String &str)
  219. {
  220.   if (alloc(str.str_length))
  221.     return TRUE;
  222.   str_length=str.str_length;
  223.   bmove(Ptr,str.Ptr,str_length); // May be overlapping
  224.   Ptr[str_length]=0;
  225.   str_charset=str.str_charset;
  226.   return FALSE;
  227. }
  229. bool String::copy(const char *str,uint32 arg_length, CHARSET_INFO *cs)
  230. {
  231.   if (alloc(arg_length))
  232.     return TRUE;
  233.   if ((str_length=arg_length))
  234.     memcpy(Ptr,str,arg_length);
  235.   Ptr[arg_length]=0;
  236.   str_charset=cs;
  237.   return FALSE;
  238. }
  240. /* Copy with charset convertion */
  241. bool String::copy(const char *str,uint32 arg_length, CHARSET_INFO *from, CHARSET_INFO *to)
  242. {
  243.   uint32      new_length=to->mbmaxlen*arg_length;
  244.   int         cnvres;
  245.   my_wc_t     wc;
  246.   const uchar *s=(const uchar *)str;
  247.   const uchar *se=s+arg_length;
  248.   uchar       *d, *de;
  250.   if (alloc(new_length))
  251.     return TRUE;
  253.   d=(uchar *)Ptr;
  254.   de=d+new_length;
  255.   
  256.   for (str_length=new_length ; s < se && d < de ; )
  257.   {
  258.     if ((cnvres=from->cset->mb_wc(from,&wc,s,se)) > 0 )
  259.     {
  260.       s+=cnvres;
  261.     }
  262.     else if (cnvres==MY_CS_ILSEQ)
  263.     {
  264.       s++;
  265.       wc='?';
  266.     }
  267.     else
  268.       break;
  270. outp:
  271.     if((cnvres=to->cset->wc_mb(to,wc,d,de)) >0 )
  272.     {
  273.       d+=cnvres;
  274.     }
  275.     else if (cnvres==MY_CS_ILUNI && wc!='?')
  276.     {
  277.       wc='?';
  278.       goto outp;
  279.     }
  280.     else
  281.       break;
  282.   }
  283.   Ptr[new_length]=0;
  284.   length((uint32) (d-(uchar *)Ptr));
  285.   str_charset=to;
  286.   return FALSE;
  287. }
  289. /* This is used by mysql.cc */
  291. bool String::fill(uint32 max_length,char fill_char)
  292. {
  293.   if (str_length > max_length)
  294.     Ptr[str_length=max_length]=0;
  295.   else
  296.   {
  297.     if (realloc(max_length))
  298.       return TRUE;
  299.     bfill(Ptr+str_length,max_length-str_length,fill_char);
  300.     str_length=max_length;
  301.   }
  302.   return FALSE;
  303. }
  305. void String::strip_sp()
  306. {
  307.    while (str_length && my_isspace(str_charset,Ptr[str_length-1]))
  308.     str_length--;
  309. }
  311. bool String::append(const String &s)
  312. {
  313.   if (s.length())
  314.   {
  315.     if (realloc(str_length+s.length()))
  316.       return TRUE;
  317.     memcpy(Ptr+str_length,s.ptr(),s.length());
  318.     str_length+=s.length();
  319.   }
  320.   return FALSE;
  321. }
  323. bool String::append(const char *s,uint32 arg_length)
  324. {
  325.   if (!arg_length) // Default argument
  326.     if (!(arg_length= (uint32) strlen(s)))
  327.       return FALSE;
  328.   if (realloc(str_length+arg_length))
  329.     return TRUE;
  330.   memcpy(Ptr+str_length,s,arg_length);
  331.   str_length+=arg_length;
  332.   return FALSE;
  333. }
  335. #ifdef TO_BE_REMOVED
  336. bool String::append(FILE* file, uint32 arg_length, myf my_flags)
  337. {
  338.   if (realloc(str_length+arg_length))
  339.     return TRUE;
  340.   if (my_fread(file, (byte*) Ptr + str_length, arg_length, my_flags))
  341.   {
  342.     shrink(str_length);
  343.     return TRUE;
  344.   }
  345.   str_length+=arg_length;
  346.   return FALSE;
  347. }
  348. #endif
  350. bool String::append(IO_CACHE* file, uint32 arg_length)
  351. {
  352.   if (realloc(str_length+arg_length))
  353.     return TRUE;
  354.   if (my_b_read(file, (byte*) Ptr + str_length, arg_length))
  355.   {
  356.     shrink(str_length);
  357.     return TRUE;
  358.   }
  359.   str_length+=arg_length;
  360.   return FALSE;
  361. }
  363. uint32 String::numchars()
  364. {
  365. #ifdef USE_MB
  366.   register uint32 n=0,mblen;
  367.   register const char *mbstr=Ptr;
  368.   register const char *end=mbstr+str_length;
  369.   if (use_mb(str_charset))
  370.   {
  371.     while (mbstr < end) {
  372.         if ((mblen=my_ismbchar(str_charset, mbstr,end))) mbstr+=mblen;
  373.         else ++mbstr;
  374.         ++n;
  375.     }
  376.     return n;
  377.   }
  378.   else
  379. #endif
  380.     return str_length;
  381. }
  383. int String::charpos(int i,uint32 offset)
  384. {
  385. #ifdef USE_MB
  386.   register uint32 mblen;
  387.   register const char *mbstr=Ptr+offset;
  388.   register const char *end=Ptr+str_length;
  389.   if (use_mb(str_charset))
  390.   {
  391.     if (i<=0) return i;
  392.     while (i && mbstr < end) {
  393.        if ((mblen=my_ismbchar(str_charset, mbstr,end))) mbstr+=mblen;
  394.        else ++mbstr;
  395.        --i;
  396.     }
  397.     if ( INT_MAX32-i <= (int) (mbstr-Ptr-offset)) 
  398.       return INT_MAX32;
  399.     else 
  400.       return (int) ((mbstr-Ptr-offset)+i);
  401.   }
  402.   else
  403. #endif
  404.     return i;
  405. }
  407. int String::strstr(const String &s,uint32 offset)
  408. {
  409.   if (s.length()+offset <= str_length)
  410.   {
  411.     if (!s.length())
  412.       return ((int) offset); // Empty string is always found
  414.     register const char *str = Ptr+offset;
  415.     register const char *search=s.ptr();
  416.     const char *end=Ptr+str_length-s.length()+1;
  417.     const char *search_end=s.ptr()+s.length();
  418. skip:
  419.     while (str != end)
  420.     {
  421.       if (*str++ == *search)
  422.       {
  423. register char *i,*j;
  424. i=(char*) str; j=(char*) search+1;
  425. while (j != search_end)
  426.   if (*i++ != *j++) goto skip;
  427. return (int) (str-Ptr) -1;
  428.       }
  429.     }
  430.   }
  431.   return -1;
  432. }
  434. /*
  435.   Search after a string without regarding to case
  436.   This needs to be replaced when we have character sets per string
  437. */
  439. int String::strstr_case(const String &s,uint32 offset)
  440. {
  441.   if (s.length()+offset <= str_length)
  442.   {
  443.     if (!s.length())
  444.       return ((int) offset); // Empty string is always found
  446.     register const char *str = Ptr+offset;
  447.     register const char *search=s.ptr();
  448.     const char *end=Ptr+str_length-s.length()+1;
  449.     const char *search_end=s.ptr()+s.length();
  450. skip:
  451.     while (str != end)
  452.     {
  453.       if (str_charset->sort_order[*str++] == str_charset->sort_order[*search])
  454.       {
  455. register char *i,*j;
  456. i=(char*) str; j=(char*) search+1;
  457. while (j != search_end)
  458.   if (str_charset->sort_order[*i++] != 
  459.               str_charset->sort_order[*j++]) 
  460.             goto skip;
  461. return (int) (str-Ptr) -1;
  462.       }
  463.     }
  464.   }
  465.   return -1;
  466. }
  468. /*
  469. ** Search string from end. Offset is offset to the end of string
  470. */
  472. int String::strrstr(const String &s,uint32 offset)
  473. {
  474.   if (s.length() <= offset && offset <= str_length)
  475.   {
  476.     if (!s.length())
  477.       return offset; // Empty string is always found
  478.     register const char *str = Ptr+offset-1;
  479.     register const char *search=s.ptr()+s.length()-1;
  481.     const char *end=Ptr+s.length()-2;
  482.     const char *search_end=s.ptr()-1;
  483. skip:
  484.     while (str != end)
  485.     {
  486.       if (*str-- == *search)
  487.       {
  488. register char *i,*j;
  489. i=(char*) str; j=(char*) search-1;
  490. while (j != search_end)
  491.   if (*i-- != *j--) goto skip;
  492. return (int) (i-Ptr) +1;
  493.       }
  494.     }
  495.   }
  496.   return -1;
  497. }
  499. /*
  500. ** replace substring with string
  501. ** If wrong parameter or not enough memory, do nothing
  502. */
  505. bool String::replace(uint32 offset,uint32 arg_length,const String &to)
  506. {
  507.   long diff = (long) to.length()-(long) arg_length;
  508.   if (offset+arg_length <= str_length)
  509.   {
  510.     if (diff < 0)
  511.     {
  512.       if (to.length())
  513. memcpy(Ptr+offset,to.ptr(),to.length());
  514.       bmove(Ptr+offset+to.length(),Ptr+offset+arg_length,
  515.     str_length-offset-arg_length);
  516.     }
  517.     else
  518.     {
  519.       if (diff)
  520.       {
  521. if (realloc(str_length+(uint32) diff))
  522.   return TRUE;
  523. bmove_upp(Ptr+str_length+diff,Ptr+str_length,
  524.   str_length-offset-arg_length);
  525.       }
  526.       if (to.length())
  527. memcpy(Ptr+offset,to.ptr(),to.length());
  528.     }
  529.     str_length+=(uint32) diff;
  530.   }
  531.   return FALSE;
  532. }
  534. // added by Holyfoot for "geometry" needs
  535. int String::reserve(uint32 space_needed, uint32 grow_by)
  536. {
  537.   if (Alloced_length < str_length + space_needed)
  538.   {
  539.     if (realloc(Alloced_length + max(space_needed, grow_by) - 1))
  540.       return TRUE;
  541.   }
  542.   return FALSE;
  543. }
  545. void String::qs_append(const char *str)
  546. {
  547.   int len = (int)strlen(str);
  548.   memcpy(Ptr + str_length, str, len + 1);
  549.   str_length += len;
  550. }
  552. void String::qs_append(double d)
  553. {
  554.   char *buff = Ptr + str_length;
  555.   sprintf(buff,"%.14g", d);
  556.   str_length += (int)strlen(buff);
  557. }
  559. void String::qs_append(double *d)
  560. {
  561.   double ld;
  562.   float8get(ld, (char*) d);
  563.   qs_append(ld);
  564. }
  566. void String::qs_append(const char &c)
  567. {
  568.   Ptr[str_length] = c;
  569.   str_length += sizeof(c);
  570. }
  573. int sortcmp(const String *x,const String *y)
  574. {
  575.   const char *s= x->ptr();
  576.   const char *t= y->ptr();
  577.   uint32 x_len=x->length(),y_len=y->length(),len=min(x_len,y_len);
  579.   if (use_strnxfrm(x->str_charset))
  580.   {
  581. #ifndef CMP_ENDSPACE
  582.     while (x_len && my_isspace(x->str_charset,s[x_len-1]))
  583.       x_len--;
  584.     while (y_len && my_isspace(x->str_charset,t[y_len-1]))
  585.       y_len--;
  586. #endif
  587.     return my_strnncoll(x->str_charset,
  588.                         (unsigned char *)s,x_len,(unsigned char *)t,y_len);
  589.   }
  590.   else
  591.   {
  592.     x_len-=len; // For easy end space test
  593.     y_len-=len;
  594.     if (x->str_charset->sort_order)
  595.     {
  596.       while (len--)
  597.       {
  598.         if (x->str_charset->sort_order[(uchar) *s++] != 
  599.           x->str_charset->sort_order[(uchar) *t++])
  600.             return ((int) x->str_charset->sort_order[(uchar) s[-1]] -
  601.                   (int) x->str_charset->sort_order[(uchar) t[-1]]);
  602.       }
  603.     }
  604.     else
  605.     {
  606.       while (len--)
  607.       {
  608.         if (*s++ != *t++)
  609.             return ((int) s[-1] - (int) t[-1]);
  610.       }
  611.     }
  612. #ifndef CMP_ENDSPACE
  613.     /* Don't compare end space in strings */
  614.     {
  615.       if (y_len)
  616.       {
  617.         const char *end=t+y_len;
  618.         for (; t != end ; t++)
  619.           if (!my_isspace(x->str_charset,*t))
  620.             return -1;
  621.       }
  622.       else
  623.       {
  624.         const char *end=s+x_len;
  625.         for (; s != end ; s++)
  626.           if (!my_isspace(x->str_charset,*s))
  627.             return 1;
  628.       }
  629.       return 0;
  630.     }
  631. #else
  632.     return (int) (x_len-y_len);
  633. #endif /* CMP_ENDSPACE */
  634.   }
  635. }
  638. int stringcmp(const String *x,const String *y)
  639. {
  640.   const char *s= x->ptr();
  641.   const char *t= y->ptr();
  642.   uint32 x_len=x->length(),y_len=y->length(),len=min(x_len,y_len);
  644.   while (len--)
  645.   {
  646.     if (*s++ != *t++)
  647.       return ((int) (uchar) s[-1] - (int) (uchar) t[-1]);
  648.   }
  649.   return (int) (x_len-y_len);
  650. }
  653. String *copy_if_not_alloced(String *to,String *from,uint32 from_length)
  654. {
  655.   if (from->Alloced_length >= from_length)
  656.     return from;
  657.   if (from->alloced || !to || from == to)
  658.   {
  659.     (void) from->realloc(from_length);
  660.     return from;
  661.   }
  662.   if (to->realloc(from_length))
  663.     return from; // Actually an error
  664.   if ((to->str_length=min(from->str_length,from_length)))
  665.     memcpy(to->Ptr,from->Ptr,to->str_length);
  666.   to->str_charset=from->str_charset;
  667.   return to;
  668. }