rename O_DIRECTORY to O_TMP_DIRECTORY to avoid conflict with open option
[nvi.git] / vi / v_itxt.c
blob30c3db22ab9d35298f81baaf6a27eb648379fae2
1 /*-
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.
8 */
10 #include "config.h"
12 #ifndef lint
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 $";
14 #endif /* not lint */
16 #include <sys/types.h>
17 #include <sys/queue.h>
18 #include <sys/time.h>
20 #include <bitstring.h>
21 #include <ctype.h>
22 #include <errno.h>
23 #include <limits.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
28 #include "../common/common.h"
29 #include "vi.h"
32 * !!!
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.
41 * !!!
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));
63 * v_iA -- [count]A
64 * Append text to the end of the line.
66 * PUBLIC: int v_iA __P((SCR *, VICMD *));
68 int
69 v_iA(SCR *sp, VICMD *vp)
71 size_t len;
73 if (!db_get(sp, vp->m_start.lno, 0, NULL, &len))
74 sp->cno = len == 0 ? 0 : len - 1;
76 LOG_CORRECT;
78 return (v_ia(sp, vp));
82 * v_ia -- [count]a
83 * [count]A
84 * Append text to the cursor position.
86 * PUBLIC: int v_ia __P((SCR *, VICMD *));
88 int
89 v_ia(SCR *sp, VICMD *vp)
91 size_t len;
92 u_int32_t flags;
93 int isempty;
94 CHAR_T *p;
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)) {
102 if (!isempty)
103 return (1);
104 len = 0;
105 LF_SET(TXT_APPENDEOL);
106 } else if (len) {
107 if (len == sp->cno + 1) {
108 sp->cno = len;
109 LF_SET(TXT_APPENDEOL);
110 } else
111 ++sp->cno;
112 } else
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));
120 * v_iI -- [count]I
121 * Insert text at the first nonblank.
123 * PUBLIC: int v_iI __P((SCR *, VICMD *));
126 v_iI(SCR *sp, VICMD *vp)
128 sp->cno = 0;
129 if (nonblank(sp, vp->m_start.lno, &sp->cno))
130 return (1);
132 LOG_CORRECT;
134 return (v_ii(sp, vp));
138 * v_ii -- [count]i
139 * [count]I
140 * Insert text at the cursor position.
142 * PUBLIC: int v_ii __P((SCR *, VICMD *));
145 v_ii(SCR *sp, VICMD *vp)
147 size_t len;
148 u_int32_t flags;
149 int isempty;
150 CHAR_T *p;
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)) {
157 if (!isempty)
158 return (1);
159 len = 0;
162 if (len == 0)
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));
172 * v_iO -- [count]O
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));
184 * v_io -- [count]o
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));
195 static int
196 io(SCR *sp, VICMD *vp, enum which cmd)
198 db_recno_t ai_line, lno;
199 size_t len;
200 u_int32_t flags;
201 CHAR_T *p;
203 flags = set_txt_std(sp, vp, TXT_ADDNEWLINE | TXT_APPENDEOL);
204 sp->showmode = SM_INSERT;
206 if (sp->lno == 1) {
207 if (db_last(sp, &lno))
208 return (1);
209 if (lno != 0)
210 goto insert;
211 p = NULL;
212 len = 0;
213 ai_line = OOBLNO;
214 } else {
215 static CHAR_T nul = 0;
216 insert: p = &nul;
217 sp->cno = 0;
218 LOG_CORRECT;
220 if (cmd == O_cmd) {
221 if (db_insert(sp, sp->lno, p, 0))
222 return (1);
223 if (db_get(sp, sp->lno, DBG_FATAL, &p, &len))
224 return (1);
225 ai_line = sp->lno + 1;
226 } else {
227 if (db_append(sp, 1, 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;
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
240 * [buffer][count]C
241 * [buffer][count]S
242 * Change command.
244 * PUBLIC: int v_change __P((SCR *, VICMD *));
247 v_change(SCR *sp, VICMD *vp)
249 size_t blen, len;
250 u_int32_t flags;
251 int isempty, lmode, rval;
252 CHAR_T *bp;
253 CHAR_T *p;
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
266 * special case.
268 if (vp->m_start.lno == vp->m_stop.lno &&
269 db_eget(sp, vp->m_start.lno, &p, &len, &isempty)) {
270 if (!isempty)
271 return (1);
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;
286 if (lmode) {
287 vp->m_start.cno = 0;
288 if (O_ISSET(sp, O_AUTOINDENT)) {
289 if (nonblank(sp, vp->m_start.lno, &vp->m_start.cno))
290 return (1);
291 LF_SET(TXT_AICHARS);
294 sp->lno = vp->m_start.lno;
295 sp->cno = vp->m_start.cno;
297 LOG_CORRECT;
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) {
305 * !!!
306 * Historic practice, c did not cut into the numeric buffers,
307 * only the unnamed one.
309 if (cut(sp,
310 F_ISSET(vp, VC_BUFFER) ? &vp->buffer : NULL,
311 &vp->m_start, &vp->m_stop, lmode))
312 return (1);
313 if (len == 0)
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.
327 * !!!
328 * Copy the text. Historic practice, c did not cut into the numeric
329 * buffers, only the unnamed one.
331 if (cut(sp,
332 F_ISSET(vp, VC_BUFFER) ? &vp->buffer : NULL,
333 &vp->m_start, &vp->m_stop, lmode))
334 return (1);
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
340 * leading text.
342 if (db_get(sp, vp->m_start.lno, DBG_FATAL, &p, &len))
343 return (1);
344 GET_SPACE_RETW(sp, bp, blen, vp->m_start.cno);
345 MEMMOVEW(bp, p, vp->m_start.cno);
346 } else
347 bp = NULL;
349 /* Delete the text. */
350 if (del(sp, &vp->m_start, &vp->m_stop, lmode))
351 return (1);
353 /* If replacing entire lines, insert a replacement line. */
354 if (lmode) {
355 if (db_insert(sp, vp->m_start.lno, bp, vp->m_start.cno))
356 return (1);
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)) {
363 if (!isempty)
364 return (1);
365 len = 0;
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);
375 if (bp != NULL)
376 FREE_SPACEW(sp, bp, blen);
377 return (rval);
381 * v_Replace -- [count]R
382 * Overwrite multiple characters.
384 * PUBLIC: int v_Replace __P((SCR *, VICMD *));
387 v_Replace(SCR *sp, VICMD *vp)
389 size_t len;
390 u_int32_t flags;
391 int isempty;
392 CHAR_T *p;
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)) {
398 if (!isempty)
399 return (1);
400 len = 0;
401 LF_SET(TXT_APPENDEOL);
402 } else {
403 if (len == 0)
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)
423 size_t len;
424 u_int32_t flags;
425 int isempty;
426 CHAR_T *p;
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)) {
432 if (!isempty)
433 return (1);
434 len = 0;
435 LF_SET(TXT_APPENDEOL);
436 } else {
437 if (len == 0)
438 LF_SET(TXT_APPENDEOL);
439 LF_SET(TXT_EMARK | TXT_OVERWRITE);
442 vp->m_stop.lno = vp->m_start.lno;
443 vp->m_stop.cno =
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))
451 return (1);
453 return (v_txt(sp, vp, &vp->m_stop, p, len, 0, OOBLNO, 1, flags));
457 * set_txt_std --
458 * Initialize text processing flags.
460 static u_int32_t
461 set_txt_std(SCR *sp, VICMD *vp, u_int32_t flags)
463 LF_SET(TXT_CNTRLT |
464 TXT_ESCAPE | TXT_MAPINPUT | TXT_RECORD | TXT_RESOLVE);
466 if (F_ISSET(vp, VC_ISDOT))
467 LF_SET(TXT_REPLAY);
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))
478 LF_SET(TXT_CR);
479 if (O_ISSET(sp, O_TTYWERASE))
480 LF_SET(TXT_TTYWERASE);
483 * !!!
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.
489 * aABC DEF <ESC>....
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.
507 * XXX
508 * Once I work my courage up, this is all gonna go away. It's too
509 * evil to survive.
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);
514 return (flags);