xref: /freebsd/contrib/nvi/common/put.c (revision 1e413cf93298b5b97441a21d9a50fdcd0ee9945e)
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.
6  *
7  * See the LICENSE file for redistribution information.
8  */
9 
10 #include "config.h"
11 
12 #ifndef lint
13 static const char sccsid[] = "@(#)put.c	10.11 (Berkeley) 9/23/96";
14 #endif /* not lint */
15 
16 #include <sys/types.h>
17 #include <sys/queue.h>
18 
19 #include <bitstring.h>
20 #include <ctype.h>
21 #include <limits.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 
26 #include "common.h"
27 
28 /*
29  * put --
30  *	Put text buffer contents into the file.
31  *
32  * PUBLIC: int put __P((SCR *, CB *, CHAR_T *, MARK *, MARK *, int));
33  */
34 int
35 put(sp, cbp, namep, cp, rp, append)
36 	SCR *sp;
37 	CB *cbp;
38 	CHAR_T *namep;
39 	MARK *cp, *rp;
40 	int append;
41 {
42 	CHAR_T name;
43 	TEXT *ltp, *tp;
44 	recno_t lno;
45 	size_t blen, clen, len;
46 	int rval;
47 	char *bp, *p, *t;
48 
49 	if (cbp == NULL)
50 		if (namep == NULL) {
51 			cbp = sp->gp->dcbp;
52 			if (cbp == NULL) {
53 				msgq(sp, M_ERR,
54 				    "053|The default buffer is empty");
55 				return (1);
56 			}
57 		} else {
58 			name = *namep;
59 			CBNAME(sp, cbp, name);
60 			if (cbp == NULL) {
61 				msgq(sp, M_ERR, "054|Buffer %s is empty",
62 				    KEY_NAME(sp, name));
63 				return (1);
64 			}
65 		}
66 	tp = cbp->textq.cqh_first;
67 
68 	/*
69 	 * It's possible to do a put into an empty file, meaning that the cut
70 	 * buffer simply becomes the file.  It's a special case so that we can
71 	 * ignore it in general.
72 	 *
73 	 * !!!
74 	 * Historically, pasting into a file with no lines in vi would preserve
75 	 * the single blank line.  This is surely a result of the fact that the
76 	 * historic vi couldn't deal with a file that had no lines in it.  This
77 	 * implementation treats that as a bug, and does not retain the blank
78 	 * line.
79 	 *
80 	 * Historical practice is that the cursor ends at the first character
81 	 * in the file.
82 	 */
83 	if (cp->lno == 1) {
84 		if (db_last(sp, &lno))
85 			return (1);
86 		if (lno == 0) {
87 			for (; tp != (void *)&cbp->textq;
88 			    ++lno, ++sp->rptlines[L_ADDED], tp = tp->q.cqe_next)
89 				if (db_append(sp, 1, lno, tp->lb, tp->len))
90 					return (1);
91 			rp->lno = 1;
92 			rp->cno = 0;
93 			return (0);
94 		}
95 	}
96 
97 	/* If a line mode buffer, append each new line into the file. */
98 	if (F_ISSET(cbp, CB_LMODE)) {
99 		lno = append ? cp->lno : cp->lno - 1;
100 		rp->lno = lno + 1;
101 		for (; tp != (void *)&cbp->textq;
102 		    ++lno, ++sp->rptlines[L_ADDED], tp = tp->q.cqe_next)
103 			if (db_append(sp, 1, lno, tp->lb, tp->len))
104 				return (1);
105 		rp->cno = 0;
106 		(void)nonblank(sp, rp->lno, &rp->cno);
107 		return (0);
108 	}
109 
110 	/*
111 	 * If buffer was cut in character mode, replace the current line with
112 	 * one built from the portion of the first line to the left of the
113 	 * split plus the first line in the CB.  Append each intermediate line
114 	 * in the CB.  Append a line built from the portion of the first line
115 	 * to the right of the split plus the last line in the CB.
116 	 *
117 	 * Get the first line.
118 	 */
119 	lno = cp->lno;
120 	if (db_get(sp, lno, DBG_FATAL, &p, &len))
121 		return (1);
122 
123 	GET_SPACE_RET(sp, bp, blen, tp->len + len + 1);
124 	t = bp;
125 
126 	/* Original line, left of the split. */
127 	if (len > 0 && (clen = cp->cno + (append ? 1 : 0)) > 0) {
128 		memcpy(bp, p, clen);
129 		p += clen;
130 		t += clen;
131 	}
132 
133 	/* First line from the CB. */
134 	if (tp->len != 0) {
135 		memcpy(t, tp->lb, tp->len);
136 		t += tp->len;
137 	}
138 
139 	/* Calculate length left in the original line. */
140 	clen = len == 0 ? 0 : len - (cp->cno + (append ? 1 : 0));
141 
142 	/*
143 	 * !!!
144 	 * In the historical 4BSD version of vi, character mode puts within
145 	 * a single line have two cursor behaviors: if the put is from the
146 	 * unnamed buffer, the cursor moves to the character inserted which
147 	 * appears last in the file.  If the put is from a named buffer,
148 	 * the cursor moves to the character inserted which appears first
149 	 * in the file.  In System III/V, it was changed at some point and
150 	 * the cursor always moves to the first character.  In both versions
151 	 * of vi, character mode puts that cross line boundaries leave the
152 	 * cursor on the first character.  Nvi implements the System III/V
153 	 * behavior, and expect POSIX.2 to do so as well.
154 	 */
155 	rp->lno = lno;
156 	rp->cno = len == 0 ? 0 : sp->cno + (append && tp->len ? 1 : 0);
157 
158 	/*
159 	 * If no more lines in the CB, append the rest of the original
160 	 * line and quit.  Otherwise, build the last line before doing
161 	 * the intermediate lines, because the line changes will lose
162 	 * the cached line.
163 	 */
164 	if (tp->q.cqe_next == (void *)&cbp->textq) {
165 		if (clen > 0) {
166 			memcpy(t, p, clen);
167 			t += clen;
168 		}
169 		if (db_set(sp, lno, bp, t - bp))
170 			goto err;
171 		if (sp->rptlchange != lno) {
172 			sp->rptlchange = lno;
173 			++sp->rptlines[L_CHANGED];
174 		}
175 	} else {
176 		/*
177 		 * Have to build both the first and last lines of the
178 		 * put before doing any sets or we'll lose the cached
179 		 * line.  Build both the first and last lines in the
180 		 * same buffer, so we don't have to have another buffer
181 		 * floating around.
182 		 *
183 		 * Last part of original line; check for space, reset
184 		 * the pointer into the buffer.
185 		 */
186 		ltp = cbp->textq.cqh_last;
187 		len = t - bp;
188 		ADD_SPACE_RET(sp, bp, blen, ltp->len + clen);
189 		t = bp + len;
190 
191 		/* Add in last part of the CB. */
192 		memcpy(t, ltp->lb, ltp->len);
193 		if (clen)
194 			memcpy(t + ltp->len, p, clen);
195 		clen += ltp->len;
196 
197 		/*
198 		 * Now: bp points to the first character of the first
199 		 * line, t points to the last character of the last
200 		 * line, t - bp is the length of the first line, and
201 		 * clen is the length of the last.  Just figured you'd
202 		 * want to know.
203 		 *
204 		 * Output the line replacing the original line.
205 		 */
206 		if (db_set(sp, lno, bp, t - bp))
207 			goto err;
208 		if (sp->rptlchange != lno) {
209 			sp->rptlchange = lno;
210 			++sp->rptlines[L_CHANGED];
211 		}
212 
213 		/* Output any intermediate lines in the CB. */
214 		for (tp = tp->q.cqe_next;
215 		    tp->q.cqe_next != (void *)&cbp->textq;
216 		    ++lno, ++sp->rptlines[L_ADDED], tp = tp->q.cqe_next)
217 			if (db_append(sp, 1, lno, tp->lb, tp->len))
218 				goto err;
219 
220 		if (db_append(sp, 1, lno, t, clen))
221 			goto err;
222 		++sp->rptlines[L_ADDED];
223 	}
224 	rval = 0;
225 
226 	if (0)
227 err:		rval = 1;
228 
229 	FREE_SPACE(sp, bp, blen);
230 	return (rval);
231 }
232