1 /* $NetBSD: read.c,v 1.54 2009/12/31 15:58:26 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. Neither the name of the University nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 35 #include "config.h" 36 #if !defined(lint) && !defined(SCCSID) 37 #if 0 38 static char sccsid[] = "@(#)read.c 8.1 (Berkeley) 6/4/93"; 39 #else 40 __RCSID("$NetBSD: read.c,v 1.54 2009/12/31 15:58:26 christos Exp $"); 41 #endif 42 #endif /* not lint && not SCCSID */ 43 44 /* 45 * read.c: Clean this junk up! This is horrible code. 46 * Terminal read functions 47 */ 48 #include <errno.h> 49 #include <fcntl.h> 50 #include <unistd.h> 51 #include <stdlib.h> 52 #include <limits.h> 53 #include "el.h" 54 55 #define OKCMD -1 /* must be -1! */ 56 57 private int read__fixio(int, int); 58 private int read_preread(EditLine *); 59 private int read_char(EditLine *, Char *); 60 private int read_getcmd(EditLine *, el_action_t *, Char *); 61 private void read_pop(c_macro_t *); 62 63 /* read_init(): 64 * Initialize the read stuff 65 */ 66 protected int 67 read_init(EditLine *el) 68 { 69 /* builtin read_char */ 70 el->el_read.read_char = read_char; 71 return 0; 72 } 73 74 75 /* el_read_setfn(): 76 * Set the read char function to the one provided. 77 * If it is set to EL_BUILTIN_GETCFN, then reset to the builtin one. 78 */ 79 protected int 80 el_read_setfn(EditLine *el, el_rfunc_t rc) 81 { 82 el->el_read.read_char = (rc == EL_BUILTIN_GETCFN) ? read_char : rc; 83 return 0; 84 } 85 86 87 /* el_read_getfn(): 88 * return the current read char function, or EL_BUILTIN_GETCFN 89 * if it is the default one 90 */ 91 protected el_rfunc_t 92 el_read_getfn(EditLine *el) 93 { 94 return (el->el_read.read_char == read_char) ? 95 EL_BUILTIN_GETCFN : el->el_read.read_char; 96 } 97 98 99 #ifndef MIN 100 #define MIN(A,B) ((A) < (B) ? (A) : (B)) 101 #endif 102 103 #ifdef DEBUG_EDIT 104 private void 105 read_debug(EditLine *el) 106 { 107 108 if (el->el_line.cursor > el->el_line.lastchar) 109 (void) fprintf(el->el_errfile, "cursor > lastchar\r\n"); 110 if (el->el_line.cursor < el->el_line.buffer) 111 (void) fprintf(el->el_errfile, "cursor < buffer\r\n"); 112 if (el->el_line.cursor > el->el_line.limit) 113 (void) fprintf(el->el_errfile, "cursor > limit\r\n"); 114 if (el->el_line.lastchar > el->el_line.limit) 115 (void) fprintf(el->el_errfile, "lastchar > limit\r\n"); 116 if (el->el_line.limit != &el->el_line.buffer[EL_BUFSIZ - 2]) 117 (void) fprintf(el->el_errfile, "limit != &buffer[EL_BUFSIZ-2]\r\n"); 118 } 119 #endif /* DEBUG_EDIT */ 120 121 122 /* read__fixio(): 123 * Try to recover from a read error 124 */ 125 /* ARGSUSED */ 126 private int 127 read__fixio(int fd __attribute__((__unused__)), int e) 128 { 129 130 switch (e) { 131 case -1: /* Make sure that the code is reachable */ 132 133 #ifdef EWOULDBLOCK 134 case EWOULDBLOCK: 135 #ifndef TRY_AGAIN 136 #define TRY_AGAIN 137 #endif 138 #endif /* EWOULDBLOCK */ 139 140 #if defined(POSIX) && defined(EAGAIN) 141 #if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN 142 case EAGAIN: 143 #ifndef TRY_AGAIN 144 #define TRY_AGAIN 145 #endif 146 #endif /* EWOULDBLOCK && EWOULDBLOCK != EAGAIN */ 147 #endif /* POSIX && EAGAIN */ 148 149 e = 0; 150 #ifdef TRY_AGAIN 151 #if defined(F_SETFL) && defined(O_NDELAY) 152 if ((e = fcntl(fd, F_GETFL, 0)) == -1) 153 return (-1); 154 155 if (fcntl(fd, F_SETFL, e & ~O_NDELAY) == -1) 156 return (-1); 157 else 158 e = 1; 159 #endif /* F_SETFL && O_NDELAY */ 160 161 #ifdef FIONBIO 162 { 163 int zero = 0; 164 165 if (ioctl(fd, FIONBIO, (ioctl_t) & zero) == -1) 166 return (-1); 167 else 168 e = 1; 169 } 170 #endif /* FIONBIO */ 171 172 #endif /* TRY_AGAIN */ 173 return (e ? 0 : -1); 174 175 case EINTR: 176 return (-1); 177 178 default: 179 return (-1); 180 } 181 } 182 183 184 /* read_preread(): 185 * Try to read the stuff in the input queue; 186 */ 187 private int 188 read_preread(EditLine *el) 189 { 190 int chrs = 0; 191 192 if (el->el_tty.t_mode == ED_IO) 193 return (0); 194 195 #ifndef WIDECHAR 196 /* FIONREAD attempts to buffer up multiple bytes, and to make that work 197 * properly with partial wide/UTF-8 characters would need some careful work. */ 198 #ifdef FIONREAD 199 (void) ioctl(el->el_infd, FIONREAD, (ioctl_t) & chrs); 200 if (chrs > 0) { 201 char buf[EL_BUFSIZ]; 202 203 chrs = read(el->el_infd, buf, 204 (size_t) MIN(chrs, EL_BUFSIZ - 1)); 205 if (chrs > 0) { 206 buf[chrs] = '\0'; 207 el_push(el, buf); 208 } 209 } 210 #endif /* FIONREAD */ 211 #endif 212 return (chrs > 0); 213 } 214 215 216 /* el_push(): 217 * Push a macro 218 */ 219 public void 220 FUN(el,push)(EditLine *el, const Char *str) 221 { 222 c_macro_t *ma = &el->el_chared.c_macro; 223 224 if (str != NULL && ma->level + 1 < EL_MAXMACRO) { 225 ma->level++; 226 if ((ma->macro[ma->level] = Strdup(str)) != NULL) 227 return; 228 ma->level--; 229 } 230 term_beep(el); 231 term__flush(el); 232 } 233 234 235 /* read_getcmd(): 236 * Return next command from the input stream. 237 * Character values > 255 are not looked up in the map, but inserted. 238 */ 239 private int 240 read_getcmd(EditLine *el, el_action_t *cmdnum, Char *ch) 241 { 242 el_action_t cmd; 243 int num; 244 245 el->el_errno = 0; 246 do { 247 if ((num = FUN(el,getc)(el, ch)) != 1) {/* if EOF or error */ 248 el->el_errno = num == 0 ? 0 : errno; 249 return (num); 250 } 251 252 #ifdef KANJI 253 if ((*ch & 0200)) { 254 el->el_state.metanext = 0; 255 cmd = CcViMap[' ']; 256 break; 257 } else 258 #endif /* KANJI */ 259 260 if (el->el_state.metanext) { 261 el->el_state.metanext = 0; 262 *ch |= 0200; 263 } 264 #ifdef WIDECHAR 265 if (*ch >= N_KEYS) 266 cmd = ED_INSERT; 267 else 268 #endif 269 cmd = el->el_map.current[(unsigned char) *ch]; 270 if (cmd == ED_SEQUENCE_LEAD_IN) { 271 key_value_t val; 272 switch (key_get(el, ch, &val)) { 273 case XK_CMD: 274 cmd = val.cmd; 275 break; 276 case XK_STR: 277 FUN(el,push)(el, val.str); 278 break; 279 #ifdef notyet 280 case XK_EXE: 281 /* XXX: In the future to run a user function */ 282 RunCommand(val.str); 283 break; 284 #endif 285 default: 286 EL_ABORT((el->el_errfile, "Bad XK_ type \n")); 287 break; 288 } 289 } 290 if (el->el_map.alt == NULL) 291 el->el_map.current = el->el_map.key; 292 } while (cmd == ED_SEQUENCE_LEAD_IN); 293 *cmdnum = cmd; 294 return (OKCMD); 295 } 296 297 #ifdef WIDECHAR 298 /* utf8_islead(): 299 * Test whether a byte is a leading byte of a UTF-8 sequence. 300 */ 301 private int 302 utf8_islead(unsigned char c) 303 { 304 return (c < 0x80) || /* single byte char */ 305 (c >= 0xc2 && c <= 0xf4); /* start of multibyte sequence */ 306 } 307 #endif 308 309 /* read_char(): 310 * Read a character from the tty. 311 */ 312 private int 313 read_char(EditLine *el, Char *cp) 314 { 315 ssize_t num_read; 316 int tried = 0; 317 char cbuf[MB_LEN_MAX]; 318 int cbp = 0; 319 int bytes = 0; 320 321 again: 322 el->el_signal->sig_no = 0; 323 while ((num_read = read(el->el_infd, cbuf + cbp, 1)) == -1) { 324 if (el->el_signal->sig_no == SIGCONT) { 325 sig_set(el); 326 el_set(el, EL_REFRESH); 327 goto again; 328 } 329 if (!tried && read__fixio(el->el_infd, errno) == 0) 330 tried = 1; 331 else { 332 *cp = '\0'; 333 return (-1); 334 } 335 } 336 337 #ifdef WIDECHAR 338 if (el->el_flags & CHARSET_IS_UTF8) { 339 if (!utf8_islead((unsigned char)cbuf[0])) 340 goto again; /* discard the byte we read and try again */ 341 ++cbp; 342 if ((bytes = ct_mbtowc(cp, cbuf, cbp)) == -1) { 343 ct_mbtowc_reset; 344 if (cbp >= MB_LEN_MAX) { /* "shouldn't happen" */ 345 *cp = '\0'; 346 return (-1); 347 } 348 goto again; 349 } 350 } else /* we don't support other multibyte charsets */ 351 #endif 352 *cp = (unsigned char)cbuf[0]; 353 354 if ((el->el_flags & IGNORE_EXTCHARS) && bytes > 1) { 355 cbp = 0; /* skip this character */ 356 goto again; 357 } 358 359 return (int)num_read; 360 } 361 362 /* read_pop(): 363 * Pop a macro from the stack 364 */ 365 private void 366 read_pop(c_macro_t *ma) 367 { 368 int i; 369 370 el_free(ma->macro[0]); 371 for (i = 0; i < ma->level; i++) 372 ma->macro[i] = ma->macro[i + 1]; 373 ma->level--; 374 ma->offset = 0; 375 } 376 377 /* el_getc(): 378 * Read a character 379 */ 380 public int 381 FUN(el,getc)(EditLine *el, Char *cp) 382 { 383 int num_read; 384 c_macro_t *ma = &el->el_chared.c_macro; 385 386 term__flush(el); 387 for (;;) { 388 if (ma->level < 0) { 389 if (!read_preread(el)) 390 break; 391 } 392 393 if (ma->level < 0) 394 break; 395 396 if (ma->macro[0][ma->offset] == '\0') { 397 read_pop(ma); 398 continue; 399 } 400 401 *cp = ma->macro[0][ma->offset++]; 402 403 if (ma->macro[0][ma->offset] == '\0') { 404 /* Needed for QuoteMode On */ 405 read_pop(ma); 406 } 407 408 return (1); 409 } 410 411 #ifdef DEBUG_READ 412 (void) fprintf(el->el_errfile, "Turning raw mode on\n"); 413 #endif /* DEBUG_READ */ 414 if (tty_rawmode(el) < 0)/* make sure the tty is set up correctly */ 415 return (0); 416 417 #ifdef DEBUG_READ 418 (void) fprintf(el->el_errfile, "Reading a character\n"); 419 #endif /* DEBUG_READ */ 420 num_read = (*el->el_read.read_char)(el, cp); 421 #ifdef WIDECHAR 422 if (el->el_flags & NARROW_READ) 423 *cp = *(char *)(void *)cp; 424 #endif 425 #ifdef DEBUG_READ 426 (void) fprintf(el->el_errfile, "Got it %c\n", *cp); 427 #endif /* DEBUG_READ */ 428 return (num_read); 429 } 430 431 protected void 432 read_prepare(EditLine *el) 433 { 434 if (el->el_flags & HANDLE_SIGNALS) 435 sig_set(el); 436 if (el->el_flags & NO_TTY) 437 return; 438 if ((el->el_flags & (UNBUFFERED|EDIT_DISABLED)) == UNBUFFERED) 439 tty_rawmode(el); 440 441 /* This is relatively cheap, and things go terribly wrong if 442 we have the wrong size. */ 443 el_resize(el); 444 re_clear_display(el); /* reset the display stuff */ 445 ch_reset(el, 0); 446 re_refresh(el); /* print the prompt */ 447 448 if (el->el_flags & UNBUFFERED) 449 term__flush(el); 450 } 451 452 protected void 453 read_finish(EditLine *el) 454 { 455 if ((el->el_flags & UNBUFFERED) == 0) 456 (void) tty_cookedmode(el); 457 if (el->el_flags & HANDLE_SIGNALS) 458 sig_clr(el); 459 } 460 461 public const Char * 462 FUN(el,gets)(EditLine *el, int *nread) 463 { 464 int retval; 465 el_action_t cmdnum = 0; 466 int num; /* how many chars we have read at NL */ 467 Char ch; 468 int crlf = 0; 469 int nrb; 470 #ifdef FIONREAD 471 c_macro_t *ma = &el->el_chared.c_macro; 472 #endif /* FIONREAD */ 473 474 if (nread == NULL) 475 nread = &nrb; 476 *nread = 0; 477 478 if (el->el_flags & NO_TTY) { 479 Char *cp = el->el_line.buffer; 480 size_t idx; 481 482 while ((num = (*el->el_read.read_char)(el, cp)) == 1) { 483 /* make sure there is space for next character */ 484 if (cp + 1 >= el->el_line.limit) { 485 idx = (cp - el->el_line.buffer); 486 if (!ch_enlargebufs(el, 2)) 487 break; 488 cp = &el->el_line.buffer[idx]; 489 } 490 cp++; 491 if (el->el_flags & UNBUFFERED) 492 break; 493 if (cp[-1] == '\r' || cp[-1] == '\n') 494 break; 495 } 496 if (num == -1) { 497 if (errno == EINTR) 498 cp = el->el_line.buffer; 499 el->el_errno = errno; 500 } 501 502 el->el_line.cursor = el->el_line.lastchar = cp; 503 *cp = '\0'; 504 *nread = (int)(el->el_line.cursor - el->el_line.buffer); 505 goto done; 506 } 507 508 509 #ifdef FIONREAD 510 if (el->el_tty.t_mode == EX_IO && ma->level < 0) { 511 long chrs = 0; 512 513 (void) ioctl(el->el_infd, FIONREAD, (ioctl_t) & chrs); 514 if (chrs == 0) { 515 if (tty_rawmode(el) < 0) { 516 errno = 0; 517 *nread = 0; 518 return (NULL); 519 } 520 } 521 } 522 #endif /* FIONREAD */ 523 524 if ((el->el_flags & UNBUFFERED) == 0) 525 read_prepare(el); 526 527 if (el->el_flags & EDIT_DISABLED) { 528 Char *cp; 529 size_t idx; 530 531 if ((el->el_flags & UNBUFFERED) == 0) 532 cp = el->el_line.buffer; 533 else 534 cp = el->el_line.lastchar; 535 536 term__flush(el); 537 538 while ((num = (*el->el_read.read_char)(el, cp)) == 1) { 539 /* make sure there is space next character */ 540 if (cp + 1 >= el->el_line.limit) { 541 idx = (cp - el->el_line.buffer); 542 if (!ch_enlargebufs(el, 2)) 543 break; 544 cp = &el->el_line.buffer[idx]; 545 } 546 cp++; 547 crlf = cp[-1] == '\r' || cp[-1] == '\n'; 548 if (el->el_flags & UNBUFFERED) 549 break; 550 if (crlf) 551 break; 552 } 553 554 if (num == -1) { 555 if (errno == EINTR) 556 cp = el->el_line.buffer; 557 el->el_errno = errno; 558 } 559 560 el->el_line.cursor = el->el_line.lastchar = cp; 561 *cp = '\0'; 562 goto done; 563 } 564 565 for (num = OKCMD; num == OKCMD;) { /* while still editing this 566 * line */ 567 #ifdef DEBUG_EDIT 568 read_debug(el); 569 #endif /* DEBUG_EDIT */ 570 /* if EOF or error */ 571 if ((num = read_getcmd(el, &cmdnum, &ch)) != OKCMD) { 572 #ifdef DEBUG_READ 573 (void) fprintf(el->el_errfile, 574 "Returning from el_gets %d\n", num); 575 #endif /* DEBUG_READ */ 576 break; 577 } 578 if (el->el_errno == EINTR) { 579 el->el_line.buffer[0] = '\0'; 580 el->el_line.lastchar = 581 el->el_line.cursor = el->el_line.buffer; 582 break; 583 } 584 if ((unsigned int)cmdnum >= (unsigned int)el->el_map.nfunc) { /* BUG CHECK command */ 585 #ifdef DEBUG_EDIT 586 (void) fprintf(el->el_errfile, 587 "ERROR: illegal command from key 0%o\r\n", ch); 588 #endif /* DEBUG_EDIT */ 589 continue; /* try again */ 590 } 591 /* now do the real command */ 592 #ifdef DEBUG_READ 593 { 594 el_bindings_t *b; 595 for (b = el->el_map.help; b->name; b++) 596 if (b->func == cmdnum) 597 break; 598 if (b->name) 599 (void) fprintf(el->el_errfile, 600 "Executing %s\n", b->name); 601 else 602 (void) fprintf(el->el_errfile, 603 "Error command = %d\n", cmdnum); 604 } 605 #endif /* DEBUG_READ */ 606 /* vi redo needs these way down the levels... */ 607 el->el_state.thiscmd = cmdnum; 608 el->el_state.thisch = ch; 609 if (el->el_map.type == MAP_VI && 610 el->el_map.current == el->el_map.key && 611 el->el_chared.c_redo.pos < el->el_chared.c_redo.lim) { 612 if (cmdnum == VI_DELETE_PREV_CHAR && 613 el->el_chared.c_redo.pos != el->el_chared.c_redo.buf 614 && Isprint(el->el_chared.c_redo.pos[-1])) 615 el->el_chared.c_redo.pos--; 616 else 617 *el->el_chared.c_redo.pos++ = ch; 618 } 619 retval = (*el->el_map.func[cmdnum]) (el, ch); 620 #ifdef DEBUG_READ 621 (void) fprintf(el->el_errfile, 622 "Returned state %d\n", retval ); 623 #endif /* DEBUG_READ */ 624 625 /* save the last command here */ 626 el->el_state.lastcmd = cmdnum; 627 628 /* use any return value */ 629 switch (retval) { 630 case CC_CURSOR: 631 re_refresh_cursor(el); 632 break; 633 634 case CC_REDISPLAY: 635 re_clear_lines(el); 636 re_clear_display(el); 637 /* FALLTHROUGH */ 638 639 case CC_REFRESH: 640 re_refresh(el); 641 break; 642 643 case CC_REFRESH_BEEP: 644 re_refresh(el); 645 term_beep(el); 646 break; 647 648 case CC_NORM: /* normal char */ 649 break; 650 651 case CC_ARGHACK: /* Suggested by Rich Salz */ 652 /* <rsalz@pineapple.bbn.com> */ 653 continue; /* keep going... */ 654 655 case CC_EOF: /* end of file typed */ 656 if ((el->el_flags & UNBUFFERED) == 0) 657 num = 0; 658 else if (num == -1) { 659 *el->el_line.lastchar++ = CONTROL('d'); 660 el->el_line.cursor = el->el_line.lastchar; 661 num = 1; 662 } 663 break; 664 665 case CC_NEWLINE: /* normal end of line */ 666 num = (int)(el->el_line.lastchar - el->el_line.buffer); 667 break; 668 669 case CC_FATAL: /* fatal error, reset to known state */ 670 #ifdef DEBUG_READ 671 (void) fprintf(el->el_errfile, 672 "*** editor fatal ERROR ***\r\n\n"); 673 #endif /* DEBUG_READ */ 674 /* put (real) cursor in a known place */ 675 re_clear_display(el); /* reset the display stuff */ 676 ch_reset(el, 1); /* reset the input pointers */ 677 re_refresh(el); /* print the prompt again */ 678 break; 679 680 case CC_ERROR: 681 default: /* functions we don't know about */ 682 #ifdef DEBUG_READ 683 (void) fprintf(el->el_errfile, 684 "*** editor ERROR ***\r\n\n"); 685 #endif /* DEBUG_READ */ 686 term_beep(el); 687 term__flush(el); 688 break; 689 } 690 el->el_state.argument = 1; 691 el->el_state.doingarg = 0; 692 el->el_chared.c_vcmd.action = NOP; 693 if (el->el_flags & UNBUFFERED) 694 break; 695 } 696 697 term__flush(el); /* flush any buffered output */ 698 /* make sure the tty is set up correctly */ 699 if ((el->el_flags & UNBUFFERED) == 0) { 700 read_finish(el); 701 *nread = num != -1 ? num : 0; 702 } else { 703 *nread = (int)(el->el_line.lastchar - el->el_line.buffer); 704 } 705 done: 706 if (*nread == 0) { 707 if (num == -1) { 708 *nread = -1; 709 errno = el->el_errno; 710 } 711 return NULL; 712 } else 713 return el->el_line.buffer; 714 } 715