This makes the part numbers readily accessible to formatters. Hierarchical part numbering would be a more natural and efficient fit for MIME and may be the way to go in the future, but depth-first numbering maintains compatibility with what we currently do. --- mime-node.c | 33 ++++++++++++++++++++++++++++++++- notmuch-client.h | 11 +++++++++++ 2 files changed, 43 insertions(+), 1 deletions(-) diff --git a/mime-node.c b/mime-node.c index d26bb44..30b542f 100644 --- a/mime-node.c +++ b/mime-node.c @@ -104,6 +104,10 @@ mime_node_open (const void *ctx, notmuch_message_t *message, root->nchildren = 1; root->ctx = mctx; + root->part_num = 0; + root->next_child = 0; + root->next_part_num = 1; + *root_out = root; return NOTMUCH_STATUS_SUCCESS; @@ -133,6 +137,8 @@ _mime_node_create (const mime_node_t *parent, GMimeObject *part) talloc_free (node); return NULL; } + node->parent = parent; + node->part_num = node->next_part_num = -1; /* Deal with the different types of parts */ if (GMIME_IS_PART (part)) { @@ -217,6 +223,7 @@ mime_node_t * mime_node_child (const mime_node_t *parent, int child) { GMimeObject *sub; + mime_node_t *node; if (!parent || child < 0 || child >= parent->nchildren) return NULL; @@ -234,7 +241,31 @@ mime_node_child (const mime_node_t *parent, int child) INTERNAL_ERROR ("Unexpected GMimeObject type: %s", g_type_name (G_OBJECT_TYPE (parent->part))); } - return _mime_node_create (parent, sub); + node = _mime_node_create (parent, sub); + + if (child == parent->next_child && parent->next_part_num != -1) { + /* We're traversing in depth-first order. Record the child's + * depth-first numbering. */ + node->part_num = parent->next_part_num; + node->next_part_num = node->part_num + 1; + + /* Drop the const qualifier because these are internal fields + * whose mutability doesn't affect the interface. */ + ((mime_node_t*)parent)->next_child++; + ((mime_node_t*)parent)->next_part_num = -1; + + if (node->nchildren == 0) { + /* We've reached a leaf, so find the parent that has more + * children and set it up to number its next child. */ + const mime_node_t *it = node; + while (it && it->next_child == it->nchildren) + it = it->parent; + if (it) + ((mime_node_t*)it)->next_part_num = node->part_num + 1; + } + } + + return node; } static mime_node_t * diff --git a/notmuch-client.h b/notmuch-client.h index 517c010..8832242 100644 --- a/notmuch-client.h +++ b/notmuch-client.h @@ -273,6 +273,13 @@ typedef struct mime_node { /* The number of children of this part. */ int nchildren; + /* The parent of this node or NULL if this is the root node. */ + const struct mime_node *parent; + + /* The depth-first part number of this child if the MIME tree is + * being traversed in depth-first order, or -1 otherwise. */ + int part_num; + /* True if decryption of this part was attempted. */ notmuch_bool_t decrypt_attempted; /* True if decryption of this part's child succeeded. In this @@ -294,6 +301,10 @@ typedef struct mime_node { /* Internal: For successfully decrypted multipart parts, the * decrypted part to substitute for the second child. */ GMimeObject *decrypted_child; + + /* Internal: The next child for depth-first traversal and the part + * number to assign it (or -1 if unknown). */ + int next_child, next_part_num; } mime_node_t; /* Construct a new MIME node pointing to the root message part of -- 1.7.7.3