1 /* $NetBSD: v_itxt.c,v 1.3 2014/01/26 21:43:45 christos Exp $ */
2 /*-
3 * Copyright (c) 1992, 1993, 1994
4 * The Regents of the University of California. All rights reserved.
5 * Copyright (c) 1992, 1993, 1994, 1995, 1996
6 * Keith Bostic. All rights reserved.
7 *
8 * See the LICENSE file for redistribution information.
9 */
10
11 #include "config.h"
12
13 #include <sys/cdefs.h>
14 #if 0
15 #ifndef lint
16 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 ";
17 #endif /* not lint */
18 #else
19 __RCSID("$NetBSD: v_itxt.c,v 1.3 2014/01/26 21:43:45 christos Exp $");
20 #endif
21
22 #include <sys/types.h>
23 #include <sys/queue.h>
24 #include <sys/time.h>
25
26 #include <bitstring.h>
27 #include <ctype.h>
28 #include <errno.h>
29 #include <limits.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33
34 #include "../common/common.h"
35 #include "vi.h"
36
37 /*
38 * !!!
39 * Repeated input in the historic vi is mostly wrong and this isn't very
40 * backward compatible. For example, if the user entered "3Aab\ncd" in
41 * the historic vi, the "ab" was repeated 3 times, and the "\ncd" was then
42 * appended to the result. There was also a hack which I don't remember
43 * right now, where "3o" would open 3 lines and then let the user fill them
44 * in, to make screen movements on 300 baud modems more tolerable. I don't
45 * think it's going to be missed.
46 *
47 * !!!
48 * There's a problem with the way that we do logging for change commands with
49 * implied motions (e.g. A, I, O, cc, etc.). Since the main vi loop logs the
50 * starting cursor position before the change command "moves" the cursor, the
51 * cursor position to which we return on undo will be where the user entered
52 * the change command, not the start of the change. Several of the following
53 * routines re-log the cursor to make this work correctly. Historic vi tried
54 * to do the same thing, and mostly got it right. (The only spectacular way
55 * it fails is if the user entered 'o' from anywhere but the last character of
56 * the line, the undo returned the cursor to the start of the line. If the
57 * user was on the last character of the line, the cursor returned to that
58 * position.) We also check for mapped keys waiting, i.e. if we're in the
59 * middle of a map, don't bother logging the cursor.
60 */
61 #define LOG_CORRECT { \
62 if (!MAPPED_KEYS_WAITING(sp)) \
63 (void)log_cursor(sp); \
64 }
65
66 static u_int32_t set_txt_std __P((SCR *, VICMD *, u_int32_t));
67
68 /*
69 * v_iA -- [count]A
70 * Append text to the end of the line.
71 *
72 * PUBLIC: int v_iA __P((SCR *, VICMD *));
73 */
74 int
v_iA(SCR * sp,VICMD * vp)75 v_iA(SCR *sp, VICMD *vp)
76 {
77 size_t len;
78
79 if (!db_get(sp, vp->m_start.lno, 0, NULL, &len))
80 sp->cno = len == 0 ? 0 : len - 1;
81
82 LOG_CORRECT;
83
84 return (v_ia(sp, vp));
85 }
86
87 /*
88 * v_ia -- [count]a
89 * [count]A
90 * Append text to the cursor position.
91 *
92 * PUBLIC: int v_ia __P((SCR *, VICMD *));
93 */
94 int
v_ia(SCR * sp,VICMD * vp)95 v_ia(SCR *sp, VICMD *vp)
96 {
97 size_t len;
98 u_int32_t flags;
99 int isempty;
100 CHAR_T *p;
101
102 flags = set_txt_std(sp, vp, 0);
103 sp->showmode = SM_APPEND;
104 sp->lno = vp->m_start.lno;
105
106 /* Move the cursor one column to the right and repaint the screen. */
107 if (db_eget(sp, sp->lno, &p, &len, &isempty)) {
108 if (!isempty)
109 return (1);
110 len = 0;
111 LF_SET(TXT_APPENDEOL);
112 } else if (len) {
113 if (len == sp->cno + 1) {
114 sp->cno = len;
115 LF_SET(TXT_APPENDEOL);
116 } else
117 ++sp->cno;
118 } else
119 LF_SET(TXT_APPENDEOL);
120
121 return (v_txt(sp, vp, NULL, p, len,
122 0, OOBLNO, F_ISSET(vp, VC_C1SET) ? vp->count : 1, flags));
123 }
124
125 /*
126 * v_iI -- [count]I
127 * Insert text at the first nonblank.
128 *
129 * PUBLIC: int v_iI __P((SCR *, VICMD *));
130 */
131 int
v_iI(SCR * sp,VICMD * vp)132 v_iI(SCR *sp, VICMD *vp)
133 {
134 sp->cno = 0;
135 if (nonblank(sp, vp->m_start.lno, &sp->cno))
136 return (1);
137
138 LOG_CORRECT;
139
140 return (v_ii(sp, vp));
141 }
142
143 /*
144 * v_ii -- [count]i
145 * [count]I
146 * Insert text at the cursor position.
147 *
148 * PUBLIC: int v_ii __P((SCR *, VICMD *));
149 */
150 int
v_ii(SCR * sp,VICMD * vp)151 v_ii(SCR *sp, VICMD *vp)
152 {
153 size_t len;
154 u_int32_t flags;
155 int isempty;
156 CHAR_T *p;
157
158 flags = set_txt_std(sp, vp, 0);
159 sp->showmode = SM_INSERT;
160 sp->lno = vp->m_start.lno;
161
162 if (db_eget(sp, sp->lno, &p, &len, &isempty)) {
163 if (!isempty)
164 return (1);
165 len = 0;
166 }
167
168 if (len == 0)
169 LF_SET(TXT_APPENDEOL);
170 return (v_txt(sp, vp, NULL, p, len,
171 0, OOBLNO, F_ISSET(vp, VC_C1SET) ? vp->count : 1, flags));
172 }
173
174 enum which { o_cmd, O_cmd };
175 static int io __P((SCR *, VICMD *, enum which));
176
177 /*
178 * v_iO -- [count]O
179 * Insert text above this line.
180 *
181 * PUBLIC: int v_iO __P((SCR *, VICMD *));
182 */
183 int
v_iO(SCR * sp,VICMD * vp)184 v_iO(SCR *sp, VICMD *vp)
185 {
186 return (io(sp, vp, O_cmd));
187 }
188
189 /*
190 * v_io -- [count]o
191 * Insert text after this line.
192 *
193 * PUBLIC: int v_io __P((SCR *, VICMD *));
194 */
195 int
v_io(SCR * sp,VICMD * vp)196 v_io(SCR *sp, VICMD *vp)
197 {
198 return (io(sp, vp, o_cmd));
199 }
200
201 static int
io(SCR * sp,VICMD * vp,enum which cmd)202 io(SCR *sp, VICMD *vp, enum which cmd)
203 {
204 db_recno_t ai_line, lno;
205 size_t len;
206 u_int32_t flags;
207 CHAR_T *p;
208
209 flags = set_txt_std(sp, vp, TXT_ADDNEWLINE | TXT_APPENDEOL);
210 sp->showmode = SM_INSERT;
211
212 if (sp->lno == 1) {
213 if (db_last(sp, &lno))
214 return (1);
215 if (lno != 0)
216 goto insert;
217 p = NULL;
218 len = 0;
219 ai_line = OOBLNO;
220 } else {
221 static CHAR_T nul = 0;
222 insert: p = &nul;
223 sp->cno = 0;
224 LOG_CORRECT;
225
226 if (cmd == O_cmd) {
227 if (db_insert(sp, sp->lno, p, 0))
228 return (1);
229 if (db_get(sp, sp->lno, DBG_FATAL, &p, &len))
230 return (1);
231 ai_line = sp->lno + 1;
232 } else {
233 if (db_append(sp, 1, sp->lno, p, 0))
234 return (1);
235 if (db_get(sp, ++sp->lno, DBG_FATAL, &p, &len))
236 return (1);
237 ai_line = sp->lno - 1;
238 }
239 }
240 return (v_txt(sp, vp, NULL, p, len,
241 0, ai_line, F_ISSET(vp, VC_C1SET) ? vp->count : 1, flags));
242 }
243
244 /*
245 * v_change -- [buffer][count]c[count]motion
246 * [buffer][count]C
247 * [buffer][count]S
248 * Change command.
249 *
250 * PUBLIC: int v_change __P((SCR *, VICMD *));
251 */
252 int
v_change(SCR * sp,VICMD * vp)253 v_change(SCR *sp, VICMD *vp)
254 {
255 size_t blen, len;
256 u_int32_t flags;
257 int isempty, lmode, rval;
258 CHAR_T *bp;
259 CHAR_T *p;
260
261 /*
262 * 'c' can be combined with motion commands that set the resulting
263 * cursor position, i.e. "cG". Clear the VM_RCM flags and make the
264 * resulting cursor position stick, inserting text has its own rules
265 * for cursor positioning.
266 */
267 F_CLR(vp, VM_RCM_MASK);
268 F_SET(vp, VM_RCM_SET);
269
270 /*
271 * Find out if the file is empty, it's easier to handle it as a
272 * special case.
273 */
274 if (vp->m_start.lno == vp->m_stop.lno &&
275 db_eget(sp, vp->m_start.lno, &p, &len, &isempty)) {
276 if (!isempty)
277 return (1);
278 return (v_ia(sp, vp));
279 }
280
281 flags = set_txt_std(sp, vp, 0);
282 sp->showmode = SM_CHANGE;
283
284 /*
285 * Move the cursor to the start of the change. Note, if autoindent
286 * is turned on, the cc command in line mode changes from the first
287 * *non-blank* character of the line, not the first character. And,
288 * to make it just a bit more exciting, the initial space is handled
289 * as auto-indent characters.
290 */
291 lmode = F_ISSET(vp, VM_LMODE) ? CUT_LINEMODE : 0;
292 if (lmode) {
293 vp->m_start.cno = 0;
294 if (O_ISSET(sp, O_AUTOINDENT)) {
295 if (nonblank(sp, vp->m_start.lno, &vp->m_start.cno))
296 return (1);
297 LF_SET(TXT_AICHARS);
298 }
299 }
300 sp->lno = vp->m_start.lno;
301 sp->cno = vp->m_start.cno;
302
303 LOG_CORRECT;
304
305 /*
306 * If not in line mode and changing within a single line, copy the
307 * text and overwrite it.
308 */
309 if (!lmode && vp->m_start.lno == vp->m_stop.lno) {
310 /*
311 * !!!
312 * Historic practice, c did not cut into the numeric buffers,
313 * only the unnamed one.
314 */
315 if (cut(sp,
316 F_ISSET(vp, VC_BUFFER) ? &vp->buffer : NULL,
317 &vp->m_start, &vp->m_stop, lmode))
318 return (1);
319 if (len == 0)
320 LF_SET(TXT_APPENDEOL);
321 LF_SET(TXT_EMARK | TXT_OVERWRITE);
322 return (v_txt(sp, vp, &vp->m_stop, p, len,
323 0, OOBLNO, F_ISSET(vp, VC_C1SET) ? vp->count : 1, flags));
324 }
325
326 /*
327 * It's trickier if in line mode or changing over multiple lines. If
328 * we're in line mode delete all of the lines and insert a replacement
329 * line which the user edits. If there was leading whitespace in the
330 * first line being changed, we copy it and use it as the replacement.
331 * If we're not in line mode, we delete the text and start inserting.
332 *
333 * !!!
334 * Copy the text. Historic practice, c did not cut into the numeric
335 * buffers, only the unnamed one.
336 */
337 if (cut(sp,
338 F_ISSET(vp, VC_BUFFER) ? &vp->buffer : NULL,
339 &vp->m_start, &vp->m_stop, lmode))
340 return (1);
341
342 /* If replacing entire lines and there's leading text. */
343 if (lmode && vp->m_start.cno) {
344 /*
345 * Get a copy of the first line changed, and copy out the
346 * leading text.
347 */
348 if (db_get(sp, vp->m_start.lno, DBG_FATAL, &p, &len))
349 return (1);
350 GET_SPACE_RETW(sp, bp, blen, vp->m_start.cno);
351 MEMMOVEW(bp, p, vp->m_start.cno);
352 } else
353 bp = NULL;
354
355 /* Delete the text. */
356 if (del(sp, &vp->m_start, &vp->m_stop, lmode))
357 return (1);
358
359 /* If replacing entire lines, insert a replacement line. */
360 if (lmode) {
361 if (db_insert(sp, vp->m_start.lno, bp, vp->m_start.cno))
362 return (1);
363 sp->lno = vp->m_start.lno;
364 len = sp->cno = vp->m_start.cno;
365 }
366
367 /* Get the line we're editing. */
368 if (db_eget(sp, vp->m_start.lno, &p, &len, &isempty)) {
369 if (!isempty)
370 return (1);
371 len = 0;
372 }
373
374 /* Check to see if we're appending to the line. */
375 if (vp->m_start.cno >= len)
376 LF_SET(TXT_APPENDEOL);
377
378 rval = v_txt(sp, vp, NULL, p, len,
379 0, OOBLNO, F_ISSET(vp, VC_C1SET) ? vp->count : 1, flags);
380
381 if (bp != NULL)
382 FREE_SPACEW(sp, bp, blen);
383 return (rval);
384 }
385
386 /*
387 * v_Replace -- [count]R
388 * Overwrite multiple characters.
389 *
390 * PUBLIC: int v_Replace __P((SCR *, VICMD *));
391 */
392 int
v_Replace(SCR * sp,VICMD * vp)393 v_Replace(SCR *sp, VICMD *vp)
394 {
395 size_t len;
396 u_int32_t flags;
397 int isempty;
398 CHAR_T *p;
399
400 flags = set_txt_std(sp, vp, 0);
401 sp->showmode = SM_REPLACE;
402
403 if (db_eget(sp, vp->m_start.lno, &p, &len, &isempty)) {
404 if (!isempty)
405 return (1);
406 len = 0;
407 LF_SET(TXT_APPENDEOL);
408 } else {
409 if (len == 0)
410 LF_SET(TXT_APPENDEOL);
411 LF_SET(TXT_OVERWRITE | TXT_REPLACE);
412 }
413 vp->m_stop.lno = vp->m_start.lno;
414 vp->m_stop.cno = len ? len - 1 : 0;
415
416 return (v_txt(sp, vp, &vp->m_stop, p, len,
417 0, OOBLNO, F_ISSET(vp, VC_C1SET) ? vp->count : 1, flags));
418 }
419
420 /*
421 * v_subst -- [buffer][count]s
422 * Substitute characters.
423 *
424 * PUBLIC: int v_subst __P((SCR *, VICMD *));
425 */
426 int
v_subst(SCR * sp,VICMD * vp)427 v_subst(SCR *sp, VICMD *vp)
428 {
429 size_t len;
430 u_int32_t flags;
431 int isempty;
432 CHAR_T *p;
433
434 flags = set_txt_std(sp, vp, 0);
435 sp->showmode = SM_CHANGE;
436
437 if (db_eget(sp, vp->m_start.lno, &p, &len, &isempty)) {
438 if (!isempty)
439 return (1);
440 len = 0;
441 LF_SET(TXT_APPENDEOL);
442 } else {
443 if (len == 0)
444 LF_SET(TXT_APPENDEOL);
445 LF_SET(TXT_EMARK | TXT_OVERWRITE);
446 }
447
448 vp->m_stop.lno = vp->m_start.lno;
449 vp->m_stop.cno =
450 vp->m_start.cno + (F_ISSET(vp, VC_C1SET) ? vp->count - 1 : 0);
451 if (vp->m_stop.cno > len - 1)
452 vp->m_stop.cno = len - 1;
453
454 if (p != NULL && cut(sp,
455 F_ISSET(vp, VC_BUFFER) ? &vp->buffer : NULL,
456 &vp->m_start, &vp->m_stop, 0))
457 return (1);
458
459 return (v_txt(sp, vp, &vp->m_stop, p, len, 0, OOBLNO, 1, flags));
460 }
461
462 /*
463 * set_txt_std --
464 * Initialize text processing flags.
465 */
466 static u_int32_t
set_txt_std(SCR * sp,VICMD * vp,u_int32_t flags)467 set_txt_std(SCR *sp, VICMD *vp, u_int32_t flags)
468 {
469 LF_SET(TXT_CNTRLT |
470 TXT_ESCAPE | TXT_MAPINPUT | TXT_RECORD | TXT_RESOLVE);
471
472 if (F_ISSET(vp, VC_ISDOT))
473 LF_SET(TXT_REPLAY);
474
475 if (O_ISSET(sp, O_ALTWERASE))
476 LF_SET(TXT_ALTWERASE);
477 if (O_ISSET(sp, O_AUTOINDENT))
478 LF_SET(TXT_AUTOINDENT);
479 if (O_ISSET(sp, O_BEAUTIFY))
480 LF_SET(TXT_BEAUTIFY);
481 if (O_ISSET(sp, O_SHOWMATCH))
482 LF_SET(TXT_SHOWMATCH);
483 if (F_ISSET(sp, SC_SCRIPT))
484 LF_SET(TXT_CR);
485 if (O_ISSET(sp, O_TTYWERASE))
486 LF_SET(TXT_TTYWERASE);
487
488 /*
489 * !!!
490 * Mapped keys were sometimes unaffected by the wrapmargin option
491 * in the historic 4BSD vi. Consider the following commands, where
492 * each is executed on an empty line, in an 80 column screen, with
493 * the wrapmargin value set to 60.
494 *
495 * aABC DEF <ESC>....
496 * :map K aABC DEF ^V<ESC><CR>KKKKK
497 * :map K 5aABC DEF ^V<ESC><CR>K
498 *
499 * The first and second commands are affected by wrapmargin. The
500 * third is not. (If the inserted text is itself longer than the
501 * wrapmargin value, i.e. if the "ABC DEF " string is replaced by
502 * something that's longer than 60 columns from the beginning of
503 * the line, the first two commands behave as before, but the third
504 * command gets fairly strange.) The problem is that people wrote
505 * macros that depended on the third command NOT being affected by
506 * wrapmargin, as in this gem which centers lines:
507 *
508 * map #c $mq81a ^V^[81^V^V|D`qld0:s/ / /g^V^M$p
509 *
510 * For compatibility reasons, we try and make it all work here. I
511 * offer no hope that this is right, but it's probably pretty close.
512 *
513 * XXX
514 * Once I work my courage up, this is all gonna go away. It's too
515 * evil to survive.
516 */
517 if ((O_ISSET(sp, O_WRAPLEN) || O_ISSET(sp, O_WRAPMARGIN)) &&
518 (!MAPPED_KEYS_WAITING(sp) || !F_ISSET(vp, VC_C1SET)))
519 LF_SET(TXT_WRAPMARGIN);
520 return (flags);
521 }
522