+static volatile sig_atomic_t interrupted;
+
+static void
+handle_sigint (unused (int sig))
+{
+ static char msg[] = "Stopping... \n";
+
+ /* This write is "opportunistic", so it's okay to ignore the
+ * result. It is not required for correctness, and if it does
+ * fail or produce a short write, we want to get out of the signal
+ * handler as quickly as possible, not retry it. */
+ IGNORE_RESULT (write (2, msg, sizeof (msg) - 1));
+ interrupted = 1;
+}
+
+static char *
+_escape_tag (char *buf, const char *tag)
+{
+ const char *in = tag;
+ char *out = buf;
+
+ /* Boolean terms surrounded by double quotes can contain any
+ * character. Double quotes are quoted by doubling them. */
+ *out++ = '"';
+ while (*in) {
+ if (*in == '"')
+ *out++ = '"';
+ *out++ = *in++;
+ }
+ *out++ = '"';
+ *out = 0;
+ return buf;
+}
+
+typedef struct {
+ const char *tag;
+ notmuch_bool_t remove;
+} tag_operation_t;
+
+static char *
+_optimize_tag_query (void *ctx, const char *orig_query_string,
+ const tag_operation_t *tag_ops)
+{
+ /* This is subtler than it looks. Xapian ignores the '-' operator
+ * at the beginning both queries and parenthesized groups and,
+ * furthermore, the presence of a '-' operator at the beginning of
+ * a group can inhibit parsing of the previous operator. Hence,
+ * the user-provided query MUST appear first, but it is safe to
+ * parenthesize and the exclusion part of the query must not use
+ * the '-' operator (though the NOT operator is fine). */
+
+ char *escaped, *query_string;
+ const char *join = "";
+ int i;
+ unsigned int max_tag_len = 0;
+
+ /* Don't optimize if there are no tag changes. */
+ if (tag_ops[0].tag == NULL)
+ return talloc_strdup (ctx, orig_query_string);
+
+ /* Allocate a buffer for escaping tags. This is large enough to
+ * hold a fully escaped tag with every character doubled plus
+ * enclosing quotes and a NUL. */
+ for (i = 0; tag_ops[i].tag; i++)
+ if (strlen (tag_ops[i].tag) > max_tag_len)
+ max_tag_len = strlen (tag_ops[i].tag);
+ escaped = talloc_array (ctx, char, max_tag_len * 2 + 3);
+ if (! escaped)
+ return NULL;
+
+ /* Build the new query string */
+ if (strcmp (orig_query_string, "*") == 0)
+ query_string = talloc_strdup (ctx, "(");
+ else
+ query_string = talloc_asprintf (ctx, "( %s ) and (", orig_query_string);
+
+ for (i = 0; tag_ops[i].tag && query_string; i++) {
+ query_string = talloc_asprintf_append_buffer (
+ query_string, "%s%stag:%s", join,
+ tag_ops[i].remove ? "" : "not ",
+ _escape_tag (escaped, tag_ops[i].tag));
+ join = " or ";
+ }
+
+ if (query_string)
+ query_string = talloc_strdup_append_buffer (query_string, ")");
+
+ talloc_free (escaped);
+ return query_string;
+}
+
+/* Tag messages matching 'query_string' according to 'tag_ops', which
+ * must be an array of tagging operations terminated with an empty
+ * element. */
+static int
+tag_query (void *ctx, notmuch_database_t *notmuch, const char *query_string,
+ tag_operation_t *tag_ops, notmuch_bool_t synchronize_flags)