git.marmaro.de Git - mmh/blob - sbr/m_convert.c

   1 /*
   2 ** m_convert.c -- parse a message range or sequence and set SELECTED
   3 **
   4 ** This code is Copyright (c) 2002, by the authors of nmh.  See the
   5 ** COPYRIGHT file in the root directory of the nmh distribution for
   6 ** complete copyright information.
   7 */
   8
   9 #include <h/mh.h>
  10
  11 /*
  12 ** error codes for sequence
  13 ** and message range processing
  14 */
  15 #define BADMSG (-2)
  16 #define BADRNG (-3)
  17 #define BADNEW (-4)
  18 #define BADNUM (-5)
  19 #define BADLST (-6)
  20
  21 #define FIRST 1
  22 #define LAST 2
  23
  24 #define getnew(mp) (mp->hghmsg + 1)
  25
  26 static int convdir; /* convert direction */
  27 static char *delimp;
  28
  29 /*
  30 ** static prototypes
  31 */
  32 static int m_conv(struct msgs *, char *, int);
  33 static int attr(struct msgs *, char *);
  34
  35
  36 int
  37 m_convert(struct msgs *mp, char *name)
  38 {
  39         int first, last, found, range, err;
  40         unsigned char *bp;
  41         char *cp;
  42
  43         /* check if user defined sequence */
  44         err = attr(mp, cp = name);
  45
  46         if (err == -1)
  47                 return 0;
  48         else if (err < 0)
  49                 goto badmsg;
  50         else if (err > 0)
  51                 return 1;
  52         /*
  53         ** else err == 0, so continue
  54         */
  55
  56         found = 0;
  57
  58         /*
  59         ** Check for special "new" sequence, which
  60         ** is valid only if ALLOW_NEW is set.
  61         */
  62         if ((mp->msgflags & ALLOW_NEW) && !strcmp(cp, "new")) {
  63                 if ((err = first = getnew(mp)) <= 0)
  64                         goto badmsg;
  65                 else
  66                         goto single;
  67         }
  68
  69         if (!strcmp(cp, "all"))
  70                 cp = "first-last";
  71
  72         if ((err = first = m_conv(mp, cp, FIRST)) <= 0)
  73                 goto badmsg;
  74
  75         cp = delimp;
  76         if (*cp != '\0' && *cp != '-' && *cp != ':') {
  77 badelim:
  78                 advise(NULL, "illegal argument delimiter: `%c'(0%o)",
  79                                 *delimp, *delimp);
  80                 return 0;
  81         }
  82
  83         if (*cp == '-') {
  84                 cp++;
  85                 if ((err = last = m_conv(mp, cp, LAST)) <= 0) {
  86 badmsg:
  87                         switch (err) {
  88                         case BADMSG:
  89                                 advise(NULL, "no %s message", cp);
  90                                 break;
  91
  92                         case BADNUM:
  93                                 advise(NULL, "message %s doesn't exist", cp);
  94                                 break;
  95
  96                         case BADRNG:
  97                                 advise(NULL, "message %s out of range 1-%d",
  98                                                 cp, mp->hghmsg);
  99                                 break;
 100
 101                         case BADLST:
 102 badlist:
 103                                 advise(NULL, "bad message list %s", name);
 104                                 break;
 105
 106                         case BADNEW:
 107                                 advise(NULL, "folder full, no %s message",
 108                                                 name);
 109                                 break;
 110
 111                         default:
 112                                 advise(NULL, "no messages match specification");
 113                         }
 114                         return 0;
 115                 }
 116
 117                 if (last < first)
 118                         goto badlist;
 119                 if (*delimp)
 120                         goto badelim;
 121                 if (first > mp->hghmsg || last < mp->lowmsg) {
 122 rangerr:
 123                         advise(NULL, "no messages in range %s", name);
 124                         return 0;
 125                 }
 126
 127                 /* tighten the range to search */
 128                 if (last > mp->hghmsg)
 129                         last = mp->hghmsg;
 130                 if (first < mp->lowmsg)
 131                         first = mp->lowmsg;
 132
 133         } else if (*cp == ':') {
 134                 cp++;
 135                 if (*cp == '-') {
 136                         convdir = -1;
 137                         cp++;
 138                 } else if (*cp == '+') {
 139                         convdir = 1;
 140                         cp++;
 141                 }
 142                 if ((range = atoi(bp = cp)) == 0)
 143                         goto badlist;
 144                 while (isdigit(*bp))
 145                         bp++;
 146                 if (*bp)
 147                         goto badelim;
 148                 if ((convdir > 0 && first > mp->hghmsg)
 149                         || (convdir < 0 && first < mp->lowmsg))
 150                         goto rangerr;
 151
 152                 /* tighten the range to search */
 153                 if (first < mp->lowmsg)
 154                         first = mp->lowmsg;
 155                 if (first > mp->hghmsg)
 156                         first = mp->hghmsg;
 157
 158                 for (last = first; last >= mp->lowmsg && last <= mp->hghmsg;
 159                         last += convdir)
 160                         if (does_exist(mp, last))
 161                                 if (--range <= 0)
 162                                         break;
 163                 if (last < mp->lowmsg)
 164                         last = mp->lowmsg;
 165                 if (last > mp->hghmsg)
 166                         last = mp->hghmsg;
 167                 if (last < first) {
 168                         range = last;
 169                         last = first;
 170                         first = range;
 171                 }
 172         } else {
 173
 174 single:
 175                 /*
 176                 ** Single Message
 177                 **
 178                 ** If ALLOW_NEW is set, then allow selecting of an
 179                 ** empty slot.  If ALLOW_NEW is not set, then we
 180                 ** check if message is in-range and exists.
 181                 */
 182                 if (mp->msgflags & ALLOW_NEW) {
 183                         set_select_empty(mp, first);
 184                 } else {
 185                         if (first > mp->hghmsg
 186                                 || first < mp->lowmsg
 187                                 || !(does_exist(mp, first))) {
 188                                 if (!strcmp(name, "cur"))
 189                                         advise(NULL, "no %s message", name);
 190                                 else
 191                                         advise(NULL, "message %d doesn't exist", first);
 192                                 return 0;
 193                         }
 194                 }
 195                 last = first;  /* range of 1 */
 196         }
 197
 198         /*
 199         ** Cycle through the range and select the messages
 200         ** that exist.  If ALLOW_NEW is set, then we also check
 201         ** if we are selecting an empty slot.
 202         */
 203         for (; first <= last; first++) {
 204                 if (does_exist(mp, first) ||
 205                         ((mp->msgflags & ALLOW_NEW) && is_select_empty(mp, first))) {
 206                         if (!is_selected(mp, first)) {
 207                                 set_selected(mp, first);
 208                                 mp->numsel++;
 209                                 if (mp->lowsel == 0 || first < mp->lowsel)
 210                                         mp->lowsel = first;
 211                                 if (first > mp->hghsel)
 212                                         mp->hghsel = first;
 213                         }
 214                         found++;
 215                 }
 216         }
 217
 218         if (!found)
 219                 goto rangerr;
 220
 221         return 1;
 222 }
 223
 224 /*
 225 ** Convert the various message names to
 226 ** their numeric values.
 227 **
 228 ** n  (integer)
 229 ** prev
 230 ** next
 231 ** first
 232 ** last
 233 ** cur
 234 */
 235 static int
 236 m_conv(struct msgs *mp, char *str, int call)
 237 {
 238         register int i;
 239         register unsigned char *cp, *bp;
 240         unsigned char buf[16];
 241
 242         convdir = 1;
 243         cp = bp = str;
 244         if (isdigit(*cp)) {
 245                 while (isdigit(*bp))
 246                         bp++;
 247                 delimp = bp;
 248                 i = atoi(cp);
 249
 250                 if (i <= mp->hghmsg)
 251                         return i;
 252                 else if (*delimp || call == LAST)
 253                         return mp->hghmsg + 1;
 254                 else if (mp->msgflags & ALLOW_NEW)
 255                         return BADRNG;
 256                 else
 257                         return BADNUM;
 258         }
 259
 260 #ifdef LOCALE
 261         /* doesn't enforce lower case */
 262         for (bp = buf; isalpha(*cp) && (bp - buf < sizeof(buf) - 1); )
 263 #else
 264         for (bp = buf; islower(*cp) && (bp - buf < sizeof(buf) - 1); )
 265 #endif /* LOCALE */
 266         {
 267                 *bp++ = *cp++;
 268         }
 269         *bp++ = '\0';
 270         delimp = cp;
 271
 272         if (!strcmp(buf, "first"))
 273                 return (mp->hghmsg || !(mp->msgflags & ALLOW_NEW)
 274                                 ? mp->lowmsg : BADMSG);
 275
 276         if (!strcmp(buf, "last")) {
 277                 convdir = -1;
 278                 return (mp->hghmsg || !(mp->msgflags & ALLOW_NEW) ? mp->hghmsg : BADMSG);
 279         }
 280
 281         if (!strcmp(buf, "cur"))
 282                 return (mp->curmsg > 0 ? mp->curmsg : BADMSG);
 283
 284         if (!strcmp(buf, "prev")) {
 285                 convdir = -1;
 286                 for (i = (mp->curmsg <= mp->hghmsg) ? mp->curmsg - 1 : mp->hghmsg;
 287                         i >= mp->lowmsg; i--) {
 288                         if (does_exist(mp, i))
 289                                 return i;
 290                 }
 291                 return BADMSG;
 292         }
 293
 294         if (!strcmp(buf, "next")) {
 295                 for (i = (mp->curmsg >= mp->lowmsg) ? mp->curmsg + 1 : mp->lowmsg;
 296                         i <= mp->hghmsg; i++) {
 297                         if (does_exist(mp, i))
 298                                 return i;
 299                 }
 300                 return BADMSG;
 301         }
 302
 303         return BADLST;
 304 }
 305
 306 /*
 307 ** Handle user defined sequences.
 308 ** They can take the following forms:
 309 **
 310 ** seq
 311 ** seq:prev
 312 ** seq:next
 313 ** seq:first
 314 ** seq:last
 315 ** seq:+n
 316 ** seq:-n
 317 ** seq:n
 318 */
 319
 320 static int
 321 attr(struct msgs *mp, char *cp)
 322 {
 323         register unsigned char *dp;
 324         char *bp = NULL;
 325         register int i, j;
 326         int found;
 327         int inverted = 0;
 328         int range = 0;  /* no range */
 329         int first = 0;
 330
 331         /* hack for "cur-name", "cur-n", etc. */
 332         if (!strcmp(cp, "cur"))
 333                 return 0;
 334         if (isprefix("cur:", cp))  /* this code need to be rewritten... */
 335                 return 0;
 336
 337         /* Check for sequence negation */
 338         if (!(dp = context_find(nsequence))) {
 339                 dp = seq_neg;  /* use default */
 340         }
 341         if (dp && *dp && isprefix(dp, cp)) {
 342                 inverted = 1;
 343                 cp += strlen(dp);
 344         }
 345
 346         convdir = 1;  /* convert direction */
 347
 348         for (dp = cp; *dp && isalnum(*dp); dp++)
 349                 continue;
 350
 351         if (*dp == ':') {
 352                 bp = dp++;
 353                 range = 1;
 354
 355                 /*
 356                 ** seq:prev  (or)
 357                 ** seq:next  (or)
 358                 ** seq:first (or)
 359                 ** seq:last
 360                 */
 361                 if (isalpha(*dp)) {
 362                         if (!strcmp(dp, "prev")) {
 363                                 convdir = -1;
 364                                 first = (mp->curmsg > 0) && (mp->curmsg <= mp->hghmsg)
 365                                         ? mp->curmsg - 1 : mp->hghmsg;
 366                         } else if (!strcmp(dp, "next")) {
 367                                 convdir = 1;
 368                                 first = (mp->curmsg >= mp->lowmsg)
 369                                         ? mp->curmsg + 1 : mp->lowmsg;
 370                         } else if (!strcmp(dp, "first")) {
 371                                 convdir = 1;
 372                         } else if (!strcmp(dp, "last")) {
 373                                 convdir = -1;
 374                         } else
 375                                 return BADLST;
 376                 } else {
 377                         /*
 378                         ** seq:n  (or)
 379                         ** seq:+n (or)
 380                         ** seq:-n
 381                         */
 382                         if (*dp == '+')
 383                                 dp++;
 384                         else if (*dp == '-') {
 385                                 dp++;
 386                                 convdir = -1;
 387                         }
 388                         if ((range = atoi(dp)) == 0)
 389                                 return BADLST;
 390                         while (isdigit(*dp))
 391                                 dp++;
 392                         if (*dp)
 393                                 return BADLST;
 394                 }
 395
 396                 *bp = '\0';  /* temporarily terminate sequence name */
 397         }
 398
 399         i = seq_getnum(mp, cp);  /* get index of sequence */
 400
 401         if (bp)
 402                 *bp = ':';  /* restore sequence name */
 403         if (i == -1)
 404                 return 0;
 405
 406         found = 0;  /* count the number we select for this argument */
 407
 408         for (j = first ? first : (convdir > 0) ? mp->lowmsg : mp->hghmsg;
 409                 j >= mp->lowmsg && j <= mp->hghmsg; j += convdir) {
 410                 if (does_exist(mp, j)
 411                         && inverted ? !in_sequence(mp, i, j) : in_sequence(mp, i, j)) {
 412                         if (!is_selected(mp, j)) {
 413                                 set_selected(mp, j);
 414                                 mp->numsel++;
 415                                 if (mp->lowsel == 0 || j < mp->lowsel)
 416                                         mp->lowsel = j;
 417                                 if (j > mp->hghsel)
 418                                         mp->hghsel = j;
 419                         }
 420                         found++;
 421
 422                         /*
 423                         ** If we have a range, then break out
 424                         ** once we've found enough.
 425                         */
 426                         if (range && found >= range)
 427                                 break;
 428                 }
 429         }
 430
 431         if (found > 0)
 432                 return found;
 433
 434         if (first)
 435                 return BADMSG;
 436         advise(NULL, "sequence %s %s", cp, inverted ? "full" : "empty");
 437         return -1;
 438 }