← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/drizzle.cc

  • Committer: Brian Aker
  • Date: 2010-08-03 20:57:39 UTC
  • mfrom: (1680.6.4 rollup)
  • Revision ID: brian@gaz-20100803205739-7betgobkod41363k
Removes LOCK_system_variables_hash, one goto, drops internall new for std
new (so possible performance regression), fixes bug where Session was not
unlocked correctly.

Show diffs side-by-side

added added

removed removed

Lines of Context:
client/drizzle.cc
1
1
/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2010 Vijay Samuel
5
4
 *  Copyright (C) 2008 MySQL
6
5
 *
7
6
 *  This program is free software; you can redistribute it and/or modify
61
60
#include <cassert>
62
61
#include <stdarg.h>
63
62
#include <math.h>
64
 
#include <memory>
65
63
#include "client/linebuffer.h"
66
64
#include <signal.h>
67
65
#include <sys/ioctl.h>
159
157
#define vidattr(A) {}      // Can't get this to work
160
158
#endif
161
159
#include <boost/program_options.hpp>
162
 
#include <boost/scoped_ptr.hpp>
163
 
#include "drizzled/program_options/config_file.h"
164
160
 
165
161
using namespace std;
166
162
namespace po=boost::program_options;
167
 
namespace dpo=drizzled::program_options;
168
163
 
 
164
const string VER("14.14");
169
165
/* Don't try to make a nice table if the data is too big */
170
166
const uint32_t MAX_COLUMN_LENGTH= 1024;
171
167
 
180
176
 
181
177
  Status(int in_exit_status, 
182
178
         uint32_t in_query_start_line,
183
 
         char *in_file_name,
 
179
         char *in_file_name,
184
180
         LineBuffer *in_line_buff,
185
 
         bool in_batch,
186
 
         bool in_add_to_history)
 
181
         bool in_batch,
 
182
         bool in_add_to_history)
187
183
    :
188
184
    exit_status(in_exit_status),
189
185
    query_start_line(in_query_start_line),
193
189
    add_to_history(in_add_to_history)
194
190
    {}
195
191
 
196
 
  Status() :
197
 
    exit_status(0),
198
 
    query_start_line(0),
199
 
    file_name(NULL),
200
 
    line_buff(NULL),
201
 
    batch(false),        
202
 
    add_to_history(false)
203
 
  {}
 
192
  Status()
 
193
    :
 
194
    exit_status(),
 
195
    query_start_line(),
 
196
    file_name(),
 
197
    line_buff(),
 
198
    batch(),        
 
199
    add_to_history()
 
200
    {}
204
201
  
205
202
  int getExitStatus() const
206
203
  {
290
287
  connected= false, opt_raw_data= false, unbuffered= false,
291
288
  output_tables= false, opt_rehash= true, skip_updates= false,
292
289
  safe_updates= false, one_database= false,
293
 
  opt_shutdown= false, opt_ping= false,
 
290
  opt_compress= false, opt_shutdown= false, opt_ping= false,
294
291
  vertical= false, line_numbers= true, column_names= true,
295
292
  opt_nopager= true, opt_outfile= false, named_cmds= false,
296
293
  opt_nobeep= false, opt_reconnect= true,
298
295
  default_pager_set= false, opt_sigint_ignore= false,
299
296
  auto_vertical_output= false,
300
297
  show_warnings= false, executing_query= false, interrupted_query= false,
301
 
  use_drizzle_protocol= false, opt_local_infile;
 
298
  opt_mysql= false, opt_local_infile;
302
299
static uint32_t show_progress_size= 0;
303
300
static bool column_types_flag;
304
301
static bool preserve_comments= false;
323
320
  current_user,
324
321
  opt_verbose,
325
322
  current_password,
326
 
  opt_password,
327
 
  opt_protocol;
 
323
  opt_password;
328
324
// TODO: Need to i18n these
329
325
static const char *day_names[]= {"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
330
326
static const char *month_names[]= {"Jan","Feb","Mar","Apr","May","Jun","Jul",
341
337
static uint32_t delimiter_length= 1;
342
338
unsigned short terminal_width= 80;
343
339
 
344
 
int drizzleclient_real_query_for_lazy(const char *buf, size_t length,
 
340
int drizzleclient_real_query_for_lazy(const char *buf, int length,
345
341
                                      drizzle_result_st *result,
346
342
                                      uint32_t *error_code);
347
343
int drizzleclient_store_result_for_lazy(drizzle_result_st *result);
360
356
  com_help(string *str,const char*), com_clear(string *str,const char*),
361
357
  com_connect(string *str,const char*), com_status(string *str,const char*),
362
358
  com_use(string *str,const char*), com_source(string *str, const char*),
363
 
  com_shutdown(string *str,const char*),
364
359
  com_rehash(string *str, const char*), com_tee(string *str, const char*),
365
360
  com_notee(string *str, const char*),
366
361
  com_prompt(string *str, const char*), com_delimiter(string *str, const char*),
492
487
    N_("Set outfile [to_outfile]. Append everything into given outfile.") ),
493
488
  Commands( "use",    'u', com_use,    1,
494
489
    N_("Use another database. Takes database name as argument.") ),
495
 
  Commands( "shutdown",    'u', com_shutdown,    1,
496
 
    N_("Shutdown the instance you are connected too.") ),
497
490
  Commands( "warnings", 'W', com_warnings,  0,
498
491
    N_("Show warnings after every statement.") ),
499
492
  Commands( "nowarning", 'w', com_nowarnings, 0,
529
522
  Commands( "AUTO_INCREMENT", 0, 0, 0, ""),
530
523
  Commands( "AVG", 0, 0, 0, ""),
531
524
  Commands( "AVG_ROW_LENGTH", 0, 0, 0, ""),
 
525
  Commands( "BACKUP", 0, 0, 0, ""),
 
526
  Commands( "BDB", 0, 0, 0, ""),
532
527
  Commands( "BEFORE", 0, 0, 0, ""),
533
528
  Commands( "BEGIN", 0, 0, 0, ""),
 
529
  Commands( "BERKELEYDB", 0, 0, 0, ""),
534
530
  Commands( "BETWEEN", 0, 0, 0, ""),
535
531
  Commands( "BIGINT", 0, 0, 0, ""),
536
532
  Commands( "BINARY", 0, 0, 0, ""),
 
533
  Commands( "BINLOG", 0, 0, 0, ""),
537
534
  Commands( "BIT", 0, 0, 0, ""),
538
535
  Commands( "BLOB", 0, 0, 0, ""),
539
536
  Commands( "BOOL", 0, 0, 0, ""),
552
549
  Commands( "CHANGED", 0, 0, 0, ""),
553
550
  Commands( "CHAR", 0, 0, 0, ""),
554
551
  Commands( "CHARACTER", 0, 0, 0, ""),
 
552
  Commands( "CHARSET", 0, 0, 0, ""),
555
553
  Commands( "CHECK", 0, 0, 0, ""),
556
554
  Commands( "CHECKSUM", 0, 0, 0, ""),
 
555
  Commands( "CIPHER", 0, 0, 0, ""),
557
556
  Commands( "CLIENT", 0, 0, 0, ""),
558
557
  Commands( "CLOSE", 0, 0, 0, ""),
 
558
  Commands( "CODE", 0, 0, 0, ""),
559
559
  Commands( "COLLATE", 0, 0, 0, ""),
560
560
  Commands( "COLLATION", 0, 0, 0, ""),
561
561
  Commands( "COLUMN", 0, 0, 0, ""),
597
597
  Commands( "DEFAULT", 0, 0, 0, ""),
598
598
  Commands( "DEFINER", 0, 0, 0, ""),
599
599
  Commands( "DELAYED", 0, 0, 0, ""),
 
600
  Commands( "DELAY_KEY_WRITE", 0, 0, 0, ""),
600
601
  Commands( "DELETE", 0, 0, 0, ""),
601
602
  Commands( "DESC", 0, 0, 0, ""),
602
603
  Commands( "DESCRIBE", 0, 0, 0, ""),
 
604
  Commands( "DES_KEY_FILE", 0, 0, 0, ""),
603
605
  Commands( "DETERMINISTIC", 0, 0, 0, ""),
 
606
  Commands( "DIRECTORY", 0, 0, 0, ""),
604
607
  Commands( "DISABLE", 0, 0, 0, ""),
605
608
  Commands( "DISCARD", 0, 0, 0, ""),
606
609
  Commands( "DISTINCT", 0, 0, 0, ""),
607
610
  Commands( "DISTINCTROW", 0, 0, 0, ""),
608
611
  Commands( "DIV", 0, 0, 0, ""),
 
612
  Commands( "DO", 0, 0, 0, ""),
609
613
  Commands( "DOUBLE", 0, 0, 0, ""),
610
614
  Commands( "DROP", 0, 0, 0, ""),
 
615
  Commands( "DUAL", 0, 0, 0, ""),
611
616
  Commands( "DUMPFILE", 0, 0, 0, ""),
612
617
  Commands( "DUPLICATE", 0, 0, 0, ""),
613
618
  Commands( "DYNAMIC", 0, 0, 0, ""),
623
628
  Commands( "ERRORS", 0, 0, 0, ""),
624
629
  Commands( "ESCAPE", 0, 0, 0, ""),
625
630
  Commands( "ESCAPED", 0, 0, 0, ""),
 
631
  Commands( "EVENTS", 0, 0, 0, ""),
 
632
  Commands( "EXECUTE", 0, 0, 0, ""),
626
633
  Commands( "EXISTS", 0, 0, 0, ""),
627
634
  Commands( "EXIT", 0, 0, 0, ""),
 
635
  Commands( "EXPANSION", 0, 0, 0, ""),
628
636
  Commands( "EXPLAIN", 0, 0, 0, ""),
629
637
  Commands( "EXTENDED", 0, 0, 0, ""),
630
638
  Commands( "FALSE", 0, 0, 0, ""),
645
653
  Commands( "FRAC_SECOND", 0, 0, 0, ""),
646
654
  Commands( "FROM", 0, 0, 0, ""),
647
655
  Commands( "FULL", 0, 0, 0, ""),
 
656
  Commands( "FULLTEXT", 0, 0, 0, ""),
648
657
  Commands( "FUNCTION", 0, 0, 0, ""),
649
658
  Commands( "GLOBAL", 0, 0, 0, ""),
650
659
  Commands( "GRANT", 0, 0, 0, ""),
712
721
  Commands( "LOCKS", 0, 0, 0, ""),
713
722
  Commands( "LOGS", 0, 0, 0, ""),
714
723
  Commands( "LONG", 0, 0, 0, ""),
 
724
  Commands( "LONGTEXT", 0, 0, 0, ""),
715
725
  Commands( "LOOP", 0, 0, 0, ""),
 
726
  Commands( "LOW_PRIORITY", 0, 0, 0, ""),
 
727
  Commands( "MASTER", 0, 0, 0, ""),
 
728
  Commands( "MASTER_CONNECT_RETRY", 0, 0, 0, ""),
 
729
  Commands( "MASTER_HOST", 0, 0, 0, ""),
 
730
  Commands( "MASTER_LOG_FILE", 0, 0, 0, ""),
 
731
  Commands( "MASTER_LOG_POS", 0, 0, 0, ""),
 
732
  Commands( "MASTER_PASSWORD", 0, 0, 0, ""),
 
733
  Commands( "MASTER_PORT", 0, 0, 0, ""),
 
734
  Commands( "MASTER_SERVER_ID", 0, 0, 0, ""),
 
735
  Commands( "MASTER_SSL", 0, 0, 0, ""),
 
736
  Commands( "MASTER_SSL_CA", 0, 0, 0, ""),
 
737
  Commands( "MASTER_SSL_CAPATH", 0, 0, 0, ""),
 
738
  Commands( "MASTER_SSL_CERT", 0, 0, 0, ""),
 
739
  Commands( "MASTER_SSL_CIPHER", 0, 0, 0, ""),
 
740
  Commands( "MASTER_SSL_KEY", 0, 0, 0, ""),
 
741
  Commands( "MASTER_USER", 0, 0, 0, ""),
716
742
  Commands( "MATCH", 0, 0, 0, ""),
717
743
  Commands( "MAX_CONNECTIONS_PER_HOUR", 0, 0, 0, ""),
718
744
  Commands( "MAX_QUERIES_PER_HOUR", 0, 0, 0, ""),
720
746
  Commands( "MAX_UPDATES_PER_HOUR", 0, 0, 0, ""),
721
747
  Commands( "MAX_USER_CONNECTIONS", 0, 0, 0, ""),
722
748
  Commands( "MEDIUM", 0, 0, 0, ""),
 
749
  Commands( "MEDIUMTEXT", 0, 0, 0, ""),
723
750
  Commands( "MERGE", 0, 0, 0, ""),
724
751
  Commands( "MICROSECOND", 0, 0, 0, ""),
 
752
  Commands( "MIDDLEINT", 0, 0, 0, ""),
725
753
  Commands( "MIGRATE", 0, 0, 0, ""),
726
754
  Commands( "MINUTE", 0, 0, 0, ""),
727
755
  Commands( "MINUTE_MICROSECOND", 0, 0, 0, ""),
740
768
  Commands( "NAMES", 0, 0, 0, ""),
741
769
  Commands( "NATIONAL", 0, 0, 0, ""),
742
770
  Commands( "NATURAL", 0, 0, 0, ""),
 
771
  Commands( "NDB", 0, 0, 0, ""),
 
772
  Commands( "NDBCLUSTER", 0, 0, 0, ""),
743
773
  Commands( "NCHAR", 0, 0, 0, ""),
744
774
  Commands( "NEW", 0, 0, 0, ""),
745
775
  Commands( "NEXT", 0, 0, 0, ""),
746
776
  Commands( "NO", 0, 0, 0, ""),
747
777
  Commands( "NONE", 0, 0, 0, ""),
748
778
  Commands( "NOT", 0, 0, 0, ""),
 
779
  Commands( "NO_WRITE_TO_BINLOG", 0, 0, 0, ""),
749
780
  Commands( "NULL", 0, 0, 0, ""),
750
781
  Commands( "NUMERIC", 0, 0, 0, ""),
751
782
  Commands( "NVARCHAR", 0, 0, 0, ""),
752
783
  Commands( "OFFSET", 0, 0, 0, ""),
 
784
  Commands( "OLD_PASSWORD", 0, 0, 0, ""),
753
785
  Commands( "ON", 0, 0, 0, ""),
754
786
  Commands( "ONE", 0, 0, 0, ""),
755
787
  Commands( "ONE_SHOT", 0, 0, 0, ""),
766
798
  Commands( "PARTIAL", 0, 0, 0, ""),
767
799
  Commands( "PASSWORD", 0, 0, 0, ""),
768
800
  Commands( "PHASE", 0, 0, 0, ""),
 
801
  Commands( "POINT", 0, 0, 0, ""),
 
802
  Commands( "POLYGON", 0, 0, 0, ""),
769
803
  Commands( "PRECISION", 0, 0, 0, ""),
770
804
  Commands( "PREPARE", 0, 0, 0, ""),
771
805
  Commands( "PREV", 0, 0, 0, ""),
785
819
  Commands( "REDUNDANT", 0, 0, 0, ""),
786
820
  Commands( "REFERENCES", 0, 0, 0, ""),
787
821
  Commands( "REGEXP", 0, 0, 0, ""),
 
822
  Commands( "RELAY_LOG_FILE", 0, 0, 0, ""),
 
823
  Commands( "RELAY_LOG_POS", 0, 0, 0, ""),
 
824
  Commands( "RELAY_THREAD", 0, 0, 0, ""),
788
825
  Commands( "RELEASE", 0, 0, 0, ""),
789
826
  Commands( "RELOAD", 0, 0, 0, ""),
790
827
  Commands( "RENAME", 0, 0, 0, ""),
791
828
  Commands( "REPAIR", 0, 0, 0, ""),
792
829
  Commands( "REPEATABLE", 0, 0, 0, ""),
793
830
  Commands( "REPLACE", 0, 0, 0, ""),
 
831
  Commands( "REPLICATION", 0, 0, 0, ""),
794
832
  Commands( "REPEAT", 0, 0, 0, ""),
795
833
  Commands( "REQUIRE", 0, 0, 0, ""),
796
834
  Commands( "RESET", 0, 0, 0, ""),
829
867
  Commands( "SIMPLE", 0, 0, 0, ""),
830
868
  Commands( "SLAVE", 0, 0, 0, ""),
831
869
  Commands( "SNAPSHOT", 0, 0, 0, ""),
 
870
  Commands( "SMALLINT", 0, 0, 0, ""),
832
871
  Commands( "SOME", 0, 0, 0, ""),
833
872
  Commands( "SONAME", 0, 0, 0, ""),
834
873
  Commands( "SOUNDS", 0, 0, 0, ""),
877
916
  Commands( "TIMESTAMP", 0, 0, 0, ""),
878
917
  Commands( "TIMESTAMPADD", 0, 0, 0, ""),
879
918
  Commands( "TIMESTAMPDIFF", 0, 0, 0, ""),
 
919
  Commands( "TINYTEXT", 0, 0, 0, ""),
880
920
  Commands( "TO", 0, 0, 0, ""),
881
921
  Commands( "TRAILING", 0, 0, 0, ""),
882
922
  Commands( "TRANSACTION", 0, 0, 0, ""),
 
923
  Commands( "TRIGGER", 0, 0, 0, ""),
 
924
  Commands( "TRIGGERS", 0, 0, 0, ""),
883
925
  Commands( "TRUE", 0, 0, 0, ""),
884
926
  Commands( "TRUNCATE", 0, 0, 0, ""),
885
927
  Commands( "TYPE", 0, 0, 0, ""),
892
934
  Commands( "UNIQUE", 0, 0, 0, ""),
893
935
  Commands( "UNKNOWN", 0, 0, 0, ""),
894
936
  Commands( "UNLOCK", 0, 0, 0, ""),
 
937
  Commands( "UNSIGNED", 0, 0, 0, ""),
895
938
  Commands( "UNTIL", 0, 0, 0, ""),
896
939
  Commands( "UPDATE", 0, 0, 0, ""),
897
940
  Commands( "UPGRADE", 0, 0, 0, ""),
899
942
  Commands( "USE", 0, 0, 0, ""),
900
943
  Commands( "USER", 0, 0, 0, ""),
901
944
  Commands( "USER_RESOURCES", 0, 0, 0, ""),
 
945
  Commands( "USE_FRM", 0, 0, 0, ""),
902
946
  Commands( "USING", 0, 0, 0, ""),
903
947
  Commands( "UTC_DATE", 0, 0, 0, ""),
904
948
  Commands( "UTC_TIMESTAMP", 0, 0, 0, ""),
918
962
  Commands( "WITH", 0, 0, 0, ""),
919
963
  Commands( "WORK", 0, 0, 0, ""),
920
964
  Commands( "WRITE", 0, 0, 0, ""),
 
965
  Commands( "X509", 0, 0, 0, ""),
921
966
  Commands( "XOR", 0, 0, 0, ""),
922
967
  Commands( "XA", 0, 0, 0, ""),
923
968
  Commands( "YEAR", 0, 0, 0, ""),
926
971
  Commands( "ABS", 0, 0, 0, ""),
927
972
  Commands( "ACOS", 0, 0, 0, ""),
928
973
  Commands( "ADDDATE", 0, 0, 0, ""),
 
974
  Commands( "AES_ENCRYPT", 0, 0, 0, ""),
 
975
  Commands( "AES_DECRYPT", 0, 0, 0, ""),
929
976
  Commands( "AREA", 0, 0, 0, ""),
930
977
  Commands( "ASIN", 0, 0, 0, ""),
931
978
  Commands( "ASBINARY", 0, 0, 0, ""),
932
979
  Commands( "ASTEXT", 0, 0, 0, ""),
 
980
  Commands( "ASWKB", 0, 0, 0, ""),
 
981
  Commands( "ASWKT", 0, 0, 0, ""),
933
982
  Commands( "ATAN", 0, 0, 0, ""),
934
983
  Commands( "ATAN2", 0, 0, 0, ""),
935
984
  Commands( "BENCHMARK", 0, 0, 0, ""),
995
1044
  Commands( "GROUP_UNIQUE_USERS", 0, 0, 0, ""),
996
1045
  Commands( "HEX", 0, 0, 0, ""),
997
1046
  Commands( "IFNULL", 0, 0, 0, ""),
 
1047
  Commands( "INET_ATON", 0, 0, 0, ""),
 
1048
  Commands( "INET_NTOA", 0, 0, 0, ""),
998
1049
  Commands( "INSTR", 0, 0, 0, ""),
999
1050
  Commands( "INTERIORRINGN", 0, 0, 0, ""),
1000
1051
  Commands( "INTERSECTS", 0, 0, 0, ""),
1010
1061
  Commands( "LEAST", 0, 0, 0, ""),
1011
1062
  Commands( "LENGTH", 0, 0, 0, ""),
1012
1063
  Commands( "LN", 0, 0, 0, ""),
 
1064
  Commands( "LINEFROMTEXT", 0, 0, 0, ""),
 
1065
  Commands( "LINEFROMWKB", 0, 0, 0, ""),
 
1066
  Commands( "LINESTRINGFROMTEXT", 0, 0, 0, ""),
 
1067
  Commands( "LINESTRINGFROMWKB", 0, 0, 0, ""),
1013
1068
  Commands( "LOAD_FILE", 0, 0, 0, ""),
1014
1069
  Commands( "LOCATE", 0, 0, 0, ""),
1015
1070
  Commands( "LOG", 0, 0, 0, ""),
1032
1087
  Commands( "MD5", 0, 0, 0, ""),
1033
1088
  Commands( "MID", 0, 0, 0, ""),
1034
1089
  Commands( "MIN", 0, 0, 0, ""),
 
1090
  Commands( "MLINEFROMTEXT", 0, 0, 0, ""),
 
1091
  Commands( "MLINEFROMWKB", 0, 0, 0, ""),
 
1092
  Commands( "MPOINTFROMTEXT", 0, 0, 0, ""),
 
1093
  Commands( "MPOINTFROMWKB", 0, 0, 0, ""),
 
1094
  Commands( "MPOLYFROMTEXT", 0, 0, 0, ""),
 
1095
  Commands( "MPOLYFROMWKB", 0, 0, 0, ""),
1035
1096
  Commands( "MONTHNAME", 0, 0, 0, ""),
 
1097
  Commands( "MULTILINESTRINGFROMTEXT", 0, 0, 0, ""),
 
1098
  Commands( "MULTILINESTRINGFROMWKB", 0, 0, 0, ""),
 
1099
  Commands( "MULTIPOINTFROMTEXT", 0, 0, 0, ""),
 
1100
  Commands( "MULTIPOINTFROMWKB", 0, 0, 0, ""),
 
1101
  Commands( "MULTIPOLYGONFROMTEXT", 0, 0, 0, ""),
 
1102
  Commands( "MULTIPOLYGONFROMWKB", 0, 0, 0, ""),
1036
1103
  Commands( "NAME_CONST", 0, 0, 0, ""),
1037
1104
  Commands( "NOW", 0, 0, 0, ""),
1038
1105
  Commands( "NULLIF", 0, 0, 0, ""),
 
1106
  Commands( "NUMINTERIORRINGS", 0, 0, 0, ""),
1039
1107
  Commands( "NUMPOINTS", 0, 0, 0, ""),
1040
1108
  Commands( "OCTET_LENGTH", 0, 0, 0, ""),
1041
1109
  Commands( "OCT", 0, 0, 0, ""),
1044
1112
  Commands( "PERIOD_ADD", 0, 0, 0, ""),
1045
1113
  Commands( "PERIOD_DIFF", 0, 0, 0, ""),
1046
1114
  Commands( "PI", 0, 0, 0, ""),
 
1115
  Commands( "POINTFROMTEXT", 0, 0, 0, ""),
 
1116
  Commands( "POINTFROMWKB", 0, 0, 0, ""),
1047
1117
  Commands( "POINTN", 0, 0, 0, ""),
 
1118
  Commands( "POLYFROMTEXT", 0, 0, 0, ""),
 
1119
  Commands( "POLYFROMWKB", 0, 0, 0, ""),
 
1120
  Commands( "POLYGONFROMTEXT", 0, 0, 0, ""),
 
1121
  Commands( "POLYGONFROMWKB", 0, 0, 0, ""),
1048
1122
  Commands( "POSITION", 0, 0, 0, ""),
1049
1123
  Commands( "POW", 0, 0, 0, ""),
1050
1124
  Commands( "POWER", 0, 0, 0, ""),
1147
1221
 
1148
1222
  if (verbose)
1149
1223
  {
1150
 
    printf(_("shutting down drizzled"));
 
1224
    printf("shutting down drizzled");
1151
1225
    if (opt_drizzle_port > 0)
1152
 
      printf(_(" on port %d"), opt_drizzle_port);
 
1226
      printf(" on port %d", opt_drizzle_port);
1153
1227
    printf("... ");
1154
1228
  }
1155
1229
 
1158
1232
  {
1159
1233
    if (ret == DRIZZLE_RETURN_ERROR_CODE)
1160
1234
    {
1161
 
      fprintf(stderr, _("shutdown failed; error: '%s'"),
 
1235
      fprintf(stderr, "shutdown failed; error: '%s'",
1162
1236
              drizzle_result_error(&result));
1163
1237
      drizzle_result_free(&result);
1164
1238
    }
1165
1239
    else
1166
1240
    {
1167
 
      fprintf(stderr, _("shutdown failed; error: '%s'"),
 
1241
      fprintf(stderr, "shutdown failed; error: '%s'",
1168
1242
              drizzle_con_error(&con));
1169
1243
    }
1170
1244
    return false;
1173
1247
  drizzle_result_free(&result);
1174
1248
 
1175
1249
  if (verbose)
1176
 
    printf(_("done\n"));
 
1250
    printf("done\n");
1177
1251
 
1178
1252
  return true;
1179
1253
}
1194
1268
  if (drizzle_ping(&con, &result, &ret) != NULL && ret == DRIZZLE_RETURN_OK)
1195
1269
  {
1196
1270
    if (opt_silent < 2)
1197
 
      printf(_("drizzled is alive\n"));
 
1271
      printf("drizzled is alive\n");
1198
1272
  }
1199
1273
  else
1200
1274
  {
1201
1275
    if (ret == DRIZZLE_RETURN_ERROR_CODE)
1202
1276
    {
1203
 
      fprintf(stderr, _("ping failed; error: '%s'"),
 
1277
      fprintf(stderr, "ping failed; error: '%s'",
1204
1278
              drizzle_result_error(&result));
1205
1279
      drizzle_result_free(&result);
1206
1280
    }
1207
1281
    else
1208
1282
    {
1209
 
      fprintf(stderr, _("drizzled won't answer to ping, error: '%s'"),
 
1283
      fprintf(stderr, "drizzled won't answer to ping, error: '%s'",
1210
1284
              drizzle_con_error(&con));
1211
1285
    }
1212
1286
    return false;
1255
1329
  opt_connect_timeout= 0;
1256
1330
  if (in_connect_timeout > 3600*12)
1257
1331
  {
1258
 
    cout << _("Error: Invalid Value for connect_timeout"); 
 
1332
    cout<<N_("Error: Invalid Value for connect_timeout"); 
1259
1333
    exit(-1);
1260
1334
  }
1261
1335
  opt_connect_timeout= in_connect_timeout;
1264
1338
static void check_max_input_line(uint32_t in_max_input_line)
1265
1339
{
1266
1340
  opt_max_input_line= 0;
1267
 
  if (in_max_input_line < 4096 || in_max_input_line > (int64_t)2*1024L*1024L*1024L)
 
1341
  if (in_max_input_line<4096 || in_max_input_line>(int64_t)2*1024L*1024L*1024L)
1268
1342
  {
1269
 
    cout << _("Error: Invalid Value for max_input_line");
 
1343
    cout<<N_("Error: Invalid Value for max_input_line");
1270
1344
    exit(-1);
1271
1345
  }
1272
 
  opt_max_input_line= in_max_input_line - (in_max_input_line % 1024);
 
1346
  opt_max_input_line= in_max_input_line/1024;
 
1347
  opt_max_input_line*=1024;
1273
1348
}
1274
1349
 
1275
1350
int main(int argc,char *argv[])
1276
1351
{
1277
1352
try
1278
1353
{
1279
 
 
1280
1354
#if defined(ENABLE_NLS)
1281
1355
# if defined(HAVE_LOCALE_H)
1282
1356
  setlocale(LC_ALL, "");
1285
1359
  textdomain("drizzle");
1286
1360
#endif
1287
1361
 
1288
 
  po::options_description commandline_options(N_("Options used only in command line"));
 
1362
  po::options_description commandline_options("Options used only in command line");
1289
1363
  commandline_options.add_options()
1290
1364
  ("help,?",N_("Displays this help and exit."))
1291
1365
  ("batch,B",N_("Don't use history file. Disable interactive behavior. (Enables --silent)"))
1293
1367
  N_("Display column type information."))
1294
1368
  ("comments,c", po::value<bool>(&preserve_comments)->default_value(false)->zero_tokens(),
1295
1369
  N_("Preserve comments. Send comments to the server. The default is --skip-comments (discard comments), enable with --comments"))
 
1370
  ("compress,C", po::value<bool>(&opt_compress)->default_value(false)->zero_tokens(),
 
1371
  N_("Use compression in server/client protocol."))  
1296
1372
  ("vertical,E", po::value<bool>(&vertical)->default_value(false)->zero_tokens(),
1297
1373
  N_("Print the output of a query (rows) vertically."))
1298
1374
  ("force,f", po::value<bool>(&ignore_errors)->default_value(false)->zero_tokens(),
1299
1375
  N_("Continue even if we get an sql error."))
1300
1376
  ("named-commands,G", po::value<bool>(&named_cmds)->default_value(false)->zero_tokens(),
1301
 
  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."))
 
1377
  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. Disable with --disable-named-commands. This option is disabled by default."))
 
1378
  ("no-named-commands,g",
 
1379
  N_("Named commands are disabled. Use \\* form only, or use named commands only in the beginning of a line ending with a semicolon (;) Since version 10.9 the client now starts with this option ENABLED by default! Disable with '-G'. Long format commands still work from the first line. WARNING: option deprecated; use --disable-named-commands instead."))
 
1380
  ("ignore-spaces,i", N_("Ignore space after function names."))
1302
1381
  ("no-beep,b", po::value<bool>(&opt_nobeep)->default_value(false)->zero_tokens(),
1303
1382
  N_("Turn off beep on error."))
1304
 
  ("disable-line-numbers", N_("Do not write line numbers for errors."))
1305
 
  ("disable-column-names", N_("Do not write column names in results."))
 
1383
  ("line-numbers", po::value<bool>(&line_numbers)->default_value(true)->zero_tokens(),
 
1384
  N_("Write line numbers for errors."))
 
1385
  ("skip-line-numbers,L", 
 
1386
  N_("Don't write line number for errors. WARNING: -L is deprecated, use long version of this option instead."))
 
1387
  ("column-name", po::value<bool>(&column_names)->default_value(true)->zero_tokens(),
 
1388
  N_("Write column names in results."))
1306
1389
  ("skip-column-names,N", 
1307
1390
  N_("Don't write column names in results. WARNING: -N is deprecated, use long version of this options instead."))
1308
1391
  ("set-variable,O", po::value<string>(),
1309
1392
  N_("Change the value of a variable. Please note that this option is deprecated; you can set variables directly with --variable-name=value."))
1310
1393
  ("table,t", po::value<bool>(&output_tables)->default_value(false)->zero_tokens(),
1311
1394
  N_("Output in table format.")) 
1312
 
  ("safe-updates,U", po::value<bool>(&safe_updates)->default_value(false)->zero_tokens(),
 
1395
  ("safe-updates,U", po::value<bool>(&safe_updates)->default_value(0)->zero_tokens(),
1313
1396
  N_("Only allow UPDATE and DELETE that uses keys."))
1314
 
  ("i-am-a-dummy,U", po::value<bool>(&safe_updates)->default_value(false)->zero_tokens(),
 
1397
  ("i-am-a-dummy,U", po::value<bool>(&safe_updates)->default_value(0)->zero_tokens(),
1315
1398
  N_("Synonym for option --safe-updates, -U."))
1316
1399
  ("verbose,v", po::value<string>(&opt_verbose)->default_value(""),
1317
1400
  N_("-v vvv implies that verbose= 3, Used to specify verbose"))
1328
1411
  N_("Configuration file defaults are not used if no-defaults is set"))
1329
1412
  ;
1330
1413
 
1331
 
  po::options_description drizzle_options(N_("Options specific to the drizzle client"));
 
1414
  po::options_description drizzle_options("Options specific to the drizzle client");
1332
1415
  drizzle_options.add_options()
1333
 
  ("disable-auto-rehash,A",
1334
 
  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."))
 
1416
  ("auto-rehash", po::value<bool>(&opt_rehash)->default_value(true)->zero_tokens(),
 
1417
  N_("Enable 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 with --disable-auto-rehash."))
 
1418
  ("no-auto-rehash,A",N_("No automatic rehashing. One has to use 'rehash' to get table and field completion. This gives a quicker start of drizzle_st and disables rehashing on reconnect. WARNING: options deprecated; use --disable-auto-rehash instead."))
1335
1419
  ("auto-vertical-output", po::value<bool>(&auto_vertical_output)->default_value(false)->zero_tokens(),
1336
1420
  N_("Automatically switch to vertical output mode if the result is wider than the terminal width."))
1337
1421
  ("database,D", po::value<string>(&current_db)->default_value(""),
1343
1427
  ("execute,e", po::value<string>(),
1344
1428
  N_("Execute command and quit. (Disables --force and history file)"))
1345
1429
  ("local-infile", po::value<bool>(&opt_local_infile)->default_value(false)->zero_tokens(),
1346
 
  N_("Enable LOAD DATA LOCAL INFILE."))
 
1430
  N_("Enable/disable LOAD DATA LOCAL INFILE."))
1347
1431
  ("unbuffered,n", po::value<bool>(&unbuffered)->default_value(false)->zero_tokens(),
1348
1432
  N_("Flush buffer after each query."))
1349
1433
  ("sigint-ignore", po::value<bool>(&opt_sigint_ignore)->default_value(false)->zero_tokens(),
1360
1444
  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."))
1361
1445
  ("raw,r", po::value<bool>(&opt_raw_data)->default_value(false)->zero_tokens(),
1362
1446
  N_("Write fields without conversion. Used with --batch.")) 
1363
 
  ("disable-reconnect", N_("Do not reconnect if the connection is lost."))
1364
 
  ("shutdown", po::value<bool>()->zero_tokens(),
 
1447
  ("reconnect", po::value<bool>(&opt_reconnect)->default_value(true)->zero_tokens(),
 
1448
  N_("Reconnect if the connection is lost. Disable with --disable-reconnect. This option is enabled by default."))
 
1449
  ("shutdown", po::value<bool>(&opt_shutdown)->default_value(false)->zero_tokens(),
1365
1450
  N_("Shutdown the server"))
1366
1451
  ("silent,s", N_("Be more silent. Print results with a tab as separator, each row on new line."))
1367
1452
  ("tee", po::value<string>(),
1368
1453
  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."))
1369
1454
  ("disable-tee", po::value<bool>()->default_value(false)->zero_tokens(), 
1370
1455
  N_("Disable outfile. See interactive help (\\h) also."))
1371
 
  ("connect-timeout", po::value<uint32_t>(&opt_connect_timeout)->default_value(0)->notifier(&check_timeout_value),
 
1456
  ("wait,w", N_("Wait and retry if connection is down."))
 
1457
  ("connect_timeout", po::value<uint32_t>(&opt_connect_timeout)->default_value(0)->notifier(&check_timeout_value),
1372
1458
  N_("Number of seconds before connection timeout."))
1373
 
  ("max-input-line", po::value<uint32_t>(&opt_max_input_line)->default_value(16*1024L*1024L)->notifier(&check_max_input_line),
 
1459
  ("max_input_line", po::value<uint32_t>(&opt_max_input_line)->default_value(16*1024L*1024L)->notifier(&check_max_input_line),
1374
1460
  N_("Max length of input line"))
1375
 
  ("select-limit", po::value<uint32_t>(&select_limit)->default_value(1000L),
 
1461
  ("select_limit", po::value<uint32_t>(&select_limit)->default_value(1000L),
1376
1462
  N_("Automatic limit for SELECT when using --safe-updates"))
1377
 
  ("max-join-size", po::value<uint32_t>(&max_join_size)->default_value(1000000L),
 
1463
  ("max_join_size", po::value<uint32_t>(&max_join_size)->default_value(1000000L),
1378
1464
  N_("Automatic limit for rows in a join when using --safe-updates"))
1379
1465
  ;
1380
1466
 
1381
 
  po::options_description client_options(N_("Options specific to the client"));
 
1467
  po::options_description client_options("Options specific to the client");
1382
1468
  client_options.add_options()
 
1469
  ("mysql,m", po::value<bool>(&opt_mysql)->default_value(true)->zero_tokens(),
 
1470
  N_("Use MySQL Protocol."))
1383
1471
  ("host,h", po::value<string>(&current_host)->default_value("localhost"),
1384
1472
  N_("Connect to host"))
1385
1473
  ("password,P", po::value<string>(&current_password)->default_value(PASSWORD_SENTINEL),
1386
1474
  N_("Password to use when connecting to server. If password is not given it's asked from the tty."))
1387
1475
  ("port,p", po::value<uint32_t>()->default_value(0),
1388
1476
  N_("Port number to use for connection or 0 for default to, in order of preference, drizzle.cnf, $DRIZZLE_TCP_PORT, built-in default"))
1389
 
#ifdef DRIZZLE_ADMIN_TOOL
1390
 
  ("user,u", po::value<string>(&current_user)->default_value("root"),
1391
 
#else
1392
1477
  ("user,u", po::value<string>(&current_user)->default_value(""),
1393
 
#endif
1394
1478
  N_("User for login if not current user."))
1395
 
  ("protocol",po::value<string>(&opt_protocol)->default_value("mysql"),
1396
 
  N_("The protocol of connection (mysql or drizzle)."))
 
1479
  ("protocol",po::value<string>(),
 
1480
  N_("The protocol of connection (tcp,socket,pipe,memory)."))
1397
1481
  ;
1398
1482
 
1399
 
  po::options_description long_options(N_("Allowed Options"));
 
1483
  po::options_description long_options("Allowed Options");
1400
1484
  long_options.add(commandline_options).add(drizzle_options).add(client_options);
1401
1485
 
1402
1486
  std::string system_config_dir_drizzle(SYSCONFDIR); 
1406
1490
  system_config_dir_client.append("/drizzle/client.cnf");
1407
1491
 
1408
1492
  std::string user_config_dir((getenv("XDG_CONFIG_HOME")? getenv("XDG_CONFIG_HOME"):"~/.config"));
1409
 
 
1410
 
  if (user_config_dir.compare(0, 2, "~/") == 0)
1411
 
  {
1412
 
    char *homedir;
1413
 
    homedir= getenv("HOME");
1414
 
    if (homedir != NULL)
1415
 
      user_config_dir.replace(0, 1, homedir);
1416
 
  }
1417
 
 
 
1493
  
1418
1494
  po::variables_map vm;
1419
1495
 
1420
1496
  po::positional_options_description p;
1421
1497
  p.add("database", 1);
1422
1498
 
1423
 
  // Disable allow_guessing
1424
 
  int style = po::command_line_style::default_style & ~po::command_line_style::allow_guessing;
1425
 
 
1426
1499
  po::store(po::command_line_parser(argc, argv).options(long_options).
1427
 
            style(style).positional(p).extra_parser(parse_password_arg).run(),
1428
 
            vm);
 
1500
            positional(p).extra_parser(parse_password_arg).run(), vm);
1429
1501
 
1430
1502
  if (! vm["no-defaults"].as<bool>())
1431
1503
  {
1436
1508
    user_config_dir_client.append("/drizzle/client.cnf");
1437
1509
 
1438
1510
    ifstream user_drizzle_ifs(user_config_dir_drizzle.c_str());
1439
 
    po::store(dpo::parse_config_file(user_drizzle_ifs, drizzle_options), vm);
 
1511
    po::store(parse_config_file(user_drizzle_ifs, drizzle_options), vm);
1440
1512
 
1441
1513
    ifstream user_client_ifs(user_config_dir_client.c_str());
1442
 
    po::store(dpo::parse_config_file(user_client_ifs, client_options), vm);
 
1514
    po::store(parse_config_file(user_client_ifs, client_options), vm);
1443
1515
 
1444
1516
    ifstream system_drizzle_ifs(system_config_dir_drizzle.c_str());
1445
 
    store(dpo::parse_config_file(system_drizzle_ifs, drizzle_options), vm);
 
1517
    store(parse_config_file(system_drizzle_ifs, drizzle_options), vm);
1446
1518
 
1447
1519
    ifstream system_client_ifs(system_config_dir_client.c_str());
1448
 
    po::store(dpo::parse_config_file(system_client_ifs, client_options), vm);
 
1520
    po::store(parse_config_file(system_client_ifs, client_options), vm);
1449
1521
  }
1450
1522
 
1451
1523
  po::notify(vm);
1452
1524
 
1453
 
#ifdef DRIZZLE_ADMIN_TOOL
1454
 
  default_prompt= strdup(getenv("DRIZZLE_PS1") ?
1455
 
                         getenv("DRIZZLE_PS1") :
1456
 
                         "drizzleadmin> ");
1457
 
#else
1458
1525
  default_prompt= strdup(getenv("DRIZZLE_PS1") ?
1459
1526
                         getenv("DRIZZLE_PS1") :
1460
1527
                         "drizzle> ");
1461
 
#endif
1462
1528
  if (default_prompt == NULL)
1463
1529
  {
1464
1530
    fprintf(stderr, _("Memory allocation error while constructing initial "
1510
1576
      close(stdout_fileno_copy);             /* Clean up dup(). */
1511
1577
  }
1512
1578
 
1513
 
  /* Inverted Booleans */
1514
 
 
1515
 
  line_numbers= (vm.count("disable-line-numbers")) ? false : true;
1516
 
  column_names= (vm.count("disable-column-names")) ? false : true;
1517
 
  opt_rehash= (vm.count("disable-auto-rehash")) ? false : true;
1518
 
  opt_reconnect= (vm.count("disable-reconnect")) ? false : true;
1519
 
 
1520
 
  /* Don't rehash with --shutdown */
1521
 
  if (vm.count("shutdown"))
1522
 
  {
1523
 
    opt_rehash= false;
1524
 
    opt_shutdown= true;
1525
 
  }
1526
 
 
1527
1579
  if (vm.count("delimiter"))
1528
1580
  {
1529
1581
    /* Check that delimiter does not contain a backslash */
1600
1652
 
1601
1653
  if (one_database)
1602
1654
    skip_updates= true;
1603
 
 
1604
 
  if (vm.count("protocol"))
1605
 
  {
1606
 
    std::transform(opt_protocol.begin(), opt_protocol.end(), 
1607
 
      opt_protocol.begin(), ::tolower);
1608
 
 
1609
 
    if (not opt_protocol.compare("mysql"))
1610
 
      use_drizzle_protocol=false;
1611
 
    else if (not opt_protocol.compare("drizzle"))
1612
 
      use_drizzle_protocol=true;
1613
 
    else
1614
 
    {
1615
 
      cout << _("Error: Unknown protocol") << " '" << opt_protocol << "'" << endl;
1616
 
      exit(-1);
1617
 
    }
1618
 
  }
1619
 
 
 
1655
  
1620
1656
  if (vm.count("port"))
1621
1657
  {
1622
1658
    opt_drizzle_port= vm["port"].as<uint32_t>();
1669
1705
  {
1670
1706
    opt_silent++;
1671
1707
  }
 
1708
  if (vm.count("version"))
 
1709
  {
 
1710
    printf(_("drizzle  Ver %s Distrib %s, for %s-%s (%s) using readline %s\n"),
 
1711
           VER.c_str(), drizzle_version(),
 
1712
           HOST_VENDOR, HOST_OS, HOST_CPU,
 
1713
           rl_library_version);
 
1714
 
 
1715
    exit(0);
 
1716
  }
1672
1717
  
1673
 
  if (vm.count("help") || vm.count("version"))
 
1718
  if (vm.count("help"))
1674
1719
  {
1675
 
    printf(_("Drizzle client %s build %s, for %s-%s (%s) using readline %s\n"),
1676
 
           drizzle_version(), VERSION,
 
1720
    printf(_("drizzle  Ver %s Distrib %s, for %s-%s (%s) using readline %s\n"),
 
1721
           VER.c_str(), drizzle_version(),
1677
1722
           HOST_VENDOR, HOST_OS, HOST_CPU,
1678
1723
           rl_library_version);
1679
 
    if (vm.count("version"))
1680
 
      exit(0);
1681
1724
    printf(_("Copyright (C) 2008 Sun Microsystems\n"
1682
1725
           "This software comes with ABSOLUTELY NO WARRANTY. "
1683
1726
           "This is free software,\n"
1684
1727
           "and you are welcome to modify and redistribute it "
1685
1728
           "under the GPL license\n"));
1686
1729
    printf(_("Usage: drizzle [OPTIONS] [database]\n"));
1687
 
    cout << long_options;
 
1730
    cout<<long_options;
1688
1731
    exit(0);
1689
1732
  }
1690
1733
 
1733
1776
  /* call the SIGWINCH handler to get the default term width */
1734
1777
  window_resize(0);
1735
1778
#endif
1736
 
  std::vector<char> output_buff;
1737
 
  output_buff.resize(512);
1738
 
 
1739
 
  snprintf(&output_buff[0], output_buff.size(), 
1740
 
           _("Welcome to the Drizzle client..  Commands end with %s or \\g."), 
1741
 
           delimiter);
1742
 
 
1743
 
  put_info(&output_buff[0], INFO_INFO, 0, 0);
 
1779
 
 
1780
  put_info(_("Welcome to the Drizzle client..  Commands end with ; or \\g."),
 
1781
           INFO_INFO,0,0);
1744
1782
 
1745
1783
  glob_buffer= new string();
1746
1784
  glob_buffer->reserve(512);
1747
1785
 
1748
 
  snprintf(&output_buff[0], output_buff.size(),
1749
 
          _("Your Drizzle connection id is %u\nConnection protocol: %s\nServer version: %s\n"),
 
1786
  char * output_buff= (char *)malloc(512);
 
1787
  memset(output_buff, '\0', 512);
 
1788
 
 
1789
  sprintf(output_buff,
 
1790
          _("Your Drizzle connection id is %u\nServer version: %s\n"),
1750
1791
          drizzle_con_thread_id(&con),
1751
 
          opt_protocol.c_str(),
1752
1792
          server_version_string(&con));
1753
 
  put_info(&output_buff[0], INFO_INFO, 0, 0);
1754
 
 
 
1793
  put_info(output_buff, INFO_INFO, 0, 0);
1755
1794
 
1756
1795
  initialize_readline((char *)current_prompt.c_str());
1757
1796
  if (!status.getBatch() && !quick)
1801
1840
 
1802
1841
  catch(exception &err)
1803
1842
  {
1804
 
    cerr << _("Error:") << err.what() << endl;
 
1843
  cerr<<"Error:"<<err.what()<<endl;
1805
1844
  }
1806
1845
  return(0);        // Keep compiler happy
1807
1846
}
1823
1862
 
1824
1863
  if (sig >= 0)
1825
1864
    put_info(sig ? _("Aborted") : _("Bye"), INFO_RESULT,0,0);
1826
 
  delete glob_buffer;
1827
 
  delete processed_prompt;
 
1865
  if (glob_buffer)
 
1866
    delete glob_buffer;
 
1867
  if (processed_prompt)
 
1868
    delete processed_prompt;
1828
1869
  opt_password.erase();
1829
1870
  free(histfile);
1830
1871
  free(histfile_tmp);
1848
1889
void handle_sigint(int sig)
1849
1890
{
1850
1891
  char kill_buffer[40];
1851
 
  boost::scoped_ptr<drizzle_con_st> kill_drizzle(new drizzle_con_st);
 
1892
  drizzle_con_st kill_drizzle;
1852
1893
  drizzle_result_st res;
1853
1894
  drizzle_return_t ret;
1854
1895
 
1857
1898
    goto err;
1858
1899
  }
1859
1900
 
1860
 
  if (drizzle_con_add_tcp(&drizzle, kill_drizzle.get(), current_host.c_str(),
1861
 
    opt_drizzle_port, current_user.c_str(), opt_password.c_str(), NULL,
1862
 
    use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL) == NULL)
 
1901
  if (drizzle_con_add_tcp(&drizzle, &kill_drizzle, current_host.c_str(),
 
1902
                          opt_drizzle_port, current_user.c_str(), opt_password.c_str(), NULL,
 
1903
                          opt_mysql ? DRIZZLE_CON_MYSQL : DRIZZLE_CON_NONE) == NULL)
1863
1904
  {
1864
1905
    goto err;
1865
1906
  }
1868
1909
  sprintf(kill_buffer, "KILL /*!50000 QUERY */ %u",
1869
1910
          drizzle_con_thread_id(&con));
1870
1911
 
1871
 
  if (drizzle_query_str(kill_drizzle.get(), &res, kill_buffer, &ret) != NULL)
 
1912
  if (drizzle_query_str(&kill_drizzle, &res, kill_buffer, &ret) != NULL)
1872
1913
    drizzle_result_free(&res);
1873
1914
 
1874
 
  drizzle_con_free(kill_drizzle.get());
 
1915
  drizzle_con_free(&kill_drizzle);
1875
1916
  tee_fprintf(stdout, _("Query aborted by Ctrl+C\n"));
1876
1917
 
1877
1918
  interrupted_query= 1;
2342
2383
  {
2343
2384
    *out++='\n';
2344
2385
    uint32_t length=(uint32_t) (out-line);
2345
 
    if ((buffer->length() + length) > opt_max_input_line)
2346
 
    {
2347
 
      status.setExitStatus(1);
2348
 
      put_info(_("Not found a delimiter within max_input_line of input"), INFO_ERROR, 0, 0);
2349
 
      return 1;
2350
 
    }
2351
2386
    if ((!*ml_comment || preserve_comments))
2352
2387
      buffer->append(line, length);
2353
2388
  }
2623
2658
  {
2624
2659
    string query;
2625
2660
 
2626
 
    query.append("show fields in `");
 
2661
    query.append("show fields in '");
2627
2662
    query.append(table_row[0]);
2628
 
    query.append("`");
 
2663
    query.append("'");
2629
2664
    
2630
2665
    if (drizzle_query(&con, &fields, query.c_str(), query.length(),
2631
2666
                      &ret) != NULL)
2695
2730
 The different commands
2696
2731
***************************************************************************/
2697
2732
 
2698
 
int drizzleclient_real_query_for_lazy(const char *buf, size_t length,
 
2733
int drizzleclient_real_query_for_lazy(const char *buf, int length,
2699
2734
                                      drizzle_result_st *result,
2700
2735
                                      uint32_t *error_code)
2701
2736
{
2734
2769
    return 0;
2735
2770
 
2736
2771
  if (drizzle_con_error(&con)[0])
2737
 
  {
2738
 
    int ret= put_error(&con, result);
2739
 
    drizzle_result_free(result);
2740
 
    return ret;
2741
 
  }
 
2772
    return put_error(&con, result);
2742
2773
  return 0;
2743
2774
}
2744
2775
 
2747
2778
{
2748
2779
  register int i, j;
2749
2780
  char buff[32], *end;
2750
 
  std::vector<char> output_buff;
2751
 
  output_buff.resize(512);
2752
2781
 
2753
2782
  put_info(_("List of all Drizzle commands:"), INFO_INFO,0,0);
2754
2783
  if (!named_cmds)
2755
 
  {
2756
 
    snprintf(&output_buff[0], output_buff.size(),
2757
 
             _("Note that all text commands must be first on line and end with '%s' or \\g"),
2758
 
             delimiter);
2759
 
    put_info(&output_buff[0], INFO_INFO, 0, 0);
2760
 
  }
 
2784
    put_info(_("Note that all text commands must be first on line and end with ';'"),INFO_INFO,0,0);
2761
2785
  for (i = 0; commands[i].getName(); i++)
2762
2786
  {
2763
2787
    end= strcpy(buff, commands[i].getName());
2973
2997
  {
2974
2998
    if (!(PAGER= popen(pager.c_str(), "w")))
2975
2999
    {
2976
 
      tee_fprintf(stdout,_( "popen() failed! defaulting PAGER to stdout!\n"));
 
3000
      tee_fprintf(stdout, "popen() failed! defaulting PAGER to stdout!\n");
2977
3001
      PAGER= stdout;
2978
3002
    }
2979
3003
  }
2995
3019
    end_tee();
2996
3020
  if (!(new_outfile= fopen(file_name, "a")))
2997
3021
  {
2998
 
    tee_fprintf(stdout, _("Error logging to file '%s'\n"), file_name);
 
3022
    tee_fprintf(stdout, "Error logging to file '%s'\n", file_name);
2999
3023
    return;
3000
3024
  }
3001
3025
  OUTFILE = new_outfile;
3002
3026
  outfile.assign(file_name);
3003
 
  tee_fprintf(stdout, _("Logging to file '%s'\n"), file_name);
 
3027
  tee_fprintf(stdout, "Logging to file '%s'\n", file_name);
3004
3028
  opt_outfile= 1;
3005
3029
 
3006
3030
  return;
3084
3108
 
3085
3109
  while ((field = drizzle_column_next(result)))
3086
3110
  {
3087
 
    tee_fprintf(PAGER, _("Field %3u:  `%s`\n"
 
3111
    tee_fprintf(PAGER, "Field %3u:  `%s`\n"
3088
3112
                "Catalog:    `%s`\n"
3089
3113
                "Database:   `%s`\n"
3090
3114
                "Table:      `%s`\n"
3094
3118
                "Length:     %lu\n"
3095
3119
                "Max_length: %lu\n"
3096
3120
                "Decimals:   %u\n"
3097
 
                "Flags:      %s\n\n"),
 
3121
                "Flags:      %s\n\n",
3098
3122
                ++i,
3099
3123
                drizzle_column_name(field), drizzle_column_catalog(field),
3100
3124
                drizzle_column_db(field), drizzle_column_table(field),
3113
3137
  drizzle_row_t cur;
3114
3138
  drizzle_return_t ret;
3115
3139
  drizzle_column_st *field;
3116
 
  std::vector<bool> num_flag;
 
3140
  bool *num_flag;
3117
3141
  string separator;
3118
3142
 
3119
3143
  separator.reserve(256);
3120
3144
 
3121
 
  num_flag.resize(drizzle_result_column_count(result));
 
3145
  num_flag=(bool*) malloc(sizeof(bool)*drizzle_result_column_count(result));
3122
3146
  if (column_types_flag)
3123
3147
  {
3124
3148
    print_field_types(result);
3259
3283
      drizzle_row_free(result, cur);
3260
3284
  }
3261
3285
  tee_puts(separator.c_str(), PAGER);
 
3286
  free(num_flag);
3262
3287
}
3263
3288
 
3264
3289
/**
3551
3576
  {
3552
3577
    if (outfile.empty())
3553
3578
    {
3554
 
      printf(_("No previous outfile available, you must give a filename!\n"));
 
3579
      printf("No previous outfile available, you must give a filename!\n");
3555
3580
      return 0;
3556
3581
    }
3557
3582
    else if (opt_outfile)
3558
3583
    {
3559
 
      tee_fprintf(stdout, _("Currently logging to file '%s'\n"), outfile.c_str());
 
3584
      tee_fprintf(stdout, "Currently logging to file '%s'\n", outfile.c_str());
3560
3585
      return 0;
3561
3586
    }
3562
3587
    else
3576
3601
  end[0]= 0;
3577
3602
  if (end == file_name)
3578
3603
  {
3579
 
    printf(_("No outfile specified!\n"));
 
3604
    printf("No outfile specified!\n");
3580
3605
    return 0;
3581
3606
  }
3582
3607
  init_tee(file_name);
3589
3614
{
3590
3615
  if (opt_outfile)
3591
3616
    end_tee();
3592
 
  tee_fprintf(stdout, _("Outfile disabled.\n"));
 
3617
  tee_fprintf(stdout, "Outfile disabled.\n");
3593
3618
  return 0;
3594
3619
}
3595
3620
 
3612
3637
  /* Skip the spaces between the command and the argument */
3613
3638
  while (param && isspace(*param))
3614
3639
    param++;
3615
 
  if (!param || (*param == '\0')) // if pager was not given, use the default
 
3640
  if (!param || !strlen(param)) // if pager was not given, use the default
3616
3641
  {
3617
3642
    if (!default_pager_set)
3618
3643
    {
3619
 
      tee_fprintf(stdout, _("Default pager wasn't set, using stdout.\n"));
 
3644
      tee_fprintf(stdout, "Default pager wasn't set, using stdout.\n");
3620
3645
      opt_nopager=1;
3621
3646
      pager.assign("stdout");
3622
3647
      PAGER= stdout;
3636
3661
    default_pager.assign(pager_name);
3637
3662
  }
3638
3663
  opt_nopager=0;
3639
 
  tee_fprintf(stdout, _("PAGER set to '%s'\n"), pager.c_str());
 
3664
  tee_fprintf(stdout, "PAGER set to '%s'\n", pager.c_str());
3640
3665
  return 0;
3641
3666
}
3642
3667
 
3647
3672
  pager.assign("stdout");
3648
3673
  opt_nopager=1;
3649
3674
  PAGER= stdout;
3650
 
  tee_fprintf(stdout, _("PAGER set to stdout\n"));
 
3675
  tee_fprintf(stdout, "PAGER set to stdout\n");
3651
3676
  return 0;
3652
3677
}
3653
3678
 
3730
3755
 
3731
3756
  if (connected)
3732
3757
  {
3733
 
    sprintf(buff, _("Connection id:    %u"), drizzle_con_thread_id(&con));
 
3758
    sprintf(buff,"Connection id:    %u",drizzle_con_thread_id(&con));
3734
3759
    put_info(buff,INFO_INFO,0,0);
3735
 
    sprintf(buff, _("Current database: %.128s\n"),
3736
 
            !current_db.empty() ? current_db.c_str() : _("*** NONE ***"));
 
3760
    sprintf(buff,"Current database: %.128s\n",
 
3761
            !current_db.empty() ? current_db.c_str() : "*** NONE ***");
3737
3762
    put_info(buff,INFO_INFO,0,0);
3738
3763
  }
3739
3764
  return error;
3753
3778
  while (isspace(*line))
3754
3779
    line++;
3755
3780
  if (!(param = strchr(line, ' ')))    // Skip command name
3756
 
    return put_info(_("Usage: \\. <filename> | source <filename>"),
 
3781
    return put_info("Usage: \\. <filename> | source <filename>",
3757
3782
                    INFO_ERROR, 0,0);
3758
3783
  while (isspace(*param))
3759
3784
    param++;
3768
3793
  if (!(sql_file = fopen(source_name, "r")))
3769
3794
  {
3770
3795
    char buff[FN_REFLEN+60];
3771
 
    sprintf(buff, _("Failed to open file '%s', error: %d"), source_name,errno);
 
3796
    sprintf(buff,"Failed to open file '%s', error: %d", source_name,errno);
3772
3797
    return put_info(buff, INFO_ERROR, 0 ,0);
3773
3798
  }
3774
3799
 
3776
3801
  if (line_buff == NULL)
3777
3802
  {
3778
3803
    fclose(sql_file);
3779
 
    return put_info(_("Can't initialize LineBuffer"), INFO_ERROR, 0, 0);
 
3804
    return put_info("Can't initialize LineBuffer", INFO_ERROR, 0, 0);
3780
3805
  }
3781
3806
 
3782
3807
  /* Save old status */
3812
3837
 
3813
3838
  if (!tmp || !*tmp)
3814
3839
  {
3815
 
    put_info(_("DELIMITER must be followed by a 'delimiter' character or string"),
 
3840
    put_info("DELIMITER must be followed by a 'delimiter' character or string",
3816
3841
             INFO_ERROR, 0, 0);
3817
3842
    return 0;
3818
3843
  }
3820
3845
  {
3821
3846
    if (strstr(tmp, "\\"))
3822
3847
    {
3823
 
      put_info(_("DELIMITER cannot contain a backslash character"),
 
3848
      put_info("DELIMITER cannot contain a backslash character",
3824
3849
               INFO_ERROR, 0, 0);
3825
3850
      return 0;
3826
3851
    }
3845
3870
  tmp= get_arg(buff, 0);
3846
3871
  if (!tmp || !*tmp)
3847
3872
  {
3848
 
    put_info(_("USE must be followed by a database name"), INFO_ERROR, 0, 0);
 
3873
    put_info("USE must be followed by a database name", INFO_ERROR, 0, 0);
3849
3874
    return 0;
3850
3875
  }
3851
3876
  /*
3913
3938
      build_completion_hash(opt_rehash, 1);
3914
3939
  }
3915
3940
 
3916
 
  put_info(_("Database changed"),INFO_INFO, 0, 0);
 
3941
  put_info("Database changed",INFO_INFO, 0, 0);
3917
3942
  return 0;
3918
3943
}
3919
3944
 
3920
 
static int com_shutdown(string *, const char *)
3921
 
{
3922
 
  drizzle_result_st result;
3923
 
  drizzle_return_t ret;
3924
 
 
3925
 
  if (verbose)
3926
 
  {
3927
 
    printf(_("shutting down drizzled"));
3928
 
    if (opt_drizzle_port > 0)
3929
 
      printf(_(" on port %d"), opt_drizzle_port);
3930
 
    printf("... ");
3931
 
  }
3932
 
 
3933
 
  if (drizzle_shutdown(&con, &result, DRIZZLE_SHUTDOWN_DEFAULT,
3934
 
                       &ret) == NULL || ret != DRIZZLE_RETURN_OK)
3935
 
  {
3936
 
    if (ret == DRIZZLE_RETURN_ERROR_CODE)
3937
 
    {
3938
 
      fprintf(stderr, _("shutdown failed; error: '%s'"),
3939
 
              drizzle_result_error(&result));
3940
 
      drizzle_result_free(&result);
3941
 
    }
3942
 
    else
3943
 
    {
3944
 
      fprintf(stderr, _("shutdown failed; error: '%s'"),
3945
 
              drizzle_con_error(&con));
3946
 
    }
3947
 
    return false;
3948
 
  }
3949
 
 
3950
 
  drizzle_result_free(&result);
3951
 
 
3952
 
  if (verbose)
3953
 
    printf(_("done\n"));
3954
 
 
3955
 
  return false;
3956
 
}
3957
 
 
3958
3945
static int
3959
3946
com_warnings(string *, const char *)
3960
3947
{
3961
3948
  show_warnings = 1;
3962
 
  put_info(_("Show warnings enabled."),INFO_INFO, 0, 0);
 
3949
  put_info("Show warnings enabled.",INFO_INFO, 0, 0);
3963
3950
  return 0;
3964
3951
}
3965
3952
 
3967
3954
com_nowarnings(string *, const char *)
3968
3955
{
3969
3956
  show_warnings = 0;
3970
 
  put_info(_("Show warnings disabled."),INFO_INFO, 0, 0);
 
3957
  put_info("Show warnings disabled.",INFO_INFO, 0, 0);
3971
3958
  return 0;
3972
3959
}
3973
3960
 
4045
4032
    drizzle_free(&drizzle);
4046
4033
  }
4047
4034
  drizzle_create(&drizzle);
4048
 
 
4049
 
#ifdef DRIZZLE_ADMIN_TOOL
4050
 
  drizzle_con_options_t options= (drizzle_con_options_t) (DRIZZLE_CON_ADMIN | (use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL));
4051
 
#else
4052
 
  drizzle_con_options_t options= (drizzle_con_options_t) (use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL);
4053
 
#endif
4054
 
 
4055
 
  if (drizzle_con_add_tcp(&drizzle, &con, (char *)host.c_str(),
4056
 
    opt_drizzle_port, (char *)user.c_str(),
4057
 
    (char *)password.c_str(), (char *)database.c_str(),
4058
 
    options) == NULL)
 
4035
  if (drizzle_con_add_tcp(&drizzle, &con, (char *)host.c_str(), opt_drizzle_port, (char *)user.c_str(),
 
4036
                          (char *)password.c_str(), (char *)database.c_str(), opt_mysql ? DRIZZLE_CON_MYSQL : DRIZZLE_CON_NONE) == NULL)
4059
4037
  {
4060
4038
    (void) put_error(&con, NULL);
4061
4039
    (void) fflush(stdout);
4111
4089
  drizzle_return_t ret;
4112
4090
 
4113
4091
  tee_puts("--------------", stdout);
4114
 
  printf(_("Drizzle client %s build %s, for %s-%s (%s) using readline %s\n"),
4115
 
         drizzle_version(), VERSION,
4116
 
         HOST_VENDOR, HOST_OS, HOST_CPU,
4117
 
         rl_library_version);
 
4092
  printf(_("drizzle  Ver %s Distrib %s, for %s-%s (%s) using readline %s\n"),
 
4093
  VER.c_str(), drizzle_version(),
 
4094
  HOST_VENDOR, HOST_OS, HOST_CPU,
 
4095
  rl_library_version);          /* Print version */
 
4096
 
4118
4097
 
4119
4098
  if (connected)
4120
4099
  {
4121
 
    tee_fprintf(stdout, _("\nConnection id:\t\t%lu\n"),drizzle_con_thread_id(&con));
 
4100
    tee_fprintf(stdout, "\nConnection id:\t\t%lu\n",drizzle_con_thread_id(&con));
4122
4101
    /*
4123
4102
      Don't remove "limit 1",
4124
4103
      it is protection againts SQL_SELECT_LIMIT=0
4130
4109
      drizzle_row_t cur=drizzle_row_next(&result);
4131
4110
      if (cur)
4132
4111
      {
4133
 
        tee_fprintf(stdout, _("Current database:\t%s\n"), cur[0] ? cur[0] : "");
4134
 
        tee_fprintf(stdout, _("Current user:\t\t%s\n"), cur[1]);
 
4112
        tee_fprintf(stdout, "Current database:\t%s\n", cur[0] ? cur[0] : "");
 
4113
        tee_fprintf(stdout, "Current user:\t\t%s\n", cur[1]);
4135
4114
      }
4136
4115
      drizzle_result_free(&result);
4137
4116
    }
4138
4117
    else if (ret == DRIZZLE_RETURN_ERROR_CODE)
4139
4118
      drizzle_result_free(&result);
4140
 
    tee_puts(_("SSL:\t\t\tNot in use"), stdout);
 
4119
    tee_puts("SSL:\t\t\tNot in use", stdout);
4141
4120
  }
4142
4121
  else
4143
4122
  {
4144
4123
    vidattr(A_BOLD);
4145
 
    tee_fprintf(stdout, _("\nNo connection\n"));
 
4124
    tee_fprintf(stdout, "\nNo connection\n");
4146
4125
    vidattr(A_NORMAL);
4147
4126
    return 0;
4148
4127
  }
4149
4128
  if (skip_updates)
4150
4129
  {
4151
4130
    vidattr(A_BOLD);
4152
 
    tee_fprintf(stdout, _("\nAll updates ignored to this database\n"));
 
4131
    tee_fprintf(stdout, "\nAll updates ignored to this database\n");
4153
4132
    vidattr(A_NORMAL);
4154
4133
  }
4155
 
  tee_fprintf(stdout, _("Current pager:\t\t%s\n"), pager.c_str());
4156
 
  tee_fprintf(stdout, _("Using outfile:\t\t'%s'\n"), opt_outfile ? outfile.c_str() : "");
4157
 
  tee_fprintf(stdout, _("Using delimiter:\t%s\n"), delimiter);
4158
 
  tee_fprintf(stdout, _("Server version:\t\t%s\n"), server_version_string(&con));
4159
 
  tee_fprintf(stdout, _("Protocol:\t\t%s\n"), opt_protocol.c_str());
4160
 
  tee_fprintf(stdout, _("Protocol version:\t%d\n"), drizzle_con_protocol_version(&con));
4161
 
  tee_fprintf(stdout, _("Connection:\t\t%s\n"), drizzle_con_host(&con));
 
4134
  tee_fprintf(stdout, "Current pager:\t\t%s\n", pager.c_str());
 
4135
  tee_fprintf(stdout, "Using outfile:\t\t'%s'\n", opt_outfile ? outfile.c_str() : "");
 
4136
  tee_fprintf(stdout, "Using delimiter:\t%s\n", delimiter);
 
4137
  tee_fprintf(stdout, "Server version:\t\t%s\n", server_version_string(&con));
 
4138
  tee_fprintf(stdout, "Protocol version:\t%d\n", drizzle_con_protocol_version(&con));
 
4139
  tee_fprintf(stdout, "Connection:\t\t%s\n", drizzle_con_host(&con));
4162
4140
/* XXX need to save this from result
4163
4141
  if ((id= drizzleclient_insert_id(&drizzle)))
4164
4142
    tee_fprintf(stdout, "Insert id:\t\t%s\n", internal::llstr(id, buff));
4165
4143
*/
4166
4144
 
4167
4145
  if (drizzle_con_uds(&con))
4168
 
    tee_fprintf(stdout, _("UNIX socket:\t\t%s\n"), drizzle_con_uds(&con));
 
4146
    tee_fprintf(stdout, "UNIX socket:\t\t%s\n", drizzle_con_uds(&con));
4169
4147
  else
4170
 
    tee_fprintf(stdout, _("TCP port:\t\t%d\n"), drizzle_con_port(&con));
 
4148
    tee_fprintf(stdout, "TCP port:\t\t%d\n", drizzle_con_port(&con));
4171
4149
 
4172
4150
  if (safe_updates)
4173
4151
  {
4174
4152
    vidattr(A_BOLD);
4175
 
    tee_fprintf(stdout, _("\nNote that you are running in safe_update_mode:\n"));
 
4153
    tee_fprintf(stdout, "\nNote that you are running in safe_update_mode:\n");
4176
4154
    vidattr(A_NORMAL);
4177
 
    tee_fprintf(stdout, _("\
 
4155
    tee_fprintf(stdout, "\
4178
4156
UPDATEs and DELETEs that don't use a key in the WHERE clause are not allowed.\n\
4179
4157
(One can force an UPDATE/DELETE by adding LIMIT # at the end of the command.)\n \
4180
4158
SELECT has an automatic 'LIMIT %lu' if LIMIT is not used.\n             \
4181
 
Max number of examined row combination in a join is set to: %lu\n\n"),
 
4159
Max number of examined row combination in a join is set to: %lu\n\n",
4182
4160
                select_limit, max_join_size);
4183
4161
  }
4184
4162
  tee_puts("--------------\n", stdout);
4236
4214
    if (info_type == INFO_ERROR)
4237
4215
    {
4238
4216
      (void) fflush(file);
4239
 
      fprintf(file,_("ERROR"));
 
4217
      fprintf(file,"ERROR");
4240
4218
      if (error)
4241
4219
      {
4242
4220
        if (sqlstate)
4279
4257
      if (error)
4280
4258
      {
4281
4259
        if (sqlstate)
4282
 
          (void) tee_fprintf(file, _("ERROR %d (%s): "), error, sqlstate);
 
4260
          (void) tee_fprintf(file, "ERROR %d (%s): ", error, sqlstate);
4283
4261
        else
4284
 
          (void) tee_fprintf(file, _("ERROR %d: "), error);
 
4262
          (void) tee_fprintf(file, "ERROR %d: ", error);
4285
4263
      }
4286
4264
      else
4287
 
        tee_puts(_("ERROR: "), file);
 
4265
        tee_puts("ERROR: ", file);
4288
4266
    }
4289
4267
    else
4290
4268
      vidattr(A_BOLD);
4417
4395
    tmp_buff_str << tmp;
4418
4396
 
4419
4397
    if (tmp > 1)
4420
 
      tmp_buff_str << _(" hours ");
 
4398
      tmp_buff_str << " hours ";
4421
4399
    else
4422
 
      tmp_buff_str << _(" hour ");
 
4400
      tmp_buff_str << " hour ";
4423
4401
  }
4424
4402
  if (sec >= 60.0)
4425
4403
  {
4426
4404
    tmp=(uint32_t) floor(sec/60.0);
4427
4405
    sec-=60.0*tmp;
4428
 
    tmp_buff_str << tmp << _(" min ");
 
4406
    tmp_buff_str << tmp << " min ";
4429
4407
  }
4430
4408
  if (part_second)
4431
4409
    tmp_buff_str.precision(2);
4432
4410
  else
4433
4411
    tmp_buff_str.precision(0);
4434
 
  tmp_buff_str << sec << _(" sec");
 
4412
  tmp_buff_str << sec << " sec";
4435
4413
  strcpy(buff, tmp_buff_str.str().c_str());
4436
4414
}
4437
4415
 
4532
4510
        if (!full_username)
4533
4511
          init_username();
4534
4512
        processed_prompt->append(part_username ? part_username :
4535
 
                                 (!current_user.empty() ?  current_user : _("(unknown)")));
 
4513
                                 (!current_user.empty() ?  current_user : "(unknown)"));
4536
4514
        break;
4537
4515
      case PROMPT_CHAR:
4538
4516
        {
4652
4630
{
4653
4631
  const char *ptr=strchr(line, ' ');
4654
4632
  if (ptr == NULL)
4655
 
    tee_fprintf(stdout, _("Returning to default PROMPT of %s\n"),
 
4633
    tee_fprintf(stdout, "Returning to default PROMPT of %s\n",
4656
4634
                default_prompt);
4657
4635
  prompt_counter = 0;
4658
4636
  char * tmpptr= strdup(ptr ? ptr+1 : default_prompt);
4659
4637
  if (tmpptr == NULL)
4660
 
    tee_fprintf(stdout, _("Memory allocation error. Not changing prompt\n"));
 
4638
    tee_fprintf(stdout, "Memory allocation error. Not changing prompt\n");
4661
4639
  else
4662
4640
  {
4663
4641
    current_prompt.erase();
4664
4642
    current_prompt= tmpptr;
4665
 
    tee_fprintf(stdout, _("PROMPT set to '%s'\n"), current_prompt.c_str());
 
4643
    tee_fprintf(stdout, "PROMPT set to '%s'\n", current_prompt.c_str());
4666
4644
  }
4667
4645
  return 0;
4668
4646
}