Annotation of OpenXM_contrib/gnuplot/readline.c, Revision 1.1
1.1 ! maekawa 1: #ifndef lint
! 2: static char *RCSid = "$Id: readline.c,v 1.69 1998/04/14 00:16:12 drd Exp $";
! 3: #endif
! 4:
! 5: /* GNUPLOT - readline.c */
! 6:
! 7: /*[
! 8: * Copyright 1986 - 1993, 1998 Thomas Williams, Colin Kelley
! 9: *
! 10: * Permission to use, copy, and distribute this software and its
! 11: * documentation for any purpose with or without fee is hereby granted,
! 12: * provided that the above copyright notice appear in all copies and
! 13: * that both that copyright notice and this permission notice appear
! 14: * in supporting documentation.
! 15: *
! 16: * Permission to modify the software is granted, but not the right to
! 17: * distribute the complete modified source code. Modifications are to
! 18: * be distributed as patches to the released version. Permission to
! 19: * distribute binaries produced by compiling modified sources is granted,
! 20: * provided you
! 21: * 1. distribute the corresponding source modifications from the
! 22: * released version in the form of a patch file along with the binaries,
! 23: * 2. add special version identification to distinguish your version
! 24: * in addition to the base release version number,
! 25: * 3. provide your name and address as the primary contact for the
! 26: * support of your modified version, and
! 27: * 4. retain our contact information in regard to use of the base
! 28: * software.
! 29: * Permission to distribute the released version of the source code along
! 30: * with corresponding source modifications in the form of a patch file is
! 31: * granted with same provisions 2 through 4 for binary distributions.
! 32: *
! 33: * This software is provided "as is" without express or implied warranty
! 34: * to the extent permitted by applicable law.
! 35: ]*/
! 36:
! 37:
! 38: /*
! 39: * AUTHORS
! 40: *
! 41: * Original Software:
! 42: * Tom Tkacik
! 43: *
! 44: * Msdos port and some enhancements:
! 45: * Gershon Elber and many others.
! 46: *
! 47: * In add_history(), do not store duplicated entries:
! 48: * Petr Mikulik
! 49: */
! 50:
! 51: #include <signal.h>
! 52: /* get prototype for alloc and gpfaralloc */
! 53: #include "plot.h"
! 54:
! 55: #if defined(READLINE) && !defined(GNU_READLINE)
! 56:
! 57: /* a small portable version of GNU's readline
! 58: * this is not the BASH or GNU EMACS version of READLINE due to Copyleft
! 59: * restrictions
! 60: * do not need any terminal capabilities except backspace,
! 61: * and space overwrites a character
! 62: */
! 63:
! 64: /* NANO-EMACS line editing facility
! 65: * printable characters print as themselves (insert not overwrite)
! 66: * ^A moves to the beginning of the line
! 67: * ^B moves back a single character
! 68: * ^E moves to the end of the line
! 69: * ^F moves forward a single character
! 70: * ^K kills from current position to the end of line
! 71: * ^P moves back through history
! 72: * ^N moves forward through history
! 73: * ^H and DEL delete the previous character
! 74: * ^D deletes the current character, or EOF if line is empty
! 75: * ^L/^R redraw line in case it gets trashed
! 76: * ^U kills the entire line
! 77: * ^W kills last word
! 78: * LF and CR return the entire line regardless of the cursor postition
! 79: * EOF with an empty line returns (char *)NULL
! 80: *
! 81: * all other characters are ignored
! 82: */
! 83:
! 84: #ifdef __linux__
! 85: /* HBB: to get prototype for ioctl() */
! 86: # include <sys/ioctl.h>
! 87: #endif
! 88:
! 89: /* replaces the previous klugde in configure */
! 90: #if defined(HAVE_TERMIOS_H) && defined(HAVE_TCGETATTR)
! 91: # define TERMIOS
! 92: #else /* not HAVE_TERMIOS_H && HAVE_TCGETATTR */
! 93: # ifdef HAVE_SGTTY_H
! 94: # define SGTTY
! 95: # endif
! 96: #endif /* not HAVE_TERMIOS_H && HAVE_TCGETATTR */
! 97:
! 98: #if !defined(MSDOS) && !defined(ATARI) && !defined(MTOS) && !defined(_Windows) && !defined(DOS386) && !defined(OSK)
! 99:
! 100: /*
! 101: * Set up structures using the proper include file
! 102: */
! 103: # if defined(_IBMR2) || defined(alliant)
! 104: # define SGTTY
! 105: # endif
! 106:
! 107: /* submitted by Francois.Dagorn@cicb.fr */
! 108: # ifdef SGTTY
! 109: # include <sgtty.h>
! 110: static struct sgttyb orig_termio, rl_termio;
! 111: /* define terminal control characters */
! 112: static struct tchars s_tchars;
! 113: # ifndef VERASE
! 114: # define VERASE 0
! 115: # endif /* not VERASE */
! 116: # ifndef VEOF
! 117: # define VEOF 1
! 118: # endif /* not VEOF */
! 119: # ifndef VKILL
! 120: # define VKILL 2
! 121: # endif /* not VKILL */
! 122: # ifdef TIOCGLTC /* available only with the 'new' line discipline */
! 123: static struct ltchars s_ltchars;
! 124: # ifndef VWERASE
! 125: # define VWERASE 3
! 126: # endif /* not VWERASE */
! 127: # ifndef VREPRINT
! 128: # define VREPRINT 4
! 129: # endif /* not VREPRINT */
! 130: # ifndef VSUSP
! 131: # define VSUSP 5
! 132: # endif /* not VSUP */
! 133: # endif /* TIOCGLTC */
! 134: # ifndef NCCS
! 135: # define NCCS 6
! 136: # endif /* not NCCS */
! 137:
! 138: # else /* not SGTTY */
! 139:
! 140: /* SIGTSTP defines job control
! 141: * if there is job control then we need termios.h instead of termio.h
! 142: * (Are there any systems with job control that use termio.h? I hope not.)
! 143: */
! 144: # if defined(SIGTSTP) || defined(TERMIOS)
! 145: # ifndef TERMIOS
! 146: # define TERMIOS
! 147: # endif /* not TERMIOS */
! 148: # include <termios.h>
! 149: /* Added by Robert Eckardt, RobertE@beta.TP2.Ruhr-Uni-Bochum.de */
! 150: # ifdef ISC22
! 151: # ifndef ONOCR /* taken from sys/termio.h */
! 152: # define ONOCR 0000020 /* true at least for ISC 2.2 */
! 153: # endif /* not ONOCR */
! 154: # ifndef IUCLC
! 155: # define IUCLC 0001000
! 156: # endif /* not IUCLC */
! 157: # endif /* ISC22 */
! 158: # if !defined(IUCLC)
! 159: /* translate upper to lower case not supported */
! 160: # define IUCLC 0
! 161: # endif /* not IUCLC */
! 162:
! 163: static struct termios orig_termio, rl_termio;
! 164: # else /* not SIGSTP || TERMIOS */
! 165: # include <termio.h>
! 166: static struct termio orig_termio, rl_termio;
! 167: /* termio defines NCC instead of NCCS */
! 168: # define NCCS NCC
! 169: # endif /* not SIGTSTP || TERMIOS */
! 170: # endif /* SGTTY */
! 171:
! 172: /* ULTRIX defines VRPRNT instead of VREPRINT */
! 173: # if defined(VRPRNT) && !defined(VREPRINT)
! 174: # define VREPRINT VRPRNT
! 175: # endif /* VRPRNT */
! 176:
! 177: /* define characters to use with our input character handler */
! 178: static char term_chars[NCCS];
! 179:
! 180: static int term_set = 0; /* =1 if rl_termio set */
! 181:
! 182: #define special_getc() ansi_getc()
! 183: static int ansi_getc __PROTO((void));
! 184:
! 185: #else /* MSDOS or ATARI or MTOS or _Windows or DOS386 or OSK */
! 186:
! 187: # ifdef _Windows
! 188: # include <windows.h>
! 189: # include "win/wtext.h"
! 190: # include "win/wgnuplib.h"
! 191: extern TW textwin;
! 192: # define TEXTUSER 0xf1
! 193: # define TEXTGNUPLOT 0xf0
! 194: # define special_getc() msdos_getch()
! 195: static char msdos_getch __PROTO((void)); /* HBB 980308: PROTO'ed it */
! 196: # endif /* _Windows */
! 197:
! 198: # if defined(MSDOS) || defined(DOS386)
! 199: /* MSDOS specific stuff */
! 200: # ifdef DJGPP
! 201: # include <pc.h>
! 202: # endif /* DJGPP */
! 203: # ifdef __EMX__
! 204: # include <conio.h>
! 205: # endif /* __EMX__ */
! 206: # define special_getc() msdos_getch()
! 207: static char msdos_getch();
! 208: # endif /* MSDOS || DOS386 */
! 209:
! 210: # ifdef OSK
! 211: # include <sgstat.h>
! 212: # include <modes.h>
! 213:
! 214: # define STDIN 0
! 215: static int term_set = 0; /* =1 if new_settings is set */
! 216:
! 217: static struct _sgs old_settings; /* old terminal settings */
! 218: static struct _sgs new_settings; /* new terminal settings */
! 219:
! 220: # define special_getc() ansi_getc()
! 221: static int ansi_getc __PROTO((void));
! 222:
! 223: /* On OS9 a '\n' is a character 13 and '\r' == '\n'. This gives troubles
! 224: here, so we need a new putc wich handles this correctly and print a
! 225: character 10 on each place we want a '\n'.
! 226: */
! 227: # undef putc /* Undefine the macro for putc */
! 228:
! 229: static int putc(c, fp)
! 230: char c;
! 231: FILE *fp;
! 232: {
! 233: write(fileno(fp), &c, 1);
! 234: if (c == '\012') { /* A normal ASCII '\n' */
! 235: c = '\r';
! 236: write(fileno(fp), &c, 1);
! 237: }
! 238: }
! 239:
! 240: # endif /* OSK */
! 241:
! 242: # if defined(ATARI) || defined(MTOS)
! 243: # define special_getc() tos_getch()
! 244: # endif /* ATARI || MTOS */
! 245:
! 246: #endif /* MSDOS or ATARI or MTOS or _Windows or DOS386 or OSK */
! 247:
! 248: #ifdef OS2
! 249: # if defined( special_getc )
! 250: # undef special_getc()
! 251: # endif /* special_getc */
! 252: # define special_getc() msdos_getch()
! 253: static char msdos_getch __PROTO((void)); /* HBB 980308: PROTO'ed it */
! 254: #endif /* OS2 */
! 255:
! 256:
! 257: /* initial size and increment of input line length */
! 258: #define MAXBUF 1024
! 259: /* ^H */
! 260: #define BACKSPACE 0x08
! 261: #define SPACE ' '
! 262:
! 263: #ifdef OSK
! 264: # define NEWLINE '\012'
! 265: #else /* OSK */
! 266: # define NEWLINE '\n'
! 267: #endif /* not OSK */
! 268:
! 269: struct hist {
! 270: char *line;
! 271: struct hist *prev;
! 272: struct hist *next;
! 273: };
! 274:
! 275: static struct hist *history = NULL; /* no history yet */
! 276: static struct hist *cur_entry = NULL;
! 277:
! 278: static char *cur_line; /* current contents of the line */
! 279: static int line_len = 0;
! 280: static int cur_pos = 0; /* current position of the cursor */
! 281: static int max_pos = 0; /* maximum character position */
! 282:
! 283:
! 284: static void fix_line __PROTO((void));
! 285: static void redraw_line __PROTO((char *prompt));
! 286: static void clear_line __PROTO((char *prompt));
! 287: static void clear_eoline __PROTO((void));
! 288: static void copy_line __PROTO((char *line));
! 289: static void set_termio __PROTO((void));
! 290: static void reset_termio __PROTO((void));
! 291: static int ansi_getc __PROTO((void));
! 292: static int user_putc __PROTO((int ch));
! 293: static int user_puts __PROTO((char *str));
! 294: static void backspace __PROTO((void));
! 295: static void extend_cur_line __PROTO((void));
! 296:
! 297: /* user_putc and user_puts should be used in the place of
! 298: * fputc(ch,stderr) and fputs(str,stderr) for all output
! 299: * of user typed characters. This allows MS-Windows to
! 300: * display user input in a different color.
! 301: */
! 302: static int user_putc(ch)
! 303: int ch;
! 304: {
! 305: int rv;
! 306: #ifdef _Windows
! 307: TextAttr(&textwin, TEXTUSER);
! 308: #endif
! 309: rv = fputc(ch, stderr);
! 310: #ifdef _Windows
! 311: TextAttr(&textwin, TEXTGNUPLOT);
! 312: #endif
! 313: return rv;
! 314: }
! 315:
! 316: static int user_puts(str)
! 317: char *str;
! 318: {
! 319: int rv;
! 320: #ifdef _Windows
! 321: TextAttr(&textwin, TEXTUSER);
! 322: #endif
! 323: rv = fputs(str, stderr);
! 324: #ifdef _Windows
! 325: TextAttr(&textwin, TEXTGNUPLOT);
! 326: #endif
! 327: return rv;
! 328: }
! 329:
! 330: /* This function provides a centralized non-destructive backspace capability
! 331: * M. Castro
! 332: */
! 333: static void backspace()
! 334: {
! 335: user_putc(BACKSPACE);
! 336: }
! 337:
! 338: static void extend_cur_line()
! 339: {
! 340: char *new_line;
! 341:
! 342: /* extent input line length */
! 343: new_line = gp_realloc(cur_line, line_len + MAXBUF, NULL);
! 344: if (!new_line) {
! 345: reset_termio();
! 346: int_error("Can't extend readline length", NO_CARET);
! 347: }
! 348: cur_line = new_line;
! 349: line_len += MAXBUF;
! 350: FPRINTF((stderr, "\nextending readline length to %d chars\n", line_len));
! 351: }
! 352:
! 353: char *
! 354: readline(prompt)
! 355: char *prompt;
! 356: {
! 357:
! 358: int cur_char;
! 359: char *new_line;
! 360:
! 361: /* start with a string of MAXBUF chars */
! 362:
! 363: if (line_len != 0) {
! 364: free(cur_line);
! 365: line_len = 0;
! 366: }
! 367: cur_line = gp_alloc((unsigned long) MAXBUF, "readline");
! 368: line_len = MAXBUF;
! 369:
! 370: /* set the termio so we can do our own input processing */
! 371: set_termio();
! 372:
! 373: /* print the prompt */
! 374: fputs(prompt, stderr);
! 375: cur_line[0] = '\0';
! 376: cur_pos = 0;
! 377: max_pos = 0;
! 378: cur_entry = NULL;
! 379:
! 380: /* get characters */
! 381: for (;;) {
! 382: cur_char = special_getc();
! 383:
! 384: /*
! 385: * The #define CHARSET7BIT should be used when one encounters problems with
! 386: * 8bit characters that should not be entered on the commandline. I cannot
! 387: * think on any reasonable example where this could happen, but what do I know?
! 388: * After all, the unix world still ignores 8bit chars in most applications.
! 389: *
! 390: * Note that latin1 defines the chars 0x80-0x9f as control chars. For the
! 391: * benefit of Atari, MSDOS, Windows and NeXT I have decided to ignore this,
! 392: * since it would require more #ifs.
! 393: *
! 394: */
! 395:
! 396: #ifdef CHARSET7BIT
! 397: if (isprint(cur_char)) {
! 398: #else /* CHARSET7BIT */
! 399: if (isprint(cur_char) || (((unsigned char) cur_char > 0x7f) &&
! 400: cur_char != EOF)) {
! 401: #endif /* CHARSET7BIT */
! 402: int i;
! 403:
! 404: if (max_pos + 1 >= line_len) {
! 405: extend_cur_line();
! 406: }
! 407: for (i = max_pos; i > cur_pos; i--) {
! 408: cur_line[i] = cur_line[i - 1];
! 409: }
! 410: user_putc(cur_char);
! 411: cur_line[cur_pos] = cur_char;
! 412: cur_pos += 1;
! 413: max_pos += 1;
! 414: if (cur_pos < max_pos)
! 415: fix_line();
! 416: cur_line[max_pos] = '\0';
! 417:
! 418: /* else interpret unix terminal driver characters */
! 419: #ifdef VERASE
! 420: } else if (cur_char == term_chars[VERASE]) { /* DEL? */
! 421: if (cur_pos > 0) {
! 422: int i;
! 423: cur_pos -= 1;
! 424: backspace();
! 425: for (i = cur_pos; i < max_pos; i++)
! 426: cur_line[i] = cur_line[i + 1];
! 427: max_pos -= 1;
! 428: fix_line();
! 429: }
! 430: #endif /* VERASE */
! 431: #ifdef VEOF
! 432: } else if (cur_char == term_chars[VEOF]) { /* ^D? */
! 433: if (max_pos == 0) {
! 434: reset_termio();
! 435: return ((char *) NULL);
! 436: }
! 437: if ((cur_pos < max_pos) && (cur_char == 004)) { /* ^D */
! 438: int i;
! 439: for (i = cur_pos; i < max_pos; i++)
! 440: cur_line[i] = cur_line[i + 1];
! 441: max_pos -= 1;
! 442: fix_line();
! 443: }
! 444: #endif /* VEOF */
! 445: #ifdef VKILL
! 446: } else if (cur_char == term_chars[VKILL]) { /* ^U? */
! 447: clear_line(prompt);
! 448: #endif /* VKILL */
! 449: #ifdef VWERASE
! 450: } else if (cur_char == term_chars[VWERASE]) { /* ^W? */
! 451: while ((cur_pos > 0) &&
! 452: (cur_line[cur_pos - 1] == SPACE)) {
! 453: cur_pos -= 1;
! 454: backspace();
! 455: }
! 456: while ((cur_pos > 0) &&
! 457: (cur_line[cur_pos - 1] != SPACE)) {
! 458: cur_pos -= 1;
! 459: backspace();
! 460: }
! 461: clear_eoline();
! 462: max_pos = cur_pos;
! 463: #endif /* VWERASE */
! 464: #ifdef VREPRINT
! 465: } else if (cur_char == term_chars[VREPRINT]) { /* ^R? */
! 466: putc(NEWLINE, stderr); /* go to a fresh line */
! 467: redraw_line(prompt);
! 468: #endif /* VREPRINT */
! 469: #ifdef VSUSP
! 470: } else if (cur_char == term_chars[VSUSP]) {
! 471: reset_termio();
! 472: kill(0, SIGTSTP);
! 473:
! 474: /* process stops here */
! 475:
! 476: set_termio();
! 477: /* print the prompt */
! 478: redraw_line(prompt);
! 479: #endif /* VSUSP */
! 480: } else {
! 481: /* do normal editing commands */
! 482: /* some of these are also done above */
! 483: int i;
! 484: switch (cur_char) {
! 485: case EOF:
! 486: reset_termio();
! 487: return ((char *) NULL);
! 488: case 001: /* ^A */
! 489: while (cur_pos > 0) {
! 490: cur_pos -= 1;
! 491: backspace();
! 492: }
! 493: break;
! 494: case 002: /* ^B */
! 495: if (cur_pos > 0) {
! 496: cur_pos -= 1;
! 497: backspace();
! 498: }
! 499: break;
! 500: case 005: /* ^E */
! 501: while (cur_pos < max_pos) {
! 502: user_putc(cur_line[cur_pos]);
! 503: cur_pos += 1;
! 504: }
! 505: break;
! 506: case 006: /* ^F */
! 507: if (cur_pos < max_pos) {
! 508: user_putc(cur_line[cur_pos]);
! 509: cur_pos += 1;
! 510: }
! 511: break;
! 512: case 013: /* ^K */
! 513: clear_eoline();
! 514: max_pos = cur_pos;
! 515: break;
! 516: case 020: /* ^P */
! 517: if (history != NULL) {
! 518: if (cur_entry == NULL) {
! 519: cur_entry = history;
! 520: clear_line(prompt);
! 521: copy_line(cur_entry->line);
! 522: } else if (cur_entry->prev != NULL) {
! 523: cur_entry = cur_entry->prev;
! 524: clear_line(prompt);
! 525: copy_line(cur_entry->line);
! 526: }
! 527: }
! 528: break;
! 529: case 016: /* ^N */
! 530: if (cur_entry != NULL) {
! 531: cur_entry = cur_entry->next;
! 532: clear_line(prompt);
! 533: if (cur_entry != NULL)
! 534: copy_line(cur_entry->line);
! 535: else
! 536: cur_pos = max_pos = 0;
! 537: }
! 538: break;
! 539: case 014: /* ^L */
! 540: case 022: /* ^R */
! 541: putc(NEWLINE, stderr); /* go to a fresh line */
! 542: redraw_line(prompt);
! 543: break;
! 544: case 0177: /* DEL */
! 545: case 010: /* ^H */
! 546: if (cur_pos > 0) {
! 547: cur_pos -= 1;
! 548: backspace();
! 549: for (i = cur_pos; i < max_pos; i++)
! 550: cur_line[i] = cur_line[i + 1];
! 551: max_pos -= 1;
! 552: fix_line();
! 553: }
! 554: break;
! 555: case 004: /* ^D */
! 556: if (max_pos == 0) {
! 557: reset_termio();
! 558: return ((char *) NULL);
! 559: }
! 560: if (cur_pos < max_pos) {
! 561: for (i = cur_pos; i < max_pos; i++)
! 562: cur_line[i] = cur_line[i + 1];
! 563: max_pos -= 1;
! 564: fix_line();
! 565: }
! 566: break;
! 567: case 025: /* ^U */
! 568: clear_line(prompt);
! 569: break;
! 570: case 027: /* ^W */
! 571: while ((cur_pos > 0) &&
! 572: (cur_line[cur_pos - 1] == SPACE)) {
! 573: cur_pos -= 1;
! 574: backspace();
! 575: }
! 576: while ((cur_pos > 0) &&
! 577: (cur_line[cur_pos - 1] != SPACE)) {
! 578: cur_pos -= 1;
! 579: backspace();
! 580: }
! 581: clear_eoline();
! 582: max_pos = cur_pos;
! 583: break;
! 584: case '\n': /* ^J */
! 585: #ifndef OSK
! 586: case '\r': /* ^M */
! 587: #endif
! 588: cur_line[max_pos + 1] = '\0';
! 589: #ifdef OS2
! 590: while (cur_pos < max_pos) {
! 591: user_putc(cur_line[cur_pos]);
! 592: cur_pos += 1;
! 593: }
! 594: #endif
! 595: putc(NEWLINE, stderr);
! 596:
! 597: /* Shrink the block down to fit the string ?
! 598: * if the alloc fails, we still own block at cur_line,
! 599: * but this shouldn't really fail.
! 600: */
! 601: new_line = (char *) gp_realloc(cur_line, (unsigned long) (strlen(cur_line) + 1), "line resize");
! 602: if (new_line)
! 603: cur_line = new_line;
! 604: /* else we just hang on to what we had - it's not a problem */
! 605:
! 606: line_len = 0;
! 607: FPRINTF((stderr, "Resizing input line to %d chars\n", strlen(cur_line)));
! 608: reset_termio();
! 609: return (cur_line);
! 610: default:
! 611: break;
! 612: }
! 613: }
! 614: }
! 615: }
! 616:
! 617: /* fix up the line from cur_pos to max_pos
! 618: * do not need any terminal capabilities except backspace,
! 619: * and space overwrites a character
! 620: */
! 621: static void fix_line()
! 622: {
! 623: int i;
! 624:
! 625: /* write tail of string */
! 626: for (i = cur_pos; i < max_pos; i++)
! 627: user_putc(cur_line[i]);
! 628:
! 629: /* write a space at the end of the line in case we deleted one */
! 630: user_putc(SPACE);
! 631:
! 632: /* backup to original position */
! 633: for (i = max_pos + 1; i > cur_pos; i--)
! 634: backspace();
! 635:
! 636: }
! 637:
! 638: /* redraw the entire line, putting the cursor where it belongs */
! 639: static void redraw_line(prompt)
! 640: char *prompt;
! 641: {
! 642: int i;
! 643:
! 644: fputs(prompt, stderr);
! 645: user_puts(cur_line);
! 646:
! 647: /* put the cursor where it belongs */
! 648: for (i = max_pos; i > cur_pos; i--)
! 649: backspace();
! 650: }
! 651:
! 652: /* clear cur_line and the screen line */
! 653: static void clear_line(prompt)
! 654: char *prompt;
! 655: {
! 656: int i;
! 657: for (i = 0; i < max_pos; i++)
! 658: cur_line[i] = '\0';
! 659:
! 660: for (i = cur_pos; i > 0; i--)
! 661: backspace();
! 662:
! 663: for (i = 0; i < max_pos; i++)
! 664: putc(SPACE, stderr);
! 665:
! 666: putc('\r', stderr);
! 667: fputs(prompt, stderr);
! 668:
! 669: cur_pos = 0;
! 670: max_pos = 0;
! 671: }
! 672:
! 673: /* clear to end of line and the screen end of line */
! 674: static void clear_eoline()
! 675: {
! 676: int i;
! 677: for (i = cur_pos; i < max_pos; i++)
! 678: cur_line[i] = '\0';
! 679:
! 680: for (i = cur_pos; i < max_pos; i++)
! 681: putc(SPACE, stderr);
! 682: for (i = cur_pos; i < max_pos; i++)
! 683: backspace();
! 684: }
! 685:
! 686: /* copy line to cur_line, draw it and set cur_pos and max_pos */
! 687: static void copy_line(line)
! 688: char *line;
! 689: {
! 690: while (strlen(line) + 1 > line_len) {
! 691: extend_cur_line();
! 692: }
! 693: strcpy(cur_line, line);
! 694: user_puts(cur_line);
! 695: cur_pos = max_pos = strlen(cur_line);
! 696: }
! 697:
! 698: /* add line to the history */
! 699: void add_history(line)
! 700: char *line;
! 701: {
! 702: struct hist *entry;
! 703:
! 704: entry = history;
! 705: while (entry != NULL) {
! 706: /* Don't store duplicate entries */
! 707: if (!strcmp(entry->line, line)) {
! 708: /* cmd lines are equal, relink entry that was found last */
! 709: if (entry->next == NULL) {
! 710: /* previous command repeated, no change */
! 711: return;
! 712: }
! 713: if (entry->prev == NULL) {
! 714: /* current cmd line equals the first in the history */
! 715: (entry->next)->prev = NULL;
! 716: history->next = entry;
! 717: entry->prev = history;
! 718: entry->next = NULL;
! 719: history = entry;
! 720: return;
! 721: }
! 722: /* bridge over entry's vacancy, then move it to the end */
! 723: (entry->prev)->next = entry->next;
! 724: (entry->next)->prev = entry->prev;
! 725: entry->prev = history;
! 726: history->next = entry;
! 727: entry->next = NULL;
! 728: history = entry;
! 729: return;
! 730: }
! 731: entry = entry->prev;
! 732: } /* end of not-storing duplicated entries */
! 733:
! 734: entry = (struct hist *) gp_alloc((unsigned long) sizeof(struct hist), "history");
! 735: entry->line = gp_alloc((unsigned long) (strlen(line) + 1), "history");
! 736: strcpy(entry->line, line);
! 737:
! 738: entry->prev = history;
! 739: entry->next = NULL;
! 740: if (history != NULL) {
! 741: history->next = entry;
! 742: }
! 743: history = entry;
! 744: }
! 745:
! 746:
! 747: /* Convert ANSI arrow keys to control characters */
! 748: static int ansi_getc()
! 749: {
! 750: int c = getc(stdin);
! 751: if (c == 033) {
! 752: c = getc(stdin); /* check for CSI */
! 753: if (c == '[') {
! 754: c = getc(stdin); /* get command character */
! 755: switch (c) {
! 756: case 'D': /* left arrow key */
! 757: c = 002;
! 758: break;
! 759: case 'C': /* right arrow key */
! 760: c = 006;
! 761: break;
! 762: case 'A': /* up arrow key */
! 763: c = 020;
! 764: break;
! 765: case 'B': /* down arrow key */
! 766: c = 016;
! 767: break;
! 768: }
! 769: }
! 770: }
! 771: return c;
! 772: }
! 773:
! 774: #if defined(MSDOS) || defined(_Windows) || defined(DOS386) || defined(OS2)
! 775:
! 776: /* Convert Arrow keystrokes to Control characters: */
! 777: static char msdos_getch()
! 778: {
! 779: #ifdef DJGPP
! 780: char c;
! 781: int ch = getkey();
! 782: c = (ch & 0xff00) ? 0 : ch & 0xff;
! 783: #else /* not DJGPP */
! 784: # ifdef OS2
! 785: char c = getc(stdin);
! 786: # else /* not OS2 */
! 787: char c = getch();
! 788: # endif /* not OS2 */
! 789: #endif /* not DJGPP */
! 790:
! 791: if (c == 0) {
! 792: #ifdef DJGPP
! 793: c = ch & 0xff;
! 794: #else /* not DJGPP */
! 795: # ifdef OS2
! 796: c = getc(stdin);
! 797: # else /* not OS2 */
! 798: c = getch(); /* Get the extended code. */
! 799: # endif /* not OS2 */
! 800: #endif /* not DJGPP */
! 801: switch (c) {
! 802: case 75: /* Left Arrow. */
! 803: c = 002;
! 804: break;
! 805: case 77: /* Right Arrow. */
! 806: c = 006;
! 807: break;
! 808: case 72: /* Up Arrow. */
! 809: c = 020;
! 810: break;
! 811: case 80: /* Down Arrow. */
! 812: c = 016;
! 813: break;
! 814: case 115: /* Ctl Left Arrow. */
! 815: case 71: /* Home */
! 816: c = 001;
! 817: break;
! 818: case 116: /* Ctl Right Arrow. */
! 819: case 79: /* End */
! 820: c = 005;
! 821: break;
! 822: case 83: /* Delete */
! 823: c = 004;
! 824: break;
! 825: default:
! 826: c = 0;
! 827: break;
! 828: }
! 829: } else if (c == 033) { /* ESC */
! 830: c = 025;
! 831: }
! 832: return c;
! 833: }
! 834:
! 835: #endif /* MSDOS || _Windows || DOS386 || OS2 */
! 836:
! 837:
! 838: #if defined(ATARI) || defined(MTOS)
! 839:
! 840: /* Convert Arrow keystrokes to Control characters: TOS version */
! 841:
! 842: long poll_events(int); /* from term/atariaes.trm */
! 843:
! 844: /* this function is used in help.c as well. this means that the
! 845: * program doesn't work without -DREADLINE (which would be the case
! 846: * if help.c didn't use it as well, since no events would be processed)
! 847: */
! 848: char tos_getch()
! 849: {
! 850: long rawkey;
! 851: char c;
! 852: int scan_code;
! 853: static int in_help = 0;
! 854:
! 855: if (strcmp(term->name, "atari") == 0)
! 856: poll_events(0);
! 857:
! 858: if (in_help) {
! 859: switch (in_help) {
! 860: case 1:
! 861: case 5:
! 862: in_help++;
! 863: return 'e';
! 864: case 2:
! 865: case 6:
! 866: in_help++;
! 867: return 'l';
! 868: case 3:
! 869: case 7:
! 870: in_help++;
! 871: return 'p';
! 872: case 4:
! 873: in_help = 0;
! 874: return 0x0d;
! 875: case 8:
! 876: in_help = 0;
! 877: return ' ';
! 878: }
! 879: }
! 880: if (strcmp(term->name, "atari") == 0) {
! 881: do {
! 882: if (Bconstat(2))
! 883: rawkey = Cnecin();
! 884: else
! 885: rawkey = poll_events(1);
! 886: } while (rawkey == 0);
! 887: } else
! 888: rawkey = Cnecin();
! 889:
! 890: c = (char) rawkey;
! 891: scan_code = ((int) (rawkey >> 16)) & 0xff; /* get the scancode */
! 892: if (Kbshift(-1) & 0x00000007)
! 893: scan_code |= 0x80; /* shift or control ? */
! 894:
! 895: switch (scan_code) {
! 896: case 0x62: /* HELP */
! 897: case 0xe2: /* shift HELP */
! 898: if (max_pos == 0) {
! 899: if (scan_code == 0x62) {
! 900: in_help = 1;
! 901: } else {
! 902: in_help = 5;
! 903: }
! 904: return 'h';
! 905: } else {
! 906: return 0;
! 907: }
! 908: case 0x48: /* Up Arrow */
! 909: return 0x10; /* ^P */
! 910: case 0x50: /* Down Arrow */
! 911: return 0x0e; /* ^N */
! 912: case 0x4b: /* Left Arrow */
! 913: return 0x02; /* ^B */
! 914: case 0x4d: /* Right Arrow */
! 915: return 0x06; /* ^F */
! 916: case 0xcb: /* Shift Left Arrow */
! 917: case 0xf3: /* Ctrl Left Arrow (TOS-bug ?) */
! 918: case 0x47: /* Home */
! 919: return 0x01; /* ^A */
! 920: case 0xcd: /* Shift Right Arrow */
! 921: case 0xf4: /* Ctrl Right Arrow (TOS-bug ?) */
! 922: case 0xc7: /* Shift Home */
! 923: case 0xf7: /* Ctrl Home */
! 924: return 0x05; /* ^E */
! 925: case 0x61: /* Undo - redraw line */
! 926: return 0x0c; /* ^L */
! 927: default:
! 928: if (c == 0x1b)
! 929: return 0x15; /* ESC becomes ^U */
! 930: if (c == 0x7f)
! 931: return 0x04; /* Del becomes ^D */
! 932: break;
! 933: }
! 934: return c;
! 935: }
! 936:
! 937: #endif /* ATARI || MTOS */
! 938:
! 939: /* set termio so we can do our own input processing */
! 940: static void set_termio()
! 941: {
! 942: #if !defined(MSDOS) && !defined(ATARI) && !defined(MTOS) && !defined(_Windows) && !defined(DOS386)
! 943: /* set termio so we can do our own input processing */
! 944: /* and save the old terminal modes so we can reset them later */
! 945: if (term_set == 0) {
! 946: /*
! 947: * Get terminal modes.
! 948: */
! 949: # ifndef OSK
! 950: # ifdef SGTTY
! 951: ioctl(0, TIOCGETP, &orig_termio);
! 952: # else /* not SGTTY */
! 953: # ifdef TERMIOS
! 954: # ifdef TCGETS
! 955: ioctl(0, TCGETS, &orig_termio);
! 956: # else /* not TCGETS */
! 957: tcgetattr(0, &orig_termio);
! 958: # endif /* not TCGETS */
! 959: # else /* not TERMIOS */
! 960: ioctl(0, TCGETA, &orig_termio);
! 961: # endif /* TERMIOS */
! 962: # endif /* not SGTTY */
! 963: # else /* OSK */
! 964: setbuf(stdin, (char *) 0); /* Make stdin and stdout unbuffered */
! 965: setbuf(stderr, (char *) 0);
! 966: _gs_opt(STDIN, &new_settings);
! 967: # endif /* OSK */
! 968:
! 969: /*
! 970: * Save terminal modes
! 971: */
! 972: # ifndef OSK
! 973: rl_termio = orig_termio;
! 974: # else /* OSK */
! 975: _gs_opt(STDIN, &old_settings);
! 976: # endif /* OSK */
! 977:
! 978: /*
! 979: * Set the modes to the way we want them
! 980: * and save our input special characters
! 981: */
! 982: # ifndef OSK
! 983: # ifdef SGTTY
! 984: rl_termio.sg_flags |= CBREAK;
! 985: rl_termio.sg_flags &= ~(ECHO | XTABS);
! 986: ioctl(0, TIOCSETN, &rl_termio);
! 987:
! 988: ioctl(0, TIOCGETC, &s_tchars);
! 989: term_chars[VERASE] = orig_termio.sg_erase;
! 990: term_chars[VEOF] = s_tchars.t_eofc;
! 991: term_chars[VKILL] = orig_termio.sg_kill;
! 992: # ifdef TIOCGLTC
! 993: ioctl(0, TIOCGLTC, &s_ltchars);
! 994: term_chars[VWERASE] = s_ltchars.t_werasc;
! 995: term_chars[VREPRINT] = s_ltchars.t_rprntc;
! 996: term_chars[VSUSP] = s_ltchars.t_suspc;
! 997:
! 998: /* disable suspending process on ^Z */
! 999: s_ltchars.t_suspc = 0;
! 1000: ioctl(0, TIOCSLTC, &s_ltchars);
! 1001: # endif /* TIOCGLTC */
! 1002: # else /* not SGTTY */
! 1003: rl_termio.c_iflag &= ~(BRKINT | PARMRK | INPCK | IUCLC | IXON | IXOFF);
! 1004: rl_termio.c_iflag |= (IGNBRK | IGNPAR);
! 1005:
! 1006: /* rl_termio.c_oflag &= ~(ONOCR); Costas Sphocleous Irvine,CA */
! 1007:
! 1008: rl_termio.c_lflag &= ~(ICANON | ECHO | ECHOE | ECHOK | ECHONL | NOFLSH);
! 1009: # ifdef OS2
! 1010: /* for emx: remove default terminal processing */
! 1011: rl_termio.c_lflag &= ~(IDEFAULT);
! 1012: # endif /* OS2 */
! 1013: rl_termio.c_lflag |= (ISIG);
! 1014: rl_termio.c_cc[VMIN] = 1;
! 1015: rl_termio.c_cc[VTIME] = 0;
! 1016:
! 1017: # ifndef VWERASE
! 1018: # define VWERASE 3
! 1019: # endif /* VWERASE */
! 1020: term_chars[VERASE] = orig_termio.c_cc[VERASE];
! 1021: term_chars[VEOF] = orig_termio.c_cc[VEOF];
! 1022: term_chars[VKILL] = orig_termio.c_cc[VKILL];
! 1023: # ifdef TERMIOS
! 1024: term_chars[VWERASE] = orig_termio.c_cc[VWERASE];
! 1025: # ifdef VREPRINT
! 1026: term_chars[VREPRINT] = orig_termio.c_cc[VREPRINT];
! 1027: # else /* not VREPRINT */
! 1028: # ifdef VRPRNT
! 1029: term_chars[VRPRNT] = orig_termio.c_cc[VRPRNT];
! 1030: # endif /* VRPRNT */
! 1031: # endif /* not VREPRINT */
! 1032: term_chars[VSUSP] = orig_termio.c_cc[VSUSP];
! 1033:
! 1034: /* disable suspending process on ^Z */
! 1035: rl_termio.c_cc[VSUSP] = 0;
! 1036: # endif /* TERMIOS */
! 1037: # endif /* not SGTTY */
! 1038: # else /* OSK */
! 1039: new_settings._sgs_echo = 0; /* switch off terminal echo */
! 1040: new_settings._sgs_pause = 0; /* inhibit page pause */
! 1041: new_settings._sgs_eofch = 0; /* inhibit eof */
! 1042: new_settings._sgs_kbich = 0; /* inhibit ^C */
! 1043: new_settings._sgs_kbach = 0; /* inhibit ^E */
! 1044: # endif /* OSK */
! 1045:
! 1046: /*
! 1047: * Set the new terminal modes.
! 1048: */
! 1049: # ifndef OSK
! 1050: # ifdef SGTTY
! 1051: ioctl(0, TIOCSLTC, &s_ltchars);
! 1052: # else /* not SGTTY */
! 1053: # ifdef TERMIOS
! 1054: # ifdef TCSETSW
! 1055: ioctl(0, TCSETSW, &rl_termio);
! 1056: # else /* not TCSETSW */
! 1057: tcsetattr(0, TCSADRAIN, &rl_termio);
! 1058: # endif /* not TCSETSW */
! 1059: # else /* not TERMIOS */
! 1060: ioctl(0, TCSETAW, &rl_termio);
! 1061: # endif /* not TERMIOS */
! 1062: # endif /* not SGTTY */
! 1063: # else /* OSK */
! 1064: _ss_opt(STDIN, &new_settings);
! 1065: # endif /* OSK */
! 1066: term_set = 1;
! 1067: }
! 1068: #endif /* not MSDOS && not ATARI && not MTOS && not _Windows && not DOS386 */
! 1069: }
! 1070:
! 1071: static void reset_termio()
! 1072: {
! 1073: #if !defined(MSDOS) && !defined(ATARI) && !defined(MTOS) && !defined(_Windows) && !defined(DOS386)
! 1074: /* reset saved terminal modes */
! 1075: if (term_set == 1) {
! 1076: # ifndef OSK
! 1077: # ifdef SGTTY
! 1078: ioctl(0, TIOCSETN, &orig_termio);
! 1079: # ifdef TIOCGLTC
! 1080: /* enable suspending process on ^Z */
! 1081: s_ltchars.t_suspc = term_chars[VSUSP];
! 1082: ioctl(0, TIOCSLTC, &s_ltchars);
! 1083: # endif /* TIOCGLTC */
! 1084: # else /* not SGTTY */
! 1085: # ifdef TERMIOS
! 1086: # ifdef TCSETSW
! 1087: ioctl(0, TCSETSW, &orig_termio);
! 1088: # else /* not TCSETSW */
! 1089: tcsetattr(0, TCSADRAIN, &orig_termio);
! 1090: # endif /* not TCSETSW */
! 1091: # else /* not TERMIOS */
! 1092: ioctl(0, TCSETAW, &orig_termio);
! 1093: # endif /* TERMIOS */
! 1094: # endif /* not SGTTY */
! 1095: # else /* OSK */
! 1096: _ss_opt(STDIN, &old_settings);
! 1097: # endif /* OSK */
! 1098: term_set = 0;
! 1099: }
! 1100: #endif /* not MSDOS && not ATARI && not MTOS && not _Windows && not DOS386 */
! 1101: }
! 1102:
! 1103:
! 1104: #endif /* READLINE && not GNU_READLINE */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to readline.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gnuplot