Merge lp:~linuxjedi/drizzle/trunk-translation-bugs into lp:drizzle/7.0

[Andrew Hutchings]

Fix intl domain
Add intl domain for drizzledump
Fix boost::program_options translation output

=== modified file 'client/drizzle.cc'
--- client/drizzle.cc	2011-01-04 22:06:30 +0000
+++ client/drizzle.cc	2011-01-10 20:36:11 +0000
@@ -1280,122 +1280,122 @@
 # if defined(HAVE_LOCALE_H)
   setlocale(LC_ALL, "");
 # endif
-  bindtextdomain("drizzle", LOCALEDIR);
-  textdomain("drizzle");
+  bindtextdomain("drizzle7", LOCALEDIR);
+  textdomain("drizzle7");
 #endif
 
-  po::options_description commandline_options(N_("Options used only in command line"));
+  po::options_description commandline_options(_("Options used only in command line"));
   commandline_options.add_options()
-  ("help,?",N_("Displays this help and exit."))
-  ("batch,B",N_("Don't use history file. Disable interactive behavior. (Enables --silent)"))
+  ("help,?",_("Displays this help and exit."))
+  ("batch,B",_("Don't use history file. Disable interactive behavior. (Enables --silent)"))
   ("column-type-info", po::value<bool>(&column_types_flag)->default_value(false)->zero_tokens(),
-  N_("Display column type information."))
+  _("Display column type information."))
   ("comments,c", po::value<bool>(&preserve_comments)->default_value(false)->zero_tokens(),
-  N_("Preserve comments. Send comments to the server. The default is --skip-comments (discard comments), enable with --comments"))
+  _("Preserve comments. Send comments to the server. The default is --skip-comments (discard comments), enable with --comments"))
   ("vertical,E", po::value<bool>(&vertical)->default_value(false)->zero_tokens(),
-  N_("Print the output of a query (rows) vertically."))
+  _("Print the output of a query (rows) vertically."))
   ("force,f", po::value<bool>(&ignore_errors)->default_value(false)->zero_tokens(),
-  N_("Continue even if we get an sql error."))
+  _("Continue even if we get an sql error."))
   ("named-commands,G", po::value<bool>(&named_cmds)->default_value(false)->zero_tokens(),
-  N_("Enable named commands. Named commands mean this program's internal commands; see drizzle> help . When enabled, the named commands can be used from any line of the query, otherwise only from the first line, before an enter."))
+  _("Enable named commands. Named commands mean this program's internal commands; see drizzle> help . When enabled, the named commands can be used from any line of the query, otherwise only from the first line, before an enter."))
   ("no-beep,b", po::value<bool>(&opt_nobeep)->default_value(false)->zero_tokens(),
-  N_("Turn off beep on error."))
-  ("disable-line-numbers", N_("Do not write line numbers for errors."))
-  ("disable-column-names", N_("Do not write column names in results."))
+  _("Turn off beep on error."))
+  ("disable-line-numbers", _("Do not write line numbers for errors."))
+  ("disable-column-names", _("Do not write column names in results."))
   ("skip-column-names,N", 
-  N_("Don't write column names in results. WARNING: -N is deprecated, use long version of this options instead."))
+  _("Don't write column names in results. WARNING: -N is deprecated, use long version of this options instead."))
   ("set-variable,O", po::value<string>(),
-  N_("Change the value of a variable. Please note that this option is deprecated; you can set variables directly with --variable-name=value."))
+  _("Change the value of a variable. Please note that this option is deprecated; you can set variables directly with --variable-name=value."))
   ("table,t", po::value<bool>(&output_tables)->default_value(false)->zero_tokens(),
-  N_("Output in table format.")) 
+  _("Output in table format.")) 
   ("safe-updates,U", po::value<bool>(&safe_updates)->default_value(false)->zero_tokens(),
-  N_("Only allow UPDATE and DELETE that uses keys."))
+  _("Only allow UPDATE and DELETE that uses keys."))
   ("i-am-a-dummy,U", po::value<bool>(&safe_updates)->default_value(false)->zero_tokens(),
-  N_("Synonym for option --safe-updates, -U."))
+  _("Synonym for option --safe-updates, -U."))
   ("verbose,v", po::value<string>(&opt_verbose)->default_value(""),
-  N_("-v vvv implies that verbose= 3, Used to specify verbose"))
-  ("version,V", N_("Output version information and exit."))
+  _("-v vvv implies that verbose= 3, Used to specify verbose"))
+  ("version,V", _("Output version information and exit."))
   ("secure-auth", po::value<bool>(&opt_secure_auth)->default_value(false)->zero_tokens(),
-  N_("Refuse client connecting to server if it uses old (pre-4.1.1) protocol"))
+  _("Refuse client connecting to server if it uses old (pre-4.1.1) protocol"))
   ("show-warnings", po::value<bool>(&show_warnings)->default_value(false)->zero_tokens(),
-  N_("Show warnings after every statement."))
+  _("Show warnings after every statement."))
   ("show-progress-size", po::value<uint32_t>(&show_progress_size)->default_value(0),
-  N_("Number of lines before each import progress report."))
+  _("Number of lines before each import progress report."))
   ("ping", po::value<bool>(&opt_ping)->default_value(false)->zero_tokens(),
-  N_("Ping the server to check if it's alive."))
+  _("Ping the server to check if it's alive."))
   ("no-defaults", po::value<bool>()->default_value(false)->zero_tokens(),
-  N_("Configuration file defaults are not used if no-defaults is set"))
+  _("Configuration file defaults are not used if no-defaults is set"))
   ;
 
-  po::options_description drizzle_options(N_("Options specific to the drizzle client"));
+  po::options_description drizzle_options(_("Options specific to the drizzle client"));
   drizzle_options.add_options()
   ("disable-auto-rehash,A",
-  N_("Disable automatic rehashing. One doesn't need to use 'rehash' to get table and field completion, but startup and reconnecting may take a longer time."))
+  _("Disable automatic rehashing. One doesn't need to use 'rehash' to get table and field completion, but startup and reconnecting may take a longer time."))
   ("auto-vertical-output", po::value<bool>(&auto_vertical_output)->default_value(false)->zero_tokens(),
-  N_("Automatically switch to vertical output mode if the result is wider than the terminal width."))
+  _("Automatically switch to vertical output mode if the result is wider than the terminal width."))
   ("database,D", po::value<string>(&current_db)->default_value(""),
-  N_("Database to use."))
+  _("Database to use."))
   ("default-character-set",po::value<string>(),
-  N_("(not used)"))
+  _("(not used)"))
   ("delimiter", po::value<string>(&delimiter_str)->default_value(";"),
-  N_("Delimiter to be used."))
+  _("Delimiter to be used."))
   ("execute,e", po::value<string>(),
-  N_("Execute command and quit. (Disables --force and history file)"))
+  _("Execute command and quit. (Disables --force and history file)"))
   ("local-infile", po::value<bool>(&opt_local_infile)->default_value(false)->zero_tokens(),
-  N_("Enable LOAD DATA LOCAL INFILE."))
+  _("Enable LOAD DATA LOCAL INFILE."))
   ("unbuffered,n", po::value<bool>(&unbuffered)->default_value(false)->zero_tokens(),
-  N_("Flush buffer after each query."))
+  _("Flush buffer after each query."))
   ("sigint-ignore", po::value<bool>(&opt_sigint_ignore)->default_value(false)->zero_tokens(),
-  N_("Ignore SIGINT (CTRL-C)"))
+  _("Ignore SIGINT (CTRL-C)"))
   ("one-database,o", po::value<bool>(&one_database)->default_value(false)->zero_tokens(),
-  N_("Only update the default database. This is useful for skipping updates to other database in the update log."))
+  _("Only update the default database. This is useful for skipping updates to other database in the update log."))
   ("pager", po::value<string>(),
-  N_("Pager to use to display results. If you don't supply an option the default pager is taken from your ENV variable PAGER. Valid pagers are less, more, cat [> filename], etc. See interactive help (\\h) also. This option does not work in batch mode. Disable with --disable-pager. This option is disabled by default."))
+  _("Pager to use to display results. If you don't supply an option the default pager is taken from your ENV variable PAGER. Valid pagers are less, more, cat [> filename], etc. See interactive help (\\h) also. This option does not work in batch mode. Disable with --disable-pager. This option is disabled by default."))
   ("disable-pager", po::value<bool>(&opt_nopager)->default_value(false)->zero_tokens(),
-  N_("Disable pager and print to stdout. See interactive help (\\h) also."))
+  _("Disable pager and print to stdout. See interactive help (\\h) also."))
   ("prompt", po::value<string>(&current_prompt)->default_value(""),  
-  N_("Set the drizzle prompt to this value."))
+  _("Set the drizzle prompt to this value."))
   ("quick,q", po::value<bool>(&quick)->default_value(false)->zero_tokens(),
-  N_("Don't cache result, print it row by row. This may slow down the server if the output is suspended. Doesn't use history file."))
+  _("Don't cache result, print it row by row. This may slow down the server if the output is suspended. Doesn't use history file."))
   ("raw,r", po::value<bool>(&opt_raw_data)->default_value(false)->zero_tokens(),
-  N_("Write fields without conversion. Used with --batch.")) 
-  ("disable-reconnect", N_("Do not reconnect if the connection is lost."))
+  _("Write fields without conversion. Used with --batch.")) 
+  ("disable-reconnect", _("Do not reconnect if the connection is lost."))
   ("shutdown", po::value<bool>()->zero_tokens(),
-  N_("Shutdown the server"))
-  ("silent,s", N_("Be more silent. Print results with a tab as separator, each row on new line."))
+  _("Shutdown the server"))
+  ("silent,s", _("Be more silent. Print results with a tab as separator, each row on new line."))
   ("tee", po::value<string>(),
-  N_("Append everything into outfile. See interactive help (\\h) also. Does not work in batch mode. Disable with --disable-tee. This option is disabled by default."))
+  _("Append everything into outfile. See interactive help (\\h) also. Does not work in batch mode. Disable with --disable-tee. This option is disabled by default."))
   ("disable-tee", po::value<bool>()->default_value(false)->zero_tokens(), 
-  N_("Disable outfile. See interactive help (\\h) also."))
+  _("Disable outfile. See interactive help (\\h) also."))
   ("connect-timeout", po::value<uint32_t>(&opt_connect_timeout)->default_value(0)->notifier(&check_timeout_value),
-  N_("Number of seconds before connection timeout."))
+  _("Number of seconds before connection timeout."))
   ("max-input-line", po::value<uint32_t>(&opt_max_input_line)->default_value(16*1024L*1024L)->notifier(&check_max_input_line),
-  N_("Max length of input line"))
+  _("Max length of input line"))
   ("select-limit", po::value<uint32_t>(&select_limit)->default_value(1000L),
-  N_("Automatic limit for SELECT when using --safe-updates"))
+  _("Automatic limit for SELECT when using --safe-updates"))
   ("max-join-size", po::value<uint32_t>(&max_join_size)->default_value(1000000L),
-  N_("Automatic limit for rows in a join when using --safe-updates"))
+  _("Automatic limit for rows in a join when using --safe-updates"))
   ;
 
-  po::options_description client_options(N_("Options specific to the client"));
+  po::options_description client_options(_("Options specific to the client"));
   client_options.add_options()
   ("host,h", po::value<string>(&current_host)->default_value("localhost"),
-  N_("Connect to host"))
+  _("Connect to host"))
   ("password,P", po::value<string>(&current_password)->default_value(PASSWORD_SENTINEL),
-  N_("Password to use when connecting to server. If password is not given it's asked from the tty."))
+  _("Password to use when connecting to server. If password is not given it's asked from the tty."))
   ("port,p", po::value<uint32_t>()->default_value(0),
-  N_("Port number to use for connection or 0 for default to, in order of preference, drizzle.cnf, $DRIZZLE_TCP_PORT, built-in default"))
+  _("Port number to use for connection or 0 for default to, in order of preference, drizzle.cnf, $DRIZZLE_TCP_PORT, built-in default"))
 #ifdef DRIZZLE_ADMIN_TOOL
   ("user,u", po::value<string>(&current_user)->default_value("root"),
 #else
   ("user,u", po::value<string>(&current_user)->default_value(""),
 #endif
-  N_("User for login if not current user."))
+  _("User for login if not current user."))
   ("protocol",po::value<string>(&opt_protocol)->default_value("mysql"),
-  N_("The protocol of connection (mysql or drizzle)."))
+  _("The protocol of connection (mysql or drizzle)."))
   ;
 
-  po::options_description long_options(N_("Allowed Options"));
+  po::options_description long_options(_("Allowed Options"));
   long_options.add(commandline_options).add(drizzle_options).add(client_options);
 
   std::string system_config_dir_drizzle(SYSCONFDIR); 
 
=== modified file 'client/drizzledump.cc'
--- client/drizzledump.cc	2010-12-06 12:40:05 +0000
+++ client/drizzledump.cc	2011-01-10 20:36:11 +0000
@@ -472,99 +472,107 @@
 {
   int exit_code;
 
-  po::options_description commandline_options(N_("Options used only in command line"));
+#if defined(ENABLE_NLS)
+# if defined(HAVE_LOCALE_H)
+  setlocale(LC_ALL, "");
+# endif
+  bindtextdomain("drizzle7", LOCALEDIR);
+  textdomain("drizzle7");
+#endif
+
+  po::options_description commandline_options(_("Options used only in command line"));
   commandline_options.add_options()
   ("all-databases,A", po::value<bool>(&opt_alldbs)->default_value(false)->zero_tokens(),
-  N_("Dump all the databases. This will be same as --databases with all databases selected."))
+  _("Dump all the databases. This will be same as --databases with all databases selected."))
   ("all-tablespaces,Y", po::value<bool>(&opt_alltspcs)->default_value(false)->zero_tokens(),
-  N_("Dump all the tablespaces."))
+  _("Dump all the tablespaces."))
   ("complete-insert,c", po::value<bool>(&opt_complete_insert)->default_value(false)->zero_tokens(),
-  N_("Use complete insert statements."))
+  _("Use complete insert statements."))
   ("flush-logs,F", po::value<bool>(&flush_logs)->default_value(false)->zero_tokens(),
-  N_("Flush logs file in server before starting dump. Note that if you dump many databases at once (using the option --databases= or --all-databases), the logs will be flushed for each database dumped. The exception is when using --lock-all-tables in this case the logs will be flushed only once, corresponding to the moment all tables are locked. So if you want your dump and the log flush to happen at the same exact moment you should use --lock-all-tables or --flush-logs"))
+  _("Flush logs file in server before starting dump. Note that if you dump many databases at once (using the option --databases= or --all-databases), the logs will be flushed for each database dumped. The exception is when using --lock-all-tables in this case the logs will be flushed only once, corresponding to the moment all tables are locked. So if you want your dump and the log flush to happen at the same exact moment you should use --lock-all-tables or --flush-logs"))
   ("force,f", po::value<bool>(&ignore_errors)->default_value(false)->zero_tokens(),
-  N_("Continue even if we get an sql-error."))
-  ("help,?", N_("Display this help message and exit."))
+  _("Continue even if we get an sql-error."))
+  ("help,?", _("Display this help message and exit."))
   ("lock-all-tables,x", po::value<bool>(&opt_lock_all_tables)->default_value(false)->zero_tokens(),
-  N_("Locks all tables across all databases. This is achieved by taking a global read lock for the duration of the whole dump. Automatically turns --single-transaction off."))
+  _("Locks all tables across all databases. This is achieved by taking a global read lock for the duration of the whole dump. Automatically turns --single-transaction off."))
   ("single-transaction", po::value<bool>(&opt_single_transaction)->default_value(false)->zero_tokens(),
-  N_("Creates a consistent snapshot by dumping all tables in a single transaction. Works ONLY for tables stored in storage engines which support multiversioning (currently only InnoDB does); the dump is NOT guaranteed to be consistent for other storage engines. While a --single-transaction dump is in process, to ensure a valid dump file (correct table contents), no other connection should use the following statements: ALTER TABLE, DROP TABLE, RENAME TABLE, TRUNCATE TABLE, as consistent snapshot is not isolated from them."))
+  _("Creates a consistent snapshot by dumping all tables in a single transaction. Works ONLY for tables stored in storage engines which support multiversioning (currently only InnoDB does); the dump is NOT guaranteed to be consistent for other storage engines. While a --single-transaction dump is in process, to ensure a valid dump file (correct table contents), no other connection should use the following statements: ALTER TABLE, DROP TABLE, RENAME TABLE, TRUNCATE TABLE, as consistent snapshot is not isolated from them."))
   ("skip-opt", 
-  N_("Disable --opt. Disables --add-drop-table, --add-locks, --create-options, ---extended-insert and --disable-keys."))    
-  ("tables", N_("Overrides option --databases (-B)."))
+  _("Disable --opt. Disables --add-drop-table, --add-locks, --create-options, ---extended-insert and --disable-keys."))    
+  ("tables", _("Overrides option --databases (-B)."))
   ("show-progress-size", po::value<uint32_t>(&show_progress_size)->default_value(10000),
-  N_("Number of rows before each output progress report (requires --verbose)."))
+  _("Number of rows before each output progress report (requires --verbose)."))
   ("verbose,v", po::value<bool>(&verbose)->default_value(false)->zero_tokens(),
-  N_("Print info about the various stages."))
-  ("version,V", N_("Output version information and exit."))
-  ("skip-comments", N_("Turn off Comments"))
-  ("skip-create", N_("Turn off create-options"))
-  ("skip-extended-insert", N_("Turn off extended-insert"))
-  ("skip-dump-date",N_( "Turn off dump date at the end of the output"))
-  ("no-defaults", N_("Do not read from the configuration files"))
+  _("Print info about the various stages."))
+  ("version,V", _("Output version information and exit."))
+  ("skip-comments", _("Turn off Comments"))
+  ("skip-create", _("Turn off create-options"))
+  ("skip-extended-insert", _("Turn off extended-insert"))
+  ("skip-dump-date", _( "Turn off dump date at the end of the output"))
+  ("no-defaults", _("Do not read from the configuration files"))
   ;
 
-  po::options_description dump_options(N_("Options specific to the drizzle client"));
+  po::options_description dump_options(_("Options specific to the drizzle client"));
   dump_options.add_options()
   ("add-drop-database", po::value<bool>(&opt_drop_database)->default_value(false)->zero_tokens(),
-  N_("Add a 'DROP DATABASE' before each create."))
-  ("skip-drop-table", N_("Do not add a 'drop table' before each create."))
+  _("Add a 'DROP DATABASE' before each create."))
+  ("skip-drop-table", _("Do not add a 'drop table' before each create."))
   ("compact", po::value<bool>(&opt_compact)->default_value(false)->zero_tokens(),
-  N_("Give less verbose output (useful for debugging). Disables structure comments and header/footer constructs.  Enables options --skip-add-drop-table --no-set-names --skip-disable-keys"))
+  _("Give less verbose output (useful for debugging). Disables structure comments and header/footer constructs.  Enables options --skip-add-drop-table --no-set-names --skip-disable-keys"))
   ("databases,B", po::value<bool>(&opt_databases)->default_value(false)->zero_tokens(),
-  N_("To dump several databases. Note the difference in usage; In this case no tables are given. All name arguments are regarded as databasenames. 'USE db_name;' will be included in the output."))
+  _("To dump several databases. Note the difference in usage; In this case no tables are given. All name arguments are regarded as databasenames. 'USE db_name;' will be included in the output."))
   ("skip-disable-keys,K",
-  N_("'ALTER TABLE tb_name DISABLE KEYS; and 'ALTER TABLE tb_name ENABLE KEYS; will not be put in the output."))
+  _("'ALTER TABLE tb_name DISABLE KEYS;' and 'ALTER TABLE tb_name ENABLE KEYS;' will not be put in the output."))
   ("ignore-table", po::value<string>(),
-  N_("Do not dump the specified table. To specify more than one table to ignore, use the directive multiple times, once for each table.  Each table must be specified with both database and table names, e.g. --ignore-table=database.table"))
+  _("Do not dump the specified table. To specify more than one table to ignore, use the directive multiple times, once for each table.  Each table must be specified with both database and table names, e.g. --ignore-table=database.table"))
   ("insert-ignore", po::value<bool>(&opt_ignore)->default_value(false)->zero_tokens(),
-  N_("Insert rows with INSERT IGNORE."))
+  _("Insert rows with INSERT IGNORE."))
   ("no-autocommit", po::value<bool>(&opt_autocommit)->default_value(false)->zero_tokens(),
-  N_("Wrap a table's data in START TRANSACTION/COMMIT statements."))
+  _("Wrap a table's data in START TRANSACTION/COMMIT statements."))
   ("no-create-db,n", po::value<bool>(&opt_create_db)->default_value(false)->zero_tokens(),
-  N_("'CREATE DATABASE IF NOT EXISTS db_name;' will not be put in the output. The above line will be added otherwise, if --databases or --all-databases option was given."))
+  _("'CREATE DATABASE IF NOT EXISTS db_name;' will not be put in the output. The above line will be added otherwise, if --databases or --all-databases option was given."))
   ("no-data,d", po::value<bool>(&opt_no_data)->default_value(false)->zero_tokens(),
-  N_("No row information."))
+  _("No row information."))
   ("replace", po::value<bool>(&opt_replace_into)->default_value(false)->zero_tokens(),
-  N_("Use REPLACE INTO instead of INSERT INTO."))
+  _("Use REPLACE INTO instead of INSERT INTO."))
   ("destination-type", po::value<string>()->default_value("stdout"),
-  N_("Where to send output to (stdout|database"))
+  _("Where to send output to (stdout|database"))
   ("destination-host", po::value<string>(&opt_destination_host)->default_value("localhost"),
-  N_("Hostname for destination db server (requires --destination-type=database)"))
+  _("Hostname for destination db server (requires --destination-type=database)"))
   ("destination-port", po::value<uint16_t>(&opt_destination_port)->default_value(4427),
-  N_("Port number for destination db server (requires --destination-type=database)"))
+  _("Port number for destination db server (requires --destination-type=database)"))
   ("destination-user", po::value<string>(&opt_destination_user),
-  N_("User name for destination db server (resquires --destination-type=database)"))
+  _("User name for destination db server (resquires --destination-type=database)"))
   ("destination-password", po::value<string>(&opt_destination_password),
-  N_("Password for destination db server (requires --destination-type=database)"))
+  _("Password for destination db server (requires --destination-type=database)"))
   ("destination-database", po::value<string>(&opt_destination_database),
-  N_("The database in the destination db server (requires --destination-type=database, not for use with --all-databases)"))
+  _("The database in the destination db server (requires --destination-type=database, not for use with --all-databases)"))
   ;
 
-  po::options_description client_options(N_("Options specific to the client"));
+  po::options_description client_options(_("Options specific to the client"));
   client_options.add_options()
   ("host,h", po::value<string>(&current_host)->default_value("localhost"),
-  N_("Connect to host."))
+  _("Connect to host."))
   ("password,P", po::value<string>(&password)->default_value(PASSWORD_SENTINEL),
-  N_("Password to use when connecting to server. If password is not given it's solicited on the tty."))
+  _("Password to use when connecting to server. If password is not given it's solicited on the tty."))
   ("port,p", po::value<uint32_t>(&opt_drizzle_port)->default_value(0),
-  N_("Port number to use for connection."))
+  _("Port number to use for connection."))
   ("user,u", po::value<string>(&current_user)->default_value(""),
-  N_("User for login if not current user."))
+  _("User for login if not current user."))
   ("protocol",po::value<string>(&opt_protocol)->default_value("mysql"),
-  N_("The protocol of connection (mysql or drizzle)."))
+  _("The protocol of connection (mysql or drizzle)."))
   ;
 
-  po::options_description hidden_options(N_("Hidden Options"));
+  po::options_description hidden_options(_("Hidden Options"));
   hidden_options.add_options()
-  ("database-used", po::value<vector<string> >(), N_("Used to select the database"))
-  ("Table-used", po::value<vector<string> >(), N_("Used to select the tables"))
+  ("database-used", po::value<vector<string> >(), _("Used to select the database"))
+  ("Table-used", po::value<vector<string> >(), _("Used to select the tables"))
   ;
 
-  po::options_description all_options(N_("Allowed Options + Hidden Options"));
+  po::options_description all_options(_("Allowed Options + Hidden Options"));
   all_options.add(commandline_options).add(dump_options).add(client_options).add(hidden_options);
 
-  po::options_description long_options(N_("Allowed Options"));
+  po::options_description long_options(_("Allowed Options"));
   long_options.add(commandline_options).add(dump_options).add(client_options);
 
   std::string system_config_dir_dump(SYSCONFDIR); 
 
=== modified file 'drizzled/drizzled.cc'
--- drizzled/drizzled.cc	2010-12-30 17:09:51 +0000
+++ drizzled/drizzled.cc	2011-01-10 20:36:11 +0000
@@ -597,12 +597,12 @@
   initgroups((char*) user, user_info_arg->pw_gid);
   if (setgid(user_info_arg->pw_gid) == -1)
   {
-    sql_perror(N_("Set process group ID failed"));
+    sql_perror(_("Set process group ID failed"));
     unireg_abort(1);
   }
   if (setuid(user_info_arg->pw_uid) == -1)
   {
-    sql_perror(N_("Set process user ID failed"));
+    sql_perror(_("Set process user ID failed"));
     unireg_abort(1);
   }
 }
@@ -614,7 +614,7 @@
 {
   if ((chroot(path) == -1) || !chdir("/"))
   {
-    sql_perror(N_("Process chroot failed"));
+    sql_perror(_("Process chroot failed"));
     unireg_abort(1);
   }
 }
@@ -734,7 +734,7 @@
   global_system_variables.auto_increment_increment= 1;
   if (in_auto_increment_increment < 1 || in_auto_increment_increment > UINT64_MAX)
   {
-    cout << N_("Error: Invalid Value for auto_increment_increment");
+    cout << _("Error: Invalid Value for auto_increment_increment");
     exit(-1);
   }
   global_system_variables.auto_increment_increment= in_auto_increment_increment;
@@ -745,7 +745,7 @@
   global_system_variables.auto_increment_offset= 1;
   if (in_auto_increment_offset < 1 || in_auto_increment_offset > UINT64_MAX)
   {
-    cout << N_("Error: Invalid Value for auto_increment_offset");
+    cout << _("Error: Invalid Value for auto_increment_offset");
     exit(-1);
   }
   global_system_variables.auto_increment_offset= in_auto_increment_offset;
@@ -756,7 +756,7 @@
   global_system_variables.completion_type= 0;
   if (in_completion_type > 2)
   {
-    cout << N_("Error: Invalid Value for completion_type");
+    cout << _("Error: Invalid Value for completion_type");
     exit(-1);
   }
   global_system_variables.completion_type= in_completion_type;
@@ -768,7 +768,7 @@
   global_system_variables.div_precincrement= 4;
   if (in_div_precincrement > DECIMAL_MAX_SCALE)
   {
-    cout << N_("Error: Invalid Value for div-precision-increment");
+    cout << _("Error: Invalid Value for div-precision-increment");
     exit(-1);
   }
   global_system_variables.div_precincrement= in_div_precincrement;
@@ -779,7 +779,7 @@
   global_system_variables.group_concat_max_len= 1024;
   if (in_group_concat_max_len > ULONG_MAX || in_group_concat_max_len < 4)
   {
-    cout << N_("Error: Invalid Value for group_concat_max_len");
+    cout << _("Error: Invalid Value for group_concat_max_len");
     exit(-1);
   }
   global_system_variables.group_concat_max_len= in_group_concat_max_len;
@@ -790,7 +790,7 @@
   global_system_variables.join_buff_size= (128*1024L);
   if (in_join_buffer_size < IO_SIZE*2 || in_join_buffer_size > ULONG_MAX)
   {
-    cout << N_("Error: Invalid Value for join_buffer_size");
+    cout << _("Error: Invalid Value for join_buffer_size");
     exit(-1);
   }
   in_join_buffer_size-= in_join_buffer_size % IO_SIZE;
@@ -802,7 +802,7 @@
   global_system_variables.max_allowed_packet= (64*1024*1024L);
   if (in_max_allowed_packet < 1024 || in_max_allowed_packet > 1024*1024L*1024L)
   {
-    cout << N_("Error: Invalid Value for max_allowed_packet");
+    cout << _("Error: Invalid Value for max_allowed_packet");
     exit(-1);
   }
   in_max_allowed_packet-= in_max_allowed_packet % 1024;
@@ -814,7 +814,7 @@
   max_connect_errors= MAX_CONNECT_ERRORS;
   if (in_max_connect_errors < 1 || in_max_connect_errors > ULONG_MAX)
   {
-    cout << N_("Error: Invalid Value for max_connect_errors");
+    cout << _("Error: Invalid Value for max_connect_errors");
     exit(-1);
   }
   max_connect_errors= in_max_connect_errors;
@@ -825,7 +825,7 @@
   global_system_variables.max_error_count= DEFAULT_ERROR_COUNT;
   if (in_max_error_count > 65535)
   {
-    cout << N_("Error: Invalid Value for max_error_count");
+    cout << _("Error: Invalid Value for max_error_count");
     exit(-1);
   }
   global_system_variables.max_error_count= in_max_error_count;
@@ -836,7 +836,7 @@
   global_system_variables.max_heap_table_size= (16*1024*1024L);
   if (in_max_heap_table_size < 16384 || in_max_heap_table_size > MAX_MEM_TABLE_SIZE)
   {
-    cout << N_("Error: Invalid Value for max_heap_table_size");
+    cout << _("Error: Invalid Value for max_heap_table_size");
     exit(-1);
   }
   in_max_heap_table_size-= in_max_heap_table_size % 1024;
@@ -848,7 +848,7 @@
   global_system_variables.min_examined_row_limit= 0;
   if (in_min_examined_row_limit > ULONG_MAX)
   {
-    cout << N_("Error: Invalid Value for min_examined_row_limit");
+    cout << _("Error: Invalid Value for min_examined_row_limit");
     exit(-1);
   }
   global_system_variables.min_examined_row_limit= in_min_examined_row_limit;
@@ -859,7 +859,7 @@
   global_system_variables.max_join_size= INT32_MAX;
   if ((uint64_t)in_max_join_size < 1 || (uint64_t)in_max_join_size > INT32_MAX)
   {
-    cout << N_("Error: Invalid Value for max_join_size");
+    cout << _("Error: Invalid Value for max_join_size");
     exit(-1);
   }
   global_system_variables.max_join_size= in_max_join_size;
@@ -870,7 +870,7 @@
   global_system_variables.max_length_for_sort_data= 1024;
   if (in_max_length_for_sort_data < 4 || in_max_length_for_sort_data > 8192*1024L)
   {
-    cout << N_("Error: Invalid Value for max_length_for_sort_data");
+    cout << _("Error: Invalid Value for max_length_for_sort_data");
     exit(-1);
   }
   global_system_variables.max_length_for_sort_data= in_max_length_for_sort_data;
@@ -881,7 +881,7 @@
   global_system_variables.max_seeks_for_key= ULONG_MAX;
   if (in_max_seeks_for_key < 1 || in_max_seeks_for_key > ULONG_MAX)
   {
-    cout << N_("Error: Invalid Value for max_seeks_for_key");
+    cout << _("Error: Invalid Value for max_seeks_for_key");
     exit(-1);
   }
   global_system_variables.max_seeks_for_key= in_max_seeks_for_key;
@@ -892,7 +892,7 @@
   global_system_variables.max_sort_length= 1024;
   if ((int64_t)in_max_sort_length < 4 || (int64_t)in_max_sort_length > 8192*1024L)
   {
-    cout << N_("Error: Invalid Value for max_sort_length");
+    cout << _("Error: Invalid Value for max_sort_length");
     exit(-1);
   }
   global_system_variables.max_sort_length= in_max_sort_length;
@@ -903,7 +903,7 @@
   global_system_variables.optimizer_search_depth= 0;
   if (in_optimizer_search_depth > MAX_TABLES + 2)
   {
-    cout << N_("Error: Invalid Value for optimizer_search_depth");
+    cout << _("Error: Invalid Value for optimizer_search_depth");
     exit(-1);
   }
   global_system_variables.optimizer_search_depth= in_optimizer_search_depth;
@@ -914,7 +914,7 @@
   global_system_variables.preload_buff_size= (32*1024L);
   if (in_preload_buff_size < 1024 || in_preload_buff_size > 1024*1024*1024L)
   {
-    cout << N_("Error: Invalid Value for preload_buff_size");
+    cout << _("Error: Invalid Value for preload_buff_size");
     exit(-1);
   }
   global_system_variables.preload_buff_size= in_preload_buff_size;
@@ -925,7 +925,7 @@
   global_system_variables.query_alloc_block_size= QUERY_ALLOC_BLOCK_SIZE;
   if (in_query_alloc_block_size < 1024)
   {
-    cout << N_("Error: Invalid Value for query_alloc_block_size");
+    cout << _("Error: Invalid Value for query_alloc_block_size");
     exit(-1);
   }
   in_query_alloc_block_size-= in_query_alloc_block_size % 1024;
@@ -937,7 +937,7 @@
   global_system_variables.query_prealloc_size= QUERY_ALLOC_PREALLOC_SIZE;
   if (in_query_prealloc_size < QUERY_ALLOC_PREALLOC_SIZE)
   {
-    cout << N_("Error: Invalid Value for query_prealloc_size");
+    cout << _("Error: Invalid Value for query_prealloc_size");
     exit(-1);
   }
   in_query_prealloc_size-= in_query_prealloc_size % 1024;
@@ -949,7 +949,7 @@
   global_system_variables.range_alloc_block_size= RANGE_ALLOC_BLOCK_SIZE;
   if (in_range_alloc_block_size < RANGE_ALLOC_BLOCK_SIZE)
   {
-    cout << N_("Error: Invalid Value for range_alloc_block_size");
+    cout << _("Error: Invalid Value for range_alloc_block_size");
     exit(-1);
   }
   in_range_alloc_block_size-= in_range_alloc_block_size % 1024;
@@ -961,7 +961,7 @@
   global_system_variables.read_buff_size= (128*1024L);
   if (in_read_buff_size < IO_SIZE*2 || in_read_buff_size > INT32_MAX)
   {
-    cout << N_("Error: Invalid Value for read_buff_size");
+    cout << _("Error: Invalid Value for read_buff_size");
     exit(-1);
   }
   in_read_buff_size-= in_read_buff_size % IO_SIZE;
@@ -973,7 +973,7 @@
   global_system_variables.read_rnd_buff_size= (256*1024L);
   if (in_read_rnd_buff_size < 64 || in_read_rnd_buff_size > UINT32_MAX)
   {
-    cout << N_("Error: Invalid Value for read_rnd_buff_size");
+    cout << _("Error: Invalid Value for read_rnd_buff_size");
     exit(-1);
   }
   global_system_variables.read_rnd_buff_size= in_read_rnd_buff_size;
@@ -984,7 +984,7 @@
   global_system_variables.sortbuff_size= MAX_SORT_MEMORY;
   if ((uint32_t)in_sortbuff_size < MIN_SORT_MEMORY)
   {
-    cout << N_("Error: Invalid Value for sort_buff_size");
+    cout << _("Error: Invalid Value for sort_buff_size");
     exit(-1);
   }
   global_system_variables.sortbuff_size= in_sortbuff_size;
@@ -995,7 +995,7 @@
   table_def_size= 128;
   if (in_table_def_size < 1 || in_table_def_size > 512*1024L)
   {
-    cout << N_("Error: Invalid Value for table_def_size");
+    cout << _("Error: Invalid Value for table_def_size");
     exit(-1);
   }
   table_def_size= in_table_def_size;
@@ -1006,7 +1006,7 @@
   table_cache_size= TABLE_OPEN_CACHE_DEFAULT;
   if (in_table_cache_size < TABLE_OPEN_CACHE_MIN || in_table_cache_size > 512*1024L)
   {
-    cout << N_("Error: Invalid Value for table_cache_size");
+    cout << _("Error: Invalid Value for table_cache_size");
     exit(-1);
   }
   table_cache_size= in_table_cache_size;
@@ -1017,7 +1017,7 @@
   table_lock_wait_timeout= 50;
   if (in_table_lock_wait_timeout < 1 || in_table_lock_wait_timeout > 1024*1024*1024)
   {
-    cout << N_("Error: Invalid Value for table_lock_wait_timeout");
+    cout << _("Error: Invalid Value for table_lock_wait_timeout");
     exit(-1);
   }
   table_lock_wait_timeout= in_table_lock_wait_timeout;
@@ -1033,7 +1033,7 @@
   global_system_variables.tmp_table_size= 16*1024*1024L;
   if (in_tmp_table_size < 1024 || in_tmp_table_size > MAX_MEM_TABLE_SIZE)
   {
-    cout << N_("Error: Invalid Value for table_lock_wait_timeout");
+    cout << _("Error: Invalid Value for table_lock_wait_timeout");
     exit(-1);
   }
   global_system_variables.tmp_table_size= in_tmp_table_size;
@@ -1044,7 +1044,7 @@
   global_system_variables.transaction_message_threshold= 1024*1024;
   if ((int64_t) in_transaction_message_threshold < 128*1024 || (int64_t)in_transaction_message_threshold > 1024*1024)
   {
-    cout << N_("Error: Invalid Value for transaction_message_threshold valid values are between 131072 - 1048576 bytes");
+    cout << _("Error: Invalid Value for transaction_message_threshold valid values are between 131072 - 1048576 bytes");
     exit(-1);
   }
   global_system_variables.transaction_message_threshold= in_transaction_message_threshold;
@@ -1158,138 +1158,138 @@
 
   config_options.add_options()
   ("help,?", po::value<bool>(&opt_help)->default_value(false)->zero_tokens(),
-  N_("Display this help and exit."))
+  _("Display this help and exit."))
   ("no-defaults", po::value<bool>()->default_value(false)->zero_tokens(),
-  N_("Configuration file defaults are not used if no-defaults is set"))
+  _("Configuration file defaults are not used if no-defaults is set"))
   ("defaults-file", po::value<vector<string> >()->composing()->notifier(&compose_defaults_file_list),
-   N_("Configuration file to use"))
+  _("Configuration file to use"))
   ("config-dir", po::value<fs::path>(&system_config_dir),
-   N_("Base location for config files"))
+  _("Base location for config files"))
   ("plugin-dir", po::value<fs::path>(&plugin_dir)->notifier(&notify_plugin_dir),
-  N_("Directory for plugins."))
+  _("Directory for plugins."))
   ;
 
   plugin_load_options.add_options()
   ("plugin-add", po::value<vector<string> >()->composing()->notifier(&compose_plugin_add),
-  N_("Optional comma separated list of plugins to load at startup in addition "
+  _("Optional comma separated list of plugins to load at startup in addition "
      "to the default list of plugins. "
      "[for example: --plugin_add=crc32,logger_gearman]"))    
   ("plugin-remove", po::value<vector<string> >()->composing()->notifier(&compose_plugin_remove),
-  N_("Optional comma separated list of plugins to not load at startup. Effectively "
+  _("Optional comma separated list of plugins to not load at startup. Effectively "
      "removes a plugin from the list of plugins to be loaded. "
      "[for example: --plugin_remove=crc32,logger_gearman]"))
   ("plugin-load", po::value<string>()->notifier(&notify_plugin_load)->default_value(PANDORA_PLUGIN_LIST),
-  N_("Optional comma separated list of plugins to load at starup instead of "
+  _("Optional comma separated list of plugins to load at starup instead of "
      "the default plugin load list. "
      "[for example: --plugin_load=crc32,logger_gearman]"))
   ;
 
   long_options.add_options()
   ("auto-increment-increment", po::value<uint64_t>(&global_system_variables.auto_increment_increment)->default_value(1)->notifier(&check_limits_aii),
-  N_("Auto-increment columns are incremented by this"))
+  _("Auto-increment columns are incremented by this"))
   ("auto-increment-offset", po::value<uint64_t>(&global_system_variables.auto_increment_offset)->default_value(1)->notifier(&check_limits_aio),
-  N_("Offset added to Auto-increment columns. Used when auto-increment-increment != 1"))
+  _("Offset added to Auto-increment columns. Used when auto-increment-increment != 1"))
   ("basedir,b", po::value<fs::path>(&basedir),
-  N_("Path to installation directory. All paths are usually resolved "
+  _("Path to installation directory. All paths are usually resolved "
      "relative to this."))
   ("chroot,r", po::value<string>(),
-  N_("Chroot drizzled daemon during startup."))
+  _("Chroot drizzled daemon during startup."))
   ("collation-server", po::value<string>(),
-  N_("Set the default collation."))      
+  _("Set the default collation."))      
   ("completion-type", po::value<uint32_t>(&global_system_variables.completion_type)->default_value(0)->notifier(&check_limits_completion_type),
-  N_("Default completion type."))
-  ("core-file",  N_("Write core on errors."))
+  _("Default completion type."))
+  ("core-file",  _("Write core on errors."))
   ("datadir", po::value<fs::path>(&data_home),
-  N_("Path to the database root."))
+  _("Path to the database root."))
   ("default-storage-engine", po::value<string>(),
-  N_("Set the default storage engine for tables."))
+  _("Set the default storage engine for tables."))
   ("default-time-zone", po::value<string>(),
-  N_("Set the default time zone."))
+  _("Set the default time zone."))
   ("exit-info,T", po::value<long>(),
-  N_("Used for debugging;  Use at your own risk!"))
+  _("Used for debugging;  Use at your own risk!"))
   ("gdb", po::value<bool>(&opt_debugging)->default_value(false)->zero_tokens(),
-  N_("Set up signals usable for debugging"))
+  _("Set up signals usable for debugging"))
   ("lc-time-name", po::value<string>(),
-  N_("Set the language used for the month names and the days of the week."))
+  _("Set the language used for the month names and the days of the week."))
   ("log-warnings,W", po::value<bool>(&global_system_variables.log_warnings)->default_value(false)->zero_tokens(),
-  N_("Log some not critical warnings to the log file."))  
+  _("Log some not critical warnings to the log file."))  
   ("pid-file", po::value<fs::path>(&pid_file),
-  N_("Pid file used by drizzled."))
+  _("Pid file used by drizzled."))
   ("port-open-timeout", po::value<uint32_t>(&drizzled_bind_timeout)->default_value(0),
-  N_("Maximum time in seconds to wait for the port to become free. "))
+  _("Maximum time in seconds to wait for the port to become free. "))
   ("replicate-query", po::value<bool>(&global_system_variables.replicate_query)->default_value(false)->zero_tokens(),
-  N_("Include the SQL query in replicated protobuf messages."))
+  _("Include the SQL query in replicated protobuf messages."))
   ("secure-file-priv", po::value<fs::path>(&secure_file_priv)->notifier(expand_secure_file_priv),
-  N_("Limit LOAD DATA, SELECT ... OUTFILE, and LOAD_FILE() to files "
+  _("Limit LOAD DATA, SELECT ... OUTFILE, and LOAD_FILE() to files "
      "within specified directory"))
   ("server-id", po::value<uint32_t>(&server_id)->default_value(0),
-  N_("Uniquely identifies the server instance in the community of "
+  _("Uniquely identifies the server instance in the community of "
      "replication partners."))
   ("skip-stack-trace",  
-  N_("Don't print a stack trace on failure."))
+  _("Don't print a stack trace on failure."))
   ("symbolic-links,s", po::value<bool>(&internal::my_use_symdir)->default_value(IF_PURIFY(false,true))->zero_tokens(),
-  N_("Enable symbolic link support."))
+  _("Enable symbolic link support."))
   ("timed-mutexes", po::value<bool>(&internal::timed_mutexes)->default_value(false)->zero_tokens(),
-  N_("Specify whether to time mutexes (only InnoDB mutexes are currently "
+  _("Specify whether to time mutexes (only InnoDB mutexes are currently "
      "supported)")) 
   ("tmpdir,t", po::value<string>(),
-  N_("Path for temporary files."))
+  _("Path for temporary files."))
   ("transaction-isolation", po::value<string>(),
-  N_("Default transaction isolation level."))
+  _("Default transaction isolation level."))
   ("transaction-message-threshold", po::value<size_t>(&global_system_variables.transaction_message_threshold)->default_value(1024*1024)->notifier(&check_limits_transaction_message_threshold),
-  N_("Max message size written to transaction log, valid values 131072 - 1048576 bytes."))
+  _("Max message size written to transaction log, valid values 131072 - 1048576 bytes."))
   ("user,u", po::value<string>(),
-  N_("Run drizzled daemon as user."))  
+  _("Run drizzled daemon as user."))  
   ("version,V", 
-  N_("Output version information and exit."))
+  _("Output version information and exit."))
   ("back-log", po::value<back_log_constraints>(&back_log),
-  N_("The number of outstanding connection requests Drizzle can have. This "
+  _("The number of outstanding connection requests Drizzle can have. This "
      "comes into play when the main Drizzle thread gets very many connection "
      "requests in a very short time."))
   ("bulk-insert-buffer-size", 
   po::value<uint64_t>(&global_system_variables.bulk_insert_buff_size)->default_value(8192*1024),
-  N_("Size of tree cache used in bulk insert optimization. Note that this is "
+  _("Size of tree cache used in bulk insert optimization. Note that this is "
      "a limit per thread!"))
   ("div-precision-increment",  po::value<uint32_t>(&global_system_variables.div_precincrement)->default_value(4)->notifier(&check_limits_dpi),
-  N_("Precision of the result of '/' operator will be increased on that "
+  _("Precision of the result of '/' operator will be increased on that "
      "value."))
   ("group-concat-max-len", po::value<uint64_t>(&global_system_variables.group_concat_max_len)->default_value(1024)->notifier(&check_limits_gcml),
-  N_("The maximum length of the result of function  group_concat."))
+  _("The maximum length of the result of function  group_concat."))
   ("join-buffer-size", po::value<uint64_t>(&global_system_variables.join_buff_size)->default_value(128*1024L)->notifier(&check_limits_join_buffer_size),
-  N_("The size of the buffer that is used for full joins."))
+  _("The size of the buffer that is used for full joins."))
   ("join-heap-threshold",
   po::value<uint64_t>()->default_value(0),
-  N_("A global cap on the amount of memory that can be allocated by session join buffers (0 means unlimited)"))
+  _("A global cap on the amount of memory that can be allocated by session join buffers (0 means unlimited)"))
   ("max-allowed-packet", po::value<uint32_t>(&global_system_variables.max_allowed_packet)->default_value(64*1024*1024L)->notifier(&check_limits_map),
-  N_("Max packetlength to send/receive from to server."))
+  _("Max packetlength to send/receive from to server."))
   ("max-connect-errors", po::value<uint64_t>(&max_connect_errors)->default_value(MAX_CONNECT_ERRORS)->notifier(&check_limits_mce),
-  N_("If there is more than this number of interrupted connections from a "
+  _("If there is more than this number of interrupted connections from a "
      "host this host will be blocked from further connections."))
   ("max-error-count", po::value<uint64_t>(&global_system_variables.max_error_count)->default_value(DEFAULT_ERROR_COUNT)->notifier(&check_limits_max_err_cnt),
-  N_("Max number of errors/warnings to store for a statement."))
+  _("Max number of errors/warnings to store for a statement."))
   ("max-heap-table-size", po::value<uint64_t>(&global_system_variables.max_heap_table_size)->default_value(16*1024*1024L)->notifier(&check_limits_mhts),
-  N_("Don't allow creation of heap tables bigger than this."))
+  _("Don't allow creation of heap tables bigger than this."))
   ("max-join-size", po::value<drizzled::ha_rows>(&global_system_variables.max_join_size)->default_value(INT32_MAX)->notifier(&check_limits_max_join_size),
-  N_("Joins that are probably going to read more than max_join_size records "
+  _("Joins that are probably going to read more than max_join_size records "
      "return an error."))
   ("max-length-for-sort-data", po::value<uint64_t>(&global_system_variables.max_length_for_sort_data)->default_value(1024)->notifier(&check_limits_mlfsd),
-  N_("Max number of bytes in sorted records."))
+  _("Max number of bytes in sorted records."))
   ("max-seeks-for-key", po::value<uint64_t>(&global_system_variables.max_seeks_for_key)->default_value(ULONG_MAX)->notifier(&check_limits_msfk),
-  N_("Limit assumed max number of seeks when looking up rows based on a key"))
+  _("Limit assumed max number of seeks when looking up rows based on a key"))
   ("max-sort-length", po::value<size_t>(&global_system_variables.max_sort_length)->default_value(1024)->notifier(&check_limits_max_sort_length),  
-  N_("The number of bytes to use when sorting BLOB or TEXT values "
+  _("The number of bytes to use when sorting BLOB or TEXT values "
      "(only the first max_sort_length bytes of each value are used; the "
      "rest are ignored)."))
   ("max-write-lock-count", po::value<uint64_t>(&max_write_lock_count)->default_value(UINT64_MAX),
-  N_("After this many write locks, allow some read locks to run in between."))
+  _("After this many write locks, allow some read locks to run in between."))
   ("min-examined-row-limit", po::value<uint64_t>(&global_system_variables.min_examined_row_limit)->default_value(0)->notifier(&check_limits_merl),
-  N_("Don't log queries which examine less than min_examined_row_limit "
+  _("Don't log queries which examine less than min_examined_row_limit "
      "rows to file."))
   ("disable-optimizer-prune",
-  N_("Do not apply any heuristic(s) during query optimization to prune, "
+  _("Do not apply any heuristic(s) during query optimization to prune, "
      "thus perform an exhaustive search from the optimizer search space."))
   ("optimizer-search-depth", po::value<uint32_t>(&global_system_variables.optimizer_search_depth)->default_value(0)->notifier(&check_limits_osd),
-  N_("Maximum depth of search performed by the query optimizer. Values "
+  _("Maximum depth of search performed by the query optimizer. Values "
      "larger than the number of relations in a query result in better query "
      "plans, but take longer to compile a query. Smaller values than the "
      "number of tables in a relation result in faster optimization, but may "
@@ -1298,52 +1298,52 @@
      "optimizer will switch to the original find_best (used for "
      "testing/comparison)."))
   ("preload-buffer-size", po::value<uint64_t>(&global_system_variables.preload_buff_size)->default_value(32*1024L)->notifier(&check_limits_pbs),
-  N_("The size of the buffer that is allocated when preloading indexes"))
+  _("The size of the buffer that is allocated when preloading indexes"))
   ("query-alloc-block-size", 
   po::value<uint32_t>(&global_system_variables.query_alloc_block_size)->default_value(QUERY_ALLOC_BLOCK_SIZE)->notifier(&check_limits_qabs),
-  N_("Allocation block size for query parsing and execution"))
+  _("Allocation block size for query parsing and execution"))
   ("query-prealloc-size",
   po::value<uint32_t>(&global_system_variables.query_prealloc_size)->default_value(QUERY_ALLOC_PREALLOC_SIZE)->notifier(&check_limits_qps),
-  N_("Persistent buffer for query parsing and execution"))
+  _("Persistent buffer for query parsing and execution"))
   ("range-alloc-block-size",
   po::value<size_t>(&global_system_variables.range_alloc_block_size)->default_value(RANGE_ALLOC_BLOCK_SIZE)->notifier(&check_limits_rabs),
-  N_("Allocation block size for storing ranges during optimization"))
+  _("Allocation block size for storing ranges during optimization"))
   ("read-buffer-size",
   po::value<uint32_t>(&global_system_variables.read_buff_size)->default_value(128*1024L)->notifier(&check_limits_read_buffer_size),
-  N_("Each thread that does a sequential scan allocates a buffer of this "
+  _("Each thread that does a sequential scan allocates a buffer of this "
       "size for each table it scans. If you do many sequential scans, you may "
       "want to increase this value."))
   ("read-buffer-threshold",
   po::value<uint64_t>()->default_value(0),
-  N_("A global cap on the size of read-buffer-size (0 means unlimited)"))
+  _("A global cap on the size of read-buffer-size (0 means unlimited)"))
   ("read-rnd-buffer-size",
   po::value<uint32_t>(&global_system_variables.read_rnd_buff_size)->default_value(256*1024L)->notifier(&check_limits_read_rnd_buffer_size),
-  N_("When reading rows in sorted order after a sort, the rows are read "
+  _("When reading rows in sorted order after a sort, the rows are read "
      "through this buffer to avoid a disk seeks. If not set, then it's set "
      "to the value of record_buffer."))
   ("read-rnd-threshold",
   po::value<uint64_t>()->default_value(0),
-  N_("A global cap on the size of read-rnd-buffer-size (0 means unlimited)"))
+  _("A global cap on the size of read-rnd-buffer-size (0 means unlimited)"))
   ("scheduler", po::value<string>(),
-  N_("Select scheduler to be used (by default multi-thread)."))
+  _("Select scheduler to be used (by default multi-thread)."))
   ("sort-buffer-size",
   po::value<size_t>(&global_system_variables.sortbuff_size)->default_value(MAX_SORT_MEMORY)->notifier(&check_limits_sort_buffer_size),
-  N_("Each thread that needs to do a sort allocates a buffer of this size."))
+  _("Each thread that needs to do a sort allocates a buffer of this size."))
   ("sort-heap-threshold",
   po::value<uint64_t>()->default_value(0),
-  N_("A global cap on the amount of memory that can be allocated by session sort buffers (0 means unlimited)"))
+  _("A global cap on the amount of memory that can be allocated by session sort buffers (0 means unlimited)"))
   ("table-definition-cache", po::value<size_t>(&table_def_size)->default_value(128)->notifier(&check_limits_tdc),
-  N_("The number of cached table definitions."))
+  _("The number of cached table definitions."))
   ("table-open-cache", po::value<uint64_t>(&table_cache_size)->default_value(TABLE_OPEN_CACHE_DEFAULT)->notifier(&check_limits_toc),
-  N_("The number of cached open tables."))
+  _("The number of cached open tables."))
   ("table-lock-wait-timeout", po::value<uint64_t>(&table_lock_wait_timeout)->default_value(50)->notifier(&check_limits_tlwt),
-  N_("Timeout in seconds to wait for a table level lock before returning an "
+  _("Timeout in seconds to wait for a table level lock before returning an "
      "error. Used only if the connection has active cursors."))
   ("thread-stack", po::value<size_t>(&my_thread_stack_size)->default_value(DEFAULT_THREAD_STACK)->notifier(&check_limits_thread_stack),
-  N_("The stack size for each thread."))
+  _("The stack size for each thread."))
   ("tmp-table-size", 
   po::value<uint64_t>(&global_system_variables.tmp_table_size)->default_value(16*1024*1024L)->notifier(&check_limits_tmp_table_size),
-  N_("If an internal in-memory temporary table exceeds this size, Drizzle will"
+  _("If an internal in-memory temporary table exceeds this size, Drizzle will"
      " automatically convert it to an on-disk MyISAM table."))
   ;
 
@@ -2234,7 +2234,7 @@
       (vm["sort-heap-threshold"].as<uint64_t>() < 
       global_system_variables.sortbuff_size))
     {
-      cout << N_("Error: sort-heap-threshold cannot be less than sort-buffer-size") << endl;
+      cout << _("Error: sort-heap-threshold cannot be less than sort-buffer-size") << endl;
       exit(-1);
     }
 
@@ -2247,7 +2247,7 @@
       (vm["join-heap-threshold"].as<uint64_t>() <
       global_system_variables.join_buff_size))
     {
-      cout << N_("Error: join-heap-threshold cannot be less than join-buffer-size") << endl;
+      cout << _("Error: join-heap-threshold cannot be less than join-buffer-size") << endl;
       exit(-1);
     }
 
@@ -2260,7 +2260,7 @@
       (vm["read-rnd-threshold"].as<uint64_t>() <
       global_system_variables.read_rnd_buff_size))
     {
-      cout << N_("Error: read-rnd-threshold cannot be less than read-rnd-buffer-size") << endl;
+      cout << _("Error: read-rnd-threshold cannot be less than read-rnd-buffer-size") << endl;
       exit(-1);
     }
 
@@ -2273,7 +2273,7 @@
       (vm["read-buffer-threshold"].as<uint64_t>() <
       global_system_variables.read_buff_size))
     {
-      cout << N_("Error: read-buffer-threshold cannot be less than read-buffer-size") << endl;
+      cout << _("Error: read-buffer-threshold cannot be less than read-buffer-size") << endl;
       exit(-1);
     }
 
 
=== modified file 'drizzled/main.cc'
--- drizzled/main.cc	2010-12-30 15:27:27 +0000
+++ drizzled/main.cc	2011-01-10 20:36:11 +0000
@@ -221,8 +221,8 @@
 # if defined(HAVE_LOCALE_H)
   setlocale(LC_ALL, "");
 # endif
-  bindtextdomain("drizzle", LOCALEDIR);
-  textdomain("drizzle");
+  bindtextdomain("drizzle7", LOCALEDIR);
+  textdomain("drizzle7");
 #endif
 
   module::Registry &modules= module::Registry::singleton();
 
=== modified file 'plugin/logging_gearman/logging_gearman.cc'
--- plugin/logging_gearman/logging_gearman.cc	2011-01-01 03:24:09 +0000
+++ plugin/logging_gearman/logging_gearman.cc	2011-01-10 20:36:11 +0000
@@ -299,10 +299,10 @@
 {
   context("host",
           po::value<std::string>()->default_value("localhost"),
-          N_("Hostname for logging to a Gearman server"));
+          _("Hostname for logging to a Gearman server"));
   context("function",
           po::value<std::string>()->default_value("drizzlelog"),
-          N_("Gearman Function to send logging to"));
+          _("Gearman Function to send logging to"));
 }
 
 } /* namespace drizzle_plugin */
 
=== modified file 'plugin/logging_query/logging_query.cc'
--- plugin/logging_query/logging_query.cc	2010-12-31 21:25:11 +0000
+++ plugin/logging_query/logging_query.cc	2011-01-10 20:36:11 +0000
@@ -316,22 +316,22 @@
 {
   context("enable",
           po::value<bool>(&sysvar_logging_query_enable)->default_value(false)->zero_tokens(),
-          N_("Enable logging to CSV file"));
+          _("Enable logging to CSV file"));
   context("filename",
           po::value<string>(),
-          N_("File to log to"));
+          _("File to log to"));
   context("pcre",
           po::value<string>()->default_value(""),
-          N_("PCRE to match the query against"));
+          _("PCRE to match the query against"));
   context("threshold-slow",
           po::value<uint32_constraint>(&sysvar_logging_query_threshold_slow)->default_value(0),
-          N_("Threshold for logging slow queries, in microseconds"));
+          _("Threshold for logging slow queries, in microseconds"));
   context("threshold-big-resultset",
           po::value<uint32_constraint>(&sysvar_logging_query_threshold_big_resultset)->default_value(0),
-          N_("Threshold for logging big queries, for rows returned"));
+          _("Threshold for logging big queries, for rows returned"));
   context("threshold-big-examined",
           po::value<uint32_constraint>(&sysvar_logging_query_threshold_big_examined)->default_value(0),
-          N_("Threshold for logging big queries, for rows examined"));
+          _("Threshold for logging big queries, for rows examined"));
 }
 
 } /* namespace drizzle_plugin */
 
=== modified file 'plugin/logging_stats/logging_stats.cc'
--- plugin/logging_stats/logging_stats.cc	2011-01-01 01:54:09 +0000
+++ plugin/logging_stats/logging_stats.cc	2011-01-10 20:36:11 +0000
@@ -370,14 +370,14 @@
 {
   context("max-user-count",
           po::value<max_user_count_constraint>(&sysvar_logging_stats_max_user_count)->default_value(500),
-          N_("Max number of users that will be logged"));
+          _("Max number of users that will be logged"));
   context("bucket-count",
           po::value<bucket_count_constraint>(&sysvar_logging_stats_bucket_count)->default_value(10),
-          N_("Max number of range locks to use for Scoreboard"));
+          _("Max number of range locks to use for Scoreboard"));
   context("scoreboard-size",
           po::value<scoreboard_size_constraint>(&sysvar_logging_stats_scoreboard_size)->default_value(2000),
-          N_("Max number of concurrent sessions that will be logged"));
-  context("disable", N_("Enable Logging Statistics Collection"));
+          _("Max number of concurrent sessions that will be logged"));
+  context("disable", _("Enable Logging Statistics Collection"));
 }
 
 DRIZZLE_DECLARE_PLUGIN
 
=== modified file 'plugin/memcached_query_cache/memcached_qc.cc'
--- plugin/memcached_query_cache/memcached_qc.cc	2010-12-18 04:43:40 +0000
+++ plugin/memcached_query_cache/memcached_qc.cc	2011-01-10 20:36:11 +0000
@@ -385,13 +385,13 @@
 {
   context("servers",
           po::value<string>()->default_value("127.0.0.1:11211"),
-          N_("List of memcached servers."));
+          _("List of memcached servers."));
   context("expiry",
           po::value<uint64_constraint>(&expiry_time)->default_value(1000),
-          N_("Expiry time of memcached entries"));
+          _("Expiry time of memcached entries"));
   context("enable",
           po::value<bool>(&sysvar_memcached_qc_enable)->default_value(false)->zero_tokens(),
-          N_("Enable Memcached Query Cache"));
+          _("Enable Memcached Query Cache"));
 }
 
 DRIZZLE_DECLARE_PLUGIN
 
=== modified file 'plugin/memcached_stats/memcached_stats.cc'
--- plugin/memcached_stats/memcached_stats.cc	2010-12-18 04:43:40 +0000
+++ plugin/memcached_stats/memcached_stats.cc	2011-01-10 20:36:11 +0000
@@ -84,7 +84,7 @@
 {
   context("servers",
           po::value<std::string>()->default_value(""),
-          N_("List of memcached servers."));
+          _("List of memcached servers."));
 }
 
 } /* namespace drizzle_plugin */
 
=== modified file 'plugin/multi_thread/multi_thread.cc'
--- plugin/multi_thread/multi_thread.cc	2011-01-08 18:21:31 +0000
+++ plugin/multi_thread/multi_thread.cc	2011-01-10 20:36:11 +0000
@@ -208,7 +208,7 @@
 {
   context("max-threads",
           po::value<max_threads_constraint>(&max_threads)->default_value(2048),
-          N_("Maximum number of user threads available."));
+          _("Maximum number of user threads available."));
 }
 
 DRIZZLE_DECLARE_PLUGIN
 
=== modified file 'plugin/myisam/ha_myisam.cc'
--- plugin/myisam/ha_myisam.cc	2010-12-18 10:19:12 +0000
+++ plugin/myisam/ha_myisam.cc	2011-01-10 20:36:11 +0000
@@ -1503,10 +1503,10 @@
 {
   context("max-sort-file-size",
           po::value<uint64_t>(&max_sort_file_size)->default_value(INT32_MAX),
-          N_("Don't use the fast sort index method to created index if the temporary file would get bigger than this."));
+          _("Don't use the fast sort index method to created index if the temporary file would get bigger than this."));
   context("sort-buffer-size",
           po::value<sort_buffer_constraint>(&sort_buffer_size)->default_value(8192*1024),
-          N_("The buffer that is allocated when sorting the index when doing a REPAIR or when creating indexes with CREATE INDEX or ALTER TABLE."));
+          _("The buffer that is allocated when sorting the index when doing a REPAIR or when creating indexes with CREATE INDEX or ALTER TABLE."));
 }
 
 
 
=== modified file 'plugin/mysql_protocol/mysql_protocol.cc'
--- plugin/mysql_protocol/mysql_protocol.cc	2011-01-04 04:05:27 +0000
+++ plugin/mysql_protocol/mysql_protocol.cc	2011-01-10 20:36:11 +0000
@@ -1011,32 +1011,32 @@
 {
   context("port",
           po::value<port_constraint>(&port)->default_value(3306),
-          N_("Port number to use for connection or 0 for default to with MySQL "
+          _("Port number to use for connection or 0 for default to with MySQL "
                               "protocol."));
   context("connect-timeout",
           po::value<timeout_constraint>(&connect_timeout)->default_value(10),
-          N_("Connect Timeout."));
+          _("Connect Timeout."));
   context("read-timeout",
           po::value<timeout_constraint>(&read_timeout)->default_value(30),
-          N_("Read Timeout."));
+          _("Read Timeout."));
   context("write-timeout",
           po::value<timeout_constraint>(&write_timeout)->default_value(60),
-          N_("Write Timeout."));
+          _("Write Timeout."));
   context("retry-count",
           po::value<retry_constraint>(&retry_count)->default_value(10),
-          N_("Retry Count."));
+          _("Retry Count."));
   context("buffer-length",
           po::value<buffer_constraint>(&buffer_length)->default_value(16384),
-          N_("Buffer length."));
+          _("Buffer length."));
   context("bind-address",
           po::value<string>()->default_value(""),
-          N_("Address to bind to."));
+          _("Address to bind to."));
   context("max-connections",
           po::value<uint32_t>(&ListenMySQLProtocol::mysql_counters->max_connections)->default_value(1000),
-          N_("Maximum simultaneous connections."));
+          _("Maximum simultaneous connections."));
   context("admin-ip-addresses",
           po::value<vector<string> >()->composing()->notifier(&ClientMySQLProtocol::mysql_compose_ip_addresses),
-          N_("A restrictive IP address list for incoming admin connections."));
+          _("A restrictive IP address list for incoming admin connections."));
 }
 
 static int mysql_protocol_connection_count_func(drizzle_show_var *var, char *buff)
 
=== modified file 'plugin/mysql_unix_socket_protocol/protocol.cc'
--- plugin/mysql_unix_socket_protocol/protocol.cc	2010-12-13 14:34:37 +0000
+++ plugin/mysql_unix_socket_protocol/protocol.cc	2011-01-10 20:36:11 +0000
@@ -165,12 +165,12 @@
 {
   context("path",
           po::value<fs::path>()->default_value(DRIZZLE_UNIX_SOCKET_PATH),
-          N_("Path used for MySQL UNIX Socket Protocol."));
+          _("Path used for MySQL UNIX Socket Protocol."));
   context("clobber",
-          N_("Clobber socket file if one is there already."));
+          _("Clobber socket file if one is there already."));
   context("max-connections",
           po::value<uint32_t>(&Protocol::mysql_unix_counters->max_connections)->default_value(1000),
-          N_("Maximum simultaneous connections."));
+          _("Maximum simultaneous connections."));
 }
 
 } /* namespace mysql_unix_socket_protocol */
 
=== modified file 'plugin/pbms/src/parameters_ms.cc'
--- plugin/pbms/src/parameters_ms.cc	2010-12-18 04:43:40 +0000
+++ plugin/pbms/src/parameters_ms.cc	2011-01-10 20:36:11 +0000
@@ -423,42 +423,42 @@
 {
 	context("port",
                 po::value<port_constraint>(&pbms_port_number)->default_value(DEFAULT_PBMS_PORT),
-                N_("Port number to use for connection or 0 for default PBMS port "));
+                _("Port number to use for connection or 0 for default PBMS port "));
         context("repository-threshold",
                 po::value<std::string>(&my_repository_threshold)->default_value(MS_REPO_THRESHOLD_DEF),
-                N_("The maximum size of a BLOB repository file."));
+                _("The maximum size of a BLOB repository file."));
         context("temp-log-threshold",
                 po::value<std::string>(&my_temp_log_threshold)->default_value(MS_TEMP_LOG_THRESHOLD_DEF),
-                N_("The maximum size of a temorary BLOB log file."));
+                _("The maximum size of a temorary BLOB log file."));
         context("http-metadata-headers",
                 po::value<std::string>(&my_http_metadata_headers)->default_value(MS_HTTP_METADATA_HEADERS_DEF),
-                N_("A ':' delimited list of metadata header names to be used to initialize "
+                _("A ':' delimited list of metadata header names to be used to initialize "
                    "the pbms_metadata_header table when a database is created."));
         context("garbage-threshold",
                 po::value<percent_constraint>(&my_garbage_threshold)->default_value(MS_DEFAULT_GARBAGE_LEVEL),
-                N_("The percentage of garbage in a repository file before it is compacted."));
+                _("The percentage of garbage in a repository file before it is compacted."));
 	context("temp-blob-timeout",
 		po::value<uint32_nonzero_constraint>(&my_temp_blob_timeout)->default_value(MS_DEFAULT_TEMP_LOG_WAIT),
-		N_("The timeout, in seconds, for temporary BLOBs. Uploaded blob data is removed after this time, unless committed to the database."));
+		_("The timeout, in seconds, for temporary BLOBs. Uploaded blob data is removed after this time, unless committed to the database."));
 	context("max-keep-alive",
 		po::value<uint32_nonzero_constraint>(&my_temp_blob_timeout)->default_value(MS_DEFAULT_KEEP_ALIVE),
-		N_("The timeout, in milli-seconds, before the HTTP server will close an inactive HTTP connection."));
+		_("The timeout, in milli-seconds, before the HTTP server will close an inactive HTTP connection."));
 	context("next-backup-db-id",
 		po::value<uint32_nonzero_constraint>(&my_backup_db_id)->default_value(1),
-		N_("The next backup ID to use when backing up a PBMS database."));
+		_("The next backup ID to use when backing up a PBMS database."));
 	context("watch-tables",
 		po::value<std::string>(&my_table_list)->default_value("*"),
-		N_("A comma delimited list of tables to watch of the format: <database>.<table>, ..."));
+		_("A comma delimited list of tables to watch of the format: <database>.<table>, ..."));
 	context("watch-disable",
-		N_("Enable PBMS daemon Insert/Update/Delete event scanning"));
+		_("Enable PBMS daemon Insert/Update/Delete event scanning"));
 
 	context("before-insert-position",
 		po::value<before_position_constraint>(&my_before_insert_position)->default_value(1),
-		N_("Before insert row event observer call position"));
+		_("Before insert row event observer call position"));
 
 	context("before-update-position",
 		po::value<before_position_constraint>(&my_before_update_position)->default_value(1),
-		N_("Before update row event observer call position"));
+		_("Before update row event observer call position"));
 
 }
 #endif
 
=== modified file 'plugin/rabbitmq/rabbitmq_log.cc'
--- plugin/rabbitmq/rabbitmq_log.cc	2010-12-05 20:05:39 +0000
+++ plugin/rabbitmq/rabbitmq_log.cc	2011-01-10 20:36:11 +0000
@@ -152,28 +152,28 @@
 {
   context("host", 
           po::value<string>()->default_value("localhost"),
-          N_("Host name to connect to"));
+          _("Host name to connect to"));
   context("port",
           po::value<port_constraint>(&sysvar_rabbitmq_port)->default_value(5672),
-          N_("Port to connect to"));
+          _("Port to connect to"));
   context("virtualhost",
           po::value<string>()->default_value("/"),
-          N_("RabbitMQ virtualhost"));
+          _("RabbitMQ virtualhost"));
   context("username",
           po::value<string>()->default_value("guest"),
-          N_("RabbitMQ username"));
+          _("RabbitMQ username"));
   context("password",
           po::value<string>()->default_value("guest"),
-          N_("RabbitMQ password"));
+          _("RabbitMQ password"));
   context("use-replicator",
           po::value<string>()->default_value("default_replicator"),
-          N_("Name of the replicator plugin to use (default='default_replicator')"));
+          _("Name of the replicator plugin to use (default='default_replicator')"));
   context("exchange",
           po::value<string>()->default_value("ReplicationExchange"),
-          N_("Name of RabbitMQ exchange to publish to"));
+          _("Name of RabbitMQ exchange to publish to"));
   context("routingkey",
           po::value<string>()->default_value("ReplicationRoutingKey"),
-          N_("Name of RabbitMQ routing key to use"));
+          _("Name of RabbitMQ routing key to use"));
 }
 
 } /* namespace drizzle_plugin */
 
=== modified file 'plugin/syslog/module.cc'
--- plugin/syslog/module.cc	2010-12-03 19:56:07 +0000
+++ plugin/syslog/module.cc	2011-01-10 20:36:11 +0000
@@ -92,31 +92,31 @@
 {
   context("ident",
           po::value<string>()->default_value("drizzled"),
-          N_("Syslog Ident"));
+          _("Syslog Ident"));
   context("facility",
           po::value<string>()->default_value("local0"),
-          N_("Syslog Facility"));
+          _("Syslog Facility"));
   context("logging-enable",
           po::value<bool>(&sysvar_logging_enable)->default_value(false)->zero_tokens(),
-          N_("Enable logging to syslog of the query log"));
+          _("Enable logging to syslog of the query log"));
   context("logging-priority",
           po::value<string>()->default_value("warning"),
-          N_("Syslog Priority of query logging"));
+          _("Syslog Priority of query logging"));
   context("logging-threshold-slow",
           po::value<uint64_constraint>(&sysvar_logging_threshold_slow)->default_value(0),
-          N_("Threshold for logging slow queries, in microseconds"));
+          _("Threshold for logging slow queries, in microseconds"));
   context("logging-threshold-big-resultset",
           po::value<uint64_constraint>(&sysvar_logging_threshold_big_resultset)->default_value(0),
-          N_("Threshold for logging big queries, for rows returned"));
+          _("Threshold for logging big queries, for rows returned"));
   context("logging-threshold-big-examined",
           po::value<uint64_constraint>(&sysvar_logging_threshold_big_examined)->default_value(0),
-          N_("Threshold for logging big queries, for rows examined"));
+          _("Threshold for logging big queries, for rows examined"));
   context("errmsg-enable",
           po::value<bool>(&sysvar_errmsg_enable)->default_value(false)->zero_tokens(),
-          N_("Enable logging to syslog of the error messages"));
+          _("Enable logging to syslog of the error messages"));
   context("errmsg-priority",
           po::value<string>()->default_value("warning"),
-          N_("Syslog Priority of error messages"));
+          _("Syslog Priority of error messages"));
 }
 
 } /* namespace drizzle_plugin */
 
=== modified file 'plugin/transaction_log/module.cc'
--- plugin/transaction_log/module.cc	2010-12-18 04:43:40 +0000
+++ plugin/transaction_log/module.cc	2011-01-10 20:36:11 +0000
@@ -255,25 +255,25 @@
 {
   context("truncate-debug",
           po::value<bool>(&sysvar_transaction_log_truncate_debug)->default_value(false)->zero_tokens(),
-          N_("DEBUGGING - Truncate transaction log"));
+          _("DEBUGGING - Truncate transaction log"));
   context("enable-checksum",
           po::value<bool>(&sysvar_transaction_log_checksum_enabled)->default_value(false)->zero_tokens(),
-          N_("Enable CRC32 Checksumming of each written transaction log entry"));  
+          _("Enable CRC32 Checksumming of each written transaction log entry"));  
   context("enable",
           po::value<bool>(&sysvar_transaction_log_enabled)->default_value(false)->zero_tokens(),
-          N_("Enable transaction log"));
+          _("Enable transaction log"));
   context("file",
           po::value<string>(&sysvar_transaction_log_file)->default_value(DEFAULT_LOG_FILE_PATH),
-          N_("Path to the file to use for transaction log"));
+          _("Path to the file to use for transaction log"));
   context("use-replicator",
           po::value<string>(&sysvar_transaction_log_use_replicator)->default_value(DEFAULT_USE_REPLICATOR),
-          N_("Name of the replicator plugin to use (default='default_replicator')")); 
+          _("Name of the replicator plugin to use (default='default_replicator')")); 
   context("flush-frequency",
           po::value<flush_constraint>(&sysvar_transaction_log_flush_frequency)->default_value(0),
-          N_("0 == rely on operating system to sync log file (default), 1 == sync file at each transaction write, 2 == sync log file once per second"));
+          _("0 == rely on operating system to sync log file (default), 1 == sync file at each transaction write, 2 == sync log file once per second"));
   context("num-write-buffers",
           po::value<write_buffers_constraint>(&sysvar_transaction_log_num_write_buffers)->default_value(8),
-          N_("Number of slots for in-memory write buffers (default=8)."));
+          _("Number of slots for in-memory write buffers (default=8)."));
 }
 
 DRIZZLE_PLUGIN(init, NULL, init_options);
 
=== modified file 'plugin/transaction_log/utilities/transaction_reader.cc'
--- plugin/transaction_log/utilities/transaction_reader.cc	2010-12-18 04:43:40 +0000
+++ plugin/transaction_log/utilities/transaction_reader.cc	2011-01-10 20:36:11 +0000
@@ -469,30 +469,30 @@
    */
   po::options_description desc("Program options");
   desc.add_options()
-    ("help", N_("Display help and exit"))
-    ("use-innodb-replication-log", N_("Read from the innodb transaction log"))
+    ("help", _("Display help and exit"))
+    ("use-innodb-replication-log", _("Read from the innodb transaction log"))
     ("user,u", po::value<string>(&current_user)->default_value(""), 
-      N_("User for login if not current user."))
+      _("User for login if not current user."))
     ("port,p", po::value<uint32_t>(&opt_drizzle_port)->default_value(0), 
-      N_("Port number to use for connection."))
+      _("Port number to use for connection."))
     ("password,P", po::value<string>(&opt_password)->default_value(""), 
-      N_("Password to use when connecting to server"))
+      _("Password to use when connecting to server"))
     ("protocol",po::value<string>(&opt_protocol)->default_value("mysql"),
-      N_("The protocol of connection (mysql or drizzle)."))
-    ("checksum", N_("Perform checksum"))
-    ("ignore-events", N_("Ignore event messages"))
-    ("input-file", po::value< vector<string> >(), N_("Transaction log file"))
-    ("raw", N_("Print raw Protobuf messages instead of SQL"))
+      _("The protocol of connection (mysql or drizzle)."))
+    ("checksum", _("Perform checksum"))
+    ("ignore-events", _("Ignore event messages"))
+    ("input-file", po::value< vector<string> >(), _("Transaction log file"))
+    ("raw", _("Print raw Protobuf messages instead of SQL"))
     ("start-pos",
       po::value<int>(&opt_start_pos),
-      N_("Start reading from the given file position"))
+      _("Start reading from the given file position"))
     ("start-transaction-id",
       po::value<uint64_t>(&opt_start_transaction_id),
-      N_("Only output for the given transaction ID and later"))
+      _("Only output for the given transaction ID and later"))
     ("transaction-id",
       po::value<uint64_t>(&opt_transaction_id),
-      N_("Only output for the given transaction ID"))
-    ("summarize", N_("Summarize message contents"));
+      _("Only output for the given transaction ID"))
+    ("summarize", _("Summarize message contents"));
 
   /*
    * We allow one positional argument that will be transaction file name