Head

GCC Code Coverage Report

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


/*	$OpenBSD: mark.c,v 1.14 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 <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "common.h"

static LMARK *mark_find(SCR *, CHAR_T);

/*
 * Marks are maintained in a key sorted doubly linked list.  We can't
 * use arrays because we have no idea how big an index key could be.
 * The underlying assumption is that users don't have more than, say,
 * 10 marks at any one time, so this will be is fast enough.
 *
 * Marks are fixed, and modifications to the line don't update the mark's
 * position in the line.  This can be hard.  If you add text to the line,
 * place a mark in that text, undo the addition and use ` to move to the
 * mark, the location will have disappeared.  It's tempting to try to adjust
 * the mark with the changes in the line, but this is hard to do, especially
 * if we've given the line to v_ntext.c:v_ntext() for editing.  Historic vi
 * would move to the first non-blank on the line when the mark location was
 * past the end of the line.  This can be complicated by deleting to a mark
 * that has disappeared using the ` command.  Historic vi treated this as
 * a line-mode motion and deleted the line.  This implementation complains to
 * the user.
 *
 * In historic vi, marks returned if the operation was undone, unless the
 * mark had been subsequently reset.  Tricky.  This is hard to start with,
 * but in the presence of repeated undo it gets nasty.  When a line is
 * deleted, we delete (and log) any marks on that line.  An undo will create
 * the mark.  Any mark creations are noted as to whether the user created
 * it or if it was created by an undo.  The former cannot be reset by another
 * undo, but the latter may.
 *
 * All of these routines translate ABSMARK2 to ABSMARK1.  Setting either of
 * the absolute mark locations sets both, so that "m'" and "m`" work like
 * they, ah, for lack of a better word, "should".
 */

/*
 * mark_init --
 *	Set up the marks.
 *
 * PUBLIC: int mark_init(SCR *, EXF *);
 */
int
mark_init(SCR *sp, EXF *ep)
{
	/*
	 * !!!
	 * ep MAY NOT BE THE SAME AS sp->ep, DON'T USE THE LATTER.
	 *
	 * Set up the marks.
	 */
	LIST_INIT(&ep->marks);
	return (0);
}

/*
 * mark_end --
 *	Free up the marks.
 *
 * PUBLIC: int mark_end(SCR *, EXF *);
 */
int
mark_end(SCR *sp, EXF *ep)
{
	LMARK *lmp;

	/*
	 * !!!
	 * ep MAY NOT BE THE SAME AS sp->ep, DON'T USE THE LATTER.
	 */
	while ((lmp = LIST_FIRST(&ep->marks)) != NULL) {
		LIST_REMOVE(lmp, q);
		free(lmp);
	}
	return (0);
}

/*
 * mark_get --
 *	Get the location referenced by a mark.
 *
 * PUBLIC: int mark_get(SCR *, CHAR_T, MARK *, mtype_t);
 */
int
mark_get(SCR *sp, CHAR_T key, MARK *mp, mtype_t mtype)
{
	LMARK *lmp;

	if (key == ABSMARK2)
		key = ABSMARK1;

	lmp = mark_find(sp, key);
	if (lmp == NULL || lmp->name != key) {
		msgq(sp, mtype, "Mark %s: not set", KEY_NAME(sp, key));
                return (1);
	}
	if (F_ISSET(lmp, MARK_DELETED)) {
		msgq(sp, mtype,
		    "Mark %s: the line was deleted", KEY_NAME(sp, key));
                return (1);
	}

	/*
	 * !!!
	 * The absolute mark is initialized to lno 1/cno 0, and historically
	 * you could use it in an empty file.  Make such a mark always work.
	 */
	if ((lmp->lno != 1 || lmp->cno != 0) && !db_exist(sp, lmp->lno)) {
		msgq(sp, mtype,
		    "Mark %s: cursor position no longer exists",
		    KEY_NAME(sp, key));
		return (1);
	}
	mp->lno = lmp->lno;
	mp->cno = lmp->cno;
	return (0);
}

/*
 * mark_set --
 *	Set the location referenced by a mark.
 *
 * PUBLIC: int mark_set(SCR *, CHAR_T, MARK *, int);
 */
int
mark_set(SCR *sp, CHAR_T key, MARK *value, int userset)
{
	LMARK *lmp, *lmt;

	if (key == ABSMARK2)
		key = ABSMARK1;

	/*
	 * The rules are simple.  If the user is setting a mark (if it's a
	 * new mark this is always true), it always happens.  If not, it's
	 * an undo, and we set it if it's not already set or if it was set
	 * by a previous undo.
	 */
	lmp = mark_find(sp, key);
	if (lmp == NULL || lmp->name != key) {
		MALLOC_RET(sp, lmt, sizeof(LMARK));
		if (lmp == NULL) {
			LIST_INSERT_HEAD(&sp->ep->marks, lmt, q);
		} else
			LIST_INSERT_AFTER(lmp, lmt, q);
		lmp = lmt;
	} else if (!userset &&
	    !F_ISSET(lmp, MARK_DELETED) && F_ISSET(lmp, MARK_USERSET))
		return (0);

	lmp->lno = value->lno;
	lmp->cno = value->cno;
	lmp->name = key;
	lmp->flags = userset ? MARK_USERSET : 0;
	return (0);
}

/*
 * mark_find --
 *	Find the requested mark, or, the slot immediately before
 *	where it would go.
 */
static LMARK *
mark_find(SCR *sp, CHAR_T key)
{
	LMARK *lmp, *lastlmp;

	/*
	 * Return the requested mark or the slot immediately before
	 * where it should go.
	 */
	for (lastlmp = NULL, lmp = LIST_FIRST(&sp->ep->marks);
	    lmp != NULL; lastlmp = lmp, lmp = LIST_NEXT(lmp, q))
		if (lmp->name >= key)
			return (lmp->name == key ? lmp : lastlmp);
	return (lastlmp);
}

/*
 * mark_insdel --
 *	Update the marks based on an insertion or deletion.
 *
 * PUBLIC: int mark_insdel(SCR *, lnop_t, recno_t);
 */
int
mark_insdel(SCR *sp, lnop_t op, recno_t lno)
{
	LMARK *lmp;
	recno_t lline;

	switch (op) {
	case LINE_APPEND:
		/* All insert/append operations are done as inserts. */
		abort();
	case LINE_DELETE:
		LIST_FOREACH(lmp, &sp->ep->marks, q)
			if (lmp->lno >= lno) {
				if (lmp->lno == lno) {
					F_SET(lmp, MARK_DELETED);
					(void)log_mark(sp, lmp);
				} else
					--lmp->lno;
			}
		break;
	case LINE_INSERT:
		/*
		 * XXX
		 * Very nasty special case.  If the file was empty, then we're
		 * adding the first line, which is a replacement.  So, we don't
		 * modify the marks.  This is a hack to make:
		 *
		 *	mz:r!echo foo<carriage-return>'z
		 *
		 * work, i.e. historically you could mark the "line" in an empty
		 * file and replace it, and continue to use the mark.  Insane,
		 * well, yes, I know, but someone complained.
		 *
		 * Check for line #2 before going to the end of the file.
		 */
		if (!db_exist(sp, 2)) {
			if (db_last(sp, &lline))
				return (1);
			if (lline == 1)
				return (0);
		}

		LIST_FOREACH(lmp, &sp->ep->marks, q)
			if (lmp->lno >= lno)
				++lmp->lno;
		break;
	case LINE_RESET:
		break;
	}
	return (0);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: mark.c,v 1.14 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 <errno.h>
19			#include <limits.h>
20			#include <stdio.h>
21			#include <stdlib.h>
22			#include <string.h>
23
24			#include "common.h"
25
26			static LMARK mark_find(SCR , CHAR_T);
27
28			/*
29			* Marks are maintained in a key sorted doubly linked list. We can't
30			* use arrays because we have no idea how big an index key could be.
31			* The underlying assumption is that users don't have more than, say,
32			* 10 marks at any one time, so this will be is fast enough.
33			*
34			* Marks are fixed, and modifications to the line don't update the mark's
35			* position in the line. This can be hard. If you add text to the line,
36			* place a mark in that text, undo the addition and use ` to move to the
37			* mark, the location will have disappeared. It's tempting to try to adjust
38			* the mark with the changes in the line, but this is hard to do, especially
39			* if we've given the line to v_ntext.c:v_ntext() for editing. Historic vi
40			* would move to the first non-blank on the line when the mark location was
41			* past the end of the line. This can be complicated by deleting to a mark
42			* that has disappeared using the ` command. Historic vi treated this as
43			* a line-mode motion and deleted the line. This implementation complains to
44			* the user.
45			*
46			* In historic vi, marks returned if the operation was undone, unless the
47			* mark had been subsequently reset. Tricky. This is hard to start with,
48			* but in the presence of repeated undo it gets nasty. When a line is
49			* deleted, we delete (and log) any marks on that line. An undo will create
50			* the mark. Any mark creations are noted as to whether the user created
51			* it or if it was created by an undo. The former cannot be reset by another
52			* undo, but the latter may.
53			*
54			* All of these routines translate ABSMARK2 to ABSMARK1. Setting either of
55			* the absolute mark locations sets both, so that "m'" and "m`" work like
56			* they, ah, for lack of a better word, "should".
57			*/
58
59			/*
60			* mark_init --
61			* Set up the marks.
62			*
63			* PUBLIC: int mark_init(SCR , EXF );
64			*/
65			int
66			mark_init(SCR sp, EXF ep)
67			{
68			/*
69			* !!!
70			* ep MAY NOT BE THE SAME AS sp->ep, DON'T USE THE LATTER.
71			*
72			* Set up the marks.
73			*/
74			LIST_INIT(&ep->marks);
75			return (0);
76			}
77
78			/*
79			* mark_end --
80			* Free up the marks.
81			*
82			* PUBLIC: int mark_end(SCR , EXF );
83			*/
84			int
85			mark_end(SCR sp, EXF ep)
86			{
87			LMARK *lmp;
88
89			/*
90			* !!!
91			* ep MAY NOT BE THE SAME AS sp->ep, DON'T USE THE LATTER.
92			*/
93			while ((lmp = LIST_FIRST(&ep->marks)) != NULL) {
94			LIST_REMOVE(lmp, q);
95			free(lmp);
96			}
97			return (0);
98			}
99
100			/*
101			* mark_get --
102			* Get the location referenced by a mark.
103			*
104			* PUBLIC: int mark_get(SCR , CHAR_T, MARK , mtype_t);
105			*/
106			int
107			mark_get(SCR sp, CHAR_T key, MARK mp, mtype_t mtype)
108			{
109			LMARK *lmp;
110
111			if (key == ABSMARK2)
112			key = ABSMARK1;
113
114			lmp = mark_find(sp, key);
115			if (lmp == NULL \|\| lmp->name != key) {
116			msgq(sp, mtype, "Mark %s: not set", KEY_NAME(sp, key));
117			return (1);
118			}
119			if (F_ISSET(lmp, MARK_DELETED)) {
120			msgq(sp, mtype,
121			"Mark %s: the line was deleted", KEY_NAME(sp, key));
122			return (1);
123			}
124
125			/*
126			* !!!
127			* The absolute mark is initialized to lno 1/cno 0, and historically
128			* you could use it in an empty file. Make such a mark always work.
129			*/
130			if ((lmp->lno != 1 \|\| lmp->cno != 0) && !db_exist(sp, lmp->lno)) {
131			msgq(sp, mtype,
132			"Mark %s: cursor position no longer exists",
133			KEY_NAME(sp, key));
134			return (1);
135			}
136			mp->lno = lmp->lno;
137			mp->cno = lmp->cno;
138			return (0);
139			}
140
141			/*
142			* mark_set --
143			* Set the location referenced by a mark.
144			*
145			* PUBLIC: int mark_set(SCR , CHAR_T, MARK , int);
146			*/
147			int
148			mark_set(SCR sp, CHAR_T key, MARK value, int userset)
149			{
150			LMARK lmp, lmt;
151
152			if (key == ABSMARK2)
153			key = ABSMARK1;
154
155			/*
156			* The rules are simple. If the user is setting a mark (if it's a
157			* new mark this is always true), it always happens. If not, it's
158			* an undo, and we set it if it's not already set or if it was set
159			* by a previous undo.
160			*/
161			lmp = mark_find(sp, key);
162			if (lmp == NULL \|\| lmp->name != key) {
163			MALLOC_RET(sp, lmt, sizeof(LMARK));
164			if (lmp == NULL) {
165			LIST_INSERT_HEAD(&sp->ep->marks, lmt, q);
166			} else
167			LIST_INSERT_AFTER(lmp, lmt, q);
168			lmp = lmt;
169			} else if (!userset &&
170			!F_ISSET(lmp, MARK_DELETED) && F_ISSET(lmp, MARK_USERSET))
171			return (0);
172
173			lmp->lno = value->lno;
174			lmp->cno = value->cno;
175			lmp->name = key;
176			lmp->flags = userset ? MARK_USERSET : 0;
177			return (0);
178			}
179
180			/*
181			* mark_find --
182			* Find the requested mark, or, the slot immediately before
183			* where it would go.
184			*/
185			static LMARK *
186			mark_find(SCR *sp, CHAR_T key)
187			{
188			LMARK lmp, lastlmp;
189
190			/*
191			* Return the requested mark or the slot immediately before
192			* where it should go.
193			*/
194			for (lastlmp = NULL, lmp = LIST_FIRST(&sp->ep->marks);
195			lmp != NULL; lastlmp = lmp, lmp = LIST_NEXT(lmp, q))
196			if (lmp->name >= key)
197			return (lmp->name == key ? lmp : lastlmp);
198			return (lastlmp);
199			}
200
201			/*
202			* mark_insdel --
203			* Update the marks based on an insertion or deletion.
204			*
205			* PUBLIC: int mark_insdel(SCR *, lnop_t, recno_t);
206			*/
207			int
208			mark_insdel(SCR *sp, lnop_t op, recno_t lno)
209			{
210			LMARK *lmp;
211			recno_t lline;
212
213			switch (op) {
214			case LINE_APPEND:
215			/* All insert/append operations are done as inserts. */
216			abort();
217			case LINE_DELETE:
218			LIST_FOREACH(lmp, &sp->ep->marks, q)
219			if (lmp->lno >= lno) {
220			if (lmp->lno == lno) {
221			F_SET(lmp, MARK_DELETED);
222			(void)log_mark(sp, lmp);
223			} else
224			--lmp->lno;
225			}
226			break;
227			case LINE_INSERT:
228			/*
229			* XXX
230			* Very nasty special case. If the file was empty, then we're
231			* adding the first line, which is a replacement. So, we don't
232			* modify the marks. This is a hack to make:
233			*
234			* mz:r!echo foo<carriage-return>'z
235			*
236			* work, i.e. historically you could mark the "line" in an empty
237			* file and replace it, and continue to use the mark. Insane,
238			* well, yes, I know, but someone complained.
239			*
240			* Check for line #2 before going to the end of the file.
241			*/
242			if (!db_exist(sp, 2)) {
243			if (db_last(sp, &lline))
244			return (1);
245			if (lline == 1)
246			return (0);
247			}
248
249			LIST_FOREACH(lmp, &sp->ep->marks, q)
250			if (lmp->lno >= lno)
251			++lmp->lno;
252			break;
253			case LINE_RESET:
254			break;
255			}
256			return (0);
257			}