/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved. */ /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ /* All Rights Reserved */ /* Copyright (c) 1981 Regents of the University of California */ #include "ex.h" #include "ex_tty.h" #include "ex_vis.h" /* * Input routines for open/visual. * We handle upper case only terminals in visual and reading from the * echo area here as well as notification on large changes * which appears in the echo area. */ /* * Return the key. */ void ungetkey(int c) { if (Peekkey != ATTN) Peekkey = c; } /* * Return a keystroke, but never a ^@. */ int getkey(void) { int c; /* char --> int */ do { c = getbr(); if (c==0) (void) beep(); } while (c == 0); return (c); } /* * Tell whether next keystroke would be a ^@. */ int peekbr(void) { Peekkey = getbr(); return (Peekkey == 0); } short precbksl; /* * Get a keystroke, including a ^@. * If an key was returned with ungetkey, that * comes back first. Next comes unread input (e.g. * from repeating commands with .), and finally new * keystrokes. * * The hard work here is in mapping of \ escaped * characters on upper case only terminals. */ int getbr(void) { unsigned char ch; int c, d; unsigned char *colp; int cnt; static unsigned char Peek2key; extern short slevel, ttyindes; getATTN: if (Peekkey) { c = Peekkey; Peekkey = 0; return (c); } if (Peek2key) { c = Peek2key; Peek2key = 0; return (c); } if (vglobp) { if (*vglobp) return (lastvgk = *vglobp++); lastvgk = 0; return (ESCAPE); } if (vmacp) { if (*vmacp) return(*vmacp++); /* End of a macro or set of nested macros */ vmacp = 0; if (inopen == -1) /* don't mess up undo for esc esc */ vundkind = VMANY; inopen = 1; /* restore old setting now that macro done */ vch_mac = VC_NOTINMAC; } flusho(); again: if ((c=read(slevel == 0 ? 0 : ttyindes, &ch, 1)) != 1) { if (errno == EINTR) goto getATTN; else if (errno == EIO) kill(getpid(), SIGHUP); error(gettext("Input read error")); } c = ch; if (beehive_glitch && slevel==0 && c == ESCAPE) { if (read(0, &Peek2key, 1) != 1) goto getATTN; switch (Peek2key) { case 'C': /* SPOW mode sometimes sends \EC for space */ c = ' '; Peek2key = 0; break; case 'q': /* f2 -> ^C */ c = CTRL('c'); Peek2key = 0; break; case 'p': /* f1 -> esc */ Peek2key = 0; break; } } /* * The algorithm here is that of the UNIX kernel. * See the description in the programmers manual. */ if (UPPERCASE) { if (isupper(c)) c = tolower(c); if (c == '\\') { if (precbksl < 2) precbksl++; if (precbksl == 1) goto again; } else if (precbksl) { d = 0; if (islower(c)) d = toupper(c); else { colp = (unsigned char *)"({)}!|^~'~"; while (d = *colp++) if (d == c) { d = *colp++; break; } else colp++; } if (precbksl == 2) { if (!d) { Peekkey = c; precbksl = 0; c = '\\'; } } else if (d) c = d; else { Peekkey = c; precbksl = 0; c = '\\'; } } if (c != '\\') precbksl = 0; } #ifdef TRACE if (trace) { if (!techoin) { tfixnl(); techoin = 1; fprintf(trace, "*** Input: "); } tracec(c); } #endif lastvgk = 0; return (c); } /* * Get a key, but if a delete, quit or attention * is typed return 0 so we will abort a partial command. */ int getesc(void) { int c; c = getkey(); switch (c) { case CTRL('v'): case CTRL('q'): c = getkey(); return (c); case ATTN: case QUIT: ungetkey(c); return (0); case ESCAPE: return (0); } return (c); } /* * Peek at the next keystroke. */ int peekkey(void) { Peekkey = getkey(); return (Peekkey); } /* * Read a line from the echo area, with single character prompt c. * A return value of 1 means the user blewit or blewit away. */ int readecho(c) unsigned char c; { unsigned char *sc = cursor; int (*OP)(); bool waste; int OPeek; if (WBOT == WECHO) vclean(); else vclrech(0); splitw++; vgoto(WECHO, 0); putchar(c); vclreol(); vgoto(WECHO, 1); cursor = linebuf; linebuf[0] = 0; genbuf[0] = c; ixlatctl(1); if (peekbr()) { if (!INS[0] || (unsigned char)INS[128] == 0200) { INS[128] = 0; goto blewit; } vglobp = INS; } OP = Pline; Pline = normline; (void)vgetline(0, genbuf + 1, &waste, c); doomed = 0; /* don't care about doomed characters in echo line */ ixlatctl(0); if (Outchar == termchar) putchar('\n'); vscrap(); Pline = OP; if (Peekkey != ATTN && Peekkey != QUIT && Peekkey != CTRL('h')) { cursor = sc; vclreol(); return (0); } blewit: OPeek = Peekkey==CTRL('h') ? 0 : Peekkey; Peekkey = 0; splitw = 0; vclean(); vshow(dot, NOLINE); vnline(sc); Peekkey = OPeek; return (1); } /* * A complete command has been defined for * the purposes of repeat, so copy it from * the working to the previous command buffer. */ void setLAST(void) { if (vglobp || vmacp) return; lastreg = vreg; lasthad = Xhadcnt; lastcnt = Xcnt; *lastcp = 0; CP(lastcmd, workcmd); } /* * Gather up some more text from an insert. * If the insertion buffer oveflows, then destroy * the repeatability of the insert. */ void addtext(unsigned char *cp) { if (vglobp) return; addto(INS, cp); if ((unsigned char)INS[128] == 0200) lastcmd[0] = 0; } void setDEL(void) { setBUF(DEL); } /* * Put text from cursor upto wcursor in BUF. */ void setBUF(unsigned char *BUF) { int c; unsigned char *wp = wcursor; c = *wp; *wp = 0; BUF[0] = 0; BUF[128] = 0; addto(BUF, cursor); *wp = c; } void addto(unsigned char *buf, unsigned char *str) { if ((unsigned char)buf[128] == 0200) return; if (strlen(buf) + strlen(str) + 1 >= VBSIZE) { buf[128] = 0200; return; } (void)strcat(buf, str); buf[128] = 0; } /* * Verbalize command name and embed it in message. */ char * verbalize(cnt, cmdstr, sgn) int cnt; char *cmdstr, *sgn; { if (cmdstr[0] == '\0') cmdstr = (char *)Command; if (sgn[0] == '\0') { switch (cmdstr[0]) { case 'c': if (cmdstr[1] == 'h') { viprintf((cnt == 1) ? gettext("1 line changed") : gettext("%d lines changed"), cnt); break; } else if (cmdstr[1] != 'o') { goto Default; } case 't': if (cmdstr[1] != '\0') goto Default; viprintf((cnt == 1) ? gettext("1 line copied") : gettext("%d lines copied"), cnt); break; case 'd': viprintf((cnt == 1) ? gettext("1 line deleted") : gettext("%d lines deleted"), cnt); break; case 'j': viprintf((cnt == 1) ? gettext("1 line joined") : gettext("%d lines joined"), cnt); break; case 'm': viprintf((cnt == 1) ? gettext("1 line moved") : gettext("%d lines moved"), cnt); break; case 'p': viprintf((cnt == 1) ? gettext("1 line put") : gettext("%d lines put"), cnt); break; case 'y': viprintf((cnt == 1) ? gettext("1 line yanked") : gettext("%d lines yanked"), cnt); break; case '>': viprintf((cnt == 1) ? gettext("1 line >>ed") : gettext("%d lines >>ed"), cnt); break; case '=': viprintf((cnt == 1) ? gettext("1 line =ed") : gettext("%d lines =ed"), cnt); break; case '<': viprintf((cnt == 1) ? gettext("1 line <<ed") : gettext("%d lines <<ed"), cnt); break; default: Default: viprintf((cnt == 1) ? gettext("1 line") : gettext("%d lines"), cnt); break; } } else if (sgn[0] == 'm') { viprintf((cnt == 1) ? gettext("1 more line") : gettext("%d more lines"), cnt); } else { viprintf((cnt == 1) ? gettext("1 fewer line") : gettext("%d fewer lines"), cnt); } return (NULL); } /* * Note a change affecting a lot of lines, or non-visible * lines. If the parameter must is set, then we only want * to do this for open modes now; return and save for later * notification in visual. */ int noteit(must) bool must; { int sdl = destline, sdc = destcol; if (notecnt < 1 || !must && state == VISUAL) return (0); splitw++; if (WBOT == WECHO) vmoveitup(1, 1); vigoto(WECHO, 0); verbalize(notecnt, notenam, notesgn); vclreol(); notecnt = 0; if (state != VISUAL) vcnt = vcline = 0; splitw = 0; if (state == ONEOPEN || state == CRTOPEN) vup1(); destline = sdl; destcol = sdc; return (1); } /* * Ring or beep. * If possible, flash screen. */ int beep(void) { if (flash_screen && value(vi_FLASH)) vputp(flash_screen, 0); else if (bell) vputp(bell, 0); return (0); } /* * Map the command input character c, * for keypads and labelled keys which do cursor * motions. I.e. on an adm3a we might map ^K to ^P. * DM1520 for example has a lot of mappable characters. */ int map(c, maps, commch) int c; struct maps *maps; unsigned char commch; /* indicate if in append/insert/replace mode */ { int d; unsigned char *p, *q; unsigned char b[10]; /* Assumption: no keypad sends string longer than 10 */ unsigned char *st; /* * Mapping for special keys on the terminal only. * BUG: if there's a long sequence and it matches * some chars and then misses, we lose some chars. * * For this to work, some conditions must be met. * 1) Keypad sends SHORT (2 or 3 char) strings * 2) All strings sent are same length & similar * 3) The user is unlikely to type the first few chars of * one of these strings very fast. * Note: some code has been fixed up since the above was laid out, * so conditions 1 & 2 are probably not required anymore. * However, this hasn't been tested with any first char * that means anything else except escape. */ #ifdef MDEBUG if (trace) fprintf(trace,"map(%c): ",c); #endif /* * If c==0, the char came from getesc typing escape. Pass it through * unchanged. 0 messes up the following code anyway. */ if (c==0) return(0); b[0] = c; b[1] = 0; for (d=0; d < MAXNOMACS && maps[d].mapto; d++) { #ifdef MDEBUG if (trace) fprintf(trace,"\ntry '%s', ",maps[d].cap); #endif if (p = maps[d].cap) { for (q=b; *p; p++, q++) { #ifdef MDEBUG if (trace) fprintf(trace,"q->b[%d], ",q-b); #endif if (*q==0) { /* * Is there another char waiting? * * This test is oversimplified, but * should work mostly. It handles the * case where we get an ESCAPE that * wasn't part of a keypad string. */ if ((c=='#' ? peekkey() : fastpeekkey()) == 0) { #ifdef MDEBUG if (trace) fprintf(trace,"fpk=0: will return '%c'",c); #endif /* * Nothing waiting. Push back * what we peeked at & return * failure (c). * * We want to be able to undo * commands, but it's nonsense * to undo part of an insertion * so if in input mode don't. */ #ifdef MDEBUG if (trace) fprintf(trace, "Call macpush, b %d %d %d\n", b[0], b[1], b[2]); #endif macpush(&b[1],maps == arrows); #ifdef MDEBUG if (trace) fprintf(trace, "return %d\n", c); #endif return(c); } *q = getkey(); q[1] = 0; } if (*p != *q) goto contin; } macpush(maps[d].mapto,maps == arrows); /* * For all macros performed within insert, * append, or replacement mode, we must end * up returning back to that mode when we * return (except that append will become * insert for <home> key, so cursor is not * in second column). * * In order to preserve backward movement * when leaving insert mode, an 'l' must be * done to compensate for the left done by * the <esc> (except when cursor is already * in the first column: i.e., outcol = 0). */ if ((maps == immacs) && strcmp(maps[d].descr, maps[d].cap)) { switch (commch) { case 'R': if (!strcmp(maps[d].descr, "home")) st = (unsigned char *)"R"; else if (outcol == 0) st = (unsigned char *)"R"; else st = (unsigned char *)"lR"; break; case 'i': if (!strcmp(maps[d].descr, "home")) st = (unsigned char *)"i"; else if (outcol == 0) st = (unsigned char *)"i"; else st = (unsigned char *)"li"; break; case 'a': if (!strcmp(maps[d].descr, "home")) st = (unsigned char *)"i"; else st = (unsigned char *)"a"; break; default: st = (unsigned char *)"i"; } if(strlen(vmacbuf) + strlen(st) > BUFSIZE) error(value(vi_TERSE) ? gettext("Macro too long") : gettext("Macro too long - maybe recursive?")); else /* * Macros such as function keys are * performed by leaving the insert, * replace, or append mode, executing * the proper cursor movement commands * and returning to the mode we are * currently in (commch). */ strcat(vmacbuf, st); } c = getkey(); #ifdef MDEBUG if (trace) fprintf(trace,"Success: push(%s), return %c",maps[d].mapto, c); #endif return(c); /* first char of map string */ contin:; } } #ifdef MDEBUG if (trace) fprintf(trace,"Fail: push(%s), return %c", &b[1], c); #endif macpush(&b[1],0); return(c); } /* * Push st onto the front of vmacp. This is tricky because we have to * worry about where vmacp was previously pointing. We also have to * check for overflow (which is typically from a recursive macro) * Finally we have to set a flag so the whole thing can be undone. * canundo is 1 iff we want to be able to undo the macro. This * is false for, for example, pushing back lookahead from fastpeekkey(), * since otherwise two fast escapes can clobber our undo. */ void macpush(unsigned char *st, int canundo) { unsigned char tmpbuf[BUFSIZE]; if (st==0 || *st==0) return; #ifdef MDEBUG if (trace) fprintf(trace, "macpush(%s), canundo=%d\n",st,canundo); #endif if ((vmacp ? strlen(vmacp) : 0) + strlen(st) > BUFSIZE) error(value(vi_TERSE) ? gettext("Macro too long") : gettext("Macro too long - maybe recursive?")); if (vmacp) { strcpy(tmpbuf, vmacp); if (!FIXUNDO) canundo = 0; /* can't undo inside a macro anyway */ } strcpy(vmacbuf, st); if (vmacp) strcat(vmacbuf, tmpbuf); vmacp = vmacbuf; /* arrange to be able to undo the whole macro */ if (canundo) { #ifdef notdef otchng = tchng; vsave(); saveall(); inopen = -1; /* no need to save since it had to be 1 or -1 before */ vundkind = VMANY; #endif vch_mac = VC_NOCHANGE; } } #ifdef UNDOTRACE visdump(s) unsigned char *s; { int i; if (!trace) return; fprintf(trace, "\n%s: basWTOP=%d, basWLINES=%d, WTOP=%d, WBOT=%d, WLINES=%d, WCOLS=%d, WECHO=%d\n", s, basWTOP, basWLINES, WTOP, WBOT, WLINES, WCOLS, WECHO); fprintf(trace, " vcnt=%d, vcline=%d, cursor=%d, wcursor=%d, wdot=%d\n", vcnt, vcline, cursor-linebuf, wcursor-linebuf, wdot-zero); for (i=0; i<TUBELINES; i++) if (vtube[i] && *vtube[i]) fprintf(trace, "%d: '%s'\n", i, vtube[i]); tvliny(); } vudump(s) unsigned char *s; { line *p; unsigned char savelb[1024]; if (!trace) return; fprintf(trace, "\n%s: undkind=%d, vundkind=%d, unddel=%d, undap1=%d, undap2=%d,\n", s, undkind, vundkind, lineno(unddel), lineno(undap1), lineno(undap2)); fprintf(trace, " undadot=%d, dot=%d, dol=%d, unddol=%d, truedol=%d\n", lineno(undadot), lineno(dot), lineno(dol), lineno(unddol), lineno(truedol)); fprintf(trace, " [\n"); CP(savelb, linebuf); fprintf(trace, "linebuf = '%s'\n", linebuf); for (p=zero+1; p<=truedol; p++) { fprintf(trace, "%o ", *p); getaline(*p); fprintf(trace, "'%s'\n", linebuf); } fprintf(trace, "]\n"); CP(linebuf, savelb); } #endif /* * Get a count from the keyed input stream. * A zero count is indistinguishable from no count. */ int vgetcnt(void) { int c, cnt; cnt = 0; for (;;) { c = getkey(); if (!isdigit(c)) break; cnt *= 10, cnt += c - '0'; } ungetkey(c); Xhadcnt = 1; Xcnt = cnt; return(cnt); } /* * fastpeekkey is just like peekkey but insists the character come in * fast (within 1 second). This will succeed if it is the 2nd char of * a machine generated sequence (such as a function pad from an escape * flavor terminal) but fail for a human hitting escape then waiting. */ int fastpeekkey(void) { void trapalarm(); int c; /* * If the user has set notimeout, we wait forever for a key. * If we are in a macro we do too, but since it's already * buffered internally it will return immediately. * In other cases we force this to die in 1 second. * This is pretty reliable (VMUNIX rounds it to .5 - 1.5 secs, * but UNIX truncates it to 0 - 1 secs) but due to system delays * there are times when arrow keys or very fast typing get counted * as separate. notimeout is provided for people who dislike such * nondeterminism. */ CATCH if (value(vi_TIMEOUT) && inopen >= 0) { signal(SIGALRM, trapalarm); setalarm(); } c = peekkey(); cancelalarm(); ONERR c = 0; ENDCATCH /* Should have an alternative method based on select for 4.2BSD */ return(c); } static int ftfd; struct requestbuf { short time; short signo; }; /* * Arrange for SIGALRM to come in shortly, so we don't * hang very long if the user didn't type anything. There are * various ways to do this on different systems. */ void setalarm(void) { unsigned char ftname[20]; struct requestbuf rb; #ifdef FTIOCSET /* * Use nonstandard "fast timer" to get better than * one second resolution. We must wait at least * 1/15th of a second because some keypads don't * transmit faster than this. */ /* Open ft psuedo-device - we need our own copy. */ if (ftfd == 0) { strcpy(ftname, "/dev/ft0"); while (ftfd <= 0 && ftname[7] <= '~') { ftfd = open(ftname, 0); if (ftfd <= 0) ftname[7] ++; } } if (ftfd <= 0) { /* Couldn't open a /dev/ft? */ alarm(1); } else { rb.time = 6; /* 6 ticks = 100 ms > 67 ms. */ rb.signo = SIGALRM; ioctl(ftfd, FTIOCSET, &rb); } #else /* * No special capabilities, so we use alarm, with 1 sec. resolution. */ alarm(1); #endif } /* * Get rid of any impending incoming SIGALRM. */ void cancelalarm(void) { struct requestbuf rb; #ifdef FTIOCSET if (ftfd > 0) { rb.time = 0; rb.signo = SIGALRM; ioctl(ftfd, FTIOCCANCEL, &rb); } #endif alarm(0); /* Have to do this whether or not FTIOCSET */ } void trapalarm() { alarm(0); longjmp(vreslab,1); }