da1b9d1c337b882fa500f5a1bdba22185ebef732
[dragonfly.git] / lib / libedit / chared.c
1 /*-
2  * Copyright (c) 1992, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Christos Zoulas of Cornell University.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *      This product includes software developed by the University of
19  *      California, Berkeley and its contributors.
20  * 4. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  *
36  * @(#)chared.c 8.1 (Berkeley) 6/4/93
37  * $DragonFly: src/lib/libedit/chared.c,v 1.6 2005/08/04 17:27:09 drhodus Exp $
38  */
39
40 /*
41  * chared.c: Character editor utilities
42  */
43 #include "sys.h"
44
45 #include <stdlib.h>
46 #include "el.h"
47
48 /* cv_undo():
49  *      Handle state for the vi undo command
50  */
51 protected void
52 cv_undo(EditLine *el, int action, int size, char *ptr)
53 {
54     c_undo_t *vu = &el->el_chared.c_undo;
55     vu->action = action;
56     vu->ptr    = ptr;
57     vu->isize  = size;
58     (void) memcpy(vu->buf, vu->ptr, size);
59 #ifdef DEBUG_UNDO
60     (void) fprintf(el->el_errfile, "Undo buffer \"%s\" size = +%d -%d\n",
61                    vu->ptr, vu->isize, vu->dsize);
62 #endif
63 }
64
65
66 /* c_insert():
67  *      Insert num characters
68  */
69 protected void
70 c_insert(EditLine *el, int num)
71 {
72     char *cp;
73
74     if (el->el_line.lastchar + num >= el->el_line.limit)
75         return;                 /* can't go past end of buffer */
76
77     if (el->el_line.cursor < el->el_line.lastchar) {
78         /* if I must move chars */
79         for (cp = el->el_line.lastchar; cp >= el->el_line.cursor; cp--)
80             cp[num] = *cp;
81     }
82     el->el_line.lastchar += num;
83 } /* end c_insert */
84
85
86 /* c_delafter():
87  *      Delete num characters after the cursor
88  */
89 protected void
90 c_delafter(EditLine *el, int num)
91 {
92
93     if (el->el_line.cursor + num > el->el_line.lastchar)
94         num = el->el_line.lastchar - el->el_line.cursor;
95
96     if (num > 0) {
97         char *cp;
98
99         if (el->el_map.current != el->el_map.emacs)
100             cv_undo(el, INSERT, num, el->el_line.cursor);
101
102         for (cp = el->el_line.cursor; cp <= el->el_line.lastchar; cp++)
103             *cp = cp[num];
104
105         el->el_line.lastchar -= num;
106     }
107 }
108
109
110 /* c_delbefore():
111  *      Delete num characters before the cursor
112  */
113 protected void
114 c_delbefore(EditLine *el, int num)
115 {
116
117     if (el->el_line.cursor - num < el->el_line.buffer)
118         num = el->el_line.cursor - el->el_line.buffer;
119
120     if (num > 0) {
121         char *cp;
122
123         if (el->el_map.current != el->el_map.emacs)
124             cv_undo(el, INSERT, num, el->el_line.cursor - num);
125
126         for (cp = el->el_line.cursor - num; cp <= el->el_line.lastchar; cp++)
127             *cp = cp[num];
128
129         el->el_line.lastchar -= num;
130     }
131 }
132
133
134 /* ce__isword():
135  *      Return if p is part of a word according to emacs
136  */
137 protected int
138 ce__isword(int p)
139 {
140     return isalpha((unsigned char) p) || isdigit((unsigned char) p) || strchr("*?_-.[]~=", p) != NULL;
141 }
142
143
144 /* cv__isword():
145  *      Return type of word for p according to vi
146  */
147 protected int
148 cv__isword(int p)
149 {
150     if (isspace((unsigned char) p))
151         return 0;
152     if ((unsigned char) p == '_' || isalnum((unsigned char) p))
153         return 1;
154     return 2;
155 }
156
157
158 /* c___isword():
159  *      Return if p is part of a space-delimited word (!isspace)
160  */
161 protected int
162 c___isword(int p)
163 {
164     return !isspace((unsigned char) p);
165 }
166
167
168 /* c__prev_word():
169  *      Find the previous word
170  */
171 protected char *
172 c__prev_word(char *p, char *low, int n, int (*wtest)(int))
173 {
174     p--;
175
176     while (n--) {
177         while ((p >= low) && !(*wtest)((unsigned char) *p))
178             p--;
179         while ((p >= low) && (*wtest)((unsigned char) *p))
180             p--;
181     }
182
183     /* cp now points to one character before the word */
184     p++;
185     if (p < low)
186         p = low;
187     /* cp now points where we want it */
188     return p;
189 }
190
191
192 /* c__next_word():
193  *      Find the next word
194  */
195 protected char *
196 c__next_word(char *p, char *high, int n, int (*wtest)(int))
197 {
198     while (n--) {
199         while ((p < high) && !(*wtest)((unsigned char) *p))
200             p++;
201         while ((p < high) && (*wtest)((unsigned char) *p))
202             p++;
203     }
204     if (p > high)
205         p = high;
206     /* p now points where we want it */
207     return p;
208 }
209
210 /* cv_next_word():
211  *      Find the next word vi style
212  */
213 protected char *
214 cv_next_word(EditLine *el, char *p, char *high, int n, int (*wtest)(int))
215 {
216     int test;
217
218     while (n--) {
219         test = (*wtest)((unsigned char) *p);
220         while ((p < high) && (*wtest)((unsigned char) *p) == test)
221             p++;
222         /*
223          * vi historically deletes with cw only the word preserving the
224          * trailing whitespace! This is not what 'w' does..
225          */
226         if (el->el_chared.c_vcmd.action != (DELETE|INSERT))
227             while ((p < high) && isspace((unsigned char) *p))
228                 p++;
229     }
230
231     /* p now points where we want it */
232     if (p > high)
233         return high;
234     else
235         return p;
236 }
237
238
239 /* cv_prev_word():
240  *      Find the previous word vi style
241  */
242 protected char *
243 cv_prev_word(EditLine *el, char *p, char *low, int n, int (*wtest)(int))
244 {
245     int test;
246
247     while (n--) {
248         p--;
249         /*
250          * vi historically deletes with cb only the word preserving the
251          * leading whitespace! This is not what 'b' does..
252          */
253         if (el->el_chared.c_vcmd.action != (DELETE|INSERT))
254             while ((p > low) && isspace((unsigned char) *p))
255                 p--;
256         test = (*wtest)((unsigned char) *p);
257         while ((p >= low) && (*wtest)((unsigned char) *p) == test)
258             p--;
259         p++;
260         while (isspace((unsigned char) *p))
261                 p++;
262     }
263
264     /* p now points where we want it */
265     if (p < low)
266         return low;
267     else
268         return p;
269 }
270
271
272 #ifdef notdef
273 /* c__number():
274  *      Ignore character p points to, return number appearing after that.
275  *      A '$' by itself means a big number; "$-" is for negative; '^' means 1.
276  *      Return p pointing to last char used.
277  */
278 protected char *
279 c__number(
280     char *p,    /* character position */
281     int *num,   /* Return value */
282     int dval,   /* dval is the number to subtract from like $-3 */
283 )
284 {
285     int i;
286     int sign = 1;
287
288     if (*++p == '^') {
289         *num = 1;
290         return p;
291     }
292     if (*p == '$') {
293         if (*++p != '-') {
294             *num = 0x7fffffff;  /* Handle $ */
295             return --p;
296         }
297         sign = -1;              /* Handle $- */
298         ++p;
299     }
300     for (i = 0; isdigit((unsigned char) *p); i = 10 * i + *p++ - '0')
301         continue;
302     *num = (sign < 0 ? dval - i : i);
303     return --p;
304 }
305 #endif
306
307 /* cv_delfini():
308  *      Finish vi delete action
309  */
310 protected void
311 cv_delfini(EditLine *el)
312 {
313     int size;
314     int oaction;
315
316     if (el->el_chared.c_vcmd.action & INSERT)
317         el->el_map.current = el->el_map.key;
318
319     oaction = el->el_chared.c_vcmd.action;
320     el->el_chared.c_vcmd.action = NOP;
321
322     if (el->el_chared.c_vcmd.pos == 0)
323         return;
324
325
326     if (el->el_line.cursor > el->el_chared.c_vcmd.pos) {
327         size = (int) (el->el_line.cursor - el->el_chared.c_vcmd.pos);
328         c_delbefore(el, size);
329         el->el_line.cursor = el->el_chared.c_vcmd.pos;
330         re_refresh_cursor(el);
331     }
332     else if (el->el_line.cursor < el->el_chared.c_vcmd.pos) {
333         size = (int)(el->el_chared.c_vcmd.pos - el->el_line.cursor);
334         c_delafter(el, size);
335     }
336     else {
337         size = 1;
338         c_delafter(el, size);
339     }
340     switch (oaction) {
341     case DELETE|INSERT:
342         el->el_chared.c_undo.action = DELETE|INSERT;
343         break;
344     case DELETE:
345         el->el_chared.c_undo.action = INSERT;
346         break;
347     case NOP:
348     case INSERT:
349     default:
350         abort();
351         break;
352     }
353
354
355     el->el_chared.c_undo.ptr = el->el_line.cursor;
356     el->el_chared.c_undo.dsize = size;
357 }
358
359
360 #ifdef notdef
361 /* ce__endword():
362  *      Go to the end of this word according to emacs
363  */
364 protected char *
365 ce__endword(char *p, char *high, int n)
366 {
367     p++;
368
369     while (n--) {
370         while ((p < high) && isspace((unsigned char) *p))
371             p++;
372         while ((p < high) && !isspace((unsigned char) *p))
373             p++;
374     }
375
376     p--;
377     return p;
378 }
379 #endif
380
381
382 /* cv__endword():
383  *      Go to the end of this word according to vi
384  */
385 protected char *
386 cv__endword(char *p, char *high, int n)
387 {
388     p++;
389
390     while (n--) {
391         while ((p < high) && isspace((unsigned char) *p))
392             p++;
393
394         if (isalnum((unsigned char) *p))
395             while ((p < high) && isalnum((unsigned char) *p))
396                 p++;
397         else
398             while ((p < high) && !(isspace((unsigned char) *p) ||
399                                    isalnum((unsigned char) *p)))
400                 p++;
401     }
402     p--;
403     return p;
404 }
405
406 /* ch_init():
407  *      Initialize the character editor
408  */
409 protected int
410 ch_init(EditLine *el)
411 {
412     el->el_line.buffer              = (char *)  el_malloc(EL_BUFSIZ);
413     (void) memset(el->el_line.buffer, 0, EL_BUFSIZ);
414     el->el_line.cursor              = el->el_line.buffer;
415     el->el_line.lastchar            = el->el_line.buffer;
416     el->el_line.limit               = &el->el_line.buffer[EL_BUFSIZ - 2];
417
418     el->el_chared.c_undo.buf        = (char *)  el_malloc(EL_BUFSIZ);
419     (void) memset(el->el_chared.c_undo.buf, 0, EL_BUFSIZ);
420     el->el_chared.c_undo.action     = NOP;
421     el->el_chared.c_undo.isize      = 0;
422     el->el_chared.c_undo.dsize      = 0;
423     el->el_chared.c_undo.ptr        = el->el_line.buffer;
424
425     el->el_chared.c_vcmd.action     = NOP;
426     el->el_chared.c_vcmd.pos        = el->el_line.buffer;
427     el->el_chared.c_vcmd.ins        = el->el_line.buffer;
428
429     el->el_chared.c_kill.buf        = (char *)  el_malloc(EL_BUFSIZ);
430     (void) memset(el->el_chared.c_kill.buf, 0, EL_BUFSIZ);
431     el->el_chared.c_kill.mark       = el->el_line.buffer;
432     el->el_chared.c_kill.last       = el->el_chared.c_kill.buf;
433
434     el->el_map.current              = el->el_map.key;
435
436     el->el_state.inputmode = MODE_INSERT; /* XXX: save a default */
437     el->el_state.doingarg  = 0;
438     el->el_state.metanext  = 0;
439     el->el_state.argument  = 1;
440     el->el_state.lastcmd   = ED_UNASSIGNED;
441
442     el->el_chared.c_macro.nline     = NULL;
443     el->el_chared.c_macro.level     = -1;
444     el->el_chared.c_macro.macro     = (char **) el_malloc(EL_MAXMACRO *
445                                                           sizeof(char *));
446     return 0;
447 }
448
449 /* ch_reset():
450  *      Reset the character editor
451  */
452 protected void
453 ch_reset(EditLine *el)
454 {
455     el->el_line.cursor              = el->el_line.buffer;
456     el->el_line.lastchar            = el->el_line.buffer;
457
458     el->el_chared.c_undo.action     = NOP;
459     el->el_chared.c_undo.isize      = 0;
460     el->el_chared.c_undo.dsize      = 0;
461     el->el_chared.c_undo.ptr        = el->el_line.buffer;
462
463     el->el_chared.c_vcmd.action     = NOP;
464     el->el_chared.c_vcmd.pos        = el->el_line.buffer;
465     el->el_chared.c_vcmd.ins        = el->el_line.buffer;
466
467     el->el_chared.c_kill.mark       = el->el_line.buffer;
468
469     el->el_map.current              = el->el_map.key;
470
471     el->el_state.inputmode = MODE_INSERT; /* XXX: save a default */
472     el->el_state.doingarg  = 0;
473     el->el_state.metanext  = 0;
474     el->el_state.argument  = 1;
475     el->el_state.lastcmd   = ED_UNASSIGNED;
476
477     el->el_chared.c_macro.level     = -1;
478
479     el->el_history.eventno = 0;
480 }
481
482
483 /* ch_end():
484  *      Free the data structures used by the editor
485  */
486 protected void
487 ch_end(EditLine *el)
488 {
489     el_free((ptr_t) el->el_line.buffer);
490     el->el_line.buffer = NULL;
491     el->el_line.limit = NULL;
492     el_free((ptr_t) el->el_chared.c_undo.buf);
493     el->el_chared.c_undo.buf = NULL;
494     el_free((ptr_t) el->el_chared.c_kill.buf);
495     el->el_chared.c_kill.buf = NULL;
496     el_free((ptr_t) el->el_chared.c_macro.macro);
497     el->el_chared.c_macro.macro = NULL;
498     ch_reset(el);
499 }
500
501
502 /* el_insertstr():
503  *      Insert string at cursorI
504  */
505 public int
506 el_insertstr(EditLine *el, char *s)
507 {
508     int len;
509
510     if ((len = strlen(s)) == 0)
511         return -1;
512     if (el->el_line.lastchar + len >= el->el_line.limit)
513         return -1;
514
515     c_insert(el, len);
516     while (*s)
517         *el->el_line.cursor++ = *s++;
518     return 0;
519 }
520
521
522 /* el_deletestr():
523  *      Delete num characters before the cursor
524  */
525 public void
526 el_deletestr(EditLine *el, int n)
527 {
528     if (n <= 0)
529         return;
530
531     if (el->el_line.cursor < &el->el_line.buffer[n])
532         return;
533
534     c_delbefore(el, n);         /* delete before dot */
535     el->el_line.cursor -= n;
536     if (el->el_line.cursor < el->el_line.buffer)
537         el->el_line.cursor = el->el_line.buffer;
538 }
539
540 /* c_gets():
541  *      Get a string
542  */
543 protected int
544 c_gets(EditLine *el, char *buf)
545 {
546     char ch;
547     int len = 0;
548
549     for (ch = 0; ch == 0;) {
550         if (el_getc(el, &ch) != 1)
551             return ed_end_of_file(el, 0);
552         switch (ch) {
553         case '\010':      /* Delete and backspace */
554         case '\177':
555             if (len > 1) {
556                 *el->el_line.cursor-- = '\0';
557                 el->el_line.lastchar = el->el_line.cursor;
558                 buf[len--] = '\0';
559             }
560             else {
561                 el->el_line.buffer[0] = '\0';
562                 el->el_line.lastchar = el->el_line.buffer;
563                 el->el_line.cursor = el->el_line.buffer;
564                 return CC_REFRESH;
565             }
566             re_refresh(el);
567             ch = 0;
568             break;
569
570         case '\033':      /* ESC */
571         case '\r':      /* Newline */
572         case '\n':
573             break;
574
575         default:
576             if (len >= EL_BUFSIZ)
577                 term_beep(el);
578             else {
579                 buf[len++] = ch;
580                 *el->el_line.cursor++ = ch;
581                 el->el_line.lastchar = el->el_line.cursor;
582             }
583             re_refresh(el);
584             ch = 0;
585             break;
586         }
587     }
588     buf[len] = ch;
589     return len;
590 }
591
592
593 /* c_hpos():
594  *      Return the current horizontal position of the cursor
595  */
596 protected int
597 c_hpos(EditLine *el)
598 {
599     char *ptr;
600
601     /*
602      * Find how many characters till the beginning of this line.
603      */
604     if (el->el_line.cursor == el->el_line.buffer)
605         return 0;
606     else {
607         for (ptr = el->el_line.cursor - 1;
608              ptr >= el->el_line.buffer && *ptr != '\n';
609              ptr--)
610             continue;
611         return el->el_line.cursor - ptr - 1;
612     }
613 }