root/src/noitedit/common.c

Revision bafab25395cb398ddf5eae42145f0d0bfc00ec22, 19.6 kB (checked in by Theo Schlossnagle <jesus@omniti.com>, 7 years ago)

import of libedit... prepare to hack

  • Property mode set to 100644
Line 
1 /*      $NetBSD: common.c,v 1.10 2001/01/10 07:45:41 jdolecek Exp $     */
2
3 /*-
4  * Copyright (c) 1992, 1993
5  *      The Regents of the University of California.  All rights reserved.
6  *
7  * This code is derived from software contributed to Berkeley by
8  * Christos Zoulas of Cornell University.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. All advertising materials mentioning features or use of this software
19  *    must display the following acknowledgement:
20  *      This product includes software developed by the University of
21  *      California, Berkeley and its contributors.
22  * 4. Neither the name of the University nor the names of its contributors
23  *    may be used to endorse or promote products derived from this software
24  *    without specific prior written permission.
25  *
26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36  * SUCH DAMAGE.
37  */
38
39 #include "compat.h"
40 #if !defined(lint) && !defined(SCCSID)
41 #if 0
42 static char sccsid[] = "@(#)common.c    8.1 (Berkeley) 6/4/93";
43 #else
44 __RCSID("$NetBSD: common.c,v 1.10 2001/01/10 07:45:41 jdolecek Exp $");
45 #endif
46 #endif /* not lint && not SCCSID */
47
48 /*
49  * common.c: Common Editor functions
50  */
51 #include "sys.h"
52 #include "el.h"
53
54 /* ed_end_of_file():
55  *      Indicate end of file
56  *      [^D]
57  */
58 protected el_action_t
59 /*ARGSUSED*/
60 ed_end_of_file(EditLine *el, int c)
61 {
62
63         re_goto_bottom(el);
64         *el->el_line.lastchar = '\0';
65         return (CC_EOF);
66 }
67
68
69 /* ed_insert():
70  *      Add character to the line
71  *      Insert a character [bound to all insert keys]
72  */
73 protected el_action_t
74 ed_insert(EditLine *el, int c)
75 {
76         int i;
77
78         if (c == '\0')
79                 return (CC_ERROR);
80
81         if (el->el_line.lastchar + el->el_state.argument >=
82             el->el_line.limit) {
83                 /* end of buffer space, try to allocate more */
84                 if (!ch_enlargebufs(el, (size_t) el->el_state.argument))
85                         return CC_ERROR;        /* error allocating more */
86         }
87
88         if (el->el_state.argument == 1) {
89                 if (el->el_state.inputmode != MODE_INSERT) {
90                         el->el_chared.c_undo.buf[el->el_chared.c_undo.isize++] =
91                             *el->el_line.cursor;
92                         el->el_chared.c_undo.buf[el->el_chared.c_undo.isize] =
93                             '\0';
94                         c_delafter(el, 1);
95                 }
96                 c_insert(el, 1);
97
98                 *el->el_line.cursor++ = c;
99                 el->el_state.doingarg = 0;      /* just in case */
100                 re_fastaddc(el);                /* fast refresh for one char. */
101         } else {
102                 if (el->el_state.inputmode != MODE_INSERT) {
103                         for (i = 0; i < el->el_state.argument; i++)
104                                 el->el_chared.c_undo.buf[el->el_chared.c_undo.isize++] =
105                                     el->el_line.cursor[i];
106
107                         el->el_chared.c_undo.buf[el->el_chared.c_undo.isize] =
108                             '\0';
109                         c_delafter(el, el->el_state.argument);
110                 }
111                 c_insert(el, el->el_state.argument);
112
113                 while (el->el_state.argument--)
114                         *el->el_line.cursor++ = c;
115                 re_refresh(el);
116         }
117
118         if (el->el_state.inputmode == MODE_REPLACE_1)
119                 (void) vi_command_mode(el, 0);
120
121         return (CC_NORM);
122 }
123
124
125 /* ed_delete_prev_word():
126  *      Delete from beginning of current word to cursor
127  *      [M-^?] [^W]
128  */
129 protected el_action_t
130 /*ARGSUSED*/
131 ed_delete_prev_word(EditLine *el, int c)
132 {
133         char *cp, *p, *kp;
134
135         if (el->el_line.cursor == el->el_line.buffer)
136                 return (CC_ERROR);
137
138         cp = c__prev_word(el->el_line.cursor, el->el_line.buffer,
139             el->el_state.argument, ce__isword);
140
141         for (p = cp, kp = el->el_chared.c_kill.buf; p < el->el_line.cursor; p++)
142                 *kp++ = *p;
143         el->el_chared.c_kill.last = kp;
144
145         c_delbefore(el, el->el_line.cursor - cp);       /* delete before dot */
146         el->el_line.cursor = cp;
147         if (el->el_line.cursor < el->el_line.buffer)
148                 el->el_line.cursor = el->el_line.buffer; /* bounds check */
149         return (CC_REFRESH);
150 }
151
152
153 /* ed_delete_next_char():
154  *      Delete character under cursor
155  *      [^D] [x]
156  */
157 protected el_action_t
158 /*ARGSUSED*/
159 ed_delete_next_char(EditLine *el, int c)
160 {
161 #ifdef notdef                   /* XXX */
162 #define EL      el->el_line
163         (void) fprintf(el->el_errlfile,
164             "\nD(b: %x(%s)  c: %x(%s) last: %x(%s) limit: %x(%s)\n",
165             EL.buffer, EL.buffer, EL.cursor, EL.cursor, EL.lastchar,
166             EL.lastchar, EL.limit, EL.limit);
167 #endif
168         if (el->el_line.cursor == el->el_line.lastchar) {
169                         /* if I'm at the end */
170                 if (el->el_map.type == MAP_VI) {
171                         if (el->el_line.cursor == el->el_line.buffer) {
172                                 /* if I'm also at the beginning */
173 #ifdef KSHVI
174                                 return (CC_ERROR);
175 #else
176                                 term_overwrite(el, STReof, 4);
177                                         /* then do a EOF */
178                                 term__flush();
179                                 return (CC_EOF);
180 #endif
181                         } else {
182 #ifdef KSHVI
183                                 el->el_line.cursor--;
184 #else
185                                 return (CC_ERROR);
186 #endif
187                         }
188                 } else {
189                         if (el->el_line.cursor != el->el_line.buffer)
190                                 el->el_line.cursor--;
191                         else
192                                 return (CC_ERROR);
193                 }
194         }
195         c_delafter(el, el->el_state.argument);  /* delete after dot */
196         if (el->el_line.cursor >= el->el_line.lastchar &&
197             el->el_line.cursor > el->el_line.buffer)
198                         /* bounds check */
199                 el->el_line.cursor = el->el_line.lastchar - 1;
200         return (CC_REFRESH);
201 }
202
203
204 /* ed_kill_line():
205  *      Cut to the end of line
206  *      [^K] [^K]
207  */
208 protected el_action_t
209 /*ARGSUSED*/
210 ed_kill_line(EditLine *el, int c)
211 {
212         char *kp, *cp;
213
214         cp = el->el_line.cursor;
215         kp = el->el_chared.c_kill.buf;
216         while (cp < el->el_line.lastchar)
217                 *kp++ = *cp++;  /* copy it */
218         el->el_chared.c_kill.last = kp;
219                         /* zap! -- delete to end */
220         el->el_line.lastchar = el->el_line.cursor;
221         return (CC_REFRESH);
222 }
223
224
225 /* ed_move_to_end():
226  *      Move cursor to the end of line
227  *      [^E] [^E]
228  */
229 protected el_action_t
230 /*ARGSUSED*/
231 ed_move_to_end(EditLine *el, int c)
232 {
233
234         el->el_line.cursor = el->el_line.lastchar;
235         if (el->el_map.type == MAP_VI) {
236 #ifdef VI_MOVE
237                 el->el_line.cursor--;
238 #endif
239                 if (el->el_chared.c_vcmd.action & DELETE) {
240                         cv_delfini(el);
241                         return (CC_REFRESH);
242                 }
243         }
244         return (CC_CURSOR);
245 }
246
247
248 /* ed_move_to_beg():
249  *      Move cursor to the beginning of line
250  *      [^A] [^A]
251  */
252 protected el_action_t
253 /*ARGSUSED*/
254 ed_move_to_beg(EditLine *el, int c)
255 {
256
257         el->el_line.cursor = el->el_line.buffer;
258
259         if (el->el_map.type == MAP_VI) {
260                         /* We want FIRST non space character */
261                 while (isspace((unsigned char) *el->el_line.cursor))
262                         el->el_line.cursor++;
263                 if (el->el_chared.c_vcmd.action & DELETE) {
264                         cv_delfini(el);
265                         return (CC_REFRESH);
266                 }
267         }
268         return (CC_CURSOR);
269 }
270
271
272 /* ed_transpose_chars():
273  *      Exchange the character to the left of the cursor with the one under it
274  *      [^T] [^T]
275  */
276 protected el_action_t
277 ed_transpose_chars(EditLine *el, int c)
278 {
279
280         if (el->el_line.cursor < el->el_line.lastchar) {
281                 if (el->el_line.lastchar <= &el->el_line.buffer[1])
282                         return (CC_ERROR);
283                 else
284                         el->el_line.cursor++;
285         }
286         if (el->el_line.cursor > &el->el_line.buffer[1]) {
287                 /* must have at least two chars entered */
288                 c = el->el_line.cursor[-2];
289                 el->el_line.cursor[-2] = el->el_line.cursor[-1];
290                 el->el_line.cursor[-1] = c;
291                 return (CC_REFRESH);
292         } else
293                 return (CC_ERROR);
294 }
295
296
297 /* ed_next_char():
298  *      Move to the right one character
299  *      [^F] [^F]
300  */
301 protected el_action_t
302 /*ARGSUSED*/
303 ed_next_char(EditLine *el, int c)
304 {
305
306         if (el->el_line.cursor >= el->el_line.lastchar)
307                 return (CC_ERROR);
308
309         el->el_line.cursor += el->el_state.argument;
310         if (el->el_line.cursor > el->el_line.lastchar)
311                 el->el_line.cursor = el->el_line.lastchar;
312
313         if (el->el_map.type == MAP_VI)
314                 if (el->el_chared.c_vcmd.action & DELETE) {
315                         cv_delfini(el);
316                         return (CC_REFRESH);
317                 }
318         return (CC_CURSOR);
319 }
320
321
322 /* ed_prev_word():
323  *      Move to the beginning of the current word
324  *      [M-b] [b]
325  */
326 protected el_action_t
327 /*ARGSUSED*/
328 ed_prev_word(EditLine *el, int c)
329 {
330
331         if (el->el_line.cursor == el->el_line.buffer)
332                 return (CC_ERROR);
333
334         el->el_line.cursor = c__prev_word(el->el_line.cursor,
335             el->el_line.buffer,
336             el->el_state.argument,
337             ce__isword);
338
339         if (el->el_map.type == MAP_VI)
340                 if (el->el_chared.c_vcmd.action & DELETE) {
341                         cv_delfini(el);
342                         return (CC_REFRESH);
343                 }
344         return (CC_CURSOR);
345 }
346
347
348 /* ed_prev_char():
349  *      Move to the left one character
350  *      [^B] [^B]
351  */
352 protected el_action_t
353 /*ARGSUSED*/
354 ed_prev_char(EditLine *el, int c)
355 {
356
357         if (el->el_line.cursor > el->el_line.buffer) {
358                 el->el_line.cursor -= el->el_state.argument;
359                 if (el->el_line.cursor < el->el_line.buffer)
360                         el->el_line.cursor = el->el_line.buffer;
361
362                 if (el->el_map.type == MAP_VI)
363                         if (el->el_chared.c_vcmd.action & DELETE) {
364                                 cv_delfini(el);
365                                 return (CC_REFRESH);
366                         }
367                 return (CC_CURSOR);
368         } else
369                 return (CC_ERROR);
370 }
371
372
373 /* ed_quoted_insert():
374  *      Add the next character typed verbatim
375  *      [^V] [^V]
376  */
377 protected el_action_t
378 ed_quoted_insert(EditLine *el, int c)
379 {
380         int num;
381         char tc;
382
383         tty_quotemode(el);
384         num = el_getc(el, &tc);
385         c = (unsigned char) tc;
386         tty_noquotemode(el);
387         if (num == 1)
388                 return (ed_insert(el, c));
389         else
390                 return (ed_end_of_file(el, 0));
391 }
392
393
394 /* ed_digit():
395  *      Adds to argument or enters a digit
396  */
397 protected el_action_t
398 ed_digit(EditLine *el, int c)
399 {
400
401         if (!isdigit(c))
402                 return (CC_ERROR);
403
404         if (el->el_state.doingarg) {
405                         /* if doing an arg, add this in... */
406                 if (el->el_state.lastcmd == EM_UNIVERSAL_ARGUMENT)
407                         el->el_state.argument = c - '0';
408                 else {
409                         if (el->el_state.argument > 1000000)
410                                 return (CC_ERROR);
411                         el->el_state.argument =
412                             (el->el_state.argument * 10) + (c - '0');
413                 }
414                 return (CC_ARGHACK);
415         } else {
416                 if (el->el_line.lastchar + 1 >= el->el_line.limit) {
417                         if (!ch_enlargebufs(el, 1))
418                                 return (CC_ERROR);
419                 }
420
421                 if (el->el_state.inputmode != MODE_INSERT) {
422                         el->el_chared.c_undo.buf[el->el_chared.c_undo.isize++] =
423                             *el->el_line.cursor;
424                         el->el_chared.c_undo.buf[el->el_chared.c_undo.isize] =
425                             '\0';
426                         c_delafter(el, 1);
427                 }
428                 c_insert(el, 1);
429                 *el->el_line.cursor++ = c;
430                 el->el_state.doingarg = 0;
431                 re_fastaddc(el);
432         }
433         return (CC_NORM);
434 }
435
436
437 /* ed_argument_digit():
438  *      Digit that starts argument
439  *      For ESC-n
440  */
441 protected el_action_t
442 ed_argument_digit(EditLine *el, int c)
443 {
444
445         if (!isdigit(c))
446                 return (CC_ERROR);
447
448         if (el->el_state.doingarg) {
449                 if (el->el_state.argument > 1000000)
450                         return (CC_ERROR);
451                 el->el_state.argument = (el->el_state.argument * 10) +
452                     (c - '0');
453         } else {                /* else starting an argument */
454                 el->el_state.argument = c - '0';
455                 el->el_state.doingarg = 1;
456         }
457         return (CC_ARGHACK);
458 }
459
460
461 /* ed_unassigned():
462  *      Indicates unbound character
463  *      Bound to keys that are not assigned
464  */
465 protected el_action_t
466 /*ARGSUSED*/
467 ed_unassigned(EditLine *el, int c)
468 {
469
470         term_beep(el);
471         term__flush();
472         return (CC_NORM);
473 }
474
475
476 /**
477  ** TTY key handling.
478  **/
479
480 /* ed_tty_sigint():
481  *      Tty interrupt character
482  *      [^C]
483  */
484 protected el_action_t
485 /*ARGSUSED*/
486 ed_tty_sigint(EditLine *el, int c)
487 {
488
489         return (CC_NORM);
490 }
491
492
493 /* ed_tty_dsusp():
494  *      Tty delayed suspend character
495  *      [^Y]
496  */
497 protected el_action_t
498 /*ARGSUSED*/
499 ed_tty_dsusp(EditLine *el, int c)
500 {
501
502         return (CC_NORM);
503 }
504
505
506 /* ed_tty_flush_output():
507  *      Tty flush output characters
508  *      [^O]
509  */
510 protected el_action_t
511 /*ARGSUSED*/
512 ed_tty_flush_output(EditLine *el, int c)
513 {
514
515         return (CC_NORM);
516 }
517
518
519 /* ed_tty_sigquit():
520  *      Tty quit character
521  *      [^\]
522  */
523 protected el_action_t
524 /*ARGSUSED*/
525 ed_tty_sigquit(EditLine *el, int c)
526 {
527
528         return (CC_NORM);
529 }
530
531
532 /* ed_tty_sigtstp():
533  *      Tty suspend character
534  *      [^Z]
535  */
536 protected el_action_t
537 /*ARGSUSED*/
538 ed_tty_sigtstp(EditLine *el, int c)
539 {
540
541         return (CC_NORM);
542 }
543
544
545 /* ed_tty_stop_output():
546  *      Tty disallow output characters
547  *      [^S]
548  */
549 protected el_action_t
550 /*ARGSUSED*/
551 ed_tty_stop_output(EditLine *el, int c)
552 {
553
554         return (CC_NORM);
555 }
556
557
558 /* ed_tty_start_output():
559  *      Tty allow output characters
560  *      [^Q]
561  */
562 protected el_action_t
563 /*ARGSUSED*/
564 ed_tty_start_output(EditLine *el, int c)
565 {
566
567         return (CC_NORM);
568 }
569
570
571 /* ed_newline():
572  *      Execute command
573  *      [^J]
574  */
575 protected el_action_t
576 /*ARGSUSED*/
577 ed_newline(EditLine *el, int c)
578 {
579
580         re_goto_bottom(el);
581         *el->el_line.lastchar++ = '\n';
582         *el->el_line.lastchar = '\0';
583         if (el->el_map.type == MAP_VI)
584                 el->el_chared.c_vcmd.ins = el->el_line.buffer;
585         return (CC_NEWLINE);
586 }
587
588
589 /* ed_delete_prev_char():
590  *      Delete the character to the left of the cursor
591  *      [^?]
592  */
593 protected el_action_t
594 /*ARGSUSED*/
595 ed_delete_prev_char(EditLine *el, int c)
596 {
597
598         if (el->el_line.cursor <= el->el_line.buffer)
599                 return (CC_ERROR);
600
601         c_delbefore(el, el->el_state.argument);
602         el->el_line.cursor -= el->el_state.argument;
603         if (el->el_line.cursor < el->el_line.buffer)
604                 el->el_line.cursor = el->el_line.buffer;
605         return (CC_REFRESH);
606 }
607
608
609 /* ed_clear_screen():
610  *      Clear screen leaving current line at the top
611  *      [^L]
612  */
613 protected el_action_t
614 /*ARGSUSED*/
615 ed_clear_screen(EditLine *el, int c)
616 {
617
618         term_clear_screen(el);  /* clear the whole real screen */
619         re_clear_display(el);   /* reset everything */
620         return (CC_REFRESH);
621 }
622
623
624 /* ed_redisplay():
625  *      Redisplay everything
626  *      ^R
627  */
628 protected el_action_t
629 /*ARGSUSED*/
630 ed_redisplay(EditLine *el, int c)
631 {
632
633         return (CC_REDISPLAY);
634 }
635
636
637 /* ed_start_over():
638  *      Erase current line and start from scratch
639  *      [^G]
640  */
641 protected el_action_t
642 /*ARGSUSED*/
643 ed_start_over(EditLine *el, int c)
644 {
645
646         ch_reset(el);
647         return (CC_REFRESH);
648 }
649
650
651 /* ed_sequence_lead_in():
652  *      First character in a bound sequence
653  *      Placeholder for external keys
654  */
655 protected el_action_t
656 /*ARGSUSED*/
657 ed_sequence_lead_in(EditLine *el, int c)
658 {
659
660         return (CC_NORM);
661 }
662
663
664 /* ed_prev_history():
665  *      Move to the previous history line
666  *      [^P] [k]
667  */
668 protected el_action_t
669 /*ARGSUSED*/
670 ed_prev_history(EditLine *el, int c)
671 {
672         char beep = 0;
673
674         el->el_chared.c_undo.action = NOP;
675         *el->el_line.lastchar = '\0';           /* just in case */
676
677         if (el->el_history.eventno == 0) {      /* save the current buffer
678                                                  * away */
679                 (void) strncpy(el->el_history.buf, el->el_line.buffer,
680                     EL_BUFSIZ);
681                 el->el_history.last = el->el_history.buf +
682                     (el->el_line.lastchar - el->el_line.buffer);
683         }
684         el->el_history.eventno += el->el_state.argument;
685
686         if (hist_get(el) == CC_ERROR) {
687                 beep = 1;
688                 /* el->el_history.eventno was fixed by first call */
689                 (void) hist_get(el);
690         }
691         re_refresh(el);
692         if (beep)
693                 return (CC_ERROR);
694         else
695                 return (CC_NORM);       /* was CC_UP_HIST */
696 }
697
698
699 /* ed_next_history():
700  *      Move to the next history line
701  *      [^N] [j]
702  */
703 protected el_action_t
704 /*ARGSUSED*/
705 ed_next_history(EditLine *el, int c)
706 {
707
708         el->el_chared.c_undo.action = NOP;
709         *el->el_line.lastchar = '\0';   /* just in case */
710
711         el->el_history.eventno -= el->el_state.argument;
712
713         if (el->el_history.eventno < 0) {
714                 el->el_history.eventno = 0;
715                 return (CC_ERROR);/* make it beep */
716         }
717         return (hist_get(el));
718 }
719
720
721 /* ed_search_prev_history():
722  *      Search previous in history for a line matching the current
723  *      next search history [M-P] [K]
724  */
725 protected el_action_t
726 /*ARGSUSED*/
727 ed_search_prev_history(EditLine *el, int c)
728 {
729         const char *hp;
730         int h;
731         bool_t found = 0;
732
733         el->el_chared.c_vcmd.action = NOP;
734         el->el_chared.c_undo.action = NOP;
735         *el->el_line.lastchar = '\0';   /* just in case */
736         if (el->el_history.eventno < 0) {
737 #ifdef DEBUG_EDIT
738                 (void) fprintf(el->el_errfile,
739                     "e_prev_search_hist(): eventno < 0;\n");
740 #endif
741                 el->el_history.eventno = 0;
742                 return (CC_ERROR);
743         }
744         if (el->el_history.eventno == 0) {
745                 (void) strncpy(el->el_history.buf, el->el_line.buffer,
746                     EL_BUFSIZ);
747                 el->el_history.last = el->el_history.buf +
748                     (el->el_line.lastchar - el->el_line.buffer);
749         }
750         if (el->el_history.ref == NULL)
751                 return (CC_ERROR);
752
753         hp = HIST_FIRST(el);
754         if (hp == NULL)
755                 return (CC_ERROR);
756
757         c_setpat(el);           /* Set search pattern !! */
758
759         for (h = 1; h <= el->el_history.eventno; h++)
760                 hp = HIST_NEXT(el);
761
762         while (hp != NULL) {
763 #ifdef SDEBUG
764                 (void) fprintf(el->el_errfile, "Comparing with \"%s\"\n", hp);
765 #endif
766                 if ((strncmp(hp, el->el_line.buffer, (size_t)
767                             (el->el_line.lastchar - el->el_line.buffer)) ||
768                         hp[el->el_line.lastchar - el->el_line.buffer]) &&
769                     c_hmatch(el, hp)) {
770                         found++;
771                         break;
772                 }
773                 h++;
774                 hp = HIST_NEXT(el);
775         }
776
777         if (!found) {
778 #ifdef SDEBUG
779                 (void) fprintf(el->el_errfile, "not found\n");
780 #endif
781                 return (CC_ERROR);
782         }
783         el->el_history.eventno = h;
784
785         return (hist_get(el));
786 }
787
788
789 /* ed_search_next_history():
790  *      Search next in history for a line matching the current
791  *      [M-N] [J]
792  */
793 protected el_action_t
794 /*ARGSUSED*/
795 ed_search_next_history(EditLine *el, int c)
796 {
797         const char *hp;
798         int h;
799         bool_t found = 0;
800
801         el->el_chared.c_vcmd.action = NOP;
802         el->el_chared.c_undo.action = NOP;
803         *el->el_line.lastchar = '\0';   /* just in case */
804
805         if (el->el_history.eventno == 0)
806                 return (CC_ERROR);
807
808         if (el->el_history.ref == NULL)
809                 return (CC_ERROR);
810
811         hp = HIST_FIRST(el);
812         if (hp == NULL)
813                 return (CC_ERROR);
814
815         c_setpat(el);           /* Set search pattern !! */
816
817         for (h = 1; h < el->el_history.eventno && hp; h++) {
818 #ifdef SDEBUG
819                 (void) fprintf(el->el_errfile, "Comparing with \"%s\"\n", hp);
820 #endif
821                 if ((strncmp(hp, el->el_line.buffer, (size_t)
822                             (el->el_line.lastchar - el->el_line.buffer)) ||
823                         hp[el->el_line.lastchar - el->el_line.buffer]) &&
824                     c_hmatch(el, hp))
825                         found = h;
826                 hp = HIST_NEXT(el);
827         }
828
829         if (!found) {           /* is it the current history number? */
830                 if (!c_hmatch(el, el->el_history.buf)) {
831 #ifdef SDEBUG
832                         (void) fprintf(el->el_errfile, "not found\n");
833 #endif
834                         return (CC_ERROR);
835                 }
836         }
837         el->el_history.eventno = found;
838
839         return (hist_get(el));
840 }
841
842
843 /* ed_prev_line():
844  *      Move up one line
845  *      Could be [k] [^p]
846  */
847 protected el_action_t
848 /*ARGSUSED*/
849 ed_prev_line(EditLine *el, int c)
850 {
851         char *ptr;
852         int nchars = c_hpos(el);
853
854         /*
855          * Move to the line requested
856          */
857         if (*(ptr = el->el_line.cursor) == '\n')
858                 ptr--;
859
860         for (; ptr >= el->el_line.buffer; ptr--)
861                 if (*ptr == '\n' && --el->el_state.argument <= 0)
862                         break;
863
864         if (el->el_state.argument > 0)
865                 return (CC_ERROR);
866
867         /*
868          * Move to the beginning of the line
869          */
870         for (ptr--; ptr >= el->el_line.buffer && *ptr != '\n'; ptr--)
871                 continue;
872
873         /*
874          * Move to the character requested
875          */
876         for (ptr++;
877             nchars-- > 0 && ptr < el->el_line.lastchar && *ptr != '\n';
878             ptr++)
879                 continue;
880
881         el->el_line.cursor = ptr;
882         return (CC_CURSOR);
883 }
884
885
886 /* ed_next_line():
887  *      Move down one line
888  *      Could be [j] [^n]
889  */
890 protected el_action_t
891 /*ARGSUSED*/
892 ed_next_line(EditLine *el, int c)
893 {
894         char *ptr;
895         int nchars = c_hpos(el);
896
897         /*
898          * Move to the line requested
899          */
900         for (ptr = el->el_line.cursor; ptr < el->el_line.lastchar; ptr++)
901                 if (*ptr == '\n' && --el->el_state.argument <= 0)
902                         break;
903
904         if (el->el_state.argument > 0)
905                 return (CC_ERROR);
906
907         /*
908          * Move to the character requested
909          */
910         for (ptr++;
911             nchars-- > 0 && ptr < el->el_line.lastchar && *ptr != '\n';
912             ptr++)
913                 continue;
914
915         el->el_line.cursor = ptr;
916         return (CC_CURSOR);
917 }
918
919
920 /* ed_command():
921  *      Editline extended command
922  *      [M-X] [:]
923  */
924 protected el_action_t
925 /*ARGSUSED*/
926 ed_command(EditLine *el, int c)
927 {
928         char tmpbuf[EL_BUFSIZ];
929         int tmplen;
930
931         el->el_line.buffer[0] = '\0';
932         el->el_line.lastchar = el->el_line.buffer;
933         el->el_line.cursor = el->el_line.buffer;
934
935         c_insert(el, 3);        /* prompt + ": " */
936         *el->el_line.cursor++ = '\n';
937         *el->el_line.cursor++ = ':';
938         *el->el_line.cursor++ = ' ';
939         re_refresh(el);
940
941         tmplen = c_gets(el, tmpbuf);
942         tmpbuf[tmplen] = '\0';
943
944         el->el_line.buffer[0] = '\0';
945         el->el_line.lastchar = el->el_line.buffer;
946         el->el_line.cursor = el->el_line.buffer;
947
948         if (parse_line(el, tmpbuf) == -1)
949                 return (CC_ERROR);
950         else
951                 return (CC_REFRESH);
952 }
Note: See TracBrowser for help on using the browser.