cmd-message.c

   1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
   2  *@ Iterating over, and over such housekeeping message user commands.
   3  *
   4  * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
   5  * Copyright (c) 2012 - 2017 Steffen (Daode) Nurpmeso <steffen@sdaoden.eu>.
   6  */
   7 /*
   8  * Copyright (c) 1980, 1993
   9  *      The Regents of the University of California.  All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 3. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35 #undef n_FILE
  36 #define n_FILE cmd_message
  37
  38 #ifndef HAVE_AMALGAMATION
  39 # include "nail.h"
  40 #endif
  41
  42 /* Prepare and print "[Message: xy]:" intro */
  43 static bool_t a_cmsg_show_overview(FILE *obuf, struct message *mp, int msg_no);
  44
  45 /* Show the requested messages */
  46 static int     _type1(int *msgvec, bool_t doign, bool_t dopage, bool_t dopipe,
  47                   bool_t donotdecode, char *cmd, ui64_t *tstats);
  48
  49 /* Pipe the requested messages */
  50 static int     _pipe1(char *str, int doign);
  51
  52 /* `top' / `Top' */
  53 static int a_cmsg_top(void *vp, struct n_ignore const *itp);
  54
  55 /* Delete the indicated messages.  Set dot to some nice place afterwards */
  56 static int     delm(int *msgvec);
  57
  58 static bool_t
  59 a_cmsg_show_overview(FILE *obuf, struct message *mp, int msg_no){
  60    bool_t rv;
  61    char const *cpre, *csuf;
  62    NYD2_ENTER;
  63
  64    cpre = csuf = n_empty;
  65 #ifdef HAVE_COLOUR
  66    if(n_COLOUR_IS_ACTIVE()){
  67       struct n_colour_pen *cpen;
  68
  69       if((cpen = n_colour_pen_create(n_COLOUR_ID_VIEW_MSGINFO, NULL)) != NULL){
  70          struct str const *sp;
  71
  72          if((sp = n_colour_pen_to_str(cpen)) != NULL)
  73             cpre = sp->s;
  74          if((sp = n_colour_reset_to_str()) != NULL)
  75             csuf = sp->s;
  76       }
  77    }
  78 #endif
  79    /* XXX Message info uses wire format for line count */
  80    rv = (fprintf(obuf, _("%s[-- Message %2d -- %lu lines, %lu bytes --]:%s\n"),
  81          cpre, msg_no, (ul_i)mp->m_lines, (ul_i)mp->m_size, csuf) > 0);
  82    NYD2_LEAVE;
  83    return rv;
  84 }
  85
  86 static int
  87 _type1(int *msgvec, bool_t doign, bool_t dopage, bool_t dopipe,
  88    bool_t donotdecode, char *cmd, ui64_t *tstats)
  89 {
  90    ui64_t mstats[1];
  91    int *ip;
  92    struct message *mp;
  93    char const *cp;
  94    enum sendaction action;
  95    bool_t volatile formfeed;
  96    FILE * volatile obuf;
  97    int volatile rv;
  98    NYD_ENTER;
  99
 100    rv = 1;
 101    obuf = n_stdout;
 102    formfeed = (dopipe && ok_blook(page));
 103    action = ((dopipe && ok_blook(piperaw))
 104          ? SEND_MBOX : donotdecode
 105          ? SEND_SHOW : doign
 106          ? SEND_TODISP : SEND_TODISP_ALL);
 107
 108    if (dopipe) {
 109       if ((obuf = Popen(cmd, "w", ok_vlook(SHELL), NULL, 1)) == NULL) {
 110          n_perr(cmd, 0);
 111          obuf = n_stdout;
 112       }
 113    } else if ((n_psonce & n_PSO_TTYOUT) && (dopage ||
 114          ((n_psonce & n_PSO_INTERACTIVE) && (cp = ok_vlook(crt)) != NULL))) {
 115       uiz_t nlines, lib;
 116
 117       nlines = 0;
 118
 119       if (!dopage) {
 120          for (ip = msgvec; *ip && PTRCMP(ip - msgvec, <, msgCount); ++ip) {
 121             mp = message + *ip - 1;
 122             if (!(mp->m_content_info & CI_HAVE_BODY))
 123                if (get_body(mp) != OKAY)
 124                   goto jleave;
 125             nlines += mp->m_lines + 1; /* TODO BUT wire format, not display! */
 126          }
 127       }
 128
 129       /* >= not <: we return to the prompt */
 130       if(dopage || nlines >= (*cp != '\0'
 131                ? (n_idec_uiz_cp(&lib, cp, 0, NULL), lib)
 132                : (uiz_t)n_realscreenheight)){
 133          if((obuf = n_pager_open()) == NULL)
 134             obuf = n_stdout;
 135       }
 136       n_COLOUR(
 137          if(action == SEND_TODISP || action == SEND_TODISP_ALL)
 138             n_colour_env_create(n_COLOUR_CTX_VIEW, obuf, obuf != n_stdout);
 139       )
 140    }
 141    n_COLOUR(
 142       else if(action == SEND_TODISP || action == SEND_TODISP_ALL)
 143          n_colour_env_create(n_COLOUR_CTX_VIEW, n_stdout, FAL0);
 144    )
 145
 146    rv = 0;
 147    srelax_hold();
 148    for (ip = msgvec; *ip && PTRCMP(ip - msgvec, <, msgCount); ++ip) {
 149       mp = message + *ip - 1;
 150       touch(mp);
 151       setdot(mp);
 152       n_pstate |= n_PS_DID_PRINT_DOT;
 153       uncollapse1(mp, 1);
 154       if(!dopipe && ip != msgvec && fprintf(obuf, "\n") < 0){
 155          rv = 1;
 156          break;
 157       }
 158       if(action != SEND_MBOX && !a_cmsg_show_overview(obuf, mp, *ip)){
 159          rv = 1;
 160          break;
 161       }
 162       if(sendmp(mp, obuf, (doign ? n_IGNORE_TYPE : NULL), NULL, action, mstats
 163             ) < 0){
 164          rv = 1;
 165          break;
 166       }
 167       srelax();
 168       if(formfeed){ /* TODO a nicer way to separate piped messages! */
 169          if(putc('\f', obuf) == EOF){
 170             rv = 1;
 171             break;
 172          }
 173       }
 174       if (tstats != NULL)
 175          tstats[0] += mstats[0];
 176    }
 177    srelax_rele();
 178    n_COLOUR(
 179       if(!dopipe && (action == SEND_TODISP || action == SEND_TODISP_ALL))
 180          n_colour_env_gut();
 181    )
 182 jleave:
 183    if (obuf != n_stdout)
 184       n_pager_close(obuf);
 185    NYD_LEAVE;
 186    return rv;
 187 }
 188
 189 static int
 190 _pipe1(char *str, int doign)
 191 {
 192    ui64_t stats[1];
 193    char const *cmd, *cmdq;
 194    int *msgvec, rv = 1;
 195    bool_t needs_list;
 196    NYD_ENTER;
 197
 198    if ((cmd = laststring(str, &needs_list, TRU1)) == NULL) {
 199       cmd = ok_vlook(cmd);
 200       if (cmd == NULL || *cmd == '\0') {
 201          n_err(_("Variable *cmd* not set\n"));
 202          goto jleave;
 203       }
 204    }
 205
 206    msgvec = salloc((msgCount + 2) * sizeof *msgvec);
 207
 208    if (!needs_list) {
 209       *msgvec = first(0, MMNORM);
 210       if (*msgvec == 0) {
 211          if (n_pstate & (n_PS_ROBOT | n_PS_HOOK_MASK)) {
 212             rv = 0;
 213             goto jleave;
 214          }
 215          fputs(_("No messages to pipe.\n"), n_stdout);
 216          goto jleave;
 217       }
 218       msgvec[1] = 0;
 219    } else if (getmsglist(str, msgvec, 0) < 0)
 220       goto jleave;
 221    if (*msgvec == 0) {
 222       if (n_pstate & (n_PS_ROBOT | n_PS_HOOK_MASK)) {
 223          rv = 0;
 224          goto jleave;
 225       }
 226       fprintf(n_stdout, "No applicable messages.\n");
 227       goto jleave;
 228    }
 229
 230    cmdq = n_shexp_quote_cp(cmd, FAL0);
 231    fprintf(n_stdout, _("Pipe to: %s\n"), cmdq);
 232    stats[0] = 0;
 233    if ((rv = _type1(msgvec, doign, FAL0, TRU1, FAL0, n_UNCONST(cmd), stats)
 234          ) == 0)
 235       fprintf(n_stdout, "%s %" PRIu64 " bytes\n", cmdq, stats[0]);
 236 jleave:
 237    NYD_LEAVE;
 238    return rv;
 239 }
 240
 241 static int
 242 a_cmsg_top(void *vp, struct n_ignore const *itp){
 243    struct n_string s;
 244    int *msgvec, *ip;
 245    enum{a_NONE, a_SQUEEZE = 1u<<0,
 246       a_EMPTY = 1u<<8, a_STOP = 1u<<9,  a_WORKMASK = 0xFF00u} f;
 247    size_t tmax, plines;
 248    FILE *iobuf, *pbuf;
 249    NYD2_ENTER;
 250
 251    if((iobuf = Ftmp(NULL, "topio", OF_RDWR | OF_UNLINK | OF_REGISTER)) == NULL){
 252       n_perr(_("`top': I/O temporary file"), 0);
 253       vp = NULL;
 254       goto jleave;
 255    }
 256    if((pbuf = Ftmp(NULL, "toppag", OF_RDWR | OF_UNLINK | OF_REGISTER)) == NULL){
 257       n_perr(_("`top': temporary pager file"), 0);
 258       vp = NULL;
 259       goto jleave1;
 260    }
 261
 262    /* TODO In v15 we should query the m_message object, and directly send only
 263     * TODO those parts, optionally over empty-line-squeeze and quote-strip
 264     * TODO filters, in which we are interested in: only text content!
 265     * TODO And: with *topsqueeze*, header/content separating empty line.. */
 266    n_pstate &= ~n_PS_MSGLIST_DIRECT; /* TODO NO ATTACHMENTS */
 267    plines = 0;
 268
 269    n_COLOUR( n_colour_env_create(n_COLOUR_CTX_VIEW, iobuf, FAL0); )
 270    n_string_creat_auto(&s);
 271    /* C99 */{
 272       siz_t l;
 273
 274       if((n_idec_siz_cp(&l, ok_vlook(toplines), 0, NULL
 275                ) & (n_IDEC_STATE_EMASK | n_IDEC_STATE_CONSUMED)
 276             ) != n_IDEC_STATE_CONSUMED)
 277          l = 0;
 278       if(l <= 0){
 279          tmax = n_screensize();
 280          if(l < 0){
 281             l = n_ABS(l);
 282             tmax >>= l;
 283          }
 284       }else
 285          tmax = (size_t)l;
 286    }
 287    f = ok_blook(topsqueeze) ? a_SQUEEZE : a_NONE;
 288
 289    for(ip = msgvec = vp;
 290          *ip != 0 && UICMP(z, PTR2SIZE(ip - msgvec), <, msgCount); ++ip){
 291       struct message *mp;
 292
 293       mp = &message[*ip - 1];
 294       touch(mp);
 295       setdot(mp);
 296       n_pstate |= n_PS_DID_PRINT_DOT;
 297       uncollapse1(mp, 1);
 298
 299       rewind(iobuf);
 300       if(ftruncate(fileno(iobuf), 0)){
 301          n_perr(_("`top': ftruncate(2)"), 0);
 302          vp = NULL;
 303          break;
 304       }
 305
 306       if(!a_cmsg_show_overview(iobuf, mp, *ip) ||
 307             sendmp(mp, iobuf, itp, NULL, SEND_TODISP_ALL, NULL) < 0){
 308          n_err(_("`top': failed to prepare message %d\n"), *ip);
 309          vp = NULL;
 310          break;
 311       }
 312       fflush_rewind(iobuf);
 313
 314       /* TODO Skip over the _msg_overview line -- this is a hack to make
 315        * TODO colours work: colour contexts should be objects */
 316       for(;;){
 317          int c;
 318
 319          if((c = getc(iobuf)) == EOF || putc(c, pbuf) == EOF){
 320             vp = NULL;
 321             break;
 322          }else if(c == '\n')
 323             break;
 324       }
 325       if(vp == NULL)
 326          break;
 327       ++plines;
 328
 329       /* C99 */{
 330          size_t l;
 331
 332          n_string_trunc(&s, 0);
 333          for(l = 0, f &= ~a_WORKMASK; !(f & a_STOP);){
 334             int c;
 335
 336             if((c = getc(iobuf)) == EOF){
 337                f |= a_STOP;
 338                c = '\n';
 339             }
 340
 341             if(c != '\n')
 342                n_string_push_c(&s, c);
 343             else if((f & a_SQUEEZE) && s.s_len == 0){
 344                if(!(f & a_STOP) && ((f & a_EMPTY) || tmax - 1 <= l))
 345                   continue;
 346                if(putc('\n', pbuf) == EOF){
 347                   vp = NULL;
 348                   break;
 349                }
 350                f |= a_EMPTY;
 351                ++l;
 352             }else{
 353                char const *cp, *xcp;
 354
 355                cp = n_string_cp_const(&s);
 356                /* TODO Brute simple skip part overviews; see above.. */
 357                if(!(f & a_SQUEEZE))
 358                   c = '\1';
 359                else if(s.s_len > 8 &&
 360                      (xcp = strstr(cp, "[-- ")) != NULL &&
 361                       strstr(&xcp[1], " --]") != NULL)
 362                   c = '\0';
 363                else for(; (c = *cp) != '\0'; ++cp){
 364                   if(!asciichar(c))
 365                      break;
 366                   if(!blankspacechar(c)){
 367                      if(!n_QUOTE_IS_A(c))
 368                         break;
 369                      c = '\0';
 370                      break;
 371                   }
 372                }
 373
 374                if(c != '\0'){
 375                   if(fputs(n_string_cp_const(&s), pbuf) == EOF ||
 376                         putc('\n', pbuf) == EOF){
 377                      vp = NULL;
 378                      break;
 379                   }
 380                   if(++l >= tmax)
 381                      break;
 382                   f &= ~a_EMPTY;
 383                }else
 384                   f |= a_EMPTY;
 385                n_string_trunc(&s, 0);
 386             }
 387          }
 388          if(vp == NULL)
 389             break;
 390          if(l > 0)
 391             plines += l;
 392          else{
 393             if(!(f & a_EMPTY) && putc('\n', pbuf) == EOF){
 394                vp = NULL;
 395                break;
 396             }
 397             ++plines;
 398          }
 399       }
 400    }
 401
 402    n_string_gut(&s);
 403    n_COLOUR( n_colour_env_gut(); )
 404
 405    fflush(pbuf);
 406    page_or_print(pbuf, plines);
 407
 408    Fclose(pbuf);
 409 jleave1:
 410    Fclose(iobuf);
 411 jleave:
 412    NYD2_LEAVE;
 413    return (vp != NULL);
 414 }
 415
 416 static int
 417 delm(int *msgvec)
 418 {
 419    struct message *mp;
 420    int rv = -1, *ip, last;
 421    NYD_ENTER;
 422
 423    last = 0;
 424    for (ip = msgvec; *ip != 0; ++ip) {
 425       mp = message + *ip - 1;
 426       touch(mp);
 427       mp->m_flag |= MDELETED | MTOUCH;
 428       mp->m_flag &= ~(MPRESERVE | MSAVED | MBOX);
 429       last = *ip;
 430    }
 431    if (last != 0) {
 432       setdot(message + last - 1);
 433       last = first(0, MDELETED);
 434       if (last != 0) {
 435          setdot(message + last - 1);
 436          rv = 0;
 437       } else {
 438          setdot(message);
 439       }
 440    }
 441    NYD_LEAVE;
 442    return rv;
 443 }
 444
 445 FL int
 446 c_more(void *v)
 447 {
 448    int *msgvec = v, rv;
 449    NYD_ENTER;
 450
 451    rv = _type1(msgvec, TRU1, TRU1, FAL0, FAL0, NULL, NULL);
 452    NYD_LEAVE;
 453    return rv;
 454 }
 455
 456 FL int
 457 c_More(void *v)
 458 {
 459    int *msgvec = v, rv;
 460    NYD_ENTER;
 461
 462    rv = _type1(msgvec, FAL0, TRU1, FAL0, FAL0, NULL, NULL);
 463    NYD_LEAVE;
 464    return rv;
 465 }
 466
 467 FL int
 468 c_type(void *v)
 469 {
 470    int *msgvec = v, rv;
 471    NYD_ENTER;
 472
 473    rv = _type1(msgvec, TRU1, FAL0, FAL0, FAL0, NULL, NULL);
 474    NYD_LEAVE;
 475    return rv;
 476 }
 477
 478 FL int
 479 c_Type(void *v)
 480 {
 481    int *msgvec = v, rv;
 482    NYD_ENTER;
 483
 484    rv = _type1(msgvec, FAL0, FAL0, FAL0, FAL0, NULL, NULL);
 485    NYD_LEAVE;
 486    return rv;
 487 }
 488
 489 FL int
 490 c_show(void *v)
 491 {
 492    int *msgvec = v, rv;
 493    NYD_ENTER;
 494
 495    rv = _type1(msgvec, FAL0, FAL0, FAL0, TRU1, NULL, NULL);
 496    NYD_LEAVE;
 497    return rv;
 498 }
 499
 500 FL int
 501 c_partview(void *vp){ /* TODO direct addressable parts, multiple such */
 502    struct message *mp;
 503    int rv, *msgvec;
 504    NYD_ENTER;
 505
 506    if((msgvec = vp)[1] != 0){
 507       n_err(_("`partview': can yet only take one message, sorry!\n"));/* TODO */
 508       n_pstate_err_no = n_ERR_NOTSUP;
 509       rv = 1;
 510       goto jleave;
 511    }
 512
 513    mp = &message[*msgvec - 1];
 514    touch(mp);
 515    setdot(mp);
 516    n_pstate |= n_PS_DID_PRINT_DOT;
 517    uncollapse1(mp, 1);
 518
 519    n_COLOUR(
 520       n_colour_env_create(n_COLOUR_CTX_VIEW, n_stdout, FAL0);
 521    )
 522
 523    if(!a_cmsg_show_overview(n_stdout, mp, *msgvec))
 524       n_pstate_err_no = n_ERR_IO;
 525    else if(sendmp(mp, n_stdout, n_IGNORE_TYPE, NULL, SEND_TODISP_PARTS,
 526          NULL) < 0)
 527       n_pstate_err_no = n_ERR_IO;
 528    else
 529       n_pstate_err_no = n_ERR_NONE;
 530
 531    n_COLOUR(
 532       n_colour_env_gut();
 533    )
 534
 535    rv = (n_pstate_err_no != n_ERR_NONE);
 536 jleave:
 537    NYD_LEAVE;
 538    return rv;
 539 }
 540
 541 FL int
 542 c_pipe(void *v)
 543 {
 544    char *str = v;
 545    int rv;
 546    NYD_ENTER;
 547
 548    rv = _pipe1(str, 1);
 549    NYD_LEAVE;
 550    return rv;
 551 }
 552
 553 FL int
 554 c_Pipe(void *v)
 555 {
 556    char *str = v;
 557    int rv;
 558    NYD_ENTER;
 559
 560    rv = _pipe1(str, 0);
 561    NYD_LEAVE;
 562    return rv;
 563 }
 564
 565 FL int
 566 c_top(void *v){
 567    struct n_ignore *itp;
 568    int rv;
 569    NYD_ENTER;
 570
 571    if(n_ignore_is_any(n_IGNORE_TOP))
 572       itp = n_IGNORE_TOP;
 573    else{
 574       itp = n_ignore_new(TRU1);
 575       n_ignore_insert(itp, TRU1, "from", sizeof("from") -1);
 576       n_ignore_insert(itp, TRU1, "to", sizeof("to") -1);
 577       n_ignore_insert(itp, TRU1, "cc", sizeof("cc") -1);
 578       n_ignore_insert(itp, TRU1, "subject", sizeof("subject") -1);
 579    }
 580
 581    rv = !a_cmsg_top(v, itp);
 582    NYD_LEAVE;
 583    return rv;
 584 }
 585
 586 FL int
 587 c_Top(void *v){
 588    int rv;
 589    NYD_ENTER;
 590
 591    rv = !a_cmsg_top(v, n_IGNORE_TYPE);
 592    NYD_LEAVE;
 593    return rv;
 594 }
 595
 596 FL int
 597 c_next(void *v)
 598 {
 599    int list[2], *ip, *ip2, mdot, *msgvec = v, rv = 1;
 600    struct message *mp;
 601    NYD_ENTER;
 602
 603    if (*msgvec != 0) {
 604       /* If some messages were supplied, find the first applicable one
 605        * following dot using wrap around */
 606       mdot = (int)PTR2SIZE(dot - message + 1);
 607
 608       /* Find first message in supplied message list which follows dot */
 609       for (ip = msgvec; *ip != 0; ++ip) {
 610          if ((mb.mb_threaded ? message[*ip - 1].m_threadpos > dot->m_threadpos
 611                : *ip > mdot))
 612             break;
 613       }
 614       if (*ip == 0)
 615          ip = msgvec;
 616       ip2 = ip;
 617       do {
 618          mp = message + *ip2 - 1;
 619          if (!(mp->m_flag & MMNDEL)) {
 620             setdot(mp);
 621             goto jhitit;
 622          }
 623          if (*ip2 != 0)
 624             ++ip2;
 625          if (*ip2 == 0)
 626             ip2 = msgvec;
 627       } while (ip2 != ip);
 628       fprintf(n_stdout, _("No messages applicable\n"));
 629       goto jleave;
 630    }
 631
 632    /* If this is the first command, select message 1.  Note that this must
 633     * exist for us to get here at all */
 634    if (!(n_pstate & n_PS_SAW_COMMAND)) {
 635       if (msgCount == 0)
 636          goto jateof;
 637       goto jhitit;
 638    }
 639
 640    /* Just find the next good message after dot, no wraparound */
 641    if (mb.mb_threaded == 0) {
 642       for (mp = dot + !!(n_pstate & n_PS_DID_PRINT_DOT);
 643             PTRCMP(mp, <, message + msgCount); ++mp)
 644          if (!(mp->m_flag & MMNORM))
 645             break;
 646    } else {
 647       /* TODO The threading code had some bugs that caused crashes.
 648        * TODO The last thing (before the deep look) happens here,
 649        * TODO so let's not trust n_PS_DID_PRINT_DOT but check & hope it fixes */
 650       if ((mp = dot) != NULL && (n_pstate & n_PS_DID_PRINT_DOT))
 651          mp = next_in_thread(mp);
 652       while (mp != NULL && (mp->m_flag & MMNORM))
 653          mp = next_in_thread(mp);
 654    }
 655    if (mp == NULL || PTRCMP(mp, >=, message + msgCount)) {
 656 jateof:
 657       fprintf(n_stdout, _("At EOF\n"));
 658       rv = 0;
 659       goto jleave;
 660    }
 661    setdot(mp);
 662
 663    /* Print dot */
 664 jhitit:
 665    list[0] = (int)PTR2SIZE(dot - message + 1);
 666    list[1] = 0;
 667    rv = c_type(list);
 668 jleave:
 669    NYD_LEAVE;
 670    return rv;
 671 }
 672
 673 FL int
 674 c_pdot(void *vp)
 675 {
 676    NYD_ENTER;
 677    n_UNUSED(vp);
 678    fprintf(n_stdout, "%d\n", (int)PTR2SIZE(dot - message + 1));
 679    NYD_LEAVE;
 680    return 0;
 681 }
 682
 683 FL int
 684 c_messize(void *v)
 685 {
 686    int *msgvec = v, *ip, mesg;
 687    struct message *mp;
 688    NYD_ENTER;
 689
 690    for (ip = msgvec; *ip != 0; ++ip) {
 691       mesg = *ip;
 692       mp = message + mesg - 1;
 693       fprintf(n_stdout, "%d: ", mesg);
 694       if (mp->m_xlines > 0)
 695          fprintf(n_stdout, "%ld", mp->m_xlines);
 696       else
 697          putc(' ', n_stdout);
 698       fprintf(n_stdout, "/%lu\n", (ul_i)mp->m_xsize);
 699    }
 700    NYD_LEAVE;
 701    return 0;
 702 }
 703
 704 FL int
 705 c_delete(void *v)
 706 {
 707    int *msgvec = v;
 708    NYD_ENTER;
 709
 710    delm(msgvec);
 711    NYD_LEAVE;
 712    return 0;
 713 }
 714
 715 FL int
 716 c_deltype(void *v)
 717 {
 718    int list[2], rv = 0, *msgvec = v, lastdot;
 719    NYD_ENTER;
 720
 721    lastdot = (int)PTR2SIZE(dot - message + 1);
 722    if (delm(msgvec) >= 0) {
 723       list[0] = (int)PTR2SIZE(dot - message + 1);
 724       if (list[0] > lastdot) {
 725          touch(dot);
 726          list[1] = 0;
 727          rv = c_type(list);
 728          goto jleave;
 729       }
 730       fprintf(n_stdout, _("At EOF\n"));
 731    } else
 732       fprintf(n_stdout, _("No more messages\n"));
 733 jleave:
 734    NYD_LEAVE;
 735    return rv;
 736 }
 737
 738 FL int
 739 c_undelete(void *v)
 740 {
 741    int *msgvec = v, *ip;
 742    struct message *mp;
 743    NYD_ENTER;
 744
 745    for (ip = msgvec; *ip != 0 && UICMP(z, PTR2SIZE(ip - msgvec), <, msgCount);
 746          ++ip) {
 747       mp = message + *ip - 1;
 748       touch(mp);
 749       setdot(mp);
 750       if (mp->m_flag & (MDELETED | MSAVED))
 751          mp->m_flag &= ~(MDELETED | MSAVED);
 752       else
 753          mp->m_flag &= ~MDELETED;
 754    }
 755    NYD_LEAVE;
 756    return 0;
 757 }
 758
 759 FL int
 760 c_stouch(void *v)
 761 {
 762    int *msgvec = v, *ip;
 763    NYD_ENTER;
 764
 765    for (ip = msgvec; *ip != 0; ++ip) {
 766       setdot(message + *ip - 1);
 767       dot->m_flag |= MTOUCH;
 768       dot->m_flag &= ~MPRESERVE;
 769       n_pstate |= n_PS_DID_PRINT_DOT;
 770    }
 771    NYD_LEAVE;
 772    return 0;
 773 }
 774
 775 FL int
 776 c_mboxit(void *v)
 777 {
 778    int *msgvec = v, *ip;
 779    NYD_ENTER;
 780
 781    if (n_pstate & n_PS_EDIT) {
 782       n_err(_("`mbox' can only be used in a system mailbox\n")); /* TODO */
 783       goto jleave;
 784    }
 785
 786    for (ip = msgvec; *ip != 0; ++ip) {
 787       setdot(message + *ip - 1);
 788       dot->m_flag |= MTOUCH | MBOX;
 789       dot->m_flag &= ~MPRESERVE;
 790       n_pstate |= n_PS_DID_PRINT_DOT;
 791    }
 792 jleave:
 793    NYD_LEAVE;
 794    return 0;
 795 }
 796
 797 FL int
 798 c_preserve(void *v)
 799 {
 800    int *msgvec = v, *ip, mesg, rv = 1;
 801    struct message *mp;
 802    NYD_ENTER;
 803
 804    if (n_pstate & n_PS_EDIT) {
 805       fprintf(n_stdout, _("Cannot `preserve' in a system mailbox\n"));
 806       goto jleave;
 807    }
 808
 809    for (ip = msgvec; *ip != 0; ++ip) {
 810       mesg = *ip;
 811       mp = message + mesg - 1;
 812       mp->m_flag |= MPRESERVE;
 813       mp->m_flag &= ~MBOX;
 814       setdot(mp);
 815       n_pstate |= n_PS_DID_PRINT_DOT;
 816    }
 817    rv = 0;
 818 jleave:
 819    NYD_LEAVE;
 820    return rv;
 821 }
 822
 823 FL int
 824 c_unread(void *v)
 825 {
 826    int *msgvec = v, *ip;
 827    NYD_ENTER;
 828
 829    for (ip = msgvec; *ip != 0; ++ip) {
 830       setdot(message + *ip - 1);
 831       dot->m_flag &= ~(MREAD | MTOUCH);
 832       dot->m_flag |= MSTATUS;
 833       n_pstate |= n_PS_DID_PRINT_DOT;
 834    }
 835    NYD_LEAVE;
 836    return 0;
 837 }
 838
 839 FL int
 840 c_seen(void *v)
 841 {
 842    int *msgvec = v, *ip;
 843    NYD_ENTER;
 844
 845    for (ip = msgvec; *ip != 0; ++ip) {
 846       struct message *mp = message + *ip - 1;
 847       setdot(mp);
 848       touch(mp);
 849    }
 850    NYD_LEAVE;
 851    return 0;
 852 }
 853
 854 FL int
 855 c_flag(void *v)
 856 {
 857    struct message *m;
 858    int *msgvec = v, *ip;
 859    NYD_ENTER;
 860
 861    for (ip = msgvec; *ip != 0; ++ip) {
 862       m = message + *ip - 1;
 863       setdot(m);
 864       if (!(m->m_flag & (MFLAG | MFLAGGED)))
 865          m->m_flag |= MFLAG | MFLAGGED;
 866    }
 867    NYD_LEAVE;
 868    return 0;
 869 }
 870
 871 FL int
 872 c_unflag(void *v)
 873 {
 874    struct message *m;
 875    int *msgvec = v, *ip;
 876    NYD_ENTER;
 877
 878    for (ip = msgvec; *ip != 0; ++ip) {
 879       m = message + *ip - 1;
 880       setdot(m);
 881       if (m->m_flag & (MFLAG | MFLAGGED)) {
 882          m->m_flag &= ~(MFLAG | MFLAGGED);
 883          m->m_flag |= MUNFLAG;
 884       }
 885    }
 886    NYD_LEAVE;
 887    return 0;
 888 }
 889
 890 FL int
 891 c_answered(void *v)
 892 {
 893    struct message *m;
 894    int *msgvec = v, *ip;
 895    NYD_ENTER;
 896
 897    for (ip = msgvec; *ip != 0; ++ip) {
 898       m = message + *ip - 1;
 899       setdot(m);
 900       if (!(m->m_flag & (MANSWER | MANSWERED)))
 901          m->m_flag |= MANSWER | MANSWERED;
 902    }
 903    NYD_LEAVE;
 904    return 0;
 905 }
 906
 907 FL int
 908 c_unanswered(void *v)
 909 {
 910    struct message *m;
 911    int *msgvec = v, *ip;
 912    NYD_ENTER;
 913
 914    for (ip = msgvec; *ip != 0; ++ip) {
 915       m = message + *ip - 1;
 916       setdot(m);
 917       if (m->m_flag & (MANSWER | MANSWERED)) {
 918          m->m_flag &= ~(MANSWER | MANSWERED);
 919          m->m_flag |= MUNANSWER;
 920       }
 921    }
 922    NYD_LEAVE;
 923    return 0;
 924 }
 925
 926 FL int
 927 c_draft(void *v)
 928 {
 929    struct message *m;
 930    int *msgvec = v, *ip;
 931    NYD_ENTER;
 932
 933    for (ip = msgvec; *ip != 0; ++ip) {
 934       m = message + *ip - 1;
 935       setdot(m);
 936       if (!(m->m_flag & (MDRAFT | MDRAFTED)))
 937          m->m_flag |= MDRAFT | MDRAFTED;
 938    }
 939    NYD_LEAVE;
 940    return 0;
 941 }
 942
 943 FL int
 944 c_undraft(void *v)
 945 {
 946    struct message *m;
 947    int *msgvec = v, *ip;
 948    NYD_ENTER;
 949
 950    for (ip = msgvec; *ip != 0; ++ip) {
 951       m = message + *ip - 1;
 952       setdot(m);
 953       if (m->m_flag & (MDRAFT | MDRAFTED)) {
 954          m->m_flag &= ~(MDRAFT | MDRAFTED);
 955          m->m_flag |= MUNDRAFT;
 956       }
 957    }
 958    NYD_LEAVE;
 959    return 0;
 960 }
 961
 962 /* s-it-mode */