![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to regexp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / bin / vi|
Return to regexp.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / vi |
1.1 root 1: /* regexp.c */
2:
3: /* This file contains the code that compiles regular expressions and executes
4: * them. It supports the same syntax and features as vi's regular expression
5: * code. Specifically, the meta characters are:
6: * ^ matches the beginning of a line
7: * $ matches the end of a line
8: * \< matches the beginning of a word
9: * \> matches the end of a word
10: * . matches any single character
11: * [] matches any character in a character class
12: * \( delimits the start of a subexpression
13: * \) delimits the end of a subexpression
14: * * repeats the preceding 0 or more times
15: * NOTE: You cannot follow a \) with a *.
16: *
17: * The physical structure of a compiled RE is as follows:
18: * - First, there is a one-byte value that says how many character classes
19: * are used in this regular expression
20: * - Next, each character class is stored as a bitmap that is 256 bits
21: * (32 bytes) long.
22: * - A mixture of literal characters and compiled meta characters follows.
23: * This begins with M_BEGIN(0) and ends with M_END(0). All meta chars
24: * are stored as a \n followed by a one-byte code, so they take up two
25: * bytes apiece. Literal characters take up one byte apiece. \n can't
26: * be used as a literal character.
27: *
28: * If NO_MAGIC is defined, then a different set of functions is used instead.
29: * That right, this file contains TWO versions of the code.
30: */
31:
32: #include <setjmp.h>
33: #include "config.h"
34: #include "ctype.h"
35: #include "vi.h"
36: #include "regexp.h"
37:
38:
39:
40: static char *previous; /* the previous regexp, used when null regexp is given */
41:
42:
43: #ifndef NO_MAGIC
44: /* THE REAL REGEXP PACKAGE IS USED UNLESS "NO_MAGIC" IS DEFINED */
45:
46: /* These are used to classify or recognize meta-characters */
47: #define META '\0'
48: #define BASE_META(m) ((m) - 256)
49: #define INT_META(c) ((c) + 256)
50: #define IS_META(m) ((m) >= 256)
51: #define IS_CLASS(m) ((m) >= M_CLASS(0) && (m) <= M_CLASS(9))
52: #define IS_START(m) ((m) >= M_START(0) && (m) <= M_START(9))
53: #define IS_END(m) ((m) >= M_END(0) && (m) <= M_END(9))
54: #define IS_CLOSURE(m) ((m) >= M_SPLAT && (m) <= M_RANGE)
55: #define ADD_META(s,m) (*(s)++ = META, *(s)++ = BASE_META(m))
56: #define GET_META(s) (*(s) == META ? INT_META(*++(s)) : *s)
57:
58: /* These are the internal codes used for each type of meta-character */
59: #define M_BEGLINE 256 /* internal code for ^ */
60: #define M_ENDLINE 257 /* internal code for $ */
61: #define M_BEGWORD 258 /* internal code for \< */
62: #define M_ENDWORD 259 /* internal code for \> */
63: #define M_ANY 260 /* internal code for . */
64: #define M_SPLAT 261 /* internal code for * */
65: #define M_PLUS 262 /* internal code for \+ */
66: #define M_QMARK 263 /* internal code for \? */
67: #define M_RANGE 264 /* internal code for \{ */
68: #define M_CLASS(n) (265+(n)) /* internal code for [] */
69: #define M_START(n) (275+(n)) /* internal code for \( */
70: #define M_END(n) (285+(n)) /* internal code for \) */
71:
72: /* These are used during compilation */
73: static int class_cnt; /* used to assign class IDs */
74: static int start_cnt; /* used to assign start IDs */
75: static int end_stk[NSUBEXP];/* used to assign end IDs */
76: static int end_sp;
77: static char *retext; /* points to the text being compiled */
78:
79: /* error-handling stuff */
80: jmp_buf errorhandler;
81: #define FAIL(why) regerror(why); longjmp(errorhandler, 1)
82:
83:
84:
85:
86:
87: /* This function builds a bitmap for a particular class */
88: static char *makeclass(text, bmap)
89: REG char *text; /* start of the class */
90: REG char *bmap; /* the bitmap */
91: {
92: REG int i;
93: int complement = 0;
94:
95:
96: checkmem();
97:
98: /* zero the bitmap */
99: for (i = 0; bmap && i < 32; i++)
100: {
101: bmap[i] = 0;
102: }
103:
104: /* see if we're going to complement this class */
105: if (*text == '^')
106: {
107: text++;
108: complement = 1;
109: }
110:
111: /* add in the characters */
112: while (*text && *text != ']')
113: {
114: /* is this a span of characters? */
115: if (text[1] == '-' && text[2])
116: {
117: /* spans can't be backwards */
118: if (text[0] > text[2])
119: {
120: FAIL("Backwards span in []");
121: }
122:
123: /* add each character in the span to the bitmap */
124: for (i = UCHAR(text[0]); bmap && i <= UCHAR(text[2]); i++)
125: {
126: bmap[i >> 3] |= (1 << (i & 7));
127: }
128:
129: /* move past this span */
130: text += 3;
131: }
132: else
133: {
134: /* add this single character to the span */
135: i = *text++;
136: if (bmap)
137: {
138: bmap[UCHAR(i) >> 3] |= (1 << (UCHAR(i) & 7));
139: }
140: }
141: }
142:
143: /* make sure the closing ] is missing */
144: if (*text++ != ']')
145: {
146: FAIL("] missing");
147: }
148:
149: /* if we're supposed to complement this class, then do so */
150: if (complement && bmap)
151: {
152: for (i = 0; i < 32; i++)
153: {
154: bmap[i] = ~bmap[i];
155: }
156: }
157:
158: checkmem();
159:
160: return text;
161: }
162:
163:
164:
165:
166: /* This function gets the next character or meta character from a string.
167: * The pointer is incremented by 1, or by 2 for \-quoted characters. For [],
168: * a bitmap is generated via makeclass() (if re is given), and the
169: * character-class text is skipped.
170: */
171: static int gettoken(sptr, re)
172: char **sptr;
173: regexp *re;
174: {
175: int c;
176:
177: c = **sptr;
178: if (!c)
179: {
180: return c;
181: }
182: ++*sptr;
183: if (c == '\\')
184: {
185: c = **sptr;
186: ++*sptr;
187: switch (c)
188: {
189: case '<':
190: return M_BEGWORD;
191:
192: case '>':
193: return M_ENDWORD;
194:
195: case '(':
196: if (start_cnt >= NSUBEXP)
197: {
198: FAIL("Too many \\(s");
199: }
200: end_stk[end_sp++] = start_cnt;
201: return M_START(start_cnt++);
202:
203: case ')':
204: if (end_sp <= 0)
205: {
206: FAIL("Mismatched \\)");
207: }
208: return M_END(end_stk[--end_sp]);
209:
210: case '*':
211: return (*o_magic ? c : M_SPLAT);
212:
213: case '.':
214: return (*o_magic ? c : M_ANY);
215:
216: case '+':
217: return M_PLUS;
218:
219: case '?':
220: return M_QMARK;
221: #ifndef CRUNCH
222: case '{':
223: return M_RANGE;
224: #endif
225: default:
226: return c;
227: }
228: }
229: else if (*o_magic)
230: {
231: switch (c)
232: {
233: case '^':
234: if (*sptr == retext + 1)
235: {
236: return M_BEGLINE;
237: }
238: return c;
239:
240: case '$':
241: if (!**sptr)
242: {
243: return M_ENDLINE;
244: }
245: return c;
246:
247: case '.':
248: return M_ANY;
249:
250: case '*':
251: return M_SPLAT;
252:
253: case '[':
254: /* make sure we don't have too many classes */
255: if (class_cnt >= 10)
256: {
257: FAIL("Too many []s");
258: }
259:
260: /* process the character list for this class */
261: if (re)
262: {
263: /* generate the bitmap for this class */
264: *sptr = makeclass(*sptr, re->program + 1 + 32 * class_cnt);
265: }
266: else
267: {
268: /* skip to end of the class */
269: *sptr = makeclass(*sptr, (char *)0);
270: }
271: return M_CLASS(class_cnt++);
272:
273: default:
274: return c;
275: }
276: }
277: else /* unquoted nomagic */
278: {
279: switch (c)
280: {
281: case '^':
282: if (*sptr == retext + 1)
283: {
284: return M_BEGLINE;
285: }
286: return c;
287:
288: case '$':
289: if (!**sptr)
290: {
291: return M_ENDLINE;
292: }
293: return c;
294:
295: default:
296: return c;
297: }
298: }
299: /*NOTREACHED*/
300: }
301:
302:
303:
304:
305: /* This function calculates the number of bytes that will be needed for a
306: * compiled RE. Its argument is the uncompiled version. It is not clever
307: * about catching syntax errors; that is done in a later pass.
308: */
309: static unsigned calcsize(text)
310: char *text;
311: {
312: unsigned size;
313: int token;
314:
315: retext = text;
316: class_cnt = 0;
317: start_cnt = 1;
318: end_sp = 0;
319: size = 5;
320: while ((token = gettoken(&text, (regexp *)0)) != 0)
321: {
322: if (IS_CLASS(token))
323: {
324: size += 34;
325: }
326: #ifndef CRUNCH
327: else if (token == M_RANGE)
328: {
329: size += 4;
330: while ((token = gettoken(&text, (regexp *)0)) != 0
331: && token != '}')
332: {
333: }
334: if (!token)
335: {
336: return size;
337: }
338: }
339: #endif
340: else if (IS_META(token))
341: {
342: size += 2;
343: }
344: else
345: {
346: size++;
347: }
348: }
349:
350: return size;
351: }
352:
353:
354:
355: /* This function compiles a regexp. */
356: regexp *regcomp(exp)
357: char *exp;
358: {
359: int needfirst;
360: unsigned size;
361: int token;
362: int peek;
363: char *build;
364: regexp *re;
365: #ifndef CRUNCH
366: int from;
367: int to;
368: int digit;
369: #endif
370: #ifdef DEBUG
371: int calced;
372: #endif
373:
374:
375: checkmem();
376:
377: /* prepare for error handling */
378: re = (regexp *)0;
379: if (setjmp(errorhandler))
380: {
381: checkmem();
382: if (re)
383: {
384: _free_(re);
385: }
386: return (regexp *)0;
387: }
388:
389: /* if an empty regexp string was given, use the previous one */
390: if (*exp == 0)
391: {
392: if (!previous)
393: {
394: FAIL("No previous RE");
395: }
396: exp = previous;
397: }
398: else /* non-empty regexp given, so remember it */
399: {
400: if (previous)
401: _free_(previous);
402: previous = (char *)malloc((unsigned)(strlen(exp) + 1));
403: if (previous)
404: strcpy(previous, exp);
405: }
406:
407: /* allocate memory */
408: checkmem();
409: class_cnt = 0;
410: start_cnt = 1;
411: end_sp = 0;
412: retext = exp;
413: #ifdef DEBUG
414: calced = calcsize(exp);
415: size = calced + sizeof(regexp);
416: #else
417: size = calcsize(exp) + sizeof(regexp) + 10; /* !!! 10 bytes for slop */
418: #endif
419: #ifdef lint
420: re = (regexp *)0;
421: #else
422: re = (regexp *)malloc((unsigned)size);
423: #endif
424: if (!re)
425: {
426: FAIL("Not enough memory for this RE");
427: }
428: checkmem();
429:
430: /* compile it */
431: build = &re->program[1 + 32 * class_cnt];
432: re->program[0] = class_cnt;
433: for (token = 0; token < NSUBEXP; token++)
434: {
435: re->startp[token] = re->endp[token] = (char *)0;
436: }
437: re->first = 0;
438: re->bol = 0;
439: re->minlen = 0;
440: needfirst = 1;
441: class_cnt = 0;
442: start_cnt = 1;
443: end_sp = 0;
444: retext = exp;
445: for (token = M_START(0), peek = gettoken(&exp, re);
446: token;
447: token = peek, peek = gettoken(&exp, re))
448: {
449: /* special processing for the closure operator */
450: if (IS_CLOSURE(peek))
451: {
452: /* detect misuse of closure operator */
453: if (IS_START(token))
454: {
455: FAIL("Closure operator follows nothing");
456: }
457: else if (IS_META(token) && token != M_ANY && !IS_CLASS(token))
458: {
459: FAIL("Closure operators can only follow a normal character or . or []");
460: }
461:
462: #ifndef CRUNCH
463: /* if \{ \} then read the range */
464: if (peek == M_RANGE)
465: {
466: from = 0;
467: for (digit = gettoken(&exp, re);
468: !IS_META(digit) && isdigit(digit);
469: digit = gettoken(&exp, re))
470: {
471: from = from * 10 + digit - '0';
472: }
473: if (digit == '}')
474: {
475: to = from;
476: }
477: else if (digit == ',')
478: {
479: to = 0;
480: for (digit = gettoken(&exp, re);
481: !IS_META(digit) && isdigit(digit);
482: digit = gettoken(&exp, re))
483: {
484: to = to * 10 + digit - '0';
485: }
486: if (to == 0)
487: {
488: to = 255;
489: }
490: }
491: if (digit != '}')
492: {
493: FAIL("Bad characters after \\{");
494: }
495: else if (to < from || to == 0 || from >= 255)
496: {
497: FAIL("Invalid range for \\{ \\}");
498: }
499: re->minlen += from;
500: }
501: else
502: #endif
503: if (peek != M_SPLAT)
504: {
505: re->minlen++;
506: }
507:
508: /* it is okay -- make it prefix instead of postfix */
509: ADD_META(build, peek);
510: #ifndef CRUNCH
511: if (peek == M_RANGE)
512: {
513: *build++ = from;
514: *build++ = (to < 255 ? to : 255);
515: }
516: #endif
517:
518:
519: /* take care of "needfirst" - is this the first char? */
520: if (needfirst && peek == M_PLUS && !IS_META(token))
521: {
522: re->first = token;
523: }
524: needfirst = 0;
525:
526: /* we used "peek" -- need to refill it */
527: peek = gettoken(&exp, re);
528: if (IS_CLOSURE(peek))
529: {
530: FAIL("* or \\+ or \\? doubled up");
531: }
532: }
533: else if (!IS_META(token))
534: {
535: /* normal char is NOT argument of closure */
536: if (needfirst)
537: {
538: re->first = token;
539: needfirst = 0;
540: }
541: re->minlen++;
542: }
543: else if (token == M_ANY || IS_CLASS(token))
544: {
545: /* . or [] is NOT argument of closure */
546: needfirst = 0;
547: re->minlen++;
548: }
549:
550: /* the "token" character is not closure -- process it normally */
551: if (token == M_BEGLINE)
552: {
553: /* set the BOL flag instead of storing M_BEGLINE */
554: re->bol = 1;
555: }
556: else if (IS_META(token))
557: {
558: ADD_META(build, token);
559: }
560: else
561: {
562: *build++ = token;
563: }
564: }
565: checkmem();
566:
567: /* end it with a \) which MUST MATCH the opening \( */
568: ADD_META(build, M_END(0));
569: if (end_sp > 0)
570: {
571: FAIL("Not enough \\)s");
572: }
573:
574: #ifdef DEBUG
575: if ((int)(build - re->program) != calced)
576: {
577: msg("regcomp error: calced=%d, actual=%d", calced, (int)(build - re->program));
578: getkey(0);
579: }
580: #endif
581:
582: checkmem();
583: return re;
584: }
585:
586:
587:
588: /*---------------------------------------------------------------------------*/
589:
590:
591: /* This function checks for a match between a character and a token which is
592: * known to represent a single character. It returns 0 if they match, or
593: * 1 if they don't.
594: */
595: int match1(re, ch, token)
596: regexp *re;
597: REG char ch;
598: REG int token;
599: {
600: if (!ch)
601: {
602: /* the end of a line can't match any RE of width 1 */
603: return 1;
604: }
605: if (token == M_ANY)
606: {
607: return 0;
608: }
609: else if (IS_CLASS(token))
610: {
611: if (re->program[1 + 32 * (token - M_CLASS(0)) + (UCHAR(ch) >> 3)] & (1 << (UCHAR(ch) & 7)))
612: return 0;
613: }
614: else if (ch == token || *o_ignorecase && tolower(ch) == tolower(token))
615: {
616: return 0;
617: }
618: return 1;
619: }
620:
621:
622:
623: /* This function checks characters up to and including the next closure, at
624: * which point it does a recursive call to check the rest of it. This function
625: * returns 0 if everything matches, or 1 if something doesn't match.
626: */
627: int match(re, str, prog, here)
628: regexp *re; /* the regular expression */
629: char *str; /* the string */
630: REG char *prog; /* a portion of re->program, an compiled RE */
631: REG char *here; /* a portion of str, the string to compare it to */
632: {
633: REG int token; /* the roken pointed to by prog */
634: REG int nmatched;/* counter, used during closure matching */
635: REG int closure;/* the token denoting the type of closure */
636: int from; /* minimum number of matches in closure */
637: int to; /* maximum number of matches in closure */
638:
639: for (token = GET_META(prog); !IS_CLOSURE(token); prog++, token = GET_META(prog))
640: {
641: switch (token)
642: {
643: /*case M_BEGLINE: can't happen; re->bol is used instead */
644: case M_ENDLINE:
645: if (*here)
646: return 1;
647: break;
648:
649: case M_BEGWORD:
650: if (here != str &&
651: (here[-1] == '_' || isalnum(here[-1])))
652: return 1;
653: break;
654:
655: case M_ENDWORD:
656: if (here[0] == '_' || isalnum(here[0]))
657: return 1;
658: break;
659:
660: case M_START(0):
661: case M_START(1):
662: case M_START(2):
663: case M_START(3):
664: case M_START(4):
665: case M_START(5):
666: case M_START(6):
667: case M_START(7):
668: case M_START(8):
669: case M_START(9):
670: re->startp[token - M_START(0)] = (char *)here;
671: break;
672:
673: case M_END(0):
674: case M_END(1):
675: case M_END(2):
676: case M_END(3):
677: case M_END(4):
678: case M_END(5):
679: case M_END(6):
680: case M_END(7):
681: case M_END(8):
682: case M_END(9):
683: re->endp[token - M_END(0)] = (char *)here;
684: if (token == M_END(0))
685: {
686: return 0;
687: }
688: break;
689:
690: default: /* literal, M_CLASS(n), or M_ANY */
691: if (match1(re, *here, token) != 0)
692: return 1;
693: here++;
694: }
695: }
696:
697: /* C L O S U R E */
698:
699: /* step 1: see what we have to match against, and move "prog" to point
700: * to the remainder of the compiled RE.
701: */
702: closure = token;
703: prog++;
704: switch (closure)
705: {
706: case M_SPLAT:
707: from = 0;
708: to = strlen(str); /* infinity */
709: break;
710:
711: case M_PLUS:
712: from = 1;
713: to = strlen(str); /* infinity */
714: break;
715:
716: case M_QMARK:
717: from = 0;
718: to = 1;
719: break;
720:
721: #ifndef CRUNCH
722: case M_RANGE:
723: from = UCHAR(*prog++);
724: to = UCHAR(*prog++);
725: if (to == 255)
726: {
727: to = strlen(str); /* infinity */
728: }
729: break;
730: #endif
731: }
732: token = GET_META(prog);
733: prog++;
734:
735: /* step 2: see how many times we can match that token against the string */
736: for (nmatched = 0;
737: nmatched < to && *here && match1(re, *here, token) == 0;
738: nmatched++, here++)
739: {
740: }
741:
742: /* step 3: try to match the remainder, and back off if it doesn't */
743: while (nmatched >= from && match(re, str, prog, here) != 0)
744: {
745: nmatched--;
746: here--;
747: }
748:
749: /* so how did it work out? */
750: if (nmatched >= from)
751: return 0;
752: return 1;
753: }
754:
755:
756:
757: /* This function searches through a string for text that matches an RE. */
758: int regexec(re, str, bol)
759: regexp *re; /* the compiled regexp to search for */
760: char *str; /* the string to search through */
761: int bol; /* boolean: does str start at the beginning of a line? */
762: {
763: char *prog; /* the entry point of re->program */
764: int len; /* length of the string */
765: REG char *here;
766:
767: checkmem();
768:
769: /* if must start at the beginning of a line, and this isn't, then fail */
770: if (re->bol && !bol)
771: {
772: return 0;
773: }
774:
775: len = strlen(str);
776: prog = re->program + 1 + 32 * re->program[0];
777:
778: /* search for the RE in the string */
779: if (re->bol)
780: {
781: /* must occur at BOL */
782: if ((re->first
783: && match1(re, *(char *)str, re->first))/* wrong first letter? */
784: || len < re->minlen /* not long enough? */
785: || match(re, (char *)str, prog, str)) /* doesn't match? */
786: return 0; /* THEN FAIL! */
787: }
788: #ifndef CRUNCH
789: else if (!*o_ignorecase)
790: {
791: /* can occur anywhere in the line, noignorecase */
792: for (here = (char *)str;
793: (re->first && re->first != *here)
794: || match(re, (char *)str, prog, here);
795: here++, len--)
796: {
797: if (len < re->minlen)
798: return 0;
799: }
800: }
801: #endif
802: else
803: {
804: /* can occur anywhere in the line, ignorecase */
805: for (here = (char *)str;
806: (re->first && match1(re, *here, (int)re->first))
807: || match(re, (char *)str, prog, here);
808: here++, len--)
809: {
810: if (len < re->minlen)
811: return 0;
812: }
813: }
814:
815: /* if we didn't fail, then we must have succeeded */
816: checkmem();
817: return 1;
818: }
819:
820: /*============================================================================*/
821: #else /* NO_MAGIC */
822:
823: regexp *regcomp(exp)
824: char *exp;
825: {
826: char *src;
827: char *dest;
828: regexp *re;
829: int i;
830:
831: /* allocate a big enough regexp structure */
832: #ifdef lint
833: re = (regexp *)0;
834: #else
835: re = (regexp *)malloc((unsigned)(strlen(exp) + 1 + sizeof(struct regexp)));
836: #endif
837: if (!re)
838: {
839: regerror("Could not malloc a regexp structure");
840: return (regexp *)0;
841: }
842:
843: /* initialize all fields of the structure */
844: for (i = 0; i < NSUBEXP; i++)
845: {
846: re->startp[i] = re->endp[i] = (char *)0;
847: }
848: re->minlen = 0;
849: re->first = 0;
850: re->bol = 0;
851:
852: /* copy the string into it, translating ^ and $ as needed */
853: for (src = exp, dest = re->program + 1; *src; src++)
854: {
855: switch (*src)
856: {
857: case '^':
858: if (src == exp)
859: {
860: re->bol += 1;
861: }
862: else
863: {
864: *dest++ = '^';
865: re->minlen++;
866: }
867: break;
868:
869: case '$':
870: if (!src[1])
871: {
872: re->bol += 2;
873: }
874: else
875: {
876: *dest++ = '$';
877: re->minlen++;
878: }
879: break;
880:
881: case '\\':
882: if (src[1])
883: {
884: *dest++ = *++src;
885: re->minlen++;
886: }
887: else
888: {
889: regerror("extra \\ at end of regular expression");
890: }
891: break;
892:
893: default:
894: *dest++ = *src;
895: re->minlen++;
896: }
897: }
898: *dest = '\0';
899:
900: return re;
901: }
902:
903:
904: /* This "helper" function checks for a match at a given location. It returns
905: * 1 if it matches, 0 if it doesn't match here but might match later on in the
906: * string, or -1 if it could not possibly match
907: */
908: static int reghelp(prog, string, bolflag)
909: struct regexp *prog;
910: char *string;
911: int bolflag;
912: {
913: char *scan;
914: char *str;
915:
916: /* if ^, then require bolflag */
917: if ((prog->bol & 1) && !bolflag)
918: {
919: return -1;
920: }
921:
922: /* if it matches, then it will start here */
923: prog->startp[0] = string;
924:
925: /* compare, possibly ignoring case */
926: if (*o_ignorecase)
927: {
928: for (scan = &prog->program[1]; *scan; scan++, string++)
929: if (tolower(*scan) != tolower(*string))
930: return *string ? 0 : -1;
931: }
932: else
933: {
934: for (scan = &prog->program[1]; *scan; scan++, string++)
935: if (*scan != *string)
936: return *string ? 0 : -1;
937: }
938:
939: /* if $, then require string to end here, too */
940: if ((prog->bol & 2) && *string)
941: {
942: return 0;
943: }
944:
945: /* if we get to here, it matches */
946: prog->endp[0] = string;
947: return 1;
948: }
949:
950:
951:
952: int regexec(prog, string, bolflag)
953: struct regexp *prog;
954: char *string;
955: int bolflag;
956: {
957: int rc;
958:
959: /* keep trying to match it */
960: for (rc = reghelp(prog, string, bolflag); rc == 0; rc = reghelp(prog, string, 0))
961: {
962: string++;
963: }
964:
965: /* did we match? */
966: return rc == 1;
967: }
968: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.