lex.c

   1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
   2  *@ (Lexical processing of) Commands, and the (blocking) "event mainloop".
   3  *
   4  * Copyright (c) 2000-2004 Gunnar Ritter, Freiburg i. Br., Germany.
   5  * Copyright (c) 2012 - 2014 Steffen (Daode) Nurpmeso <sdaoden@users.sf.net>.
   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. All advertising materials mentioning features or use of this software
  20  *    must display the following acknowledgement:
  21  *    This product includes software developed by the University of
  22  *    California, Berkeley and its contributors.
  23  * 4. Neither the name of the University nor the names of its contributors
  24  *    may be used to endorse or promote products derived from this software
  25  *    without specific prior written permission.
  26  *
  27  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  37  * SUCH DAMAGE.
  38  */
  39
  40 #ifndef HAVE_AMALGAMATION
  41 # include "nail.h"
  42 #endif
  43
  44 #include <fcntl.h>
  45
  46 struct cmd {
  47    char const     *name;         /* Name of command */
  48    int            (*func)(void*); /* Implementor of command */
  49    enum argtype   argtype;       /* Arglist type (see below) */
  50    short          msgflag;       /* Required flags of msgs */
  51    short          msgmask;       /* Relevant flags of msgs */
  52 #ifdef HAVE_DOCSTRINGS
  53    int            docid;         /* Translation id of .doc */
  54    char const     *doc;          /* One line doc for command */
  55 #endif
  56 };
  57 /* Yechh, can't initialize unions */
  58 #define minargs   msgflag        /* Minimum argcount for RAWLIST */
  59 #define maxargs   msgmask        /* Max argcount for RAWLIST */
  60
  61 struct cmd_ghost {
  62    struct cmd_ghost  *next;
  63    struct str        cmd;        /* Data follows after .name */
  64    char              name[VFIELD_SIZE(sizeof(size_t))];
  65 };
  66
  67 static int              *_msgvec;
  68 static int              _reset_on_stop;   /* do a reset() if stopped */
  69 static sighandler_type  _oldpipe;
  70 static struct cmd_ghost *_cmd_ghosts;
  71 /* _cmd_tab[] after fun protos */
  72 static int              _lex_inithdr;     /* am printing startup headers */
  73
  74 /* Update mailname (if name != NULL) and displayname, return wether displayname
  75  * was large enough to swallow mailname */
  76 static bool_t  _update_mailname(char const *name);
  77 #ifdef HAVE_C90AMEND1 /* TODO unite __narrow_{pre,suf}fix() into one fun! */
  78 SINLINE size_t __narrow_prefix(char const *cp, size_t maxl);
  79 SINLINE size_t __narrow_suffix(char const *cp, size_t cpl, size_t maxl);
  80 #endif
  81
  82 /* Isolate the command from the arguments */
  83 static char *  _lex_isolate(char const *comm);
  84
  85 /* Get first-fit, or NULL */
  86 static struct cmd const * _lex(char const *comm);
  87
  88 /* Command ghost handling */
  89 static int     _ghost(void *v);
  90 static int     _unghost(void *v);
  91
  92 /* Print a list of all commands */
  93 static int     _pcmdlist(void *v);
  94 static int     __pcmd_cmp(void const *s1, void const *s2);
  95
  96 /* Print the binaries compiled-in features */
  97 static int     _features(void *v);
  98
  99 /* Print the binaries version number */
 100 static int     _version(void *v);
 101
 102 /* When we wake up after ^Z, reprint the prompt */
 103 static void    stop(int s);
 104
 105 /* Branch here on hangup signal and simulate "exit" */
 106 static void    hangup(int s);
 107
 108 /* List of all commands */
 109 static struct cmd const _cmd_tab[] = {
 110 #include "cmd_tab.h"
 111 };
 112
 113 #ifdef HAVE_C90AMEND1
 114 SINLINE size_t
 115 __narrow_prefix(char const *cp, size_t maxl)
 116 {
 117    int err;
 118    size_t i, ok;
 119    NYD_ENTER;
 120
 121    for (err = ok = i = 0; i < maxl;) {
 122       int ml = mblen(cp, maxl - i);
 123       if (ml < 0) { /* XXX _narrow_prefix(): mblen() error; action? */
 124          (void)mblen(NULL, 0);
 125          err = 1;
 126          ml = 1;
 127       } else {
 128          if (!err)
 129             ok = i;
 130          err = 0;
 131          if (ml == 0)
 132             break;
 133       }
 134       cp += ml;
 135       i += ml;
 136    }
 137    NYD_LEAVE;
 138    return ok;
 139 }
 140
 141 SINLINE size_t
 142 __narrow_suffix(char const *cp, size_t cpl, size_t maxl)
 143 {
 144    int err;
 145    size_t i, ok;
 146    NYD_ENTER;
 147
 148    for (err = ok = i = 0; cpl > maxl || err;) {
 149       int ml = mblen(cp, cpl);
 150       if (ml < 0) { /* XXX _narrow_suffix(): mblen() error; action? */
 151          (void)mblen(NULL, 0);
 152          err = 1;
 153          ml = 1;
 154       } else {
 155          if (!err)
 156             ok = i;
 157          err = 0;
 158          if (ml == 0)
 159             break;
 160       }
 161       cp += ml;
 162       i += ml;
 163       cpl -= ml;
 164    }
 165    NYD_LEAVE;
 166    return ok;
 167 }
 168 #endif /* HAVE_C90AMEND1 */
 169
 170 static bool_t
 171 _update_mailname(char const *name)
 172 {
 173    char tbuf[PATH_MAX], *mailp, *dispp;
 174    size_t i, j;
 175    bool_t rv = TRU1;
 176    NYD_ENTER;
 177
 178    /* Don't realpath(3) if it's only an update request */
 179    if (name != NULL) {
 180 #ifdef HAVE_REALPATH
 181       enum protocol p = which_protocol(name);
 182       if (p == PROTO_FILE || p == PROTO_MAILDIR) {
 183          if (realpath(name, mailname) == NULL) {
 184             fprintf(stderr, tr(151, "Can't canonicalize `%s'\n"), name);
 185             rv = FAL0;
 186             goto jdocopy;
 187          }
 188       } else
 189 jdocopy:
 190 #endif
 191          n_strlcpy(mailname, name, sizeof(mailname));
 192    }
 193
 194    mailp = mailname;
 195    dispp = displayname;
 196
 197    /* Don't display an absolute path but "+FOLDER" if under *folder* */
 198    if (getfold(tbuf, sizeof tbuf)) {
 199       i = strlen(tbuf);
 200       if (i < sizeof(tbuf) -1)
 201          tbuf[i++] = '/';
 202       if (!strncmp(tbuf, mailp, i)) {
 203          mailp += i;
 204          *dispp++ = '+';
 205       }
 206    }
 207
 208    /* We want to see the name of the folder .. on the screen */
 209    i = strlen(mailp);
 210    if (i < sizeof(displayname) -1)
 211       memcpy(dispp, mailp, i +1);
 212    else {
 213       rv = FAL0;
 214       /* Avoid disrupting multibyte sequences (if possible) */
 215 #ifndef HAVE_C90AMEND1
 216       j = sizeof(displayname) / 3 - 1;
 217       i -= sizeof(displayname) - (1/* + */ + 3) - j;
 218 #else
 219       j = __narrow_prefix(mailp, sizeof(displayname) / 3);
 220       i = j + __narrow_suffix(mailp + j, i - j,
 221          sizeof(displayname) - (1/* + */ + 3 + 1) - j);
 222 #endif
 223       snprintf(dispp, sizeof(displayname), "%.*s...%s",
 224          (int)j, mailp, mailp + i);
 225    }
 226    NYD_LEAVE;
 227    return rv;
 228 }
 229
 230 static char *
 231 _lex_isolate(char const *comm)
 232 {
 233    NYD_ENTER;
 234    while (*comm != '\0' &&
 235          strchr("~|? \t0123456789&%@$^.:/-+*'\",;(`", *comm) == NULL)
 236       ++comm;
 237    NYD_LEAVE;
 238    return UNCONST(comm);
 239 }
 240
 241 static struct cmd const *
 242 _lex(char const *comm) /* TODO **command hashtable**! linear list search!!! */
 243 {
 244    struct cmd const *cp;
 245    NYD_ENTER;
 246
 247    for (cp = _cmd_tab; cp->name != NULL; ++cp)
 248       if (*comm == *cp->name && is_prefix(comm, cp->name))
 249          goto jleave;
 250    cp = NULL;
 251 jleave:
 252    NYD_LEAVE;
 253    return cp;
 254 }
 255
 256 static int
 257 _ghost(void *v)
 258 {
 259    char const **argv = v;
 260    struct cmd_ghost *lcg, *cg;
 261    size_t nl, cl;
 262    NYD_ENTER;
 263
 264    /* Show the list? */
 265    if (*argv == NULL) {
 266       printf(tr(144, "Command ghosts are:\n"));
 267       for (nl = 0, cg = _cmd_ghosts; cg != NULL; cg = cg->next) {
 268          cl = strlen(cg->name) + 5 + cg->cmd.l + 3;
 269          nl += cl;
 270          if (UICMP(z, nl, >=, scrnwidth)) {
 271             nl = cl;
 272             printf("\n");
 273          }
 274          printf((cg->next != NULL ? "%s -> <%s>, " : "%s -> <%s>\n"),
 275             cg->name, cg->cmd.s);
 276       }
 277       v = NULL;
 278       goto jleave;
 279    }
 280
 281    /* Request to add new ghost */
 282    if (argv[1] == NULL || argv[1][0] == '\0' || argv[2] != NULL) {
 283       fprintf(stderr, tr(159, "Usage: %s\n"),
 284          tr(425, "Define a <ghost> of <command>, or list all ghosts"));
 285       v = NULL;
 286       goto jleave;
 287    }
 288
 289    /* Check that we can deal with this one */
 290    if (argv[0] == _lex_isolate(argv[0])) {
 291       fprintf(stderr, tr(151, "Can't canonicalize `%s'\n"), argv[0]);
 292       v = NULL;
 293       goto jleave;
 294    }
 295
 296    /* Always recreate */
 297    for (lcg = NULL, cg = _cmd_ghosts; cg != NULL; lcg = cg, cg = cg->next)
 298       if (!strcmp(cg->name, argv[0])) {
 299          if (lcg != NULL)
 300             lcg->next = cg->next;
 301          else
 302             _cmd_ghosts = cg->next;
 303          free(cg);
 304          break;
 305       }
 306
 307    /* Need a new one */
 308    nl = strlen(argv[0]) +1;
 309    cl = strlen(argv[1]) +1;
 310    cg = smalloc(sizeof(*cg) - VFIELD_SIZEOF(struct cmd_ghost, name) + nl + cl);
 311    cg->next = _cmd_ghosts;
 312    memcpy(cg->name, argv[0], nl);
 313    cg->cmd.s = cg->name + nl;
 314    cg->cmd.l = cl -1;
 315    memcpy(cg->cmd.s, argv[1], cl);
 316
 317    _cmd_ghosts = cg;
 318 jleave:
 319    NYD_LEAVE;
 320    return (v == NULL);
 321 }
 322
 323 static int
 324 _unghost(void *v)
 325 {
 326    int rv = 0;
 327    char const **argv = v, *cp;
 328    struct cmd_ghost *lcg, *cg;
 329    NYD_ENTER;
 330
 331    while ((cp = *argv++) != NULL) {
 332       for (lcg = NULL, cg = _cmd_ghosts; cg != NULL; lcg = cg, cg = cg->next)
 333          if (!strcmp(cg->name, cp)) {
 334             if (lcg != NULL)
 335                lcg->next = cg->next;
 336             else
 337                _cmd_ghosts = cg->next;
 338             free(cg);
 339             goto jouter;
 340          }
 341       fprintf(stderr, tr(91, "Unknown command: `%s'\n"), cp);
 342       rv = 1;
 343 jouter:
 344       ;
 345    }
 346    NYD_LEAVE;
 347    return rv;
 348 }
 349
 350 static int
 351 __pcmd_cmp(void const *s1, void const *s2)
 352 {
 353    struct cmd const * const *c1 = s1, * const *c2 = s2;
 354    int rv;
 355    NYD_ENTER;
 356
 357    rv = strcmp((*c1)->name, (*c2)->name);
 358    NYD_LEAVE;
 359    return rv;
 360 }
 361
 362 static int
 363 _pcmdlist(void *v)
 364 {
 365    struct cmd const **cpa, *cp, **cursor;
 366    size_t i;
 367    NYD_ENTER;
 368    UNUSED(v);
 369
 370    for (i = 0; _cmd_tab[i].name != NULL; ++i)
 371       ;
 372    ++i;
 373    cpa = ac_alloc(sizeof(cp) * i);
 374
 375    for (i = 0; (cp = _cmd_tab + i)->name != NULL; ++i)
 376       cpa[i] = cp;
 377    cpa[i] = NULL;
 378
 379    qsort(cpa, i, sizeof(cp), &__pcmd_cmp);
 380
 381    printf(tr(14, "Commands are:\n"));
 382    for (i = 0, cursor = cpa; (cp = *cursor++) != NULL;) {
 383       size_t j;
 384       if (cp->func == &c_cmdnotsupp)
 385          continue;
 386       j = strlen(cp->name) + 2;
 387       if ((i += j) > 72) {
 388          i = j;
 389          printf("\n");
 390       }
 391       printf((*cursor != NULL ? "%s, " : "%s\n"), cp->name);
 392    }
 393
 394    ac_free(cpa);
 395    NYD_LEAVE;
 396    return 0;
 397 }
 398
 399 static int
 400 _features(void *v)
 401 {
 402    NYD_ENTER;
 403    UNUSED(v);
 404    printf(tr(523, "Features: %s\n"), features);
 405    NYD_LEAVE;
 406    return 0;
 407 }
 408
 409 static int
 410 _version(void *v)
 411 {
 412    NYD_ENTER;
 413    UNUSED(v);
 414    printf(tr(111, "Version %s\n"), version);
 415    NYD_LEAVE;
 416    return 0;
 417 }
 418
 419 static void
 420 stop(int s)
 421 {
 422    sighandler_type old_action;
 423    sigset_t nset;
 424    NYD_X; /* Signal handler */
 425
 426    old_action = safe_signal(s, SIG_DFL);
 427
 428    sigemptyset(&nset);
 429    sigaddset(&nset, s);
 430    sigprocmask(SIG_UNBLOCK, &nset, NULL);
 431    kill(0, s);
 432    sigprocmask(SIG_BLOCK, &nset, NULL);
 433    safe_signal(s, old_action);
 434    if (_reset_on_stop) {
 435       _reset_on_stop = 0;
 436       reset(0);
 437    }
 438 }
 439
 440 static void
 441 hangup(int s)
 442 {
 443    NYD_X; /* Signal handler */
 444    UNUSED(s);
 445    /* nothing to do? */
 446    exit(1);
 447 }
 448
 449 FL int
 450 setfile(char const *name, int nmail) /* TODO oh my god */
 451 {
 452    static int shudclob;
 453
 454    struct stat stb;
 455    struct flock flp;
 456    FILE *ibuf = NULL;
 457    int rv, i, compressed = 0, omsgCount = 0;
 458    bool_t isedit;
 459    char const *who;
 460    size_t offset;
 461    struct shortcut *sh;
 462    NYD_ENTER;
 463
 464    /* Note we don't 'userid(myname) != getuid()', preliminary steps are usually
 465     * necessary to make a mailbox accessible by a different user, and if that
 466     * has happened, let's just let the usual file perms decide */
 467    who = (name[1] != '\0') ? name + 1 : myname;
 468    isedit = (*name != '%' && ((sh = get_shortcut(name)) == NULL ||
 469          *sh->sh_long != '%'));
 470    if ((name = expand(name)) == NULL)
 471       goto jem1;
 472
 473    switch (which_protocol(name)) {
 474    case PROTO_FILE:
 475       break;
 476    case PROTO_MAILDIR:
 477       rv = maildir_setfile(name, nmail, isedit);
 478       goto jleave;
 479 #ifdef HAVE_POP3
 480    case PROTO_POP3:
 481       shudclob = 1;
 482       rv = pop3_setfile(name, nmail, isedit);
 483       goto jleave;
 484 #endif
 485 #ifdef HAVE_IMAP
 486    case PROTO_IMAP:
 487       shudclob = 1;
 488       if (nmail && mb.mb_type == MB_CACHE)
 489          rv = 1;
 490       else
 491          rv = imap_setfile(name, nmail, isedit);
 492       goto jleave;
 493 #endif
 494    default:
 495       fprintf(stderr, tr(217, "Cannot handle protocol: %s\n"), name);
 496       goto jem1;
 497    }
 498
 499    /* FIXME this FILE leaks if quit()->edstop() reset()s!  This entire code
 500     * FIXME here is total crap, below we open(2) the same name again just to
 501     * FIXME close it right away etc.  The normal thing would be to (1) finalize
 502     * FIXME the current box and (2) open the new box; yet, since (2) may fail
 503     * FIXME we terribly need our VOID box to make this logic order possible! */
 504    if ((ibuf = Zopen(name, "r", &compressed)) == NULL) {
 505       if ((!isedit && errno == ENOENT) || nmail) {
 506          if (nmail)
 507             goto jnonmail;
 508          goto jnomail;
 509       }
 510       perror(name);
 511       goto jem1;
 512    }
 513
 514    if (fstat(fileno(ibuf), &stb) == -1) {
 515       if (nmail)
 516          goto jnonmail;
 517       perror("fstat");
 518       goto jem1;
 519    }
 520
 521    if (S_ISREG(stb.st_mode) ||
 522          ((options & OPT_BATCH_FLAG) && !strcmp(name, "/dev/null"))) {
 523       /* EMPTY */
 524    } else {
 525       if (nmail)
 526          goto jnonmail;
 527       errno = S_ISDIR(stb.st_mode) ? EISDIR : EINVAL;
 528       perror(name);
 529       goto jem1;
 530    }
 531
 532    /* Looks like all will be well.  We must now relinquish our hold on the
 533     * current set of stuff.  Must hold signals while we are reading the new
 534     * file, else we will ruin the message[] data structure */
 535
 536    hold_sigs(); /* TODO note on this one in quit.c:quit() */
 537    if (shudclob && !nmail)
 538       quit();
 539 #ifdef HAVE_SOCKETS
 540    if (!nmail && mb.mb_sock.s_fd >= 0)
 541       sclose(&mb.mb_sock); /* TODO sorry? VMAILFS->close(), thank you */
 542 #endif
 543
 544    /* Copy the messages into /tmp and set pointers */
 545    flp.l_type = F_RDLCK;
 546    flp.l_start = 0;
 547    flp.l_whence = SEEK_SET;
 548    if (!nmail) {
 549       mb.mb_type = MB_FILE;
 550       mb.mb_perm = (options & OPT_R_FLAG) ? 0 : MB_DELE | MB_EDIT;
 551       mb.mb_compressed = compressed;
 552       if (compressed) {
 553          if (compressed & 0200)
 554             mb.mb_perm = 0;
 555       } else {
 556          if ((i = open(name, O_WRONLY)) == -1)
 557             mb.mb_perm = 0;
 558          else
 559             close(i);
 560       }
 561       if (shudclob) {
 562          if (mb.mb_itf) {
 563             fclose(mb.mb_itf);
 564             mb.mb_itf = NULL;
 565          }
 566          if (mb.mb_otf) {
 567             fclose(mb.mb_otf);
 568             mb.mb_otf = NULL;
 569          }
 570       }
 571       shudclob = 1;
 572       edit = isedit;
 573       initbox(name);
 574       offset = 0;
 575       flp.l_len = 0;
 576       if (!edit && fcntl(fileno(ibuf), F_SETLKW, &flp) == -1) {/*TODO dotlock!*/
 577          perror("Unable to lock mailbox");
 578          rele_sigs();
 579          goto jem1;
 580       }
 581    } else /* nmail */{
 582       fseek(mb.mb_otf, 0L, SEEK_END);
 583       fseek(ibuf, mailsize, SEEK_SET);
 584       offset = mailsize;
 585       omsgCount = msgCount;
 586       flp.l_len = offset;
 587       if (!edit && fcntl(fileno(ibuf), F_SETLKW, &flp) == -1) {/*TODO dotlock!*/
 588          rele_sigs();
 589          goto jnonmail;
 590       }
 591    }
 592    mailsize = fsize(ibuf);
 593
 594    if (nmail && UICMP(z, mailsize, <=, offset)) {
 595       rele_sigs();
 596       goto jnonmail;
 597    }
 598    setptr(ibuf, offset);
 599    setmsize(msgCount);
 600    if (nmail && mb.mb_sorted) {
 601       mb.mb_threaded = 0;
 602       c_sort((void*)-1);
 603    }
 604
 605    Fclose(ibuf);
 606    ibuf = NULL;
 607    rele_sigs();
 608    if (!nmail)
 609       sawcom = FAL0;
 610
 611    if ((!edit || nmail) && msgCount == 0) {
 612 jnonmail:
 613       if (!nmail) {
 614          if (!ok_blook(emptystart))
 615 jnomail:
 616             fprintf(stderr, tr(88, "No mail for %s\n"), who);
 617       }
 618       rv = 1;
 619       goto jleave;
 620    }
 621    if (nmail)
 622       newmailinfo(omsgCount);
 623
 624    rv = 0;
 625 jleave:
 626    if (ibuf != NULL)
 627       Fclose(ibuf);
 628    NYD_LEAVE;
 629    return rv;
 630 jem1:
 631    rv = -1;
 632    goto jleave;
 633 }
 634
 635 FL int
 636 newmailinfo(int omsgCount)
 637 {
 638    int mdot, i;
 639    NYD_ENTER;
 640
 641    for (i = 0; i < omsgCount; ++i)
 642       message[i].m_flag &= ~MNEWEST;
 643    if (msgCount > omsgCount) {
 644       for (i = omsgCount; i < msgCount; ++i)
 645          message[i].m_flag |= MNEWEST;
 646       printf(tr(158, "New mail has arrived.\n"));
 647       if ((i = msgCount - omsgCount) == 1)
 648          printf(tr(214, "Loaded 1 new message.\n"));
 649       else
 650          printf(tr(215, "Loaded %d new messages.\n"), i);
 651    } else
 652       printf(tr(224, "Loaded %d messages.\n"), msgCount);
 653    callhook(mailname, 1);
 654    mdot = getmdot(1);
 655    if (ok_blook(header))
 656       print_headers(omsgCount + 1, msgCount, FAL0);
 657    NYD_LEAVE;
 658    return mdot;
 659 }
 660
 661 FL void
 662 commands(void)
 663 {
 664    struct eval_ctx ev;
 665    int n;
 666    NYD_ENTER;
 667
 668    if (!sourcing) {
 669       if (safe_signal(SIGINT, SIG_IGN) != SIG_IGN)
 670          safe_signal(SIGINT, onintr);
 671       if (safe_signal(SIGHUP, SIG_IGN) != SIG_IGN)
 672          safe_signal(SIGHUP, hangup);
 673       /* TODO We do a lot of redundant signal handling, especially
 674        * TODO with the command line editor(s); try to merge this */
 675       safe_signal(SIGTSTP, stop);
 676       safe_signal(SIGTTOU, stop);
 677       safe_signal(SIGTTIN, stop);
 678    }
 679    _oldpipe = safe_signal(SIGPIPE, SIG_IGN);
 680    safe_signal(SIGPIPE, _oldpipe);
 681
 682    memset(&ev, 0, sizeof ev);
 683
 684    setexit();
 685    for (;;) {
 686       interrupts = 0;
 687       handlerstacktop = NULL;
 688
 689       if (!sourcing && (options & OPT_INTERACTIVE)) {
 690          char *cp;
 691
 692          cp = ok_vlook(newmail);
 693          if ((options & OPT_TTYIN) && (cp != NULL || mb.mb_type == MB_IMAP)) {
 694             struct stat st;
 695
 696             n = (cp != NULL && strcmp(cp, "noimap") && strcmp(cp, "nopoll"));
 697             if ((mb.mb_type == MB_FILE && !stat(mailname, &st) &&
 698                      st.st_size > mailsize) ||
 699 #ifdef HAVE_IMAP
 700                   (mb.mb_type == MB_IMAP && imap_newmail(n) > (cp == NULL)) ||
 701 #endif
 702                   (mb.mb_type == MB_MAILDIR && n != 0)) {
 703                size_t odot = PTR2SIZE(dot - message);
 704                bool_t odid = did_print_dot;
 705
 706                setfile(mailname, 1);
 707                if (mb.mb_type != MB_IMAP) {
 708                   dot = message + odot;
 709                   did_print_dot = odid;
 710                }
 711             }
 712          }
 713
 714          _reset_on_stop = 1;
 715          exit_status = EXIT_OK;
 716       }
 717
 718 #ifdef HAVE_COLOUR
 719       colour_table = NULL; /* XXX intermediate hack */
 720 #endif
 721       if (temporary_localopts_store != NULL) /* XXX intermediate hack */
 722          temporary_localopts_free(); /* XXX intermediate hack */
 723       sreset(sourcing);
 724       if (!sourcing) {
 725          char *cp;
 726
 727          /* TODO Note: this buffer may contain a password.  We should redefine
 728           * TODO the code flow which has to do that */
 729          if ((cp = termios_state.ts_linebuf) != NULL) {
 730             termios_state.ts_linebuf = NULL;
 731             termios_state.ts_linesize = 0;
 732             free(cp); /* TODO pool give-back */
 733          }
 734          /* TODO Due to expand-on-tab of NCL the buffer may grow */
 735          if (ev.ev_line.l > LINESIZE * 3) {
 736             free(ev.ev_line.s); /* TODO pool! but what? */
 737             ev.ev_line.s = NULL;
 738             ev.ev_line.l = 0;
 739          }
 740       }
 741
 742       /* Read a line of commands and handle end of file specially */
 743 jreadline:
 744       n = readline_input(NULL, TRU1, &ev.ev_line.s, &ev.ev_line.l,
 745             ev.ev_new_content);
 746       _reset_on_stop = 0;
 747       if (n < 0) {
 748          /* EOF */
 749          if (loading)
 750             break;
 751          if (sourcing) {
 752             unstack();
 753             continue;
 754          }
 755          if ((options & OPT_INTERACTIVE) && ok_blook(ignoreeof)) {
 756             printf(tr(89, "Use `quit' to quit.\n"));
 757             continue;
 758          }
 759          break;
 760       }
 761
 762       inhook = 0;
 763       if (evaluate(&ev))
 764          break;
 765       if ((options & OPT_BATCH_FLAG) && ok_blook(batch_exit_on_error)) {
 766          if (exit_status != EXIT_OK)
 767             break;
 768          /* TODO *batch-exit-on-error*: sourcing and loading MUST BE FLAGS!
 769           * TODO the current behaviour is suboptimal AT BEST! */
 770          if (exec_last_comm_error != 0 && !sourcing && !loading) {
 771             exit_status = EXIT_ERR;
 772             break;
 773          }
 774       }
 775       if (!sourcing && (options & OPT_INTERACTIVE)) {
 776          if (ev.ev_new_content != NULL)
 777             goto jreadline;
 778          if (ev.ev_add_history)
 779             tty_addhist(ev.ev_line.s);
 780       }
 781    }
 782
 783    if (ev.ev_line.s != NULL)
 784       free(ev.ev_line.s);
 785    if (sourcing)
 786       sreset(FAL0);
 787    NYD_LEAVE;
 788 }
 789
 790 FL int
 791 execute(char *linebuf, int contxt, size_t linesize) /* XXX LEGACY */
 792 {
 793    struct eval_ctx ev;
 794 #ifdef HAVE_COLOUR
 795    struct colour_table *ct_save;
 796 #endif
 797    int rv;
 798    NYD_ENTER;
 799
 800    /* TODO Maybe recursion from within collect.c!  As long as we don't have
 801     * TODO a value carrier that transports the entire state of a recursion
 802     * TODO we need to save away also the colour table */
 803 #ifdef HAVE_COLOUR
 804    ct_save = colour_table;
 805    colour_table = NULL;
 806 #endif
 807
 808    memset(&ev, 0, sizeof ev);
 809    ev.ev_line.s = linebuf;
 810    ev.ev_line.l = linesize;
 811    ev.ev_is_recursive = (contxt != 0);
 812    rv = evaluate(&ev);
 813
 814 #ifdef HAVE_COLOUR
 815    colour_table = ct_save;
 816 #endif
 817    NYD_LEAVE;
 818    return rv;
 819 }
 820
 821 FL int
 822 evaluate(struct eval_ctx *evp)
 823 {
 824    struct str line;
 825    char _wordbuf[2], *arglist[MAXARGC], *cp, *word;
 826    struct cmd_ghost *cg = NULL;
 827    struct cmd const *com = NULL;
 828    int muvec[2], c, e = 1;
 829    NYD_ENTER;
 830
 831    line = evp->ev_line; /* XXX don't change original (buffer pointer) */
 832    evp->ev_add_history = FAL0;
 833    evp->ev_new_content = NULL;
 834
 835    /* Command ghosts that refer to shell commands or macro expansion restart */
 836 jrestart:
 837
 838    /* Strip the white space away from the beginning of the command */
 839    for (cp = line.s; whitechar(*cp); ++cp)
 840       ;
 841    line.l -= PTR2SIZE(cp - line.s);
 842
 843    /* Ignore comments */
 844    if (*cp == '#')
 845       goto jleave0;
 846
 847    /* Handle ! differently to get the correct lexical conventions */
 848    if (*cp == '!') {
 849       if (sourcing) {
 850          fprintf(stderr, tr(90, "Can't `!' while sourcing\n"));
 851          goto jleave;
 852       }
 853       c_shell(++cp);
 854       evp->ev_add_history = TRU1;
 855       goto jleave0;
 856    }
 857
 858    /* Isolate the actual command; since it may not necessarily be
 859     * separated from the arguments (as in `p1') we need to duplicate it to
 860     * be able to create a NUL terminated version.
 861     * We must be aware of several special one letter commands here */
 862    arglist[0] = cp;
 863    if ((cp = _lex_isolate(cp)) == arglist[0] &&
 864          (*cp == '|' || *cp == '~' || *cp == '?'))
 865       ++cp;
 866    c = (int)PTR2SIZE(cp - arglist[0]);
 867    line.l -= c;
 868    word = UICMP(z, c, <, sizeof _wordbuf) ? _wordbuf : salloc(c +1);
 869    memcpy(word, arglist[0], c);
 870    word[c] = '\0';
 871
 872    /* Look up the command; if not found, bitch.
 873     * Normally, a blank command would map to the first command in the
 874     * table; while sourcing, however, we ignore blank lines to eliminate
 875     * confusion; act just the same for ghosts */
 876    if (*word == '\0') {
 877       if (sourcing || cg != NULL)
 878          goto jleave0;
 879       com = _cmd_tab + 0;
 880       goto jexec;
 881    }
 882
 883    /* If this is the first evaluation, check command ghosts */
 884    if (cg == NULL) {
 885       /* TODO relink list head, so it's sorted on usage over time?
 886        * TODO in fact, there should be one hashmap over all commands and ghosts
 887        * TODO so that the lookup could be made much more efficient than it is
 888        * TODO now (two adjacent list searches! */
 889       for (cg = _cmd_ghosts; cg != NULL; cg = cg->next)
 890          if (!strcmp(word, cg->name)) {
 891             if (line.l > 0) {
 892                size_t i = cg->cmd.l;
 893                line.s = salloc(i + 1 + line.l +1);
 894                memcpy(line.s, cg->cmd.s, i);
 895                line.s[i++] = ' ';
 896                memcpy(line.s + i, cp, line.l);
 897                line.s[i += line.l] = '\0';
 898                line.l = i;
 899             } else {
 900                line.s = cg->cmd.s;
 901                line.l = cg->cmd.l;
 902             }
 903             goto jrestart;
 904          }
 905    }
 906
 907    if ((com = _lex(word)) == NULL || com->func == &c_cmdnotsupp) {
 908       fprintf(stderr, tr(91, "Unknown command: `%s'\n"), word);
 909       if (com != NULL) {
 910          c_cmdnotsupp(NULL);
 911          com = NULL;
 912       }
 913       goto jleave;
 914    }
 915
 916    /* See if we should execute the command -- if a conditional we always
 917     * execute it, otherwise, check the state of cond */
 918 jexec:
 919    if (!(com->argtype & ARG_F) && condstack_isskip())
 920       goto jleave0;
 921
 922    /* Process the arguments to the command, depending on the type it expects,
 923     * default to error.  If we're sourcing an interactive command: error */
 924    if ((options & OPT_SENDMODE) && !(com->argtype & ARG_M)) {
 925       fprintf(stderr, tr(92, "May not execute `%s' while sending\n"),
 926          com->name);
 927       goto jleave;
 928    }
 929    if (sourcing && (com->argtype & ARG_I)) {
 930       fprintf(stderr, tr(93, "May not execute `%s' while sourcing\n"),
 931          com->name);
 932       goto jleave;
 933    }
 934    if (!(mb.mb_perm & MB_DELE) && (com->argtype & ARG_W)) {
 935       fprintf(stderr, tr(94, "May not execute `%s' -- "
 936          "message file is read only\n"), com->name);
 937       goto jleave;
 938    }
 939    if (evp->ev_is_recursive && (com->argtype & ARG_R)) {
 940       fprintf(stderr, tr(95, "Cannot recursively invoke `%s'\n"), com->name);
 941       goto jleave;
 942    }
 943    if (mb.mb_type == MB_VOID && (com->argtype & ARG_A)) {
 944       fprintf(stderr, tr(257, "Cannot execute `%s' without active mailbox\n"),
 945          com->name);
 946       goto jleave;
 947    }
 948
 949    if (com->argtype & ARG_V)
 950       temporary_arg_v_store = NULL;
 951
 952    switch (com->argtype & ARG_ARGMASK) {
 953    case ARG_MSGLIST:
 954       /* Message list defaulting to nearest forward legal message */
 955       if (_msgvec == NULL)
 956          goto je96;
 957       if ((c = getmsglist(cp, _msgvec, com->msgflag)) < 0)
 958          break;
 959       if (c == 0) {
 960          *_msgvec = first(com->msgflag, com->msgmask);
 961          if (*_msgvec != 0)
 962             _msgvec[1] = 0;
 963       }
 964       if (*_msgvec == 0) {
 965          if (!inhook)
 966             printf(tr(97, "No applicable messages\n"));
 967          break;
 968       }
 969       e = (*com->func)(_msgvec);
 970       break;
 971
 972    case ARG_NDMLIST:
 973       /* Message list with no defaults, but no error if none exist */
 974       if (_msgvec == NULL) {
 975 je96:
 976          fprintf(stderr, tr(96, "Illegal use of `message list'\n"));
 977          break;
 978       }
 979       if ((c = getmsglist(cp, _msgvec, com->msgflag)) < 0)
 980          break;
 981       e = (*com->func)(_msgvec);
 982       break;
 983
 984    case ARG_STRLIST:
 985       /* Just the straight string, with leading blanks removed */
 986       while (whitechar(*cp))
 987          ++cp;
 988       e = (*com->func)(cp);
 989       break;
 990
 991    case ARG_RAWLIST:
 992    case ARG_ECHOLIST:
 993       /* A vector of strings, in shell style */
 994       if ((c = getrawlist(cp, line.l, arglist, NELEM(arglist),
 995             ((com->argtype & ARG_ARGMASK) == ARG_ECHOLIST))) < 0)
 996          break;
 997       if (c < com->minargs) {
 998          fprintf(stderr, tr(99, "`%s' requires at least %d arg(s)\n"),
 999             com->name, com->minargs);
1000          break;
1001       }
1002       if (c > com->maxargs) {
1003          fprintf(stderr, tr(100, "`%s' takes no more than %d arg(s)\n"),
1004             com->name, com->maxargs);
1005          break;
1006       }
1007       e = (*com->func)(arglist);
1008       break;
1009
1010    case ARG_NOLIST:
1011       /* Just the constant zero, for exiting, eg. */
1012       e = (*com->func)(0);
1013       break;
1014
1015    default:
1016       panic(tr(101, "Unknown argument type"));
1017    }
1018
1019    if (e == 0 && (com->argtype & ARG_V) &&
1020          (cp = temporary_arg_v_store) != NULL) {
1021       temporary_arg_v_store = NULL;
1022       evp->ev_new_content = cp;
1023       goto jleave0;
1024    }
1025    if (!(com->argtype & ARG_H) && !list_saw_numbers)
1026       evp->ev_add_history = TRU1;
1027
1028 jleave:
1029    /* Exit the current source file on error */
1030    if ((exec_last_comm_error = (e != 0))) {
1031       if (e < 0 || loading) {
1032          e = 1;
1033          goto jret;
1034       }
1035       if (sourcing)
1036          unstack();
1037       goto jret0;
1038    }
1039    if (com == NULL)
1040       goto jret0;
1041    if ((com->argtype & ARG_P) && ok_blook(autoprint))
1042       if (visible(dot)) {
1043          muvec[0] = (int)PTR2SIZE(dot - message + 1);
1044          muvec[1] = 0;
1045          c_type(muvec); /* TODO what if error?  re-eval! */
1046       }
1047    if (!sourcing && !inhook && !(com->argtype & ARG_T))
1048       sawcom = TRU1;
1049 jleave0:
1050    exec_last_comm_error = 0;
1051 jret0:
1052    e = 0;
1053 jret:
1054    NYD_LEAVE;
1055    return e;
1056 }
1057
1058 FL void
1059 setmsize(int sz)
1060 {
1061    NYD_ENTER;
1062    if (_msgvec != NULL)
1063       free(_msgvec);
1064    _msgvec = scalloc(sz + 1, sizeof *_msgvec);
1065    NYD_LEAVE;
1066 }
1067
1068 FL void
1069 print_header_summary(char const *Larg)
1070 {
1071    size_t bot, top, i, j;
1072    NYD_ENTER;
1073
1074    if (Larg != NULL) {
1075       /* Avoid any messages XXX add a make_mua_silent() and use it? */
1076       if ((options & (OPT_VERBOSE | OPT_HEADERSONLY)) == OPT_HEADERSONLY) {
1077          freopen("/dev/null", "w", stdout);
1078          freopen("/dev/null", "w", stderr);
1079       }
1080       i = (getmsglist(/*TODO make arg const */UNCONST(Larg), _msgvec, 0) <= 0);
1081       if (options & OPT_HEADERSONLY) {
1082          exit_status = (int)i;
1083          goto jleave;
1084       }
1085       if (i)
1086          goto jleave;
1087       for (bot = msgCount, top = 0, i = 0; (j = _msgvec[i]) != 0; ++i) {
1088          if (bot > j)
1089             bot = j;
1090          if (top < j)
1091             top = j;
1092       }
1093    } else
1094       bot = 1, top = msgCount;
1095    print_headers(bot, top, (Larg != NULL)); /* TODO should take iterator!! */
1096 jleave:
1097    NYD_LEAVE;
1098 }
1099
1100 FL void
1101 onintr(int s)
1102 {
1103    NYD_X; /* Signal handler */
1104
1105    if (handlerstacktop != NULL) {
1106       handlerstacktop(s);
1107       return;
1108    }
1109    safe_signal(SIGINT, onintr);
1110    noreset = 0;
1111    if (!_lex_inithdr)
1112       sawcom = TRU1;
1113    _lex_inithdr = 0;
1114    while (sourcing)
1115       unstack();
1116
1117    termios_state_reset();
1118    close_all_files();
1119
1120    if (image >= 0) {
1121       close(image);
1122       image = -1;
1123    }
1124    if (interrupts != 1)
1125       fprintf(stderr, tr(102, "Interrupt\n"));
1126    safe_signal(SIGPIPE, _oldpipe);
1127    reset(0);
1128 }
1129
1130 FL void
1131 announce(int printheaders)
1132 {
1133    int vec[2], mdot;
1134    NYD_ENTER;
1135
1136    mdot = newfileinfo();
1137    vec[0] = mdot;
1138    vec[1] = 0;
1139    dot = message + mdot - 1;
1140    if (printheaders && msgCount > 0 && ok_blook(header)) {
1141       ++_lex_inithdr;
1142       c_headers(vec); /* XXX errors? */
1143       _lex_inithdr = 0;
1144    }
1145    NYD_LEAVE;
1146 }
1147
1148 FL int
1149 newfileinfo(void)
1150 {
1151    struct message *mp;
1152    int u, n, mdot, d, s, hidden, moved;
1153    NYD_ENTER;
1154
1155    if (mb.mb_type == MB_VOID) {
1156       mdot = 1;
1157       goto jleave;
1158    }
1159
1160    mdot = getmdot(0);
1161    s = d = hidden = moved =0;
1162    for (mp = message, n = 0, u = 0; PTRCMP(mp, <, message + msgCount); ++mp) {
1163       if (mp->m_flag & MNEW)
1164          ++n;
1165       if ((mp->m_flag & MREAD) == 0)
1166          ++u;
1167       if ((mp->m_flag & (MDELETED | MSAVED)) == (MDELETED | MSAVED))
1168          ++moved;
1169       if ((mp->m_flag & (MDELETED | MSAVED)) == MDELETED)
1170          ++d;
1171       if ((mp->m_flag & (MDELETED | MSAVED)) == MSAVED)
1172          ++s;
1173       if (mp->m_flag & MHIDDEN)
1174          ++hidden;
1175    }
1176
1177    /* If displayname gets truncated the user effectively has no option to see
1178     * the full pathname of the mailbox, so print it at least for '? fi' */
1179    printf(tr(103, "\"%s\": "),
1180       (_update_mailname(NULL) ? displayname : mailname));
1181    if (msgCount == 1)
1182       printf(tr(104, "1 message"));
1183    else
1184       printf(tr(105, "%d messages"), msgCount);
1185    if (n > 0)
1186       printf(tr(106, " %d new"), n);
1187    if (u-n > 0)
1188       printf(tr(107, " %d unread"), u);
1189    if (d > 0)
1190       printf(tr(108, " %d deleted"), d);
1191    if (s > 0)
1192       printf(tr(109, " %d saved"), s);
1193    if (moved > 0)
1194       printf(tr(136, " %d moved"), moved);
1195    if (hidden > 0)
1196       printf(tr(139, " %d hidden"), hidden);
1197    if (mb.mb_type == MB_CACHE)
1198       printf(" [Disconnected]");
1199    else if (mb.mb_perm == 0)
1200       printf(tr(110, " [Read only]"));
1201    printf("\n");
1202 jleave:
1203    NYD_LEAVE;
1204    return mdot;
1205 }
1206
1207 FL int
1208 getmdot(int nmail)
1209 {
1210    struct message *mp;
1211    char *cp;
1212    int mdot;
1213    enum mflag avoid = MHIDDEN | MDELETED;
1214    NYD_ENTER;
1215
1216    if (!nmail) {
1217       if (ok_blook(autothread))
1218          c_thread(NULL);
1219       else if ((cp = ok_vlook(autosort)) != NULL) {
1220          free(mb.mb_sorted);
1221          mb.mb_sorted = sstrdup(cp);
1222          c_sort(NULL);
1223       }
1224    }
1225    if (mb.mb_type == MB_VOID) {
1226       mdot = 1;
1227       goto jleave;
1228    }
1229
1230    if (nmail)
1231       for (mp = message; PTRCMP(mp, <, message + msgCount); ++mp)
1232          if ((mp->m_flag & (MNEWEST | avoid)) == MNEWEST)
1233             break;
1234
1235    if (!nmail || PTRCMP(mp, >=, message + msgCount)) {
1236       if (mb.mb_threaded) {
1237          for (mp = threadroot; mp != NULL; mp = next_in_thread(mp))
1238             if ((mp->m_flag & (MNEW | avoid)) == MNEW)
1239                break;
1240       } else {
1241          for (mp = message; PTRCMP(mp, <, message + msgCount); ++mp)
1242             if ((mp->m_flag & (MNEW | avoid)) == MNEW)
1243                break;
1244       }
1245    }
1246
1247    if ((mb.mb_threaded ? (mp == NULL) : PTRCMP(mp, >=, message + msgCount))) {
1248       if (mb.mb_threaded) {
1249          for (mp = threadroot; mp != NULL; mp = next_in_thread(mp))
1250             if (mp->m_flag & MFLAGGED)
1251                break;
1252       } else {
1253          for (mp = message; PTRCMP(mp, <, message + msgCount); ++mp)
1254             if (mp->m_flag & MFLAGGED)
1255                break;
1256       }
1257    }
1258
1259    if ((mb.mb_threaded ? (mp == NULL) : PTRCMP(mp, >=, message + msgCount))) {
1260       if (mb.mb_threaded) {
1261          for (mp = threadroot; mp != NULL; mp = next_in_thread(mp))
1262             if (!(mp->m_flag & (MREAD | avoid)))
1263                break;
1264       } else {
1265          for (mp = message; PTRCMP(mp, <, message + msgCount); ++mp)
1266             if (!(mp->m_flag & (MREAD | avoid)))
1267                break;
1268       }
1269    }
1270
1271    if ((mb.mb_threaded ? (mp != NULL) : PTRCMP(mp, <, message + msgCount)))
1272       mdot = (int)PTR2SIZE(mp - message + 1);
1273    else if (ok_blook(showlast)) {
1274       if (mb.mb_threaded) {
1275          for (mp = this_in_thread(threadroot, -1); mp;
1276                mp = prev_in_thread(mp))
1277             if (!(mp->m_flag & avoid))
1278                break;
1279          mdot = (mp != NULL) ? (int)PTR2SIZE(mp - message + 1) : msgCount;
1280       } else {
1281          for (mp = message + msgCount - 1; mp >= message; --mp)
1282             if (!(mp->m_flag & avoid))
1283                break;
1284          mdot = (mp >= message) ? (int)PTR2SIZE(mp - message + 1) : msgCount;
1285       }
1286    } else if (mb.mb_threaded) {
1287       for (mp = threadroot; mp; mp = next_in_thread(mp))
1288          if (!(mp->m_flag & avoid))
1289             break;
1290       mdot = (mp != NULL) ? (int)PTR2SIZE(mp - message + 1) : 1;
1291    } else {
1292       for (mp = message; PTRCMP(mp, <, message + msgCount); ++mp)
1293          if (!(mp->m_flag & avoid))
1294             break;
1295       mdot = PTRCMP(mp, <, message + msgCount)
1296             ? (int)PTR2SIZE(mp - message + 1) : 1;
1297    }
1298 jleave:
1299    NYD_LEAVE;
1300    return mdot;
1301 }
1302
1303 FL void
1304 initbox(char const *name)
1305 {
1306    char *tempMesg;
1307    NYD_ENTER;
1308
1309    if (mb.mb_type != MB_VOID)
1310       n_strlcpy(prevfile, mailname, PATH_MAX);
1311
1312    _update_mailname((name != mailname) ? name : NULL);
1313
1314    if ((mb.mb_otf = Ftmp(&tempMesg, "tmpbox", OF_WRONLY | OF_HOLDSIGS, 0600)) ==
1315          NULL) {
1316       perror(tr(87, "temporary mail message file"));
1317       exit(1);
1318    }
1319    if ((mb.mb_itf = safe_fopen(tempMesg, "r", NULL)) == NULL) {
1320       perror(tr(87, "temporary mail message file"));
1321       exit(1);
1322    }
1323    Ftmp_release(&tempMesg);
1324
1325    message_reset();
1326    mb.mb_threaded = 0;
1327    if (mb.mb_sorted != NULL) {
1328       free(mb.mb_sorted);
1329       mb.mb_sorted = NULL;
1330    }
1331 #ifdef HAVE_IMAP
1332    mb.mb_flags = MB_NOFLAGS;
1333 #endif
1334    prevdot = NULL;
1335    dot = NULL;
1336    did_print_dot = FAL0;
1337    NYD_LEAVE;
1338 }
1339
1340 #ifdef HAVE_DOCSTRINGS
1341 FL bool_t
1342 print_comm_docstr(char const *comm)
1343 {
1344    bool_t rv = FAL0;
1345    struct cmd_ghost *cg;
1346    struct cmd const *cp;
1347    NYD_ENTER;
1348
1349    /* Ghosts take precedence */
1350    for (cg = _cmd_ghosts; cg != NULL; cg = cg->next)
1351       if (!strcmp(comm, cg->name)) {
1352          printf("%s -> <%s>\n", comm, cg->cmd.s);
1353          rv = TRU1;
1354          goto jleave;
1355       }
1356
1357    for (cp = _cmd_tab; cp->name != NULL; ++cp) {
1358       if (cp->func == &c_cmdnotsupp)
1359          continue;
1360       if (!strcmp(comm, cp->name))
1361          printf("%s: %s\n", comm, tr(cp->docid, cp->doc));
1362       else if (is_prefix(comm, cp->name))
1363          printf("%s (%s): %s\n", comm, cp->name, tr(cp->docid, cp->doc));
1364       else
1365          continue;
1366       rv = TRU1;
1367       break;
1368    }
1369 jleave:
1370    NYD_LEAVE;
1371    return rv;
1372 }
1373 #endif
1374
1375 /* vim:set fenc=utf-8:s-it-mode */