From 0f27cca46a4a529459ca988268972f480a9730c6 Mon Sep 17 00:00:00 2001 From: Michael Wallner Date: Fri, 23 Oct 2020 14:26:50 +0200 Subject: [PATCH] clang-format: no single-line case --- .clang-format | 4 +- src/bin/common/utilities.cc | 87 ++++-- src/bin/memaslap.c | 97 +++++-- src/bin/memaslap/ms_conn.c | 29 +- src/bin/memaslap/ms_setting.c | 7 +- src/bin/memaslap/ms_task.c | 10 +- src/bin/memcapable.cc | 37 ++- src/bin/memcat.cc | 46 +++- src/bin/memcp.cc | 66 +++-- src/bin/memdump.cc | 46 +++- src/bin/memerror.cc | 14 +- src/bin/memexist.cc | 46 +++- src/bin/memflush.cc | 42 ++- src/bin/memping.cc | 34 ++- src/bin/memrm.cc | 46 +++- src/bin/memslap.cc | 42 ++- src/bin/memstat.cc | 46 +++- src/bin/memtouch.cc | 46 +++- src/libhashkit/digest.cc | 27 +- src/libhashkit/function.cc | 31 ++- src/libhashkit/has.cc | 6 +- src/libhashkit/hsieh.cc | 3 +- src/libhashkit/jenkins.cc | 50 +++- src/libhashkit/str_algorithm.cc | 39 ++- src/libhashkit/strerror.cc | 18 +- src/libmemcached/behavior.cc | 317 +++++++++++++++------- src/libmemcached/callback.cc | 3 +- src/libmemcached/connect.cc | 26 +- src/libmemcached/csl/context.h | 20 +- src/libmemcached/flag.cc | 101 +++++-- src/libmemcached/hash.cc | 6 +- src/libmemcached/hosts.cc | 13 +- src/libmemcached/io.cc | 18 +- src/libmemcached/purge.cc | 8 +- src/libmemcached/response.cc | 37 ++- src/libmemcached/sasl.cc | 3 +- src/libmemcached/server.cc | 9 +- src/libmemcached/storage.cc | 54 ++-- src/libmemcached/strerror.cc | 138 ++++++---- src/libmemcachedprotocol/ascii_handler.c | 99 +++++-- src/libmemcachedprotocol/binary_handler.c | 3 +- src/libmemcachedprotocol/pedantic.c | 3 +- src/libmemcachedutil/pool.cc | 12 +- 43 files changed, 1266 insertions(+), 523 deletions(-) diff --git a/.clang-format b/.clang-format index b86de6c1..7b77b814 100644 --- a/.clang-format +++ b/.clang-format @@ -12,9 +12,9 @@ AllowAllArgumentsOnNextLine: true AllowAllConstructorInitializersOnNextLine: true AllowAllParametersOfDeclarationOnNextLine: true AllowShortBlocksOnASingleLine: Never -AllowShortCaseLabelsOnASingleLine: true +AllowShortCaseLabelsOnASingleLine: false #AllowShortEnumsOnASingleLine: true (in v11) -AllowShortFunctionsOnASingleLine: Inline +AllowShortFunctionsOnASingleLine: Empty AllowShortIfStatementsOnASingleLine: Never AllowShortLambdasOnASingleLine: All AllowShortLoopsOnASingleLine: true diff --git a/src/bin/common/utilities.cc b/src/bin/common/utilities.cc index 0e21d709..ce7bd3d8 100644 --- a/src/bin/common/utilities.cc +++ b/src/bin/common/utilities.cc @@ -67,35 +67,64 @@ void close_stdio(void) { static const char *lookup_help(memcached_options option) { switch (option) { - case OPT_SERVERS: return ("List which servers you wish to connect to."); - case OPT_VERSION: return ("Display the version of the application and then exit."); - case OPT_HELP: return ("Display this message and then exit."); - case OPT_VERBOSE: return ("Give more details on the progression of the application."); - case OPT_QUIET: return ("stderr and stdin will be closed at application startup."); - case OPT_DEBUG: return ("Provide output only useful for debugging."); - case OPT_FLAG: return ("Provide flag information for storage operation."); - case OPT_EXPIRE: return ("Set the expire option for the object."); - case OPT_SET: return ("Use set command with memcached when storing."); - case OPT_REPLACE: return ("Use replace command with memcached when storing."); - case OPT_ADD: return ("Use add command with memcached when storing."); - case OPT_SLAP_EXECUTE_NUMBER: return ("Number of times to execute the given test."); - case OPT_SLAP_INITIAL_LOAD: return ("Number of key pairs to load before executing tests."); - case OPT_SLAP_TEST: return ("Test to run (currently \"get\" or \"set\")."); - case OPT_SLAP_CONCURRENCY: return ("Number of users to simulate with load."); - case OPT_SLAP_NON_BLOCK: return ("Set TCP up to use non-blocking IO."); - case OPT_SLAP_TCP_NODELAY: return ("Set TCP socket up to use nodelay."); - case OPT_FLUSH: return ("Flush servers before running tests."); - case OPT_HASH: return ("Select hash type."); - case OPT_BINARY: return ("Switch to binary protocol."); - case OPT_ANALYZE: return ("Analyze the provided servers."); - case OPT_UDP: return ("Use UDP protocol when communicating with server."); - case OPT_BUFFER: return ("Enable request buffering."); - case OPT_USERNAME: return "Username to use for SASL authentication"; - case OPT_PASSWD: return "Password to use for SASL authentication"; - case OPT_FILE: return "Path to file in which to save result"; - case OPT_STAT_ARGS: return "Argument for statistics"; - case OPT_SERVER_VERSION: return "Memcached daemon software version"; - default: break; + case OPT_SERVERS: + return ("List which servers you wish to connect to."); + case OPT_VERSION: + return ("Display the version of the application and then exit."); + case OPT_HELP: + return ("Display this message and then exit."); + case OPT_VERBOSE: + return ("Give more details on the progression of the application."); + case OPT_QUIET: + return ("stderr and stdin will be closed at application startup."); + case OPT_DEBUG: + return ("Provide output only useful for debugging."); + case OPT_FLAG: + return ("Provide flag information for storage operation."); + case OPT_EXPIRE: + return ("Set the expire option for the object."); + case OPT_SET: + return ("Use set command with memcached when storing."); + case OPT_REPLACE: + return ("Use replace command with memcached when storing."); + case OPT_ADD: + return ("Use add command with memcached when storing."); + case OPT_SLAP_EXECUTE_NUMBER: + return ("Number of times to execute the given test."); + case OPT_SLAP_INITIAL_LOAD: + return ("Number of key pairs to load before executing tests."); + case OPT_SLAP_TEST: + return ("Test to run (currently \"get\" or \"set\")."); + case OPT_SLAP_CONCURRENCY: + return ("Number of users to simulate with load."); + case OPT_SLAP_NON_BLOCK: + return ("Set TCP up to use non-blocking IO."); + case OPT_SLAP_TCP_NODELAY: + return ("Set TCP socket up to use nodelay."); + case OPT_FLUSH: + return ("Flush servers before running tests."); + case OPT_HASH: + return ("Select hash type."); + case OPT_BINARY: + return ("Switch to binary protocol."); + case OPT_ANALYZE: + return ("Analyze the provided servers."); + case OPT_UDP: + return ("Use UDP protocol when communicating with server."); + case OPT_BUFFER: + return ("Enable request buffering."); + case OPT_USERNAME: + return "Username to use for SASL authentication"; + case OPT_PASSWD: + return "Password to use for SASL authentication"; + case OPT_FILE: + return "Path to file in which to save result"; + case OPT_STAT_ARGS: + return "Argument for statistics"; + case OPT_SERVER_VERSION: + return "Memcached daemon software version"; + default: + break; }; assert(0); diff --git a/src/bin/memaslap.c b/src/bin/memaslap.c index 05919611..a5481bb8 100644 --- a/src/bin/memaslap.c +++ b/src/bin/memaslap.c @@ -204,9 +204,11 @@ static const char *ms_lookup_help(ms_options_t option) { return "List one or more servers to connect. Servers count must be less than\n" " threads count. e.g.: --servers=localhost:1234,localhost:11211"; - case OPT_VERSION: return "Display the version of the application and then exit."; + case OPT_VERSION: + return "Display the version of the application and then exit."; - case OPT_HELP: return "Display this message and then exit."; + case OPT_HELP: + return "Display this message and then exit."; case OPT_EXECUTE_NUMBER: return "Number of operations(get and set) to execute for the\n" @@ -215,13 +217,17 @@ static const char *ms_lookup_help(ms_options_t option) { case OPT_THREAD_NUMBER: return "Number of threads to startup, better equal to CPU numbers. Default 8."; - case OPT_CONCURRENCY: return "Number of concurrency to simulate with load. Default 128."; + case OPT_CONCURRENCY: + return "Number of concurrency to simulate with load. Default 128."; - case OPT_FIXED_LTH: return "Fixed length of value."; + case OPT_FIXED_LTH: + return "Fixed length of value."; - case OPT_VERIFY: return "The proportion of date verification, e.g.: --verify=0.01"; + case OPT_VERIFY: + return "The proportion of date verification, e.g.: --verify=0.01"; - case OPT_GETS_DIVISION: return "Number of keys to multi-get once. Default 1, means single get."; + case OPT_GETS_DIVISION: + return "Number of keys to multi-get once. Default 1, means single get."; case OPT_TIME: return "How long the test to run, suffix: s-seconds, m-minutes, h-hours,\n" @@ -250,11 +256,14 @@ static const char *ms_lookup_help(ms_options_t option) { return "Frequency of dumping statistic information. suffix: s-seconds,\n" " m-minutes, e.g.: --resp_freq=10s."; - case OPT_SOCK_PER_CONN: return "Number of TCP socks per concurrency. Default 1."; + case OPT_SOCK_PER_CONN: + return "Number of TCP socks per concurrency. Default 1."; - case OPT_RECONNECT: return "Reconnect support, when connection is closed it will be reconnected."; + case OPT_RECONNECT: + return "Reconnect support, when connection is closed it will be reconnected."; - case OPT_VERBOSE: return "Whether it outputs detailed information when verification fails."; + case OPT_VERBOSE: + return "Whether it outputs detailed information when verification fails."; case OPT_FACEBOOK_TEST: return "Whether it enables facebook test feature, set with TCP and multi-get with UDP."; @@ -262,11 +271,14 @@ static const char *ms_lookup_help(ms_options_t option) { case OPT_BINARY_PROTOCOL: return "Whether it enables binary protocol. Default with ASCII protocol."; - case OPT_TPS: return "Expected throughput, suffix: K, e.g.: --tps=10k."; + case OPT_TPS: + return "Expected throughput, suffix: K, e.g.: --tps=10k."; - case OPT_REP_WRITE_SRV: return "The first nth servers can write data, e.g.: --rep_write=2."; + case OPT_REP_WRITE_SRV: + return "The first nth servers can write data, e.g.: --rep_write=2."; - default: return "Forgot to document this option :)"; + default: + return "Forgot to document this option :)"; } /* switch */ } /* ms_lookup_help */ @@ -292,9 +304,12 @@ static int64_t ms_parse_time() { ret *= 60; /* fall through */ case 's': - case 'S': break; + case 'S': + break; - default: ret = -1; break; + default: + ret = -1; + break; } /* switch */ return ret; @@ -315,15 +330,23 @@ static int64_t ms_parse_size() { switch (unit) { case 'k': - case 'K': ret *= 1024; break; + case 'K': + ret *= 1024; + break; case 'm': - case 'M': ret *= 1024 * 1024; break; + case 'M': + ret *= 1024 * 1024; + break; case 'g': - case 'G': ret *= 1024 * 1024 * 1024; break; + case 'G': + ret *= 1024 * 1024 * 1024; + break; - default: ret = -1; break; + default: + ret = -1; + break; } /* switch */ return ret; @@ -341,16 +364,21 @@ static void ms_options_parse(int argc, char *argv[]) { != -1) { switch (option_rv) { - case 0: break; + case 0: + break; - case OPT_VERSION: /* --version or -V */ ms_version_command(PROGRAM_NAME); break; + case OPT_VERSION: /* --version or -V */ + ms_version_command(PROGRAM_NAME); + break; case OPT_HELP: /* --help or -h */ ms_help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION); exit(0); break; - case OPT_SERVERS: /* --servers or -s */ ms_setting.srv_str = strdup(optarg); break; + case OPT_SERVERS: /* --servers or -s */ + ms_setting.srv_str = strdup(optarg); + break; case OPT_CONCURRENCY: /* --concurrency or -c */ errno = 0; @@ -425,7 +453,9 @@ static void ms_options_parse(int argc, char *argv[]) { } break; - case OPT_CONFIG_CMD: /* --cfg_cmd or -F */ ms_setting.cfg_file = strdup(optarg); break; + case OPT_CONFIG_CMD: /* --cfg_cmd or -F */ + ms_setting.cfg_file = strdup(optarg); + break; case OPT_WINDOW_SIZE: /* --win_size or -w */ ms_setting.win_size = (size_t) ms_parse_size(); @@ -437,7 +467,9 @@ static void ms_options_parse(int argc, char *argv[]) { } break; - case OPT_UDP: /* --udp or -U*/ ms_setting.udp = true; break; + case OPT_UDP: /* --udp or -U*/ + ms_setting.udp = true; + break; case OPT_EXPIRE: /* --exp_verify or -e */ ms_setting.exp_ver_per = atof(optarg); @@ -489,13 +521,21 @@ static void ms_options_parse(int argc, char *argv[]) { } break; - case OPT_RECONNECT: /* --reconnect or -R */ ms_setting.reconnect = true; break; + case OPT_RECONNECT: /* --reconnect or -R */ + ms_setting.reconnect = true; + break; - case OPT_VERBOSE: /* --verbose or -b */ ms_setting.verbose = true; break; + case OPT_VERBOSE: /* --verbose or -b */ + ms_setting.verbose = true; + break; - case OPT_FACEBOOK_TEST: /* --facebook or -a */ ms_setting.facebook_test = true; break; + case OPT_FACEBOOK_TEST: /* --facebook or -a */ + ms_setting.facebook_test = true; + break; - case OPT_BINARY_PROTOCOL: /* --binary or -B */ ms_setting.binary_prot_ = true; break; + case OPT_BINARY_PROTOCOL: /* --binary or -B */ + ms_setting.binary_prot_ = true; + break; case OPT_TPS: /* --tps or -P */ ms_setting.expected_tps = (int) ms_parse_size(); @@ -522,7 +562,8 @@ static void ms_options_parse(int argc, char *argv[]) { /* getopt_long already printed an error message. */ exit(1); - default: abort(); + default: + abort(); } /* switch */ } } /* ms_options_parse */ diff --git a/src/bin/memaslap/ms_conn.c b/src/bin/memaslap/ms_conn.c index 815c67ff..dade7090 100644 --- a/src/bin/memaslap/ms_conn.c +++ b/src/bin/memaslap/ms_conn.c @@ -1006,7 +1006,9 @@ static int ms_ascii_process_line(ms_conn_t *c, char *command) { break; - case 'O': /* OK */ c->currcmd.retstat = MCD_SUCCESS; break; + case 'O': /* OK */ + c->currcmd.retstat = MCD_SUCCESS; + break; case 'S': /* STORED STATS SERVER_ERROR */ if (buffer[2] == 'A') /* STORED STATS */ { /* STATS*/ @@ -1064,7 +1066,9 @@ static int ms_ascii_process_line(ms_conn_t *c, char *command) { c->currcmd.retstat = MCD_CLIENT_ERROR; break; - default: c->currcmd.retstat = MCD_UNKNOWN_READ_FAILURE; break; + default: + c->currcmd.retstat = MCD_UNKNOWN_READ_FAILURE; + break; } /* switch */ return ret; @@ -2200,16 +2204,21 @@ static void ms_drive_machine(ms_conn_t *c) { stop = true; break; - case TRANSMIT_INCOMPLETE: c->ctnwrite = true; break; /* Continue in state machine. */ + case TRANSMIT_INCOMPLETE: + c->ctnwrite = true; + break; /* Continue in state machine. */ - case TRANSMIT_HARD_ERROR: c->ctnwrite = false; break; + case TRANSMIT_HARD_ERROR: + c->ctnwrite = false; + break; case TRANSMIT_SOFT_ERROR: c->ctnwrite = true; stop = true; break; - default: break; + default: + break; } /* switch */ break; @@ -2242,7 +2251,8 @@ static void ms_drive_machine(ms_conn_t *c) { break; } - default: assert(0); + default: + assert(0); } /* switch */ } } /* ms_drive_machine */ @@ -2362,7 +2372,8 @@ static int ms_update_conn_sock_event(ms_conn_t *c) { } break; - default: break; + default: + break; } /* switch */ if (!c->udp && (c->total_sfds > 1)) { @@ -2692,7 +2703,9 @@ static int ms_bin_process_response(ms_conn_t *c) { c->currcmd.retstat = MCD_PROTOCOL_ERROR; break; - case PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS: errstr = "Data exists for key."; break; + case PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS: + errstr = "Data exists for key."; + break; case PROTOCOL_BINARY_RESPONSE_E2BIG: errstr = "Too large."; diff --git a/src/bin/memaslap/ms_setting.c b/src/bin/memaslap/ms_setting.c index adab65a1..76101ba0 100644 --- a/src/bin/memaslap/ms_setting.c +++ b/src/bin/memaslap/ms_setting.c @@ -446,7 +446,9 @@ static void ms_parse_cfg_file(char *cfg_file) { } break; - default: assert(0); break; + default: + assert(0); + break; } /* switch */ } @@ -527,7 +529,8 @@ static int ms_shuffle_distr(ms_distr_t *distr, int length) { distr[i].value_size = tmp_size; break; - default: break; + default: + break; } /* switch */ } diff --git a/src/bin/memaslap/ms_task.c b/src/bin/memaslap/ms_task.c index 638fb485..89754ec6 100644 --- a/src/bin/memaslap/ms_task.c +++ b/src/bin/memaslap/ms_task.c @@ -793,7 +793,8 @@ static void ms_update_set_result(ms_conn_t *c, ms_task_item_t *item) { break; case MCD_SERVER_ERROR: - default: break; + default: + break; } /* switch */ } } /* ms_update_set_result */ @@ -817,7 +818,9 @@ static void ms_update_stat_result(ms_conn_t *c) { pthread_mutex_lock(&ms_statistic.stat_mutex); switch (c->precmd.cmd) { - case CMD_SET: ms_record_event(&ms_statistic.set_stat, time_diff, false); break; + case CMD_SET: + ms_record_event(&ms_statistic.set_stat, time_diff, false); + break; case CMD_GET: if (c->curr_task.get_miss) { @@ -826,7 +829,8 @@ static void ms_update_stat_result(ms_conn_t *c) { ms_record_event(&ms_statistic.get_stat, time_diff, get_miss); break; - default: break; + default: + break; } /* switch */ ms_record_event(&ms_statistic.total_stat, time_diff, get_miss); diff --git a/src/bin/memcapable.cc b/src/bin/memcapable.cc index feda49df..7b3b7c92 100644 --- a/src/bin/memcapable.cc +++ b/src/bin/memcapable.cc @@ -302,9 +302,11 @@ static enum test_return retry_read(void *buf, size_t len) { verify(get_socket_errno() == EINTR || get_socket_errno() == EAGAIN); break; - case 0: return TEST_FAIL; + case 0: + return TEST_FAIL; - default: offset += (size_t) nr; + default: + offset += (size_t) nr; } } while (offset < len); @@ -465,7 +467,8 @@ static enum test_return do_validate_response_header(response *rsp, uint8_t cc, u case PROTOCOL_BINARY_CMD_SETQ: verify("Quiet command shouldn't return on success" == NULL); /* fall through */ - default: break; + default: + break; } switch (cc) { @@ -1828,19 +1831,33 @@ int main(int argc, char **argv) { } break; - case 'v': verbose = true; break; + case 'v': + verbose = true; + break; - case 'c': do_core = true; break; + case 'c': + do_core = true; + break; - case 'h': hostname = optarg; break; + case 'h': + hostname = optarg; + break; - case 'p': port = optarg; break; + case 'p': + port = optarg; + break; - case 'q': close_stdio(); break; + case 'q': + close_stdio(); + break; - case 'P': prompt = true; break; + case 'P': + prompt = true; + break; - case 'T': testname = optarg; break; + case 'T': + testname = optarg; + break; default: fprintf(stderr, diff --git a/src/bin/memcat.cc b/src/bin/memcat.cc index 6ebcf7fd..84de35ed 100644 --- a/src/bin/memcat.cc +++ b/src/bin/memcat.cc @@ -193,26 +193,48 @@ void options_parse(int argc, char *argv[]) { if (option_rv == -1) break; switch (option_rv) { - case 0: break; - case OPT_BINARY: opt_binary = 1; break; - case OPT_VERBOSE: /* --verbose or -v */ opt_verbose = OPT_VERBOSE; break; - case OPT_DEBUG: /* --debug or -d */ opt_verbose = OPT_DEBUG; break; - case OPT_VERSION: /* --version or -V */ version_command(PROGRAM_NAME); break; + case 0: + break; + case OPT_BINARY: + opt_binary = 1; + break; + case OPT_VERBOSE: /* --verbose or -v */ + opt_verbose = OPT_VERBOSE; + break; + case OPT_DEBUG: /* --debug or -d */ + opt_verbose = OPT_DEBUG; + break; + case OPT_VERSION: /* --version or -V */ + version_command(PROGRAM_NAME); + break; case OPT_HELP: /* --help or -h */ help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options); break; - case OPT_SERVERS: /* --servers or -s */ opt_servers = strdup(optarg); break; - case OPT_HASH: opt_hash = strdup(optarg); break; - case OPT_USERNAME: opt_username = optarg; break; - case OPT_PASSWD: opt_passwd = optarg; break; - case OPT_FILE: opt_file = optarg; break; + case OPT_SERVERS: /* --servers or -s */ + opt_servers = strdup(optarg); + break; + case OPT_HASH: + opt_hash = strdup(optarg); + break; + case OPT_USERNAME: + opt_username = optarg; + break; + case OPT_PASSWD: + opt_passwd = optarg; + break; + case OPT_FILE: + opt_file = optarg; + break; - case OPT_QUIET: close_stdio(); break; + case OPT_QUIET: + close_stdio(); + break; case '?': /* getopt_long already printed an error message. */ exit(EXIT_FAILURE); - default: abort(); + default: + abort(); } } } diff --git a/src/bin/memcp.cc b/src/bin/memcp.cc index c0815dac..feb4dcd1 100644 --- a/src/bin/memcp.cc +++ b/src/bin/memcp.cc @@ -296,19 +296,32 @@ static void options_parse(int argc, char *argv[]) { break; switch (option_rv) { - case 0: break; + case 0: + break; - case OPT_BINARY: opt_binary = true; break; + case OPT_BINARY: + opt_binary = true; + break; - case OPT_VERBOSE: /* --verbose or -v */ opt_verbose = OPT_VERBOSE; break; + case OPT_VERBOSE: /* --verbose or -v */ + opt_verbose = OPT_VERBOSE; + break; - case OPT_DEBUG: /* --debug or -d */ opt_verbose = OPT_DEBUG; break; + case OPT_DEBUG: /* --debug or -d */ + opt_verbose = OPT_DEBUG; + break; - case OPT_VERSION: /* --version or -V */ opt_version = true; break; + case OPT_VERSION: /* --version or -V */ + opt_version = true; + break; - case OPT_HELP: /* --help or -h */ opt_help = true; break; + case OPT_HELP: /* --help or -h */ + opt_help = true; + break; - case OPT_SERVERS: /* --servers or -s */ opt_servers = strdup(optarg); break; + case OPT_SERVERS: /* --servers or -s */ + opt_servers = strdup(optarg); + break; case OPT_FLAG: /* --flag */ { @@ -330,28 +343,47 @@ static void options_parse(int argc, char *argv[]) { } } break; - case OPT_SET: opt_method = OPT_SET; break; + case OPT_SET: + opt_method = OPT_SET; + break; - case OPT_REPLACE: opt_method = OPT_REPLACE; break; + case OPT_REPLACE: + opt_method = OPT_REPLACE; + break; - case OPT_ADD: opt_method = OPT_ADD; break; + case OPT_ADD: + opt_method = OPT_ADD; + break; - case OPT_HASH: opt_hash = strdup(optarg); break; + case OPT_HASH: + opt_hash = strdup(optarg); + break; - case OPT_USERNAME: opt_username = optarg; break; + case OPT_USERNAME: + opt_username = optarg; + break; - case OPT_PASSWD: opt_passwd = optarg; break; + case OPT_PASSWD: + opt_passwd = optarg; + break; - case OPT_QUIET: close_stdio(); break; + case OPT_QUIET: + close_stdio(); + break; - case OPT_UDP: opt_udp = true; break; + case OPT_UDP: + opt_udp = true; + break; - case OPT_BUFFER: opt_buffer = true; break; + case OPT_BUFFER: + opt_buffer = true; + break; case '?': /* getopt_long already printed an error message. */ exit(1); - default: abort(); + default: + abort(); } } diff --git a/src/bin/memdump.cc b/src/bin/memdump.cc index aa75f8a8..6d31780c 100644 --- a/src/bin/memdump.cc +++ b/src/bin/memdump.cc @@ -156,32 +156,54 @@ static void options_parse(int argc, char *argv[]) { break; switch (option_rv) { - case 0: break; + case 0: + break; - case OPT_BINARY: opt_binary = true; break; + case OPT_BINARY: + opt_binary = true; + break; - case OPT_VERBOSE: /* --verbose or -v */ opt_verbose = OPT_VERBOSE; break; + case OPT_VERBOSE: /* --verbose or -v */ + opt_verbose = OPT_VERBOSE; + break; - case OPT_DEBUG: /* --debug or -d */ opt_verbose = OPT_DEBUG; break; + case OPT_DEBUG: /* --debug or -d */ + opt_verbose = OPT_DEBUG; + break; - case OPT_VERSION: /* --version or -V */ opt_verbose = true; break; + case OPT_VERSION: /* --version or -V */ + opt_verbose = true; + break; - case OPT_HELP: /* --help or -h */ opt_help = true; break; + case OPT_HELP: /* --help or -h */ + opt_help = true; + break; - case OPT_SERVERS: /* --servers or -s */ opt_servers = strdup(optarg); break; + case OPT_SERVERS: /* --servers or -s */ + opt_servers = strdup(optarg); + break; - case OPT_HASH: opt_hash = strdup(optarg); break; + case OPT_HASH: + opt_hash = strdup(optarg); + break; - case OPT_USERNAME: opt_username = optarg; break; + case OPT_USERNAME: + opt_username = optarg; + break; - case OPT_PASSWD: opt_passwd = optarg; break; + case OPT_PASSWD: + opt_passwd = optarg; + break; - case OPT_QUIET: close_stdio(); break; + case OPT_QUIET: + close_stdio(); + break; case '?': /* getopt_long already printed an error message. */ exit(1); - default: abort(); + default: + abort(); } } diff --git a/src/bin/memerror.cc b/src/bin/memerror.cc index c35684ad..2580550f 100644 --- a/src/bin/memerror.cc +++ b/src/bin/memerror.cc @@ -84,17 +84,23 @@ void options_parse(int argc, char *argv[]) { } switch (option_rv) { - case 0: break; + case 0: + break; - case OPT_VERSION: /* --version or -V */ opt_version = true; break; + case OPT_VERSION: /* --version or -V */ + opt_version = true; + break; - case OPT_HELP: /* --help or -h */ opt_help = true; break; + case OPT_HELP: /* --help or -h */ + opt_help = true; + break; case '?': /* getopt_long already printed an error message. */ exit(EXIT_FAILURE); - default: exit(EXIT_FAILURE); + default: + exit(EXIT_FAILURE); } } diff --git a/src/bin/memexist.cc b/src/bin/memexist.cc index eec39abf..8fb69d47 100644 --- a/src/bin/memexist.cc +++ b/src/bin/memexist.cc @@ -155,33 +155,55 @@ static void options_parse(int argc, char *argv[]) { } switch (option_rv) { - case 0: break; + case 0: + break; - case OPT_BINARY: opt_binary = 1; break; + case OPT_BINARY: + opt_binary = 1; + break; - case OPT_VERBOSE: /* --verbose or -v */ opt_verbose = OPT_VERBOSE; break; + case OPT_VERBOSE: /* --verbose or -v */ + opt_verbose = OPT_VERBOSE; + break; - case OPT_DEBUG: /* --debug or -d */ opt_verbose = OPT_DEBUG; break; + case OPT_DEBUG: /* --debug or -d */ + opt_verbose = OPT_DEBUG; + break; - case OPT_VERSION: /* --version or -V */ opt_version = true; break; + case OPT_VERSION: /* --version or -V */ + opt_version = true; + break; - case OPT_HELP: /* --help or -h */ opt_help = true; break; + case OPT_HELP: /* --help or -h */ + opt_help = true; + break; - case OPT_SERVERS: /* --servers or -s */ opt_servers = strdup(optarg); break; + case OPT_SERVERS: /* --servers or -s */ + opt_servers = strdup(optarg); + break; - case OPT_HASH: opt_hash = strdup(optarg); break; + case OPT_HASH: + opt_hash = strdup(optarg); + break; - case OPT_USERNAME: opt_username = optarg; break; + case OPT_USERNAME: + opt_username = optarg; + break; - case OPT_PASSWD: opt_passwd = optarg; break; + case OPT_PASSWD: + opt_passwd = optarg; + break; - case OPT_QUIET: close_stdio(); break; + case OPT_QUIET: + close_stdio(); + break; case '?': /* getopt_long already printed an error message. */ exit(EXIT_SUCCESS); - default: abort(); + default: + abort(); } } diff --git a/src/bin/memflush.cc b/src/bin/memflush.cc index baa552d1..b87521c3 100644 --- a/src/bin/memflush.cc +++ b/src/bin/memflush.cc @@ -119,19 +119,32 @@ void options_parse(int argc, char *argv[]) { if (option_rv == -1) break; switch (option_rv) { - case 0: break; + case 0: + break; - case OPT_BINARY: opt_binary = true; break; + case OPT_BINARY: + opt_binary = true; + break; - case OPT_VERBOSE: /* --verbose or -v */ opt_verbose = OPT_VERBOSE; break; + case OPT_VERBOSE: /* --verbose or -v */ + opt_verbose = OPT_VERBOSE; + break; - case OPT_DEBUG: /* --debug or -d */ opt_verbose = OPT_DEBUG; break; + case OPT_DEBUG: /* --debug or -d */ + opt_verbose = OPT_DEBUG; + break; - case OPT_VERSION: /* --version or -V */ opt_version = true; break; + case OPT_VERSION: /* --version or -V */ + opt_version = true; + break; - case OPT_HELP: /* --help or -h */ opt_help = true; break; + case OPT_HELP: /* --help or -h */ + opt_help = true; + break; - case OPT_SERVERS: /* --servers or -s */ opt_servers = strdup(optarg); break; + case OPT_SERVERS: /* --servers or -s */ + opt_servers = strdup(optarg); + break; case OPT_EXPIRE: /* --expire */ errno = 0; @@ -142,17 +155,24 @@ void options_parse(int argc, char *argv[]) { } break; - case OPT_USERNAME: opt_username = optarg; break; + case OPT_USERNAME: + opt_username = optarg; + break; - case OPT_PASSWD: opt_passwd = optarg; break; + case OPT_PASSWD: + opt_passwd = optarg; + break; - case OPT_QUIET: close_stdio(); break; + case OPT_QUIET: + close_stdio(); + break; case '?': /* getopt_long already printed an error message. */ exit(EXIT_FAILURE); - default: abort(); + default: + abort(); } } diff --git a/src/bin/memping.cc b/src/bin/memping.cc index 184647b2..ba9c1ab2 100644 --- a/src/bin/memping.cc +++ b/src/bin/memping.cc @@ -116,21 +116,32 @@ void options_parse(int argc, char *argv[]) { break; switch (option_rv) { - case 0: break; + case 0: + break; - case OPT_BINARY: opt_binary = true; break; + case OPT_BINARY: + opt_binary = true; + break; - case OPT_VERBOSE: /* --verbose or -v */ opt_verbose = OPT_VERBOSE; break; + case OPT_VERBOSE: /* --verbose or -v */ + opt_verbose = OPT_VERBOSE; + break; - case OPT_DEBUG: /* --debug or -d */ opt_verbose = OPT_DEBUG; break; + case OPT_DEBUG: /* --debug or -d */ + opt_verbose = OPT_DEBUG; + break; - case OPT_VERSION: /* --version or -V */ version_command(PROGRAM_NAME); break; + case OPT_VERSION: /* --version or -V */ + version_command(PROGRAM_NAME); + break; case OPT_HELP: /* --help or -h */ help_command(PROGRAM_NAME, PROGRAM_DESCRIPTION, long_options, help_options); break; - case OPT_SERVERS: /* --servers or -s */ opt_servers = strdup(optarg); break; + case OPT_SERVERS: /* --servers or -s */ + opt_servers = strdup(optarg); + break; case OPT_EXPIRE: /* --expire */ errno = 0; @@ -146,14 +157,19 @@ void options_parse(int argc, char *argv[]) { opt_binary = true; break; - case OPT_PASSWD: opt_passwd = optarg; break; + case OPT_PASSWD: + opt_passwd = optarg; + break; - case OPT_QUIET: close_stdio(); break; + case OPT_QUIET: + close_stdio(); + break; case '?': /* getopt_long already printed an error message. */ exit(1); - default: abort(); + default: + abort(); } } diff --git a/src/bin/memrm.cc b/src/bin/memrm.cc index 7bd35132..c2b4a36f 100644 --- a/src/bin/memrm.cc +++ b/src/bin/memrm.cc @@ -160,19 +160,32 @@ static void options_parse(int argc, char *argv[]) { } switch (option_rv) { - case 0: break; + case 0: + break; - case OPT_BINARY: opt_binary = 1; break; + case OPT_BINARY: + opt_binary = 1; + break; - case OPT_VERBOSE: /* --verbose or -v */ opt_verbose = OPT_VERBOSE; break; + case OPT_VERBOSE: /* --verbose or -v */ + opt_verbose = OPT_VERBOSE; + break; - case OPT_DEBUG: /* --debug or -d */ opt_verbose = OPT_DEBUG; break; + case OPT_DEBUG: /* --debug or -d */ + opt_verbose = OPT_DEBUG; + break; - case OPT_VERSION: /* --version or -V */ opt_version = true; break; + case OPT_VERSION: /* --version or -V */ + opt_version = true; + break; - case OPT_HELP: /* --help or -h */ opt_help = true; break; + case OPT_HELP: /* --help or -h */ + opt_help = true; + break; - case OPT_SERVERS: /* --servers or -s */ opt_servers = strdup(optarg); break; + case OPT_SERVERS: /* --servers or -s */ + opt_servers = strdup(optarg); + break; case OPT_EXPIRE: /* --expire */ errno = 0; @@ -183,19 +196,28 @@ static void options_parse(int argc, char *argv[]) { } break; - case OPT_HASH: opt_hash = strdup(optarg); break; + case OPT_HASH: + opt_hash = strdup(optarg); + break; - case OPT_USERNAME: opt_username = optarg; break; + case OPT_USERNAME: + opt_username = optarg; + break; - case OPT_PASSWD: opt_passwd = optarg; break; + case OPT_PASSWD: + opt_passwd = optarg; + break; - case OPT_QUIET: close_stdio(); break; + case OPT_QUIET: + close_stdio(); + break; case '?': /* getopt_long already printed an error message. */ exit(EXIT_SUCCESS); - default: abort(); + default: + abort(); } } diff --git a/src/bin/memslap.cc b/src/bin/memslap.cc index b7b606e9..a8ecf2d1 100644 --- a/src/bin/memslap.cc +++ b/src/bin/memslap.cc @@ -80,7 +80,9 @@ struct thread_context_st { , memc(NULL) , root(memc_arg) {} - void init() { memc = memcached_clone(NULL, root); } + void init() { + memc = memcached_clone(NULL, root); + } ~thread_context_st() { if (execute_pairs) { @@ -143,7 +145,9 @@ static __attribute__((noreturn)) void *run_task(void *p) { execute_set(context->memc, context->execute_pairs, context->execute_number); break; - case GET_TEST: execute_get(context->memc, context->initial_pairs, context->initial_number); break; + case GET_TEST: + execute_get(context->memc, context->initial_pairs, context->initial_number); + break; case MGET_TEST: execute_mget(context->memc, (const char *const *) context->keys, context->key_lengths, @@ -345,7 +349,8 @@ void options_parse(int argc, char *argv[]) { break; switch (option_rv) { - case 0: break; + case 0: + break; case OPT_UDP: if (opt_test == GET_TEST) { @@ -357,17 +362,29 @@ void options_parse(int argc, char *argv[]) { opt_udp_io = true; break; - case OPT_BINARY: opt_binary = true; break; + case OPT_BINARY: + opt_binary = true; + break; - case OPT_VERBOSE: /* --verbose or -v */ opt_verbose = OPT_VERBOSE; break; + case OPT_VERBOSE: /* --verbose or -v */ + opt_verbose = OPT_VERBOSE; + break; - case OPT_DEBUG: /* --debug or -d */ opt_verbose = OPT_DEBUG; break; + case OPT_DEBUG: /* --debug or -d */ + opt_verbose = OPT_DEBUG; + break; - case OPT_VERSION: /* --version or -V */ opt_version = true; break; + case OPT_VERSION: /* --version or -V */ + opt_version = true; + break; - case OPT_HELP: /* --help or -h */ opt_help = true; break; + case OPT_HELP: /* --help or -h */ + opt_help = true; + break; - case OPT_SERVERS: /* --servers or -s */ opt_servers = strdup(optarg); break; + case OPT_SERVERS: /* --servers or -s */ + opt_servers = strdup(optarg); + break; case OPT_SLAP_TEST: if (strcmp(optarg, "get") == 0) { @@ -415,13 +432,16 @@ void options_parse(int argc, char *argv[]) { } break; - case OPT_QUIET: close_stdio(); break; + case OPT_QUIET: + close_stdio(); + break; case '?': /* getopt_long already printed an error message. */ exit(EXIT_FAILURE); - default: abort(); + default: + abort(); } } diff --git a/src/bin/memstat.cc b/src/bin/memstat.cc index b7f75679..be2fe4a8 100644 --- a/src/bin/memstat.cc +++ b/src/bin/memstat.cc @@ -332,42 +332,64 @@ static void options_parse(int argc, char *argv[]) { break; switch (option_rv) { - case 0: break; + case 0: + break; - case OPT_VERBOSE: /* --verbose or -v */ opt_verbose = true; break; + case OPT_VERBOSE: /* --verbose or -v */ + opt_verbose = true; + break; - case OPT_DEBUG: /* --debug or -d */ opt_verbose = true; break; + case OPT_DEBUG: /* --debug or -d */ + opt_verbose = true; + break; - case OPT_BINARY: opt_binary = true; break; + case OPT_BINARY: + opt_binary = true; + break; - case OPT_SERVER_VERSION: opt_server_version = true; break; + case OPT_SERVER_VERSION: + opt_server_version = true; + break; - case OPT_VERSION: /* --version or -V */ opt_version = true; break; + case OPT_VERSION: /* --version or -V */ + opt_version = true; + break; - case OPT_HELP: /* --help or -h */ opt_help = true; break; + case OPT_HELP: /* --help or -h */ + opt_help = true; + break; - case OPT_SERVERS: /* --servers or -s */ opt_servers = strdup(optarg); break; + case OPT_SERVERS: /* --servers or -s */ + opt_servers = strdup(optarg); + break; - case OPT_STAT_ARGS: stat_args = strdup(optarg); break; + case OPT_STAT_ARGS: + stat_args = strdup(optarg); + break; case OPT_ANALYZE: /* --analyze or -a */ opt_analyze = true; analyze_mode = (optarg) ? strdup(optarg) : NULL; break; - case OPT_QUIET: close_stdio(); break; + case OPT_QUIET: + close_stdio(); + break; case OPT_USERNAME: opt_username = optarg; opt_binary = true; break; - case OPT_PASSWD: opt_passwd = optarg; break; + case OPT_PASSWD: + opt_passwd = optarg; + break; case '?': /* getopt_long already printed an error message. */ exit(1); - default: abort(); + default: + abort(); } } diff --git a/src/bin/memtouch.cc b/src/bin/memtouch.cc index 1de4b92f..e160e6a3 100644 --- a/src/bin/memtouch.cc +++ b/src/bin/memtouch.cc @@ -158,25 +158,44 @@ void options_parse(int argc, char *argv[]) { } switch (option_rv) { - case 0: break; + case 0: + break; - case OPT_BINARY: opt_binary = true; break; + case OPT_BINARY: + opt_binary = true; + break; - case OPT_VERBOSE: /* --verbose or -v */ opt_verbose = OPT_VERBOSE; break; + case OPT_VERBOSE: /* --verbose or -v */ + opt_verbose = OPT_VERBOSE; + break; - case OPT_DEBUG: /* --debug or -d */ opt_verbose = OPT_DEBUG; break; + case OPT_DEBUG: /* --debug or -d */ + opt_verbose = OPT_DEBUG; + break; - case OPT_VERSION: /* --version or -V */ opt_version = true; break; + case OPT_VERSION: /* --version or -V */ + opt_version = true; + break; - case OPT_HELP: /* --help or -h */ opt_help = true; break; + case OPT_HELP: /* --help or -h */ + opt_help = true; + break; - case OPT_SERVERS: /* --servers or -s */ opt_servers = strdup(optarg); break; + case OPT_SERVERS: /* --servers or -s */ + opt_servers = strdup(optarg); + break; - case OPT_HASH: opt_hash = strdup(optarg); break; + case OPT_HASH: + opt_hash = strdup(optarg); + break; - case OPT_USERNAME: opt_username = optarg; break; + case OPT_USERNAME: + opt_username = optarg; + break; - case OPT_PASSWD: opt_passwd = optarg; break; + case OPT_PASSWD: + opt_passwd = optarg; + break; case OPT_EXPIRE: errno = 0; @@ -187,13 +206,16 @@ void options_parse(int argc, char *argv[]) { } break; - case OPT_QUIET: close_stdio(); break; + case OPT_QUIET: + close_stdio(); + break; case '?': /* getopt_long already printed an error message. */ exit(EXIT_FAILURE); - default: abort(); + default: + abort(); } } diff --git a/src/libhashkit/digest.cc b/src/libhashkit/digest.cc index 3ea5588f..6ca176a6 100644 --- a/src/libhashkit/digest.cc +++ b/src/libhashkit/digest.cc @@ -22,20 +22,28 @@ uint32_t hashkit_digest(const hashkit_st *self, const char *key, size_t key_leng uint32_t libhashkit_digest(const char *key, size_t key_length, hashkit_hash_algorithm_t hash_algorithm) { switch (hash_algorithm) { - case HASHKIT_HASH_DEFAULT: return libhashkit_one_at_a_time(key, key_length); - case HASHKIT_HASH_MD5: return libhashkit_md5(key, key_length); - case HASHKIT_HASH_CRC: return libhashkit_crc32(key, key_length); - case HASHKIT_HASH_FNV1_64: return libhashkit_fnv1_64(key, key_length); - case HASHKIT_HASH_FNV1A_64: return libhashkit_fnv1a_64(key, key_length); - case HASHKIT_HASH_FNV1_32: return libhashkit_fnv1_32(key, key_length); - case HASHKIT_HASH_FNV1A_32: return libhashkit_fnv1a_32(key, key_length); + case HASHKIT_HASH_DEFAULT: + return libhashkit_one_at_a_time(key, key_length); + case HASHKIT_HASH_MD5: + return libhashkit_md5(key, key_length); + case HASHKIT_HASH_CRC: + return libhashkit_crc32(key, key_length); + case HASHKIT_HASH_FNV1_64: + return libhashkit_fnv1_64(key, key_length); + case HASHKIT_HASH_FNV1A_64: + return libhashkit_fnv1a_64(key, key_length); + case HASHKIT_HASH_FNV1_32: + return libhashkit_fnv1_32(key, key_length); + case HASHKIT_HASH_FNV1A_32: + return libhashkit_fnv1a_32(key, key_length); case HASHKIT_HASH_HSIEH: #ifdef HAVE_HSIEH_HASH return libhashkit_hsieh(key, key_length); #else return 1; #endif - case HASHKIT_HASH_MURMUR3: return libhashkit_murmur3(key, key_length); + case HASHKIT_HASH_MURMUR3: + return libhashkit_murmur3(key, key_length); case HASHKIT_HASH_MURMUR: #ifdef HAVE_MURMUR_HASH @@ -43,7 +51,8 @@ uint32_t libhashkit_digest(const char *key, size_t key_length, #else return 1; #endif - case HASHKIT_HASH_JENKINS: return libhashkit_jenkins(key, key_length); + case HASHKIT_HASH_JENKINS: + return libhashkit_jenkins(key, key_length); case HASHKIT_HASH_CUSTOM: case HASHKIT_HASH_MAX: default: diff --git a/src/libhashkit/function.cc b/src/libhashkit/function.cc index f66a63ea..67bb9947 100644 --- a/src/libhashkit/function.cc +++ b/src/libhashkit/function.cc @@ -22,9 +22,13 @@ static hashkit_return_t _set_function(struct hashkit_st::hashkit_function_st *se } switch (hash_algorithm) { - case HASHKIT_HASH_MD5: self->function = hashkit_md5; break; + case HASHKIT_HASH_MD5: + self->function = hashkit_md5; + break; - case HASHKIT_HASH_CRC: self->function = hashkit_crc32; break; + case HASHKIT_HASH_CRC: + self->function = hashkit_crc32; + break; case HASHKIT_HASH_FNV1_64: if (libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64)) { @@ -40,9 +44,13 @@ static hashkit_return_t _set_function(struct hashkit_st::hashkit_function_st *se } return HASHKIT_INVALID_ARGUMENT; - case HASHKIT_HASH_FNV1_32: self->function = hashkit_fnv1_32; break; + case HASHKIT_HASH_FNV1_32: + self->function = hashkit_fnv1_32; + break; - case HASHKIT_HASH_FNV1A_32: self->function = hashkit_fnv1a_32; break; + case HASHKIT_HASH_FNV1A_32: + self->function = hashkit_fnv1a_32; + break; case HASHKIT_HASH_HSIEH: if (libhashkit_has_algorithm(HASHKIT_HASH_HSIEH)) { @@ -64,13 +72,20 @@ static hashkit_return_t _set_function(struct hashkit_st::hashkit_function_st *se } return HASHKIT_INVALID_ARGUMENT; - case HASHKIT_HASH_JENKINS: self->function = hashkit_jenkins; break; + case HASHKIT_HASH_JENKINS: + self->function = hashkit_jenkins; + break; - case HASHKIT_HASH_CUSTOM: return HASHKIT_INVALID_ARGUMENT; + case HASHKIT_HASH_CUSTOM: + return HASHKIT_INVALID_ARGUMENT; - case HASHKIT_HASH_DEFAULT: self->function = hashkit_one_at_a_time; break; + case HASHKIT_HASH_DEFAULT: + self->function = hashkit_one_at_a_time; + break; - case HASHKIT_HASH_MAX: self->function = hashkit_one_at_a_time; return HASHKIT_INVALID_HASH; + case HASHKIT_HASH_MAX: + self->function = hashkit_one_at_a_time; + return HASHKIT_INVALID_HASH; } self->context = NULL; diff --git a/src/libhashkit/has.cc b/src/libhashkit/has.cc index 60e5af00..1a2dd762 100644 --- a/src/libhashkit/has.cc +++ b/src/libhashkit/has.cc @@ -46,9 +46,11 @@ bool libhashkit_has_algorithm(const hashkit_hash_algorithm_t algo) { case HASHKIT_HASH_MD5: case HASHKIT_HASH_CRC: case HASHKIT_HASH_JENKINS: - case HASHKIT_HASH_CUSTOM: return true; + case HASHKIT_HASH_CUSTOM: + return true; - case HASHKIT_HASH_MAX: break; + case HASHKIT_HASH_MAX: + break; } return false; diff --git a/src/libhashkit/hsieh.cc b/src/libhashkit/hsieh.cc index 6fc4fbb4..3a8baf89 100644 --- a/src/libhashkit/hsieh.cc +++ b/src/libhashkit/hsieh.cc @@ -62,7 +62,8 @@ uint32_t hashkit_hsieh(const char *key, size_t key_length, void *) { hash += (unsigned char) (*key); hash ^= hash << 10; hash += hash >> 1; - default: break; + default: + break; } /* Force "avalanching" of final 127 bits */ diff --git a/src/libhashkit/jenkins.cc b/src/libhashkit/jenkins.cc index b07509b9..64595f69 100644 --- a/src/libhashkit/jenkins.cc +++ b/src/libhashkit/jenkins.cc @@ -155,12 +155,22 @@ hashkit_jenkins(const char *key, size_t length, void *) { b += k[1] & 0xff; a += k[0]; break; - case 4: a += k[0]; break; - case 3: a += k[0] & 0xffffff; break; - case 2: a += k[0] & 0xffff; break; - case 1: a += k[0] & 0xff; break; - case 0: return c; /* zero length strings require no mixing */ - default: return c; + case 4: + a += k[0]; + break; + case 3: + a += k[0] & 0xffffff; + break; + case 2: + a += k[0] & 0xffff; + break; + case 1: + a += k[0] & 0xff; + break; + case 0: + return c; /* zero length strings require no mixing */ + default: + return c; } } else if ((u.i & 0x1) == 0) { @@ -210,14 +220,22 @@ hashkit_jenkins(const char *key, size_t length, void *) { case 5: b += k8[4]; /* fall through */ - case 4: a += k[0] + (((uint32_t) k[1]) << 16); break; + case 4: + a += k[0] + (((uint32_t) k[1]) << 16); + break; case 3: a += ((uint32_t) k8[2]) << 16; /* fall through */ - case 2: a += k[0]; break; - case 1: a += k8[0]; break; - case 0: return c; /* zero length requires no mixing */ - default: return c; + case 2: + a += k[0]; + break; + case 1: + a += k8[0]; + break; + case 0: + return c; /* zero length requires no mixing */ + default: + return c; } } else { /* need to read the key one byte at a time */ @@ -278,9 +296,13 @@ hashkit_jenkins(const char *key, size_t length, void *) { case 2: a += ((uint32_t) k[1]) << 8; /* fall through */ - case 1: a += k[0]; break; - case 0: return c; - default: return c; + case 1: + a += k[0]; + break; + case 0: + return c; + default: + return c; } #if !WORDS_BIGENDIAN } diff --git a/src/libhashkit/str_algorithm.cc b/src/libhashkit/str_algorithm.cc index 1a34653e..9c3bc3cd 100644 --- a/src/libhashkit/str_algorithm.cc +++ b/src/libhashkit/str_algorithm.cc @@ -17,19 +17,32 @@ const char *libhashkit_string_hash(hashkit_hash_algorithm_t type) { switch (type) { - case HASHKIT_HASH_DEFAULT: return "DEFAULT"; - case HASHKIT_HASH_MD5: return "MD5"; - case HASHKIT_HASH_CRC: return "CRC"; - case HASHKIT_HASH_FNV1_64: return "FNV1_64"; - case HASHKIT_HASH_FNV1A_64: return "FNV1A_64"; - case HASHKIT_HASH_FNV1_32: return "FNV1_32"; - case HASHKIT_HASH_FNV1A_32: return "FNV1A_32"; - case HASHKIT_HASH_HSIEH: return "HSIEH"; - case HASHKIT_HASH_MURMUR: return "MURMUR"; - case HASHKIT_HASH_MURMUR3: return "MURMUR3"; - case HASHKIT_HASH_JENKINS: return "JENKINS"; - case HASHKIT_HASH_CUSTOM: return "CUSTOM"; + case HASHKIT_HASH_DEFAULT: + return "DEFAULT"; + case HASHKIT_HASH_MD5: + return "MD5"; + case HASHKIT_HASH_CRC: + return "CRC"; + case HASHKIT_HASH_FNV1_64: + return "FNV1_64"; + case HASHKIT_HASH_FNV1A_64: + return "FNV1A_64"; + case HASHKIT_HASH_FNV1_32: + return "FNV1_32"; + case HASHKIT_HASH_FNV1A_32: + return "FNV1A_32"; + case HASHKIT_HASH_HSIEH: + return "HSIEH"; + case HASHKIT_HASH_MURMUR: + return "MURMUR"; + case HASHKIT_HASH_MURMUR3: + return "MURMUR3"; + case HASHKIT_HASH_JENKINS: + return "JENKINS"; + case HASHKIT_HASH_CUSTOM: + return "CUSTOM"; default: - case HASHKIT_HASH_MAX: return "INVALID"; + case HASHKIT_HASH_MAX: + return "INVALID"; } } diff --git a/src/libhashkit/strerror.cc b/src/libhashkit/strerror.cc index 997aff26..022fb22c 100644 --- a/src/libhashkit/strerror.cc +++ b/src/libhashkit/strerror.cc @@ -18,12 +18,18 @@ const char *hashkit_strerror(hashkit_st *ptr, hashkit_return_t rc) { (void) ptr; switch (rc) { - case HASHKIT_SUCCESS: return "SUCCESS"; - case HASHKIT_FAILURE: return "FAILURE"; - case HASHKIT_MEMORY_ALLOCATION_FAILURE: return "MEMORY ALLOCATION FAILURE"; - case HASHKIT_INVALID_ARGUMENT: return "INVALID ARGUMENT"; - case HASHKIT_INVALID_HASH: return "INVALID hashkit_hash_algorithm_t"; + case HASHKIT_SUCCESS: + return "SUCCESS"; + case HASHKIT_FAILURE: + return "FAILURE"; + case HASHKIT_MEMORY_ALLOCATION_FAILURE: + return "MEMORY ALLOCATION FAILURE"; + case HASHKIT_INVALID_ARGUMENT: + return "INVALID ARGUMENT"; + case HASHKIT_INVALID_HASH: + return "INVALID hashkit_hash_algorithm_t"; case HASHKIT_MAXIMUM_RETURN: - default: return "INVALID hashkit_return_t"; + default: + return "INVALID hashkit_return_t"; } } diff --git a/src/libmemcached/behavior.cc b/src/libmemcached/behavior.cc index 08f86f94..576ec883 100644 --- a/src/libmemcached/behavior.cc +++ b/src/libmemcached/behavior.cc @@ -25,12 +25,14 @@ bool memcached_is_consistent_distribution(const Memcached *memc) { case MEMCACHED_DISTRIBUTION_CONSISTENT: case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA: case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY: - case MEMCACHED_DISTRIBUTION_CONSISTENT_WEIGHTED: return true; + case MEMCACHED_DISTRIBUTION_CONSISTENT_WEIGHTED: + return true; case MEMCACHED_DISTRIBUTION_MODULA: case MEMCACHED_DISTRIBUTION_RANDOM: case MEMCACHED_DISTRIBUTION_VIRTUAL_BUCKET: - case MEMCACHED_DISTRIBUTION_CONSISTENT_MAX: break; + case MEMCACHED_DISTRIBUTION_CONSISTENT_MAX: + break; } return false; @@ -50,19 +52,33 @@ memcached_return_t memcached_behavior_set(memcached_st *shell, const memcached_b } switch (flag) { - case MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS: ptr->number_of_replicas = (uint32_t) data; break; + case MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS: + ptr->number_of_replicas = (uint32_t) data; + break; - case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK: ptr->io_msg_watermark = (uint32_t) data; break; + case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK: + ptr->io_msg_watermark = (uint32_t) data; + break; - case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK: ptr->io_bytes_watermark = (uint32_t) data; break; + case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK: + ptr->io_bytes_watermark = (uint32_t) data; + break; - case MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH: ptr->io_key_prefetch = (uint32_t) data; break; + case MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH: + ptr->io_key_prefetch = (uint32_t) data; + break; - case MEMCACHED_BEHAVIOR_SND_TIMEOUT: ptr->snd_timeout = (int32_t) data; break; + case MEMCACHED_BEHAVIOR_SND_TIMEOUT: + ptr->snd_timeout = (int32_t) data; + break; - case MEMCACHED_BEHAVIOR_RCV_TIMEOUT: ptr->rcv_timeout = (int32_t) data; break; + case MEMCACHED_BEHAVIOR_RCV_TIMEOUT: + ptr->rcv_timeout = (int32_t) data; + break; - case MEMCACHED_BEHAVIOR_REMOVE_FAILED_SERVERS: ptr->flags.auto_eject_hosts = bool(data); break; + case MEMCACHED_BEHAVIOR_REMOVE_FAILED_SERVERS: + ptr->flags.auto_eject_hosts = bool(data); + break; case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT: if (data == 0) { @@ -74,7 +90,9 @@ memcached_return_t memcached_behavior_set(memcached_st *shell, const memcached_b ptr->server_failure_limit = uint32_t(data); break; - case MEMCACHED_BEHAVIOR_SERVER_TIMEOUT_LIMIT: ptr->server_timeout_limit = uint32_t(data); break; + case MEMCACHED_BEHAVIOR_SERVER_TIMEOUT_LIMIT: + ptr->server_timeout_limit = uint32_t(data); + break; case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL: send_quit( @@ -85,7 +103,9 @@ memcached_return_t memcached_behavior_set(memcached_st *shell, const memcached_b ptr->flags.binary_protocol = bool(data); break; - case MEMCACHED_BEHAVIOR_SUPPORT_CAS: ptr->flags.support_cas = bool(data); break; + case MEMCACHED_BEHAVIOR_SUPPORT_CAS: + ptr->flags.support_cas = bool(data); + break; case MEMCACHED_BEHAVIOR_NO_BLOCK: ptr->flags.no_block = bool(data); @@ -176,13 +196,21 @@ memcached_return_t memcached_behavior_set(memcached_st *shell, const memcached_b return run_distribution(ptr); } - case MEMCACHED_BEHAVIOR_POLL_TIMEOUT: ptr->poll_timeout = (int32_t) data; break; + case MEMCACHED_BEHAVIOR_POLL_TIMEOUT: + ptr->poll_timeout = (int32_t) data; + break; - case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT: ptr->connect_timeout = (int32_t) data; break; + case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT: + ptr->connect_timeout = (int32_t) data; + break; - case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT: ptr->retry_timeout = int32_t(data); break; + case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT: + ptr->retry_timeout = int32_t(data); + break; - case MEMCACHED_BEHAVIOR_DEAD_TIMEOUT: ptr->dead_timeout = int32_t(data); break; + case MEMCACHED_BEHAVIOR_DEAD_TIMEOUT: + ptr->dead_timeout = int32_t(data); + break; case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE: ptr->send_size = (int32_t) data; @@ -203,7 +231,9 @@ memcached_return_t memcached_behavior_set(memcached_st *shell, const memcached_b return memcached_set_error(*ptr, MEMCACHED_DEPRECATED, MEMCACHED_AT, memcached_literal_param("MEMCACHED_BEHAVIOR_USER_DATA deprecated.")); - case MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY: ptr->flags.hash_with_namespace = bool(data); break; + case MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY: + ptr->flags.hash_with_namespace = bool(data); + break; case MEMCACHED_BEHAVIOR_NOREPLY: if (memcached_is_udp(ptr) and bool(data) == false) { @@ -217,7 +247,9 @@ memcached_return_t memcached_behavior_set(memcached_st *shell, const memcached_b ptr->flags.reply = bool(data) ? false : true; break; - case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS: ptr->flags.auto_eject_hosts = bool(data); break; + case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS: + ptr->flags.auto_eject_hosts = bool(data); + break; case MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ: srandom((uint32_t) time(NULL)); @@ -259,29 +291,41 @@ uint64_t memcached_behavior_get(memcached_st *shell, const memcached_behavior_t } switch (flag) { - case MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS: return ptr->number_of_replicas; + case MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS: + return ptr->number_of_replicas; - case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK: return ptr->io_msg_watermark; + case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK: + return ptr->io_msg_watermark; - case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK: return ptr->io_bytes_watermark; + case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK: + return ptr->io_bytes_watermark; - case MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH: return ptr->io_key_prefetch; + case MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH: + return ptr->io_key_prefetch; - case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL: return ptr->flags.binary_protocol; + case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL: + return ptr->flags.binary_protocol; - case MEMCACHED_BEHAVIOR_SUPPORT_CAS: return ptr->flags.support_cas; + case MEMCACHED_BEHAVIOR_SUPPORT_CAS: + return ptr->flags.support_cas; - case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS: return true; + case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS: + return true; - case MEMCACHED_BEHAVIOR_NO_BLOCK: return ptr->flags.no_block; + case MEMCACHED_BEHAVIOR_NO_BLOCK: + return ptr->flags.no_block; - case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS: return ptr->flags.buffer_requests; + case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS: + return ptr->flags.buffer_requests; - case MEMCACHED_BEHAVIOR_USE_UDP: return memcached_is_udp(ptr); + case MEMCACHED_BEHAVIOR_USE_UDP: + return memcached_is_udp(ptr); - case MEMCACHED_BEHAVIOR_TCP_NODELAY: return ptr->flags.tcp_nodelay; + case MEMCACHED_BEHAVIOR_TCP_NODELAY: + return ptr->flags.tcp_nodelay; - case MEMCACHED_BEHAVIOR_VERIFY_KEY: return ptr->flags.verify_key; + case MEMCACHED_BEHAVIOR_VERIFY_KEY: + return ptr->flags.verify_key; case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED: if (memcached_is_consistent_distribution(ptr)) { @@ -289,35 +333,50 @@ uint64_t memcached_behavior_get(memcached_st *shell, const memcached_behavior_t } return false; - case MEMCACHED_BEHAVIOR_DISTRIBUTION: return ptr->distribution; + case MEMCACHED_BEHAVIOR_DISTRIBUTION: + return ptr->distribution; - case MEMCACHED_BEHAVIOR_KETAMA: return memcached_is_consistent_distribution(ptr); + case MEMCACHED_BEHAVIOR_KETAMA: + return memcached_is_consistent_distribution(ptr); - case MEMCACHED_BEHAVIOR_HASH: return hashkit_get_function(&ptr->hashkit); + case MEMCACHED_BEHAVIOR_HASH: + return hashkit_get_function(&ptr->hashkit); - case MEMCACHED_BEHAVIOR_KETAMA_HASH: return hashkit_get_distribution_function(&ptr->hashkit); + case MEMCACHED_BEHAVIOR_KETAMA_HASH: + return hashkit_get_distribution_function(&ptr->hashkit); - case MEMCACHED_BEHAVIOR_REMOVE_FAILED_SERVERS: return ptr->flags.auto_eject_hosts; + case MEMCACHED_BEHAVIOR_REMOVE_FAILED_SERVERS: + return ptr->flags.auto_eject_hosts; - case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT: return ptr->server_failure_limit; + case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT: + return ptr->server_failure_limit; - case MEMCACHED_BEHAVIOR_SERVER_TIMEOUT_LIMIT: return ptr->server_timeout_limit; + case MEMCACHED_BEHAVIOR_SERVER_TIMEOUT_LIMIT: + return ptr->server_timeout_limit; - case MEMCACHED_BEHAVIOR_SORT_HOSTS: return ptr->flags.use_sort_hosts; + case MEMCACHED_BEHAVIOR_SORT_HOSTS: + return ptr->flags.use_sort_hosts; - case MEMCACHED_BEHAVIOR_POLL_TIMEOUT: return (uint64_t) ptr->poll_timeout; + case MEMCACHED_BEHAVIOR_POLL_TIMEOUT: + return (uint64_t) ptr->poll_timeout; - case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT: return (uint64_t) ptr->connect_timeout; + case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT: + return (uint64_t) ptr->connect_timeout; - case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT: return (uint64_t) ptr->retry_timeout; + case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT: + return (uint64_t) ptr->retry_timeout; - case MEMCACHED_BEHAVIOR_DEAD_TIMEOUT: return uint64_t(ptr->dead_timeout); + case MEMCACHED_BEHAVIOR_DEAD_TIMEOUT: + return uint64_t(ptr->dead_timeout); - case MEMCACHED_BEHAVIOR_SND_TIMEOUT: return (uint64_t) ptr->snd_timeout; + case MEMCACHED_BEHAVIOR_SND_TIMEOUT: + return (uint64_t) ptr->snd_timeout; - case MEMCACHED_BEHAVIOR_RCV_TIMEOUT: return (uint64_t) ptr->rcv_timeout; + case MEMCACHED_BEHAVIOR_RCV_TIMEOUT: + return (uint64_t) ptr->rcv_timeout; - case MEMCACHED_BEHAVIOR_TCP_KEEPIDLE: return (uint64_t) ptr->tcp_keepidle; + case MEMCACHED_BEHAVIOR_TCP_KEEPIDLE: + return (uint64_t) ptr->tcp_keepidle; case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE: { int sock_size = 0; @@ -387,13 +446,17 @@ uint64_t memcached_behavior_get(memcached_st *shell, const memcached_behavior_t memcached_literal_param("MEMCACHED_BEHAVIOR_USER_DATA deprecated.")); return 0; - case MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY: return ptr->flags.hash_with_namespace; + case MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY: + return ptr->flags.hash_with_namespace; - case MEMCACHED_BEHAVIOR_NOREPLY: return ptr->flags.reply ? false : true; + case MEMCACHED_BEHAVIOR_NOREPLY: + return ptr->flags.reply ? false : true; - case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS: return ptr->flags.auto_eject_hosts; + case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS: + return ptr->flags.auto_eject_hosts; - case MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ: return ptr->flags.randomize_replica_read; + case MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ: + return ptr->flags.randomize_replica_read; case MEMCACHED_BEHAVIOR_CORK: #ifdef HAVE_MSG_MORE @@ -402,12 +465,16 @@ uint64_t memcached_behavior_get(memcached_st *shell, const memcached_behavior_t return false; #endif - case MEMCACHED_BEHAVIOR_TCP_KEEPALIVE: return ptr->flags.tcp_keepalive; + case MEMCACHED_BEHAVIOR_TCP_KEEPALIVE: + return ptr->flags.tcp_keepalive; - case MEMCACHED_BEHAVIOR_LOAD_FROM_FILE: return bool(memcached_parse_filename(ptr)); + case MEMCACHED_BEHAVIOR_LOAD_FROM_FILE: + return bool(memcached_parse_filename(ptr)); case MEMCACHED_BEHAVIOR_MAX: - default: assert_msg(0, "Invalid behavior passed to memcached_behavior_get()"); return 0; + default: + assert_msg(0, "Invalid behavior passed to memcached_behavior_get()"); + return 0; } /* NOTREACHED */ @@ -418,20 +485,26 @@ memcached_return_t memcached_behavior_set_distribution(memcached_st *shell, Memcached *ptr = memcached2Memcached(shell); if (ptr) { switch (type) { - case MEMCACHED_DISTRIBUTION_MODULA: break; + case MEMCACHED_DISTRIBUTION_MODULA: + break; case MEMCACHED_DISTRIBUTION_CONSISTENT: - case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA: memcached_set_weighted_ketama(ptr, false); break; + case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA: + memcached_set_weighted_ketama(ptr, false); + break; - case MEMCACHED_DISTRIBUTION_RANDOM: break; + case MEMCACHED_DISTRIBUTION_RANDOM: + break; - case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY: break; + case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY: + break; case MEMCACHED_DISTRIBUTION_CONSISTENT_WEIGHTED: memcached_set_weighted_ketama(ptr, true); break; - case MEMCACHED_DISTRIBUTION_VIRTUAL_BUCKET: break; + case MEMCACHED_DISTRIBUTION_VIRTUAL_BUCKET: + break; default: case MEMCACHED_DISTRIBUTION_CONSISTENT_MAX: @@ -507,63 +580,107 @@ memcached_hash_t memcached_behavior_get_distribution_hash(memcached_st *shell) { const char *libmemcached_string_behavior(const memcached_behavior_t flag) { switch (flag) { - case MEMCACHED_BEHAVIOR_SERVER_TIMEOUT_LIMIT: return "MEMCACHED_BEHAVIOR_SERVER_TIMEOUT_LIMIT"; - case MEMCACHED_BEHAVIOR_NO_BLOCK: return "MEMCACHED_BEHAVIOR_NO_BLOCK"; - case MEMCACHED_BEHAVIOR_TCP_NODELAY: return "MEMCACHED_BEHAVIOR_TCP_NODELAY"; - case MEMCACHED_BEHAVIOR_HASH: return "MEMCACHED_BEHAVIOR_HASH"; - case MEMCACHED_BEHAVIOR_KETAMA: return "MEMCACHED_BEHAVIOR_KETAMA"; - case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE: return "MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE"; - case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE: return "MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE"; - case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS: return "MEMCACHED_BEHAVIOR_CACHE_LOOKUPS"; - case MEMCACHED_BEHAVIOR_SUPPORT_CAS: return "MEMCACHED_BEHAVIOR_SUPPORT_CAS"; - case MEMCACHED_BEHAVIOR_POLL_TIMEOUT: return "MEMCACHED_BEHAVIOR_POLL_TIMEOUT"; - case MEMCACHED_BEHAVIOR_DISTRIBUTION: return "MEMCACHED_BEHAVIOR_DISTRIBUTION"; - case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS: return "MEMCACHED_BEHAVIOR_BUFFER_REQUESTS"; - case MEMCACHED_BEHAVIOR_USER_DATA: return "MEMCACHED_BEHAVIOR_USER_DATA"; - case MEMCACHED_BEHAVIOR_SORT_HOSTS: return "MEMCACHED_BEHAVIOR_SORT_HOSTS"; - case MEMCACHED_BEHAVIOR_VERIFY_KEY: return "MEMCACHED_BEHAVIOR_VERIFY_KEY"; - case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT: return "MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT"; - case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT: return "MEMCACHED_BEHAVIOR_RETRY_TIMEOUT"; - case MEMCACHED_BEHAVIOR_DEAD_TIMEOUT: return "MEMCACHED_BEHAVIOR_DEAD_TIMEOUT"; - case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED: return "MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED"; - case MEMCACHED_BEHAVIOR_KETAMA_HASH: return "MEMCACHED_BEHAVIOR_KETAMA_HASH"; - case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL: return "MEMCACHED_BEHAVIOR_BINARY_PROTOCOL"; - case MEMCACHED_BEHAVIOR_SND_TIMEOUT: return "MEMCACHED_BEHAVIOR_SND_TIMEOUT"; - case MEMCACHED_BEHAVIOR_RCV_TIMEOUT: return "MEMCACHED_BEHAVIOR_RCV_TIMEOUT"; - case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT: return "MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT"; - case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK: return "MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK"; - case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK: return "MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK"; - case MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH: return "MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH"; - case MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY: return "MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY"; - case MEMCACHED_BEHAVIOR_NOREPLY: return "MEMCACHED_BEHAVIOR_NOREPLY"; - case MEMCACHED_BEHAVIOR_USE_UDP: return "MEMCACHED_BEHAVIOR_USE_UDP"; - case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS: return "MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS"; - case MEMCACHED_BEHAVIOR_REMOVE_FAILED_SERVERS: return "MEMCACHED_BEHAVIOR_REMOVE_FAILED_SERVERS"; - case MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS: return "MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS"; + case MEMCACHED_BEHAVIOR_SERVER_TIMEOUT_LIMIT: + return "MEMCACHED_BEHAVIOR_SERVER_TIMEOUT_LIMIT"; + case MEMCACHED_BEHAVIOR_NO_BLOCK: + return "MEMCACHED_BEHAVIOR_NO_BLOCK"; + case MEMCACHED_BEHAVIOR_TCP_NODELAY: + return "MEMCACHED_BEHAVIOR_TCP_NODELAY"; + case MEMCACHED_BEHAVIOR_HASH: + return "MEMCACHED_BEHAVIOR_HASH"; + case MEMCACHED_BEHAVIOR_KETAMA: + return "MEMCACHED_BEHAVIOR_KETAMA"; + case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE: + return "MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE"; + case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE: + return "MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE"; + case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS: + return "MEMCACHED_BEHAVIOR_CACHE_LOOKUPS"; + case MEMCACHED_BEHAVIOR_SUPPORT_CAS: + return "MEMCACHED_BEHAVIOR_SUPPORT_CAS"; + case MEMCACHED_BEHAVIOR_POLL_TIMEOUT: + return "MEMCACHED_BEHAVIOR_POLL_TIMEOUT"; + case MEMCACHED_BEHAVIOR_DISTRIBUTION: + return "MEMCACHED_BEHAVIOR_DISTRIBUTION"; + case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS: + return "MEMCACHED_BEHAVIOR_BUFFER_REQUESTS"; + case MEMCACHED_BEHAVIOR_USER_DATA: + return "MEMCACHED_BEHAVIOR_USER_DATA"; + case MEMCACHED_BEHAVIOR_SORT_HOSTS: + return "MEMCACHED_BEHAVIOR_SORT_HOSTS"; + case MEMCACHED_BEHAVIOR_VERIFY_KEY: + return "MEMCACHED_BEHAVIOR_VERIFY_KEY"; + case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT: + return "MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT"; + case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT: + return "MEMCACHED_BEHAVIOR_RETRY_TIMEOUT"; + case MEMCACHED_BEHAVIOR_DEAD_TIMEOUT: + return "MEMCACHED_BEHAVIOR_DEAD_TIMEOUT"; + case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED: + return "MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED"; + case MEMCACHED_BEHAVIOR_KETAMA_HASH: + return "MEMCACHED_BEHAVIOR_KETAMA_HASH"; + case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL: + return "MEMCACHED_BEHAVIOR_BINARY_PROTOCOL"; + case MEMCACHED_BEHAVIOR_SND_TIMEOUT: + return "MEMCACHED_BEHAVIOR_SND_TIMEOUT"; + case MEMCACHED_BEHAVIOR_RCV_TIMEOUT: + return "MEMCACHED_BEHAVIOR_RCV_TIMEOUT"; + case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT: + return "MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT"; + case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK: + return "MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK"; + case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK: + return "MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK"; + case MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH: + return "MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH"; + case MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY: + return "MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY"; + case MEMCACHED_BEHAVIOR_NOREPLY: + return "MEMCACHED_BEHAVIOR_NOREPLY"; + case MEMCACHED_BEHAVIOR_USE_UDP: + return "MEMCACHED_BEHAVIOR_USE_UDP"; + case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS: + return "MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS"; + case MEMCACHED_BEHAVIOR_REMOVE_FAILED_SERVERS: + return "MEMCACHED_BEHAVIOR_REMOVE_FAILED_SERVERS"; + case MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS: + return "MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS"; case MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ: return "MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ"; - case MEMCACHED_BEHAVIOR_CORK: return "MEMCACHED_BEHAVIOR_CORK"; - case MEMCACHED_BEHAVIOR_TCP_KEEPALIVE: return "MEMCACHED_BEHAVIOR_TCP_KEEPALIVE"; - case MEMCACHED_BEHAVIOR_TCP_KEEPIDLE: return "MEMCACHED_BEHAVIOR_TCP_KEEPIDLE"; - case MEMCACHED_BEHAVIOR_LOAD_FROM_FILE: return "MEMCACHED_BEHAVIOR_LOAD_FROM_FILE"; + case MEMCACHED_BEHAVIOR_CORK: + return "MEMCACHED_BEHAVIOR_CORK"; + case MEMCACHED_BEHAVIOR_TCP_KEEPALIVE: + return "MEMCACHED_BEHAVIOR_TCP_KEEPALIVE"; + case MEMCACHED_BEHAVIOR_TCP_KEEPIDLE: + return "MEMCACHED_BEHAVIOR_TCP_KEEPIDLE"; + case MEMCACHED_BEHAVIOR_LOAD_FROM_FILE: + return "MEMCACHED_BEHAVIOR_LOAD_FROM_FILE"; default: - case MEMCACHED_BEHAVIOR_MAX: return "INVALID memcached_behavior_t"; + case MEMCACHED_BEHAVIOR_MAX: + return "INVALID memcached_behavior_t"; } } const char *libmemcached_string_distribution(const memcached_server_distribution_t flag) { switch (flag) { - case MEMCACHED_DISTRIBUTION_MODULA: return "MEMCACHED_DISTRIBUTION_MODULA"; - case MEMCACHED_DISTRIBUTION_CONSISTENT: return "MEMCACHED_DISTRIBUTION_CONSISTENT"; - case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA: return "MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA"; - case MEMCACHED_DISTRIBUTION_RANDOM: return "MEMCACHED_DISTRIBUTION_RANDOM"; + case MEMCACHED_DISTRIBUTION_MODULA: + return "MEMCACHED_DISTRIBUTION_MODULA"; + case MEMCACHED_DISTRIBUTION_CONSISTENT: + return "MEMCACHED_DISTRIBUTION_CONSISTENT"; + case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA: + return "MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA"; + case MEMCACHED_DISTRIBUTION_RANDOM: + return "MEMCACHED_DISTRIBUTION_RANDOM"; case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY: return "MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY"; case MEMCACHED_DISTRIBUTION_CONSISTENT_WEIGHTED: return "MEMCACHED_DISTRIBUTION_CONSISTENT_WEIGHTED"; - case MEMCACHED_DISTRIBUTION_VIRTUAL_BUCKET: return "MEMCACHED_DISTRIBUTION_VIRTUAL_BUCKET"; + case MEMCACHED_DISTRIBUTION_VIRTUAL_BUCKET: + return "MEMCACHED_DISTRIBUTION_VIRTUAL_BUCKET"; default: - case MEMCACHED_DISTRIBUTION_CONSISTENT_MAX: return "INVALID memcached_server_distribution_t"; + case MEMCACHED_DISTRIBUTION_CONSISTENT_MAX: + return "INVALID memcached_server_distribution_t"; } } diff --git a/src/libmemcached/callback.cc b/src/libmemcached/callback.cc index eaa54568..fbbf68d7 100644 --- a/src/libmemcached/callback.cc +++ b/src/libmemcached/callback.cc @@ -136,7 +136,8 @@ void *memcached_callback_get(memcached_st *shell, const memcached_callback_t fla return *(void **) &ptr->delete_trigger; } - case MEMCACHED_CALLBACK_MAX: break; + case MEMCACHED_CALLBACK_MAX: + break; } assert_msg(0, "Invalid callback passed to memcached_callback_get()"); diff --git a/src/libmemcached/connect.cc b/src/libmemcached/connect.cc index 04b86f62..3648a242 100644 --- a/src/libmemcached/connect.cc +++ b/src/libmemcached/connect.cc @@ -65,7 +65,8 @@ static memcached_return_t connect_poll(memcached_instance_st *server, const int #ifdef __linux__ case ERESTART: #endif - case EINTR: continue; + case EINTR: + continue; case EFAULT: case ENOMEM: @@ -422,9 +423,13 @@ static memcached_return_t unix_socket_connect(memcached_instance_st *server) { switch (errno) { case EINPROGRESS: case EALREADY: - case EAGAIN: server->events(POLLOUT); break; + case EAGAIN: + server->events(POLLOUT); + break; - case EINTR: server->reset_socket(); continue; + case EINTR: + server->reset_socket(); + continue; case EISCONN: /* We were spinning waiting on connect */ { @@ -509,7 +514,9 @@ static memcached_return_t network_connect(memcached_instance_st *server) { /* An error occurred */ int local_error = get_socket_errno(); switch (local_error) { - case ETIMEDOUT: timeout_error_occured = true; break; + case ETIMEDOUT: + timeout_error_occured = true; + break; #if EWOULDBLOCK != EAGAIN case EWOULDBLOCK: @@ -544,7 +551,9 @@ static memcached_return_t network_connect(memcached_instance_st *server) { case ECONNREFUSED: // Probably not running service - default: memcached_set_errno(*server, local_error, MEMCACHED_AT); break; + default: + memcached_set_errno(*server, local_error, MEMCACHED_AT); + break; } WATCHPOINT_ASSERT(server->fd != INVALID_SOCKET); @@ -672,7 +681,8 @@ static memcached_return_t _memcached_connect(memcached_instance_st *server, /* We need to clean up the multi startup piece */ switch (server->type) { case MEMCACHED_CONNECTION_UDP: - case MEMCACHED_CONNECTION_TCP: rc = network_connect(server); + case MEMCACHED_CONNECTION_TCP: + rc = network_connect(server); #if defined(LIBMEMCACHED_WITH_SASL_SUPPORT) if (LIBMEMCACHED_WITH_SASL_SUPPORT) { @@ -687,7 +697,9 @@ static memcached_return_t _memcached_connect(memcached_instance_st *server, #endif break; - case MEMCACHED_CONNECTION_UNIX_SOCKET: rc = unix_socket_connect(server); break; + case MEMCACHED_CONNECTION_UNIX_SOCKET: + rc = unix_socket_connect(server); + break; } if (memcached_success(rc)) { diff --git a/src/libmemcached/csl/context.h b/src/libmemcached/csl/context.h index 2fa62407..4339f9e5 100644 --- a/src/libmemcached/csl/context.h +++ b/src/libmemcached/csl/context.h @@ -41,7 +41,9 @@ public: memcached_string_create(memc, &_string_buffer, 1024); } - bool end() { return _end; } + bool end() { + return _end; + } void start(); @@ -52,17 +54,25 @@ public: bool set_hash(memcached_hash_t hash); - void set_server() { _is_server = true; } + void set_server() { + _is_server = true; + } - void unset_server() { _is_server = false; } + void unset_server() { + _is_server = false; + } - bool is_server() const { return _is_server; } + bool is_server() const { + return _is_server; + } void hostname(const char *, size_t, server_t &); bool string_buffer(const char *, size_t, memcached_string_t &); - const char *hostname() const { return _hostname; } + const char *hostname() const { + return _hostname; + } void abort(const char *, config_tokentype, const char *); void error(const char *, config_tokentype, const char *); diff --git a/src/libmemcached/flag.cc b/src/libmemcached/flag.cc index c17ea4e0..dec8266c 100644 --- a/src/libmemcached/flag.cc +++ b/src/libmemcached/flag.cc @@ -17,35 +17,50 @@ bool memcached_flag(const memcached_st &memc, const memcached_flag_t flag) { switch (flag) { - case MEMCACHED_FLAG_AUTO_EJECT_HOSTS: return memcached_is_auto_eject_hosts(&memc); + case MEMCACHED_FLAG_AUTO_EJECT_HOSTS: + return memcached_is_auto_eject_hosts(&memc); - case MEMCACHED_FLAG_BINARY_PROTOCOL: return memcached_is_binary(&memc); + case MEMCACHED_FLAG_BINARY_PROTOCOL: + return memcached_is_binary(&memc); - case MEMCACHED_FLAG_BUFFER_REQUESTS: return memcached_is_buffering(&memc); + case MEMCACHED_FLAG_BUFFER_REQUESTS: + return memcached_is_buffering(&memc); - case MEMCACHED_FLAG_HASH_WITH_NAMESPACE: return memcached_is_hash_with_namespace(&memc); + case MEMCACHED_FLAG_HASH_WITH_NAMESPACE: + return memcached_is_hash_with_namespace(&memc); - case MEMCACHED_FLAG_NO_BLOCK: return memcached_is_no_block(&memc); + case MEMCACHED_FLAG_NO_BLOCK: + return memcached_is_no_block(&memc); - case MEMCACHED_FLAG_REPLY: return memcached_is_replying(&memc); + case MEMCACHED_FLAG_REPLY: + return memcached_is_replying(&memc); - case MEMCACHED_FLAG_RANDOMIZE_REPLICA_READ: return memcached_is_randomize_replica_read(&memc); + case MEMCACHED_FLAG_RANDOMIZE_REPLICA_READ: + return memcached_is_randomize_replica_read(&memc); - case MEMCACHED_FLAG_SUPPORT_CAS: return memcached_is_cas(&memc); + case MEMCACHED_FLAG_SUPPORT_CAS: + return memcached_is_cas(&memc); - case MEMCACHED_FLAG_TCP_NODELAY: return memcached_is_tcp_nodelay(&memc); + case MEMCACHED_FLAG_TCP_NODELAY: + return memcached_is_tcp_nodelay(&memc); - case MEMCACHED_FLAG_USE_SORT_HOSTS: return memcached_is_use_sort_hosts(&memc); + case MEMCACHED_FLAG_USE_SORT_HOSTS: + return memcached_is_use_sort_hosts(&memc); - case MEMCACHED_FLAG_USE_UDP: return memcached_is_udp(&memc); + case MEMCACHED_FLAG_USE_UDP: + return memcached_is_udp(&memc); - case MEMCACHED_FLAG_VERIFY_KEY: return memcached_is_verify_key(&memc); + case MEMCACHED_FLAG_VERIFY_KEY: + return memcached_is_verify_key(&memc); - case MEMCACHED_FLAG_TCP_KEEPALIVE: return memcached_is_use_sort_hosts(&memc); + case MEMCACHED_FLAG_TCP_KEEPALIVE: + return memcached_is_use_sort_hosts(&memc); - case MEMCACHED_FLAG_IS_AES: return memcached_is_aes(&memc); + case MEMCACHED_FLAG_IS_AES: + return memcached_is_aes(&memc); - case MEMCACHED_FLAG_IS_FETCHING_VERSION: return memcached_is_fetching_version(&memc); + case MEMCACHED_FLAG_IS_FETCHING_VERSION: + return memcached_is_fetching_version(&memc); } abort(); @@ -53,36 +68,64 @@ bool memcached_flag(const memcached_st &memc, const memcached_flag_t flag) { void memcached_flag(memcached_st &memc, const memcached_flag_t flag, const bool arg) { switch (flag) { - case MEMCACHED_FLAG_AUTO_EJECT_HOSTS: memcached_set_auto_eject_hosts(memc, arg); break; + case MEMCACHED_FLAG_AUTO_EJECT_HOSTS: + memcached_set_auto_eject_hosts(memc, arg); + break; - case MEMCACHED_FLAG_BINARY_PROTOCOL: memcached_set_binary(memc, arg); break; + case MEMCACHED_FLAG_BINARY_PROTOCOL: + memcached_set_binary(memc, arg); + break; - case MEMCACHED_FLAG_BUFFER_REQUESTS: memcached_set_buffering(memc, arg); break; + case MEMCACHED_FLAG_BUFFER_REQUESTS: + memcached_set_buffering(memc, arg); + break; - case MEMCACHED_FLAG_HASH_WITH_NAMESPACE: memcached_set_hash_with_namespace(memc, arg); break; + case MEMCACHED_FLAG_HASH_WITH_NAMESPACE: + memcached_set_hash_with_namespace(memc, arg); + break; - case MEMCACHED_FLAG_NO_BLOCK: memcached_set_no_block(memc, arg); break; + case MEMCACHED_FLAG_NO_BLOCK: + memcached_set_no_block(memc, arg); + break; - case MEMCACHED_FLAG_REPLY: memcached_set_replying(memc, arg); break; + case MEMCACHED_FLAG_REPLY: + memcached_set_replying(memc, arg); + break; case MEMCACHED_FLAG_RANDOMIZE_REPLICA_READ: memcached_set_randomize_replica_read(memc, arg); break; - case MEMCACHED_FLAG_SUPPORT_CAS: memcached_set_cas(memc, arg); break; + case MEMCACHED_FLAG_SUPPORT_CAS: + memcached_set_cas(memc, arg); + break; - case MEMCACHED_FLAG_TCP_NODELAY: memcached_set_tcp_nodelay(memc, arg); break; + case MEMCACHED_FLAG_TCP_NODELAY: + memcached_set_tcp_nodelay(memc, arg); + break; - case MEMCACHED_FLAG_USE_SORT_HOSTS: memcached_set_use_sort_hosts(memc, arg); break; + case MEMCACHED_FLAG_USE_SORT_HOSTS: + memcached_set_use_sort_hosts(memc, arg); + break; - case MEMCACHED_FLAG_USE_UDP: memcached_set_udp(memc, arg); break; + case MEMCACHED_FLAG_USE_UDP: + memcached_set_udp(memc, arg); + break; - case MEMCACHED_FLAG_VERIFY_KEY: memcached_set_verify_key(memc, arg); break; + case MEMCACHED_FLAG_VERIFY_KEY: + memcached_set_verify_key(memc, arg); + break; - case MEMCACHED_FLAG_TCP_KEEPALIVE: memcached_set_use_sort_hosts(memc, arg); break; + case MEMCACHED_FLAG_TCP_KEEPALIVE: + memcached_set_use_sort_hosts(memc, arg); + break; - case MEMCACHED_FLAG_IS_AES: memcached_set_aes(memc, arg); break; + case MEMCACHED_FLAG_IS_AES: + memcached_set_aes(memc, arg); + break; - case MEMCACHED_FLAG_IS_FETCHING_VERSION: memcached_set_fetching_version(memc, arg); break; + case MEMCACHED_FLAG_IS_FETCHING_VERSION: + memcached_set_fetching_version(memc, arg); + break; } } diff --git a/src/libmemcached/hash.cc b/src/libmemcached/hash.cc index 33766b5f..e062e4e7 100644 --- a/src/libmemcached/hash.cc +++ b/src/libmemcached/hash.cc @@ -52,8 +52,10 @@ static uint32_t dispatch_host(const Memcached *ptr, uint32_t hash) { right = begin; return right->index; } - case MEMCACHED_DISTRIBUTION_MODULA: return hash % memcached_server_count(ptr); - case MEMCACHED_DISTRIBUTION_RANDOM: return (uint32_t) random() % memcached_server_count(ptr); + case MEMCACHED_DISTRIBUTION_MODULA: + return hash % memcached_server_count(ptr); + case MEMCACHED_DISTRIBUTION_RANDOM: + return (uint32_t) random() % memcached_server_count(ptr); case MEMCACHED_DISTRIBUTION_VIRTUAL_BUCKET: { return memcached_virtual_bucket_get(ptr, hash); } diff --git a/src/libmemcached/hosts.cc b/src/libmemcached/hosts.cc index 8afbdb25..0ce66130 100644 --- a/src/libmemcached/hosts.cc +++ b/src/libmemcached/hosts.cc @@ -51,15 +51,20 @@ memcached_return_t run_distribution(Memcached *ptr) { case MEMCACHED_DISTRIBUTION_CONSISTENT: case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA: case MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY: - case MEMCACHED_DISTRIBUTION_CONSISTENT_WEIGHTED: return update_continuum(ptr); + case MEMCACHED_DISTRIBUTION_CONSISTENT_WEIGHTED: + return update_continuum(ptr); case MEMCACHED_DISTRIBUTION_VIRTUAL_BUCKET: - case MEMCACHED_DISTRIBUTION_MODULA: break; + case MEMCACHED_DISTRIBUTION_MODULA: + break; - case MEMCACHED_DISTRIBUTION_RANDOM: srandom((uint32_t) time(NULL)); break; + case MEMCACHED_DISTRIBUTION_RANDOM: + srandom((uint32_t) time(NULL)); + break; case MEMCACHED_DISTRIBUTION_CONSISTENT_MAX: - default: assert_msg(0, "Invalid distribution type passed to run_distribution()"); + default: + assert_msg(0, "Invalid distribution type passed to run_distribution()"); } return MEMCACHED_SUCCESS; diff --git a/src/libmemcached/io.cc b/src/libmemcached/io.cc index 087ae606..8e5d93b7 100644 --- a/src/libmemcached/io.cc +++ b/src/libmemcached/io.cc @@ -56,7 +56,8 @@ static bool repack_input_buffer(memcached_instance_st *instance) { memcached_set_error(*instance, MEMCACHED_CONNECTION_FAILURE, MEMCACHED_AT); } else { switch (get_socket_errno()) { - case EINTR: continue; + case EINTR: + continue; #if EWOULDBLOCK != EAGAIN case EWOULDBLOCK: @@ -67,7 +68,8 @@ static bool repack_input_buffer(memcached_instance_st *instance) { #endif break; // No IO is fine, we can just move on - default: memcached_set_errno(*instance, get_socket_errno(), MEMCACHED_AT); + default: + memcached_set_errno(*instance, get_socket_errno(), MEMCACHED_AT); } } @@ -213,7 +215,8 @@ static memcached_return_t io_wait(memcached_instance_st *instance, const short e #ifdef __linux case ERESTART: #endif - case EINTR: continue; + case EINTR: + continue; case EFAULT: case ENOMEM: @@ -293,7 +296,8 @@ static bool io_flush(memcached_instance_st *instance, const bool with_flush, WATCHPOINT_NUMBER(get_socket_errno()); #endif switch (get_socket_errno()) { - case ENOBUFS: continue; + case ENOBUFS: + continue; #if EWOULDBLOCK != EAGAIN case EWOULDBLOCK: @@ -515,7 +519,8 @@ memcached_return_t memcached_io_slurp(memcached_instance_st *instance) { case EINVAL: case EFAULT: case ECONNREFUSED: - default: return MEMCACHED_CONNECTION_FAILURE; // We want this! + default: + return MEMCACHED_CONNECTION_FAILURE; // We want this! } } } while (data_read > 0); @@ -694,7 +699,8 @@ memcached_instance_st *memcached_io_get_readable_server(Memcached *memc, memcach case -1: memcached_set_errno(*memc, get_socket_errno(), MEMCACHED_AT); /* FALLTHROUGH */ - case 0: break; + case 0: + break; default: for (nfds_t x = 0; x < host_index; ++x) { diff --git a/src/libmemcached/purge.cc b/src/libmemcached/purge.cc index a347e9cb..ae3961b2 100644 --- a/src/libmemcached/purge.cc +++ b/src/libmemcached/purge.cc @@ -24,7 +24,9 @@ public: memcached_set_purging(_memc, true); } - ~Purge() { memcached_set_purging(_memc, false); } + ~Purge() { + memcached_set_purging(_memc, false); + } private: Memcached *_memc; @@ -38,7 +40,9 @@ public: _origin = ms; } - ~PollTimeout() { _origin = _timeout; } + ~PollTimeout() { + _origin = _timeout; + } private: int32_t _timeout; diff --git a/src/libmemcached/response.cc b/src/libmemcached/response.cc index ffd361e3..174ed957 100644 --- a/src/libmemcached/response.cc +++ b/src/libmemcached/response.cc @@ -421,7 +421,8 @@ static memcached_return_t textual_read_one_response(memcached_instance_st *insta return MEMCACHED_SUCCESS; } - default: break; + default: + break; } buffer[total_read] = 0; @@ -691,28 +692,44 @@ static memcached_return_t binary_read_one_response(memcached_instance_st *instan case PROTOCOL_BINARY_CMD_ADDQ: case PROTOCOL_BINARY_CMD_REPLACEQ: case PROTOCOL_BINARY_CMD_APPENDQ: - case PROTOCOL_BINARY_CMD_PREPENDQ: return MEMCACHED_FETCH_NOTFINISHED; + case PROTOCOL_BINARY_CMD_PREPENDQ: + return MEMCACHED_FETCH_NOTFINISHED; - default: break; + default: + break; } } rc = MEMCACHED_SUCCESS; if (header.response.status != 0) { switch (header.response.status) { - case PROTOCOL_BINARY_RESPONSE_KEY_ENOENT: rc = MEMCACHED_NOTFOUND; break; + case PROTOCOL_BINARY_RESPONSE_KEY_ENOENT: + rc = MEMCACHED_NOTFOUND; + break; - case PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS: rc = MEMCACHED_DATA_EXISTS; break; + case PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS: + rc = MEMCACHED_DATA_EXISTS; + break; - case PROTOCOL_BINARY_RESPONSE_NOT_STORED: rc = MEMCACHED_NOTSTORED; break; + case PROTOCOL_BINARY_RESPONSE_NOT_STORED: + rc = MEMCACHED_NOTSTORED; + break; - case PROTOCOL_BINARY_RESPONSE_E2BIG: rc = MEMCACHED_E2BIG; break; + case PROTOCOL_BINARY_RESPONSE_E2BIG: + rc = MEMCACHED_E2BIG; + break; - case PROTOCOL_BINARY_RESPONSE_ENOMEM: rc = MEMCACHED_MEMORY_ALLOCATION_FAILURE; break; + case PROTOCOL_BINARY_RESPONSE_ENOMEM: + rc = MEMCACHED_MEMORY_ALLOCATION_FAILURE; + break; - case PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE: rc = MEMCACHED_AUTH_CONTINUE; break; + case PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE: + rc = MEMCACHED_AUTH_CONTINUE; + break; - case PROTOCOL_BINARY_RESPONSE_AUTH_ERROR: rc = MEMCACHED_AUTH_FAILURE; break; + case PROTOCOL_BINARY_RESPONSE_AUTH_ERROR: + rc = MEMCACHED_AUTH_FAILURE; + break; case PROTOCOL_BINARY_RESPONSE_EINVAL: case PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND: diff --git a/src/libmemcached/sasl.cc b/src/libmemcached/sasl.cc index 637ceeef..a190c5b7 100644 --- a/src/libmemcached/sasl.cc +++ b/src/libmemcached/sasl.cc @@ -394,7 +394,8 @@ memcached_return_t memcached_clone_sasl(memcached_st *clone, const memcached_st switch (source->sasl.callbacks[total].id) { case SASL_CB_USER: case SASL_CB_AUTHNAME: - case SASL_CB_PASS: break; + case SASL_CB_PASS: + break; default: /* I don't know how to deal with this... */ return MEMCACHED_NOT_SUPPORTED; diff --git a/src/libmemcached/server.cc b/src/libmemcached/server.cc index bf028621..e038196a 100644 --- a/src/libmemcached/server.cc +++ b/src/libmemcached/server.cc @@ -188,11 +188,14 @@ uint32_t memcached_server_response_count(const memcached_instance_st *self) { const char *memcached_server_type(const memcached_instance_st *ptr) { if (ptr) { switch (ptr->type) { - case MEMCACHED_CONNECTION_TCP: return "TCP"; + case MEMCACHED_CONNECTION_TCP: + return "TCP"; - case MEMCACHED_CONNECTION_UDP: return "UDP"; + case MEMCACHED_CONNECTION_UDP: + return "UDP"; - case MEMCACHED_CONNECTION_UNIX_SOCKET: return "SOCKET"; + case MEMCACHED_CONNECTION_UNIX_SOCKET: + return "SOCKET"; } } diff --git a/src/libmemcached/storage.cc b/src/libmemcached/storage.cc index 0700c055..0404b193 100644 --- a/src/libmemcached/storage.cc +++ b/src/libmemcached/storage.cc @@ -20,17 +20,23 @@ enum memcached_storage_action_t { SET_OP, REPLACE_OP, ADD_OP, PREPEND_OP, APPEND /* Inline this */ static inline const char *storage_op_string(memcached_storage_action_t verb) { switch (verb) { - case REPLACE_OP: return "replace "; + case REPLACE_OP: + return "replace "; - case ADD_OP: return "add "; + case ADD_OP: + return "add "; - case PREPEND_OP: return "prepend "; + case PREPEND_OP: + return "prepend "; - case APPEND_OP: return "append "; + case APPEND_OP: + return "append "; - case CAS_OP: return "cas "; + case CAS_OP: + return "cas "; - case SET_OP: break; + case SET_OP: + break; } return "set "; @@ -41,10 +47,12 @@ static inline bool can_by_encrypted(const memcached_storage_action_t verb) { case SET_OP: case ADD_OP: case CAS_OP: - case REPLACE_OP: return true; + case REPLACE_OP: + return true; case APPEND_OP: - case PREPEND_OP: break; + case PREPEND_OP: + break; } return false; @@ -53,30 +61,40 @@ static inline bool can_by_encrypted(const memcached_storage_action_t verb) { static inline uint8_t get_com_code(const memcached_storage_action_t verb, const bool reply) { if (reply == false) { switch (verb) { - case SET_OP: return PROTOCOL_BINARY_CMD_SETQ; + case SET_OP: + return PROTOCOL_BINARY_CMD_SETQ; - case ADD_OP: return PROTOCOL_BINARY_CMD_ADDQ; + case ADD_OP: + return PROTOCOL_BINARY_CMD_ADDQ; case CAS_OP: /* FALLTHROUGH */ - case REPLACE_OP: return PROTOCOL_BINARY_CMD_REPLACEQ; + case REPLACE_OP: + return PROTOCOL_BINARY_CMD_REPLACEQ; - case APPEND_OP: return PROTOCOL_BINARY_CMD_APPENDQ; + case APPEND_OP: + return PROTOCOL_BINARY_CMD_APPENDQ; - case PREPEND_OP: return PROTOCOL_BINARY_CMD_PREPENDQ; + case PREPEND_OP: + return PROTOCOL_BINARY_CMD_PREPENDQ; } } switch (verb) { - case SET_OP: break; + case SET_OP: + break; - case ADD_OP: return PROTOCOL_BINARY_CMD_ADD; + case ADD_OP: + return PROTOCOL_BINARY_CMD_ADD; case CAS_OP: /* FALLTHROUGH */ - case REPLACE_OP: return PROTOCOL_BINARY_CMD_REPLACE; + case REPLACE_OP: + return PROTOCOL_BINARY_CMD_REPLACE; - case APPEND_OP: return PROTOCOL_BINARY_CMD_APPEND; + case APPEND_OP: + return PROTOCOL_BINARY_CMD_APPEND; - case PREPEND_OP: return PROTOCOL_BINARY_CMD_PREPEND; + case PREPEND_OP: + return PROTOCOL_BINARY_CMD_PREPEND; } return PROTOCOL_BINARY_CMD_SET; diff --git a/src/libmemcached/strerror.cc b/src/libmemcached/strerror.cc index 3dc89811..24a5e44d 100644 --- a/src/libmemcached/strerror.cc +++ b/src/libmemcached/strerror.cc @@ -17,109 +17,155 @@ const char *memcached_strerror(const memcached_st *, memcached_return_t rc) { switch (rc) { - case MEMCACHED_SUCCESS: return "SUCCESS"; + case MEMCACHED_SUCCESS: + return "SUCCESS"; - case MEMCACHED_FAILURE: return "FAILURE"; + case MEMCACHED_FAILURE: + return "FAILURE"; case MEMCACHED_HOST_LOOKUP_FAILURE: // getaddrinfo only return "getaddrinfo() or getnameinfo() HOSTNAME LOOKUP FAILURE"; - case MEMCACHED_CONNECTION_FAILURE: return "CONNECTION FAILURE"; + case MEMCACHED_CONNECTION_FAILURE: + return "CONNECTION FAILURE"; case MEMCACHED_CONNECTION_BIND_FAILURE: // DEPRECATED, see MEMCACHED_HOST_LOOKUP_FAILURE return "CONNECTION BIND FAILURE"; - case MEMCACHED_READ_FAILURE: return "READ FAILURE"; + case MEMCACHED_READ_FAILURE: + return "READ FAILURE"; - case MEMCACHED_UNKNOWN_READ_FAILURE: return "UNKNOWN READ FAILURE"; + case MEMCACHED_UNKNOWN_READ_FAILURE: + return "UNKNOWN READ FAILURE"; - case MEMCACHED_PROTOCOL_ERROR: return "PROTOCOL ERROR"; + case MEMCACHED_PROTOCOL_ERROR: + return "PROTOCOL ERROR"; - case MEMCACHED_CLIENT_ERROR: return "CLIENT ERROR"; + case MEMCACHED_CLIENT_ERROR: + return "CLIENT ERROR"; - case MEMCACHED_SERVER_ERROR: return "SERVER ERROR"; + case MEMCACHED_SERVER_ERROR: + return "SERVER ERROR"; - case MEMCACHED_WRITE_FAILURE: return "WRITE FAILURE"; + case MEMCACHED_WRITE_FAILURE: + return "WRITE FAILURE"; - case MEMCACHED_ERROR: return "ERROR was returned by server"; + case MEMCACHED_ERROR: + return "ERROR was returned by server"; - case MEMCACHED_DATA_EXISTS: return "CONNECTION DATA EXISTS"; + case MEMCACHED_DATA_EXISTS: + return "CONNECTION DATA EXISTS"; - case MEMCACHED_DATA_DOES_NOT_EXIST: return "CONNECTION DATA DOES NOT EXIST"; + case MEMCACHED_DATA_DOES_NOT_EXIST: + return "CONNECTION DATA DOES NOT EXIST"; - case MEMCACHED_NOTSTORED: return "NOT STORED"; + case MEMCACHED_NOTSTORED: + return "NOT STORED"; - case MEMCACHED_STORED: return "STORED"; + case MEMCACHED_STORED: + return "STORED"; - case MEMCACHED_NOTFOUND: return "NOT FOUND"; + case MEMCACHED_NOTFOUND: + return "NOT FOUND"; - case MEMCACHED_MEMORY_ALLOCATION_FAILURE: return "MEMORY ALLOCATION FAILURE"; + case MEMCACHED_MEMORY_ALLOCATION_FAILURE: + return "MEMORY ALLOCATION FAILURE"; - case MEMCACHED_PARTIAL_READ: return "PARTIAL READ"; + case MEMCACHED_PARTIAL_READ: + return "PARTIAL READ"; - case MEMCACHED_SOME_ERRORS: return "SOME ERRORS WERE REPORTED"; + case MEMCACHED_SOME_ERRORS: + return "SOME ERRORS WERE REPORTED"; - case MEMCACHED_NO_SERVERS: return "NO SERVERS DEFINED"; + case MEMCACHED_NO_SERVERS: + return "NO SERVERS DEFINED"; - case MEMCACHED_END: return "SERVER END"; + case MEMCACHED_END: + return "SERVER END"; - case MEMCACHED_DELETED: return "SERVER DELETE"; + case MEMCACHED_DELETED: + return "SERVER DELETE"; - case MEMCACHED_VALUE: return "SERVER VALUE"; + case MEMCACHED_VALUE: + return "SERVER VALUE"; - case MEMCACHED_STAT: return "STAT VALUE"; + case MEMCACHED_STAT: + return "STAT VALUE"; - case MEMCACHED_ITEM: return "ITEM VALUE"; + case MEMCACHED_ITEM: + return "ITEM VALUE"; - case MEMCACHED_ERRNO: return "SYSTEM ERROR"; + case MEMCACHED_ERRNO: + return "SYSTEM ERROR"; - case MEMCACHED_FAIL_UNIX_SOCKET: return "COULD NOT OPEN UNIX SOCKET"; + case MEMCACHED_FAIL_UNIX_SOCKET: + return "COULD NOT OPEN UNIX SOCKET"; - case MEMCACHED_NOT_SUPPORTED: return "ACTION NOT SUPPORTED"; + case MEMCACHED_NOT_SUPPORTED: + return "ACTION NOT SUPPORTED"; - case MEMCACHED_FETCH_NOTFINISHED: return "FETCH WAS NOT COMPLETED"; + case MEMCACHED_FETCH_NOTFINISHED: + return "FETCH WAS NOT COMPLETED"; - case MEMCACHED_NO_KEY_PROVIDED: return "A KEY LENGTH OF ZERO WAS PROVIDED"; + case MEMCACHED_NO_KEY_PROVIDED: + return "A KEY LENGTH OF ZERO WAS PROVIDED"; - case MEMCACHED_BUFFERED: return "ACTION QUEUED"; + case MEMCACHED_BUFFERED: + return "ACTION QUEUED"; - case MEMCACHED_TIMEOUT: return "A TIMEOUT OCCURRED"; + case MEMCACHED_TIMEOUT: + return "A TIMEOUT OCCURRED"; - case MEMCACHED_BAD_KEY_PROVIDED: return "A BAD KEY WAS PROVIDED/CHARACTERS OUT OF RANGE"; + case MEMCACHED_BAD_KEY_PROVIDED: + return "A BAD KEY WAS PROVIDED/CHARACTERS OUT OF RANGE"; case MEMCACHED_INVALID_HOST_PROTOCOL: return "THE HOST TRANSPORT PROTOCOL DOES NOT MATCH THAT OF THE CLIENT"; - case MEMCACHED_SERVER_MARKED_DEAD: return "SERVER IS MARKED DEAD"; + case MEMCACHED_SERVER_MARKED_DEAD: + return "SERVER IS MARKED DEAD"; - case MEMCACHED_UNKNOWN_STAT_KEY: return "ENCOUNTERED AN UNKNOWN STAT KEY"; + case MEMCACHED_UNKNOWN_STAT_KEY: + return "ENCOUNTERED AN UNKNOWN STAT KEY"; - case MEMCACHED_E2BIG: return "ITEM TOO BIG"; + case MEMCACHED_E2BIG: + return "ITEM TOO BIG"; - case MEMCACHED_INVALID_ARGUMENTS: return "INVALID ARGUMENTS"; + case MEMCACHED_INVALID_ARGUMENTS: + return "INVALID ARGUMENTS"; - case MEMCACHED_KEY_TOO_BIG: return "KEY RETURNED FROM SERVER WAS TOO LARGE"; + case MEMCACHED_KEY_TOO_BIG: + return "KEY RETURNED FROM SERVER WAS TOO LARGE"; - case MEMCACHED_AUTH_PROBLEM: return "FAILED TO SEND AUTHENTICATION TO SERVER"; + case MEMCACHED_AUTH_PROBLEM: + return "FAILED TO SEND AUTHENTICATION TO SERVER"; - case MEMCACHED_AUTH_FAILURE: return "AUTHENTICATION FAILURE"; + case MEMCACHED_AUTH_FAILURE: + return "AUTHENTICATION FAILURE"; - case MEMCACHED_AUTH_CONTINUE: return "CONTINUE AUTHENTICATION"; + case MEMCACHED_AUTH_CONTINUE: + return "CONTINUE AUTHENTICATION"; - case MEMCACHED_PARSE_ERROR: return "ERROR OCCURED WHILE PARSING"; + case MEMCACHED_PARSE_ERROR: + return "ERROR OCCURED WHILE PARSING"; - case MEMCACHED_PARSE_USER_ERROR: return "USER INITIATED ERROR OCCURED WHILE PARSING"; + case MEMCACHED_PARSE_USER_ERROR: + return "USER INITIATED ERROR OCCURED WHILE PARSING"; - case MEMCACHED_DEPRECATED: return "DEPRECATED"; + case MEMCACHED_DEPRECATED: + return "DEPRECATED"; - case MEMCACHED_IN_PROGRESS: return "OPERATION IN PROCESS"; + case MEMCACHED_IN_PROGRESS: + return "OPERATION IN PROCESS"; case MEMCACHED_SERVER_TEMPORARILY_DISABLED: return "SERVER HAS FAILED AND IS DISABLED UNTIL TIMED RETRY"; - case MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE: return "SERVER FAILED TO ALLOCATE OBJECT"; + case MEMCACHED_SERVER_MEMORY_ALLOCATION_FAILURE: + return "SERVER FAILED TO ALLOCATE OBJECT"; default: - case MEMCACHED_MAXIMUM_RETURN: return "INVALID memcached_return_t"; + case MEMCACHED_MAXIMUM_RETURN: + return "INVALID memcached_return_t"; } } diff --git a/src/libmemcachedprotocol/ascii_handler.c b/src/libmemcachedprotocol/ascii_handler.c index 83a71828..f5d8e22c 100644 --- a/src/libmemcachedprotocol/ascii_handler.c +++ b/src/libmemcachedprotocol/ascii_handler.c @@ -24,40 +24,74 @@ static void print_ascii_command(memcached_protocol_client_st *client) { if (client->is_verbose) { switch (client->ascii_command) { - case SET_CMD: fprintf(stderr, "%s:%d SET_CMD\n", __FILE__, __LINE__); break; + case SET_CMD: + fprintf(stderr, "%s:%d SET_CMD\n", __FILE__, __LINE__); + break; - case ADD_CMD: fprintf(stderr, "%s:%d ADD_CMD\n", __FILE__, __LINE__); break; + case ADD_CMD: + fprintf(stderr, "%s:%d ADD_CMD\n", __FILE__, __LINE__); + break; - case REPLACE_CMD: fprintf(stderr, "%s:%d REPLACE_CMD\n", __FILE__, __LINE__); break; + case REPLACE_CMD: + fprintf(stderr, "%s:%d REPLACE_CMD\n", __FILE__, __LINE__); + break; - case CAS_CMD: fprintf(stderr, "%s:%d CAS_CMD\n", __FILE__, __LINE__); break; + case CAS_CMD: + fprintf(stderr, "%s:%d CAS_CMD\n", __FILE__, __LINE__); + break; - case APPEND_CMD: fprintf(stderr, "%s:%d APPEND_CMD\n", __FILE__, __LINE__); break; + case APPEND_CMD: + fprintf(stderr, "%s:%d APPEND_CMD\n", __FILE__, __LINE__); + break; - case PREPEND_CMD: fprintf(stderr, "%s:%d PREPEND_CMD\n", __FILE__, __LINE__); break; + case PREPEND_CMD: + fprintf(stderr, "%s:%d PREPEND_CMD\n", __FILE__, __LINE__); + break; - case DELETE_CMD: fprintf(stderr, "%s:%d DELETE_CMD\n", __FILE__, __LINE__); break; + case DELETE_CMD: + fprintf(stderr, "%s:%d DELETE_CMD\n", __FILE__, __LINE__); + break; - case INCR_CMD: /* FALLTHROUGH */ fprintf(stderr, "%s:%d INCR_CMD\n", __FILE__, __LINE__); break; + case INCR_CMD: /* FALLTHROUGH */ + fprintf(stderr, "%s:%d INCR_CMD\n", __FILE__, __LINE__); + break; - case DECR_CMD: fprintf(stderr, "%s:%d DECR_CMD\n", __FILE__, __LINE__); break; + case DECR_CMD: + fprintf(stderr, "%s:%d DECR_CMD\n", __FILE__, __LINE__); + break; - case STATS_CMD: fprintf(stderr, "%s:%d STATS_CMD\n", __FILE__, __LINE__); break; + case STATS_CMD: + fprintf(stderr, "%s:%d STATS_CMD\n", __FILE__, __LINE__); + break; - case FLUSH_ALL_CMD: fprintf(stderr, "%s:%d FLUSH_ALL_CMD\n", __FILE__, __LINE__); break; + case FLUSH_ALL_CMD: + fprintf(stderr, "%s:%d FLUSH_ALL_CMD\n", __FILE__, __LINE__); + break; - case VERSION_CMD: fprintf(stderr, "%s:%d VERSION_CMD\n", __FILE__, __LINE__); break; + case VERSION_CMD: + fprintf(stderr, "%s:%d VERSION_CMD\n", __FILE__, __LINE__); + break; - case QUIT_CMD: fprintf(stderr, "%s:%d QUIT_CMD\n", __FILE__, __LINE__); break; + case QUIT_CMD: + fprintf(stderr, "%s:%d QUIT_CMD\n", __FILE__, __LINE__); + break; - case VERBOSITY_CMD: fprintf(stderr, "%s:%d VERBOSITY_CMD\n", __FILE__, __LINE__); break; + case VERBOSITY_CMD: + fprintf(stderr, "%s:%d VERBOSITY_CMD\n", __FILE__, __LINE__); + break; - case GET_CMD: fprintf(stderr, "%s:%d GET_CMD\n", __FILE__, __LINE__); break; + case GET_CMD: + fprintf(stderr, "%s:%d GET_CMD\n", __FILE__, __LINE__); + break; - case GETS_CMD: fprintf(stderr, "%s:%d GETS_CMD\n", __FILE__, __LINE__); break; + case GETS_CMD: + fprintf(stderr, "%s:%d GETS_CMD\n", __FILE__, __LINE__); + break; default: - case UNKNOWN_CMD: fprintf(stderr, "%s:%d UNKNOWN_CMD\n", __FILE__, __LINE__); break; + case UNKNOWN_CMD: + fprintf(stderr, "%s:%d UNKNOWN_CMD\n", __FILE__, __LINE__); + break; } } } @@ -639,7 +673,8 @@ static inline int process_storage_command(memcached_protocol_client_st *client, case QUIT_CMD: case VERBOSITY_CMD: case UNKNOWN_CMD: - default: abort(); /* impossible */ + default: + abort(); /* impossible */ } if (rval == PROTOCOL_BINARY_RESPONSE_SUCCESS) { @@ -807,15 +842,21 @@ memcached_ascii_protocol_process_data(memcached_protocol_client_st *client, ssiz print_ascii_command(client); switch (client->ascii_command) { - case SET_CMD: error = process_set_command(client, tokens, ntokens, ptr, &end, *length); break; + case SET_CMD: + error = process_set_command(client, tokens, ntokens, ptr, &end, *length); + break; - case ADD_CMD: error = process_add_command(client, tokens, ntokens, ptr, &end, *length); break; + case ADD_CMD: + error = process_add_command(client, tokens, ntokens, ptr, &end, *length); + break; case REPLACE_CMD: error = process_replace_command(client, tokens, ntokens, ptr, &end, *length); break; - case CAS_CMD: error = process_cas_command(client, tokens, ntokens, ptr, &end, *length); break; + case CAS_CMD: + error = process_cas_command(client, tokens, ntokens, ptr, &end, *length); + break; case APPEND_CMD: error = process_append_command(client, tokens, ntokens, ptr, &end, *length); @@ -825,10 +866,14 @@ memcached_ascii_protocol_process_data(memcached_protocol_client_st *client, ssiz error = process_prepend_command(client, tokens, ntokens, ptr, &end, *length); break; - case DELETE_CMD: process_delete(client, tokens, ntokens); break; + case DELETE_CMD: + process_delete(client, tokens, ntokens); + break; case INCR_CMD: /* FALLTHROUGH */ - case DECR_CMD: process_arithmetic(client, tokens, ntokens); break; + case DECR_CMD: + process_arithmetic(client, tokens, ntokens); + break; case STATS_CMD: if (client->mute) { @@ -839,7 +884,9 @@ memcached_ascii_protocol_process_data(memcached_protocol_client_st *client, ssiz } break; - case FLUSH_ALL_CMD: process_flush(client, tokens, ntokens); break; + case FLUSH_ALL_CMD: + process_flush(client, tokens, ntokens); + break; case VERSION_CMD: if (client->mute) { @@ -869,7 +916,9 @@ memcached_ascii_protocol_process_data(memcached_protocol_client_st *client, ssiz } break; - case UNKNOWN_CMD: send_command_usage(client); break; + case UNKNOWN_CMD: + send_command_usage(client); + break; case GET_CMD: case GETS_CMD: diff --git a/src/libmemcachedprotocol/binary_handler.c b/src/libmemcachedprotocol/binary_handler.c index 51fa60be..c7a76b3f 100644 --- a/src/libmemcachedprotocol/binary_handler.c +++ b/src/libmemcachedprotocol/binary_handler.c @@ -265,7 +265,8 @@ static void print_cmd(protocol_binary_command cmd) { case PROTOCOL_BINARY_CMD_SCRUB: fprintf(stderr, "%s:%d PROTOCOL_BINARY_CMD_SCRUB\n", __FILE__, __LINE__); return; - default: abort(); + default: + abort(); } } diff --git a/src/libmemcachedprotocol/pedantic.c b/src/libmemcachedprotocol/pedantic.c index 85624f24..b6e7a002 100644 --- a/src/libmemcachedprotocol/pedantic.c +++ b/src/libmemcachedprotocol/pedantic.c @@ -139,7 +139,8 @@ bool memcached_binary_protocol_pedantic_check_response( case PROTOCOL_BINARY_CMD_SETQ: /* Quiet command shouldn't return on success */ return false; - default: break; + default: + break; } switch (opcode) { diff --git a/src/libmemcachedutil/pool.cc b/src/libmemcachedutil/pool.cc index 44852651..718be8b2 100644 --- a/src/libmemcachedutil/pool.cc +++ b/src/libmemcachedutil/pool.cc @@ -44,7 +44,9 @@ struct memcached_pool_st { _timeout.tv_nsec = 0; } - const struct timespec &timeout() const { return _timeout; } + const struct timespec &timeout() const { + return _timeout; + } bool release(memcached_st *, memcached_return_t &rc); @@ -74,13 +76,17 @@ struct memcached_pool_st { } } - void increment_version() { ++master->configure.version; } + void increment_version() { + ++master->configure.version; + } bool compare_version(const memcached_st *arg) const { return (arg->configure.version == version()); } - int32_t version() const { return master->configure.version; } + int32_t version() const { + return master->configure.version; + } }; /** -- 2.30.2