chared.c revision 1.15
1 /* $NetBSD: chared.c,v 1.15 2002/03/18 16:00:50 christos 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 "config.h" 40 #if !defined(lint) && !defined(SCCSID) 41 #if 0 42 static char sccsid[] = "@(#)chared.c 8.1 (Berkeley) 6/4/93"; 43 #else 44 __RCSID("$NetBSD: chared.c,v 1.15 2002/03/18 16:00:50 christos Exp $"); 45 #endif 46 #endif /* not lint && not SCCSID */ 47 48 /* 49 * chared.c: Character editor utilities 50 */ 51 #include <stdlib.h> 52 #include "el.h" 53 54 /* value to leave unused in line buffer */ 55 #define EL_LEAVE 2 56 57 /* cv_undo(): 58 * Handle state for the vi undo command 59 */ 60 protected void 61 cv_undo(EditLine *el,int action, size_t size, char *ptr) 62 { 63 c_undo_t *vu = &el->el_chared.c_undo; 64 vu->action = action; 65 vu->ptr = ptr; 66 vu->isize = size; 67 (void) memcpy(vu->buf, vu->ptr, size); 68 #ifdef DEBUG_UNDO 69 (void) fprintf(el->el_errfile, "Undo buffer \"%s\" size = +%d -%d\n", 70 vu->ptr, vu->isize, vu->dsize); 71 #endif 72 } 73 74 75 /* c_insert(): 76 * Insert num characters 77 */ 78 protected void 79 c_insert(EditLine *el, int num) 80 { 81 char *cp; 82 83 if (el->el_line.lastchar + num >= el->el_line.limit) 84 return; /* can't go past end of buffer */ 85 86 if (el->el_line.cursor < el->el_line.lastchar) { 87 /* if I must move chars */ 88 for (cp = el->el_line.lastchar; cp >= el->el_line.cursor; cp--) 89 cp[num] = *cp; 90 } 91 el->el_line.lastchar += num; 92 } 93 94 95 /* c_delafter(): 96 * Delete num characters after the cursor 97 */ 98 protected void 99 c_delafter(EditLine *el, int num) 100 { 101 102 if (el->el_line.cursor + num > el->el_line.lastchar) 103 num = el->el_line.lastchar - el->el_line.cursor; 104 105 if (num > 0) { 106 char *cp; 107 108 if (el->el_map.current != el->el_map.emacs) 109 cv_undo(el, INSERT, (size_t)num, el->el_line.cursor); 110 111 for (cp = el->el_line.cursor; cp <= el->el_line.lastchar; cp++) 112 *cp = cp[num]; 113 114 el->el_line.lastchar -= num; 115 } 116 } 117 118 119 /* c_delbefore(): 120 * Delete num characters before the cursor 121 */ 122 protected void 123 c_delbefore(EditLine *el, int num) 124 { 125 126 if (el->el_line.cursor - num < el->el_line.buffer) 127 num = el->el_line.cursor - el->el_line.buffer; 128 129 if (num > 0) { 130 char *cp; 131 132 if (el->el_map.current != el->el_map.emacs) 133 cv_undo(el, INSERT, (size_t)num, 134 el->el_line.cursor - num); 135 136 for (cp = el->el_line.cursor - num; 137 cp <= el->el_line.lastchar; 138 cp++) 139 *cp = cp[num]; 140 141 el->el_line.lastchar -= num; 142 } 143 } 144 145 146 /* ce__isword(): 147 * Return if p is part of a word according to emacs 148 */ 149 protected int 150 ce__isword(int p) 151 { 152 return (isalpha(p) || isdigit(p) || strchr("*?_-.[]~=", p) != NULL); 153 } 154 155 156 /* cv__isword(): 157 * Return if p is part of a word according to vi 158 */ 159 protected int 160 cv__isword(int p) 161 { 162 return (!isspace(p)); 163 } 164 165 166 /* c__prev_word(): 167 * Find the previous word 168 */ 169 protected char * 170 c__prev_word(char *p, char *low, int n, int (*wtest)(int)) 171 { 172 p--; 173 174 while (n--) { 175 while ((p >= low) && !(*wtest)((unsigned char) *p)) 176 p--; 177 while ((p >= low) && (*wtest)((unsigned char) *p)) 178 p--; 179 } 180 181 /* cp now points to one character before the word */ 182 p++; 183 if (p < low) 184 p = low; 185 /* cp now points where we want it */ 186 return (p); 187 } 188 189 190 /* c__next_word(): 191 * Find the next word 192 */ 193 protected char * 194 c__next_word(char *p, char *high, int n, int (*wtest)(int)) 195 { 196 while (n--) { 197 while ((p < high) && !(*wtest)((unsigned char) *p)) 198 p++; 199 while ((p < high) && (*wtest)((unsigned char) *p)) 200 p++; 201 } 202 if (p > high) 203 p = high; 204 /* p now points where we want it */ 205 return (p); 206 } 207 208 /* cv_next_word(): 209 * Find the next word vi style 210 */ 211 protected char * 212 cv_next_word(EditLine *el, char *p, char *high, int n, int (*wtest)(int)) 213 { 214 int test; 215 216 while (n--) { 217 test = (*wtest)((unsigned char) *p); 218 while ((p < high) && (*wtest)((unsigned char) *p) == test) 219 p++; 220 /* 221 * vi historically deletes with cw only the word preserving the 222 * trailing whitespace! This is not what 'w' does.. 223 */ 224 if (el->el_chared.c_vcmd.action != (DELETE|INSERT)) 225 while ((p < high) && isspace((unsigned char) *p)) 226 p++; 227 } 228 229 /* p now points where we want it */ 230 if (p > high) 231 return (high); 232 else 233 return (p); 234 } 235 236 237 /* cv_prev_word(): 238 * Find the previous word vi style 239 */ 240 protected char * 241 cv_prev_word(EditLine *el, char *p, char *low, int n, int (*wtest)(int)) 242 { 243 int test; 244 245 while (n--) { 246 p--; 247 /* 248 * vi historically deletes with cb only the word preserving the 249 * leading whitespace! This is not what 'b' does.. 250 */ 251 if (el->el_chared.c_vcmd.action != (DELETE|INSERT)) 252 while ((p > low) && isspace((unsigned char) *p)) 253 p--; 254 test = (*wtest)((unsigned char) *p); 255 while ((p >= low) && (*wtest)((unsigned char) *p) == test) 256 p--; 257 p++; 258 while (isspace((unsigned char) *p)) 259 p++; 260 } 261 262 /* p now points where we want it */ 263 if (p < low) 264 return (low); 265 else 266 return (p); 267 } 268 269 270 #ifdef notdef 271 /* c__number(): 272 * Ignore character p points to, return number appearing after that. 273 * A '$' by itself means a big number; "$-" is for negative; '^' means 1. 274 * Return p pointing to last char used. 275 */ 276 protected char * 277 c__number( 278 char *p, /* character position */ 279 int *num, /* Return value */ 280 int dval) /* dval is the number to subtract from like $-3 */ 281 { 282 int i; 283 int sign = 1; 284 285 if (*++p == '^') { 286 *num = 1; 287 return (p); 288 } 289 if (*p == '$') { 290 if (*++p != '-') { 291 *num = 0x7fffffff; /* Handle $ */ 292 return (--p); 293 } 294 sign = -1; /* Handle $- */ 295 ++p; 296 } 297 for (i = 0; isdigit((unsigned char) *p); i = 10 * i + *p++ - '0') 298 continue; 299 *num = (sign < 0 ? dval - i : i); 300 return (--p); 301 } 302 #endif 303 304 /* cv_delfini(): 305 * Finish vi delete action 306 */ 307 protected void 308 cv_delfini(EditLine *el) 309 { 310 int size; 311 int oaction; 312 313 if (el->el_chared.c_vcmd.action & INSERT) 314 el->el_map.current = el->el_map.key; 315 316 oaction = el->el_chared.c_vcmd.action; 317 el->el_chared.c_vcmd.action = NOP; 318 319 if (el->el_chared.c_vcmd.pos == 0) 320 return; 321 322 323 if (el->el_line.cursor > el->el_chared.c_vcmd.pos) { 324 size = (int) (el->el_line.cursor - el->el_chared.c_vcmd.pos); 325 c_delbefore(el, size); 326 el->el_line.cursor = el->el_chared.c_vcmd.pos; 327 re_refresh_cursor(el); 328 } else if (el->el_line.cursor < el->el_chared.c_vcmd.pos) { 329 size = (int)(el->el_chared.c_vcmd.pos - el->el_line.cursor); 330 c_delafter(el, size); 331 } else { 332 size = 1; 333 c_delafter(el, size); 334 } 335 switch (oaction) { 336 case DELETE|INSERT: 337 el->el_chared.c_undo.action = DELETE|INSERT; 338 break; 339 case DELETE: 340 el->el_chared.c_undo.action = INSERT; 341 break; 342 case NOP: 343 case INSERT: 344 default: 345 EL_ABORT((el->el_errfile, "Bad oaction %d\n", oaction)); 346 break; 347 } 348 349 350 el->el_chared.c_undo.ptr = el->el_line.cursor; 351 el->el_chared.c_undo.dsize = size; 352 } 353 354 355 #ifdef notdef 356 /* ce__endword(): 357 * Go to the end of this word according to emacs 358 */ 359 protected char * 360 ce__endword(char *p, char *high, int n) 361 { 362 p++; 363 364 while (n--) { 365 while ((p < high) && isspace((unsigned char) *p)) 366 p++; 367 while ((p < high) && !isspace((unsigned char) *p)) 368 p++; 369 } 370 371 p--; 372 return (p); 373 } 374 #endif 375 376 377 /* cv__endword(): 378 * Go to the end of this word according to vi 379 */ 380 protected char * 381 cv__endword(char *p, char *high, int n) 382 { 383 p++; 384 385 while (n--) { 386 while ((p < high) && isspace((unsigned char) *p)) 387 p++; 388 389 if (isalnum((unsigned char) *p)) 390 while ((p < high) && isalnum((unsigned char) *p)) 391 p++; 392 else 393 while ((p < high) && !(isspace((unsigned char) *p) || 394 isalnum((unsigned char) *p))) 395 p++; 396 } 397 p--; 398 return (p); 399 } 400 401 /* ch_init(): 402 * Initialize the character editor 403 */ 404 protected int 405 ch_init(EditLine *el) 406 { 407 el->el_line.buffer = (char *) el_malloc(EL_BUFSIZ); 408 if (el->el_line.buffer == NULL) 409 return (-1); 410 411 (void) memset(el->el_line.buffer, 0, EL_BUFSIZ); 412 el->el_line.cursor = el->el_line.buffer; 413 el->el_line.lastchar = el->el_line.buffer; 414 el->el_line.limit = &el->el_line.buffer[EL_BUFSIZ - 2]; 415 416 el->el_chared.c_undo.buf = (char *) el_malloc(EL_BUFSIZ); 417 if (el->el_chared.c_undo.buf == NULL) 418 return (-1); 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 if (el->el_chared.c_kill.buf == NULL) 431 return (-1); 432 (void) memset(el->el_chared.c_kill.buf, 0, EL_BUFSIZ); 433 el->el_chared.c_kill.mark = el->el_line.buffer; 434 el->el_chared.c_kill.last = el->el_chared.c_kill.buf; 435 436 el->el_map.current = el->el_map.key; 437 438 el->el_state.inputmode = MODE_INSERT; /* XXX: save a default */ 439 el->el_state.doingarg = 0; 440 el->el_state.metanext = 0; 441 el->el_state.argument = 1; 442 el->el_state.lastcmd = ED_UNASSIGNED; 443 444 el->el_chared.c_macro.nline = NULL; 445 el->el_chared.c_macro.level = -1; 446 el->el_chared.c_macro.macro = (char **) el_malloc(EL_MAXMACRO * 447 sizeof(char *)); 448 if (el->el_chared.c_macro.macro == NULL) 449 return (-1); 450 return (0); 451 } 452 453 /* ch_reset(): 454 * Reset the character editor 455 */ 456 protected void 457 ch_reset(EditLine *el) 458 { 459 el->el_line.cursor = el->el_line.buffer; 460 el->el_line.lastchar = el->el_line.buffer; 461 462 el->el_chared.c_undo.action = NOP; 463 el->el_chared.c_undo.isize = 0; 464 el->el_chared.c_undo.dsize = 0; 465 el->el_chared.c_undo.ptr = el->el_line.buffer; 466 467 el->el_chared.c_vcmd.action = NOP; 468 el->el_chared.c_vcmd.pos = el->el_line.buffer; 469 el->el_chared.c_vcmd.ins = el->el_line.buffer; 470 471 el->el_chared.c_kill.mark = el->el_line.buffer; 472 473 el->el_map.current = el->el_map.key; 474 475 el->el_state.inputmode = MODE_INSERT; /* XXX: save a default */ 476 el->el_state.doingarg = 0; 477 el->el_state.metanext = 0; 478 el->el_state.argument = 1; 479 el->el_state.lastcmd = ED_UNASSIGNED; 480 481 el->el_chared.c_macro.level = -1; 482 483 el->el_history.eventno = 0; 484 } 485 486 /* ch_enlargebufs(): 487 * Enlarge line buffer to be able to hold twice as much characters. 488 * Returns 1 if successful, 0 if not. 489 */ 490 protected int 491 ch_enlargebufs(el, addlen) 492 EditLine *el; 493 size_t addlen; 494 { 495 size_t sz, newsz; 496 char *newbuffer, *oldbuf, *oldkbuf; 497 498 sz = el->el_line.limit - el->el_line.buffer + EL_LEAVE; 499 newsz = sz * 2; 500 /* 501 * If newly required length is longer than current buffer, we need 502 * to make the buffer big enough to hold both old and new stuff. 503 */ 504 if (addlen > sz) { 505 while(newsz - sz < addlen) 506 newsz *= 2; 507 } 508 509 /* 510 * Reallocate line buffer. 511 */ 512 newbuffer = el_realloc(el->el_line.buffer, newsz); 513 if (!newbuffer) 514 return 0; 515 516 /* zero the newly added memory, leave old data in */ 517 (void) memset(&newbuffer[sz], 0, newsz - sz); 518 519 oldbuf = el->el_line.buffer; 520 521 el->el_line.buffer = newbuffer; 522 el->el_line.cursor = newbuffer + (el->el_line.cursor - oldbuf); 523 el->el_line.lastchar = newbuffer + (el->el_line.lastchar - oldbuf); 524 el->el_line.limit = &newbuffer[newsz - EL_LEAVE]; 525 526 /* 527 * Reallocate kill buffer. 528 */ 529 newbuffer = el_realloc(el->el_chared.c_kill.buf, newsz); 530 if (!newbuffer) 531 return 0; 532 533 /* zero the newly added memory, leave old data in */ 534 (void) memset(&newbuffer[sz], 0, newsz - sz); 535 536 oldkbuf = el->el_chared.c_kill.buf; 537 538 el->el_chared.c_kill.buf = newbuffer; 539 el->el_chared.c_kill.last = newbuffer + 540 (el->el_chared.c_kill.last - oldkbuf); 541 el->el_chared.c_kill.mark = el->el_line.buffer + 542 (el->el_chared.c_kill.mark - oldbuf); 543 544 /* 545 * Reallocate undo buffer. 546 */ 547 newbuffer = el_realloc(el->el_chared.c_undo.buf, newsz); 548 if (!newbuffer) 549 return 0; 550 551 /* zero the newly added memory, leave old data in */ 552 (void) memset(&newbuffer[sz], 0, newsz - sz); 553 554 el->el_chared.c_undo.ptr = el->el_line.buffer + 555 (el->el_chared.c_undo.ptr - oldbuf); 556 el->el_chared.c_undo.buf = newbuffer; 557 558 if (!hist_enlargebuf(el, sz, newsz)) 559 return 0; 560 561 return 1; 562 } 563 564 /* ch_end(): 565 * Free the data structures used by the editor 566 */ 567 protected void 568 ch_end(EditLine *el) 569 { 570 el_free((ptr_t) el->el_line.buffer); 571 el->el_line.buffer = NULL; 572 el->el_line.limit = NULL; 573 el_free((ptr_t) el->el_chared.c_undo.buf); 574 el->el_chared.c_undo.buf = NULL; 575 el_free((ptr_t) el->el_chared.c_kill.buf); 576 el->el_chared.c_kill.buf = NULL; 577 el_free((ptr_t) el->el_chared.c_macro.macro); 578 el->el_chared.c_macro.macro = NULL; 579 ch_reset(el); 580 } 581 582 583 /* el_insertstr(): 584 * Insert string at cursorI 585 */ 586 public int 587 el_insertstr(EditLine *el, const char *s) 588 { 589 size_t len; 590 591 if ((len = strlen(s)) == 0) 592 return (-1); 593 if (el->el_line.lastchar + len >= el->el_line.limit) { 594 if (!ch_enlargebufs(el, len)) 595 return (-1); 596 } 597 598 c_insert(el, (int)len); 599 while (*s) 600 *el->el_line.cursor++ = *s++; 601 return (0); 602 } 603 604 605 /* el_deletestr(): 606 * Delete num characters before the cursor 607 */ 608 public void 609 el_deletestr(EditLine *el, int n) 610 { 611 if (n <= 0) 612 return; 613 614 if (el->el_line.cursor < &el->el_line.buffer[n]) 615 return; 616 617 c_delbefore(el, n); /* delete before dot */ 618 el->el_line.cursor -= n; 619 if (el->el_line.cursor < el->el_line.buffer) 620 el->el_line.cursor = el->el_line.buffer; 621 } 622 623 /* c_gets(): 624 * Get a string 625 */ 626 protected int 627 c_gets(EditLine *el, char *buf) 628 { 629 char ch; 630 int len = 0; 631 632 for (ch = 0; ch == 0;) { 633 if (el_getc(el, &ch) != 1) 634 return (ed_end_of_file(el, 0)); 635 switch (ch) { 636 case 0010: /* Delete and backspace */ 637 case 0177: 638 if (len > 1) { 639 *el->el_line.cursor-- = '\0'; 640 el->el_line.lastchar = el->el_line.cursor; 641 buf[len--] = '\0'; 642 } else { 643 el->el_line.buffer[0] = '\0'; 644 el->el_line.lastchar = el->el_line.buffer; 645 el->el_line.cursor = el->el_line.buffer; 646 return (CC_REFRESH); 647 } 648 re_refresh(el); 649 ch = 0; 650 break; 651 652 case 0033: /* ESC */ 653 case '\r': /* Newline */ 654 case '\n': 655 break; 656 657 default: 658 if (len >= EL_BUFSIZ) 659 term_beep(el); 660 else { 661 buf[len++] = ch; 662 *el->el_line.cursor++ = ch; 663 el->el_line.lastchar = el->el_line.cursor; 664 } 665 re_refresh(el); 666 ch = 0; 667 break; 668 } 669 } 670 buf[len] = ch; 671 return (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 char *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 (el->el_line.cursor - ptr - 1); 694 } 695 } 696
Indexes created Fri Sep 26 08:10:20 GMT 2025