1 /* $NetBSD: read.c,v 1.39 2005/08/02 12:11:14 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.39 2005/08/02 12:11:14 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 "el.h" 53 54 #define OKCMD -1 55 56 private int read__fixio(int, int); 57 private int read_preread(EditLine *); 58 private int read_char(EditLine *, char *); 59 private int read_getcmd(EditLine *, el_action_t *, char *); 60 61 /* read_init(): 62 * Initialize the read stuff 63 */ 64 protected int 65 read_init(EditLine *el) 66 { 67 /* builtin read_char */ 68 el->el_read.read_char = read_char; 69 return 0; 70 } 71 72 73 /* el_read_setfn(): 74 * Set the read char function to the one provided. 75 * If it is set to EL_BUILTIN_GETCFN, then reset to the builtin one. 76 */ 77 protected int 78 el_read_setfn(EditLine *el, el_rfunc_t rc) 79 { 80 el->el_read.read_char = (rc == EL_BUILTIN_GETCFN) ? read_char : rc; 81 return 0; 82 } 83 84 85 /* el_read_getfn(): 86 * return the current read char function, or EL_BUILTIN_GETCFN 87 * if it is the default one 88 */ 89 protected el_rfunc_t 90 el_read_getfn(EditLine *el) 91 { 92 return (el->el_read.read_char == read_char) ? 93 EL_BUILTIN_GETCFN : el->el_read.read_char; 94 } 95 96 97 #ifndef MIN 98 #define MIN(A,B) ((A) < (B) ? (A) : (B)) 99 #endif 100 101 #ifdef DEBUG_EDIT 102 private void 103 read_debug(EditLine *el) 104 { 105 106 if (el->el_line.cursor > el->el_line.lastchar) 107 (void) fprintf(el->el_errfile, "cursor > lastchar\r\n"); 108 if (el->el_line.cursor < el->el_line.buffer) 109 (void) fprintf(el->el_errfile, "cursor < buffer\r\n"); 110 if (el->el_line.cursor > el->el_line.limit) 111 (void) fprintf(el->el_errfile, "cursor > limit\r\n"); 112 if (el->el_line.lastchar > el->el_line.limit) 113 (void) fprintf(el->el_errfile, "lastchar > limit\r\n"); 114 if (el->el_line.limit != &el->el_line.buffer[EL_BUFSIZ - 2]) 115 (void) fprintf(el->el_errfile, "limit != &buffer[EL_BUFSIZ-2]\r\n"); 116 } 117 #endif /* DEBUG_EDIT */ 118 119 120 /* read__fixio(): 121 * Try to recover from a read error 122 */ 123 /* ARGSUSED */ 124 private int 125 read__fixio(int fd __attribute__((__unused__)), int e) 126 { 127 128 switch (e) { 129 case -1: /* Make sure that the code is reachable */ 130 131 #ifdef EWOULDBLOCK 132 case EWOULDBLOCK: 133 #ifndef TRY_AGAIN 134 #define TRY_AGAIN 135 #endif 136 #endif /* EWOULDBLOCK */ 137 138 #if defined(POSIX) && defined(EAGAIN) 139 #if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN 140 case EAGAIN: 141 #ifndef TRY_AGAIN 142 #define TRY_AGAIN 143 #endif 144 #endif /* EWOULDBLOCK && EWOULDBLOCK != EAGAIN */ 145 #endif /* POSIX && EAGAIN */ 146 147 e = 0; 148 #ifdef TRY_AGAIN 149 #if defined(F_SETFL) && defined(O_NDELAY) 150 if ((e = fcntl(fd, F_GETFL, 0)) == -1) 151 return (-1); 152 153 if (fcntl(fd, F_SETFL, e & ~O_NDELAY) == -1) 154 return (-1); 155 else 156 e = 1; 157 #endif /* F_SETFL && O_NDELAY */ 158 159 #ifdef FIONBIO 160 { 161 int zero = 0; 162 163 if (ioctl(fd, FIONBIO, (ioctl_t) & zero) == -1) 164 return (-1); 165 else 166 e = 1; 167 } 168 #endif /* FIONBIO */ 169 170 #endif /* TRY_AGAIN */ 171 return (e ? 0 : -1); 172 173 case EINTR: 174 return (0); 175 176 default: 177 return (-1); 178 } 179 } 180 181 182 /* read_preread(): 183 * Try to read the stuff in the input queue; 184 */ 185 private int 186 read_preread(EditLine *el) 187 { 188 int chrs = 0; 189 190 if (el->el_tty.t_mode == ED_IO) 191 return (0); 192 193 #ifdef FIONREAD 194 (void) ioctl(el->el_infd, FIONREAD, (ioctl_t) & chrs); 195 if (chrs > 0) { 196 char buf[EL_BUFSIZ]; 197 198 chrs = read(el->el_infd, buf, 199 (size_t) MIN(chrs, EL_BUFSIZ - 1)); 200 if (chrs > 0) { 201 buf[chrs] = '\0'; 202 el_push(el, buf); 203 } 204 } 205 #endif /* FIONREAD */ 206 207 return (chrs > 0); 208 } 209 210 211 /* el_push(): 212 * Push a macro 213 */ 214 public void 215 el_push(EditLine *el, char *str) 216 { 217 c_macro_t *ma = &el->el_chared.c_macro; 218 219 if (str != NULL && ma->level + 1 < EL_MAXMACRO) { 220 ma->level++; 221 if ((ma->macro[ma->level] = el_strdup(str)) != NULL) 222 return; 223 ma->level--; 224 } 225 term_beep(el); 226 term__flush(); 227 } 228 229 230 /* read_getcmd(): 231 * Return next command from the input stream. 232 */ 233 private int 234 read_getcmd(EditLine *el, el_action_t *cmdnum, char *ch) 235 { 236 el_action_t cmd; 237 int num; 238 239 do { 240 if ((num = el_getc(el, ch)) != 1) /* if EOF or error */ 241 return (num); 242 243 #ifdef KANJI 244 if ((*ch & 0200)) { 245 el->el_state.metanext = 0; 246 cmd = CcViMap[' ']; 247 break; 248 } else 249 #endif /* KANJI */ 250 251 if (el->el_state.metanext) { 252 el->el_state.metanext = 0; 253 *ch |= 0200; 254 } 255 cmd = el->el_map.current[(unsigned char) *ch]; 256 if (cmd == ED_SEQUENCE_LEAD_IN) { 257 key_value_t val; 258 switch (key_get(el, ch, &val)) { 259 case XK_CMD: 260 cmd = val.cmd; 261 break; 262 case XK_STR: 263 el_push(el, val.str); 264 break; 265 #ifdef notyet 266 case XK_EXE: 267 /* XXX: In the future to run a user function */ 268 RunCommand(val.str); 269 break; 270 #endif 271 default: 272 EL_ABORT((el->el_errfile, "Bad XK_ type \n")); 273 break; 274 } 275 } 276 if (el->el_map.alt == NULL) 277 el->el_map.current = el->el_map.key; 278 } while (cmd == ED_SEQUENCE_LEAD_IN); 279 *cmdnum = cmd; 280 return (OKCMD); 281 } 282 283 284 /* read_char(): 285 * Read a character from the tty. 286 */ 287 private int 288 read_char(EditLine *el, char *cp) 289 { 290 int num_read; 291 int tried = 0; 292 293 while ((num_read = read(el->el_infd, cp, 1)) == -1) 294 if (!tried && read__fixio(el->el_infd, errno) == 0) 295 tried = 1; 296 else { 297 *cp = '\0'; 298 return (-1); 299 } 300 301 return (num_read); 302 } 303 304 305 /* el_getc(): 306 * Read a character 307 */ 308 public int 309 el_getc(EditLine *el, char *cp) 310 { 311 int num_read; 312 c_macro_t *ma = &el->el_chared.c_macro; 313 314 term__flush(); 315 for (;;) { 316 if (ma->level < 0) { 317 if (!read_preread(el)) 318 break; 319 } 320 if (ma->level < 0) 321 break; 322 323 if (ma->macro[ma->level][ma->offset] == '\0') { 324 el_free(ma->macro[ma->level--]); 325 ma->offset = 0; 326 continue; 327 } 328 *cp = ma->macro[ma->level][ma->offset++] & 0377; 329 if (ma->macro[ma->level][ma->offset] == '\0') { 330 /* Needed for QuoteMode On */ 331 el_free(ma->macro[ma->level--]); 332 ma->offset = 0; 333 } 334 return (1); 335 } 336 337 #ifdef DEBUG_READ 338 (void) fprintf(el->el_errfile, "Turning raw mode on\n"); 339 #endif /* DEBUG_READ */ 340 if (tty_rawmode(el) < 0)/* make sure the tty is set up correctly */ 341 return (0); 342 343 #ifdef DEBUG_READ 344 (void) fprintf(el->el_errfile, "Reading a character\n"); 345 #endif /* DEBUG_READ */ 346 num_read = (*el->el_read.read_char)(el, cp); 347 #ifdef DEBUG_READ 348 (void) fprintf(el->el_errfile, "Got it %c\n", *cp); 349 #endif /* DEBUG_READ */ 350 return (num_read); 351 } 352 353 protected void 354 read_prepare(EditLine *el) 355 { 356 if (el->el_flags & HANDLE_SIGNALS) 357 sig_set(el); 358 if (el->el_flags & NO_TTY) 359 return; 360 if ((el->el_flags & (UNBUFFERED|EDIT_DISABLED)) == UNBUFFERED) 361 tty_rawmode(el); 362 363 /* This is relatively cheap, and things go terribly wrong if 364 we have the wrong size. */ 365 el_resize(el); 366 re_clear_display(el); /* reset the display stuff */ 367 ch_reset(el, 0); 368 re_refresh(el); /* print the prompt */ 369 370 if (el->el_flags & UNBUFFERED) 371 term__flush(); 372 } 373 374 protected void 375 read_finish(EditLine *el) 376 { 377 if ((el->el_flags & UNBUFFERED) == 0) 378 (void) tty_cookedmode(el); 379 if (el->el_flags & HANDLE_SIGNALS) 380 sig_clr(el); 381 } 382 383 public const char * 384 el_gets(EditLine *el, int *nread) 385 { 386 int retval; 387 el_action_t cmdnum = 0; 388 int num; /* how many chars we have read at NL */ 389 char ch; 390 int crlf = 0; 391 #ifdef FIONREAD 392 c_macro_t *ma = &el->el_chared.c_macro; 393 #endif /* FIONREAD */ 394 395 if (el->el_flags & NO_TTY) { 396 char *cp = el->el_line.buffer; 397 size_t idx; 398 399 while ((*el->el_read.read_char)(el, cp) == 1) { 400 /* make sure there is space for next character */ 401 if (cp + 1 >= el->el_line.limit) { 402 idx = (cp - el->el_line.buffer); 403 if (!ch_enlargebufs(el, 2)) 404 break; 405 cp = &el->el_line.buffer[idx]; 406 } 407 cp++; 408 if (el->el_flags & UNBUFFERED) 409 break; 410 if (cp[-1] == '\r' || cp[-1] == '\n') 411 break; 412 } 413 414 el->el_line.cursor = el->el_line.lastchar = cp; 415 *cp = '\0'; 416 if (nread) 417 *nread = el->el_line.cursor - el->el_line.buffer; 418 return (el->el_line.buffer); 419 } 420 421 422 #ifdef FIONREAD 423 if (el->el_tty.t_mode == EX_IO && ma->level < 0) { 424 long chrs = 0; 425 426 (void) ioctl(el->el_infd, FIONREAD, (ioctl_t) & chrs); 427 if (chrs == 0) { 428 if (tty_rawmode(el) < 0) { 429 if (nread) 430 *nread = 0; 431 return (NULL); 432 } 433 } 434 } 435 #endif /* FIONREAD */ 436 437 if ((el->el_flags & UNBUFFERED) == 0) 438 read_prepare(el); 439 440 if (el->el_flags & EDIT_DISABLED) { 441 char *cp; 442 size_t idx; 443 if ((el->el_flags & UNBUFFERED) == 0) 444 cp = el->el_line.buffer; 445 else 446 cp = el->el_line.lastchar; 447 448 term__flush(); 449 450 while ((*el->el_read.read_char)(el, cp) == 1) { 451 /* make sure there is space next character */ 452 if (cp + 1 >= el->el_line.limit) { 453 idx = (cp - el->el_line.buffer); 454 if (!ch_enlargebufs(el, 2)) 455 break; 456 cp = &el->el_line.buffer[idx]; 457 } 458 if (*cp == 4) /* ought to be stty eof */ 459 break; 460 cp++; 461 crlf = cp[-1] == '\r' || cp[-1] == '\n'; 462 if (el->el_flags & UNBUFFERED) 463 break; 464 if (crlf) 465 break; 466 } 467 468 el->el_line.cursor = el->el_line.lastchar = cp; 469 *cp = '\0'; 470 if (nread) 471 *nread = el->el_line.cursor - el->el_line.buffer; 472 return (el->el_line.buffer); 473 } 474 475 for (num = OKCMD; num == OKCMD;) { /* while still editing this 476 * line */ 477 #ifdef DEBUG_EDIT 478 read_debug(el); 479 #endif /* DEBUG_EDIT */ 480 /* if EOF or error */ 481 if ((num = read_getcmd(el, &cmdnum, &ch)) != OKCMD) { 482 #ifdef DEBUG_READ 483 (void) fprintf(el->el_errfile, 484 "Returning from el_gets %d\n", num); 485 #endif /* DEBUG_READ */ 486 break; 487 } 488 if ((unsigned int)cmdnum >= el->el_map.nfunc) { /* BUG CHECK command */ 489 #ifdef DEBUG_EDIT 490 (void) fprintf(el->el_errfile, 491 "ERROR: illegal command from key 0%o\r\n", ch); 492 #endif /* DEBUG_EDIT */ 493 continue; /* try again */ 494 } 495 /* now do the real command */ 496 #ifdef DEBUG_READ 497 { 498 el_bindings_t *b; 499 for (b = el->el_map.help; b->name; b++) 500 if (b->func == cmdnum) 501 break; 502 if (b->name) 503 (void) fprintf(el->el_errfile, 504 "Executing %s\n", b->name); 505 else 506 (void) fprintf(el->el_errfile, 507 "Error command = %d\n", cmdnum); 508 } 509 #endif /* DEBUG_READ */ 510 /* vi redo needs these way down the levels... */ 511 el->el_state.thiscmd = cmdnum; 512 el->el_state.thisch = ch; 513 if (el->el_map.type == MAP_VI && 514 el->el_map.current == el->el_map.key && 515 el->el_chared.c_redo.pos < el->el_chared.c_redo.lim) { 516 if (cmdnum == VI_DELETE_PREV_CHAR && 517 el->el_chared.c_redo.pos != el->el_chared.c_redo.buf 518 && isprint((unsigned char)el->el_chared.c_redo.pos[-1])) 519 el->el_chared.c_redo.pos--; 520 else 521 *el->el_chared.c_redo.pos++ = ch; 522 } 523 retval = (*el->el_map.func[cmdnum]) (el, ch); 524 #ifdef DEBUG_READ 525 (void) fprintf(el->el_errfile, 526 "Returned state %d\n", retval ); 527 #endif /* DEBUG_READ */ 528 529 /* save the last command here */ 530 el->el_state.lastcmd = cmdnum; 531 532 /* use any return value */ 533 switch (retval) { 534 case CC_CURSOR: 535 re_refresh_cursor(el); 536 break; 537 538 case CC_REDISPLAY: 539 re_clear_lines(el); 540 re_clear_display(el); 541 /* FALLTHROUGH */ 542 543 case CC_REFRESH: 544 re_refresh(el); 545 break; 546 547 case CC_REFRESH_BEEP: 548 re_refresh(el); 549 term_beep(el); 550 break; 551 552 case CC_NORM: /* normal char */ 553 break; 554 555 case CC_ARGHACK: /* Suggested by Rich Salz */ 556 /* <rsalz@pineapple.bbn.com> */ 557 continue; /* keep going... */ 558 559 case CC_EOF: /* end of file typed */ 560 if ((el->el_flags & UNBUFFERED) == 0) 561 num = 0; 562 else if (num == -1) { 563 *el->el_line.lastchar++ = CONTROL('d'); 564 el->el_line.cursor = el->el_line.lastchar; 565 num = 1; 566 } 567 break; 568 569 case CC_NEWLINE: /* normal end of line */ 570 num = el->el_line.lastchar - el->el_line.buffer; 571 break; 572 573 case CC_FATAL: /* fatal error, reset to known state */ 574 #ifdef DEBUG_READ 575 (void) fprintf(el->el_errfile, 576 "*** editor fatal ERROR ***\r\n\n"); 577 #endif /* DEBUG_READ */ 578 /* put (real) cursor in a known place */ 579 re_clear_display(el); /* reset the display stuff */ 580 ch_reset(el, 1); /* reset the input pointers */ 581 re_refresh(el); /* print the prompt again */ 582 break; 583 584 case CC_ERROR: 585 default: /* functions we don't know about */ 586 #ifdef DEBUG_READ 587 (void) fprintf(el->el_errfile, 588 "*** editor ERROR ***\r\n\n"); 589 #endif /* DEBUG_READ */ 590 term_beep(el); 591 term__flush(); 592 break; 593 } 594 el->el_state.argument = 1; 595 el->el_state.doingarg = 0; 596 el->el_chared.c_vcmd.action = NOP; 597 if (el->el_flags & UNBUFFERED) 598 break; 599 } 600 601 term__flush(); /* flush any buffered output */ 602 /* make sure the tty is set up correctly */ 603 if ((el->el_flags & UNBUFFERED) == 0) { 604 read_finish(el); 605 if (nread) 606 *nread = num; 607 } else { 608 if (nread) 609 *nread = el->el_line.lastchar - el->el_line.buffer; 610 } 611 return (num ? el->el_line.buffer : NULL); 612 } 613