Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libedit/search.c	Lines:	10	251	4.0 %
Date:	2017-11-13	Branches:	1	158	0.6 %


/*	$OpenBSD: search.c,v 1.27 2016/05/06 13:12:52 schwarze Exp $	*/
/*	$NetBSD: search.c,v 1.45 2016/04/18 17:01:19 christos Exp $	*/

/*-
 * Copyright (c) 1992, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Christos Zoulas of Cornell University.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include "config.h"

/*
 * search.c: History and character search functions
 */
#include <stdlib.h>
#include <string.h>
#if defined(REGEX)
#include <regex.h>
#elif defined(REGEXP)
#include <regexp.h>
#endif

#include "el.h"
#include "common.h"
#include "fcns.h"

/*
 * Adjust cursor in vi mode to include the character under it
 */
#define	EL_CURSOR(el) \
    ((el)->el_line.cursor + (((el)->el_map.type == MAP_VI) && \
			    ((el)->el_map.current == (el)->el_map.alt)))

/* search_init():
 *	Initialize the search stuff
 */
protected int
search_init(EditLine *el)
{

	el->el_search.patbuf = reallocarray(NULL, EL_BUFSIZ,
	    sizeof(*el->el_search.patbuf));
	if (el->el_search.patbuf == NULL)
		return -1;
	*el->el_search.patbuf = L'\0';
	el->el_search.patlen = 0;
	el->el_search.patdir = -1;
	el->el_search.chacha = '\0';
	el->el_search.chadir = CHAR_FWD;
	el->el_search.chatflg = 0;
	return 0;
}


/* search_end():
 *	Initialize the search stuff
 */
protected void
search_end(EditLine *el)
{

	free(el->el_search.patbuf);
	el->el_search.patbuf = NULL;
}


#ifdef REGEXP
/* regerror():
 *	Handle regular expression errors
 */
void
/*ARGSUSED*/
regerror(const char *msg)
{
}
#endif


/* el_match():
 *	Return if string matches pattern
 */
protected int
el_match(const wchar_t *str, const wchar_t *pat)
{
	static ct_buffer_t conv;
#if defined (REGEX)
	regex_t re;
	int rv;
#elif defined (REGEXP)
	regexp *rp;
	int rv;
#else
	extern char	*re_comp(const char *);
	extern int	 re_exec(const char *);
#endif

	if (wcsstr(str, pat) != 0)
		return 1;

#if defined(REGEX)
	if (regcomp(&re, ct_encode_string(pat, &conv), 0) == 0) {
		rv = regexec(&re, ct_encode_string(str, &conv), 0, NULL, 0) == 0;
		regfree(&re);
	} else {
		rv = 0;
	}
	return rv;
#elif defined(REGEXP)
	if ((re = regcomp(ct_encode_string(pat, &conv))) != NULL) {
		rv = regexec(re, ct_encode_string(str, &conv));
		free(re);
	} else {
		rv = 0;
	}
	return rv;
#else
	if (re_comp(ct_encode_string(pat, &conv)) != NULL)
		return 0;
	else
		return re_exec(ct_encode_string(str, &conv)) == 1;
#endif
}


/* c_hmatch():
 *	 return True if the pattern matches the prefix
 */
protected int
c_hmatch(EditLine *el, const wchar_t *str)
{
#ifdef SDEBUG
	(void) fprintf(el->el_errfile, "match `%s' with `%s'\n",
	    el->el_search.patbuf, str);
#endif /* SDEBUG */

	return el_match(str, el->el_search.patbuf);
}


/* c_setpat():
 *	Set the history seatch pattern
 */
protected void
c_setpat(EditLine *el)
{
	if (el->el_state.lastcmd != ED_SEARCH_PREV_HISTORY &&
	    el->el_state.lastcmd != ED_SEARCH_NEXT_HISTORY) {
		el->el_search.patlen = EL_CURSOR(el) - el->el_line.buffer;
		if (el->el_search.patlen >= EL_BUFSIZ)
			el->el_search.patlen = EL_BUFSIZ - 1;
		if (el->el_search.patlen != 0) {
			(void) wcsncpy(el->el_search.patbuf, el->el_line.buffer,
			    el->el_search.patlen);
			el->el_search.patbuf[el->el_search.patlen] = '\0';
		} else
			el->el_search.patlen = wcslen(el->el_search.patbuf);
	}
#ifdef SDEBUG
	(void) fprintf(el->el_errfile, "\neventno = %d\n",
	    el->el_history.eventno);
	(void) fprintf(el->el_errfile, "patlen = %d\n", el->el_search.patlen);
	(void) fprintf(el->el_errfile, "patbuf = \"%s\"\n",
	    el->el_search.patbuf);
	(void) fprintf(el->el_errfile, "cursor %d lastchar %d\n",
	    EL_CURSOR(el) - el->el_line.buffer,
	    el->el_line.lastchar - el->el_line.buffer);
#endif
}


/* ce_inc_search():
 *	Emacs incremental search
 */
protected el_action_t
ce_inc_search(EditLine *el, int dir)
{
	static const wchar_t STRfwd[] = L"fwd", STRbck[] = L"bck";
	static wchar_t pchar = L':';  /* ':' = normal, '?' = failed */
	static wchar_t endcmd[2] = {'\0', '\0'};
	wchar_t *ocursor = el->el_line.cursor, oldpchar = pchar, ch;
	const wchar_t *cp;

	el_action_t ret = CC_NORM;

	int ohisteventno = el->el_history.eventno;
	size_t oldpatlen = el->el_search.patlen;
	int newdir = dir;
	int done, redo;

	if (el->el_line.lastchar + sizeof(STRfwd) /
	    sizeof(*el->el_line.lastchar) + 2 +
	    el->el_search.patlen >= el->el_line.limit)
		return CC_ERROR;

	for (;;) {

		if (el->el_search.patlen == 0) {	/* first round */
			pchar = ':';
#ifdef ANCHOR
#define	LEN	2
			el->el_search.patbuf[el->el_search.patlen++] = '.';
			el->el_search.patbuf[el->el_search.patlen++] = '*';
#else
#define	LEN	0
#endif
		}
		done = redo = 0;
		*el->el_line.lastchar++ = '\n';
		for (cp = (newdir == ED_SEARCH_PREV_HISTORY) ? STRbck : STRfwd;
		    *cp; *el->el_line.lastchar++ = *cp++)
			continue;
		*el->el_line.lastchar++ = pchar;
		for (cp = &el->el_search.patbuf[LEN];
		    cp < &el->el_search.patbuf[el->el_search.patlen];
		    *el->el_line.lastchar++ = *cp++)
			continue;
		*el->el_line.lastchar = '\0';
		re_refresh(el);

		if (el_wgetc(el, &ch) != 1)
			return ed_end_of_file(el, 0);

		switch (el->el_map.current[(unsigned char) ch]) {
		case ED_INSERT:
		case ED_DIGIT:
			if (el->el_search.patlen >= EL_BUFSIZ - LEN)
				terminal_beep(el);
			else {
				el->el_search.patbuf[el->el_search.patlen++] =
				    ch;
				*el->el_line.lastchar++ = ch;
				*el->el_line.lastchar = '\0';
				re_refresh(el);
			}
			break;

		case EM_INC_SEARCH_NEXT:
			newdir = ED_SEARCH_NEXT_HISTORY;
			redo++;
			break;

		case EM_INC_SEARCH_PREV:
			newdir = ED_SEARCH_PREV_HISTORY;
			redo++;
			break;

		case EM_DELETE_PREV_CHAR:
		case ED_DELETE_PREV_CHAR:
			if (el->el_search.patlen > LEN)
				done++;
			else
				terminal_beep(el);
			break;

		default:
			switch (ch) {
			case 0007:	/* ^G: Abort */
				ret = CC_ERROR;
				done++;
				break;

			case 0027:	/* ^W: Append word */
			/* No can do if globbing characters in pattern */
				for (cp = &el->el_search.patbuf[LEN];; cp++)
				    if (cp >= &el->el_search.patbuf[
					el->el_search.patlen]) {
					el->el_line.cursor +=
					    el->el_search.patlen - LEN - 1;
					cp = c__next_word(el->el_line.cursor,
					    el->el_line.lastchar, 1,
					    ce__isword);
					while (el->el_line.cursor < cp &&
					    *el->el_line.cursor != '\n') {
						if (el->el_search.patlen >=
						    EL_BUFSIZ - LEN) {
							terminal_beep(el);
							break;
						}
						el->el_search.patbuf[el->el_search.patlen++] =
						    *el->el_line.cursor;
						*el->el_line.lastchar++ =
						    *el->el_line.cursor++;
					}
					el->el_line.cursor = ocursor;
					*el->el_line.lastchar = '\0';
					re_refresh(el);
					break;
				    } else if (isglob(*cp)) {
					    terminal_beep(el);
					    break;
				    }
				break;

			default:	/* Terminate and execute cmd */
				endcmd[0] = ch;
				el_wpush(el, endcmd);
				/* FALLTHROUGH */

			case 0033:	/* ESC: Terminate */
				ret = CC_REFRESH;
				done++;
				break;
			}
			break;
		}

		while (el->el_line.lastchar > el->el_line.buffer &&
		    *el->el_line.lastchar != '\n')
			*el->el_line.lastchar-- = '\0';
		*el->el_line.lastchar = '\0';

		if (!done) {

			/* Can't search if unmatched '[' */
			for (cp = &el->el_search.patbuf[el->el_search.patlen-1],
			    ch = L']';
			    cp >= &el->el_search.patbuf[LEN];
			    cp--)
				if (*cp == '[' || *cp == ']') {
					ch = *cp;
					break;
				}
			if (el->el_search.patlen > LEN && ch != L'[') {
				if (redo && newdir == dir) {
					if (pchar == '?') { /* wrap around */
						el->el_history.eventno =
						    newdir == ED_SEARCH_PREV_HISTORY ? 0 : 0x7fffffff;
						if (hist_get(el) == CC_ERROR)
							/* el->el_history.event
							 * no was fixed by
							 * first call */
							(void) hist_get(el);
						el->el_line.cursor = newdir ==
						    ED_SEARCH_PREV_HISTORY ?
						    el->el_line.lastchar :
						    el->el_line.buffer;
					} else
						el->el_line.cursor +=
						    newdir ==
						    ED_SEARCH_PREV_HISTORY ?
						    -1 : 1;
				}
#ifdef ANCHOR
				el->el_search.patbuf[el->el_search.patlen++] =
				    '.';
				el->el_search.patbuf[el->el_search.patlen++] =
				    '*';
#endif
				el->el_search.patbuf[el->el_search.patlen] =
				    '\0';
				if (el->el_line.cursor < el->el_line.buffer ||
				    el->el_line.cursor > el->el_line.lastchar ||
				    (ret = ce_search_line(el, newdir))
				    == CC_ERROR) {
					/* avoid c_setpat */
					el->el_state.lastcmd =
					    (el_action_t) newdir;
					ret = newdir == ED_SEARCH_PREV_HISTORY ?
					    ed_search_prev_history(el, 0) :
					    ed_search_next_history(el, 0);
					if (ret != CC_ERROR) {
						el->el_line.cursor = newdir ==
						    ED_SEARCH_PREV_HISTORY ?
						    el->el_line.lastchar :
						    el->el_line.buffer;
						(void) ce_search_line(el,
						    newdir);
					}
				}
				el->el_search.patlen -= LEN;
				el->el_search.patbuf[el->el_search.patlen] =
				    '\0';
				if (ret == CC_ERROR) {
					terminal_beep(el);
					if (el->el_history.eventno !=
					    ohisteventno) {
						el->el_history.eventno =
						    ohisteventno;
						if (hist_get(el) == CC_ERROR)
							return CC_ERROR;
					}
					el->el_line.cursor = ocursor;
					pchar = '?';
				} else {
					pchar = ':';
				}
			}
			ret = ce_inc_search(el, newdir);

			if (ret == CC_ERROR && pchar == '?' && oldpchar == ':')
				/*
				 * break abort of failed search at last
				 * non-failed
				 */
				ret = CC_NORM;

		}
		if (ret == CC_NORM || (ret == CC_ERROR && oldpatlen == 0)) {
			/* restore on normal return or error exit */
			pchar = oldpchar;
			el->el_search.patlen = oldpatlen;
			if (el->el_history.eventno != ohisteventno) {
				el->el_history.eventno = ohisteventno;
				if (hist_get(el) == CC_ERROR)
					return CC_ERROR;
			}
			el->el_line.cursor = ocursor;
			if (ret == CC_ERROR)
				re_refresh(el);
		}
		if (done || ret != CC_NORM)
			return ret;
	}
}


/* cv_search():
 *	Vi search.
 */
protected el_action_t
cv_search(EditLine *el, int dir)
{
	wchar_t ch;
	wchar_t tmpbuf[EL_BUFSIZ];
	int tmplen;

#ifdef ANCHOR
	tmpbuf[0] = '.';
	tmpbuf[1] = '*';
#endif
	tmplen = LEN;

	el->el_search.patdir = dir;

	tmplen = c_gets(el, &tmpbuf[LEN],
		dir == ED_SEARCH_PREV_HISTORY ? L"\n/" : L"\n?" );
	if (tmplen == -1)
		return CC_REFRESH;

	tmplen += LEN;
	ch = tmpbuf[tmplen];
	tmpbuf[tmplen] = '\0';

	if (tmplen == LEN) {
		/*
		 * Use the old pattern, but wild-card it.
		 */
		if (el->el_search.patlen == 0) {
			re_refresh(el);
			return CC_ERROR;
		}
#ifdef ANCHOR
		if (el->el_search.patbuf[0] != '.' &&
		    el->el_search.patbuf[0] != '*') {
			(void) wcsncpy(tmpbuf, el->el_search.patbuf,
			    sizeof(tmpbuf) / sizeof(*tmpbuf) - 1);
			el->el_search.patbuf[0] = '.';
			el->el_search.patbuf[1] = '*';
			(void) wcsncpy(&el->el_search.patbuf[2], tmpbuf,
			    EL_BUFSIZ - 3);
			el->el_search.patlen++;
			el->el_search.patbuf[el->el_search.patlen++] = '.';
			el->el_search.patbuf[el->el_search.patlen++] = '*';
			el->el_search.patbuf[el->el_search.patlen] = '\0';
		}
#endif
	} else {
#ifdef ANCHOR
		tmpbuf[tmplen++] = '.';
		tmpbuf[tmplen++] = '*';
#endif
		tmpbuf[tmplen] = '\0';
		(void) wcsncpy(el->el_search.patbuf, tmpbuf, EL_BUFSIZ - 1);
		el->el_search.patlen = tmplen;
	}
	el->el_state.lastcmd = (el_action_t) dir;	/* avoid c_setpat */
	el->el_line.cursor = el->el_line.lastchar = el->el_line.buffer;
	if ((dir == ED_SEARCH_PREV_HISTORY ? ed_search_prev_history(el, 0) :
	    ed_search_next_history(el, 0)) == CC_ERROR) {
		re_refresh(el);
		return CC_ERROR;
	}
	if (ch == 0033) {
		re_refresh(el);
		return ed_newline(el, 0);
	}
	return CC_REFRESH;
}


/* ce_search_line():
 *	Look for a pattern inside a line
 */
protected el_action_t
ce_search_line(EditLine *el, int dir)
{
	wchar_t *cp = el->el_line.cursor;
	wchar_t *pattern = el->el_search.patbuf;
	wchar_t oc, *ocp;
#ifdef ANCHOR
	ocp = &pattern[1];
	oc = *ocp;
	*ocp = '^';
#else
	ocp = pattern;
	oc = *ocp;
#endif

	if (dir == ED_SEARCH_PREV_HISTORY) {
		for (; cp >= el->el_line.buffer; cp--) {
			if (el_match(cp, ocp)) {
				*ocp = oc;
				el->el_line.cursor = cp;
				return CC_NORM;
			}
		}
		*ocp = oc;
		return CC_ERROR;
	} else {
		for (; *cp != '\0' && cp < el->el_line.limit; cp++) {
			if (el_match(cp, ocp)) {
				*ocp = oc;
				el->el_line.cursor = cp;
				return CC_NORM;
			}
		}
		*ocp = oc;
		return CC_ERROR;
	}
}


/* cv_repeat_srch():
 *	Vi repeat search
 */
protected el_action_t
cv_repeat_srch(EditLine *el, wint_t c)
{

#ifdef SDEBUG
	(void) fprintf(el->el_errfile, "dir %d patlen %d patbuf %s\n",
	    c, el->el_search.patlen, ct_encode_string(el->el_search.patbuf));
#endif

	el->el_state.lastcmd = (el_action_t) c;	/* Hack to stop c_setpat */
	el->el_line.lastchar = el->el_line.buffer;

	switch (c) {
	case ED_SEARCH_NEXT_HISTORY:
		return ed_search_next_history(el, 0);
	case ED_SEARCH_PREV_HISTORY:
		return ed_search_prev_history(el, 0);
	default:
		return CC_ERROR;
	}
}


/* cv_csearch():
 *	Vi character search
 */
protected el_action_t
cv_csearch(EditLine *el, int direction, wint_t ch, int count, int tflag)
{
	wchar_t *cp;

	if (ch == 0)
		return CC_ERROR;

	if (ch == (wint_t)-1) {
		if (el_wgetc(el, &ch) != 1)
			return ed_end_of_file(el, 0);
	}

	/* Save for ';' and ',' commands */
	el->el_search.chacha = ch;
	el->el_search.chadir = direction;
	el->el_search.chatflg = tflag;

	cp = el->el_line.cursor;
	while (count--) {
		if ((wint_t)*cp == ch)
			cp += direction;
		for (;;cp += direction) {
			if (cp >= el->el_line.lastchar)
				return CC_ERROR;
			if (cp < el->el_line.buffer)
				return CC_ERROR;
			if ((wint_t)*cp == ch)
				break;
		}
	}

	if (tflag)
		cp -= direction;

	el->el_line.cursor = cp;

	if (el->el_chared.c_vcmd.action != NOP) {
		if (direction > 0)
			el->el_line.cursor++;
		cv_delfini(el);
		return CC_REFRESH;
	}
	return CC_CURSOR;
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: search.c,v 1.27 2016/05/06 13:12:52 schwarze Exp $ */
2			/* $NetBSD: search.c,v 1.45 2016/04/18 17:01:19 christos Exp $ */
3
4			/*-
5			* Copyright (c) 1992, 1993
6			* The Regents of the University of California. All rights reserved.
7			*
8			* This code is derived from software contributed to Berkeley by
9			* Christos Zoulas of Cornell University.
10			*
11			* Redistribution and use in source and binary forms, with or without
12			* modification, are permitted provided that the following conditions
13			* are met:
14			* 1. Redistributions of source code must retain the above copyright
15			* notice, this list of conditions and the following disclaimer.
16			* 2. Redistributions in binary form must reproduce the above copyright
17			* notice, this list of conditions and the following disclaimer in the
18			* documentation and/or other materials provided with the distribution.
19			* 3. Neither the name of the University nor the names of its contributors
20			* may be used to endorse or promote products derived from this software
21			* without specific prior written permission.
22			*
23			* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26			* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33			* SUCH DAMAGE.
34			*/
35
36			#include "config.h"
37
38			/*
39			* search.c: History and character search functions
40			*/
41			#include <stdlib.h>
42			#include <string.h>
43			#if defined(REGEX)
44			#include <regex.h>
45			#elif defined(REGEXP)
46			#include <regexp.h>
47			#endif
48
49			#include "el.h"
50			#include "common.h"
51			#include "fcns.h"
52
53			/*
54			* Adjust cursor in vi mode to include the character under it
55			*/
56			#define EL_CURSOR(el) \
57			((el)->el_line.cursor + (((el)->el_map.type == MAP_VI) && \
58			((el)->el_map.current == (el)->el_map.alt)))
59
60			/* search_init():
61			* Initialize the search stuff
62			*/
63			protected int
64			search_init(EditLine *el)
65			{
66
67		6	el->el_search.patbuf = reallocarray(NULL, EL_BUFSIZ,
68			sizeof(*el->el_search.patbuf));
69	✗✓	3	if (el->el_search.patbuf == NULL)
70			return -1;
71		3	*el->el_search.patbuf = L'\0';
72		3	el->el_search.patlen = 0;
73		3	el->el_search.patdir = -1;
74		3	el->el_search.chacha = '\0';
75		3	el->el_search.chadir = CHAR_FWD;
76		3	el->el_search.chatflg = 0;
77		3	return 0;
78		3	}
79
80
81			/* search_end():
82			* Initialize the search stuff
83			*/
84			protected void
85			search_end(EditLine *el)
86			{
87
88			free(el->el_search.patbuf);
89			el->el_search.patbuf = NULL;
90			}
91
92
93			#ifdef REGEXP
94			/* regerror():
95			* Handle regular expression errors
96			*/
97			void
98			/ARGSUSED/
99			regerror(const char *msg)
100			{
101			}
102			#endif
103
104
105			/* el_match():
106			* Return if string matches pattern
107			*/
108			protected int
109			el_match(const wchar_t str, const wchar_t pat)
110			{
111			static ct_buffer_t conv;
112			#if defined (REGEX)
113			regex_t re;
114			int rv;
115			#elif defined (REGEXP)
116			regexp *rp;
117			int rv;
118			#else
119			extern char re_comp(const char );
120			extern int re_exec(const char *);
121			#endif
122
123			if (wcsstr(str, pat) != 0)
124			return 1;
125
126			#if defined(REGEX)
127			if (regcomp(&re, ct_encode_string(pat, &conv), 0) == 0) {
128			rv = regexec(&re, ct_encode_string(str, &conv), 0, NULL, 0) == 0;
129			regfree(&re);
130			} else {
131			rv = 0;
132			}
133			return rv;
134			#elif defined(REGEXP)
135			if ((re = regcomp(ct_encode_string(pat, &conv))) != NULL) {
136			rv = regexec(re, ct_encode_string(str, &conv));
137			free(re);
138			} else {
139			rv = 0;
140			}
141			return rv;
142			#else
143			if (re_comp(ct_encode_string(pat, &conv)) != NULL)
144			return 0;
145			else
146			return re_exec(ct_encode_string(str, &conv)) == 1;
147			#endif
148			}
149
150
151			/* c_hmatch():
152			* return True if the pattern matches the prefix
153			*/
154			protected int
155			c_hmatch(EditLine el, const wchar_t str)
156			{
157			#ifdef SDEBUG
158			(void) fprintf(el->el_errfile, "match `%s' with `%s'\n",
159			el->el_search.patbuf, str);
160			#endif /* SDEBUG */
161
162			return el_match(str, el->el_search.patbuf);
163			}
164
165
166			/* c_setpat():
167			* Set the history seatch pattern
168			*/
169			protected void
170			c_setpat(EditLine *el)
171			{
172			if (el->el_state.lastcmd != ED_SEARCH_PREV_HISTORY &&
173			el->el_state.lastcmd != ED_SEARCH_NEXT_HISTORY) {
174			el->el_search.patlen = EL_CURSOR(el) - el->el_line.buffer;
175			if (el->el_search.patlen >= EL_BUFSIZ)
176			el->el_search.patlen = EL_BUFSIZ - 1;
177			if (el->el_search.patlen != 0) {
178			(void) wcsncpy(el->el_search.patbuf, el->el_line.buffer,
179			el->el_search.patlen);
180			el->el_search.patbuf[el->el_search.patlen] = '\0';
181			} else
182			el->el_search.patlen = wcslen(el->el_search.patbuf);
183			}
184			#ifdef SDEBUG
185			(void) fprintf(el->el_errfile, "\neventno = %d\n",
186			el->el_history.eventno);
187			(void) fprintf(el->el_errfile, "patlen = %d\n", el->el_search.patlen);
188			(void) fprintf(el->el_errfile, "patbuf = \"%s\"\n",
189			el->el_search.patbuf);
190			(void) fprintf(el->el_errfile, "cursor %d lastchar %d\n",
191			EL_CURSOR(el) - el->el_line.buffer,
192			el->el_line.lastchar - el->el_line.buffer);
193			#endif
194			}
195
196
197			/* ce_inc_search():
198			* Emacs incremental search
199			*/
200			protected el_action_t
201			ce_inc_search(EditLine *el, int dir)
202			{
203			static const wchar_t STRfwd[] = L"fwd", STRbck[] = L"bck";
204			static wchar_t pchar = L':'; /* ':' = normal, '?' = failed */
205			static wchar_t endcmd[2] = {'\0', '\0'};
206			wchar_t *ocursor = el->el_line.cursor, oldpchar = pchar, ch;
207			const wchar_t *cp;
208
209			el_action_t ret = CC_NORM;
210
211			int ohisteventno = el->el_history.eventno;
212			size_t oldpatlen = el->el_search.patlen;
213			int newdir = dir;
214			int done, redo;
215
216			if (el->el_line.lastchar + sizeof(STRfwd) /
217			sizeof(*el->el_line.lastchar) + 2 +
218			el->el_search.patlen >= el->el_line.limit)
219			return CC_ERROR;
220
221			for (;;) {
222
223			if (el->el_search.patlen == 0) { /* first round */
224			pchar = ':';
225			#ifdef ANCHOR
226			#define LEN 2
227			el->el_search.patbuf[el->el_search.patlen++] = '.';
228			el->el_search.patbuf[el->el_search.patlen++] = '*';
229			#else
230			#define LEN 0
231			#endif
232			}
233			done = redo = 0;
234			*el->el_line.lastchar++ = '\n';
235			for (cp = (newdir == ED_SEARCH_PREV_HISTORY) ? STRbck : STRfwd;
236			cp; el->el_line.lastchar++ = *cp++)
237			continue;
238			*el->el_line.lastchar++ = pchar;
239			for (cp = &el->el_search.patbuf[LEN];
240			cp < &el->el_search.patbuf[el->el_search.patlen];
241			el->el_line.lastchar++ = cp++)
242			continue;
243			*el->el_line.lastchar = '\0';
244			re_refresh(el);
245
246			if (el_wgetc(el, &ch) != 1)
247			return ed_end_of_file(el, 0);
248
249			switch (el->el_map.current[(unsigned char) ch]) {
250			case ED_INSERT:
251			case ED_DIGIT:
252			if (el->el_search.patlen >= EL_BUFSIZ - LEN)
253			terminal_beep(el);
254			else {
255			el->el_search.patbuf[el->el_search.patlen++] =
256			ch;
257			*el->el_line.lastchar++ = ch;
258			*el->el_line.lastchar = '\0';
259			re_refresh(el);
260			}
261			break;
262
263			case EM_INC_SEARCH_NEXT:
264			newdir = ED_SEARCH_NEXT_HISTORY;
265			redo++;
266			break;
267
268			case EM_INC_SEARCH_PREV:
269			newdir = ED_SEARCH_PREV_HISTORY;
270			redo++;
271			break;
272
273			case EM_DELETE_PREV_CHAR:
274			case ED_DELETE_PREV_CHAR:
275			if (el->el_search.patlen > LEN)
276			done++;
277			else
278			terminal_beep(el);
279			break;
280
281			default:
282			switch (ch) {
283			case 0007: /* ^G: Abort */
284			ret = CC_ERROR;
285			done++;
286			break;
287
288			case 0027: /* ^W: Append word */
289			/* No can do if globbing characters in pattern */
290			for (cp = &el->el_search.patbuf[LEN];; cp++)
291			if (cp >= &el->el_search.patbuf[
292			el->el_search.patlen]) {
293			el->el_line.cursor +=
294			el->el_search.patlen - LEN - 1;
295			cp = c__next_word(el->el_line.cursor,
296			el->el_line.lastchar, 1,
297			ce__isword);
298			while (el->el_line.cursor < cp &&
299			*el->el_line.cursor != '\n') {
300			if (el->el_search.patlen >=
301			EL_BUFSIZ - LEN) {
302			terminal_beep(el);
303			break;
304			}
305			el->el_search.patbuf[el->el_search.patlen++] =
306			*el->el_line.cursor;
307			*el->el_line.lastchar++ =
308			*el->el_line.cursor++;
309			}
310			el->el_line.cursor = ocursor;
311			*el->el_line.lastchar = '\0';
312			re_refresh(el);
313			break;
314			} else if (isglob(*cp)) {
315			terminal_beep(el);
316			break;
317			}
318			break;
319
320			default: /* Terminate and execute cmd */
321			endcmd[0] = ch;
322			el_wpush(el, endcmd);
323			/* FALLTHROUGH */
324
325			case 0033: /* ESC: Terminate */
326			ret = CC_REFRESH;
327			done++;
328			break;
329			}
330			break;
331			}
332
333			while (el->el_line.lastchar > el->el_line.buffer &&
334			*el->el_line.lastchar != '\n')
335			*el->el_line.lastchar-- = '\0';
336			*el->el_line.lastchar = '\0';
337
338			if (!done) {
339
340			/* Can't search if unmatched '[' */
341			for (cp = &el->el_search.patbuf[el->el_search.patlen-1],
342			ch = L']';
343			cp >= &el->el_search.patbuf[LEN];
344			cp--)
345			if (cp == '[' \|\| cp == ']') {
346			ch = *cp;
347			break;
348			}
349			if (el->el_search.patlen > LEN && ch != L'[') {
350			if (redo && newdir == dir) {
351			if (pchar == '?') { /* wrap around */
352			el->el_history.eventno =
353			newdir == ED_SEARCH_PREV_HISTORY ? 0 : 0x7fffffff;
354			if (hist_get(el) == CC_ERROR)
355			/* el->el_history.event
356			* no was fixed by
357			* first call */
358			(void) hist_get(el);
359			el->el_line.cursor = newdir ==
360			ED_SEARCH_PREV_HISTORY ?
361			el->el_line.lastchar :
362			el->el_line.buffer;
363			} else
364			el->el_line.cursor +=
365			newdir ==
366			ED_SEARCH_PREV_HISTORY ?
367			-1 : 1;
368			}
369			#ifdef ANCHOR
370			el->el_search.patbuf[el->el_search.patlen++] =
371			'.';
372			el->el_search.patbuf[el->el_search.patlen++] =
373			'*';
374			#endif
375			el->el_search.patbuf[el->el_search.patlen] =
376			'\0';
377			if (el->el_line.cursor < el->el_line.buffer \|\|
378			el->el_line.cursor > el->el_line.lastchar \|\|
379			(ret = ce_search_line(el, newdir))
380			== CC_ERROR) {
381			/* avoid c_setpat */
382			el->el_state.lastcmd =
383			(el_action_t) newdir;
384			ret = newdir == ED_SEARCH_PREV_HISTORY ?
385			ed_search_prev_history(el, 0) :
386			ed_search_next_history(el, 0);
387			if (ret != CC_ERROR) {
388			el->el_line.cursor = newdir ==
389			ED_SEARCH_PREV_HISTORY ?
390			el->el_line.lastchar :
391			el->el_line.buffer;
392			(void) ce_search_line(el,
393			newdir);
394			}
395			}
396			el->el_search.patlen -= LEN;
397			el->el_search.patbuf[el->el_search.patlen] =
398			'\0';
399			if (ret == CC_ERROR) {
400			terminal_beep(el);
401			if (el->el_history.eventno !=
402			ohisteventno) {
403			el->el_history.eventno =
404			ohisteventno;
405			if (hist_get(el) == CC_ERROR)
406			return CC_ERROR;
407			}
408			el->el_line.cursor = ocursor;
409			pchar = '?';
410			} else {
411			pchar = ':';
412			}
413			}
414			ret = ce_inc_search(el, newdir);
415
416			if (ret == CC_ERROR && pchar == '?' && oldpchar == ':')
417			/*
418			* break abort of failed search at last
419			* non-failed
420			*/
421			ret = CC_NORM;
422
423			}
424			if (ret == CC_NORM \|\| (ret == CC_ERROR && oldpatlen == 0)) {
425			/* restore on normal return or error exit */
426			pchar = oldpchar;
427			el->el_search.patlen = oldpatlen;
428			if (el->el_history.eventno != ohisteventno) {
429			el->el_history.eventno = ohisteventno;
430			if (hist_get(el) == CC_ERROR)
431			return CC_ERROR;
432			}
433			el->el_line.cursor = ocursor;
434			if (ret == CC_ERROR)
435			re_refresh(el);
436			}
437			if (done \|\| ret != CC_NORM)
438			return ret;
439			}
440			}
441
442
443			/* cv_search():
444			* Vi search.
445			*/
446			protected el_action_t
447			cv_search(EditLine *el, int dir)
448			{
449			wchar_t ch;
450			wchar_t tmpbuf[EL_BUFSIZ];
451			int tmplen;
452
453			#ifdef ANCHOR
454			tmpbuf[0] = '.';
455			tmpbuf[1] = '*';
456			#endif
457			tmplen = LEN;
458
459			el->el_search.patdir = dir;
460
461			tmplen = c_gets(el, &tmpbuf[LEN],
462			dir == ED_SEARCH_PREV_HISTORY ? L"\n/" : L"\n?" );
463			if (tmplen == -1)
464			return CC_REFRESH;
465
466			tmplen += LEN;
467			ch = tmpbuf[tmplen];
468			tmpbuf[tmplen] = '\0';
469
470			if (tmplen == LEN) {
471			/*
472			* Use the old pattern, but wild-card it.
473			*/
474			if (el->el_search.patlen == 0) {
475			re_refresh(el);
476			return CC_ERROR;
477			}
478			#ifdef ANCHOR
479			if (el->el_search.patbuf[0] != '.' &&
480			el->el_search.patbuf[0] != '*') {
481			(void) wcsncpy(tmpbuf, el->el_search.patbuf,
482			sizeof(tmpbuf) / sizeof(*tmpbuf) - 1);
483			el->el_search.patbuf[0] = '.';
484			el->el_search.patbuf[1] = '*';
485			(void) wcsncpy(&el->el_search.patbuf[2], tmpbuf,
486			EL_BUFSIZ - 3);
487			el->el_search.patlen++;
488			el->el_search.patbuf[el->el_search.patlen++] = '.';
489			el->el_search.patbuf[el->el_search.patlen++] = '*';
490			el->el_search.patbuf[el->el_search.patlen] = '\0';
491			}
492			#endif
493			} else {
494			#ifdef ANCHOR
495			tmpbuf[tmplen++] = '.';
496			tmpbuf[tmplen++] = '*';
497			#endif
498			tmpbuf[tmplen] = '\0';
499			(void) wcsncpy(el->el_search.patbuf, tmpbuf, EL_BUFSIZ - 1);
500			el->el_search.patlen = tmplen;
501			}
502			el->el_state.lastcmd = (el_action_t) dir; /* avoid c_setpat */
503			el->el_line.cursor = el->el_line.lastchar = el->el_line.buffer;
504			if ((dir == ED_SEARCH_PREV_HISTORY ? ed_search_prev_history(el, 0) :
505			ed_search_next_history(el, 0)) == CC_ERROR) {
506			re_refresh(el);
507			return CC_ERROR;
508			}
509			if (ch == 0033) {
510			re_refresh(el);
511			return ed_newline(el, 0);
512			}
513			return CC_REFRESH;
514			}
515
516
517			/* ce_search_line():
518			* Look for a pattern inside a line
519			*/
520			protected el_action_t
521			ce_search_line(EditLine *el, int dir)
522			{
523			wchar_t *cp = el->el_line.cursor;
524			wchar_t *pattern = el->el_search.patbuf;
525			wchar_t oc, *ocp;
526			#ifdef ANCHOR
527			ocp = &pattern[1];
528			oc = *ocp;
529			*ocp = '^';
530			#else
531			ocp = pattern;
532			oc = *ocp;
533			#endif
534
535			if (dir == ED_SEARCH_PREV_HISTORY) {
536			for (; cp >= el->el_line.buffer; cp--) {
537			if (el_match(cp, ocp)) {
538			*ocp = oc;
539			el->el_line.cursor = cp;
540			return CC_NORM;
541			}
542			}
543			*ocp = oc;
544			return CC_ERROR;
545			} else {
546			for (; *cp != '\0' && cp < el->el_line.limit; cp++) {
547			if (el_match(cp, ocp)) {
548			*ocp = oc;
549			el->el_line.cursor = cp;
550			return CC_NORM;
551			}
552			}
553			*ocp = oc;
554			return CC_ERROR;
555			}
556			}
557
558
559			/* cv_repeat_srch():
560			* Vi repeat search
561			*/
562			protected el_action_t
563			cv_repeat_srch(EditLine *el, wint_t c)
564			{
565
566			#ifdef SDEBUG
567			(void) fprintf(el->el_errfile, "dir %d patlen %d patbuf %s\n",
568			c, el->el_search.patlen, ct_encode_string(el->el_search.patbuf));
569			#endif
570
571			el->el_state.lastcmd = (el_action_t) c; /* Hack to stop c_setpat */
572			el->el_line.lastchar = el->el_line.buffer;
573
574			switch (c) {
575			case ED_SEARCH_NEXT_HISTORY:
576			return ed_search_next_history(el, 0);
577			case ED_SEARCH_PREV_HISTORY:
578			return ed_search_prev_history(el, 0);
579			default:
580			return CC_ERROR;
581			}
582			}
583
584
585			/* cv_csearch():
586			* Vi character search
587			*/
588			protected el_action_t
589			cv_csearch(EditLine *el, int direction, wint_t ch, int count, int tflag)
590			{
591			wchar_t *cp;
592
593			if (ch == 0)
594			return CC_ERROR;
595
596			if (ch == (wint_t)-1) {
597			if (el_wgetc(el, &ch) != 1)
598			return ed_end_of_file(el, 0);
599			}
600
601			/* Save for ';' and ',' commands */
602			el->el_search.chacha = ch;
603			el->el_search.chadir = direction;
604			el->el_search.chatflg = tflag;
605
606			cp = el->el_line.cursor;
607			while (count--) {
608			if ((wint_t)*cp == ch)
609			cp += direction;
610			for (;;cp += direction) {
611			if (cp >= el->el_line.lastchar)
612			return CC_ERROR;
613			if (cp < el->el_line.buffer)
614			return CC_ERROR;
615			if ((wint_t)*cp == ch)
616			break;
617			}
618			}
619
620			if (tflag)
621			cp -= direction;
622
623			el->el_line.cursor = cp;
624
625			if (el->el_chared.c_vcmd.action != NOP) {
626			if (direction > 0)
627			el->el_line.cursor++;
628			cv_delfini(el);
629			return CC_REFRESH;
630			}
631			return CC_CURSOR;
632			}