2 * Copyright (c) 1992, 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_itxt.c,v 10.21 2001/06/25 15:19:32 skimo Exp $ (Berkeley) $Date: 2001/06/25 15:19:32 $";
16 #include <sys/types.h>
17 #include <sys/queue.h>
20 #include <bitstring.h>
28 #include "../common/common.h"
33 * Repeated input in the historic vi is mostly wrong and this isn't very
34 * backward compatible. For example, if the user entered "3Aab\ncd" in
35 * the historic vi, the "ab" was repeated 3 times, and the "\ncd" was then
36 * appended to the result. There was also a hack which I don't remember
37 * right now, where "3o" would open 3 lines and then let the user fill them
38 * in, to make screen movements on 300 baud modems more tolerable. I don't
39 * think it's going to be missed.
42 * There's a problem with the way that we do logging for change commands with
43 * implied motions (e.g. A, I, O, cc, etc.). Since the main vi loop logs the
44 * starting cursor position before the change command "moves" the cursor, the
45 * cursor position to which we return on undo will be where the user entered
46 * the change command, not the start of the change. Several of the following
47 * routines re-log the cursor to make this work correctly. Historic vi tried
48 * to do the same thing, and mostly got it right. (The only spectacular way
49 * it fails is if the user entered 'o' from anywhere but the last character of
50 * the line, the undo returned the cursor to the start of the line. If the
51 * user was on the last character of the line, the cursor returned to that
52 * position.) We also check for mapped keys waiting, i.e. if we're in the
53 * middle of a map, don't bother logging the cursor.
55 #define LOG_CORRECT { \
56 if (!MAPPED_KEYS_WAITING(sp)) \
57 (void)log_cursor(sp); \
60 static u_int32_t set_txt_std
__P((SCR
*, VICMD
*, u_int32_t
));
64 * Append text to the end of the line.
66 * PUBLIC: int v_iA __P((SCR *, VICMD *));
69 v_iA(SCR
*sp
, VICMD
*vp
)
73 if (!db_get(sp
, vp
->m_start
.lno
, 0, NULL
, &len
))
74 sp
->cno
= len
== 0 ? 0 : len
- 1;
78 return (v_ia(sp
, vp
));
84 * Append text to the cursor position.
86 * PUBLIC: int v_ia __P((SCR *, VICMD *));
89 v_ia(SCR
*sp
, VICMD
*vp
)
96 flags
= set_txt_std(sp
, vp
, 0);
97 sp
->showmode
= SM_APPEND
;
98 sp
->lno
= vp
->m_start
.lno
;
100 /* Move the cursor one column to the right and repaint the screen. */
101 if (db_eget(sp
, sp
->lno
, &p
, &len
, &isempty
)) {
105 LF_SET(TXT_APPENDEOL
);
107 if (len
== sp
->cno
+ 1) {
109 LF_SET(TXT_APPENDEOL
);
113 LF_SET(TXT_APPENDEOL
);
115 return (v_txt(sp
, vp
, NULL
, p
, len
,
116 0, OOBLNO
, F_ISSET(vp
, VC_C1SET
) ? vp
->count
: 1, flags
));
121 * Insert text at the first nonblank.
123 * PUBLIC: int v_iI __P((SCR *, VICMD *));
126 v_iI(SCR
*sp
, VICMD
*vp
)
129 if (nonblank(sp
, vp
->m_start
.lno
, &sp
->cno
))
134 return (v_ii(sp
, vp
));
140 * Insert text at the cursor position.
142 * PUBLIC: int v_ii __P((SCR *, VICMD *));
145 v_ii(SCR
*sp
, VICMD
*vp
)
152 flags
= set_txt_std(sp
, vp
, 0);
153 sp
->showmode
= SM_INSERT
;
154 sp
->lno
= vp
->m_start
.lno
;
156 if (db_eget(sp
, sp
->lno
, &p
, &len
, &isempty
)) {
163 LF_SET(TXT_APPENDEOL
);
164 return (v_txt(sp
, vp
, NULL
, p
, len
,
165 0, OOBLNO
, F_ISSET(vp
, VC_C1SET
) ? vp
->count
: 1, flags
));
168 enum which
{ o_cmd
, O_cmd
};
169 static int io
__P((SCR
*, VICMD
*, enum which
));
173 * Insert text above this line.
175 * PUBLIC: int v_iO __P((SCR *, VICMD *));
178 v_iO(SCR
*sp
, VICMD
*vp
)
180 return (io(sp
, vp
, O_cmd
));
185 * Insert text after this line.
187 * PUBLIC: int v_io __P((SCR *, VICMD *));
190 v_io(SCR
*sp
, VICMD
*vp
)
192 return (io(sp
, vp
, o_cmd
));
196 io(SCR
*sp
, VICMD
*vp
, enum which cmd
)
198 db_recno_t ai_line
, lno
;
203 flags
= set_txt_std(sp
, vp
, TXT_ADDNEWLINE
| TXT_APPENDEOL
);
204 sp
->showmode
= SM_INSERT
;
207 if (db_last(sp
, &lno
))
215 static CHAR_T nul
= 0;
221 if (db_insert(sp
, sp
->lno
, p
, 0))
223 if (db_get(sp
, sp
->lno
, DBG_FATAL
, &p
, &len
))
225 ai_line
= sp
->lno
+ 1;
227 if (db_append(sp
, 1, sp
->lno
, p
, 0))
229 if (db_get(sp
, ++sp
->lno
, DBG_FATAL
, &p
, &len
))
231 ai_line
= sp
->lno
- 1;
234 return (v_txt(sp
, vp
, NULL
, p
, len
,
235 0, ai_line
, F_ISSET(vp
, VC_C1SET
) ? vp
->count
: 1, flags
));
239 * v_change -- [buffer][count]c[count]motion
244 * PUBLIC: int v_change __P((SCR *, VICMD *));
247 v_change(SCR
*sp
, VICMD
*vp
)
251 int isempty
, lmode
, rval
;
256 * 'c' can be combined with motion commands that set the resulting
257 * cursor position, i.e. "cG". Clear the VM_RCM flags and make the
258 * resulting cursor position stick, inserting text has its own rules
259 * for cursor positioning.
261 F_CLR(vp
, VM_RCM_MASK
);
262 F_SET(vp
, VM_RCM_SET
);
265 * Find out if the file is empty, it's easier to handle it as a
268 if (vp
->m_start
.lno
== vp
->m_stop
.lno
&&
269 db_eget(sp
, vp
->m_start
.lno
, &p
, &len
, &isempty
)) {
272 return (v_ia(sp
, vp
));
275 flags
= set_txt_std(sp
, vp
, 0);
276 sp
->showmode
= SM_CHANGE
;
279 * Move the cursor to the start of the change. Note, if autoindent
280 * is turned on, the cc command in line mode changes from the first
281 * *non-blank* character of the line, not the first character. And,
282 * to make it just a bit more exciting, the initial space is handled
283 * as auto-indent characters.
285 lmode
= F_ISSET(vp
, VM_LMODE
) ? CUT_LINEMODE
: 0;
288 if (O_ISSET(sp
, O_AUTOINDENT
)) {
289 if (nonblank(sp
, vp
->m_start
.lno
, &vp
->m_start
.cno
))
294 sp
->lno
= vp
->m_start
.lno
;
295 sp
->cno
= vp
->m_start
.cno
;
300 * If not in line mode and changing within a single line, copy the
301 * text and overwrite it.
303 if (!lmode
&& vp
->m_start
.lno
== vp
->m_stop
.lno
) {
306 * Historic practice, c did not cut into the numeric buffers,
307 * only the unnamed one.
310 F_ISSET(vp
, VC_BUFFER
) ? &vp
->buffer
: NULL
,
311 &vp
->m_start
, &vp
->m_stop
, lmode
))
314 LF_SET(TXT_APPENDEOL
);
315 LF_SET(TXT_EMARK
| TXT_OVERWRITE
);
316 return (v_txt(sp
, vp
, &vp
->m_stop
, p
, len
,
317 0, OOBLNO
, F_ISSET(vp
, VC_C1SET
) ? vp
->count
: 1, flags
));
321 * It's trickier if in line mode or changing over multiple lines. If
322 * we're in line mode delete all of the lines and insert a replacement
323 * line which the user edits. If there was leading whitespace in the
324 * first line being changed, we copy it and use it as the replacement.
325 * If we're not in line mode, we delete the text and start inserting.
328 * Copy the text. Historic practice, c did not cut into the numeric
329 * buffers, only the unnamed one.
332 F_ISSET(vp
, VC_BUFFER
) ? &vp
->buffer
: NULL
,
333 &vp
->m_start
, &vp
->m_stop
, lmode
))
336 /* If replacing entire lines and there's leading text. */
337 if (lmode
&& vp
->m_start
.cno
) {
339 * Get a copy of the first line changed, and copy out the
342 if (db_get(sp
, vp
->m_start
.lno
, DBG_FATAL
, &p
, &len
))
344 GET_SPACE_RETW(sp
, bp
, blen
, vp
->m_start
.cno
);
345 MEMMOVEW(bp
, p
, vp
->m_start
.cno
);
349 /* Delete the text. */
350 if (del(sp
, &vp
->m_start
, &vp
->m_stop
, lmode
))
353 /* If replacing entire lines, insert a replacement line. */
355 if (db_insert(sp
, vp
->m_start
.lno
, bp
, vp
->m_start
.cno
))
357 sp
->lno
= vp
->m_start
.lno
;
358 len
= sp
->cno
= vp
->m_start
.cno
;
361 /* Get the line we're editing. */
362 if (db_eget(sp
, vp
->m_start
.lno
, &p
, &len
, &isempty
)) {
368 /* Check to see if we're appending to the line. */
369 if (vp
->m_start
.cno
>= len
)
370 LF_SET(TXT_APPENDEOL
);
372 rval
= v_txt(sp
, vp
, NULL
, p
, len
,
373 0, OOBLNO
, F_ISSET(vp
, VC_C1SET
) ? vp
->count
: 1, flags
);
376 FREE_SPACEW(sp
, bp
, blen
);
381 * v_Replace -- [count]R
382 * Overwrite multiple characters.
384 * PUBLIC: int v_Replace __P((SCR *, VICMD *));
387 v_Replace(SCR
*sp
, VICMD
*vp
)
394 flags
= set_txt_std(sp
, vp
, 0);
395 sp
->showmode
= SM_REPLACE
;
397 if (db_eget(sp
, vp
->m_start
.lno
, &p
, &len
, &isempty
)) {
401 LF_SET(TXT_APPENDEOL
);
404 LF_SET(TXT_APPENDEOL
);
405 LF_SET(TXT_OVERWRITE
| TXT_REPLACE
);
407 vp
->m_stop
.lno
= vp
->m_start
.lno
;
408 vp
->m_stop
.cno
= len
? len
- 1 : 0;
410 return (v_txt(sp
, vp
, &vp
->m_stop
, p
, len
,
411 0, OOBLNO
, F_ISSET(vp
, VC_C1SET
) ? vp
->count
: 1, flags
));
415 * v_subst -- [buffer][count]s
416 * Substitute characters.
418 * PUBLIC: int v_subst __P((SCR *, VICMD *));
421 v_subst(SCR
*sp
, VICMD
*vp
)
428 flags
= set_txt_std(sp
, vp
, 0);
429 sp
->showmode
= SM_CHANGE
;
431 if (db_eget(sp
, vp
->m_start
.lno
, &p
, &len
, &isempty
)) {
435 LF_SET(TXT_APPENDEOL
);
438 LF_SET(TXT_APPENDEOL
);
439 LF_SET(TXT_EMARK
| TXT_OVERWRITE
);
442 vp
->m_stop
.lno
= vp
->m_start
.lno
;
444 vp
->m_start
.cno
+ (F_ISSET(vp
, VC_C1SET
) ? vp
->count
- 1 : 0);
445 if (vp
->m_stop
.cno
> len
- 1)
446 vp
->m_stop
.cno
= len
- 1;
448 if (p
!= NULL
&& cut(sp
,
449 F_ISSET(vp
, VC_BUFFER
) ? &vp
->buffer
: NULL
,
450 &vp
->m_start
, &vp
->m_stop
, 0))
453 return (v_txt(sp
, vp
, &vp
->m_stop
, p
, len
, 0, OOBLNO
, 1, flags
));
458 * Initialize text processing flags.
461 set_txt_std(SCR
*sp
, VICMD
*vp
, u_int32_t flags
)
464 TXT_ESCAPE
| TXT_MAPINPUT
| TXT_RECORD
| TXT_RESOLVE
);
466 if (F_ISSET(vp
, VC_ISDOT
))
469 if (O_ISSET(sp
, O_ALTWERASE
))
470 LF_SET(TXT_ALTWERASE
);
471 if (O_ISSET(sp
, O_AUTOINDENT
))
472 LF_SET(TXT_AUTOINDENT
);
473 if (O_ISSET(sp
, O_BEAUTIFY
))
474 LF_SET(TXT_BEAUTIFY
);
475 if (O_ISSET(sp
, O_SHOWMATCH
))
476 LF_SET(TXT_SHOWMATCH
);
477 if (F_ISSET(sp
, SC_SCRIPT
))
479 if (O_ISSET(sp
, O_TTYWERASE
))
480 LF_SET(TXT_TTYWERASE
);
484 * Mapped keys were sometimes unaffected by the wrapmargin option
485 * in the historic 4BSD vi. Consider the following commands, where
486 * each is executed on an empty line, in an 80 column screen, with
487 * the wrapmargin value set to 60.
490 * :map K aABC DEF ^V<ESC><CR>KKKKK
491 * :map K 5aABC DEF ^V<ESC><CR>K
493 * The first and second commands are affected by wrapmargin. The
494 * third is not. (If the inserted text is itself longer than the
495 * wrapmargin value, i.e. if the "ABC DEF " string is replaced by
496 * something that's longer than 60 columns from the beginning of
497 * the line, the first two commands behave as before, but the third
498 * command gets fairly strange.) The problem is that people wrote
499 * macros that depended on the third command NOT being affected by
500 * wrapmargin, as in this gem which centers lines:
502 * map #c $mq81a ^V^[81^V^V|D`qld0:s/ / /g^V^M$p
504 * For compatibility reasons, we try and make it all work here. I
505 * offer no hope that this is right, but it's probably pretty close.
508 * Once I work my courage up, this is all gonna go away. It's too
511 if ((O_ISSET(sp
, O_WRAPLEN
) || O_ISSET(sp
, O_WRAPMARGIN
)) &&
512 (!MAPPED_KEYS_WAITING(sp
) || !F_ISSET(vp
, VC_C1SET
)))
513 LF_SET(TXT_WRAPMARGIN
);