Cleanup: rename is_* to starts_*, move functions together, factor out start finding...

[ccan] / ccan / tdb / tools / replay_trace.c

diff --git a/ccan/tdb/tools/replay_trace.c b/ccan/tdb/tools/replay_trace.c
index 0968deddc23832c5a0203238a275708916190ba4..8e099f2f13a255cfefbf15e5806e27ceac397ab4 100644 (file)
--- a/ccan/tdb/tools/replay_trace.c
+++ b/ccan/tdb/tools/replay_trace.c
@@ -213,8 +213,7 @@ static void op_add_key(const char *filename,
                fail(filename, op_num+1, "Expected just a key");
 
        op[op_num].key = make_tdb_data(op, filename, op_num+1, words[2]);
-       if (op[op_num].op != OP_TDB_TRAVERSE)
-               total_keys++;
+       total_keys++;
 }
 
 static void op_add_key_ret(const char *filename,
@@ -243,6 +242,16 @@ static void op_add_key_data(const char *filename,
                total_keys++;
 }
 
+/* We don't record the keys or data for a traverse, as we don't use them. */
+static void op_add_traverse(const char *filename,
+                           struct op op[], unsigned int op_num, char *words[])
+{
+       if (!words[2] || !words[3] || !words[4] || words[5]
+           || !streq(words[3], "="))
+               fail(filename, op_num+1, "Expected <key> = <data>");
+       op[op_num].key = tdb_null;
+}
+
 /* <serial> tdb_store <rec> <rec> <flag> = <ret> */
 static void op_add_store(const char *filename,
                         struct op op[], unsigned int op_num, char *words[])
@@ -290,8 +299,9 @@ static void op_add_seqnum(const char *filename,
        op[op_num].ret = atoi(words[3]);
 }
 
-static void op_add_traverse(const char *filename,
-                           struct op op[], unsigned int op_num, char *words[])
+static void op_add_traverse_start(const char *filename,
+                                 struct op op[],
+                                 unsigned int op_num, char *words[])
 {
        if (words[2])
                fail(filename, op_num+1, "Expect no arguments");
@@ -310,12 +320,12 @@ static void op_add_transaction(const char *filename, struct op op[],
        op[op_num].group_len = 0;
 }
 
-static int op_transaction_start(struct op op[], unsigned int op_num)
+static int op_find_start(struct op op[], unsigned int op_num, enum op_type type)
 {
        unsigned int i;
 
        for (i = op_num-1; i > 0; i--) {
-               if (op[i].op == OP_TDB_TRANSACTION_START && !op[i].group_len)
+               if (op[i].op == type && !op[i].group_len)
                        return i;
        }
        return 0;
@@ -332,7 +342,7 @@ static void op_analyze_transaction(const char *filename,
        if (words[2])
                fail(filename, op_num+1, "Expect no arguments");
 
-       start = op_transaction_start(op, op_num);
+       start = op_find_start(op, op_num, OP_TDB_TRANSACTION_START);
        if (!start)
                fail(filename, op_num+1, "no transaction start found");
 
@@ -343,11 +353,6 @@ static void op_analyze_transaction(const char *filename,
                op[i].group_start = start;
 }
 
-struct traverse_hash {
-       TDB_DATA key;
-       unsigned int index;
-};
-
 static void op_analyze_traverse(const char *filename,
                                struct op op[], unsigned int op_num,
                                char *words[])
@@ -364,19 +369,12 @@ static void op_analyze_traverse(const char *filename,
        } else
                op[op_num].ret = 0;
 
-       for (i = op_num-1; i >= 0; i--) {
-               if (op[i].op != OP_TDB_TRAVERSE_READ_START
-                   && op[i].op != OP_TDB_TRAVERSE_START)
-                       continue;
-               if (op[i].group_len)
-                       continue;
-               break;
-       }
-
-       if (i < 0)
+       start = op_find_start(op, op_num, OP_TDB_TRAVERSE_START);
+       if (!start)
+               start = op_find_start(op, op_num, OP_TDB_TRAVERSE_READ_START);
+       if (!start)
                fail(filename, op_num+1, "no traversal start found");
 
-       start = i;
        op[start].group_len = op_num - start;
 
        for (i = start; i <= op_num; i++)
@@ -733,7 +731,7 @@ unsigned run_ops(struct tdb_context *tdb,
 static struct op *maybe_cancel_transaction(const char *filename,
                                           struct op *op, unsigned int *num)
 {
-       unsigned int start = op_transaction_start(op, *num);
+       unsigned int start = op_find_start(op, *num, OP_TDB_TRANSACTION_START);
 
        if (start) {
                char *words[] = { "<unknown>", "tdb_close", NULL };
@@ -894,16 +892,32 @@ static const TDB_DATA *needs(const struct op *op)
        
 }
 
-static bool is_transaction(const struct op *op)
+static bool starts_transaction(const struct op *op)
 {
        return op->op == OP_TDB_TRANSACTION_START;
 }
 
+static bool in_transaction(const struct op op[], unsigned int i)
+{
+       return op[i].group_start && starts_transaction(&op[op[i].group_start]);
+}
+
+static bool starts_traverse(const struct op *op)
+{
+       return op->op == OP_TDB_TRAVERSE_START
+               || op->op == OP_TDB_TRAVERSE_READ_START;
+}
+
+static bool in_traverse(const struct op op[], unsigned int i)
+{
+       return op[i].group_start && starts_traverse(&op[op[i].group_start]);
+}
+
 /* What's the data after this op?  pre if nothing changed. */
 static const TDB_DATA *gives(const TDB_DATA *key, const TDB_DATA *pre,
                             const struct op *op)
 {
-       if (is_transaction(op)) {
+       if (starts_transaction(op)) {
                unsigned int i;
 
                /* Cancelled transactions don't change anything. */
@@ -913,8 +927,7 @@ static const TDB_DATA *gives(const TDB_DATA *key, const TDB_DATA *pre,
 
                for (i = 1; i < op->group_len; i++) {
                        /* This skips nested transactions, too */
-                       if (op[i].op != OP_TDB_TRAVERSE
-                           && key_eq(op[i].key, *key))
+                       if (key_eq(op[i].key, *key))
                                pre = gives(key, pre, &op[i]);
                }
                return pre;
@@ -936,22 +949,6 @@ static const TDB_DATA *gives(const TDB_DATA *key, const TDB_DATA *pre,
        return pre;
 }
 
-static bool in_transaction(const struct op op[], unsigned int i)
-{
-       return op[i].group_start && is_transaction(&op[op[i].group_start]);
-}
-
-static bool is_traverse(const struct op *op)
-{
-       return op->op == OP_TDB_TRAVERSE_START
-               || op->op == OP_TDB_TRAVERSE_READ_START;
-}
-
-static bool in_traverse(const struct op op[], unsigned int i)
-{
-       return op[i].group_start && is_traverse(&op[op[i].group_start]);
-}
-
 static struct keyinfo *hash_ops(struct op *op[], unsigned int num_ops[],
                                unsigned int num)
 {
@@ -968,11 +965,6 @@ static struct keyinfo *hash_ops(struct op *op[], unsigned int num_ops[],
                        if (!op[i][j].key.dptr)
                                continue;
 
-                       /* We don't wait for traverse keys */
-                       /* FIXME: We should, for trivial traversals. */
-                       if (op[i][j].op == OP_TDB_TRAVERSE)
-                               continue;
-
                        h = hash_key(&op[i][j].key) % (total_keys * 2);
                        while (!key_eq(hash[h].key, op[i][j].key)) {
                                if (!hash[h].key.dptr) {
@@ -1019,14 +1011,13 @@ static bool satisfies(const TDB_DATA *key, const TDB_DATA *data,
 {
        const TDB_DATA *need = NULL;
 
-       if (is_transaction(op)) {
+       if (starts_transaction(op)) {
                unsigned int i;
 
                /* Look through for an op in this transaction which
                 * needs this key. */
                for (i = 1; i < op->group_len; i++) {
-                       if (op[i].op != OP_TDB_TRAVERSE
-                           && key_eq(op[i].key, *key)) {
+                       if (key_eq(op[i].key, *key)) {
                                need = needs(&op[i]);
                                /* tdb_exists() is special: there might be
                                 * something in the transaction with more
@@ -1280,7 +1271,7 @@ static void add_dependency(void *ctx,
 #endif
 
        /* If you depend on a transaction, you actually depend on it ending. */
-       if (is_transaction(&op[satisfies_file][satisfies_opnum])) {
+       if (starts_transaction(&op[satisfies_file][satisfies_opnum])) {
                satisfies_opnum
                        += op[satisfies_file][satisfies_opnum].group_len;
 #if DEBUG_DEPS
@@ -1437,7 +1428,7 @@ static void make_traverse_depends(char *filename[],
                        /* Traverse start (ignore those in
                         * transactions; they're already covered by
                         * transaction dependencies). */
-                       if (is_traverse(&op[i][j])
+                       if (starts_traverse(&op[i][j])
                            && !in_transaction(op[i], j)) {
                                dep = talloc_realloc(NULL, dep,
                                                     struct traverse_dep,