move "dump" to state functions keyed off of trie->type

diff --git a/src/lib/util/trie.c b/src/lib/util/trie.c
index 370789f8c0fc11046141171cd58f4638f95b88a6..e1137e8f1bc1cbdd5186c5e75f220308600e6636 100644 (file)
--- a/src/lib/util/trie.c
+++ b/src/lib/util/trie.c
@@ -1774,105 +1774,111 @@ static int fr_trie_key_walk(fr_trie_t *trie, fr_trie_callback_t *cb, int depth,
  */
 static void fr_trie_dump_edge(FILE *fp, fr_trie_t *trie)
 {
-       if (trie->type == FR_TRIE_USER) {
-               fr_trie_user_t *user = (fr_trie_user_t *) trie;
+       fr_cond_assert(trie != NULL);
 
-               fprintf(fp, "NODE-%d\n", user->number);
-               return;
-       }
+       fprintf(fp, "NODE-%d\n", trie->number);
+       return;
+}
 
-       if (trie->type == FR_TRIE_NODE) {
-               fr_trie_node_t *node = (fr_trie_node_t *) trie;
 
-               fprintf(fp, "NODE-%d\n", node->number);
-               return;
-       }
+typedef void (*fr_trie_dump_t)(FILE *fp, fr_trie_t *trie, char const *key, int keylen);
 
-#ifdef WITH_PATH_COMPRESSION
-       if (trie->type == FR_TRIE_PATH) {
-               fr_trie_path_t *path = (fr_trie_path_t *) trie;
+static void fr_trie_user_dump(FILE *fp, fr_trie_t *trie, char const *key, int keylen)
+{
+       fr_trie_user_t *user = (fr_trie_user_t *) trie;
+       int bytes = BYTES(keylen);
 
-               fprintf(fp, "NODE-%d\n", path->number);
+       fprintf(fp, "{ NODE-%d\n", user->number);
+       fprintf(fp, "\ttype\tUSER\n");
+       fprintf(fp, "\tinput\t{%d}%.*s\n", keylen, bytes, key);
+
+       fprintf(fp, "\tdata\t\"%s\"\n", (char const *) user->data);
+       if (!user->trie) {
+               fprintf(fp, "}\n\n");
                return;
        }
-#endif
 
-       fprintf(fp, "NODE-???");
+       fprintf(fp, "\tnext\t");
+       fr_trie_dump_edge(fp, user->trie);
+       fprintf(fp, "}\n\n");
 }
 
-
-/**  Dump the trie nodes
- *
- */
-static int fr_trie_dump_cb(fr_trie_t *trie, fr_trie_callback_t *cb, int keylen, UNUSED bool more)
+static void fr_trie_node_dump(FILE *fp, fr_trie_t *trie, char const *key, int keylen)
 {
-       int i, bytes;
-       FILE *fp = cb->ctx;
-       fr_trie_node_t *node;
-
-       if (!trie) return 0;
-
-       bytes = BYTES(keylen);
+       fr_trie_node_t *node = (fr_trie_node_t *) trie;
+       int i;
+       int bytes = BYTES(keylen);
 
-       if (trie->type == FR_TRIE_USER) {
-               fr_trie_user_t *user = (fr_trie_user_t *) trie;
+       fprintf(fp, "{ NODE-%d\n", node->number);
+       fprintf(fp, "\ttype\tNODE\n");
+       fprintf(fp, "\tinput\t{%d}%.*s\n", keylen, bytes, key);
 
-               fprintf(fp, "{ NODE-%d\n", user->number);
-               fprintf(fp, "\ttype\tUSER\n");
-               fprintf(fp, "\tinput\t{%d}%.*s\n", keylen, bytes, cb->start);
+       fprintf(fp, "\tbits\t%d\n", node->bits);
+       fprintf(fp, "\tused\t%d\n", node->used);
 
-               fprintf(fp, "\tdata\t\"%s\"\n", (char const *) user->data);
-               if (!user->trie) {
-                       fprintf(fp, "}\n\n");
-                       return 0;
-               }
+       for (i = 0; i < (1 << node->bits); i++) {
+               if (!node->trie[i]) continue;
 
-               fprintf(fp, "\tnext\t");
-               fr_trie_dump_edge(fp, user->trie);
-               fprintf(fp, "}\n\n");
-               return 0;
+               fprintf(fp, "\t%02x\t", (int) i);
+               fr_trie_dump_edge(fp, node->trie[i]);
        }
+       fprintf(fp, "}\n\n");
+}
 
 #ifdef WITH_PATH_COMPRESSION
-       if (trie->type == FR_TRIE_PATH) {
-               fr_trie_path_t *path = (fr_trie_path_t *) trie;
-               fprintf(fp, "{ NODE-%d\n", path->number);
-               fprintf(fp, "\ttype\tPATH\n");
-               fprintf(fp, "\tinput\t{%d}%.*s\n", keylen, bytes, cb->start);
+static void fr_trie_path_dump(FILE *fp, fr_trie_t *trie, char const *key, int keylen)
+{
+       fr_trie_path_t *path = (fr_trie_path_t *) trie;
+       int bytes = BYTES(keylen);
 
-               fprintf(fp, "\tbits\t%d\n", (int) path->bits);
-               fprintf(fp, "\tpath\t");
+       fprintf(fp, "{ NODE-%d\n", path->number);
+       fprintf(fp, "\ttype\tPATH\n");
+       fprintf(fp, "\tinput\t{%d}%.*s\n", keylen, bytes, key);
 
-               fprintf(fp, "%02x %02x", path->key[0], path->key[1]);
+       fprintf(fp, "\tbits\t%d\n", (int) path->bits);
+       fprintf(fp, "\tpath\t");
 
-               fprintf(fp, "\n");
+       fprintf(fp, "%02x %02x", path->key[0], path->key[1]);
 
-               fprintf(fp, "\tnext\t");
-               fr_trie_dump_edge(fp, path->trie);
+       fprintf(fp, "\n");
 
-               fprintf(fp, "}\n\n");
-               return 0;
-       }
+       fprintf(fp, "\tnext\t");
+       fr_trie_dump_edge(fp, path->trie);
+
+       fprintf(fp, "}\n\n");
+}
 #endif
 
+static fr_trie_dump_t trie_dump[FR_TRIE_MAX] = {
+       [ FR_TRIE_USER ] = fr_trie_user_dump,
+       [ FR_TRIE_NODE ] = fr_trie_node_dump,
 
-       node = (fr_trie_node_t *) trie;
+#ifdef WITH_PATH_COMPRESSION
+       [ FR_TRIE_PATH ] = fr_trie_path_dump,
+#endif
+};
 
-       fprintf(fp, "{ NODE-%d\n", node->number);
-       fprintf(fp, "\ttype\tNODE\n");
-       fprintf(fp, "\tinput\t{%d}%.*s\n", keylen, bytes, cb->start);
 
-       fprintf(fp, "\tbits\t%d\n", node->bits);
-       fprintf(fp, "\tused\t%d\n", node->used);
+/**  Dump the trie nodes
+ *
+ */
+static int fr_trie_dump_cb(fr_trie_t *trie, fr_trie_callback_t *cb, int keylen, UNUSED bool more)
+{
+       FILE *fp = cb->ctx;
 
-       for (i = 0; i < (1 << node->bits); i++) {
-               if (!node->trie[i]) continue;
+       if (!trie) return 0;
 
-               fprintf(fp, "\t%02x\t", (int) i);
-               fr_trie_dump_edge(fp, node->trie[i]);
+       /*
+        *      Catch problems.
+        */
+       if ((trie->type == FR_TRIE_INVALID) ||
+           (trie->type >= FR_TRIE_MAX) ||
+           !trie_dump[trie->type]) {
+               fr_strerror_printf("unknown trie type %d in dump", trie->type);
+               return 0;
        }
-       fprintf(fp, "}\n\n");
 
+       trie_dump[trie->type](fp, trie, (char const *) cb->start, keylen);
        return 0;
 }