Indentation cleanup & new comments

libmysql/Makefile.shared

@@ -62,9 +62,9 @@ mysysobjects1 =		my_init.lo my_static.lo my_malloc.lo my_realloc.lo \
 			my_getopt.lo my_gethostbyname.lo
 
 # Not needed in the minimum library
-mysysobjects2 =		getvar.lo my_lib.lo
+mysysobjects2 =		my_lib.lo
 mysysobjects =		$(mysysobjects1) $(mysysobjects2)
-target_libadd = $(mysysobjects) $(mystringsobjects) $(dbugobjects) \
+target_libadd =		$(mysysobjects) $(mystringsobjects) $(dbugobjects) \
  $(vio_objects)
 target_ldflags = -version-info @SHARED_LIB_VERSION@
 vio_objects= vio.lo viosocket.lo viossl.lo viosslfactories.lo

myisam/mi_cache.c

@@ -72,8 +72,8 @@ int _mi_read_cache(IO_CACHE *info, byte *buff, my_off_t pos, uint length,
     in_buff_length=0;
   if (flag & READING_NEXT || info->share)
   {
-    if (pos !=
-        (info->pos_in_file + (uint) (info->read_end - info->request_pos)))
+    if (pos != (info->pos_in_file + (uint) (info->read_end -
+					    info->request_pos)))
     {
       info->pos_in_file=pos;				/* Force start here */
       info->read_pos=info->read_end=info->request_pos;	/* Everything used */

myisam/mi_check.c

@@ -1203,10 +1203,11 @@ int mi_repair(MI_CHECK *param, register MI_INFO *info,
   for (i=0 ; i < share->state.header.max_block_size ; i++)
     share->state.key_del[i]=  HA_OFFSET_ERROR;
 
-  /* I think mi_repair and mi_repair_by_sort should do the same
-     (according, e.g. to ha_myisam::repair), but as mi_repair doesn't
-     touch key_map it cannot be used to T_CREATE_MISSING_KEYS.
-     That is what the next line is for... (serg)
+  /*
+    I think mi_repair and mi_repair_by_sort should do the same
+    (according, e.g. to ha_myisam::repair), but as mi_repair doesn't
+    touch key_map it cannot be used to T_CREATE_MISSING_KEYS.
+    That is what the next line is for... (serg)
   */
 
   share->state.key_map= ((((ulonglong) 1L << share->base.keys)-1) &
@@ -1737,8 +1738,22 @@ err:
 		       type,my_errno);
   DBUG_RETURN(1);
 }
-	/* Fix table or given index using sorting */
-	/* saves new table in temp_filename */
+
+
+/*
+  Repair table or given index using sorting
+
+  SYNOPSIS
+    mi_repair_by_sort()
+    param		Repair parameters
+    info		MyISAM handler to repair
+    name		Name of table (for warnings)
+    rep_quick		set to <> 0 if we should not change data file
+
+  RESULT
+    0	ok
+    <>0	Error
+*/
 
 int mi_repair_by_sort(MI_CHECK *param, register MI_INFO *info,
 		      const char * name, int rep_quick)
@@ -1956,8 +1971,8 @@ int mi_repair_by_sort(MI_CHECK *param, register MI_INFO *info,
 	  goto err;
 	}
       }
-      share->state.state.data_file_length = info->state->data_file_length
-	= sort_param.filepos;
+      share->state.state.data_file_length = info->state->data_file_length=
+	sort_param.filepos;
       /* Only whole records */
       share->state.version=(ulong) time((time_t*) 0);
       my_close(info->dfile,MYF(0));
@@ -2079,19 +2094,35 @@ err:
   DBUG_RETURN(got_error);
 }
 
-	/* same as mi_repair_by_sort */
-        /* but do it multithreaded   */
+/*
+  Threaded repair of table using sorting
+
+  SYNOPSIS
+    mi_repair_by_sort_r()
+    param		Repair parameters
+    info		MyISAM handler to repair
+    name		Name of table (for warnings)
+    rep_quick		set to <> 0 if we should not change data file
+
+  DESCRIPTION
+    Same as mi_repair_by_sort but do it multithreaded
+    Each key is handled by a separate thread.
+
+  RESULT
+    0	ok
+    <>0	Error
+*/
 
 int mi_repair_by_sort_r(MI_CHECK *param, register MI_INFO *info,
-		      const char * name, int rep_quick)
+			const char * name, int rep_quick)
 {
   int got_error;
-  uint i,key;
-  ulong length;
+  uint i,key, total_key_length;
+  ulong rec_length;
   ha_rows start_records;
   my_off_t new_header_length,del;
   File new_file;
-  MI_SORT_PARAM *sort_param=0, *sinfo;
+  MI_SORT_PARAM *sort_param=0;
   MYISAM_SHARE *share=info->s;
   ulong   *rec_per_key_part;
   MI_KEYSEG *keyseg;
@@ -2193,14 +2224,14 @@ int mi_repair_by_sort_r(MI_CHECK *param, register MI_INFO *info,
     my_seek(param->read_cache.file,0L,MY_SEEK_END,MYF(0));
 
   if (share->data_file_type == DYNAMIC_RECORD)
-    length=max(share->base.min_pack_length+1,share->base.min_block_length);
+    rec_length=max(share->base.min_pack_length+1,share->base.min_block_length);
   else if (share->data_file_type == COMPRESSED_RECORD)
-    length=share->base.min_block_length;
+    rec_length=share->base.min_block_length;
   else
-    length=share->base.pack_reclength;
+    rec_length=share->base.pack_reclength;
   sort_info.max_records=
     ((param->testflag & T_CREATE_MISSING_KEYS) ? info->state->records :
-     (ha_rows) (sort_info.filelength/length+1));
+     (ha_rows) (sort_info.filelength/rec_length+1));
 
   del=info->state->del;
   param->glob_crc=0;
@@ -2209,13 +2240,13 @@ int mi_repair_by_sort_r(MI_CHECK *param, register MI_INFO *info,
 
   if (!(sort_param=(MI_SORT_PARAM *)
         my_malloc((uint) share->base.keys *
-          (sizeof(MI_SORT_PARAM) + share->base.pack_reclength),
-                                                   MYF(MY_ZEROFILL))))
+		  (sizeof(MI_SORT_PARAM) + share->base.pack_reclength),
+		  MYF(MY_ZEROFILL))))
   {
     mi_check_print_error(param,"Not enough memory!");
     goto err;
   }
-  length=0;
+  total_key_length=0;
   rec_per_key_part= param->rec_per_key_part;
   info->state->records=info->state->del=share->state.split=0;
   info->state->empty=0;
@@ -2235,10 +2266,8 @@ int mi_repair_by_sort_r(MI_CHECK *param, register MI_INFO *info,
       i--;
       continue;
     }
-    if ((!(param->testflag & T_SILENT)))
-      printf ("- Fixing index %d\n",key+1);
-    sort_param[i].key_read=(sort_param[i].keyinfo->flag & HA_FULLTEXT) ?
-                                       sort_ft_key_read : sort_key_read;
+    sort_param[i].key_read= ((sort_param[i].keyinfo->flag & HA_FULLTEXT) ?
+			     sort_ft_key_read : sort_key_read);
     sort_param[i].key_cmp=sort_key_cmp;
     sort_param[i].key_write=sort_key_write;
     sort_param[i].lock_in_memory=lock_memory;
@@ -2249,12 +2278,12 @@ int mi_repair_by_sort_r(MI_CHECK *param, register MI_INFO *info,
     sort_param[i].filepos=new_header_length;
     sort_param[i].max_pos=sort_param[i].pos=share->pack.header_length;
 
-    sort_param[i].record=((char *)(sort_param+share->base.keys))+
-                                  (share->base.pack_reclength * i);
+    sort_param[i].record= (((char *)(sort_param+share->base.keys))+
+			   (share->base.pack_reclength * i));
 
     sort_param[i].key_length=share->rec_reflength;
     for (keyseg=sort_param[i].keyinfo->seg; keyseg->type != HA_KEYTYPE_END;
-                                                                    keyseg++)
+	 keyseg++)
     {
       sort_param[i].key_length+=keyseg->length;
       if (keyseg->flag & HA_SPACE_PACK)
@@ -2264,8 +2293,7 @@ int mi_repair_by_sort_r(MI_CHECK *param, register MI_INFO *info,
       if (keyseg->flag & HA_NULL_PART)
         sort_param[i].key_length++;
     }
-
-    length+=sort_param[i].key_length;
+    total_key_length+=sort_param[i].key_length;
 
     if (sort_param[i].keyinfo->flag & HA_FULLTEXT)
       sort_param[i].key_length+=ft_max_word_len_for_sort-ft_max_word_len;
@@ -2274,12 +2302,12 @@ int mi_repair_by_sort_r(MI_CHECK *param, register MI_INFO *info,
   sort_param[0].fix_datafile= ! rep_quick;
 
   sort_info.got_error=0;
-  pthread_mutex_init(& sort_info.mutex, MY_MUTEX_INIT_FAST);
-  pthread_cond_init(& sort_info.cond, 0);
-  pthread_mutex_lock(& sort_info.mutex);
+  pthread_mutex_init(&sort_info.mutex, MY_MUTEX_INIT_FAST);
+  pthread_cond_init(&sort_info.cond, 0);
+  pthread_mutex_lock(&sort_info.mutex);
 
-  init_io_cache_share(& param->read_cache, &io_share, i);
-  for (i=0 ; i<sort_info.total_keys ; i++)
+  init_io_cache_share(&param->read_cache, &io_share, i);
+  for (i=0 ; i < sort_info.total_keys ; i++)
   {
     sort_param[i].read_cache=param->read_cache;
     sort_param[i].sortbuff_size=
@@ -2292,13 +2320,13 @@ int mi_repair_by_sort_r(MI_CHECK *param, register MI_INFO *info,
 #if 1
       param->sort_buffer_length/sort_info.total_keys;
 #else
-      param->sort_buffer_length*sort_param[i].key_length/length;
+    param->sort_buffer_length*sort_param[i].key_length/total_key_length;
 #endif
     if (pthread_create(& sort_param[i].thr, 0,
-                  (void *(*)(void*))_thr_find_all_keys, sort_param+i))
+		       (void *(*)(void*))_thr_find_all_keys, sort_param+i))
     {
       mi_check_print_error(param,"Cannot start a repair thread");
-      remove_io_thread(& param->read_cache);
+      remove_io_thread(&param->read_cache);
       sort_info.got_error=1;
     }
     else
@@ -2307,17 +2335,17 @@ int mi_repair_by_sort_r(MI_CHECK *param, register MI_INFO *info,
 
   /* waiting for all threads to finish */
   while (sort_info.threads_running)
-    pthread_cond_wait(& sort_info.cond, &sort_info.mutex);
-  pthread_mutex_unlock(& sort_info.mutex);
+    pthread_cond_wait(&sort_info.cond, &sort_info.mutex);
+  pthread_mutex_unlock(&sort_info.mutex);
 
-  if (got_error=_thr_write_keys(sort_param))
+  if ((got_error= _thr_write_keys(sort_param)))
   {
     param->retry_repair=1;
     goto err;
   }
-  got_error=1;
+  got_error=1;				/* Assume the following may go wrong */
 
-  if (sort_param[0].fix_datafile)
+  if (sort_param->fix_datafile)
   {
     if (write_data_suffix(&sort_info,1) || end_io_cache(&info->rec_cache))
       goto err;
@@ -2330,8 +2358,8 @@ int mi_repair_by_sort_r(MI_CHECK *param, register MI_INFO *info,
         goto err;
       }
     }
-    share->state.state.data_file_length = info->state->data_file_length
-      = sort_param->filepos;
+    share->state.state.data_file_length= info->state->data_file_length=
+      sort_param->filepos;
     /* Only whole records */
     share->state.version=(ulong) time((time_t*) 0);
     my_close(info->dfile,MYF(0));
@@ -2372,7 +2400,7 @@ int mi_repair_by_sort_r(MI_CHECK *param, register MI_INFO *info,
 
   if (my_chsize(share->kfile,info->state->key_file_length,MYF(0)))
     mi_check_print_warning(param,
-                     "Can't change size of indexfile, error: %d", my_errno);
+			   "Can't change size of indexfile, error: %d", my_errno);
 
   if (!(param->testflag & T_SILENT))
   {
@@ -2424,8 +2452,8 @@ err:
     share->state.changed&= ~STATE_NOT_OPTIMIZED_KEYS;
   share->state.changed|=STATE_NOT_SORTED_PAGES;
 
-  pthread_cond_destroy (& sort_info.cond);
-  pthread_mutex_destroy(& sort_info.mutex);
+  pthread_cond_destroy (&sort_info.cond);
+  pthread_mutex_destroy(&sort_info.mutex);
 
   my_free((gptr) sort_info.key_block,MYF(MY_ALLOW_ZERO_PTR));
   my_free((gptr) sort_param,MYF(MY_ALLOW_ZERO_PTR));
@@ -2457,9 +2485,10 @@ static int sort_key_read(MI_SORT_PARAM *sort_param, void *key)
 			 "Found too many records; Can`t continue");
     DBUG_RETURN(1);
   }
-  sort_param->real_key_length=(info->s->rec_reflength+
-                        _mi_make_key(info, sort_param->key, (uchar*) key,
-                        sort_param->record, sort_param->filepos));
+  sort_param->real_key_length=
+    (info->s->rec_reflength+ 
+     _mi_make_key(info, sort_param->key, (uchar*) key,
+		  sort_param->record, sort_param->filepos));
   DBUG_RETURN(sort_write_record(sort_param));
 } /* sort_key_read */
 
@@ -2981,7 +3010,8 @@ int sort_write_record(MI_SORT_PARAM *sort_param)
 
 	/* Compare two keys from _create_index_by_sort */
 
-static int sort_key_cmp(MI_SORT_PARAM *sort_param, const void *a, const void *b)
+static int sort_key_cmp(MI_SORT_PARAM *sort_param, const void *a,
+			const void *b)
 {
   uint not_used;
   return (_mi_key_cmp(sort_param->keyinfo->seg,*((uchar**) a),*((uchar**) b),
@@ -2999,8 +3029,9 @@ static int sort_key_write(MI_SORT_PARAM *sort_param, const void *a)
 
   if (sort_info->key_block->inited)
   {
-    cmp=_mi_key_cmp(sort_param->keyinfo->seg,sort_info->key_block->lastkey,
-          (uchar*) a, USE_WHOLE_KEY,SEARCH_FIND | SEARCH_UPDATE ,&diff_pos);
+    cmp=_mi_key_cmp(sort_param->keyinfo->seg, sort_info->key_block->lastkey,
+		    (uchar*) a, USE_WHOLE_KEY, SEARCH_FIND | SEARCH_UPDATE,
+		    &diff_pos);
     sort_param->unique[diff_pos-1]++;
   }
   else
@@ -3032,7 +3063,7 @@ static int sort_key_write(MI_SORT_PARAM *sort_param, const void *a)
   }
 #endif
   return (sort_insert_key(sort_param,sort_info->key_block,
-                                              (uchar*) a, HA_OFFSET_ERROR));
+			  (uchar*) a, HA_OFFSET_ERROR));
 } /* sort_key_write */
 
 
@@ -3448,7 +3479,7 @@ int write_data_suffix(SORT_INFO *sort_info, my_bool fix_datafile)
     if (my_b_write(&info->rec_cache,buff,sizeof(buff)))
     {
       mi_check_print_error(sort_info->param,
-          "%d when writing to datafile",my_errno);
+			   "%d when writing to datafile",my_errno);
       return 1;
     }
     sort_info->param->read_cache.end_of_file+=sizeof(buff);
@@ -3638,8 +3669,7 @@ void mi_disable_non_unique_index(MI_INFO *info, ha_rows rows)
 */
 
 my_bool mi_test_if_sort_rep(MI_INFO *info, ha_rows rows,
-			    ulonglong key_map,
-			    my_bool force)
+			    ulonglong key_map, my_bool force)
 {
   MYISAM_SHARE *share=info->s;
   MI_KEYDEF *key=share->keyinfo;

myisam/sort.c

@@ -27,7 +27,8 @@
 #endif
 #include <queues.h>
 
-        /* static variables */
+/* static variables */
+
 #undef MIN_SORT_MEMORY
 #undef MYF_RW
 #undef DISK_BUFFER_SIZE
@@ -48,7 +49,7 @@ typedef struct st_buffpek {
 
 extern void print_error _VARARGS((const char *fmt,...));
 
-        /* functions defined in this file */
+/* Functions defined in this file */
 
 static ha_rows NEAR_F find_all_keys(MI_SORT_PARAM *info,uint keys,
                                     uchar **sort_keys,
@@ -57,7 +58,8 @@ static ha_rows NEAR_F find_all_keys(MI_SORT_PARAM *info,uint keys,
                                     IO_CACHE *tempfile_for_exceptions);
 static int NEAR_F write_keys(MI_SORT_PARAM *info,uchar * *sort_keys,
                              uint count, BUFFPEK *buffpek,IO_CACHE *tempfile);
-static int NEAR_F write_key(MI_SORT_PARAM *info, uchar *key, IO_CACHE *tempfile);
+static int NEAR_F write_key(MI_SORT_PARAM *info, uchar *key,
+			    IO_CACHE *tempfile);
 static int NEAR_F write_index(MI_SORT_PARAM *info,uchar * *sort_keys,
                               uint count);
 static int NEAR_F merge_many_buff(MI_SORT_PARAM *info,uint keys,
@@ -72,8 +74,21 @@ static int NEAR_F merge_buffers(MI_SORT_PARAM *info,uint keys,
                                 BUFFPEK *Fb, BUFFPEK *Tb);
 static int NEAR_F merge_index(MI_SORT_PARAM *,uint,uchar **,BUFFPEK *, int,
                               IO_CACHE *);
-	/* Creates a index of sorted keys */
-	/* Returns 0 if everything went ok */
+
+
+/*
+  Creates a index of sorted keys
+
+  SYNOPSIS
+    _create_index_by_sort()
+    info		Sort parameters
+    no_messages		Set to 1 if no output
+    sortbuff_size	Size if sortbuffer to allocate
+
+  RESULT
+    0	ok
+   <> 0 Error
+*/
 
 int _create_index_by_sort(MI_SORT_PARAM *info,my_bool no_messages,
 			  ulong sortbuff_size)
@@ -209,7 +224,7 @@ err:
 } /* _create_index_by_sort */
 
 
-	/* Search after all keys and place them in a temp. file */
+/* Search after all keys and place them in a temp. file */
 
 static ha_rows NEAR_F find_all_keys(MI_SORT_PARAM *info, uint keys,
 				    uchar **sort_keys, DYNAMIC_ARRAY *buffpek,
@@ -223,7 +238,7 @@ static ha_rows NEAR_F find_all_keys(MI_SORT_PARAM *info, uint keys,
   idx=error=0;
   sort_keys[0]=(uchar*) (sort_keys+keys);
 
-  while(!(error=(*info->key_read)(info,sort_keys[idx])))
+  while (!(error=(*info->key_read)(info,sort_keys[idx])))
   {
     if (info->real_key_length > info->key_length)
     {
@@ -248,7 +263,8 @@ static ha_rows NEAR_F find_all_keys(MI_SORT_PARAM *info, uint keys,
     DBUG_RETURN(HA_POS_ERROR);		/* Aborted by get_key */ /* purecov: inspected */
   if (buffpek->elements)
   {
-    if (write_keys(info,sort_keys,idx,(BUFFPEK *)alloc_dynamic(buffpek),tempfile))
+    if (write_keys(info,sort_keys,idx,(BUFFPEK *)alloc_dynamic(buffpek),
+		   tempfile))
       DBUG_RETURN(HA_POS_ERROR);		/* purecov: inspected */
     *maxbuffer=buffpek->elements-1;
   }
@@ -258,21 +274,22 @@ static ha_rows NEAR_F find_all_keys(MI_SORT_PARAM *info, uint keys,
   DBUG_RETURN((*maxbuffer)*(keys-1)+idx);
 } /* find_all_keys */
 
-        /* Search after all keys and place them in a temp. file */
+
+/* Search after all keys and place them in a temp. file */
 
 void *_thr_find_all_keys(MI_SORT_PARAM *info)
 {
-  int error,skr;
+  int error;
   uint memavl,old_memavl,keys,sort_length;
   uint idx, maxbuffer;
   uchar **sort_keys;
-  MI_KEYSEG *keyseg;
 
   my_b_clear(&info->tempfile);
   my_b_clear(&info->tempfile_for_exceptions);
   bzero((char*) &info->buffpek,sizeof(info->buffpek));
   bzero((char*) &info->unique, sizeof(info->unique));
-  sort_keys= (uchar **) NULL; error= 1;
+  sort_keys= (uchar **) NULL;
+  error= 1;
   if (info->sort_info->got_error)
     goto err;
 
@@ -280,12 +297,15 @@ void *_thr_find_all_keys(MI_SORT_PARAM *info)
   idx=      info->sort_info->max_records;
   sort_length=  info->key_length;
 
+  maxbuffer=1;
   while (memavl >= MIN_SORT_MEMORY)
   {
     if ((my_off_t) (idx+1)*(sort_length+sizeof(char*)) <=
         (my_off_t) memavl)
       keys= idx+1;
     else
+    {
+      uint skr;
       do
       {
         skr=maxbuffer;
@@ -299,12 +319,13 @@ void *_thr_find_all_keys(MI_SORT_PARAM *info)
         }
       }
       while ((maxbuffer= (int) (idx/(keys-1)+1)) != skr);
-
+    }
     if ((sort_keys=(uchar **)my_malloc(keys*(sort_length+sizeof(char*))+
-           ((info->keyinfo->flag & HA_FULLTEXT) ? HA_FT_MAXLEN : 0), MYF(0))))
+				       ((info->keyinfo->flag & HA_FULLTEXT) ?
+					HA_FT_MAXLEN : 0), MYF(0))))
     {
       if (my_init_dynamic_array(&info->buffpek, sizeof(BUFFPEK),
-            maxbuffer, maxbuffer/2))
+				maxbuffer, maxbuffer/2))
         my_free((gptr) sort_keys,MYF(0));
       else
         break;
@@ -318,7 +339,6 @@ void *_thr_find_all_keys(MI_SORT_PARAM *info)
     mi_check_print_error(info->sort_info->param,"Sort buffer to small"); /* purecov: tested */
     goto err; /* purecov: tested */
   }
-//  (*info->lock_in_memory)(info->sort_info->param);/* Everything is allocated */
 
   if (info->sort_info->param->testflag & T_VERBOSE)
     printf("Key %d - Allocating buffer for %d keys\n",info->key+1,keys);
@@ -327,12 +347,12 @@ void *_thr_find_all_keys(MI_SORT_PARAM *info)
   idx=error=0;
   sort_keys[0]=(uchar*) (sort_keys+keys);
 
-  while(!(error=info->sort_info->got_error) ||
-        !(error=(*info->key_read)(info,sort_keys[idx])))
+  while (!(error=info->sort_info->got_error) ||
+	 !(error=(*info->key_read)(info,sort_keys[idx])))
   {
     if (info->real_key_length > info->key_length)
     {
-      if (write_key(info,sort_keys[idx],& info->tempfile_for_exceptions))
+      if (write_key(info,sort_keys[idx], &info->tempfile_for_exceptions))
         goto err;
       continue;
     }
@@ -340,7 +360,8 @@ void *_thr_find_all_keys(MI_SORT_PARAM *info)
     if (++idx == keys)
     {
       if (write_keys(info,sort_keys,idx-1,
-            (BUFFPEK *)alloc_dynamic(&info->buffpek), &info->tempfile))
+		     (BUFFPEK *)alloc_dynamic(&info->buffpek),
+		     &info->tempfile))
         goto err;
 
       sort_keys[0]=(uchar*) (sort_keys+keys);
@@ -353,8 +374,8 @@ void *_thr_find_all_keys(MI_SORT_PARAM *info)
     goto err;
   if (info->buffpek.elements)
   {
-    if (write_keys(info,sort_keys,idx,(BUFFPEK *)
-          alloc_dynamic(&info->buffpek),&info->tempfile))
+    if (write_keys(info,sort_keys, idx,
+		   (BUFFPEK *) alloc_dynamic(&info->buffpek), &info->tempfile))
       goto err;
     info->keys=(info->buffpek.elements-1)*(keys-1)+idx;
   }
@@ -370,31 +391,36 @@ err:
     my_free((gptr) sort_keys,MYF(0));
   info->sort_keys=0;
   delete_dynamic(& info->buffpek);
-  close_cached_file(& info->tempfile);
-  close_cached_file(& info->tempfile_for_exceptions);
+  close_cached_file(&info->tempfile);
+  close_cached_file(&info->tempfile_for_exceptions);
+
 ok:
-  remove_io_thread(& info->read_cache);
-  pthread_mutex_lock(& info->sort_info->mutex);
+  remove_io_thread(&info->read_cache);
+  pthread_mutex_lock(&info->sort_info->mutex);
   info->sort_info->threads_running--;
-  pthread_cond_signal(& info->sort_info->cond);
-  pthread_mutex_unlock(& info->sort_info->mutex);
+  pthread_cond_signal(&info->sort_info->cond);
+  pthread_mutex_unlock(&info->sort_info->mutex);
   return NULL;
 } /* _thr_find_all_keys */
 
+
 int _thr_write_keys(MI_SORT_PARAM *sort_param)
 {
   SORT_INFO *sort_info=sort_param->sort_info;
   MI_CHECK *param=sort_info->param;
   ulong length, keys;
   ulong *rec_per_key_part=param->rec_per_key_part;
-  int i, got_error=sort_info->got_error;
+  int got_error=sort_info->got_error;
+  uint i;
   MI_INFO *info=sort_info->info;
   MYISAM_SHARE *share=info->s;  
   MI_SORT_PARAM *sinfo;
   byte *mergebuf=0;
+  LINT_INIT(length);
 
-  for (i=0, sinfo=sort_param ; i<sort_info->total_keys ; i++, sinfo++,
-                            rec_per_key_part+=sinfo->keyinfo->keysegs)
+  for (i=0, sinfo=sort_param ;
+       i < sort_info->total_keys ;
+       i++, sinfo++, rec_per_key_part+=sinfo->keyinfo->keysegs)
   {
     if (!sinfo->sort_keys)
     {
@@ -404,25 +430,30 @@ int _thr_write_keys(MI_SORT_PARAM *sort_param)
     share->state.key_map|=(ulonglong) 1 << sinfo->key;
     if (param->testflag & T_STATISTICS)
       update_key_parts(sinfo->keyinfo, rec_per_key_part,
-                        sinfo->unique, (ulonglong) info->state->records);
+		       sinfo->unique, (ulonglong) info->state->records);
     if (!sinfo->buffpek.elements)
     {
       if (param->testflag & T_VERBOSE)
-        printf("Key %d  - Dumping %lu keys\n",sinfo->key+1, sinfo->keys);
-      if (write_index(sinfo,sinfo->sort_keys,(uint) sinfo->keys) ||
-                                       flush_pending_blocks(sinfo))
+      {
+        printf("Key %d  - Dumping %u keys\n",sinfo->key+1, sinfo->keys);
+	fflush(stdout);
+      }
+      if (write_index(sinfo, sinfo->sort_keys, sinfo->keys) ||
+	  flush_pending_blocks(sinfo))
         got_error=1;
     }
     my_free((gptr) sinfo->sort_keys,MYF(0));
     sinfo->sort_keys=0;
   }
 
-  for (i=0, sinfo=sort_param ; i<sort_info->total_keys ; i++, sinfo++,
-                                      delete_dynamic(& sinfo->buffpek),
-                                      close_cached_file(& sinfo->tempfile),
-                        close_cached_file(& sinfo->tempfile_for_exceptions))
+  for (i=0, sinfo=sort_param ;
+       i < sort_info->total_keys ;
+       i++, sinfo++, delete_dynamic(&sinfo->buffpek),
+	 close_cached_file(&sinfo->tempfile),
+	 close_cached_file(&sinfo->tempfile_for_exceptions))
   {
-    if (got_error) continue;
+    if (got_error)
+      continue;
     if (sinfo->buffpek.elements)
     {
       uint maxbuffer=sinfo->buffpek.elements-1;
@@ -444,10 +475,10 @@ int _thr_write_keys(MI_SORT_PARAM *sort_param)
       if (maxbuffer >= MERGEBUFF2)
       {
         if (param->testflag & T_VERBOSE)
-          printf("Key %d  - Merging %lu keys\n",sinfo->key+1, sinfo->keys);
+          printf("Key %d  - Merging %u keys\n",sinfo->key+1, sinfo->keys);
         if (merge_many_buff(sinfo, keys, (uchar **)mergebuf,
-                          dynamic_element(&sinfo->buffpek, 0, BUFFPEK *),
-                          &maxbuffer, &sinfo->tempfile))
+			    dynamic_element(&sinfo->buffpek, 0, BUFFPEK *),
+			    &maxbuffer, &sinfo->tempfile))
         {
           got_error=1;
           continue;
@@ -463,8 +494,8 @@ int _thr_write_keys(MI_SORT_PARAM *sort_param)
         printf("Key %d  - Last merge and dumping keys", sinfo->key+1);
       if (merge_index(sinfo, keys, (uchar **)mergebuf,
                       dynamic_element(&sinfo->buffpek,0,BUFFPEK *),
-                      maxbuffer,&sinfo->tempfile)
-          || flush_pending_blocks(sinfo))
+                      maxbuffer,&sinfo->tempfile) ||
+	  flush_pending_blocks(sinfo))
       {
         got_error=1;
         continue;
@@ -484,15 +515,15 @@ int _thr_write_keys(MI_SORT_PARAM *sort_param)
         continue;
       }
 
-      while (!got_error
-          && !my_b_read(&sinfo->tempfile_for_exceptions,(byte*)&key_length,
-                        sizeof(key_length))
-          && !my_b_read(&sinfo->tempfile_for_exceptions,(byte*)mergebuf,
-                        (uint) key_length))
+      while (!got_error &&
+	     !my_b_read(&sinfo->tempfile_for_exceptions,(byte*)&key_length,
+			sizeof(key_length)) &&
+	     !my_b_read(&sinfo->tempfile_for_exceptions,(byte*)mergebuf,
+			(uint) key_length))
       {
-          if (_mi_ck_write(info,sinfo->key,(uchar*) mergebuf,
-                key_length - info->s->rec_reflength))
-            got_error=1;
+	if (_mi_ck_write(info,sinfo->key,(uchar*) mergebuf,
+			 key_length - info->s->rec_reflength))
+	  got_error=1;
       }
     }
   }
@@ -526,7 +557,8 @@ static int NEAR_F write_keys(MI_SORT_PARAM *info, register uchar **sort_keys,
 } /* write_keys */
 
 
-static int NEAR_F write_key(MI_SORT_PARAM *info, uchar *key, IO_CACHE *tempfile)
+static int NEAR_F write_key(MI_SORT_PARAM *info, uchar *key,
+			    IO_CACHE *tempfile)
 {
   uint key_length=info->real_key_length;
   DBUG_ENTER("write_key");
@@ -542,6 +574,7 @@ static int NEAR_F write_key(MI_SORT_PARAM *info, uchar *key, IO_CACHE *tempfile)
   DBUG_RETURN(0);
 } /* write_key */
 
+
         /* Write index */
 
 static int NEAR_F write_index(MI_SORT_PARAM *info, register uchar **sort_keys,
@@ -552,8 +585,10 @@ static int NEAR_F write_index(MI_SORT_PARAM *info, register uchar **sort_keys,
   qsort2((gptr) sort_keys,(size_t) count,sizeof(byte*),
         (qsort2_cmp) info->key_cmp,info);
   while (count--)
+  {
     if ((*info->key_write)(info,*sort_keys++))
       DBUG_RETURN(-1); /* purecov: inspected */
+  }
   DBUG_RETURN(0);
 } /* write_index */
 
@@ -604,8 +639,18 @@ static int NEAR_F merge_many_buff(MI_SORT_PARAM *info, uint keys,
 } /* merge_many_buff */
 
 
-        /* Read data to buffer */
-        /* This returns (uint) -1 if something goes wrong */
+/*
+   Read data to buffer
+
+  SYNOPSIS
+    read_to_buffer()
+    fromfile		File to read from
+    buffpek		Where to read from
+    sort_length		max length to read
+  RESULT
+    > 0	Ammount of bytes read
+    -1	Error
+*/
 
 static uint NEAR_F read_to_buffer(IO_CACHE *fromfile, BUFFPEK *buffpek,
                                   uint sort_length)
@@ -627,8 +672,10 @@ static uint NEAR_F read_to_buffer(IO_CACHE *fromfile, BUFFPEK *buffpek,
 } /* read_to_buffer */
 
 
-        /* Merge buffers to one buffer */
-        /* If to_file == 0 then use info->key_write */
+/*
+  Merge buffers to one buffer
+  If to_file == 0 then use info->key_write
+*/
 
 static int NEAR_F
 merge_buffers(MI_SORT_PARAM *info, uint keys, IO_CACHE *from_file,

myisammrg/myrg_delete.c

@@ -18,12 +18,10 @@
 
 #include "myrg_def.h"
 
-int myrg_delete(
-MYRG_INFO *info,
-const byte *record)
+int myrg_delete(MYRG_INFO *info, const byte *record)
 {
   if (!info->current_table)
-    return my_errno=HA_ERR_NO_ACTIVE_RECORD ;
+    return (my_errno= HA_ERR_NO_ACTIVE_RECORD);
 
   return mi_delete(info->current_table->table,record);
 }

myisammrg/myrg_rsame.c

@@ -19,10 +19,10 @@
 int myrg_rsame(MYRG_INFO *info,byte *record,int inx)
 {
   if (inx)					/* not yet used, should be 0 */
-    return my_errno=HA_ERR_WRONG_INDEX;
+    return (my_errno=HA_ERR_WRONG_INDEX);
 
   if (!info->current_table)
-    return my_errno=HA_ERR_NO_ACTIVE_RECORD;
+    return (my_errno=HA_ERR_NO_ACTIVE_RECORD);
 
   return mi_rsame(info->current_table->table,record,inx);
 }

myisammrg/myrg_update.c

@@ -21,7 +21,7 @@
 int myrg_update(register MYRG_INFO *info,const byte *oldrec, byte *newrec)
 {
   if (!info->current_table)
-    return my_errno=HA_ERR_NO_ACTIVE_RECORD;
+    return (my_errno=HA_ERR_NO_ACTIVE_RECORD);
 
   return mi_update(info->current_table->table,oldrec,newrec);
 }

myisammrg/myrg_write.c

@@ -26,5 +26,5 @@ int myrg_write(register MYRG_INFO *info, byte *rec)
   else if (info->merge_insert_method == MERGE_INSERT_TO_LAST)
     return mi_write(info->end_table[-1].table,rec);
   else /* unsupported insertion method */
-    return my_errno=HA_ERR_WRONG_COMMAND;
+    return (my_errno= HA_ERR_WRONG_COMMAND);
 }

mysys/Makefile.am

@@ -44,7 +44,7 @@ libmysys_a_SOURCES =	my_init.c my_getwd.c mf_getdate.c\
 			my_delete.c my_rename.c my_redel.c my_tempnam.c \
 			my_chsize.c my_lread.c my_lwrite.c my_clock.c \
 			my_quick.c my_lockmem.c my_static.c \
-			my_getopt.c getvar.c my_mkdir.c \
+			my_getopt.c my_mkdir.c \
 			default.c my_compress.c checksum.c raid.cc \
 			my_net.c \
 			my_vsnprintf.c charset.c my_bitmap.c my_bit.c md5.c \

mysys/getvar.c

-/* Copyright (C) 2000 MySQL AB
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
-
-/* Allow use of the -O variable= option to set long variables */
-
-#include "mysys_priv.h"
-#include <m_string.h>
-#include <m_ctype.h>
-#include <my_getopt.h>
-	/* set all changeable variables */
-
-void set_all_changeable_vars(CHANGEABLE_VAR *vars)
-{
-  for ( ; vars->name ; vars++)
-    *vars->varptr= vars->def_value;
-}
-
-
-my_bool set_changeable_varval(const char* var, ulong val,
-			      CHANGEABLE_VAR *vars)
-{
-  char buffer[256];
-  sprintf( buffer, "%s=%lu", var, (unsigned long) val );
-  return set_changeable_var( buffer, vars );
-}
-
-
-my_bool set_changeable_var(my_string str,CHANGEABLE_VAR *vars)
-{
-  char endchar;
-  my_string end;
-  DBUG_ENTER("set_changeable_var");
-  DBUG_PRINT("enter",("%s",str));
-
-  if (str)
-  {
-    if (!(end=strchr(str,'=')))
-      fprintf(stderr,"Can't find '=' in expression '%s' to option -O\n",str);
-    else
-    {
-      uint length,found_count=0;
-      CHANGEABLE_VAR *var,*found;
-      my_string var_end;
-      const char *name;
-      longlong num;
-
-      /* Skip end space from variable */
-      for (var_end=end ; end > str && isspace(var_end[-1]) ; var_end--) ;
-      length=(uint) (var_end-str);
-      /* Skip start space from argument */
-      for (end++ ; isspace(*end) ; end++) ;
-
-      for (var=vars,found=0 ; (name=var->name) ; var++)
-      {
-	if (!my_casecmp(name,str,length))
-	{
-	  found=var; found_count++;
-	  if (!name[length])
-	  {
-	    found_count=1;
-	    break;
-	  }
-	}
-      }
-      if (found_count == 0)
-      {
-	fprintf(stderr,"No variable match for: -O '%s'\n",str);
-	DBUG_RETURN(1);
-      }
-      if (found_count > 1)
-      {
-	fprintf(stderr,"Variable prefix '%*s' is not unique\n",length,str);
-	DBUG_RETURN(1);
-      }
-
-      num=strtoll(end, (char **)NULL, 10); endchar=strend(end)[-1];
-      if (endchar == 'k' || endchar == 'K')
-	num*=1024;
-      else if (endchar == 'm' || endchar == 'M')
-	num*=1024L*1024L;
-      else if (endchar == 'g' || endchar == 'G')
-	num*=1024L*1024L*1024L;
-      else if (!isdigit(endchar))
-      {
-	fprintf(stderr,"Unknown prefix used for variable value '%s'\n",str);
-	DBUG_RETURN(1);
-      }
-      if (num < (longlong) found->min_value)
-	num=(longlong) found->min_value;
-      else if (num > 0 && (ulonglong) num > (ulonglong) (ulong) found->max_value)
-	num=(longlong) (ulong) found->max_value;
-      num=((num- (longlong) found->sub_size) / (ulonglong) found->block_size);
-      (*found->varptr)= (long) (num*(ulonglong) found->block_size);
-      DBUG_RETURN(0);
-    }
-  }
-  DBUG_RETURN(1);
-}

sql/field.cc

@@ -312,8 +312,8 @@ bool Field::optimize_range(uint idx)
 }
 
 /****************************************************************************
-** Functions for the Field_decimal class
-** This is an unpacked number.
+  Functions for the Field_decimal class
+  This is an number stored as a pre-space (or pre-zero) string
 ****************************************************************************/
 
 void
@@ -326,6 +326,8 @@ void Field_decimal::overflow(bool negative)
 {
   uint len=field_length;
   char *to=ptr, filler= '9';
+
+  current_thd->cuted_fields++;
   if (negative)
   {
     if (!unsigned_flag)
@@ -419,7 +421,7 @@ void Field_decimal::store(const char *from,uint len)
   if ((tmp_dec=dec))
     tmp_dec++;
 
-  for (; from!=end && isspace(*from); from++) ;	// Read spaces
+  for (; from !=end && isspace(*from); from++) ; // Read spaces
   if (from == end)
   {
     current_thd->cuted_fields++;
@@ -428,23 +430,22 @@ void Field_decimal::store(const char *from,uint len)
   else if (*from == '+' || *from == '-')	// Found some sign ?
   {
     sign_char= *from++;
-    /* 
-     Unsigned can't have any flag. So we'll just drop "+"  
-     and will overflow on "-"
+    /*
+      Unsigned can't have any flag. So we'll just drop "+"
+      and will overflow on "-"
     */ 
     if (unsigned_flag)  
     { 
       if (sign_char=='-')
       {
-        current_thd->cuted_fields++;
         Field_decimal::overflow(1);
         return;
       }
       else 
         sign_char=0;
     }
-      
   }
+
   pre_zeros_from= from;
   for (; from!=end && *from == '0'; from++) ;	// Read prezeros
   pre_zeros_end=int_digits_from=from;      
@@ -484,7 +485,7 @@ void Field_decimal::store(const char *from,uint len)
 
   if (current_thd->count_cuted_fields)
   {
-    for (;from!=end && isspace(*from); from++) ;   // Read end spaces
+    for (;from != end && isspace(*from); from++) ;   // Read end spaces
     if (from != end)                     // If still something left, warn
     {
       current_thd->cuted_fields++; 
@@ -563,7 +564,6 @@ void Field_decimal::store(const char *from,uint len)
 
   if (field_length < tmp_uint + (int) (sign_char == '-'))
   {
-    current_thd->cuted_fields++;
     // too big number, change to max or min number
     Field_decimal::overflow(sign_char == '-');
     return;
@@ -606,7 +606,7 @@ void Field_decimal::store(const char *from,uint len)
   }
   else
   {
-    left_wall=to+(sign_char!=0)-1;
+    left_wall=to+(sign_char != 0)-1;
     if (!expo_sign_char)	// If exponent was specified, ignore prezeros
     {
       for (;pos != left_wall && pre_zeros_from !=pre_zeros_end;
@@ -659,7 +659,7 @@ void Field_decimal::store(const char *from,uint len)
 	{
 	  if (tmp_char != '0')			// Losing a non zero digit ?
 	  {
-	    if (current_thd->count_cuted_fields && !is_cuted_fields_incr)
+	    if (!is_cuted_fields_incr)
 	      current_thd->cuted_fields++;
 	    return;
 	  }
@@ -696,14 +696,12 @@ void Field_decimal::store(double nr)
   if (unsigned_flag && nr < 0)
   {
     overflow(1);
-    current_thd->cuted_fields++;
     return;
   }
   
   if (isinf(nr)) // Handle infinity as special case
   {
     overflow(nr < 0.0);
-    current_thd->cuted_fields++;
     return;      
   }
   
@@ -721,10 +719,7 @@ void Field_decimal::store(double nr)
   length=(uint) strlen(buff);
 
   if (length > field_length)
-  {
     overflow(nr < 0.0);
-    current_thd->cuted_fields++;
-  }
   else
   {
     to=ptr;
@@ -740,7 +735,6 @@ void Field_decimal::store(longlong nr)
   if (unsigned_flag && nr < 0)
   {
     overflow(1);
-    current_thd->cuted_fields++;
     return;
   }
   char buff[22];
@@ -748,10 +742,7 @@ void Field_decimal::store(longlong nr)
   uint int_part=field_length- (dec  ? dec+1 : 0);
 
   if (length > int_part)
-  {
     overflow(test(nr < 0L));			/* purecov: inspected */
-    current_thd->cuted_fields++;		/* purecov: inspected */
-  }
   else
   {
     char fyllchar = zerofill ? (char) '0' : (char) ' ';