X-Git-Url: https://git.notmuchmail.org/git?p=notmuch;a=blobdiff_plain;f=tag-util.c;h=343c161f471aa827ff186df01e7c24afe71e5d06;hp=6d33ef8f3010be5ebf7fe932c23a5db4b9245d09;hb=4e2c351c588ad74f4800ca0344232be90387c54a;hpb=fb50cc41fe6f508118697d65a44e8f742a466ca0 diff --git a/tag-util.c b/tag-util.c index 6d33ef8f..343c161f 100644 --- a/tag-util.c +++ b/tag-util.c @@ -31,6 +31,24 @@ line_error (tag_parse_status_t status, return status; } +const char * +illegal_tag (const char *tag, notmuch_bool_t remove) +{ + + if (*tag == '\0' && ! remove) + return "empty tag forbidden"; + + /* This disallows adding tags starting with "-", in particular the + * non-removable tag "-" and enables notmuch tag to take long + * options more easily. + */ + + if (*tag == '-' && ! remove) + return "tag starting with '-' forbidden"; + + return NULL; +} + tag_parse_status_t parse_tag_line (void *ctx, char *line, tag_op_flag_t flags, @@ -40,14 +58,14 @@ parse_tag_line (void *ctx, char *line, char *tok = line; size_t tok_len = 0; char *line_for_error; - int ret = 0; + tag_parse_status_t ret = TAG_PARSE_SUCCESS; chomp_newline (line); line_for_error = talloc_strdup (ctx, line); if (line_for_error == NULL) { fprintf (stderr, "Error: out of memory\n"); - return -1; + return TAG_PARSE_OUT_OF_MEMORY; } /* remove leading space */ @@ -95,11 +113,13 @@ parse_tag_line (void *ctx, char *line, remove = (*tok == '-'); tag = tok + 1; - /* Maybe refuse empty tags. */ - if (! (flags & TAG_FLAG_BE_GENEROUS) && *tag == '\0') { - ret = line_error (TAG_PARSE_INVALID, line_for_error, - "empty tag"); - goto DONE; + /* Maybe refuse illegal tags. */ + if (! (flags & TAG_FLAG_BE_GENEROUS)) { + const char *msg = illegal_tag (tag, remove); + if (msg) { + ret = line_error (TAG_PARSE_INVALID, line_for_error, msg); + goto DONE; + } } /* Decode tag. */ @@ -109,7 +129,7 @@ parse_tag_line (void *ctx, char *line, goto DONE; } - if (tag_op_list_append (ctx, tag_ops, tag, remove)) { + if (tag_op_list_append (tag_ops, tag, remove)) { ret = line_error (TAG_PARSE_OUT_OF_MEMORY, line_for_error, "aborting"); goto DONE; @@ -124,12 +144,6 @@ parse_tag_line (void *ctx, char *line, } /* tok now points to the query string */ - if (hex_decode_inplace (tok) != HEX_SUCCESS) { - ret = line_error (TAG_PARSE_INVALID, line_for_error, - "hex decoding of query %s failed", tok); - goto DONE; - } - *query_string = tok; DONE: @@ -137,6 +151,45 @@ parse_tag_line (void *ctx, char *line, return ret; } +tag_parse_status_t +parse_tag_command_line (void *ctx, int argc, char **argv, + char **query_str, tag_op_list_t *tag_ops) +{ + + int i; + + for (i = 0; i < argc; i++) { + if (strcmp (argv[i], "--") == 0) { + i++; + break; + } + + if (argv[i][0] != '+' && argv[i][0] != '-') + break; + + notmuch_bool_t is_remove = argv[i][0] == '-'; + const char *msg; + + msg = illegal_tag (argv[i] + 1, is_remove); + if (msg) { + fprintf (stderr, "Error: %s\n", msg); + return TAG_PARSE_INVALID; + } + + tag_op_list_append (tag_ops, argv[i] + 1, is_remove); + } + + *query_str = query_string_from_args (ctx, argc - i, &argv[i]); + + if (*query_str == NULL) { + fprintf (stderr, "Out of memory.\n"); + return TAG_PARSE_OUT_OF_MEMORY; + } + + return TAG_PARSE_SUCCESS; +} + + static inline void message_error (notmuch_message_t *message, notmuch_status_t status, @@ -151,6 +204,71 @@ message_error (notmuch_message_t *message, fprintf (stderr, "Status: %s\n", notmuch_status_to_string (status)); } +static int +makes_changes (notmuch_message_t *message, + tag_op_list_t *list, + tag_op_flag_t flags) +{ + + size_t i; + + notmuch_tags_t *tags; + notmuch_bool_t changes = FALSE; + + /* First, do we delete an existing tag? */ + changes = FALSE; + for (tags = notmuch_message_get_tags (message); + ! changes && notmuch_tags_valid (tags); + notmuch_tags_move_to_next (tags)) { + const char *cur_tag = notmuch_tags_get (tags); + int last_op = (flags & TAG_FLAG_REMOVE_ALL) ? -1 : 0; + + /* scan backwards to get last operation */ + i = list->count; + while (i > 0) { + i--; + if (strcmp (cur_tag, list->ops[i].tag) == 0) { + last_op = list->ops[i].remove ? -1 : 1; + break; + } + } + + changes = (last_op == -1); + } + notmuch_tags_destroy (tags); + + if (changes) + return TRUE; + + /* Now check for adding new tags */ + for (i = 0; i < list->count; i++) { + notmuch_bool_t exists = FALSE; + + if (list->ops[i].remove) + continue; + + for (tags = notmuch_message_get_tags (message); + notmuch_tags_valid (tags); + notmuch_tags_move_to_next (tags)) { + const char *cur_tag = notmuch_tags_get (tags); + if (strcmp (cur_tag, list->ops[i].tag) == 0) { + exists = TRUE; + break; + } + } + notmuch_tags_destroy (tags); + + /* the following test is conservative, + * in the sense it ignores cases like +foo ... -foo + * but this is OK from a correctness point of view + */ + if (! exists) + return TRUE; + } + return FALSE; + +} + notmuch_status_t tag_op_list_apply (notmuch_message_t *message, tag_op_list_t *list, @@ -160,6 +278,9 @@ tag_op_list_apply (notmuch_message_t *message, notmuch_status_t status = 0; tag_operation_t *tag_ops = list->ops; + if (! (flags & TAG_FLAG_PRE_OPTIMIZED) && ! makes_changes (message, list, flags)) + return NOTMUCH_STATUS_SUCCESS; + status = notmuch_message_freeze (message); if (status) { message_error (message, status, "freezing message"); @@ -226,7 +347,7 @@ tag_op_list_create (void *ctx) list->size = TAG_OP_LIST_INITIAL_SIZE; list->count = 0; - list->ops = talloc_array (ctx, tag_operation_t, list->size); + list->ops = talloc_array (list, tag_operation_t, list->size); if (list->ops == NULL) return NULL; @@ -235,8 +356,7 @@ tag_op_list_create (void *ctx) int -tag_op_list_append (void *ctx, - tag_op_list_t *list, +tag_op_list_append (tag_op_list_t *list, const char *tag, notmuch_bool_t remove) { @@ -246,7 +366,7 @@ tag_op_list_append (void *ctx, if (list->count == list->size) { list->size *= 2; - list->ops = talloc_realloc (ctx, list->ops, tag_operation_t, + list->ops = talloc_realloc (list, list->ops, tag_operation_t, list->size); if (list->ops == NULL) { fprintf (stderr, "Out of memory.\n");