?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Vendor import of tcsh 6.15.00
[dragonfly.git] / contrib / tcsh-6 / ed.chared.c
blob9f09c68562af05775f22943d5a52237cda82ddf2
1 /* $Header: /p/tcsh/cvsroot/tcsh/ed.chared.c,v 3.93 2006/08/23 15:03:13 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.93 2006/08/23 15:03:13 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 void c_excl (Char *);
124 static void 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 */
686
687 static void
688 c_excl(Char *p)
689 {
690 int i;
691 Char *q;
692
693 /*
694 * if />[SPC TAB]*![SPC TAB]/, back up p to just after the >. otherwise,
695 * back p up to just before the current word.
696 */
697 if ((p[1] == ' ' || p[1] == '\t') &&
698 (p[-1] == ' ' || p[-1] == '\t' || p[-1] == '>')) {
699 for (q = p - 1; q > InputBuf && (*q == ' ' || *q == '\t'); --q)
700 continue;
701 if (*q == '>')
702 ++p;
703 }
704 else {
705 while (*p != ' ' && *p != '\t' && p > InputBuf)
706 --p;
707 }
708
709 /*
710 * Forever: Look for history char. (Stop looking when we find the cursor.)
711 * Count backslashes. Of odd, skip history char. Return if all done.
712 * Expand if even number of backslashes.
713 */
714 for (;;) {
715 while (*p != HIST && p < Cursor)
716 ++p;
717 for (i = 1; (p - i) >= InputBuf && p[-i] == '\\'; i++)
718 continue;
719 if (i % 2 == 0)
720 ++p;
721 if (p >= Cursor)
722 return;
723 if (i % 2 == 1)
724 p = c_expand(p);
725 }
726 }
727
728
729 static void
730 c_substitute(void)
731 {
732 Char *p;
733
734 /*
735 * Start p out one character before the cursor. Move it backwards looking
736 * for white space, the beginning of the line, or a history character.
737 */
738 for (p = Cursor - 1;
739 p > InputBuf && *p != ' ' && *p != '\t' && *p != HIST; --p)
740 continue;
741
742 /*
743 * If we found a history character, go expand it.
744 */
745 if (*p == HIST)
746 c_excl(p);
747 Refresh();
748 }
749
750 static void
751 c_delfini(void) /* Finish up delete action */
752 {
753 int Size;
754
755 if (ActionFlag & TCSHOP_INSERT)
756 c_alternativ_key_map(0);
757
758 ActionFlag = TCSHOP_NOP;
759
760 if (ActionPos == 0)
761 return;
762
763 UndoAction = TCSHOP_INSERT;
764
765 if (Cursor > ActionPos) {
766 Size = (int) (Cursor-ActionPos);
767 c_delbefore(Size);
768 RefCursor();
769 }
770 else if (Cursor < ActionPos) {
771 Size = (int)(ActionPos-Cursor);
772 c_delafter(Size);
773 }
774 else {
775 Size = 1;
776 c_delafter(Size);
777 }
778 UndoPtr = Cursor;
779 UndoSize = Size;
780 }
781
782 static Char *
783 c_endword(Char *p, Char *high, int n, Char *delim)
784 {
785 Char inquote = 0;
786 p++;
787
788 while (n--) {
789 while (p < high) { /* Skip non-word chars */
790 if (!Strchr(delim, *p) || *(p-1) == (Char)'\\')
791 break;
792 p++;
793 }
794 while (p < high) { /* Skip string */
795 if ((*p == (Char)'\'' || *p == (Char)'"')) { /* Quotation marks? */
796 if (inquote || *(p-1) != (Char)'\\') { /* Should it be honored? */
797 if (inquote == 0) inquote = *p;
798 else if (inquote == *p) inquote = 0;
799 }
800 }
801 /* Break if unquoted non-word char */
802 if (!inquote && Strchr(delim, *p) && *(p-1) != (Char)'\\')
803 break;
804 p++;
805 }
806 }
807
808 p--;
809 return(p);
810 }
811
812
813 static Char *
814 c_eword(Char *p, Char *high, int n)
815 {
816 p++;
817
818 while (n--) {
819 while ((p < high) && Isspace(*p))
820 p++;
821
822 if (Isalnum(*p))
823 while ((p < high) && Isalnum(*p))
824 p++;
825 else
826 while ((p < high) && !(Isspace(*p) || Isalnum(*p)))
827 p++;
828 }
829
830 p--;
831 return(p);
832 }
833
834 /* Set the max length of the kill ring */
835 void
836 SetKillRing(int max)
837 {
838 CStr *new;
839 int count, i, j;
840
841 if (max < 1)
842 max = 1; /* no ring, but always one buffer */
843 if (max == KillRingMax)
844 return;
845 new = xcalloc(max, sizeof(CStr));
846 if (KillRing != NULL) {
847 if (KillRingLen != 0) {
848 if (max >= KillRingLen) {
849 count = KillRingLen;
850 j = KillPos;
851 } else {
852 count = max;
853 j = (KillPos - count + KillRingLen) % KillRingLen;
854 }
855 for (i = 0; i < KillRingLen; i++) {
856 if (i < count) /* copy latest */
857 new[i] = KillRing[j];
858 else /* free the others */
859 xfree(KillRing[j].buf);
860 j = (j + 1) % KillRingLen;
861 }
862 KillRingLen = count;
863 KillPos = count % max;
864 YankPos = count - 1;
865 }
866 xfree(KillRing);
867 }
868 KillRing = new;
869 KillRingMax = max;
870 }
871
872 /* Push string from start upto (but not including) end onto kill ring */
873 static void
874 c_push_kill(Char *start, Char *end)
875 {
876 CStr save, *pos;
877 Char *dp, *cp, *kp;
878 int len = end - start, i, j, k;
879
880 /* Check for duplicates? */
881 if (KillRingLen > 0 && (dp = varval(STRkilldup)) != STRNULL) {
882 YankPos = (KillPos - 1 + KillRingLen) % KillRingLen;
883 if (eq(dp, STRerase)) { /* erase earlier one (actually move up) */
884 j = YankPos;
885 for (i = 0; i < KillRingLen; i++) {
886 if (Strncmp(KillRing[j].buf, start, (size_t) len) == 0 &&
887 KillRing[j].buf[len] == '\0') {
888 save = KillRing[j];
889 for ( ; i > 0; i--) {
890 k = j;
891 j = (j + 1) % KillRingLen;
892 KillRing[k] = KillRing[j];
893 }
894 KillRing[j] = save;
895 return;
896 }
897 j = (j - 1 + KillRingLen) % KillRingLen;
898 }
899 } else if (eq(dp, STRall)) { /* skip if any earlier */
900 for (i = 0; i < KillRingLen; i++)
901 if (Strncmp(KillRing[i].buf, start, (size_t) len) == 0 &&
902 KillRing[i].buf[len] == '\0')
903 return;
904 } else if (eq(dp, STRprev)) { /* skip if immediately previous */
905 j = YankPos;
906 if (Strncmp(KillRing[j].buf, start, (size_t) len) == 0 &&
907 KillRing[j].buf[len] == '\0')
908 return;
909 }
910 }
911
912 /* No duplicate, go ahead and push */
913 len++; /* need space for '\0' */
914 YankPos = KillPos;
915 if (KillRingLen < KillRingMax)
916 KillRingLen++;
917 pos = &KillRing[KillPos];
918 KillPos = (KillPos + 1) % KillRingMax;
919 if (pos->len < len) {
920 pos->buf = xrealloc(pos->buf, len * sizeof(Char));
921 pos->len = len;
922 }
923 cp = start;
924 kp = pos->buf;
925 while (cp < end)
926 *kp++ = *cp++;
927 *kp = '\0';
928 }
929
930 /* Save InputBuf etc in SavedBuf etc for restore after cmd exec */
931 static void
932 c_save_inputbuf()
933 {
934 SavedBuf.len = 0;
935 Strbuf_append(&SavedBuf, InputBuf);
936 Strbuf_terminate(&SavedBuf);
937 LastSaved = LastChar - InputBuf;
938 CursSaved = Cursor - InputBuf;
939 HistSaved = Hist_num;
940 RestoreSaved = 1;
941 }
942
943 CCRETVAL
944 GetHistLine()
945 {
946 struct Hist *hp;
947 int h;
948
949 if (Hist_num == 0) { /* if really the current line */
950 if (HistBuf.s != NULL)
951 copyn(InputBuf, HistBuf.s, INBUFSIZE);/*FIXBUF*/
952 else
953 *InputBuf = '\0';
954 LastChar = InputBuf + HistBuf.len;
955
956 #ifdef KSHVI
957 if (VImode)
958 Cursor = InputBuf;
959 else
960 #endif /* KSHVI */
961 Cursor = LastChar;
962
963 return(CC_REFRESH);
964 }
965
966 hp = Histlist.Hnext;
967 if (hp == NULL)
968 return(CC_ERROR);
969
970 for (h = 1; h < Hist_num; h++) {
971 if ((hp->Hnext) == NULL) {
972 Hist_num = h;
973 return(CC_ERROR);
974 }
975 hp = hp->Hnext;
976 }
977
978 if (HistLit && hp->histline) {
979 copyn(InputBuf, hp->histline, INBUFSIZE);/*FIXBUF*/
980 CurrentHistLit = 1;
981 }
982 else {
983 Char *p;
984
985 p = sprlex(&hp->Hlex);
986 copyn(InputBuf, p, sizeof(InputBuf) / sizeof(Char));/*FIXBUF*/
987 xfree(p);
988 CurrentHistLit = 0;
989 }
990 LastChar = Strend(InputBuf);
991
992 if (LastChar > InputBuf) {
993 if (LastChar[-1] == '\n')
994 LastChar--;
995 #if 0
996 if (LastChar[-1] == ' ')
997 LastChar--;
998 #endif
999 if (LastChar < InputBuf)
1000 LastChar = InputBuf;
1001 }
1002
1003 #ifdef KSHVI
1004 if (VImode)
1005 Cursor = InputBuf;
1006 else
1007 #endif /* KSHVI */
1008 Cursor = LastChar;
1009
1010 return(CC_REFRESH);
1011 }
1012
1013 static CCRETVAL
1014 c_search_line(Char *pattern, int dir)
1015 {
1016 Char *cp;
1017 size_t len;
1018
1019 len = Strlen(pattern);
1020
1021 if (dir == F_UP_SEARCH_HIST) {
1022 for (cp = Cursor; cp >= InputBuf; cp--)
1023 if (Strncmp(cp, pattern, len) == 0 ||
1024 Gmatch(cp, pattern)) {
1025 Cursor = cp;
1026 return(CC_NORM);
1027 }
1028 return(CC_ERROR);
1029 } else {
1030 for (cp = Cursor; *cp != '\0' && cp < InputLim; cp++)
1031 if (Strncmp(cp, pattern, len) == 0 ||
1032 Gmatch(cp, pattern)) {
1033 Cursor = cp;
1034 return(CC_NORM);
1035 }
1036 return(CC_ERROR);
1037 }
1038 }
1039
1040 static CCRETVAL
1041 e_inc_search(int dir)
1042 {
1043 static const Char STRfwd[] = { 'f', 'w', 'd', '\0' },
1044 STRbck[] = { 'b', 'c', 'k', '\0' };
1045 static Char pchar = ':'; /* ':' = normal, '?' = failed */
1046 static Char endcmd[2];
1047 const Char *cp;
1048 Char ch,
1049 *oldCursor = Cursor,
1050 oldpchar = pchar;
1051 CCRETVAL ret = CC_NORM;
1052 int oldHist_num = Hist_num,
1053 oldpatlen = patbuf.len,
1054 newdir = dir,
1055 done, redo;
1056
1057 if (LastChar + sizeof(STRfwd)/sizeof(Char) + 2 + patbuf.len >= InputLim)
1058 return(CC_ERROR);
1059
1060 for (;;) {
1061
1062 if (patbuf.len == 0) { /* first round */
1063 pchar = ':';
1064 Strbuf_append1(&patbuf, '*');
1065 }
1066 done = redo = 0;
1067 *LastChar++ = '\n';
1068 for (cp = newdir == F_UP_SEARCH_HIST ? STRbck : STRfwd;
1069 *cp; *LastChar++ = *cp++)
1070 continue;
1071 *LastChar++ = pchar;
1072 for (cp = &patbuf.s[1]; cp < &patbuf.s[patbuf.len];
1073 *LastChar++ = *cp++)
1074 continue;
1075 *LastChar = '\0';
1076 if (adrof(STRhighlight) && pchar == ':') {
1077 /* if the no-glob-search patch is applied, remove the - 1 below */
1078 IncMatchLen = patbuf.len - 1;
1079 ClearLines();
1080 ClearDisp();
1081 }
1082 Refresh();
1083
1084 if (GetNextChar(&ch) != 1)
1085 return(e_send_eof(0));
1086
1087 switch (ch > NT_NUM_KEYS
1088 ? F_INSERT : CurrentKeyMap[(unsigned char) ch]) {
1089 case F_INSERT:
1090 case F_DIGIT:
1091 case F_MAGIC_SPACE:
1092 if (LastChar + 1 >= InputLim) /*FIXBUF*/
1093 SoundBeep();
1094 else {
1095 Strbuf_append1(&patbuf, ch);
1096 *LastChar++ = ch;
1097 *LastChar = '\0';
1098 Refresh();
1099 }
1100 break;
1101
1102 case F_INC_FWD:
1103 newdir = F_DOWN_SEARCH_HIST;
1104 redo++;
1105 break;
1106
1107 case F_INC_BACK:
1108 newdir = F_UP_SEARCH_HIST;
1109 redo++;
1110 break;
1111
1112 case F_DELPREV:
1113 if (patbuf.len > 1)
1114 done++;
1115 else
1116 SoundBeep();
1117 break;
1118
1119 default:
1120 switch (ASC(ch)) {
1121 case 0007: /* ^G: Abort */
1122 ret = CC_ERROR;
1123 done++;
1124 break;
1125
1126 case 0027: /* ^W: Append word */
1127 /* No can do if globbing characters in pattern */
1128 for (cp = &patbuf.s[1]; ; cp++)
1129 if (cp >= &patbuf.s[patbuf.len]) {
1130 Cursor += patbuf.len - 1;
1131 cp = c_next_word(Cursor, LastChar, 1);
1132 while (Cursor < cp && *Cursor != '\n') {
1133 if (LastChar + 1 >= InputLim) {/*FIXBUF*/
1134 SoundBeep();
1135 break;
1136 }
1137 Strbuf_append1(&patbuf, *Cursor);
1138 *LastChar++ = *Cursor++;
1139 }
1140 Cursor = oldCursor;
1141 *LastChar = '\0';
1142 Refresh();
1143 break;
1144 } else if (isglob(*cp)) {
1145 SoundBeep();
1146 break;
1147 }
1148 break;
1149
1150 default: /* Terminate and execute cmd */
1151 endcmd[0] = ch;
1152 PushMacro(endcmd);
1153 /*FALLTHROUGH*/
1154
1155 case 0033: /* ESC: Terminate */
1156 ret = CC_REFRESH;
1157 done++;
1158 break;
1159 }
1160 break;
1161 }
1162
1163 while (LastChar > InputBuf && *LastChar != '\n')
1164 *LastChar-- = '\0';
1165 *LastChar = '\0';
1166
1167 if (!done) {
1168
1169 /* Can't search if unmatched '[' */
1170 for (cp = &patbuf.s[patbuf.len - 1], ch = ']'; cp > patbuf.s; cp--)
1171 if (*cp == '[' || *cp == ']') {
1172 ch = *cp;
1173 break;
1174 }
1175
1176 if (patbuf.len > 1 && ch != '[') {
1177 if (redo && newdir == dir) {
1178 if (pchar == '?') { /* wrap around */
1179 Hist_num = newdir == F_UP_SEARCH_HIST ? 0 : INT_MAX;
1180 if (GetHistLine() == CC_ERROR)
1181 /* Hist_num was fixed by first call */
1182 (void) GetHistLine();
1183 Cursor = newdir == F_UP_SEARCH_HIST ?
1184 LastChar : InputBuf;
1185 } else
1186 Cursor += newdir == F_UP_SEARCH_HIST ? -1 : 1;
1187 }
1188 Strbuf_append1(&patbuf, '*');
1189 Strbuf_terminate(&patbuf);
1190 if (Cursor < InputBuf || Cursor > LastChar ||
1191 (ret = c_search_line(&patbuf.s[1], newdir)) == CC_ERROR) {
1192 LastCmd = (KEYCMD) newdir; /* avoid c_hsetpat */
1193 ret = newdir == F_UP_SEARCH_HIST ?
1194 e_up_search_hist(0) : e_down_search_hist(0);
1195 if (ret != CC_ERROR) {
1196 Cursor = newdir == F_UP_SEARCH_HIST ?
1197 LastChar : InputBuf;
1198 (void) c_search_line(&patbuf.s[1], newdir);
1199 }
1200 }
1201 patbuf.s[--patbuf.len] = '\0';
1202 if (ret == CC_ERROR) {
1203 SoundBeep();
1204 if (Hist_num != oldHist_num) {
1205 Hist_num = oldHist_num;
1206 if (GetHistLine() == CC_ERROR)
1207 return(CC_ERROR);
1208 }
1209 Cursor = oldCursor;
1210 pchar = '?';
1211 } else {
1212 pchar = ':';
1213 }
1214 }
1215
1216 ret = e_inc_search(newdir);
1217
1218 if (ret == CC_ERROR && pchar == '?' && oldpchar == ':') {
1219 /* break abort of failed search at last non-failed */
1220 ret = CC_NORM;
1221 }
1222
1223 }
1224
1225 if (ret == CC_NORM || (ret == CC_ERROR && oldpatlen == 0)) {
1226 /* restore on normal return or error exit */
1227 pchar = oldpchar;
1228 patbuf.len = oldpatlen;
1229 if (Hist_num != oldHist_num) {
1230 Hist_num = oldHist_num;
1231 if (GetHistLine() == CC_ERROR)
1232 return(CC_ERROR);
1233 }
1234 Cursor = oldCursor;
1235 if (ret == CC_ERROR)
1236 Refresh();
1237 }
1238 if (done || ret != CC_NORM)
1239 return(ret);
1240
1241 }
1242
1243 }
1244
1245 static CCRETVAL
1246 v_search(int dir)
1247 {
1248 struct Strbuf tmpbuf = Strbuf_INIT;
1249 Char ch;
1250 Char *oldbuf;
1251 Char *oldlc, *oldc;
1252
1253 cleanup_push(&tmpbuf, Strbuf_cleanup);
1254 oldbuf = Strsave(InputBuf);
1255 cleanup_push(oldbuf, xfree);
1256 oldlc = LastChar;
1257 oldc = Cursor;
1258 Strbuf_append1(&tmpbuf, '*');
1259
1260 InputBuf[0] = '\0';
1261 LastChar = InputBuf;
1262 Cursor = InputBuf;
1263 searchdir = dir;
1264
1265 c_insert(2); /* prompt + '\n' */
1266 *Cursor++ = '\n';
1267 *Cursor++ = dir == F_UP_SEARCH_HIST ? '?' : '/';
1268 Refresh();
1269 for (ch = 0;ch == 0;) {
1270 if (GetNextChar(&ch) != 1) {
1271 cleanup_until(&tmpbuf);
1272 return(e_send_eof(0));
1273 }
1274 switch (ASC(ch)) {
1275 case 0010: /* Delete and backspace */
1276 case 0177:
1277 if (tmpbuf.len > 1) {
1278 *Cursor-- = '\0';
1279 LastChar = Cursor;
1280 tmpbuf.len--;
1281 }
1282 else {
1283 copyn(InputBuf, oldbuf, INBUFSIZE);/*FIXBUF*/
1284 LastChar = oldlc;
1285 Cursor = oldc;
1286 cleanup_until(&tmpbuf);
1287 return(CC_REFRESH);
1288 }
1289 Refresh();
1290 ch = 0;
1291 break;
1292
1293 case 0033: /* ESC */
1294 #ifdef IS_ASCII
1295 case '\r': /* Newline */
1296 case '\n':
1297 #else
1298 case '\012': /* ASCII Line feed */
1299 case '\015': /* ASCII (or EBCDIC) Return */
1300 #endif
1301 break;
1302
1303 default:
1304 Strbuf_append1(&tmpbuf, ch);
1305 *Cursor++ = ch;
1306 LastChar = Cursor;
1307 Refresh();
1308 ch = 0;
1309 break;
1310 }
1311 }
1312 cleanup_until(oldbuf);
1313
1314 if (tmpbuf.len == 1) {
1315 /*
1316 * Use the old pattern, but wild-card it.
1317 */
1318 if (patbuf.len == 0) {
1319 InputBuf[0] = '\0';
1320 LastChar = InputBuf;
1321 Cursor = InputBuf;
1322 Refresh();
1323 cleanup_until(&tmpbuf);
1324 return(CC_ERROR);
1325 }
1326 if (patbuf.s[0] != '*') {
1327 oldbuf = Strsave(patbuf.s);
1328 patbuf.len = 0;
1329 Strbuf_append1(&patbuf, '*');
1330 Strbuf_append(&patbuf, oldbuf);
1331 xfree(oldbuf);
1332 Strbuf_append1(&patbuf, '*');
1333 Strbuf_terminate(&patbuf);
1334 }
1335 }
1336 else {
1337 Strbuf_append1(&tmpbuf, '*');
1338 Strbuf_terminate(&tmpbuf);
1339 patbuf.len = 0;
1340 Strbuf_append(&patbuf, tmpbuf.s);
1341 Strbuf_terminate(&patbuf);
1342 }
1343 cleanup_until(&tmpbuf);
1344 LastCmd = (KEYCMD) dir; /* avoid c_hsetpat */
1345 Cursor = LastChar = InputBuf;
1346 if ((dir == F_UP_SEARCH_HIST ? e_up_search_hist(0) :
1347 e_down_search_hist(0)) == CC_ERROR) {
1348 Refresh();
1349 return(CC_ERROR);
1350 }
1351 else {
1352 if (ASC(ch) == 0033) {
1353 Refresh();
1354 *LastChar++ = '\n';
1355 *LastChar = '\0';
1356 PastBottom();
1357 return(CC_NEWLINE);
1358 }
1359 else
1360 return(CC_REFRESH);
1361 }
1362 }
1363
1364 /*
1365 * semi-PUBLIC routines. Any routine that is of type CCRETVAL is an
1366 * entry point, called from the CcKeyMap indirected into the
1367 * CcFuncTbl array.
1368 */
1369
1370 /*ARGSUSED*/
1371 CCRETVAL
1372 v_cmd_mode(Char c)
1373 {
1374 USE(c);
1375 InsertPos = 0;
1376 ActionFlag = TCSHOP_NOP; /* [Esc] cancels pending action */
1377 ActionPos = 0;
1378 DoingArg = 0;
1379 if (UndoPtr > Cursor)
1380 UndoSize = (int)(UndoPtr - Cursor);
1381 else
1382 UndoSize = (int)(Cursor - UndoPtr);
1383
1384 inputmode = MODE_INSERT;
1385 c_alternativ_key_map(1);
1386 #ifdef notdef
1387 /*
1388 * We don't want to move the cursor, because all the editing
1389 * commands don't include the character under the cursor.
1390 */
1391 if (Cursor > InputBuf)
1392 Cursor--;
1393 #endif
1394 RefCursor();
1395 return(CC_NORM);
1396 }
1397
1398 /*ARGSUSED*/
1399 CCRETVAL
1400 e_unassigned(Char c)
1401 { /* bound to keys that arn't really assigned */
1402 USE(c);
1403 SoundBeep();
1404 flush();
1405 return(CC_NORM);
1406 }
1407
1408 #ifdef notyet
1409 static CCRETVAL
1410 e_insert_str(Char *c)
1411 {
1412 int i, n;
1413
1414 n = Strlen(c);
1415 if (LastChar + Argument * n >= InputLim)
1416 return(CC_ERROR); /* end of buffer space */
1417 if (inputmode != MODE_INSERT) {
1418 c_delafter(Argument * Strlen(c));
1419 }
1420 c_insert(Argument * n);
1421 while (Argument--) {
1422 for (i = 0; i < n; i++)
1423 *Cursor++ = c[i];
1424 }
1425 Refresh();
1426 return(CC_NORM);
1427 }
1428 #endif
1429
1430 CCRETVAL
1431 e_insert(Char c)
1432 {
1433 #ifndef SHORT_STRINGS
1434 c &= ASCII; /* no meta chars ever */
1435 #endif
1436
1437 if (!c)
1438 return(CC_ERROR); /* no NULs in the input ever!! */
1439
1440 if (LastChar + Argument >= InputLim)
1441 return(CC_ERROR); /* end of buffer space */
1442
1443 if (Argument == 1) { /* How was this optimized ???? */
1444
1445 if (inputmode != MODE_INSERT) {
1446 UndoBuf[UndoSize++] = *Cursor;
1447 UndoBuf[UndoSize] = '\0';
1448 c_delafter(1); /* Do NOT use the saving ONE */
1449 }
1450
1451 c_insert(1);
1452 *Cursor++ = (Char) c;
1453 DoingArg = 0; /* just in case */
1454 RefPlusOne(1); /* fast refresh for one char. */
1455 }
1456 else {
1457 if (inputmode != MODE_INSERT) {
1458 int i;
1459 for(i = 0; i < Argument; i++)
1460 UndoBuf[UndoSize++] = *(Cursor + i);
1461
1462 UndoBuf[UndoSize] = '\0';
1463 c_delafter(Argument); /* Do NOT use the saving ONE */
1464 }
1465
1466 c_insert(Argument);
1467
1468 while (Argument--)
1469 *Cursor++ = (Char) c;
1470 Refresh();
1471 }
1472
1473 if (inputmode == MODE_REPLACE_1)
1474 (void) v_cmd_mode(0);
1475
1476 return(CC_NORM);
1477 }
1478
1479 int
1480 InsertStr(Char *s) /* insert ASCIZ s at cursor (for complete) */
1481 {
1482 int len;
1483
1484 if ((len = (int) Strlen(s)) <= 0)
1485 return -1;
1486 if (LastChar + len >= InputLim)
1487 return -1; /* end of buffer space */
1488
1489 c_insert(len);
1490 while (len--)
1491 *Cursor++ = *s++;
1492 return 0;
1493 }
1494
1495 void
1496 DeleteBack(int n) /* delete the n characters before . */
1497 {
1498 if (n <= 0)
1499 return;
1500 if (Cursor >= &InputBuf[n]) {
1501 c_delbefore(n); /* delete before dot */
1502 }
1503 }
1504
1505 CCRETVAL
1506 e_digit(Char c) /* gray magic here */
1507 {
1508 if (!Isdigit(c))
1509 return(CC_ERROR); /* no NULs in the input ever!! */
1510
1511 if (DoingArg) { /* if doing an arg, add this in... */
1512 if (LastCmd == F_ARGFOUR) /* if last command was ^U */
1513 Argument = c - '0';
1514 else {
1515 if (Argument > 1000000)
1516 return CC_ERROR;
1517 Argument = (Argument * 10) + (c - '0');
1518 }
1519 return(CC_ARGHACK);
1520 }
1521 else {
1522 if (LastChar + 1 >= InputLim)
1523 return CC_ERROR; /* end of buffer space */
1524
1525 if (inputmode != MODE_INSERT) {
1526 UndoBuf[UndoSize++] = *Cursor;
1527 UndoBuf[UndoSize] = '\0';
1528 c_delafter(1); /* Do NOT use the saving ONE */
1529 }
1530 c_insert(1);
1531 *Cursor++ = (Char) c;
1532 DoingArg = 0; /* just in case */
1533 RefPlusOne(1); /* fast refresh for one char. */
1534 }
1535 return(CC_NORM);
1536 }
1537
1538 CCRETVAL
1539 e_argdigit(Char c) /* for ESC-n */
1540 {
1541 #ifdef IS_ASCII
1542 c &= ASCII;
1543 #else
1544 c = CTL_ESC(ASC(c) & ASCII); /* stripping for EBCDIC done the ASCII way */
1545 #endif
1546
1547 if (!Isdigit(c))
1548 return(CC_ERROR); /* no NULs in the input ever!! */
1549
1550 if (DoingArg) { /* if doing an arg, add this in... */
1551 if (Argument > 1000000)
1552 return CC_ERROR;
1553 Argument = (Argument * 10) + (c - '0');
1554 }
1555 else { /* else starting an argument */
1556 Argument = c - '0';
1557 DoingArg = 1;
1558 }
1559 return(CC_ARGHACK);
1560 }
1561
1562 CCRETVAL
1563 v_zero(Char c) /* command mode 0 for vi */
1564 {
1565 if (DoingArg) { /* if doing an arg, add this in... */
1566 if (Argument > 1000000)
1567 return CC_ERROR;
1568 Argument = (Argument * 10) + (c - '0');
1569 return(CC_ARGHACK);
1570 }
1571 else { /* else starting an argument */
1572 Cursor = InputBuf;
1573 if (ActionFlag & TCSHOP_DELETE) {
1574 c_delfini();
1575 return(CC_REFRESH);
1576 }
1577 RefCursor(); /* move the cursor */
1578 return(CC_NORM);
1579 }
1580 }
1581
1582 /*ARGSUSED*/
1583 CCRETVAL
1584 e_newline(Char c)
1585 { /* always ignore argument */
1586 USE(c);
1587 if (adrof(STRhighlight) && MarkIsSet) {
1588 MarkIsSet = 0;
1589 ClearLines();
1590 ClearDisp();
1591 Refresh();
1592 }
1593 MarkIsSet = 0;
1594
1595 /* PastBottom(); NOW done in ed.inputl.c */
1596 *LastChar++ = '\n'; /* for the benefit of CSH */
1597 *LastChar = '\0'; /* just in case */
1598 if (VImode)
1599 InsertPos = InputBuf; /* Reset editing position */
1600 return(CC_NEWLINE);
1601 }
1602
1603 /*ARGSUSED*/
1604 CCRETVAL
1605 e_newline_hold(Char c)
1606 {
1607 USE(c);
1608 c_save_inputbuf();
1609 HistSaved = 0;
1610 *LastChar++ = '\n'; /* for the benefit of CSH */
1611 *LastChar = '\0'; /* just in case */
1612 return(CC_NEWLINE);
1613 }
1614
1615 /*ARGSUSED*/
1616 CCRETVAL
1617 e_newline_down_hist(Char c)
1618 {
1619 USE(c);
1620 if (Hist_num > 1) {
1621 HistSaved = Hist_num;
1622 }
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_send_eof(Char c)
1631 { /* for when ^D is ONLY send-eof */
1632 USE(c);
1633 PastBottom();
1634 *LastChar = '\0'; /* just in case */
1635 return(CC_EOF);
1636 }
1637
1638 /*ARGSUSED*/
1639 CCRETVAL
1640 e_complete(Char c)
1641 {
1642 USE(c);
1643 *LastChar = '\0'; /* just in case */
1644 return(CC_COMPLETE);
1645 }
1646
1647 /*ARGSUSED*/
1648 CCRETVAL
1649 e_complete_back(Char c)
1650 {
1651 USE(c);
1652 *LastChar = '\0'; /* just in case */
1653 return(CC_COMPLETE_BACK);
1654 }
1655
1656 /*ARGSUSED*/
1657 CCRETVAL
1658 e_complete_fwd(Char c)
1659 {
1660 USE(c);
1661 *LastChar = '\0'; /* just in case */
1662 return(CC_COMPLETE_FWD);
1663 }
1664
1665 /*ARGSUSED*/
1666 CCRETVAL
1667 e_complete_all(Char c)
1668 {
1669 USE(c);
1670 *LastChar = '\0'; /* just in case */
1671 return(CC_COMPLETE_ALL);
1672 }
1673
1674 /*ARGSUSED*/
1675 CCRETVAL
1676 v_cm_complete(Char c)
1677 {
1678 USE(c);
1679 if (Cursor < LastChar)
1680 Cursor++;
1681 *LastChar = '\0'; /* just in case */
1682 return(CC_COMPLETE);
1683 }
1684
1685 /*ARGSUSED*/
1686 CCRETVAL
1687 e_toggle_hist(Char c)
1688 {
1689 struct Hist *hp;
1690 int h;
1691
1692 USE(c);
1693 *LastChar = '\0'; /* just in case */
1694
1695 if (Hist_num <= 0) {
1696 return CC_ERROR;
1697 }
1698
1699 hp = Histlist.Hnext;
1700 if (hp == NULL) { /* this is only if no history */
1701 return(CC_ERROR);
1702 }
1703
1704 for (h = 1; h < Hist_num; h++)
1705 hp = hp->Hnext;
1706
1707 if (!CurrentHistLit) {
1708 if (hp->histline) {
1709 copyn(InputBuf, hp->histline, INBUFSIZE);/*FIXBUF*/
1710 CurrentHistLit = 1;
1711 }
1712 else {
1713 return CC_ERROR;
1714 }
1715 }
1716 else {
1717 Char *p;
1718
1719 p = sprlex(&hp->Hlex);
1720 copyn(InputBuf, p, sizeof(InputBuf) / sizeof(Char));/*FIXBUF*/
1721 xfree(p);
1722 CurrentHistLit = 0;
1723 }
1724
1725 LastChar = Strend(InputBuf);
1726 if (LastChar > InputBuf) {
1727 if (LastChar[-1] == '\n')
1728 LastChar--;
1729 if (LastChar[-1] == ' ')
1730 LastChar--;
1731 if (LastChar < InputBuf)
1732 LastChar = InputBuf;
1733 }
1734
1735 #ifdef KSHVI
1736 if (VImode)
1737 Cursor = InputBuf;
1738 else
1739 #endif /* KSHVI */
1740 Cursor = LastChar;
1741
1742 return(CC_REFRESH);
1743 }
1744
1745 /*ARGSUSED*/
1746 CCRETVAL
1747 e_up_hist(Char c)
1748 {
1749 Char beep = 0;
1750
1751 USE(c);
1752 UndoAction = TCSHOP_NOP;
1753 *LastChar = '\0'; /* just in case */
1754
1755 if (Hist_num == 0) { /* save the current buffer away */
1756 HistBuf.len = 0;
1757 Strbuf_append(&HistBuf, InputBuf);
1758 Strbuf_terminate(&HistBuf);
1759 }
1760
1761 Hist_num += Argument;
1762
1763 if (GetHistLine() == CC_ERROR) {
1764 beep = 1;
1765 (void) GetHistLine(); /* Hist_num was fixed by first call */
1766 }
1767
1768 Refresh();
1769 if (beep)
1770 return(CC_ERROR);
1771 else
1772 return(CC_NORM); /* was CC_UP_HIST */
1773 }
1774
1775 /*ARGSUSED*/
1776 CCRETVAL
1777 e_down_hist(Char c)
1778 {
1779 USE(c);
1780 UndoAction = TCSHOP_NOP;
1781 *LastChar = '\0'; /* just in case */
1782
1783 Hist_num -= Argument;
1784
1785 if (Hist_num < 0) {
1786 Hist_num = 0;
1787 return(CC_ERROR); /* make it beep */
1788 }
1789
1790 return(GetHistLine());
1791 }
1792
1793
1794
1795 /*
1796 * c_hmatch() return True if the pattern matches the prefix
1797 */
1798 static int
1799 c_hmatch(Char *str)
1800 {
1801 if (Strncmp(patbuf.s, str, patbuf.len) == 0)
1802 return 1;
1803 return Gmatch(str, patbuf.s);
1804 }
1805
1806 /*
1807 * c_hsetpat(): Set the history seatch pattern
1808 */
1809 static void
1810 c_hsetpat(void)
1811 {
1812 if (LastCmd != F_UP_SEARCH_HIST && LastCmd != F_DOWN_SEARCH_HIST) {
1813 patbuf.len = 0;
1814 Strbuf_appendn(&patbuf, InputBuf, Cursor - InputBuf);
1815 Strbuf_terminate(&patbuf);
1816 }
1817 #ifdef SDEBUG
1818 xprintf("\nHist_num = %d\n", Hist_num);
1819 xprintf("patlen = %d\n", (int)patbuf.len);
1820 xprintf("patbuf = \"%S\"\n", patbuf.s);
1821 xprintf("Cursor %d LastChar %d\n", Cursor - InputBuf, LastChar - InputBuf);
1822 #endif
1823 }
1824
1825 /*ARGSUSED*/
1826 CCRETVAL
1827 e_up_search_hist(Char c)
1828 {
1829 struct Hist *hp;
1830 int h;
1831 int found = 0;
1832
1833 USE(c);
1834 ActionFlag = TCSHOP_NOP;
1835 UndoAction = TCSHOP_NOP;
1836 *LastChar = '\0'; /* just in case */
1837 if (Hist_num < 0) {
1838 #ifdef DEBUG_EDIT
1839 xprintf("%s: e_up_search_hist(): Hist_num < 0; resetting.\n", progname);
1840 #endif
1841 Hist_num = 0;
1842 return(CC_ERROR);
1843 }
1844
1845 if (Hist_num == 0) {
1846 HistBuf.len = 0;
1847 Strbuf_append(&HistBuf, InputBuf);
1848 Strbuf_terminate(&HistBuf);
1849 }
1850
1851
1852 hp = Histlist.Hnext;
1853 if (hp == NULL)
1854 return(CC_ERROR);
1855
1856 c_hsetpat(); /* Set search pattern !! */
1857
1858 for (h = 1; h <= Hist_num; h++)
1859 hp = hp->Hnext;
1860
1861 while (hp != NULL) {
1862 Char *hl;
1863 int matched;
1864
1865 if (hp->histline == NULL)
1866 hp->histline = sprlex(&hp->Hlex);
1867 if (HistLit)
1868 hl = hp->histline;
1869 else {
1870 hl = sprlex(&hp->Hlex);
1871 cleanup_push(hl, xfree);
1872 }
1873 #ifdef SDEBUG
1874 xprintf("Comparing with \"%S\"\n", hl);
1875 #endif
1876 matched = (Strncmp(hl, InputBuf, (size_t) (LastChar - InputBuf)) ||
1877 hl[LastChar-InputBuf]) && c_hmatch(hl);
1878 if (!HistLit)
1879 cleanup_until(hl);
1880 if (matched) {
1881 found++;
1882 break;
1883 }
1884 h++;
1885 hp = hp->Hnext;
1886 }
1887
1888 if (!found) {
1889 #ifdef SDEBUG
1890 xprintf("not found\n");
1891 #endif
1892 return(CC_ERROR);
1893 }
1894
1895 Hist_num = h;
1896
1897 return(GetHistLine());
1898 }
1899
1900 /*ARGSUSED*/
1901 CCRETVAL
1902 e_down_search_hist(Char c)
1903 {
1904 struct Hist *hp;
1905 int h;
1906 int found = 0;
1907
1908 USE(c);
1909 ActionFlag = TCSHOP_NOP;
1910 UndoAction = TCSHOP_NOP;
1911 *LastChar = '\0'; /* just in case */
1912
1913 if (Hist_num == 0)
1914 return(CC_ERROR);
1915
1916 hp = Histlist.Hnext;
1917 if (hp == 0)
1918 return(CC_ERROR);
1919
1920 c_hsetpat(); /* Set search pattern !! */
1921
1922 for (h = 1; h < Hist_num && hp; h++) {
1923 Char *hl;
1924 if (hp->histline == NULL)
1925 hp->histline = sprlex(&hp->Hlex);
1926 if (HistLit)
1927 hl = hp->histline;
1928 else {
1929 hl = sprlex(&hp->Hlex);
1930 cleanup_push(hl, xfree);
1931 }
1932 #ifdef SDEBUG
1933 xprintf("Comparing with \"%S\"\n", hl);
1934 #endif
1935 if ((Strncmp(hl, InputBuf, (size_t) (LastChar - InputBuf)) ||
1936 hl[LastChar-InputBuf]) && c_hmatch(hl))
1937 found = h;
1938 if (!HistLit)
1939 cleanup_until(hl);
1940 hp = hp->Hnext;
1941 }
1942
1943 if (!found) { /* is it the current history number? */
1944 if (!c_hmatch(HistBuf.s)) {
1945 #ifdef SDEBUG
1946 xprintf("not found\n");
1947 #endif
1948 return(CC_ERROR);
1949 }
1950 }
1951
1952 Hist_num = found;
1953
1954 return(GetHistLine());
1955 }
1956
1957 /*ARGSUSED*/
1958 CCRETVAL
1959 e_helpme(Char c)
1960 {
1961 USE(c);
1962 PastBottom();
1963 *LastChar = '\0'; /* just in case */
1964 return(CC_HELPME);
1965 }
1966
1967 /*ARGSUSED*/
1968 CCRETVAL
1969 e_correct(Char c)
1970 {
1971 USE(c);
1972 *LastChar = '\0'; /* just in case */
1973 return(CC_CORRECT);
1974 }
1975
1976 /*ARGSUSED*/
1977 CCRETVAL
1978 e_correctl(Char c)
1979 {
1980 USE(c);
1981 *LastChar = '\0'; /* just in case */
1982 return(CC_CORRECT_L);
1983 }
1984
1985 /*ARGSUSED*/
1986 CCRETVAL
1987 e_run_fg_editor(Char c)
1988 {
1989 struct process *pp;
1990
1991 USE(c);
1992 if ((pp = find_stop_ed()) != NULL) {
1993 /* save our editor state so we can restore it */
1994 c_save_inputbuf();
1995 Hist_num = 0; /* for the history commands */
1996
1997 /* put the tty in a sane mode */
1998 PastBottom();
1999 (void) Cookedmode(); /* make sure the tty is set up correctly */
2000
2001 /* do it! */
2002 fg_proc_entry(pp);
2003
2004 (void) Rawmode(); /* go on */
2005 Refresh();
2006 RestoreSaved = 0;
2007 HistSaved = 0;
2008 }
2009 return(CC_NORM);
2010 }
2011
2012 /*ARGSUSED*/
2013 CCRETVAL
2014 e_list_choices(Char c)
2015 {
2016 USE(c);
2017 PastBottom();
2018 *LastChar = '\0'; /* just in case */
2019 return(CC_LIST_CHOICES);
2020 }
2021
2022 /*ARGSUSED*/
2023 CCRETVAL
2024 e_list_all(Char c)
2025 {
2026 USE(c);
2027 PastBottom();
2028 *LastChar = '\0'; /* just in case */
2029 return(CC_LIST_ALL);
2030 }
2031
2032 /*ARGSUSED*/
2033 CCRETVAL
2034 e_list_glob(Char c)
2035 {
2036 USE(c);
2037 PastBottom();
2038 *LastChar = '\0'; /* just in case */
2039 return(CC_LIST_GLOB);
2040 }
2041
2042 /*ARGSUSED*/
2043 CCRETVAL
2044 e_expand_glob(Char c)
2045 {
2046 USE(c);
2047 *LastChar = '\0'; /* just in case */
2048 return(CC_EXPAND_GLOB);
2049 }
2050
2051 /*ARGSUSED*/
2052 CCRETVAL
2053 e_normalize_path(Char c)
2054 {
2055 USE(c);
2056 *LastChar = '\0'; /* just in case */
2057 return(CC_NORMALIZE_PATH);
2058 }
2059
2060 /*ARGSUSED*/
2061 CCRETVAL
2062 e_normalize_command(Char c)
2063 {
2064 USE(c);
2065 *LastChar = '\0'; /* just in case */
2066 return(CC_NORMALIZE_COMMAND);
2067 }
2068
2069 /*ARGSUSED*/
2070 CCRETVAL
2071 e_expand_vars(Char c)
2072 {
2073 USE(c);
2074 *LastChar = '\0'; /* just in case */
2075 return(CC_EXPAND_VARS);
2076 }
2077
2078 /*ARGSUSED*/
2079 CCRETVAL
2080 e_which(Char c)
2081 { /* do a fast command line which(1) */
2082 USE(c);
2083 c_save_inputbuf();
2084 Hist_num = 0; /* for the history commands */
2085 PastBottom();
2086 *LastChar = '\0'; /* just in case */
2087 return(CC_WHICH);
2088 }
2089
2090 /*ARGSUSED*/
2091 CCRETVAL
2092 e_last_item(Char c)
2093 { /* insert the last element of the prev. cmd */
2094 struct Hist *hp;
2095 struct wordent *wp, *firstp;
2096 int i;
2097 Char *expanded;
2098
2099 USE(c);
2100 if (Argument <= 0)
2101 return(CC_ERROR);
2102
2103 hp = Histlist.Hnext;
2104 if (hp == NULL) { /* this is only if no history */
2105 return(CC_ERROR);
2106 }
2107
2108 wp = (hp->Hlex).prev;
2109
2110 if (wp->prev == (struct wordent *) NULL)
2111 return(CC_ERROR); /* an empty history entry */
2112
2113 firstp = (hp->Hlex).next;
2114
2115 /* back up arg words in lex */
2116 for (i = 0; i < Argument && wp != firstp; i++) {
2117 wp = wp->prev;
2118 }
2119
2120 expanded = expand_lex(wp->prev, 0, i - 1);
2121 if (InsertStr(expanded)) {
2122 xfree(expanded);
2123 return(CC_ERROR);
2124 }
2125
2126 xfree(expanded);
2127 return(CC_REFRESH);
2128 }
2129
2130 /*ARGSUSED*/
2131 CCRETVAL
2132 e_dabbrev_expand(Char c)
2133 { /* expand to preceding word matching prefix */
2134 Char *cp, *ncp, *bp;
2135 struct Hist *hp;
2136 int arg = 0, i;
2137 size_t len = 0;
2138 int found = 0;
2139 Char *hbuf;
2140 static int oldevent, hist, word;
2141 static Char *start, *oldcursor;
2142
2143 USE(c);
2144 if (Argument <= 0)
2145 return(CC_ERROR);
2146
2147 cp = c_preword(Cursor, InputBuf, 1, STRshwordsep);
2148 if (cp == Cursor || Isspace(*cp))
2149 return(CC_ERROR);
2150
2151 hbuf = NULL;
2152 hp = Histlist.Hnext;
2153 bp = InputBuf;
2154 if (Argument == 1 && eventno == oldevent && cp == start &&
2155 Cursor == oldcursor && patbuf.len > 0
2156 && Strncmp(patbuf.s, cp, patbuf.len) == 0){
2157 /* continue previous search - go to last match (hist/word) */
2158 if (hist != 0) { /* need to move up history */
2159 for (i = 1; i < hist && hp != NULL; i++)
2160 hp = hp->Hnext;
2161 if (hp == NULL) /* "can't happen" */
2162 goto err_hbuf;
2163 hbuf = expand_lex(&hp->Hlex, 0, INT_MAX);
2164 cp = Strend(hbuf);
2165 bp = hbuf;
2166 hp = hp->Hnext;
2167 }
2168 cp = c_preword(cp, bp, word, STRshwordsep);
2169 } else { /* starting new search */
2170 oldevent = eventno;
2171 start = cp;
2172 patbuf.len = 0;
2173 Strbuf_appendn(&patbuf, cp, Cursor - cp);
2174 hist = 0;
2175 word = 0;
2176 }
2177
2178 while (!found) {
2179 ncp = c_preword(cp, bp, 1, STRshwordsep);
2180 if (ncp == cp || Isspace(*ncp)) { /* beginning of line */
2181 hist++;
2182 word = 0;
2183 if (hp == NULL)
2184 goto err_hbuf;
2185 hbuf = expand_lex(&hp->Hlex, 0, INT_MAX);
2186 cp = Strend(hbuf);
2187 bp = hbuf;
2188 hp = hp->Hnext;
2189 continue;
2190 } else {
2191 word++;
2192 len = c_endword(ncp-1, cp, 1, STRshwordsep) - ncp + 1;
2193 cp = ncp;
2194 }
2195 if (len > patbuf.len && Strncmp(cp, patbuf.s, patbuf.len) == 0) {
2196 /* We don't fully check distinct matches as Gnuemacs does: */
2197 if (Argument > 1) { /* just count matches */
2198 if (++arg >= Argument)
2199 found++;
2200 } else { /* match if distinct from previous */
2201 if (len != (size_t)(Cursor - start)
2202 || Strncmp(cp, start, len) != 0)
2203 found++;
2204 }
2205 }
2206 }
2207
2208 if (LastChar + len - (Cursor - start) >= InputLim)
2209 goto err_hbuf; /* no room */
2210 DeleteBack(Cursor - start);
2211 c_insert(len);
2212 while (len--)
2213 *Cursor++ = *cp++;
2214 oldcursor = Cursor;
2215 xfree(hbuf);
2216 return(CC_REFRESH);
2217
2218 err_hbuf:
2219 xfree(hbuf);
2220 return CC_ERROR;
2221 }
2222
2223 /*ARGSUSED*/
2224 CCRETVAL
2225 e_yank_kill(Char c)
2226 { /* almost like GnuEmacs */
2227 int len;
2228 Char *kp, *cp;
2229
2230 USE(c);
2231 if (KillRingLen == 0) /* nothing killed */
2232 return(CC_ERROR);
2233 len = Strlen(KillRing[YankPos].buf);
2234 if (LastChar + len >= InputLim)
2235 return(CC_ERROR); /* end of buffer space */
2236
2237 /* else */
2238 cp = Cursor; /* for speed */
2239
2240 c_insert(len); /* open the space, */
2241 for (kp = KillRing[YankPos].buf; *kp; kp++) /* copy the chars */
2242 *cp++ = *kp;
2243
2244 if (Argument == 1) { /* if no arg */
2245 Mark = Cursor; /* mark at beginning, cursor at end */
2246 Cursor = cp;
2247 } else {
2248 Mark = cp; /* else cursor at beginning, mark at end */
2249 }
2250
2251 if (adrof(STRhighlight) && MarkIsSet) {
2252 ClearLines();
2253 ClearDisp();
2254 }
2255 MarkIsSet = 0;
2256 return(CC_REFRESH);
2257 }
2258
2259 /*ARGSUSED*/
2260 CCRETVAL
2261 e_yank_pop(Char c)
2262 { /* almost like GnuEmacs */
2263 int m_bef_c, del_len, ins_len;
2264 Char *kp, *cp;
2265
2266 USE(c);
2267
2268 #if 0
2269 /* XXX This "should" be here, but doesn't work, since LastCmd
2270 gets set on CC_ERROR and CC_ARGHACK, which it shouldn't(?).
2271 (But what about F_ARGFOUR?) I.e. if you hit M-y twice the
2272 second one will "succeed" even if the first one wasn't preceded
2273 by a yank, and giving an argument is impossible. Now we "succeed"
2274 regardless of previous command, which is wrong too of course. */
2275 if (LastCmd != F_YANK_KILL && LastCmd != F_YANK_POP)
2276 return(CC_ERROR);
2277 #endif
2278
2279 if (KillRingLen == 0) /* nothing killed */
2280 return(CC_ERROR);
2281 YankPos -= Argument;
2282 while (YankPos < 0)
2283 YankPos += KillRingLen;
2284 YankPos %= KillRingLen;
2285
2286 if (Cursor > Mark) {
2287 del_len = Cursor - Mark;
2288 m_bef_c = 1;
2289 } else {
2290 del_len = Mark - Cursor;
2291 m_bef_c = 0;
2292 }
2293 ins_len = Strlen(KillRing[YankPos].buf);
2294 if (LastChar + ins_len - del_len >= InputLim)
2295 return(CC_ERROR); /* end of buffer space */
2296
2297 if (m_bef_c) {
2298 c_delbefore(del_len);
2299 } else {
2300 c_delafter(del_len);
2301 }
2302 cp = Cursor; /* for speed */
2303
2304 c_insert(ins_len); /* open the space, */
2305 for (kp = KillRing[YankPos].buf; *kp; kp++) /* copy the chars */
2306 *cp++ = *kp;
2307
2308 if (m_bef_c) {
2309 Mark = Cursor; /* mark at beginning, cursor at end */
2310 Cursor = cp;
2311 } else {
2312 Mark = cp; /* else cursor at beginning, mark at end */
2313 }
2314
2315 if (adrof(STRhighlight) && MarkIsSet) {
2316 ClearLines();
2317 ClearDisp();
2318 }
2319 MarkIsSet = 0;
2320 return(CC_REFRESH);
2321 }
2322
2323 /*ARGSUSED*/
2324 CCRETVAL
2325 v_delprev(Char c) /* Backspace key in insert mode */
2326 {
2327 int rc;
2328
2329 USE(c);
2330 rc = CC_ERROR;
2331
2332 if (InsertPos != 0) {
2333 if (Argument <= Cursor - InsertPos) {
2334 c_delbefore(Argument); /* delete before */
2335 rc = CC_REFRESH;
2336 }
2337 }
2338 return(rc);
2339 } /* v_delprev */
2340
2341 /*ARGSUSED*/
2342 CCRETVAL
2343 e_delprev(Char c)
2344 {
2345 USE(c);
2346 if (Cursor > InputBuf) {
2347 c_delbefore(Argument); /* delete before dot */
2348 return(CC_REFRESH);
2349 }
2350 else {
2351 return(CC_ERROR);
2352 }
2353 }
2354
2355 /*ARGSUSED*/
2356 CCRETVAL
2357 e_delwordprev(Char c)
2358 {
2359 Char *cp;
2360
2361 USE(c);
2362 if (Cursor == InputBuf)
2363 return(CC_ERROR);
2364 /* else */
2365
2366 cp = c_prev_word(Cursor, InputBuf, Argument);
2367
2368 c_push_kill(cp, Cursor); /* save the text */
2369
2370 c_delbefore((int)(Cursor - cp)); /* delete before dot */
2371 return(CC_REFRESH);
2372 }
2373
2374 /* DCS <dcs@neutron.chem.yale.edu>, 9 Oct 93
2375 *
2376 * Changed the names of some of the ^D family of editor functions to
2377 * correspond to what they actually do and created new e_delnext_list
2378 * for completeness.
2379 *
2380 * Old names: New names:
2381 *
2382 * delete-char delete-char-or-eof
2383 * F_DELNEXT F_DELNEXT_EOF
2384 * e_delnext e_delnext_eof
2385 * edelnxt edelnxteof
2386 * delete-char-or-eof delete-char
2387 * F_DELNEXT_EOF F_DELNEXT
2388 * e_delnext_eof e_delnext
2389 * edelnxteof edelnxt
2390 * delete-char-or-list delete-char-or-list-or-eof
2391 * F_LIST_DELNEXT F_DELNEXT_LIST_EOF
2392 * e_list_delnext e_delnext_list_eof
2393 * edellsteof
2394 * (no old equivalent) delete-char-or-list
2395 * F_DELNEXT_LIST
2396 * e_delnext_list
2397 * e_delnxtlst
2398 */
2399
2400 /* added by mtk@ari.ncl.omron.co.jp (920818) */
2401 /* rename e_delnext() -> e_delnext_eof() */
2402 /*ARGSUSED*/
2403 CCRETVAL
2404 e_delnext(Char c)
2405 {
2406 USE(c);
2407 if (Cursor == LastChar) {/* if I'm at the end */
2408 if (!VImode) {
2409 return(CC_ERROR);
2410 }
2411 else {
2412 if (Cursor != InputBuf)
2413 Cursor--;
2414 else
2415 return(CC_ERROR);
2416 }
2417 }
2418 c_delafter(Argument); /* delete after dot */
2419 if (Cursor > LastChar)
2420 Cursor = LastChar; /* bounds check */
2421 return(CC_REFRESH);
2422 }
2423
2424
2425 /*ARGSUSED*/
2426 CCRETVAL
2427 e_delnext_eof(Char c)
2428 {
2429 USE(c);
2430 if (Cursor == LastChar) {/* if I'm at the end */
2431 if (!VImode) {
2432 if (Cursor == InputBuf) {
2433 /* if I'm also at the beginning */
2434 so_write(STReof, 4);/* then do a EOF */
2435 flush();
2436 return(CC_EOF);
2437 }
2438 else
2439 return(CC_ERROR);
2440 }
2441 else {
2442 if (Cursor != InputBuf)
2443 Cursor--;
2444 else
2445 return(CC_ERROR);
2446 }
2447 }
2448 c_delafter(Argument); /* delete after dot */
2449 if (Cursor > LastChar)
2450 Cursor = LastChar; /* bounds check */
2451 return(CC_REFRESH);
2452 }
2453
2454 /*ARGSUSED*/
2455 CCRETVAL
2456 e_delnext_list(Char c)
2457 {
2458 USE(c);
2459 if (Cursor == LastChar) { /* if I'm at the end */
2460 PastBottom();
2461 *LastChar = '\0'; /* just in case */
2462 return(CC_LIST_CHOICES);
2463 }
2464 else {
2465 c_delafter(Argument); /* delete after dot */
2466 if (Cursor > LastChar)
2467 Cursor = LastChar; /* bounds check */
2468 return(CC_REFRESH);
2469 }
2470 }
2471
2472 /*ARGSUSED*/
2473 CCRETVAL
2474 e_delnext_list_eof(Char c)
2475 {
2476 USE(c);
2477 if (Cursor == LastChar) { /* if I'm at the end */
2478 if (Cursor == InputBuf) { /* if I'm also at the beginning */
2479 so_write(STReof, 4);/* then do a EOF */
2480 flush();
2481 return(CC_EOF);
2482 }
2483 else {
2484 PastBottom();
2485 *LastChar = '\0'; /* just in case */
2486 return(CC_LIST_CHOICES);
2487 }
2488 }
2489 else {
2490 c_delafter(Argument); /* delete after dot */
2491 if (Cursor > LastChar)
2492 Cursor = LastChar; /* bounds check */
2493 return(CC_REFRESH);
2494 }
2495 }
2496
2497 /*ARGSUSED*/
2498 CCRETVAL
2499 e_list_eof(Char c)
2500 {
2501 CCRETVAL rv;
2502
2503 USE(c);
2504 if (Cursor == LastChar && Cursor == InputBuf) {
2505 so_write(STReof, 4); /* then do a EOF */
2506 flush();
2507 rv = CC_EOF;
2508 }
2509 else {
2510 PastBottom();
2511 *LastChar = '\0'; /* just in case */
2512 rv = CC_LIST_CHOICES;
2513 }
2514 return rv;
2515 }
2516
2517 /*ARGSUSED*/
2518 CCRETVAL
2519 e_delwordnext(Char c)
2520 {
2521 Char *cp;
2522
2523 USE(c);
2524 if (Cursor == LastChar)
2525 return(CC_ERROR);
2526 /* else */
2527
2528 cp = c_next_word(Cursor, LastChar, Argument);
2529
2530 c_push_kill(Cursor, cp); /* save the text */
2531
2532 c_delafter((int)(cp - Cursor)); /* delete after dot */
2533 if (Cursor > LastChar)
2534 Cursor = LastChar; /* bounds check */
2535 return(CC_REFRESH);
2536 }
2537
2538 /*ARGSUSED*/
2539 CCRETVAL
2540 e_toend(Char c)
2541 {
2542 USE(c);
2543 Cursor = LastChar;
2544 if (VImode)
2545 if (ActionFlag & TCSHOP_DELETE) {
2546 c_delfini();
2547 return(CC_REFRESH);
2548 }
2549 RefCursor(); /* move the cursor */
2550 return(CC_NORM);
2551 }
2552
2553 /*ARGSUSED*/
2554 CCRETVAL
2555 e_tobeg(Char c)
2556 {
2557 USE(c);
2558 Cursor = InputBuf;
2559
2560 if (VImode) {
2561 while (Isspace(*Cursor)) /* We want FIRST non space character */
2562 Cursor++;
2563 if (ActionFlag & TCSHOP_DELETE) {
2564 c_delfini();
2565 return(CC_REFRESH);
2566 }
2567 }
2568
2569 RefCursor(); /* move the cursor */
2570 return(CC_NORM);
2571 }
2572
2573 /*ARGSUSED*/
2574 CCRETVAL
2575 e_killend(Char c)
2576 {
2577 USE(c);
2578 c_push_kill(Cursor, LastChar); /* copy it */
2579 LastChar = Cursor; /* zap! -- delete to end */
2580 if (Mark > Cursor)
2581 Mark = Cursor;
2582 MarkIsSet = 0;
2583 return(CC_REFRESH);
2584 }
2585
2586
2587 /*ARGSUSED*/
2588 CCRETVAL
2589 e_killbeg(Char c)
2590 {
2591 USE(c);
2592 c_push_kill(InputBuf, Cursor); /* copy it */
2593 c_delbefore((int)(Cursor - InputBuf));
2594 if (Mark && Mark > Cursor)
2595 Mark -= Cursor-InputBuf;
2596 return(CC_REFRESH);
2597 }
2598
2599 /*ARGSUSED*/
2600 CCRETVAL
2601 e_killall(Char c)
2602 {
2603 USE(c);
2604 c_push_kill(InputBuf, LastChar); /* copy it */
2605 Cursor = Mark = LastChar = InputBuf; /* zap! -- delete all of it */
2606 MarkIsSet = 0;
2607 return(CC_REFRESH);
2608 }
2609
2610 /*ARGSUSED*/
2611 CCRETVAL
2612 e_killregion(Char c)
2613 {
2614 USE(c);
2615 if (!Mark)
2616 return(CC_ERROR);
2617
2618 if (Mark > Cursor) {
2619 c_push_kill(Cursor, Mark); /* copy it */
2620 c_delafter((int)(Mark - Cursor)); /* delete it - UNUSED BY VI mode */
2621 Mark = Cursor;
2622 }
2623 else { /* mark is before cursor */
2624 c_push_kill(Mark, Cursor); /* copy it */
2625 c_delbefore((int)(Cursor - Mark));
2626 }
2627 if (adrof(STRhighlight) && MarkIsSet) {
2628 ClearLines();
2629 ClearDisp();
2630 }
2631 MarkIsSet = 0;
2632 return(CC_REFRESH);
2633 }
2634
2635 /*ARGSUSED*/
2636 CCRETVAL
2637 e_copyregion(Char c)
2638 {
2639 USE(c);
2640 if (!Mark)
2641 return(CC_ERROR);
2642
2643 if (Mark > Cursor) {
2644 c_push_kill(Cursor, Mark); /* copy it */
2645 }
2646 else { /* mark is before cursor */
2647 c_push_kill(Mark, Cursor); /* copy it */
2648 }
2649 return(CC_NORM); /* don't even need to Refresh() */
2650 }
2651
2652 /*ARGSUSED*/
2653 CCRETVAL
2654 e_charswitch(Char cc)
2655 {
2656 Char c;
2657
2658 USE(cc);
2659
2660 /* do nothing if we are at beginning of line or have only one char */
2661 if (Cursor == &InputBuf[0] || LastChar == &InputBuf[1]) {
2662 return(CC_ERROR);
2663 }
2664
2665 if (Cursor < LastChar) {
2666 Cursor++;
2667 }
2668 c = Cursor[-2];
2669 Cursor[-2] = Cursor[-1];
2670 Cursor[-1] = c;
2671 return(CC_REFRESH);
2672 }
2673
2674 /*ARGSUSED*/
2675 CCRETVAL
2676 e_gcharswitch(Char cc)
2677 { /* gosmacs style ^T */
2678 Char c;
2679
2680 USE(cc);
2681 if (Cursor > &InputBuf[1]) {/* must have at least two chars entered */
2682 c = Cursor[-2];
2683 Cursor[-2] = Cursor[-1];
2684 Cursor[-1] = c;
2685 return(CC_REFRESH);
2686 }
2687 else {
2688 return(CC_ERROR);
2689 }
2690 }
2691
2692 /*ARGSUSED*/
2693 CCRETVAL
2694 e_charback(Char c)
2695 {
2696 USE(c);
2697 if (Cursor > InputBuf) {
2698 if (Argument > Cursor - InputBuf)
2699 Cursor = InputBuf;
2700 else
2701 Cursor -= Argument;
2702
2703 if (VImode)
2704 if (ActionFlag & TCSHOP_DELETE) {
2705 c_delfini();
2706 return(CC_REFRESH);
2707 }
2708
2709 RefCursor();
2710 return(CC_NORM);
2711 }
2712 else {
2713 return(CC_ERROR);
2714 }
2715 }
2716
2717 /*ARGSUSED*/
2718 CCRETVAL
2719 v_wordback(Char c)
2720 {
2721 USE(c);
2722 if (Cursor == InputBuf)
2723 return(CC_ERROR);
2724 /* else */
2725
2726 Cursor = c_preword(Cursor, InputBuf, Argument, STRshwspace); /* bounds check */
2727
2728 if (ActionFlag & TCSHOP_DELETE) {
2729 c_delfini();
2730 return(CC_REFRESH);
2731 }
2732
2733 RefCursor();
2734 return(CC_NORM);
2735 }
2736
2737 /*ARGSUSED*/
2738 CCRETVAL
2739 e_wordback(Char c)
2740 {
2741 USE(c);
2742 if (Cursor == InputBuf)
2743 return(CC_ERROR);
2744 /* else */
2745
2746 Cursor = c_prev_word(Cursor, InputBuf, Argument); /* bounds check */
2747
2748 if (VImode)
2749 if (ActionFlag & TCSHOP_DELETE) {
2750 c_delfini();
2751 return(CC_REFRESH);
2752 }
2753
2754 RefCursor();
2755 return(CC_NORM);
2756 }
2757
2758 /*ARGSUSED*/
2759 CCRETVAL
2760 e_charfwd(Char c)
2761 {
2762 USE(c);
2763 if (Cursor < LastChar) {
2764 Cursor += Argument;
2765 if (Cursor > LastChar)
2766 Cursor = LastChar;
2767
2768 if (VImode)
2769 if (ActionFlag & TCSHOP_DELETE) {
2770 c_delfini();
2771 return(CC_REFRESH);
2772 }
2773
2774 RefCursor();
2775 return(CC_NORM);
2776 }
2777 else {
2778 return(CC_ERROR);
2779 }
2780 }
2781
2782 /*ARGSUSED*/
2783 CCRETVAL
2784 e_wordfwd(Char c)
2785 {
2786 USE(c);
2787 if (Cursor == LastChar)
2788 return(CC_ERROR);
2789 /* else */
2790
2791 Cursor = c_next_word(Cursor, LastChar, Argument);
2792
2793 if (VImode)
2794 if (ActionFlag & TCSHOP_DELETE) {
2795 c_delfini();
2796 return(CC_REFRESH);
2797 }
2798
2799 RefCursor();
2800 return(CC_NORM);
2801 }
2802
2803 /*ARGSUSED*/
2804 CCRETVAL
2805 v_wordfwd(Char c)
2806 {
2807 USE(c);
2808 if (Cursor == LastChar)
2809 return(CC_ERROR);
2810 /* else */
2811
2812 Cursor = c_nexword(Cursor, LastChar, Argument);
2813
2814 if (VImode)
2815 if (ActionFlag & TCSHOP_DELETE) {
2816 c_delfini();
2817 return(CC_REFRESH);
2818 }
2819
2820 RefCursor();
2821 return(CC_NORM);
2822 }
2823
2824 /*ARGSUSED*/
2825 CCRETVAL
2826 v_wordbegnext(Char c)
2827 {
2828 USE(c);
2829 if (Cursor == LastChar)
2830 return(CC_ERROR);
2831 /* else */
2832
2833 Cursor = c_next_word(Cursor, LastChar, Argument);
2834 if (Cursor < LastChar)
2835 Cursor++;
2836
2837 if (VImode)
2838 if (ActionFlag & TCSHOP_DELETE) {
2839 c_delfini();
2840 return(CC_REFRESH);
2841 }
2842
2843 RefCursor();
2844 return(CC_NORM);
2845 }
2846
2847 /*ARGSUSED*/
2848 static CCRETVAL
2849 v_repeat_srch(int c)
2850 {
2851 CCRETVAL rv = CC_ERROR;
2852 #ifdef SDEBUG
2853 xprintf("dir %d patlen %d patbuf %S\n",
2854 c, (int)patbuf.len, patbuf.s);
2855 #endif
2856
2857 LastCmd = (KEYCMD) c; /* Hack to stop c_hsetpat */
2858 LastChar = InputBuf;
2859 switch (c) {
2860 case F_DOWN_SEARCH_HIST:
2861 rv = e_down_search_hist(0);
2862 break;
2863 case F_UP_SEARCH_HIST:
2864 rv = e_up_search_hist(0);
2865 break;
2866 default:
2867 break;
2868 }
2869 return rv;
2870 }
2871
2872 static CCRETVAL
2873 v_csearch_back(Char ch, int count, int tflag)
2874 {
2875 Char *cp;
2876
2877 cp = Cursor;
2878 while (count--) {
2879 if (*cp == ch)
2880 cp--;
2881 while (cp > InputBuf && *cp != ch)
2882 cp--;
2883 }
2884
2885 if (cp < InputBuf || (cp == InputBuf && *cp != ch))
2886 return(CC_ERROR);
2887
2888 if (*cp == ch && tflag)
2889 cp++;
2890
2891 Cursor = cp;
2892
2893 if (ActionFlag & TCSHOP_DELETE) {
2894 Cursor++;
2895 c_delfini();
2896 return(CC_REFRESH);
2897 }
2898
2899 RefCursor();
2900 return(CC_NORM);
2901 }
2902
2903 static CCRETVAL
2904 v_csearch_fwd(Char ch, int count, int tflag)
2905 {
2906 Char *cp;
2907
2908 cp = Cursor;
2909 while (count--) {
2910 if(*cp == ch)
2911 cp++;
2912 while (cp < LastChar && *cp != ch)
2913 cp++;
2914 }
2915
2916 if (cp >= LastChar)
2917 return(CC_ERROR);
2918
2919 if (*cp == ch && tflag)
2920 cp--;
2921
2922 Cursor = cp;
2923
2924 if (ActionFlag & TCSHOP_DELETE) {
2925 Cursor++;
2926 c_delfini();
2927 return(CC_REFRESH);
2928 }
2929 RefCursor();
2930 return(CC_NORM);
2931 }
2932
2933 /*ARGSUSED*/
2934 static CCRETVAL
2935 v_action(int c)
2936 {
2937 Char *cp, *kp;
2938
2939 if (ActionFlag == TCSHOP_DELETE) {
2940 ActionFlag = TCSHOP_NOP;
2941 ActionPos = 0;
2942
2943 UndoSize = 0;
2944 kp = UndoBuf;
2945 for (cp = InputBuf; cp < LastChar; cp++) {
2946 *kp++ = *cp;
2947 UndoSize++;
2948 }
2949
2950 UndoAction = TCSHOP_INSERT;
2951 UndoPtr = InputBuf;
2952 LastChar = InputBuf;
2953 Cursor = InputBuf;
2954 if (c & TCSHOP_INSERT)
2955 c_alternativ_key_map(0);
2956
2957 return(CC_REFRESH);
2958 }
2959 #ifdef notdef
2960 else if (ActionFlag == TCSHOP_NOP) {
2961 #endif
2962 ActionPos = Cursor;
2963 ActionFlag = c;
2964 return(CC_ARGHACK); /* Do NOT clear out argument */
2965 #ifdef notdef
2966 }
2967 else {
2968 ActionFlag = 0;
2969 ActionPos = 0;
2970 return(CC_ERROR);
2971 }
2972 #endif
2973 }
2974
2975 #ifdef COMMENT
2976 /* by: Brian Allison <uiucdcs!convex!allison@RUTGERS.EDU> */
2977 static void
2978 c_get_word(Char **begin, Char **end)
2979 {
2980 Char *cp;
2981
2982 cp = &Cursor[0];
2983 while (Argument--) {
2984 while ((cp <= LastChar) && (isword(*cp)))
2985 cp++;
2986 *end = --cp;
2987 while ((cp >= InputBuf) && (isword(*cp)))
2988 cp--;
2989 *begin = ++cp;
2990 }
2991 }
2992 #endif /* COMMENT */
2993
2994 /*ARGSUSED*/
2995 CCRETVAL
2996 e_uppercase(Char c)
2997 {
2998 Char *cp, *end;
2999
3000 USE(c);
3001 end = c_next_word(Cursor, LastChar, Argument);
3002
3003 for (cp = Cursor; cp < end; cp++) /* PWP: was cp=begin */
3004 if (Islower(*cp))
3005 *cp = Toupper(*cp);
3006
3007 Cursor = end;
3008 if (Cursor > LastChar)
3009 Cursor = LastChar;
3010 return(CC_REFRESH);
3011 }
3012
3013
3014 /*ARGSUSED*/
3015 CCRETVAL
3016 e_capitolcase(Char c)
3017 {
3018 Char *cp, *end;
3019
3020 USE(c);
3021 end = c_next_word(Cursor, LastChar, Argument);
3022
3023 cp = Cursor;
3024 for (; cp < end; cp++) {
3025 if (Isalpha(*cp)) {
3026 if (Islower(*cp))
3027 *cp = Toupper(*cp);
3028 cp++;
3029 break;
3030 }
3031 }
3032 for (; cp < end; cp++)
3033 if (Isupper(*cp))
3034 *cp = Tolower(*cp);
3035
3036 Cursor = end;
3037 if (Cursor > LastChar)
3038 Cursor = LastChar;
3039 return(CC_REFRESH);
3040 }
3041
3042 /*ARGSUSED*/
3043 CCRETVAL
3044 e_lowercase(Char c)
3045 {
3046 Char *cp, *end;
3047
3048 USE(c);
3049 end = c_next_word(Cursor, LastChar, Argument);
3050
3051 for (cp = Cursor; cp < end; cp++)
3052 if (Isupper(*cp))
3053 *cp = Tolower(*cp);
3054
3055 Cursor = end;
3056 if (Cursor > LastChar)
3057 Cursor = LastChar;
3058 return(CC_REFRESH);
3059 }
3060
3061
3062 /*ARGSUSED*/
3063 CCRETVAL
3064 e_set_mark(Char c)
3065 {
3066 USE(c);
3067 if (adrof(STRhighlight) && MarkIsSet && Mark != Cursor) {
3068 ClearLines();
3069 ClearDisp();
3070 Refresh();
3071 }
3072 Mark = Cursor;
3073 MarkIsSet = 1;
3074 return(CC_NORM);
3075 }
3076
3077 /*ARGSUSED*/
3078 CCRETVAL
3079 e_exchange_mark(Char c)
3080 {
3081 Char *cp;
3082
3083 USE(c);
3084 cp = Cursor;
3085 Cursor = Mark;
3086 Mark = cp;
3087 RefCursor();
3088 return(CC_NORM);
3089 }
3090
3091 /*ARGSUSED*/
3092 CCRETVAL
3093 e_argfour(Char c)
3094 { /* multiply current argument by 4 */
3095 USE(c);
3096 if (Argument > 1000000)
3097 return CC_ERROR;
3098 DoingArg = 1;
3099 Argument *= 4;
3100 return(CC_ARGHACK);
3101 }
3102
3103 static void
3104 quote_mode_cleanup(void *unused)
3105 {
3106 USE(unused);
3107 QuoteModeOff();
3108 }
3109
3110 /*ARGSUSED*/
3111 CCRETVAL
3112 e_quote(Char c)
3113 {
3114 Char ch;
3115 int num;
3116
3117 USE(c);
3118 QuoteModeOn();
3119 cleanup_push(&c, quote_mode_cleanup); /* Using &c just as a mark */
3120 num = GetNextChar(&ch);
3121 cleanup_until(&c);
3122 if (num == 1)
3123 return e_insert(ch);
3124 else
3125 return e_send_eof(0);
3126 }
3127
3128 /*ARGSUSED*/
3129 CCRETVAL
3130 e_metanext(Char c)
3131 {
3132 USE(c);
3133 MetaNext = 1;
3134 return(CC_ARGHACK); /* preserve argument */
3135 }
3136
3137 #ifdef notdef
3138 /*ARGSUSED*/
3139 CCRETVAL
3140 e_extendnext(Char c)
3141 {
3142 CurrentKeyMap = CcAltMap;
3143 return(CC_ARGHACK); /* preserve argument */
3144 }
3145
3146 #endif
3147
3148 /*ARGSUSED*/
3149 CCRETVAL
3150 v_insbeg(Char c)
3151 { /* move to beginning of line and start vi
3152 * insert mode */
3153 USE(c);
3154 Cursor = InputBuf;
3155 InsertPos = Cursor;
3156
3157 UndoPtr = Cursor;
3158 UndoAction = TCSHOP_DELETE;
3159
3160 RefCursor(); /* move the cursor */
3161 c_alternativ_key_map(0);
3162 return(CC_NORM);
3163 }
3164
3165 /*ARGSUSED*/
3166 CCRETVAL
3167 v_replone(Char c)
3168 { /* vi mode overwrite one character */
3169 USE(c);
3170 c_alternativ_key_map(0);
3171 inputmode = MODE_REPLACE_1;
3172 UndoAction = TCSHOP_CHANGE; /* Set Up for VI undo command */
3173 UndoPtr = Cursor;
3174 UndoSize = 0;
3175 return(CC_NORM);
3176 }
3177
3178 /*ARGSUSED*/
3179 CCRETVAL
3180 v_replmode(Char c)
3181 { /* vi mode start overwriting */
3182 USE(c);
3183 c_alternativ_key_map(0);
3184 inputmode = MODE_REPLACE;
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_substchar(Char c)
3194 { /* vi mode substitute for one char */
3195 USE(c);
3196 c_delafter(Argument);
3197 c_alternativ_key_map(0);
3198 return(CC_REFRESH);
3199 }
3200
3201 /*ARGSUSED*/
3202 CCRETVAL
3203 v_substline(Char c)
3204 { /* vi mode replace whole line */
3205 USE(c);
3206 (void) e_killall(0);
3207 c_alternativ_key_map(0);
3208 return(CC_REFRESH);
3209 }
3210
3211 /*ARGSUSED*/
3212 CCRETVAL
3213 v_chgtoend(Char c)
3214 { /* vi mode change to end of line */
3215 USE(c);
3216 (void) e_killend(0);
3217 c_alternativ_key_map(0);
3218 return(CC_REFRESH);
3219 }
3220
3221 /*ARGSUSED*/
3222 CCRETVAL
3223 v_insert(Char c)
3224 { /* vi mode start inserting */
3225 USE(c);
3226 c_alternativ_key_map(0);
3227
3228 InsertPos = Cursor;
3229 UndoPtr = Cursor;
3230 UndoAction = TCSHOP_DELETE;
3231
3232 return(CC_NORM);
3233 }
3234
3235 /*ARGSUSED*/
3236 CCRETVAL
3237 v_add(Char c)
3238 { /* vi mode start adding */
3239 USE(c);
3240 c_alternativ_key_map(0);
3241 if (Cursor < LastChar)
3242 {
3243 Cursor++;
3244 if (Cursor > LastChar)
3245 Cursor = LastChar;
3246 RefCursor();
3247 }
3248
3249 InsertPos = Cursor;
3250 UndoPtr = Cursor;
3251 UndoAction = TCSHOP_DELETE;
3252
3253 return(CC_NORM);
3254 }
3255
3256 /*ARGSUSED*/
3257 CCRETVAL
3258 v_addend(Char c)
3259 { /* vi mode to add at end of line */
3260 USE(c);
3261 c_alternativ_key_map(0);
3262 Cursor = LastChar;
3263
3264 InsertPos = LastChar; /* Mark where insertion begins */
3265 UndoPtr = LastChar;
3266 UndoAction = TCSHOP_DELETE;
3267
3268 RefCursor();
3269 return(CC_NORM);
3270 }
3271
3272 /*ARGSUSED*/
3273 CCRETVAL
3274 v_change_case(Char cc)
3275 {
3276 Char c;
3277
3278 USE(cc);
3279 if (Cursor < LastChar) {
3280 #ifndef WINNT_NATIVE
3281 c = *Cursor;
3282 #else
3283 c = CHAR & *Cursor;
3284 #endif /* WINNT_NATIVE */
3285 if (Isupper(c))
3286 *Cursor++ = Tolower(c);
3287 else if (Islower(c))
3288 *Cursor++ = Toupper(c);
3289 else
3290 Cursor++;
3291 RefPlusOne(1); /* fast refresh for one char */
3292 return(CC_NORM);
3293 }
3294 return(CC_ERROR);
3295 }
3296
3297 /*ARGSUSED*/
3298 CCRETVAL
3299 e_expand(Char c)
3300 {
3301 Char *p;
3302
3303 USE(c);
3304 for (p = InputBuf; Isspace(*p); p++)
3305 continue;
3306 if (p == LastChar)
3307 return(CC_ERROR);
3308
3309 justpr++;
3310 Expand++;
3311 return(e_newline(0));
3312 }
3313
3314 /*ARGSUSED*/
3315 CCRETVAL
3316 e_startover(Char c)
3317 { /* erase all of current line, start again */
3318 USE(c);
3319 ResetInLine(0); /* reset the input pointers */
3320 return(CC_REFRESH);
3321 }
3322
3323 /*ARGSUSED*/
3324 CCRETVAL
3325 e_redisp(Char c)
3326 {
3327 USE(c);
3328 ClearLines();
3329 ClearDisp();
3330 return(CC_REFRESH);
3331 }
3332
3333 /*ARGSUSED*/
3334 CCRETVAL
3335 e_cleardisp(Char c)
3336 {
3337 USE(c);
3338 ClearScreen(); /* clear the whole real screen */
3339 ClearDisp(); /* reset everything */
3340 return(CC_REFRESH);
3341 }
3342
3343 /*ARGSUSED*/
3344 CCRETVAL
3345 e_tty_int(Char c)
3346 {
3347 USE(c);
3348 #if defined(_MINIX) || defined(WINNT_NATIVE)
3349 /* SAK PATCH: erase all of current line, start again */
3350 ResetInLine(0); /* reset the input pointers */
3351 xputchar('\n');
3352 ClearDisp();
3353 return (CC_REFRESH);
3354 #else /* !_MINIX && !WINNT_NATIVE */
3355 /* do no editing */
3356 return (CC_NORM);
3357 #endif /* _MINIX || WINNT_NATIVE */
3358 }
3359
3360 /*
3361 * From: ghazi@cesl.rutgers.edu (Kaveh R. Ghazi)
3362 * Function to send a character back to the input stream in cooked
3363 * mode. Only works if we have TIOCSTI
3364 */
3365 /*ARGSUSED*/
3366 CCRETVAL
3367 e_stuff_char(Char c)
3368 {
3369 #ifdef TIOCSTI
3370 int was_raw = Tty_raw_mode;
3371 char buf[MB_LEN_MAX];
3372 size_t i, len;
3373
3374 if (was_raw)
3375 (void) Cookedmode();
3376
3377 (void) xwrite(SHIN, "\n", 1);
3378 len = one_wctomb(buf, c & CHAR);
3379 for (i = 0; i < len; i++)
3380 (void) ioctl(SHIN, TIOCSTI, (ioctl_t) &buf[i]);
3381
3382 if (was_raw)
3383 (void) Rawmode();
3384 return(e_redisp(c));
3385 #else /* !TIOCSTI */
3386 return(CC_ERROR);
3387 #endif /* !TIOCSTI */
3388 }
3389
3390 /*ARGSUSED*/
3391 CCRETVAL
3392 e_insovr(Char c)
3393 {
3394 USE(c);
3395 inputmode = (inputmode == MODE_INSERT ? MODE_REPLACE : MODE_INSERT);
3396 return(CC_NORM);
3397 }
3398
3399 /*ARGSUSED*/
3400 CCRETVAL
3401 e_tty_dsusp(Char c)
3402 {
3403 USE(c);
3404 /* do no editing */
3405 return(CC_NORM);
3406 }
3407
3408 /*ARGSUSED*/
3409 CCRETVAL
3410 e_tty_flusho(Char c)
3411 {
3412 USE(c);
3413 /* do no editing */
3414 return(CC_NORM);
3415 }
3416
3417 /*ARGSUSED*/
3418 CCRETVAL
3419 e_tty_quit(Char c)
3420 {
3421 USE(c);
3422 /* do no editing */
3423 return(CC_NORM);
3424 }
3425
3426 /*ARGSUSED*/
3427 CCRETVAL
3428 e_tty_tsusp(Char c)
3429 {
3430 USE(c);
3431 /* do no editing */
3432 return(CC_NORM);
3433 }
3434
3435 /*ARGSUSED*/
3436 CCRETVAL
3437 e_tty_stopo(Char c)
3438 {
3439 USE(c);
3440 /* do no editing */
3441 return(CC_NORM);
3442 }
3443
3444 /*ARGSUSED*/
3445 CCRETVAL
3446 e_expand_history(Char c)
3447 {
3448 USE(c);
3449 *LastChar = '\0'; /* just in case */
3450 c_substitute();
3451 return(CC_NORM);
3452 }
3453
3454 /*ARGSUSED*/
3455 CCRETVAL
3456 e_magic_space(Char c)
3457 {
3458 USE(c);
3459 *LastChar = '\0'; /* just in case */
3460 c_substitute();
3461 return(e_insert(' '));
3462 }
3463
3464 /*ARGSUSED*/
3465 CCRETVAL
3466 e_inc_fwd(Char c)
3467 {
3468 CCRETVAL ret;
3469
3470 USE(c);
3471 patbuf.len = 0;
3472 MarkIsSet = 0;
3473 ret = e_inc_search(F_DOWN_SEARCH_HIST);
3474 if (adrof(STRhighlight) && IncMatchLen) {
3475 IncMatchLen = 0;
3476 ClearLines();
3477 ClearDisp();
3478 Refresh();
3479 }
3480 IncMatchLen = 0;
3481 return ret;
3482 }
3483
3484
3485 /*ARGSUSED*/
3486 CCRETVAL
3487 e_inc_back(Char c)
3488 {
3489 CCRETVAL ret;
3490
3491 USE(c);
3492 patbuf.len = 0;
3493 MarkIsSet = 0;
3494 ret = e_inc_search(F_UP_SEARCH_HIST);
3495 if (adrof(STRhighlight) && IncMatchLen) {
3496 IncMatchLen = 0;
3497 ClearLines();
3498 ClearDisp();
3499 Refresh();
3500 }
3501 IncMatchLen = 0;
3502 return ret;
3503 }
3504
3505 /*ARGSUSED*/
3506 CCRETVAL
3507 e_copyprev(Char c)
3508 {
3509 Char *cp, *oldc, *dp;
3510
3511 USE(c);
3512 if (Cursor == InputBuf)
3513 return(CC_ERROR);
3514 /* else */
3515
3516 oldc = Cursor;
3517 /* does a bounds check */
3518 cp = c_prev_word(Cursor, InputBuf, Argument);
3519
3520 c_insert((int)(oldc - cp));
3521 for (dp = oldc; cp < oldc && dp < LastChar; cp++)
3522 *dp++ = *cp;
3523
3524 Cursor = dp; /* put cursor at end */
3525
3526 return(CC_REFRESH);
3527 }
3528
3529 /*ARGSUSED*/
3530 CCRETVAL
3531 e_tty_starto(Char c)
3532 {
3533 USE(c);
3534 /* do no editing */
3535 return(CC_NORM);
3536 }
3537
3538 /*ARGSUSED*/
3539 CCRETVAL
3540 e_load_average(Char c)
3541 {
3542 USE(c);
3543 PastBottom();
3544 #ifdef TIOCSTAT
3545 /*
3546 * Here we pass &c to the ioctl because some os's (NetBSD) expect it
3547 * there even if they don't use it. (lukem@netbsd.org)
3548 */
3549 if (ioctl(SHIN, TIOCSTAT, (ioctl_t) &c) < 0)
3550 #endif
3551 xprintf(CGETS(5, 1, "Load average unavailable\n"));
3552 return(CC_REFRESH);
3553 }
3554
3555 /*ARGSUSED*/
3556 CCRETVAL
3557 v_chgmeta(Char c)
3558 {
3559 USE(c);
3560 /*
3561 * Delete with insert == change: first we delete and then we leave in
3562 * insert mode.
3563 */
3564 return(v_action(TCSHOP_DELETE|TCSHOP_INSERT));
3565 }
3566
3567 /*ARGSUSED*/
3568 CCRETVAL
3569 v_delmeta(Char c)
3570 {
3571 USE(c);
3572 return(v_action(TCSHOP_DELETE));
3573 }
3574
3575
3576 /*ARGSUSED*/
3577 CCRETVAL
3578 v_endword(Char c)
3579 {
3580 USE(c);
3581 if (Cursor == LastChar)
3582 return(CC_ERROR);
3583 /* else */
3584
3585 Cursor = c_endword(Cursor, LastChar, Argument, STRshwspace);
3586
3587 if (ActionFlag & TCSHOP_DELETE)
3588 {
3589 Cursor++;
3590 c_delfini();
3591 return(CC_REFRESH);
3592 }
3593
3594 RefCursor();
3595 return(CC_NORM);
3596 }
3597
3598 /*ARGSUSED*/
3599 CCRETVAL
3600 v_eword(Char c)
3601 {
3602 USE(c);
3603 if (Cursor == LastChar)
3604 return(CC_ERROR);
3605 /* else */
3606
3607 Cursor = c_eword(Cursor, LastChar, Argument);
3608
3609 if (ActionFlag & TCSHOP_DELETE) {
3610 Cursor++;
3611 c_delfini();
3612 return(CC_REFRESH);
3613 }
3614
3615 RefCursor();
3616 return(CC_NORM);
3617 }
3618
3619 /*ARGSUSED*/
3620 CCRETVAL
3621 v_char_fwd(Char c)
3622 {
3623 Char ch;
3624
3625 USE(c);
3626 if (GetNextChar(&ch) != 1)
3627 return e_send_eof(0);
3628
3629 srch_dir = CHAR_FWD;
3630 srch_char = ch;
3631
3632 return v_csearch_fwd(ch, Argument, 0);
3633
3634 }
3635
3636 /*ARGSUSED*/
3637 CCRETVAL
3638 v_char_back(Char c)
3639 {
3640 Char ch;
3641
3642 USE(c);
3643 if (GetNextChar(&ch) != 1)
3644 return e_send_eof(0);
3645
3646 srch_dir = CHAR_BACK;
3647 srch_char = ch;
3648
3649 return v_csearch_back(ch, Argument, 0);
3650 }
3651
3652 /*ARGSUSED*/
3653 CCRETVAL
3654 v_charto_fwd(Char c)
3655 {
3656 Char ch;
3657
3658 USE(c);
3659 if (GetNextChar(&ch) != 1)
3660 return e_send_eof(0);
3661
3662 return v_csearch_fwd(ch, Argument, 1);
3663
3664 }
3665
3666 /*ARGSUSED*/
3667 CCRETVAL
3668 v_charto_back(Char c)
3669 {
3670 Char ch;
3671
3672 USE(c);
3673 if (GetNextChar(&ch) != 1)
3674 return e_send_eof(0);
3675
3676 return v_csearch_back(ch, Argument, 1);
3677 }
3678
3679 /*ARGSUSED*/
3680 CCRETVAL
3681 v_rchar_fwd(Char c)
3682 {
3683 USE(c);
3684 if (srch_char == 0)
3685 return CC_ERROR;
3686
3687 return srch_dir == CHAR_FWD ? v_csearch_fwd(srch_char, Argument, 0) :
3688 v_csearch_back(srch_char, Argument, 0);
3689 }
3690
3691 /*ARGSUSED*/
3692 CCRETVAL
3693 v_rchar_back(Char c)
3694 {
3695 USE(c);
3696 if (srch_char == 0)
3697 return CC_ERROR;
3698
3699 return srch_dir == CHAR_BACK ? v_csearch_fwd(srch_char, Argument, 0) :
3700 v_csearch_back(srch_char, Argument, 0);
3701 }
3702
3703 /*ARGSUSED*/
3704 CCRETVAL
3705 v_undo(Char c)
3706 {
3707 int loop;
3708 Char *kp, *cp;
3709 Char temp;
3710 int size;
3711
3712 USE(c);
3713 switch (UndoAction) {
3714 case TCSHOP_DELETE|TCSHOP_INSERT:
3715 case TCSHOP_DELETE:
3716 if (UndoSize == 0) return(CC_NORM);
3717 cp = UndoPtr;
3718 kp = UndoBuf;
3719 for (loop=0; loop < UndoSize; loop++) /* copy the chars */
3720 *kp++ = *cp++; /* into UndoBuf */
3721
3722 for (cp = UndoPtr; cp <= LastChar; cp++)
3723 *cp = cp[UndoSize];
3724
3725 LastChar -= UndoSize;
3726 Cursor = UndoPtr;
3727
3728 UndoAction = TCSHOP_INSERT;
3729 break;
3730
3731 case TCSHOP_INSERT:
3732 if (UndoSize == 0) return(CC_NORM);
3733 cp = UndoPtr;
3734 Cursor = UndoPtr;
3735 kp = UndoBuf;
3736 c_insert(UndoSize); /* open the space, */
3737 for (loop = 0; loop < UndoSize; loop++) /* copy the chars */
3738 *cp++ = *kp++;
3739
3740 UndoAction = TCSHOP_DELETE;
3741 break;
3742
3743 case TCSHOP_CHANGE:
3744 if (UndoSize == 0) return(CC_NORM);
3745 cp = UndoPtr;
3746 Cursor = UndoPtr;
3747 kp = UndoBuf;
3748 size = (int)(Cursor-LastChar); /* NOT NSL independant */
3749 if (size < UndoSize)
3750 size = UndoSize;
3751 for(loop = 0; loop < size; loop++) {
3752 temp = *kp;
3753 *kp++ = *cp;
3754 *cp++ = temp;
3755 }
3756 break;
3757
3758 default:
3759 return(CC_ERROR);
3760 }
3761
3762 return(CC_REFRESH);
3763 }
3764
3765 /*ARGSUSED*/
3766 CCRETVAL
3767 v_ush_meta(Char c)
3768 {
3769 USE(c);
3770 return v_search(F_UP_SEARCH_HIST);
3771 }
3772
3773 /*ARGSUSED*/
3774 CCRETVAL
3775 v_dsh_meta(Char c)
3776 {
3777 USE(c);
3778 return v_search(F_DOWN_SEARCH_HIST);
3779 }
3780
3781 /*ARGSUSED*/
3782 CCRETVAL
3783 v_rsrch_fwd(Char c)
3784 {
3785 USE(c);
3786 if (patbuf.len == 0) return(CC_ERROR);
3787 return(v_repeat_srch(searchdir));
3788 }
3789
3790 /*ARGSUSED*/
3791 CCRETVAL
3792 v_rsrch_back(Char c)
3793 {
3794 USE(c);
3795 if (patbuf.len == 0) return(CC_ERROR);
3796 return(v_repeat_srch(searchdir == F_UP_SEARCH_HIST ?
3797 F_DOWN_SEARCH_HIST : F_UP_SEARCH_HIST));
3798 }
3799
3800 #ifndef WINNT_NATIVE
3801 /* Since ed.defns.h is generated from ed.defns.c, these empty
3802 functions will keep the F_NUM_FNS consistent
3803 */
3804 CCRETVAL
3805 e_copy_to_clipboard(Char c)
3806 {
3807 USE(c);
3808 return CC_ERROR;
3809 }
3810
3811 CCRETVAL
3812 e_paste_from_clipboard(Char c)
3813 {
3814 USE(c);
3815 return (CC_ERROR);
3816 }
3817
3818 CCRETVAL
3819 e_dosify_next(Char c)
3820 {
3821 USE(c);
3822 return (CC_ERROR);
3823 }
3824 CCRETVAL
3825 e_dosify_prev(Char c)
3826 {
3827 USE(c);
3828 return (CC_ERROR);
3829 }
3830 CCRETVAL
3831 e_page_up(Char c)
3832 {
3833 USE(c);
3834 return (CC_ERROR);
3835 }
3836 CCRETVAL
3837 e_page_down(Char c)
3838 {
3839 USE(c);
3840 return (CC_ERROR);
3841 }
3842 #endif /* !WINNT_NATIVE */
3843
3844 #ifdef notdef
3845 void
3846 MoveCursor(int n) /* move cursor + right - left char */
3847 {
3848 Cursor = Cursor + n;
3849 if (Cursor < InputBuf)
3850 Cursor = InputBuf;
3851 if (Cursor > LastChar)
3852 Cursor = LastChar;
3853 return;
3854 }
3855
3856 Char *
3857 GetCursor(void)
3858 {
3859 return(Cursor);
3860 }
3861
3862 int
3863 PutCursor(Char *p)
3864 {
3865 if (p < InputBuf || p > LastChar)
3866 return 1; /* Error */
3867 Cursor = p;
3868 return 0;
3869 }
3870 #endif
DragonFly BSD