/* $OpenBSD: vi.c,v 1.56 2018/03/15 16:51:29 anton Exp $ */ /* * vi command editing * written by John Rochester (initially for nsh) * bludgeoned to fit pdksh by Larry Bouzane, Jeff Sparkes & Eric Gisin * */ #include "config.h" #ifdef VI #include <sys/stat.h> /* completion */ #include <ctype.h> #include <stdlib.h> #include <string.h> #include "sh.h" #include "edit.h" #define CTRL(c) (c & 0x1f) struct edstate { char *cbuf; /* main buffer to build the command line */ int cbufsize; /* number of bytes allocated for cbuf */ int linelen; /* current number of bytes in cbuf */ int winleft; /* first byte# in cbuf to be displayed */ int cursor; /* byte# in cbuf having the cursor */ }; static int vi_hook(int); static void vi_reset(char *, size_t); static int nextstate(int); static int vi_insert(int); static int vi_cmd(int, const char *); static int domove(int, const char *, int); static int redo_insert(int); static void yank_range(int, int); static int bracktype(int); static void save_cbuf(void); static void restore_cbuf(void); static void edit_reset(char *, size_t); static int putbuf(const char *, int, int); static void del_range(int, int); static int findch(int, int, int, int); static int forwword(int); static int backword(int); static int endword(int); static int Forwword(int); static int Backword(int); static int Endword(int); static int grabhist(int, int); static int grabsearch(int, int, int, char *); static void redraw_line(int); static void refresh(int); static int outofwin(void); static void rewindow(void); static int newcol(int, int); static void display(char *, char *, int); static void ed_mov_opt(int, char *); static int expand_word(int); static int complete_word(int, int); static int print_expansions(struct edstate *); static int char_len(int); static void x_vi_zotc(int); static void vi_pprompt(int); static void vi_error(void); static void vi_macro_reset(void); static int x_vi_putbuf(const char *, size_t); static int isu8cont(unsigned char); #define C_ 0x1 /* a valid command that isn't a M_, E_, U_ */ #define M_ 0x2 /* movement command (h, l, etc.) */ #define E_ 0x4 /* extended command (c, d, y) */ #define X_ 0x8 /* long command (@, f, F, t, T, etc.) */ #define U_ 0x10 /* an UN-undoable command (that isn't a M_) */ #define B_ 0x20 /* bad command (^@) */ #define Z_ 0x40 /* repeat count defaults to 0 (not 1) */ #define S_ 0x80 /* search (/, ?) */ #define is_bad(c) (classify[(c)&0x7f]&B_) #define is_cmd(c) (classify[(c)&0x7f]&(M_|E_|C_|U_)) #define is_move(c) (classify[(c)&0x7f]&M_) #define is_extend(c) (classify[(c)&0x7f]&E_) #define is_long(c) (classify[(c)&0x7f]&X_) #define is_undoable(c) (!(classify[(c)&0x7f]&U_)) #define is_srch(c) (classify[(c)&0x7f]&S_) #define is_zerocount(c) (classify[(c)&0x7f]&Z_) const unsigned char classify[128] = { /* 0 1 2 3 4 5 6 7 */ /* 0 ^@ ^A ^B ^C ^D ^E ^F ^G */ B_, 0, 0, 0, 0, C_|U_, C_|Z_, 0, /* 01 ^H ^I ^J ^K ^L ^M ^N ^O */ M_, C_|Z_, 0, 0, C_|U_, 0, C_, 0, /* 02 ^P ^Q ^R ^S ^T ^U ^V ^W */ C_, 0, C_|U_, 0, 0, 0, C_, 0, /* 03 ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */ C_, 0, 0, C_|Z_, 0, 0, 0, 0, /* 04 <space> ! " # $ % & ' */ M_, 0, 0, C_, M_, M_, 0, 0, /* 05 ( ) * + , - . / */ 0, 0, C_, C_, M_, C_, 0, C_|S_, /* 06 0 1 2 3 4 5 6 7 */ M_, 0, 0, 0, 0, 0, 0, 0, /* 07 8 9 : ; < = > ? */ 0, 0, 0, M_, 0, C_, 0, C_|S_, /* 010 @ A B C D E F G */ C_|X_, C_, M_, C_, C_, M_, M_|X_, C_|U_|Z_, /* 011 H I J K L M N O */ 0, C_, 0, 0, 0, 0, C_|U_, 0, /* 012 P Q R S T U V W */ C_, 0, C_, C_, M_|X_, C_, 0, M_, /* 013 X Y Z [ \ ] ^ _ */ C_, C_|U_, 0, 0, C_|Z_, 0, M_, C_|Z_, /* 014 ` a b c d e f g */ 0, C_, M_, E_, E_, M_, M_|X_, C_|Z_, /* 015 h i j k l m n o */ M_, C_, C_|U_, C_|U_, M_, 0, C_|U_, 0, /* 016 p q r s t u v w */ C_, 0, X_, C_, M_|X_, C_|U_, C_|U_|Z_,M_, /* 017 x y z { | } ~ ^? */ C_, E_|U_, 0, 0, M_|Z_, 0, C_, 0 }; #define MAXVICMD 3 #define SRCHLEN 40 #define INSERT 1 #define REPLACE 2 #define VNORMAL 0 /* command, insert or replace mode */ #define VARG1 1 /* digit prefix (first, eg, 5l) */ #define VEXTCMD 2 /* cmd + movement (eg, cl) */ #define VARG2 3 /* digit prefix (second, eg, 2c3l) */ #define VXCH 4 /* f, F, t, T, @ */ #define VFAIL 5 /* bad command */ #define VCMD 6 /* single char command (eg, X) */ #define VREDO 7 /* . */ #define VLIT 8 /* ^V */ #define VSEARCH 9 /* /, ? */ static char undocbuf[LINE]; static struct edstate *save_edstate(struct edstate *old); static void restore_edstate(struct edstate *old, struct edstate *new); static void free_edstate(struct edstate *old); static struct edstate ebuf; static struct edstate undobuf = { undocbuf, LINE, 0, 0, 0 }; static struct edstate *es; /* current editor state */ static struct edstate *undo; static char ibuf[LINE]; /* input buffer */ static int first_insert; /* set when starting in insert mode */ static int saved_inslen; /* saved inslen for first insert */ static int inslen; /* length of input buffer */ static int srchlen; /* number of bytes in search pattern */ static char ybuf[LINE]; /* yank buffer */ static int yanklen; /* length of yank buffer */ static int fsavecmd = ' '; /* last find command */ static int fsavech; /* character to find */ static char lastcmd[MAXVICMD]; /* last non-move command */ static int lastac; /* argcnt for lastcmd */ static int lastsearch = ' '; /* last search command */ static char srchpat[SRCHLEN]; /* last search pattern */ static int insert; /* mode: INSERT, REPLACE, or 0 */ static int hnum; /* position in history */ static int ohnum; /* history line copied (after mod) */ static int hlast; /* 1 past last position in history */ static int modified; /* buffer has been "modified" */ static int state; /* Information for keeping track of macros that are being expanded. * The format of buf is the alias contents followed by a null byte followed * by the name (letter) of the alias. The end of the buffer is marked by * a double null. The name of the alias is stored so recursive macros can * be detected. */ struct macro_state { unsigned char *p; /* current position in buf */ unsigned char *buf; /* pointer to macro(s) being expanded */ int len; /* how much data in buffer */ }; static struct macro_state macro; enum expand_mode { NONE, EXPAND, COMPLETE, PRINT }; static enum expand_mode expanded = NONE;/* last input was expanded */ int x_vi(char *buf, size_t len) { int c; vi_reset(buf, len > LINE ? LINE : len); vi_pprompt(1); x_flush(); while (1) { if (macro.p) { c = (unsigned char)*macro.p++; /* end of current macro? */ if (!c) { /* more macros left to finish? */ if (*macro.p++) continue; /* must be the end of all the macros */ vi_macro_reset(); c = x_getc(); } } else c = x_getc(); if (c == -1) break; if (state != VLIT) { if (c == edchars.intr || c == edchars.quit) { /* pretend we got an interrupt */ x_vi_zotc(c); x_flush(); trapsig(c == edchars.intr ? SIGINT : SIGQUIT); x_mode(false); unwind(LSHELL); } else if (c == edchars.eof) { if (es->linelen == 0) { x_vi_zotc(edchars.eof); c = -1; break; } continue; } } if (vi_hook(c)) break; x_flush(); } x_putc('\r'); x_putc('\n'); x_flush(); if (c == -1 || len <= (size_t)es->linelen) return -1; if (es->cbuf != buf) memmove(buf, es->cbuf, es->linelen); buf[es->linelen++] = '\n'; return es->linelen; } static int vi_hook(int ch) { static char curcmd[MAXVICMD], locpat[SRCHLEN]; static int cmdlen, argc1, argc2; switch (state) { case VNORMAL: if (insert != 0) { if (ch == CTRL('v')) { state = VLIT; ch = '^'; } switch (vi_insert(ch)) { case -1: vi_error(); state = VNORMAL; break; case 0: if (state == VLIT) { es->cursor--; refresh(0); } else refresh(insert != 0); break; case 1: return 1; } } else { if (ch == '\r' || ch == '\n') return 1; cmdlen = 0; argc1 = 0; if (ch >= '1' && ch <= '9') { argc1 = ch - '0'; state = VARG1; } else { curcmd[cmdlen++] = ch; state = nextstate(ch); if (state == VSEARCH) { save_cbuf(); es->cursor = 0; es->linelen = 0; if (ch == '/') { if (putbuf("/", 1, 0) != 0) return -1; } else if (putbuf("?", 1, 0) != 0) return -1; refresh(0); } } } break; case VLIT: if (is_bad(ch)) { del_range(es->cursor, es->cursor + 1); vi_error(); } else es->cbuf[es->cursor++] = ch; refresh(1); state = VNORMAL; break; case VARG1: if (isdigit(ch)) argc1 = argc1 * 10 + ch - '0'; else { curcmd[cmdlen++] = ch; state = nextstate(ch); } break; case VEXTCMD: argc2 = 0; if (ch >= '1' && ch <= '9') { argc2 = ch - '0'; state = VARG2; return 0; } else { curcmd[cmdlen++] = ch; if (ch == curcmd[0]) state = VCMD; else if (is_move(ch)) state = nextstate(ch); else state = VFAIL; } break; case VARG2: if (isdigit(ch)) argc2 = argc2 * 10 + ch - '0'; else { if (argc1 == 0) argc1 = argc2; else argc1 *= argc2; curcmd[cmdlen++] = ch; if (ch == curcmd[0]) state = VCMD; else if (is_move(ch)) state = nextstate(ch); else state = VFAIL; } break; case VXCH: if (ch == CTRL('[')) state = VNORMAL; else { curcmd[cmdlen++] = ch; state = VCMD; } break; case VSEARCH: if (ch == '\r' || ch == '\n' /*|| ch == CTRL('[')*/ ) { restore_cbuf(); /* Repeat last search? */ if (srchlen == 0) { if (!srchpat[0]) { vi_error(); state = VNORMAL; refresh(0); return 0; } } else { locpat[srchlen] = '\0'; (void) strlcpy(srchpat, locpat, sizeof srchpat); } state = VCMD; } else if (ch == edchars.erase || ch == CTRL('h')) { if (srchlen != 0) { do { srchlen--; es->linelen -= char_len( (unsigned char)locpat[srchlen]); } while (srchlen > 0 && isu8cont(locpat[srchlen])); es->cursor = es->linelen; refresh(0); return 0; } restore_cbuf(); state = VNORMAL; refresh(0); } else if (ch == edchars.kill) { srchlen = 0; es->linelen = 1; es->cursor = 1; refresh(0); return 0; } else if (ch == edchars.werase) { struct edstate new_es, *save_es; int i; int n = srchlen; new_es.cursor = n; new_es.cbuf = locpat; save_es = es; es = &new_es; n = backword(1); es = save_es; for (i = srchlen; --i >= n; ) es->linelen -= char_len((unsigned char)locpat[i]); srchlen = n; es->cursor = es->linelen; refresh(0); return 0; } else { if (srchlen == SRCHLEN - 1) vi_error(); else { locpat[srchlen++] = ch; if ((ch & 0x80) && Flag(FVISHOW8)) { if (es->linelen + 2 > es->cbufsize) vi_error(); es->cbuf[es->linelen++] = 'M'; es->cbuf[es->linelen++] = '-'; ch &= 0x7f; } if (ch < ' ' || ch == 0x7f) { if (es->linelen + 2 > es->cbufsize) vi_error(); es->cbuf[es->linelen++] = '^'; es->cbuf[es->linelen++] = ch ^ '@'; } else { if (es->linelen >= es->cbufsize) vi_error(); es->cbuf[es->linelen++] = ch; } es->cursor = es->linelen; refresh(0); } return 0; } break; } switch (state) { case VCMD: state = VNORMAL; switch (vi_cmd(argc1, curcmd)) { case -1: vi_error(); refresh(0); break; case 0: if (insert != 0) inslen = 0; refresh(insert != 0); break; case 1: refresh(0); return 1; case 2: /* back from a 'v' command - don't redraw the screen */ return 1; } break; case VREDO: state = VNORMAL; if (argc1 != 0) lastac = argc1; switch (vi_cmd(lastac, lastcmd)) { case -1: vi_error(); refresh(0); break; case 0: if (insert != 0) { if (lastcmd[0] == 's' || lastcmd[0] == 'c' || lastcmd[0] == 'C') { if (redo_insert(1) != 0) vi_error(); } else { if (redo_insert(lastac) != 0) vi_error(); } } refresh(0); break; case 1: refresh(0); return 1; case 2: /* back from a 'v' command - can't happen */ break; } break; case VFAIL: state = VNORMAL; vi_error(); break; } return 0; } static void vi_reset(char *buf, size_t len) { state = VNORMAL; ohnum = hnum = hlast = histnum(-1) + 1; insert = INSERT; saved_inslen = inslen; first_insert = 1; inslen = 0; modified = 1; vi_macro_reset(); edit_reset(buf, len); } static int nextstate(int ch) { if (is_extend(ch)) return VEXTCMD; else if (is_srch(ch)) return VSEARCH; else if (is_long(ch)) return VXCH; else if (ch == '.') return VREDO; else if (is_cmd(ch)) return VCMD; else return VFAIL; } static int vi_insert(int ch) { int tcursor; if (ch == edchars.erase || ch == CTRL('h')) { if (insert == REPLACE) { if (es->cursor == undo->cursor) { vi_error(); return 0; } } else { if (es->cursor == 0) { /* x_putc(BEL); no annoying bell here */ return 0; } } tcursor = es->cursor - 1; while(tcursor > 0 && isu8cont(es->cbuf[tcursor])) tcursor--; if (insert == INSERT) memmove(es->cbuf + tcursor, es->cbuf + es->cursor, es->linelen - es->cursor); if (insert == REPLACE && es->cursor < undo->linelen) memcpy(es->cbuf + tcursor, undo->cbuf + tcursor, es->cursor - tcursor); else es->linelen -= es->cursor - tcursor; if (inslen < es->cursor - tcursor) inslen = 0; else inslen -= es->cursor - tcursor; es->cursor = tcursor; expanded = NONE; return 0; } if (ch == edchars.kill) { if (es->cursor != 0) { inslen = 0; memmove(es->cbuf, &es->cbuf[es->cursor], es->linelen - es->cursor); es->linelen -= es->cursor; es->cursor = 0; } expanded = NONE; return 0; } if (ch == edchars.werase) { if (es->cursor != 0) { tcursor = backword(1); memmove(&es->cbuf[tcursor], &es->cbuf[es->cursor], es->linelen - es->cursor); es->linelen -= es->cursor - tcursor; if (inslen < es->cursor - tcursor) inslen = 0; else inslen -= es->cursor - tcursor; es->cursor = tcursor; } expanded = NONE; return 0; } /* If any chars are entered before escape, trash the saved insert * buffer (if user inserts & deletes char, ibuf gets trashed and * we don't want to use it) */ if (first_insert && ch != CTRL('[')) saved_inslen = 0; switch (ch) { case '\0': return -1; case '\r': case '\n': return 1; case CTRL('['): expanded = NONE; if (first_insert) { first_insert = 0; if (inslen == 0) { inslen = saved_inslen; return redo_insert(0); } lastcmd[0] = 'a'; lastac = 1; } if (lastcmd[0] == 's' || lastcmd[0] == 'c' || lastcmd[0] == 'C') return redo_insert(0); else return redo_insert(lastac - 1); /* { Begin nonstandard vi commands */ case CTRL('x'): expand_word(0); break; case CTRL('f'): complete_word(0, 0); break; case CTRL('e'): print_expansions(es); break; case CTRL('i'): if (Flag(FVITABCOMPLETE)) { complete_word(0, 0); break; } /* FALLTHROUGH */ /* End nonstandard vi commands } */ default: if (es->linelen >= es->cbufsize - 1) return -1; ibuf[inslen++] = ch; if (insert == INSERT) { memmove(&es->cbuf[es->cursor+1], &es->cbuf[es->cursor], es->linelen - es->cursor); es->linelen++; } es->cbuf[es->cursor++] = ch; if (insert == REPLACE && es->cursor > es->linelen) es->linelen++; expanded = NONE; } return 0; } static int vi_cmd(int argcnt, const char *cmd) { int ncursor; int cur, c1, c2, c3 = 0; int any; struct edstate *t; if (argcnt == 0 && !is_zerocount(*cmd)) argcnt = 1; if (is_move(*cmd)) { if ((cur = domove(argcnt, cmd, 0)) >= 0) { if (cur == es->linelen && cur != 0) while (isu8cont(es->cbuf[--cur])) continue; es->cursor = cur; } else return -1; } else { /* Don't save state in middle of macro.. */ if (is_undoable(*cmd) && !macro.p) { undo->winleft = es->winleft; memmove(undo->cbuf, es->cbuf, es->linelen); undo->linelen = es->linelen; undo->cursor = es->cursor; lastac = argcnt; memmove(lastcmd, cmd, MAXVICMD); } switch (*cmd) { case CTRL('l'): case CTRL('r'): redraw_line(1); break; case '@': { static char alias[] = "_\0"; struct tbl *ap; int olen, nlen; char *p, *nbuf; /* lookup letter in alias list... */ alias[1] = cmd[1]; ap = ktsearch(&aliases, alias, hash(alias)); if (!cmd[1] || !ap || !(ap->flag & ISSET)) return -1; /* check if this is a recursive call... */ if ((p = (char *) macro.p)) while ((p = strchr(p, '\0')) && p[1]) if (*++p == cmd[1]) return -1; /* insert alias into macro buffer */ nlen = strlen(ap->val.s) + 1; olen = !macro.p ? 2 : macro.len - (macro.p - macro.buf); nbuf = alloc(nlen + 1 + olen, APERM); memcpy(nbuf, ap->val.s, nlen); nbuf[nlen++] = cmd[1]; if (macro.p) { memcpy(nbuf + nlen, macro.p, olen); afree(macro.buf, APERM); nlen += olen; } else { nbuf[nlen++] = '\0'; nbuf[nlen++] = '\0'; } macro.p = macro.buf = (unsigned char *) nbuf; macro.len = nlen; } break; case 'a': modified = 1; hnum = hlast; if (es->linelen != 0) while (isu8cont(es->cbuf[++es->cursor])) continue; insert = INSERT; break; case 'A': modified = 1; hnum = hlast; del_range(0, 0); es->cursor = es->linelen; insert = INSERT; break; case 'S': es->cursor = domove(1, "^", 1); del_range(es->cursor, es->linelen); modified = 1; hnum = hlast; insert = INSERT; break; case 'Y': cmd = "y$"; /* ahhhhhh... */ case 'c': case 'd': case 'y': if (*cmd == cmd[1]) { c1 = *cmd == 'c' ? domove(1, "^", 1) : 0; c2 = es->linelen; } else if (!is_move(cmd[1])) return -1; else { if ((ncursor = domove(argcnt, &cmd[1], 1)) < 0) return -1; if (*cmd == 'c' && (cmd[1]=='w' || cmd[1]=='W') && !isspace((unsigned char)es->cbuf[es->cursor])) { while (isspace( (unsigned char)es->cbuf[--ncursor])) ; ncursor++; } if (ncursor > es->cursor) { c1 = es->cursor; c2 = ncursor; } else { c1 = ncursor; c2 = es->cursor; if (cmd[1] == '%') c2++; } } if (*cmd != 'c' && c1 != c2) yank_range(c1, c2); if (*cmd != 'y') { del_range(c1, c2); es->cursor = c1; } if (*cmd == 'c') { modified = 1; hnum = hlast; insert = INSERT; } break; case 'p': modified = 1; hnum = hlast; if (es->linelen != 0) es->cursor++; while (putbuf(ybuf, yanklen, 0) == 0 && --argcnt > 0) ; if (es->cursor != 0) es->cursor--; if (argcnt != 0) return -1; break; case 'P': modified = 1; hnum = hlast; any = 0; while (putbuf(ybuf, yanklen, 0) == 0 && --argcnt > 0) any = 1; if (any && es->cursor != 0) es->cursor--; if (argcnt != 0) return -1; break; case 'C': modified = 1; hnum = hlast; del_range(es->cursor, es->linelen); insert = INSERT; break; case 'D': yank_range(es->cursor, es->linelen); del_range(es->cursor, es->linelen); if (es->cursor != 0) es->cursor--; break; case 'g': if (!argcnt) argcnt = hlast; /* FALLTHROUGH */ case 'G': if (!argcnt) argcnt = 1; else argcnt = hlast - (source->line - argcnt); if (grabhist(modified, argcnt - 1) < 0) return -1; else { modified = 0; hnum = argcnt - 1; } break; case 'i': modified = 1; hnum = hlast; insert = INSERT; break; case 'I': modified = 1; hnum = hlast; es->cursor = domove(1, "^", 1); insert = INSERT; break; case 'j': case '+': case CTRL('n'): if (grabhist(modified, hnum + argcnt) < 0) return -1; else { modified = 0; hnum += argcnt; } break; case 'k': case '-': case CTRL('p'): if (grabhist(modified, hnum - argcnt) < 0) return -1; else { modified = 0; hnum -= argcnt; } break; case 'r': if (es->linelen == 0) return -1; modified = 1; hnum = hlast; if (cmd[1] == 0) vi_error(); else { c1 = 0; for (cur = es->cursor; cur < es->linelen; cur++) { if (!isu8cont(es->cbuf[cur])) c1++; if (c1 > argcnt) break; } if (argcnt > c1) return -1; del_range(es->cursor, cur); while (argcnt-- > 0) putbuf(&cmd[1], 1, 0); while (es->cursor > 0) if (!isu8cont(es->cbuf[--es->cursor])) break; es->cbuf[es->linelen] = '\0'; } break; case 'R': modified = 1; hnum = hlast; insert = REPLACE; break; case 's': if (es->linelen == 0) return -1; modified = 1; hnum = hlast; for (cur = es->cursor; cur < es->linelen; cur++) if (!isu8cont(es->cbuf[cur])) if (argcnt-- == 0) break; del_range(es->cursor, cur); insert = INSERT; break; case 'v': if (es->linelen == 0 && argcnt == 0) return -1; if (!argcnt) { if (modified) { es->cbuf[es->linelen] = '\0'; source->line++; histsave(source->line, es->cbuf, 1); } else argcnt = source->line + 1 - (hlast - hnum); } shf_snprintf(es->cbuf, es->cbufsize, argcnt ? "%s %d" : "%s", "fc -e ${VISUAL:-${EDITOR:-vi}} --", argcnt); es->linelen = strlen(es->cbuf); return 2; case 'x': if (es->linelen == 0) return -1; modified = 1; hnum = hlast; for (cur = es->cursor; cur < es->linelen; cur++) if (!isu8cont(es->cbuf[cur])) if (argcnt-- == 0) break; yank_range(es->cursor, cur); del_range(es->cursor, cur); break; case 'X': if (es->cursor == 0) return -1; modified = 1; hnum = hlast; for (cur = es->cursor; cur > 0; cur--) if (!isu8cont(es->cbuf[cur])) if (argcnt-- == 0) break; yank_range(cur, es->cursor); del_range(cur, es->cursor); es->cursor = cur; break; case 'u': t = es; es = undo; undo = t; break; case 'U': if (!modified) return -1; if (grabhist(modified, ohnum) < 0) return -1; modified = 0; hnum = ohnum; break; case '?': if (hnum == hlast) hnum = -1; /* ahhh */ case '/': c3 = 1; srchlen = 0; lastsearch = *cmd; /* FALLTHROUGH */ case 'n': case 'N': if (lastsearch == ' ') return -1; if (lastsearch == '?') c1 = 1; else c1 = 0; if (*cmd == 'N') c1 = !c1; if ((c2 = grabsearch(modified, hnum, c1, srchpat)) < 0) { if (c3) { restore_cbuf(); refresh(0); } return -1; } else { modified = 0; hnum = c2; ohnum = hnum; } break; case '_': { int inspace; char *p, *sp; if (histnum(-1) < 0) return -1; p = *histpos(); #define issp(c) (isspace((unsigned char)(c)) || (c) == '\n') if (argcnt) { while (*p && issp(*p)) p++; while (*p && --argcnt) { while (*p && !issp(*p)) p++; while (*p && issp(*p)) p++; } if (!*p) return -1; sp = p; } else { sp = p; inspace = 0; while (*p) { if (issp(*p)) inspace = 1; else if (inspace) { inspace = 0; sp = p; } p++; } p = sp; } modified = 1; hnum = hlast; if (es->cursor != es->linelen) es->cursor++; while (*p && !issp(*p)) { argcnt++; p++; } if (putbuf(" ", 1, 0) != 0) argcnt = -1; else if (putbuf(sp, argcnt, 0) != 0) argcnt = -1; if (argcnt < 0) { if (es->cursor != 0) es->cursor--; return -1; } insert = INSERT; } break; case '~': { char *p; unsigned char c; int i; if (es->linelen == 0) return -1; for (i = 0; i < argcnt; i++) { p = &es->cbuf[es->cursor]; c = (unsigned char)*p; if (islower(c)) { modified = 1; hnum = hlast; *p = toupper(c); } else if (isupper(c)) { modified = 1; hnum = hlast; *p = tolower(c); } if (es->cursor < es->linelen - 1) es->cursor++; } break; } case '#': { int ret = x_do_comment(es->cbuf, es->cbufsize, &es->linelen); if (ret >= 0) es->cursor = 0; return ret; } case '=': /* at&t ksh */ case CTRL('e'): /* Nonstandard vi/ksh */ print_expansions(es); break; case CTRL('i'): /* Nonstandard vi/ksh */ if (!Flag(FVITABCOMPLETE)) return -1; complete_word(1, argcnt); break; case CTRL('['): /* some annoying at&t ksh's */ if (!Flag(FVIESCCOMPLETE)) return -1; case '\\': /* at&t ksh */ case CTRL('f'): /* Nonstandard vi/ksh */ complete_word(1, argcnt); break; case '*': /* at&t ksh */ case CTRL('x'): /* Nonstandard vi/ksh */ expand_word(1); break; } if (insert == 0 && es->cursor >= es->linelen) while (es->cursor > 0) if (!isu8cont(es->cbuf[--es->cursor])) break; } return 0; } static int domove(int argcnt, const char *cmd, int sub) { int bcount, i = 0, t; int ncursor = 0; switch (*cmd) { case 'b': case 'B': if (!sub && es->cursor == 0) return -1; ncursor = (*cmd == 'b' ? backword : Backword)(argcnt); break; case 'e': case 'E': if (!sub && es->cursor + 1 >= es->linelen) return -1; ncursor = (*cmd == 'e' ? endword : Endword)(argcnt); if (!sub) while (isu8cont((unsigned char)es->cbuf[--ncursor])) continue; break; case 'f': case 'F': case 't': case 'T': fsavecmd = *cmd; fsavech = cmd[1]; /* drop through */ case ',': case ';': if (fsavecmd == ' ') return -1; i = fsavecmd == 'f' || fsavecmd == 'F'; t = fsavecmd > 'a'; if (*cmd == ',') t = !t; if ((ncursor = findch(fsavech, argcnt, t, i)) < 0) return -1; if (sub && t) ncursor++; break; case 'h': case CTRL('h'): if (!sub && es->cursor == 0) return -1; for (ncursor = es->cursor; ncursor > 0; ncursor--) if (!isu8cont(es->cbuf[ncursor])) if (argcnt-- == 0) break; break; case ' ': case 'l': if (!sub && es->cursor + 1 >= es->linelen) return -1; for (ncursor = es->cursor; ncursor < es->linelen; ncursor++) if (!isu8cont(es->cbuf[ncursor])) if (argcnt-- == 0) break; break; case 'w': case 'W': if (!sub && es->cursor + 1 >= es->linelen) return -1; ncursor = (*cmd == 'w' ? forwword : Forwword)(argcnt); break; case '0': ncursor = 0; break; case '^': ncursor = 0; while (ncursor < es->linelen - 1 && isspace((unsigned char)es->cbuf[ncursor])) ncursor++; break; case '|': ncursor = argcnt; if (ncursor > es->linelen) ncursor = es->linelen; if (ncursor) ncursor--; while (isu8cont(es->cbuf[ncursor])) ncursor--; break; case '$': ncursor = es->linelen; break; case '%': ncursor = es->cursor; while (ncursor < es->linelen && (i = bracktype(es->cbuf[ncursor])) == 0) ncursor++; if (ncursor == es->linelen) return -1; bcount = 1; do { if (i > 0) { if (++ncursor >= es->linelen) return -1; } else { if (--ncursor < 0) return -1; } t = bracktype(es->cbuf[ncursor]); if (t == i) bcount++; else if (t == -i) bcount--; } while (bcount != 0); if (sub && i > 0) ncursor++; break; default: return -1; } return ncursor; } static int redo_insert(int count) { while (count-- > 0) if (putbuf(ibuf, inslen, insert==REPLACE) != 0) return -1; if (es->cursor > 0) while (isu8cont(es->cbuf[--es->cursor])) continue; insert = 0; return 0; } static void yank_range(int a, int b) { yanklen = b - a; if (yanklen != 0) memmove(ybuf, &es->cbuf[a], yanklen); } static int bracktype(int ch) { switch (ch) { case '(': return 1; case '[': return 2; case '{': return 3; case ')': return -1; case ']': return -2; case '}': return -3; default: return 0; } } /* * Non user interface editor routines below here */ static int cur_col; /* current display column */ static int pwidth; /* display columns needed for prompt */ static int prompt_trunc; /* how much of prompt to truncate */ static int prompt_skip; /* how much of prompt to skip */ static int winwidth; /* available column positions */ static char *wbuf[2]; /* current & previous window buffer */ static int wbuf_len; /* length of window buffers (x_cols-3)*/ static int win; /* number of window buffer in use */ static char morec; /* more character at right of window */ static char holdbuf[LINE]; /* place to hold last edit buffer */ static int holdlen; /* length of holdbuf */ static void save_cbuf(void) { memmove(holdbuf, es->cbuf, es->linelen); holdlen = es->linelen; holdbuf[holdlen] = '\0'; } static void restore_cbuf(void) { es->cursor = 0; es->linelen = holdlen; memmove(es->cbuf, holdbuf, holdlen); } /* return a new edstate */ static struct edstate * save_edstate(struct edstate *old) { struct edstate *new; new = alloc(sizeof(struct edstate), APERM); new->cbuf = alloc(old->cbufsize, APERM); memcpy(new->cbuf, old->cbuf, old->linelen); new->cbufsize = old->cbufsize; new->linelen = old->linelen; new->cursor = old->cursor; new->winleft = old->winleft; return new; } static void restore_edstate(struct edstate *new, struct edstate *old) { memcpy(new->cbuf, old->cbuf, old->linelen); new->linelen = old->linelen; new->cursor = old->cursor; new->winleft = old->winleft; free_edstate(old); } static void free_edstate(struct edstate *old) { afree(old->cbuf, APERM); afree(old, APERM); } static void edit_reset(char *buf, size_t len) { const char *p; es = &ebuf; es->cbuf = buf; es->cbufsize = len; undo = &undobuf; undo->cbufsize = len; es->linelen = undo->linelen = 0; es->cursor = undo->cursor = 0; es->winleft = undo->winleft = 0; cur_col = pwidth = promptlen(prompt, &p); prompt_skip = p - prompt; if (pwidth > x_cols - 3 - MIN_EDIT_SPACE) { cur_col = x_cols - 3 - MIN_EDIT_SPACE; prompt_trunc = pwidth - cur_col; pwidth -= prompt_trunc; } else prompt_trunc = 0; if (!wbuf_len || wbuf_len != x_cols - 3) { wbuf_len = x_cols - 3; wbuf[0] = aresize(wbuf[0], wbuf_len, APERM); wbuf[1] = aresize(wbuf[1], wbuf_len, APERM); } (void) memset(wbuf[0], ' ', wbuf_len); (void) memset(wbuf[1], ' ', wbuf_len); winwidth = x_cols - pwidth - 3; win = 0; morec = ' '; holdlen = 0; } /* * this is used for calling x_escape() in complete_word() */ static int x_vi_putbuf(const char *s, size_t len) { return putbuf(s, len, 0); } static int putbuf(const char *buf, int len, int repl) { if (len == 0) return 0; if (repl) { if (es->cursor + len >= es->cbufsize) return -1; if (es->cursor + len > es->linelen) es->linelen = es->cursor + len; } else { if (es->linelen + len >= es->cbufsize) return -1; memmove(&es->cbuf[es->cursor + len], &es->cbuf[es->cursor], es->linelen - es->cursor); es->linelen += len; } memmove(&es->cbuf[es->cursor], buf, len); es->cursor += len; return 0; } static void del_range(int a, int b) { if (es->linelen != b) memmove(&es->cbuf[a], &es->cbuf[b], es->linelen - b); es->linelen -= b - a; } static int findch(int ch, int cnt, int forw, int incl) { int ncursor; if (es->linelen == 0) return -1; ncursor = es->cursor; while (cnt--) { do { if (forw) { if (++ncursor == es->linelen) return -1; } else { if (--ncursor < 0) return -1; } } while (es->cbuf[ncursor] != ch); } if (!incl) { if (forw) ncursor--; else ncursor++; } return ncursor; } /* Move right one character, and then to the beginning of the next word. */ static int forwword(int argcnt) { int ncursor, skip_space, want_letnum; unsigned char uc; ncursor = es->cursor; while (ncursor < es->linelen && argcnt--) { skip_space = 0; want_letnum = -1; ncursor--; while (++ncursor < es->linelen) { uc = es->cbuf[ncursor]; if (isspace(uc)) { skip_space = 1; continue; } else if (skip_space) break; if (uc & 0x80) continue; if (want_letnum == -1) want_letnum = letnum(uc); else if (want_letnum != letnum(uc)) break; } } return ncursor; } /* Move left one character, and then to the beginning of the word. */ static int backword(int argcnt) { int ncursor, skip_space, want_letnum; unsigned char uc; ncursor = es->cursor; while (ncursor > 0 && argcnt--) { skip_space = 1; want_letnum = -1; while (ncursor-- > 0) { uc = es->cbuf[ncursor]; if (isspace(uc)) { if (skip_space) continue; else break; } skip_space = 0; if (uc & 0x80) continue; if (want_letnum == -1) want_letnum = letnum(uc); else if (want_letnum != letnum(uc)) break; } ncursor++; } return ncursor; } /* Move right one character, and then to the byte after the word. */ static int endword(int argcnt) { int ncursor, skip_space, want_letnum; unsigned char uc; ncursor = es->cursor; while (ncursor < es->linelen && argcnt--) { skip_space = 1; want_letnum = -1; while (++ncursor < es->linelen) { uc = es->cbuf[ncursor]; if (isspace(uc)) { if (skip_space) continue; else break; } skip_space = 0; if (uc & 0x80) continue; if (want_letnum == -1) want_letnum = letnum(uc); else if (want_letnum != letnum(uc)) break; } } return ncursor; } /* Move right one character, and then to the beginning of the next big word. */ static int Forwword(int argcnt) { int ncursor; ncursor = es->cursor; while (ncursor < es->linelen && argcnt--) { while (!isspace((unsigned char)es->cbuf[ncursor]) && ncursor < es->linelen) ncursor++; while (isspace((unsigned char)es->cbuf[ncursor]) && ncursor < es->linelen) ncursor++; } return ncursor; } /* Move left one character, and then to the beginning of the big word. */ static int Backword(int argcnt) { int ncursor; ncursor = es->cursor; while (ncursor > 0 && argcnt--) { while (--ncursor >= 0 && isspace((unsigned char)es->cbuf[ncursor])) ; while (ncursor >= 0 && !isspace((unsigned char)es->cbuf[ncursor])) ncursor--; ncursor++; } return ncursor; } /* Move right one character, and then to the byte after the big word. */ static int Endword(int argcnt) { int ncursor; ncursor = es->cursor; while (ncursor < es->linelen && argcnt--) { while (++ncursor < es->linelen && isspace((unsigned char)es->cbuf[ncursor])) ; while (ncursor < es->linelen && !isspace((unsigned char)es->cbuf[ncursor])) ncursor++; } return ncursor; } static int grabhist(int save, int n) { char *hptr; if (n < 0 || n > hlast) return -1; if (n == hlast) { restore_cbuf(); ohnum = n; return 0; } (void) histnum(n); if ((hptr = *histpos()) == NULL) { internal_warningf("%s: bad history array", __func__); return -1; } if (save) save_cbuf(); if ((es->linelen = strlen(hptr)) >= es->cbufsize) es->linelen = es->cbufsize - 1; memmove(es->cbuf, hptr, es->linelen); es->cursor = 0; ohnum = n; return 0; } static int grabsearch(int save, int start, int fwd, char *pat) { char *hptr; int hist; int anchored; if ((start == 0 && fwd == 0) || (start >= hlast-1 && fwd == 1)) return -1; if (fwd) start++; else start--; anchored = *pat == '^' ? (++pat, 1) : 0; if ((hist = findhist(start, fwd, pat, anchored)) < 0) { /* if (start != 0 && fwd && match(holdbuf, pat) >= 0) { */ /* XXX should strcmp be strncmp? */ if (start != 0 && fwd && strcmp(holdbuf, pat) >= 0) { restore_cbuf(); return 0; } else return -1; } if (save) save_cbuf(); histnum(hist); hptr = *histpos(); if ((es->linelen = strlen(hptr)) >= es->cbufsize) es->linelen = es->cbufsize - 1; memmove(es->cbuf, hptr, es->linelen); es->cursor = 0; return hist; } static void redraw_line(int newline) { (void) memset(wbuf[win], ' ', wbuf_len); if (newline) { x_putc('\r'); x_putc('\n'); } vi_pprompt(0); cur_col = pwidth; morec = ' '; } static void refresh(int leftside) { if (outofwin()) rewindow(); display(wbuf[1 - win], wbuf[win], leftside); win = 1 - win; } static int outofwin(void) { int cur, col; if (es->cursor < es->winleft) return 1; col = 0; cur = es->winleft; while (cur < es->cursor) col = newcol((unsigned char) es->cbuf[cur++], col); if (col >= winwidth) return 1; return 0; } static void rewindow(void) { int tcur, tcol; int holdcur1, holdcol1; int holdcur2, holdcol2; holdcur1 = holdcur2 = tcur = 0; holdcol1 = holdcol2 = tcol = 0; while (tcur < es->cursor) { if (tcol - holdcol2 > winwidth / 2) { holdcur1 = holdcur2; holdcol1 = holdcol2; holdcur2 = tcur; holdcol2 = tcol; } tcol = newcol((unsigned char) es->cbuf[tcur++], tcol); } while (tcol - holdcol1 > winwidth / 2) holdcol1 = newcol((unsigned char) es->cbuf[holdcur1++], holdcol1); es->winleft = holdcur1; } /* Printing the byte ch at display column col moves to which column? */ static int newcol(int ch, int col) { if (ch == '\t') return (col | 7) + 1; if (isu8cont(ch)) return col; return col + char_len(ch); } /* Display wb1 assuming that wb2 is currently displayed. */ static void display(char *wb1, char *wb2, int leftside) { char *twb1; /* pointer into the buffer to display */ char *twb2; /* pointer into the previous display buffer */ static int lastb = -1; /* last byte# written from wb1, if UTF-8 */ int cur; /* byte# in the main command line buffer */ int col; /* display column loop variable */ int ncol; /* display column of the cursor */ int cnt; /* remaining display columns to fill */ int moreright; char mc; /* new "more character" at the right of window */ unsigned char ch; /* * Fill the current display buffer with data from cbuf. * In this first loop, col does not include the prompt. */ ncol = col = 0; cur = es->winleft; moreright = 0; twb1 = wb1; while (col < winwidth && cur < es->linelen) { if (cur == es->cursor && leftside) ncol = col + pwidth; if ((ch = es->cbuf[cur]) == '\t') { do { *twb1++ = ' '; } while (++col < winwidth && (col & 7) != 0); } else { if ((ch & 0x80) && Flag(FVISHOW8)) { *twb1++ = 'M'; if (++col < winwidth) { *twb1++ = '-'; col++; } ch &= 0x7f; } if (col < winwidth) { if (ch < ' ' || ch == 0x7f) { *twb1++ = '^'; if (++col < winwidth) { *twb1++ = ch ^ '@'; col++; } } else { *twb1++ = ch; if (!isu8cont(ch)) col++; } } } if (cur == es->cursor && !leftside) ncol = col + pwidth - 1; cur++; } if (cur == es->cursor) ncol = col + pwidth; /* Pad the current display buffer to the right margin. */ if (col < winwidth) { while (col < winwidth) { *twb1++ = ' '; col++; } } else moreright++; *twb1 = ' '; /* * Update the terminal display with data from wb1. * In this final loop, col includes the prompt. */ col = pwidth; cnt = winwidth; for (twb1 = wb1, twb2 = wb2; cnt; twb1++, twb2++) { if (*twb1 != *twb2) { /* * When a byte changes in the middle of a UTF-8 * character, back up to the start byte, unless * the previous byte was the last one written. */ if (col > 0 && isu8cont(*twb1)) { col--; if (lastb >= 0 && twb1 == wb1 + lastb + 1) cur_col = col; else while (twb1 > wb1 && isu8cont(*twb1)) { twb1--; twb2--; } } if (cur_col != col) ed_mov_opt(col, wb1); /* * Always write complete characters, and * advance all pointers accordingly. */ x_putc(*twb1); while (isu8cont(twb1[1])) { x_putc(*++twb1); twb2++; } lastb = *twb1 & 0x80 ? twb1 - wb1 : -1; cur_col++; } else if (isu8cont(*twb1)) continue; /* * For changed continuation bytes, we backed up. * For unchanged ones, we jumped to the next byte. * So, getting here, we had a real column. */ col++; cnt--; } /* Update the "more character". */ if (es->winleft > 0 && moreright) /* POSIX says to use * for this but that is a globbing * character and may confuse people; + is more innocuous */ mc = '+'; else if (es->winleft > 0) mc = '<'; else if (moreright) mc = '>'; else mc = ' '; if (mc != morec) { ed_mov_opt(pwidth + winwidth + 1, wb1); x_putc(mc); cur_col++; morec = mc; lastb = -1; } /* Move the cursor to its new position. */ if (cur_col != ncol) { ed_mov_opt(ncol, wb1); lastb = -1; } } /* Move the display cursor to display column number col. */ static void ed_mov_opt(int col, char *wb) { int ci; /* The cursor is already at the right place. */ if (cur_col == col) return; /* The cursor is too far right. */ if (cur_col > col) { if (cur_col > 2 * col + 1) { /* Much too far right, redraw from scratch. */ x_putc('\r'); vi_pprompt(0); cur_col = pwidth; } else { /* Slightly too far right, back up. */ do { x_putc('\b'); } while (--cur_col > col); return; } } /* Advance the cursor. */ for (ci = pwidth; ci < col || isu8cont(*wb); ci = newcol((unsigned char)*wb++, ci)) if (ci > cur_col || (ci == cur_col && !isu8cont(*wb))) x_putc(*wb); cur_col = ci; } /* replace word with all expansions (ie, expand word*) */ static int expand_word(int command) { static struct edstate *buf; int rval = 0; int nwords; int start, end; char **words; int i; /* Undo previous expansion */ if (command == 0 && expanded == EXPAND && buf) { restore_edstate(es, buf); buf = NULL; expanded = NONE; return 0; } if (buf) { free_edstate(buf); buf = NULL; } nwords = x_cf_glob(XCF_COMMAND_FILE|XCF_FULLPATH, es->cbuf, es->linelen, es->cursor, &start, &end, &words, NULL); if (nwords == 0) { vi_error(); return -1; } buf = save_edstate(es); expanded = EXPAND; del_range(start, end); es->cursor = start; for (i = 0; i < nwords; ) { if (x_escape(words[i], strlen(words[i]), x_vi_putbuf) != 0) { rval = -1; break; } if (++i < nwords && putbuf(" ", 1, 0) != 0) { rval = -1; break; } } i = buf->cursor - end; if (rval == 0 && i > 0) es->cursor += i; modified = 1; hnum = hlast; insert = INSERT; lastac = 0; refresh(0); return rval; } static int complete_word(int command, int count) { static struct edstate *buf; int rval = 0; int nwords; int start, end; char **words; char *match; int match_len; int is_unique; int is_command; /* Undo previous completion */ if (command == 0 && expanded == COMPLETE && buf) { print_expansions(buf); expanded = PRINT; return 0; } if (command == 0 && expanded == PRINT && buf) { restore_edstate(es, buf); buf = NULL; expanded = NONE; return 0; } if (buf) { free_edstate(buf); buf = NULL; } /* XCF_FULLPATH for count 'cause the menu printed by print_expansions() * was done this way. */ nwords = x_cf_glob(XCF_COMMAND_FILE | (count ? XCF_FULLPATH : 0), es->cbuf, es->linelen, es->cursor, &start, &end, &words, &is_command); if (nwords == 0) { vi_error(); return -1; } if (count) { int i; count--; if (count >= nwords) { vi_error(); x_print_expansions(nwords, words, is_command); x_free_words(nwords, words); redraw_line(0); return -1; } /* * Expand the count'th word to its basename */ if (is_command) { match = words[count] + x_basename(words[count], NULL); /* If more than one possible match, use full path */ for (i = 0; i < nwords; i++) if (i != count && strcmp(words[i] + x_basename(words[i], NULL), match) == 0) { match = words[count]; break; } } else match = words[count]; match_len = strlen(match); is_unique = 1; /* expanded = PRINT; next call undo */ } else { match = words[0]; match_len = x_longest_prefix(nwords, words); expanded = COMPLETE; /* next call will list completions */ is_unique = nwords == 1; } buf = save_edstate(es); del_range(start, end); es->cursor = start; /* escape all shell-sensitive characters and put the result into * command buffer */ rval = x_escape(match, match_len, x_vi_putbuf); if (rval == 0 && is_unique) { /* If exact match, don't undo. Allows directory completions * to be used (ie, complete the next portion of the path). */ expanded = NONE; /* If not a directory, add a space to the end... */ if (match_len > 0 && match[match_len - 1] != '/') rval = putbuf(" ", 1, 0); } x_free_words(nwords, words); modified = 1; hnum = hlast; insert = INSERT; lastac = 0; /* prevent this from being redone... */ refresh(0); return rval; } static int print_expansions(struct edstate *e) { int nwords; int start, end; char **words; int is_command; nwords = x_cf_glob(XCF_COMMAND_FILE|XCF_FULLPATH, e->cbuf, e->linelen, e->cursor, &start, &end, &words, &is_command); if (nwords == 0) { vi_error(); return -1; } x_print_expansions(nwords, words, is_command); x_free_words(nwords, words); redraw_line(0); return 0; } /* * The number of bytes needed to encode byte c. * Control bytes get "M-" or "^" prepended. * This function does not handle tabs. */ static int char_len(int c) { int len = 1; if ((c & 0x80) && Flag(FVISHOW8)) { len += 2; c &= 0x7f; } if (c < ' ' || c == 0x7f) len++; return len; } /* Similar to x_zotc(emacs.c), but no tab weirdness */ static void x_vi_zotc(int c) { if (Flag(FVISHOW8) && (c & 0x80)) { x_puts("M-"); c &= 0x7f; } if (c < ' ' || c == 0x7f) { x_putc('^'); c ^= '@'; } x_putc(c); } static void vi_pprompt(int full) { pprompt(prompt + (full ? 0 : prompt_skip), prompt_trunc); } static void vi_error(void) { /* Beem out of any macros as soon as an error occurs */ vi_macro_reset(); x_putc(BEL); x_flush(); } static void vi_macro_reset(void) { if (macro.p) { afree(macro.buf, APERM); memset((char *) ¯o, 0, sizeof(macro)); } } static int isu8cont(unsigned char c) { return !Flag(FVISHOW8) && (c & (0x80 | 0x40)) == 0x80; } #endif /* VI */