Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/vi/build/../ex/ex_global.c	Lines:	0	111	0.0 %
Date:	2017-11-07	Branches:	0	105	0.0 %


/*	$OpenBSD: ex_global.c,v 1.17 2016/05/27 09:18:12 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 <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "../common/common.h"

enum which {GLOBAL, V};

static int ex_g_setup(SCR *, EXCMD *, enum which);

/*
 * ex_global -- [line [,line]] g[lobal][!] /pattern/ [commands]
 *	Exec on lines matching a pattern.
 *
 * PUBLIC: int ex_global(SCR *, EXCMD *);
 */
int
ex_global(SCR *sp, EXCMD *cmdp)
{
	return (ex_g_setup(sp,
	    cmdp, FL_ISSET(cmdp->iflags, E_C_FORCE) ? V : GLOBAL));
}

/*
 * ex_v -- [line [,line]] v /pattern/ [commands]
 *	Exec on lines not matching a pattern.
 *
 * PUBLIC: int ex_v(SCR *, EXCMD *);
 */
int
ex_v(SCR *sp, EXCMD *cmdp)
{
	return (ex_g_setup(sp, cmdp, V));
}

/*
 * ex_g_setup --
 *	Ex global and v commands.
 */
static int
ex_g_setup(SCR *sp, EXCMD *cmdp, enum which cmd)
{
	CHAR_T *ptrn, *p, *t;
	EXCMD *ecp;
	MARK abs_mark;
	RANGE *rp;
	busy_t btype;
	recno_t start, end;
	regex_t *re;
	regmatch_t match[1];
	size_t len;
	int cnt, delim, eval;
	char *dbp;

	NEEDFILE(sp, cmdp);

	if (F_ISSET(sp, SC_EX_GLOBAL)) {
		msgq(sp, M_ERR,
	"The %s command can't be used as part of a global or v command",
		    cmdp->cmd->name);
		return (1);
	}

	/*
	 * Skip leading white space.  Historic vi allowed any non-alphanumeric
	 * to serve as the global command delimiter.
	 */
	if (cmdp->argc == 0)
		goto usage;
	for (p = cmdp->argv[0]->bp; isblank(*p); ++p);
	if (*p == '\0' || isalnum(*p) ||
	    *p == '\\' || *p == '|' || *p == '\n') {
usage:		ex_emsg(sp, cmdp->cmd->usage, EXM_USAGE);
		return (1);
	}
	delim = *p++;

	/*
	 * Get the pattern string, toss escaped characters.
	 *
	 * QUOTING NOTE:
	 * Only toss an escaped character if it escapes a delimiter.
	 */
	for (ptrn = t = p;;) {
		if (p[0] == '\0' || p[0] == delim) {
			if (p[0] == delim)
				++p;
			/*
			 * !!!
			 * Nul terminate the pattern string -- it's passed
			 * to regcomp which doesn't understand anything else.
			 */
			*t = '\0';
			break;
		}
		if (p[0] == '\\') {
			if (p[1] == delim)
				++p;
			else if (p[1] == '\\')
				*t++ = *p++;
		}
		*t++ = *p++;
	}

	/* If the pattern string is empty, use the last one. */
	if (*ptrn == '\0') {
		if (sp->re == NULL) {
			ex_emsg(sp, NULL, EXM_NOPREVRE);
			return (1);
		}

		/* Re-compile the RE if necessary. */
		if (!F_ISSET(sp, SC_RE_SEARCH) && re_compile(sp,
		    sp->re, sp->re_len, NULL, NULL, &sp->re_c, RE_C_SEARCH))
			return (1);
	} else {
		/* Compile the RE. */
		if (re_compile(sp, ptrn, t - ptrn,
		    &sp->re, &sp->re_len, &sp->re_c, RE_C_SEARCH))
			return (1);

		/*
		 * Set saved RE.  Historic practice is that globals set
		 * direction as well as the RE.
		 */
		sp->searchdir = FORWARD;
	}
	re = &sp->re_c;

	/* The global commands always set the previous context mark. */
	abs_mark.lno = sp->lno;
	abs_mark.cno = sp->cno;
	if (mark_set(sp, ABSMARK1, &abs_mark, 1))
		return (1);

	/* Get an EXCMD structure. */
	CALLOC_RET(sp, ecp, 1, sizeof(EXCMD));
	TAILQ_INIT(&ecp->rq);

	/*
	 * Get a copy of the command string; the default command is print.
	 * Don't worry about a set of <blank>s with no command, that will
	 * default to print in the ex parser.  We need to have two copies
	 * because the ex parser may step on the command string when it's
	 * parsing it.
	 */
	if ((len = cmdp->argv[0]->len - (p - cmdp->argv[0]->bp)) == 0) {
		p = "pp";
		len = 1;
	}

	MALLOC_RET(sp, ecp->cp, len * 2);
	ecp->o_cp = ecp->cp;
	ecp->o_clen = len;
	memcpy(ecp->cp + len, p, len);
	ecp->range_lno = OOBLNO;
	FL_SET(ecp->agv_flags, cmd == GLOBAL ? AGV_GLOBAL : AGV_V);
	LIST_INSERT_HEAD(&sp->gp->ecq, ecp, q);

	/*
	 * For each line...  The semantics of global matching are that we first
	 * have to decide which lines are going to get passed to the command,
	 * and then pass them to the command, ignoring other changes.  There's
	 * really no way to do this in a single pass, since arbitrary line
	 * creation, deletion and movement can be done in the ex command.  For
	 * example, a good vi clone test is ":g/X/mo.-3", or "g/X/.,.+1d".
	 * What we do is create linked list of lines that are tracked through
	 * each ex command.  There's a callback routine which the DB interface
	 * routines call when a line is created or deleted.  This doesn't help
	 * the layering much.
	 */
	btype = BUSY_ON;
	cnt = INTERRUPT_CHECK;
	for (start = cmdp->addr1.lno,
	    end = cmdp->addr2.lno; start <= end; ++start) {
		if (cnt-- == 0) {
			if (INTERRUPTED(sp)) {
				LIST_REMOVE(ecp, q);
				free(ecp->cp);
				free(ecp);
				break;
			}
			search_busy(sp, btype);
			btype = BUSY_UPDATE;
			cnt = INTERRUPT_CHECK;
		}
		if (db_get(sp, start, DBG_FATAL, &dbp, &len))
			return (1);
		match[0].rm_so = 0;
		match[0].rm_eo = len;
		switch (eval =
		    regexec(&sp->re_c, dbp, 0, match, REG_STARTEND)) {
		case 0:
			if (cmd == V)
				continue;
			break;
		case REG_NOMATCH:
			if (cmd == GLOBAL)
				continue;
			break;
		default:
			re_error(sp, eval, &sp->re_c);
			break;
		}

		/* If follows the last entry, extend the last entry's range. */
		if ((rp = TAILQ_LAST(&ecp->rq, _rh)) && rp->stop == start - 1) {
			++rp->stop;
			continue;
		}

		/* Allocate a new range, and append it to the list. */
		CALLOC(sp, rp, 1, sizeof(RANGE));
		if (rp == NULL)
			return (1);
		rp->start = rp->stop = start;
		TAILQ_INSERT_TAIL(&ecp->rq, rp, q);
	}
	search_busy(sp, BUSY_OFF);
	return (0);
}

/*
 * ex_g_insdel --
 *	Update the ranges based on an insertion or deletion.
 *
 * PUBLIC: int ex_g_insdel(SCR *, lnop_t, recno_t);
 */
int
ex_g_insdel(SCR *sp, lnop_t op, recno_t lno)
{
	EXCMD *ecp;
	RANGE *nrp, *rp;

	/* All insert/append operations are done as inserts. */
	if (op == LINE_APPEND)
		abort();

	if (op == LINE_RESET)
		return (0);

	LIST_FOREACH(ecp, &sp->gp->ecq, q) {
		if (!FL_ISSET(ecp->agv_flags, AGV_AT | AGV_GLOBAL | AGV_V))
			continue;
		for (rp = TAILQ_FIRST(&ecp->rq); rp != NULL; rp = nrp) {
			nrp = TAILQ_NEXT(rp, q);

			/* If range less than the line, ignore it. */
			if (rp->stop < lno)
				continue;

			/*
			 * If range greater than the line, decrement or
			 * increment the range.
			 */
			if (rp->start > lno) {
				if (op == LINE_DELETE) {
					--rp->start;
					--rp->stop;
				} else {
					++rp->start;
					++rp->stop;
				}
				continue;
			}

			/*
			 * Lno is inside the range, decrement the end point
			 * for deletion, and split the range for insertion.
			 * In the latter case, since we're inserting a new
			 * element, neither range can be exhausted.
			 */
			if (op == LINE_DELETE) {
				if (rp->start > --rp->stop) {
					TAILQ_REMOVE(&ecp->rq, rp, q);
					free(rp);
				}
			} else {
				CALLOC_RET(sp, nrp, 1, sizeof(RANGE));
				nrp->start = lno + 1;
				nrp->stop = rp->stop + 1;
				rp->stop = lno - 1;
				TAILQ_INSERT_AFTER(&ecp->rq, rp, nrp, q);
				rp = nrp;
			}
		}

		/*
		 * If the command deleted/inserted lines, the cursor moves to
		 * the line after the deleted/inserted line.
		 */
		ecp->range_lno = lno;
	}
	return (0);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: ex_global.c,v 1.17 2016/05/27 09:18:12 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 <errno.h>
20			#include <limits.h>
21			#include <stdio.h>
22			#include <stdlib.h>
23			#include <string.h>
24			#include <unistd.h>
25
26			#include "../common/common.h"
27
28			enum which {GLOBAL, V};
29
30			static int ex_g_setup(SCR , EXCMD , enum which);
31
32			/*
33			* ex_global -- [line [,line]] g[lobal][!] /pattern/ [commands]
34			* Exec on lines matching a pattern.
35			*
36			* PUBLIC: int ex_global(SCR , EXCMD );
37			*/
38			int
39			ex_global(SCR sp, EXCMD cmdp)
40			{
41			return (ex_g_setup(sp,
42			cmdp, FL_ISSET(cmdp->iflags, E_C_FORCE) ? V : GLOBAL));
43			}
44
45			/*
46			* ex_v -- [line [,line]] v /pattern/ [commands]
47			* Exec on lines not matching a pattern.
48			*
49			* PUBLIC: int ex_v(SCR , EXCMD );
50			*/
51			int
52			ex_v(SCR sp, EXCMD cmdp)
53			{
54			return (ex_g_setup(sp, cmdp, V));
55			}
56
57			/*
58			* ex_g_setup --
59			* Ex global and v commands.
60			*/
61			static int
62			ex_g_setup(SCR sp, EXCMD cmdp, enum which cmd)
63			{
64			CHAR_T ptrn, p, *t;
65			EXCMD *ecp;
66			MARK abs_mark;
67			RANGE *rp;
68			busy_t btype;
69			recno_t start, end;
70			regex_t *re;
71			regmatch_t match[1];
72			size_t len;
73			int cnt, delim, eval;
74			char *dbp;
75
76			NEEDFILE(sp, cmdp);
77
78			if (F_ISSET(sp, SC_EX_GLOBAL)) {
79			msgq(sp, M_ERR,
80			"The %s command can't be used as part of a global or v command",
81			cmdp->cmd->name);
82			return (1);
83			}
84
85			/*
86			* Skip leading white space. Historic vi allowed any non-alphanumeric
87			* to serve as the global command delimiter.
88			*/
89			if (cmdp->argc == 0)
90			goto usage;
91			for (p = cmdp->argv[0]->bp; isblank(*p); ++p);
92			if (p == '\0' \|\| isalnum(p) \|\|
93			p == '\\' \|\| p == '\|' \|\| *p == '\n') {
94			usage: ex_emsg(sp, cmdp->cmd->usage, EXM_USAGE);
95			return (1);
96			}
97			delim = *p++;
98
99			/*
100			* Get the pattern string, toss escaped characters.
101			*
102			* QUOTING NOTE:
103			* Only toss an escaped character if it escapes a delimiter.
104			*/
105			for (ptrn = t = p;;) {
106			if (p[0] == '\0' \|\| p[0] == delim) {
107			if (p[0] == delim)
108			++p;
109			/*
110			* !!!
111			* Nul terminate the pattern string -- it's passed
112			* to regcomp which doesn't understand anything else.
113			*/
114			*t = '\0';
115			break;
116			}
117			if (p[0] == '\\') {
118			if (p[1] == delim)
119			++p;
120			else if (p[1] == '\\')
121			t++ = p++;
122			}
123			t++ = p++;
124			}
125
126			/* If the pattern string is empty, use the last one. */
127			if (*ptrn == '\0') {
128			if (sp->re == NULL) {
129			ex_emsg(sp, NULL, EXM_NOPREVRE);
130			return (1);
131			}
132
133			/* Re-compile the RE if necessary. */
134			if (!F_ISSET(sp, SC_RE_SEARCH) && re_compile(sp,
135			sp->re, sp->re_len, NULL, NULL, &sp->re_c, RE_C_SEARCH))
136			return (1);
137			} else {
138			/* Compile the RE. */
139			if (re_compile(sp, ptrn, t - ptrn,
140			&sp->re, &sp->re_len, &sp->re_c, RE_C_SEARCH))
141			return (1);
142
143			/*
144			* Set saved RE. Historic practice is that globals set
145			* direction as well as the RE.
146			*/
147			sp->searchdir = FORWARD;
148			}
149			re = &sp->re_c;
150
151			/* The global commands always set the previous context mark. */
152			abs_mark.lno = sp->lno;
153			abs_mark.cno = sp->cno;
154			if (mark_set(sp, ABSMARK1, &abs_mark, 1))
155			return (1);
156
157			/* Get an EXCMD structure. */
158			CALLOC_RET(sp, ecp, 1, sizeof(EXCMD));
159			TAILQ_INIT(&ecp->rq);
160
161			/*
162			* Get a copy of the command string; the default command is print.
163			* Don't worry about a set of <blank>s with no command, that will
164			* default to print in the ex parser. We need to have two copies
165			* because the ex parser may step on the command string when it's
166			* parsing it.
167			*/
168			if ((len = cmdp->argv[0]->len - (p - cmdp->argv[0]->bp)) == 0) {
169			p = "pp";
170			len = 1;
171			}
172
173			MALLOC_RET(sp, ecp->cp, len * 2);
174			ecp->o_cp = ecp->cp;
175			ecp->o_clen = len;
176			memcpy(ecp->cp + len, p, len);
177			ecp->range_lno = OOBLNO;
178			FL_SET(ecp->agv_flags, cmd == GLOBAL ? AGV_GLOBAL : AGV_V);
179			LIST_INSERT_HEAD(&sp->gp->ecq, ecp, q);
180
181			/*
182			* For each line... The semantics of global matching are that we first
183			* have to decide which lines are going to get passed to the command,
184			* and then pass them to the command, ignoring other changes. There's
185			* really no way to do this in a single pass, since arbitrary line
186			* creation, deletion and movement can be done in the ex command. For
187			* example, a good vi clone test is ":g/X/mo.-3", or "g/X/.,.+1d".
188			* What we do is create linked list of lines that are tracked through
189			* each ex command. There's a callback routine which the DB interface
190			* routines call when a line is created or deleted. This doesn't help
191			* the layering much.
192			*/
193			btype = BUSY_ON;
194			cnt = INTERRUPT_CHECK;
195			for (start = cmdp->addr1.lno,
196			end = cmdp->addr2.lno; start <= end; ++start) {
197			if (cnt-- == 0) {
198			if (INTERRUPTED(sp)) {
199			LIST_REMOVE(ecp, q);
200			free(ecp->cp);
201			free(ecp);
202			break;
203			}
204			search_busy(sp, btype);
205			btype = BUSY_UPDATE;
206			cnt = INTERRUPT_CHECK;
207			}
208			if (db_get(sp, start, DBG_FATAL, &dbp, &len))
209			return (1);
210			match[0].rm_so = 0;
211			match[0].rm_eo = len;
212			switch (eval =
213			regexec(&sp->re_c, dbp, 0, match, REG_STARTEND)) {
214			case 0:
215			if (cmd == V)
216			continue;
217			break;
218			case REG_NOMATCH:
219			if (cmd == GLOBAL)
220			continue;
221			break;
222			default:
223			re_error(sp, eval, &sp->re_c);
224			break;
225			}
226
227			/* If follows the last entry, extend the last entry's range. */
228			if ((rp = TAILQ_LAST(&ecp->rq, _rh)) && rp->stop == start - 1) {
229			++rp->stop;
230			continue;
231			}
232
233			/* Allocate a new range, and append it to the list. */
234			CALLOC(sp, rp, 1, sizeof(RANGE));
235			if (rp == NULL)
236			return (1);
237			rp->start = rp->stop = start;
238			TAILQ_INSERT_TAIL(&ecp->rq, rp, q);
239			}
240			search_busy(sp, BUSY_OFF);
241			return (0);
242			}
243
244			/*
245			* ex_g_insdel --
246			* Update the ranges based on an insertion or deletion.
247			*
248			* PUBLIC: int ex_g_insdel(SCR *, lnop_t, recno_t);
249			*/
250			int
251			ex_g_insdel(SCR *sp, lnop_t op, recno_t lno)
252			{
253			EXCMD *ecp;
254			RANGE nrp, rp;
255
256			/* All insert/append operations are done as inserts. */
257			if (op == LINE_APPEND)
258			abort();
259
260			if (op == LINE_RESET)
261			return (0);
262
263			LIST_FOREACH(ecp, &sp->gp->ecq, q) {
264			if (!FL_ISSET(ecp->agv_flags, AGV_AT \| AGV_GLOBAL \| AGV_V))
265			continue;
266			for (rp = TAILQ_FIRST(&ecp->rq); rp != NULL; rp = nrp) {
267			nrp = TAILQ_NEXT(rp, q);
268
269			/* If range less than the line, ignore it. */
270			if (rp->stop < lno)
271			continue;
272
273			/*
274			* If range greater than the line, decrement or
275			* increment the range.
276			*/
277			if (rp->start > lno) {
278			if (op == LINE_DELETE) {
279			--rp->start;
280			--rp->stop;
281			} else {
282			++rp->start;
283			++rp->stop;
284			}
285			continue;
286			}
287
288			/*
289			* Lno is inside the range, decrement the end point
290			* for deletion, and split the range for insertion.
291			* In the latter case, since we're inserting a new
292			* element, neither range can be exhausted.
293			*/
294			if (op == LINE_DELETE) {
295			if (rp->start > --rp->stop) {
296			TAILQ_REMOVE(&ecp->rq, rp, q);
297			free(rp);
298			}
299			} else {
300			CALLOC_RET(sp, nrp, 1, sizeof(RANGE));
301			nrp->start = lno + 1;
302			nrp->stop = rp->stop + 1;
303			rp->stop = lno - 1;
304			TAILQ_INSERT_AFTER(&ecp->rq, rp, nrp, q);
305			rp = nrp;
306			}
307			}
308
309			/*
310			* If the command deleted/inserted lines, the cursor moves to
311			* the line after the deleted/inserted line.
312			*/
313			ecp->range_lno = lno;
314			}
315			return (0);
316			}