Cleanups...

client/mysql.cc

@@ -2212,14 +2212,14 @@ com_status(String *buffer __attribute__((unused)),
   if (safe_updates)
   {
     vidattr(A_BOLD);
-    tee_fprintf(stdout, "\nNote that we are running in safe_update_mode:\n");
+    tee_fprintf(stdout, "\nNote that you are running in safe_update_mode:\n");
     vidattr(A_NORMAL);
     tee_fprintf(stdout, "\
-UPDATE and DELETE that doesn't use a key in the WHERE clause are not allowed\n\
-(One can force UPDATE/DELETE by adding LIMIT # at the end of the command)\n\
-SELECT has an automatic 'LIMIT %lu' if LIMIT is not used\n\
+UPDATEs and DELETEs that don't use a key in the WHERE clause are not allowed.\n\
+(One can force an UPDATE/DELETE by adding LIMIT # at the end of the command.)\n\
+SELECT has an automatic 'LIMIT %lu' if LIMIT is not used.\n\
 Max number of examined row combination in a join is set to: %lu\n\n",
-select_limit,max_join_size);
+select_limit, max_join_size);
   }
   tee_puts("--------------\n", stdout);
   return 0;

client/mysqltest.c

@@ -145,19 +145,36 @@ struct st_query
   uint expected_errno[MAX_EXPECTED_ERRORS];
   char record_file[FN_REFLEN];
   /* Add new commands before Q_UNKNOWN */
-  enum { Q_CONNECTION=1, Q_QUERY, Q_CONNECT,
-	 Q_SLEEP, Q_INC, Q_DEC,Q_SOURCE,
-	 Q_DISCONNECT,Q_LET, Q_ECHO, Q_WHILE, Q_END_BLOCK,
-	 Q_SYSTEM, Q_RESULT, Q_REQUIRE, Q_SAVE_MASTER_POS,
-	 Q_SYNC_WITH_MASTER, Q_ERROR, Q_SEND, Q_REAP, Q_DIRTY_CLOSE,
-	 Q_REPLACE,
-	 Q_UNKNOWN, Q_COMMENT, Q_COMMENT_WITH_COMMAND} type;
+  enum { Q_CONNECTION=1,     Q_QUERY, 
+         Q_CONNECT,          Q_SLEEP, 
+         Q_INC,              Q_DEC,
+         Q_SOURCE,           Q_DISCONNECT,
+         Q_LET,              Q_ECHO, 
+         Q_WHILE,            Q_END_BLOCK,
+         Q_SYSTEM,           Q_RESULT, 
+         Q_REQUIRE,          Q_SAVE_MASTER_POS,
+         Q_SYNC_WITH_MASTER, Q_ERROR, 
+         Q_SEND,             Q_REAP, 
+         Q_DIRTY_CLOSE,      Q_REPLACE,
+         Q_UNKNOWN,                             /* Unknown command.   */
+         Q_COMMENT,                             /* Comments, ignored. */
+         Q_COMMENT_WITH_COMMAND
+  } type;
 };
 
 const char *command_names[] = {
-"connection", "query","connect","sleep","inc","dec","source","disconnect",
-"let","echo","while","end","system","result", "require", "save_master_pos",
- "sync_with_master", "error", "send", "reap", "dirty_close", "replace_result", 0
+  "connection",       "query",
+  "connect",          "sleep",
+  "inc",              "dec",
+  "source",           "disconnect",
+  "let",              "echo",
+  "while",            "end",
+  "system",           "result",
+  "require",          "save_master_pos",
+  "sync_with_master", "error",
+  "send",             "reap", 
+  "dirty_close",      "replace_result",
+  0
 };
 
 TYPELIB command_typelib= {array_elements(command_names),"",
@@ -873,9 +890,9 @@ int do_connect(struct st_query* q)
   p = safe_get_param(p, &con_pass, "missing connection password");
   p = safe_get_param(p, &con_db, "missing connection db");
   p = safe_get_param(p, &con_port_str, "missing connection port");
-  p = safe_get_param(p, &con_sock, "missing connection scoket");
+  p = safe_get_param(p, &con_sock, "missing connection socket");
   if (next_con == cons_end)
-    die("Connection limit exhausted - incread MAX_CONS in mysqltest.c");
+    die("Connection limit exhausted - increase MAX_CONS in mysqltest.c");
 
   if (!mysql_init(&next_con->mysql))
     die("Failed on mysql_init()");
@@ -914,7 +931,7 @@ int do_while(struct st_query* q)
   char* expr_start, *expr_end;
   VAR v;
   if (cur_block == block_stack_end)
-	die("Nesting too deep");
+	die("Nesting too deeply");
   if (!block_ok)
     {
       ++false_block_depth;
@@ -1204,23 +1221,23 @@ int read_query(struct st_query** q_ptr)
 
 struct option long_options[] =
 {
-  {"debug",    optional_argument, 0, '#'},
-  {"database", required_argument, 0, 'D'},
-  {"help", no_argument, 0, '?'},
-  {"host", required_argument, 0, 'h'},
-  {"password", optional_argument, 0, 'p'},
-  {"port", required_argument, 0, 'P'},
-  {"quiet", no_argument, 0, 'q'},
-  {"record", no_argument, 0, 'r'},
+  {"debug",       optional_argument, 0, '#'},
+  {"database",    required_argument, 0, 'D'},
+  {"help",        no_argument,       0, '?'},
+  {"host",        required_argument, 0, 'h'},
+  {"password",    optional_argument, 0, 'p'},
+  {"port",        required_argument, 0, 'P'},
+  {"quiet",       no_argument,       0, 'q'},
+  {"record",      no_argument,       0, 'r'},
   {"result-file", required_argument, 0, 'R'},
-  {"silent", no_argument, 0, 'q'},
-  {"sleep",  required_argument, 0, 'T'},
-  {"socket", required_argument, 0, 'S'},
-  {"tmpdir", required_argument, 0, 't'},
-  {"user", required_argument, 0, 'u'},
-  {"verbose", no_argument, 0, 'v'},
-  {"version", no_argument, 0, 'V'},
-  {0, 0,0,0}
+  {"silent",      no_argument,       0, 'q'},
+  {"sleep",       required_argument, 0, 'T'},
+  {"socket",      required_argument, 0, 'S'},
+  {"tmpdir",      required_argument, 0, 't'},
+  {"user",        required_argument, 0, 'u'},
+  {"verbose",     no_argument,       0, 'v'},
+  {"version",     no_argument,       0, 'V'},
+  {0, 0, 0, 0}
 };
 
 

sql/ha_myisam.cc

@@ -369,7 +369,7 @@ int ha_myisam::restore(THD* thd, HA_CHECK_OPT *check_opt)
 				  MI_NAME_DEXT, 4), MYF(MY_WME)))
   {
     error = HA_ADMIN_FAILED;
-    errmsg = "failed in my_copy( Error %d)";
+    errmsg = "Failed in my_copy (Error %d)";
     goto err;
   }
 
@@ -402,7 +402,7 @@ int ha_myisam::backup(THD* thd, HA_CHECK_OPT *check_opt)
   
   if (!fn_format(dst_path, table_name, backup_dir, reg_ext, 4 + 64))
     {
-      errmsg = "failed in fn_format() for .frm file: errno=%d";
+      errmsg = "Failed in fn_format() for .frm file: errno = %d";
       error = HA_ADMIN_INVALID;
       goto err;
     }
@@ -418,7 +418,7 @@ int ha_myisam::backup(THD* thd, HA_CHECK_OPT *check_opt)
 
   if (!fn_format(dst_path, table_name, backup_dir, MI_NAME_DEXT, 4 + 64))
     {
-      errmsg = "failed in fn_format() for .MYD file: errno=%d";
+      errmsg = "Failed in fn_format() for .MYD file: errno = %d";
       error = HA_ADMIN_INVALID;
       goto err;
     }
@@ -470,7 +470,7 @@ int ha_myisam::repair(THD* thd, HA_CHECK_OPT *check_opt)
     if (param.retry_without_quick && param.opt_rep_quick)
     {
       param.opt_rep_quick=0;
-      sql_print_error("Warning: Retrying repair of:  '%s' without quick",
+      sql_print_error("Warning: Retrying repair of: '%s' without quick",
 		      table->path);
       continue;
     }
@@ -478,7 +478,7 @@ int ha_myisam::repair(THD* thd, HA_CHECK_OPT *check_opt)
     if ((param.testflag & T_REP_BY_SORT))
     {
       param.testflag= (param.testflag & ~T_REP_BY_SORT) | T_REP;
-      sql_print_error("Warning: Retrying repair of:  '%s' with keycache",
+      sql_print_error("Warning: Retrying repair of: '%s' with keycache",
 		      table->path);
       continue;
     }
@@ -579,7 +579,7 @@ int ha_myisam::repair(THD *thd, MI_CHECK &param, bool optimize)
       error = chk_key(&param, file);
     }
   }
-  thd->proc_info="saving state";
+  thd->proc_info="Saving state";
   if (!error)
   {
     if ((share->state.changed & STATE_CHANGED) || mi_is_crashed(file))
@@ -636,7 +636,7 @@ bool ha_myisam::activate_all_index(THD *thd)
   if (share->state.key_map != ((ulonglong) 1L << share->base.keys)-1)
   {
     const char *save_proc_info=thd->proc_info;
-    thd->proc_info="creating index";
+    thd->proc_info="Creating index";
     myisamchk_init(&param);
     param.op_name = (char*) "recreating_index";
     param.testflag = (T_SILENT | T_REP_BY_SORT |

sql/mysqld.cc

@@ -193,8 +193,8 @@ int segfaulted = 0; // ensure we do not enter SIGSEGV handler twice
 extern MASTER_INFO glob_mi;
 extern int init_master_info(MASTER_INFO* mi);
 
-// if sql_bin_update is true, SQL_LOG_UPDATE and SQL_LOG_BIN are kept in sync, and are
-// treated as aliases for each other
+// if sql_bin_update is true, SQL_LOG_UPDATE and SQL_LOG_BIN are kept in sync,
+// and are treated as aliases for each other
 
 static bool kill_in_progress=FALSE;
 static struct rand_struct sql_rand;
@@ -1110,9 +1110,9 @@ inline __volatile__ void  trace_stack()
   LINT_INIT(stack_bottom);
 
   fprintf(stderr,
-"Attemping backtrace. You can use the following information to find out\n\
+"Attempting backtrace. You can use the following information to find out\n\
 where mysqld died.  If you see no messages after this, something went\n\
-terribly wrong\n");
+terribly wrong...\n");
   THD* thd = current_thd;
   uint frame_count = 0;
   __asm __volatile__ ("movl %%ebp,%0"
@@ -1121,12 +1121,12 @@ terribly wrong\n");
   if (!ebp)
   {
     fprintf(stderr, "frame pointer (ebp) is NULL, did you compile with\n\
--fomit-frame-pointer? Aborting backtrace\n");
+-fomit-frame-pointer? Aborting backtrace!\n");
     return;
   }
   if (!thd)
   {
-    fprintf(stderr, "Cannot determine thread, ebp=%p, backtrace may not be correct\n", ebp);
+    fprintf(stderr, "Cannot determine thread, ebp=%p, backtrace may not be correct.\n", ebp);
     /* Assume that the stack starts at the previous even 65K */
     ulong tmp= min(0x10000,thread_stack);
     stack_bottom= (uchar**) (((ulong) &stack_bottom + tmp) &
@@ -1137,11 +1137,11 @@ terribly wrong\n");
   if (ebp > stack_bottom || ebp < stack_bottom - thread_stack)
   {
     fprintf(stderr,
-	    "Bogus stack limit or frame pointer, aborting backtrace\n");
+	    "Bogus stack limit or frame pointer, aborting backtrace.\n");
     return;
   }
 
-  fprintf(stderr, "stack range sanity check, ok, backtrace follows\n");
+  fprintf(stderr, "Stack range sanity check OK, backtrace follows:\n");
   
   while (ebp < stack_bottom)
   {
@@ -1151,22 +1151,22 @@ terribly wrong\n");
     if (new_ebp <= ebp )
     {
       fprintf(stderr, "\
-New value of ebp failed sanity check terminating backtrace\n");
+New value of ebp failed sanity check, terminating backtrace!\n");
       return;
     }
     ebp = new_ebp;
     ++frame_count;
   }
 
-  fprintf(stderr, "stack trace successful, now will try to get some\n\
-variables. Some pointers may be invalid and cause dump abort\n");
+  fprintf(stderr, "Stack trace successful, tryint to get some variables.\n\
+Some pointers may be invalid and cause the dump to abort...\n");
   heap_start = __bss_start; 
   heap_end = (char*)sbrk(0);
   print_str("thd->query", thd->query, 1024);
   fprintf(stderr, "thd->thread_id = %ld\n", thd->thread_id);
-  fprintf(stderr, "successfully dumped variables, if you ran with --log\n \
+  fprintf(stderr, "Successfully dumped variables, if you ran with --log,\n\
 take a look at the details of what thread %ld did to cause the crash.\n\
-In some cases of really bad corruption, this value can be invalid \n",
+In some cases of really bad corruption, this value may be invalid\n",
 	  thd->thread_id);
   fprintf(stderr, "Please use the information above to create a repeatable\n\
 test case for the crash, and send it to bugs@lists.mysql.com\n");
@@ -1187,7 +1187,7 @@ static sig_handler handle_segfault(int sig)
 mysqld got signal %d;\n\
 The manual section 'Debugging a MySQL server' tells you how to use a\n\
 stack trace and/or the core file to produce a readable backtrace that may\n\
-help in finding out why mysqld died\n",sig);
+help in finding out why mysqld died.\n",sig);
 #if defined(HAVE_LINUXTHREADS)
 #ifdef __i386__
   trace_stack();
@@ -1676,13 +1676,14 @@ int main(int argc, char **argv)
 #ifdef EXTRA_DEBUG
     case 1:
       sql_print_error("\
-Warning: one should set server-id to a non-0 value if log-bin is enabled.\n\
-mysqld log updates to binary log, but will not accept connections from slaves.");
+Warning: You should set server-id to a non-0 value if log-bin is enabled.\n\
+mysqld will log updates to the binary log, but will not accept connections\n\
+from slaves.");
       break;
 #endif
     case 2:
       sql_print_error("\
-Warning: one should set server-id to a non-0 value if master_host is set.\n\
+Warning: You should set server-id to a non-0 value if master_host is set.\n\
 The server will not act as a slave.");
       break;
     }
@@ -2019,7 +2020,7 @@ static void create_new_thread(THD *thd)
   /* don't allow too many connections */
   if (thread_count - delayed_insert_threads >= max_connections+1 || abort_loop)
   {
-    DBUG_PRINT("error",("too many connections"));
+    DBUG_PRINT("error",("Too many connections"));
     close_connection(net,ER_CON_COUNT_ERROR);
     delete thd;
     DBUG_VOID_RETURN;
@@ -2372,43 +2373,48 @@ pthread_handler_decl(handle_connections_namedpipes,arg)
 ******************************************************************************/
 
 enum options {
-               OPT_ISAM_LOG=256,         OPT_SKIP_NEW, 
-               OPT_SKIP_GRANT,           OPT_SKIP_LOCK, 
-               OPT_ENABLE_LOCK,          OPT_USE_LOCKING,
-               OPT_SOCKET,               OPT_UPDATE_LOG, 
-               OPT_BIN_LOG,              OPT_SKIP_RESOLVE, 
-               OPT_SKIP_NETWORKING,      OPT_BIN_LOG_INDEX,
-               OPT_BIND_ADDRESS,         OPT_PID_FILE,
-               OPT_SKIP_PRIOR,           OPT_BIG_TABLES,    
-               OPT_STANDALONE,           OPT_ONE_THREAD,
-               OPT_CONSOLE,              OPT_LOW_PRIORITY_UPDATES,
-               OPT_SKIP_HOST_CACHE,      OPT_LONG_FORMAT,   
-               OPT_FLUSH,                OPT_SAFE, 
-               OPT_BOOTSTRAP,            OPT_SKIP_SHOW_DB,
-               OPT_TABLE_TYPE,           OPT_INIT_FILE,   
-               OPT_DELAY_KEY_WRITE,      OPT_SLOW_QUERY_LOG, 
-               OPT_SKIP_DELAY_KEY_WRITE, OPT_CHARSETS_DIR,
-               OPT_BDB_HOME,             OPT_BDB_LOG,  
-               OPT_BDB_TMP,              OPT_BDB_NOSYNC,
-               OPT_BDB_LOCK,             OPT_BDB_SKIP, 
-               OPT_BDB_NO_RECOVER,	 OPT_BDB_SHARED,
-	       OPT_MASTER_HOST,  
-               OPT_MASTER_USER,          OPT_MASTER_PASSWORD,
-               OPT_MASTER_PORT,          OPT_MASTER_INFO_FILE,
-               OPT_MASTER_CONNECT_RETRY, OPT_SQL_BIN_UPDATE_SAME,
-               OPT_REPLICATE_DO_DB,      OPT_REPLICATE_IGNORE_DB, 
-               OPT_LOG_SLAVE_UPDATES,    OPT_BINLOG_DO_DB, 
-               OPT_BINLOG_IGNORE_DB,     OPT_WANT_CORE,
-	       OPT_SKIP_CONCURRENT_INSERT, OPT_MEMLOCK, OPT_MYISAM_RECOVER,
-	       OPT_REPLICATE_REWRITE_DB, OPT_SERVER_ID, OPT_SKIP_SLAVE_START,
-	       OPT_SKIP_INNOBASE,OPT_SAFEMALLOC_MEM_LIMIT,
-	       OPT_REPLICATE_DO_TABLE, OPT_REPLICATE_IGNORE_TABLE,
-	       OPT_REPLICATE_WILD_DO_TABLE, OPT_REPLICATE_WILD_IGNORE_TABLE,
-	       OPT_DISCONNECT_SLAVE_EVENT_COUNT, OPT_ABORT_SLAVE_EVENT_COUNT,
-	       OPT_INNOBASE_DATA_HOME_DIR,OPT_INNOBASE_DATA_FILE_PATH,
-	       OPT_INNOBASE_LOG_GROUP_HOME_DIR,
-	       OPT_INNOBASE_LOG_ARCH_DIR, OPT_INNOBASE_LOG_ARCHIVE,
-	       OPT_INNOBASE_FLUSH_LOG_AT_TRX_COMMIT, OPT_SAFE_SHOW_DB,
+               OPT_ISAM_LOG=256,            OPT_SKIP_NEW, 
+               OPT_SKIP_GRANT,              OPT_SKIP_LOCK, 
+               OPT_ENABLE_LOCK,             OPT_USE_LOCKING,
+               OPT_SOCKET,                  OPT_UPDATE_LOG, 
+               OPT_BIN_LOG,                 OPT_SKIP_RESOLVE, 
+               OPT_SKIP_NETWORKING,         OPT_BIN_LOG_INDEX,
+               OPT_BIND_ADDRESS,            OPT_PID_FILE,
+               OPT_SKIP_PRIOR,              OPT_BIG_TABLES,    
+               OPT_STANDALONE,              OPT_ONE_THREAD,
+               OPT_CONSOLE,                 OPT_LOW_PRIORITY_UPDATES,
+               OPT_SKIP_HOST_CACHE,         OPT_LONG_FORMAT,   
+               OPT_FLUSH,                   OPT_SAFE, 
+               OPT_BOOTSTRAP,               OPT_SKIP_SHOW_DB,
+               OPT_TABLE_TYPE,              OPT_INIT_FILE,   
+               OPT_DELAY_KEY_WRITE,         OPT_SLOW_QUERY_LOG, 
+               OPT_SKIP_DELAY_KEY_WRITE,    OPT_CHARSETS_DIR,
+               OPT_BDB_HOME,                OPT_BDB_LOG,  
+               OPT_BDB_TMP,                 OPT_BDB_NOSYNC,
+               OPT_BDB_LOCK,                OPT_BDB_SKIP, 
+               OPT_BDB_NO_RECOVER,	    OPT_BDB_SHARED,
+	       OPT_MASTER_HOST,             OPT_MASTER_USER,
+               OPT_MASTER_PASSWORD,         OPT_MASTER_PORT,
+               OPT_MASTER_INFO_FILE,        OPT_MASTER_CONNECT_RETRY,
+               OPT_SQL_BIN_UPDATE_SAME,     OPT_REPLICATE_DO_DB,      
+               OPT_REPLICATE_IGNORE_DB,     OPT_LOG_SLAVE_UPDATES,
+               OPT_BINLOG_DO_DB,            OPT_BINLOG_IGNORE_DB,
+               OPT_WANT_CORE,               OPT_SKIP_CONCURRENT_INSERT,
+               OPT_MEMLOCK,                 OPT_MYISAM_RECOVER,
+               OPT_REPLICATE_REWRITE_DB,    OPT_SERVER_ID, 
+               OPT_SKIP_SLAVE_START,        OPT_SKIP_INNOBASE,
+               OPT_SAFEMALLOC_MEM_LIMIT,    OPT_REPLICATE_DO_TABLE, 
+               OPT_REPLICATE_IGNORE_TABLE,  OPT_REPLICATE_WILD_DO_TABLE, 
+               OPT_REPLICATE_WILD_IGNORE_TABLE, 
+               OPT_DISCONNECT_SLAVE_EVENT_COUNT, 
+               OPT_ABORT_SLAVE_EVENT_COUNT,
+	       OPT_INNOBASE_DATA_HOME_DIR,
+               OPT_INNOBASE_DATA_FILE_PATH,
+	       OPT_INNOBASE_LOG_GROUP_HOME_DIR, 
+               OPT_INNOBASE_LOG_ARCH_DIR, 
+               OPT_INNOBASE_LOG_ARCHIVE, 
+               OPT_INNOBASE_FLUSH_LOG_AT_TRX_COMMIT, 
+               OPT_SAFE_SHOW_DB,
 	       OPT_GEMINI_SKIP, OPT_INNOBASE_SKIP,
                OPT_TEMP_POOL
 };
@@ -2527,7 +2533,7 @@ static struct option long_options[] = {
   {"skip-name-resolve",     no_argument,       0, (int) OPT_SKIP_RESOLVE},
   {"skip-new",              no_argument,       0, (int) OPT_SKIP_NEW},
   {"skip-show-database",    no_argument,       0, (int) OPT_SKIP_SHOW_DB},
-  {"skip-slave-start",    no_argument,       0, (int) OPT_SKIP_SLAVE_START},
+  {"skip-slave-start",      no_argument,       0, (int) OPT_SKIP_SLAVE_START},
   {"skip-networking",       no_argument,       0, (int) OPT_SKIP_NETWORKING},
   {"skip-thread-priority",  no_argument,       0, (int) OPT_SKIP_PRIOR},
   {"sql-bin-update-same",   no_argument,       0, (int) OPT_SQL_BIN_UPDATE_SAME},
@@ -2560,11 +2566,11 @@ CHANGEABLE_VAR changeable_vars[] = {
   { "bdb_lock_max",            (long*) &berkeley_max_lock, 
       10000, 0, (long) ~0, 0, 1 },
 #endif
-  { "binlog_cache_size", 	(long*) &binlog_cache_size,
+  { "binlog_cache_size",       (long*) &binlog_cache_size,
       32*1024L, IO_SIZE, ~0L, 0, IO_SIZE },
   { "connect_timeout",         (long*) &connect_timeout,
       CONNECT_TIMEOUT, 2, 65535, 0, 1 },
-  { "delayed_insert_timeout", (long*) &delayed_insert_timeout, 
+  { "delayed_insert_timeout",  (long*) &delayed_insert_timeout, 
       DELAYED_WAIT_TIMEOUT, 1, ~0L, 0, 1 },
   { "delayed_insert_limit",    (long*) &delayed_insert_limit, 
       DELAYED_LIMIT, 1, ~0L, 0, 1 },
@@ -2609,7 +2615,7 @@ CHANGEABLE_VAR changeable_vars[] = {
       1024*1024L, 80, 64*1024*1024L, MALLOC_OVERHEAD, 1024 },
   { "max_binlog_cache_size",   (long*) &max_binlog_cache_size,
       ~0L, IO_SIZE, ~0L, 0, IO_SIZE },
-  { "max_binlog_size",           (long*) &max_binlog_size,
+  { "max_binlog_size",         (long*) &max_binlog_size,
       1024*1024L*1024L, 1024, 1024*1024L*1024L, 0, 1 },
   { "max_connections",         (long*) &max_connections,
       100, 1, 16384, 0, 1 },
@@ -3180,7 +3186,7 @@ static void get_options(int argc,char **argv)
 	if (!p)
 	  {
 	    fprintf(stderr,
-		    "bad syntax in replicate-rewrite-db - missing ->\n");
+		    "Bad syntax in replicate-rewrite-db - missing '->'!\n");
 	    exit(1);
 	  }
 	val = p--;
@@ -3188,7 +3194,7 @@ static void get_options(int argc,char **argv)
 	if(p == optarg)
 	  {
 	    fprintf(stderr,
-		    "bad syntax in replicate-rewrite-db - empty FROM db\n");
+		    "Bad syntax in replicate-rewrite-db - empty FROM db!\n");
 	    exit(1);
 	  }
 	*val = 0;
@@ -3197,7 +3203,7 @@ static void get_options(int argc,char **argv)
 	if (!*val)
 	  {
 	    fprintf(stderr,
-		    "bad syntax in replicate-rewrite-db - empty TO db\n");
+		    "Bad syntax in replicate-rewrite-db - empty TO db!\n");
 	    exit(1);
 	  }
 
@@ -3224,7 +3230,7 @@ static void get_options(int argc,char **argv)
 	  init_table_rule_hash(&replicate_do_table, &do_table_inited);
 	if(add_table_rule(&replicate_do_table, optarg))
 	  {
-	    fprintf(stderr, "could not add do table rule '%s'\n", optarg);
+	    fprintf(stderr, "Could not add do table rule '%s'!\n", optarg);
 	    exit(1);
 	  }
 	table_rules_on = 1;
@@ -3237,7 +3243,7 @@ static void get_options(int argc,char **argv)
 				&wild_do_table_inited);
 	if(add_wild_table_rule(&replicate_wild_do_table, optarg))
 	  {
-	    fprintf(stderr, "could not add do table rule '%s'\n", optarg);
+	    fprintf(stderr, "Could not add do table rule '%s'!\n", optarg);
 	    exit(1);
 	  }
 	table_rules_on = 1;
@@ -3250,7 +3256,7 @@ static void get_options(int argc,char **argv)
 				&wild_ignore_table_inited);
 	if(add_wild_table_rule(&replicate_wild_ignore_table, optarg))
 	  {
-	    fprintf(stderr, "could not add do table rule '%s'\n", optarg);
+	    fprintf(stderr, "Could not add ignore table rule '%s'!\n", optarg);
 	    exit(1);
 	  }
 	table_rules_on = 1;
@@ -3262,7 +3268,7 @@ static void get_options(int argc,char **argv)
 	  init_table_rule_hash(&replicate_ignore_table, &ignore_table_inited);
 	if(add_table_rule(&replicate_ignore_table, optarg))
 	  {
-	    fprintf(stderr, "could not add ignore table rule '%s'\n", optarg);
+	    fprintf(stderr, "Could not add ignore table rule '%s'!\n", optarg);
 	    exit(1);
 	  }
 	table_rules_on = 1;

sql/slave.cc

@@ -379,7 +379,7 @@ static int create_table_from_dump(THD* thd, NET* net, const char* db,
   check_opt.init();
   check_opt.flags|= T_VERY_SILENT;
   check_opt.quick = 1;
-  thd->proc_info = "rebuilding the index on master dump table";
+  thd->proc_info = "Rebuilding the index on master dump table";
   Vio* save_vio = thd->net.vio;
   // we do not want repair() to spam us with messages
   // just send them to the error log, and report the failure in case of
@@ -1027,7 +1027,7 @@ static int exec_event(THD* thd, NET* net, MASTER_INFO* mi, int event_len)
 	if(!sql_error)
 	  sql_error = ER_UNKNOWN_ERROR;
 		
-	sql_print_error("Slave:  error '%s' running load data infile ",
+	sql_print_error("Slave: Error '%s' running load data infile ",
 			ER(sql_error));
 	delete ev;
         free_root(&thd->mem_root,0);
@@ -1106,8 +1106,10 @@ static int exec_event(THD* thd, NET* net, MASTER_INFO* mi, int event_len)
   }
   else
   {
-    sql_print_error("Could not parse log event entry, check the master for binlog corruption\n\
- This may also be a network problem, or just a bug in the master or slave code");
+    sql_print_error("\
+Could not parse log event entry, check the master for binlog corruption\n\
+This may also be a network problem, or just a bug in the master or slave code.\
+");
     return 1;
   }
   return 0;	  
@@ -1173,7 +1175,7 @@ pthread_handler_decl(handle_slave,arg __attribute__((unused)))
     goto err;
   }
   
-  thd->proc_info = "connecting to master";
+  thd->proc_info = "Connecting to master";
 #ifndef DBUG_OFF  
   sql_print_error("Slave thread initialized");
 #endif
@@ -1189,14 +1191,14 @@ pthread_handler_decl(handle_slave,arg __attribute__((unused)))
   
   while (!slave_killed(thd))
   {
-      thd->proc_info = "requesting binlog dump";
+      thd->proc_info = "Requesting binlog dump";
       if(request_dump(mysql, &glob_mi))
 	{
 	  sql_print_error("Failed on request_dump()");
 	  if(slave_killed(thd))
            goto err;
 	  
-	  thd->proc_info = "waiting to reconnect after a failed dump request";
+	  thd->proc_info = "Waiting to reconnect after a failed dump request";
 	  if(mysql->net.vio)
 	    vio_close(mysql->net.vio);
 	  // first time retry immediately, assuming that we can recover
@@ -1210,7 +1212,7 @@ pthread_handler_decl(handle_slave,arg __attribute__((unused)))
 	  if(slave_killed(thd))
 	      goto err;
 
-	  thd->proc_info = "reconnecting after a failed dump request";
+	  thd->proc_info = "Reconnecting after a failed dump request";
           sql_print_error("Slave: failed dump request, reconnecting to \
 try again, log '%s' at postion %ld", RPL_LOG_NAME,
 			  last_failed_pos = glob_mi.pos );
@@ -1223,14 +1225,14 @@ try again, log '%s' at postion %ld", RPL_LOG_NAME,
 
       while(!slave_killed(thd))
 	{
-	  thd->proc_info = "reading master update";
+	  thd->proc_info = "Reading master update";
 	  uint event_len = read_event(mysql, &glob_mi);
 	  if(slave_killed(thd))
 	    goto err;
 	  
 	  if (event_len == packet_error)
 	  {
-	    thd->proc_info = "waiting to reconnect after a failed read";
+	    thd->proc_info = "Waiting to reconnect after a failed read";
 	    if(mysql->net.vio)
  	      vio_close(mysql->net.vio);
 	    if(retried_once) // punish repeat offender with sleep
@@ -1240,7 +1242,7 @@ try again, log '%s' at postion %ld", RPL_LOG_NAME,
 	    
 	    if(slave_killed(thd))
 	      goto err;
-	    thd->proc_info = "reconnecting after a failed read";
+	    thd->proc_info = "Reconnecting after a failed read";
 	    sql_print_error("Slave: Failed reading log event, \
 reconnecting to retry, log '%s' position %ld", RPL_LOG_NAME,
 			    last_failed_pos = glob_mi.pos);
@@ -1249,7 +1251,7 @@ reconnecting to retry, log '%s' position %ld", RPL_LOG_NAME,
 	    break;
 	  }
 	  
-	  thd->proc_info = "processing master log event"; 
+	  thd->proc_info = "Processing master log event"; 
 	  if(exec_event(thd, &mysql->net, &glob_mi, event_len))
 	    {
 	      sql_print_error("\
@@ -1303,7 +1305,7 @@ position %ld",
   thd->query = thd->db = 0; // extra safety
   if(mysql)
       mc_mysql_close(mysql);
-  thd->proc_info = "waiting for slave mutex on exit";
+  thd->proc_info = "Waiting for slave mutex on exit";
   pthread_mutex_lock(&LOCK_slave);
   slave_running = 0;
   abort_slave = 0;