Update libedit from NetBSD.
[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. Neither the name of the University nor the names of its contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  *
32  * @(#)chared.c 8.1 (Berkeley) 6/4/93
33  * $NetBSD: chared.c,v 1.23 2005/06/01 11:37:52 lukem Exp $
34  * $DragonFly: src/lib/libedit/chared.c,v 1.7 2005/11/13 11:58:30 corecode Exp $
35  */
36
37 #include "config.h"
38
39 /*
40  * chared.c: Character editor utilities
41  */
42 #include <stdlib.h>
43 #include "el.h"
44
45 /* value to leave unused in line buffer */
46 #define EL_LEAVE        2
47
48 /* cv_undo():
49  *      Handle state for the vi undo command
50  */
51 protected void
52 cv_undo(EditLine *el)
53 {
54         c_undo_t *vu = &el->el_chared.c_undo;
55         c_redo_t *r = &el->el_chared.c_redo;
56         unsigned int size;
57
58         /* Save entire line for undo */
59         size = el->el_line.lastchar - el->el_line.buffer;
60         vu->len = size;
61         vu->cursor = el->el_line.cursor - el->el_line.buffer;
62         memcpy(vu->buf, el->el_line.buffer, size);
63
64         /* save command info for redo */
65         r->count = el->el_state.doingarg ? el->el_state.argument : 0;
66         r->action = el->el_chared.c_vcmd.action;
67         r->pos = r->buf;
68         r->cmd = el->el_state.thiscmd;
69         r->ch = el->el_state.thisch;
70 }
71
72 /* cv_yank():
73  *      Save yank/delete data for paste
74  */
75 protected void
76 cv_yank(EditLine *el, const char *ptr, int size)
77 {
78         c_kill_t *k = &el->el_chared.c_kill;
79
80         memcpy(k->buf, ptr, size +0u);
81         k->last = k->buf + size;
82 }
83
84
85 /* c_insert():
86  *      Insert num characters
87  */
88 protected void
89 c_insert(EditLine *el, int num)
90 {
91         char *cp;
92
93         if (el->el_line.lastchar + num >= el->el_line.limit) {
94                 if (!ch_enlargebufs(el, num +0u))
95                         return;         /* can't go past end of buffer */
96         }
97
98         if (el->el_line.cursor < el->el_line.lastchar) {
99                 /* if I must move chars */
100                 for (cp = el->el_line.lastchar; cp >= el->el_line.cursor; cp--)
101                         cp[num] = *cp;
102         }
103         el->el_line.lastchar += num;
104 }
105
106
107 /* c_delafter():
108  *      Delete num characters after the cursor
109  */
110 protected void
111 c_delafter(EditLine *el, int num)
112 {
113
114         if (el->el_line.cursor + num > el->el_line.lastchar)
115                 num = el->el_line.lastchar - el->el_line.cursor;
116
117         if (el->el_map.current != el->el_map.emacs) {
118                 cv_undo(el);
119                 cv_yank(el, el->el_line.cursor, num);
120         }
121
122         if (num > 0) {
123                 char *cp;
124
125                 for (cp = el->el_line.cursor; cp <= el->el_line.lastchar; cp++)
126                         *cp = cp[num];
127
128                 el->el_line.lastchar -= num;
129         }
130 }
131
132
133 /* c_delafter1():
134  *      Delete the character after the cursor, do not yank
135  */
136 protected void
137 c_delafter1(EditLine *el)
138 {
139         char *cp;
140
141         for (cp = el->el_line.cursor; cp <= el->el_line.lastchar; cp++)
142                 *cp = cp[1];
143
144         el->el_line.lastchar--;
145 }
146
147
148 /* c_delbefore():
149  *      Delete num characters before the cursor
150  */
151 protected void
152 c_delbefore(EditLine *el, int num)
153 {
154
155         if (el->el_line.cursor - num < el->el_line.buffer)
156                 num = el->el_line.cursor - el->el_line.buffer;
157
158         if (el->el_map.current != el->el_map.emacs) {
159                 cv_undo(el);
160                 cv_yank(el, el->el_line.cursor - num, num);
161         }
162
163         if (num > 0) {
164                 char *cp;
165
166                 for (cp = el->el_line.cursor - num;
167                     cp <= el->el_line.lastchar;
168                     cp++)
169                         *cp = cp[num];
170
171                 el->el_line.lastchar -= num;
172         }
173 }
174
175
176 /* c_delbefore1():
177  *      Delete the character before the cursor, do not yank
178  */
179 protected void
180 c_delbefore1(EditLine *el)
181 {
182         char *cp;
183
184         for (cp = el->el_line.cursor - 1; cp <= el->el_line.lastchar; cp++)
185                 *cp = cp[1];
186
187         el->el_line.lastchar--;
188 }
189
190
191 /* ce__isword():
192  *      Return if p is part of a word according to emacs
193  */
194 protected int
195 ce__isword(int p)
196 {
197         return (isalnum(p) || strchr("*?_-.[]~=", p) != NULL);
198 }
199
200
201 /* cv__isword():
202  *      Return if p is part of a word according to vi
203  */
204 protected int
205 cv__isword(int p)
206 {
207         if (isalnum(p) || p == '_')
208                 return 1;
209         if (isgraph(p))
210                 return 2;
211         return 0;
212 }
213
214
215 /* cv__isWord():
216  *      Return if p is part of a big word according to vi
217  */
218 protected int
219 cv__isWord(int p)
220 {
221         return (!isspace(p));
222 }
223
224
225 /* c__prev_word():
226  *      Find the previous word
227  */
228 protected char *
229 c__prev_word(char *p, char *low, int n, int (*wtest)(int))
230 {
231         p--;
232
233         while (n--) {
234                 while ((p >= low) && !(*wtest)((unsigned char) *p))
235                         p--;
236                 while ((p >= low) && (*wtest)((unsigned char) *p))
237                         p--;
238         }
239
240         /* cp now points to one character before the word */
241         p++;
242         if (p < low)
243                 p = low;
244         /* cp now points where we want it */
245         return (p);
246 }
247
248
249 /* c__next_word():
250  *      Find the next word
251  */
252 protected char *
253 c__next_word(char *p, char *high, int n, int (*wtest)(int))
254 {
255         while (n--) {
256                 while ((p < high) && !(*wtest)((unsigned char) *p))
257                         p++;
258                 while ((p < high) && (*wtest)((unsigned char) *p))
259                         p++;
260         }
261         if (p > high)
262                 p = high;
263         /* p now points where we want it */
264         return (p);
265 }
266
267 /* cv_next_word():
268  *      Find the next word vi style
269  */
270 protected char *
271 cv_next_word(EditLine *el, char *p, char *high, int n, int (*wtest)(int))
272 {
273         int test;
274
275         while (n--) {
276                 test = (*wtest)((unsigned char) *p);
277                 while ((p < high) && (*wtest)((unsigned char) *p) == test)
278                         p++;
279                 /*
280                  * vi historically deletes with cw only the word preserving the
281                  * trailing whitespace! This is not what 'w' does..
282                  */
283                 if (n || el->el_chared.c_vcmd.action != (DELETE|INSERT))
284                         while ((p < high) && isspace((unsigned char) *p))
285                                 p++;
286         }
287
288         /* p now points where we want it */
289         if (p > high)
290                 return (high);
291         else
292                 return (p);
293 }
294
295
296 /* cv_prev_word():
297  *      Find the previous word vi style
298  */
299 protected char *
300 cv_prev_word(char *p, char *low, int n, int (*wtest)(int))
301 {
302         int test;
303
304         p--;
305         while (n--) {
306                 while ((p > low) && isspace((unsigned char) *p))
307                         p--;
308                 test = (*wtest)((unsigned char) *p);
309                 while ((p >= low) && (*wtest)((unsigned char) *p) == test)
310                         p--;
311         }
312         p++;
313
314         /* p now points where we want it */
315         if (p < low)
316                 return (low);
317         else
318                 return (p);
319 }
320
321
322 #ifdef notdef
323 /* c__number():
324  *      Ignore character p points to, return number appearing after that.
325  *      A '$' by itself means a big number; "$-" is for negative; '^' means 1.
326  *      Return p pointing to last char used.
327  */
328 protected char *
329 c__number(
330     char *p,    /* character position */
331     int *num,   /* Return value */
332     int dval)   /* dval is the number to subtract from like $-3 */
333 {
334         int i;
335         int sign = 1;
336
337         if (*++p == '^') {
338                 *num = 1;
339                 return (p);
340         }
341         if (*p == '$') {
342                 if (*++p != '-') {
343                         *num = 0x7fffffff;      /* Handle $ */
344                         return (--p);
345                 }
346                 sign = -1;                      /* Handle $- */
347                 ++p;
348         }
349         for (i = 0; isdigit((unsigned char) *p); i = 10 * i + *p++ - '0')
350                 continue;
351         *num = (sign < 0 ? dval - i : i);
352         return (--p);
353 }
354 #endif
355
356 /* cv_delfini():
357  *      Finish vi delete action
358  */
359 protected void
360 cv_delfini(EditLine *el)
361 {
362         int size;
363         int action = el->el_chared.c_vcmd.action;
364
365         if (action & INSERT)
366                 el->el_map.current = el->el_map.key;
367
368         if (el->el_chared.c_vcmd.pos == 0)
369                 /* sanity */
370                 return;
371
372         size = el->el_line.cursor - el->el_chared.c_vcmd.pos;
373         if (size == 0)
374                 size = 1;
375         el->el_line.cursor = el->el_chared.c_vcmd.pos;
376         if (action & YANK) {
377                 if (size > 0)
378                         cv_yank(el, el->el_line.cursor, size);
379                 else
380                         cv_yank(el, el->el_line.cursor + size, -size);
381         } else {
382                 if (size > 0) {
383                         c_delafter(el, size);
384                         re_refresh_cursor(el);
385                 } else  {
386                         c_delbefore(el, -size);
387                         el->el_line.cursor += size;
388                 }
389         }
390         el->el_chared.c_vcmd.action = NOP;
391 }
392
393
394 #ifdef notdef
395 /* ce__endword():
396  *      Go to the end of this word according to emacs
397  */
398 protected char *
399 ce__endword(char *p, char *high, int n)
400 {
401         p++;
402
403         while (n--) {
404                 while ((p < high) && isspace((unsigned char) *p))
405                         p++;
406                 while ((p < high) && !isspace((unsigned char) *p))
407                         p++;
408         }
409
410         p--;
411         return (p);
412 }
413 #endif
414
415
416 /* cv__endword():
417  *      Go to the end of this word according to vi
418  */
419 protected char *
420 cv__endword(char *p, char *high, int n, int (*wtest)(int))
421 {
422         int test;
423
424         p++;
425
426         while (n--) {
427                 while ((p < high) && isspace((unsigned char) *p))
428                         p++;
429
430                 test = (*wtest)((unsigned char) *p);
431                 while ((p < high) && (*wtest)((unsigned char) *p) == test)
432                         p++;
433         }
434         p--;
435         return (p);
436 }
437
438 /* ch_init():
439  *      Initialize the character editor
440  */
441 protected int
442 ch_init(EditLine *el)
443 {
444         el->el_line.buffer              = (char *) el_malloc(EL_BUFSIZ);
445         if (el->el_line.buffer == NULL)
446                 return (-1);
447
448         (void) memset(el->el_line.buffer, 0, EL_BUFSIZ);
449         el->el_line.cursor              = el->el_line.buffer;
450         el->el_line.lastchar            = el->el_line.buffer;
451         el->el_line.limit               = &el->el_line.buffer[EL_BUFSIZ - EL_LEAVE];
452
453         el->el_chared.c_undo.buf        = (char *) el_malloc(EL_BUFSIZ);
454         if (el->el_chared.c_undo.buf == NULL)
455                 return (-1);
456         (void) memset(el->el_chared.c_undo.buf, 0, EL_BUFSIZ);
457         el->el_chared.c_undo.len        = -1;
458         el->el_chared.c_undo.cursor     = 0;
459         el->el_chared.c_redo.buf        = (char *) el_malloc(EL_BUFSIZ);
460         if (el->el_chared.c_redo.buf == NULL)
461                 return (-1);
462         el->el_chared.c_redo.pos        = el->el_chared.c_redo.buf;
463         el->el_chared.c_redo.lim        = el->el_chared.c_redo.buf + EL_BUFSIZ;
464         el->el_chared.c_redo.cmd        = ED_UNASSIGNED;
465
466         el->el_chared.c_vcmd.action     = NOP;
467         el->el_chared.c_vcmd.pos        = el->el_line.buffer;
468
469         el->el_chared.c_kill.buf        = (char *) el_malloc(EL_BUFSIZ);
470         if (el->el_chared.c_kill.buf == NULL)
471                 return (-1);
472         (void) memset(el->el_chared.c_kill.buf, 0, EL_BUFSIZ);
473         el->el_chared.c_kill.mark       = el->el_line.buffer;
474         el->el_chared.c_kill.last       = el->el_chared.c_kill.buf;
475
476         el->el_map.current              = el->el_map.key;
477
478         el->el_state.inputmode          = MODE_INSERT; /* XXX: save a default */
479         el->el_state.doingarg           = 0;
480         el->el_state.metanext           = 0;
481         el->el_state.argument           = 1;
482         el->el_state.lastcmd            = ED_UNASSIGNED;
483
484         el->el_chared.c_macro.level     = -1;
485         el->el_chared.c_macro.offset    = 0;
486         el->el_chared.c_macro.macro     = (char **) el_malloc(EL_MAXMACRO *
487             sizeof(char *));
488         if (el->el_chared.c_macro.macro == NULL)
489                 return (-1);
490         return (0);
491 }
492
493 /* ch_reset():
494  *      Reset the character editor
495  */
496 protected void
497 ch_reset(EditLine *el)
498 {
499         el->el_line.cursor              = el->el_line.buffer;
500         el->el_line.lastchar            = el->el_line.buffer;
501
502         el->el_chared.c_undo.len        = -1;
503         el->el_chared.c_undo.cursor     = 0;
504
505         el->el_chared.c_vcmd.action     = NOP;
506         el->el_chared.c_vcmd.pos        = el->el_line.buffer;
507
508         el->el_chared.c_kill.mark       = el->el_line.buffer;
509
510         el->el_map.current              = el->el_map.key;
511
512         el->el_state.inputmode          = MODE_INSERT; /* XXX: save a default */
513         el->el_state.doingarg           = 0;
514         el->el_state.metanext           = 0;
515         el->el_state.argument           = 1;
516         el->el_state.lastcmd            = ED_UNASSIGNED;
517
518         el->el_chared.c_macro.level     = -1;
519
520         el->el_history.eventno          = 0;
521 }
522
523 /* ch_enlargebufs():
524  *      Enlarge line buffer to be able to hold twice as much characters.
525  *      Returns 1 if successful, 0 if not.
526  */
527 protected int
528 ch_enlargebufs(el, addlen)
529         EditLine *el;
530         size_t addlen;
531 {
532         size_t sz, newsz;
533         char *newbuffer, *oldbuf, *oldkbuf;
534
535         sz = el->el_line.limit - el->el_line.buffer + EL_LEAVE;
536         newsz = sz * 2;
537         /*
538          * If newly required length is longer than current buffer, we need
539          * to make the buffer big enough to hold both old and new stuff.
540          */
541         if (addlen > sz) {
542                 while(newsz - sz < addlen)
543                         newsz *= 2;
544         }
545
546         /*
547          * Reallocate line buffer.
548          */
549         newbuffer = el_realloc(el->el_line.buffer, newsz);
550         if (!newbuffer)
551                 return 0;
552
553         /* zero the newly added memory, leave old data in */
554         (void) memset(&newbuffer[sz], 0, newsz - sz);
555             
556         oldbuf = el->el_line.buffer;
557
558         el->el_line.buffer = newbuffer;
559         el->el_line.cursor = newbuffer + (el->el_line.cursor - oldbuf);
560         el->el_line.lastchar = newbuffer + (el->el_line.lastchar - oldbuf);
561         /* don't set new size until all buffers are enlarged */
562         el->el_line.limit  = &newbuffer[sz - EL_LEAVE];
563
564         /*
565          * Reallocate kill buffer.
566          */
567         newbuffer = el_realloc(el->el_chared.c_kill.buf, newsz);
568         if (!newbuffer)
569                 return 0;
570
571         /* zero the newly added memory, leave old data in */
572         (void) memset(&newbuffer[sz], 0, newsz - sz);
573
574         oldkbuf = el->el_chared.c_kill.buf;
575
576         el->el_chared.c_kill.buf = newbuffer;
577         el->el_chared.c_kill.last = newbuffer +
578                                         (el->el_chared.c_kill.last - oldkbuf);
579         el->el_chared.c_kill.mark = el->el_line.buffer +
580                                         (el->el_chared.c_kill.mark - oldbuf);
581
582         /*
583          * Reallocate undo buffer.
584          */
585         newbuffer = el_realloc(el->el_chared.c_undo.buf, newsz);
586         if (!newbuffer)
587                 return 0;
588
589         /* zero the newly added memory, leave old data in */
590         (void) memset(&newbuffer[sz], 0, newsz - sz);
591         el->el_chared.c_undo.buf = newbuffer;
592
593         newbuffer = el_realloc(el->el_chared.c_redo.buf, newsz);
594         if (!newbuffer)
595                 return 0;
596         el->el_chared.c_redo.pos = newbuffer +
597                         (el->el_chared.c_redo.pos - el->el_chared.c_redo.buf);
598         el->el_chared.c_redo.lim = newbuffer +
599                         (el->el_chared.c_redo.lim - el->el_chared.c_redo.buf);
600         el->el_chared.c_redo.buf = newbuffer;
601         
602         if (!hist_enlargebuf(el, sz, newsz))
603                 return 0;
604
605         /* Safe to set enlarged buffer size */
606         el->el_line.limit  = &el->el_line.buffer[newsz - EL_LEAVE];
607         return 1;
608 }
609
610 /* ch_end():
611  *      Free the data structures used by the editor
612  */
613 protected void
614 ch_end(EditLine *el)
615 {
616         el_free((ptr_t) el->el_line.buffer);
617         el->el_line.buffer = NULL;
618         el->el_line.limit = NULL;
619         el_free((ptr_t) el->el_chared.c_undo.buf);
620         el->el_chared.c_undo.buf = NULL;
621         el_free((ptr_t) el->el_chared.c_redo.buf);
622         el->el_chared.c_redo.buf = NULL;
623         el->el_chared.c_redo.pos = NULL;
624         el->el_chared.c_redo.lim = NULL;
625         el->el_chared.c_redo.cmd = ED_UNASSIGNED;
626         el_free((ptr_t) el->el_chared.c_kill.buf);
627         el->el_chared.c_kill.buf = NULL;
628         el_free((ptr_t) el->el_chared.c_macro.macro);
629         el->el_chared.c_macro.macro = NULL;
630         ch_reset(el);
631 }
632
633
634 /* el_insertstr():
635  *      Insert string at cursorI
636  */
637 public int
638 el_insertstr(EditLine *el, const char *s)
639 {
640         size_t len;
641
642         if ((len = strlen(s)) == 0)
643                 return (-1);
644         if (el->el_line.lastchar + len >= el->el_line.limit) {
645                 if (!ch_enlargebufs(el, len))
646                         return (-1);
647         }
648
649         c_insert(el, (int)len);
650         while (*s)
651                 *el->el_line.cursor++ = *s++;
652         return (0);
653 }
654
655
656 /* el_deletestr():
657  *      Delete num characters before the cursor
658  */
659 public void
660 el_deletestr(EditLine *el, int n)
661 {
662         if (n <= 0)
663                 return;
664
665         if (el->el_line.cursor < &el->el_line.buffer[n])
666                 return;
667
668         c_delbefore(el, n);             /* delete before dot */
669         el->el_line.cursor -= n;
670         if (el->el_line.cursor < el->el_line.buffer)
671                 el->el_line.cursor = el->el_line.buffer;
672 }
673
674 /* c_gets():
675  *      Get a string
676  */
677 protected int
678 c_gets(EditLine *el, char *buf, const char *prompt)
679 {
680         char ch;
681         int len;
682         char *cp = el->el_line.buffer;
683
684         if (prompt) {
685                 len = strlen(prompt);
686                 memcpy(cp, prompt, len + 0u);
687                 cp += len;
688         }
689         len = 0;
690
691         for (;;) {
692                 el->el_line.cursor = cp;
693                 *cp = ' ';
694                 el->el_line.lastchar = cp + 1;
695                 re_refresh(el);
696
697                 if (el_getc(el, &ch) != 1) {
698                         ed_end_of_file(el, 0);
699                         len = -1;
700                         break;
701                 }
702
703                 switch (ch) {
704
705                 case 0010:      /* Delete and backspace */
706                 case 0177:
707                         if (len <= 0) {
708                                 len = -1;
709                                 break;
710                         }
711                         cp--;
712                         continue;
713
714                 case 0033:      /* ESC */
715                 case '\r':      /* Newline */
716                 case '\n':
717                         buf[len] = ch;
718                         break;
719
720                 default:
721                         if (len >= EL_BUFSIZ - 16)
722                                 term_beep(el);
723                         else {
724                                 buf[len++] = ch;
725                                 *cp++ = ch;
726                         }
727                         continue;
728                 }
729                 break;
730         }
731
732         el->el_line.buffer[0] = '\0';
733         el->el_line.lastchar = el->el_line.buffer;
734         el->el_line.cursor = el->el_line.buffer;
735         return len;
736 }
737
738
739 /* c_hpos():
740  *      Return the current horizontal position of the cursor
741  */
742 protected int
743 c_hpos(EditLine *el)
744 {
745         char *ptr;
746
747         /*
748          * Find how many characters till the beginning of this line.
749          */
750         if (el->el_line.cursor == el->el_line.buffer)
751                 return (0);
752         else {
753                 for (ptr = el->el_line.cursor - 1;
754                      ptr >= el->el_line.buffer && *ptr != '\n';
755                      ptr--)
756                         continue;
757                 return (el->el_line.cursor - ptr - 1);
758         }
759 }