CLEANUP: Rename process_config_xxx_command()

namsic · jhpark816 · commit 154d41a43129 · 2025-10-16T16:11:02.000+09:00
diff --git a/memcached.c b/memcached.c
@@ -9209,7 +9209,7 @@ static void process_flush_command(conn *c, token_t *tokens, const size_t ntokens
     }
 }
 
-static void process_maxconns_command(conn *c, token_t *tokens, const size_t ntokens)
+static void process_config_maxconns_command(conn *c, token_t *tokens, const size_t ntokens)
 {
     int new_max;
 
@@ -9253,7 +9253,7 @@ static void process_maxconns_command(conn *c, token_t *tokens, const size_t ntok
 }
 
 #ifdef ENABLE_ZK_INTEGRATION
-static void process_zkfailstop_command(conn *c, token_t *tokens, const size_t ntokens)
+static void process_config_zkfailstop_command(conn *c, token_t *tokens, const size_t ntokens)
 {
     assert(c != NULL);
     if (ntokens == 3) {
@@ -9279,7 +9279,7 @@ static void process_zkfailstop_command(conn *c, token_t *tokens, const size_t nt
     }
 }
 
-static void process_hbtimeout_command(conn *c, token_t *tokens, const size_t ntokens)
+static void process_config_hbtimeout_command(conn *c, token_t *tokens, const size_t ntokens)
 {
     assert(c != NULL);
     unsigned int hbtimeout;
@@ -9299,7 +9299,7 @@ static void process_hbtimeout_command(conn *c, token_t *tokens, const size_t nto
     }
 }
 
-static void process_hbfailstop_command(conn *c, token_t *tokens, const size_t ntokens)
+static void process_config_hbfailstop_command(conn *c, token_t *tokens, const size_t ntokens)
 {
     assert(c != NULL);
     unsigned int hbfailstop;
@@ -9320,7 +9320,7 @@ static void process_hbfailstop_command(conn *c, token_t *tokens, const size_t nt
 }
 #endif
 
-static void process_memlimit_command(conn *c, token_t *tokens, const size_t ntokens)
+static void process_config_memlimit_command(conn *c, token_t *tokens, const size_t ntokens)
 {
     assert(c != NULL);
     char *config_key = tokens[SUBCOMMAND_TOKEN].value;
@@ -9350,7 +9350,7 @@ static void process_memlimit_command(conn *c, token_t *tokens, const size_t ntok
 }
 
 #ifdef ENABLE_STICKY_ITEM
-static void process_stickylimit_command(conn *c, token_t *tokens, const size_t ntokens)
+static void process_config_stickylimit_command(conn *c, token_t *tokens, const size_t ntokens)
 {
     assert(c != NULL);
     char *config_key = tokens[SUBCOMMAND_TOKEN].value;
@@ -9380,7 +9380,7 @@ static void process_stickylimit_command(conn *c, token_t *tokens, const size_t n
 }
 #endif
 
-static void process_maxcollsize_command(conn *c, token_t *tokens, const size_t ntokens,
+static void process_config_maxcollsize_command(conn *c, token_t *tokens, const size_t ntokens,
                                         int coll_type)
 {
     assert(c != NULL && coll_type != ITEM_TYPE_KV);
@@ -9438,7 +9438,7 @@ static void process_maxcollsize_command(conn *c, token_t *tokens, const size_t n
     }
 }
 
-static void process_maxelembytes_command(conn *c, token_t *tokens, const size_t ntokens)
+static void process_config_maxelembytes_command(conn *c, token_t *tokens, const size_t ntokens)
 {
     assert(c != NULL);
     char *config_key = tokens[SUBCOMMAND_TOKEN].value;
@@ -9468,7 +9468,7 @@ static void process_maxelembytes_command(conn *c, token_t *tokens, const size_t
     }
 }
 
-static void process_scrubcount_command(conn *c, token_t *tokens, const size_t ntokens)
+static void process_config_scrubcount_command(conn *c, token_t *tokens, const size_t ntokens)
 {
     char *config_key = tokens[SUBCOMMAND_TOKEN].value;
     char *config_val = tokens[SUBCOMMAND_TOKEN+1].value;
@@ -9495,7 +9495,7 @@ static void process_scrubcount_command(conn *c, token_t *tokens, const size_t nt
     }
 }
 
-static void process_maxstatsprefixes_command(conn *c, token_t *tokens, const size_t ntokens)
+static void process_config_maxstatsprefixes_command(conn *c, token_t *tokens, const size_t ntokens)
 {
     char *config_val = tokens[SUBCOMMAND_TOKEN+1].value;
     uint32_t new_max_stats_prefixes;
@@ -9515,7 +9515,7 @@ static void process_maxstatsprefixes_command(conn *c, token_t *tokens, const siz
     }
 }
 
-static void process_verbosity_command(conn *c, token_t *tokens, const size_t ntokens)
+static void process_config_verbosity_command(conn *c, token_t *tokens, const size_t ntokens)
 {
     assert(c != NULL);
     char *config_key = tokens[SUBCOMMAND_TOKEN].value;
@@ -9544,7 +9544,7 @@ static void process_verbosity_command(conn *c, token_t *tokens, const size_t nto
 }
 
 #ifdef ENABLE_PERSISTENCE
-static void process_chkpt_interval_pct_snapshot_command(conn *c, token_t *tokens, const size_t ntokens)
+static void process_config_chkpt_interval_pct_snapshot_command(conn *c, token_t *tokens, const size_t ntokens)
 {
     assert(c != NULL);
     char *config_key = tokens[SUBCOMMAND_TOKEN].value;
@@ -9573,7 +9573,7 @@ static void process_chkpt_interval_pct_snapshot_command(conn *c, token_t *tokens
     }
 }
 
-static void process_chkpt_interval_min_logsize_command(conn *c, token_t *tokens, const size_t ntokens)
+static void process_config_chkpt_interval_min_logsize_command(conn *c, token_t *tokens, const size_t ntokens)
 {
     assert(c != NULL);
     char *config_key = tokens[SUBCOMMAND_TOKEN].value;
@@ -9602,7 +9602,7 @@ static void process_chkpt_interval_min_logsize_command(conn *c, token_t *tokens,
     }
 }
 
-static void process_async_logging_command(conn *c, token_t *tokens, const size_t ntokens)
+static void process_config_async_logging_command(conn *c, token_t *tokens, const size_t ntokens)
 {
     assert(c != NULL);
     char *config_key = tokens[SUBCOMMAND_TOKEN].value;
@@ -9654,7 +9654,7 @@ static void* init_sasl_thread(void *arg)
     return NULL;
 }
 
-static void process_auth_command(conn *c, token_t *tokens, const size_t ntokens)
+static void process_config_auth_command(conn *c, token_t *tokens, const size_t ntokens)
 {
     assert(c != NULL);
     if (ntokens == 3) {
@@ -9701,65 +9701,65 @@ static void process_config_command(conn *c, token_t *tokens, const size_t ntoken
     }
 
     if (strcmp(config_key, "maxconns") == 0) {
-        process_maxconns_command(c, tokens, ntokens);
+        process_config_maxconns_command(c, tokens, ntokens);
     }
     else if (strcmp(config_key, "memlimit") == 0) {
-        process_memlimit_command(c, tokens, ntokens);
+        process_config_memlimit_command(c, tokens, ntokens);
     }
     else if (strcmp(config_key, "max_list_size") == 0) {
-        process_maxcollsize_command(c, tokens, ntokens, ITEM_TYPE_LIST);
+        process_config_maxcollsize_command(c, tokens, ntokens, ITEM_TYPE_LIST);
     }
     else if (strcmp(config_key, "max_set_size") == 0) {
-        process_maxcollsize_command(c, tokens, ntokens, ITEM_TYPE_SET);
+        process_config_maxcollsize_command(c, tokens, ntokens, ITEM_TYPE_SET);
     }
     else if (strcmp(config_key, "max_map_size") == 0) {
-        process_maxcollsize_command(c, tokens, ntokens, ITEM_TYPE_MAP);
+        process_config_maxcollsize_command(c, tokens, ntokens, ITEM_TYPE_MAP);
     }
     else if (strcmp(config_key, "max_btree_size") == 0) {
-        process_maxcollsize_command(c, tokens, ntokens, ITEM_TYPE_BTREE);
+        process_config_maxcollsize_command(c, tokens, ntokens, ITEM_TYPE_BTREE);
     }
     else if (strcmp(config_key, "max_element_bytes") == 0) {
-        process_maxelembytes_command(c, tokens, ntokens);
+        process_config_maxelembytes_command(c, tokens, ntokens);
     }
     else if (strcmp(config_key, "scrub_count") == 0) {
-        process_scrubcount_command(c, tokens, ntokens);
+        process_config_scrubcount_command(c, tokens, ntokens);
     }
     else if (strcmp(config_key, "max_stats_prefixes") == 0) {
-        process_maxstatsprefixes_command(c, tokens, ntokens);
+        process_config_maxstatsprefixes_command(c, tokens, ntokens);
     }
 #ifdef ENABLE_ZK_INTEGRATION
     else if (strcmp(config_key, "zkfailstop") == 0) {
-        process_zkfailstop_command(c, tokens, ntokens);
+        process_config_zkfailstop_command(c, tokens, ntokens);
     }
     else if (strcmp(config_key, "hbtimeout") == 0) {
-        process_hbtimeout_command(c, tokens, ntokens);
+        process_config_hbtimeout_command(c, tokens, ntokens);
     }
     else if (strcmp(config_key, "hbfailstop") == 0) {
-        process_hbfailstop_command(c, tokens, ntokens);
+        process_config_hbfailstop_command(c, tokens, ntokens);
     }
 #endif
 #ifdef ENABLE_STICKY_ITEM
     else if (strcmp(config_key, "sticky_limit") == 0) {
-        process_stickylimit_command(c, tokens, ntokens);
+        process_config_stickylimit_command(c, tokens, ntokens);
     }
 #endif
     else if (strcmp(config_key, "verbosity") == 0) {
-        process_verbosity_command(c, tokens, ntokens);
+        process_config_verbosity_command(c, tokens, ntokens);
     }
 #ifdef ENABLE_PERSISTENCE
     else if (strcmp(config_key, "chkpt_interval_pct_snapshot") == 0) {
-        process_chkpt_interval_pct_snapshot_command(c, tokens, ntokens);
+        process_config_chkpt_interval_pct_snapshot_command(c, tokens, ntokens);
     }
     else if (strcmp(config_key, "chkpt_interval_min_logsize") == 0) {
-        process_chkpt_interval_min_logsize_command(c, tokens, ntokens);
+        process_config_chkpt_interval_min_logsize_command(c, tokens, ntokens);
     }
     else if (strcmp(config_key, "async_logging") == 0) {
-        process_async_logging_command(c, tokens, ntokens);
+        process_config_async_logging_command(c, tokens, ntokens);
     }
 #endif
 #ifdef SASL_ENABLED
     else if (strcmp(config_key, "auth") == 0) {
-        process_auth_command(c, tokens, ntokens);
+        process_config_auth_command(c, tokens, ntokens);
     }
 #endif
     else {

Original file line number	Diff line number	Diff line change
`@@ -9209,7 +9209,7 @@ static void process_flush_command(conn c, token_t tokens, const size_t ntokens`
`9209`	`9209`	`}`
`9210`	`9210`	`}`
`9211`	`9211`
`9212`		`-static void process_maxconns_command(conn c, token_t tokens, const size_t ntokens)`
	`9212`	`+static void process_config_maxconns_command(conn c, token_t tokens, const size_t ntokens)`
`9213`	`9213`	`{`
`9214`	`9214`	`int new_max;`
`9215`	`9215`
`@@ -9253,7 +9253,7 @@ static void process_maxconns_command(conn c, token_t tokens, const size_t ntok`
`9253`	`9253`	`}`
`9254`	`9254`
`9255`	`9255`	`#ifdef ENABLE_ZK_INTEGRATION`
`9256`		`-static void process_zkfailstop_command(conn c, token_t tokens, const size_t ntokens)`
	`9256`	`+static void process_config_zkfailstop_command(conn c, token_t tokens, const size_t ntokens)`
`9257`	`9257`	`{`
`9258`	`9258`	`assert(c != NULL);`
`9259`	`9259`	`if (ntokens == 3) {`
`@@ -9279,7 +9279,7 @@ static void process_zkfailstop_command(conn c, token_t tokens, const size_t nt`
`9279`	`9279`	`}`
`9280`	`9280`	`}`
`9281`	`9281`
`9282`		`-static void process_hbtimeout_command(conn c, token_t tokens, const size_t ntokens)`
	`9282`	`+static void process_config_hbtimeout_command(conn c, token_t tokens, const size_t ntokens)`
`9283`	`9283`	`{`
`9284`	`9284`	`assert(c != NULL);`
`9285`	`9285`	`unsigned int hbtimeout;`
`@@ -9299,7 +9299,7 @@ static void process_hbtimeout_command(conn c, token_t tokens, const size_t nto`
`9299`	`9299`	`}`
`9300`	`9300`	`}`
`9301`	`9301`
`9302`		`-static void process_hbfailstop_command(conn c, token_t tokens, const size_t ntokens)`
	`9302`	`+static void process_config_hbfailstop_command(conn c, token_t tokens, const size_t ntokens)`
`9303`	`9303`	`{`
`9304`	`9304`	`assert(c != NULL);`
`9305`	`9305`	`unsigned int hbfailstop;`
`@@ -9320,7 +9320,7 @@ static void process_hbfailstop_command(conn c, token_t tokens, const size_t nt`
`9320`	`9320`	`}`
`9321`	`9321`	`#endif`
`9322`	`9322`
`9323`		`-static void process_memlimit_command(conn c, token_t tokens, const size_t ntokens)`
	`9323`	`+static void process_config_memlimit_command(conn c, token_t tokens, const size_t ntokens)`
`9324`	`9324`	`{`
`9325`	`9325`	`assert(c != NULL);`
`9326`	`9326`	`char *config_key = tokens[SUBCOMMAND_TOKEN].value;`
`@@ -9350,7 +9350,7 @@ static void process_memlimit_command(conn c, token_t tokens, const size_t ntok`
`9350`	`9350`	`}`
`9351`	`9351`
`9352`	`9352`	`#ifdef ENABLE_STICKY_ITEM`
`9353`		`-static void process_stickylimit_command(conn c, token_t tokens, const size_t ntokens)`
	`9353`	`+static void process_config_stickylimit_command(conn c, token_t tokens, const size_t ntokens)`
`9354`	`9354`	`{`
`9355`	`9355`	`assert(c != NULL);`
`9356`	`9356`	`char *config_key = tokens[SUBCOMMAND_TOKEN].value;`
`@@ -9380,7 +9380,7 @@ static void process_stickylimit_command(conn c, token_t tokens, const size_t n`
`9380`	`9380`	`}`
`9381`	`9381`	`#endif`
`9382`	`9382`
`9383`		`-static void process_maxcollsize_command(conn c, token_t tokens, const size_t ntokens,`
	`9383`	`+static void process_config_maxcollsize_command(conn c, token_t tokens, const size_t ntokens,`
`9384`	`9384`	`int coll_type)`
`9385`	`9385`	`{`
`9386`	`9386`	`assert(c != NULL && coll_type != ITEM_TYPE_KV);`
`@@ -9438,7 +9438,7 @@ static void process_maxcollsize_command(conn c, token_t tokens, const size_t n`
`9438`	`9438`	`}`
`9439`	`9439`	`}`
`9440`	`9440`
`9441`		`-static void process_maxelembytes_command(conn c, token_t tokens, const size_t ntokens)`
	`9441`	`+static void process_config_maxelembytes_command(conn c, token_t tokens, const size_t ntokens)`
`9442`	`9442`	`{`
`9443`	`9443`	`assert(c != NULL);`
`9444`	`9444`	`char *config_key = tokens[SUBCOMMAND_TOKEN].value;`
`@@ -9468,7 +9468,7 @@ static void process_maxelembytes_command(conn c, token_t tokens, const size_t`
`9468`	`9468`	`}`
`9469`	`9469`	`}`
`9470`	`9470`
`9471`		`-static void process_scrubcount_command(conn c, token_t tokens, const size_t ntokens)`
	`9471`	`+static void process_config_scrubcount_command(conn c, token_t tokens, const size_t ntokens)`
`9472`	`9472`	`{`
`9473`	`9473`	`char *config_key = tokens[SUBCOMMAND_TOKEN].value;`
`9474`	`9474`	`char *config_val = tokens[SUBCOMMAND_TOKEN+1].value;`
`@@ -9495,7 +9495,7 @@ static void process_scrubcount_command(conn c, token_t tokens, const size_t nt`
`9495`	`9495`	`}`
`9496`	`9496`	`}`
`9497`	`9497`
`9498`		`-static void process_maxstatsprefixes_command(conn c, token_t tokens, const size_t ntokens)`
	`9498`	`+static void process_config_maxstatsprefixes_command(conn c, token_t tokens, const size_t ntokens)`
`9499`	`9499`	`{`
`9500`	`9500`	`char *config_val = tokens[SUBCOMMAND_TOKEN+1].value;`
`9501`	`9501`	`uint32_t new_max_stats_prefixes;`
`@@ -9515,7 +9515,7 @@ static void process_maxstatsprefixes_command(conn c, token_t tokens, const siz`
`9515`	`9515`	`}`
`9516`	`9516`	`}`
`9517`	`9517`
`9518`		`-static void process_verbosity_command(conn c, token_t tokens, const size_t ntokens)`
	`9518`	`+static void process_config_verbosity_command(conn c, token_t tokens, const size_t ntokens)`
`9519`	`9519`	`{`
`9520`	`9520`	`assert(c != NULL);`
`9521`	`9521`	`char *config_key = tokens[SUBCOMMAND_TOKEN].value;`
`@@ -9544,7 +9544,7 @@ static void process_verbosity_command(conn c, token_t tokens, const size_t nto`
`9544`	`9544`	`}`
`9545`	`9545`
`9546`	`9546`	`#ifdef ENABLE_PERSISTENCE`
`9547`		`-static void process_chkpt_interval_pct_snapshot_command(conn c, token_t tokens, const size_t ntokens)`
	`9547`	`+static void process_config_chkpt_interval_pct_snapshot_command(conn c, token_t tokens, const size_t ntokens)`
`9548`	`9548`	`{`
`9549`	`9549`	`assert(c != NULL);`
`9550`	`9550`	`char *config_key = tokens[SUBCOMMAND_TOKEN].value;`
`@@ -9573,7 +9573,7 @@ static void process_chkpt_interval_pct_snapshot_command(conn c, token_t tokens`
`9573`	`9573`	`}`
`9574`	`9574`	`}`
`9575`	`9575`
`9576`		`-static void process_chkpt_interval_min_logsize_command(conn c, token_t tokens, const size_t ntokens)`
	`9576`	`+static void process_config_chkpt_interval_min_logsize_command(conn c, token_t tokens, const size_t ntokens)`
`9577`	`9577`	`{`
`9578`	`9578`	`assert(c != NULL);`
`9579`	`9579`	`char *config_key = tokens[SUBCOMMAND_TOKEN].value;`
`@@ -9602,7 +9602,7 @@ static void process_chkpt_interval_min_logsize_command(conn c, token_t tokens,`
`9602`	`9602`	`}`
`9603`	`9603`	`}`
`9604`	`9604`
`9605`		`-static void process_async_logging_command(conn c, token_t tokens, const size_t ntokens)`
	`9605`	`+static void process_config_async_logging_command(conn c, token_t tokens, const size_t ntokens)`
`9606`	`9606`	`{`
`9607`	`9607`	`assert(c != NULL);`
`9608`	`9608`	`char *config_key = tokens[SUBCOMMAND_TOKEN].value;`
`@@ -9654,7 +9654,7 @@ static void* init_sasl_thread(void *arg)`
`9654`	`9654`	`return NULL;`
`9655`	`9655`	`}`
`9656`	`9656`
`9657`		`-static void process_auth_command(conn c, token_t tokens, const size_t ntokens)`
	`9657`	`+static void process_config_auth_command(conn c, token_t tokens, const size_t ntokens)`
`9658`	`9658`	`{`
`9659`	`9659`	`assert(c != NULL);`
`9660`	`9660`	`if (ntokens == 3) {`
`@@ -9701,65 +9701,65 @@ static void process_config_command(conn c, token_t tokens, const size_t ntoken`
`9701`	`9701`	`}`
`9702`	`9702`
`9703`	`9703`	`if (strcmp(config_key, "maxconns") == 0) {`
`9704`		`- process_maxconns_command(c, tokens, ntokens);`
	`9704`	`+ process_config_maxconns_command(c, tokens, ntokens);`
`9705`	`9705`	`}`
`9706`	`9706`	`else if (strcmp(config_key, "memlimit") == 0) {`
`9707`		`- process_memlimit_command(c, tokens, ntokens);`
	`9707`	`+ process_config_memlimit_command(c, tokens, ntokens);`
`9708`	`9708`	`}`
`9709`	`9709`	`else if (strcmp(config_key, "max_list_size") == 0) {`
`9710`		`- process_maxcollsize_command(c, tokens, ntokens, ITEM_TYPE_LIST);`
	`9710`	`+ process_config_maxcollsize_command(c, tokens, ntokens, ITEM_TYPE_LIST);`
`9711`	`9711`	`}`
`9712`	`9712`	`else if (strcmp(config_key, "max_set_size") == 0) {`
`9713`		`- process_maxcollsize_command(c, tokens, ntokens, ITEM_TYPE_SET);`
	`9713`	`+ process_config_maxcollsize_command(c, tokens, ntokens, ITEM_TYPE_SET);`
`9714`	`9714`	`}`
`9715`	`9715`	`else if (strcmp(config_key, "max_map_size") == 0) {`
`9716`		`- process_maxcollsize_command(c, tokens, ntokens, ITEM_TYPE_MAP);`
	`9716`	`+ process_config_maxcollsize_command(c, tokens, ntokens, ITEM_TYPE_MAP);`
`9717`	`9717`	`}`
`9718`	`9718`	`else if (strcmp(config_key, "max_btree_size") == 0) {`
`9719`		`- process_maxcollsize_command(c, tokens, ntokens, ITEM_TYPE_BTREE);`
	`9719`	`+ process_config_maxcollsize_command(c, tokens, ntokens, ITEM_TYPE_BTREE);`
`9720`	`9720`	`}`
`9721`	`9721`	`else if (strcmp(config_key, "max_element_bytes") == 0) {`
`9722`		`- process_maxelembytes_command(c, tokens, ntokens);`
	`9722`	`+ process_config_maxelembytes_command(c, tokens, ntokens);`
`9723`	`9723`	`}`
`9724`	`9724`	`else if (strcmp(config_key, "scrub_count") == 0) {`
`9725`		`- process_scrubcount_command(c, tokens, ntokens);`
	`9725`	`+ process_config_scrubcount_command(c, tokens, ntokens);`
`9726`	`9726`	`}`
`9727`	`9727`	`else if (strcmp(config_key, "max_stats_prefixes") == 0) {`
`9728`		`- process_maxstatsprefixes_command(c, tokens, ntokens);`
	`9728`	`+ process_config_maxstatsprefixes_command(c, tokens, ntokens);`
`9729`	`9729`	`}`
`9730`	`9730`	`#ifdef ENABLE_ZK_INTEGRATION`
`9731`	`9731`	`else if (strcmp(config_key, "zkfailstop") == 0) {`
`9732`		`- process_zkfailstop_command(c, tokens, ntokens);`
	`9732`	`+ process_config_zkfailstop_command(c, tokens, ntokens);`
`9733`	`9733`	`}`
`9734`	`9734`	`else if (strcmp(config_key, "hbtimeout") == 0) {`
`9735`		`- process_hbtimeout_command(c, tokens, ntokens);`
	`9735`	`+ process_config_hbtimeout_command(c, tokens, ntokens);`
`9736`	`9736`	`}`
`9737`	`9737`	`else if (strcmp(config_key, "hbfailstop") == 0) {`
`9738`		`- process_hbfailstop_command(c, tokens, ntokens);`
	`9738`	`+ process_config_hbfailstop_command(c, tokens, ntokens);`
`9739`	`9739`	`}`
`9740`	`9740`	`#endif`
`9741`	`9741`	`#ifdef ENABLE_STICKY_ITEM`
`9742`	`9742`	`else if (strcmp(config_key, "sticky_limit") == 0) {`
`9743`		`- process_stickylimit_command(c, tokens, ntokens);`
	`9743`	`+ process_config_stickylimit_command(c, tokens, ntokens);`
`9744`	`9744`	`}`
`9745`	`9745`	`#endif`
`9746`	`9746`	`else if (strcmp(config_key, "verbosity") == 0) {`
`9747`		`- process_verbosity_command(c, tokens, ntokens);`
	`9747`	`+ process_config_verbosity_command(c, tokens, ntokens);`
`9748`	`9748`	`}`
`9749`	`9749`	`#ifdef ENABLE_PERSISTENCE`
`9750`	`9750`	`else if (strcmp(config_key, "chkpt_interval_pct_snapshot") == 0) {`
`9751`		`- process_chkpt_interval_pct_snapshot_command(c, tokens, ntokens);`
	`9751`	`+ process_config_chkpt_interval_pct_snapshot_command(c, tokens, ntokens);`
`9752`	`9752`	`}`
`9753`	`9753`	`else if (strcmp(config_key, "chkpt_interval_min_logsize") == 0) {`
`9754`		`- process_chkpt_interval_min_logsize_command(c, tokens, ntokens);`
	`9754`	`+ process_config_chkpt_interval_min_logsize_command(c, tokens, ntokens);`
`9755`	`9755`	`}`
`9756`	`9756`	`else if (strcmp(config_key, "async_logging") == 0) {`
`9757`		`- process_async_logging_command(c, tokens, ntokens);`
	`9757`	`+ process_config_async_logging_command(c, tokens, ntokens);`
`9758`	`9758`	`}`
`9759`	`9759`	`#endif`
`9760`	`9760`	`#ifdef SASL_ENABLED`
`9761`	`9761`	`else if (strcmp(config_key, "auth") == 0) {`
`9762`		`- process_auth_command(c, tokens, ntokens);`
	`9762`	`+ process_config_auth_command(c, tokens, ntokens);`
`9763`	`9763`	`}`
`9764`	`9764`	`#endif`
`9765`	`9765`	`else {`