1 /* gnu/regexp/RESyntax.java
2    Copyright (C) 1998-2002, 2004 Free Software Foundation, Inc.
3 
4 This file is part of GNU Classpath.
5 
6 GNU Classpath 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, or (at your option)
9 any later version.
10 
11 GNU Classpath is distributed in the hope that it will be useful, but
12 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 GNU Classpath; see the file COPYING.  If not, write to the
18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19 02110-1301 USA.
20 
21 Linking this library statically or dynamically with other modules is
22 making a combined work based on this library.  Thus, the terms and
23 conditions of the GNU General Public License cover the whole
24 combination.
25 
26 As a special exception, the copyright holders of this library give you
27 permission to link this library with independent modules to produce an
28 executable, regardless of the license terms of these independent
29 modules, and to copy and distribute the resulting executable under
30 terms of your choice, provided that you also meet, for each linked
31 independent module, the terms and conditions of the license of that
32 module.  An independent module is a module which is not derived from
33 or based on this library.  If you modify this library, you may extend
34 this exception to your version of the library, but you are not
35 obligated to do so.  If you do not wish to do so, delete this
36 exception statement from your version. */
37 
38 
39 package gnu.regexp;
40 import java.io.Serializable;
41 import java.util.BitSet;
42 
43 /**
44  * An RESyntax specifies the way a regular expression will be compiled.
45  * This class provides a number of predefined useful constants for
46  * emulating popular regular expression syntaxes.  Additionally the
47  * user may construct his or her own syntax, using any combination of the
48  * syntax bit constants.  The syntax is an optional argument to any of the
49  * matching methods on class RE.
50  *
51  * @author <A HREF="mailto:wes@cacas.org">Wes Biggs</A>
52  */
53 
54 public final class RESyntax implements Serializable {
55     static final String DEFAULT_LINE_SEPARATOR = System.getProperty("line.separator");
56 
57     private static final String SYNTAX_IS_FINAL = RE.getLocalizedMessage("syntax.final");
58 
59     private BitSet bits;
60 
61     // true for the constant defined syntaxes
62     private boolean isFinal = false;
63 
64     private String lineSeparator = DEFAULT_LINE_SEPARATOR;
65 
66   // Values for constants are bit indexes
67 
68   /**
69    * Syntax bit. Backslash is an escape character in lists.
70    */
71   public static final int RE_BACKSLASH_ESCAPE_IN_LISTS =  0;
72 
73   /**
74    * Syntax bit. Use \? instead of ? and \+ instead of +.
75    */
76   public static final int RE_BK_PLUS_QM                =  1;
77 
78   /**
79    * Syntax bit. POSIX character classes ([:...:]) in lists are allowed.
80    */
81   public static final int RE_CHAR_CLASSES              =  2;
82 
83   /**
84    * Syntax bit. ^ and $ are special everywhere.
85    * <B>Not implemented.</B>
86    */
87   public static final int RE_CONTEXT_INDEP_ANCHORS     =  3;
88 
89   /**
90    * Syntax bit. Repetition operators are only special in valid positions.
91    * <B>Not implemented.</B>
92    */
93   public static final int RE_CONTEXT_INDEP_OPS         =  4;
94 
95   /**
96    * Syntax bit. Repetition and alternation operators are invalid
97    * at start and end of pattern and other places.
98    * <B>Not implemented</B>.
99    */
100   public static final int RE_CONTEXT_INVALID_OPS       =  5;
101 
102   /**
103    * Syntax bit. Match-any-character operator (.) matches a newline.
104    */
105   public static final int RE_DOT_NEWLINE               =  6;
106 
107   /**
108    * Syntax bit. Match-any-character operator (.) does not match a null.
109    */
110   public static final int RE_DOT_NOT_NULL              =  7;
111 
112   /**
113    * Syntax bit. Intervals ({x}, {x,}, {x,y}) are allowed.
114    */
115   public static final int RE_INTERVALS                 =  8;
116 
117   /**
118    * Syntax bit. No alternation (|), match one-or-more (+), or
119    * match zero-or-one (?) operators.
120    */
121   public static final int RE_LIMITED_OPS               =  9;
122 
123   /**
124    * Syntax bit. Newline is an alternation operator.
125    */
126   public static final int RE_NEWLINE_ALT               = 10; // impl.
127 
128   /**
129    * Syntax bit. Intervals use { } instead of \{ \}
130    */
131   public static final int RE_NO_BK_BRACES              = 11;
132 
133   /**
134    * Syntax bit. Grouping uses ( ) instead of \( \).
135    */
136   public static final int RE_NO_BK_PARENS              = 12;
137 
138   /**
139    * Syntax bit. Backreferences not allowed.
140    */
141   public static final int RE_NO_BK_REFS                = 13;
142 
143   /**
144    * Syntax bit. Alternation uses | instead of \|
145    */
146   public static final int RE_NO_BK_VBAR                = 14;
147 
148   /**
149    * Syntax bit. <B>Not implemented</B>.
150    */
151   public static final int RE_NO_EMPTY_RANGES           = 15;
152 
153   /**
154    * Syntax bit. An unmatched right parenthesis (')' or '\)', depending
155    * on RE_NO_BK_PARENS) will throw an exception when compiling.
156    */
157   public static final int RE_UNMATCHED_RIGHT_PAREN_ORD = 16;
158 
159   /**
160    * Syntax bit. <B>Not implemented.</B>
161    */
162   public static final int RE_HAT_LISTS_NOT_NEWLINE     = 17;
163 
164   /**
165    * Syntax bit.  Stingy matching is allowed (+?, *?, ??, {x,y}?).
166    */
167   public static final int RE_STINGY_OPS                = 18;
168 
169   /**
170    * Syntax bit. Allow character class escapes (\d, \D, \s, \S, \w, \W).
171    */
172   public static final int RE_CHAR_CLASS_ESCAPES        = 19;
173 
174   /**
175    * Syntax bit. Allow use of (?:xxx) grouping (subexpression is not saved).
176    */
177   public static final int RE_PURE_GROUPING             = 20;
178 
179   /**
180    * Syntax bit. Allow use of (?=xxx) and (?!xxx) apply the subexpression
181    * to the text following the current position without consuming that text.
182    */
183   public static final int RE_LOOKAHEAD                 = 21;
184 
185   /**
186    * Syntax bit. Allow beginning- and end-of-string anchors (\A, \Z).
187    */
188   public static final int RE_STRING_ANCHORS            = 22;
189 
190   /**
191    * Syntax bit. Allow embedded comments, (?#comment), as in Perl5.
192    */
193   public static final int RE_COMMENTS                  = 23;
194 
195   /**
196    * Syntax bit. Allow character class escapes within lists, as in Perl5.
197    */
198   public static final int RE_CHAR_CLASS_ESC_IN_LISTS   = 24;
199 
200   /**
201    * Syntax bit.  Possessive matching is allowed (++, *+, ?+, {x,y}+).
202    */
203   public static final int RE_POSSESSIVE_OPS            = 25;
204 
205   private static final int BIT_TOTAL                   = 26;
206 
207   /**
208    * Predefined syntax.
209    * Emulates regular expression support in the awk utility.
210    */
211   public static final RESyntax RE_SYNTAX_AWK;
212 
213   /**
214    * Predefined syntax.
215    * Emulates regular expression support in the ed utility.
216    */
217   public static final RESyntax RE_SYNTAX_ED;
218 
219   /**
220    * Predefined syntax.
221    * Emulates regular expression support in the egrep utility.
222    */
223   public static final RESyntax RE_SYNTAX_EGREP;
224 
225   /**
226    * Predefined syntax.
227    * Emulates regular expression support in the GNU Emacs editor.
228    */
229   public static final RESyntax RE_SYNTAX_EMACS;
230 
231   /**
232    * Predefined syntax.
233    * Emulates regular expression support in the grep utility.
234    */
235   public static final RESyntax RE_SYNTAX_GREP;
236 
237   /**
238    * Predefined syntax.
239    * Emulates regular expression support in the POSIX awk specification.
240    */
241   public static final RESyntax RE_SYNTAX_POSIX_AWK;
242 
243   /**
244    * Predefined syntax.
245    * Emulates POSIX basic regular expression support.
246    */
247   public static final RESyntax RE_SYNTAX_POSIX_BASIC;
248 
249   /**
250    * Predefined syntax.
251    * Emulates regular expression support in the POSIX egrep specification.
252    */
253   public static final RESyntax RE_SYNTAX_POSIX_EGREP;
254 
255   /**
256    * Predefined syntax.
257    * Emulates POSIX extended regular expression support.
258    */
259   public static final RESyntax RE_SYNTAX_POSIX_EXTENDED;
260 
261   /**
262    * Predefined syntax.
263    * Emulates POSIX basic minimal regular expressions.
264    */
265   public static final RESyntax RE_SYNTAX_POSIX_MINIMAL_BASIC;
266 
267   /**
268    * Predefined syntax.
269    * Emulates POSIX extended minimal regular expressions.
270    */
271   public static final RESyntax RE_SYNTAX_POSIX_MINIMAL_EXTENDED;
272 
273   /**
274    * Predefined syntax.
275    * Emulates regular expression support in the sed utility.
276    */
277   public static final RESyntax RE_SYNTAX_SED;
278 
279   /**
280    * Predefined syntax.
281    * Emulates regular expression support in Larry Wall's perl, version 4,
282    */
283   public static final RESyntax RE_SYNTAX_PERL4;
284 
285   /**
286    * Predefined syntax.
287    * Emulates regular expression support in Larry Wall's perl, version 4,
288    * using single line mode (/s modifier).
289    */
290   public static final RESyntax RE_SYNTAX_PERL4_S; // single line mode (/s)
291 
292   /**
293    * Predefined syntax.
294    * Emulates regular expression support in Larry Wall's perl, version 5.
295    */
296   public static final RESyntax RE_SYNTAX_PERL5;
297 
298   /**
299    * Predefined syntax.
300    * Emulates regular expression support in Larry Wall's perl, version 5,
301    * using single line mode (/s modifier).
302    */
303   public static final RESyntax RE_SYNTAX_PERL5_S;
304 
305     /**
306      * Predefined syntax.
307      * Emulates regular expression support in Java 1.4's java.util.regex
308      * package.
309      */
310     public static final RESyntax RE_SYNTAX_JAVA_1_4;
311 
312   static {
313       // Define syntaxes
314 
315       RE_SYNTAX_EMACS = new RESyntax().makeFinal();
316 
317       RESyntax RE_SYNTAX_POSIX_COMMON = new RESyntax()
318 	  .set(RE_CHAR_CLASSES)
319 	  .set(RE_DOT_NEWLINE)
320 	  .set(RE_DOT_NOT_NULL)
321 	  .set(RE_INTERVALS)
322 	  .set(RE_NO_EMPTY_RANGES)
323 	  .makeFinal();
324 
325       RE_SYNTAX_POSIX_BASIC = new RESyntax(RE_SYNTAX_POSIX_COMMON)
326 	  .set(RE_BK_PLUS_QM)
327 	  .makeFinal();
328 
329       RE_SYNTAX_POSIX_EXTENDED = new RESyntax(RE_SYNTAX_POSIX_COMMON)
330 	  .set(RE_CONTEXT_INDEP_ANCHORS)
331 	  .set(RE_CONTEXT_INDEP_OPS)
332 	  .set(RE_NO_BK_BRACES)
333 	  .set(RE_NO_BK_PARENS)
334 	  .set(RE_NO_BK_VBAR)
335 	  .set(RE_UNMATCHED_RIGHT_PAREN_ORD)
336 	  .makeFinal();
337 
338       RE_SYNTAX_AWK = new RESyntax()
339 	  .set(RE_BACKSLASH_ESCAPE_IN_LISTS)
340 	  .set(RE_DOT_NOT_NULL)
341 	  .set(RE_NO_BK_PARENS)
342 	  .set(RE_NO_BK_REFS)
343 	  .set(RE_NO_BK_VBAR)
344 	  .set(RE_NO_EMPTY_RANGES)
345 	  .set(RE_UNMATCHED_RIGHT_PAREN_ORD)
346 	  .makeFinal();
347 
348       RE_SYNTAX_POSIX_AWK = new RESyntax(RE_SYNTAX_POSIX_EXTENDED)
349 	  .set(RE_BACKSLASH_ESCAPE_IN_LISTS)
350 	  .makeFinal();
351 
352       RE_SYNTAX_GREP = new RESyntax()
353 	  .set(RE_BK_PLUS_QM)
354 	  .set(RE_CHAR_CLASSES)
355 	  .set(RE_HAT_LISTS_NOT_NEWLINE)
356 	  .set(RE_INTERVALS)
357 	  .set(RE_NEWLINE_ALT)
358 	  .makeFinal();
359 
360       RE_SYNTAX_EGREP = new RESyntax()
361 	  .set(RE_CHAR_CLASSES)
362 	  .set(RE_CONTEXT_INDEP_ANCHORS)
363 	  .set(RE_CONTEXT_INDEP_OPS)
364 	  .set(RE_HAT_LISTS_NOT_NEWLINE)
365 	  .set(RE_NEWLINE_ALT)
366 	  .set(RE_NO_BK_PARENS)
367 	  .set(RE_NO_BK_VBAR)
368 	  .makeFinal();
369 
370       RE_SYNTAX_POSIX_EGREP = new RESyntax(RE_SYNTAX_EGREP)
371 	  .set(RE_INTERVALS)
372 	  .set(RE_NO_BK_BRACES)
373 	  .makeFinal();
374 
375       /* P1003.2/D11.2, section 4.20.7.1, lines 5078ff.  */
376 
377       RE_SYNTAX_ED = new RESyntax(RE_SYNTAX_POSIX_BASIC)
378 	  .makeFinal();
379 
380       RE_SYNTAX_SED = new RESyntax(RE_SYNTAX_POSIX_BASIC)
381 	  .makeFinal();
382 
383       RE_SYNTAX_POSIX_MINIMAL_BASIC = new RESyntax(RE_SYNTAX_POSIX_COMMON)
384 	  .set(RE_LIMITED_OPS)
385 	  .makeFinal();
386 
387       /* Differs from RE_SYNTAX_POSIX_EXTENDED in that RE_CONTEXT_INVALID_OPS
388 	 replaces RE_CONTEXT_INDEP_OPS and RE_NO_BK_REFS is added. */
389 
390       RE_SYNTAX_POSIX_MINIMAL_EXTENDED = new RESyntax(RE_SYNTAX_POSIX_COMMON)
391 	  .set(RE_CONTEXT_INDEP_ANCHORS)
392 	  .set(RE_CONTEXT_INVALID_OPS)
393 	  .set(RE_NO_BK_BRACES)
394 	  .set(RE_NO_BK_PARENS)
395 	  .set(RE_NO_BK_REFS)
396 	  .set(RE_NO_BK_VBAR)
397 	  .set(RE_UNMATCHED_RIGHT_PAREN_ORD)
398 	  .makeFinal();
399 
400       /* There is no official Perl spec, but here's a "best guess" */
401 
402       RE_SYNTAX_PERL4 = new RESyntax()
403 	  .set(RE_BACKSLASH_ESCAPE_IN_LISTS)
404 	  .set(RE_CONTEXT_INDEP_ANCHORS)
405 	  .set(RE_CONTEXT_INDEP_OPS)          // except for '{', apparently
406 	  .set(RE_INTERVALS)
407 	  .set(RE_NO_BK_BRACES)
408 	  .set(RE_NO_BK_PARENS)
409 	  .set(RE_NO_BK_VBAR)
410 	  .set(RE_NO_EMPTY_RANGES)
411 	  .set(RE_CHAR_CLASS_ESCAPES)    // \d,\D,\w,\W,\s,\S
412 	  .makeFinal();
413 
414       RE_SYNTAX_PERL4_S = new RESyntax(RE_SYNTAX_PERL4)
415 	  .set(RE_DOT_NEWLINE)
416 	  .makeFinal();
417 
418       RE_SYNTAX_PERL5 = new RESyntax(RE_SYNTAX_PERL4)
419 	  .set(RE_PURE_GROUPING)          // (?:)
420 	  .set(RE_STINGY_OPS)             // *?,??,+?,{}?
421 	  .set(RE_LOOKAHEAD)              // (?=)(?!)
422 	  .set(RE_STRING_ANCHORS)         // \A,\Z
423 	  .set(RE_CHAR_CLASS_ESC_IN_LISTS)// \d,\D,\w,\W,\s,\S within []
424 	  .set(RE_COMMENTS)              // (?#)
425 	  .makeFinal();
426 
427       RE_SYNTAX_PERL5_S = new RESyntax(RE_SYNTAX_PERL5)
428 	  .set(RE_DOT_NEWLINE)
429 	  .makeFinal();
430 
431       RE_SYNTAX_JAVA_1_4 = new RESyntax(RE_SYNTAX_PERL5)
432 	  // XXX
433 	  .set(RE_POSSESSIVE_OPS)         // *+,?+,++,{}+
434 	  .makeFinal();
435   }
436 
437   /**
438    * Construct a new syntax object with all bits turned off.
439    * This is equivalent to RE_SYNTAX_EMACS.
440    */
RESyntax()441   public RESyntax() {
442     bits = new BitSet(BIT_TOTAL);
443   }
444 
445     /**
446      * Called internally when constructing predefined syntaxes
447      * so their interpretation cannot vary.  Conceivably useful
448      * for your syntaxes as well.  Causes IllegalAccessError to
449      * be thrown if any attempt to modify the syntax is made.
450      *
451      * @return this object for convenient chaining
452      */
makeFinal()453     public RESyntax makeFinal() {
454 	isFinal = true;
455 	return this;
456     }
457 
458   /**
459    * Construct a new syntax object with all bits set the same
460    * as the other syntax.
461    */
RESyntax(RESyntax other)462   public RESyntax(RESyntax other) {
463     bits = (BitSet) other.bits.clone();
464   }
465 
466   /**
467    * Check if a given bit is set in this syntax.
468    */
get(int index)469   public boolean get(int index) {
470     return bits.get(index);
471   }
472 
473   /**
474    * Set a given bit in this syntax.
475    *
476    * @param index the constant (RESyntax.RE_xxx) bit to set.
477    * @return a reference to this object for easy chaining.
478    */
set(int index)479   public RESyntax set(int index) {
480       if (isFinal) throw new IllegalAccessError(SYNTAX_IS_FINAL);
481     bits.set(index);
482     return this;
483   }
484 
485   /**
486    * Clear a given bit in this syntax.
487    *
488    * @param index the constant (RESyntax.RE_xxx) bit to clear.
489    * @return a reference to this object for easy chaining.
490    */
clear(int index)491   public RESyntax clear(int index) {
492       if (isFinal) throw new IllegalAccessError(SYNTAX_IS_FINAL);
493       bits.clear(index);
494       return this;
495   }
496 
497     /**
498      * Changes the line separator string for regular expressions
499      * created using this RESyntax.  The default separator is the
500      * value returned by the system property "line.separator", which
501      * should be correct when reading platform-specific files from a
502      * filesystem.  However, many programs may collect input from
503      * sources where the line separator is differently specified (for
504      * example, in the applet environment, the text box widget
505      * interprets line breaks as single-character newlines,
506      * regardless of the host platform.
507      *
508      * Note that setting the line separator to a character or
509      * characters that have specific meaning within the current syntax
510      * can cause unexpected chronosynclastic infundibula.
511      *
512      * @return this object for convenient chaining
513      */
setLineSeparator(String aSeparator)514     public RESyntax setLineSeparator(String aSeparator) {
515 	if (isFinal) throw new IllegalAccessError(SYNTAX_IS_FINAL);
516 	lineSeparator = aSeparator;
517 	return this;
518     }
519 
520     /**
521      * Returns the currently active line separator string.  The default
522      * is the platform-dependent system property "line.separator".
523      */
getLineSeparator()524     public String getLineSeparator() {
525 	return lineSeparator;
526     }
527 }
528