aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorMark Whitley <markw@lineo.com>2000-07-10 23:07:54 +0000
committerMark Whitley <markw@lineo.com>2000-07-10 23:07:54 +0000
commitcc54d12ef716e9206344c18006b46386fe49ba9b (patch)
treec2f88581d8e81aef6de5010941380e1cb872f463
parentdd23b8bb431d27ea95534f528a1e1381e5841b8b (diff)
downloadbusybox-w32-cc54d12ef716e9206344c18006b46386fe49ba9b.tar.gz
busybox-w32-cc54d12ef716e9206344c18006b46386fe49ba9b.tar.bz2
busybox-w32-cc54d12ef716e9206344c18006b46386fe49ba9b.zip
Removed all trace of hand-tooled regexp routines. Bye bye, baby.
Diffstat
-rw-r--r--Makefile2
-rw-r--r--regexp.c789
-rw-r--r--regexp.h33
3 files changed, 1 insertions, 823 deletions
diff --git a/Makefile b/Makefile
index bc2eb8192..032e21663 100644
--- a/Makefile
+++ b/Makefile
@@ -142,7 +142,7 @@ busybox: $(OBJECTS)
142busybox.links: busybox.def.h 142busybox.links: busybox.def.h
143 - ./busybox.mkll | sort >$@ 143 - ./busybox.mkll | sort >$@
144 144
145regexp.o nfsmount.o cmdedit.o: %.o: %.h 145nfsmount.o cmdedit.o: %.o: %.h
146$(OBJECTS): %.o: busybox.def.h internal.h %.c Makefile 146$(OBJECTS): %.o: busybox.def.h internal.h %.c Makefile
147 147
148test tests: 148test tests:
diff --git a/regexp.c b/regexp.c
deleted file mode 100644
index 6fedb01ba..000000000
--- a/regexp.c
+++ /dev/null
@@ -1,789 +0,0 @@
1/* vi: set sw=4 ts=4: */
2/* regexp.c */
3
4#include "internal.h"
5#include "regexp.h"
6#include <setjmp.h>
7#include <stdio.h>
8#include <ctype.h>
9
10
11#define NSUBEXP 10
12typedef struct regexp {
13 char *startp[NSUBEXP];
14 char *endp[NSUBEXP];
15 int minlen; /* length of shortest possible match */
16 char first; /* first character, if known; else \0 */
17 char bol; /* boolean: must start at beginning of line? */
18 char program[1]; /* Unwarranted chumminess with compiler. */
19} regexp;
20
21
22static regexp *regcomp(char* text);
23static int regexec(struct regexp* re, char* str, int bol, int ignoreCase);
24static void regsub(struct regexp* re, char* src, char* dst);
25
26#if ( defined BB_GREP || defined BB_SED)
27
28/* This also tries to find a needle in a haystack, but uses
29 * real regular expressions.... The fake regular expression
30 * version of find_match lives in utility.c. Using this version
31 * will add 3.9k to busybox...
32 * -Erik Andersen
33 */
34extern int find_match(char *haystack, char *needle, int ignoreCase)
35{
36 int status;
37 struct regexp *re;
38
39 re = regcomp(needle);
40 status = regexec(re, haystack, FALSE, ignoreCase);
41 free(re);
42 return (status);
43}
44
45#if defined BB_SED
46/* This performs substitutions after a regexp match has been found.
47 * The new string is returned. It is malloc'ed, and do must be freed. */
48extern int replace_match(char *haystack, char *needle, char *newNeedle,
49 int ignoreCase)
50{
51 int status;
52 struct regexp *re;
53 char *s, buf[BUF_SIZE], *d = buf;
54
55 re = regcomp(needle);
56 status = regexec(re, haystack, FALSE, ignoreCase);
57 if (status == TRUE) {
58 s = haystack;
59
60 do {
61 /* copy stuff from before the match */
62 while (s < re->startp[0])
63 *d++ = *s++;
64 /* substitute for the matched part */
65 regsub(re, newNeedle, d);
66 s = re->endp[0];
67 d += strlen(d);
68 } while (regexec(re, s, FALSE, ignoreCase) == TRUE);
69 /* copy stuff from after the match */
70 while ((*d++ = *s++)) {
71 }
72 d[0] = '\0';
73 strcpy(haystack, buf);
74 }
75 free(re);
76 return (status);
77}
78#endif
79
80
81/* code swiped from elvis-tiny 1.4 (a clone of vi) and adjusted to
82 * suit the needs of busybox by Erik Andersen.
83 *
84 * From the README:
85 * "Elvis is freely redistributable, in either source form or executable form.
86 * There are no restrictions on how you may use it".
87 * Elvis was written by Steve Kirkendall <kirkenda@cs.pdx.edu>
88 *
89 *
90 * This file contains the code that compiles regular expressions and executes
91 * them. It supports the same syntax and features as vi's regular expression
92 * code. Specifically, the meta characters are:
93 * ^ matches the beginning of a line
94 * $ matches the end of a line
95 * \< matches the beginning of a word
96 * \> matches the end of a word
97 * . matches any single character
98 * [] matches any character in a character class
99 * \( delimits the start of a subexpression
100 * \) delimits the end of a subexpression
101 * * repeats the preceding 0 or more times
102 * NOTE: You cannot follow a \) with a *.
103 *
104 * The physical structure of a compiled RE is as follows:
105 * - First, there is a one-byte value that says how many character classes
106 * are used in this regular expression
107 * - Next, each character class is stored as a bitmap that is 256 bits
108 * (32 bytes) long.
109 * - A mixture of literal characters and compiled meta characters follows.
110 * This begins with M_BEGIN(0) and ends with M_END(0). All meta chars
111 * are stored as a \n followed by a one-byte code, so they take up two
112 * bytes apiece. Literal characters take up one byte apiece. \n can't
113 * be used as a literal character.
114 *
115 */
116
117
118
119static char *previous; /* the previous regexp, used when null regexp is given */
120
121#if defined BB_SED
122static char *previous1; /* a copy of the text from the previous substitution for regsub() */
123#endif
124
125
126/* These are used to classify or recognize meta-characters */
127#define META '\0'
128#define BASE_META(m) ((m) - 256)
129#define INT_META(c) ((c) + 256)
130#define IS_META(m) ((m) >= 256)
131#define IS_CLASS(m) ((m) >= M_CLASS(0) && (m) <= M_CLASS(9))
132#define IS_START(m) ((m) >= M_START(0) && (m) <= M_START(9))
133#define IS_END(m) ((m) >= M_END(0) && (m) <= M_END(9))
134#define IS_CLOSURE(m) ((m) >= M_SPLAT && (m) <= M_QMARK)
135#define ADD_META(s,m) (*(s)++ = META, *(s)++ = BASE_META(m))
136#define GET_META(s) (*(s) == META ? INT_META(*++(s)) : *s)
137
138/* These are the internal codes used for each type of meta-character */
139#define M_BEGLINE 256 /* internal code for ^ */
140#define M_ENDLINE 257 /* internal code for $ */
141#define M_BEGWORD 258 /* internal code for \< */
142#define M_ENDWORD 259 /* internal code for \> */
143#define M_ANY 260 /* internal code for . */
144#define M_SPLAT 261 /* internal code for * */
145#define M_PLUS 262 /* internal code for \+ */
146#define M_QMARK 263 /* internal code for \? */
147#define M_CLASS(n) (264+(n)) /* internal code for [] */
148#define M_START(n) (274+(n)) /* internal code for \( */
149#define M_END(n) (284+(n)) /* internal code for \) */
150
151/* These are used during compilation */
152static int class_cnt; /* used to assign class IDs */
153static int start_cnt; /* used to assign start IDs */
154static int end_stk[NSUBEXP]; /* used to assign end IDs */
155static int end_sp;
156static char *retext; /* points to the text being compiled */
157
158/* error-handling stuff */
159jmp_buf errorhandler;
160
161#define FAIL(why) do {fprintf(stderr, why); longjmp(errorhandler, 1);} while (0)
162
163
164
165
166/* This function builds a bitmap for a particular class */
167/* text -- start of the class */
168/* bmap -- the bitmap */
169static char *makeclass(char *text, char *bmap)
170{
171 int i;
172 int complement = 0;
173
174
175 /* zero the bitmap */
176 for (i = 0; bmap && i < 32; i++) {
177 bmap[i] = 0;
178 }
179
180 /* see if we're going to complement this class */
181 if (*text == '^') {
182 text++;
183 complement = 1;
184 }
185
186 /* add in the characters */
187 while (*text && *text != ']') {
188 /* is this a span of characters? */
189 if (text[1] == '-' && text[2]) {
190 /* spans can't be backwards */
191 if (text[0] > text[2]) {
192 FAIL("Backwards span in []");
193 }
194
195 /* add each character in the span to the bitmap */
196 for (i = text[0]; bmap && i <= text[2]; i++) {
197 bmap[i >> 3] |= (1 << (i & 7));
198 }
199
200 /* move past this span */
201 text += 3;
202 } else {
203 /* add this single character to the span */
204 i = *text++;
205 if (bmap) {
206 bmap[i >> 3] |= (1 << (i & 7));
207 }
208 }
209 }
210
211 /* make sure the closing ] is missing */
212 if (*text++ != ']') {
213 FAIL("] missing");
214 }
215
216 /* if we're supposed to complement this class, then do so */
217 if (complement && bmap) {
218 for (i = 0; i < 32; i++) {
219 bmap[i] = ~bmap[i];
220 }
221 }
222
223 return text;
224}
225
226
227
228
229/* This function gets the next character or meta character from a string.
230 * The pointer is incremented by 1, or by 2 for \-quoted characters. For [],
231 * a bitmap is generated via makeclass() (if re is given), and the
232 * character-class text is skipped.
233 */
234static int gettoken(sptr, re)
235char **sptr;
236regexp *re;
237{
238 int c;
239
240 c = **sptr;
241 ++*sptr;
242 if (c == '\\') {
243 c = **sptr;
244 ++*sptr;
245 switch (c) {
246 case '<':
247 return M_BEGWORD;
248
249 case '>':
250 return M_ENDWORD;
251
252 case '(':
253 if (start_cnt >= NSUBEXP) {
254 FAIL("Too many \\(s");
255 }
256 end_stk[end_sp++] = start_cnt;
257 return M_START(start_cnt++);
258
259 case ')':
260 if (end_sp <= 0) {
261 FAIL("Mismatched \\)");
262 }
263 return M_END(end_stk[--end_sp]);
264
265 case '*':
266 return M_SPLAT;
267
268 case '.':
269 return M_ANY;
270
271 case '+':
272 return M_PLUS;
273
274 case '?':
275 return M_QMARK;
276
277 default:
278 return c;
279 }
280 } else {
281 switch (c) {
282 case '^':
283 if (*sptr == retext + 1) {
284 return M_BEGLINE;
285 }
286 return c;
287
288 case '$':
289 if (!**sptr) {
290 return M_ENDLINE;
291 }
292 return c;
293
294 case '.':
295 return M_ANY;
296
297 case '*':
298 return M_SPLAT;
299
300 case '[':
301 /* make sure we don't have too many classes */
302 if (class_cnt >= 10) {
303 FAIL("Too many []s");
304 }
305
306 /* process the character list for this class */
307 if (re) {
308 /* generate the bitmap for this class */
309 *sptr = makeclass(*sptr, re->program + 1 + 32 * class_cnt);
310 } else {
311 /* skip to end of the class */
312 *sptr = makeclass(*sptr, (char *) 0);
313 }
314 return M_CLASS(class_cnt++);
315
316 default:
317 return c;
318 }
319 }
320 /*NOTREACHED*/}
321
322
323
324
325/* This function calculates the number of bytes that will be needed for a
326 * compiled RE. Its argument is the uncompiled version. It is not clever
327 * about catching syntax errors; that is done in a later pass.
328 */
329static unsigned calcsize(text)
330char *text;
331{
332 unsigned size;
333 int token;
334
335 retext = text;
336 class_cnt = 0;
337 start_cnt = 1;
338 end_sp = 0;
339 size = 5;
340 while ((token = gettoken(&text, (regexp *) 0)) != 0) {
341 if (IS_CLASS(token)) {
342 size += 34;
343 } else if (IS_META(token)) {
344 size += 2;
345 } else {
346 size++;
347 }
348 }
349
350 return size;
351}
352
353
354
355/*---------------------------------------------------------------------------*/
356
357
358/* This function checks for a match between a character and a token which is
359 * known to represent a single character. It returns 0 if they match, or
360 * 1 if they don't.
361 */
362static int match1(regexp * re, char ch, int token, int ignoreCase)
363{
364 if (!ch) {
365 /* the end of a line can't match any RE of width 1 */
366 return 1;
367 }
368 if (token == M_ANY) {
369 return 0;
370 } else if (IS_CLASS(token)) {
371 if (re->program[1 + 32 * (token - M_CLASS(0)) + (ch >> 3)] & (1 << (ch & 7)))
372 return 0;
373 }
374//fprintf(stderr, "match1: ch='%c' token='%c': ", ch, token);
375 if (ch == token || (ignoreCase == TRUE && tolower(ch) == tolower(token))) {
376//fprintf(stderr, "match\n");
377 return 0;
378 }
379//fprintf(stderr, "no match\n");
380 return 1;
381}
382
383
384
385/* This function checks characters up to and including the next closure, at
386 * which point it does a recursive call to check the rest of it. This function
387 * returns 0 if everything matches, or 1 if something doesn't match.
388 */
389/* re -- the regular expression */
390/* str -- the string */
391/* prog -- a portion of re->program, an compiled RE */
392/* here -- a portion of str, the string to compare it to */
393static int match(regexp * re, char *str, char *prog, char *here,
394 int ignoreCase)
395{
396 int token;
397 int nmatched;
398 int closure;
399
400 for (token = GET_META(prog); !IS_CLOSURE(token);
401 prog++, token = GET_META(prog)) {
402 switch (token) {
403 /*case M_BEGLINE: can't happen; re->bol is used instead */
404 case M_ENDLINE:
405 if (*here)
406 return 1;
407 break;
408
409 case M_BEGWORD:
410 if (here != str &&
411 (here[-1] == '_' ||
412 (isascii(here[-1]) && isalnum(here[-1])))) return 1;
413 break;
414
415 case M_ENDWORD:
416 if ((here[0] == '_' || isascii(here[0])) && isalnum(here[0]))
417 return 1;
418 break;
419
420 case M_START(0):
421 case M_START(1):
422 case M_START(2):
423 case M_START(3):
424 case M_START(4):
425 case M_START(5):
426 case M_START(6):
427 case M_START(7):
428 case M_START(8):
429 case M_START(9):
430 re->startp[token - M_START(0)] = (char *) here;
431 break;
432
433 case M_END(0):
434 case M_END(1):
435 case M_END(2):
436 case M_END(3):
437 case M_END(4):
438 case M_END(5):
439 case M_END(6):
440 case M_END(7):
441 case M_END(8):
442 case M_END(9):
443 re->endp[token - M_END(0)] = (char *) here;
444 if (token == M_END(0)) {
445 return 0;
446 }
447 break;
448
449 default: /* literal, M_CLASS(n), or M_ANY */
450 if (match1(re, *here, token, ignoreCase) != 0)
451 return 1;
452 here++;
453 }
454 }
455
456 /* C L O S U R E */
457
458 /* step 1: see what we have to match against, and move "prog" to point
459 * the the remainder of the compiled RE.
460 */
461 closure = token;
462 prog++, token = GET_META(prog);
463 prog++;
464
465 /* step 2: see how many times we can match that token against the string */
466 for (nmatched = 0;
467 (closure != M_QMARK || nmatched < 1) && *here
468 && match1(re, *here, token, ignoreCase) == 0; nmatched++, here++) {
469 }
470
471 /* step 3: try to match the remainder, and back off if it doesn't */
472 while (nmatched >= 0 && match(re, str, prog, here, ignoreCase) != 0) {
473 nmatched--;
474 here--;
475 }
476
477 /* so how did it work out? */
478 if (nmatched >= ((closure == M_PLUS) ? 1 : 0))
479 return 0;
480 return 1;
481}
482
483
484/* This function compiles a regexp. */
485static regexp *regcomp(char *text)
486{
487 int needfirst;
488 unsigned size;
489 int token;
490 int peek;
491 char *build;
492 regexp *re;
493
494
495 /* prepare for error handling */
496 re = (regexp *) 0;
497 if (setjmp(errorhandler)) {
498 if (re) {
499 free(re);
500 }
501 return (regexp *) 0;
502 }
503
504 /* if an empty regexp string was given, use the previous one */
505 if (*text == 0) {
506 if (!previous) {
507 FAIL("No previous RE");
508 }
509 text = previous;
510 } else { /* non-empty regexp given, so remember it */
511
512 if (previous)
513 free(previous);
514 previous = (char *) malloc((unsigned) (strlen(text) + 1));
515 if (previous)
516 strcpy(previous, text);
517 }
518
519 /* allocate memory */
520 class_cnt = 0;
521 start_cnt = 1;
522 end_sp = 0;
523 retext = text;
524 size = calcsize(text) + sizeof(regexp);
525 re = (regexp *) malloc((unsigned) size);
526
527 if (!re) {
528 FAIL("Not enough memory for this RE");
529 }
530
531 /* compile it */
532 build = &re->program[1 + 32 * class_cnt];
533 re->program[0] = class_cnt;
534 for (token = 0; token < NSUBEXP; token++) {
535 re->startp[token] = re->endp[token] = (char *) 0;
536 }
537 re->first = 0;
538 re->bol = 0;
539 re->minlen = 0;
540 needfirst = 1;
541 class_cnt = 0;
542 start_cnt = 1;
543 end_sp = 0;
544 retext = text;
545 for (token = M_START(0), peek = gettoken(&text, re);
546 token; token = peek, peek = gettoken(&text, re)) {
547
548 /* special processing for the closure operator */
549 if (IS_CLOSURE(peek)) {
550
551 /* detect misuse of closure operator */
552 if (IS_START(token)) {
553 FAIL("* or \\+ or \\? follows nothing");
554 } else if (IS_META(token) && token != M_ANY && !IS_CLASS(token)) {
555 FAIL("* or \\+ or \\? can only follow a normal character or . or []");
556 }
557
558 /* it is okay -- make it prefix instead of postfix */
559 ADD_META(build, peek);
560
561 /* take care of "needfirst" - is this the first char? */
562 if (needfirst && peek == M_PLUS && !IS_META(token)) {
563 re->first = token;
564 }
565 needfirst = 0;
566
567 /* we used "peek" -- need to refill it */
568 peek = gettoken(&text, re);
569 if (IS_CLOSURE(peek)) {
570 FAIL("* or \\+ or \\? doubled up");
571 }
572 } else if (!IS_META(token)) {
573 /* normal char is NOT argument of closure */
574 if (needfirst) {
575 re->first = token;
576 needfirst = 0;
577 }
578 re->minlen++;
579 } else if (token == M_ANY || IS_CLASS(token)) {
580 /* . or [] is NOT argument of closure */
581 needfirst = 0;
582 re->minlen++;
583 }
584
585 /* the "token" character is not closure -- process it normally */
586 if (token == M_BEGLINE) {
587 /* set the BOL flag instead of storing M_BEGLINE */
588 re->bol = 1;
589 } else if (IS_META(token)) {
590 ADD_META(build, token);
591 } else {
592 *build++ = token;
593 }
594 }
595
596 /* end it with a \) which MUST MATCH the opening \( */
597 ADD_META(build, M_END(0));
598 if (end_sp > 0) {
599 FAIL("Not enough \\)s");
600 }
601
602 return re;
603}
604
605
606
607
608/* This function searches through a string for text that matches an RE. */
609/* re -- the compiled regexp to search for */
610/* str -- the string to search through */
611/* bol -- does str start at the beginning of a line? (boolean) */
612/* ignoreCase -- ignoreCase or not */
613static int regexec(struct regexp *re, char *str, int bol, int ignoreCase)
614{
615 char *prog; /* the entry point of re->program */
616 int len; /* length of the string */
617 char *here;
618
619 /* if must start at the beginning of a line, and this isn't, then fail */
620 if (re->bol && bol == TRUE) {
621 return FALSE;
622 }
623
624 len = strlen(str);
625 prog = re->program + 1 + 32 * re->program[0];
626
627 /* search for the RE in the string */
628 if (re->bol) {
629 /* must occur at BOL */
630 if ((re->first && match1(re, *(char *) str, re->first, ignoreCase)) /* wrong first letter? */
631 ||len < re->minlen /* not long enough? */
632 || match(re, (char *) str, prog, str, ignoreCase)) /* doesn't match? */
633 return FALSE; /* THEN FAIL! */
634 } else if (ignoreCase == FALSE) {
635 /* can occur anywhere in the line, noignorecase */
636 for (here = (char *) str; (re->first && re->first != *here)
637 || match(re, (char *) str, prog, here, ignoreCase);
638 here++, len--) {
639 if (len < re->minlen)
640 return FALSE;
641 }
642 } else {
643 /* can occur anywhere in the line, ignorecase */
644 for (here = (char *) str;
645 (re->first && match1(re, *here, (int) re->first, ignoreCase))
646 || match(re, (char *) str, prog, here, ignoreCase);
647 here++, len--) {
648 if (len < re->minlen)
649 return FALSE;
650 }
651 }
652
653 /* if we didn't fail, then we must have succeeded */
654 return TRUE;
655}
656
657
658
659
660#if defined BB_SED
661/* This performs substitutions after a regexp match has been found. */
662static void regsub(regexp * re, char *src, char *dst)
663{
664 char *cpy;
665 char *end;
666 char c;
667 char *start;
668 int mod;
669
670 mod = 0;
671
672 start = src;
673 while ((c = *src++) != '\0') {
674 /* recognize any meta characters */
675 if (c == '&') {
676 cpy = re->startp[0];
677 end = re->endp[0];
678 } else if (c == '~') {
679 cpy = previous1;
680 if (cpy)
681 end = cpy + strlen(cpy);
682 } else if (c == '\\') {
683 c = *src++;
684 switch (c) {
685 case '0':
686 case '1':
687 case '2':
688 case '3':
689 case '4':
690 case '5':
691 case '6':
692 case '7':
693 case '8':
694 case '9':
695 /* \0 thru \9 mean "copy subexpression" */
696 c -= '0';
697 cpy = re->startp[(int) c];
698 end = re->endp[(int) c];
699 break;
700 case 'U':
701 case 'u':
702 case 'L':
703 case 'l':
704 /* \U and \L mean "convert to upper/lowercase" */
705 mod = c;
706 continue;
707
708 case 'E':
709 case 'e':
710 /* \E ends the \U or \L */
711 mod = 0;
712 continue;
713 case '&':
714 /* "\&" means "original text" */
715 *dst++ = c;
716 continue;
717
718 case '~':
719 /* "\~" means "previous text, if any" */
720 *dst++ = c;
721 continue;
722 default:
723 /* ordinary char preceded by backslash */
724 *dst++ = c;
725 continue;
726 }
727 } else {
728 /* ordinary character, so just copy it */
729 *dst++ = c;
730 continue;
731 }
732
733 /* Note: to reach this point in the code, we must have evaded
734 * all "continue" statements. To do that, we must have hit
735 * a metacharacter that involves copying.
736 */
737
738 /* if there is nothing to copy, loop */
739 if (!cpy)
740 continue;
741
742 /* copy over a portion of the original */
743 while (cpy < end) {
744 switch (mod) {
745 case 'U':
746 case 'u':
747 /* convert to uppercase */
748 if (isascii(*cpy) && islower(*cpy)) {
749 *dst++ = toupper(*cpy);
750 cpy++;
751 } else {
752 *dst++ = *cpy++;
753 }
754 break;
755
756 case 'L':
757 case 'l':
758 /* convert to lowercase */
759 if (isascii(*cpy) && isupper(*cpy)) {
760 *dst++ = tolower(*cpy);
761 cpy++;
762 } else {
763 *dst++ = *cpy++;
764 }
765 break;
766
767 default:
768 /* copy without any conversion */
769 *dst++ = *cpy++;
770 }
771
772 /* \u and \l end automatically after the first char */
773 if (mod && (mod == 'u' || mod == 'l')) {
774 mod = 0;
775 }
776 }
777 }
778 *dst = '\0';
779
780 /* remember what text we inserted this time */
781 if (previous1)
782 free(previous1);
783 previous1 = (char *) malloc((unsigned) (strlen(start) + 1));
784 if (previous1)
785 strcpy(previous1, start);
786}
787#endif
788
789#endif /* BB_REGEXP */
diff --git a/regexp.h b/regexp.h
deleted file mode 100644
index 9e0cb4022..000000000
--- a/regexp.h
+++ /dev/null
@@ -1,33 +0,0 @@
1/* vi: set sw=4 ts=4: */
2/*
3 * Busybox regexp header file
4 *
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 * Based in part on code from sash, Copyright (c) 1999 by David I. Bell
21 * Permission has been granted to redistribute this code under the GPL.
22 *
23 */
24#ifndef _REGEXP_H_
25#define _REGEXP_H_
26
27
28extern int find_match(char *haystack, char *needle, int ignoreCase);
29extern int replace_match(char *haystack, char *needle, char *newNeedle, int ignoreCase);
30
31#endif
32
33
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-03-22 15:51:40 +0000