1 /* $NetBSD: read.c,v 1.19 2001/01/10 07:45:41 jdolecek 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 <sys/cdefs.h> 40 #if !defined(lint) && !defined(SCCSID) 41 #if 0 42 static char sccsid[] = "@(#)read.c 8.1 (Berkeley) 6/4/93"; 43 #else 44 __RCSID("$NetBSD: read.c,v 1.19 2001/01/10 07:45:41 jdolecek Exp $"); 45 #endif 46 #endif /* not lint && not SCCSID */ 47 48 /* 49 * read.c: Clean this junk up! This is horrible code. 50 * Terminal read functions 51 */ 52 #include "sys.h" 53 #include <errno.h> 54 #include <unistd.h> 55 #include <stdlib.h> 56 #include "el.h" 57 58 #define OKCMD -1 59 60 private int read__fixio(int, int); 61 private int read_preread(EditLine *); 62 private int read_getcmd(EditLine *, el_action_t *, char *); 63 private int read_char(EditLine *, char *); 64 65 #ifdef DEBUG_EDIT 66 private void 67 read_debug(EditLine *el) 68 { 69 70 if (el->el_line.cursor > el->el_line.lastchar) 71 (void) fprintf(el->el_errfile, "cursor > lastchar\r\n"); 72 if (el->el_line.cursor < el->el_line.buffer) 73 (void) fprintf(el->el_errfile, "cursor < buffer\r\n"); 74 if (el->el_line.cursor > el->el_line.limit) 75 (void) fprintf(el->el_errfile, "cursor > limit\r\n"); 76 if (el->el_line.lastchar > el->el_line.limit) 77 (void) fprintf(el->el_errfile, "lastchar > limit\r\n"); 78 if (el->el_line.limit != &el->el_line.buffer[EL_BUFSIZ - 2]) 79 (void) fprintf(el->el_errfile, "limit != &buffer[EL_BUFSIZ-2]\r\n"); 80 } 81 #endif /* DEBUG_EDIT */ 82 83 84 /* read__fixio(): 85 * Try to recover from a read error 86 */ 87 /* ARGSUSED */ 88 private int 89 read__fixio(int fd, int e) 90 { 91 92 switch (e) { 93 case -1: /* Make sure that the code is reachable */ 94 95 #ifdef EWOULDBLOCK 96 case EWOULDBLOCK: 97 #ifndef TRY_AGAIN 98 #define TRY_AGAIN 99 #endif 100 #endif /* EWOULDBLOCK */ 101 102 #if defined(POSIX) && defined(EAGAIN) 103 #if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN 104 case EAGAIN: 105 #ifndef TRY_AGAIN 106 #define TRY_AGAIN 107 #endif 108 #endif /* EWOULDBLOCK && EWOULDBLOCK != EAGAIN */ 109 #endif /* POSIX && EAGAIN */ 110 111 e = 0; 112 #ifdef TRY_AGAIN 113 #if defined(F_SETFL) && defined(O_NDELAY) 114 if ((e = fcntl(fd, F_GETFL, 0)) == -1) 115 return (-1); 116 117 if (fcntl(fd, F_SETFL, e & ~O_NDELAY) == -1) 118 return (-1); 119 else 120 e = 1; 121 #endif /* F_SETFL && O_NDELAY */ 122 123 #ifdef FIONBIO 124 { 125 int zero = 0; 126 127 if (ioctl(fd, FIONBIO, (ioctl_t) & zero) == -1) 128 return (-1); 129 else 130 e = 1; 131 } 132 #endif /* FIONBIO */ 133 134 #endif /* TRY_AGAIN */ 135 return (e ? 0 : -1); 136 137 case EINTR: 138 return (0); 139 140 default: 141 return (-1); 142 } 143 } 144 145 146 /* read_preread(): 147 * Try to read the stuff in the input queue; 148 */ 149 private int 150 read_preread(EditLine *el) 151 { 152 int chrs = 0; 153 154 if (el->el_chared.c_macro.nline) { 155 el_free((ptr_t) el->el_chared.c_macro.nline); 156 el->el_chared.c_macro.nline = NULL; 157 } 158 if (el->el_tty.t_mode == ED_IO) 159 return (0); 160 161 #ifdef FIONREAD 162 (void) ioctl(el->el_infd, FIONREAD, (ioctl_t) & chrs); 163 if (chrs > 0) { 164 char buf[EL_BUFSIZ]; 165 166 chrs = read(el->el_infd, buf, 167 (size_t) MIN(chrs, EL_BUFSIZ - 1)); 168 if (chrs > 0) { 169 buf[chrs] = '\0'; 170 el->el_chared.c_macro.nline = strdup(buf); 171 el_push(el, el->el_chared.c_macro.nline); 172 } 173 } 174 #endif /* FIONREAD */ 175 176 return (chrs > 0); 177 } 178 179 180 /* el_push(): 181 * Push a macro 182 */ 183 public void 184 el_push(EditLine *el, const char *str) 185 { 186 c_macro_t *ma = &el->el_chared.c_macro; 187 188 if (str != NULL && ma->level + 1 < EL_MAXMACRO) { 189 ma->level++; 190 /* LINTED const cast */ 191 ma->macro[ma->level] = (char *) str; 192 } else { 193 term_beep(el); 194 term__flush(); 195 } 196 } 197 198 199 /* read_getcmd(): 200 * Return next command from the input stream. 201 */ 202 private int 203 read_getcmd(EditLine *el, el_action_t *cmdnum, char *ch) 204 { 205 el_action_t cmd = ED_UNASSIGNED; 206 int num; 207 208 while (cmd == ED_UNASSIGNED || cmd == ED_SEQUENCE_LEAD_IN) { 209 if ((num = el_getc(el, ch)) != 1) /* if EOF or error */ 210 return (num); 211 212 #ifdef KANJI 213 if ((*ch & 0200)) { 214 el->el_state.metanext = 0; 215 cmd = CcViMap[' ']; 216 break; 217 } else 218 #endif /* KANJI */ 219 220 if (el->el_state.metanext) { 221 el->el_state.metanext = 0; 222 *ch |= 0200; 223 } 224 cmd = el->el_map.current[(unsigned char) *ch]; 225 if (cmd == ED_SEQUENCE_LEAD_IN) { 226 key_value_t val; 227 switch (key_get(el, ch, &val)) { 228 case XK_CMD: 229 cmd = val.cmd; 230 break; 231 case XK_STR: 232 el_push(el, val.str); 233 break; 234 #ifdef notyet 235 case XK_EXE: 236 /* XXX: In the future to run a user function */ 237 RunCommand(val.str); 238 break; 239 #endif 240 default: 241 EL_ABORT((el->el_errfile, "Bad XK_ type \n")); 242 break; 243 } 244 } 245 if (el->el_map.alt == NULL) 246 el->el_map.current = el->el_map.key; 247 } 248 *cmdnum = cmd; 249 return (OKCMD); 250 } 251 252 253 /* read_char(): 254 * Read a character from the tty. 255 */ 256 private int 257 read_char(EditLine *el, char *cp) 258 { 259 int num_read; 260 int tried = 0; 261 262 while ((num_read = read(el->el_infd, cp, 1)) == -1) 263 if (!tried && read__fixio(el->el_infd, errno) == 0) 264 tried = 1; 265 else { 266 *cp = '\0'; 267 return (-1); 268 } 269 270 return (num_read); 271 } 272 273 274 /* el_getc(): 275 * Read a character 276 */ 277 public int 278 el_getc(EditLine *el, char *cp) 279 { 280 int num_read; 281 c_macro_t *ma = &el->el_chared.c_macro; 282 283 term__flush(); 284 for (;;) { 285 if (ma->level < 0) { 286 if (!read_preread(el)) 287 break; 288 } 289 if (ma->level < 0) 290 break; 291 292 if (*ma->macro[ma->level] == 0) { 293 ma->level--; 294 continue; 295 } 296 *cp = *ma->macro[ma->level]++ & 0377; 297 if (*ma->macro[ma->level] == 0) { /* Needed for QuoteMode 298 * On */ 299 ma->level--; 300 } 301 return (1); 302 } 303 304 #ifdef DEBUG_READ 305 (void) fprintf(el->el_errfile, "Turning raw mode on\n"); 306 #endif /* DEBUG_READ */ 307 if (tty_rawmode(el) < 0)/* make sure the tty is set up correctly */ 308 return (0); 309 310 #ifdef DEBUG_READ 311 (void) fprintf(el->el_errfile, "Reading a character\n"); 312 #endif /* DEBUG_READ */ 313 num_read = read_char(el, cp); 314 #ifdef DEBUG_READ 315 (void) fprintf(el->el_errfile, "Got it %c\n", *cp); 316 #endif /* DEBUG_READ */ 317 return (num_read); 318 } 319 320 321 public const char * 322 el_gets(EditLine *el, int *nread) 323 { 324 int retval; 325 el_action_t cmdnum = 0; 326 int num; /* how many chars we have read at NL */ 327 char ch; 328 #ifdef FIONREAD 329 c_macro_t *ma = &el->el_chared.c_macro; 330 #endif /* FIONREAD */ 331 332 if (el->el_flags & HANDLE_SIGNALS) 333 sig_set(el); 334 335 if (el->el_flags & NO_TTY) { 336 char *cp = el->el_line.buffer; 337 size_t idx; 338 339 while (read_char(el, cp) == 1) { 340 /* make sure there is space for next character */ 341 if (cp + 1 >= el->el_line.limit) { 342 idx = (cp - el->el_line.buffer); 343 if (!ch_enlargebufs(el, 2)) 344 break; 345 cp = &el->el_line.buffer[idx]; 346 } 347 cp++; 348 if (cp[-1] == '\r' || cp[-1] == '\n') 349 break; 350 } 351 352 el->el_line.cursor = el->el_line.lastchar = cp; 353 *cp = '\0'; 354 if (nread) 355 *nread = el->el_line.cursor - el->el_line.buffer; 356 return (el->el_line.buffer); 357 } 358 re_clear_display(el); /* reset the display stuff */ 359 ch_reset(el); 360 361 #ifdef FIONREAD 362 if (el->el_tty.t_mode == EX_IO && ma->level < 0) { 363 long chrs = 0; 364 365 (void) ioctl(el->el_infd, FIONREAD, (ioctl_t) & chrs); 366 if (chrs == 0) { 367 if (tty_rawmode(el) < 0) { 368 if (nread) 369 *nread = 0; 370 return (NULL); 371 } 372 } 373 } 374 #endif /* FIONREAD */ 375 376 re_refresh(el); /* print the prompt */ 377 378 if (el->el_flags & EDIT_DISABLED) { 379 char *cp = el->el_line.buffer; 380 size_t idx; 381 382 term__flush(); 383 384 while (read_char(el, cp) == 1) { 385 /* make sure there is space next character */ 386 if (cp + 1 >= el->el_line.limit) { 387 idx = (cp - el->el_line.buffer); 388 if (!ch_enlargebufs(el, 2)) 389 break; 390 cp = &el->el_line.buffer[idx]; 391 } 392 cp++; 393 if (cp[-1] == '\r' || cp[-1] == '\n') 394 break; 395 } 396 397 el->el_line.cursor = el->el_line.lastchar = cp; 398 *cp = '\0'; 399 if (nread) 400 *nread = el->el_line.cursor - el->el_line.buffer; 401 return (el->el_line.buffer); 402 } 403 for (num = OKCMD; num == OKCMD;) { /* while still editing this 404 * line */ 405 #ifdef DEBUG_EDIT 406 read_debug(el); 407 #endif /* DEBUG_EDIT */ 408 /* if EOF or error */ 409 if ((num = read_getcmd(el, &cmdnum, &ch)) != OKCMD) { 410 #ifdef DEBUG_READ 411 (void) fprintf(el->el_errfile, 412 "Returning from el_gets %d\n", num); 413 #endif /* DEBUG_READ */ 414 break; 415 } 416 if ((int) cmdnum >= el->el_map.nfunc) { /* BUG CHECK command */ 417 #ifdef DEBUG_EDIT 418 (void) fprintf(el->el_errfile, 419 "ERROR: illegal command from key 0%o\r\n", ch); 420 #endif /* DEBUG_EDIT */ 421 continue; /* try again */ 422 } 423 /* now do the real command */ 424 #ifdef DEBUG_READ 425 { 426 el_bindings_t *b; 427 for (b = el->el_map.help; b->name; b++) 428 if (b->func == cmdnum) 429 break; 430 if (b->name) 431 (void) fprintf(el->el_errfile, 432 "Executing %s\n", b->name); 433 else 434 (void) fprintf(el->el_errfile, 435 "Error command = %d\n", cmdnum); 436 } 437 #endif /* DEBUG_READ */ 438 retval = (*el->el_map.func[cmdnum]) (el, ch); 439 440 /* save the last command here */ 441 el->el_state.lastcmd = cmdnum; 442 443 /* use any return value */ 444 switch (retval) { 445 case CC_CURSOR: 446 el->el_state.argument = 1; 447 el->el_state.doingarg = 0; 448 re_refresh_cursor(el); 449 break; 450 451 case CC_REDISPLAY: 452 re_clear_lines(el); 453 re_clear_display(el); 454 /* FALLTHROUGH */ 455 456 case CC_REFRESH: 457 el->el_state.argument = 1; 458 el->el_state.doingarg = 0; 459 re_refresh(el); 460 break; 461 462 case CC_REFRESH_BEEP: 463 el->el_state.argument = 1; 464 el->el_state.doingarg = 0; 465 re_refresh(el); 466 term_beep(el); 467 break; 468 469 case CC_NORM: /* normal char */ 470 el->el_state.argument = 1; 471 el->el_state.doingarg = 0; 472 break; 473 474 case CC_ARGHACK: /* Suggested by Rich Salz */ 475 /* <rsalz@pineapple.bbn.com> */ 476 break; /* keep going... */ 477 478 case CC_EOF: /* end of file typed */ 479 num = 0; 480 break; 481 482 case CC_NEWLINE: /* normal end of line */ 483 num = el->el_line.lastchar - el->el_line.buffer; 484 break; 485 486 case CC_FATAL: /* fatal error, reset to known state */ 487 #ifdef DEBUG_READ 488 (void) fprintf(el->el_errfile, 489 "*** editor fatal ERROR ***\r\n\n"); 490 #endif /* DEBUG_READ */ 491 /* put (real) cursor in a known place */ 492 re_clear_display(el); /* reset the display stuff */ 493 ch_reset(el); /* reset the input pointers */ 494 re_refresh(el); /* print the prompt again */ 495 el->el_state.argument = 1; 496 el->el_state.doingarg = 0; 497 break; 498 499 case CC_ERROR: 500 default: /* functions we don't know about */ 501 #ifdef DEBUG_READ 502 (void) fprintf(el->el_errfile, 503 "*** editor ERROR ***\r\n\n"); 504 #endif /* DEBUG_READ */ 505 el->el_state.argument = 1; 506 el->el_state.doingarg = 0; 507 term_beep(el); 508 term__flush(); 509 break; 510 } 511 } 512 513 /* make sure the tty is set up correctly */ 514 (void) tty_cookedmode(el); 515 term__flush(); /* flush any buffered output */ 516 if (el->el_flags & HANDLE_SIGNALS) 517 sig_clr(el); 518 if (nread) 519 *nread = num; 520 return (num ? el->el_line.buffer : NULL); 521 } 522