![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to re.3 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / man / adm / man3|
Return to re.3 CVS log | Up to [Research Unix] / researchv10dc / man / adm / man3 |
1.1 root 1: .TH RE 3
2: .CT 2 data_man
3: .SH NAME
4: re_bm, re_cw, re_re \(mi string and pattern matching
5: .SH SYNOPSIS
6: .nf
7: .2C
8: .B "#include <re.h>"
9: .PP
10: .B "re_bm *re_bmcomp(b, e, map)"
11: .B "char *b, *e;"
12: .B "unsigned char map[256];"
13: .PP
14: .B "int re_bmexec(pat, rdfn, matchfn)"
15: .B re_bm *pat;
16: .B int (*rdfn)(), (*matchfn)();
17: .PP
18: .B void re_bmfree(pat);
19: .B re_bm *pat;
20: .PP
21: .BR "re_cw *re_cwinit(map)"
22: .B unsigned char map[256];
23: .PP
24: .BR "void re_cwadd(pat, b, e)"
25: .B re_cw *pat;
26: .B char *b, *e;
27: .PP
28: .BR "void re_cwcomp(pat)"
29: .B re_cw *pat;
30: .PP
31: .B "int re_cwexec(pat, rdfn, matchfn)"
32: .B re_cw *pat;
33: .B int (*rdfn)(), (*matchfn)();
34: .PP
35: .B void re_cwfree(pat);
36: .B re_cw *pat;
37: .PP
38: .BR "re_re *re_recomp(b, e, map)"
39: .B char *b, *e;
40: .B unsigned char map[256];
41: .PP
42: .B "re_reexec(pat, b, e, match)"
43: .B re_re *pat;
44: .B char *b, *e, *match[10][2];
45: .PP
46: .B void re_refree(pat);
47: .B re_re *pat;
48: .PP
49: .B void re_rerror(str);
50: .B char *str;
51: .1C
52: .fi
53: .SH DESCRIPTION
54: These routines search for patterns in strings.
55: The
56: .I re_re
57: routines search for general regular expressions (defined below)
58: using a lazily evaluated deterministic finite automaton.
59: The more specialized and faster
60: .I re_cw
61: routines search for multiple literal strings
62: using the Commentz-Walter algorithm.
63: The still more specialized and efficient
64: .I re_bm
65: routines search for a single string using the Boyer-Moore algorithm.
66: The routines handle strings designated by pointers to
67: the first character of the string
68: and to the character following the string.
69: .PP
70: To use the
71: .I re_bm
72: routines, first build a recognizer by calling
73: .I re_bmcomp,
74: which takes the search string and a character map;
75: all characters are compared after mapping.
76: The recognizer can be run (multiple times) by calling
77: .I re_bmexec,
78: which stops and returns the first non-positive return from either
79: .I rdfn
80: or
81: .IR matchfn .
82: The recognizer calls the supplied function
83: .I rdfn
84: to obtain input and
85: .I matchfn
86: to report text matching the search string.
87: .PP
88: .I Rdfn
89: should be declared as
90: .IP
91: .EX
92: int rdfn(pb, pe)
93: char **pb, **pe;
94: .EE
95: .LP
96: where
97: .B *pb
98: and
99: .B *pe
100: delimit an as yet unprocessed text fragment
101: (none if
102: .LR *pb==*pe )
103: to be saved across the call to
104: .IR rdfn .
105: On return,
106: .B *pb
107: and
108: .B *pe
109: point to the new text, including the saved fragment.
110: .I Rdfn
111: returns 0 for EOF, negative for error, and positive otherwise.
112: The first call to
113: .I rdfn
114: from each invocation of
115: .I re_bmexec
116: has
117: .BR *pb==0 .
118: .PP
119: .I Matchfn
120: should be declared as
121: .IP
122: .EX
123: int matchfn(pb, pe)
124: char **pb, **pe;
125: .EE
126: .LP
127: where
128: .B *pb
129: and
130: .B *pe
131: delimit the matched text.
132: .I Matchfn
133: sets
134: .BR *pb ,
135: .BR *pe ,
136: and returns a value in the same way as
137: .I rdfn.
138: .PP
139: To use the
140: .I re_cw
141: routines, first build the recognizer by calling
142: .IR re_cwinit ,
143: then
144: .I re_cwadd
145: for each string, and finally
146: .IR re_cwcomp .
147: The recognizer is run by
148: .I re_cwexec
149: analogously to
150: .IR re_bmexec .
151: .PP
152: A full regular expression recognizer is compiled by
153: .I re_recomp
154: and executed by
155: .I re_reexec,
156: which returns 1 if there was a match and 0 if there wasn't.
157: The strings that match subexpressions are returned in array
158: .IR match .
159: .L match[0]
160: refers to the whole matched expression.
161: If
162: .I match
163: is zero, then no match delimiters are set.
164: .PP
165: The routine
166: .I re_error
167: prints its argument on standard error and exits.
168: You may supply your own version for specialized error handling.
169: .PP
170: The recognizers that these routines construct occupy storage
171: obtained from
172: .IR malloc (3).
173: The storage can be deallocated by
174: .I free.
175: .SS Regular Expressions
176: The syntax for a regular expression
177: .B e0
178: is
179: .EX
180: e3: literal | charclass | '.' | '^' | '$' | '\e'\fIn\fP | '(' e0 ')'
181:
182: e2: e3
183: | e2 REP
184: REP: '*' | '+' | '?'
185:
186: e1: e2
187: | e1 e2
188:
189: e0: e1
190: | e0 ALT e1
191: ALT: '|' | newline
192: .EE
193: .PP
194: A literal is any non-metacharacter or a metacharacter
195: (one of
196: .BR .*+?[]()|\e^$ )
197: preceded by
198: .LR \e .
199: .PP
200: A charclass is a nonempty string
201: .I s
202: bracketed
203: .BI [ \|s\| ]
204: (or
205: .BI [^ s\| ]\fR);
206: it matches any character in (or not in)
207: .I s.
208: In
209: .I s,
210: the metacharacters other than
211: .L ]
212: have no special meaning, and
213: .L ]
214: may only appear as
215: the first letter.
216: A substring
217: .IB a - b ,
218: with
219: .I a
220: and
221: .I b
222: in ascending
223: .SM ASCII
224: order, stands for the inclusive
225: range of
226: .SM ASCII
227: characters between
228: .I a
229: and
230: .IR b .
231: .PP
232: A
233: .L \e
234: followed by a digit
235: .I n
236: matches a copy of the string that the
237: parenthesized subexpression beginning with the
238: .IR n th
239: .LR ( ,
240: counting from 1, matched.
241: .PP
242: A
243: .L .
244: matches any character.
245: .PP
246: A
247: .L ^
248: matches the beginning of the input string;
249: .L $
250: matches the end.
251: .PP
252: The
253: .B REP
254: operators match zero or more
255: .RB ( * ),
256: one or more
257: .RB ( + ),
258: and zero or one
259: .RB ( ? )
260: instances respectively of the preceding regular expression
261: .BR e2 .
262: .PP
263: A concatenated regular expression,
264: .BR "e1 e2" ,
265: matches a match to
266: .B e1
267: followed by a match to
268: .BR e2 .
269: .PP
270: An alternative regular expression,
271: .BR "e0 ALT e1" ,
272: matches either a match to
273: .B e0
274: or a match to
275: .BR e1 .
276: .PP
277: A match to any part of a regular expression
278: extends as far as possible without preventing
279: a match to the remainder of the regular expression.
280: .SH SEE ALSO
281: .IR regexp (3),
282: .IR gre (1)
283: .SH DIAGNOSTICS
284: Routines that return pointers return 0 on error.
285: .SH BUGS
286: Between
287: .IR re (3)
288: and
289: .IR regexp (3)
290: there are too many routines.
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.