crypto/dist/heimdal/lib/editline/editline.c

   1 /*  Copyright 1992 Simmule Turner and Rich Salz.  All rights reserved.
   2  *
   3  *  This software is not subject to any license of the American Telephone
   4  *  and Telegraph Company or of the Regents of the University of California.
   5  *
   6  *  Permission is granted to anyone to use this software for any purpose on
   7  *  any computer system, and to alter it and redistribute it freely, subject
   8  *  to the following restrictions:
   9  *  1. The authors are not responsible for the consequences of use of this
  10  *     software, no matter how awful, even if they arise from flaws in it.
  11  *  2. The origin of this software must not be misrepresented, either by
  12  *     explicit claim or by omission.  Since few users ever read sources,
  13  *     credits must appear in the documentation.
  14  *  3. Altered versions must be plainly marked as such, and must not be
  15  *     misrepresented as being the original software.  Since few users
  16  *     ever read sources, credits must appear in the documentation.
  17  *  4. This notice may not be removed or altered.
  18  */
  19
  20 /*
  21 **  Main editing routines for editline library.
  22 */
  23 #include <config.h>
  24 #include "edit_locl.h"
  25 #include <ctype.h>
  26 #include <errno.h>
  27
  28 __RCSID("$Heimdal: editline.c 15581 2005-07-07 20:55:18Z lha $"
  29         "$NetBSD$");
  30
  31 /*
  32 **  Manifest constants.
  33 */
  34 #define SCREEN_WIDTH    80
  35 #define SCREEN_ROWS     24
  36 #define NO_ARG          (-1)
  37 #define DEL             127
  38 #define CTL(x)          ((x) & 0x1F)
  39 #define ISCTL(x)        ((x) && (x) < ' ')
  40 #define UNCTL(x)        ((x) + 64)
  41 #define META(x)         ((x) | 0x80)
  42 #define ISMETA(x)       ((x) & 0x80)
  43 #define UNMETA(x)       ((x) & 0x7F)
  44 #if     !defined(HIST_SIZE)
  45 #define HIST_SIZE       20
  46 #endif  /* !defined(HIST_SIZE) */
  47
  48 /*
  49 **  Command status codes.
  50 */
  51 typedef enum _el_STATUS {
  52     CSdone, CSeof, CSmove, CSdispatch, CSstay
  53 } el_STATUS;
  54
  55 /*
  56 **  The type of case-changing to perform.
  57 */
  58 typedef enum _CASE {
  59     TOupper, TOlower
  60 } CASE;
  61
  62 /*
  63 **  Key to command mapping.
  64 */
  65 typedef struct _KEYMAP {
  66     unsigned char       Key;
  67     el_STATUS   (*Function)(void);
  68 } KEYMAP;
  69
  70 /*
  71 **  Command history structure.
  72 */
  73 typedef struct _HISTORY {
  74     int         Size;
  75     int         Pos;
  76     unsigned char       *Lines[HIST_SIZE];
  77 } HISTORY;
  78
  79 /*
  80 **  Globals.
  81 */
  82 int             rl_eof;
  83 int             rl_erase;
  84 int             rl_intr;
  85 int             rl_kill;
  86
  87 static unsigned char            NIL[] = "";
  88 static const unsigned char      *Input = NIL;
  89 static unsigned char            *Line;
  90 static const char       *Prompt;
  91 static unsigned char            *Yanked;
  92 static char             *Screen;
  93 static char             NEWLINE[]= CRLF;
  94 static HISTORY          H;
  95 int             rl_quit;
  96 static int              Repeat;
  97 static int              End;
  98 static int              Mark;
  99 static int              OldPoint;
 100 static int              Point;
 101 static int              PushBack;
 102 static int              Pushed;
 103 static KEYMAP           Map[33];
 104 static KEYMAP           MetaMap[16];
 105 static size_t           Length;
 106 static size_t           ScreenCount;
 107 static size_t           ScreenSize;
 108 static char             *backspace;
 109 static int              TTYwidth;
 110 static int              TTYrows;
 111
 112 /* Display print 8-bit chars as `M-x' or as the actual 8-bit char? */
 113 int             rl_meta_chars = 1;
 114
 115 /*
 116 **  Declarations.
 117 */
 118 static unsigned char    *editinput(void);
 119 char    *tgetstr(const char*, char**);
 120 int     tgetent(char*, const char*);
 121 int     tgetnum(const char*);
 122 \f
 123 /*
 124 **  TTY input/output functions.
 125 */
 126
 127 static void
 128 TTYflush(void)
 129 {
 130     if (ScreenCount) {
 131         write(1, Screen, ScreenCount);
 132         ScreenCount = 0;
 133     }
 134 }
 135
 136 static void
 137 TTYput(unsigned char c)
 138 {
 139     Screen[ScreenCount] = c;
 140     if (++ScreenCount >= ScreenSize - 1) {
 141         ScreenSize += SCREEN_INC;
 142         Screen = realloc(Screen, ScreenSize);
 143     }
 144 }
 145
 146 static void
 147 TTYputs(const char *p)
 148 {
 149     while (*p)
 150         TTYput(*p++);
 151 }
 152
 153 static void
 154 TTYshow(unsigned char c)
 155 {
 156     if (c == DEL) {
 157         TTYput('^');
 158         TTYput('?');
 159     }
 160     else if (ISCTL(c)) {
 161         TTYput('^');
 162         TTYput(UNCTL(c));
 163     }
 164     else if (rl_meta_chars && ISMETA(c)) {
 165         TTYput('M');
 166         TTYput('-');
 167         TTYput(UNMETA(c));
 168     }
 169     else
 170         TTYput(c);
 171 }
 172
 173 static void
 174 TTYstring(unsigned char *p)
 175 {
 176     while (*p)
 177         TTYshow(*p++);
 178 }
 179
 180 static int
 181 TTYget(void)
 182 {
 183     unsigned char c;
 184     int e;
 185
 186     TTYflush();
 187     if (Pushed) {
 188         Pushed = 0;
 189         return PushBack;
 190     }
 191     if (*Input)
 192         return *Input++;
 193     do {
 194         e = read(0, &c, 1);
 195     } while(e < 0 && errno == EINTR);
 196     if(e == 1)
 197         return c;
 198     return EOF;
 199 }
 200
 201 static void
 202 TTYback(void)
 203 {
 204     if (backspace)
 205         TTYputs(backspace);
 206     else
 207         TTYput('\b');
 208 }
 209
 210 static void
 211 TTYbackn(int n)
 212 {
 213     while (--n >= 0)
 214         TTYback();
 215 }
 216
 217 static void
 218 TTYinfo(void)
 219 {
 220     static int          init;
 221 #if     defined(TIOCGWINSZ)
 222     struct winsize      W;
 223 #endif  /* defined(TIOCGWINSZ) */
 224
 225     if (init) {
 226 #if     defined(TIOCGWINSZ)
 227         /* Perhaps we got resized. */
 228         if (ioctl(0, TIOCGWINSZ, &W) >= 0
 229          && W.ws_col > 0 && W.ws_row > 0) {
 230             TTYwidth = (int)W.ws_col;
 231             TTYrows = (int)W.ws_row;
 232         }
 233 #endif  /* defined(TIOCGWINSZ) */
 234         return;
 235     }
 236     init++;
 237
 238 #ifdef HAVE_TGETENT
 239     {
 240         char            buff[2048];
 241         char            *tmp;
 242         char            *bp;
 243         const char      *term;
 244
 245         TTYwidth = TTYrows = 0;
 246         bp = &buff[0];
 247         if ((term = getenv("TERM")) == NULL)
 248             term = "dumb";
 249         if (tgetent(buff, term) >= 0) {
 250
 251             tmp = tgetstr("le", &bp);
 252             if (tmp != NULL)
 253                 backspace = strdup(tmp);
 254             TTYwidth = tgetnum("co");
 255             TTYrows = tgetnum("li");
 256             return;
 257         }
 258     }
 259 #endif
 260
 261 #if     defined(TIOCGWINSZ)
 262     if (ioctl(0, TIOCGWINSZ, &W) >= 0) {
 263         TTYwidth = (int)W.ws_col;
 264         TTYrows = (int)W.ws_row;
 265     }
 266 #endif  /* defined(TIOCGWINSZ) */
 267
 268     if (TTYwidth <= 0 || TTYrows <= 0) {
 269         TTYwidth = SCREEN_WIDTH;
 270         TTYrows = SCREEN_ROWS;
 271     }
 272 }
 273 \f
 274
 275 /*
 276 **  Print an array of words in columns.
 277 */
 278 static void
 279 columns(int ac, unsigned char **av)
 280 {
 281     unsigned char       *p;
 282     int         i;
 283     int         j;
 284     int         k;
 285     int         len;
 286     int         skip;
 287     int         longest;
 288     int         cols;
 289
 290     /* Find longest name, determine column count from that. */
 291     for (longest = 0, i = 0; i < ac; i++)
 292         if ((j = strlen((char *)av[i])) > longest)
 293             longest = j;
 294     cols = TTYwidth / (longest + 3);
 295
 296     TTYputs(NEWLINE);
 297     for (skip = ac / cols + 1, i = 0; i < skip; i++) {
 298         for (j = i; j < ac; j += skip) {
 299             for (p = av[j], len = strlen((char *)p), k = len; --k >= 0; p++)
 300                 TTYput(*p);
 301             if (j + skip < ac)
 302                 while (++len < longest + 3)
 303                     TTYput(' ');
 304         }
 305         TTYputs(NEWLINE);
 306     }
 307 }
 308
 309 static void
 310 reposition(void)
 311 {
 312     int         i;
 313     unsigned char       *p;
 314
 315     TTYput('\r');
 316     TTYputs(Prompt);
 317     for (i = Point, p = Line; --i >= 0; p++)
 318         TTYshow(*p);
 319 }
 320
 321 static void
 322 left(el_STATUS Change)
 323 {
 324     TTYback();
 325     if (Point) {
 326         if (ISCTL(Line[Point - 1]))
 327             TTYback();
 328         else if (rl_meta_chars && ISMETA(Line[Point - 1])) {
 329             TTYback();
 330             TTYback();
 331         }
 332     }
 333     if (Change == CSmove)
 334         Point--;
 335 }
 336
 337 static void
 338 right(el_STATUS Change)
 339 {
 340     TTYshow(Line[Point]);
 341     if (Change == CSmove)
 342         Point++;
 343 }
 344
 345 static el_STATUS
 346 ring_bell(void)
 347 {
 348     TTYput('\07');
 349     TTYflush();
 350     return CSstay;
 351 }
 352
 353 static el_STATUS
 354 do_macro(unsigned char c)
 355 {
 356     unsigned char               name[4];
 357
 358     name[0] = '_';
 359     name[1] = c;
 360     name[2] = '_';
 361     name[3] = '\0';
 362
 363     if ((Input = (unsigned char *)getenv((char *)name)) == NULL) {
 364         Input = NIL;
 365         return ring_bell();
 366     }
 367     return CSstay;
 368 }
 369
 370 static el_STATUS
 371 do_forward(el_STATUS move)
 372 {
 373     int         i;
 374     unsigned char       *p;
 375
 376     i = 0;
 377     do {
 378         p = &Line[Point];
 379         for ( ; Point < End && (*p == ' ' || !isalnum(*p)); Point++, p++)
 380             if (move == CSmove)
 381                 right(CSstay);
 382
 383         for (; Point < End && isalnum(*p); Point++, p++)
 384             if (move == CSmove)
 385                 right(CSstay);
 386
 387         if (Point == End)
 388             break;
 389     } while (++i < Repeat);
 390
 391     return CSstay;
 392 }
 393
 394 static el_STATUS
 395 do_case(CASE type)
 396 {
 397     int         i;
 398     int         end;
 399     int         count;
 400     unsigned char       *p;
 401
 402     do_forward(CSstay);
 403     if (OldPoint != Point) {
 404         if ((count = Point - OldPoint) < 0)
 405             count = -count;
 406         Point = OldPoint;
 407         if ((end = Point + count) > End)
 408             end = End;
 409         for (i = Point, p = &Line[i]; i < end; i++, p++) {
 410             if (type == TOupper) {
 411                 if (islower(*p))
 412                     *p = toupper(*p);
 413             }
 414             else if (isupper(*p))
 415                 *p = tolower(*p);
 416             right(CSmove);
 417         }
 418     }
 419     return CSstay;
 420 }
 421
 422 static el_STATUS
 423 case_down_word(void)
 424 {
 425     return do_case(TOlower);
 426 }
 427
 428 static el_STATUS
 429 case_up_word(void)
 430 {
 431     return do_case(TOupper);
 432 }
 433
 434 static void
 435 ceol(void)
 436 {
 437     int         extras;
 438     int         i;
 439     unsigned char       *p;
 440
 441     for (extras = 0, i = Point, p = &Line[i]; i <= End; i++, p++) {
 442         TTYput(' ');
 443         if (ISCTL(*p)) {
 444             TTYput(' ');
 445             extras++;
 446         }
 447         else if (rl_meta_chars && ISMETA(*p)) {
 448             TTYput(' ');
 449             TTYput(' ');
 450             extras += 2;
 451         }
 452     }
 453
 454     for (i += extras; i > Point; i--)
 455         TTYback();
 456 }
 457
 458 static void
 459 clear_line(void)
 460 {
 461     Point = -strlen(Prompt);
 462     TTYput('\r');
 463     ceol();
 464     Point = 0;
 465     End = 0;
 466     Line[0] = '\0';
 467 }
 468
 469 static el_STATUS
 470 insert_string(unsigned char *p)
 471 {
 472     size_t      len;
 473     int         i;
 474     unsigned char       *new;
 475     unsigned char       *q;
 476
 477     len = strlen((char *)p);
 478     if (End + len >= Length) {
 479         if ((new = malloc(sizeof(unsigned char) * (Length + len + MEM_INC))) == NULL)
 480             return CSstay;
 481         if (Length) {
 482             memcpy(new, Line, Length);
 483             free(Line);
 484         }
 485         Line = new;
 486         Length += len + MEM_INC;
 487     }
 488
 489     for (q = &Line[Point], i = End - Point; --i >= 0; )
 490         q[len + i] = q[i];
 491     memcpy(&Line[Point], p, len);
 492     End += len;
 493     Line[End] = '\0';
 494     TTYstring(&Line[Point]);
 495     Point += len;
 496
 497     return Point == End ? CSstay : CSmove;
 498 }
 499 \f
 500
 501 static unsigned char *
 502 next_hist(void)
 503 {
 504     return H.Pos >= H.Size - 1 ? NULL : H.Lines[++H.Pos];
 505 }
 506
 507 static unsigned char *
 508 prev_hist(void)
 509 {
 510     return H.Pos == 0 ? NULL : H.Lines[--H.Pos];
 511 }
 512
 513 static el_STATUS
 514 do_insert_hist(unsigned char *p)
 515 {
 516     if (p == NULL)
 517         return ring_bell();
 518     Point = 0;
 519     reposition();
 520     ceol();
 521     End = 0;
 522     return insert_string(p);
 523 }
 524
 525 static el_STATUS
 526 do_hist(unsigned char *(*move)(void))
 527 {
 528     unsigned char       *p;
 529     int         i;
 530
 531     i = 0;
 532     do {
 533         if ((p = (*move)()) == NULL)
 534             return ring_bell();
 535     } while (++i < Repeat);
 536     return do_insert_hist(p);
 537 }
 538
 539 static el_STATUS
 540 h_next(void)
 541 {
 542     return do_hist(next_hist);
 543 }
 544
 545 static el_STATUS
 546 h_prev(void)
 547 {
 548     return do_hist(prev_hist);
 549 }
 550
 551 static el_STATUS
 552 h_first(void)
 553 {
 554     return do_insert_hist(H.Lines[H.Pos = 0]);
 555 }
 556
 557 static el_STATUS
 558 h_last(void)
 559 {
 560     return do_insert_hist(H.Lines[H.Pos = H.Size - 1]);
 561 }
 562
 563 /*
 564 **  Return zero if pat appears as a substring in text.
 565 */
 566 static int
 567 substrcmp(const char *text, const char *pat, size_t len)
 568 {
 569     char        c;
 570
 571     if ((c = *pat) == '\0')
 572         return *text == '\0';
 573     for ( ; *text; text++)
 574         if (*text == c && strncmp(text, pat, len) == 0)
 575             return 0;
 576     return 1;
 577 }
 578
 579 static unsigned char *
 580 search_hist(unsigned char *search, unsigned char *(*move)(void))
 581 {
 582     static unsigned char        *old_search;
 583     int         len;
 584     int         pos;
 585     int         (*match)(const char *, const char *, size_t);
 586     char        *pat;
 587
 588     /* Save or get remembered search pattern. */
 589     if (search && *search) {
 590         if (old_search)
 591             free(old_search);
 592         old_search = (unsigned char *)strdup((char *)search);
 593     }
 594     else {
 595         if (old_search == NULL || *old_search == '\0')
 596             return NULL;
 597         search = old_search;
 598     }
 599
 600     /* Set up pattern-finder. */
 601     if (*search == '^') {
 602         match = strncmp;
 603         pat = (char *)(search + 1);
 604     }
 605     else {
 606         match = substrcmp;
 607         pat = (char *)search;
 608     }
 609     len = strlen(pat);
 610
 611     for (pos = H.Pos; (*move)() != NULL; )
 612         if ((*match)((char *)H.Lines[H.Pos], pat, len) == 0)
 613             return H.Lines[H.Pos];
 614     H.Pos = pos;
 615     return NULL;
 616 }
 617
 618 static el_STATUS
 619 h_search(void)
 620 {
 621     static int  Searching;
 622     const char  *old_prompt;
 623     unsigned char       *(*move)(void);
 624     unsigned char       *p;
 625
 626     if (Searching)
 627         return ring_bell();
 628     Searching = 1;
 629
 630     clear_line();
 631     old_prompt = Prompt;
 632     Prompt = "Search: ";
 633     TTYputs(Prompt);
 634     move = Repeat == NO_ARG ? prev_hist : next_hist;
 635     p = search_hist(editinput(), move);
 636     clear_line();
 637     Prompt = old_prompt;
 638     TTYputs(Prompt);
 639
 640     Searching = 0;
 641     return do_insert_hist(p);
 642 }
 643
 644 static el_STATUS
 645 fd_char(void)
 646 {
 647     int         i;
 648
 649     i = 0;
 650     do {
 651         if (Point >= End)
 652             break;
 653         right(CSmove);
 654     } while (++i < Repeat);
 655     return CSstay;
 656 }
 657
 658 static void
 659 save_yank(int begin, int i)
 660 {
 661     if (Yanked) {
 662         free(Yanked);
 663         Yanked = NULL;
 664     }
 665
 666     if (i < 1)
 667         return;
 668
 669     if ((Yanked = malloc(sizeof(unsigned char) * (i + 1))) != NULL) {
 670         memcpy(Yanked, &Line[begin], i);
 671         Yanked[i+1] = '\0';
 672     }
 673 }
 674
 675 static el_STATUS
 676 delete_string(int count)
 677 {
 678     int         i;
 679     unsigned char       *p;
 680
 681     if (count <= 0 || End == Point)
 682         return ring_bell();
 683
 684     if (count == 1 && Point == End - 1) {
 685         /* Optimize common case of delete at end of line. */
 686         End--;
 687         p = &Line[Point];
 688         i = 1;
 689         TTYput(' ');
 690         if (ISCTL(*p)) {
 691             i = 2;
 692             TTYput(' ');
 693         }
 694         else if (rl_meta_chars && ISMETA(*p)) {
 695             i = 3;
 696             TTYput(' ');
 697             TTYput(' ');
 698         }
 699         TTYbackn(i);
 700         *p = '\0';
 701         return CSmove;
 702     }
 703     if (Point + count > End && (count = End - Point) <= 0)
 704         return CSstay;
 705
 706     if (count > 1)
 707         save_yank(Point, count);
 708
 709     for (p = &Line[Point], i = End - (Point + count) + 1; --i >= 0; p++)
 710         p[0] = p[count];
 711     ceol();
 712     End -= count;
 713     TTYstring(&Line[Point]);
 714     return CSmove;
 715 }
 716
 717 static el_STATUS
 718 bk_char(void)
 719 {
 720     int         i;
 721
 722     i = 0;
 723     do {
 724         if (Point == 0)
 725             break;
 726         left(CSmove);
 727     } while (++i < Repeat);
 728
 729     return CSstay;
 730 }
 731
 732 static el_STATUS
 733 bk_del_char(void)
 734 {
 735     int         i;
 736
 737     i = 0;
 738     do {
 739         if (Point == 0)
 740             break;
 741         left(CSmove);
 742     } while (++i < Repeat);
 743
 744     return delete_string(i);
 745 }
 746
 747 static el_STATUS
 748 redisplay(void)
 749 {
 750     TTYputs(NEWLINE);
 751     TTYputs(Prompt);
 752     TTYstring(Line);
 753     return CSmove;
 754 }
 755
 756 static el_STATUS
 757 kill_line(void)
 758 {
 759     int         i;
 760
 761     if (Repeat != NO_ARG) {
 762         if (Repeat < Point) {
 763             i = Point;
 764             Point = Repeat;
 765             reposition();
 766             delete_string(i - Point);
 767         }
 768         else if (Repeat > Point) {
 769             right(CSmove);
 770             delete_string(Repeat - Point - 1);
 771         }
 772         return CSmove;
 773     }
 774
 775     save_yank(Point, End - Point);
 776     Line[Point] = '\0';
 777     ceol();
 778     End = Point;
 779     return CSstay;
 780 }
 781
 782 static el_STATUS
 783 insert_char(int c)
 784 {
 785     el_STATUS   s;
 786     unsigned char       buff[2];
 787     unsigned char       *p;
 788     unsigned char       *q;
 789     int         i;
 790
 791     if (Repeat == NO_ARG || Repeat < 2) {
 792         buff[0] = c;
 793         buff[1] = '\0';
 794         return insert_string(buff);
 795     }
 796
 797     if ((p = malloc(Repeat + 1)) == NULL)
 798         return CSstay;
 799     for (i = Repeat, q = p; --i >= 0; )
 800         *q++ = c;
 801     *q = '\0';
 802     Repeat = 0;
 803     s = insert_string(p);
 804     free(p);
 805     return s;
 806 }
 807
 808 static el_STATUS
 809 meta(void)
 810 {
 811     unsigned int        c;
 812     KEYMAP              *kp;
 813
 814     if ((c = TTYget()) == EOF)
 815         return CSeof;
 816     /* Also include VT-100 arrows. */
 817     if (c == '[' || c == 'O')
 818         switch (c = TTYget()) {
 819         default:        return ring_bell();
 820         case EOF:       return CSeof;
 821         case 'A':       return h_prev();
 822         case 'B':       return h_next();
 823         case 'C':       return fd_char();
 824         case 'D':       return bk_char();
 825         }
 826
 827     if (isdigit(c)) {
 828         for (Repeat = c - '0'; (c = TTYget()) != EOF && isdigit(c); )
 829             Repeat = Repeat * 10 + c - '0';
 830         Pushed = 1;
 831         PushBack = c;
 832         return CSstay;
 833     }
 834
 835     if (isupper(c))
 836         return do_macro(c);
 837     for (OldPoint = Point, kp = MetaMap; kp->Function; kp++)
 838         if (kp->Key == c)
 839             return (*kp->Function)();
 840
 841     return ring_bell();
 842 }
 843
 844 static el_STATUS
 845 emacs(unsigned int c)
 846 {
 847     el_STATUS           s;
 848     KEYMAP              *kp;
 849
 850     if (ISMETA(c)) {
 851         Pushed = 1;
 852         PushBack = UNMETA(c);
 853         return meta();
 854     }
 855     for (kp = Map; kp->Function; kp++)
 856         if (kp->Key == c)
 857             break;
 858     s = kp->Function ? (*kp->Function)() : insert_char((int)c);
 859     if (!Pushed)
 860         /* No pushback means no repeat count; hacky, but true. */
 861         Repeat = NO_ARG;
 862     return s;
 863 }
 864
 865 static el_STATUS
 866 TTYspecial(unsigned int c)
 867 {
 868     if (ISMETA(c))
 869         return CSdispatch;
 870
 871     if (c == rl_erase || c == DEL)
 872         return bk_del_char();
 873     if (c == rl_kill) {
 874         if (Point != 0) {
 875             Point = 0;
 876             reposition();
 877         }
 878         Repeat = NO_ARG;
 879         return kill_line();
 880     }
 881     if (c == rl_intr || c == rl_quit) {
 882         Point = End = 0;
 883         Line[0] = '\0';
 884         return redisplay();
 885     }
 886     if (c == rl_eof && Point == 0 && End == 0)
 887         return CSeof;
 888
 889     return CSdispatch;
 890 }
 891
 892 static unsigned char *
 893 editinput(void)
 894 {
 895     unsigned int        c;
 896
 897     Repeat = NO_ARG;
 898     OldPoint = Point = Mark = End = 0;
 899     Line[0] = '\0';
 900
 901     while ((c = TTYget()) != EOF)
 902         switch (TTYspecial(c)) {
 903         case CSdone:
 904             return Line;
 905         case CSeof:
 906             return NULL;
 907         case CSmove:
 908             reposition();
 909             break;
 910         case CSdispatch:
 911             switch (emacs(c)) {
 912             case CSdone:
 913                 return Line;
 914             case CSeof:
 915                 return NULL;
 916             case CSmove:
 917                 reposition();
 918                 break;
 919             case CSdispatch:
 920             case CSstay:
 921                 break;
 922             }
 923             break;
 924         case CSstay:
 925             break;
 926         }
 927     return NULL;
 928 }
 929
 930 static void
 931 hist_add(unsigned char *p)
 932 {
 933     int         i;
 934
 935     if ((p = (unsigned char *)strdup((char *)p)) == NULL)
 936         return;
 937     if (H.Size < HIST_SIZE)
 938         H.Lines[H.Size++] = p;
 939     else {
 940         free(H.Lines[0]);
 941         for (i = 0; i < HIST_SIZE - 1; i++)
 942             H.Lines[i] = H.Lines[i + 1];
 943         H.Lines[i] = p;
 944     }
 945     H.Pos = H.Size - 1;
 946 }
 947
 948 /*
 949 **  For compatibility with FSF readline.
 950 */
 951 /* ARGSUSED0 */
 952 void
 953 rl_reset_terminal(char *p)
 954 {
 955 }
 956
 957 void
 958 rl_initialize(void)
 959 {
 960 }
 961
 962 char *
 963 readline(const char* prompt)
 964 {
 965     unsigned char       *line;
 966
 967     if (Line == NULL) {
 968         Length = MEM_INC;
 969         if ((Line = malloc(Length)) == NULL)
 970             return NULL;
 971     }
 972
 973     TTYinfo();
 974     rl_ttyset(0);
 975     hist_add(NIL);
 976     ScreenSize = SCREEN_INC;
 977     Screen = malloc(ScreenSize);
 978     Prompt = prompt ? prompt : (char *)NIL;
 979     TTYputs(Prompt);
 980     if ((line = editinput()) != NULL) {
 981         line = (unsigned char *)strdup((char *)line);
 982         TTYputs(NEWLINE);
 983         TTYflush();
 984     }
 985     rl_ttyset(1);
 986     free(Screen);
 987     free(H.Lines[--H.Size]);
 988     return (char *)line;
 989 }
 990
 991 void
 992 add_history(char *p)
 993 {
 994     if (p == NULL || *p == '\0')
 995         return;
 996
 997 #if     defined(UNIQUE_HISTORY)
 998     if (H.Pos && strcmp(p, H.Lines[H.Pos - 1]) == 0)
 999         return;
1000 #endif  /* defined(UNIQUE_HISTORY) */
1001     hist_add((unsigned char *)p);
1002 }
1003 \f
1004
1005 static el_STATUS
1006 beg_line(void)
1007 {
1008     if (Point) {
1009         Point = 0;
1010         return CSmove;
1011     }
1012     return CSstay;
1013 }
1014
1015 static el_STATUS
1016 del_char(void)
1017 {
1018     return delete_string(Repeat == NO_ARG ? 1 : Repeat);
1019 }
1020
1021 static el_STATUS
1022 end_line(void)
1023 {
1024     if (Point != End) {
1025         Point = End;
1026         return CSmove;
1027     }
1028     return CSstay;
1029 }
1030
1031 /*
1032 **  Move back to the beginning of the current word and return an
1033 **  allocated copy of it.
1034 */
1035 static unsigned char *
1036 find_word(void)
1037 {
1038     static char SEPS[] = "#;&|^$=`'{}()<>\n\t ";
1039     unsigned char       *p;
1040     unsigned char       *new;
1041     size_t      len;
1042
1043     for (p = &Line[Point]; p > Line && strchr(SEPS, (char)p[-1]) == NULL; p--)
1044         continue;
1045     len = Point - (p - Line) + 1;
1046     if ((new = malloc(len)) == NULL)
1047         return NULL;
1048     memcpy(new, p, len);
1049     new[len - 1] = '\0';
1050     return new;
1051 }
1052
1053 static el_STATUS
1054 c_complete(void)
1055 {
1056     unsigned char       *p;
1057     unsigned char       *word;
1058     int         unique;
1059     el_STATUS   s;
1060
1061     word = find_word();
1062     p = (unsigned char *)rl_complete((char *)word, &unique);
1063     if (word)
1064         free(word);
1065     if (p && *p) {
1066         s = insert_string(p);
1067         if (!unique)
1068             ring_bell();
1069         free(p);
1070         return s;
1071     }
1072     return ring_bell();
1073 }
1074
1075 static el_STATUS
1076 c_possible(void)
1077 {
1078     unsigned char       **av;
1079     unsigned char       *word;
1080     int         ac;
1081
1082     word = find_word();
1083     ac = rl_list_possib((char *)word, (void *)&av);
1084     if (word)
1085         free(word);
1086     if (ac) {
1087         columns(ac, av);
1088         while (--ac >= 0)
1089             free(av[ac]);
1090         free(av);
1091         return CSmove;
1092     }
1093     return ring_bell();
1094 }
1095
1096 static el_STATUS
1097 accept_line(void)
1098 {
1099     Line[End] = '\0';
1100     return CSdone;
1101 }
1102
1103 static el_STATUS
1104 transpose(void)
1105 {
1106     unsigned char       c;
1107
1108     if (Point) {
1109         if (Point == End)
1110             left(CSmove);
1111         c = Line[Point - 1];
1112         left(CSstay);
1113         Line[Point - 1] = Line[Point];
1114         TTYshow(Line[Point - 1]);
1115         Line[Point++] = c;
1116         TTYshow(c);
1117     }
1118     return CSstay;
1119 }
1120
1121 static el_STATUS
1122 quote(void)
1123 {
1124     unsigned int        c;
1125
1126     return (c = TTYget()) == EOF ? CSeof : insert_char((int)c);
1127 }
1128
1129 static el_STATUS
1130 wipe(void)
1131 {
1132     int         i;
1133
1134     if (Mark > End)
1135         return ring_bell();
1136
1137     if (Point > Mark) {
1138         i = Point;
1139         Point = Mark;
1140         Mark = i;
1141         reposition();
1142     }
1143
1144     return delete_string(Mark - Point);
1145 }
1146
1147 static el_STATUS
1148 mk_set(void)
1149 {
1150     Mark = Point;
1151     return CSstay;
1152 }
1153
1154 static el_STATUS
1155 exchange(void)
1156 {
1157     unsigned int        c;
1158
1159     if ((c = TTYget()) != CTL('X'))
1160         return c == EOF ? CSeof : ring_bell();
1161
1162     if ((c = Mark) <= End) {
1163         Mark = Point;
1164         Point = c;
1165         return CSmove;
1166     }
1167     return CSstay;
1168 }
1169
1170 static el_STATUS
1171 yank(void)
1172 {
1173     if (Yanked && *Yanked)
1174         return insert_string(Yanked);
1175     return CSstay;
1176 }
1177
1178 static el_STATUS
1179 copy_region(void)
1180 {
1181     if (Mark > End)
1182         return ring_bell();
1183
1184     if (Point > Mark)
1185         save_yank(Mark, Point - Mark);
1186     else
1187         save_yank(Point, Mark - Point);
1188
1189     return CSstay;
1190 }
1191
1192 static el_STATUS
1193 move_to_char(void)
1194 {
1195     unsigned int        c;
1196     int                 i;
1197     unsigned char               *p;
1198
1199     if ((c = TTYget()) == EOF)
1200         return CSeof;
1201     for (i = Point + 1, p = &Line[i]; i < End; i++, p++)
1202         if (*p == c) {
1203             Point = i;
1204             return CSmove;
1205         }
1206     return CSstay;
1207 }
1208
1209 static el_STATUS
1210 fd_word(void)
1211 {
1212     return do_forward(CSmove);
1213 }
1214
1215 static el_STATUS
1216 fd_kill_word(void)
1217 {
1218     int         i;
1219
1220     do_forward(CSstay);
1221     if (OldPoint != Point) {
1222         i = Point - OldPoint;
1223         Point = OldPoint;
1224         return delete_string(i);
1225     }
1226     return CSstay;
1227 }
1228
1229 static el_STATUS
1230 bk_word(void)
1231 {
1232     int         i;
1233     unsigned char       *p;
1234
1235     i = 0;
1236     do {
1237         for (p = &Line[Point]; p > Line && !isalnum(p[-1]); p--)
1238             left(CSmove);
1239
1240         for (; p > Line && p[-1] != ' ' && isalnum(p[-1]); p--)
1241             left(CSmove);
1242
1243         if (Point == 0)
1244             break;
1245     } while (++i < Repeat);
1246
1247     return CSstay;
1248 }
1249
1250 static el_STATUS
1251 bk_kill_word(void)
1252 {
1253     bk_word();
1254     if (OldPoint != Point)
1255         return delete_string(OldPoint - Point);
1256     return CSstay;
1257 }
1258
1259 static int
1260 argify(unsigned char *line, unsigned char ***avp)
1261 {
1262     unsigned char       *c;
1263     unsigned char       **p;
1264     unsigned char       **new;
1265     int         ac;
1266     int         i;
1267
1268     i = MEM_INC;
1269     if ((*avp = p = malloc(sizeof(unsigned char*) * i))== NULL)
1270          return 0;
1271
1272     for (c = line; isspace(*c); c++)
1273         continue;
1274     if (*c == '\n' || *c == '\0')
1275         return 0;
1276
1277     for (ac = 0, p[ac++] = c; *c && *c != '\n'; ) {
1278         if (isspace(*c)) {
1279             *c++ = '\0';
1280             if (*c && *c != '\n') {
1281                 if (ac + 1 == i) {
1282                     new = malloc(sizeof(unsigned char*) * (i + MEM_INC));
1283                     if (new == NULL) {
1284                         p[ac] = NULL;
1285                         return ac;
1286                     }
1287                     memcpy(new, p, i * sizeof (char **));
1288                     i += MEM_INC;
1289                     free(p);
1290                     *avp = p = new;
1291                 }
1292                 p[ac++] = c;
1293             }
1294         }
1295         else
1296             c++;
1297     }
1298     *c = '\0';
1299     p[ac] = NULL;
1300     return ac;
1301 }
1302
1303 static el_STATUS
1304 last_argument(void)
1305 {
1306     unsigned char       **av;
1307     unsigned char       *p;
1308     el_STATUS   s;
1309     int         ac;
1310
1311     if (H.Size == 1 || (p = H.Lines[H.Size - 2]) == NULL)
1312         return ring_bell();
1313
1314     if ((p = (unsigned char *)strdup((char *)p)) == NULL)
1315         return CSstay;
1316     ac = argify(p, &av);
1317
1318     if (Repeat != NO_ARG)
1319         s = Repeat < ac ? insert_string(av[Repeat]) : ring_bell();
1320     else
1321         s = ac ? insert_string(av[ac - 1]) : CSstay;
1322
1323     if (ac)
1324         free(av);
1325     free(p);
1326     return s;
1327 }
1328
1329 static KEYMAP   Map[33] = {
1330     {   CTL('@'),       ring_bell       },
1331     {   CTL('A'),       beg_line        },
1332     {   CTL('B'),       bk_char         },
1333     {   CTL('D'),       del_char        },
1334     {   CTL('E'),       end_line        },
1335     {   CTL('F'),       fd_char         },
1336     {   CTL('G'),       ring_bell       },
1337     {   CTL('H'),       bk_del_char     },
1338     {   CTL('I'),       c_complete      },
1339     {   CTL('J'),       accept_line     },
1340     {   CTL('K'),       kill_line       },
1341     {   CTL('L'),       redisplay       },
1342     {   CTL('M'),       accept_line     },
1343     {   CTL('N'),       h_next          },
1344     {   CTL('O'),       ring_bell       },
1345     {   CTL('P'),       h_prev          },
1346     {   CTL('Q'),       ring_bell       },
1347     {   CTL('R'),       h_search        },
1348     {   CTL('S'),       ring_bell       },
1349     {   CTL('T'),       transpose       },
1350     {   CTL('U'),       ring_bell       },
1351     {   CTL('V'),       quote           },
1352     {   CTL('W'),       wipe            },
1353     {   CTL('X'),       exchange        },
1354     {   CTL('Y'),       yank            },
1355     {   CTL('Z'),       ring_bell       },
1356     {   CTL('['),       meta            },
1357     {   CTL(']'),       move_to_char    },
1358     {   CTL('^'),       ring_bell       },
1359     {   CTL('_'),       ring_bell       },
1360     {   0,              NULL            }
1361 };
1362
1363 static KEYMAP   MetaMap[16]= {
1364     {   CTL('H'),       bk_kill_word    },
1365     {   DEL,            bk_kill_word    },
1366     {   ' ',            mk_set  },
1367     {   '.',            last_argument   },
1368     {   '<',            h_first         },
1369     {   '>',            h_last          },
1370     {   '?',            c_possible      },
1371     {   'b',            bk_word         },
1372     {   'd',            fd_kill_word    },
1373     {   'f',            fd_word         },
1374     {   'l',            case_down_word  },
1375     {   'u',            case_up_word    },
1376     {   'y',            yank            },
1377     {   'w',            copy_region     },
1378     {   0,              NULL            }
1379 };