2 * Copyright (c) 1993, 1994
3 * The Regents of the University of California. All rights reserved.
4 * Copyright (c) 1992, 1993, 1994, 1995, 1996
5 * Keith Bostic. All rights reserved.
7 * See the LICENSE file for redistribution information.
13 static const char sccsid[] = "$Id: v_txt.c,v 11.5 2013/05/19 20:37:45 bentley Exp $";
16 #include <sys/types.h>
17 #include <sys/queue.h>
20 #include <bitstring.h>
29 #include "../common/common.h"
32 static int txt_abbrev __P((SCR *, TEXT *, CHAR_T *, int, int *, int *));
33 static void txt_ai_resolve __P((SCR *, TEXT *, int *));
34 static TEXT *txt_backup __P((SCR *, TEXTH *, TEXT *, u_int32_t *));
35 static int txt_dent __P((SCR *, TEXT *, int));
36 static int txt_emark __P((SCR *, TEXT *, size_t));
37 static void txt_err __P((SCR *, TEXTH *));
38 static int txt_fc __P((SCR *, TEXT *, int *));
39 static int txt_fc_col __P((SCR *, int, ARGS **));
40 static int txt_hex __P((SCR *, TEXT *));
41 static int txt_insch __P((SCR *, TEXT *, CHAR_T *, u_int));
42 static int txt_isrch __P((SCR *, VICMD *, TEXT *, u_int8_t *));
43 static int txt_map_end __P((SCR *));
44 static int txt_map_init __P((SCR *));
45 static int txt_margin __P((SCR *, TEXT *, TEXT *, int *, u_int32_t));
46 static void txt_nomorech __P((SCR *));
47 static void txt_Rresolve __P((SCR *, TEXTH *, TEXT *, const size_t));
48 static int txt_resolve __P((SCR *, TEXTH *, u_int32_t));
49 static int txt_showmatch __P((SCR *, TEXT *));
50 static void txt_unmap __P((SCR *, TEXT *, u_int32_t *));
52 /* Cursor character (space is hard to track on the screen). */
53 #if defined(DEBUG) && 0
60 * Fill a buffer from the terminal for vi.
62 * PUBLIC: int v_tcmd __P((SCR *, VICMD *, ARG_CHAR_T, u_int));
65 v_tcmd(SCR *sp, VICMD *vp, ARG_CHAR_T prompt, u_int flags)
67 /* Normally, we end up where we started. */
68 vp->m_final.lno = sp->lno;
69 vp->m_final.cno = sp->cno;
71 /* Initialize the map. */
75 /* Move to the last line. */
76 sp->lno = TMAP[0].lno;
79 /* Don't update the modeline for now. */
80 F_SET(sp, SC_TINPUT_INFO);
82 /* Set the input flags. */
83 LF_SET(TXT_APPENDEOL |
84 TXT_CR | TXT_ESCAPE | TXT_INFOLINE | TXT_MAPINPUT);
85 if (O_ISSET(sp, O_ALTWERASE))
86 LF_SET(TXT_ALTWERASE);
87 if (O_ISSET(sp, O_TTYWERASE))
88 LF_SET(TXT_TTYWERASE);
90 /* Do the input thing. */
91 if (v_txt(sp, vp, NULL, NULL, 0, prompt, 0, 1, flags))
94 /* Reenable the modeline updates. */
95 F_CLR(sp, SC_TINPUT_INFO);
97 /* Clean up the map. */
102 F_SET(sp, SC_SCR_REDRAW); /* XXX */
104 /* Set the cursor to the resulting position. */
105 sp->lno = vp->m_final.lno;
106 sp->cno = vp->m_final.cno;
113 * Initialize the screen map for colon command-line input.
116 txt_map_init(SCR *sp)
122 if (!IS_ONELINE(sp)) {
124 * Fake like the user is doing input on the last line of the
125 * screen. This makes all of the scrolling work correctly,
126 * and allows us the use of the vi text editing routines, not
127 * to mention practically infinite length ex commands.
129 * Save the current location.
131 vip->sv_tm_lno = TMAP->lno;
132 vip->sv_tm_soff = TMAP->soff;
133 vip->sv_tm_coff = TMAP->coff;
134 vip->sv_t_maxrows = sp->t_maxrows;
135 vip->sv_t_minrows = sp->t_minrows;
136 vip->sv_t_rows = sp->t_rows;
139 * If it's a small screen, TMAP may be small for the screen.
140 * Fix it, filling in fake lines as we go.
144 HMAP + (sp->t_maxrows - 1); TMAP < esmp; ++TMAP) {
145 TMAP[1].lno = TMAP[0].lno + 1;
146 TMAP[1].coff = HMAP->coff;
150 /* Build the fake entry. */
151 TMAP[1].lno = TMAP[0].lno + 1;
154 SMAP_FLUSH(&TMAP[1]);
157 /* Reset the screen information. */
158 sp->t_rows = sp->t_minrows = ++sp->t_maxrows;
165 * Reset the screen map for colon command-line input.
174 if (!IS_ONELINE(sp)) {
175 /* Restore the screen information. */
176 sp->t_rows = vip->sv_t_rows;
177 sp->t_minrows = vip->sv_t_minrows;
178 sp->t_maxrows = vip->sv_t_maxrows;
181 * If it's a small screen, TMAP may be wrong. Clear any
182 * lines that might have been overwritten.
185 for (cnt = sp->t_rows; cnt <= sp->t_maxrows; ++cnt) {
186 (void)sp->gp->scr_move(sp, cnt, 0);
187 (void)sp->gp->scr_clrtoeol(sp);
189 TMAP = HMAP + (sp->t_rows - 1);
194 * The map may be wrong if the user entered more than one
195 * (logical) line. Fix it. If the user entered a whole
196 * screen, this will be slow, but we probably don't care.
198 if (!O_ISSET(sp, O_LEFTRIGHT))
199 while (vip->sv_tm_lno != TMAP->lno ||
200 vip->sv_tm_soff != TMAP->soff)
206 * Invalidate the cursor and the line size cache, the line never
207 * really existed. This fixes bugs where the user searches for
208 * the last line on the screen + 1 and the refresh routine thinks
209 * that's where we just were.
212 F_SET(vip, VIP_CUR_INVALID);
218 * If doing input mapping on the colon command line, may need to unmap
219 * based on the command.
222 FL_ISSET(ec_flags, EC_MAPINPUT) && LF_ISSET(TXT_INFOLINE)
225 * Internally, we maintain tp->lno and tp->cno, externally, everyone uses
226 * sp->lno and sp->cno. Make them consistent as necessary.
228 #define UPDATE_POSITION(sp, tp) { \
229 (sp)->lno = (tp)->lno; \
230 (sp)->cno = (tp)->cno; \
237 * PUBLIC: int v_txt __P((SCR *, VICMD *, MARK *,
238 * PUBLIC: const CHAR_T *, size_t, ARG_CHAR_T, recno_t, u_long, u_int32_t));
244 MARK *tm, /* To MARK. */
245 const CHAR_T *lp, /* Input line. */
246 size_t len, /* Input line length. */
247 ARG_CHAR_T prompt, /* Prompt to display. */
248 recno_t ai_line, /* Line number to use for autoindent count. */
249 u_long rcount, /* Replay count. */
250 u_int32_t flags) /* TXT_* flags. */
252 EVENT ev, *evp = NULL; /* Current event. */
253 EVENT fc; /* File name completion event. */
255 TEXT *ntp, *tp; /* Input text structures. */
256 TEXT ait; /* Autoindent text structure. */
257 TEXT wmt = {{ 0 }}; /* Wrapmargin text structure. */
260 abb_t abb; /* State of abbreviation checks. */
261 carat_t carat; /* State of the "[^0]^D" sequences. */
262 quote_t quote; /* State of quotation. */
263 size_t owrite, insert; /* Temporary copies of TEXT fields. */
264 size_t margin; /* Wrapmargin value. */
265 size_t rcol; /* 0-N: insert offset in the replay buffer. */
266 size_t tcol; /* Temporary column. */
267 u_int32_t ec_flags; /* Input mapping flags. */
268 #define IS_RESTART 0x01 /* Reset the incremental search. */
269 #define IS_RUNNING 0x02 /* Incremental search turned on. */
271 int abcnt, ab_turnoff; /* Abbreviation character count, switch. */
272 int filec_redraw; /* Redraw after the file completion routine. */
273 int hexcnt; /* Hex character count. */
274 int showmatch; /* Showmatch set on this character. */
275 int wm_set, wm_skip; /* Wrapmargin happened, blank skip flags. */
284 * Set the input flag, so tabs get displayed correctly
285 * and everyone knows that the text buffer is in use.
287 F_SET(sp, SC_TINPUT);
290 * Get one TEXT structure with some initial buffer space, reusing
291 * the last one if it's big enough. (All TEXT bookkeeping fields
292 * default to 0 -- text_init() handles this.) If changing a line,
293 * copy it into the TEXT buffer.
296 if (!TAILQ_EMPTY(tiqh)) {
297 tp = TAILQ_FIRST(tiqh);
298 if (TAILQ_NEXT(tp, q) != NULL || tp->lb_len < len + 32) {
302 tp->ai = tp->insert = tp->offset = tp->owrite = 0;
305 BINC_RETW(sp, tp->lb, tp->lb_len, len);
306 MEMMOVE(tp->lb, lp, len);
310 newtp: if ((tp = text_init(sp, lp, len, len + 32)) == NULL)
312 TAILQ_INSERT_HEAD(tiqh, tp, q);
315 /* Set default termination condition. */
318 /* Set the starting line, column. */
323 * Set the insert and overwrite counts. If overwriting characters,
324 * do insertion afterward. If not overwriting characters, assume
325 * doing insertion. If change is to a mark, emphasize it with an
326 * CH_ENDMARK character.
329 if (LF_ISSET(TXT_OVERWRITE)) {
330 tp->owrite = (tm->cno - tp->cno) + 1;
331 tp->insert = (len - tm->cno) - 1;
333 tp->insert = len - tp->cno;
335 if (LF_ISSET(TXT_EMARK) && txt_emark(sp, tp, tm->cno))
340 * Many of the special cases in text input are to handle autoindent
341 * support. Somebody decided that it would be a good idea if "^^D"
342 * and "0^D" deleted all of the autoindented characters. In an editor
343 * that takes single character input from the user, this beggars the
344 * imagination. Note also, "^^D" resets the next lines' autoindent,
347 * We assume that autoindent only happens on empty lines, so insert
348 * and overwrite will be zero. If doing autoindent, figure out how
349 * much indentation we need and fill it in. Update input column and
350 * screen cursor as necessary.
352 if (LF_ISSET(TXT_AUTOINDENT) && ai_line != OOBLNO) {
353 if (v_txt_auto(sp, ai_line, NULL, 0, tp))
358 * The cc and S commands have a special feature -- leading
359 * <blank> characters are handled as autoindent characters.
362 if (LF_ISSET(TXT_AICHARS)) {
366 tp->offset = tp->cno;
369 /* If getting a command buffer from the user, there may be a prompt. */
370 if (LF_ISSET(TXT_PROMPT)) {
371 tp->lb[tp->cno++] = prompt;
377 * If appending after the end-of-line, add a space into the buffer
378 * and move the cursor right. This space is inserted, i.e. pushed
379 * along, and then deleted when the line is resolved. Assumes that
380 * the cursor is already positioned at the end of the line. This
381 * avoids the nastiness of having the cursor reside on a magical
382 * column, i.e. a column that doesn't really exist. The only down
383 * side is that we may wrap lines or scroll the screen before it's
384 * strictly necessary. Not a big deal.
386 if (LF_ISSET(TXT_APPENDEOL)) {
387 tp->lb[tp->cno] = CH_CURSOR;
390 (void)vs_change(sp, tp->lno, LINE_RESET);
394 * Historic practice is that the wrapmargin value was a distance
395 * from the RIGHT-HAND margin, not the left. It's more useful to
396 * us as a distance from the left-hand margin, i.e. the same as
397 * the wraplen value. The wrapmargin option is historic practice.
398 * Nvi added the wraplen option so that it would be possible to
399 * edit files with consistent margins without knowing the number of
400 * columns in the window.
403 * Setting margin causes a significant performance hit. Normally
404 * we don't update the screen if there are keys waiting, but we
405 * have to if margin is set, otherwise the screen routines don't
406 * know where the cursor is.
409 * Abbreviated keys were affected by the wrapmargin option in the
410 * historic 4BSD vi. Mapped keys were usually, but sometimes not.
411 * See the comment in vi/v_text():set_txt_std for more information.
414 * One more special case. If an inserted <blank> character causes
415 * wrapmargin to split the line, the next user entered character is
416 * discarded if it's a <space> character.
418 wm_set = wm_skip = 0;
419 if (LF_ISSET(TXT_WRAPMARGIN))
420 if ((margin = O_VAL(sp, O_WRAPMARGIN)) != 0)
421 margin = sp->cols - margin;
423 margin = O_VAL(sp, O_WRAPLEN);
427 /* Initialize abbreviation checks. */
428 abcnt = ab_turnoff = 0;
429 abb = F_ISSET(gp, G_ABBREV) &&
430 LF_ISSET(TXT_MAPINPUT) ? AB_INWORD : AB_NOTSET;
433 * Set up the dot command. Dot commands are done by saving the actual
434 * characters and then reevaluating them so that things like wrapmargin
435 * can change between the insert and the replay.
438 * Historically, vi did not remap or reabbreviate replayed input. (It
439 * did beep at you if you changed an abbreviation and then replayed the
440 * input. We're not that compatible.) We don't have to do anything to
441 * avoid remapping, as we're not getting characters from the terminal
442 * routines. Turn the abbreviation check off.
445 * It would be nice if we could swallow backspaces and such, but it's
446 * not all that easy to do. What we can do is turn off the common
447 * error messages during the replay. Otherwise, when the user enters
448 * an illegal command, e.g., "Ia<erase><erase><erase><erase>b<escape>",
449 * and then does a '.', they get a list of error messages after command
453 if (LF_ISSET(TXT_REPLAY)) {
458 /* Other text input mode setup. */
463 LF_ISSET(TXT_SEARCHINCR) ? IS_RESTART | IS_RUNNING : 0);
464 filec_redraw = hexcnt = showmatch = 0;
466 /* Initialize input flags. */
467 ec_flags = LF_ISSET(TXT_MAPINPUT) ? EC_MAPINPUT : 0;
469 /* Refresh the screen. */
470 UPDATE_POSITION(sp, tp);
471 if (vs_refresh(sp, 1))
474 /* If it's dot, just do it now. */
475 if (F_ISSET(vp, VC_ISDOT))
480 next: if (v_event_get(sp, evp, 0, ec_flags))
484 * If file completion overwrote part of the screen and nothing else has
485 * been displayed, clean up. We don't do this as part of the normal
486 * message resolution because we know the user is on the colon command
487 * line and there's no reason to enter explicit characters to continue.
489 if (filec_redraw && !F_ISSET(sp, SC_SCR_EXWROTE)) {
492 fc.e_event = E_REPAINT;
493 fc.e_flno = vip->totalcount >=
494 sp->rows ? 1 : sp->rows - vip->totalcount;
495 fc.e_tlno = sp->rows;
496 vip->linecount = vip->lcontinue = vip->totalcount = 0;
497 (void)vs_repaint(sp, &fc);
498 (void)vs_refresh(sp, 1);
501 /* Deal with all non-character events. */
502 switch (evp->e_event) {
507 F_SET(sp, SC_EXIT_FORCE);
512 * Historically, <interrupt> exited the user from text input
513 * mode or cancelled a colon command, and returned to command
514 * mode. It also beeped the terminal, but that seems a bit
519 if (vs_repaint(sp, &ev))
523 /* <resize> interrupts the input mode. */
524 v_emsg(sp, NULL, VIM_WRESIZE);
527 v_event_err(sp, evp);
533 * If the first character of the input is a nul, replay the previous
534 * input. (Historically, it's okay to replay non-existent input.)
535 * This was not documented as far as I know, and is a great test of vi
538 if (LF_ISSET(TXT_RECORD) && rcol == 0 && evp->e_c == '\0') {
539 if (vip->rep == NULL)
549 * File name completion and colon command-line editing. We don't
550 * have enough meta characters, so we expect people to overload
551 * them. If the two characters are the same, then we do file name
552 * completion if the cursor is past the first column, and do colon
553 * command-line editing if it's not.
555 if (quote == Q_NOTSET) {
556 int L__cedit, L__filec;
558 L__cedit = L__filec = 0;
559 if (LF_ISSET(TXT_CEDIT) && O_STR(sp, O_CEDIT) != NULL &&
560 O_STR(sp, O_CEDIT)[0] == evp->e_c)
562 if (LF_ISSET(TXT_FILEC) && O_STR(sp, O_FILEC) != NULL &&
563 O_STR(sp, O_FILEC)[0] == evp->e_c)
565 if (L__cedit == 1 && (L__filec == 0 || tp->cno == tp->offset)) {
566 tp->term = TERM_CEDIT;
570 if (txt_fc(sp, tp, &filec_redraw))
576 /* Abbreviation overflow check. See comment in txt_abbrev(). */
577 #define MAX_ABBREVIATION_EXPANSION 256
578 if (F_ISSET(&evp->e_ch, CH_ABBREVIATED)) {
579 if (++abcnt > MAX_ABBREVIATION_EXPANSION) {
580 if (v_event_flush(sp, CH_ABBREVIATED))
582 "191|Abbreviation exceeded expansion limit: characters discarded");
584 if (LF_ISSET(TXT_REPLAY))
591 /* Check to see if the character fits into the replay buffers. */
592 if (LF_ISSET(TXT_RECORD)) {
593 BINC_GOTO(sp, EVENT, vip->rep,
594 vip->rep_len, (rcol + 1) * sizeof(EVENT));
595 vip->rep[rcol++] = *evp;
598 replay: if (LF_ISSET(TXT_REPLAY)) {
599 if (rcol == vip->rep_cnt)
601 evp = vip->rep + rcol++;
604 /* Wrapmargin check for leading space. */
611 /* If quoted by someone else, simply insert the character. */
612 if (F_ISSET(&evp->e_ch, CH_QUOTED))
617 * If this character was quoted by a K_VLNEXT or a backslash, replace
618 * the placeholder (a carat or a backslash) with the new character.
619 * If it was quoted by a K_VLNEXT, we've already adjusted the cursor
620 * because it has to appear on top of the placeholder character. If
621 * it was quoted by a backslash, adjust the cursor now, the cursor
622 * doesn't appear on top of it. Historic practice in both cases.
624 * Skip tests for abbreviations; ":ab xa XA" followed by "ixa^V<space>"
625 * doesn't perform an abbreviation. Special case, ^V^J (not ^V^M) is
626 * the same as ^J, historically.
628 if (quote == Q_BTHIS || quote == Q_VTHIS) {
629 FL_CLR(ec_flags, EC_QUOTED);
630 if (LF_ISSET(TXT_MAPINPUT))
631 FL_SET(ec_flags, EC_MAPINPUT);
633 if (quote == Q_BTHIS &&
634 (evp->e_value == K_VERASE || evp->e_value == K_VKILL)) {
640 if (quote == Q_VTHIS && evp->e_value != K_NL) {
649 * Translate "<CH_HEX>[isxdigit()]*" to a character with a hex value:
650 * this test delimits the value by any non-hex character. Offset by
651 * one, we use 0 to mean that we've found <CH_HEX>.
653 if (hexcnt > 1 && !ISXDIGIT(evp->e_c)) {
659 switch (evp->e_value) {
660 case K_CR: /* Carriage return. */
661 case K_NL: /* New line. */
662 /* Return in script windows and the command line. */
663 k_cr: if (LF_ISSET(TXT_CR)) {
665 * If this was a map, we may have not displayed
666 * the line. Display it, just in case.
668 * If a script window and not the colon line,
669 * push a <cr> so it gets executed.
671 if (LF_ISSET(TXT_INFOLINE)) {
672 if (vs_change(sp, tp->lno, LINE_RESET))
674 } else if (F_ISSET(sp, SC_SCRIPT))
675 (void)v_event_push(sp, NULL, L("\r"), 1, CH_NOMAP);
677 /* Set term condition: if empty. */
678 if (tp->cno <= tp->offset)
681 * Set term condition: if searching incrementally and
682 * the user entered a pattern, return a completed
683 * search, regardless if the entire pattern was found.
685 if (FL_ISSET(is_flags, IS_RUNNING) &&
686 tp->cno >= tp->offset + 1)
687 tp->term = TERM_SEARCH;
692 #define LINE_RESOLVE { \
694 * Handle abbreviations. If there was one, discard the \
695 * replay characters. \
697 if (abb == AB_INWORD && \
698 !LF_ISSET(TXT_REPLAY) && F_ISSET(gp, G_ABBREV)) { \
699 if (txt_abbrev(sp, tp, &evp->e_c, \
700 LF_ISSET(TXT_INFOLINE), &tmp, \
704 if (LF_ISSET(TXT_RECORD)) \
709 if (abb != AB_NOTSET) \
712 txt_unmap(sp, tp, &ec_flags); \
714 * Delete any appended cursor. It's possible to get in \
715 * situations where TXT_APPENDEOL is set but tp->insert \
716 * is 0 when using the R command and all the characters \
717 * are tp->owrite characters. \
719 if (LF_ISSET(TXT_APPENDEOL) && tp->insert > 0) { \
727 * Save the current line information for restoration in
728 * txt_backup(), and set the line final length.
730 tp->sv_len = tp->len;
731 tp->sv_cno = tp->cno;
734 /* Update the old line. */
735 if (vs_change(sp, tp->lno, LINE_RESET))
739 * Historic practice, when the autoindent edit option was set,
740 * was to delete <blank> characters following the inserted
741 * newline. This affected the 'R', 'c', and 's' commands; 'c'
742 * and 's' retained the insert characters only, 'R' moved the
743 * overwrite and insert characters into the next TEXT structure.
744 * We keep track of the number of characters erased for the 'R'
745 * command so that the final resolution of the line is correct.
750 if (LF_ISSET(TXT_REPLACE) && owrite != 0) {
751 for (p = tp->lb + tp->cno; owrite > 0 && isblank(*p);
752 ++p, --owrite, ++tp->R_erase);
754 for (; insert > 0 && isblank(*p);
755 ++p, ++tp->R_erase, --insert);
757 p = tp->lb + tp->cno + owrite;
758 if (O_ISSET(sp, O_AUTOINDENT))
760 isblank(*p); ++p, --insert);
766 * Create a new line and insert the new TEXT into the queue.
767 * DON'T insert until the old line has been updated, or the
768 * inserted line count in line.c:db_get() will be wrong.
770 if ((ntp = text_init(sp, p,
771 insert + owrite, insert + owrite + 32)) == NULL)
773 TAILQ_INSERT_TAIL(sp->tiq, ntp, q);
775 /* Set up bookkeeping for the new line. */
776 ntp->insert = insert;
777 ntp->owrite = owrite;
778 ntp->lno = tp->lno + 1;
781 * Reset the autoindent line value. 0^D keeps the autoindent
782 * line from changing, ^D changes the level, even if there were
783 * no characters in the old line. Note, if using the current
784 * tp structure, use the cursor as the length, the autoindent
785 * characters may have been erased.
787 if (LF_ISSET(TXT_AUTOINDENT)) {
790 if (v_txt_auto(sp, OOBLNO, &ait, ait.ai, ntp))
792 FREE_SPACEW(sp, ait.lb, ait.lb_len);
794 if (v_txt_auto(sp, OOBLNO, tp, tp->cno, ntp))
799 /* Reset the cursor. */
803 * If we're here because wrapmargin was set and we've broken a
804 * line, there may be additional information (i.e. the start of
805 * a line) in the wmt structure.
808 if (wmt.offset != 0 ||
809 wmt.owrite != 0 || wmt.insert != 0) {
810 #define WMTSPACE wmt.offset + wmt.owrite + wmt.insert
811 BINC_GOTOW(sp, ntp->lb,
812 ntp->lb_len, ntp->len + WMTSPACE + 32);
813 MEMMOVE(ntp->lb + ntp->cno, wmt.lb, WMTSPACE);
814 ntp->len += WMTSPACE;
815 ntp->cno += wmt.offset;
816 ntp->owrite = wmt.owrite;
817 ntp->insert = wmt.insert;
822 /* New lines are TXT_APPENDEOL. */
823 if (ntp->owrite == 0 && ntp->insert == 0) {
824 BINC_GOTOW(sp, ntp->lb, ntp->lb_len, ntp->len + 1);
825 LF_SET(TXT_APPENDEOL);
826 ntp->lb[ntp->cno] = CH_CURSOR;
831 /* Swap old and new TEXT's, and update the new line. */
833 if (vs_change(sp, tp->lno, LINE_INSERT))
837 case K_ESCAPE: /* Escape. */
838 if (!LF_ISSET(TXT_ESCAPE))
841 /* If we have a count, start replaying the input. */
852 * Some commands (e.g. 'o') need a <newline> for each
855 if (LF_ISSET(TXT_ADDNEWLINE))
859 * The R command turns into the 'a' command after the
862 if (LF_ISSET(TXT_REPLACE)) {
863 tp->insert = tp->owrite;
870 /* Set term condition: if empty. */
871 if (tp->cno <= tp->offset)
874 * Set term condition: if searching incrementally and the user
875 * entered a pattern, return a completed search, regardless if
876 * the entire pattern was found.
878 if (FL_ISSET(is_flags, IS_RUNNING) && tp->cno >= tp->offset + 1)
879 tp->term = TERM_SEARCH;
881 k_escape: LINE_RESOLVE;
884 * Clean up for the 'R' command, restoring overwrite
885 * characters, and making them into insert characters.
887 if (LF_ISSET(TXT_REPLACE))
888 txt_Rresolve(sp, sp->tiq, tp, len);
891 * If there are any overwrite characters, copy down
892 * any insert characters, and decrement the length.
896 MEMMOVE(tp->lb + tp->cno,
897 tp->lb + tp->cno + tp->owrite, tp->insert);
898 tp->len -= tp->owrite;
902 * Optionally resolve the lines into the file. If not
903 * resolving the lines into the file, end the line with
904 * a nul. If the line is empty, then set the length to
905 * 0, the termination condition has already been set.
908 * This is wrong, should pass back a length.
910 if (LF_ISSET(TXT_RESOLVE)) {
911 if (txt_resolve(sp, sp->tiq, flags))
914 BINC_GOTOW(sp, tp->lb, tp->lb_len, tp->len + 1);
915 tp->lb[tp->len] = '\0';
919 * Set the return cursor position to rest on the last
920 * inserted character.
925 /* Update the last line. */
926 if (vs_change(sp, tp->lno, LINE_RESET))
929 case K_CARAT: /* Delete autoindent chars. */
930 if (tp->cno <= tp->ai && LF_ISSET(TXT_AUTOINDENT))
933 case K_ZERO: /* Delete autoindent chars. */
934 if (tp->cno <= tp->ai && LF_ISSET(TXT_AUTOINDENT))
937 case K_CNTRLD: /* Delete autoindent char. */
939 * If in the first column or no characters to erase, ignore
940 * the ^D (this matches historic practice). If not doing
941 * autoindent or already inserted non-ai characters, it's a
942 * literal. The latter test is done in the switch, as the
943 * CARAT forms are N + 1, not N.
945 if (!LF_ISSET(TXT_AUTOINDENT))
951 case C_CARATSET: /* ^^D */
952 if (tp->ai == 0 || tp->cno > tp->ai + tp->offset + 1)
955 /* Save the ai string for later. */
958 BINC_GOTOW(sp, ait.lb, ait.lb_len, tp->ai);
959 MEMMOVE(ait.lb, tp->lb, tp->ai);
960 ait.ai = ait.len = tp->ai;
965 case C_ZEROSET: /* 0^D */
966 if (tp->ai == 0 || tp->cno > tp->ai + tp->offset + 1)
970 leftmargin: tp->lb[tp->cno - 1] = ' ';
971 tp->owrite += tp->cno - tp->offset;
973 tp->cno = tp->offset;
975 case C_NOTSET: /* ^D */
976 if (tp->ai == 0 || tp->cno > tp->ai + tp->offset)
979 (void)txt_dent(sp, tp, 0);
985 case K_VERASE: /* Erase the last character. */
986 /* If can erase over the prompt, return. */
987 if (tp->cno <= tp->offset && LF_ISSET(TXT_BS)) {
993 * If at the beginning of the line, try and drop back to a
994 * previously inserted line.
998 txt_backup(sp, sp->tiq, tp, &flags)) == NULL)
1004 /* If nothing to erase, bell the user. */
1005 if (tp->cno <= tp->offset) {
1006 if (!LF_ISSET(TXT_REPLAY))
1011 /* Drop back one character. */
1015 * Historically, vi didn't replace the erased characters with
1016 * <blank>s, presumably because it's easier to fix a minor
1017 * typing mistake and continue on if the previous letters are
1018 * already there. This is a problem for incremental searching,
1019 * because the user can no longer tell where they are in the
1020 * colon command line because the cursor is at the last search
1021 * point in the screen. So, if incrementally searching, erase
1022 * the erased characters from the screen.
1024 if (FL_ISSET(is_flags, IS_RUNNING))
1025 tp->lb[tp->cno] = ' ';
1028 * Increment overwrite, decrement ai if deleted.
1031 * Historic vi did not permit users to use erase characters
1032 * to delete autoindent characters. We do. Eat hot death,
1036 if (tp->cno < tp->ai)
1039 /* Reset if we deleted an incremental search character. */
1040 if (FL_ISSET(is_flags, IS_RUNNING))
1041 FL_SET(is_flags, IS_RESTART);
1043 case K_VWERASE: /* Skip back one word. */
1045 * If at the beginning of the line, try and drop back to a
1046 * previously inserted line.
1050 txt_backup(sp, sp->tiq, tp, &flags)) == NULL)
1056 * If at offset, nothing to erase so bell the user.
1058 if (tp->cno <= tp->offset) {
1059 if (!LF_ISSET(TXT_REPLAY))
1065 * The first werase goes back to any autoindent column and the
1066 * second werase goes back to the offset.
1069 * Historic vi did not permit users to use erase characters to
1070 * delete autoindent characters.
1072 if (tp->ai && tp->cno > tp->ai)
1079 /* Skip over trailing space characters. */
1080 while (tp->cno > max && ISBLANK(tp->lb[tp->cno - 1])) {
1087 * There are three types of word erase found on UNIX systems.
1088 * They can be identified by how the string /a/b/c is treated
1089 * -- as 1, 3, or 6 words. Historic vi had two classes of
1090 * characters, and strings were delimited by them and
1091 * <blank>'s, so, 6 words. The historic tty interface used
1092 * <blank>'s to delimit strings, so, 1 word. The algorithm
1093 * offered in the 4.4BSD tty interface (as stty altwerase)
1094 * treats it as 3 words -- there are two classes of
1095 * characters, and strings are delimited by them and
1096 * <blank>'s. The difference is that the type of the first
1097 * erased character erased is ignored, which is exactly right
1098 * when erasing pathname components. The edit options
1099 * TXT_ALTWERASE and TXT_TTYWERASE specify the 4.4BSD tty
1100 * interface and the historic tty driver behavior,
1101 * respectively, and the default is the same as the historic
1104 * Overwrite erased characters if doing incremental search;
1105 * see comment above.
1107 if (LF_ISSET(TXT_TTYWERASE))
1108 while (tp->cno > max) {
1109 if (ISBLANK(tp->lb[tp->cno - 1]))
1113 if (FL_ISSET(is_flags, IS_RUNNING))
1114 tp->lb[tp->cno] = ' ';
1117 if (LF_ISSET(TXT_ALTWERASE)) {
1120 if (FL_ISSET(is_flags, IS_RUNNING))
1121 tp->lb[tp->cno] = ' ';
1124 tmp = inword(tp->lb[tp->cno - 1]);
1125 while (tp->cno > max) {
1126 if (tmp != inword(tp->lb[tp->cno - 1])
1127 || ISBLANK(tp->lb[tp->cno - 1]))
1131 if (FL_ISSET(is_flags, IS_RUNNING))
1132 tp->lb[tp->cno] = ' ';
1136 /* Reset if we deleted an incremental search character. */
1137 if (FL_ISSET(is_flags, IS_RUNNING))
1138 FL_SET(is_flags, IS_RESTART);
1140 case K_VKILL: /* Restart this line. */
1143 * If at the beginning of the line, try and drop back to a
1144 * previously inserted line. Historic vi did not permit
1145 * users to go back to previous lines.
1149 txt_backup(sp, sp->tiq, tp, &flags)) == NULL)
1154 /* If at offset, nothing to erase so bell the user. */
1155 if (tp->cno <= tp->offset) {
1156 if (!LF_ISSET(TXT_REPLAY))
1162 * First kill goes back to any autoindent and second kill goes
1163 * back to the offset.
1166 * Historic vi did not permit users to use erase characters to
1167 * delete autoindent characters.
1169 if (tp->ai && tp->cno > tp->ai)
1175 tp->owrite += tp->cno - max;
1178 * Overwrite erased characters if doing incremental search;
1179 * see comment above.
1181 if (FL_ISSET(is_flags, IS_RUNNING))
1183 tp->lb[--tp->cno] = ' ';
1184 } while (tp->cno > max);
1188 /* Reset if we deleted an incremental search character. */
1189 if (FL_ISSET(is_flags, IS_RUNNING))
1190 FL_SET(is_flags, IS_RESTART);
1192 case K_CNTRLT: /* Add autoindent characters. */
1193 if (!LF_ISSET(TXT_CNTRLT))
1195 if (txt_dent(sp, tp, 1))
1198 case K_BACKSLASH: /* Quote next erase/kill. */
1201 * Historic vi tried to make abbreviations after a backslash
1202 * escape work. If you did ":ab x y", and inserted "x\^H",
1203 * (assuming the erase character was ^H) you got "x^H", and
1204 * no abbreviation was done. If you inserted "x\z", however,
1205 * it tried to back up and do the abbreviation, i.e. replace
1206 * 'x' with 'y'. The problem was it got it wrong, and you
1207 * ended up with "zy\".
1209 * This is really hard to do (you have to remember the
1210 * word/non-word state, for example), and doesn't make any
1211 * sense to me. Both backslash and the characters it
1212 * (usually) escapes will individually trigger the
1213 * abbreviation, so I don't see why the combination of them
1214 * wouldn't. I don't expect to get caught on this one,
1215 * particularly since it never worked right, but I've been
1218 * Do the tests for abbreviations, so ":ab xa XA",
1219 * "ixa\<K_VERASE>" performs the abbreviation.
1223 case K_VLNEXT: /* Quote next character. */
1227 * Turn on the quote flag so that the underlying routines
1228 * quote the next character where it's possible. Turn off
1229 * the input mapbiting flag so that we don't remap the next
1232 FL_SET(ec_flags, EC_QUOTED);
1233 FL_CLR(ec_flags, EC_MAPINPUT);
1237 * Skip the tests for abbreviations, so ":ab xa XA",
1238 * "ixa^V<space>" doesn't perform the abbreviation.
1244 default: /* Insert the character. */
1245 if (LF_ISSET(TXT_SHOWMATCH)) {
1246 CHAR_T *match_chars, *cp;
1248 match_chars = VIP(sp)->mcs;
1249 cp = STRCHR(match_chars, evp->e_c);
1250 if (cp != NULL && (cp - match_chars) & 1)
1254 * Historically, vi eliminated nul's out of hand. If the
1255 * beautify option was set, it also deleted any unknown
1256 * ASCII value less than space (040) and the del character
1257 * (0177), except for tabs. Unknown is a key word here.
1258 * Most vi documentation claims that it deleted everything
1259 * but <tab>, <nl> and <ff>, as that's what the original
1260 * 4BSD documentation said. This is obviously wrong,
1261 * however, as <esc> would be included in that list. What
1262 * we do is eliminate any unquoted, iscntrl() character that
1263 * wasn't a replay and wasn't handled specially, except
1266 if (LF_ISSET(TXT_BEAUTIFY) && ISCNTRL(evp->e_c) &&
1267 evp->e_value != K_FORMFEED && evp->e_value != K_TAB) {
1269 "192|Illegal character; quote to enter");
1270 if (LF_ISSET(TXT_REPLAY))
1276 * If entering a non-word character after a word, check for
1277 * abbreviations. If there was one, discard replay characters.
1278 * If entering a blank character, check for unmap commands,
1281 if (!inword(evp->e_c)) {
1282 if (abb == AB_INWORD &&
1283 !LF_ISSET(TXT_REPLAY) && F_ISSET(gp, G_ABBREV)) {
1284 if (txt_abbrev(sp, tp, &evp->e_c,
1285 LF_ISSET(TXT_INFOLINE), &tmp, &ab_turnoff))
1288 if (LF_ISSET(TXT_RECORD))
1293 if (isblank(evp->e_c) && UNMAP_TST)
1294 txt_unmap(sp, tp, &ec_flags);
1296 if (abb != AB_NOTSET)
1297 abb = inword(evp->e_c) ? AB_INWORD : AB_NOTWORD;
1299 insl_ch: if (txt_insch(sp, tp, &evp->e_c, flags))
1303 * If we're using K_VLNEXT to quote the next character, then
1304 * we want the cursor to position itself on the ^ placeholder
1305 * we're displaying, to match historic practice.
1307 if (quote == Q_VNEXT) {
1314 * Translate "<CH_HEX>[isxdigit()]*" to a character with
1315 * a hex value: this test delimits the value by the max
1316 * number of hex bytes. Offset by one, we use 0 to mean
1317 * that we've found <CH_HEX>.
1319 if (hexcnt != 0 && hexcnt++ == 3) {
1321 if (txt_hex(sp, tp))
1326 * Check to see if we've crossed the margin.
1329 * In the historic vi, the wrapmargin value was figured out
1330 * using the display widths of the characters, i.e. <tab>
1331 * characters were counted as two characters if the list edit
1332 * option is set, but as the tabstop edit option number of
1333 * characters otherwise. That's what the vs_column() function
1334 * gives us, so we use it.
1337 if (vs_column(sp, &tcol))
1339 if (tcol >= margin) {
1340 if (txt_margin(sp, tp, &wmt, &tmp, flags))
1343 if (isblank(evp->e_c))
1352 * If we've reached the end of the buffer, then we need to
1353 * switch into insert mode. This happens when there's a
1354 * change to a mark and the user puts in more characters than
1355 * the length of the motion.
1357 ebuf_chk: if (tp->cno >= tp->len) {
1358 BINC_GOTOW(sp, tp->lb, tp->lb_len, tp->len + 1);
1359 LF_SET(TXT_APPENDEOL);
1361 tp->lb[tp->cno] = CH_CURSOR;
1366 /* Step the quote state forward. */
1367 if (quote != Q_NOTSET) {
1368 if (quote == Q_BNEXT)
1370 if (quote == Q_VNEXT)
1377 if (tp->cno + tp->insert + tp->owrite != tp->len) {
1379 "len %zu != cno: %zu ai: %zu insert %zu overwrite %zu",
1380 tp->len, tp->cno, tp->ai, tp->insert, tp->owrite);
1381 if (LF_ISSET(TXT_REPLAY))
1383 tp->len = tp->cno + tp->insert + tp->owrite;
1388 * 1: If we don't need to know where the cursor really is and we're
1389 * replaying text, keep going.
1391 if (margin == 0 && LF_ISSET(TXT_REPLAY))
1395 * 2: Reset the line. Don't bother unless we're about to wait on
1396 * a character or we need to know where the cursor really is.
1397 * We have to do this before showing matching characters so the
1398 * user can see what they're matching.
1400 if ((margin != 0 || !KEYS_WAITING(sp)) &&
1401 vs_change(sp, tp->lno, LINE_RESET))
1405 * 3: If there aren't keys waiting, display the matching character.
1406 * We have to do this before resolving any messages, otherwise
1407 * the error message from a missing match won't appear correctly.
1410 if (!KEYS_WAITING(sp) && txt_showmatch(sp, tp))
1416 * 4: If there have been messages and we're not editing on the colon
1417 * command line or doing file name completion, resolve them.
1419 if ((vip->totalcount != 0 || F_ISSET(gp, G_BELLSCHED)) &&
1420 !F_ISSET(sp, SC_TINPUT_INFO) && !filec_redraw &&
1421 vs_resolve(sp, NULL, 0))
1425 * 5: Refresh the screen if we're about to wait on a character or we
1426 * need to know where the cursor really is.
1428 if (margin != 0 || !KEYS_WAITING(sp)) {
1429 UPDATE_POSITION(sp, tp);
1430 if (vs_refresh(sp, margin != 0))
1434 /* 6: Proceed with the incremental search. */
1435 if (FL_ISSET(is_flags, IS_RUNNING) && txt_isrch(sp, vp, tp, &is_flags))
1438 /* 7: Next character... */
1439 if (LF_ISSET(TXT_REPLAY))
1443 done: /* Leave input mode. */
1444 F_CLR(sp, SC_TINPUT);
1446 /* If recording for playback, save it. */
1447 if (LF_ISSET(TXT_RECORD))
1448 vip->rep_cnt = rcol;
1451 * If not working on the colon command line, set the final cursor
1454 if (!F_ISSET(sp, SC_TINPUT_INFO)) {
1455 vp->m_final.lno = tp->lno;
1456 vp->m_final.cno = tp->cno;
1462 F_CLR(sp, SC_TINPUT);
1463 txt_err(sp, sp->tiq);
1469 * Handle abbreviations.
1472 txt_abbrev(SCR *sp, TEXT *tp, CHAR_T *pushcp, int isinfoline, int *didsubp, int *turnoffp)
1479 /* Check to make sure we're not at the start of an append. */
1481 if (tp->cno == tp->offset)
1487 * Find the start of the "word".
1490 * We match historic practice, which, as far as I can tell, had an
1491 * off-by-one error. The way this worked was that when the inserted
1492 * text switched from a "word" character to a non-word character,
1493 * vi would check for possible abbreviations. It would then take the
1494 * type (i.e. word/non-word) of the character entered TWO characters
1495 * ago, and move backward in the text until reaching a character that
1496 * was not that type, or the beginning of the insert, the line, or
1497 * the file. For example, in the string "abc<space>", when the <space>
1498 * character triggered the abbreviation check, the type of the 'b'
1499 * character was used for moving through the string. Maybe there's a
1500 * reason for not using the first (i.e. 'c') character, but I can't
1503 * Terminate at the beginning of the insert or the character after the
1504 * offset character -- both can be tested for using tp->offset.
1506 off = tp->cno - 1; /* Previous character. */
1508 len = 1; /* One character test. */
1509 if (off == tp->offset || isblank(p[-1]))
1511 if (inword(p[-1])) /* Move backward to change. */
1514 if (off == tp->offset || !inword(p[-1]))
1520 if (off == tp->offset ||
1521 inword(p[-1]) || isblank(p[-1]))
1527 * Historic vi exploded abbreviations on the command line. This has
1528 * obvious problems in that unabbreviating the string can be extremely
1529 * tricky, particularly if the string has, say, an embedded escape
1530 * character. Personally, I think it's a stunningly bad idea. Other
1531 * examples of problems this caused in historic vi are:
1534 * results in "bar" being abbreviated to "baz", which wasn't what the
1535 * user had in mind at all. Also, the commands:
1538 * resulted in an error message that "bar" wasn't mapped. Finally,
1539 * since the string was already exploded by the time the unabbreviate
1540 * command got it, all it knew was that an abbreviation had occurred.
1541 * Cleverly, it checked the replacement string for its unabbreviation
1542 * match, which meant that the commands:
1546 * unabbreviate "foo1", and the commands:
1549 * unabbreviate "foo"!
1551 * Anyway, people neglected to first ask my opinion before they wrote
1552 * macros that depend on this stuff, so, we make this work as follows.
1553 * When checking for an abbreviation on the command line, if we get a
1554 * string which is <blank> terminated and which starts at the beginning
1555 * of the line, we check to see it is the abbreviate or unabbreviate
1556 * commands. If it is, turn abbreviations off and return as if no
1557 * abbreviation was found. Note also, minor trickiness, so that if
1558 * the user erases the line and starts another command, we turn the
1559 * abbreviations back on.
1561 * This makes the layering look like a Nachos Supreme.
1563 search: if (isinfoline)
1564 if (off == tp->ai || off == tp->offset)
1565 if (ex_is_abbrev(p, len)) {
1574 /* Check for any abbreviations. */
1575 if ((qp = seq_find(sp, NULL, NULL, p, len, SEQ_ABBREV, NULL)) == NULL)
1579 * Push the abbreviation onto the tty stack. Historically, characters
1580 * resulting from an abbreviation expansion were themselves subject to
1581 * map expansions, O_SHOWMATCH matching etc. This means the expanded
1582 * characters will be re-tested for abbreviations. It's difficult to
1583 * know what historic practice in this case was, since abbreviations
1584 * were applied to :colon command lines, so entering abbreviations that
1585 * looped was tricky, although possible. In addition, obvious loops
1586 * didn't work as expected. (The command ':ab a b|ab b c|ab c a' will
1587 * silently only implement and/or display the last abbreviation.)
1589 * This implementation doesn't recover well from such abbreviations.
1590 * The main input loop counts abbreviated characters, and, when it
1591 * reaches a limit, discards any abbreviated characters on the queue.
1592 * It's difficult to back up to the original position, as the replay
1593 * queue would have to be adjusted, and the line state when an initial
1594 * abbreviated character was received would have to be saved.
1597 if (v_event_push(sp, NULL, &ch, 1, CH_ABBREVIATED))
1599 if (v_event_push(sp, NULL, qp->output, qp->olen, CH_ABBREVIATED))
1603 * If the size of the abbreviation is larger than or equal to the size
1604 * of the original text, move to the start of the replaced characters,
1605 * and add their length to the overwrite count.
1607 * If the abbreviation is smaller than the original text, we have to
1608 * delete the additional overwrite characters and copy down any insert
1612 if (qp->olen >= len)
1616 MEMMOVE(tp->lb + tp->cno + qp->olen,
1617 tp->lb + tp->cno + tp->owrite + len, tp->insert);
1618 tp->owrite += qp->olen;
1619 tp->len -= len - qp->olen;
1623 * We return the length of the abbreviated characters. This is so
1624 * the calling routine can replace the replay characters with the
1625 * abbreviation. This means that subsequent '.' commands will produce
1626 * the same text, regardless of intervening :[un]abbreviate commands.
1627 * This is historic practice.
1635 * Handle the unmap command.
1638 txt_unmap(SCR *sp, TEXT *tp, u_int32_t *ec_flagsp)
1643 /* Find the beginning of this "word". */
1644 for (off = tp->cno - 1, p = tp->lb + off, len = 0;; --p, --off) {
1650 if (off == tp->ai || off == tp->offset)
1656 * Historic vi exploded input mappings on the command line. See the
1657 * txt_abbrev() routine for an explanation of the problems inherent
1660 * We make this work as follows. If we get a string which is <blank>
1661 * terminated and which starts at the beginning of the line, we check
1662 * to see it is the unmap command. If it is, we return that the input
1663 * mapping should be turned off. Note also, minor trickiness, so that
1664 * if the user erases the line and starts another command, we go ahead
1665 * an turn mapping back on.
1667 if ((off == tp->ai || off == tp->offset) && ex_is_unmap(p, len))
1668 FL_CLR(*ec_flagsp, EC_MAPINPUT);
1670 FL_SET(*ec_flagsp, EC_MAPINPUT);
1675 * When a line is resolved by <esc>, review autoindent characters.
1678 txt_ai_resolve(SCR *sp, TEXT *tp, int *changedp)
1682 size_t cno, len, new, old, scno, spaces, tab_after_sp, tabs;
1688 * If the line is empty, has an offset, or no autoindent
1689 * characters, we're done.
1691 if (!tp->len || tp->offset || !tp->ai)
1695 * If the length is less than or equal to the autoindent
1696 * characters, delete them.
1698 if (tp->len <= tp->ai) {
1699 tp->ai = tp->cno = tp->len = 0;
1704 * The autoindent characters plus any leading <blank> characters
1705 * in the line are resolved into the minimum number of characters.
1706 * Historic practice.
1708 ts = O_VAL(sp, O_TABSTOP);
1710 /* Figure out the last <blank> screen column. */
1711 for (p = tp->lb, scno = 0, len = tp->len,
1712 spaces = tab_after_sp = 0; len-- && isblank(*p); ++p)
1716 scno += COL_OFF(scno, ts);
1723 * If there are no spaces, or no tabs after spaces and less than
1724 * ts spaces, it's already minimal.
1726 if (!spaces || (!tab_after_sp && spaces < ts))
1729 /* Count up spaces/tabs needed to get to the target. */
1730 for (cno = 0, tabs = 0; cno + COL_OFF(cno, ts) <= scno; ++tabs)
1731 cno += COL_OFF(cno, ts);
1732 spaces = scno - cno;
1735 * Figure out how many characters we're dropping -- if we're not
1736 * dropping any, it's already minimal, we're done.
1739 new = spaces + tabs;
1743 /* Shift the rest of the characters down, adjust the counts. */
1745 MEMMOVE(p - del, p, tp->len - old);
1749 /* Fill in space/tab characters. */
1750 for (p = tp->lb; tabs--;)
1759 * Handle autoindent. If aitp isn't NULL, use it, otherwise,
1760 * retrieve the line.
1762 * PUBLIC: int v_txt_auto __P((SCR *, recno_t, TEXT *, size_t, TEXT *));
1765 v_txt_auto(SCR *sp, recno_t lno, TEXT *aitp, size_t len, TEXT *tp)
1772 * If the ex append command is executed with an address of 0,
1773 * it's possible to get here with a line number of 0. Return
1780 if (db_get(sp, lno, DBG_FATAL, &t, &len))
1785 /* Count whitespace characters. */
1786 for (p = t; len > 0; ++p, --len)
1790 /* Set count, check for no indentation. */
1791 if ((nlen = (p - t)) == 0)
1794 /* Make sure the buffer's big enough. */
1795 BINC_RETW(sp, tp->lb, tp->lb_len, tp->len + nlen);
1797 /* Copy the buffer's current contents up. */
1799 MEMMOVE(tp->lb + nlen, tp->lb, tp->len);
1802 /* Copy the indentation into the new buffer. */
1803 MEMMOVE(tp->lb, t, nlen);
1805 /* Set the autoindent count. */
1812 * Back up to the previously edited line.
1815 txt_backup(SCR *sp, TEXTH *tiqh, TEXT *tp, u_int32_t *flagsp)
1820 /* Get a handle on the previous TEXT structure. */
1821 if ((ntp = TAILQ_PREV(tp, _texth, q)) == NULL) {
1822 if (!FL_ISSET(*flagsp, TXT_REPLAY))
1824 "193|Already at the beginning of the insert");
1829 ntp->len = ntp->sv_len;
1831 /* Handle appending to the line. */
1833 if (ntp->owrite == 0 && ntp->insert == 0) {
1834 ntp->lb[ntp->len] = CH_CURSOR;
1837 FL_SET(*flagsp, TXT_APPENDEOL);
1839 FL_CLR(*flagsp, TXT_APPENDEOL);
1841 /* Release the current TEXT. */
1842 TAILQ_REMOVE(tiqh, tp, q);
1845 /* Update the old line on the screen. */
1846 if (vs_change(sp, ntp->lno + 1, LINE_DELETE))
1849 /* Return the new/current TEXT. */
1854 * Text indentation is truly strange. ^T and ^D do movements to the next or
1855 * previous shiftwidth value, i.e. for a 1-based numbering, with shiftwidth=3,
1856 * ^T moves a cursor on the 7th, 8th or 9th column to the 10th column, and ^D
1860 * The ^T and ^D characters in historical vi had special meaning only when they
1861 * were the first characters entered after entering text input mode. As normal
1862 * erase characters couldn't erase autoindent characters (^T in this case), it
1863 * meant that inserting text into previously existing text was strange -- ^T
1864 * only worked if it was the first keystroke(s), and then could only be erased
1865 * using ^D. This implementation treats ^T specially anywhere it occurs in the
1866 * input, and permits the standard erase characters to erase the characters it
1870 * A fun test is to try:
1872 * i<CR>^Tx<CR>^Tx<CR>^Tx<CR>^Dx<CR>^Dx<CR>^Dx<esc>
1873 * Historic vi loses some of the '$' marks on the line ends, but otherwise gets
1877 * Technically, txt_dent should be part of the screen interface, as it requires
1878 * knowledge of character sizes, including <space>s, on the screen. It's here
1879 * because it's a complicated little beast, and I didn't want to shove it down
1880 * into the screen. It's probable that KEY_COL will call into the screen once
1881 * there are screens with different character representations.
1884 * Handle ^T indents, ^D outdents.
1886 * If anything changes here, check the ex version to see if it needs similar
1890 txt_dent(SCR *sp, TEXT *tp, int isindent)
1894 size_t cno, current, spaces, target, tabs;
1897 ts = O_VAL(sp, O_TABSTOP);
1898 sw = O_VAL(sp, O_SHIFTWIDTH);
1901 * Since we don't know what precedes the character(s) being inserted
1902 * (or deleted), the preceding whitespace characters must be resolved.
1903 * An example is a <tab>, which doesn't need a full shiftwidth number
1904 * of columns because it's preceded by <space>s. This is easy to get
1905 * if the user sets shiftwidth to a value less than tabstop (or worse,
1906 * something for which tabstop isn't a multiple) and then uses ^T to
1907 * indent, and ^D to outdent.
1909 * Figure out the current and target screen columns. In the historic
1910 * vi, the autoindent column was NOT determined using display widths
1911 * of characters as was the wrapmargin column. For that reason, we
1912 * can't use the vs_column() function, but have to calculate it here.
1913 * This is slow, but it's normally only on the first few characters of
1916 for (current = cno = 0; cno < tp->cno; ++cno)
1917 current += tp->lb[cno] == '\t' ?
1918 COL_OFF(current, ts) : KEY_COL(sp, tp->lb[cno]);
1922 target += COL_OFF(target, sw);
1925 target -= target % sw;
1929 * The AI characters will be turned into overwrite characters if the
1930 * cursor immediately follows them. We test both the cursor position
1931 * and the indent flag because there's no single test. (^T can only
1932 * be detected by the cursor position, and while we know that the test
1933 * is always true for ^D, the cursor can be in more than one place, as
1934 * "0^D" and "^D" are different.)
1936 ai_reset = !isindent || tp->cno == tp->ai + tp->offset;
1939 * Back up over any previous <blank> characters, changing them into
1940 * overwrite characters (including any ai characters). Then figure
1941 * out the current screen column.
1943 for (; tp->cno > tp->offset &&
1944 (tp->lb[tp->cno - 1] == ' ' || tp->lb[tp->cno - 1] == '\t');
1945 --tp->cno, ++tp->owrite);
1946 for (current = cno = 0; cno < tp->cno; ++cno)
1947 current += tp->lb[cno] == '\t' ?
1948 COL_OFF(current, ts) : KEY_COL(sp, tp->lb[cno]);
1951 * If we didn't move up to or past the target, it's because there
1952 * weren't enough characters to delete, e.g. the first character
1953 * of the line was a tp->offset character, and the user entered
1954 * ^D to move to the beginning of a line. An example of this is:
1956 * :set ai sw=4<cr>i<space>a<esc>i^T^D
1958 * Otherwise, count up the total spaces/tabs needed to get from the
1959 * beginning of the line (or the last non-<blank> character) to the
1962 if (current >= target)
1966 tabs = 0; cno + COL_OFF(cno, ts) <= target; ++tabs)
1967 cno += COL_OFF(cno, ts);
1968 spaces = target - cno;
1971 /* If we overwrote ai characters, reset the ai count. */
1973 tp->ai = tabs + spaces;
1976 * Call txt_insch() to insert each character, so that we get the
1977 * correct effect when we add a <tab> to replace N <spaces>.
1979 for (ch = '\t'; tabs > 0; --tabs)
1980 (void)txt_insch(sp, tp, &ch, 0);
1981 for (ch = ' '; spaces > 0; --spaces)
1982 (void)txt_insch(sp, tp, &ch, 0);
1988 * File name and ex command completion.
1991 txt_fc(SCR *sp, TEXT *tp, int *redrawp)
1996 size_t indx, len, nlen, off;
1999 char *np, *epd = NULL;
2004 ex_cinit(sp, &cmd, 0, 0, OOBLNO, OOBLNO, 0);
2007 * Find the beginning of this "word" -- if we're at the beginning
2008 * of the line, it's a special case.
2017 off = MAX(tp->ai, tp->offset), ap = tp->lb + off, p = ap;
2018 off < tp->cno; ++off, ++ap) {
2019 if (IS_ESCAPE(sp, &cmd, *ap)) {
2020 if (++off == tp->cno)
2024 } else if (cmdskip(*ap)) {
2035 * If we are at the first word, do ex command completion instead of
2036 * file name completion.
2039 (void)argv_flt_ex(sp, &cmd, p, len);
2041 if ((bp = argv_uesc(sp, &cmd, p, len)) == NULL)
2043 if (argv_flt_path(sp, &cmd, bp, STRLEN(bp))) {
2044 FREE_SPACEW(sp, bp, 0);
2047 FREE_SPACEW(sp, bp, 0);
2053 case 0: /* No matches. */
2054 (void)sp->gp->scr_bell(sp);
2056 case 1: /* One match. */
2057 /* Always overwrite the old text. */
2058 nlen = STRLEN(cmd.argv[0]->bp);
2060 default: /* Multiple matches. */
2062 if (txt_fc_col(sp, argc, argv))
2065 /* Find the length of the shortest match. */
2066 for (nlen = cmd.argv[0]->len; --argc > 0;) {
2067 if (cmd.argv[argc]->len < nlen)
2068 nlen = cmd.argv[argc]->len;
2069 for (indx = 0; indx < nlen &&
2070 cmd.argv[argc]->bp[indx] == cmd.argv[0]->bp[indx];
2077 /* Escape the matched part of the path. */
2079 bp = cmd.argv[0]->bp;
2081 if ((bp = argv_esc(sp, &cmd, cmd.argv[0]->bp, nlen)) == NULL)
2086 /* Overwrite the expanded text first. */
2087 for (t = bp; len > 0 && nlen > 0; --len, --nlen)
2090 /* If lost text, make the remaining old text overwrite characters. */
2096 /* Overwrite any overwrite characters next. */
2097 for (; nlen > 0 && tp->owrite > 0; --nlen, --tp->owrite, ++tp->cno)
2100 /* Shift remaining text up, and move the cursor to the end. */
2103 BINC_RETW(sp, tp->lb, tp->lb_len, tp->len + nlen);
2109 if (tp->insert != 0)
2110 (void)MEMMOVE(p + nlen, p, tp->insert);
2116 FREE_SPACEW(sp, bp, 0);
2118 /* If not a single match of path, we've done. */
2119 if (argc != 1 || fstwd)
2122 /* If a single match and it's a directory, append a '/'. */
2123 INT2CHAR(sp, cmd.argv[0]->bp, cmd.argv[0]->len + 1, np, nplen);
2124 if ((epd = expanduser(np)) != NULL)
2126 if (!stat(np, &sb) && S_ISDIR(sb.st_mode)) {
2127 if (tp->owrite == 0) {
2129 BINC_RETW(sp, tp->lb, tp->lb_len, tp->len + 1);
2131 if (tp->insert != 0)
2132 (void)MEMMOVE(p + 1, p, tp->insert);
2146 * Display file names for file name completion.
2149 txt_fc_col(SCR *sp, int argc, ARGS **argv)
2154 size_t base, cnt, col, colwidth, numrows, numcols, prefix, row;
2161 /* Trim any directory prefix common to all of the files. */
2162 INT2CHAR(sp, argv[0]->bp, argv[0]->len + 1, np, nlen);
2163 if ((pp = strrchr(np, '/')) == NULL)
2166 prefix = (pp - np) + 1;
2167 for (ac = argc - 1, av = argv + 1; ac > 0; --ac, ++av)
2168 if (av[0]->len < prefix ||
2169 MEMCMP(av[0]->bp, argv[0]->bp,
2177 * Figure out the column width for the longest name. Output is done on
2178 * 6 character "tab" boundaries for no particular reason. (Since we
2179 * don't output tab characters, we ignore the terminal's tab settings.)
2180 * Ignore the user's tab setting because we have no idea how reasonable
2183 for (ac = argc, av = argv, colwidth = 0; ac > 0; --ac, ++av) {
2184 for (col = 0, p = av[0]->bp + prefix; *p != '\0'; ++p)
2185 col += KEY_COL(sp, *p);
2189 colwidth += COL_OFF(colwidth, 6);
2192 * Writing to the bottom line of the screen is always turned off when
2193 * SC_TINPUT_INFO is set. Turn it back on, we know what we're doing.
2195 if (F_ISSET(sp, SC_TINPUT_INFO)) {
2197 F_CLR(sp, SC_TINPUT_INFO);
2202 if (F_ISSET(gp, G_INTERRUPTED)) \
2205 /* If the largest file name is too large, just print them. */
2206 if (colwidth >= sp->cols) {
2207 for (ac = argc, av = argv; ac > 0; --ac, ++av) {
2208 INT2CHAR(sp, av[0]->bp+prefix, av[0]->len+1-prefix,
2210 pp = msg_print(sp, np, &nf);
2211 (void)ex_printf(sp, "%s\n", pp);
2213 FREE_SPACE(sp, pp, 0);
2214 if (F_ISSET(gp, G_INTERRUPTED))
2219 /* Figure out the number of columns. */
2220 numcols = (sp->cols - 1) / colwidth;
2221 if (argc > numcols) {
2222 numrows = argc / numcols;
2228 /* Display the files in sorted order. */
2229 for (row = 0; row < numrows; ++row) {
2230 for (base = row, col = 0; col < numcols; ++col) {
2231 INT2CHAR(sp, argv[base]->bp+prefix,
2232 argv[base]->len+1-prefix, np, nlen);
2233 pp = msg_print(sp, np, &nf);
2234 cnt = ex_printf(sp, "%s", pp);
2236 FREE_SPACE(sp, pp, 0);
2238 if ((base += numrows) >= argc)
2241 "%*s", (int)(colwidth - cnt), "");
2244 (void)ex_puts(sp, "\n");
2247 (void)ex_puts(sp, "\n");
2250 (void)ex_fflush(sp);
2253 intr: F_CLR(gp, G_INTERRUPTED);
2256 F_SET(sp, SC_TINPUT_INFO);
2263 * Set the end mark on the line.
2266 txt_emark(SCR *sp, TEXT *tp, size_t cno)
2270 size_t chlen, nlen, olen;
2276 * The end mark may not be the same size as the current character.
2277 * Don't let the line shift.
2279 nlen = KEY_COL(sp, ch);
2280 if (tp->lb[cno] == '\t')
2281 (void)vs_columns(sp, tp->lb, tp->lno, &cno, &olen);
2283 olen = KEY_COL(sp, tp->lb[cno]);
2286 * If the line got longer, well, it's weird, but it's easy. If
2287 * it's the same length, it's easy. If it got shorter, we have
2291 BINC_RETW(sp, tp->lb, tp->lb_len, tp->len + olen);
2292 chlen = olen - nlen;
2293 if (tp->insert != 0)
2294 MEMMOVE(tp->lb + cno + 1 + chlen,
2295 tp->lb + cno + 1, tp->insert);
2298 tp->owrite += chlen;
2300 if (tp->lb[cno] == '\t' ||
2301 KEY_NEEDSWIDE(sp, tp->lb[cno]))
2302 for (cno += chlen; chlen--;)
2305 for (kp = (u_char *)
2306 KEY_NAME(sp, tp->lb[cno]),
2307 cno += chlen; chlen--;)
2311 return (vs_change(sp, tp->lno, LINE_RESET));
2316 * Handle an error during input processing.
2319 txt_err(SCR *sp, TEXTH *tiqh)
2324 * The problem with input processing is that the cursor is at an
2325 * indeterminate position since some input may have been lost due
2326 * to a malloc error. So, try to go back to the place from which
2327 * the cursor started, knowing that it may no longer be available.
2329 * We depend on at least one line number being set in the text
2332 for (lno = TAILQ_FIRST(tiqh)->lno;
2333 !db_exist(sp, lno) && lno > 0; --lno);
2335 sp->lno = lno == 0 ? 1 : lno;
2338 /* Redraw the screen, just in case. */
2339 F_SET(sp, SC_SCR_REDRAW);
2344 * Let the user insert any character value they want.
2347 * This is an extension. The pattern "^X[0-9a-fA-F]*" is a way
2348 * for the user to specify a character value which their keyboard
2349 * may not be able to enter.
2352 txt_hex(SCR *sp, TEXT *tp)
2360 * Null-terminate the string. Since nul isn't a legal hex value,
2361 * this should be okay, and lets us use a local routine, which
2362 * presumably understands the character set, to convert the value.
2364 savec = tp->lb[tp->cno];
2365 tp->lb[tp->cno] = 0;
2367 /* Find the previous CH_HEX character. */
2368 for (off = tp->cno - 1, p = tp->lb + off, len = 0;; --p, --off, ++len) {
2373 /* Not on this line? Shouldn't happen. */
2374 if (off == tp->ai || off == tp->offset)
2378 /* If length of 0, then it wasn't a hex value. */
2382 /* Get the value. */
2384 value = STRTOL(wp, NULL, 16);
2385 if (errno || value > UCHAR_MAX) {
2386 nothex: tp->lb[tp->cno] = savec;
2390 /* Restore the original character. */
2391 tp->lb[tp->cno] = savec;
2393 /* Adjust the bookkeeping. */
2396 tp->lb[tp->cno - 1] = value;
2398 /* Copy down any overwrite characters. */
2400 MEMMOVE(tp->lb + tp->cno, tp->lb + tp->cno + len,
2403 /* Copy down any insert characters. */
2405 MEMMOVE(tp->lb + tp->cno + tp->owrite,
2406 tp->lb + tp->cno + tp->owrite + len,
2416 * Historic vi did a special screen optimization for tab characters. As an
2417 * example, for the keystrokes "iabcd<esc>0C<tab>", the tab overwrote the
2418 * rest of the string when it was displayed.
2420 * Because early versions of this implementation redisplayed the entire line
2421 * on each keystroke, the "bcd" was pushed to the right as it ignored that
2422 * the user had "promised" to change the rest of the characters. However,
2423 * the historic vi implementation had an even worse bug: given the keystrokes
2424 * "iabcd<esc>0R<tab><esc>", the "bcd" disappears, and magically reappears
2425 * on the second <esc> key.
2427 * POSIX 1003.2 requires (will require) that this be fixed, specifying that
2428 * vi overwrite characters the user has committed to changing, on the basis
2429 * of the screen space they require, but that it not overwrite other characters.
2432 txt_insch(SCR *sp, TEXT *tp, CHAR_T *chp, u_int flags)
2436 size_t chlen, cno, copydown, olen, nlen;
2440 * The 'R' command does one-for-one replacement, because there's
2441 * no way to know how many characters the user intends to replace.
2443 if (LF_ISSET(TXT_REPLACE)) {
2446 tp->lb[tp->cno++] = *chp;
2449 } else if (tp->owrite) { /* Overwrite a character. */
2453 * If the old or new characters are tabs, then the length of the
2454 * display depends on the character position in the display. We
2455 * don't even try to handle this here, just ask the screen.
2458 savech = tp->lb[cno];
2460 (void)vs_columns(sp, tp->lb, tp->lno, &cno, &nlen);
2461 tp->lb[cno] = savech;
2463 nlen = KEY_COL(sp, *chp);
2466 * Eat overwrite characters until we run out of them or we've
2467 * handled the length of the new character. If we only eat
2468 * part of an overwrite character, break it into its component
2469 * elements and display the remaining components.
2471 for (copydown = 0; nlen != 0 && tp->owrite != 0;) {
2474 if (tp->lb[cno] == '\t')
2475 (void)vs_columns(sp,
2476 tp->lb, tp->lno, &cno, &olen);
2478 olen = KEY_COL(sp, tp->lb[cno]);
2489 tp->lb, tp->lb_len, tp->len + olen);
2490 chlen = olen - nlen;
2491 MEMMOVE(tp->lb + cno + 1 + chlen,
2493 tp->owrite + tp->insert);
2496 tp->owrite += chlen;
2497 if (tp->lb[cno] == '\t' ||
2498 KEY_NEEDSWIDE(sp, tp->lb[cno]))
2499 for (p = tp->lb + cno + 1; chlen--;)
2502 for (kp = (u_char *)
2503 KEY_NAME(sp, tp->lb[cno]) + nlen,
2504 p = tp->lb + cno + 1; chlen--;)
2512 * If had to erase several characters, we adjust the total
2513 * count, and if there are any characters left, shift them
2516 if (copydown != 0 && (tp->len -= copydown) != 0)
2517 MEMMOVE(tp->lb + cno, tp->lb + cno + copydown,
2518 tp->owrite + tp->insert + copydown);
2520 /* If we had enough overwrite characters, we're done. */
2522 tp->lb[tp->cno++] = *chp;
2527 /* Check to see if the character fits into the input buffer. */
2528 BINC_RETW(sp, tp->lb, tp->lb_len, tp->len + 1);
2531 if (tp->insert) { /* Insert a character. */
2532 if (tp->insert == 1)
2533 tp->lb[tp->cno + 1] = tp->lb[tp->cno];
2535 MEMMOVE(tp->lb + tp->cno + 1,
2536 tp->lb + tp->cno, tp->owrite + tp->insert);
2538 tp->lb[tp->cno++] = *chp;
2544 * Do an incremental search.
2547 txt_isrch(SCR *sp, VICMD *vp, TEXT *tp, u_int8_t *is_flagsp)
2553 /* If it's a one-line screen, we don't do incrementals. */
2554 if (IS_ONELINE(sp)) {
2555 FL_CLR(*is_flagsp, IS_RUNNING);
2560 * If the user erases back to the beginning of the buffer, there's
2561 * nothing to search for. Reset the cursor to the starting point.
2564 vp->m_final = vp->m_start;
2569 * If it's an RE quote character, and not quoted, ignore it until
2570 * we get another character.
2572 if (tp->lb[tp->cno - 1] == '\\' &&
2573 (tp->cno == 2 || tp->lb[tp->cno - 2] != '\\'))
2577 * If it's a magic shell character, and not quoted, reset the cursor
2578 * to the starting point.
2580 if (IS_SHELLMETA(sp, tp->lb[tp->cno - 1]) &&
2581 (tp->cno == 2 || tp->lb[tp->cno - 2] != '\\'))
2582 vp->m_final = vp->m_start;
2585 * If we see the search pattern termination character, then quit doing
2586 * an incremental search. There may be more, e.g., ":/foo/;/bar/",
2587 * and we can't handle that incrementally. Also, reset the cursor to
2588 * the original location, the ex search routines don't know anything
2589 * about incremental searches.
2591 if (tp->lb[0] == tp->lb[tp->cno - 1] &&
2592 (tp->cno == 2 || tp->lb[tp->cno - 2] != '\\')) {
2593 vp->m_final = vp->m_start;
2594 FL_CLR(*is_flagsp, IS_RUNNING);
2599 * Remember the input line and discard the special input map,
2600 * but don't overwrite the input line on the screen.
2603 F_SET(VIP(sp), VIP_S_MODELINE);
2604 F_CLR(sp, SC_TINPUT | SC_TINPUT_INFO);
2605 if (txt_map_end(sp))
2609 * Specify a starting point and search. If we find a match, move to
2610 * it and refresh the screen. If we didn't find the match, then we
2611 * beep the screen. When searching from the original cursor position,
2612 * we have to move the cursor, otherwise, we don't want to move the
2613 * cursor in case the text at the current position continues to match.
2615 if (FL_ISSET(*is_flagsp, IS_RESTART)) {
2616 start = vp->m_start;
2619 start = vp->m_final;
2620 sf = SEARCH_INCR | SEARCH_SET;
2623 if (tp->lb[0] == '/' ?
2625 &start, &vp->m_final, tp->lb + 1, tp->cno - 1, NULL, sf) :
2627 &start, &vp->m_final, tp->lb + 1, tp->cno - 1, NULL, sf)) {
2628 sp->lno = vp->m_final.lno;
2629 sp->cno = vp->m_final.cno;
2630 FL_CLR(*is_flagsp, IS_RESTART);
2632 if (!KEYS_WAITING(sp) && vs_refresh(sp, 0))
2635 FL_SET(*is_flagsp, IS_RESTART);
2637 /* Reinstantiate the special input map. */
2638 if (txt_map_init(sp))
2640 F_CLR(VIP(sp), VIP_S_MODELINE);
2641 F_SET(sp, SC_TINPUT | SC_TINPUT_INFO);
2643 /* Reset the line number of the input line. */
2644 tp->lno = TMAP[0].lno;
2647 * If the colon command-line moved, i.e. the screen scrolled,
2648 * refresh the input line.
2651 * We shouldn't be calling vs_line, here -- we need dirty bits
2652 * on entries in the SMAP array.
2654 if (lno != TMAP[0].lno) {
2655 if (vs_line(sp, &TMAP[0], NULL, NULL))
2657 (void)sp->gp->scr_refresh(sp, 0);
2664 * Resolve the input text chain into the file.
2667 txt_resolve(SCR *sp, TEXTH *tiqh, u_int32_t flags)
2675 * The first line replaces a current line, and all subsequent lines
2676 * are appended into the file. Resolve autoindented characters for
2677 * each line before committing it. If the latter causes the line to
2678 * change, we have to redisplay it, otherwise the information cached
2679 * about the line will be wrong.
2682 tp = TAILQ_FIRST(tiqh);
2684 if (LF_ISSET(TXT_AUTOINDENT))
2685 txt_ai_resolve(sp, tp, &changed);
2688 if (db_set(sp, tp->lno, tp->lb, tp->len) ||
2689 (changed && vs_change(sp, tp->lno, LINE_RESET)))
2692 for (lno = tp->lno; (tp = TAILQ_NEXT(tp, q)) != NULL; ++lno) {
2693 if (LF_ISSET(TXT_AUTOINDENT))
2694 txt_ai_resolve(sp, tp, &changed);
2697 if (db_append(sp, 0, lno, tp->lb, tp->len) ||
2698 (changed && vs_change(sp, tp->lno, LINE_RESET)))
2703 * Clear the input flag, the look-aside buffer is no longer valid.
2704 * Has to be done as part of text resolution, or upon return we'll
2705 * be looking at incorrect data.
2707 F_CLR(sp, SC_TINPUT);
2714 * Show a character match.
2717 * Historic vi tried to display matches even in the :colon command line.
2721 txt_showmatch(SCR *sp, TEXT *tp)
2726 int cnt, endc, startc;
2731 * Do a refresh first, in case we haven't done one in awhile,
2732 * so the user can see what we're complaining about.
2734 UPDATE_POSITION(sp, tp);
2735 if (vs_refresh(sp, 1))
2739 * We don't display the match if it's not on the screen. Find
2740 * out what the first character on the screen is.
2742 if (vs_sm_position(sp, &m, 0, P_TOP))
2745 /* Initialize the getc() interface. */
2746 cs.cs_lno = tp->lno;
2747 cs.cs_cno = tp->cno - 1;
2748 if (cs_init(sp, &cs))
2750 startc = STRCHR(VIP(sp)->mcs, endc = cs.cs_ch)[-1];
2752 /* Search for the match. */
2754 if (cs_prev(sp, &cs))
2756 if (cs.cs_flags != 0) {
2757 if (cs.cs_flags == CS_EOF || cs.cs_flags == CS_SOF) {
2759 "Unmatched %s", KEY_NAME(sp, endc));
2764 if (cs.cs_ch == endc)
2766 else if (cs.cs_ch == startc && --cnt == 0)
2770 /* If the match is on the screen, move to it. */
2771 if (cs.cs_lno < m.lno || (cs.cs_lno == m.lno && cs.cs_cno < m.cno))
2773 sp->lno = cs.cs_lno;
2774 sp->cno = cs.cs_cno;
2775 if (vs_refresh(sp, 1))
2778 /* Wait for timeout or character arrival. */
2779 return (v_event_get(sp,
2780 NULL, O_VAL(sp, O_MATCHTIME) * 100, EC_TIMEOUT));
2785 * Handle margin wrap.
2788 txt_margin(SCR *sp, TEXT *tp, TEXT *wmtp, int *didbreak, u_int32_t flags)
2794 /* Find the nearest previous blank. */
2795 for (off = tp->cno - 1, p = tp->lb + off, len = 0;; --off, --p, ++len) {
2802 * If reach the start of the line, there's nowhere to break.
2805 * Historic vi belled each time a character was entered after
2806 * crossing the margin until a space was entered which could
2807 * be used to break the line. I don't as it tends to wake the
2810 if (off == tp->ai || off == tp->offset) {
2817 * Store saved information about the rest of the line in the
2818 * wrapmargin TEXT structure.
2821 * The offset field holds the length of the current characters
2822 * that the user entered, but which are getting split to the new
2823 * line -- it's going to be used to set the cursor value when we
2824 * move to the new line.
2829 wmtp->insert = LF_ISSET(TXT_APPENDEOL) ? tp->insert - 1 : tp->insert;
2830 wmtp->owrite = tp->owrite;
2832 /* Correct current bookkeeping information. */
2834 if (LF_ISSET(TXT_APPENDEOL)) {
2835 tp->len -= len + tp->owrite + (tp->insert - 1);
2838 tp->len -= len + tp->owrite + tp->insert;
2845 * Delete any trailing whitespace from the current line.
2847 for (;; --p, --off) {
2852 if (off == tp->ai || off == tp->offset)
2861 * Resolve the input line for the 'R' command.
2864 txt_Rresolve(SCR *sp, TEXTH *tiqh, TEXT *tp, const size_t orig_len)
2867 size_t input_len, retain;
2871 * Check to make sure that the cursor hasn't moved beyond
2872 * the end of the line.
2874 if (tp->owrite == 0)
2878 * Calculate how many characters the user has entered,
2879 * plus the blanks erased by <carriage-return>/<newline>s.
2881 for (ttp = TAILQ_FIRST(tiqh), input_len = 0;;) {
2882 input_len += ttp == tp ? tp->cno : ttp->len + ttp->R_erase;
2883 if ((ttp = TAILQ_NEXT(ttp, q)) == NULL)
2888 * If the user has entered less characters than the original line
2889 * was long, restore any overwriteable characters to the original
2890 * characters. These characters are entered as "insert characters",
2891 * because they're after the cursor and we don't want to lose them.
2892 * (This is okay because the R command has no insert characters.)
2893 * We set owrite to 0 so that the insert characters don't get copied
2894 * to somewhere else, which means that the line and the length have
2895 * to be adjusted here as well.
2897 * We have to retrieve the original line because the original pinned
2898 * page has long since been discarded. If it doesn't exist, that's
2899 * okay, the user just extended the file.
2901 if (input_len < orig_len) {
2902 retain = MIN(tp->owrite, orig_len - input_len);
2904 TAILQ_FIRST(tiqh)->lno, DBG_FATAL | DBG_NOCACHE, &p, NULL))
2906 MEMCPY(tp->lb + tp->cno, p + input_len, retain);
2907 tp->len -= tp->owrite - retain;
2909 tp->insert += retain;
2915 * No more characters message.
2918 txt_nomorech(SCR *sp)
2920 msgq(sp, M_BERR, "194|No more characters to erase");