xref: /dragonfly/contrib/less/pattern.c (revision 7485684f) 
1 /*
2  * Copyright (C) 1984-2023  Mark Nudelman
3  *
4  * You may distribute under the terms of either the GNU General Public
5  * License or the Less License, as specified in the README file.
6  *
7  * For more information, see the README file.
8  */
9 
10 /*
11  * Routines to do pattern matching.
12  */
13 
14 #include "less.h"
15 
16 extern int caseless;
17 extern int is_caseless;
18 extern int utf_mode;
19 
20 /*
21  * Compile a search pattern, for future use by match_pattern.
22  */
23 static int compile_pattern2(char *pattern, int search_type, PATTERN_TYPE *comp_pattern, int show_error)
24 {
25 	if (search_type & SRCH_NO_REGEX)
26 		return (0);
27   {
28 #if HAVE_GNU_REGEX
29 	struct re_pattern_buffer *comp = (struct re_pattern_buffer *)
30 		ecalloc(1, sizeof(struct re_pattern_buffer));
31 	re_set_syntax(RE_SYNTAX_POSIX_EXTENDED);
32 	if (re_compile_pattern(pattern, strlen(pattern), comp))
33 	{
34 		free(comp);
35 		if (show_error)
36 			error("Invalid pattern", NULL_PARG);
37 		return (-1);
38 	}
39 	if (*comp_pattern != NULL)
40 	{
41 		regfree(*comp_pattern);
42 		free(*comp_pattern);
43 	}
44 	*comp_pattern = comp;
45 #endif
46 #if HAVE_POSIX_REGCOMP
47 	regex_t *comp = (regex_t *) ecalloc(1, sizeof(regex_t));
48 	if (regcomp(comp, pattern, REGCOMP_FLAG | (is_caseless ? REG_ICASE : 0)))
49 	{
50 		free(comp);
51 		if (show_error)
52 			error("Invalid pattern", NULL_PARG);
53 		return (-1);
54 	}
55 	if (*comp_pattern != NULL)
56 	{
57 		regfree(*comp_pattern);
58 		free(*comp_pattern);
59 	}
60 	*comp_pattern = comp;
61 #endif
62 #if HAVE_PCRE
63 	constant char *errstring;
64 	int erroffset;
65 	PARG parg;
66 	pcre *comp = pcre_compile(pattern,
67 			((utf_mode) ? PCRE_UTF8 | PCRE_NO_UTF8_CHECK : 0) |
68 			(is_caseless ? PCRE_CASELESS : 0),
69 			&errstring, &erroffset, NULL);
70 	if (comp == NULL)
71 	{
72 		parg.p_string = (char *) errstring;
73 		if (show_error)
74 			error("%s", &parg);
75 		return (-1);
76 	}
77 	*comp_pattern = comp;
78 #endif
79 #if HAVE_PCRE2
80 	int errcode;
81 	PCRE2_SIZE erroffset;
82 	PARG parg;
83 	pcre2_code *comp = pcre2_compile((PCRE2_SPTR)pattern, strlen(pattern),
84 			(is_caseless ? PCRE2_CASELESS : 0),
85 			&errcode, &erroffset, NULL);
86 	if (comp == NULL)
87 	{
88 		if (show_error)
89 		{
90 			char msg[160];
91 			pcre2_get_error_message(errcode, (PCRE2_UCHAR*)msg, sizeof(msg));
92 			parg.p_string = msg;
93 			error("%s", &parg);
94 		}
95 		return (-1);
96 	}
97 	*comp_pattern = comp;
98 #endif
99 #if HAVE_RE_COMP
100 	PARG parg;
101 	if ((parg.p_string = re_comp(pattern)) != NULL)
102 	{
103 		if (show_error)
104 			error("%s", &parg);
105 		return (-1);
106 	}
107 	*comp_pattern = 1;
108 #endif
109 #if HAVE_REGCMP
110 	char *comp;
111 	if ((comp = regcmp(pattern, 0)) == NULL)
112 	{
113 		if (show_error)
114 			error("Invalid pattern", NULL_PARG);
115 		return (-1);
116 	}
117 	if (comp_pattern != NULL)
118 		free(*comp_pattern);
119 	*comp_pattern = comp;
120 #endif
121 #if HAVE_V8_REGCOMP
122 	struct regexp *comp;
123 	reg_show_error = show_error;
124 	comp = regcomp(pattern);
125 	reg_show_error = 1;
126 	if (comp == NULL)
127 	{
128 		/*
129 		 * regcomp has already printed an error message
130 		 * via regerror().
131 		 */
132 		return (-1);
133 	}
134 	if (*comp_pattern != NULL)
135 		free(*comp_pattern);
136 	*comp_pattern = comp;
137 #endif
138   }
139 	return (0);
140 }
141 
142 /*
143  * Like compile_pattern2, but convert the pattern to lowercase if necessary.
144  */
145 public int compile_pattern(char *pattern, int search_type, int show_error, PATTERN_TYPE *comp_pattern)
146 {
147 	char *cvt_pattern;
148 	int result;
149 
150 	if (caseless != OPT_ONPLUS || (re_handles_caseless && !(search_type & SRCH_NO_REGEX)))
151 		cvt_pattern = pattern;
152 	else
153 	{
154 		cvt_pattern = (char*) ecalloc(1, cvt_length(strlen(pattern), CVT_TO_LC));
155 		cvt_text(cvt_pattern, pattern, (int *)NULL, (int *)NULL, CVT_TO_LC);
156 	}
157 	result = compile_pattern2(cvt_pattern, search_type, comp_pattern, show_error);
158 	if (cvt_pattern != pattern)
159 		free(cvt_pattern);
160 	return (result);
161 }
162 
163 /*
164  * Forget that we have a compiled pattern.
165  */
166 public void uncompile_pattern(PATTERN_TYPE *pattern)
167 {
168 #if HAVE_GNU_REGEX
169 	if (*pattern != NULL)
170 	{
171 		regfree(*pattern);
172 		free(*pattern);
173 	}
174 	*pattern = NULL;
175 #endif
176 #if HAVE_POSIX_REGCOMP
177 	if (*pattern != NULL)
178 	{
179 		regfree(*pattern);
180 		free(*pattern);
181 	}
182 	*pattern = NULL;
183 #endif
184 #if HAVE_PCRE
185 	if (*pattern != NULL)
186 		pcre_free(*pattern);
187 	*pattern = NULL;
188 #endif
189 #if HAVE_PCRE2
190 	if (*pattern != NULL)
191 		pcre2_code_free(*pattern);
192 	*pattern = NULL;
193 #endif
194 #if HAVE_RE_COMP
195 	*pattern = 0;
196 #endif
197 #if HAVE_REGCMP
198 	if (*pattern != NULL)
199 		free(*pattern);
200 	*pattern = NULL;
201 #endif
202 #if HAVE_V8_REGCOMP
203 	if (*pattern != NULL)
204 		free(*pattern);
205 	*pattern = NULL;
206 #endif
207 }
208 
209 #if 0
210 /*
211  * Can a pattern be successfully compiled?
212  */
213 public int valid_pattern(char *pattern)
214 {
215 	PATTERN_TYPE comp_pattern;
216 	int result;
217 
218 	SET_NULL_PATTERN(comp_pattern);
219 	result = compile_pattern2(pattern, 0, &comp_pattern, 0);
220 	if (result != 0)
221 		return (0);
222 	uncompile_pattern(&comp_pattern);
223 	return (1);
224 }
225 #endif
226 
227 /*
228  * Is a compiled pattern null?
229  */
230 public int is_null_pattern(PATTERN_TYPE pattern)
231 {
232 #if HAVE_GNU_REGEX
233 	return (pattern == NULL);
234 #endif
235 #if HAVE_POSIX_REGCOMP
236 	return (pattern == NULL);
237 #endif
238 #if HAVE_PCRE
239 	return (pattern == NULL);
240 #endif
241 #if HAVE_PCRE2
242 	return (pattern == NULL);
243 #endif
244 #if HAVE_RE_COMP
245 	return (pattern == 0);
246 #endif
247 #if HAVE_REGCMP
248 	return (pattern == NULL);
249 #endif
250 #if HAVE_V8_REGCOMP
251 	return (pattern == NULL);
252 #endif
253 #if NO_REGEX
254 	return (pattern == NULL);
255 #endif
256 }
257 /*
258  * Simple pattern matching function.
259  * It supports no metacharacters like *, etc.
260  */
261 static int match(char *pattern, int pattern_len, char *buf, int buf_len, char ***sp, char ***ep, int nsubs)
262 {
263 	char *pp, *lp;
264 	char *pattern_end = pattern + pattern_len;
265 	char *buf_end = buf + buf_len;
266 
267 	for ( ;  buf < buf_end;  buf++)
268 	{
269 		for (pp = pattern, lp = buf;  ;  pp++, lp++)
270 		{
271 			char cp = *pp;
272 			char cl = *lp;
273 			if (caseless == OPT_ONPLUS && ASCII_IS_UPPER(cp))
274 				cp = ASCII_TO_LOWER(cp);
275 			if (cp != cl)
276 				break;
277 			if (pp == pattern_end || lp == buf_end)
278 				break;
279 		}
280 		if (pp == pattern_end)
281 		{
282 			*(*sp)++ = buf;
283 			*(*ep)++ = lp;
284 			return (1);
285 		}
286 	}
287 	**sp = **ep = NULL;
288 	return (0);
289 }
290 
291 /*
292  * Perform a pattern match with the previously compiled pattern.
293  * Set sp[0] and ep[0] to the start and end of the matched string.
294  * Set sp[i] and ep[i] to the start and end of the i-th matched subpattern.
295  * Subpatterns are defined by parentheses in the regex language.
296  */
297 static int match_pattern1(PATTERN_TYPE pattern, char *tpattern, char *line, int line_len, char **sp, char **ep, int nsp, int notbol, int search_type)
298 {
299 	int matched;
300 
301 #if NO_REGEX
302 	search_type |= SRCH_NO_REGEX;
303 #endif
304 	if (search_type & SRCH_NO_REGEX)
305 		matched = match(tpattern, strlen(tpattern), line, line_len, &sp, &ep, nsp);
306 	else
307 	{
308 #if HAVE_GNU_REGEX
309 	{
310 		struct re_registers search_regs;
311 		pattern->not_bol = notbol;
312 		pattern->regs_allocated = REGS_UNALLOCATED;
313 		matched = re_search(pattern, line, line_len, 0, line_len, &search_regs) >= 0;
314 		if (matched)
315 		{
316 			*sp++ = line + search_regs.start[0];
317 			*ep++ = line + search_regs.end[0];
318 		}
319 	}
320 #endif
321 #if HAVE_POSIX_REGCOMP
322 	{
323 		#define RM_COUNT (NUM_SEARCH_COLORS+2)
324 		regmatch_t rm[RM_COUNT];
325 		int flags = (notbol) ? REG_NOTBOL : 0;
326 #ifdef REG_STARTEND
327 		flags |= REG_STARTEND;
328 		rm[0].rm_so = 0;
329 		rm[0].rm_eo = line_len;
330 #endif
331 		matched = !regexec(pattern, line, RM_COUNT, rm, flags);
332 		if (matched)
333 		{
334 			int i;
335 			int ecount;
336 			for (ecount = RM_COUNT;  ecount > 0;  ecount--)
337 				if (rm[ecount-1].rm_so >= 0)
338 					break;
339 			if (ecount >= nsp)
340 				ecount = nsp-1;
341 			for (i = 0;  i < ecount;  i++)
342 			{
343 				if (rm[i].rm_so < 0)
344 				{
345 					*sp++ = *ep++ = line;
346 				} else
347 				{
348 #ifndef __WATCOMC__
349 					*sp++ = line + rm[i].rm_so;
350 					*ep++ = line + rm[i].rm_eo;
351 #else
352 					*sp++ = rm[i].rm_sp;
353 					*ep++ = rm[i].rm_ep;
354 #endif
355 				}
356 			}
357 		}
358 	}
359 #endif
360 #if HAVE_PCRE
361 	{
362 		#define OVECTOR_COUNT ((3*NUM_SEARCH_COLORS)+3)
363 		int ovector[OVECTOR_COUNT];
364 		int flags = (notbol) ? PCRE_NOTBOL : 0;
365 		int i;
366 		int ecount;
367 		int mcount = pcre_exec(pattern, NULL, line, line_len,
368 			0, flags, ovector, OVECTOR_COUNT);
369 		matched = (mcount > 0);
370 		ecount = nsp-1;
371 		if (ecount > mcount) ecount = mcount;
372 		for (i = 0;  i < ecount*2; )
373 		{
374 			if (ovector[i] < 0 || ovector[i+1] < 0)
375 			{
376 				*sp++ = *ep++ = line;
377 				i += 2;
378 			} else
379 			{
380 				*sp++ = line + ovector[i++];
381 				*ep++ = line + ovector[i++];
382 			}
383 		}
384 	}
385 #endif
386 #if HAVE_PCRE2
387 	{
388 		int flags = (notbol) ? PCRE2_NOTBOL : 0;
389 		pcre2_match_data *md = pcre2_match_data_create(nsp-1, NULL);
390 		int mcount = pcre2_match(pattern, (PCRE2_SPTR)line, line_len,
391 			0, flags, md, NULL);
392 		matched = (mcount > 0);
393 		if (matched)
394 		{
395 			PCRE2_SIZE *ovector = pcre2_get_ovector_pointer(md);
396 			int i;
397 			int ecount = nsp-1;
398 			if (ecount > mcount) ecount = mcount;
399 			for (i = 0;  i < ecount*2; )
400 			{
401 				if (ovector[i] < 0 || ovector[i+1] < 0)
402 				{
403 					*sp++ = *ep++ = line;
404 					i += 2;
405 				} else
406 				{
407 					*sp++ = line + ovector[i++];
408 					*ep++ = line + ovector[i++];
409 				}
410 			}
411 		}
412 		pcre2_match_data_free(md);
413 	}
414 #endif
415 #if HAVE_RE_COMP
416 	matched = (re_exec(line) == 1);
417 	/*
418 	 * re_exec doesn't seem to provide a way to get the matched string.
419 	 */
420 #endif
421 #if HAVE_REGCMP
422 	matched = ((*ep++ = regex(pattern, line)) != NULL);
423 	if (matched)
424 		*sp++ = __loc1;
425 #endif
426 #if HAVE_V8_REGCOMP
427 #if HAVE_REGEXEC2
428 	matched = regexec2(pattern, line, notbol);
429 #else
430 	matched = regexec(pattern, line);
431 #endif
432 	if (matched)
433 	{
434 		*sp++ = pattern->startp[0];
435 		*ep++ = pattern->endp[0];
436 	}
437 #endif
438 	}
439 	*sp = *ep = NULL;
440 	matched = (!(search_type & SRCH_NO_MATCH) && matched) ||
441 			((search_type & SRCH_NO_MATCH) && !matched);
442 	return (matched);
443 }
444 
445 public int match_pattern(PATTERN_TYPE pattern, char *tpattern, char *line, int line_len, char **sp, char **ep, int nsp, int notbol, int search_type)
446 {
447 	int matched = match_pattern1(pattern, tpattern, line, line_len, sp, ep, nsp, notbol, search_type);
448 	int i;
449 	for (i = 1;  i <= NUM_SEARCH_COLORS;  i++)
450 	{
451 		if ((search_type & SRCH_SUBSEARCH(i)) && ep[i] == sp[i])
452 			matched = 0;
453 	}
454 	return matched;
455 }
456 
457 /*
458  * Return the name of the pattern matching library.
459  */
460 public char * pattern_lib_name(void)
461 {
462 #if HAVE_GNU_REGEX
463 	return ("GNU");
464 #else
465 #if HAVE_POSIX_REGCOMP
466 	return ("POSIX");
467 #else
468 #if HAVE_PCRE2
469 	return ("PCRE2");
470 #else
471 #if HAVE_PCRE
472 	return ("PCRE");
473 #else
474 #if HAVE_RE_COMP
475 	return ("BSD");
476 #else
477 #if HAVE_REGCMP
478 	return ("V8");
479 #else
480 #if HAVE_V8_REGCOMP
481 	return ("Spencer V8");
482 #else
483 	return ("no");
484 #endif
485 #endif
486 #endif
487 #endif
488 #endif
489 #endif
490 #endif
491 }
492