contrib/tcsh-6/ed.chared.c

   1 /* $Header: /p/tcsh/cvsroot/tcsh/ed.chared.c,v 3.95 2009/06/25 21:15:37 christos Exp $ */
   2 /*
   3  * ed.chared.c: Character editing functions.
   4  */
   5 /*-
   6  * Copyright (c) 1980, 1991 The Regents of the University of California.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33 /*
  34   Bjorn Knutsson @ Thu Jun 24 19:02:17 1999
  35
  36   e_dabbrev_expand() did not do proper completion if quoted spaces were present
  37   in the string being completed. Exemple:
  38
  39   # echo hello\ world
  40   hello world
  41   # echo h<press key bound to dabbrev-expande>
  42   # echo hello\<cursor>
  43
  44   Correct behavior is:
  45   # echo h<press key bound to dabbrev-expande>
  46   # echo hello\ world<cursor>
  47
  48   The same problem occured if spaces were present in a string withing quotation
  49   marks. Example:
  50
  51   # echo "hello world"
  52   hello world
  53   # echo "h<press key bound to dabbrev-expande>
  54   # echo "hello<cursor>
  55
  56   The former problem could be solved with minor modifications of c_preword()
  57   and c_endword(). The latter, however, required a significant rewrite of
  58   c_preword(), since quoted strings must be parsed from start to end to
  59   determine if a given character is inside or outside the quotation marks.
  60
  61   Compare the following two strings:
  62
  63   # echo \"" 'foo \' bar\"
  64   " 'foo \' bar\
  65   # echo '\"" 'foo \' bar\"
  66   \"" foo ' bar"
  67
  68   The only difference between the two echo lines is in the first character
  69   after the echo command. The result is either one or three arguments.
  70
  71  */
  72
  73 #include "sh.h"
  74
  75 RCSID("$tcsh: ed.chared.c,v 3.95 2009/06/25 21:15:37 christos Exp $")
  76
  77 #include "ed.h"
  78 #include "tw.h"
  79 #include "ed.defns.h"
  80
  81 /* #define SDEBUG */
  82
  83 #define TCSHOP_NOP        0x00
  84 #define TCSHOP_DELETE     0x01
  85 #define TCSHOP_INSERT     0x02
  86 #define TCSHOP_CHANGE     0x04
  87
  88 #define CHAR_FWD        0
  89 #define CHAR_BACK       1
  90
  91 /*
  92  * vi word treatment
  93  * from: Gert-Jan Vons <vons@cesar.crbca1.sinet.slb.com>
  94  */
  95 #define C_CLASS_WHITE   1
  96 #define C_CLASS_ALNUM   2
  97 #define C_CLASS_OTHER   3
  98
  99 static Char *InsertPos = InputBuf; /* Where insertion starts */
 100 static Char *ActionPos = 0;        /* Where action begins  */
 101 static int  ActionFlag = TCSHOP_NOP;       /* What delayed action to take */
 102 /*
 103  * Word search state
 104  */
 105 static int  searchdir = F_UP_SEARCH_HIST;       /* Direction of last search */
 106 static struct Strbuf patbuf; /* = Strbuf_INIT; Search target */
 107 /*
 108  * Char search state
 109  */
 110 static int  srch_dir = CHAR_FWD;                /* Direction of last search */
 111 static Char srch_char = 0;                      /* Search target */
 112
 113 /* all routines that start with c_ are private to this set of routines */
 114 static  void     c_alternativ_key_map   (int);
 115 void     c_insert               (int);
 116 void     c_delafter             (int);
 117 void     c_delbefore            (int);
 118 static  int      c_to_class             (Char);
 119 static  Char    *c_prev_word            (Char *, Char *, int);
 120 static  Char    *c_next_word            (Char *, Char *, int);
 121 static  Char    *c_number               (Char *, int *, int);
 122 static  Char    *c_expand               (Char *);
 123 static  int      c_excl                 (Char *);
 124 static  int      c_substitute           (void);
 125 static  void     c_delfini              (void);
 126 static  int      c_hmatch               (Char *);
 127 static  void     c_hsetpat              (void);
 128 #ifdef COMMENT
 129 static  void     c_get_word             (Char **, Char **);
 130 #endif
 131 static  Char    *c_preword              (Char *, Char *, int, Char *);
 132 static  Char    *c_nexword              (Char *, Char *, int);
 133 static  Char    *c_endword              (Char *, Char *, int, Char *);
 134 static  Char    *c_eword                (Char *, Char *, int);
 135 static  void     c_push_kill            (Char *, Char *);
 136 static  void     c_save_inputbuf        (void);
 137 static  CCRETVAL c_search_line          (Char *, int);
 138 static  CCRETVAL v_repeat_srch          (int);
 139 static  CCRETVAL e_inc_search           (int);
 140 #ifdef notyet
 141 static  CCRETVAL e_insert_str           (Char *);
 142 #endif
 143 static  CCRETVAL v_search               (int);
 144 static  CCRETVAL v_csearch_fwd          (Char, int, int);
 145 static  CCRETVAL v_action               (int);
 146 static  CCRETVAL v_csearch_back         (Char, int, int);
 147
 148 static void
 149 c_alternativ_key_map(int state)
 150 {
 151     switch (state) {
 152     case 0:
 153         CurrentKeyMap = CcKeyMap;
 154         break;
 155     case 1:
 156         CurrentKeyMap = CcAltMap;
 157         break;
 158     default:
 159         return;
 160     }
 161
 162     AltKeyMap = (Char) state;
 163 }
 164
 165 void
 166 c_insert(int num)
 167 {
 168     Char *cp;
 169
 170     if (LastChar + num >= InputLim)
 171         return;                 /* can't go past end of buffer */
 172
 173     if (Cursor < LastChar) {    /* if I must move chars */
 174         for (cp = LastChar; cp >= Cursor; cp--)
 175             cp[num] = *cp;
 176         if (Mark && Mark > Cursor)
 177                 Mark += num;
 178     }
 179     LastChar += num;
 180 }
 181
 182 void
 183 c_delafter(int num)
 184 {
 185     Char *cp, *kp = NULL;
 186
 187     if (num > LastChar - Cursor)
 188         num = (int) (LastChar - Cursor);        /* bounds check */
 189
 190     if (num > 0) {                      /* if I can delete anything */
 191         if (VImode) {
 192             kp = UndoBuf;               /* Set Up for VI undo command */
 193             UndoAction = TCSHOP_INSERT;
 194             UndoSize = num;
 195             UndoPtr  = Cursor;
 196             for (cp = Cursor; cp <= LastChar; cp++) {
 197                 *kp++ = *cp;    /* Save deleted chars into undobuf */
 198                 *cp = cp[num];
 199             }
 200         }
 201         else
 202             for (cp = Cursor; cp + num <= LastChar; cp++)
 203                 *cp = cp[num];
 204         LastChar -= num;
 205         /* Mark was within the range of the deleted word? */
 206         if (Mark && Mark > Cursor && Mark <= Cursor+num)
 207                 Mark = Cursor;
 208         /* Mark after the deleted word? */
 209         else if (Mark && Mark > Cursor)
 210                 Mark -= num;
 211     }
 212 #ifdef notdef
 213     else {
 214         /*
 215          * XXX: We don't want to do that. In emacs mode overwrite should be
 216          * sticky. I am not sure how that affects vi mode
 217          */
 218         inputmode = MODE_INSERT;
 219     }
 220 #endif /* notdef */
 221 }
 222
 223 void
 224 c_delbefore(int num)            /* delete before dot, with bounds checking */
 225 {
 226     Char *cp, *kp = NULL;
 227
 228     if (num > Cursor - InputBuf)
 229         num = (int) (Cursor - InputBuf);        /* bounds check */
 230
 231     if (num > 0) {                      /* if I can delete anything */
 232         if (VImode) {
 233             kp = UndoBuf;               /* Set Up for VI undo command */
 234             UndoAction = TCSHOP_INSERT;
 235             UndoSize = num;
 236             UndoPtr  = Cursor - num;
 237             for (cp = Cursor - num; cp <= LastChar; cp++) {
 238                 *kp++ = *cp;
 239                 *cp = cp[num];
 240             }
 241         }
 242         else
 243             for (cp = Cursor - num; cp + num <= LastChar; cp++)
 244                 *cp = cp[num];
 245         LastChar -= num;
 246         Cursor -= num;
 247         /* Mark was within the range of the deleted word? */
 248         if (Mark && Mark > Cursor && Mark <= Cursor+num)
 249                 Mark = Cursor;
 250         /* Mark after the deleted word? */
 251         else if (Mark && Mark > Cursor)
 252                 Mark -= num;
 253     }
 254 }
 255
 256 static Char *
 257 c_preword(Char *p, Char *low, int n, Char *delim)
 258 {
 259   while (n--) {
 260     Char *prev = low;
 261     Char *new;
 262
 263     while (prev < p) {          /* Skip initial non-word chars */
 264       if (!Strchr(delim, *prev) || *(prev-1) == (Char)'\\')
 265         break;
 266       prev++;
 267     }
 268
 269     new = prev;
 270
 271     while (new < p) {
 272       prev = new;
 273       new = c_endword(prev-1, p, 1, delim); /* Skip to next non-word char */
 274       new++;                    /* Step away from end of word */
 275       while (new <= p) {        /* Skip trailing non-word chars */
 276         if (!Strchr(delim, *new) || *(new-1) == (Char)'\\')
 277           break;
 278         new++;
 279       }
 280     }
 281
 282     p = prev;                   /* Set to previous word start */
 283
 284   }
 285   if (p < low)
 286     p = low;
 287   return (p);
 288 }
 289
 290 /*
 291  * c_to_class() returns the class of the given character.
 292  *
 293  * This is used to make the c_prev_word() and c_next_word() functions
 294  * work like vi's, which classify characters. A word is a sequence of
 295  * characters belonging to the same class, classes being defined as
 296  * follows:
 297  *
 298  *      1/ whitespace
 299  *      2/ alphanumeric chars, + underscore
 300  *      3/ others
 301  */
 302 static int
 303 c_to_class(Char ch)
 304 {
 305     if (Isspace(ch))
 306         return C_CLASS_WHITE;
 307
 308     if (Isdigit(ch) || Isalpha(ch) || ch == '_')
 309         return C_CLASS_ALNUM;
 310
 311     return C_CLASS_OTHER;
 312 }
 313
 314 static Char *
 315 c_prev_word(Char *p, Char *low, int n)
 316 {
 317     p--;
 318
 319     if (!VImode) {
 320         while (n--) {
 321             while ((p >= low) && !isword(*p))
 322                 p--;
 323             while ((p >= low) && isword(*p))
 324                 p--;
 325         }
 326
 327         /* cp now points to one character before the word */
 328         p++;
 329         if (p < low)
 330             p = low;
 331         /* cp now points where we want it */
 332         return(p);
 333     }
 334
 335     while (n--) {
 336         int  c_class;
 337
 338         if (p < low)
 339             break;
 340
 341         /* scan until beginning of current word (may be all whitespace!) */
 342         c_class = c_to_class(*p);
 343         while ((p >= low) && c_class == c_to_class(*p))
 344             p--;
 345
 346         /* if this was a non_whitespace word, we're ready */
 347         if (c_class != C_CLASS_WHITE)
 348             continue;
 349
 350         /* otherwise, move back to beginning of the word just found */
 351         c_class = c_to_class(*p);
 352         while ((p >= low) && c_class == c_to_class(*p))
 353             p--;
 354     }
 355
 356     p++;                        /* correct overshoot */
 357
 358     return (p);
 359 }
 360
 361 static Char *
 362 c_next_word(Char *p, Char *high, int n)
 363 {
 364     if (!VImode) {
 365         while (n--) {
 366             while ((p < high) && !isword(*p))
 367                 p++;
 368             while ((p < high) && isword(*p))
 369                 p++;
 370         }
 371         if (p > high)
 372             p = high;
 373         /* p now points where we want it */
 374         return(p);
 375     }
 376
 377     while (n--) {
 378         int  c_class;
 379
 380         if (p >= high)
 381             break;
 382
 383         /* scan until end of current word (may be all whitespace!) */
 384         c_class = c_to_class(*p);
 385         while ((p < high) && c_class == c_to_class(*p))
 386             p++;
 387
 388         /* if this was all whitespace, we're ready */
 389         if (c_class == C_CLASS_WHITE)
 390             continue;
 391
 392         /* if we've found white-space at the end of the word, skip it */
 393         while ((p < high) && c_to_class(*p) == C_CLASS_WHITE)
 394             p++;
 395     }
 396
 397     p--;                        /* correct overshoot */
 398
 399     return (p);
 400 }
 401
 402 static Char *
 403 c_nexword(Char *p, Char *high, int n)
 404 {
 405     while (n--) {
 406         while ((p < high) && !Isspace(*p))
 407             p++;
 408         while ((p < high) && Isspace(*p))
 409             p++;
 410     }
 411
 412     if (p > high)
 413         p = high;
 414     /* p now points where we want it */
 415     return(p);
 416 }
 417
 418 /*
 419  * Expand-History (originally "Magic-Space") code added by
 420  * Ray Moody <ray@gibbs.physics.purdue.edu>
 421  * this is a neat, but odd, addition.
 422  */
 423
 424 /*
 425  * c_number: Ignore character p points to, return number appearing after that.
 426  * A '$' by itself means a big number; "$-" is for negative; '^' means 1.
 427  * Return p pointing to last char used.
 428  */
 429
 430 /*
 431  * dval is the number to subtract from for things like $-3
 432  */
 433
 434 static Char *
 435 c_number(Char *p, int *num, int dval)
 436 {
 437     int i;
 438     int sign = 1;
 439
 440     if (*++p == '^') {
 441         *num = 1;
 442         return(p);
 443     }
 444     if (*p == '$') {
 445         if (*++p != '-') {
 446             *num = INT_MAX;     /* Handle $ */
 447             return(--p);
 448         }
 449         sign = -1;              /* Handle $- */
 450         ++p;
 451     }
 452     for (i = 0; *p >= '0' && *p <= '9'; i = 10 * i + *p++ - '0')
 453         continue;
 454     *num = (sign < 0 ? dval - i : i);
 455     return(--p);
 456 }
 457
 458 /*
 459  * excl_expand: There is an excl to be expanded to p -- do the right thing
 460  * with it and return a version of p advanced over the expanded stuff.  Also,
 461  * update tsh_cur and related things as appropriate...
 462  */
 463
 464 static Char *
 465 c_expand(Char *p)
 466 {
 467     Char *q;
 468     struct Hist *h = Histlist.Hnext;
 469     struct wordent *l;
 470     int     i, from, to, dval;
 471     int    all_dig;
 472     int    been_once = 0;
 473     Char   *op = p;
 474     Char   *buf;
 475     size_t buf_len;
 476     Char   *modbuf;
 477
 478     buf = NULL;
 479     if (!h)
 480         goto excl_err;
 481 excl_sw:
 482     switch (*(q = p + 1)) {
 483
 484     case '^':
 485         buf = expand_lex(&h->Hlex, 1, 1);
 486         break;
 487
 488     case '$':
 489         if ((l = (h->Hlex).prev) != 0)
 490             buf = expand_lex(l->prev->prev, 0, 0);
 491         break;
 492
 493     case '*':
 494         buf = expand_lex(&h->Hlex, 1, INT_MAX);
 495         break;
 496
 497     default:
 498         if (been_once) {        /* unknown argument */
 499             /* assume it's a modifier, e.g. !foo:h, and get whole cmd */
 500             buf = expand_lex(&h->Hlex, 0, INT_MAX);
 501             q -= 2;
 502             break;
 503         }
 504         been_once = 1;
 505
 506         if (*q == ':')          /* short form: !:arg */
 507             --q;
 508
 509         if (*q != HIST) {
 510             /*
 511              * Search for a space, tab, or colon.  See if we have a number (as
 512              * in !1234:xyz).  Remember the number.
 513              */
 514             for (i = 0, all_dig = 1;
 515                  *q != ' ' && *q != '\t' && *q != ':' && q < Cursor; q++) {
 516                 /*
 517                  * PWP: !-4 is a valid history argument too, therefore the test
 518                  * is if not a digit, or not a - as the first character.
 519                  */
 520                 if ((*q < '0' || *q > '9') && (*q != '-' || q != p + 1))
 521                     all_dig = 0;
 522                 else if (*q == '-')
 523                     all_dig = 2;/* we are sneeky about this */
 524                 else
 525                     i = 10 * i + *q - '0';
 526             }
 527             --q;
 528
 529             /*
 530              * If we have a number, search for event i.  Otherwise, search for
 531              * a named event (as in !foo).  (In this case, I is the length of
 532              * the named event).
 533              */
 534             if (all_dig) {
 535                 if (all_dig == 2)
 536                     i = -i;     /* make it negitive */
 537                 if (i < 0)      /* if !-4 (for example) */
 538                     i = eventno + 1 + i;        /* remember: i is < 0 */
 539                 for (; h; h = h->Hnext) {
 540                     if (h->Hnum == i)
 541                         break;
 542                 }
 543             }
 544             else {
 545                 for (i = (int) (q - p); h; h = h->Hnext) {
 546                     if ((l = &h->Hlex) != 0) {
 547                         if (!Strncmp(p + 1, l->next->word, (size_t) i))
 548                             break;
 549                     }
 550                 }
 551             }
 552         }
 553         if (!h)
 554             goto excl_err;
 555         if (q[1] == ':' || q[1] == '-' || q[1] == '*' ||
 556             q[1] == '$' || q[1] == '^') {       /* get some args */
 557             p = q[1] == ':' ? ++q : q;
 558             /*
 559              * Go handle !foo:*
 560              */
 561             if ((q[1] < '0' || q[1] > '9') &&
 562                 q[1] != '-' && q[1] != '$' && q[1] != '^')
 563                 goto excl_sw;
 564             /*
 565              * Go handle !foo:$
 566              */
 567             if (q[1] == '$' && (q[2] != '-' || q[3] < '0' || q[3] > '9'))
 568                 goto excl_sw;
 569             /*
 570              * Count up the number of words in this event.  Store it in dval.
 571              * Dval will be fed to number.
 572              */
 573             dval = 0;
 574             if ((l = h->Hlex.prev) != 0) {
 575                 for (l = l->prev; l != h->Hlex.next; l = l->prev, dval++)
 576                     continue;
 577             }
 578             if (!dval)
 579                 goto excl_err;
 580             if (q[1] == '-')
 581                 from = 0;
 582             else
 583                 q = c_number(q, &from, dval);
 584             if (q[1] == '-') {
 585                 ++q;
 586                 if ((q[1] < '0' || q[1] > '9') && q[1] != '$')
 587                     to = dval - 1;
 588                 else
 589                     q = c_number(q, &to, dval);
 590             }
 591             else if (q[1] == '*') {
 592                 ++q;
 593                 to = INT_MAX;
 594             }
 595             else {
 596                 to = from;
 597             }
 598             if (from < 0 || to < from)
 599                 goto excl_err;
 600             buf = expand_lex(&h->Hlex, from, to);
 601         }
 602         else                    /* get whole cmd */
 603             buf = expand_lex(&h->Hlex, 0, INT_MAX);
 604         break;
 605     }
 606     if (buf == NULL)
 607         buf = SAVE("");
 608
 609     /*
 610      * Apply modifiers, if any.
 611      */
 612     if (q[1] == ':') {
 613         modbuf = buf;
 614         while (q[1] == ':' && modbuf != NULL) {
 615             switch (q[2]) {
 616             case 'r':
 617             case 'e':
 618             case 'h':
 619             case 't':
 620             case 'q':
 621             case 'x':
 622             case 'u':
 623             case 'l':
 624                 if ((modbuf = domod(buf, (int) q[2])) != NULL) {
 625                     xfree(buf);
 626                     buf = modbuf;
 627                 }
 628                 ++q;
 629                 break;
 630
 631             case 'a':
 632             case 'g':
 633                 /* Not implemented; this needs to be done before expanding
 634                  * lex. We don't have the words available to us anymore.
 635                  */
 636                 ++q;
 637                 break;
 638
 639             case 'p':
 640                 /* Ok */
 641                 ++q;
 642                 break;
 643
 644             case '\0':
 645                 break;
 646
 647             default:
 648                 ++q;
 649                 break;
 650             }
 651             if (q[1])
 652                 ++q;
 653         }
 654     }
 655
 656     buf_len = Strlen(buf);
 657     /*
 658      * Now replace the text from op to q inclusive with the text from buf.
 659      */
 660     q++;
 661
 662     /*
 663      * Now replace text non-inclusively like a real CS major!
 664      */
 665     if (LastChar + buf_len - (q - op) >= InputLim)
 666         goto excl_err;
 667     (void) memmove(op + buf_len, q, (LastChar - q) * sizeof(Char));
 668     LastChar += buf_len - (q - op);
 669     Cursor += buf_len - (q - op);
 670     (void) memcpy(op, buf, buf_len * sizeof(Char));
 671     *LastChar = '\0';
 672     xfree(buf);
 673     return op + buf_len;
 674 excl_err:
 675     xfree(buf);
 676     SoundBeep();
 677     return(op + 1);
 678 }
 679
 680 /*
 681  * c_excl: An excl has been found at point p -- back up and find some white
 682  * space (or the beginning of the buffer) and properly expand all the excl's
 683  * from there up to the current cursor position. We also avoid (trying to)
 684  * expanding '>!'
 685  * Returns number of expansions attempted (doesn't matter whether they succeeded
 686  * or not).
 687  */
 688
 689 static int
 690 c_excl(Char *p)
 691 {
 692     int i;
 693     Char *q;
 694     int nr_exp;
 695
 696     /*
 697      * if />[SPC TAB]*![SPC TAB]/, back up p to just after the >. otherwise,
 698      * back p up to just before the current word.
 699      */
 700     if ((p[1] == ' ' || p[1] == '\t') &&
 701         (p[-1] == ' ' || p[-1] == '\t' || p[-1] == '>')) {
 702         for (q = p - 1; q > InputBuf && (*q == ' ' || *q == '\t'); --q)
 703             continue;
 704         if (*q == '>')
 705             ++p;
 706     }
 707     else {
 708         while (*p != ' ' && *p != '\t' && p > InputBuf)
 709             --p;
 710     }
 711
 712     /*
 713      * Forever: Look for history char.  (Stop looking when we find the cursor.)
 714      * Count backslashes.  If odd, skip history char.  Expand if even number of
 715      * backslashes.
 716      */
 717     nr_exp = 0;
 718     for (;;) {
 719         while (*p != HIST && p < Cursor)
 720             ++p;
 721         for (i = 1; (p - i) >= InputBuf && p[-i] == '\\'; i++)
 722             continue;
 723         if (i % 2 == 0)
 724             ++p;
 725         if (p >= Cursor)   /* all done */
 726             return nr_exp;
 727         if (i % 2 == 1) {
 728             p = c_expand(p);
 729             ++nr_exp;
 730         }
 731     }
 732
 733     return nr_exp;
 734 }
 735
 736
 737 static int
 738 c_substitute(void)
 739 {
 740     Char *p;
 741     int  nr_exp;
 742
 743     /*
 744      * Start p out one character before the cursor.  Move it backwards looking
 745      * for white space, the beginning of the line, or a history character.
 746      */
 747     for (p = Cursor - 1;
 748          p > InputBuf && *p != ' ' && *p != '\t' && *p != HIST; --p)
 749         continue;
 750
 751     /*
 752      * If we found a history character, go expand it.
 753      */
 754     if (*p == HIST)
 755         nr_exp = c_excl(p);
 756     else
 757         nr_exp = 0;
 758     Refresh();
 759
 760     return nr_exp;
 761 }
 762
 763 static void
 764 c_delfini(void)         /* Finish up delete action */
 765 {
 766     int Size;
 767
 768     if (ActionFlag & TCSHOP_INSERT)
 769         c_alternativ_key_map(0);
 770
 771     ActionFlag = TCSHOP_NOP;
 772
 773     if (ActionPos == 0)
 774         return;
 775
 776     UndoAction = TCSHOP_INSERT;
 777
 778     if (Cursor > ActionPos) {
 779         Size = (int) (Cursor-ActionPos);
 780         c_delbefore(Size);
 781         RefCursor();
 782     }
 783     else if (Cursor < ActionPos) {
 784         Size = (int)(ActionPos-Cursor);
 785         c_delafter(Size);
 786     }
 787     else  {
 788         Size = 1;
 789         c_delafter(Size);
 790     }
 791     UndoPtr = Cursor;
 792     UndoSize = Size;
 793 }
 794
 795 static Char *
 796 c_endword(Char *p, Char *high, int n, Char *delim)
 797 {
 798     Char inquote = 0;
 799     p++;
 800
 801     while (n--) {
 802         while (p < high) {      /* Skip non-word chars */
 803           if (!Strchr(delim, *p) || *(p-1) == (Char)'\\')
 804             break;
 805           p++;
 806         }
 807         while (p < high) {      /* Skip string */
 808           if ((*p == (Char)'\'' || *p == (Char)'"')) { /* Quotation marks? */
 809             if (inquote || *(p-1) != (Char)'\\') { /* Should it be honored? */
 810               if (inquote == 0) inquote = *p;
 811               else if (inquote == *p) inquote = 0;
 812             }
 813           }
 814           /* Break if unquoted non-word char */
 815           if (!inquote && Strchr(delim, *p) && *(p-1) != (Char)'\\')
 816             break;
 817           p++;
 818         }
 819     }
 820
 821     p--;
 822     return(p);
 823 }
 824
 825
 826 static Char *
 827 c_eword(Char *p, Char *high, int n)
 828 {
 829     p++;
 830
 831     while (n--) {
 832         while ((p < high) && Isspace(*p))
 833             p++;
 834
 835         if (Isalnum(*p))
 836             while ((p < high) && Isalnum(*p))
 837                 p++;
 838         else
 839             while ((p < high) && !(Isspace(*p) || Isalnum(*p)))
 840                 p++;
 841     }
 842
 843     p--;
 844     return(p);
 845 }
 846
 847 /* Set the max length of the kill ring */
 848 void
 849 SetKillRing(int max)
 850 {
 851     CStr *new;
 852     int count, i, j;
 853
 854     if (max < 1)
 855         max = 1;                /* no ring, but always one buffer */
 856     if (max == KillRingMax)
 857         return;
 858     new = xcalloc(max, sizeof(CStr));
 859     if (KillRing != NULL) {
 860         if (KillRingLen != 0) {
 861             if (max >= KillRingLen) {
 862                 count = KillRingLen;
 863                 j = KillPos;
 864             } else {
 865                 count = max;
 866                 j = (KillPos - count + KillRingLen) % KillRingLen;
 867             }
 868             for (i = 0; i < KillRingLen; i++) {
 869                 if (i < count)  /* copy latest */
 870                     new[i] = KillRing[j];
 871                 else            /* free the others */
 872                     xfree(KillRing[j].buf);
 873                 j = (j + 1) % KillRingLen;
 874             }
 875             KillRingLen = count;
 876             KillPos = count % max;
 877             YankPos = count - 1;
 878         }
 879         xfree(KillRing);
 880     }
 881     KillRing = new;
 882     KillRingMax = max;
 883 }
 884
 885 /* Push string from start upto (but not including) end onto kill ring */
 886 static void
 887 c_push_kill(Char *start, Char *end)
 888 {
 889     CStr save, *pos;
 890     Char *dp, *cp, *kp;
 891     int len = end - start, i, j, k;
 892
 893     /* Check for duplicates? */
 894     if (KillRingLen > 0 && (dp = varval(STRkilldup)) != STRNULL) {
 895         YankPos = (KillPos - 1 + KillRingLen) % KillRingLen;
 896         if (eq(dp, STRerase)) { /* erase earlier one (actually move up) */
 897             j = YankPos;
 898             for (i = 0; i < KillRingLen; i++) {
 899                 if (Strncmp(KillRing[j].buf, start, (size_t) len) == 0 &&
 900                     KillRing[j].buf[len] == '\0') {
 901                     save = KillRing[j];
 902                     for ( ; i > 0; i--) {
 903                         k = j;
 904                         j = (j + 1) % KillRingLen;
 905                         KillRing[k] = KillRing[j];
 906                     }
 907                     KillRing[j] = save;
 908                     return;
 909                 }
 910                 j = (j - 1 + KillRingLen) % KillRingLen;
 911             }
 912         } else if (eq(dp, STRall)) { /* skip if any earlier */
 913             for (i = 0; i < KillRingLen; i++)
 914                 if (Strncmp(KillRing[i].buf, start, (size_t) len) == 0 &&
 915                     KillRing[i].buf[len] == '\0')
 916                     return;
 917         } else if (eq(dp, STRprev)) { /* skip if immediately previous */
 918             j = YankPos;
 919             if (Strncmp(KillRing[j].buf, start, (size_t) len) == 0 &&
 920                 KillRing[j].buf[len] == '\0')
 921                 return;
 922         }
 923     }
 924
 925     /* No duplicate, go ahead and push */
 926     len++;                      /* need space for '\0' */
 927     YankPos = KillPos;
 928     if (KillRingLen < KillRingMax)
 929         KillRingLen++;
 930     pos = &KillRing[KillPos];
 931     KillPos = (KillPos + 1) % KillRingMax;
 932     if (pos->len < len) {
 933         pos->buf = xrealloc(pos->buf, len * sizeof(Char));
 934         pos->len = len;
 935     }
 936     cp = start;
 937     kp = pos->buf;
 938     while (cp < end)
 939         *kp++ = *cp++;
 940     *kp = '\0';
 941 }
 942
 943 /* Save InputBuf etc in SavedBuf etc for restore after cmd exec */
 944 static void
 945 c_save_inputbuf()
 946 {
 947     SavedBuf.len = 0;
 948     Strbuf_append(&SavedBuf, InputBuf);
 949     Strbuf_terminate(&SavedBuf);
 950     LastSaved = LastChar - InputBuf;
 951     CursSaved = Cursor - InputBuf;
 952     HistSaved = Hist_num;
 953     RestoreSaved = 1;
 954 }
 955
 956 CCRETVAL
 957 GetHistLine()
 958 {
 959     struct Hist *hp;
 960     int     h;
 961
 962     if (Hist_num == 0) {        /* if really the current line */
 963         if (HistBuf.s != NULL)
 964             copyn(InputBuf, HistBuf.s, INBUFSIZE);/*FIXBUF*/
 965         else
 966             *InputBuf = '\0';
 967         LastChar = InputBuf + HistBuf.len;
 968
 969 #ifdef KSHVI
 970     if (VImode)
 971         Cursor = InputBuf;
 972     else
 973 #endif /* KSHVI */
 974         Cursor = LastChar;
 975
 976         return(CC_REFRESH);
 977     }
 978
 979     hp = Histlist.Hnext;
 980     if (hp == NULL)
 981         return(CC_ERROR);
 982
 983     for (h = 1; h < Hist_num; h++) {
 984         if ((hp->Hnext) == NULL) {
 985             Hist_num = h;
 986             return(CC_ERROR);
 987         }
 988         hp = hp->Hnext;
 989     }
 990
 991     if (HistLit && hp->histline) {
 992         copyn(InputBuf, hp->histline, INBUFSIZE);/*FIXBUF*/
 993         CurrentHistLit = 1;
 994     }
 995     else {
 996         Char *p;
 997
 998         p = sprlex(&hp->Hlex);
 999         copyn(InputBuf, p, sizeof(InputBuf) / sizeof(Char));/*FIXBUF*/
1000         xfree(p);
1001         CurrentHistLit = 0;
1002     }
1003     LastChar = Strend(InputBuf);
1004
1005     if (LastChar > InputBuf) {
1006         if (LastChar[-1] == '\n')
1007             LastChar--;
1008 #if 0
1009         if (LastChar[-1] == ' ')
1010             LastChar--;
1011 #endif
1012         if (LastChar < InputBuf)
1013             LastChar = InputBuf;
1014     }
1015
1016 #ifdef KSHVI
1017     if (VImode)
1018         Cursor = InputBuf;
1019     else
1020 #endif /* KSHVI */
1021         Cursor = LastChar;
1022
1023     return(CC_REFRESH);
1024 }
1025
1026 static CCRETVAL
1027 c_search_line(Char *pattern, int dir)
1028 {
1029     Char *cp;
1030     size_t len;
1031
1032     len = Strlen(pattern);
1033
1034     if (dir == F_UP_SEARCH_HIST) {
1035         for (cp = Cursor; cp >= InputBuf; cp--)
1036             if (Strncmp(cp, pattern, len) == 0 ||
1037                 Gmatch(cp, pattern)) {
1038                 Cursor = cp;
1039                 return(CC_NORM);
1040             }
1041         return(CC_ERROR);
1042     } else {
1043         for (cp = Cursor; *cp != '\0' && cp < InputLim; cp++)
1044             if (Strncmp(cp, pattern, len) == 0 ||
1045                 Gmatch(cp, pattern)) {
1046                 Cursor = cp;
1047                 return(CC_NORM);
1048             }
1049         return(CC_ERROR);
1050     }
1051 }
1052
1053 static CCRETVAL
1054 e_inc_search(int dir)
1055 {
1056     static const Char STRfwd[] = { 'f', 'w', 'd', '\0' },
1057                       STRbck[] = { 'b', 'c', 'k', '\0' };
1058     static Char pchar = ':';    /* ':' = normal, '?' = failed */
1059     static Char endcmd[2];
1060     const Char *cp;
1061     Char ch,
1062         *oldCursor = Cursor,
1063         oldpchar = pchar;
1064     CCRETVAL ret = CC_NORM;
1065     int oldHist_num = Hist_num,
1066         oldpatlen = patbuf.len,
1067         newdir = dir,
1068         done, redo;
1069
1070     if (LastChar + sizeof(STRfwd)/sizeof(Char) + 2 + patbuf.len >= InputLim)
1071         return(CC_ERROR);
1072
1073     for (;;) {
1074
1075         if (patbuf.len == 0) {  /* first round */
1076             pchar = ':';
1077             Strbuf_append1(&patbuf, '*');
1078         }
1079         done = redo = 0;
1080         *LastChar++ = '\n';
1081         for (cp = newdir == F_UP_SEARCH_HIST ? STRbck : STRfwd;
1082              *cp; *LastChar++ = *cp++)
1083             continue;
1084         *LastChar++ = pchar;
1085         for (cp = &patbuf.s[1]; cp < &patbuf.s[patbuf.len];
1086              *LastChar++ = *cp++)
1087             continue;
1088         *LastChar = '\0';
1089         if (adrof(STRhighlight) && pchar == ':') {
1090             /* if the no-glob-search patch is applied, remove the - 1 below */
1091             IncMatchLen = patbuf.len - 1;
1092             ClearLines();
1093             ClearDisp();
1094         }
1095         Refresh();
1096
1097         if (GetNextChar(&ch) != 1)
1098             return(e_send_eof(0));
1099
1100         switch (ch > NT_NUM_KEYS
1101                 ? F_INSERT : CurrentKeyMap[(unsigned char) ch]) {
1102         case F_INSERT:
1103         case F_DIGIT:
1104         case F_MAGIC_SPACE:
1105             if (LastChar + 1 >= InputLim) /*FIXBUF*/
1106                 SoundBeep();
1107             else {
1108                 Strbuf_append1(&patbuf, ch);
1109                 *LastChar++ = ch;
1110                 *LastChar = '\0';
1111                 Refresh();
1112             }
1113             break;
1114
1115         case F_INC_FWD:
1116             newdir = F_DOWN_SEARCH_HIST;
1117             redo++;
1118             break;
1119
1120         case F_INC_BACK:
1121             newdir = F_UP_SEARCH_HIST;
1122             redo++;
1123             break;
1124
1125         case F_DELPREV:
1126             if (patbuf.len > 1)
1127                 done++;
1128             else
1129                 SoundBeep();
1130             break;
1131
1132         default:
1133             switch (ASC(ch)) {
1134             case 0007:          /* ^G: Abort */
1135                 ret = CC_ERROR;
1136                 done++;
1137                 break;
1138
1139             case 0027:          /* ^W: Append word */
1140                 /* No can do if globbing characters in pattern */
1141                 for (cp = &patbuf.s[1]; ; cp++)
1142                     if (cp >= &patbuf.s[patbuf.len]) {
1143                         Cursor += patbuf.len - 1;
1144                         cp = c_next_word(Cursor, LastChar, 1);
1145                         while (Cursor < cp && *Cursor != '\n') {
1146                             if (LastChar + 1 >= InputLim) {/*FIXBUF*/
1147                                 SoundBeep();
1148                                 break;
1149                             }
1150                             Strbuf_append1(&patbuf, *Cursor);
1151                             *LastChar++ = *Cursor++;
1152                         }
1153                         Cursor = oldCursor;
1154                         *LastChar = '\0';
1155                         Refresh();
1156                         break;
1157                     } else if (isglob(*cp)) {
1158                         SoundBeep();
1159                         break;
1160                     }
1161                 break;
1162
1163             default:            /* Terminate and execute cmd */
1164                 endcmd[0] = ch;
1165                 PushMacro(endcmd);
1166                 /*FALLTHROUGH*/
1167
1168             case 0033:          /* ESC: Terminate */
1169                 ret = CC_REFRESH;
1170                 done++;
1171                 break;
1172             }
1173             break;
1174         }
1175
1176         while (LastChar > InputBuf && *LastChar != '\n')
1177             *LastChar-- = '\0';
1178         *LastChar = '\0';
1179
1180         if (!done) {
1181
1182             /* Can't search if unmatched '[' */
1183             for (cp = &patbuf.s[patbuf.len - 1], ch = ']'; cp > patbuf.s; cp--)
1184                 if (*cp == '[' || *cp == ']') {
1185                     ch = *cp;
1186                     break;
1187                 }
1188
1189             if (patbuf.len > 1 && ch != '[') {
1190                 if (redo && newdir == dir) {
1191                     if (pchar == '?') { /* wrap around */
1192                         Hist_num = newdir == F_UP_SEARCH_HIST ? 0 : INT_MAX;
1193                         if (GetHistLine() == CC_ERROR)
1194                             /* Hist_num was fixed by first call */
1195                             (void) GetHistLine();
1196                         Cursor = newdir == F_UP_SEARCH_HIST ?
1197                             LastChar : InputBuf;
1198                     } else
1199                         Cursor += newdir == F_UP_SEARCH_HIST ? -1 : 1;
1200                 }
1201                 Strbuf_append1(&patbuf, '*');
1202                 Strbuf_terminate(&patbuf);
1203                 if (Cursor < InputBuf || Cursor > LastChar ||
1204                     (ret = c_search_line(&patbuf.s[1], newdir)) == CC_ERROR) {
1205                     LastCmd = (KEYCMD) newdir; /* avoid c_hsetpat */
1206                     ret = newdir == F_UP_SEARCH_HIST ?
1207                         e_up_search_hist(0) : e_down_search_hist(0);
1208                     if (ret != CC_ERROR) {
1209                         Cursor = newdir == F_UP_SEARCH_HIST ?
1210                             LastChar : InputBuf;
1211                         (void) c_search_line(&patbuf.s[1], newdir);
1212                     }
1213                 }
1214                 patbuf.s[--patbuf.len] = '\0';
1215                 if (ret == CC_ERROR) {
1216                     SoundBeep();
1217                     if (Hist_num != oldHist_num) {
1218                         Hist_num = oldHist_num;
1219                         if (GetHistLine() == CC_ERROR)
1220                             return(CC_ERROR);
1221                     }
1222                     Cursor = oldCursor;
1223                     pchar = '?';
1224                 } else {
1225                     pchar = ':';
1226                 }
1227             }
1228
1229             ret = e_inc_search(newdir);
1230
1231             if (ret == CC_ERROR && pchar == '?' && oldpchar == ':') {
1232                 /* break abort of failed search at last non-failed */
1233                 ret = CC_NORM;
1234             }
1235
1236         }
1237
1238         if (ret == CC_NORM || (ret == CC_ERROR && oldpatlen == 0)) {
1239             /* restore on normal return or error exit */
1240             pchar = oldpchar;
1241             patbuf.len = oldpatlen;
1242             if (Hist_num != oldHist_num) {
1243                 Hist_num = oldHist_num;
1244                 if (GetHistLine() == CC_ERROR)
1245                     return(CC_ERROR);
1246             }
1247             Cursor = oldCursor;
1248             if (ret == CC_ERROR)
1249                 Refresh();
1250         }
1251         if (done || ret != CC_NORM)
1252             return(ret);
1253
1254     }
1255
1256 }
1257
1258 static CCRETVAL
1259 v_search(int dir)
1260 {
1261     struct Strbuf tmpbuf = Strbuf_INIT;
1262     Char ch;
1263     Char *oldbuf;
1264     Char *oldlc, *oldc;
1265
1266     cleanup_push(&tmpbuf, Strbuf_cleanup);
1267     oldbuf = Strsave(InputBuf);
1268     cleanup_push(oldbuf, xfree);
1269     oldlc = LastChar;
1270     oldc = Cursor;
1271     Strbuf_append1(&tmpbuf, '*');
1272
1273     InputBuf[0] = '\0';
1274     LastChar = InputBuf;
1275     Cursor = InputBuf;
1276     searchdir = dir;
1277
1278     c_insert(2);        /* prompt + '\n' */
1279     *Cursor++ = '\n';
1280     *Cursor++ = dir == F_UP_SEARCH_HIST ? '?' : '/';
1281     Refresh();
1282     for (ch = 0;ch == 0;) {
1283         if (GetNextChar(&ch) != 1) {
1284             cleanup_until(&tmpbuf);
1285             return(e_send_eof(0));
1286         }
1287         switch (ASC(ch)) {
1288         case 0010:      /* Delete and backspace */
1289         case 0177:
1290             if (tmpbuf.len > 1) {
1291                 *Cursor-- = '\0';
1292                 LastChar = Cursor;
1293                 tmpbuf.len--;
1294             }
1295             else {
1296                 copyn(InputBuf, oldbuf, INBUFSIZE);/*FIXBUF*/
1297                 LastChar = oldlc;
1298                 Cursor = oldc;
1299                 cleanup_until(&tmpbuf);
1300                 return(CC_REFRESH);
1301             }
1302             Refresh();
1303             ch = 0;
1304             break;
1305
1306         case 0033:      /* ESC */
1307 #ifdef IS_ASCII
1308         case '\r':      /* Newline */
1309         case '\n':
1310 #else
1311         case '\012':    /* ASCII Line feed */
1312         case '\015':    /* ASCII (or EBCDIC) Return */
1313 #endif
1314             break;
1315
1316         default:
1317             Strbuf_append1(&tmpbuf, ch);
1318             *Cursor++ = ch;
1319             LastChar = Cursor;
1320             Refresh();
1321             ch = 0;
1322             break;
1323         }
1324     }
1325     cleanup_until(oldbuf);
1326
1327     if (tmpbuf.len == 1) {
1328         /*
1329          * Use the old pattern, but wild-card it.
1330          */
1331         if (patbuf.len == 0) {
1332             InputBuf[0] = '\0';
1333             LastChar = InputBuf;
1334             Cursor = InputBuf;
1335             Refresh();
1336             cleanup_until(&tmpbuf);
1337             return(CC_ERROR);
1338         }
1339         if (patbuf.s[0] != '*') {
1340             oldbuf = Strsave(patbuf.s);
1341             patbuf.len = 0;
1342             Strbuf_append1(&patbuf, '*');
1343             Strbuf_append(&patbuf, oldbuf);
1344             xfree(oldbuf);
1345             Strbuf_append1(&patbuf, '*');
1346             Strbuf_terminate(&patbuf);
1347         }
1348     }
1349     else {
1350         Strbuf_append1(&tmpbuf, '*');
1351         Strbuf_terminate(&tmpbuf);
1352         patbuf.len = 0;
1353         Strbuf_append(&patbuf, tmpbuf.s);
1354         Strbuf_terminate(&patbuf);
1355     }
1356     cleanup_until(&tmpbuf);
1357     LastCmd = (KEYCMD) dir; /* avoid c_hsetpat */
1358     Cursor = LastChar = InputBuf;
1359     if ((dir == F_UP_SEARCH_HIST ? e_up_search_hist(0) :
1360                                    e_down_search_hist(0)) == CC_ERROR) {
1361         Refresh();
1362         return(CC_ERROR);
1363     }
1364     else {
1365         if (ASC(ch) == 0033) {
1366             Refresh();
1367             *LastChar++ = '\n';
1368             *LastChar = '\0';
1369             PastBottom();
1370             return(CC_NEWLINE);
1371         }
1372         else
1373             return(CC_REFRESH);
1374     }
1375 }
1376
1377 /*
1378  * semi-PUBLIC routines.  Any routine that is of type CCRETVAL is an
1379  * entry point, called from the CcKeyMap indirected into the
1380  * CcFuncTbl array.
1381  */
1382
1383 /*ARGSUSED*/
1384 CCRETVAL
1385 v_cmd_mode(Char c)
1386 {
1387     USE(c);
1388     InsertPos = 0;
1389     ActionFlag = TCSHOP_NOP;    /* [Esc] cancels pending action */
1390     ActionPos = 0;
1391     DoingArg = 0;
1392     if (UndoPtr > Cursor)
1393         UndoSize = (int)(UndoPtr - Cursor);
1394     else
1395         UndoSize = (int)(Cursor - UndoPtr);
1396
1397     inputmode = MODE_INSERT;
1398     c_alternativ_key_map(1);
1399 #ifdef notdef
1400     /*
1401      * We don't want to move the cursor, because all the editing
1402      * commands don't include the character under the cursor.
1403      */
1404     if (Cursor > InputBuf)
1405         Cursor--;
1406 #endif
1407     RefCursor();
1408     return(CC_NORM);
1409 }
1410
1411 /*ARGSUSED*/
1412 CCRETVAL
1413 e_unassigned(Char c)
1414 {                               /* bound to keys that arn't really assigned */
1415     USE(c);
1416     SoundBeep();
1417     flush();
1418     return(CC_NORM);
1419 }
1420
1421 #ifdef notyet
1422 static CCRETVAL
1423 e_insert_str(Char *c)
1424 {
1425     int i, n;
1426
1427     n = Strlen(c);
1428     if (LastChar + Argument * n >= InputLim)
1429         return(CC_ERROR);       /* end of buffer space */
1430     if (inputmode != MODE_INSERT) {
1431         c_delafter(Argument * Strlen(c));
1432     }
1433     c_insert(Argument * n);
1434     while (Argument--) {
1435         for (i = 0; i < n; i++)
1436             *Cursor++ = c[i];
1437     }
1438     Refresh();
1439     return(CC_NORM);
1440 }
1441 #endif
1442
1443 CCRETVAL
1444 e_insert(Char c)
1445 {
1446 #ifndef SHORT_STRINGS
1447     c &= ASCII;                 /* no meta chars ever */
1448 #endif
1449
1450     if (!c)
1451         return(CC_ERROR);       /* no NULs in the input ever!! */
1452
1453     if (LastChar + Argument >= InputLim)
1454         return(CC_ERROR);       /* end of buffer space */
1455
1456     if (Argument == 1) {        /* How was this optimized ???? */
1457
1458         if (inputmode != MODE_INSERT) {
1459             UndoBuf[UndoSize++] = *Cursor;
1460             UndoBuf[UndoSize] = '\0';
1461             c_delafter(1);   /* Do NOT use the saving ONE */
1462         }
1463
1464         c_insert(1);
1465         *Cursor++ = (Char) c;
1466         DoingArg = 0;           /* just in case */
1467         RefPlusOne(1);          /* fast refresh for one char. */
1468     }
1469     else {
1470         if (inputmode != MODE_INSERT) {
1471             int i;
1472             for(i = 0; i < Argument; i++)
1473                 UndoBuf[UndoSize++] = *(Cursor + i);
1474
1475             UndoBuf[UndoSize] = '\0';
1476             c_delafter(Argument);   /* Do NOT use the saving ONE */
1477         }
1478
1479         c_insert(Argument);
1480
1481         while (Argument--)
1482             *Cursor++ = (Char) c;
1483         Refresh();
1484     }
1485
1486     if (inputmode == MODE_REPLACE_1)
1487         (void) v_cmd_mode(0);
1488
1489     return(CC_NORM);
1490 }
1491
1492 int
1493 InsertStr(Char *s)              /* insert ASCIZ s at cursor (for complete) */
1494 {
1495     int len;
1496
1497     if ((len = (int) Strlen(s)) <= 0)
1498         return -1;
1499     if (LastChar + len >= InputLim)
1500         return -1;              /* end of buffer space */
1501
1502     c_insert(len);
1503     while (len--)
1504         *Cursor++ = *s++;
1505     return 0;
1506 }
1507
1508 void
1509 DeleteBack(int n)               /* delete the n characters before . */
1510 {
1511     if (n <= 0)
1512         return;
1513     if (Cursor >= &InputBuf[n]) {
1514         c_delbefore(n);         /* delete before dot */
1515     }
1516 }
1517
1518 CCRETVAL
1519 e_digit(Char c)                 /* gray magic here */
1520 {
1521     if (!Isdigit(c))
1522         return(CC_ERROR);       /* no NULs in the input ever!! */
1523
1524     if (DoingArg) {             /* if doing an arg, add this in... */
1525         if (LastCmd == F_ARGFOUR)       /* if last command was ^U */
1526             Argument = c - '0';
1527         else {
1528             if (Argument > 1000000)
1529                 return CC_ERROR;
1530             Argument = (Argument * 10) + (c - '0');
1531         }
1532         return(CC_ARGHACK);
1533     }
1534     else {
1535         if (LastChar + 1 >= InputLim)
1536             return CC_ERROR;    /* end of buffer space */
1537
1538         if (inputmode != MODE_INSERT) {
1539             UndoBuf[UndoSize++] = *Cursor;
1540             UndoBuf[UndoSize] = '\0';
1541             c_delafter(1);   /* Do NOT use the saving ONE */
1542         }
1543         c_insert(1);
1544         *Cursor++ = (Char) c;
1545         DoingArg = 0;           /* just in case */
1546         RefPlusOne(1);          /* fast refresh for one char. */
1547     }
1548     return(CC_NORM);
1549 }
1550
1551 CCRETVAL
1552 e_argdigit(Char c)              /* for ESC-n */
1553 {
1554 #ifdef IS_ASCII
1555     c &= ASCII;
1556 #else
1557     c = CTL_ESC(ASC(c) & ASCII); /* stripping for EBCDIC done the ASCII way */
1558 #endif
1559
1560     if (!Isdigit(c))
1561         return(CC_ERROR);       /* no NULs in the input ever!! */
1562
1563     if (DoingArg) {             /* if doing an arg, add this in... */
1564         if (Argument > 1000000)
1565             return CC_ERROR;
1566         Argument = (Argument * 10) + (c - '0');
1567     }
1568     else {                      /* else starting an argument */
1569         Argument = c - '0';
1570         DoingArg = 1;
1571     }
1572     return(CC_ARGHACK);
1573 }
1574
1575 CCRETVAL
1576 v_zero(Char c)                  /* command mode 0 for vi */
1577 {
1578     if (DoingArg) {             /* if doing an arg, add this in... */
1579         if (Argument > 1000000)
1580             return CC_ERROR;
1581         Argument = (Argument * 10) + (c - '0');
1582         return(CC_ARGHACK);
1583     }
1584     else {                      /* else starting an argument */
1585         Cursor = InputBuf;
1586         if (ActionFlag & TCSHOP_DELETE) {
1587            c_delfini();
1588            return(CC_REFRESH);
1589         }
1590         RefCursor();            /* move the cursor */
1591         return(CC_NORM);
1592     }
1593 }
1594
1595 /*ARGSUSED*/
1596 CCRETVAL
1597 e_newline(Char c)
1598 {                               /* always ignore argument */
1599     USE(c);
1600     if (adrof(STRhighlight) && MarkIsSet) {
1601         MarkIsSet = 0;
1602         ClearLines();
1603         ClearDisp();
1604         Refresh();
1605     }
1606     MarkIsSet = 0;
1607
1608   /*  PastBottom();  NOW done in ed.inputl.c */
1609     *LastChar++ = '\n';         /* for the benefit of CSH */
1610     *LastChar = '\0';           /* just in case */
1611     if (VImode)
1612         InsertPos = InputBuf;   /* Reset editing position */
1613     return(CC_NEWLINE);
1614 }
1615
1616 /*ARGSUSED*/
1617 CCRETVAL
1618 e_newline_hold(Char c)
1619 {
1620     USE(c);
1621     c_save_inputbuf();
1622     HistSaved = 0;
1623     *LastChar++ = '\n';         /* for the benefit of CSH */
1624     *LastChar = '\0';           /* just in case */
1625     return(CC_NEWLINE);
1626 }
1627
1628 /*ARGSUSED*/
1629 CCRETVAL
1630 e_newline_down_hist(Char c)
1631 {
1632     USE(c);
1633     if (Hist_num > 1) {
1634         HistSaved = Hist_num;
1635     }
1636     *LastChar++ = '\n';         /* for the benefit of CSH */
1637     *LastChar = '\0';           /* just in case */
1638     return(CC_NEWLINE);
1639 }
1640
1641 /*ARGSUSED*/
1642 CCRETVAL
1643 e_send_eof(Char c)
1644 {                               /* for when ^D is ONLY send-eof */
1645     USE(c);
1646     PastBottom();
1647     *LastChar = '\0';           /* just in case */
1648     return(CC_EOF);
1649 }
1650
1651 /*ARGSUSED*/
1652 CCRETVAL
1653 e_complete(Char c)
1654 {
1655     USE(c);
1656     *LastChar = '\0';           /* just in case */
1657     return(CC_COMPLETE);
1658 }
1659
1660 /*ARGSUSED*/
1661 CCRETVAL
1662 e_complete_back(Char c)
1663 {
1664     USE(c);
1665     *LastChar = '\0';           /* just in case */
1666     return(CC_COMPLETE_BACK);
1667 }
1668
1669 /*ARGSUSED*/
1670 CCRETVAL
1671 e_complete_fwd(Char c)
1672 {
1673     USE(c);
1674     *LastChar = '\0';           /* just in case */
1675     return(CC_COMPLETE_FWD);
1676 }
1677
1678 /*ARGSUSED*/
1679 CCRETVAL
1680 e_complete_all(Char c)
1681 {
1682     USE(c);
1683     *LastChar = '\0';           /* just in case */
1684     return(CC_COMPLETE_ALL);
1685 }
1686
1687 /*ARGSUSED*/
1688 CCRETVAL
1689 v_cm_complete(Char c)
1690 {
1691     USE(c);
1692     if (Cursor < LastChar)
1693         Cursor++;
1694     *LastChar = '\0';           /* just in case */
1695     return(CC_COMPLETE);
1696 }
1697
1698 /*ARGSUSED*/
1699 CCRETVAL
1700 e_toggle_hist(Char c)
1701 {
1702     struct Hist *hp;
1703     int     h;
1704
1705     USE(c);
1706     *LastChar = '\0';           /* just in case */
1707
1708     if (Hist_num <= 0) {
1709         return CC_ERROR;
1710     }
1711
1712     hp = Histlist.Hnext;
1713     if (hp == NULL) {   /* this is only if no history */
1714         return(CC_ERROR);
1715     }
1716
1717     for (h = 1; h < Hist_num; h++)
1718         hp = hp->Hnext;
1719
1720     if (!CurrentHistLit) {
1721         if (hp->histline) {
1722             copyn(InputBuf, hp->histline, INBUFSIZE);/*FIXBUF*/
1723             CurrentHistLit = 1;
1724         }
1725         else {
1726             return CC_ERROR;
1727         }
1728     }
1729     else {
1730         Char *p;
1731
1732         p = sprlex(&hp->Hlex);
1733         copyn(InputBuf, p, sizeof(InputBuf) / sizeof(Char));/*FIXBUF*/
1734         xfree(p);
1735         CurrentHistLit = 0;
1736     }
1737
1738     LastChar = Strend(InputBuf);
1739     if (LastChar > InputBuf) {
1740         if (LastChar[-1] == '\n')
1741             LastChar--;
1742         if (LastChar[-1] == ' ')
1743             LastChar--;
1744         if (LastChar < InputBuf)
1745             LastChar = InputBuf;
1746     }
1747
1748 #ifdef KSHVI
1749     if (VImode)
1750         Cursor = InputBuf;
1751     else
1752 #endif /* KSHVI */
1753         Cursor = LastChar;
1754
1755     return(CC_REFRESH);
1756 }
1757
1758 /*ARGSUSED*/
1759 CCRETVAL
1760 e_up_hist(Char c)
1761 {
1762     Char    beep = 0;
1763
1764     USE(c);
1765     UndoAction = TCSHOP_NOP;
1766     *LastChar = '\0';           /* just in case */
1767
1768     if (Hist_num == 0) {        /* save the current buffer away */
1769         HistBuf.len = 0;
1770         Strbuf_append(&HistBuf, InputBuf);
1771         Strbuf_terminate(&HistBuf);
1772     }
1773
1774     Hist_num += Argument;
1775
1776     if (GetHistLine() == CC_ERROR) {
1777         beep = 1;
1778         (void) GetHistLine(); /* Hist_num was fixed by first call */
1779     }
1780
1781     Refresh();
1782     if (beep)
1783         return(CC_ERROR);
1784     else
1785         return(CC_NORM);        /* was CC_UP_HIST */
1786 }
1787
1788 /*ARGSUSED*/
1789 CCRETVAL
1790 e_down_hist(Char c)
1791 {
1792     USE(c);
1793     UndoAction = TCSHOP_NOP;
1794     *LastChar = '\0';           /* just in case */
1795
1796     Hist_num -= Argument;
1797
1798     if (Hist_num < 0) {
1799         Hist_num = 0;
1800         return(CC_ERROR);       /* make it beep */
1801     }
1802
1803     return(GetHistLine());
1804 }
1805
1806
1807
1808 /*
1809  * c_hmatch() return True if the pattern matches the prefix
1810  */
1811 static int
1812 c_hmatch(Char *str)
1813 {
1814     if (Strncmp(patbuf.s, str, patbuf.len) == 0)
1815         return 1;
1816     return Gmatch(str, patbuf.s);
1817 }
1818
1819 /*
1820  * c_hsetpat(): Set the history seatch pattern
1821  */
1822 static void
1823 c_hsetpat(void)
1824 {
1825     if (LastCmd != F_UP_SEARCH_HIST && LastCmd != F_DOWN_SEARCH_HIST) {
1826         patbuf.len = 0;
1827         Strbuf_appendn(&patbuf, InputBuf, Cursor - InputBuf);
1828         Strbuf_terminate(&patbuf);
1829     }
1830 #ifdef SDEBUG
1831     xprintf("\nHist_num = %d\n", Hist_num);
1832     xprintf("patlen = %d\n", (int)patbuf.len);
1833     xprintf("patbuf = \"%S\"\n", patbuf.s);
1834     xprintf("Cursor %d LastChar %d\n", Cursor - InputBuf, LastChar - InputBuf);
1835 #endif
1836 }
1837
1838 /*ARGSUSED*/
1839 CCRETVAL
1840 e_up_search_hist(Char c)
1841 {
1842     struct Hist *hp;
1843     int h;
1844     int    found = 0;
1845
1846     USE(c);
1847     ActionFlag = TCSHOP_NOP;
1848     UndoAction = TCSHOP_NOP;
1849     *LastChar = '\0';           /* just in case */
1850     if (Hist_num < 0) {
1851 #ifdef DEBUG_EDIT
1852         xprintf("%s: e_up_search_hist(): Hist_num < 0; resetting.\n", progname);
1853 #endif
1854         Hist_num = 0;
1855         return(CC_ERROR);
1856     }
1857
1858     if (Hist_num == 0) {
1859         HistBuf.len = 0;
1860         Strbuf_append(&HistBuf, InputBuf);
1861         Strbuf_terminate(&HistBuf);
1862     }
1863
1864
1865     hp = Histlist.Hnext;
1866     if (hp == NULL)
1867         return(CC_ERROR);
1868
1869     c_hsetpat();                /* Set search pattern !! */
1870
1871     for (h = 1; h <= Hist_num; h++)
1872         hp = hp->Hnext;
1873
1874     while (hp != NULL) {
1875         Char *hl;
1876         int matched;
1877
1878         if (hp->histline == NULL)
1879             hp->histline = sprlex(&hp->Hlex);
1880         if (HistLit)
1881             hl = hp->histline;
1882         else {
1883             hl = sprlex(&hp->Hlex);
1884             cleanup_push(hl, xfree);
1885         }
1886 #ifdef SDEBUG
1887         xprintf("Comparing with \"%S\"\n", hl);
1888 #endif
1889         matched = (Strncmp(hl, InputBuf, (size_t) (LastChar - InputBuf)) ||
1890                    hl[LastChar-InputBuf]) && c_hmatch(hl);
1891         if (!HistLit)
1892             cleanup_until(hl);
1893         if (matched) {
1894             found++;
1895             break;
1896         }
1897         h++;
1898         hp = hp->Hnext;
1899     }
1900
1901     if (!found) {
1902 #ifdef SDEBUG
1903         xprintf("not found\n");
1904 #endif
1905         return(CC_ERROR);
1906     }
1907
1908     Hist_num = h;
1909
1910     return(GetHistLine());
1911 }
1912
1913 /*ARGSUSED*/
1914 CCRETVAL
1915 e_down_search_hist(Char c)
1916 {
1917     struct Hist *hp;
1918     int h;
1919     int    found = 0;
1920
1921     USE(c);
1922     ActionFlag = TCSHOP_NOP;
1923     UndoAction = TCSHOP_NOP;
1924     *LastChar = '\0';           /* just in case */
1925
1926     if (Hist_num == 0)
1927         return(CC_ERROR);
1928
1929     hp = Histlist.Hnext;
1930     if (hp == 0)
1931         return(CC_ERROR);
1932
1933     c_hsetpat();                /* Set search pattern !! */
1934
1935     for (h = 1; h < Hist_num && hp; h++) {
1936         Char *hl;
1937         if (hp->histline == NULL)
1938             hp->histline = sprlex(&hp->Hlex);
1939         if (HistLit)
1940             hl = hp->histline;
1941         else {
1942             hl = sprlex(&hp->Hlex);
1943             cleanup_push(hl, xfree);
1944         }
1945 #ifdef SDEBUG
1946         xprintf("Comparing with \"%S\"\n", hl);
1947 #endif
1948         if ((Strncmp(hl, InputBuf, (size_t) (LastChar - InputBuf)) ||
1949              hl[LastChar-InputBuf]) && c_hmatch(hl))
1950             found = h;
1951         if (!HistLit)
1952             cleanup_until(hl);
1953         hp = hp->Hnext;
1954     }
1955
1956     if (!found) {               /* is it the current history number? */
1957         if (!c_hmatch(HistBuf.s)) {
1958 #ifdef SDEBUG
1959             xprintf("not found\n");
1960 #endif
1961             return(CC_ERROR);
1962         }
1963     }
1964
1965     Hist_num = found;
1966
1967     return(GetHistLine());
1968 }
1969
1970 /*ARGSUSED*/
1971 CCRETVAL
1972 e_helpme(Char c)
1973 {
1974     USE(c);
1975     PastBottom();
1976     *LastChar = '\0';           /* just in case */
1977     return(CC_HELPME);
1978 }
1979
1980 /*ARGSUSED*/
1981 CCRETVAL
1982 e_correct(Char c)
1983 {
1984     USE(c);
1985     *LastChar = '\0';           /* just in case */
1986     return(CC_CORRECT);
1987 }
1988
1989 /*ARGSUSED*/
1990 CCRETVAL
1991 e_correctl(Char c)
1992 {
1993     USE(c);
1994     *LastChar = '\0';           /* just in case */
1995     return(CC_CORRECT_L);
1996 }
1997
1998 /*ARGSUSED*/
1999 CCRETVAL
2000 e_run_fg_editor(Char c)
2001 {
2002     struct process *pp;
2003
2004     USE(c);
2005     if ((pp = find_stop_ed()) != NULL) {
2006         /* save our editor state so we can restore it */
2007         c_save_inputbuf();
2008         Hist_num = 0;           /* for the history commands */
2009
2010         /* put the tty in a sane mode */
2011         PastBottom();
2012         (void) Cookedmode();    /* make sure the tty is set up correctly */
2013
2014         /* do it! */
2015         fg_proc_entry(pp);
2016
2017         (void) Rawmode();       /* go on */
2018         Refresh();
2019         RestoreSaved = 0;
2020         HistSaved = 0;
2021     }
2022     return(CC_NORM);
2023 }
2024
2025 /*ARGSUSED*/
2026 CCRETVAL
2027 e_list_choices(Char c)
2028 {
2029     USE(c);
2030     PastBottom();
2031     *LastChar = '\0';           /* just in case */
2032     return(CC_LIST_CHOICES);
2033 }
2034
2035 /*ARGSUSED*/
2036 CCRETVAL
2037 e_list_all(Char c)
2038 {
2039     USE(c);
2040     PastBottom();
2041     *LastChar = '\0';           /* just in case */
2042     return(CC_LIST_ALL);
2043 }
2044
2045 /*ARGSUSED*/
2046 CCRETVAL
2047 e_list_glob(Char c)
2048 {
2049     USE(c);
2050     PastBottom();
2051     *LastChar = '\0';           /* just in case */
2052     return(CC_LIST_GLOB);
2053 }
2054
2055 /*ARGSUSED*/
2056 CCRETVAL
2057 e_expand_glob(Char c)
2058 {
2059     USE(c);
2060     *LastChar = '\0';           /* just in case */
2061     return(CC_EXPAND_GLOB);
2062 }
2063
2064 /*ARGSUSED*/
2065 CCRETVAL
2066 e_normalize_path(Char c)
2067 {
2068     USE(c);
2069     *LastChar = '\0';           /* just in case */
2070     return(CC_NORMALIZE_PATH);
2071 }
2072
2073 /*ARGSUSED*/
2074 CCRETVAL
2075 e_normalize_command(Char c)
2076 {
2077     USE(c);
2078     *LastChar = '\0';           /* just in case */
2079     return(CC_NORMALIZE_COMMAND);
2080 }
2081
2082 /*ARGSUSED*/
2083 CCRETVAL
2084 e_expand_vars(Char c)
2085 {
2086     USE(c);
2087     *LastChar = '\0';           /* just in case */
2088     return(CC_EXPAND_VARS);
2089 }
2090
2091 /*ARGSUSED*/
2092 CCRETVAL
2093 e_which(Char c)
2094 {                               /* do a fast command line which(1) */
2095     USE(c);
2096     c_save_inputbuf();
2097     Hist_num = 0;               /* for the history commands */
2098     PastBottom();
2099     *LastChar = '\0';           /* just in case */
2100     return(CC_WHICH);
2101 }
2102
2103 /*ARGSUSED*/
2104 CCRETVAL
2105 e_last_item(Char c)
2106 {                               /* insert the last element of the prev. cmd */
2107     struct Hist *hp;
2108     struct wordent *wp, *firstp;
2109     int i;
2110     Char *expanded;
2111
2112     USE(c);
2113     if (Argument <= 0)
2114         return(CC_ERROR);
2115
2116     hp = Histlist.Hnext;
2117     if (hp == NULL) {   /* this is only if no history */
2118         return(CC_ERROR);
2119     }
2120
2121     wp = (hp->Hlex).prev;
2122
2123     if (wp->prev == (struct wordent *) NULL)
2124         return(CC_ERROR);       /* an empty history entry */
2125
2126     firstp = (hp->Hlex).next;
2127
2128     /* back up arg words in lex */
2129     for (i = 0; i < Argument && wp != firstp; i++) {
2130         wp = wp->prev;
2131     }
2132
2133     expanded = expand_lex(wp->prev, 0, i - 1);
2134     if (InsertStr(expanded)) {
2135         xfree(expanded);
2136         return(CC_ERROR);
2137     }
2138
2139     xfree(expanded);
2140     return(CC_REFRESH);
2141 }
2142
2143 /*ARGSUSED*/
2144 CCRETVAL
2145 e_dabbrev_expand(Char c)
2146 {                               /* expand to preceding word matching prefix */
2147     Char *cp, *ncp, *bp;
2148     struct Hist *hp;
2149     int arg = 0, i;
2150     size_t len = 0;
2151     int found = 0;
2152     Char *hbuf;
2153     static int oldevent, hist, word;
2154     static Char *start, *oldcursor;
2155
2156     USE(c);
2157     if (Argument <= 0)
2158         return(CC_ERROR);
2159
2160     cp = c_preword(Cursor, InputBuf, 1, STRshwordsep);
2161     if (cp == Cursor || Isspace(*cp))
2162         return(CC_ERROR);
2163
2164     hbuf = NULL;
2165     hp = Histlist.Hnext;
2166     bp = InputBuf;
2167     if (Argument == 1 && eventno == oldevent && cp == start &&
2168         Cursor == oldcursor && patbuf.len > 0
2169         && Strncmp(patbuf.s, cp, patbuf.len) == 0){
2170         /* continue previous search - go to last match (hist/word) */
2171         if (hist != 0) {                /* need to move up history */
2172             for (i = 1; i < hist && hp != NULL; i++)
2173                 hp = hp->Hnext;
2174             if (hp == NULL)     /* "can't happen" */
2175                 goto err_hbuf;
2176             hbuf = expand_lex(&hp->Hlex, 0, INT_MAX);
2177             cp = Strend(hbuf);
2178             bp = hbuf;
2179             hp = hp->Hnext;
2180         }
2181         cp = c_preword(cp, bp, word, STRshwordsep);
2182     } else {                    /* starting new search */
2183         oldevent = eventno;
2184         start = cp;
2185         patbuf.len = 0;
2186         Strbuf_appendn(&patbuf, cp, Cursor - cp);
2187         hist = 0;
2188         word = 0;
2189     }
2190
2191     while (!found) {
2192         ncp = c_preword(cp, bp, 1, STRshwordsep);
2193         if (ncp == cp || Isspace(*ncp)) { /* beginning of line */
2194             hist++;
2195             word = 0;
2196             if (hp == NULL)
2197                 goto err_hbuf;
2198             hbuf = expand_lex(&hp->Hlex, 0, INT_MAX);
2199             cp = Strend(hbuf);
2200             bp = hbuf;
2201             hp = hp->Hnext;
2202             continue;
2203         } else {
2204             word++;
2205             len = c_endword(ncp-1, cp, 1, STRshwordsep) - ncp + 1;
2206             cp = ncp;
2207         }
2208         if (len > patbuf.len && Strncmp(cp, patbuf.s, patbuf.len) == 0) {
2209             /* We don't fully check distinct matches as Gnuemacs does: */
2210             if (Argument > 1) { /* just count matches */
2211                 if (++arg >= Argument)
2212                     found++;
2213             } else {            /* match if distinct from previous */
2214                 if (len != (size_t)(Cursor - start)
2215                     || Strncmp(cp, start, len) != 0)
2216                     found++;
2217             }
2218         }
2219     }
2220
2221     if (LastChar + len - (Cursor - start) >= InputLim)
2222         goto err_hbuf;  /* no room */
2223     DeleteBack(Cursor - start);
2224     c_insert(len);
2225     while (len--)
2226         *Cursor++ = *cp++;
2227     oldcursor = Cursor;
2228     xfree(hbuf);
2229     return(CC_REFRESH);
2230
2231  err_hbuf:
2232     xfree(hbuf);
2233     return CC_ERROR;
2234 }
2235
2236 /*ARGSUSED*/
2237 CCRETVAL
2238 e_yank_kill(Char c)
2239 {                               /* almost like GnuEmacs */
2240     int len;
2241     Char *kp, *cp;
2242
2243     USE(c);
2244     if (KillRingLen == 0)       /* nothing killed */
2245         return(CC_ERROR);
2246     len = Strlen(KillRing[YankPos].buf);
2247     if (LastChar + len >= InputLim)
2248         return(CC_ERROR);       /* end of buffer space */
2249
2250     /* else */
2251     cp = Cursor;                /* for speed */
2252
2253     c_insert(len);              /* open the space, */
2254     for (kp = KillRing[YankPos].buf; *kp; kp++) /* copy the chars */
2255         *cp++ = *kp;
2256
2257     if (Argument == 1) {        /* if no arg */
2258         Mark = Cursor;          /* mark at beginning, cursor at end */
2259         Cursor = cp;
2260     } else {
2261         Mark = cp;              /* else cursor at beginning, mark at end */
2262     }
2263
2264     if (adrof(STRhighlight) && MarkIsSet) {
2265         ClearLines();
2266         ClearDisp();
2267     }
2268     MarkIsSet = 0;
2269     return(CC_REFRESH);
2270 }
2271
2272 /*ARGSUSED*/
2273 CCRETVAL
2274 e_yank_pop(Char c)
2275 {                               /* almost like GnuEmacs */
2276     int m_bef_c, del_len, ins_len;
2277     Char *kp, *cp;
2278
2279     USE(c);
2280
2281 #if 0
2282     /* XXX This "should" be here, but doesn't work, since LastCmd
2283        gets set on CC_ERROR and CC_ARGHACK, which it shouldn't(?).
2284        (But what about F_ARGFOUR?) I.e. if you hit M-y twice the
2285        second one will "succeed" even if the first one wasn't preceded
2286        by a yank, and giving an argument is impossible. Now we "succeed"
2287        regardless of previous command, which is wrong too of course. */
2288     if (LastCmd != F_YANK_KILL && LastCmd != F_YANK_POP)
2289         return(CC_ERROR);
2290 #endif
2291
2292     if (KillRingLen == 0)       /* nothing killed */
2293         return(CC_ERROR);
2294     YankPos -= Argument;
2295     while (YankPos < 0)
2296         YankPos += KillRingLen;
2297     YankPos %= KillRingLen;
2298
2299     if (Cursor > Mark) {
2300         del_len = Cursor - Mark;
2301         m_bef_c = 1;
2302     } else {
2303         del_len = Mark - Cursor;
2304         m_bef_c = 0;
2305     }
2306     ins_len = Strlen(KillRing[YankPos].buf);
2307     if (LastChar + ins_len - del_len >= InputLim)
2308         return(CC_ERROR);       /* end of buffer space */
2309
2310     if (m_bef_c) {
2311         c_delbefore(del_len);
2312     } else {
2313         c_delafter(del_len);
2314     }
2315     cp = Cursor;                /* for speed */
2316
2317     c_insert(ins_len);          /* open the space, */
2318     for (kp = KillRing[YankPos].buf; *kp; kp++) /* copy the chars */
2319         *cp++ = *kp;
2320
2321     if (m_bef_c) {
2322         Mark = Cursor;          /* mark at beginning, cursor at end */
2323         Cursor = cp;
2324     } else {
2325         Mark = cp;              /* else cursor at beginning, mark at end */
2326     }
2327
2328     if (adrof(STRhighlight) && MarkIsSet) {
2329         ClearLines();
2330         ClearDisp();
2331     }
2332     MarkIsSet = 0;
2333     return(CC_REFRESH);
2334 }
2335
2336 /*ARGSUSED*/
2337 CCRETVAL
2338 v_delprev(Char c)               /* Backspace key in insert mode */
2339 {
2340     int rc;
2341
2342     USE(c);
2343     rc = CC_ERROR;
2344
2345     if (InsertPos != 0) {
2346         if (Argument <= Cursor - InsertPos) {
2347             c_delbefore(Argument);      /* delete before */
2348             rc = CC_REFRESH;
2349         }
2350     }
2351     return(rc);
2352 }   /* v_delprev  */
2353
2354 /*ARGSUSED*/
2355 CCRETVAL
2356 e_delprev(Char c)
2357 {
2358     USE(c);
2359     if (Cursor > InputBuf) {
2360         c_delbefore(Argument);  /* delete before dot */
2361         return(CC_REFRESH);
2362     }
2363     else {
2364         return(CC_ERROR);
2365     }
2366 }
2367
2368 /*ARGSUSED*/
2369 CCRETVAL
2370 e_delwordprev(Char c)
2371 {
2372     Char *cp;
2373
2374     USE(c);
2375     if (Cursor == InputBuf)
2376         return(CC_ERROR);
2377     /* else */
2378
2379     cp = c_prev_word(Cursor, InputBuf, Argument);
2380
2381     c_push_kill(cp, Cursor);    /* save the text */
2382
2383     c_delbefore((int)(Cursor - cp));    /* delete before dot */
2384     return(CC_REFRESH);
2385 }
2386
2387 /* DCS <dcs@neutron.chem.yale.edu>, 9 Oct 93
2388  *
2389  * Changed the names of some of the ^D family of editor functions to
2390  * correspond to what they actually do and created new e_delnext_list
2391  * for completeness.
2392  *
2393  *   Old names:                 New names:
2394  *
2395  *   delete-char                delete-char-or-eof
2396  *     F_DELNEXT                  F_DELNEXT_EOF
2397  *     e_delnext                  e_delnext_eof
2398  *     edelnxt                    edelnxteof
2399  *   delete-char-or-eof         delete-char
2400  *     F_DELNEXT_EOF              F_DELNEXT
2401  *     e_delnext_eof              e_delnext
2402  *     edelnxteof                 edelnxt
2403  *   delete-char-or-list        delete-char-or-list-or-eof
2404  *     F_LIST_DELNEXT             F_DELNEXT_LIST_EOF
2405  *     e_list_delnext             e_delnext_list_eof
2406  *                                edellsteof
2407  *   (no old equivalent)        delete-char-or-list
2408  *                                F_DELNEXT_LIST
2409  *                                e_delnext_list
2410  *                                e_delnxtlst
2411  */
2412
2413 /* added by mtk@ari.ncl.omron.co.jp (920818) */
2414 /* rename e_delnext() -> e_delnext_eof() */
2415 /*ARGSUSED*/
2416 CCRETVAL
2417 e_delnext(Char c)
2418 {
2419     USE(c);
2420     if (Cursor == LastChar) {/* if I'm at the end */
2421         if (!VImode) {
2422                 return(CC_ERROR);
2423         }
2424         else {
2425             if (Cursor != InputBuf)
2426                 Cursor--;
2427             else
2428                 return(CC_ERROR);
2429         }
2430     }
2431     c_delafter(Argument);       /* delete after dot */
2432     if (Cursor > LastChar)
2433         Cursor = LastChar;      /* bounds check */
2434     return(CC_REFRESH);
2435 }
2436
2437
2438 /*ARGSUSED*/
2439 CCRETVAL
2440 e_delnext_eof(Char c)
2441 {
2442     USE(c);
2443     if (Cursor == LastChar) {/* if I'm at the end */
2444         if (!VImode) {
2445             if (Cursor == InputBuf) {
2446                 /* if I'm also at the beginning */
2447                 so_write(STReof, 4);/* then do a EOF */
2448                 flush();
2449                 return(CC_EOF);
2450             }
2451             else
2452                 return(CC_ERROR);
2453         }
2454         else {
2455             if (Cursor != InputBuf)
2456                 Cursor--;
2457             else
2458                 return(CC_ERROR);
2459         }
2460     }
2461     c_delafter(Argument);       /* delete after dot */
2462     if (Cursor > LastChar)
2463         Cursor = LastChar;      /* bounds check */
2464     return(CC_REFRESH);
2465 }
2466
2467 /*ARGSUSED*/
2468 CCRETVAL
2469 e_delnext_list(Char c)
2470 {
2471     USE(c);
2472     if (Cursor == LastChar) {   /* if I'm at the end */
2473         PastBottom();
2474         *LastChar = '\0';       /* just in case */
2475         return(CC_LIST_CHOICES);
2476     }
2477     else {
2478         c_delafter(Argument);   /* delete after dot */
2479         if (Cursor > LastChar)
2480             Cursor = LastChar;  /* bounds check */
2481         return(CC_REFRESH);
2482     }
2483 }
2484
2485 /*ARGSUSED*/
2486 CCRETVAL
2487 e_delnext_list_eof(Char c)
2488 {
2489     USE(c);
2490     if (Cursor == LastChar) {   /* if I'm at the end */
2491         if (Cursor == InputBuf) {       /* if I'm also at the beginning */
2492             so_write(STReof, 4);/* then do a EOF */
2493             flush();
2494             return(CC_EOF);
2495         }
2496         else {
2497             PastBottom();
2498             *LastChar = '\0';   /* just in case */
2499             return(CC_LIST_CHOICES);
2500         }
2501     }
2502     else {
2503         c_delafter(Argument);   /* delete after dot */
2504         if (Cursor > LastChar)
2505             Cursor = LastChar;  /* bounds check */
2506         return(CC_REFRESH);
2507     }
2508 }
2509
2510 /*ARGSUSED*/
2511 CCRETVAL
2512 e_list_eof(Char c)
2513 {
2514     CCRETVAL rv;
2515
2516     USE(c);
2517     if (Cursor == LastChar && Cursor == InputBuf) {
2518         so_write(STReof, 4);    /* then do a EOF */
2519         flush();
2520         rv = CC_EOF;
2521     }
2522     else {
2523         PastBottom();
2524         *LastChar = '\0';       /* just in case */
2525         rv = CC_LIST_CHOICES;
2526     }
2527     return rv;
2528 }
2529
2530 /*ARGSUSED*/
2531 CCRETVAL
2532 e_delwordnext(Char c)
2533 {
2534     Char *cp;
2535
2536     USE(c);
2537     if (Cursor == LastChar)
2538         return(CC_ERROR);
2539     /* else */
2540
2541     cp = c_next_word(Cursor, LastChar, Argument);
2542
2543     c_push_kill(Cursor, cp);    /* save the text */
2544
2545     c_delafter((int)(cp - Cursor));     /* delete after dot */
2546     if (Cursor > LastChar)
2547         Cursor = LastChar;      /* bounds check */
2548     return(CC_REFRESH);
2549 }
2550
2551 /*ARGSUSED*/
2552 CCRETVAL
2553 e_toend(Char c)
2554 {
2555     USE(c);
2556     Cursor = LastChar;
2557     if (VImode)
2558         if (ActionFlag & TCSHOP_DELETE) {
2559             c_delfini();
2560             return(CC_REFRESH);
2561         }
2562     RefCursor();                /* move the cursor */
2563     return(CC_NORM);
2564 }
2565
2566 /*ARGSUSED*/
2567 CCRETVAL
2568 e_tobeg(Char c)
2569 {
2570     USE(c);
2571     Cursor = InputBuf;
2572
2573     if (VImode) {
2574        while (Isspace(*Cursor)) /* We want FIRST non space character */
2575         Cursor++;
2576         if (ActionFlag & TCSHOP_DELETE) {
2577             c_delfini();
2578             return(CC_REFRESH);
2579         }
2580     }
2581
2582     RefCursor();                /* move the cursor */
2583     return(CC_NORM);
2584 }
2585
2586 /*ARGSUSED*/
2587 CCRETVAL
2588 e_killend(Char c)
2589 {
2590     USE(c);
2591     c_push_kill(Cursor, LastChar); /* copy it */
2592     LastChar = Cursor;          /* zap! -- delete to end */
2593     if (Mark > Cursor)
2594         Mark = Cursor;
2595     MarkIsSet = 0;
2596     return(CC_REFRESH);
2597 }
2598
2599
2600 /*ARGSUSED*/
2601 CCRETVAL
2602 e_killbeg(Char c)
2603 {
2604     USE(c);
2605     c_push_kill(InputBuf, Cursor); /* copy it */
2606     c_delbefore((int)(Cursor - InputBuf));
2607     if (Mark && Mark > Cursor)
2608         Mark -= Cursor-InputBuf;
2609     return(CC_REFRESH);
2610 }
2611
2612 /*ARGSUSED*/
2613 CCRETVAL
2614 e_killall(Char c)
2615 {
2616     USE(c);
2617     c_push_kill(InputBuf, LastChar); /* copy it */
2618     Cursor = Mark = LastChar = InputBuf;        /* zap! -- delete all of it */
2619     MarkIsSet = 0;
2620     return(CC_REFRESH);
2621 }
2622
2623 /*ARGSUSED*/
2624 CCRETVAL
2625 e_killregion(Char c)
2626 {
2627     USE(c);
2628     if (!Mark)
2629         return(CC_ERROR);
2630
2631     if (Mark > Cursor) {
2632         c_push_kill(Cursor, Mark); /* copy it */
2633         c_delafter((int)(Mark - Cursor)); /* delete it - UNUSED BY VI mode */
2634         Mark = Cursor;
2635     }
2636     else {                      /* mark is before cursor */
2637         c_push_kill(Mark, Cursor); /* copy it */
2638         c_delbefore((int)(Cursor - Mark));
2639     }
2640     if (adrof(STRhighlight) && MarkIsSet) {
2641         ClearLines();
2642         ClearDisp();
2643     }
2644     MarkIsSet = 0;
2645     return(CC_REFRESH);
2646 }
2647
2648 /*ARGSUSED*/
2649 CCRETVAL
2650 e_copyregion(Char c)
2651 {
2652     USE(c);
2653     if (!Mark)
2654         return(CC_ERROR);
2655
2656     if (Mark > Cursor) {
2657         c_push_kill(Cursor, Mark); /* copy it */
2658     }
2659     else {                      /* mark is before cursor */
2660         c_push_kill(Mark, Cursor); /* copy it */
2661     }
2662     return(CC_NORM);            /* don't even need to Refresh() */
2663 }
2664
2665 /*ARGSUSED*/
2666 CCRETVAL
2667 e_charswitch(Char cc)
2668 {
2669     Char c;
2670
2671     USE(cc);
2672
2673     /* do nothing if we are at beginning of line or have only one char */
2674     if (Cursor == &InputBuf[0] || LastChar == &InputBuf[1]) {
2675         return(CC_ERROR);
2676     }
2677
2678     if (Cursor < LastChar) {
2679         Cursor++;
2680     }
2681     c = Cursor[-2];
2682     Cursor[-2] = Cursor[-1];
2683     Cursor[-1] = c;
2684     return(CC_REFRESH);
2685 }
2686
2687 /*ARGSUSED*/
2688 CCRETVAL
2689 e_gcharswitch(Char cc)
2690 {                               /* gosmacs style ^T */
2691     Char c;
2692
2693     USE(cc);
2694     if (Cursor > &InputBuf[1]) {/* must have at least two chars entered */
2695         c = Cursor[-2];
2696         Cursor[-2] = Cursor[-1];
2697         Cursor[-1] = c;
2698         return(CC_REFRESH);
2699     }
2700     else {
2701         return(CC_ERROR);
2702     }
2703 }
2704
2705 /*ARGSUSED*/
2706 CCRETVAL
2707 e_charback(Char c)
2708 {
2709     USE(c);
2710     if (Cursor > InputBuf) {
2711         if (Argument > Cursor - InputBuf)
2712             Cursor = InputBuf;
2713         else
2714             Cursor -= Argument;
2715
2716         if (VImode)
2717             if (ActionFlag & TCSHOP_DELETE) {
2718                 c_delfini();
2719                 return(CC_REFRESH);
2720             }
2721
2722         RefCursor();
2723         return(CC_NORM);
2724     }
2725     else {
2726         return(CC_ERROR);
2727     }
2728 }
2729
2730 /*ARGSUSED*/
2731 CCRETVAL
2732 v_wordback(Char c)
2733 {
2734     USE(c);
2735     if (Cursor == InputBuf)
2736         return(CC_ERROR);
2737     /* else */
2738
2739     Cursor = c_preword(Cursor, InputBuf, Argument, STRshwspace); /* bounds check */
2740
2741     if (ActionFlag & TCSHOP_DELETE) {
2742         c_delfini();
2743         return(CC_REFRESH);
2744     }
2745
2746     RefCursor();
2747     return(CC_NORM);
2748 }
2749
2750 /*ARGSUSED*/
2751 CCRETVAL
2752 e_wordback(Char c)
2753 {
2754     USE(c);
2755     if (Cursor == InputBuf)
2756         return(CC_ERROR);
2757     /* else */
2758
2759     Cursor = c_prev_word(Cursor, InputBuf, Argument); /* bounds check */
2760
2761     if (VImode)
2762         if (ActionFlag & TCSHOP_DELETE) {
2763             c_delfini();
2764             return(CC_REFRESH);
2765         }
2766
2767     RefCursor();
2768     return(CC_NORM);
2769 }
2770
2771 /*ARGSUSED*/
2772 CCRETVAL
2773 e_charfwd(Char c)
2774 {
2775     USE(c);
2776     if (Cursor < LastChar) {
2777         Cursor += Argument;
2778         if (Cursor > LastChar)
2779             Cursor = LastChar;
2780
2781         if (VImode)
2782             if (ActionFlag & TCSHOP_DELETE) {
2783                 c_delfini();
2784                 return(CC_REFRESH);
2785             }
2786
2787         RefCursor();
2788         return(CC_NORM);
2789     }
2790     else {
2791         return(CC_ERROR);
2792     }
2793 }
2794
2795 /*ARGSUSED*/
2796 CCRETVAL
2797 e_wordfwd(Char c)
2798 {
2799     USE(c);
2800     if (Cursor == LastChar)
2801         return(CC_ERROR);
2802     /* else */
2803
2804     Cursor = c_next_word(Cursor, LastChar, Argument);
2805
2806     if (VImode)
2807         if (ActionFlag & TCSHOP_DELETE) {
2808             c_delfini();
2809             return(CC_REFRESH);
2810         }
2811
2812     RefCursor();
2813     return(CC_NORM);
2814 }
2815
2816 /*ARGSUSED*/
2817 CCRETVAL
2818 v_wordfwd(Char c)
2819 {
2820     USE(c);
2821     if (Cursor == LastChar)
2822         return(CC_ERROR);
2823     /* else */
2824
2825     Cursor = c_nexword(Cursor, LastChar, Argument);
2826
2827     if (VImode)
2828         if (ActionFlag & TCSHOP_DELETE) {
2829             c_delfini();
2830             return(CC_REFRESH);
2831         }
2832
2833     RefCursor();
2834     return(CC_NORM);
2835 }
2836
2837 /*ARGSUSED*/
2838 CCRETVAL
2839 v_wordbegnext(Char c)
2840 {
2841     USE(c);
2842     if (Cursor == LastChar)
2843         return(CC_ERROR);
2844     /* else */
2845
2846     Cursor = c_next_word(Cursor, LastChar, Argument);
2847     if (Cursor < LastChar)
2848         Cursor++;
2849
2850     if (VImode)
2851         if (ActionFlag & TCSHOP_DELETE) {
2852             c_delfini();
2853             return(CC_REFRESH);
2854         }
2855
2856     RefCursor();
2857     return(CC_NORM);
2858 }
2859
2860 /*ARGSUSED*/
2861 static CCRETVAL
2862 v_repeat_srch(int c)
2863 {
2864     CCRETVAL rv = CC_ERROR;
2865 #ifdef SDEBUG
2866     xprintf("dir %d patlen %d patbuf %S\n",
2867             c, (int)patbuf.len, patbuf.s);
2868 #endif
2869
2870     LastCmd = (KEYCMD) c;  /* Hack to stop c_hsetpat */
2871     LastChar = InputBuf;
2872     switch (c) {
2873     case F_DOWN_SEARCH_HIST:
2874         rv = e_down_search_hist(0);
2875         break;
2876     case F_UP_SEARCH_HIST:
2877         rv = e_up_search_hist(0);
2878         break;
2879     default:
2880         break;
2881     }
2882     return rv;
2883 }
2884
2885 static CCRETVAL
2886 v_csearch_back(Char ch, int count, int tflag)
2887 {
2888     Char *cp;
2889
2890     cp = Cursor;
2891     while (count--) {
2892         if (*cp == ch)
2893             cp--;
2894         while (cp > InputBuf && *cp != ch)
2895             cp--;
2896     }
2897
2898     if (cp < InputBuf || (cp == InputBuf && *cp != ch))
2899         return(CC_ERROR);
2900
2901     if (*cp == ch && tflag)
2902         cp++;
2903
2904     Cursor = cp;
2905
2906     if (ActionFlag & TCSHOP_DELETE) {
2907         Cursor++;
2908         c_delfini();
2909         return(CC_REFRESH);
2910     }
2911
2912     RefCursor();
2913     return(CC_NORM);
2914 }
2915
2916 static CCRETVAL
2917 v_csearch_fwd(Char ch, int count, int tflag)
2918 {
2919     Char *cp;
2920
2921     cp = Cursor;
2922     while (count--) {
2923         if(*cp == ch)
2924             cp++;
2925         while (cp < LastChar && *cp != ch)
2926             cp++;
2927     }
2928
2929     if (cp >= LastChar)
2930         return(CC_ERROR);
2931
2932     if (*cp == ch && tflag)
2933         cp--;
2934
2935     Cursor = cp;
2936
2937     if (ActionFlag & TCSHOP_DELETE) {
2938         Cursor++;
2939         c_delfini();
2940         return(CC_REFRESH);
2941     }
2942     RefCursor();
2943     return(CC_NORM);
2944 }
2945
2946 /*ARGSUSED*/
2947 static CCRETVAL
2948 v_action(int c)
2949 {
2950     Char *cp, *kp;
2951
2952     if (ActionFlag == TCSHOP_DELETE) {
2953         ActionFlag = TCSHOP_NOP;
2954         ActionPos = 0;
2955
2956         UndoSize = 0;
2957         kp = UndoBuf;
2958         for (cp = InputBuf; cp < LastChar; cp++) {
2959             *kp++ = *cp;
2960             UndoSize++;
2961         }
2962
2963         UndoAction = TCSHOP_INSERT;
2964         UndoPtr  = InputBuf;
2965         LastChar = InputBuf;
2966         Cursor   = InputBuf;
2967         if (c & TCSHOP_INSERT)
2968             c_alternativ_key_map(0);
2969
2970         return(CC_REFRESH);
2971     }
2972 #ifdef notdef
2973     else if (ActionFlag == TCSHOP_NOP) {
2974 #endif
2975         ActionPos = Cursor;
2976         ActionFlag = c;
2977         return(CC_ARGHACK);  /* Do NOT clear out argument */
2978 #ifdef notdef
2979     }
2980     else {
2981         ActionFlag = 0;
2982         ActionPos = 0;
2983         return(CC_ERROR);
2984     }
2985 #endif
2986 }
2987
2988 #ifdef COMMENT
2989 /* by: Brian Allison <uiucdcs!convex!allison@RUTGERS.EDU> */
2990 static void
2991 c_get_word(Char **begin, Char **end)
2992 {
2993     Char   *cp;
2994
2995     cp = &Cursor[0];
2996     while (Argument--) {
2997         while ((cp <= LastChar) && (isword(*cp)))
2998             cp++;
2999         *end = --cp;
3000         while ((cp >= InputBuf) && (isword(*cp)))
3001             cp--;
3002         *begin = ++cp;
3003     }
3004 }
3005 #endif /* COMMENT */
3006
3007 /*ARGSUSED*/
3008 CCRETVAL
3009 e_uppercase(Char c)
3010 {
3011     Char   *cp, *end;
3012
3013     USE(c);
3014     end = c_next_word(Cursor, LastChar, Argument);
3015
3016     for (cp = Cursor; cp < end; cp++)   /* PWP: was cp=begin */
3017         if (Islower(*cp))
3018             *cp = Toupper(*cp);
3019
3020     Cursor = end;
3021     if (Cursor > LastChar)
3022         Cursor = LastChar;
3023     return(CC_REFRESH);
3024 }
3025
3026
3027 /*ARGSUSED*/
3028 CCRETVAL
3029 e_capitolcase(Char c)
3030 {
3031     Char   *cp, *end;
3032
3033     USE(c);
3034     end = c_next_word(Cursor, LastChar, Argument);
3035
3036     cp = Cursor;
3037     for (; cp < end; cp++) {
3038         if (Isalpha(*cp)) {
3039             if (Islower(*cp))
3040                 *cp = Toupper(*cp);
3041             cp++;
3042             break;
3043         }
3044     }
3045     for (; cp < end; cp++)
3046         if (Isupper(*cp))
3047             *cp = Tolower(*cp);
3048
3049     Cursor = end;
3050     if (Cursor > LastChar)
3051         Cursor = LastChar;
3052     return(CC_REFRESH);
3053 }
3054
3055 /*ARGSUSED*/
3056 CCRETVAL
3057 e_lowercase(Char c)
3058 {
3059     Char   *cp, *end;
3060
3061     USE(c);
3062     end = c_next_word(Cursor, LastChar, Argument);
3063
3064     for (cp = Cursor; cp < end; cp++)
3065         if (Isupper(*cp))
3066             *cp = Tolower(*cp);
3067
3068     Cursor = end;
3069     if (Cursor > LastChar)
3070         Cursor = LastChar;
3071     return(CC_REFRESH);
3072 }
3073
3074
3075 /*ARGSUSED*/
3076 CCRETVAL
3077 e_set_mark(Char c)
3078 {
3079     USE(c);
3080     if (adrof(STRhighlight) && MarkIsSet && Mark != Cursor) {
3081         ClearLines();
3082         ClearDisp();
3083         Refresh();
3084     }
3085     Mark = Cursor;
3086     MarkIsSet = 1;
3087     return(CC_NORM);
3088 }
3089
3090 /*ARGSUSED*/
3091 CCRETVAL
3092 e_exchange_mark(Char c)
3093 {
3094     Char *cp;
3095
3096     USE(c);
3097     cp = Cursor;
3098     Cursor = Mark;
3099     Mark = cp;
3100     RefCursor();
3101     return(CC_NORM);
3102 }
3103
3104 /*ARGSUSED*/
3105 CCRETVAL
3106 e_argfour(Char c)
3107 {                               /* multiply current argument by 4 */
3108     USE(c);
3109     if (Argument > 1000000)
3110         return CC_ERROR;
3111     DoingArg = 1;
3112     Argument *= 4;
3113     return(CC_ARGHACK);
3114 }
3115
3116 static void
3117 quote_mode_cleanup(void *unused)
3118 {
3119     USE(unused);
3120     QuoteModeOff();
3121 }
3122
3123 /*ARGSUSED*/
3124 CCRETVAL
3125 e_quote(Char c)
3126 {
3127     Char    ch;
3128     int     num;
3129
3130     USE(c);
3131     QuoteModeOn();
3132     cleanup_push(&c, quote_mode_cleanup); /* Using &c just as a mark */
3133     num = GetNextChar(&ch);
3134     cleanup_until(&c);
3135     if (num == 1)
3136         return e_insert(ch);
3137     else
3138         return e_send_eof(0);
3139 }
3140
3141 /*ARGSUSED*/
3142 CCRETVAL
3143 e_metanext(Char c)
3144 {
3145     USE(c);
3146     MetaNext = 1;
3147     return(CC_ARGHACK); /* preserve argument */
3148 }
3149
3150 #ifdef notdef
3151 /*ARGSUSED*/
3152 CCRETVAL
3153 e_extendnext(Char c)
3154 {
3155     CurrentKeyMap = CcAltMap;
3156     return(CC_ARGHACK); /* preserve argument */
3157 }
3158
3159 #endif
3160
3161 /*ARGSUSED*/
3162 CCRETVAL
3163 v_insbeg(Char c)
3164 {                               /* move to beginning of line and start vi
3165                                  * insert mode */
3166     USE(c);
3167     Cursor = InputBuf;
3168     InsertPos = Cursor;
3169
3170     UndoPtr  = Cursor;
3171     UndoAction = TCSHOP_DELETE;
3172
3173     RefCursor();                /* move the cursor */
3174     c_alternativ_key_map(0);
3175     return(CC_NORM);
3176 }
3177
3178 /*ARGSUSED*/
3179 CCRETVAL
3180 v_replone(Char c)
3181 {                               /* vi mode overwrite one character */
3182     USE(c);
3183     c_alternativ_key_map(0);
3184     inputmode = MODE_REPLACE_1;
3185     UndoAction = TCSHOP_CHANGE; /* Set Up for VI undo command */
3186     UndoPtr = Cursor;
3187     UndoSize = 0;
3188     return(CC_NORM);
3189 }
3190
3191 /*ARGSUSED*/
3192 CCRETVAL
3193 v_replmode(Char c)
3194 {                               /* vi mode start overwriting */
3195     USE(c);
3196     c_alternativ_key_map(0);
3197     inputmode = MODE_REPLACE;
3198     UndoAction = TCSHOP_CHANGE; /* Set Up for VI undo command */
3199     UndoPtr = Cursor;
3200     UndoSize = 0;
3201     return(CC_NORM);
3202 }
3203
3204 /*ARGSUSED*/
3205 CCRETVAL
3206 v_substchar(Char c)
3207 {                               /* vi mode substitute for one char */
3208     USE(c);
3209     c_delafter(Argument);
3210     c_alternativ_key_map(0);
3211     return(CC_REFRESH);
3212 }
3213
3214 /*ARGSUSED*/
3215 CCRETVAL
3216 v_substline(Char c)
3217 {                               /* vi mode replace whole line */
3218     USE(c);
3219     (void) e_killall(0);
3220     c_alternativ_key_map(0);
3221     return(CC_REFRESH);
3222 }
3223
3224 /*ARGSUSED*/
3225 CCRETVAL
3226 v_chgtoend(Char c)
3227 {                               /* vi mode change to end of line */
3228     USE(c);
3229     (void) e_killend(0);
3230     c_alternativ_key_map(0);
3231     return(CC_REFRESH);
3232 }
3233
3234 /*ARGSUSED*/
3235 CCRETVAL
3236 v_insert(Char c)
3237 {                               /* vi mode start inserting */
3238     USE(c);
3239     c_alternativ_key_map(0);
3240
3241     InsertPos = Cursor;
3242     UndoPtr = Cursor;
3243     UndoAction = TCSHOP_DELETE;
3244
3245     return(CC_NORM);
3246 }
3247
3248 /*ARGSUSED*/
3249 CCRETVAL
3250 v_add(Char c)
3251 {                               /* vi mode start adding */
3252     USE(c);
3253     c_alternativ_key_map(0);
3254     if (Cursor < LastChar)
3255     {
3256         Cursor++;
3257         if (Cursor > LastChar)
3258             Cursor = LastChar;
3259         RefCursor();
3260     }
3261
3262     InsertPos = Cursor;
3263     UndoPtr = Cursor;
3264     UndoAction = TCSHOP_DELETE;
3265
3266     return(CC_NORM);
3267 }
3268
3269 /*ARGSUSED*/
3270 CCRETVAL
3271 v_addend(Char c)
3272 {                               /* vi mode to add at end of line */
3273     USE(c);
3274     c_alternativ_key_map(0);
3275     Cursor = LastChar;
3276
3277     InsertPos = LastChar;       /* Mark where insertion begins */
3278     UndoPtr = LastChar;
3279     UndoAction = TCSHOP_DELETE;
3280
3281     RefCursor();
3282     return(CC_NORM);
3283 }
3284
3285 /*ARGSUSED*/
3286 CCRETVAL
3287 v_change_case(Char cc)
3288 {
3289     Char    c;
3290
3291     USE(cc);
3292     if (Cursor < LastChar) {
3293 #ifndef WINNT_NATIVE
3294         c = *Cursor;
3295 #else
3296         c = CHAR & *Cursor;
3297 #endif /* WINNT_NATIVE */
3298         if (Isupper(c))
3299             *Cursor++ = Tolower(c);
3300         else if (Islower(c))
3301             *Cursor++ = Toupper(c);
3302         else
3303             Cursor++;
3304         RefPlusOne(1);          /* fast refresh for one char */
3305         return(CC_NORM);
3306     }
3307     return(CC_ERROR);
3308 }
3309
3310 /*ARGSUSED*/
3311 CCRETVAL
3312 e_expand(Char c)
3313 {
3314     Char *p;
3315
3316     USE(c);
3317     for (p = InputBuf; Isspace(*p); p++)
3318         continue;
3319     if (p == LastChar)
3320         return(CC_ERROR);
3321
3322     justpr++;
3323     Expand++;
3324     return(e_newline(0));
3325 }
3326
3327 /*ARGSUSED*/
3328 CCRETVAL
3329 e_startover(Char c)
3330 {                               /* erase all of current line, start again */
3331     USE(c);
3332     ResetInLine(0);             /* reset the input pointers */
3333     return(CC_REFRESH);
3334 }
3335
3336 /*ARGSUSED*/
3337 CCRETVAL
3338 e_redisp(Char c)
3339 {
3340     USE(c);
3341     ClearLines();
3342     ClearDisp();
3343     return(CC_REFRESH);
3344 }
3345
3346 /*ARGSUSED*/
3347 CCRETVAL
3348 e_cleardisp(Char c)
3349 {
3350     USE(c);
3351     ClearScreen();              /* clear the whole real screen */
3352     ClearDisp();                /* reset everything */
3353     return(CC_REFRESH);
3354 }
3355
3356 /*ARGSUSED*/
3357 CCRETVAL
3358 e_tty_int(Char c)
3359 {
3360     USE(c);
3361 #if defined(_MINIX) || defined(WINNT_NATIVE)
3362     /* SAK PATCH: erase all of current line, start again */
3363     ResetInLine(0);             /* reset the input pointers */
3364     xputchar('\n');
3365     ClearDisp();
3366     return (CC_REFRESH);
3367 #else /* !_MINIX && !WINNT_NATIVE */
3368     /* do no editing */
3369     return (CC_NORM);
3370 #endif /* _MINIX || WINNT_NATIVE */
3371 }
3372
3373 /*
3374  * From: ghazi@cesl.rutgers.edu (Kaveh R. Ghazi)
3375  * Function to send a character back to the input stream in cooked
3376  * mode. Only works if we have TIOCSTI
3377  */
3378 /*ARGSUSED*/
3379 CCRETVAL
3380 e_stuff_char(Char c)
3381 {
3382 #ifdef TIOCSTI
3383      int was_raw = Tty_raw_mode;
3384      char buf[MB_LEN_MAX];
3385      size_t i, len;
3386
3387      if (was_raw)
3388          (void) Cookedmode();
3389
3390      (void) xwrite(SHIN, "\n", 1);
3391      len = one_wctomb(buf, c & CHAR);
3392      for (i = 0; i < len; i++)
3393          (void) ioctl(SHIN, TIOCSTI, (ioctl_t) &buf[i]);
3394
3395      if (was_raw)
3396          (void) Rawmode();
3397      return(e_redisp(c));
3398 #else /* !TIOCSTI */
3399      return(CC_ERROR);
3400 #endif /* !TIOCSTI */
3401 }
3402
3403 /*ARGSUSED*/
3404 CCRETVAL
3405 e_insovr(Char c)
3406 {
3407     USE(c);
3408     inputmode = (inputmode == MODE_INSERT ? MODE_REPLACE : MODE_INSERT);
3409     return(CC_NORM);
3410 }
3411
3412 /*ARGSUSED*/
3413 CCRETVAL
3414 e_tty_dsusp(Char c)
3415 {
3416     USE(c);
3417     /* do no editing */
3418     return(CC_NORM);
3419 }
3420
3421 /*ARGSUSED*/
3422 CCRETVAL
3423 e_tty_flusho(Char c)
3424 {
3425     USE(c);
3426     /* do no editing */
3427     return(CC_NORM);
3428 }
3429
3430 /*ARGSUSED*/
3431 CCRETVAL
3432 e_tty_quit(Char c)
3433 {
3434     USE(c);
3435     /* do no editing */
3436     return(CC_NORM);
3437 }
3438
3439 /*ARGSUSED*/
3440 CCRETVAL
3441 e_tty_tsusp(Char c)
3442 {
3443     USE(c);
3444     /* do no editing */
3445     return(CC_NORM);
3446 }
3447
3448 /*ARGSUSED*/
3449 CCRETVAL
3450 e_tty_stopo(Char c)
3451 {
3452     USE(c);
3453     /* do no editing */
3454     return(CC_NORM);
3455 }
3456
3457 /* returns the number of (attempted) expansions */
3458 int
3459 ExpandHistory(void)
3460 {
3461     *LastChar = '\0';           /* just in case */
3462     return c_substitute();
3463 }
3464
3465 /*ARGSUSED*/
3466 CCRETVAL
3467 e_expand_history(Char c)
3468 {
3469     USE(c);
3470     (void)ExpandHistory();
3471     return(CC_NORM);
3472 }
3473
3474 /*ARGSUSED*/
3475 CCRETVAL
3476 e_magic_space(Char c)
3477 {
3478     USE(c);
3479     *LastChar = '\0';           /* just in case */
3480     (void)c_substitute();
3481     return(e_insert(' '));
3482 }
3483
3484 /*ARGSUSED*/
3485 CCRETVAL
3486 e_inc_fwd(Char c)
3487 {
3488     CCRETVAL ret;
3489
3490     USE(c);
3491     patbuf.len = 0;
3492     MarkIsSet = 0;
3493     ret = e_inc_search(F_DOWN_SEARCH_HIST);
3494     if (adrof(STRhighlight) && IncMatchLen) {
3495         IncMatchLen = 0;
3496         ClearLines();
3497         ClearDisp();
3498         Refresh();
3499     }
3500     IncMatchLen = 0;
3501     return ret;
3502 }
3503
3504
3505 /*ARGSUSED*/
3506 CCRETVAL
3507 e_inc_back(Char c)
3508 {
3509     CCRETVAL ret;
3510
3511     USE(c);
3512     patbuf.len = 0;
3513     MarkIsSet = 0;
3514     ret = e_inc_search(F_UP_SEARCH_HIST);
3515     if (adrof(STRhighlight) && IncMatchLen) {
3516         IncMatchLen = 0;
3517         ClearLines();
3518         ClearDisp();
3519         Refresh();
3520     }
3521     IncMatchLen = 0;
3522     return ret;
3523 }
3524
3525 /*ARGSUSED*/
3526 CCRETVAL
3527 e_copyprev(Char c)
3528 {
3529     Char *cp, *oldc, *dp;
3530
3531     USE(c);
3532     if (Cursor == InputBuf)
3533         return(CC_ERROR);
3534     /* else */
3535
3536     oldc = Cursor;
3537     /* does a bounds check */
3538     cp = c_prev_word(Cursor, InputBuf, Argument);
3539
3540     c_insert((int)(oldc - cp));
3541     for (dp = oldc; cp < oldc && dp < LastChar; cp++)
3542         *dp++ = *cp;
3543
3544     Cursor = dp;                /* put cursor at end */
3545
3546     return(CC_REFRESH);
3547 }
3548
3549 /*ARGSUSED*/
3550 CCRETVAL
3551 e_tty_starto(Char c)
3552 {
3553     USE(c);
3554     /* do no editing */
3555     return(CC_NORM);
3556 }
3557
3558 /*ARGSUSED*/
3559 CCRETVAL
3560 e_load_average(Char c)
3561 {
3562     USE(c);
3563     PastBottom();
3564 #ifdef TIOCSTAT
3565     /*
3566      * Here we pass &c to the ioctl because some os's (NetBSD) expect it
3567      * there even if they don't use it. (lukem@netbsd.org)
3568      */
3569     if (ioctl(SHIN, TIOCSTAT, (ioctl_t) &c) < 0)
3570 #endif
3571         xprintf("%s", CGETS(5, 1, "Load average unavailable\n"));
3572     return(CC_REFRESH);
3573 }
3574
3575 /*ARGSUSED*/
3576 CCRETVAL
3577 v_chgmeta(Char c)
3578 {
3579     USE(c);
3580     /*
3581      * Delete with insert == change: first we delete and then we leave in
3582      * insert mode.
3583      */
3584     return(v_action(TCSHOP_DELETE|TCSHOP_INSERT));
3585 }
3586
3587 /*ARGSUSED*/
3588 CCRETVAL
3589 v_delmeta(Char c)
3590 {
3591     USE(c);
3592     return(v_action(TCSHOP_DELETE));
3593 }
3594
3595
3596 /*ARGSUSED*/
3597 CCRETVAL
3598 v_endword(Char c)
3599 {
3600     USE(c);
3601     if (Cursor == LastChar)
3602         return(CC_ERROR);
3603     /* else */
3604
3605     Cursor = c_endword(Cursor, LastChar, Argument, STRshwspace);
3606
3607     if (ActionFlag & TCSHOP_DELETE)
3608     {
3609         Cursor++;
3610         c_delfini();
3611         return(CC_REFRESH);
3612     }
3613
3614     RefCursor();
3615     return(CC_NORM);
3616 }
3617
3618 /*ARGSUSED*/
3619 CCRETVAL
3620 v_eword(Char c)
3621 {
3622     USE(c);
3623     if (Cursor == LastChar)
3624         return(CC_ERROR);
3625     /* else */
3626
3627     Cursor = c_eword(Cursor, LastChar, Argument);
3628
3629     if (ActionFlag & TCSHOP_DELETE) {
3630         Cursor++;
3631         c_delfini();
3632         return(CC_REFRESH);
3633     }
3634
3635     RefCursor();
3636     return(CC_NORM);
3637 }
3638
3639 /*ARGSUSED*/
3640 CCRETVAL
3641 v_char_fwd(Char c)
3642 {
3643     Char ch;
3644
3645     USE(c);
3646     if (GetNextChar(&ch) != 1)
3647         return e_send_eof(0);
3648
3649     srch_dir = CHAR_FWD;
3650     srch_char = ch;
3651
3652     return v_csearch_fwd(ch, Argument, 0);
3653
3654 }
3655
3656 /*ARGSUSED*/
3657 CCRETVAL
3658 v_char_back(Char c)
3659 {
3660     Char ch;
3661
3662     USE(c);
3663     if (GetNextChar(&ch) != 1)
3664         return e_send_eof(0);
3665
3666     srch_dir = CHAR_BACK;
3667     srch_char = ch;
3668
3669     return v_csearch_back(ch, Argument, 0);
3670 }
3671
3672 /*ARGSUSED*/
3673 CCRETVAL
3674 v_charto_fwd(Char c)
3675 {
3676     Char ch;
3677
3678     USE(c);
3679     if (GetNextChar(&ch) != 1)
3680         return e_send_eof(0);
3681
3682     return v_csearch_fwd(ch, Argument, 1);
3683
3684 }
3685
3686 /*ARGSUSED*/
3687 CCRETVAL
3688 v_charto_back(Char c)
3689 {
3690     Char ch;
3691
3692     USE(c);
3693     if (GetNextChar(&ch) != 1)
3694         return e_send_eof(0);
3695
3696     return v_csearch_back(ch, Argument, 1);
3697 }
3698
3699 /*ARGSUSED*/
3700 CCRETVAL
3701 v_rchar_fwd(Char c)
3702 {
3703     USE(c);
3704     if (srch_char == 0)
3705         return CC_ERROR;
3706
3707     return srch_dir == CHAR_FWD ? v_csearch_fwd(srch_char, Argument, 0) :
3708                                   v_csearch_back(srch_char, Argument, 0);
3709 }
3710
3711 /*ARGSUSED*/
3712 CCRETVAL
3713 v_rchar_back(Char c)
3714 {
3715     USE(c);
3716     if (srch_char == 0)
3717         return CC_ERROR;
3718
3719     return srch_dir == CHAR_BACK ? v_csearch_fwd(srch_char, Argument, 0) :
3720                                    v_csearch_back(srch_char, Argument, 0);
3721 }
3722
3723 /*ARGSUSED*/
3724 CCRETVAL
3725 v_undo(Char c)
3726 {
3727     int  loop;
3728     Char *kp, *cp;
3729     Char temp;
3730     int  size;
3731
3732     USE(c);
3733     switch (UndoAction) {
3734     case TCSHOP_DELETE|TCSHOP_INSERT:
3735     case TCSHOP_DELETE:
3736         if (UndoSize == 0) return(CC_NORM);
3737         cp = UndoPtr;
3738         kp = UndoBuf;
3739         for (loop=0; loop < UndoSize; loop++)   /* copy the chars */
3740             *kp++ = *cp++;                      /* into UndoBuf   */
3741
3742         for (cp = UndoPtr; cp <= LastChar; cp++)
3743             *cp = cp[UndoSize];
3744
3745         LastChar -= UndoSize;
3746         Cursor   =  UndoPtr;
3747
3748         UndoAction = TCSHOP_INSERT;
3749         break;
3750
3751     case TCSHOP_INSERT:
3752         if (UndoSize == 0) return(CC_NORM);
3753         cp = UndoPtr;
3754         Cursor = UndoPtr;
3755         kp = UndoBuf;
3756         c_insert(UndoSize);             /* open the space, */
3757         for (loop = 0; loop < UndoSize; loop++) /* copy the chars */
3758             *cp++ = *kp++;
3759
3760         UndoAction = TCSHOP_DELETE;
3761         break;
3762
3763     case TCSHOP_CHANGE:
3764         if (UndoSize == 0) return(CC_NORM);
3765         cp = UndoPtr;
3766         Cursor = UndoPtr;
3767         kp = UndoBuf;
3768         size = (int)(Cursor-LastChar); /*  NOT NSL independant */
3769         if (size < UndoSize)
3770             size = UndoSize;
3771         for(loop = 0; loop < size; loop++) {
3772             temp = *kp;
3773             *kp++ = *cp;
3774             *cp++ = temp;
3775         }
3776         break;
3777
3778     default:
3779         return(CC_ERROR);
3780     }
3781
3782     return(CC_REFRESH);
3783 }
3784
3785 /*ARGSUSED*/
3786 CCRETVAL
3787 v_ush_meta(Char c)
3788 {
3789     USE(c);
3790     return v_search(F_UP_SEARCH_HIST);
3791 }
3792
3793 /*ARGSUSED*/
3794 CCRETVAL
3795 v_dsh_meta(Char c)
3796 {
3797     USE(c);
3798     return v_search(F_DOWN_SEARCH_HIST);
3799 }
3800
3801 /*ARGSUSED*/
3802 CCRETVAL
3803 v_rsrch_fwd(Char c)
3804 {
3805     USE(c);
3806     if (patbuf.len == 0) return(CC_ERROR);
3807     return(v_repeat_srch(searchdir));
3808 }
3809
3810 /*ARGSUSED*/
3811 CCRETVAL
3812 v_rsrch_back(Char c)
3813 {
3814     USE(c);
3815     if (patbuf.len == 0) return(CC_ERROR);
3816     return(v_repeat_srch(searchdir == F_UP_SEARCH_HIST ?
3817                          F_DOWN_SEARCH_HIST : F_UP_SEARCH_HIST));
3818 }
3819
3820 #ifndef WINNT_NATIVE
3821 /* Since ed.defns.h  is generated from ed.defns.c, these empty
3822    functions will keep the F_NUM_FNS consistent
3823  */
3824 CCRETVAL
3825 e_copy_to_clipboard(Char c)
3826 {
3827     USE(c);
3828     return CC_ERROR;
3829 }
3830
3831 CCRETVAL
3832 e_paste_from_clipboard(Char c)
3833 {
3834     USE(c);
3835     return (CC_ERROR);
3836 }
3837
3838 CCRETVAL
3839 e_dosify_next(Char c)
3840 {
3841     USE(c);
3842     return (CC_ERROR);
3843 }
3844 CCRETVAL
3845 e_dosify_prev(Char c)
3846 {
3847     USE(c);
3848     return (CC_ERROR);
3849 }
3850 CCRETVAL
3851 e_page_up(Char c)
3852 {
3853     USE(c);
3854     return (CC_ERROR);
3855 }
3856 CCRETVAL
3857 e_page_down(Char c)
3858 {
3859     USE(c);
3860     return (CC_ERROR);
3861 }
3862 #endif /* !WINNT_NATIVE */
3863
3864 #ifdef notdef
3865 void
3866 MoveCursor(int n)               /* move cursor + right - left char */
3867 {
3868     Cursor = Cursor + n;
3869     if (Cursor < InputBuf)
3870         Cursor = InputBuf;
3871     if (Cursor > LastChar)
3872         Cursor = LastChar;
3873     return;
3874 }
3875
3876 Char *
3877 GetCursor(void)
3878 {
3879     return(Cursor);
3880 }
3881
3882 int
3883 PutCursor(Char *p)
3884 {
3885     if (p < InputBuf || p > LastChar)
3886         return 1;               /* Error */
3887     Cursor = p;
3888     return 0;
3889 }
3890 #endif