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