lib/libedit/chared.c

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