-/*
- * flist.c -- list nmh folders containing messages
+/* flist.c -- list nmh folders containing messages
* -- in a given sequence
*
* originally by
#include <h/mh.h>
#include <h/utils.h>
-
-#define FALSE 0
-#define TRUE 1
+#include "sbr/m_maildir.h"
/*
* We allocate space to record the names of folders
int priority;
int error; /* error == 1 for unreadable folder */
int nMsgs; /* number of messages in folder */
- int nSeq[NUMATTRS]; /* number of messages in each sequence */
- int private[NUMATTRS]; /* is given sequence, public or private */
+ ivector_t nSeq; /* number of messages in each sequence */
+ ivector_t private; /* is given sequence, public or private */
};
static struct Folder *orders = NULL;
static int maxfolders;
/* info on sequences to search for */
-static char *sequencesToDo[NUMATTRS];
-static unsigned int numsequences;
-
-static int all = FALSE; /* scan all folders in top level? */
-static int alphaOrder = FALSE; /* want alphabetical order only */
-static int recurse = FALSE; /* show nested folders? */
-static int showzero = TRUE; /* show folders even if no messages in seq? */
-static int Total = TRUE; /* display info on number of messages in *
+static svector_t sequencesToDo;
+
+static bool all; /* scan all folders in top level? */
+static bool alphaOrder; /* want alphabetical order only */
+static bool recurse; /* show nested folders? */
+static bool showzero = true; /* show folders even if no messages in seq? */
+static bool Total = true; /* display info on number of messages in
* sequence found, and total num messages */
static char curfolder[BUFSIZ]; /* name of the current folder */
typedef int (*qsort_comp) (const void *, const void *);
/*
- * prototypes
+ * static prototypes
*/
-int CompareFolders(struct Folder *, struct Folder *);
-void GetFolderOrder(void);
-void ScanFolders(void);
-int AddFolder(char *, int);
-void BuildFolderList(char *, int);
-void BuildFolderListRecurse(char *, struct stat *, int);
-void PrintFolders(void);
-void AllocFolders(struct Folder **, int *, int);
-int AssignPriority(char *);
+static int CompareFolders(struct Folder *, struct Folder *);
+static void GetFolderOrder(void);
+static void ScanFolders(void);
+static int AddFolder(char *, int);
+static void BuildFolderList(char *, int);
+static void BuildFolderListRecurse(char *, struct stat *, int);
+static void PrintFolders(void);
+static void AllocFolders(struct Folder **, int *, int);
+static int AssignPriority(char *);
static void do_readonly_folders(void);
char **arguments;
char buf[BUFSIZ];
-#ifdef LOCALE
- setlocale(LC_ALL, "");
-#endif
- invo_name = r1bindex(argv[0], '/');
-
- /* read user profile/context */
- context_read();
+ if (nmh_init(argv[0], 1)) { return 1; }
/*
* If program was invoked with name ending
* in `s', then add switch `-all'.
*/
- if (argv[0][strlen (argv[0]) - 1] == 's')
- all = TRUE;
+ all = has_suffix_c(argv[0], 's');
arguments = getarguments (invo_name, argc, argv, 1);
argp = arguments;
foldersToDo = (char **) mh_xmalloc ((size_t) (maxfolders * sizeof(*foldersToDo)));
/* no sequences yet */
- numsequences = 0;
+ sequencesToDo = svector_create (0);
/* parse arguments */
while ((cp = *argp++)) {
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
- /* check if too many sequences specified */
- if (numsequences >= NUMATTRS)
- adios (NULL, "too many sequences (more than %d) specified", NUMATTRS);
- sequencesToDo[numsequences++] = cp;
+ svector_push_back (sequencesToDo, cp);
break;
case ALLSW:
- all = TRUE;
+ all = true;
break;
case NOALLSW:
- all = FALSE;
+ all = false;
break;
case SHOWZERO:
- showzero = TRUE;
+ showzero = true;
break;
case NOSHOWZERO:
- showzero = FALSE;
+ showzero = false;
break;
case ALPHASW:
- alphaOrder = TRUE;
+ alphaOrder = true;
break;
case NOALPHASW:
- alphaOrder = FALSE;
+ alphaOrder = false;
break;
case NOFASTSW:
case TOTALSW:
- Total = TRUE;
+ Total = true;
break;
case FASTSW:
case NOTOTALSW:
- Total = FALSE;
+ Total = false;
break;
case RECURSE:
- recurse = TRUE;
+ recurse = true;
break;
case NORECURSE:
- recurse = FALSE;
+ recurse = false;
break;
}
} else {
/*
* If we didn't specify any sequences, we search
* for the "Unseen-Sequence" profile entry and use
- * all the sequences defined there. We check to
- * make sure that the Unseen-Sequence entry doesn't
- * contain more than NUMATTRS sequences.
+ * all the sequences defined there.
*/
- if (numsequences == 0) {
+ if (svector_size (sequencesToDo) == 0) {
if ((cp = context_find(usequence)) && *cp) {
char **ap, *dp;
- dp = getcpy(cp);
+ dp = mh_xstrdup(cp);
ap = brkstring (dp, " ", "\n");
- for (; ap && *ap; ap++) {
- if (numsequences >= NUMATTRS)
- adios (NULL, "too many sequences (more than %d) in %s profile entry",
- NUMATTRS, usequence);
- else
- sequencesToDo[numsequences++] = *ap;
- }
+ for (; ap && *ap; ap++)
+ svector_push_back (sequencesToDo, *ap);
} else {
adios (NULL, "no sequence specified or %s profile entry found", usequence);
}
ScanFolders();
qsort(folders, nFolders, sizeof(struct Folder), (qsort_comp) CompareFolders);
PrintFolders();
+ svector_free (sequencesToDo);
done (0);
return 1;
}
* how to sort folders for output.
*/
-void
+static void
GetFolderOrder(void)
{
- unsigned char *p, *s;
+ char *p, *s;
int priority = 1;
struct Folder *o;
if (!(p = context_find("Flist-Order")))
return;
for (;;) {
- while (isspace(*p))
+ while (isspace((unsigned char) *p))
++p;
s = p;
- while (*p && !isspace(*p))
+ while (*p && !isspace((unsigned char) *p))
++p;
if (p != s) {
/* Found one. */
* Scan all the necessary folders
*/
-void
+static void
ScanFolders(void)
{
int i;
* the top of our search tree.
*/
-void
+static void
BuildFolderList(char *dirName, int searchdepth)
{
struct stat st;
* Recursive building of folder list
*/
-void
+static void
BuildFolderListRecurse(char *dirName, struct stat *s, int searchdepth)
{
char *base, name[PATH_MAX];
- unsigned char *n;
+ char *n;
int nlinks;
DIR *dir;
struct dirent *dp;
/* Check to see if the name of the file is a number
* if it is, we assume it's a mail file and skip it
*/
- for (n = dp->d_name; *n && isdigit(*n); n++);
+ for (n = dp->d_name; isdigit((unsigned char)*n); n++);
if (!*n)
continue;
strncpy (name, base, sizeof(name) - 2);
* messages and the number of messages in each sequence.
*/
-int
+static int
AddFolder(char *name, int force)
{
unsigned int i;
int msgnum, nonzero;
- int seqnum[NUMATTRS], nSeq[NUMATTRS];
+ ivector_t seqnum = ivector_create (0), nSeq = ivector_create (0);
struct Folder *f;
struct msgs *mp;
+ char *cp;
/* Read folder and create message structure */
- if (!(mp = folder_read (name))) {
+ if (!(mp = folder_read (name, 0))) {
/* Oops, error occurred. Record it and continue. */
AllocFolders(&folders, &nFoldersAlloced, nFolders + 1);
f = &folders[nFolders++];
- f->name = getcpy(name);
+ f->name = mh_xstrdup(name);
f->error = 1;
f->priority = AssignPriority(f->name);
return 0;
}
- for (i = 0; i < numsequences; i++) {
+ for (i = 0; i < svector_size (sequencesToDo); i++) {
/* Convert sequences to their sequence numbers */
- if (sequencesToDo[i])
- seqnum[i] = seq_getnum(mp, sequencesToDo[i]);
+ if ((cp = svector_at (sequencesToDo, i)))
+ ivector_push_back (seqnum, seq_getnum(mp, cp));
else
- seqnum[i] = -1;
+ ivector_push_back (seqnum, -1);
/* Now count messages in this sequence */
- nSeq[i] = 0;
- if (mp->nummsg > 0 && seqnum[i] != -1) {
+ ivector_push_back (nSeq, 0);
+ if (mp->nummsg > 0 && ivector_at (seqnum, i) != -1) {
for (msgnum = mp->lowmsg; msgnum <= mp->hghmsg; msgnum++) {
- if (in_sequence(mp, seqnum[i], msgnum))
- nSeq[i]++;
+ if (in_sequence(mp, ivector_at (seqnum, i), msgnum))
+ (*ivector_atp (nSeq, i))++;
}
}
}
/* Check if any of the sequence checks were nonzero */
nonzero = 0;
- for (i = 0; i < numsequences; i++) {
- if (nSeq[i] > 0) {
+ for (i = 0; i < svector_size (sequencesToDo); i++) {
+ if (ivector_at (nSeq, i) > 0) {
nonzero = 1;
break;
}
/* save general folder information */
AllocFolders(&folders, &nFoldersAlloced, nFolders + 1);
f = &folders[nFolders++];
- f->name = getcpy(name);
+ f->name = mh_xstrdup(name);
f->nMsgs = mp->nummsg;
+ f->nSeq = ivector_create (0);
+ f->private = ivector_create (0);
f->error = 0;
f->priority = AssignPriority(f->name);
/* record the sequence information */
- for (i = 0; i < numsequences; i++) {
- f->nSeq[i] = nSeq[i];
- f->private[i] = (seqnum[i] != -1) ? is_seq_private(mp, seqnum[i]) : 0;
+ for (i = 0; i < svector_size (sequencesToDo); i++) {
+ *ivector_atp (f->nSeq, i) = ivector_at (nSeq, i);
+ ivector_push_back (f->private,
+ ivector_at (seqnum, i) != -1
+ ? is_seq_private(mp, ivector_at (seqnum, i))
+ : 0);
}
}
+ ivector_free (nSeq);
+ ivector_free (seqnum);
folder_free (mp); /* free folder/message structure */
return 1;
}
* Print the folder/sequence information
*/
-void
+static void
PrintFolders(void)
{
char tmpname[BUFSIZ];
if (!Total) {
for (i = 0; i < nFolders; i++)
- printf("%s\n", folders[i].name);
+ puts(folders[i].name);
return;
}
if (folders[i].nMsgs > maxnum)
maxnum = folders[i].nMsgs;
- for (j = 0; j < numsequences; j++) {
+ for (j = 0; j < svector_size (sequencesToDo); j++) {
/* find maximum width of sequence name */
- len = strlen (sequencesToDo[j]);
- if ((folders[i].nSeq[j] > 0 || showzero) && (len > maxseqlen))
+ len = strlen (svector_at (sequencesToDo, j));
+ if ((ivector_at (folders[i].nSeq, j) > 0 || showzero) &&
+ (len > maxseqlen))
maxseqlen = len;
/* find the maximum number of messages in sequence */
- if (folders[i].nSeq[j] > maxseq)
- maxseq = folders[i].nSeq[j];
+ if (ivector_at (folders[i].nSeq, j) > maxseq)
+ maxseq = ivector_at (folders[i].nSeq, j);
/* check if this sequence is private in any of the folders */
- if (folders[i].private[j])
+ if (ivector_at (folders[i].private, j))
has_private = 1;
}
}
/* Now print all the folder/sequence information */
for (i = 0; i < nFolders; i++) {
- for (j = 0; j < numsequences; j++) {
- if (folders[i].nSeq[j] > 0 || showzero) {
+ for (j = 0; j < svector_size (sequencesToDo); j++) {
+ if (ivector_at (folders[i].nSeq, j) > 0 || showzero) {
/* Add `+' to end of name of current folder */
if (strcmp(curfolder, folders[i].name))
snprintf(tmpname, sizeof(tmpname), "%s", folders[i].name);
printf("%-*s has %*d in sequence %-*s%s; out of %*d\n",
maxfolderlen+1, tmpname,
- num_digits(maxseq), folders[i].nSeq[j],
- maxseqlen, sequencesToDo[j],
- !has_private ? "" : folders[i].private[j] ? " (private)" : " ",
+ num_digits(maxseq), ivector_at (folders[i].nSeq, j),
+ maxseqlen, svector_at (sequencesToDo, j),
+ !has_private ? "" : ivector_at (folders[i].private, j)
+ ? " (private)" : " ",
num_digits(maxnum), folders[i].nMsgs);
}
}
* Put them in priority order.
*/
-int
+static int
CompareFolders(struct Folder *f1, struct Folder *f2)
{
if (!alphaOrder && f1->priority != f2->priority)
return f1->priority - f2->priority;
- else
- return strcmp(f1->name, f2->name);
+ return strcmp(f1->name, f2->name);
}
/*
* Make sure we have at least n folders allocated.
*/
-void
+static void
AllocFolders(struct Folder **f, int *nfa, int n)
{
if (n <= *nfa)
* Return the priority for a name. The highest comes from an exact match.
* After that, the longest match (then first) assigns the priority.
*/
-int
+static int
AssignPriority(char *name)
{
int i, ol, nl;
{
int atrlen;
char atrcur[BUFSIZ];
- register struct node *np;
+ struct node *np;
snprintf (atrcur, sizeof(atrcur), "atr-%s-", current);
atrlen = strlen (atrcur);
projects / nmh / blobdiff