Enchanced my_once..() functions.

Cleaned up charset.c
Removed non fatal memory leak in charset.c


include/my_sys.h:
  Enchanced my_once..() functions.
mysys/charset.c:
  Moved my_once_strdup() to my_once.cc
  Added usage of my_once_memdup()
  A lot of indentation changes.
mysys/my_once.c:
  Enchanced my_once..() functions.

include/my_sys.h

@@ -505,6 +505,8 @@ extern int my_setwd(const char *dir,myf MyFlags);
 extern int my_lock(File fd,int op,my_off_t start, my_off_t length,myf MyFlags);
 extern gptr my_once_alloc(uint Size,myf MyFlags);
 extern void my_once_free(void);
+extern char *my_once_strdup(const char *src,myf myflags);
+extern char *my_once_memdup(const char *src, uint len, myf myflags);
 extern my_string my_tempnam(const char *dir,const char *pfx,myf MyFlags);
 extern File my_open(const char *FileName,int Flags,myf MyFlags);
 extern File my_register_filename(File fd, const char *FileName,

mysys/charset.c

@@ -39,6 +39,7 @@ static int charset_initialized=0;
 #define SORT_ORDER_TABLE_SIZE 256
 #define TO_UNI_TABLE_SIZE     256
 
+
 char *get_charsets_dir(char *buf)
 {
   const char *sharedir= SHAREDIR;
@@ -56,7 +57,7 @@ char *get_charsets_dir(char *buf)
 	      NullS);
   }
   convert_dirname(buf,buf,NullS);
-  DBUG_PRINT("info",("charsets dir='%s'", buf));
+  DBUG_PRINT("info",("charsets dir: '%s'", buf));
   DBUG_RETURN(strend(buf));
 }
 
@@ -127,8 +128,10 @@ static struct my_cs_file_section_st * cs_file_sec(const char *attr, uint len)
 {
   struct my_cs_file_section_st *s;
   for (s=sec; s->str; s++)
+  {
     if (!strncmp(attr,s->str,len))
       return s;
+  }
   return NULL;
 }
 
@@ -172,15 +175,6 @@ static void simple_cs_init_functions(CHARSET_INFO *cs)
   cs->mbmaxlen    = 1;
 }
 
-/* FIXME: BAR: move to more proper place, my_alloc.c I suppose */
-static char *my_once_strdup(const char *src,myf myflags)
-{
-  uint len=strlen(src);
-  char *dst=my_once_alloc(len+1,myflags);
-  if (dst)
-    memcpy(dst,src,len+1);
-  return dst;
-}
 
 static void simple_cs_copy_data(CHARSET_INFO *to, CHARSET_INFO *from)
 {
@@ -194,43 +188,39 @@ static void simple_cs_copy_data(CHARSET_INFO *to, CHARSET_INFO *from)
     to->name= my_once_strdup(from->name,MYF(MY_WME));
   
   if (from->ctype)
-  {
+    to->ctype= (uchar*) my_once_memdup((char*) from->ctype,
-    to->ctype    = (uchar*) my_once_alloc(CTYPE_TABLE_SIZE,MYF(MY_WME));
+				       CTYPE_TABLE_SIZE, MYF(MY_WME));
-    memcpy((char*)to->ctype,(char*)from->ctype,CTYPE_TABLE_SIZE);
-  }
   if (from->to_lower)
-  {
+    to->to_lower= (uchar*) my_once_memdup((char*) from->to_lower,
-    to->to_lower = (uchar*) my_once_alloc(TO_LOWER_TABLE_SIZE,MYF(MY_WME));
+					  TO_LOWER_TABLE_SIZE, MYF(MY_WME));
-    memcpy((char*)to->to_lower,(char*)from->to_lower,TO_LOWER_TABLE_SIZE);
-  }
   if (from->to_upper)
-  {
+    to->to_upper= (uchar*) my_once_memdup((char*) from->to_upper,
-    to->to_upper = (uchar*) my_once_alloc(TO_UPPER_TABLE_SIZE,MYF(MY_WME));
+					  TO_UPPER_TABLE_SIZE, MYF(MY_WME));
-    memcpy((char*)to->to_upper,(char*)from->to_upper,TO_UPPER_TABLE_SIZE);
-  }
   if (from->sort_order)
   {
-    to->sort_order=(uchar*) my_once_alloc(SORT_ORDER_TABLE_SIZE,MYF(MY_WME));
+    to->sort_order= (uchar*) my_once_memdup((char*) from->sort_order,
-    memcpy((char*)to->sort_order,(char*)from->sort_order, SORT_ORDER_TABLE_SIZE);
+					    SORT_ORDER_TABLE_SIZE,
+					    MYF(MY_WME));
     set_max_sort_char(to);
   }
   if (from->tab_to_uni)
   {
     uint sz=TO_UNI_TABLE_SIZE*sizeof(uint16);
-    to->tab_to_uni=(uint16*)my_once_alloc(sz,MYF(MY_WME));
+    to->tab_to_uni= (uint16*)  my_once_memdup((char*)from->tab_to_uni, sz,
-    memcpy((char*)to->tab_to_uni,(char*)from->tab_to_uni,sz);
+					     MYF(MY_WME));
     create_fromuni(to);
   }
 }
 
+
 static my_bool simple_cs_is_full(CHARSET_INFO *cs)
 {
-  return 
+  return ((cs->csname && cs->tab_to_uni && cs->ctype && cs->to_upper &&
-    (cs->csname && cs->tab_to_uni && cs->ctype && cs->to_upper && cs->to_lower)
+	   cs->to_lower) &&
-    &&
+	  (cs->number && cs->name && cs->sort_order));
-    (cs->number && cs->name && cs->sort_order);
 }
 
+
 static int fill_uchar(uchar *a,uint size,const char *str, uint len)
 {
   uint i= 0;
@@ -241,9 +231,7 @@ static int fill_uchar(uchar *a,uint size,const char *str, uint len)
     for ( ; (s < e) && strchr(" \t\r\n",s[0]); s++) ;
     b=s;
     for ( ; (s < e) && !strchr(" \t\r\n",s[0]); s++) ;
-    if (s==b)
+    if (s == b || i > size)
-      break;
-    if (i>size)
       break;
     a[i]= my_strntoul(my_charset_latin1,b,s-b,NULL,16);
   }
@@ -259,15 +247,14 @@ static int fill_uint16(uint16 *a,uint size,const char *str, uint len)
     for ( ; (s < e) && strchr(" \t\r\n",s[0]); s++) ;
     b=s;
     for ( ; (s < e) && !strchr(" \t\r\n",s[0]); s++) ;
-    if (s==b)
+    if (s == b || i > size)
-      break;
-    if (i>size)
       break;
     a[i]= my_strntol(my_charset_latin1,b,s-b,NULL,16);
   }
   return 0;
 }
 
+
 static int cs_enter(MY_XML_PARSER *st,const char *attr, uint len)
 {
   struct my_cs_file_info *i= (struct my_cs_file_info *)st->user_data;
@@ -280,6 +267,7 @@ static int cs_enter(MY_XML_PARSER *st,const char *attr, uint len)
   return MY_XML_OK;
 }
 
+
 static int cs_leave(MY_XML_PARSER *st,const char *attr, uint len)
 {
   struct my_cs_file_info *i= (struct my_cs_file_info *)st->user_data;
@@ -288,15 +276,14 @@ static int cs_leave(MY_XML_PARSER *st,const char *attr, uint len)
   
   if (state == _CS_COLLATION)
   {
-    if (i->cs.name && (i->cs.number || (i->cs.number=get_charset_number(i->cs.name))))
+    if (i->cs.name && (i->cs.number ||
+		       (i->cs.number=get_charset_number(i->cs.name))))
     {
       if (!all_charsets[i->cs.number])
       {
         if (!(all_charsets[i->cs.number]=
            (CHARSET_INFO*) my_once_alloc(sizeof(CHARSET_INFO),i->myflags)))
-        {
           return MY_XML_ERROR;
-        }
         bzero((void*)all_charsets[i->cs.number],sizeof(CHARSET_INFO));
       }
       
@@ -316,10 +303,10 @@ static int cs_leave(MY_XML_PARSER *st,const char *attr, uint len)
       i->cs.state= 0;
     }
   }
-  
   return MY_XML_OK;
 }
 
+
 static int cs_value(MY_XML_PARSER *st,const char *attr, uint len)
 {
   struct my_cs_file_info *i= (struct my_cs_file_info *)st->user_data;
@@ -334,8 +321,7 @@ static int cs_value(MY_XML_PARSER *st,const char *attr, uint len)
   }
 #endif
   
-  switch (state)
+  switch (state) {
-  {
   case _CS_ID:
     i->cs.number= my_strntoul(my_charset_latin1,attr,len,(char**)NULL,0);
     break;
@@ -377,6 +363,7 @@ static int cs_value(MY_XML_PARSER *st,const char *attr, uint len)
   return MY_XML_OK;
 }
 
+
 static my_bool read_charset_index(const char *filename, myf myflags)
 {
   char *buf;
@@ -405,18 +392,18 @@ static my_bool read_charset_index(const char *filename, myf myflags)
   my_xml_set_leave_handler(&p,cs_leave);
   my_xml_set_user_data(&p,(void*)&i);
   
-  if (MY_XML_OK!=my_xml_parse(&p,buf,len))
+  if (my_xml_parse(&p,buf,len) != MY_XML_OK)
   {
-  /*
+#ifdef NOT_YET
     printf("ERROR at line %d pos %d '%s'\n",
 	   my_xml_error_lineno(&p)+1,
 	   my_xml_error_pos(&p),
 	   my_xml_error_string(&p));
-  */
+#endif
   }
 
   my_xml_parser_free(&p);
-  
+  my_free(buf, myflags);  
   return FALSE;
 }
 
@@ -477,12 +464,15 @@ void free_charsets(void)
   charset_initialized=0;
 }
 
+
 static void get_charset_conf_name(const char *cs_name, char *buf)
 {
   strxmov(get_charsets_dir(buf), cs_name, ".conf", NullS);
 }
 
-typedef struct {
+
+typedef struct
+{
   int		nchars;
   MY_UNI_IDX	uidx;
 } uni_idx;
@@ -502,7 +492,9 @@ static int pcmp(const void * f, const void * s)
   return res;
 }
 
-static my_bool create_fromuni(CHARSET_INFO *cs){
+
+static my_bool create_fromuni(CHARSET_INFO *cs)
+{
   uni_idx	idx[PLANE_NUM];
   int		i,n;
   
@@ -542,7 +534,9 @@ static my_bool create_fromuni(CHARSET_INFO *cs){
       break;
     
     numchars=idx[i].uidx.to-idx[i].uidx.from+1;
-    idx[i].uidx.tab=(unsigned char*)my_once_alloc(numchars*sizeof(*idx[i].uidx.tab),MYF(MY_WME));
+    idx[i].uidx.tab=(unsigned char*)my_once_alloc(numchars *
+						  sizeof(*idx[i].uidx.tab),
+						  MYF(MY_WME));
     bzero(idx[i].uidx.tab,numchars*sizeof(*idx[i].uidx.tab));
     
     for (ch=1; ch < PLANE_SIZE; ch++)
@@ -558,7 +552,8 @@ static my_bool create_fromuni(CHARSET_INFO *cs){
   
   /* Allocate and fill reverse table for each plane */
   n=i;
-  cs->tab_from_uni=(MY_UNI_IDX*)my_once_alloc(sizeof(MY_UNI_IDX)*(n+1),MYF(MY_WME));
+  cs->tab_from_uni= (MY_UNI_IDX*) my_once_alloc(sizeof(MY_UNI_IDX)*(n+1),
+					       MYF(MY_WME));
   for (i=0; i< n; i++)
     cs->tab_from_uni[i]= idx[i].uidx;
   
@@ -575,9 +570,10 @@ uint get_charset_number(const char *charset_name)
     return 0;
   
   for (cs= all_charsets; cs < all_charsets+255; ++cs)
+  {
     if ( cs[0] && cs[0]->name && !strcmp(cs[0]->name, charset_name))
       return cs[0]->number;
-  
+  }  
   return 0;   /* this mimics find_type() */
 }
 
@@ -653,6 +649,7 @@ my_bool set_default_charset(uint cs, myf flags)
   CHARSET_INFO *new_charset;
   DBUG_ENTER("set_default_charset");
   DBUG_PRINT("enter",("character set: %d",(int) cs));
+
   new_charset= get_charset(cs, flags);
   if (!new_charset)
   {
@@ -661,6 +658,7 @@ my_bool set_default_charset(uint cs, myf flags)
   }
   default_charset_info= new_charset;
   system_charset_info= new_charset;
+
   DBUG_RETURN(FALSE);
 }
 
@@ -680,11 +678,13 @@ CHARSET_INFO *get_charset_by_name(const char *cs_name, myf flags)
   return cs;
 }
 
+
 my_bool set_default_charset_by_name(const char *cs_name, myf flags)
 {
   CHARSET_INFO *new_charset;
   DBUG_ENTER("set_default_charset_by_name");
   DBUG_PRINT("enter",("character set: %s", cs_name));
+
   new_charset= get_charset_by_name(cs_name, flags);
   if (!new_charset)
   {
@@ -697,6 +697,7 @@ my_bool set_default_charset_by_name(const char *cs_name, myf flags)
   DBUG_RETURN(FALSE);
 }
 
+
 /* Only append name if it doesn't exist from before */
 
 static my_bool charset_in_string(const char *name, DYNAMIC_STRING *s)
@@ -708,13 +709,14 @@ static my_bool charset_in_string(const char *name, DYNAMIC_STRING *s)
     if (! pos[length] || pos[length] == ' ')
       return TRUE;				/* Already existed */
   }
-
   return FALSE;
 }
 
+
 static void charset_append(DYNAMIC_STRING *s, const char *name)
 {
-  if (!charset_in_string(name, s)) {
+  if (!charset_in_string(name, s))
+  {
     dynstr_append(s, name);
     dynstr_append(s, " ");
   }

mysys/my_once.c

@@ -78,6 +78,25 @@ gptr my_once_alloc(unsigned int Size, myf MyFlags)
 } /* my_once_alloc */
 
 
+char *my_once_strdup(const char *src,myf myflags)
+{
+  uint len=strlen(src)+1;
+  char *dst=my_once_alloc(len, myflags);
+  if (dst)
+    memcpy(dst, src, len);
+  return dst;
+}
+
+
+char *my_once_memdup(const char *src, uint len, myf myflags)
+{
+  char *dst=my_once_alloc(len, myflags);
+  if (dst)
+    memcpy(dst, src, len);
+  return dst;
+}
+
+
 /*
   Deallocate everything used by my_once_alloc