+ struct field f = {{0}};
+ enum state s = FLD2;
+
+
+ if (!head)
+ return 1;
+
+ nexus_clear(head);
+ if (!talked++ && pdebug) {
+ nexus_debug(head, 0);
+ }
+
+ while (s == FLD2 || s == BODY2) {
+ switch (s = m_getfld2(s, &f, fp)) {
+ case LENERR2:
+ s = FLD2;
+ /* FALL */
+ case FLD2:
+ nexus_match(&f, msgnum, head);
+ break;
+ case BODY2:
+ if (!body) {
+ return head->match;
+ }
+ nexus_match(&f, msgnum, head);
+ break;
+ case IOERR2:
+ advise(NULL, "IOERR in message %d\n", msgnum);
+ return FALSE;
+ case FILEEOF2:
+ break;
+ default:
+ adios(EX_SOFTWARE, "m_getfld2", "returned unknown state %d at message %d", s, msgnum);
+ }
+ }
+ return head->match;
+}
+
+static boolean
+match_grep(struct field *f, struct grep_data *g)
+{
+ int ret;
+ char buf[BUFSIZ];
+
+ if (!g->header && *f->name) {
+ return FALSE;
+ }
+
+ if (!g->header) {
+ ret = regexec(g->preg, f->value, 0, NULL, 0);
+ goto out;
+ }
+
+ /* check for the right field */
+ if (!(g->header && *g->header && mh_strcasecmp(g->header, f->name)==0)) {
+ return FALSE;
+ }
+
+ if (decode_rfc2047(f->value, buf, sizeof(buf))) {
+ ret = regexec(g->preg, buf, 0, NULL, 0);
+ } else {
+ ret = regexec(g->preg, f->value, 0, NULL, 0);
+ }
+out:
+ switch (ret) {
+ case 0:
+ return TRUE;
+ case REG_NOMATCH:
+ return FALSE;
+ default:
+ regerror(ret, g->preg, buf, sizeof(buf));
+ fprintf(stderr, "%s\n", buf);
+ return FALSE;
+ }
+}
+
+static boolean
+match_date(struct field *f, int msgnum, struct date_data *dd)
+{
+ struct tws *tw;
+ char *bp;
+ boolean ret = FALSE;
+
+ if (mh_strcasecmp(f->name, dd->datef)!=0) {
+ return FALSE;
+ }
+ bp = mh_xstrdup(f->value);
+ if ((tw = dparsetime(bp)) == NULL) {
+ advise(NULL, "unable to parse %s field in message %d, not matching...", dd->datef, msgnum);
+ } else if (dd->after) {
+ ret = twsort(tw, &dd->tws) > 0;
+ } else {
+ ret = twsort(tw, &dd->tws) < 0;
+ }
+
+ mh_free0(&bp);
+ return ret;
+}
+
+static boolean
+nexus_match(struct field *f, int msgnum, struct nexus *n)
+{
+ switch (n->t) {
+ case and_t:
+ n->match = nexus_match(f, msgnum, n->data.b.left);
+ n->match = nexus_match(f, msgnum, n->data.b.right) && n->match;
+ break;
+ case or_t:
+ n->match = nexus_match(f, msgnum, n->data.b.left);
+ n->match = nexus_match(f, msgnum, n->data.b.right) || n->match;
+ break;
+ case not_t:
+ n->match = !nexus_match(f, msgnum, n->data.b.left);
+ break;
+ case date_t:
+ if (n->match) {
+ return n->match;
+ }
+ n->match = match_date(f, msgnum, &n->data.d);
+ break;
+ case grep_t:
+ if (n->match) {
+ return n->match;
+ }
+ n->match = match_grep(f, &n->data.g);
+ break;
+ default:
+ adios(EX_SOFTWARE, NULL, "nexus tree contains a unknown nexus_type (%d)", n->t);
+ }
+ return n->match;
+}
+
+static void
+nexus_debug(struct nexus *n, size_t level)
+{
+ struct date_data *dd;
+ print_debug_level(level);
+ switch (n->t) {
+ case and_t:
+ fputs("AND\n", stderr);
+ nexus_debug(n->data.b.left, level+1);
+ nexus_debug(n->data.b.right, level+1);
+ break;
+ case or_t:
+ fputs("OR\n", stderr);
+ nexus_debug(n->data.b.left, level+1);
+ nexus_debug(n->data.b.right, level+1);
+ break;
+ case not_t:
+ fputs("NOT\n", stderr);
+ nexus_debug(n->data.b.left, level+1);
+ break;
+ case grep_t:
+ nexus_debug_grep(&n->data.g);
+ break;
+ case date_t:
+ dd = &n->data.d;
+ fprintf(stderr, "TEMPORAL(%s) %s: %s\n",dd->after ? "after" : "before", dd->datef, dasctime(&dd->tws));
+ break;
+ default:
+ adios(EX_SOFTWARE, NULL, "nexus tree contains a unknown nexus_type (%d)", n->t);
+ }
+}
+
+static void
+nexus_debug_grep(struct grep_data *gd)
+{
+ char *buf, *buf2, *pbuf, *pbuf2;
+
+ pbuf = pbuf2 = mh_xstrdup(gd->pattern);
+
+ for (;*pbuf2; pbuf2++) {
+ *pbuf2 = tolower(*pbuf2);
+ }
+
+ if (gd->header) {
+ buf = buf2 = mh_xstrdup(gd->header);
+ for (;*buf2; buf2++) {
+ *buf2 = tolower(*buf2);
+ }
+ fprintf(stderr, "PETTERN(%s) %s\n", buf, pbuf);
+ } else {
+ fprintf(stderr, "PETTERN(BODY) %s\n", pbuf);
+ }
+ mh_free0(&buf);
+ mh_free0(&pbuf);
+}
+
+static void
+nexus_free(struct nexus **n)
+{
+ if (!(*n)) {
+ return;
+ }
+ switch((*n)->t) {
+ case and_t:
+ case or_t:
+ nexus_free(&(*n)->data.b.right);
+ /* FALL */
+ case not_t:
+ nexus_free(&(*n)->data.b.left);
+ break;
+ case grep_t:
+ mh_free0(&(*n)->data.g.header);
+ mh_free0(&(*n)->data.g.pattern);
+ regfree((*n)->data.g.preg);
+ case date_t:
+ break;
+ default:
+ advise(NULL, "Unknown nexus_type (%d) to free", (*n)->t);
+ }
+ mh_free0(n);
+}
+
+static void
+print_debug_level(size_t level)
+{
+ size_t i;
+
+ for (i = 0; i < level; i++) {
+ fputs("| ", stderr);
+ }
+}
+
+static int
+gcompile(struct grep_data *g, const char *astr)
+{
+ regex_t *preg = mh_xcalloc(1, sizeof(regex_t));
+ char *buf;
+ int ret;
+
+ g->preg = preg;
+ g->pattern = mh_xstrdup(astr);
+ ret = regcomp(preg, astr, REG_ICASE | REG_NOSUB);
+ if (ret != 0) {
+ buf = mh_xcalloc(BUFSIZ, sizeof(char));
+ regerror(ret, g->preg, buf, BUFSIZ*sizeof(char));
+ fprintf(stderr, "%s\n", buf);
+ return FALSE;
+ }
+ return TRUE;
+
+}
+
+static int
+tcompile(char *ap, struct tws *tb, int isafter)
+{
+ struct tws *tw;
+
+ if ((tw = tws_parse(ap, isafter)) == NULL)
+ return 0;
+
+ twscopy(tb, tw);
+ return 1;
+}
+
+
+static struct tws *
+tws_parse(char *ap, int isafter)
+{
+ char buffer[BUFSIZ];
+ struct tws *tw, *ts;
+
+ if ((tw = tws_special(ap)) != NULL) {
+ tw->tw_sec = tw->tw_min = isafter ? 59 : 0;
+ tw->tw_hour = isafter ? 23 : 0;
+ return tw;
+ }
+ if ((tw = dparsetime(ap)) != NULL)
+ return tw;
+
+ if ((ts = dlocaltimenow()) == NULL)
+ return NULL;
+
+ snprintf(buffer, sizeof(buffer), "%s %s", ap, dtwszone(ts));
+ if ((tw = dparsetime(buffer)) != NULL)
+ return tw;
+
+ snprintf(buffer, sizeof(buffer), "%s %02d:%02d:%02d %s", ap,
+ ts->tw_hour, ts->tw_min, ts->tw_sec, dtwszone(ts));
+ if ((tw = dparsetime(buffer)) != NULL)
+ return tw;
+
+ snprintf(buffer, sizeof(buffer), "%02d %s %04d %s",
+ ts->tw_mday, tw_moty[ts->tw_mon], ts->tw_year, ap);
+ if ((tw = dparsetime(buffer)) != NULL)
+ return tw;
+
+ snprintf(buffer, sizeof(buffer), "%02d %s %04d %s %s",
+ ts->tw_mday, tw_moty[ts->tw_mon], ts->tw_year,
+ ap, dtwszone(ts));
+ if ((tw = dparsetime(buffer)) != NULL)
+ return tw;
+
+ return NULL;
+}
+
+
+static struct tws *
+tws_special(char *ap)
+{
+ int i;
+ time_t clock;
+ struct tws *tw;
+
+ time(&clock);
+ if (!mh_strcasecmp(ap, "today"))
+ return dlocaltime(&clock);
+ if (!mh_strcasecmp(ap, "yesterday")) {
+ clock -= (long) (60 * 60 * 24);
+ return dlocaltime(&clock);
+ }
+ if (!mh_strcasecmp(ap, "tomorrow")) {
+ clock += (long) (60 * 60 * 24);
+ return dlocaltime(&clock);
+ }
+
+ for (i = 0; tw_ldotw[i]; i++)
+ if (!mh_strcasecmp(ap, tw_ldotw[i]))
+ break;
+ if (tw_ldotw[i]) {
+ if ((tw = dlocaltime(&clock)) == NULL)
+ return NULL;
+ if ((i -= tw->tw_wday) > 0)
+ i -= 7;
+ }
+ else
+ if (*ap != '-')
+ return NULL;
+ else /* -ddd days ago */
+ i = atoi(ap); /* we should error check this */
+
+ clock += (long) ((60 * 60 * 24) * i);
+ return dlocaltime(&clock);
+}
+
+
+static struct nexus *
+createpickthread(char *msgs)
+{
+ char *folder = NULL;
+ struct msgs_array msgarray = {0};
+ struct msgs_array files = {0};
+ struct nexus *ret = NULL;
+ struct nexus *c;
+ struct nexus *or;
+ struct bin_data *bd;
+ char *buf;
+ char **cp = brkstring(msgs, " \t", NULL);
+ int i;
+
+ for (; cp && *cp; cp++) {
+ switch (**cp) {
+ case '@':
+ case '+':
+ if (folder) {
+ advise("","");
+ break;
+ }
+ folder = mh_xstrdup(*cp);
+ break;
+ default:
+ app_msgarg(&msgarray, mh_xstrdup(*cp));
+ }
+ }
+
+ parse_msgs(&msgarray, folder, &files);
+
+ for (i = 0; i < files.size; i++) {
+ buf = getthreadid(files.msgs[i]);
+ if (!buf) {
+ adios(EX_DATAERR, NULL, "message %s is not part of a thread", basename(files.msgs[i]));
+ continue;
+ }
+
+ c = createonethread(buf);
+
+ if (!ret) {
+ ret = c;
+ continue;
+ }
+
+
+ or = newnexus(or_t);
+ bd = &or->data.b;
+ bd->right = ret;
+ bd->left = c;
+ ret = or;
+ }
+
+ mh_free0(&(files.msgs));
+ mh_free0(&(msgarray.msgs));
+
+ return ret;
+}
+
+static struct nexus *
+createonethread(char *c)
+{
+ struct nexus *ret = newnexus(or_t);
+ struct nexus *left = newnexus(grep_t);
+ struct nexus *right = newnexus(grep_t);
+ char buf[BUFSIZ];
+
+ ret->data.b.left = left;
+ ret->data.b.right = right;
+ left->data.g.header = mh_xstrdup("message-id");
+
+
+ snprintf(buf, sizeof(buf), "^[ \t]*<%s>", c);
+ if(!gcompile(&left->data.g, buf)) {
+ padvise(NULL, "pattern error %s", c);
+ goto error;
+ }
+
+ right->data.g.header = mh_xstrdup("references");
+
+ snprintf(buf, sizeof(buf), "^[ \t]*<%s>", c);
+ if(!gcompile(&right->data.g, buf)) {
+ padvise(NULL, "pattern error in %s", c);
+ goto error;
+ }
+
+ return ret;
+
+error:
+ nexus_free(&ret);
+ return NULL;
+