Commit | Line | Data |
---|---|---|
15637ed4 RG |
1 | /* Definitions for data structures callers pass the regex library. |
2 | Copyright (C) 1985 Free Software Foundation, Inc. | |
3 | ||
4 | NO WARRANTY | |
5 | ||
6 | BECAUSE THIS PROGRAM IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY | |
7 | NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW. EXCEPT | |
8 | WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC, | |
9 | RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE THIS PROGRAM "AS IS" | |
10 | WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, | |
11 | BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND | |
12 | FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY | |
13 | AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE | |
14 | DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR | |
15 | CORRECTION. | |
16 | ||
17 | IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M. | |
18 | STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY | |
19 | WHO MAY MODIFY AND REDISTRIBUTE THIS PROGRAM AS PERMITTED BELOW, BE | |
20 | LIABLE TO YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR | |
21 | OTHER SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE | |
22 | USE OR INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR | |
23 | DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR | |
24 | A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) THIS | |
25 | PROGRAM, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH | |
26 | DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. | |
27 | ||
28 | GENERAL PUBLIC LICENSE TO COPY | |
29 | ||
30 | 1. You may copy and distribute verbatim copies of this source file | |
31 | as you receive it, in any medium, provided that you conspicuously and | |
32 | appropriately publish on each copy a valid copyright notice "Copyright | |
33 | (C) 1985 Free Software Foundation, Inc."; and include following the | |
34 | copyright notice a verbatim copy of the above disclaimer of warranty | |
35 | and of this License. You may charge a distribution fee for the | |
36 | physical act of transferring a copy. | |
37 | ||
38 | 2. You may modify your copy or copies of this source file or | |
39 | any portion of it, and copy and distribute such modifications under | |
40 | the terms of Paragraph 1 above, provided that you also do the following: | |
41 | ||
42 | a) cause the modified files to carry prominent notices stating | |
43 | that you changed the files and the date of any change; and | |
44 | ||
45 | b) cause the whole of any work that you distribute or publish, | |
46 | that in whole or in part contains or is a derivative of this | |
47 | program or any part thereof, to be licensed at no charge to all | |
48 | third parties on terms identical to those contained in this | |
49 | License Agreement (except that you may choose to grant more extensive | |
50 | warranty protection to some or all third parties, at your option). | |
51 | ||
52 | c) You may charge a distribution fee for the physical act of | |
53 | transferring a copy, and you may at your option offer warranty | |
54 | protection in exchange for a fee. | |
55 | ||
56 | Mere aggregation of another unrelated program with this program (or its | |
57 | derivative) on a volume of a storage or distribution medium does not bring | |
58 | the other program under the scope of these terms. | |
59 | ||
60 | 3. You may copy and distribute this program (or a portion or derivative | |
61 | of it, under Paragraph 2) in object code or executable form under the terms | |
62 | of Paragraphs 1 and 2 above provided that you also do one of the following: | |
63 | ||
64 | a) accompany it with the complete corresponding machine-readable | |
65 | source code, which must be distributed under the terms of | |
66 | Paragraphs 1 and 2 above; or, | |
67 | ||
68 | b) accompany it with a written offer, valid for at least three | |
69 | years, to give any third party free (except for a nominal | |
70 | shipping charge) a complete machine-readable copy of the | |
71 | corresponding source code, to be distributed under the terms of | |
72 | Paragraphs 1 and 2 above; or, | |
73 | ||
74 | c) accompany it with the information you received as to where the | |
75 | corresponding source code may be obtained. (This alternative is | |
76 | allowed only for noncommercial distribution and only if you | |
77 | received the program in object code or executable form alone.) | |
78 | ||
79 | For an executable file, complete source code means all the source code for | |
80 | all modules it contains; but, as a special exception, it need not include | |
81 | source code for modules which are standard libraries that accompany the | |
82 | operating system on which the executable file runs. | |
83 | ||
84 | 4. You may not copy, sublicense, distribute or transfer this program | |
85 | except as expressly provided under this License Agreement. Any attempt | |
86 | otherwise to copy, sublicense, distribute or transfer this program is void and | |
87 | your rights to use the program under this License agreement shall be | |
88 | automatically terminated. However, parties who have received computer | |
89 | software programs from you with this License Agreement will not have | |
90 | their licenses terminated so long as such parties remain in full compliance. | |
91 | ||
92 | 5. If you wish to incorporate parts of this program into other free | |
93 | programs whose distribution conditions are different, write to the Free | |
94 | Software Foundation at 675 Mass Ave, Cambridge, MA 02139. We have not yet | |
95 | worked out a simple rule that can be stated here, but we will often permit | |
96 | this. We will be guided by the two goals of preserving the free status of | |
97 | all derivatives of our free software and of promoting the sharing and reuse of | |
98 | software. | |
99 | ||
100 | ||
101 | In other words, you are welcome to use, share and improve this program. | |
102 | You are forbidden to forbid anyone else to use, share and improve | |
103 | what you give them. Help stamp out software-hoarding! */ | |
104 | ||
105 | #if defined(SHORT_NAMES) || defined(VMS) | |
106 | #define re_compile_pattern recmppat | |
107 | #define re_pattern_buffer repatbuf | |
108 | #define re_registers reregs | |
109 | #endif | |
110 | ||
111 | /* Define number of parens for which we record the beginnings and ends. | |
112 | This affects how much space the `struct re_registers' type takes up. */ | |
113 | #ifndef RE_NREGS | |
114 | #define RE_NREGS 10 | |
115 | #endif | |
116 | ||
117 | /* These bits are used in the obscure_syntax variable to choose among | |
118 | alternative regexp syntaxes. */ | |
119 | ||
120 | /* 1 means plain parentheses serve as grouping, and backslash | |
121 | parentheses are needed for literal searching. | |
122 | 0 means backslash-parentheses are grouping, and plain parentheses | |
123 | are for literal searching. */ | |
124 | #define RE_NO_BK_PARENS 1 | |
125 | ||
126 | /* 1 means plain | serves as the "or"-operator, and \| is a literal. | |
127 | 0 means \| serves as the "or"-operator, and | is a literal. */ | |
128 | #define RE_NO_BK_VBAR 2 | |
129 | ||
130 | /* 0 means plain + or ? serves as an operator, and \+, \? are literals. | |
131 | 1 means \+, \? are operators and plain +, ? are literals. */ | |
132 | #define RE_BK_PLUS_QM 4 | |
133 | ||
134 | /* 1 means | binds tighter than ^ or $. | |
135 | 0 means the contrary. */ | |
136 | #define RE_TIGHT_VBAR 8 | |
137 | ||
138 | /* 1 means treat \n as an _OR operator | |
139 | 0 means treat it as a normal character */ | |
140 | #define RE_NEWLINE_OR 16 | |
141 | ||
142 | /* 0 means that a special characters (such as *, ^, and $) always have | |
143 | their special meaning regardless of the surrounding context. | |
144 | 1 means that special characters may act as normal characters in some | |
145 | contexts. Specifically, this applies to: | |
146 | ^ - only special at the beginning, or after ( or | | |
147 | $ - only special at the end, or before ) or | | |
148 | *, +, ? - only special when not after the beginning, (, or | */ | |
149 | #define RE_CONTEXT_INDEP_OPS 32 | |
150 | ||
151 | /* Now define combinations of bits for the standard possibilities. */ | |
152 | #define RE_SYNTAX_AWK (RE_NO_BK_PARENS | RE_NO_BK_VBAR | RE_CONTEXT_INDEP_OPS) | |
153 | #define RE_SYNTAX_EGREP (RE_SYNTAX_AWK | RE_NEWLINE_OR) | |
154 | #define RE_SYNTAX_GREP (RE_BK_PLUS_QM | RE_NEWLINE_OR) | |
155 | #define RE_SYNTAX_EMACS 0 | |
156 | ||
157 | /* This data structure is used to represent a compiled pattern. */ | |
158 | ||
159 | struct re_pattern_buffer | |
160 | { | |
161 | char *buffer; /* Space holding the compiled pattern commands. */ | |
162 | int allocated; /* Size of space that buffer points to */ | |
163 | int used; /* Length of portion of buffer actually occupied */ | |
164 | char *fastmap; /* Pointer to fastmap, if any, or zero if none. */ | |
165 | /* re_search uses the fastmap, if there is one, | |
166 | to skip quickly over totally implausible characters */ | |
167 | char *translate; /* Translate table to apply to all characters before comparing. | |
168 | Or zero for no translation. | |
169 | The translation is applied to a pattern when it is compiled | |
170 | and to data when it is matched. */ | |
171 | char fastmap_accurate; | |
172 | /* Set to zero when a new pattern is stored, | |
173 | set to one when the fastmap is updated from it. */ | |
174 | char can_be_null; /* Set to one by compiling fastmap | |
175 | if this pattern might match the null string. | |
176 | It does not necessarily match the null string | |
177 | in that case, but if this is zero, it cannot. | |
178 | 2 as value means can match null string | |
179 | but at end of range or before a character | |
180 | listed in the fastmap. */ | |
181 | }; | |
182 | ||
183 | /* Structure to store "register" contents data in. | |
184 | ||
185 | Pass the address of such a structure as an argument to re_match, etc., | |
186 | if you want this information back. | |
187 | ||
188 | start[i] and end[i] record the string matched by \( ... \) grouping i, | |
189 | for i from 1 to RE_NREGS - 1. | |
190 | start[0] and end[0] record the entire string matched. */ | |
191 | ||
192 | struct re_registers | |
193 | { | |
194 | int start[RE_NREGS]; | |
195 | int end[RE_NREGS]; | |
196 | }; | |
197 | ||
198 | /* These are the command codes that appear in compiled regular expressions, one per byte. | |
199 | Some command codes are followed by argument bytes. | |
200 | A command code can specify any interpretation whatever for its arguments. | |
201 | Zero-bytes may appear in the compiled regular expression. */ | |
202 | ||
203 | enum regexpcode | |
204 | { | |
205 | unused, | |
206 | exactn, /* followed by one byte giving n, and then by n literal bytes */ | |
207 | begline, /* fails unless at beginning of line */ | |
208 | endline, /* fails unless at end of line */ | |
209 | jump, /* followed by two bytes giving relative address to jump to */ | |
210 | on_failure_jump, /* followed by two bytes giving relative address of place | |
211 | to resume at in case of failure. */ | |
212 | finalize_jump, /* Throw away latest failure point and then jump to address. */ | |
213 | maybe_finalize_jump, /* Like jump but finalize if safe to do so. | |
214 | This is used to jump back to the beginning | |
215 | of a repeat. If the command that follows | |
216 | this jump is clearly incompatible with the | |
217 | one at the beginning of the repeat, such that | |
218 | we can be sure that there is no use backtracking | |
219 | out of repetitions already completed, | |
220 | then we finalize. */ | |
221 | dummy_failure_jump, /* jump, and push a dummy failure point. | |
222 | This failure point will be thrown away | |
223 | if an attempt is made to use it for a failure. | |
224 | A + construct makes this before the first repeat. */ | |
225 | anychar, /* matches any one character */ | |
226 | charset, /* matches any one char belonging to specified set. | |
227 | First following byte is # bitmap bytes. | |
228 | Then come bytes for a bit-map saying which chars are in. | |
229 | Bits in each byte are ordered low-bit-first. | |
230 | A character is in the set if its bit is 1. | |
231 | A character too large to have a bit in the map | |
232 | is automatically not in the set */ | |
233 | charset_not, /* similar but match any character that is NOT one of those specified */ | |
234 | start_memory, /* starts remembering the text that is matched | |
235 | and stores it in a memory register. | |
236 | followed by one byte containing the register number. | |
237 | Register numbers must be in the range 0 through NREGS. */ | |
238 | stop_memory, /* stops remembering the text that is matched | |
239 | and stores it in a memory register. | |
240 | followed by one byte containing the register number. | |
241 | Register numbers must be in the range 0 through NREGS. */ | |
242 | duplicate, /* match a duplicate of something remembered. | |
243 | Followed by one byte containing the index of the memory register. */ | |
244 | before_dot, /* Succeeds if before dot */ | |
245 | at_dot, /* Succeeds if at dot */ | |
246 | after_dot, /* Succeeds if after dot */ | |
247 | begbuf, /* Succeeds if at beginning of buffer */ | |
248 | endbuf, /* Succeeds if at end of buffer */ | |
249 | wordchar, /* Matches any word-constituent character */ | |
250 | notwordchar, /* Matches any char that is not a word-constituent */ | |
251 | wordbeg, /* Succeeds if at word beginning */ | |
252 | wordend, /* Succeeds if at word end */ | |
253 | wordbound, /* Succeeds if at a word boundary */ | |
254 | notwordbound, /* Succeeds if not at a word boundary */ | |
255 | syntaxspec, /* Matches any character whose syntax is specified. | |
256 | followed by a byte which contains a syntax code, Sword or such like */ | |
257 | notsyntaxspec /* Matches any character whose syntax differs from the specified. */ | |
258 | }; | |
259 | \f | |
260 | ||
261 | extern char *re_compile_pattern (char*, int, struct re_pattern_buffer*); | |
262 | /* Is this really advertised? */ | |
263 | extern void re_compile_fastmap (struct re_pattern_buffer*); | |
264 | extern int re_search(struct re_pattern_buffer*, char*, int, int, | |
265 | int, struct re_registers*); | |
266 | extern int re_search_2 (struct re_pattern_buffer*, char*, int, | |
267 | char*, int, int, int, struct re_registers*, int); | |
268 | extern int re_match (struct re_pattern_buffer*, char*, int, int, | |
269 | struct re_registers*); | |
270 | extern int re_match_2 (struct re_pattern_buffer*, unsigned char*, int, | |
271 | unsigned char*, int, int, struct re_registers*, int); | |
272 | ||
273 | /* 4.2 bsd compatibility (yuck) */ | |
274 | extern char *re_comp (char*); | |
275 | extern int re_exec (char*); | |
276 | ||
277 | #ifdef SYNTAX_TABLE | |
278 | extern char *re_syntax_table; | |
279 | #endif | |
280 |