Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/vi/build/../common/put.c	Lines:	0	79	0.0 %
Date:	2017-11-07	Branches:	0	112	0.0 %


/*	$OpenBSD: put.c,v 1.16 2016/05/27 09:18:11 martijn Exp $	*/

/*-
 * Copyright (c) 1992, 1993, 1994
 *	The Regents of the University of California.  All rights reserved.
 * Copyright (c) 1992, 1993, 1994, 1995, 1996
 *	Keith Bostic.  All rights reserved.
 *
 * See the LICENSE file for redistribution information.
 */

#include "config.h"

#include <sys/types.h>
#include <sys/queue.h>

#include <bitstring.h>
#include <ctype.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "common.h"

/*
 * put --
 *	Put text buffer contents into the file.
 *
 * PUBLIC: int put(SCR *, CB *, CHAR_T *, MARK *, MARK *, int);
 */
int
put(SCR *sp, CB *cbp, CHAR_T *namep, MARK *cp, MARK *rp, int append)
{
	CHAR_T name;
	TEXT *ltp, *tp;
	recno_t lno;
	size_t blen, clen, len;
	int rval;
	char *bp, *p, *t;

	if (cbp == NULL) {
		if (namep == NULL) {
			cbp = sp->gp->dcbp;
			if (cbp == NULL) {
				msgq(sp, M_ERR,
				    "The default buffer is empty");
				return (1);
			}
		} else {
			name = *namep;
			CBNAME(sp, cbp, name);
			if (cbp == NULL) {
				msgq(sp, M_ERR, "Buffer %s is empty",
				    KEY_NAME(sp, name));
				return (1);
			}
		}
	}
	tp = TAILQ_FIRST(&cbp->textq);

	/*
	 * It's possible to do a put into an empty file, meaning that the cut
	 * buffer simply becomes the file.  It's a special case so that we can
	 * ignore it in general.
	 *
	 * !!!
	 * Historically, pasting into a file with no lines in vi would preserve
	 * the single blank line.  This is surely a result of the fact that the
	 * historic vi couldn't deal with a file that had no lines in it.  This
	 * implementation treats that as a bug, and does not retain the blank
	 * line.
	 *
	 * Historical practice is that the cursor ends at the first character
	 * in the file.
	 */
	if (cp->lno == 1) {
		if (db_last(sp, &lno))
			return (1);
		if (lno == 0) {
			for (; tp; ++lno, ++sp->rptlines[L_ADDED],
			    tp = TAILQ_NEXT(tp, q))
				if (db_append(sp, 1, lno, tp->lb, tp->len))
					return (1);
			rp->lno = 1;
			rp->cno = 0;
			return (0);
		}
	}

	/* If a line mode buffer, append each new line into the file. */
	if (F_ISSET(cbp, CB_LMODE)) {
		lno = append ? cp->lno : cp->lno - 1;
		rp->lno = lno + 1;
		for (; tp;
		    ++lno, ++sp->rptlines[L_ADDED], tp = TAILQ_NEXT(tp, q))
			if (db_append(sp, 1, lno, tp->lb, tp->len))
				return (1);
		rp->cno = 0;
		(void)nonblank(sp, rp->lno, &rp->cno);
		return (0);
	}

	/*
	 * If buffer was cut in character mode, replace the current line with
	 * one built from the portion of the first line to the left of the
	 * split plus the first line in the CB.  Append each intermediate line
	 * in the CB.  Append a line built from the portion of the first line
	 * to the right of the split plus the last line in the CB.
	 *
	 * Get the first line.
	 */
	lno = cp->lno;
	if (db_get(sp, lno, DBG_FATAL, &p, &len))
		return (1);

	GET_SPACE_RET(sp, bp, blen, tp->len + len + 1);
	t = bp;

	/* Original line, left of the split. */
	if (len > 0 && (clen = cp->cno + (append ? 1 : 0)) > 0) {
		memcpy(bp, p, clen);
		p += clen;
		t += clen;
	}

	/* First line from the CB. */
	if (tp->len != 0) {
		memcpy(t, tp->lb, tp->len);
		t += tp->len;
	}

	/* Calculate length left in the original line. */
	clen = len == 0 ? 0 : len - (cp->cno + (append ? 1 : 0));

	/*
	 * !!!
	 * In the historical 4BSD version of vi, character mode puts within
	 * a single line have two cursor behaviors: if the put is from the
	 * unnamed buffer, the cursor moves to the character inserted which
	 * appears last in the file.  If the put is from a named buffer,
	 * the cursor moves to the character inserted which appears first
	 * in the file.  In System III/V, it was changed at some point and
	 * the cursor always moves to the first character.  In both versions
	 * of vi, character mode puts that cross line boundaries leave the
	 * cursor on the first character.  Nvi implements the System III/V
	 * behavior, and expect POSIX.2 to do so as well.
	 */
	rp->lno = lno;
	rp->cno = len == 0 ? 0 : sp->cno + (append && tp->len ? 1 : 0);

	/*
	 * If no more lines in the CB, append the rest of the original
	 * line and quit.  Otherwise, build the last line before doing
	 * the intermediate lines, because the line changes will lose
	 * the cached line.
	 */
	if (TAILQ_NEXT(tp, q) == NULL) {
		if (clen > 0) {
			memcpy(t, p, clen);
			t += clen;
		}
		if (db_set(sp, lno, bp, t - bp))
			goto err;
		if (sp->rptlchange != lno) {
			sp->rptlchange = lno;
			++sp->rptlines[L_CHANGED];
		}
	} else {
		/*
		 * Have to build both the first and last lines of the
		 * put before doing any sets or we'll lose the cached
		 * line.  Build both the first and last lines in the
		 * same buffer, so we don't have to have another buffer
		 * floating around.
		 *
		 * Last part of original line; check for space, reset
		 * the pointer into the buffer.
		 */
		ltp = TAILQ_LAST(&cbp->textq, _texth);
		len = t - bp;
		ADD_SPACE_RET(sp, bp, blen, ltp->len + clen);
		t = bp + len;

		/* Add in last part of the CB. */
		memcpy(t, ltp->lb, ltp->len);
		if (clen)
			memcpy(t + ltp->len, p, clen);
		clen += ltp->len;

		/*
		 * Now: bp points to the first character of the first
		 * line, t points to the last character of the last
		 * line, t - bp is the length of the first line, and
		 * clen is the length of the last.  Just figured you'd
		 * want to know.
		 *
		 * Output the line replacing the original line.
		 */
		if (db_set(sp, lno, bp, t - bp))
			goto err;
		if (sp->rptlchange != lno) {
			sp->rptlchange = lno;
			++sp->rptlines[L_CHANGED];
		}

		/* Output any intermediate lines in the CB. */
		for (tp = TAILQ_NEXT(tp, q); TAILQ_NEXT(tp, q);
		    ++lno, ++sp->rptlines[L_ADDED], tp = TAILQ_NEXT(tp, q))
			if (db_append(sp, 1, lno, tp->lb, tp->len))
				goto err;

		if (db_append(sp, 1, lno, t, clen))
			goto err;
		++sp->rptlines[L_ADDED];
	}
	rval = 0;

	if (0)
err:		rval = 1;

	FREE_SPACE(sp, bp, blen);
	return (rval);
}


Generated by: GCOVR (Version 3.3)

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