tty.c

   1 /*@ S-nail - a mail user agent derived from Berkeley Mail.
   2  *@ TTY interaction.
   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 /* The NCL version is
   8  *
   9  * Copyright (c) 2013 - 2014 Steffen (Daode) Nurpmeso <sdaoden@users.sf.net>.
  10  *
  11  * Permission to use, copy, modify, and/or distribute this software for any
  12  * purpose with or without fee is hereby granted, provided that the above
  13  * copyright notice and this permission notice appear in all copies.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  16  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  17  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  18  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  21  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22  */
  23 /*
  24  * Copyright (c) 1980, 1993
  25  * The Regents of the University of California.  All rights reserved.
  26  *
  27  * Redistribution and use in source and binary forms, with or without
  28  * modification, are permitted provided that the following conditions
  29  * are met:
  30  * 1. Redistributions of source code must retain the above copyright
  31  *    notice, this list of conditions and the following disclaimer.
  32  * 2. Redistributions in binary form must reproduce the above copyright
  33  *    notice, this list of conditions and the following disclaimer in the
  34  *    documentation and/or other materials provided with the distribution.
  35  * 3. All advertising materials mentioning features or use of this software
  36  *    must display the following acknowledgement:
  37  *    This product includes software developed by the University of
  38  *    California, Berkeley and its contributors.
  39  * 4. Neither the name of the University nor the names of its contributors
  40  *    may be used to endorse or promote products derived from this software
  41  *    without specific prior written permission.
  42  *
  43  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  44  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  45  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  46  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  47  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  48  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  49  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  50  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  51  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  52  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  53  * SUCH DAMAGE.
  54  */
  55
  56 #ifndef HAVE_AMALGAMATION
  57 # include "nail.h"
  58 #endif
  59
  60 #ifdef HAVE_READLINE
  61 # include <readline/readline.h>
  62 # ifdef HAVE_HISTORY
  63 #  include <readline/history.h>
  64 # endif
  65 #elif defined HAVE_EDITLINE
  66 # include <histedit.h>
  67 #endif
  68
  69 /* Shared history support macros */
  70 #ifdef HAVE_HISTORY
  71 # define _CL_HISTFILE(S) \
  72 do {\
  73    S = ok_vlook(NAIL_HISTFILE);\
  74    if ((S) != NULL)\
  75       S = fexpand(S, FEXP_LOCAL);\
  76 } while (0)
  77
  78 # define _CL_HISTSIZE(V) \
  79 do {\
  80    char const *__sv = ok_vlook(NAIL_HISTSIZE);\
  81    long __rv;\
  82    if (__sv == NULL || *__sv == '\0' || (__rv = strtol(__sv, NULL, 10)) == 0)\
  83       (V) = HIST_SIZE;\
  84    else if (__rv < 0)\
  85       (V) = 0;\
  86    else\
  87       (V) = __rv;\
  88 } while (0)
  89
  90 # define _CL_CHECK_ADDHIST(S,NOACT) \
  91 do {\
  92    switch (*(S)) {\
  93    case '\0':\
  94    case ' ':\
  95       NOACT;\
  96    default:\
  97       break;\
  98    }\
  99 } while (0)
 100
 101 # define C_HISTORY_SHARED \
 102    char **argv = v;\
 103    long entry;\
 104    NYD_ENTER;\
 105 \
 106    if (*argv == NULL)\
 107       goto jlist;\
 108    if (argv[1] != NULL)\
 109       goto jerr;\
 110    if (!asccasecmp(*argv, "show"))\
 111       goto jlist;\
 112    if (!asccasecmp(*argv, "clear"))\
 113       goto jclear;\
 114    if ((entry = strtol(*argv, argv, 10)) > 0 && **argv == '\0')\
 115       goto jentry;\
 116 jerr:\
 117    fprintf(stderr, "Synopsis: history: %s\n", tr(431,\
 118       "<show> (default), <clear> or select <NO> from editor history"));\
 119    v = NULL;\
 120 jleave:\
 121    NYD_LEAVE;\
 122    return (v == NULL ? !STOP : !OKAY); /* xxx 1:bad 0:good -- do some */
 123 #endif /* HAVE_HISTORY */
 124
 125 /* fexpand() flags for expand-on-tab */
 126 #define _CL_TAB_FEXP_FL (FEXP_FULL | FEXP_SILENT | FEXP_MULTIOK)
 127
 128 /*
 129  * Because we have multiple identical implementations, change file layout a bit
 130  * and place the implementations one after the other below the other externals
 131  */
 132
 133 static sigjmp_buf __tty_actjmp; /* TODO someday, we won't need it no more */
 134 static void
 135 __tty_acthdl(int s) /* TODO someday, we won't need it no more */
 136 {
 137    NYD_X; /* Signal handler */
 138    termios_state_reset();
 139    siglongjmp(__tty_actjmp, s);
 140 }
 141
 142 FL bool_t
 143 getapproval(char const * volatile prompt, bool_t noninteract_default)
 144 {
 145    sighandler_type volatile ohdl;
 146    bool_t volatile hadsig = FAL0, rv;
 147    NYD_ENTER;
 148
 149    if (!(options & OPT_INTERACTIVE)) {
 150       rv = noninteract_default;
 151       goto jleave;
 152    }
 153    rv = FAL0;
 154
 155    if (prompt == NULL)
 156       prompt = tr(264, "Continue (y/n)? ");
 157
 158    ohdl = safe_signal(SIGINT, SIG_IGN);
 159    if (sigsetjmp(__tty_actjmp, 1) != 0) {
 160       hadsig  = TRU1;
 161       goto jrestore;
 162    }
 163    safe_signal(SIGINT, &__tty_acthdl);
 164
 165    if (readline_input(prompt, FAL0, &termios_state.ts_linebuf,
 166          &termios_state.ts_linesize, NULL) >= 0)
 167       switch (termios_state.ts_linebuf[0]) {
 168       case 'N': case 'n':  rv = FAL0; break ;
 169       default:             rv = TRU1; break;
 170       }
 171 jrestore:
 172    termios_state_reset();
 173    safe_signal(SIGINT, ohdl);
 174 jleave:
 175    NYD_LEAVE;
 176    if (hadsig && ohdl != SIG_IGN)
 177       kill(0, SIGINT);
 178    return rv;
 179 }
 180
 181 FL char *
 182 getuser(char const * volatile query) /* TODO v15-compat obsolete */
 183 {
 184    sighandler_type volatile ohdl;
 185    char * volatile user = NULL;
 186    bool_t volatile hadsig = FAL0;
 187    NYD_ENTER;
 188
 189    if (query == NULL)
 190       query = tr(509, "User: ");
 191
 192    ohdl = safe_signal(SIGINT, SIG_IGN);
 193    if (sigsetjmp(__tty_actjmp, 1) != 0) {
 194       hadsig  = TRU1;
 195       goto jrestore;
 196    }
 197    safe_signal(SIGINT, &__tty_acthdl);
 198
 199    if (readline_input(query, FAL0, &termios_state.ts_linebuf,
 200          &termios_state.ts_linesize, NULL) >= 0)
 201       user = termios_state.ts_linebuf;
 202 jrestore:
 203    termios_state_reset();
 204    safe_signal(SIGINT, ohdl);
 205    NYD_LEAVE;
 206    if (hadsig && ohdl != SIG_IGN)
 207       kill(0, SIGINT);
 208    return user;
 209 }
 210
 211 FL char *
 212 getpassword(char const *query)
 213 {
 214    sighandler_type volatile ohdl;
 215    struct termios tios;
 216    char * volatile pass = NULL;
 217 #if 0
 218    bool_t hadsig = FAL0; /* TODO getpassword() no longer reraises SIGINT */
 219 #endif
 220    NYD_ENTER;
 221
 222    if (query == NULL)
 223       query = tr(510, "Password: ");
 224    fputs(query, stdout);
 225    fflush(stdout);
 226
 227    /* FIXME everywhere: tcsetattr() generates SIGTTOU when we're not in
 228     * FIXME foreground pgrp, and can fail with EINTR!! also affects
 229     * FIXME termios_state_reset() */
 230    if (options & OPT_TTYIN) {
 231       tcgetattr(STDIN_FILENO, &termios_state.ts_tios);
 232       memcpy(&tios, &termios_state.ts_tios, sizeof tios);
 233       termios_state.ts_needs_reset = TRU1;
 234       tios.c_iflag &= ~(ISTRIP);
 235       tios.c_lflag &= ~(ECHO | ECHOE | ECHOK | ECHONL);
 236       tcsetattr(STDIN_FILENO, TCSAFLUSH, &tios);
 237    }
 238
 239    ohdl = safe_signal(SIGINT, SIG_IGN);
 240    if (sigsetjmp(__tty_actjmp, 1) != 0) {
 241 #if 0
 242       hadsig = TRU1;
 243 #endif
 244       goto jrestore;
 245    }
 246    safe_signal(SIGINT, &__tty_acthdl);
 247
 248    if (readline_restart(stdin, &termios_state.ts_linebuf,
 249          &termios_state.ts_linesize, 0) >= 0)
 250       pass = termios_state.ts_linebuf;
 251 jrestore:
 252    termios_state_reset();
 253    safe_signal(SIGINT, ohdl);
 254    if (options & OPT_TTYIN)
 255       fputc('\n', stdout);
 256    NYD_LEAVE;
 257 #if 0
 258    if (hadsig && ohdl != SIG_IGN)
 259       kill(0, SIGINT);
 260 #endif
 261    return pass;
 262 }
 263
 264 /*
 265  * readline(3)
 266  */
 267
 268 #ifdef HAVE_READLINE
 269 static sighandler_type  _rl_shup;
 270 static char *           _rl_buf;    /* pre_input() hook: initial line */
 271 static int              _rl_buflen; /* content, and its length */
 272
 273 static int  _rl_pre_input(void);
 274
 275 static int
 276 _rl_pre_input(void)
 277 {
 278    NYD_ENTER;
 279    /* Handle leftover data from \ escaped former line */
 280    rl_extend_line_buffer(_rl_buflen + 10);
 281    memcpy(rl_line_buffer, _rl_buf, _rl_buflen + 1);
 282    rl_point = rl_end = _rl_buflen;
 283    rl_pre_input_hook = (rl_hook_func_t*)NULL;
 284    rl_redisplay();
 285    NYD_LEAVE;
 286    return 0;
 287 }
 288
 289 FL void
 290 tty_init(void)
 291 {
 292 # ifdef HAVE_HISTORY
 293    long hs;
 294    char *v;
 295 # endif
 296    NYD_ENTER;
 297
 298    rl_readline_name = UNCONST(uagent);
 299 # ifdef HAVE_HISTORY
 300    _CL_HISTSIZE(hs);
 301    using_history();
 302    stifle_history((int)hs);
 303 # endif
 304    rl_read_init_file(NULL);
 305
 306    /* Because rl_read_init_file() may have introduced yet a different
 307     * history size limit, simply load and incorporate the history, leave
 308     * it up to readline(3) to do the rest */
 309 # ifdef HAVE_HISTORY
 310    _CL_HISTFILE(v);
 311    if (v != NULL)
 312       read_history(v);
 313 # endif
 314    NYD_LEAVE;
 315 }
 316
 317 FL void
 318 tty_destroy(void)
 319 {
 320 # ifdef HAVE_HISTORY
 321    char *v;
 322 # endif
 323    NYD_ENTER;
 324
 325 # ifdef HAVE_HISTORY
 326    _CL_HISTFILE(v);
 327    if (v != NULL)
 328       write_history(v);
 329 # endif
 330    NYD_LEAVE;
 331 }
 332
 333 FL void
 334 tty_signal(int sig)
 335 {
 336    sigset_t nset, oset;
 337    NYD_X; /* Signal handler */
 338
 339    switch (sig) {
 340 # ifdef SIGWINCH
 341    case SIGWINCH:
 342       break;
 343 # endif
 344    case SIGHUP:
 345       /* readline(3) doesn't catch it :( */
 346       rl_free_line_state();
 347       rl_cleanup_after_signal();
 348       safe_signal(SIGHUP, _rl_shup);
 349       sigemptyset(&nset);
 350       sigaddset(&nset, sig);
 351       sigprocmask(SIG_UNBLOCK, &nset, &oset);
 352       kill(0, sig);
 353       /* XXX When we come here we'll continue editing, so reestablish
 354        * XXX cannot happen */
 355       sigprocmask(SIG_BLOCK, &oset, NULL);
 356       _rl_shup = safe_signal(SIGHUP, &tty_signal);
 357       rl_reset_after_signal();
 358       break;
 359    default:
 360       break;
 361    }
 362 }
 363
 364 FL int
 365 (tty_readline)(char const *prompt, char **linebuf, size_t *linesize, size_t n
 366    SMALLOC_DEBUG_ARGS)
 367 {
 368    int nn;
 369    char *line;
 370    NYD_ENTER;
 371
 372    if (n > 0) {
 373       _rl_buf = *linebuf;
 374       _rl_buflen = (int)n;
 375       rl_pre_input_hook = &_rl_pre_input;
 376    }
 377
 378    _rl_shup = safe_signal(SIGHUP, &tty_signal);
 379    line = readline(prompt != NULL ? prompt : "");
 380    safe_signal(SIGHUP, _rl_shup);
 381
 382    if (line == NULL) {
 383       nn = -1;
 384       goto jleave;
 385    }
 386    n = strlen(line);
 387
 388    if (n >= *linesize) {
 389       *linesize = LINESIZE + n +1;
 390       *linebuf = (srealloc)(*linebuf, *linesize SMALLOC_DEBUG_ARGSCALL);
 391    }
 392    memcpy(*linebuf, line, n);
 393    (free)(line);
 394    (*linebuf)[n] = '\0';
 395    nn = (int)n;
 396 jleave:
 397    NYD_LEAVE;
 398    return nn;
 399 }
 400
 401 FL void
 402 tty_addhist(char const *s)
 403 {
 404    NYD_ENTER;
 405    UNUSED(s);
 406 # ifdef HAVE_HISTORY
 407    _CL_CHECK_ADDHIST(s, goto jleave);
 408    hold_all_sigs();  /* XXX too heavy */
 409    add_history(s);   /* XXX yet we jump away! */
 410    rele_all_sigs();  /* XXX remove jumps */
 411 jleave:
 412 # endif
 413    NYD_LEAVE;
 414 }
 415
 416 # ifdef HAVE_HISTORY
 417 FL int
 418 c_history(void *v)
 419 {
 420    C_HISTORY_SHARED;
 421
 422 jlist: {
 423    FILE *fp;
 424    HISTORY_STATE *hs;
 425    HIST_ENTRY **hl;
 426    ul_it i, b;
 427
 428    if ((fp = Ftmp(NULL, "hist", OF_RDWR | OF_UNLINK | OF_REGISTER, 0600)) ==
 429          NULL) {
 430       perror("tmpfile");
 431       v = NULL;
 432       goto jleave;
 433    }
 434
 435    hs = history_get_history_state();
 436
 437    for (i = (ul_it)hs->length, hl = hs->entries + i, b = 0; i > 0; --i) {
 438       char *cp = (*--hl)->line;
 439       size_t sl = strlen(cp);
 440       fprintf(fp, "%4lu. %-50.50s (%4lu+%2lu bytes)\n", i, cp, b, sl);
 441       b += sl;
 442    }
 443
 444    page_or_print(fp, (size_t)hs->length);
 445    Fclose(fp);
 446    }
 447    goto jleave;
 448
 449 jclear:
 450    clear_history();
 451    goto jleave;
 452
 453 jentry: {
 454    HISTORY_STATE *hs = history_get_history_state();
 455
 456    if (UICMP(z, entry, <=, hs->length))
 457       v = temporary_arg_v_store = hs->entries[entry - 1]->line;
 458    else
 459       v = NULL;
 460    }
 461    goto jleave;
 462 }
 463 # endif /* HAVE_HISTORY */
 464 #endif /* HAVE_READLINE */
 465
 466 /*
 467  * BSD editline(3)
 468  */
 469
 470 #ifdef HAVE_EDITLINE
 471 static EditLine *    _el_el;     /* editline(3) handle */
 472 static char const *  _el_prompt; /* Current prompt */
 473 # ifdef HAVE_HISTORY
 474 static History *     _el_hcom;   /* History handle for commline */
 475 # endif
 476
 477 static char const *  _el_getprompt(void);
 478
 479 static char const *
 480 _el_getprompt(void)
 481 {
 482    return _el_prompt;
 483 }
 484
 485 FL void
 486 tty_init(void)
 487 {
 488 # ifdef HAVE_HISTORY
 489    HistEvent he;
 490    long hs;
 491    char *v;
 492 # endif
 493    NYD_ENTER;
 494
 495 # ifdef HAVE_HISTORY
 496    _CL_HISTSIZE(hs);
 497    _el_hcom = history_init();
 498    history(_el_hcom, &he, H_SETSIZE, (int)hs);
 499    /* We unroll our own one history(_el_hcom, &he, H_SETUNIQUE, 1);*/
 500 # endif
 501
 502    _el_el = el_init(uagent, stdin, stdout, stderr);
 503    el_set(_el_el, EL_SIGNAL, 1);
 504    el_set(_el_el, EL_TERMINAL, NULL);
 505    /* Need to set HIST before EDITOR, otherwise it won't work automatic */
 506 # ifdef HAVE_HISTORY
 507    el_set(_el_el, EL_HIST, &history, _el_hcom);
 508 # endif
 509    el_set(_el_el, EL_EDITOR, "emacs");
 510 # ifdef EL_PROMPT_ESC
 511    el_set(_el_el, EL_PROMPT_ESC, &_el_getprompt, '\1');
 512 # else
 513    el_set(_el_el, EL_PROMPT, &_el_getprompt);
 514 # endif
 515 # if 0
 516    el_set(_el_el, EL_ADDFN, "tab_complete",
 517       "editline(3) internal completion function", &_el_file_cpl);
 518    el_set(_el_el, EL_BIND, "^I", "tab_complete", NULL);
 519 # endif
 520 # ifdef HAVE_HISTORY
 521    el_set(_el_el, EL_BIND, "^R", "ed-search-prev-history", NULL);
 522 # endif
 523    el_source(_el_el, NULL); /* Source ~/.editrc */
 524
 525    /* Because el_source() may have introduced yet a different history size
 526     * limit, simply load and incorporate the history, leave it up to
 527     * editline(3) to do the rest */
 528 # ifdef HAVE_HISTORY
 529    _CL_HISTFILE(v);
 530    if (v != NULL)
 531       history(_el_hcom, &he, H_LOAD, v);
 532 # endif
 533    NYD_LEAVE;
 534 }
 535
 536 FL void
 537 tty_destroy(void)
 538 {
 539 # ifdef HAVE_HISTORY
 540    HistEvent he;
 541    char *v;
 542 # endif
 543    NYD_ENTER;
 544
 545    el_end(_el_el);
 546
 547 # ifdef HAVE_HISTORY
 548    _CL_HISTFILE(v);
 549    if (v != NULL)
 550       history(_el_hcom, &he, H_SAVE, v);
 551    history_end(_el_hcom);
 552 # endif
 553    NYD_LEAVE;
 554 }
 555
 556 FL void
 557 tty_signal(int sig)
 558 {
 559    NYD_X; /* Signal handler */
 560    switch (sig) {
 561 # ifdef SIGWINCH
 562    case SIGWINCH:
 563       el_resize(_el_el);
 564       break;
 565 # endif
 566    default:
 567       break;
 568    }
 569 }
 570
 571 FL int
 572 (tty_readline)(char const *prompt, char **linebuf, size_t *linesize, size_t n
 573    SMALLOC_DEBUG_ARGS)
 574 {
 575    int nn;
 576    char const *line;
 577    NYD_ENTER;
 578
 579    _el_prompt = (prompt != NULL) ? prompt : "";
 580    if (n > 0)
 581       el_push(_el_el, *linebuf);
 582    line = el_gets(_el_el, &nn);
 583
 584    if (line == NULL) {
 585       nn = -1;
 586       goto jleave;
 587    }
 588    assert(nn >= 0);
 589    n = (size_t)nn;
 590    if (n > 0 && line[n - 1] == '\n')
 591       nn = (int)--n;
 592
 593    if (n >= *linesize) {
 594       *linesize = LINESIZE + n + 1;
 595       *linebuf = (srealloc)(*linebuf, *linesize SMALLOC_DEBUG_ARGSCALL);
 596    }
 597    memcpy(*linebuf, line, n);
 598    (*linebuf)[n] = '\0';
 599 jleave:
 600    NYD_LEAVE;
 601    return nn;
 602 }
 603
 604 FL void
 605 tty_addhist(char const *s)
 606 {
 607 # ifdef HAVE_HISTORY
 608    /* Enlarge meaning of unique .. to something that rocks;
 609     * xxx unfortunately this is expensive to do with editline(3)
 610     * xxx maybe it would be better to hook the ptfs instead? */
 611    HistEvent he;
 612    int i;
 613 # endif
 614    NYD_ENTER;
 615    UNUSED(s);
 616
 617 # ifdef HAVE_HISTORY
 618    _CL_CHECK_ADDHIST(s, goto jleave);
 619
 620    hold_all_sigs(); /* XXX too heavy, yet we jump away! */
 621    for (i = history(_el_hcom, &he, H_FIRST); i >= 0;
 622          i = history(_el_hcom, &he, H_NEXT))
 623       if (!strcmp(he.str, s)) {
 624          history(_el_hcom, &he, H_DEL, he.num);
 625          break;
 626       }
 627    history(_el_hcom, &he, H_ENTER, s);
 628    rele_all_sigs(); /* XXX remove jumps */
 629 jleave:
 630 # endif
 631    NYD_LEAVE;
 632 }
 633
 634 # ifdef HAVE_HISTORY
 635 FL int
 636 c_history(void *v)
 637 {
 638    C_HISTORY_SHARED;
 639
 640 jlist: {
 641    HistEvent he;
 642    FILE *fp;
 643    size_t i, b;
 644    int x;
 645
 646    if ((fp = Ftmp(NULL, "hist", OF_RDWR | OF_UNLINK | OF_REGISTER, 0600)) ==
 647          NULL) {
 648       perror("tmpfile");
 649       v = NULL;
 650       goto jleave;
 651    }
 652
 653    i = (size_t)((history(_el_hcom, &he, H_GETSIZE) >= 0) ? he.num : 0);
 654    b = 0;
 655    for (x = history(_el_hcom, &he, H_FIRST); x >= 0;
 656          x = history(_el_hcom, &he, H_NEXT)) {
 657       size_t sl = strlen(he.str);
 658       fprintf(fp, "%4lu. %-50.50s (%4lu+%2lu bytes)\n",
 659          (ul_it)i, he.str, (ul_it)b, (ul_it)sl);
 660       --i;
 661       b += sl;
 662    }
 663
 664    page_or_print(fp, i);
 665    Fclose(fp);
 666    }
 667    goto jleave;
 668
 669 jclear: {
 670    HistEvent he;
 671    history(_el_hcom, &he, H_CLEAR);
 672    }
 673    goto jleave;
 674
 675 jentry: {
 676    HistEvent he;
 677    size_t i;
 678    int x;
 679
 680    i = (size_t)((history(_el_hcom, &he, H_GETSIZE) >= 0) ? he.num : 0);
 681    if (UICMP(z, entry, <=, i)) {
 682       entry = (long)i - entry;
 683       for (x = history(_el_hcom, &he, H_FIRST); x >= 0;
 684             x = history(_el_hcom, &he, H_NEXT))
 685          if (entry-- == 0) {
 686             v = temporary_arg_v_store = UNCONST(he.str);
 687             goto jleave;
 688          }
 689    }
 690    v = NULL;
 691    }
 692    goto jleave;
 693 }
 694 # endif /* HAVE_HISTORY */
 695 #endif /* HAVE_EDITLINE */
 696
 697 /*
 698  * NCL: our homebrew version (inspired from NetBSD sh(1) / dash(1)s hetio.c).
 699  *
 700  * Only used in interactive mode, simply use STDIN_FILENO as point of interest.
 701  * We do not handle character widths because the terminal must deal with that
 702  * anyway on the one hand, and also wcwidth(3) doesn't support zero-width
 703  * characters by definition on the other.  We're addicted.
 704  *
 705  * To avoid memory leaks etc. with the current codebase that simply longjmp(3)s
 706  * we're forced to use the very same buffer--the one that is passed through to
 707  * us from the outside--to store anything we need, i.e., a `struct cell[]', and
 708  * convert that on-the-fly back to the plain char* result once we're done.
 709  * To simplify our live, use savestr() buffers for all other needed memory
 710  */
 711
 712 /*
 713  * TODO NCL: don't use that stupid .sint=-1 stuff, but simply block all signals
 714  * TODO NCL: during handler de-/installation handling.
 715  */
 716
 717 #ifdef HAVE_NCL
 718 # ifndef MAX_INPUT
 719 #  define MAX_INPUT 255    /* (_POSIX_MAX_INPUT = 255 as of Issue 7 TC1) */
 720 # endif
 721
 722   /* Since we simply fputs(3) the prompt, assume each character requires two
 723    * visual cells -- and we need to restrict the maximum prompt size because
 724    * of MAX_INPUT and our desire to have room for some error message left */
 725 # define _PROMPT_VLEN(P)   (strlen(P) * 2)
 726 # define _PROMPT_MAX       ((MAX_INPUT / 2) + (MAX_INPUT / 4))
 727
 728 union xsighdl {
 729    sighandler_type   shdl; /* Try avoid races by setting */
 730    sl_it             sint; /* .sint=-1 when inactive */
 731 };
 732 CTA(sizeof(sl_it) >= sizeof(sighandler_type));
 733
 734 struct xtios {
 735    struct termios told;
 736    struct termios tnew;
 737 };
 738
 739 struct cell {
 740    wchar_t  wc;
 741    ui32_t   count;
 742    char     cbuf[MB_LEN_MAX * 2];   /* .. plus reset shift sequence */
 743 };
 744
 745 struct line {
 746    size_t         cursor;     /* Current cursor position */
 747    size_t         topins;     /* Outermost cursor col set */
 748    union {
 749       char *         cbuf;    /* *x_buf */
 750       struct cell *  cells;
 751    }              line;
 752    struct str     defc;       /* Current default content */
 753    struct str     savec;      /* Saved default content */
 754 # ifdef HAVE_HISTORY
 755    struct hist *  hist;       /* History cursor */
 756 # endif
 757    char const *   prompt;
 758    char const *   nd;         /* Cursor right */
 759    char **        x_buf;      /* Caller pointers */
 760    size_t *       x_bufsize;
 761 };
 762
 763 # ifdef HAVE_HISTORY
 764 struct hist {
 765    struct hist *  older;
 766    struct hist *  younger;
 767    size_t         len;
 768    char           dat[VFIELD_SIZE(sizeof(size_t))];
 769 };
 770 # endif
 771
 772 static union xsighdl _ncl_oint;
 773 static union xsighdl _ncl_oquit;
 774 static union xsighdl _ncl_oterm;
 775 static union xsighdl _ncl_ohup;
 776 static union xsighdl _ncl_otstp;
 777 static union xsighdl _ncl_ottin;
 778 static union xsighdl _ncl_ottou;
 779 static struct xtios  _ncl_tios;
 780 # ifdef HAVE_HISTORY
 781 static struct hist * _ncl_hist;
 782 static struct hist * _ncl_hist_tail;
 783 static size_t        _ncl_hist_size;
 784 static size_t        _ncl_hist_size_max;
 785 static bool_t        _ncl_hist_load;
 786 # endif
 787
 788 static void    _ncl_sigs_up(void);
 789 static void    _ncl_sigs_down(void);
 790
 791 static void    _ncl_term_mode(bool_t raw);
 792
 793 static void    _ncl_check_grow(struct line *l, size_t no SMALLOC_DEBUG_ARGS);
 794 static void    _ncl_bs_eof_dvup(struct cell *cap, size_t i);
 795 static ssize_t _ncl_wboundary(struct line *l, ssize_t dir);
 796 static ssize_t _ncl_cell2dat(struct line *l);
 797 # if defined HAVE_HISTORY || defined HAVE_TABEXPAND
 798 static void    _ncl_cell2save(struct line *l);
 799 # endif
 800
 801 static void    _ncl_khome(struct line *l, bool_t dobell);
 802 static void    _ncl_kend(struct line *l);
 803 static void    _ncl_kbs(struct line *l);
 804 static void    _ncl_kkill(struct line *l, bool_t dobell);
 805 static ssize_t _ncl_keof(struct line *l);
 806 static void    _ncl_kleft(struct line *l);
 807 static void    _ncl_kright(struct line *l);
 808 static void    _ncl_krefresh(struct line *l);
 809 static void    _ncl_kbwddelw(struct line *l);
 810 static void    _ncl_kgow(struct line *l, ssize_t dir);
 811 static void    _ncl_kother(struct line *l, wchar_t wc);
 812 # ifdef HAVE_HISTORY
 813 static size_t  __ncl_khist_shared(struct line *l, struct hist *hp);
 814 static size_t  _ncl_khist(struct line *l, bool_t backwd);
 815 static size_t  _ncl_krhist(struct line *l);
 816 # endif
 817 # ifdef HAVE_TABEXPAND
 818 static size_t  _ncl_kht(struct line *l);
 819 # endif
 820 static ssize_t _ncl_readline(char const *prompt, char **buf, size_t *bufsize,
 821                   size_t len SMALLOC_DEBUG_ARGS);
 822
 823 static void
 824 _ncl_sigs_up(void)
 825 {
 826    NYD_ENTER;
 827    if (_ncl_oint.sint == -1)
 828       _ncl_oint.shdl = safe_signal(SIGINT, &tty_signal);
 829    if (_ncl_oquit.sint == -1)
 830       _ncl_oquit.shdl = safe_signal(SIGQUIT, &tty_signal);
 831    if (_ncl_oterm.sint == -1)
 832       _ncl_oterm.shdl = safe_signal(SIGTERM, &tty_signal);
 833    if (_ncl_ohup.sint == -1)
 834       _ncl_ohup.shdl = safe_signal(SIGHUP, &tty_signal);
 835    if (_ncl_otstp.sint == -1)
 836       _ncl_otstp.shdl = safe_signal(SIGTSTP, &tty_signal);
 837    if (_ncl_ottin.sint == -1)
 838       _ncl_ottin.shdl = safe_signal(SIGTTIN, &tty_signal);
 839    if (_ncl_ottou.sint == -1)
 840       _ncl_ottou.shdl  = safe_signal(SIGTTOU, &tty_signal);
 841    NYD_LEAVE;
 842 }
 843
 844 static void
 845 _ncl_sigs_down(void)
 846 {
 847    /* aaah.. atomic cas would be nice (but isn't it all redundant?) */
 848    sighandler_type st;
 849    NYD_ENTER;
 850
 851    if (_ncl_ottou.sint != -1) {
 852       st = _ncl_ottou.shdl, _ncl_ottou.sint = -1;
 853       safe_signal(SIGTTOU, st);
 854    }
 855    if (_ncl_ottin.sint != -1) {
 856       st = _ncl_ottin.shdl, _ncl_ottin.sint = -1;
 857       safe_signal(SIGTTIN, st);
 858    }
 859    if (_ncl_otstp.sint != -1) {
 860       st = _ncl_otstp.shdl, _ncl_otstp.sint = -1;
 861       safe_signal(SIGTSTP, st);
 862    }
 863    if (_ncl_ohup.sint != -1) {
 864       st = _ncl_ohup.shdl, _ncl_ohup.sint = -1;
 865       safe_signal(SIGHUP, st);
 866    }
 867    if (_ncl_oterm.sint != -1) {
 868       st = _ncl_oterm.shdl, _ncl_oterm.sint = -1;
 869       safe_signal(SIGTERM, st);
 870    }
 871    if (_ncl_oquit.sint != -1) {
 872       st = _ncl_oquit.shdl, _ncl_oquit.sint = -1;
 873       safe_signal(SIGQUIT, st);
 874    }
 875    if (_ncl_oint.sint != -1) {
 876       st = _ncl_oint.shdl, _ncl_oint.sint = -1;
 877       safe_signal(SIGINT, st);
 878    }
 879    NYD_LEAVE;
 880 }
 881
 882 static void
 883 _ncl_term_mode(bool_t raw)
 884 {
 885    struct termios *tiosp;
 886    NYD_ENTER;
 887
 888    tiosp = &_ncl_tios.told;
 889    if (!raw)
 890       goto jleave;
 891
 892    /* Always requery the attributes, in case we've been moved from background
 893     * to foreground or however else in between sessions */
 894    tcgetattr(STDIN_FILENO, tiosp);
 895    memcpy(&_ncl_tios.tnew, tiosp, sizeof *tiosp);
 896    tiosp = &_ncl_tios.tnew;
 897    tiosp->c_cc[VMIN] = 1;
 898    tiosp->c_cc[VTIME] = 0;
 899    tiosp->c_iflag &= ~(ISTRIP);
 900    tiosp->c_lflag &= ~(ECHO /*| ECHOE | ECHONL */| ICANON | IEXTEN);
 901 jleave:
 902    tcsetattr(STDIN_FILENO, TCSADRAIN, tiosp);
 903    NYD_LEAVE;
 904 }
 905
 906 static void
 907 _ncl_check_grow(struct line *l, size_t no SMALLOC_DEBUG_ARGS)
 908 {
 909    size_t i;
 910    NYD_ENTER;
 911
 912    i = (l->topins + no) * sizeof(struct cell) + 2 * sizeof(struct cell);
 913    if (i > *l->x_bufsize) {
 914       i <<= 1;
 915       *l->x_bufsize = i;
 916       l->line.cbuf =
 917       *l->x_buf = (srealloc)(*l->x_buf, i SMALLOC_DEBUG_ARGSCALL);
 918    }
 919    NYD_LEAVE;
 920 }
 921
 922 static void
 923 _ncl_bs_eof_dvup(struct cell *cap, size_t i)
 924 {
 925    size_t j;
 926    NYD_ENTER;
 927
 928    if (i > 0)
 929       memmove(cap, cap + 1, i * sizeof(*cap));
 930
 931    /* And.. the (rest of the) visual update */
 932    for (j = 0; j < i; ++j)
 933       fwrite(cap[j].cbuf, sizeof *cap->cbuf, cap[j].count, stdout);
 934    fputs(" \b", stdout);
 935    for (j = 0; j < i; ++j)
 936       putchar('\b');
 937    NYD_LEAVE;
 938 }
 939
 940 static ssize_t
 941 _ncl_wboundary(struct line *l, ssize_t dir)
 942 {
 943    size_t c, t, i;
 944    struct cell *cap;
 945    bool_t anynon;
 946    NYD_ENTER;
 947
 948    c = l->cursor;
 949    t = l->topins;
 950    i = (size_t)-1;
 951
 952    if (dir < 0) {
 953       if (c == 0)
 954          goto jleave;
 955    } else if (c == t)
 956       goto jleave;
 957    else
 958       --t, --c; /* Unsigned wrapping may occur (twice), then */
 959
 960    for (i = 0, cap = l->line.cells, anynon = FAL0;;) {
 961       wchar_t wc = cap[c + dir].wc;
 962       if (iswblank(wc) || iswpunct(wc)) {
 963          if (anynon)
 964             break;
 965       } else
 966          anynon = TRU1;
 967       ++i;
 968       c += dir;
 969       if (dir < 0) {
 970          if (c == 0)
 971             break;
 972       } else if (c == t)
 973          break;
 974    }
 975 jleave:
 976    NYD_LEAVE;
 977    return (ssize_t)i;
 978 }
 979
 980 static ssize_t
 981 _ncl_cell2dat(struct line *l)
 982 {
 983    size_t len = 0, i;
 984    NYD_ENTER;
 985
 986    if (l->topins > 0)
 987       for (i = 0; i < l->topins; ++i) {
 988          struct cell *cap = l->line.cells + i;
 989          memcpy(l->line.cbuf + len, cap->cbuf, cap->count);
 990          len += cap->count;
 991       }
 992    l->line.cbuf[len] = '\0';
 993    NYD_LEAVE;
 994    return (ssize_t)len;
 995 }
 996
 997 # if defined HAVE_HISTORY || defined HAVE_TABEXPAND
 998 static void
 999 _ncl_cell2save(struct line *l)
1000 {
1001    size_t len, i;
1002    struct cell *cap;
1003    NYD_ENTER;
1004
1005    l->savec.s = NULL, l->savec.l = 0;
1006    if (l->topins == 0)
1007       goto jleave;
1008
1009    for (cap = l->line.cells, len = i = 0; i < l->topins; ++cap, ++i)
1010       len += cap->count;
1011
1012    l->savec.l = len;
1013    l->savec.s = salloc(len + 1);
1014
1015    for (cap = l->line.cells, len = i = 0; i < l->topins; ++cap, ++i) {
1016       memcpy(l->savec.s + len, cap->cbuf, cap->count);
1017       len += cap->count;
1018    }
1019    l->savec.s[len] = '\0';
1020 jleave:
1021    NYD_LEAVE;
1022 }
1023 # endif
1024
1025 static void
1026 _ncl_khome(struct line *l, bool_t dobell)
1027 {
1028    size_t c;
1029    NYD_ENTER;
1030
1031    c = l->cursor;
1032    if (c > 0) {
1033       l->cursor = 0;
1034       while (c-- != 0)
1035          putchar('\b');
1036    } else if (dobell)
1037       putchar('\a');
1038    NYD_LEAVE;
1039 }
1040
1041 static void
1042 _ncl_kend(struct line *l)
1043 {
1044    ssize_t i;
1045    NYD_ENTER;
1046
1047    i = (ssize_t)(l->topins - l->cursor);
1048
1049    if (i > 0) {
1050       l->cursor = l->topins;
1051       while (i-- != 0)
1052          fputs(l->nd, stdout);
1053    } else
1054       putchar('\a');
1055    NYD_LEAVE;
1056 }
1057
1058 static void
1059 _ncl_kbs(struct line *l)
1060 {
1061    ssize_t c, t;
1062    NYD_ENTER;
1063
1064    c = l->cursor;
1065    t = l->topins;
1066
1067    if (c > 0) {
1068       putchar('\b');
1069       l->cursor = --c;
1070       l->topins = --t;
1071       t -= c;
1072       _ncl_bs_eof_dvup(l->line.cells + c, t);
1073    } else
1074       putchar('\a');
1075    NYD_LEAVE;
1076 }
1077
1078 static void
1079 _ncl_kkill(struct line *l, bool_t dobell)
1080 {
1081    size_t j, c, i;
1082    NYD_ENTER;
1083
1084    c = l->cursor;
1085    i = (size_t)(l->topins - c);
1086
1087    if (i > 0) {
1088       l->topins = c;
1089       for (j = i; j != 0; --j)
1090          putchar(' ');
1091       for (j = i; j != 0; --j)
1092          putchar('\b');
1093    } else if (dobell)
1094       putchar('\a');
1095    NYD_LEAVE;
1096 }
1097
1098 static ssize_t
1099 _ncl_keof(struct line *l)
1100 {
1101    size_t c, t;
1102    ssize_t i;
1103    NYD_ENTER;
1104
1105    c = l->cursor;
1106    t = l->topins;
1107    i = (ssize_t)(t - c);
1108
1109    if (i > 0) {
1110       l->topins = --t;
1111       _ncl_bs_eof_dvup(l->line.cells + c, --i);
1112    } else if (t == 0 && !ok_blook(ignoreeof)) {
1113       fputs("^D", stdout);
1114       fflush(stdout);
1115       i = -1;
1116    } else {
1117       putchar('\a');
1118       i = 0;
1119    }
1120    NYD_LEAVE;
1121    return i;
1122 }
1123
1124 static void
1125 _ncl_kleft(struct line *l)
1126 {
1127    NYD_ENTER;
1128    if (l->cursor > 0) {
1129       --l->cursor;
1130       putchar('\b');
1131    } else
1132       putchar('\a');
1133    NYD_LEAVE;
1134 }
1135
1136 static void
1137 _ncl_kright(struct line *l)
1138 {
1139    NYD_ENTER;
1140    if (l->cursor < l->topins) {
1141       ++l->cursor;
1142       fputs(l->nd, stdout);
1143    } else
1144       putchar('\a');
1145    NYD_LEAVE;
1146 }
1147
1148 static void
1149 _ncl_krefresh(struct line *l)
1150 {
1151    struct cell *cap;
1152    size_t i;
1153    NYD_ENTER;
1154
1155    putchar('\r');
1156    if (l->prompt != NULL && *l->prompt != '\0')
1157       fputs(l->prompt, stdout);
1158    for (cap = l->line.cells, i = l->topins; i > 0; ++cap, --i)
1159       fwrite(cap->cbuf, sizeof *cap->cbuf, cap->count, stdout);
1160    for (i = l->topins - l->cursor; i > 0; --i)
1161       putchar('\b');
1162    NYD_LEAVE;
1163 }
1164
1165 static void
1166 _ncl_kbwddelw(struct line *l)
1167 {
1168    ssize_t i;
1169    size_t c, t, j;
1170    struct cell *cap;
1171    NYD_ENTER;
1172
1173    i = _ncl_wboundary(l, -1);
1174    if (i <= 0) {
1175       if (i < 0)
1176          putchar('\a');
1177       goto jleave;
1178    }
1179
1180    c = l->cursor - i;
1181    t = l->topins;
1182    l->topins = t - i;
1183    l->cursor = c;
1184    cap = l->line.cells + c;
1185
1186    if (t != l->cursor) {
1187       j = t - c + i;
1188       memmove(cap, cap + i, j * sizeof(*cap));
1189    }
1190
1191    for (j = i; j > 0; --j)
1192       putchar('\b');
1193    for (j = l->topins - c; j > 0; ++cap, --j)
1194       fwrite(cap[0].cbuf, sizeof *cap->cbuf, cap[0].count, stdout);
1195    for (j = i; j > 0; --j)
1196       putchar(' ');
1197    for (j = t - c; j > 0; --j)
1198       putchar('\b');
1199 jleave:
1200    NYD_LEAVE;
1201 }
1202
1203 static void
1204 _ncl_kgow(struct line *l, ssize_t dir)
1205 {
1206    ssize_t i;
1207    NYD_ENTER;
1208
1209    i = _ncl_wboundary(l, dir);
1210    if (i <= 0) {
1211       if (i < 0)
1212          putchar('\a');
1213       goto jleave;
1214    }
1215
1216    if (dir < 0) {
1217       l->cursor -= i;
1218       while (i-- > 0)
1219          putchar('\b');
1220    } else {
1221       l->cursor += i;
1222       while (i-- > 0)
1223          fputs(l->nd, stdout);
1224    }
1225 jleave:
1226    NYD_LEAVE;
1227 }
1228
1229 static void
1230 _ncl_kother(struct line *l, wchar_t wc)
1231 {
1232    /* Append if at EOL, insert otherwise;
1233     * since we may move around character-wise, always use a fresh ps */
1234    mbstate_t ps;
1235    struct cell cell, *cap;
1236    size_t i, c;
1237    NYD_ENTER;
1238
1239    /* First init a cell and see wether we'll really handle this wc */
1240    cell.wc = wc;
1241    memset(&ps, 0, sizeof ps);
1242    i = wcrtomb(cell.cbuf, wc, &ps);
1243    if (i > MB_LEN_MAX)
1244       goto jleave;
1245    cell.count = (ui_it)i;
1246    if (enc_has_state) {
1247       i = wcrtomb(cell.cbuf + i, L'\0', &ps);
1248       if (i == 1)
1249          ;
1250       else if (--i < MB_LEN_MAX)
1251          cell.count += (ui_it)i;
1252       else
1253          goto jleave;
1254    }
1255
1256    /* Yes, we will!  Place it in the array */
1257    c = l->cursor++;
1258    i = l->topins++ - c;
1259    cap = l->line.cells + c;
1260    if (i > 0)
1261       memmove(cap + 1, cap, i * sizeof(cell));
1262    memcpy(cap, &cell, sizeof cell);
1263
1264    /* And update visual */
1265    c = i;
1266    do
1267       fwrite(cap->cbuf, sizeof *cap->cbuf, cap->count, stdout);
1268    while ((++cap, i-- != 0));
1269    while (c-- != 0)
1270       putchar('\b');
1271 jleave:
1272    NYD_LEAVE;
1273 }
1274
1275 # ifdef HAVE_HISTORY
1276 static size_t
1277 __ncl_khist_shared(struct line *l, struct hist *hp)
1278 {
1279    size_t rv;
1280    NYD_ENTER;
1281
1282    if ((l->hist = hp) != NULL) {
1283       l->defc.s = savestrbuf(hp->dat, hp->len);
1284       rv =
1285       l->defc.l = hp->len;
1286       if (l->topins > 0) {
1287          _ncl_khome(l, FAL0);
1288          _ncl_kkill(l, FAL0);
1289       }
1290    } else {
1291       putchar('\a');
1292       rv = 0;
1293    }
1294    NYD_LEAVE;
1295    return rv;
1296 }
1297
1298 static size_t
1299 _ncl_khist(struct line *l, bool_t backwd)
1300 {
1301    struct hist *hp;
1302    size_t rv;
1303    NYD_ENTER;
1304
1305    /* If we're not in history mode yet, save line content;
1306     * also, disallow forward search, then, and, of course, bail unless we
1307     * do have any history at all */
1308    if ((hp = l->hist) == NULL) {
1309       if (!backwd)
1310          goto jleave;
1311       if ((hp = _ncl_hist) == NULL)
1312          goto jleave;
1313       _ncl_cell2save(l);
1314       goto jleave;
1315    }
1316
1317    hp = backwd ? hp->older : hp->younger;
1318 jleave:
1319    rv = __ncl_khist_shared(l, hp);
1320    NYD_LEAVE;
1321    return rv;
1322 }
1323
1324 static size_t
1325 _ncl_krhist(struct line *l)
1326 {
1327    struct str orig_savec;
1328    struct hist *hp = NULL;
1329    size_t rv;
1330    NYD_ENTER;
1331
1332    /* We cannot complete an empty line */
1333    if (l->topins == 0) {
1334       /* XXX The upcoming hard reset would restore a set savec buffer,
1335        * XXX so forcefully reset that.  A cleaner solution would be to
1336        * XXX reset it whenever a restore is no longer desired */
1337       l->savec.s = NULL, l->savec.l = 0;
1338       goto jleave;
1339    }
1340    if ((hp = l->hist) == NULL) {
1341       if ((hp = _ncl_hist) == NULL)
1342          goto jleave;
1343       orig_savec.s = NULL;
1344       orig_savec.l = 0; /* silence CC */
1345    } else if ((hp = hp->older) == NULL)
1346       goto jleave;
1347    else
1348       orig_savec = l->savec;
1349
1350    if (orig_savec.s == NULL)
1351       _ncl_cell2save(l);
1352    for (; hp != NULL; hp = hp->older)
1353       if (is_prefix(l->savec.s, hp->dat))
1354          break;
1355    if (orig_savec.s != NULL)
1356       l->savec = orig_savec;
1357 jleave:
1358    rv = __ncl_khist_shared(l, hp);
1359    NYD_LEAVE;
1360    return rv;
1361 }
1362 # endif
1363
1364 # ifdef HAVE_TABEXPAND
1365 static size_t
1366 _ncl_kht(struct line *l)
1367 {
1368    struct str orig, bot, topp, sub, exp;
1369    struct cell *cword, *ctop, *cx;
1370    bool_t set_savec = FAL0;
1371    size_t rv = 0;
1372    NYD_ENTER;
1373
1374    /* We cannot expand an empty line */
1375    if (l->topins == 0)
1376       goto jleave;
1377
1378    /* Get plain line data; if this is the first expansion/xy, update the
1379     * very original content so that ^G gets the origin back */
1380    orig = l->savec;
1381    _ncl_cell2save(l);
1382    exp = l->savec;
1383    if (orig.s != NULL)
1384       l->savec = orig;
1385    else
1386       set_savec = TRU1;
1387    orig = exp;
1388
1389    cword = l->line.cells;
1390    ctop = cword + l->cursor;
1391
1392    /* topp: separate data right of cursor */
1393    if ((cx = cword + l->topins) != ctop) {
1394       for (rv = 0; cx > ctop; --cx)
1395          rv += cx->count;
1396       topp.l = rv;
1397       topp.s = orig.s + orig.l - rv;
1398    } else
1399       topp.s = NULL, topp.l = 0;
1400
1401    /* bot, sub: we cannot expand the entire data left of cursor, but only
1402     * the last "word", so separate them */
1403    while (cx > cword && !iswspace(cx[-1].wc))
1404       --cx;
1405    for (rv = 0; cword < cx; ++cword)
1406       rv += cword->count;
1407    sub =
1408    bot = orig;
1409    bot.l = rv;
1410    sub.s += rv;
1411    sub.l -= rv;
1412    sub.l -= topp.l;
1413
1414    /* Leave room for "implicit asterisk" expansion, as below */
1415    if (sub.l == 0) {
1416       sub.s = UNCONST("*");
1417       sub.l = 1;
1418    } else {
1419       exp.s = salloc(sub.l + 1 +1);
1420       memcpy(exp.s, sub.s, sub.l);
1421       exp.s[sub.l] = '\0';
1422       sub.s = exp.s;
1423    }
1424
1425    /* TODO there is a TODO note upon fexpand() with multi-return;
1426     * TODO if that will change, the if() below can be simplified */
1427    /* Super-Heavy-Metal: block all sigs, avoid leaks on jump */
1428 jredo:
1429    hold_all_sigs();
1430    exp.s = fexpand(sub.s, _CL_TAB_FEXP_FL);
1431    rele_all_sigs();
1432
1433    if (exp.s == NULL || (exp.l = strlen(exp.s)) == 0)
1434       goto jnope;
1435    /* If the expansion equals the original string, assume the user wants what
1436     * is usually known as tab completion, append `*' and restart */
1437    if (exp.l == sub.l && !strcmp(exp.s, sub.s)) {
1438          if (sub.s[sub.l - 1] == '*')
1439             goto jnope;
1440          sub.s[sub.l++] = '*';
1441          sub.s[sub.l] = '\0';
1442          goto jredo;
1443    }
1444
1445    /* Cramp expansion length to MAX_INPUT, or 255 if not defined.
1446     * Take care to take *prompt* into account, since we don't know
1447     * anything about it's visual length (fputs(3) is used), simply
1448     * assume each character requires two columns */
1449    /* TODO the problem is that we loose control otherwise; in the best
1450     * TODO case the user can control via ^A and ^K etc., but be safe;
1451     * TODO we cannot simply adjust fexpand() because we don't know how
1452     * TODO that is implemented...  The real solution would be to check
1453     * TODO wether we fit on a line, and start a pager if not.
1454     * TODO However, that should be part of a real tab-COMPLETION, then,
1455     * TODO i.e., don't EXPAND, but SHOW COMPLETIONS, page-wise if needed.
1456     * TODO And: MAX_INPUT is dynamic: pathconf(2), _SC_MAX_INPUT */
1457    rv = (l->prompt != NULL) ? _PROMPT_VLEN(l->prompt) : 0;
1458    if (rv + bot.l + exp.l + topp.l >= MAX_INPUT) {
1459       char const e1[] = "[ERR_TOO_LONG]";
1460       exp.s = UNCONST(e1);
1461       exp.l = sizeof(e1) - 1;
1462       topp.l = 0;
1463       if (rv + bot.l + exp.l >= MAX_INPUT)
1464          bot.l = 0;
1465       if (rv + exp.l >= MAX_INPUT) {
1466          char const e2[] = "[ERR]";
1467          exp.s = UNCONST(e2);
1468          exp.l = sizeof(e2) - 1;
1469       }
1470    }
1471
1472    orig.l = bot.l + exp.l + topp.l;
1473    orig.s = salloc(orig.l + 5 +1);
1474    if ((rv = bot.l) > 0)
1475       memcpy(orig.s, bot.s, rv);
1476    memcpy(orig.s + rv, exp.s, exp.l);
1477    rv += exp.l;
1478    if (topp.l > 0) {
1479       memcpy(orig.s + rv, topp.s, topp.l);
1480       rv += topp.l;
1481    }
1482    orig.s[rv] = '\0';
1483
1484    l->defc = orig;
1485    _ncl_khome(l, FAL0);
1486    _ncl_kkill(l, FAL0);
1487 jleave:
1488    NYD_LEAVE;
1489    return rv;
1490 jnope:
1491    /* If we've provided a default content, but failed to expand, there is
1492     * nothing we can "revert to": drop that default again */
1493    if (set_savec)
1494       l->savec.s = NULL, l->savec.l = 0;
1495    rv = 0;
1496    goto jleave;
1497 }
1498 # endif /* HAVE_TABEXPAND */
1499
1500 static ssize_t
1501 _ncl_readline(char const *prompt, char **buf, size_t *bufsize, size_t len
1502    SMALLOC_DEBUG_ARGS)
1503 {
1504    /* We want to save code, yet we may have to incorporate a lines'
1505     * default content and / or default input to switch back to after some
1506     * history movement; let "len > 0" mean "have to display some data
1507     * buffer", and only otherwise read(2) it */
1508    mbstate_t ps[2];
1509    struct line l;
1510    char cbuf_base[MB_LEN_MAX * 2], *cbuf, *cbufp, cursor_maybe, cursor_store;
1511    wchar_t wc;
1512    ssize_t rv;
1513    NYD_ENTER;
1514
1515    memset(&l, 0, sizeof l);
1516    l.line.cbuf = *buf;
1517    if (len != 0) {
1518       l.defc.s = savestrbuf(*buf, len);
1519       l.defc.l = len;
1520    }
1521    if ((l.prompt = prompt) != NULL && _PROMPT_VLEN(prompt) > _PROMPT_MAX)
1522       l.prompt = prompt = "?ERR?";
1523    /* TODO *l.nd=='\0' : instead adjust acmava.c to disallow empty vals */
1524    if ((l.nd = ok_vlook(line_editor_cursor_right)) == NULL || *l.nd == '\0')
1525       l.nd = "\033[C"; /* XXX no "magic" constant */
1526    l.x_buf = buf;
1527    l.x_bufsize = bufsize;
1528
1529    if (prompt != NULL && *prompt != '\0') {
1530       fputs(prompt, stdout);
1531       fflush(stdout);
1532    }
1533 jrestart:
1534    memset(ps, 0, sizeof ps);
1535    cursor_maybe = cursor_store = 0;
1536    /* TODO: NCL: we should output the reset sequence when we jrestart:
1537     * TODO: NCL: if we are using a stateful encoding? !
1538     * TODO: NCL: in short: this is not yet well understood */
1539    for (;;) {
1540       _ncl_check_grow(&l, len SMALLOC_DEBUG_ARGSCALL);
1541
1542       /* Normal read(2)?  Else buffer-takeover: speed this one up */
1543       if (len == 0)
1544          cbufp =
1545          cbuf = cbuf_base;
1546       else {
1547          assert(l.defc.l > 0 && l.defc.s != NULL);
1548          cbufp =
1549          cbuf = l.defc.s + (l.defc.l - len);
1550          cbufp += len;
1551       }
1552
1553       /* Read in the next complete multibyte character */
1554       for (;;) {
1555          if (len == 0) {
1556             if ((rv = read(STDIN_FILENO, cbufp, 1)) < 1) {
1557                if (errno == EINTR) /* xxx #if !SA_RESTART ? */
1558                   continue;
1559                goto jleave;
1560             }
1561             ++cbufp;
1562          }
1563
1564          /* Ach! the ISO C multibyte handling!
1565           * Encodings with locking shift states cannot really be helped, since
1566           * it is impossible to only query the shift state, as opposed to the
1567           * entire shift state + character pair (via ISO C functions) */
1568          rv = (ssize_t)mbrtowc(&wc, cbuf, PTR2SIZE(cbufp - cbuf), ps + 0);
1569          if (rv <= 0) {
1570             /* Any error during take-over can only result in a hard reset;
1571              * Otherwise, if it's a hard error, or if too many redundant shift
1572              * sequences overflow our buffer, also perform a hard reset */
1573             if (len != 0 || rv == -1 ||
1574                   sizeof cbuf_base == PTR2SIZE(cbufp - cbuf)) {
1575                l.savec.s = l.defc.s = NULL,
1576                l.savec.l = l.defc.l = len = 0;
1577                putchar('\a');
1578                wc = 'G';
1579                goto jreset;
1580             }
1581             /* Otherwise, due to the way we deal with the buffer, we need to
1582              * restore the mbstate_t from before this conversion */
1583             ps[0] = ps[1];
1584             continue;
1585          }
1586
1587          if (len != 0 && (len -= (size_t)rv) == 0)
1588             l.defc.s = NULL, l.defc.l = 0;
1589          ps[1] = ps[0];
1590          break;
1591       }
1592
1593       /* Don't interpret control bytes during buffer take-over */
1594       if (cbuf != cbuf_base)
1595          goto jprint;
1596       switch (wc) {
1597       case 'A' ^ 0x40: /* cursor home */
1598          _ncl_khome(&l, TRU1);
1599          break;
1600 j_b:
1601       case 'B' ^ 0x40: /* backward character */
1602          _ncl_kleft(&l);
1603          break;
1604       /* 'C': interrupt (CTRL-C) */
1605       case 'D' ^ 0x40: /* delete char forward if any, else EOF */
1606          if ((rv = _ncl_keof(&l)) < 0)
1607             goto jleave;
1608          break;
1609       case 'E' ^ 0x40: /* end of line */
1610          _ncl_kend(&l);
1611          break;
1612 j_f:
1613       case 'F' ^ 0x40: /* forward character */
1614          _ncl_kright(&l);
1615          break;
1616       /* 'G' below */
1617       case 'H' ^ 0x40: /* backspace */
1618       case '\177':
1619          _ncl_kbs(&l);
1620          break;
1621       case 'I' ^ 0x40: /* horizontal tab */
1622 # ifdef HAVE_TABEXPAND
1623          if ((len = _ncl_kht(&l)) > 0)
1624             goto jrestart;
1625 # endif
1626          goto jbell;
1627       case 'J' ^ 0x40: /* NL (\n) */
1628          goto jdone;
1629       case 'G' ^ 0x40: /* full reset */
1630 jreset:
1631          /* FALLTHRU */
1632       case 'U' ^ 0x40: /* ^U: ^A + ^K */
1633          _ncl_khome(&l, FAL0);
1634          /* FALLTHRU */
1635       case 'K' ^ 0x40: /* kill from cursor to end of line */
1636          _ncl_kkill(&l, (wc == ('K' ^ 0x40) || l.topins == 0));
1637          /* (Handle full reset?) */
1638          if (wc == ('G' ^ 0x40)) {
1639 # ifdef HAVE_HISTORY
1640             l.hist = NULL;
1641 # endif
1642             if ((len = l.savec.l) != 0) {
1643                l.defc = l.savec;
1644                l.savec.s = NULL, l.savec.l = 0;
1645             } else
1646                len = l.defc.l;
1647          }
1648          fflush(stdout);
1649          goto jrestart;
1650 j_l:
1651       case 'L' ^ 0x40: /* repaint line */
1652          _ncl_krefresh(&l);
1653          break;
1654       /* 'M': CR (\r) */
1655 j_n:
1656       case 'N' ^ 0x40: /* history next */
1657 # ifdef HAVE_HISTORY
1658          if (l.hist == NULL)
1659             goto jbell;
1660          if ((len = _ncl_khist(&l, FAL0)) > 0)
1661             goto jrestart;
1662          wc = 'G' ^ 0x40;
1663          goto jreset;
1664 # else
1665          goto jbell;
1666 # endif
1667       /* 'O' */
1668 j_p:
1669       case 'P' ^ 0x40: /* history previous */
1670 # ifdef HAVE_HISTORY
1671          if ((len = _ncl_khist(&l, TRU1)) > 0)
1672             goto jrestart;
1673          wc = 'G' ^ 0x40;
1674          goto jreset;
1675 # else
1676          goto jbell;
1677 # endif
1678       /* 'Q': no code */
1679       case 'R' ^ 0x40: /* reverse history search */
1680 # ifdef HAVE_HISTORY
1681          if ((len = _ncl_krhist(&l)) > 0)
1682             goto jrestart;
1683          wc = 'G' ^ 0x40;
1684          goto jreset;
1685 # else
1686          goto jbell;
1687 # endif
1688       /* 'S': no code */
1689       /* 'U' above */
1690       /*case 'V' ^ 0x40: TODO*/ /* forward delete "word" */
1691       case 'W' ^ 0x40: /* backward delete "word" */
1692          _ncl_kbwddelw(&l);
1693          break;
1694       case 'X' ^ 0x40: /* move cursor forward "word" */
1695          _ncl_kgow(&l, +1);
1696          break;
1697       case 'Y' ^ 0x40: /* move cursor backward "word" */
1698          _ncl_kgow(&l, -1);
1699          break;
1700       /* 'Z': suspend (CTRL-Z) */
1701       case 0x1B:
1702          if (cursor_maybe++ != 0)
1703             goto jreset;
1704          continue;
1705       default:
1706          /* XXX Handle usual ^[[[ABCD1456] cursor keys: UGLY,"MAGIC",INFLEX */
1707          if (cursor_maybe > 0) {
1708             if (++cursor_maybe == 2) {
1709                if (wc == L'[')
1710                   continue;
1711                cursor_maybe = 0;
1712             } else if (cursor_maybe == 3) {
1713                cursor_maybe = 0;
1714                switch (wc) {
1715                default:    break;
1716                case L'A':  goto j_p;
1717                case L'B':  goto j_n;
1718                case L'C':  goto j_f;
1719                case L'D':  goto j_b;
1720                case L'1':
1721                case L'4':
1722                case L'5':
1723                case L'6':
1724                   cursor_store = ((wc == L'1') ? '0' :
1725                         (wc == L'4' ? '$' : (wc == L'5' ? '-' : '+')));
1726                   cursor_maybe = 3;
1727                   continue;
1728                }
1729                _ncl_kother(&l, L'[');
1730             } else {
1731                cursor_maybe = 0;
1732                if (wc == L'~') {
1733                   char x[2];
1734                   x[0] = cursor_store;
1735                   x[1] = '\0';
1736                   putchar('\n');
1737                   c_scroll(x);
1738                   cursor_store = 0;
1739                   goto j_l;
1740                }
1741                _ncl_kother(&l, L'[');
1742                _ncl_kother(&l, (wchar_t)cursor_store);
1743                cursor_store = 0;
1744             }
1745          }
1746 jprint:
1747          if (iswprint(wc)) {
1748             _ncl_kother(&l, wc);
1749             /* Don't clear the history during takeover..
1750              * ..and also avoid fflush()ing unless we've worked entire buffer */
1751             if (len > 0)
1752                continue;
1753 # ifdef HAVE_HISTORY
1754             if (cbuf == cbuf_base)
1755                l.hist = NULL;
1756 # endif
1757          } else {
1758 jbell:
1759             putchar('\a');
1760          }
1761          break;
1762       }
1763       fflush(stdout);
1764    }
1765
1766    /* We have a completed input line, convert the struct cell data to its
1767     * plain character equivalent */
1768 jdone:
1769    putchar('\n');
1770    fflush(stdout);
1771    len = _ncl_cell2dat(&l);
1772    rv = (ssize_t)len;
1773 jleave:
1774    NYD_LEAVE;
1775    return rv;
1776 }
1777
1778 FL void
1779 tty_init(void)
1780 {
1781 # ifdef HAVE_HISTORY
1782    long hs;
1783    char *v, *lbuf;
1784    FILE *f;
1785    size_t lsize, cnt, llen;
1786 # endif
1787    NYD_ENTER;
1788
1789    _ncl_oint.sint = _ncl_oquit.sint = _ncl_oterm.sint =
1790    _ncl_ohup.sint = _ncl_otstp.sint = _ncl_ottin.sint =
1791    _ncl_ottou.sint = -1;
1792
1793 # ifdef HAVE_HISTORY
1794    _CL_HISTSIZE(hs);
1795    _ncl_hist_size = 0;
1796    _ncl_hist_size_max = hs;
1797    if (hs == 0)
1798       goto jleave;
1799
1800    _CL_HISTFILE(v);
1801    if (v == NULL)
1802       goto jleave;
1803
1804    hold_all_sigs(); /* TODO too heavy, yet we may jump even here!? */
1805    f = fopen(v, "r"); /* TODO HISTFILE LOAD: use linebuf pool */
1806    if (f == NULL)
1807       goto jdone;
1808    fcntl_lock(fileno(f), FLOCK_READ); /* TODO ouch, retval check, etc. */
1809
1810    lbuf = NULL;
1811    lsize = 0;
1812    cnt = fsize(f);
1813    while (fgetline(&lbuf, &lsize, &cnt, &llen, f, FAL0) != NULL) {
1814       if (llen > 0 && lbuf[llen - 1] == '\n')
1815          lbuf[--llen] = '\0';
1816       if (llen == 0 || lbuf[0] == '#') /* xxx comments? noone! */
1817          continue;
1818       _ncl_hist_load = TRU1;
1819       tty_addhist(lbuf);
1820       _ncl_hist_load = FAL0;
1821    }
1822    if (lbuf != NULL)
1823       free(lbuf);
1824
1825    fclose(f);
1826 jdone:
1827    rele_all_sigs(); /* XXX remove jumps */
1828 jleave:
1829 # endif /* HAVE_HISTORY */
1830    NYD_LEAVE;
1831 }
1832
1833 FL void
1834 tty_destroy(void)
1835 {
1836 # ifdef HAVE_HISTORY
1837    long hs;
1838    char *v;
1839    struct hist *hp;
1840    FILE *f;
1841 # endif
1842    NYD_ENTER;
1843
1844 # ifdef HAVE_HISTORY
1845    _CL_HISTSIZE(hs);
1846    if (hs == 0)
1847       goto jleave;
1848
1849    _CL_HISTFILE(v);
1850    if (v == NULL)
1851       goto jleave;
1852
1853    if ((hp = _ncl_hist) != NULL)
1854       while (hp->older != NULL && hs-- != 0)
1855          hp = hp->older;
1856
1857    hold_all_sigs(); /* TODO too heavy, yet we may jump even here!? */
1858    f = fopen(v, "w"); /* TODO temporary + rename?! */
1859    if (f == NULL)
1860       goto jdone;
1861    fcntl_lock(fileno(f), FLOCK_WRITE); /* TODO ouch, retval check, etc. */
1862    if (fchmod(fileno(f), S_IRUSR | S_IWUSR) != 0)
1863       goto jclose;
1864
1865    for (; hp != NULL; hp = hp->younger) {
1866       fwrite(hp->dat, sizeof *hp->dat, hp->len, f);
1867       putc('\n', f);
1868    }
1869 jclose:
1870    fclose(f);
1871 jdone:
1872    rele_all_sigs(); /* XXX remove jumps */
1873 jleave:
1874 # endif /* HAVE_HISTORY */
1875    NYD_LEAVE;
1876 }
1877
1878 FL void
1879 tty_signal(int sig)
1880 {
1881    sigset_t nset, oset;
1882    NYD_X; /* Signal handler */
1883
1884    switch (sig) {
1885    case SIGWINCH:
1886       /* We don't deal with SIGWINCH, yet get called from main.c */
1887       break;
1888    default:
1889       _ncl_term_mode(FAL0);
1890       _ncl_sigs_down();
1891       sigemptyset(&nset);
1892       sigaddset(&nset, sig);
1893       sigprocmask(SIG_UNBLOCK, &nset, &oset);
1894       kill(0, sig);
1895       /* When we come here we'll continue editing, so reestablish */
1896       sigprocmask(SIG_BLOCK, &oset, (sigset_t*)NULL);
1897       _ncl_sigs_up();
1898       _ncl_term_mode(TRU1);
1899       break;
1900    }
1901 }
1902
1903 FL int
1904 (tty_readline)(char const *prompt, char **linebuf, size_t *linesize, size_t n
1905    SMALLOC_DEBUG_ARGS)
1906 {
1907    ssize_t nn;
1908    NYD_ENTER;
1909
1910    /* Of course we have races here, but they cannot be avoided on POSIX
1911     * (except by even *more* actions) */
1912    _ncl_sigs_up();
1913    _ncl_term_mode(TRU1);
1914    nn = _ncl_readline(prompt, linebuf, linesize, n SMALLOC_DEBUG_ARGSCALL);
1915    _ncl_term_mode(FAL0);
1916    _ncl_sigs_down();
1917    NYD_LEAVE;
1918    return (int)nn;
1919 }
1920
1921 FL void
1922 tty_addhist(char const *s)
1923 {
1924 # ifdef HAVE_HISTORY
1925    /* Super-Heavy-Metal: block all sigs, avoid leaks+ on jump */
1926    size_t l;
1927    struct hist *h, *o, *y;
1928 # endif
1929    NYD_ENTER;
1930    UNUSED(s);
1931
1932 # ifdef HAVE_HISTORY
1933    l = strlen(s);
1934
1935    if (_ncl_hist_size_max == 0)
1936       goto j_leave;
1937    _CL_CHECK_ADDHIST(s, goto j_leave);
1938
1939    /* Eliminating duplicates is expensive, but simply inacceptable so
1940     * during the load of a potentially large history file! */
1941    if (!_ncl_hist_load)
1942       for (h = _ncl_hist; h != NULL; h = h->older)
1943          if (h->len == l && !strcmp(h->dat, s)) {
1944             hold_all_sigs(); /* TODO */
1945             o = h->older;
1946             y = h->younger;
1947             if (o != NULL)
1948                o->younger = y;
1949             else
1950                _ncl_hist_tail = y;
1951             if (y != NULL)
1952                y->older = o;
1953             else
1954                _ncl_hist = o;
1955             goto jleave;
1956          }
1957    hold_all_sigs();
1958
1959    ++_ncl_hist_size;
1960    if (!_ncl_hist_load && _ncl_hist_size > _ncl_hist_size_max) {
1961       --_ncl_hist_size;
1962       if ((h = _ncl_hist_tail) != NULL) {
1963          if ((_ncl_hist_tail = h->younger) == NULL)
1964             _ncl_hist = NULL;
1965          else
1966             _ncl_hist_tail->older = NULL;
1967          free(h);
1968       }
1969    }
1970
1971    h = smalloc((sizeof(struct hist) - VFIELD_SIZEOF(struct hist, dat)) + l +1);
1972    h->len = l;
1973    memcpy(h->dat, s, l +1);
1974 jleave:
1975    if ((h->older = _ncl_hist) != NULL)
1976       _ncl_hist->younger = h;
1977    else
1978       _ncl_hist_tail = h;
1979    h->younger = NULL;
1980    _ncl_hist = h;
1981
1982    rele_all_sigs();
1983 j_leave:
1984 # endif
1985    NYD_LEAVE;
1986 }
1987
1988 # ifdef HAVE_HISTORY
1989 FL int
1990 c_history(void *v)
1991 {
1992    C_HISTORY_SHARED;
1993
1994 jlist: {
1995    FILE *fp;
1996    size_t i, b;
1997    struct hist *h;
1998
1999    if (_ncl_hist == NULL)
2000       goto jleave;
2001
2002    if ((fp = Ftmp(NULL, "hist", OF_RDWR | OF_UNLINK | OF_REGISTER, 0600)) ==
2003          NULL) {
2004       perror("tmpfile");
2005       v = NULL;
2006       goto jleave;
2007    }
2008
2009    i = _ncl_hist_size;
2010    b = 0;
2011    for (h = _ncl_hist; h != NULL; --i, b += h->len, h = h->older)
2012       fprintf(fp, "%4lu. %-50.50s (%4lu+%2lu bytes)\n",
2013          (ul_it)i, h->dat, (ul_it)b, (ul_it)h->len);
2014
2015    page_or_print(fp, i);
2016    Fclose(fp);
2017    }
2018    goto jleave;
2019
2020 jclear: {
2021    struct hist *h;
2022    while ((h = _ncl_hist) != NULL) {
2023       _ncl_hist = h->older;
2024       free(h);
2025    }
2026    _ncl_hist_tail = NULL;
2027    _ncl_hist_size = 0;
2028    }
2029    goto jleave;
2030
2031 jentry: {
2032    struct hist *h = _ncl_hist;
2033    if (UICMP(z, entry, <=, _ncl_hist_size)) {
2034       entry = (long)_ncl_hist_size - entry;
2035       for (h = _ncl_hist;; h = h->older)
2036          if (h == NULL)
2037             break;
2038          else if (entry-- != 0)
2039             continue;
2040          else {
2041             v = temporary_arg_v_store = h->dat;
2042             goto jleave;
2043          }
2044    }
2045    v = NULL;
2046    }
2047    goto jleave;
2048 }
2049 # endif /* HAVE_HISTORY */
2050 #endif /* HAVE_NCL */
2051
2052 /*
2053  * The really-nothing-at-all implementation
2054  */
2055
2056 #if !defined HAVE_READLINE && !defined HAVE_EDITLINE && !defined HAVE_NCL
2057 FL void
2058 tty_init(void)
2059 {
2060    NYD_ENTER;
2061    NYD_LEAVE;
2062 }
2063
2064 FL void
2065 tty_destroy(void)
2066 {
2067    NYD_ENTER;
2068    NYD_LEAVE;
2069 }
2070
2071 FL void
2072 tty_signal(int sig)
2073 {
2074    NYD_X; /* Signal handler */
2075    UNUSED(sig);
2076 }
2077
2078 FL int
2079 (tty_readline)(char const *prompt, char **linebuf, size_t *linesize, size_t n
2080    SMALLOC_DEBUG_ARGS)
2081 {
2082    /* TODO The nothing-at-all tty layer even forces re-entering all the
2083     * TODO original data when re-editing a field */
2084    bool_t doffl = FAL0;
2085    int rv;
2086    NYD_ENTER;
2087
2088    if (prompt != NULL && *prompt != '\0') {
2089       fputs(prompt, stdout);
2090       doffl = TRU1;
2091    }
2092    if (n > 0) {
2093       fprintf(stdout, tr(511, "{former content: %.*s} "), (int)n, *linebuf);
2094       n = 0;
2095       doffl = TRU1;
2096    }
2097    if (doffl)
2098       fflush(stdout);
2099    rv = (readline_restart)(stdin, linebuf, linesize,n SMALLOC_DEBUG_ARGSCALL);
2100    NYD_LEAVE;
2101    return rv;
2102 }
2103
2104 FL void
2105 tty_addhist(char const *s)
2106 {
2107    NYD_ENTER;
2108    UNUSED(s);
2109    NYD_LEAVE;
2110 }
2111 #endif /* nothing at all */
2112
2113 /* vim:set fenc=utf-8:s-it-mode */