Improve msgset interface. Use it in MH.

* libmailutils/msgset/Makefile.am (libmsgset_la_SOURCES): Add new files.
* libmailutils/msgset/addset.c: New file.
* libmailutils/msgset/count.c: New file.
* libmailutils/msgset/foreachmsgno.c: New file.
* libmailutils/msgset/foreachuid.c: New file.
* libmailutils/msgset/isempty.c: New file.
* libmailutils/msgset/subset.c: New file.
* libmailutils/msgset/trans.c: New file.
* libmailutils/msgset/add.c (mu_msgset_add_range): Take fourth argument
specifying the conversion mode. Translate numbers as necessary.
* libmailutils/msgset/foreachmsg.c: Translate numbers as necessary.
* libmailutils/msgset/foreachnum.c: Rewrite.
* libmailutils/msgset/negate.c (_invert_range)
(mu_msgset_add_range): Update calls to mu_msgset_add_range.
* libmailutils/msgset/parse.c (parse_msgnum_env)<mode>: New member.
(parse_msgrange): Update calls to mu_msgset_add_range.
(mu_msgset_parse_imap): Change signature. All callers updated.
* libmailutils/msgset/sub.c (mu_msgset_sub_range): Take fourth argument
specifying the conversion mode. Translate numbers as necessary.

* imap4d/copy.c (imap4d_copy0): Update calls to mu_msgset_create
and mu_msgset_parse_imap.
* imap4d/fetch.c (fetch_thunk): Likewise.
* imap4d/search.c (parse_simple_key): Likewise.
* imap4d/store.c (store_thunk): Likewise.
* include/mailutils/msgset.h (MU_MSGSET_NUM,MU_MSGSET_UID): New defines.
(mu_msgset_add,mu_msgset_sub): New protos.
(mu_msgset_add_range,mu_msgset_sub_range): Take 4 arguments. All callers
changed.
* include/mailutils/sys/msgset.h (_mu_msgset_translate_pair)
(_mu_msgset_translate_range): New protos.

* libmailutils/tests/msgset.c: Reflect the above changes.
* testsuite/msgset.c: Likewise.
* libproto/imap/mbox.c: Update calls to mu_msgset functions.

* mh/mh.h (mh_msgset_t): Remove.
(mh_iterator_fp): Remove typedef.
(mh_msgset_parse): Change signature.
(mh_msgset_member,mh_msgset_reverse,mh_msgset_negate)
(mh_msgset_current,mh_msgset_free,mh_msgset_uids): Remove protos.
(mh_msgset_parse_string): New proto.
(mh_msgset_first_current,mh_msgset_first): New proto.
(mh_iterate: Remove proto. Use mu_msgset_foreach* functions instead.
(mh_seq_add,mh_seq_delete): Change signatures.
* mh/mh_init.c (mh_iterate): Remove.
* mh/mh_msgset.c: Rewrite using mu_msgset_t.
* mh/mh_sequence.c: Likewise.

* mh/anno.c: Use new msgset functions.
* mh/burst.c: Likewise.
* mh/comp.c: Likewise.
* mh/folder.c: Likewise.
* mh/forw.c: Likewise.
* mh/mark.c: Likewise.
* mh/mhn.c: Likewise.
* mh/mhpath.c: Likewise.
* mh/mhseq.c: Likewise.
* mh/pick.c: Likewise.
* mh/refile.c: Likewise.
* mh/repl.c: Likewise.
* mh/rmm.c: Likewise.
* mh/scan.c: Likewise.
* mh/send.c: Likewise.
* mh/sortm.c: Likewise.
* mh/whatnowenv.c: Likewise.
* mh/tests/mark.at: Reflect changes in the format of the saved
sequences, which may contain ranges now.

* mu/imap.c: Update calls to mu_msgset functions.

@@ -211,7 +211,7 @@ imap4d_copy0 (imap4d_tokbuf_t tok, int isuid, char **err_text)
   mu_mailbox_t cmbox = NULL;
   mu_mailbox_t cmbox = NULL;
   int arg = IMAP4_ARG_1 + !!isuid;
   int arg = IMAP4_ARG_1 + !!isuid;
   int ns;
   int ns;
-
+  
   *err_text = NULL;
   *err_text = NULL;
   if (imap4d_tokbuf_argc (tok) != arg + 2)
   if (imap4d_tokbuf_argc (tok) != arg + 2)
     {
     {
@@ -221,14 +221,16 @@ imap4d_copy0 (imap4d_tokbuf_t tok, int isuid, char **err_text)
   
   
   msgset_str = imap4d_tokbuf_getarg (tok, arg);
   msgset_str = imap4d_tokbuf_getarg (tok, arg);
   name = imap4d_tokbuf_getarg (tok, arg + 1);
   name = imap4d_tokbuf_getarg (tok, arg + 1);
-  status = mu_msgset_create (&msgset, mbox, isuid ? MU_MSGSET_UID : 0);
+  status = mu_msgset_create (&msgset, mbox, MU_MSGSET_NUM);
   if (!status)
   if (!status)
     {
     {
       *err_text = "Software error";
       *err_text = "Software error";
       return RESP_BAD;
       return RESP_BAD;
     }
     }
     
     
-  status = mu_msgset_parse_imap (msgset, msgset_str, &end);
+  status = mu_msgset_parse_imap (msgset,
+				 isuid ? MU_MSGSET_UID : MU_MSGSET_NUM,
+				 msgset_str, &end);
   if (status)
   if (status)
     {
     {
       mu_msgset_free (msgset);
       mu_msgset_free (msgset);

@@ -1759,13 +1759,14 @@ fetch_thunk (imap4d_parsebuf_t pb)
   
   
   mstr = imap4d_parsebuf_next (pb, 1);
   mstr = imap4d_parsebuf_next (pb, 1);
 
 
-  status = mu_msgset_create (&pclos->msgset, mbox,
-			     pclos->isuid ? MU_MSGSET_UID : 0);
+  status = mu_msgset_create (&pclos->msgset, mbox, MU_MSGSET_NUM);
   if (status)
   if (status)
     imap4d_parsebuf_exit (pb, "Software error");
     imap4d_parsebuf_exit (pb, "Software error");
   
   
   /* Parse sequence numbers. */
   /* Parse sequence numbers. */
-  status = mu_msgset_parse_imap (pclos->msgset, mstr, &end);
+  status = mu_msgset_parse_imap (pclos->msgset,
+				 pclos->isuid ? MU_MSGSET_UID : MU_MSGSET_NUM,
+				 mstr, &end);
   if (status)
   if (status)
     imap4d_parsebuf_exit (pb, "Failed to parse message set");
     imap4d_parsebuf_exit (pb, "Failed to parse message set");
   
   

@@ -608,10 +608,11 @@ parse_simple_key (struct parsebuf *pb)
   
   
   if (!condp->name)
   if (!condp->name)
     {
     {
-      mu_msgset_t msgset = parse_msgset_create (pb, mbox,
-						pb->isuid ? MU_MSGSET_UID : 0);
+      mu_msgset_t msgset = parse_msgset_create (pb, mbox, MU_MSGSET_NUM);
       
       
-      if (mu_msgset_parse_imap (msgset, pb->token, NULL) == 0) 
+      if (mu_msgset_parse_imap (msgset,
+				pb->isuid ? MU_MSGSET_UID : MU_MSGSET_NUM,
+				pb->token, NULL) == 0) 
 	{
 	{
 	  struct search_node *np = parse_alloc (pb, sizeof *np);
 	  struct search_node *np = parse_alloc (pb, sizeof *np);
 	  np->type = node_value;
 	  np->type = node_value;
@@ -696,9 +697,10 @@ parse_simple_key (struct parsebuf *pb)
 	      break;
 	      break;
 	      
 	      
 	    case 'u': /* UID message set */
 	    case 'u': /* UID message set */
-	      arg->v.value.v.msgset = parse_msgset_create (pb, NULL, 0);
-	      if (mu_msgset_parse_imap (arg->v.value.v.msgset, pb->token,
-					NULL)) 
+	      arg->v.value.v.msgset = parse_msgset_create (pb, NULL,
+							   MU_MSGSET_NUM);
+	      if (mu_msgset_parse_imap (arg->v.value.v.msgset, MU_MSGSET_UID,
+					pb->token, NULL)) 
 		{
 		{
 		  mu_msgset_free (arg->v.value.v.msgset);
 		  mu_msgset_free (arg->v.value.v.msgset);
 		  pb->err_mesg = "Bogus number set";
 		  pb->err_mesg = "Bogus number set";

@@ -69,13 +69,14 @@ store_thunk (imap4d_parsebuf_t p)
 	imap4d_parsebuf_exit (p, "Bogus data suffix");
 	imap4d_parsebuf_exit (p, "Bogus data suffix");
     }
     }
 
 
-  status = mu_msgset_create (&pclos->msgset, mbox,
-			     pclos->isuid ? MU_MSGSET_UID : 0);
+  status = mu_msgset_create (&pclos->msgset, mbox, MU_MSGSET_NUM);
   if (status)
   if (status)
     imap4d_parsebuf_exit (p, "Software error");
     imap4d_parsebuf_exit (p, "Software error");
   
   
   /* Get the message numbers in set[].  */
   /* Get the message numbers in set[].  */
-  status = mu_msgset_parse_imap (pclos->msgset, mstr, &end);
+  status = mu_msgset_parse_imap (pclos->msgset,
+				 pclos->isuid ? MU_MSGSET_UID : MU_MSGSET_NUM,
+				 mstr, &end);
   if (status)
   if (status)
     imap4d_parsebuf_exit (p, "Failed to parse message set");
     imap4d_parsebuf_exit (p, "Failed to parse message set");
 
 

@@ -18,6 +18,8 @@
 #ifndef _MAILUTILS_MSGSET_H
 #ifndef _MAILUTILS_MSGSET_H
 #define _MAILUTILS_MSGSET_H
 #define _MAILUTILS_MSGSET_H
 
 
+# include <mailutils/types.h>
+  
 #ifdef __cplusplus
 #ifdef __cplusplus
 extern "C" {
 extern "C" {
 #endif
 #endif
@@ -31,23 +33,26 @@ struct mu_msgrange
 /* Message numbers start with 1.  MU_MSGNO_LAST denotes the last
 /* Message numbers start with 1.  MU_MSGNO_LAST denotes the last
    message. */
    message. */
 #define MU_MSGNO_LAST   0
 #define MU_MSGNO_LAST   0
-  
-#define MU_MSGSET_UID   0x01   /* Message set operates on UIDs */
 
 
-int mu_msgset_create (mu_msgset_t *pmsgset, mu_mailbox_t mbox, int flags);
+#define MU_MSGSET_NUM   0      /* Message set operates on sequence numbers */   
+#define MU_MSGSET_UID   1      /* Message set operates on UIDs */
+
+#define MU_MSGSET_MODE_MASK 0x0f
+  
+int mu_msgset_create (mu_msgset_t *pmsgset, mu_mailbox_t mbox, int mode);
 int mu_msgset_get_list (mu_msgset_t msgset, mu_list_t *plist);
 int mu_msgset_get_list (mu_msgset_t msgset, mu_list_t *plist);
 int mu_msgset_get_iterator (mu_msgset_t msgset, mu_iterator_t *pitr);
 int mu_msgset_get_iterator (mu_msgset_t msgset, mu_iterator_t *pitr);
 
 
-int mu_msgset_add_range (mu_msgset_t list, size_t beg, size_t end);
-int mu_msgset_sub_range (mu_msgset_t list, size_t beg, size_t end);
-  /*int mu_msgset_add_set (mu_msgset_t a, mu_msgset_t b);*/
-  /*int mu_msgset_sub_set (mu_msgset_t a, mu_msgset_t b);*/
+int mu_msgset_add_range (mu_msgset_t set, size_t beg, size_t end, int mode);
+int mu_msgset_sub_range (mu_msgset_t set, size_t beg, size_t end, int mode);
+int mu_msgset_add (mu_msgset_t a, mu_msgset_t b);
+int mu_msgset_sub (mu_msgset_t a, mu_msgset_t b);
 int mu_msgset_aggregate (mu_msgset_t set);
 int mu_msgset_aggregate (mu_msgset_t set);
 int mu_msgset_clear (mu_msgset_t set);
 int mu_msgset_clear (mu_msgset_t set);
 void mu_msgset_free (mu_msgset_t set);
 void mu_msgset_free (mu_msgset_t set);
 void mu_msgset_destroy (mu_msgset_t *set);
 void mu_msgset_destroy (mu_msgset_t *set);
   
   
-int mu_msgset_parse_imap (mu_msgset_t set, const char *s, char **end);
+int mu_msgset_parse_imap (mu_msgset_t set, int mode, const char *s, char **end);
 
 
 int mu_msgset_print (mu_stream_t str, mu_msgset_t msgset);
 int mu_msgset_print (mu_stream_t str, mu_msgset_t msgset);
   
   
@@ -55,17 +60,34 @@ int mu_msgset_locate (mu_msgset_t msgset, size_t n,
 		      struct mu_msgrange const **prange);
 		      struct mu_msgrange const **prange);
 
 
 int mu_msgset_negate (mu_msgset_t msgset, mu_msgset_t *pnset);
 int mu_msgset_negate (mu_msgset_t msgset, mu_msgset_t *pnset);
+
+int mu_msgset_count (mu_msgset_t mset, size_t *pcount);
+int mu_msgset_is_empty (mu_msgset_t mset);
   
   
 typedef int (*mu_msgset_msgno_action_t) (size_t _n, void *_call_data);
 typedef int (*mu_msgset_msgno_action_t) (size_t _n, void *_call_data);
 typedef int (*mu_msgset_message_action_t) (size_t _n, mu_message_t _msg,
 typedef int (*mu_msgset_message_action_t) (size_t _n, mu_message_t _msg,
 					   void *_call_data);
 					   void *_call_data);
 
 
+#define MU_MSGSET_FOREACH_FORWARD  0x00
+#define MU_MSGSET_FOREACH_BACKWARD 0x10
+
+int mu_msgset_foreach_num (mu_msgset_t _msgset, int _flags,
+			   mu_msgset_msgno_action_t _action,
+			   void *_call_data);
+  
 int mu_msgset_foreach_dir_msgno (mu_msgset_t _msgset, int _dir,
 int mu_msgset_foreach_dir_msgno (mu_msgset_t _msgset, int _dir,
 				 mu_msgset_msgno_action_t _action,
 				 mu_msgset_msgno_action_t _action,
 				 void *_data);
 				 void *_data);
 int mu_msgset_foreach_msgno (mu_msgset_t _msgset,
 int mu_msgset_foreach_msgno (mu_msgset_t _msgset,
 			     mu_msgset_msgno_action_t _action,
 			     mu_msgset_msgno_action_t _action,
 			     void *_call_data);
 			     void *_call_data);
+int mu_msgset_foreach_dir_msguid (mu_msgset_t _msgset, int _dir,
+				  mu_msgset_msgno_action_t _action,
+				  void *_data);
+int mu_msgset_foreach_msguid (mu_msgset_t _msgset,
+			      mu_msgset_msgno_action_t _action,
+			      void *_data);
+  
 int mu_msgset_foreach_dir_message (mu_msgset_t _msgset, int _dir,
 int mu_msgset_foreach_dir_message (mu_msgset_t _msgset, int _dir,
 				   mu_msgset_message_action_t _action,
 				   mu_msgset_message_action_t _action,
 				   void *_call_data);
 				   void *_call_data);

@@ -28,4 +28,9 @@ struct _mu_msgset
   int flags;                /* Message set flags */
   int flags;                /* Message set flags */
 };
 };
 
 
+int _mu_msgset_translate_pair (mu_msgset_t mset, int mode,
+			       size_t *beg, size_t *end);
+int _mu_msgset_translate_range (mu_msgset_t mset, int mode,
+				struct mu_msgrange *r);
+
 #endif
 #endif

@@ -19,19 +19,26 @@ noinst_LTLIBRARIES = libmsgset.la
 
 
 libmsgset_la_SOURCES = \
 libmsgset_la_SOURCES = \
  add.c\
  add.c\
+ addset.c\
  aggr.c\
  aggr.c\
  clear.c\
  clear.c\
  create.c\
  create.c\
+ count.c\
  getitr.c\
  getitr.c\
  getlist.c\
  getlist.c\
  foreachnum.c\
  foreachnum.c\
+ foreachmsgno.c\
+ foreachuid.c\
  foreachmsg.c\
  foreachmsg.c\
  free.c\
  free.c\
+ isempty.c\
  locate.c\
  locate.c\
  negate.c\
  negate.c\
  parse.c\
  parse.c\
  print.c\
  print.c\
- sub.c
+ sub.c\
+ subset.c\
+ trans.c
 
 
 INCLUDES = @MU_LIB_COMMON_INCLUDES@ -I/libmailutils
 INCLUDES = @MU_LIB_COMMON_INCLUDES@ -I/libmailutils
 
 

@@ -23,18 +23,30 @@
 #include <mailutils/sys/msgset.h>
 #include <mailutils/sys/msgset.h>
 
 
 int
 int
-mu_msgset_add_range (mu_msgset_t mset, size_t beg, size_t end)
+mu_msgset_add_range (mu_msgset_t mset, size_t beg, size_t end, int mode)
 {
 {
   int rc;
   int rc;
   struct mu_msgrange *range;
   struct mu_msgrange *range;
   
   
   if (!mset || beg == 0)
   if (!mset || beg == 0)
     return EINVAL;
     return EINVAL;
+  if (end && beg > end)
+    {
+      size_t t = end;
+      end = beg;
+      beg = t;
+    }
   range = calloc (1, sizeof (*range));
   range = calloc (1, sizeof (*range));
   if (!range)
   if (!range)
     return ENOMEM;
     return ENOMEM;
   range->msg_beg = beg;
   range->msg_beg = beg;
   range->msg_end = end;
   range->msg_end = end;
+  rc = _mu_msgset_translate_range (mset, mode, range);
+  if (rc)
+    {
+      free (range);
+      return rc;
+    }
   rc = mu_list_append (mset->list, range);
   rc = mu_list_append (mset->list, range);
   if (rc)
   if (rc)
     free (range);
     free (range);

+/* GNU Mailutils -- a suite of utilities for electronic mail
+   Copyright (C) 2011 Free Software Foundation, Inc.
+
+   GNU Mailutils is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3, or (at your option)
+   any later version.
+
+   GNU Mailutils is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GNU Mailutils.  If not, see <http://www.gnu.org/licenses/>. */
+
+#include <config.h>
+#include <stdlib.h>
+#include <mailutils/types.h>
+#include <mailutils/errno.h>
+#include <mailutils/list.h>
+#include <mailutils/msgset.h>
+#include <mailutils/sys/msgset.h>
+
+struct add_closure
+{
+  int mode;
+  mu_msgset_t dest;
+};
+
+static int
+add_range (void *item, void *data)
+{
+  struct mu_msgrange *r = item;
+  struct add_closure *clos = data;
+  return mu_msgset_add_range (clos->dest, r->msg_beg, r->msg_end, clos->mode);
+}
+
+int
+mu_msgset_add (mu_msgset_t a, mu_msgset_t b)
+{
+  struct add_closure closure;
+  if (!a)
+    return EINVAL;
+  if (!b)
+    return 0;
+  closure.mode = b->flags;
+  closure.dest = a;
+  return mu_list_foreach (b->list, add_range, &closure);
+}

+/* GNU Mailutils -- a suite of utilities for electronic mail
+   Copyright (C) 2011 Free Software Foundation, Inc.
+
+   GNU Mailutils is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3, or (at your option)
+   any later version.
+
+   GNU Mailutils is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GNU Mailutils.  If not, see <http://www.gnu.org/licenses/>. */
+
+#include <config.h>
+#include <stdlib.h>
+#include <mailutils/types.h>
+#include <mailutils/errno.h>
+#include <mailutils/list.h>
+#include <mailutils/msgset.h>
+#include <mailutils/sys/msgset.h>
+
+static int
+count_messages (void *item, void *data)
+{
+  struct mu_msgrange *r = item;
+  size_t *count = data;
+  *count += r->msg_end - r->msg_beg + 1;
+  return 0;
+}
+  
+int
+mu_msgset_count (mu_msgset_t mset, size_t *pcount)
+{
+  int rc;
+  size_t count = 0;
+
+  if (!mset)
+    return EINVAL;
+  if (!pcount)
+    return MU_ERR_OUT_PTR_NULL;
+  rc = mu_list_foreach (mset->list, count_messages, &count);
+  if (rc == 0)
+    *pcount = count;
+  return rc;
+}

@@ -32,49 +32,47 @@ struct action_closure
 };
 };
 
 
 static int
 static int
+call_action (struct action_closure *clos, size_t i)
+{
+  int rc;
+  mu_message_t msg = NULL;
+  size_t n;
+
+  if (clos->msgset->flags == MU_MSGSET_UID)
+    {
+      rc = mu_mailbox_translate (clos->msgset->mbox, MU_MAILBOX_UID_TO_MSGNO,
+				 i, &n);
+      if (rc == MU_ERR_NOENT)
+	return 0;
+      else if (rc)
+	return rc;
+    }
+  else
+    n = i;
+  
+  rc = mu_mailbox_get_message (clos->msgset->mbox, n, &msg);
+  if (rc == MU_ERR_NOENT)
+    return 0;
+  else if (rc == 0)
+    rc = clos->action (i, msg, clos->data);
+  return rc;
+}
+
+static int
 procrange (void *item, void *data)
 procrange (void *item, void *data)
 {
 {
   struct mu_msgrange *mp = item;
   struct mu_msgrange *mp = item;
   struct action_closure *clos = data;
   struct action_closure *clos = data;
   size_t i;
   size_t i;
-
+  int rc = 0;
+  
   if (clos->dir)
   if (clos->dir)
-    for (i = mp->msg_end; i >= mp->msg_beg; i--)
-      {
-	int rc;
-	mu_message_t msg = NULL;
-	
-	if (clos->msgset->mbox)
-	  {
-	    rc = mu_mailbox_get_message (clos->msgset->mbox, i, &msg);
-	    if (rc == MU_ERR_NOENT)
-	      continue;
-	    else if (rc)
-	    return rc;
-	  }
-	rc = clos->action (i, msg, clos->data);
-	if (rc)
-	  return rc;
-      }
+    for (i = mp->msg_end; rc == 0 && i >= mp->msg_beg; i--)
+      rc = call_action (clos, i);
   else
   else
     for (i = mp->msg_beg; i <= mp->msg_end; i++)
     for (i = mp->msg_beg; i <= mp->msg_end; i++)
-      {
-	int rc;
-	mu_message_t msg = NULL;
-	
-	if (clos->msgset->mbox)
-	  {
-	    rc = mu_mailbox_get_message (clos->msgset->mbox, i, &msg);
-	    if (rc == MU_ERR_NOENT)
-	      continue;
-	    else if (rc)
-	      return rc;
-	  }
-	rc = clos->action (i, msg, clos->data);
-	if (rc)
-	  return rc;
-      }
-  return 0;
+      rc = call_action (clos, i);
+  return rc;
 }
 }
 
 
 /* Apply ACTION to each message number from MSGSET. */
 /* Apply ACTION to each message number from MSGSET. */
@@ -85,7 +83,9 @@ mu_msgset_foreach_dir_message (mu_msgset_t msgset, int dir,
 {
 {
   int rc;
   int rc;
   struct action_closure clos;
   struct action_closure clos;
-  
+
+  if (!msgset->mbox)
+    return MU_ERR_NOT_OPEN;
   rc = mu_msgset_aggregate (msgset);
   rc = mu_msgset_aggregate (msgset);
   if (rc)
   if (rc)
     return rc;
     return rc;

+/* GNU Mailutils -- a suite of utilities for electronic mail
+   Copyright (C) 2011 Free Software Foundation, Inc.
+
+   GNU Mailutils is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3, or (at your option)
+   any later version.
+
+   GNU Mailutils is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GNU Mailutils.  If not, see <http://www.gnu.org/licenses/>. */
+
+#include <config.h>
+#include <mailutils/msgset.h>
+
+/* Apply ACTION to each message number from MSGSET. */
+int
+mu_msgset_foreach_dir_msgno (mu_msgset_t msgset, int dir,
+			     mu_msgset_msgno_action_t action,
+			     void *data)
+{
+  return mu_msgset_foreach_num (msgset,
+	       (dir ? MU_MSGSET_FOREACH_BACKWARD : MU_MSGSET_FOREACH_FORWARD)|
+	       MU_MSGSET_NUM,
+	       action, data);
+}
+
+int
+mu_msgset_foreach_msgno (mu_msgset_t msgset,
+			 mu_msgset_msgno_action_t action,
+			 void *data)
+{
+  return mu_msgset_foreach_dir_msgno (msgset, 0, action, data);
+}

@@ -20,6 +20,7 @@
 #include <mailutils/errno.h>
 #include <mailutils/errno.h>
 #include <mailutils/list.h>
 #include <mailutils/list.h>
 #include <mailutils/msgset.h>
 #include <mailutils/msgset.h>
+#include <mailutils/mailbox.h>
 #include <mailutils/sys/msgset.h>
 #include <mailutils/sys/msgset.h>
 
 
 struct action_closure
 struct action_closure
@@ -27,38 +28,67 @@ struct action_closure
   mu_msgset_msgno_action_t action;
   mu_msgset_msgno_action_t action;
   void *data;
   void *data;
   mu_msgset_t msgset;
   mu_msgset_t msgset;
-  int dir;
+  int flags;
 };
 };
 
 
 static int
 static int
+call_action (struct action_closure *clos, size_t i)
+{
+  size_t n;
+  int cmd;
+  
+  if (clos->msgset->flags != (clos->flags & MU_MSGSET_MODE_MASK))
+    {
+      int rc;
+
+      switch (clos->flags & MU_MSGSET_MODE_MASK)
+	{
+	case MU_MSGSET_NUM:
+	  cmd = MU_MAILBOX_UID_TO_MSGNO;
+	  break;
+	  
+	case MU_MSGSET_UID:
+	  cmd = MU_MAILBOX_MSGNO_TO_UID;
+	  break;
+	  
+	default:
+	  return EINVAL;
+	}
+      
+      rc = mu_mailbox_translate (clos->msgset->mbox, cmd, i, &n);
+      if (rc == MU_ERR_NOENT)
+	return 0;
+      if (rc)
+	return rc;
+    }
+  else
+    n = i;
+  return clos->action (n, clos->data);
+}
+    
+
+static int
 procrange (void *item, void *data)
 procrange (void *item, void *data)
 {
 {
   struct mu_msgrange *mp = item;
   struct mu_msgrange *mp = item;
   struct action_closure *clos = data;
   struct action_closure *clos = data;
   size_t i;
   size_t i;
-
-  if (clos->dir)
-    for (i = mp->msg_end; i >= mp->msg_beg; i--)
-      {
-	int rc = clos->action (i, clos->data);
-	if (rc)
-	  return rc;
-      }
+  int rc = 0;
+  
+  if (clos->flags & MU_MSGSET_FOREACH_BACKWARD)
+    for (i = mp->msg_end; rc == 0 && i >= mp->msg_beg; i--)
+      rc = call_action (clos, i);
   else
   else
-    for (i = mp->msg_beg; i <= mp->msg_end; i++)
-      {
-	int rc = clos->action (i, clos->data);
-	if (rc)
-	  return rc;
-      }
-  return 0;
+    for (i = mp->msg_beg; rc == 0 && i <= mp->msg_end; i++)
+      rc = call_action (clos, i);
+  return rc;
 }
 }
 
 
-/* Apply ACTION to each message number from MSGSET. */
+/* Apply ACTION to each message number or UID from MSGSET. */
 int
 int
-mu_msgset_foreach_dir_msgno (mu_msgset_t msgset, int dir,
-			     mu_msgset_msgno_action_t action,
-			     void *data)
+mu_msgset_foreach_num (mu_msgset_t msgset, int flags,
+		       mu_msgset_msgno_action_t action,
+		       void *data)
 {
 {
   int rc;
   int rc;
   struct action_closure clos;
   struct action_closure clos;
@@ -68,14 +98,9 @@ mu_msgset_foreach_dir_msgno (mu_msgset_t msgset, int dir,
     return rc;
     return rc;
   clos.action = action;
   clos.action = action;
   clos.data = data;
   clos.data = data;
-  clos.dir = dir;
-  return mu_list_foreach_dir (msgset->list, dir, procrange, &clos);
-}
-
-int
-mu_msgset_foreach_msgno (mu_msgset_t msgset,
-			 mu_msgset_msgno_action_t action,
-			 void *data)
-{
-  return mu_msgset_foreach_dir_msgno (msgset, 0, action, data);
+  clos.flags = flags;
+  clos.msgset = msgset;
+  return mu_list_foreach_dir (msgset->list,
+			      !!(flags & MU_MSGSET_FOREACH_BACKWARD),
+			      procrange, &clos);
 }
 }

+/* GNU Mailutils -- a suite of utilities for electronic mail
+   Copyright (C) 2011 Free Software Foundation, Inc.
+
+   GNU Mailutils is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3, or (at your option)
+   any later version.
+
+   GNU Mailutils is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GNU Mailutils.  If not, see <http://www.gnu.org/licenses/>. */
+
+#include <config.h>
+#include <mailutils/msgset.h>
+
+/* Apply ACTION to each message number from MSGSET. */
+int
+mu_msgset_foreach_dir_msguid (mu_msgset_t msgset, int dir,
+			      mu_msgset_msgno_action_t action,
+			      void *data)
+{
+  return mu_msgset_foreach_num (msgset,
+	    (dir ? MU_MSGSET_FOREACH_BACKWARD : MU_MSGSET_FOREACH_FORWARD) |
+	    MU_MSGSET_UID, action, data);
+}
+
+int
+mu_msgset_foreach_msguid (mu_msgset_t msgset,
+			  mu_msgset_msgno_action_t action,
+			  void *data)
+{
+  return mu_msgset_foreach_dir_msguid (msgset, 0, action, data);
+}

+/* GNU Mailutils -- a suite of utilities for electronic mail
+   Copyright (C) 2011 Free Software Foundation, Inc.
+
+   GNU Mailutils is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3, or (at your option)
+   any later version.
+
+   GNU Mailutils is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GNU Mailutils.  If not, see <http://www.gnu.org/licenses/>. */
+
+#include <config.h>
+#include <stdlib.h>
+#include <mailutils/types.h>
+#include <mailutils/list.h>
+#include <mailutils/msgset.h>
+#include <mailutils/sys/msgset.h>
+
+int
+mu_msgset_is_empty (mu_msgset_t mset)
+{
+  return mset == NULL || mu_list_is_empty (mset->list);
+}

@@ -38,7 +38,9 @@ _invert_range (void *item, void *data)
   
   
   if (clos->next_num < range->msg_beg - 1)
   if (clos->next_num < range->msg_beg - 1)
     {
     {
-      rc = mu_msgset_add_range (clos->nset, clos->next_num, range->msg_beg - 1);
+      rc = mu_msgset_add_range (clos->nset,
+				clos->next_num, range->msg_beg - 1,
+				clos->nset->flags);
       if (rc)
       if (rc)
 	return rc;
 	return rc;
     }
     }
@@ -66,7 +68,15 @@ mu_msgset_negate (mu_msgset_t msgset, mu_msgset_t *pnset)
   rc = mu_mailbox_messages_count (msgset->mbox, &total);
   rc = mu_mailbox_messages_count (msgset->mbox, &total);
   if (rc)
   if (rc)
     return rc;
     return rc;
-  rc = mu_msgset_create (&clos.nset, NULL, 0);
+  if (msgset->flags == MU_MSGSET_UID)
+    {
+      rc = mu_mailbox_translate (msgset->mbox,
+				 MU_MAILBOX_MSGNO_TO_UID,
+				 total, &total);
+      if (rc)
+	return rc;
+    }
+  rc = mu_msgset_create (&clos.nset, msgset->mbox, msgset->flags);
   if (rc)
   if (rc)
     return rc;
     return rc;
   clos.next_num = 1;
   clos.next_num = 1;
@@ -74,15 +84,14 @@ mu_msgset_negate (mu_msgset_t msgset, mu_msgset_t *pnset)
   if (rc == 0)
   if (rc == 0)
     {
     {
       if (clos.next_num < total)
       if (clos.next_num < total)
-	rc = mu_msgset_add_range (clos.nset, clos.next_num, total);
+	rc = mu_msgset_add_range (clos.nset, clos.next_num, total,
+				  clos.nset->flags);
     }
     }
   
   
   if (rc)
   if (rc)
     mu_msgset_free (clos.nset);
     mu_msgset_free (clos.nset);
   else
   else
-    {
-      clos.nset->mbox = msgset->mbox;
-      *pnset = clos.nset;
-    }
-  return 0;
+    *pnset = clos.nset;
+
+  return rc;
 }
 }

@@ -33,6 +33,7 @@ struct parse_msgnum_env
   size_t minval;         /* Min. sequence number or UID */
   size_t minval;         /* Min. sequence number or UID */
   size_t maxval;         /* Max. sequence number or UID */
   size_t maxval;         /* Max. sequence number or UID */
   mu_msgset_t msgset;    /* Message set being built. */
   mu_msgset_t msgset;    /* Message set being built. */
+  int mode;              /* Operation mode (num/uid) */
 };
 };
 
 
 /* Get a single message number/UID from env->s and store it into *PN.
 /* Get a single message number/UID from env->s and store it into *PN.
@@ -95,20 +96,8 @@ parse_msgrange (struct parse_msgnum_env *env)
       msgrange.msg_beg = tmp;
       msgrange.msg_beg = tmp;
     }
     }
 
 
-  if ((env->msgset->flags & MU_MSGSET_UID) && env->msgset->mbox)
-    {
-      int rc;
-
-      rc = mu_mailbox_translate (env->msgset->mbox,
-				 MU_MAILBOX_UID_TO_MSGNO,
-				 msgrange.msg_end, &msgrange.msg_end);
-      if (rc == MU_ERR_NOENT)
-	msgrange.msg_end = env->maxval;
-      else if (rc)
-	return rc;
-    }      
-
-  return mu_msgset_add_range (env->msgset, msgrange.msg_beg, msgrange.msg_end);
+  return mu_msgset_add_range (env->msgset, msgrange.msg_beg, msgrange.msg_end,
+			      env->mode);
 }
 }
 
 
 /* Parse IMAP-style message set specification S.
 /* Parse IMAP-style message set specification S.
@@ -117,13 +106,15 @@ parse_msgrange (struct parse_msgnum_env *env)
    On error, return error code and point END to the position in the input
    On error, return error code and point END to the position in the input
    string where parsing has failed. */
    string where parsing has failed. */
 int
 int
-mu_msgset_parse_imap (mu_msgset_t mset, const char *s, char **end)
+mu_msgset_parse_imap (mu_msgset_t mset, int mode, const char *s, char **end)
 {
 {
   int rc;
   int rc;
   struct parse_msgnum_env env;
   struct parse_msgnum_env env;
   
   
   if (!s || !mset)
   if (!s || !mset)
     return EINVAL;
     return EINVAL;
+  if (end)
+    *end = (char*) s;
   if (!*s)
   if (!*s)
     return MU_ERR_PARSE;
     return MU_ERR_PARSE;
 
 
@@ -131,9 +122,8 @@ mu_msgset_parse_imap (mu_msgset_t mset, const char *s, char **end)
   env.s = s;
   env.s = s;
   env.msgset = mset;
   env.msgset = mset;
   env.minval = 1;
   env.minval = 1;
+  env.mode = mode;
   
   
-  if (end)
-    *end = (char*) s;
   if (mset->mbox)
   if (mset->mbox)
     {
     {
       size_t lastmsgno;      /* Max. sequence number. */
       size_t lastmsgno;      /* Max. sequence number. */
@@ -141,7 +131,7 @@ mu_msgset_parse_imap (mu_msgset_t mset, const char *s, char **end)
       rc = mu_mailbox_messages_count (mset->mbox, &lastmsgno);
       rc = mu_mailbox_messages_count (mset->mbox, &lastmsgno);
       if (rc == 0)
       if (rc == 0)
 	{
 	{
-	  if (mset->flags & MU_MSGSET_UID)
+	  if (mode == MU_MSGSET_UID)
 	    {
 	    {
 	      rc = mu_mailbox_translate (mset->mbox, MU_MAILBOX_MSGNO_TO_UID,
 	      rc = mu_mailbox_translate (mset->mbox, MU_MAILBOX_MSGNO_TO_UID,
 					 lastmsgno, &env.maxval);
 					 lastmsgno, &env.maxval);

@@ -112,7 +112,7 @@ sub_msgno_last (mu_msgset_t mset, size_t beg)
 }
 }
 
 
 int
 int
-mu_msgset_sub_range (mu_msgset_t mset, size_t beg, size_t end)
+mu_msgset_sub_range (mu_msgset_t mset, size_t beg, size_t end, int mode)
 {
 {
   int rc;
   int rc;
   mu_iterator_t itr;
   mu_iterator_t itr;
@@ -122,6 +122,19 @@ mu_msgset_sub_range (mu_msgset_t mset, size_t beg, size_t end)
     return EINVAL;
     return EINVAL;
   if (mu_list_is_empty (mset->list))
   if (mu_list_is_empty (mset->list))
     return MU_ERR_NOENT;
     return MU_ERR_NOENT;
+  if (end && beg > end)
+    {
+      size_t t = end;
+      end = beg;
+      beg = t;
+    }
+
+  rc = _mu_msgset_translate_pair (mset, mode, &beg, &end);
+  if (rc == MU_ERR_NOENT)
+    return 0;
+  else if (rc)
+    return rc;
+  
   rc = mu_msgset_aggregate (mset);
   rc = mu_msgset_aggregate (mset);
   if (rc)
   if (rc)
     return rc;
     return rc;
@@ -138,8 +151,6 @@ mu_msgset_sub_range (mu_msgset_t mset, size_t beg, size_t end)
   if (beg < mr->msg_beg)
   if (beg < mr->msg_beg)
     beg = mr->msg_beg;
     beg = mr->msg_beg;
   
   
-  if (rc)
-    return rc;
   rc = mu_list_tail (mset->list, (void**) &mr);
   rc = mu_list_tail (mset->list, (void**) &mr);
   if (mr->msg_end != MU_MSGNO_LAST)
   if (mr->msg_end != MU_MSGNO_LAST)
     {
     {
@@ -148,7 +159,7 @@ mu_msgset_sub_range (mu_msgset_t mset, size_t beg, size_t end)
       if (end > mr->msg_end)
       if (end > mr->msg_end)
 	end = mr->msg_end;
 	end = mr->msg_end;
     }
     }
-  
+
   rc = mu_list_get_iterator (mset->list, &itr);
   rc = mu_list_get_iterator (mset->list, &itr);
   if (rc)
   if (rc)
     return rc;
     return rc;

+/* GNU Mailutils -- a suite of utilities for electronic mail
+   Copyright (C) 2011 Free Software Foundation, Inc.
+
+   GNU Mailutils is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3, or (at your option)
+   any later version.
+
+   GNU Mailutils is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GNU Mailutils.  If not, see <http://www.gnu.org/licenses/>. */
+
+#include <config.h>
+#include <stdlib.h>
+#include <mailutils/types.h>
+#include <mailutils/errno.h>
+#include <mailutils/list.h>
+#include <mailutils/msgset.h>
+#include <mailutils/sys/msgset.h>
+
+struct sub_closure
+{
+  int mode;
+  mu_msgset_t dest;
+};
+
+static int
+sub_range (void *item, void *data)
+{
+  struct mu_msgrange *r = item;
+  struct sub_closure *clos = data;
+  return mu_msgset_sub_range (clos->dest, r->msg_beg, r->msg_end, clos->mode);
+}
+
+int
+mu_msgset_sub (mu_msgset_t a, mu_msgset_t b)
+{
+  struct sub_closure closure;
+  if (!a)
+    return EINVAL;
+  if (!b)
+    return 0;
+  closure.mode = b->flags;
+  closure.dest = a;
+  return mu_list_foreach (b->list, sub_range, &closure);
+}

+/* GNU Mailutils -- a suite of utilities for electronic mail
+   Copyright (C) 2011 Free Software Foundation, Inc.
+
+   GNU Mailutils is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3, or (at your option)
+   any later version.
+
+   GNU Mailutils is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GNU Mailutils.  If not, see <http://www.gnu.org/licenses/>. */
+
+#include <config.h>
+#include <stdlib.h>
+#include <mailutils/types.h>
+#include <mailutils/errno.h>
+#include <mailutils/list.h>
+#include <mailutils/msgset.h>
+#include <mailutils/mailbox.h>
+#include <mailutils/sys/msgset.h>
+
+int
+_mu_msgset_translate_pair (mu_msgset_t mset, int mode,
+			   size_t *pbeg, size_t *pend)
+{
+  if (mode != mset->flags && mset->mbox)
+    {
+      int cmd, rc;
+      size_t n;
+      size_t beg = *pbeg;
+      size_t end = *pend;
+      
+      switch (mset->flags)
+	{
+	case MU_MSGSET_NUM:
+	  cmd = MU_MAILBOX_UID_TO_MSGNO;
+	  break;
+
+	case MU_MSGSET_UID:
+	  cmd = MU_MAILBOX_MSGNO_TO_UID;
+	  break;
+
+	default:
+	  return EINVAL;
+	}
+
+      rc = mu_mailbox_translate (mset->mbox, cmd, beg, &n);
+      if (rc)
+	{
+	  if (rc == MU_ERR_NOENT && cmd == MU_MAILBOX_UID_TO_MSGNO)
+	    {
+	      size_t x;
+	      
+	      if (end == MU_MSGNO_LAST)
+		{
+		  rc = mu_mailbox_uidnext (mset->mbox, &x);
+		  if (rc)
+		    return rc;
+		}
+	      else
+		x = end;
+	      for (; rc == MU_ERR_NOENT && beg < x; beg++)
+		rc = mu_mailbox_translate (mset->mbox, cmd, beg, &n);
+	    }
+	  if (rc)
+	    return rc;
+	}
+
+      *pbeg = n;
+      
+      if (beg == end)
+	*pend = n;
+      else if (end != MU_MSGNO_LAST)
+	{
+	  rc = mu_mailbox_translate (mset->mbox, cmd, end, &n);
+	  if (rc == MU_ERR_NOENT && cmd == MU_MAILBOX_UID_TO_MSGNO)
+	    {
+	      for (; rc == MU_ERR_NOENT && beg < end; end--)
+		rc = mu_mailbox_translate (mset->mbox, cmd, end, &n);
+	      
+	    }
+	  if (rc)
+	    return rc;
+	  *pend = n;
+	}
+    }
+  return 0;
+}
+
+int
+_mu_msgset_translate_range (mu_msgset_t mset, int mode, struct mu_msgrange *r)
+{
+  return _mu_msgset_translate_pair (mset, mode, &r->msg_beg, &r->msg_end);
+}
+

@@ -19,7 +19,7 @@
 #include <mailutils/mailutils.h>
 #include <mailutils/mailutils.h>
 
 
 static void
 static void
-parse_msgset (char *arg, struct mu_msgrange *range)
+parse_msgrange (char *arg, struct mu_msgrange *range)
 {
 {
   size_t msgnum;
   size_t msgnum;
   char *p;
   char *p;
@@ -52,13 +52,33 @@ parse_msgset (char *arg, struct mu_msgrange *range)
   range->msg_end = msgnum;
   range->msg_end = msgnum;
 }
 }
 
 
+mu_msgset_t
+parse_msgset (const char *arg)
+{
+  int rc;
+  mu_msgset_t msgset;
+  char *end;
+
+  MU_ASSERT (mu_msgset_create (&msgset, NULL, MU_MSGSET_NUM));
+  if (arg)
+    {
+      rc = mu_msgset_parse_imap (msgset, MU_MSGSET_NUM, arg, &end);
+      if (rc)
+	{
+	  mu_error ("mu_msgset_parse_imap: %s near %s",
+		    mu_strerror (rc), end);
+	  exit (1);
+	}
+    }
+  return msgset;
+}
+
 int
 int
 main (int argc, char **argv)
 main (int argc, char **argv)
 {
 {
   int i;
   int i;
   char *msgset_string = NULL;
   char *msgset_string = NULL;
   mu_msgset_t msgset;
   mu_msgset_t msgset;
-  int rc;
   
   
   mu_set_program_name (argv[0]);
   mu_set_program_name (argv[0]);
   for (i = 1; i < argc; i++)
   for (i = 1; i < argc; i++)
@@ -67,7 +87,8 @@ main (int argc, char **argv)
 
 
       if (strcmp (arg, "-h") == 0 || strcmp (arg, "-help") == 0)
       if (strcmp (arg, "-h") == 0 || strcmp (arg, "-help") == 0)
 	{
 	{
-	  mu_printf ("usage: %s [-msgset=SET] [-add X[:Y]] [-del X:[Y]]...\n",
+	  mu_printf ("usage: %s [-msgset=SET] [-add=X[:Y]] [-del=X[:Y]] "
+		     "[-addset=SET] [-delset=SET] ...\n",
 		     mu_program_name);
 		     mu_program_name);
 	  return 0;
 	  return 0;
 	}
 	}
@@ -77,18 +98,7 @@ main (int argc, char **argv)
 	break;
 	break;
     }
     }
 
 
-  MU_ASSERT (mu_msgset_create (&msgset, NULL, 0));
-  if (msgset_string)
-    {
-      char *end;
-      rc = mu_msgset_parse_imap (msgset, msgset_string, &end);
-      if (rc)
-	{
-	  mu_error ("mu_msgset_parse_imap: %s near %s",
-		    mu_strerror (rc), end);
-	  return 1;
-	}
-    }
+  msgset = parse_msgset (msgset_string);
   
   
   for (; i < argc; i++)
   for (; i < argc; i++)
     {
     {
@@ -97,15 +107,40 @@ main (int argc, char **argv)
       
       
       if (strncmp (arg, "-add=", 5) == 0)
       if (strncmp (arg, "-add=", 5) == 0)
 	{
 	{
-	  parse_msgset (arg + 5, &range);
+	  parse_msgrange (arg + 5, &range);
 	  MU_ASSERT (mu_msgset_add_range (msgset, range.msg_beg,
 	  MU_ASSERT (mu_msgset_add_range (msgset, range.msg_beg,
-					  range.msg_end));
+					  range.msg_end, MU_MSGSET_NUM));
 	}
 	}
       else if (strncmp (arg, "-sub=", 5) == 0)
       else if (strncmp (arg, "-sub=", 5) == 0)
 	{
 	{
-	  parse_msgset (arg + 5, &range);
+	  parse_msgrange (arg + 5, &range);
 	  MU_ASSERT (mu_msgset_sub_range (msgset, range.msg_beg,
 	  MU_ASSERT (mu_msgset_sub_range (msgset, range.msg_beg,
-					  range.msg_end));
+					  range.msg_end, MU_MSGSET_NUM));
+	}
+      else if (strncmp (arg, "-addset=", 8) == 0)
+	{
+	  mu_msgset_t tset = parse_msgset (arg + 8);
+	  if (!msgset)
+	    msgset = tset;
+	  else
+	    {
+	      MU_ASSERT (mu_msgset_add (msgset, tset));
+	      mu_msgset_free (tset);
+	    }
+	}
+      else if (strncmp (arg, "-subset=", 8) == 0)
+	{
+	  mu_msgset_t tset = parse_msgset (arg + 8);
+	  if (!msgset)
+	    {
+	      mu_error ("no initial message set");
+	      exit (1);
+	    }
+	  else
+	    {
+	      MU_ASSERT (mu_msgset_sub (msgset, tset));
+	      mu_msgset_free (tset);
+	    }
 	}
 	}
       else
       else
       	{
       	{

@@ -175,7 +175,7 @@ __imap_msg_get_stream (struct _mu_imap_message *imsg, size_t msgno,
       if (rc)
       if (rc)
 	return rc;
 	return rc;
 
 
-      rc = mu_msgset_create (&msgset, NULL, 0);
+      rc = mu_msgset_create (&msgset, NULL, MU_MSGSET_NUM);
       if (rc == 0)
       if (rc == 0)
 	{
 	{
 	  struct save_closure clos;
 	  struct save_closure clos;
@@ -183,7 +183,7 @@ __imap_msg_get_stream (struct _mu_imap_message *imsg, size_t msgno,
 	  clos.imsg = imsg;
 	  clos.imsg = imsg;
 	  clos.save_stream = imbx->cache;
 	  clos.save_stream = imbx->cache;
 
 
-	  rc = mu_msgset_add_range (msgset, msgno, msgno);
+	  rc = mu_msgset_add_range (msgset, msgno, msgno, MU_MSGSET_NUM);
 	  if (rc == 0)
 	  if (rc == 0)
 	    {
 	    {
 	      _imap_mbx_clrerr (imbx);
 	      _imap_mbx_clrerr (imbx);
@@ -370,10 +370,10 @@ _imap_hdr_fill (void *data, char **pbuf, size_t *plen)
   unsigned long msgno = _imap_msg_no (imsg);
   unsigned long msgno = _imap_msg_no (imsg);
   int rc;
   int rc;
 
 
-  rc = mu_msgset_create (&msgset, NULL, 0);
+  rc = mu_msgset_create (&msgset, NULL, MU_MSGSET_NUM);
   if (rc == 0)
   if (rc == 0)
     {
     {
-      rc = mu_msgset_add_range (msgset, msgno, msgno);
+      rc = mu_msgset_add_range (msgset, msgno, msgno, MU_MSGSET_NUM);
       if (rc == 0)
       if (rc == 0)
 	{
 	{
 	  clos.imsg = imsg;
 	  clos.imsg = imsg;
@@ -619,11 +619,11 @@ _imap_msg_bodystructure (mu_message_t msg, struct mu_bodystructure **pbs)
   int rc;
   int rc;
   mu_msgset_t msgset;
   mu_msgset_t msgset;
 
 
-  rc = mu_msgset_create (&msgset, NULL, 0);
+  rc = mu_msgset_create (&msgset, NULL, MU_MSGSET_NUM);
   if (rc == 0)
   if (rc == 0)
     {
     {
       size_t msgno = _imap_msg_no (imsg);
       size_t msgno = _imap_msg_no (imsg);
-      rc = mu_msgset_add_range (msgset, msgno, msgno);
+      rc = mu_msgset_add_range (msgset, msgno, msgno, MU_MSGSET_NUM);
       if (rc == 0)
       if (rc == 0)
 	rc = _imap_fetch_with_callback (imap, msgset, "BODYSTRUCTURE",
 	rc = _imap_fetch_with_callback (imap, msgset, "BODYSTRUCTURE",
 					_imap_bodystructure_callback, pbs);
 					_imap_bodystructure_callback, pbs);
@@ -949,7 +949,7 @@ _imap_mbx_gensync (mu_mailbox_t mbox, int *pdel)
   struct attr_tab *tab;
   struct attr_tab *tab;
   size_t count;
   size_t count;
 
 
-  rc = mu_msgset_create (&msgset, NULL, 0);
+  rc = mu_msgset_create (&msgset, NULL, MU_MSGSET_NUM);
   if (rc)
   if (rc)
     return rc;
     return rc;
 
 
@@ -962,7 +962,7 @@ _imap_mbx_gensync (mu_mailbox_t mbox, int *pdel)
 	  if (imbx->msgs[i].flags & _MU_IMAP_MSG_ATTRCHG)
 	  if (imbx->msgs[i].flags & _MU_IMAP_MSG_ATTRCHG)
 	    {
 	    {
 	      mu_msgset_clear (msgset);
 	      mu_msgset_clear (msgset);
-	      mu_msgset_add_range (msgset, i + 1, i + 1);
+	      mu_msgset_add_range (msgset, i + 1, i + 1, MU_MSGSET_NUM);
 	      if (rc)
 	      if (rc)
 		break;
 		break;
 	      rc = mu_imap_store_flags (imap, 0, msgset,
 	      rc = mu_imap_store_flags (imap, 0, msgset,
@@ -994,12 +994,13 @@ _imap_mbx_gensync (mu_mailbox_t mbox, int *pdel)
 		}
 		}
 	    }
 	    }
 	  if (tab[i].end == tab[i].start)
 	  if (tab[i].end == tab[i].start)
-	    rc = mu_msgset_add_range (msgset, tab[i].start + 1,
-				      tab[i].start + 1);
+	    rc = mu_msgset_add_range (msgset,
+				      tab[i].start + 1, tab[i].start + 1,
+				      MU_MSGSET_NUM);
 	  else
 	  else
 	    rc = mu_msgset_add_range (msgset,
 	    rc = mu_msgset_add_range (msgset,
-				      tab[i].start + 1,
-				      tab[i].end + 1);
+				      tab[i].start + 1, tab[i].end + 1,
+				      MU_MSGSET_NUM);
 	  if (rc)
 	  if (rc)
 	    break;
 	    break;
 	}
 	}
@@ -1192,10 +1193,10 @@ _imap_mbx_scan (mu_mailbox_t mbox, size_t msgno, size_t *pcount)
   
   
   mu_debug (MU_DEBCAT_MAILBOX, MU_DEBUG_TRACE1,
   mu_debug (MU_DEBCAT_MAILBOX, MU_DEBUG_TRACE1,
 	    (_("scanning mailbox %s"), mu_url_to_string (mbox->url)));
 	    (_("scanning mailbox %s"), mu_url_to_string (mbox->url)));
-  rc = mu_msgset_create (&msgset, NULL, 0);
+  rc = mu_msgset_create (&msgset, NULL, MU_MSGSET_NUM);
   if (rc)
   if (rc)
     return rc;
     return rc;
-  rc = mu_msgset_add_range (msgset, msgno, MU_MSGNO_LAST);
+  rc = mu_msgset_add_range (msgset, msgno, MU_MSGNO_LAST, MU_MSGSET_NUM);
   if (rc)
   if (rc)
     {
     {
       mu_msgset_free (msgset);
       mu_msgset_free (msgset);

@@ -95,10 +95,11 @@ opt_handler (int key, char *arg, struct argp_state *state)
   return 0;
   return 0;
 }
 }
 
 
-void
-anno (mu_mailbox_t mbox, mu_message_t msg, size_t num, void *data)
+int
+anno (size_t n, mu_message_t msg, void *call_data)
 {
 {
   mh_annotate (msg, component, anno_text, anno_date);
   mh_annotate (msg, component, anno_text, anno_date);
+  return 0;
 }
 }
 
 
 int
 int
@@ -107,7 +108,7 @@ main (int argc, char **argv)
   int rc;
   int rc;
   int index;
   int index;
   mu_mailbox_t mbox;
   mu_mailbox_t mbox;
-  mh_msgset_t msgset;
+  mu_msgset_t msgset;
   size_t len;
   size_t len;
 
 
   MU_APP_INIT_NLS ();
   MU_APP_INIT_NLS ();
@@ -154,10 +155,16 @@ main (int argc, char **argv)
   argc -= index;
   argc -= index;
   argv += index;
   argv += index;
   
   
-  mh_msgset_parse (mbox, &msgset, argc, argv, "cur");
-  rc = mh_iterate (mbox, &msgset, anno, NULL);
-
-  mh_msgset_current (mbox, &msgset, 0);
+  mh_msgset_parse (&msgset, mbox, argc, argv, "cur");
+  rc = mu_msgset_foreach_message (msgset, anno, NULL);
+  if (rc)
+    {
+      mu_diag_funcall (MU_DIAG_ERROR, "mu_msgset_foreach_message", NULL, rc);
+      exit (1);
+    }
+      
+  mh_msgset_first_current (mbox, msgset);
+  mu_msgset_free (msgset);
   mh_global_save_state ();
   mh_global_save_state ();
   mu_mailbox_sync (mbox);
   mu_mailbox_sync (mbox);
   mu_mailbox_close (mbox);
   mu_mailbox_close (mbox);

@@ -578,8 +578,8 @@ burst_or_copy (mu_message_t msg, int recursive, int copy)
   return 1;
   return 1;
 }
 }
 
 
-void
-burst (mu_mailbox_t mbox, mu_message_t msg, size_t num, void *data)
+int
+burst (size_t num, mu_message_t msg, void *data)
 {
 {
   memset (&map, 0, sizeof (map));
   memset (&map, 0, sizeof (map));
   mh_message_number (msg, &map.msgno);
   mh_message_number (msg, &map.msgno);
@@ -599,36 +599,38 @@ burst (mu_mailbox_t mbox, mu_message_t msg, size_t num, void *data)
     }
     }
   else if (!quiet)
   else if (!quiet)
     mu_error (_("message %s not in digest format"), mu_umaxtostr (0, num));
     mu_error (_("message %s not in digest format"), mu_umaxtostr (0, num));
+  return 0;
 }
 }
 
 
 
 
 /* Inplace handling */
 /* Inplace handling */
+struct rename_env
+{
+  size_t lastuid;
+  size_t idx;
+};
 
 
-void
-burst_rename (mh_msgset_t *ms, size_t lastuid)
+  
+static int
+_rename (size_t msgno, void *data)
 {
 {
-  size_t i, j;
+  struct rename_env *rp = data;
+  
+  if (msgno == burst_map[rp->idx].msgno)
+    {
+      rp->lastuid -= burst_map[rp->idx].count;
+      burst_map[rp->idx].msgno = rp->lastuid;
+      rp->idx--;
+    }
 
 
-  VERBOSE ((_("Renaming messages")));
-  j = burst_count - 1;
-  for (i = ms->count; i > 0; i--)
+  if (msgno != rp->lastuid)
     {
     {
       const char *from;
       const char *from;
       const char *to;
       const char *to;
 
 
-      if (ms->list[i-1] == burst_map[j].msgno)
-	{
-	  lastuid -= burst_map[j].count;
-	  burst_map[j].msgno = lastuid;
-	  j--;
-	}
-
-      if (ms->list[i-1] == lastuid)
-	continue;
-      
-      from = mu_umaxtostr (0, ms->list[i-1]);
-      to   = mu_umaxtostr (1, lastuid);
-      --lastuid;
+      from = mu_umaxtostr (0, msgno);
+      to   = mu_umaxtostr (1, rp->lastuid);
+      --rp->lastuid;
 
 
       VERBOSE((_("message %s becomes message %s"), from, to));
       VERBOSE((_("message %s becomes message %s"), from, to));
 	       
 	       
@@ -639,6 +641,18 @@ burst_rename (mh_msgset_t *ms, size_t lastuid)
 	  exit (1);
 	  exit (1);
 	}
 	}
     }
     }
+  return 0;
+}
+
+void
+burst_rename (mu_msgset_t ms, size_t lastuid)
+{
+  struct rename_env renv;
+
+  VERBOSE ((_("Renaming messages")));
+  renv.lastuid = lastuid;
+  renv.idx = burst_count - 1;
+  mu_msgset_foreach_dir_msguid (ms, 1, _rename, &renv);
 }  
 }  
 
 
 void
 void
@@ -705,7 +719,7 @@ main (int argc, char **argv)
 {
 {
   int index, rc;
   int index, rc;
   mu_mailbox_t mbox;
   mu_mailbox_t mbox;
-  mh_msgset_t msgset;
+  mu_msgset_t msgset;
   const char *tempfolder = mh_global_profile_get ("Temp-Folder", ".temp");
   const char *tempfolder = mh_global_profile_get ("Temp-Folder", ".temp");
   
   
   /* Native Language Support */
   /* Native Language Support */
@@ -720,7 +734,7 @@ main (int argc, char **argv)
 
 
   VERBOSE ((_("Opening folder `%s'"), mh_current_folder ()));
   VERBOSE ((_("Opening folder `%s'"), mh_current_folder ()));
   mbox = mh_open_folder (mh_current_folder (), MU_STREAM_RDWR);
   mbox = mh_open_folder (mh_current_folder (), MU_STREAM_RDWR);
-  mh_msgset_parse (mbox, &msgset, argc, argv, "cur");
+  mh_msgset_parse (&msgset, mbox, argc, argv, "cur");
 
 
   if (inplace)
   if (inplace)
     {
     {
@@ -744,7 +758,7 @@ main (int argc, char **argv)
   else
   else
     tmpbox = mbox;
     tmpbox = mbox;
 
 
-  rc = mh_iterate (mbox, &msgset, burst, NULL);
+  rc = mu_msgset_foreach_message (msgset, burst, NULL);
   if (rc)
   if (rc)
     return rc;
     return rc;
 
 
@@ -752,8 +766,8 @@ main (int argc, char **argv)
     {
     {
       mu_url_t dst_url = NULL;
       mu_url_t dst_url = NULL;
       size_t i, next_uid, last_uid;
       size_t i, next_uid, last_uid;
-      mh_msgset_t ms;
-      char *xargv[2];
+      mu_msgset_t ms;
+      size_t count;
       const char *dir;
       const char *dir;
       
       
       burst_map = obstack_finish (&stk);
       burst_map = obstack_finish (&stk);
@@ -763,11 +777,14 @@ main (int argc, char **argv)
 	last_uid += burst_map[i].count;
 	last_uid += burst_map[i].count;
       VERBOSE ((_("Estimated last UID: %s"), mu_umaxtostr (0, last_uid)));
       VERBOSE ((_("Estimated last UID: %s"), mu_umaxtostr (0, last_uid)));
 
 
-      mu_asprintf (&xargv[0], "%s-last", mu_umaxtostr (0, burst_map[0].msgno));
-      xargv[1] = NULL;
-      mh_msgset_parse (mbox, &ms, 1, xargv, NULL);
-      free (xargv[0]);
-      mh_msgset_uids (mbox, &ms);
+      rc = mu_msgset_create (&ms, mbox, MU_MSGSET_NUM);
+      if (rc)
+	{
+	  mu_diag_funcall (MU_DIAG_ERROR, "mu_msgset_create", NULL, rc);
+	  exit (1);
+	}
+      mu_mailbox_messages_count (mbox, &count);
+      mu_msgset_add_range (ms, burst_map[0].msgno, count, MU_MSGSET_NUM);
 	
 	
       mu_mailbox_get_url (mbox, &dst_url);
       mu_mailbox_get_url (mbox, &dst_url);
       mu_url_sget_path (dst_url, &dir);
       mu_url_sget_path (dst_url, &dir);
@@ -779,8 +796,8 @@ main (int argc, char **argv)
 	}
 	}
       mu_mailbox_close (mbox);
       mu_mailbox_close (mbox);
 
 
-      burst_rename (&ms, last_uid);
-      mh_msgset_free (&ms);
+      burst_rename (ms, last_uid);
+      mu_msgset_free (ms);
 
 
       finalize_inplace (last_uid);
       finalize_inplace (last_uid);
 
 

@@ -246,22 +246,21 @@ main (int argc, char **argv)
 	     `-draftfolder +folder'  treat this arguments  as `msg'. */
 	     `-draftfolder +folder'  treat this arguments  as `msg'. */
 	  if (use_draft || index < argc)
 	  if (use_draft || index < argc)
 	    {
 	    {
-	      mh_msgset_t msgset;
+	      mu_msgset_t msgset;
 	      mu_mailbox_t mbox;
 	      mu_mailbox_t mbox;
 	      
 	      
 	      mbox = mh_open_folder (draftfolder, 
 	      mbox = mh_open_folder (draftfolder, 
                                      MU_STREAM_RDWR|MU_STREAM_CREAT);
                                      MU_STREAM_RDWR|MU_STREAM_CREAT);
-	      mh_msgset_parse (mbox, &msgset, 
+	      mh_msgset_parse (&msgset, mbox, 
 	                       argc - index, argv + index,
 	                       argc - index, argv + index,
 			       use_draft ? "cur" : "new");
 			       use_draft ? "cur" : "new");
-              mh_msgset_uids (mbox, &msgset);	
-	      if (msgset.count != 1)
+	      if (!mh_msgset_single_message (msgset))
 		{
 		{
 		  mu_error (_("only one message at a time!"));
 		  mu_error (_("only one message at a time!"));
 		  return 1;
 		  return 1;
 		}
 		}
-	      draftmessage = mu_umaxtostr (0, msgset.list[0]);
-	      mh_msgset_free (&msgset);
+	      draftmessage = mu_umaxtostr (0, mh_msgset_first_uid (msgset));
+	      mu_msgset_free (msgset);
 	      mu_mailbox_destroy (&mbox);
 	      mu_mailbox_destroy (&mbox);
 	    }
 	    }
 	  if (mh_draft_message (draftfolder, draftmessage,
 	  if (mh_draft_message (draftfolder, draftmessage,
@@ -273,20 +272,20 @@ main (int argc, char **argv)
 
 
   if (folder_set && index < argc)
   if (folder_set && index < argc)
     {
     {
-      mh_msgset_t msgset;
+      mu_msgset_t msgset;
       mu_mailbox_t mbox;
       mu_mailbox_t mbox;
       
       
       mbox = mh_open_folder (mh_current_folder (), MU_STREAM_READ);
       mbox = mh_open_folder (mh_current_folder (), MU_STREAM_READ);
-      mh_msgset_parse (mbox, &msgset, argc - index, argv + index, "cur");
-      if (msgset.count != 1)
+      mh_msgset_parse (&msgset, mbox, argc - index, argv + index, "cur");
+      if (!mh_msgset_single_message (msgset))
 	{
 	{
 	  mu_error (_("only one message at a time!"));
 	  mu_error (_("only one message at a time!"));
 	  return 1;
 	  return 1;
 	}
 	}
       unlink (wh_env.file);
       unlink (wh_env.file);
-      copy_message (mbox, msgset.list[0], wh_env.file);
+      copy_message (mbox, mh_msgset_first (msgset), wh_env.file);
       mu_mailbox_destroy (&mbox);
       mu_mailbox_destroy (&mbox);
-      mh_msgset_free (&msgset);
+      mu_msgset_free (msgset);
     }
     }
   else
   else
     {
     {

@@ -773,9 +773,10 @@ pack_xlate (struct pack_tab *pack_tab, size_t count, size_t n)
 static int
 static int
 _fixup (const char *name, const char *value, struct fixup_data *fd, int flags)
 _fixup (const char *name, const char *value, struct fixup_data *fd, int flags)
 {
 {
-  size_t i, j;
+  size_t i;
+  int rc;
   struct mu_wordsplit ws;
   struct mu_wordsplit ws;
-  mh_msgset_t msgset;
+  mu_msgset_t msgset;
 
 
   if (verbose)
   if (verbose)
     fprintf (stderr, "Sequence `%s'...\n", name);
     fprintf (stderr, "Sequence `%s'...\n", name);
@@ -787,20 +788,32 @@ _fixup (const char *name, const char *value, struct fixup_data *fd, int flags)
       return 0;
       return 0;
     }
     }
 
 
-  msgset.list = xcalloc (ws.ws_wordc, sizeof msgset.list[0]);
-  for (i = j = 0; i < ws.ws_wordc; i++)
+  rc = mu_msgset_create (&msgset, NULL, MU_MSGSET_UID);
+  if (rc)
+    {
+      mu_diag_funcall (MU_DIAG_ERROR, "mu_msgset_create", NULL, rc);
+      exit (1);
+    }
+  
+  for (i = 0; i < ws.ws_wordc; i++)
     {
     {
       size_t n = pack_xlate (fd->pack_tab, fd->count,
       size_t n = pack_xlate (fd->pack_tab, fd->count,
 			     strtoul (ws.ws_wordv[i], NULL, 0));
 			     strtoul (ws.ws_wordv[i], NULL, 0));
       if (n)
       if (n)
-	msgset.list[j++] = n;
+	{
+	  rc = mu_msgset_add_range (msgset, n, n, MU_MSGSET_UID);
+	  if (rc)
+	    {
+	      mu_diag_funcall (MU_DIAG_ERROR, "mu_msgset_add_range", NULL, rc);
+	      exit (1);
+	    }
+	}
     }
     }
-  msgset.count = j;
 
 
   mu_wordsplit_free (&ws);
   mu_wordsplit_free (&ws);
   
   
-  mh_seq_add (fd->mbox, name, &msgset, flags | SEQ_ZERO);
-  free (msgset.list);
+  mh_seq_add (fd->mbox, name, msgset, flags | SEQ_ZERO);
+  mu_msgset_free (msgset);
 
 
   if (verbose)
   if (verbose)
     {
     {
@@ -944,7 +957,7 @@ int
 main (int argc, char **argv)
 main (int argc, char **argv)
 {
 {
   int index = 0;
   int index = 0;
-  mh_msgset_t msgset;
+  mu_msgset_t msgset;
 
 
   /* Native Language Support */
   /* Native Language Support */
   MU_APP_INIT_NLS ();
   MU_APP_INIT_NLS ();
@@ -971,9 +984,11 @@ main (int argc, char **argv)
     
     
   if (argc - index == 1)
   if (argc - index == 1)
     {
     {
-      mu_mailbox_t mbox = mh_open_folder (mh_current_folder (), MU_STREAM_RDWR);
-      mh_msgset_parse (mbox, &msgset, argc - index, argv + index, "cur");
-      mh_msgset_current (mbox, &msgset, 0);
+      mu_mailbox_t mbox = mh_open_folder (mh_current_folder (),
+					  MU_STREAM_RDWR);
+      mh_msgset_parse (&msgset, mbox, argc - index, argv + index, "cur");
+      mh_msgset_first_current (mbox, msgset);
+      mu_msgset_free (msgset);
       mh_global_save_state ();
       mh_global_save_state ();
       mu_mailbox_close (mbox);
       mu_mailbox_close (mbox);
       mu_mailbox_destroy (&mbox);
       mu_mailbox_destroy (&mbox);

@@ -116,7 +116,7 @@ static char *draftmessage = "new";
 static const char *draftfolder = NULL;
 static const char *draftfolder = NULL;
 static char *input_file;        /* input file name (--file option) */
 static char *input_file;        /* input file name (--file option) */
 
 
-static mh_msgset_t msgset;
+static mu_msgset_t msgset;
 static mu_mailbox_t mbox;
 static mu_mailbox_t mbox;
 
 
 static int
 static int
@@ -331,15 +331,27 @@ format_message (mu_stream_t outstr, mu_message_t msg, int num,
     }
     }
 }
 }
 
 
-void
-format_message_itr (mu_mailbox_t mbox MU_ARG_UNUSED,
-		    mu_message_t msg, size_t num, void *data)
+int
+format_message_itr (size_t num, mu_message_t msg, void *data)
 {
 {
   struct format_data *fp = data;
   struct format_data *fp = data;
 
 
   format_message (fp->stream, msg, fp->num, fp->format);
   format_message (fp->stream, msg, fp->num, fp->format);
   if (fp->num)
   if (fp->num)
     fp->num++;
     fp->num++;
+  return 0;
+}
+
+static int
+_proc_forwards (size_t n, mu_message_t msg, void *call_data)
+{
+  mu_stream_t stream = call_data;
+  size_t num;
+	      
+  if (annotate)
+    mu_list_append (wh_env.anno_list, msg);
+  mh_message_number (msg, &num);
+  return mu_stream_printf (stream, " %lu", (unsigned long) num);
 }
 }
 
 
 void
 void
@@ -411,36 +423,22 @@ finish_draft ()
 	{
 	{
 	  mu_url_t url;
 	  mu_url_t url;
 	  const char *mbox_path;
 	  const char *mbox_path;
-	  const char *p;
-	  size_t i;
       
       
 	  mu_mailbox_get_url (mbox, &url);
 	  mu_mailbox_get_url (mbox, &url);
 	  mu_url_sget_path (url, &mbox_path);
 	  mu_url_sget_path (url, &mbox_path);
 	  mu_asprintf (&str, "#forw [] +%s", mbox_path);
 	  mu_asprintf (&str, "#forw [] +%s", mbox_path);
 	  rc = mu_stream_write (stream, str, strlen (str), NULL);
 	  rc = mu_stream_write (stream, str, strlen (str), NULL);
 	  free (str);
 	  free (str);
-	  for (i = 0; rc == 0 && i < msgset.count; i++)
-	    {
-	      mu_message_t msg;
-	      size_t num;
-	      
-	      mu_mailbox_get_message (mbox, msgset.list[i], &msg);
-	      if (annotate)
-		mu_list_append (wh_env.anno_list, msg);
-	      mh_message_number (msg, &num);
-	      p = mu_umaxtostr (0, num);
-	      rc = mu_stream_write (stream, " ", 1, NULL);
-	      if (rc)
-		break;
-	      rc = mu_stream_write (stream, p, strlen (p), NULL);
-	    }
+	  mu_msgset_foreach_message (msgset, _proc_forwards, stream);
 	}
 	}
       else
       else
 	{
 	{
+	  int single_message = mh_msgset_single_message (msgset);
+	  
 	  str = "\n------- ";
 	  str = "\n------- ";
 	  rc = mu_stream_write (stream, str, strlen (str), NULL);
 	  rc = mu_stream_write (stream, str, strlen (str), NULL);
 	  
 	  
-	  if (msgset.count == 1)
+	  if (single_message)
 	    {
 	    {
 	      fd.num = 0;
 	      fd.num = 0;
 	      str = (char*) _("Forwarded message\n");
 	      str = (char*) _("Forwarded message\n");
@@ -454,12 +452,12 @@ finish_draft ()
 	  rc = mu_stream_write (stream, str, strlen (str), NULL);
 	  rc = mu_stream_write (stream, str, strlen (str), NULL);
 	  fd.stream = stream;
 	  fd.stream = stream;
 	  fd.format = format;
 	  fd.format = format;
-	  rc = mh_iterate (mbox, &msgset, format_message_itr, &fd);
+	  rc = mu_msgset_foreach_message (msgset, format_message_itr, &fd);
       
       
 	  str = "\n------- ";
 	  str = "\n------- ";
 	  rc = mu_stream_write (stream, str, strlen (str), NULL);
 	  rc = mu_stream_write (stream, str, strlen (str), NULL);
 	  
 	  
-	  if (msgset.count == 1)
+	  if (single_message)
 	    str = (char*) _("End of Forwarded message");
 	    str = (char*) _("End of Forwarded message");
 	  else
 	  else
 	    str = (char*) _("End of Forwarded messages");
 	    str = (char*) _("End of Forwarded messages");
@@ -504,7 +502,7 @@ main (int argc, char **argv)
   else
   else
     {
     {
       mbox = mh_open_folder (mh_current_folder (), MU_STREAM_RDWR);
       mbox = mh_open_folder (mh_current_folder (), MU_STREAM_RDWR);
-      mh_msgset_parse (mbox, &msgset, argc, argv, "cur");
+      mh_msgset_parse (&msgset, mbox, argc, argv, "cur");
     }
     }
   
   
   if (build_only || !draftfolder)
   if (build_only || !draftfolder)

@@ -121,7 +121,7 @@ opt_handler (int key, char *arg, struct argp_state *state)
 struct mark_closure
 struct mark_closure
 {
 {
   mu_mailbox_t mbox;
   mu_mailbox_t mbox;
-  mh_msgset_t *msgset;
+  mu_msgset_t msgset;
 };
 };
 
 
 static int
 static int
@@ -191,7 +191,7 @@ int
 main (int argc, char **argv)
 main (int argc, char **argv)
 {
 {
   int index;
   int index;
-  mh_msgset_t msgset;
+  mu_msgset_t msgset;
   mu_mailbox_t mbox;
   mu_mailbox_t mbox;
   mu_url_t url;
   mu_url_t url;
   struct mark_closure clos;
   struct mark_closure clos;
@@ -209,11 +209,11 @@ main (int argc, char **argv)
 	
 	
   argc -= index;
   argc -= index;
   argv += index;
   argv += index;
-  mh_msgset_parse (mbox, &msgset, argc, argv, "cur");
-  mh_msgset_uids (mbox, &msgset);
+  mh_msgset_parse (&msgset, mbox, argc, argv, "cur");
   
   
   clos.mbox = mbox;
   clos.mbox = mbox;
-  clos.msgset = &msgset;
+  clos.msgset = msgset;
+  //FIXME: msgset operates on UIDs but there's no way to inform it about that.
   switch (action)
   switch (action)
     {
     {
     case ARG_ADD:
     case ARG_ADD:

@@ -60,6 +60,7 @@
 #include <mailutils/mh.h>
 #include <mailutils/mh.h>
 #include <mailutils/stdstream.h>
 #include <mailutils/stdstream.h>
 #include <mailutils/datetime.h>
 #include <mailutils/datetime.h>
+#include <mailutils/msgset.h>
 
 
 #include <mu_umaxtostr.h>
 #include <mu_umaxtostr.h>
 
 
@@ -194,19 +195,6 @@ typedef struct
   mu_header_t header;
   mu_header_t header;
 } mh_context_t;
 } mh_context_t;
 
 
-#define MH_MSGSET_UID   0x01
-
-typedef struct
-{
-  int flags;
-  size_t *list;
-  size_t count;
-  size_t size;
-} mh_msgset_t;
-
-typedef void (*mh_iterator_fp) (mu_mailbox_t mbox, mu_message_t msg,
-			        size_t num, void *data);
-
 /* Recipient masks */
 /* Recipient masks */
 #define RCPT_NONE 0
 #define RCPT_NONE 0
 #define RCPT_TO   0x0001
 #define RCPT_TO   0x0001
@@ -303,14 +291,14 @@ int mh_message_number (mu_message_t msg, size_t *pnum);
 
 
 mu_mailbox_t mh_open_folder (const char *folder, int flags);
 mu_mailbox_t mh_open_folder (const char *folder, int flags);
 
 
-void mh_msgset_parse (mu_mailbox_t mbox, mh_msgset_t *msgset,
+void mh_msgset_parse (mu_msgset_t *msgset, mu_mailbox_t mbox, 
 		      int argc, char **argv, char *def);
 		      int argc, char **argv, char *def);
-int mh_msgset_member (mh_msgset_t *msgset, size_t num);
-void mh_msgset_reverse (mh_msgset_t *msgset);
-void mh_msgset_negate (mu_mailbox_t mbox, mh_msgset_t *msgset);
-void mh_msgset_current (mu_mailbox_t mbox, mh_msgset_t *msgset, int index);
-void mh_msgset_free (mh_msgset_t *msgset);
-void mh_msgset_uids (mu_mailbox_t mbox, mh_msgset_t *msgset);
+void mh_msgset_parse_string (mu_msgset_t *msgset, mu_mailbox_t mbox, 
+			     const char *string, char *def);
+void mh_msgset_first_current (mu_mailbox_t mbox, mu_msgset_t msgset);
+size_t mh_msgset_first (mu_msgset_t msgset);
+size_t mh_msgset_first_uid (mu_msgset_t msgset);
+int mh_msgset_single_message (mu_msgset_t msgset);
 
 
 char *mh_get_dir (void);
 char *mh_get_dir (void);
 int mh_find_file (const char *name, char **resolved_name);
 int mh_find_file (const char *name, char **resolved_name);
@@ -323,9 +311,6 @@ void mh_expand_aliases (mu_message_t msg, mu_address_t *addr_to,
 int mh_is_my_name (const char *name);
 int mh_is_my_name (const char *name);
 char * mh_my_email (void);
 char * mh_my_email (void);
 
 
-int mh_iterate (mu_mailbox_t mbox, mh_msgset_t *msgset,
-	        mh_iterator_fp itr, void *data);
-
 size_t mh_get_message (mu_mailbox_t mbox, size_t seqno, mu_message_t *mesg);
 size_t mh_get_message (mu_mailbox_t mbox, size_t seqno, mu_message_t *mesg);
 
 
 int mh_decode_rcpt_flag (const char *arg);
 int mh_decode_rcpt_flag (const char *arg);
@@ -372,9 +357,9 @@ int mhl_format_run (mu_list_t fmt, int width, int length, int flags,
 		    mu_message_t msg, mu_stream_t output);
 		    mu_message_t msg, mu_stream_t output);
 void mhl_format_destroy (mu_list_t *fmt);
 void mhl_format_destroy (mu_list_t *fmt);
 
 
-void mh_seq_add (mu_mailbox_t mbox, const char *name, mh_msgset_t *mset,
+void mh_seq_add (mu_mailbox_t mbox, const char *name, mu_msgset_t mset,
 		 int flags);
 		 int flags);
-int mh_seq_delete (mu_mailbox_t mbox, const char *name, mh_msgset_t *mset,
+int mh_seq_delete (mu_mailbox_t mbox, const char *name, mu_msgset_t mset,
 		   int flags);
 		   int flags);
 const char *mh_seq_read (mu_mailbox_t mbox, const char *name, int flags);
 const char *mh_seq_read (mu_mailbox_t mbox, const char *name, int flags);
 
 

@@ -577,32 +577,6 @@ mh_find_file (const char *name, char **resolved_name)
 }
 }
 
 
 int
 int
-mh_iterate (mu_mailbox_t mbox, mh_msgset_t *msgset,
-	    mh_iterator_fp itr, void *data)
-{
-  int rc;
-  size_t i;
-
-  for (i = 0; i < msgset->count; i++)
-    {
-      mu_message_t msg;
-      size_t num;
-
-      num = msgset->list[i];
-      if ((rc = mu_mailbox_get_message (mbox, num, &msg)) != 0)
-	{
-	  mu_error (_("cannot get message %lu: %s"),
-		    (unsigned long) num, mu_strerror (rc));
-	  return 1;
-	}
-
-      itr (mbox, msg, num, data);
-    }
-
-  return 0;
-}
-
-int
 mh_spawnp (const char *prog, const char *file)
 mh_spawnp (const char *prog, const char *file)
 {
 {
   struct mu_wordsplit ws;
   struct mu_wordsplit ws;
@@ -1039,19 +1013,16 @@ mh_draft_message (const char *name, const char *msgspec, char **pname)
   else
   else
     {
     {
       char *argv[2];
       char *argv[2];
-      mh_msgset_t msgset;
+      mu_msgset_t msgset;
       
       
       argv[0] = (char*) msgspec;
       argv[0] = (char*) msgspec;
       argv[1] = NULL;
       argv[1] = NULL;
-      mh_msgset_parse (mbox, &msgset, 1, argv, "cur");
-      if (msgset.count > 1)
+      mh_msgset_parse (&msgset, mbox, 1, argv, "cur");
+      if (!mh_msgset_single_message (msgset))
 	mu_error (_("only one message at a time!"));
 	mu_error (_("only one message at a time!"));
       else
       else
-	{
-	  mh_msgset_uids (mbox, &msgset);
-	  uid = msgset.list[0];
-	}
-      mh_msgset_free (&msgset);
+	uid = mh_msgset_first_uid (msgset);
+      mu_msgset_free (msgset);
     }
     }
 
 
   mu_url_sget_path (url, &path);
   mu_url_sget_path (url, &path);

@@ -16,6 +16,7 @@
    along with GNU Mailutils.  If not, see <http://www.gnu.org/licenses/>. */
    along with GNU Mailutils.  If not, see <http://www.gnu.org/licenses/>. */
 
 
 #include <mh.h>
 #include <mh.h>
+#include <mailutils/sys/msgset.h>
 
 
 static char *
 static char *
 private_sequence_name (const char *name)
 private_sequence_name (const char *name)
@@ -62,118 +63,124 @@ delete_sequence (mu_mailbox_t mbox, const char *name, int private)
   write_sequence (mbox, name, NULL, private);
   write_sequence (mbox, name, NULL, private);
 }
 }
 
 
-void
-mh_seq_add (mu_mailbox_t mbox, const char *name, mh_msgset_t *mset, int flags)
+struct format_closure
 {
 {
-  const char *value = mh_seq_read (mbox, name, flags);
-  char *new_value, *p;
-  const char *buf;
-  size_t i, len;
+  mu_stream_t stream;
+  mu_mailbox_t mailbox;
+};
 
 
-  delete_sequence (mbox, name, !(flags & SEQ_PRIVATE));
+static int
+format_sequence (void *item, void *data)
+{
+  struct mu_msgrange *r = item;
+  struct format_closure *clos = data;
+  int rc;
+  size_t beg, end;
 
 
-  if (flags & SEQ_ZERO)
-    value = NULL;
-  
-  if (value)
-    len = strlen (value);
+  if (clos->mailbox)
+    {
+      rc = mu_mailbox_translate (clos->mailbox,
+				 MU_MAILBOX_MSGNO_TO_UID,
+				 r->msg_beg, &beg);
+      if (rc)
+	return rc;
+    }
+  else
+    beg = r->msg_beg;
+  if (r->msg_beg == r->msg_end)
+    rc = mu_stream_printf (clos->stream, " %lu", (unsigned long) beg);
   else
   else
-    len = 0;
-  len++;
-  for (i = 0; i < mset->count; i++)
     {
     {
-      buf = mu_umaxtostr (0, mset->list[i]);
-      len += strlen (buf) + 1;
+      if (clos->mailbox)
+	{
+	  rc = mu_mailbox_translate (clos->mailbox,
+				     MU_MAILBOX_MSGNO_TO_UID,
+				     r->msg_end, &end);
+	  if (rc)
+	    return rc;
+	}
+      else
+	end = r->msg_end;
+      if (beg + 1 == end)
+	rc = mu_stream_printf (clos->stream, " %lu %lu",
+			       (unsigned long) beg,
+			       (unsigned long) end);
+      else
+	rc = mu_stream_printf (clos->stream, " %lu-%lu",
+			       (unsigned long) beg,
+			       (unsigned long) end);
     }
     }
+  return rc;
+}
 
 
-  new_value = xmalloc (len + 1);
-  if (value)
-    strcpy (new_value, value);
+static void
+save_sequence (mu_mailbox_t mbox, const char *name, mu_msgset_t mset,
+	       int flags)
+{
+  mu_list_t list;
+  
+  mu_msgset_get_list (mset, &list);
+  if (mu_list_is_empty (list))
+    write_sequence (mset->mbox, name, NULL, flags & SEQ_PRIVATE);
   else
   else
-    new_value[0] = 0;
-  p = new_value + strlen (new_value);
-  *p++ = ' ';
-  for (i = 0; i < mset->count; i++)
     {
     {
-      p += sprintf (p, "%s", mu_umaxtostr (0, mset->list[i]));
-      *p++ = ' ';
+      struct format_closure clos;
+      int rc;
+      mu_transport_t trans[2];
+      
+      rc = mu_memory_stream_create (&clos.stream, MU_STREAM_RDWR);
+      if (rc)
+	{
+	  mu_diag_funcall (MU_DIAG_ERROR, "mu_memory_stream_create", NULL, rc);
+	  exit (1);
+	}
+      
+      clos.mailbox = mset->mbox;
+      rc = mu_list_foreach (list, format_sequence, &clos);
+      if (rc)
+	{
+	  mu_diag_funcall (MU_DIAG_ERROR, "mu_list_foreach", NULL, rc);
+	  exit (1);
+	}
+      mu_stream_write (clos.stream, "", 1, NULL);
+      mu_stream_ioctl (clos.stream, MU_IOCTL_TRANSPORT, MU_IOCTL_OP_GET,
+		       trans);
+      write_sequence (mbox, name, (char*)trans[0], flags & SEQ_PRIVATE);
+      mu_stream_unref (clos.stream);
     }
     }
-  *p = 0;
-  write_sequence (mbox, name, new_value, flags & SEQ_PRIVATE);
-  /* FIXME
-  if (mu_c_strcasecmp (name, "cur") == 0)
-    current_message = strtoul (new_value, NULL, 0);
-  */
-  free (new_value);
 }
 }
 
 
-static int
-cmp_msgnum (const void *a, const void *b)
+void
+mh_seq_add (mu_mailbox_t mbox, const char *name, mu_msgset_t mset, int flags)
 {
 {
-  const size_t *as = a;
-  const size_t *bs = b;
-
-  if (*as < *bs)
-    return -1;
-  if (*as > *bs)
-    return 1;
-  return 0;
+  const char *value = mh_seq_read (mbox, name, flags);
+  
+  delete_sequence (mbox, name, !(flags & SEQ_PRIVATE));
+  if (value && !(flags & SEQ_ZERO))
+    {
+      mu_msgset_t oldset;
+      mh_msgset_parse_string (&oldset, mbox, value, "cur");
+      mu_msgset_add (oldset, mset);
+      save_sequence (mbox, name, oldset, flags);
+      mu_msgset_free (oldset);
+    }
+  else
+    save_sequence (mbox, name, mset, flags);
 }
 }
 
 
 int
 int
 mh_seq_delete (mu_mailbox_t mbox, const char *name,
 mh_seq_delete (mu_mailbox_t mbox, const char *name,
-	       mh_msgset_t *mset, int flags)
+	       mu_msgset_t mset, int flags)
 {
 {
   const char *value = mh_seq_read (mbox, name, flags);
   const char *value = mh_seq_read (mbox, name, flags);
-  char *new_val;
-  char *p;
-  size_t i, count;
-  struct mu_wordsplit ws;
-  
+  mu_msgset_t oldset;
+
   if (!value)
   if (!value)
     return 0;
     return 0;
-
-  if (mu_wordsplit (value, &ws, MU_WRDSF_DEFFLAGS))
-    {
-      mu_error (_("cannot split line `%s': %s"), value,
-		mu_wordsplit_strerror (&ws));
-      return 0;
-    }
-
-  for (i = 0; i < ws.ws_wordc; i++)
-    {
-      char *p;
-      size_t num = strtoul (ws.ws_wordv[i], &p, 10);
-
-      if (*p)
-	continue;
-
-      if (bsearch (&num, mset->list, mset->count, sizeof (mset->list[0]),
-		   cmp_msgnum))
-	{
-	  free (ws.ws_wordv[i]);
-	  ws.ws_wordv[i] = NULL;
-	}
-    }
-
-  new_val = xstrdup (value);
-  p = new_val;
-  count = 0;
-  for (i = 0; i < ws.ws_wordc; i++)
-    {
-      if (ws.ws_wordv[i])
-	{
-	  strcpy (p, ws.ws_wordv[i]);
-	  p += strlen (p);
-	  *p++ = ' ';
-	  count++;
-	}
-    }
-  *p = 0;
-  write_sequence (mbox, name, count > 0 ? new_val : NULL, flags & SEQ_PRIVATE);
-  mu_wordsplit_free (&ws);
-  free (new_val);
-  
+  mh_msgset_parse_string (&oldset, mbox, value, "cur");
+  mu_msgset_sub (oldset, mset);
+  save_sequence (mbox, name, oldset, flags);
+  mu_msgset_free (oldset);
   return 0;
   return 0;
 }
 }
 
 

@@ -158,7 +158,7 @@ static int width = 80;
 static char *charset;  /* Charset for output file names.  NULL means
 static char *charset;  /* Charset for output file names.  NULL means
 			  no recoding is necessary. */
 			  no recoding is necessary. */
 
 
-static mh_msgset_t msgset;
+static mu_msgset_t msgset;
 static mu_mailbox_t mbox;
 static mu_mailbox_t mbox;
 static mu_message_t message;
 static mu_message_t message;
 static msg_part_t req_part;
 static msg_part_t req_part;
@@ -1369,7 +1369,7 @@ list_handler (mu_message_t msg, msg_part_t part, char *type, char *encoding,
 }
 }
 
 
 int
 int
-list_message (mu_message_t msg, size_t num)
+list_message (mu_message_t msg)
 {
 {
   size_t uid;
   size_t uid;
   msg_part_t part;
   msg_part_t part;
@@ -1381,10 +1381,10 @@ list_message (mu_message_t msg, size_t num)
   return 0;
   return 0;
 }
 }
 
 
-void
-list_iterator (mu_mailbox_t mbox, mu_message_t msg, size_t num, void *data)
+int
+list_iterator (size_t num, mu_message_t msg, void *data)
 {
 {
-  list_message (msg, num);
+  return list_message (msg);
 }
 }
 
 
 int
 int
@@ -1396,9 +1396,9 @@ mhn_list ()
     printf (_(" msg part type/subtype              size  description\n"));
     printf (_(" msg part type/subtype              size  description\n"));
 
 
   if (message)
   if (message)
-    rc = list_message (message, 0);
+    rc = list_message (message);
   else
   else
-    rc = mh_iterate (mbox, &msgset, list_iterator, NULL);
+    rc = mu_msgset_foreach_message (msgset, list_iterator, NULL);
   return rc;
   return rc;
 }
 }
 
 
@@ -1609,8 +1609,8 @@ show_message (mu_message_t msg, size_t num, void *data)
   return 0;
   return 0;
 }
 }
 
 
-void
-show_iterator (mu_mailbox_t mbox, mu_message_t msg, size_t num, void *data)
+int
+show_iterator (size_t num, mu_message_t msg, void *data)
 {
 {
   msg_part_t part;
   msg_part_t part;
   
   
@@ -1618,6 +1618,7 @@ show_iterator (mu_mailbox_t mbox, mu_message_t msg, size_t num, void *data)
   part = msg_part_create (num);
   part = msg_part_create (num);
   show_message (msg, num, data);
   show_message (msg, num, data);
   msg_part_destroy (part);
   msg_part_destroy (part);
+  return 0;
 }
 }
 
 
 int
 int
@@ -1630,7 +1631,7 @@ mhn_show ()
   if (message)
   if (message)
     rc = show_message (message, 0, mu_strout);
     rc = show_message (message, 0, mu_strout);
   else
   else
-    rc = mh_iterate (mbox, &msgset, show_iterator, mu_strout);
+    rc = mu_msgset_foreach_message (msgset, show_iterator, mu_strout);
   mu_stream_flush (mu_strout);
   mu_stream_flush (mu_strout);
   return rc;
   return rc;
 }
 }
@@ -1855,10 +1856,11 @@ store_message (mu_message_t msg, void *data)
   msg_part_destroy (part);
   msg_part_destroy (part);
 }
 }
 
 
-void
-store_iterator (mu_mailbox_t mbox, mu_message_t msg, size_t num, void *data)
+int
+store_iterator (size_t num, mu_message_t msg, void *data)
 {
 {
   store_message (msg, data);
   store_message (msg, data);
+  return 0;
 }
 }
 
 
 int
 int
@@ -1876,7 +1878,7 @@ mhn_store ()
       store_message (message, p);
       store_message (message, p);
     }
     }
   else
   else
-    rc = mh_iterate (mbox, &msgset, store_iterator, NULL);
+    rc = mu_msgset_foreach_message (msgset, store_iterator, NULL);
   return rc;
   return rc;
 }
 }
 
 
@@ -2982,7 +2984,7 @@ main (int argc, char **argv)
   else
   else
     {
     {
       mbox = mh_open_folder (mh_current_folder (), MU_STREAM_READ);
       mbox = mh_open_folder (mh_current_folder (), MU_STREAM_READ);
-      mh_msgset_parse (mbox, &msgset, argc, argv, "cur");
+      mh_msgset_parse (&msgset, mbox, argc, argv, "cur");
     }
     }
   
   
   switch (mode)
   switch (mode)

@@ -50,13 +50,14 @@ opt_handler (int key, char *arg, struct argp_state *state)
   return 0;
   return 0;
 }
 }
 
 
-void
-mhpath (mu_mailbox_t mbox, mu_message_t msg, size_t num, void *data)
+static int
+mhpath (size_t num, mu_message_t msg, void *data)
 {
 {
   size_t uid;
   size_t uid;
-      
+  
   mh_message_number (msg, &uid);
   mh_message_number (msg, &uid);
   printf ("%s/%s\n", (char*) data, mu_umaxtostr (0, uid));
   printf ("%s/%s\n", (char*) data, mu_umaxtostr (0, uid));
+  return 0;
 }
 }
 
 
 int
 int
@@ -67,7 +68,7 @@ main (int argc, char **argv)
   mu_url_t url = NULL;
   mu_url_t url = NULL;
   char *mhdir;
   char *mhdir;
   size_t total;
   size_t total;
-  mh_msgset_t msgset;
+  mu_msgset_t msgset;
   int status;
   int status;
   const char *current_folder;
   const char *current_folder;
   
   
@@ -125,9 +126,9 @@ main (int argc, char **argv)
   /* Mhpath  expands  and  sorts  the  message  list `msgs' and
   /* Mhpath  expands  and  sorts  the  message  list `msgs' and
      writes the full pathnames of the messages to the  standard
      writes the full pathnames of the messages to the  standard
      output separated by newlines. */
      output separated by newlines. */
-  mh_msgset_parse (mbox, &msgset, argc - index, argv + index, "cur");
-  status = mh_iterate (mbox, &msgset, mhpath, mhdir);
+  mh_msgset_parse (&msgset, mbox, argc - index, argv + index, "cur");
+  status = mu_msgset_foreach_message (msgset, mhpath, mhdir);
   mu_mailbox_close (mbox);
   mu_mailbox_close (mbox);
   mu_mailbox_destroy (&mbox);
   mu_mailbox_destroy (&mbox);
-  return status;
+  return status != 0;
 }
 }

@@ -63,13 +63,19 @@ opt_handler (int key, char *arg, struct argp_state *state)
   return 0;
   return 0;
 }
 }
 
 
+static int
+_print_number (size_t n, void *data)
+{
+  printf ("%lu\n", (unsigned long) n);
+  return 0;
+}
+
 int
 int
 main (int argc, char **argv)
 main (int argc, char **argv)
 {
 {
   int index;
   int index;
   mu_mailbox_t mbox;
   mu_mailbox_t mbox;
-  mh_msgset_t msgset;
-  size_t i;
+  mu_msgset_t msgset;
     
     
   /* Native Language Support */
   /* Native Language Support */
   MU_APP_INIT_NLS ();
   MU_APP_INIT_NLS ();
@@ -82,12 +88,11 @@ main (int argc, char **argv)
   argv += index;
   argv += index;
   mbox = mh_open_folder (mh_current_folder (), MU_STREAM_READ);
   mbox = mh_open_folder (mh_current_folder (), MU_STREAM_READ);
 
 
-  mh_msgset_parse (mbox, &msgset, argc, argv, "cur");
+  mh_msgset_parse (&msgset, mbox, argc, argv, "cur");
   if (uid_option)
   if (uid_option)
-    mh_msgset_uids (mbox, &msgset);
-
-  for (i = 0; i < msgset.count; i++)
-    printf ("%lu\n", (unsigned long) msgset.list[i]);
+    mu_msgset_foreach_msguid (msgset, _print_number, NULL);
+  else
+    mu_msgset_foreach_msgno (msgset, _print_number, NULL);
   return 0;
   return 0;
 }
 }
 
 

@@ -21,9 +21,6 @@
 #include <regex.h>
 #include <regex.h>
 #include <pick.h>
 #include <pick.h>
 #include <pick-gram.h>
 #include <pick-gram.h>
-#define obstack_chunk_alloc malloc
-#define obstack_chunk_free free
-#include <obstack.h>
 
 
 static char doc[] = N_("GNU MH pick")"\v"
 static char doc[] = N_("GNU MH pick")"\v"
 N_("Compatibility syntax for picking a matching component is:\n\
 N_("Compatibility syntax for picking a matching component is:\n\
@@ -146,8 +143,7 @@ static mu_list_t seq_list;  /* List of sequence names to operate upon */
 
 
 static mu_list_t lexlist;   /* List of input tokens */
 static mu_list_t lexlist;   /* List of input tokens */
 
 
-static struct obstack msgno_stk; /* Stack of selected message numbers */
-static size_t msgno_count;       /* Number of items on the stack */
+static mu_msgset_t picked_message_uids;
 
 
 static void
 static void
 add_sequence (char *name)
 add_sequence (char *name)
@@ -282,34 +278,26 @@ opt_handler (int key, char *arg, struct argp_state *state)
   return 0;
   return 0;
 }
 }
 
 
-void
-pick_message (mu_mailbox_t mbox, mu_message_t msg, size_t num, void *data)
+static int
+pick_message (size_t num, mu_message_t msg, void *data)
 {
 {
   if (pick_eval (msg))
   if (pick_eval (msg))
     {
     {
       mh_message_number (msg, &num);
       mh_message_number (msg, &num);
       if (list)
       if (list)
 	printf ("%s\n", mu_umaxtostr (0, num));
 	printf ("%s\n", mu_umaxtostr (0, num));
-      if (seq_list)
-	{
-	  obstack_grow (&msgno_stk, &num, sizeof (num));
-	  msgno_count++;
-	}
+      if (picked_message_uids)
+	mu_msgset_add_range (picked_message_uids, num, num, MU_MSGSET_UID);
     }
     }
+  return 0;
 }
 }
 
 
 
 
-struct pick_closure
-{
-  mu_mailbox_t mbox;
-  mh_msgset_t *msgset;
-};
-
 static int
 static int
 action_add (void *item, void *data)
 action_add (void *item, void *data)
 {
 {
-  struct pick_closure *clos = data;
-  mh_seq_add (clos->mbox, (char *)item, clos->msgset, seq_flags);
+  mu_mailbox_t mbox = data;
+  mh_seq_add (mbox, (char *)item, picked_message_uids, seq_flags);
   return 0;
   return 0;
 }
 }
 
 
@@ -356,7 +344,7 @@ main (int argc, char **argv)
   int status;
   int status;
   int index;
   int index;
   mu_mailbox_t mbox;
   mu_mailbox_t mbox;
-  mh_msgset_t msgset;
+  mu_msgset_t msgset;
   int interactive = mh_interactive_mode_p ();
   int interactive = mh_interactive_mode_p ();
 
 
   MU_APP_INIT_NLS ();
   MU_APP_INIT_NLS ();
@@ -397,21 +385,13 @@ main (int argc, char **argv)
   argv += index;
   argv += index;
 
 
   if (seq_list)
   if (seq_list)
-    obstack_init (&msgno_stk);
+    mu_msgset_create (&picked_message_uids, NULL, MU_MSGSET_UID);
   
   
-  mh_msgset_parse (mbox, &msgset, argc, argv, "all");
-  status = mh_iterate (mbox, &msgset, pick_message, NULL);
+  mh_msgset_parse (&msgset, mbox, argc, argv, "all");
+  status = mu_msgset_foreach_message (msgset, pick_message, NULL);
 
 
-  if (seq_list)
-    {
-      struct pick_closure clos;
-      mh_msgset_t msgset;
-      msgset.count = msgno_count;
-      msgset.list = obstack_finish (&msgno_stk);
-      clos.mbox = mbox;
-      clos.msgset = &msgset;
-      mu_list_foreach (seq_list, action_add, &clos);
-    }
+  if (picked_message_uids)
+    mu_list_foreach (seq_list, action_add, mbox);
 
 
   mh_global_save_state ();
   mh_global_save_state ();
   mu_mailbox_close (mbox);
   mu_mailbox_close (mbox);

@@ -201,8 +201,8 @@ refile (mu_message_t msg)
   enumerate_folders (refile_folder, msg);
   enumerate_folders (refile_folder, msg);
 }
 }
 
 
-void
-refile_iterator (mu_mailbox_t mbox, mu_message_t msg, size_t num, void *data)
+int
+refile_iterator (size_t num, mu_message_t msg, void *data)
 {
 {
   enumerate_folders (refile_folder, msg);
   enumerate_folders (refile_folder, msg);
   if (!link_flag)
   if (!link_flag)
@@ -211,13 +211,14 @@ refile_iterator (mu_mailbox_t mbox, mu_message_t msg, size_t num, void *data)
       mu_message_get_attribute (msg, &attr);
       mu_message_get_attribute (msg, &attr);
       mu_attribute_set_deleted (attr);
       mu_attribute_set_deleted (attr);
     }
     }
+  return 0;
 }
 }
 
 
 int
 int
 main (int argc, char **argv)
 main (int argc, char **argv)
 {
 {
   int index;
   int index;
-  mh_msgset_t msgset;
+  mu_msgset_t msgset;
   mu_mailbox_t mbox;
   mu_mailbox_t mbox;
   int status, i, j;
   int status, i, j;
 
 
@@ -262,9 +263,9 @@ main (int argc, char **argv)
   else
   else
     {
     {
       mbox = mh_open_folder (mh_current_folder (), MU_STREAM_RDWR);
       mbox = mh_open_folder (mh_current_folder (), MU_STREAM_RDWR);
-      mh_msgset_parse (mbox, &msgset, argc, argv, "cur");
+      mh_msgset_parse (&msgset, mbox, argc, argv, "cur");
 
 
-      status = mh_iterate (mbox, &msgset, refile_iterator, NULL);
+      status = mu_msgset_foreach_message (msgset, refile_iterator, NULL);
  
  
       mu_mailbox_expunge (mbox);
       mu_mailbox_expunge (mbox);
       mu_mailbox_close (mbox);
       mu_mailbox_close (mbox);

@@ -112,7 +112,7 @@ static int width = 80;
 struct mh_whatnow_env wh_env = { 0 };
 struct mh_whatnow_env wh_env = { 0 };
 static int initial_edit = 1;
 static int initial_edit = 1;
 static const char *whatnowproc;
 static const char *whatnowproc;
-static mh_msgset_t msgset;
+static mu_msgset_t msgset;
 static mu_mailbox_t mbox;
 static mu_mailbox_t mbox;
 static int build_only = 0; /* --build flag */
 static int build_only = 0; /* --build flag */
 static int query_mode = 0; /* --query flag */
 static int query_mode = 0; /* --query flag */
@@ -281,6 +281,7 @@ make_draft (mu_mailbox_t mbox, int disp, struct mh_whatnow_env *wh)
   int rc;
   int rc;
   mu_message_t msg;
   mu_message_t msg;
   struct stat st;
   struct stat st;
+  size_t msgno;
   
   
   /* First check if the draft exists */
   /* First check if the draft exists */
   if (!build_only && stat (wh->draftfile, &st) == 0)
   if (!build_only && stat (wh->draftfile, &st) == 0)
@@ -309,12 +310,13 @@ make_draft (mu_mailbox_t mbox, int disp, struct mh_whatnow_env *wh)
       unlink (wh->draftfile);
       unlink (wh->draftfile);
       break;  
       break;  
     }
     }
-  
-  rc = mu_mailbox_get_message (mbox, msgset.list[0], &msg);
+
+  msgno = mh_msgset_first (msgset);
+  rc = mu_mailbox_get_message (mbox, msgno, &msg);
   if (rc)
   if (rc)
     {
     {
       mu_error (_("cannot read message %s: %s"),
       mu_error (_("cannot read message %s: %s"),
-		mu_umaxtostr (0, msgset.list[0]),
+		mu_umaxtostr (0, msgno),
 		mu_strerror (rc));
 		mu_strerror (rc));
       exit (1);
       exit (1);
     }
     }
@@ -349,11 +351,11 @@ make_draft (mu_mailbox_t mbox, int disp, struct mh_whatnow_env *wh)
 	  mu_message_get_header (tmp_msg, &hdr);
 	  mu_message_get_header (tmp_msg, &hdr);
 	  text = obstack_finish (&fcc_stack);
 	  text = obstack_finish (&fcc_stack);
 	  mu_header_set_value (hdr, MU_HEADER_FCC, text, 0);
 	  mu_header_set_value (hdr, MU_HEADER_FCC, text, 0);
-	  mh_format (&format, tmp_msg, msgset.list[0], width, &buf);
+	  mh_format (&format, tmp_msg, msgno, width, &buf);
 	  mu_message_destroy (&tmp_msg, NULL);
 	  mu_message_destroy (&tmp_msg, NULL);
 	}
 	}
       else
       else
-	mh_format (&format, msg, msgset.list[0], width, &buf);
+	mh_format (&format, msg, msgno, width, &buf);
       
       
       mu_stream_write (str, buf, strlen (buf), NULL);
       mu_stream_write (str, buf, strlen (buf), NULL);
 
 
@@ -409,8 +411,8 @@ main (int argc, char **argv)
     }
     }
 
 
   mbox = mh_open_folder (mh_current_folder (), MU_STREAM_RDWR);
   mbox = mh_open_folder (mh_current_folder (), MU_STREAM_RDWR);
-  mh_msgset_parse (mbox, &msgset, argc - index, argv + index, "cur");
-  if (msgset.count != 1)
+  mh_msgset_parse (&msgset, mbox, argc - index, argv + index, "cur");
+  if (!mh_msgset_single_message (msgset))
     {
     {
       mu_error (_("only one message at a time!"));
       mu_error (_("only one message at a time!"));
       return 1;
       return 1;

@@ -50,12 +50,13 @@ opt_handler (int key, char *arg, struct argp_state *state)
   return 0;
   return 0;
 }
 }
 
 
-void
-rmm (mu_mailbox_t mbox, mu_message_t msg, size_t num, void *data)
+static int
+rmm (size_t num, mu_message_t msg, void *data)
 {
 {
   mu_attribute_t attr;
   mu_attribute_t attr;
   mu_message_get_attribute (msg, &attr);
   mu_message_get_attribute (msg, &attr);
   mu_attribute_set_deleted (attr);
   mu_attribute_set_deleted (attr);
+  return 0;
 }
 }
 
 
 int
 int
@@ -63,7 +64,7 @@ main (int argc, char **argv)
 {
 {
   int index = 0;
   int index = 0;
   mu_mailbox_t mbox;
   mu_mailbox_t mbox;
-  mh_msgset_t msgset;
+  mu_msgset_t msgset;
   int status;
   int status;
 
 
   /* Native Language Support */
   /* Native Language Support */
@@ -75,9 +76,9 @@ main (int argc, char **argv)
 
 
   mbox = mh_open_folder (mh_current_folder (), MU_STREAM_RDWR);
   mbox = mh_open_folder (mh_current_folder (), MU_STREAM_RDWR);
 
 
-  mh_msgset_parse (mbox, &msgset, argc - index, argv + index, "cur");
+  mh_msgset_parse (&msgset, mbox, argc - index, argv + index, "cur");
 
 
-  status = mh_iterate (mbox, &msgset, rmm, NULL);
+  status = mu_msgset_foreach_message (msgset, rmm, NULL);
 
 
   mu_mailbox_expunge (mbox);
   mu_mailbox_expunge (mbox);
   mu_mailbox_close (mbox);
   mu_mailbox_close (mbox);

@@ -75,9 +75,9 @@ static int header;
 
 
 static mh_format_t format;
 static mh_format_t format;
 
 
-static mh_msgset_t msgset;
+static mu_msgset_t msgset;
 
 
-void list_message (mu_mailbox_t mbox, mu_message_t msg, size_t num, void *data);
+static int list_message (size_t num, mu_message_t msg, void *data);
 void print_header (mu_mailbox_t mbox);
 void print_header (mu_mailbox_t mbox);
 void clear_screen (void);
 void clear_screen (void);
 
 
@@ -153,7 +153,7 @@ action (mu_observer_t o, size_t type, void *data, void *action_data)
       counter++;
       counter++;
       mu_mailbox_get_message (mbox, counter, &msg);
       mu_mailbox_get_message (mbox, counter, &msg);
       mh_message_number (msg, &num);
       mh_message_number (msg, &num);
-      list_message (mbox, msg, num, NULL);
+      list_message (num, msg, NULL);
     }
     }
   return 0;
   return 0;
 }
 }
@@ -201,13 +201,11 @@ main (int argc, char **argv)
   else
   else
     {
     {
       mu_mailbox_messages_count (mbox, &total);
       mu_mailbox_messages_count (mbox, &total);
-      mh_msgset_parse (mbox, &msgset, argc, argv, "all");
-
-      if (reverse)
-	mh_msgset_reverse (&msgset);
+      mh_msgset_parse (&msgset, mbox, argc, argv, "all");
 
 
       print_header (mbox);
       print_header (mbox);
-      status = mh_iterate (mbox, &msgset, list_message, NULL);
+      status = mu_msgset_foreach_dir_message (msgset, reverse,
+					      list_message, NULL);
     }
     }
 
 
   if (total == 0)
   if (total == 0)
@@ -282,8 +280,8 @@ clear_screen ()
     }
     }
 }
 }
 
 
-void
-list_message (mu_mailbox_t mbox, mu_message_t msg, size_t num, void *data)
+static int
+list_message (size_t num, mu_message_t msg, void *data)
 {
 {
   char *buffer;
   char *buffer;
   int len;
   int len;
@@ -294,4 +292,5 @@ list_message (mu_mailbox_t mbox, mu_message_t msg, size_t num, void *data)
   if (len > 0 && buffer[len-1] != '\n')
   if (len > 0 && buffer[len-1] != '\n')
     printf("\n");
     printf("\n");
   free (buffer);
   free (buffer);
+  return 0;
 }
 }

@@ -737,6 +737,27 @@ _action_send (void *item, void *data)
   return 0;
   return 0;
 }
 }
 
 
+static int
+_add_to_mesg_list (size_t num, mu_message_t msg, void *data)
+{
+  char const *path = data;
+  struct list_elt *elt;
+  size_t uid;
+  int rc;
+  
+  elt = xmalloc (sizeof *elt);
+  elt->msg = msg;
+  mu_message_get_uid (msg, &uid);
+  elt->file_name = mu_make_file_name (path, mu_umaxtostr (0, uid));
+  rc = mu_list_append (mesg_list, elt);
+  if (rc)
+    {
+      mu_diag_funcall (MU_DIAG_ERROR, "mu_list_append", NULL, rc);
+      exit (1);
+    }
+  return 0;
+}
+
 int
 int
 main (int argc, char **argv)
 main (int argc, char **argv)
 {
 {
@@ -758,13 +779,12 @@ main (int argc, char **argv)
 
 
   if (draftfolder)
   if (draftfolder)
     {
     {
-      mh_msgset_t msgset;
+      mu_msgset_t msgset;
       mu_url_t url;
       mu_url_t url;
       const char *path;
       const char *path;
-      size_t i;
       
       
       mbox = mh_open_folder (draftfolder, MU_STREAM_RDWR|MU_STREAM_CREAT);
       mbox = mh_open_folder (draftfolder, MU_STREAM_RDWR|MU_STREAM_CREAT);
-      mh_msgset_parse (mbox, &msgset, argc, argv, draftmessage);
+      mh_msgset_parse (&msgset, mbox, argc, argv, draftmessage);
       mu_mailbox_get_url (mbox, &url);
       mu_mailbox_get_url (mbox, &url);
       mu_url_sget_path (url, &path);
       mu_url_sget_path (url, &path);
       if ((rc = mu_list_create (&mesg_list)))
       if ((rc = mu_list_create (&mesg_list)))
@@ -772,25 +792,9 @@ main (int argc, char **argv)
 	  mu_error (_("cannot create message list: %s"), mu_strerror (rc));
 	  mu_error (_("cannot create message list: %s"), mu_strerror (rc));
 	  exit (1);
 	  exit (1);
 	}
 	}
-      for (i = 0; i < msgset.count; i++)
-	{
-	  struct list_elt *elt;
-	  size_t uid;
-	  
-	  elt = xmalloc (sizeof *elt);
-	  mu_mailbox_get_message (mbox, msgset.list[i], &elt->msg);
-	  mu_message_get_uid (elt->msg, &uid);
-	  elt->file_name =
-	    mu_make_file_name (path, mu_umaxtostr (0, uid));
-	  rc = mu_list_append (mesg_list, elt);
-	  if (rc)
-	    {
-	      mu_diag_funcall (MU_DIAG_ERROR, "mu_list_append", NULL, rc);
-	      exit (1);
-	    }
-	}
+      mu_msgset_foreach_message (msgset, _add_to_mesg_list, (void*)path);
       
       
-      mh_msgset_free (&msgset);
+      mu_msgset_free (msgset);
     }
     }
   else
   else
     {
     {

@@ -92,7 +92,10 @@ static int limit;
 static int verbose;
 static int verbose;
 static mu_mailbox_t mbox;
 static mu_mailbox_t mbox;
 static const char *mbox_path;
 static const char *mbox_path;
-static mh_msgset_t msgset;
+
+static size_t *msgarr;
+static size_t msgcount;
+
 static size_t current_num;
 static size_t current_num;
 
 
 #define ACTION_REORDER   0
 #define ACTION_REORDER   0
@@ -416,17 +419,17 @@ shell_sort ()
     int h, s, i, j;
     int h, s, i, j;
     size_t hold;
     size_t hold;
 
 
-    for (h = startdst (msgset.count, &s); s > 0; s--, h = prevdst (h))
+    for (h = startdst (msgcount, &s); s > 0; s--, h = prevdst (h))
       {
       {
 	if (verbose > 1)
 	if (verbose > 1)
 	  fprintf (stderr, _("distance %d\n"), h);
 	  fprintf (stderr, _("distance %d\n"), h);
-        for (j = h; j < msgset.count; j++)
+        for (j = h; j < msgcount; j++)
 	  {
 	  {
-            hold = msgset.list[j];
+            hold = msgarr[j];
             for (i = j - h;
             for (i = j - h;
-		 i >= 0 && comp0 (hold, msgset.list[i]) < 0; i -= h)
-	      msgset.list[i + h] = msgset.list[i];
-	    msgset.list[i + h] = hold;
+		 i >= 0 && comp0 (hold, msgarr[i]) < 0; i -= h)
+	      msgarr[i + h] = msgarr[i];
+	    msgarr[i + h] = hold;
 	  }
 	  }
       }
       }
 }
 }
@@ -467,12 +470,12 @@ transpose(size_t i, size_t n)
 {
 {
   size_t j;
   size_t j;
 
 
-  for (j = i+1; j < msgset.count; j++)
-    if (msgset.list[j] == n)
+  for (j = i+1; j < msgcount; j++)
+    if (msgarr[j] == n)
       {
       {
-	size_t t = msgset.list[i];
-	msgset.list[i] = msgset.list[j];
-	msgset.list[j] = t;
+	size_t t = msgarr[i];
+	msgarr[i] = msgarr[j];
+	msgarr[j] = t;
 	break;
 	break;
       }
       }
 }
 }
@@ -489,26 +492,25 @@ void
 sort ()
 sort ()
 {
 {
   size_t *oldlist, i;
   size_t *oldlist, i;
-  oldlist = xmalloc (msgset.count * sizeof (*oldlist));
-  memcpy (oldlist, msgset.list, msgset.count * sizeof (*oldlist));
+  oldlist = xmalloc (msgcount * sizeof (*oldlist));
+  memcpy (oldlist, msgarr, msgcount * sizeof (*oldlist));
 
 
   switch (algorithm)
   switch (algorithm)
     {
     {
     case ARG_QUICKSORT:
     case ARG_QUICKSORT:
-      qsort(msgset.list, msgset.count, sizeof (msgset.list[0]),
-	    comp);
+      qsort (msgarr, msgcount, sizeof (msgarr[0]), comp);
       break;
       break;
 
 
     case ARG_SHELL:
     case ARG_SHELL:
-      shell_sort();
+      shell_sort ();
       break;
       break;
     }
     }
 
 
   switch (action)
   switch (action)
     {
     {
     case ACTION_LIST:
     case ACTION_LIST:
-      for (i = 0; i < msgset.count; i++)
-	list_message (msgset.list[i]);
+      for (i = 0; i < msgcount; i++)
+	list_message (msgarr[i]);
       break;
       break;
 
 
     default:
     default:
@@ -519,16 +521,16 @@ sort ()
       
       
       if (verbose)
       if (verbose)
 	fprintf (stderr, _("Transpositions:\n"));
 	fprintf (stderr, _("Transpositions:\n"));
-      for (i = 0, got_signal = 0; !got_signal && i < msgset.count; i++)
+      for (i = 0, got_signal = 0; !got_signal && i < msgcount; i++)
 	{
 	{
-	  if (msgset.list[i] != oldlist[i])
+	  if (msgarr[i] != oldlist[i])
 	    {
 	    {
 	      size_t old_num, new_num;
 	      size_t old_num, new_num;
 	      mu_message_t msg;
 	      mu_message_t msg;
 
 
 	      mu_mailbox_get_message (mbox, oldlist[i], &msg);
 	      mu_mailbox_get_message (mbox, oldlist[i], &msg);
 	      mh_message_number (msg, &old_num);
 	      mh_message_number (msg, &old_num);
-	      mu_mailbox_get_message (mbox, msgset.list[i], &msg);
+	      mu_mailbox_get_message (mbox, msgarr[i], &msg);
 	      mh_message_number (msg, &new_num);
 	      mh_message_number (msg, &new_num);
 	      transpose (i, oldlist[i]);
 	      transpose (i, oldlist[i]);
 	      if (verbose)
 	      if (verbose)
@@ -563,6 +565,38 @@ sort ()
       mh_mailbox_set_cur (mbox, current_num);
       mh_mailbox_set_cur (mbox, current_num);
     }
     }
 }
 }
+
+static int
+_add_msgno (size_t n, void *data)
+{
+  size_t *pidx = data;
+  msgarr[*pidx] = n;
+  ++*pidx;
+  return 0;
+}
+
+static void
+fill_msgarr (mu_msgset_t msgset)
+{
+  size_t i;
+  int rc;
+  
+  rc = mu_msgset_count (msgset, &msgcount);
+  if (rc)
+    {
+      mu_diag_funcall (MU_DIAG_ERROR, "mu_msgset_count", NULL, rc);
+      exit (1);
+    }
+      
+  msgarr = xcalloc (msgcount, sizeof (msgarr[0]));
+  i = 0;
+  rc = mu_msgset_foreach_msgno (msgset, _add_msgno, &i);
+  if (rc)
+    {
+      mu_diag_funcall (MU_DIAG_ERROR, "mu_msgset_foreach_msgno", NULL, rc);
+      exit (1);
+    }
+}
 
 
 
 
 /* Main */
 /* Main */
@@ -572,6 +606,7 @@ main (int argc, char **argv)
 {
 {
   int index;
   int index;
   mu_url_t url;
   mu_url_t url;
+  mu_msgset_t msgset;
   
   
   MU_APP_INIT_NLS ();
   MU_APP_INIT_NLS ();
   mh_argp_init ();
   mh_argp_init ();
@@ -597,7 +632,9 @@ main (int argc, char **argv)
 
 
   mh_mailbox_get_cur (mbox, &current_num);
   mh_mailbox_get_cur (mbox, &current_num);
 
 
-  mh_msgset_parse (mbox, &msgset, argc, argv, "all");
+  mh_msgset_parse (&msgset, mbox, argc, argv, "all");
+  fill_msgarr (msgset);
+  mu_msgset_free (msgset);
   sort ();
   sort ();
   mh_global_save_state ();
   mh_global_save_state ();
   mu_mailbox_destroy (&mbox);
   mu_mailbox_destroy (&mbox);

@@ -25,7 +25,7 @@ mark -sequence andro -add 3-5
 sed -n '/^andro:/{s/  */ /g;s/ $//;p;}' Mail/inbox/.mh_sequences
 sed -n '/^andro:/{s/  */ /g;s/ $//;p;}' Mail/inbox/.mh_sequences
 ],
 ],
 [0],
 [0],
-[andro: 2 3 4 5
+[andro: 2-5
 ])
 ])
 
 
 MH_CHECK([mark -add -zero],[mark01 mark-add-zero],[
 MH_CHECK([mark -add -zero],[mark01 mark-add-zero],[
@@ -48,7 +48,7 @@ mark -nopublic -sequence andro -add 1 2 3
 sed -n '/^atr-andro/{s/  */ /g;s/ $//;s/^[[^:]]*:/atr-andro:/;p;}' Mail/context
 sed -n '/^atr-andro/{s/  */ /g;s/ $//;s/^[[^:]]*:/atr-andro:/;p;}' Mail/context
 ],
 ],
 [0],
 [0],
-[atr-andro: 1 2 3
+[atr-andro: 1-3
 ])
 ])
 
 
 MH_CHECK([mark -del],[mark03 mark-del],[
 MH_CHECK([mark -del],[mark03 mark-del],[
@@ -67,7 +67,7 @@ MUT_MBCOPY($abs_top_srcdir/testsuite/mh/mbox1,[Mail/inbox])
 echo 'Current-Folder: inbox' > Mail/context
 echo 'Current-Folder: inbox' > Mail/context
 inbox=`pwd`/Mail/inbox
 inbox=`pwd`/Mail/inbox
 cat > Mail/context <<EOT
 cat > Mail/context <<EOT
-atr-andro-$inbox: 2 3 4 5
+atr-andro-$inbox: 2-5
 EOT
 EOT
 mark -nopublic -sequence andro -del 3
 mark -nopublic -sequence andro -del 3
 sed -n '/^atr-andro/{s/  */ /g;s/ $//;s/^[[^:]]*:/atr-andro:/;p;}' Mail/context
 sed -n '/^atr-andro/{s/  */ /g;s/ $//;s/^[[^:]]*:/atr-andro:/;p;}' Mail/context

@@ -17,6 +17,13 @@
 
 
 #include <mh.h>
 #include <mh.h>
 
 
+static int
+_add_to_list (size_t num, mu_message_t msg, void *data)
+{
+  mu_list_t list = data;
+  return mu_list_append (list, msg);
+}
+
 void
 void
 mh_whatnow_env_from_environ (struct mh_whatnow_env *wh)
 mh_whatnow_env_from_environ (struct mh_whatnow_env *wh)
 {
 {
@@ -39,38 +46,15 @@ mh_whatnow_env_from_environ (struct mh_whatnow_env *wh)
 	    wh->anno_field = NULL;
 	    wh->anno_field = NULL;
 	  else
 	  else
 	    {
 	    {
-	      size_t i;
-	      struct mu_wordsplit ws;
-	      mh_msgset_t msgset;
+	      mu_msgset_t msgset;
 	      mu_mailbox_t mbox = mh_open_folder (folder, MU_STREAM_RDWR);
 	      mu_mailbox_t mbox = mh_open_folder (folder, MU_STREAM_RDWR);
 	      
 	      
-	      if (mu_wordsplit (p, &ws,
-				MU_WRDSF_DEFFLAGS & ~MU_WRDSF_CESCAPES))
-		{
-		  mu_error (_("cannot parse mhmessages (%s): %s"), p,
-			    mu_wordsplit_strerror (&ws));
-		  exit (1);
-		}
-	      mh_msgset_parse (mbox, &msgset, ws.ws_wordc, ws.ws_wordv, "cur");
-	      mu_wordsplit_free (&ws);
+	      mh_msgset_parse_string (&msgset, mbox, p, "cur");
 
 
 	      wh->mbox = mbox;
 	      wh->mbox = mbox;
 	      mu_list_create (&wh->anno_list);
 	      mu_list_create (&wh->anno_list);
-	      for (i = 0; i < msgset.count; i++)
-		{
-		  mu_message_t msg;
-		  int rc = mu_mailbox_get_message (mbox, msgset.list[i], &msg);
-		  if (rc)
-		    {
-		      mu_error (_("cannot get message %lu from %s: %s"),
-				(unsigned long) msgset.list[i],
-				folder,
-				mu_strerror (rc));
-		      continue;
-		    }
-		  mu_list_append (wh->anno_list, msg);
-		}
-	      mh_msgset_free (&msgset);
+	      mu_msgset_foreach_message (msgset, _add_to_list, wh->anno_list);
+	      mu_msgset_free (msgset);
 	      /* FIXME:
 	      /* FIXME:
 		 wh->anno_inplace = getenv ("mhinplace");
 		 wh->anno_inplace = getenv ("mhinplace");
 	      */
 	      */

@@ -118,13 +118,13 @@ parse_msgset (const char *arg)
   mu_msgset_t msgset;
   mu_msgset_t msgset;
   char *p;
   char *p;
   
   
-  status = mu_msgset_create (&msgset, NULL, 0);
+  status = mu_msgset_create (&msgset, NULL, MU_MSGSET_NUM);
   if (status)
   if (status)
     {
     {
       mu_diag_funcall (MU_DIAG_ERROR, "mu_msgset_create", NULL, status);
       mu_diag_funcall (MU_DIAG_ERROR, "mu_msgset_create", NULL, status);
       return NULL;
       return NULL;
     }
     }
-  status = mu_msgset_parse_imap (msgset, arg, &p);
+  status = mu_msgset_parse_imap (msgset, MU_MSGSET_NUM, arg, &p);
   if (status)
   if (status)
     {
     {
       mu_error (_("failed to parse message set near \"%s\": %s"),
       mu_error (_("failed to parse message set near \"%s\": %s"),

@@ -19,7 +19,7 @@
 #include <mailutils/mailutils.h>
 #include <mailutils/mailutils.h>
 
 
 static void
 static void
-parse_msgset (char *arg, struct mu_msgrange *range)
+parse_msgrange (char *arg, struct mu_msgrange *range)
 {
 {
   size_t msgnum;
   size_t msgnum;
   char *p;
   char *p;
@@ -52,14 +52,36 @@ parse_msgset (char *arg, struct mu_msgrange *range)
   range->msg_end = msgnum;
   range->msg_end = msgnum;
 }
 }
 
 
+mu_msgset_t
+parse_msgset (const char *arg, mu_mailbox_t mbox,
+	      int create_mode, int parse_mode)
+{
+  int rc;
+  mu_msgset_t msgset;
+  char *end;
+  
+  MU_ASSERT (mu_msgset_create (&msgset, mbox, create_mode));
+  if (arg)
+    {
+      rc = mu_msgset_parse_imap (msgset, parse_mode, arg, &end);
+      if (rc)
+        {
+          mu_error ("mu_msgset_parse_imap: %s near %s",
+	  	    mu_strerror (rc), end);
+          exit (1);
+        }
+    }
+  return msgset;
+}
+
 int
 int
 main (int argc, char **argv)
 main (int argc, char **argv)
 {
 {
   int i;
   int i;
   char *msgset_string = NULL;
   char *msgset_string = NULL;
   mu_msgset_t msgset;
   mu_msgset_t msgset;
-  int rc;
-  int flags = 0;
+  int create_mode = MU_MSGSET_NUM;
+  int parse_mode = MU_MSGSET_NUM;
   mu_mailbox_t mbox = NULL;
   mu_mailbox_t mbox = NULL;
   
   
   mu_set_program_name (argv[0]);
   mu_set_program_name (argv[0]);
@@ -70,14 +92,23 @@ main (int argc, char **argv)
 
 
       if (strcmp (arg, "-h") == 0 || strcmp (arg, "-help") == 0)
       if (strcmp (arg, "-h") == 0 || strcmp (arg, "-help") == 0)
 	{
 	{
-	  mu_printf ("usage: %s [-msgset=SET] [-add X[:Y]] [-del X:[Y]]...\n",
+	  mu_printf ("usage: %s [-msgset[uid]=SET] [-uid] [-add[uid]=X[:Y]] [-del[uid]=X[:Y]] "
+		     "[-addset[uid]=SET] [-delset[uid]=SET] ...\n",
 		     mu_program_name);
 		     mu_program_name);
 	  return 0;
 	  return 0;
 	}
 	}
       else if (strncmp (arg, "-msgset=", 8) == 0)
       else if (strncmp (arg, "-msgset=", 8) == 0)
-	msgset_string = arg + 8;
+	{
+	  parse_mode = MU_MSGSET_NUM;
+	  msgset_string = arg + 8;
+	}
+      else if (strncmp (arg, "-msgsetuid=", 11) == 0)
+	{
+	  parse_mode = MU_MSGSET_UID;
+	  msgset_string = arg + 11;
+	}      
       else if (strcmp (arg, "-uid") == 0)
       else if (strcmp (arg, "-uid") == 0)
-	flags |= MU_MSGSET_UID;
+	create_mode = MU_MSGSET_UID;
       else if (strncmp (arg, "-mailbox=", 9) == 0)
       else if (strncmp (arg, "-mailbox=", 9) == 0)
 	{
 	{
 	  MU_ASSERT (mu_mailbox_create (&mbox, arg + 9));
 	  MU_ASSERT (mu_mailbox_create (&mbox, arg + 9));
@@ -87,18 +118,7 @@ main (int argc, char **argv)
 	break;
 	break;
     }
     }
 
 
-  MU_ASSERT (mu_msgset_create (&msgset, mbox, flags));
-  if (msgset_string)
-    {
-      char *end;
-      rc = mu_msgset_parse_imap (msgset, msgset_string, &end);
-      if (rc)
-	{
-	  mu_error ("mu_msgset_parse_imap: %s near %s",
-		    mu_strerror (rc), end);
-	  return 1;
-	}
-    }
+  msgset = parse_msgset (msgset_string, mbox, create_mode, parse_mode);
   
   
   for (; i < argc; i++)
   for (; i < argc; i++)
     {
     {
@@ -107,15 +127,95 @@ main (int argc, char **argv)
       
       
       if (strncmp (arg, "-add=", 5) == 0)
       if (strncmp (arg, "-add=", 5) == 0)
 	{
 	{
-	  parse_msgset (arg + 5, &range);
-	  MU_ASSERT (mu_msgset_add_range (msgset, range.msg_beg,
-					  range.msg_end));
+	  parse_msgrange (arg + 5, &range);
+	  MU_ASSERT (mu_msgset_add_range (msgset,
+					  range.msg_beg, range.msg_end,
+					  MU_MSGSET_NUM));
 	}
 	}
       else if (strncmp (arg, "-sub=", 5) == 0)
       else if (strncmp (arg, "-sub=", 5) == 0)
 	{
 	{
-	  parse_msgset (arg + 5, &range);
-	  MU_ASSERT (mu_msgset_sub_range (msgset, range.msg_beg,
-					  range.msg_end));
+	  parse_msgrange (arg + 5, &range);
+	  MU_ASSERT (mu_msgset_sub_range (msgset,
+					  range.msg_beg, range.msg_end,
+					  MU_MSGSET_NUM));
+	}
+      else if (strncmp (arg, "-adduid=", 8) == 0)
+	{
+	  parse_msgrange (arg + 8, &range);
+	  MU_ASSERT (mu_msgset_add_range (msgset,
+					  range.msg_beg, range.msg_end,
+					  MU_MSGSET_UID));
+	}
+      else if (strncmp (arg, "-subuid=", 8) == 0)
+	{
+	  parse_msgrange (arg + 8, &range);
+	  MU_ASSERT (mu_msgset_sub_range (msgset,
+					  range.msg_beg, range.msg_end,
+					  MU_MSGSET_UID));
+	}
+      else if (strncmp (arg, "-addset", 7) == 0)
+	{
+	  mu_msgset_t tset;
+	  int m;
+
+	  arg += 7;
+	  if (strncmp (arg, "uid", 3) == 0)
+	    {
+	      m = MU_MSGSET_UID;
+	      arg += 3;
+	    }
+	  else
+	    m = MU_MSGSET_NUM;
+	  if (*arg == '=')
+	    arg++;
+	  else
+	    {
+	      mu_error ("unknown option %s", argv[i]);
+	      return 1;
+	    }
+	  
+	  tset = parse_msgset (arg, mbox, m, m);
+	  if (!msgset)
+	    msgset = tset;
+	  else
+	    {
+	      MU_ASSERT (mu_msgset_add (msgset, tset));
+	      mu_msgset_free (tset);
+	    }
+	}
+      else if (strncmp (arg, "-subset=", 8) == 0)
+	{
+	  mu_msgset_t tset;
+	  int m;
+
+	  arg += 7;
+	  if (strncmp (arg, "uid", 3) == 0)
+	    {
+	      m = MU_MSGSET_UID;
+	      arg += 3;
+	    }
+	  else
+	    m = MU_MSGSET_NUM;
+	  if (*arg == '=')
+	    arg++;
+	  else
+	    {
+	      mu_error ("unknown option %s", argv[i]);
+	      return 1;
+	    }
+	  
+	  tset = parse_msgset (arg, mbox, m, m);
+	  
+	  if (!msgset)
+	    {
+	      mu_error ("no initial message set");
+	      exit (1);
+	    }
+	  else
+	    {
+	      MU_ASSERT (mu_msgset_sub (msgset, tset));
+	      mu_msgset_free (tset);
+	    }
 	}
 	}
       else if (strcmp (arg, "-neg") == 0)
       else if (strcmp (arg, "-neg") == 0)
 	{
 	{