+2003-04-30 Michael Koch <konqueror@gmx.de>
+
+ * java/util/regex/Matcher.java
+ (pattern): New member variable.
+ (appendReplacement): New method.
+ (appendTail): New method.
+ (end): New method.
+ (find): New method.
+ (group): New method.
+ (replaceFirst): Added documentation.
+ (replaceAll): Added documentation.
+ (groupCount): New method.
+ (lookingAt): New method.
+ (matches): New method.
+ (reset): New method.
+ (start): New method.
+ * java/util/regex/Pattern.java
+ (serialVersionUID): New constant.
+ (CANON_EQ): New constant.
+ (CASE_INSENSITIVE): New constant.
+ (COMMENTS): New constant.
+ (DOTALL): New constant.
+ (MULTILINE): New constant.
+ (UNICODE_CASE): New constant.
+ (UNIX_LINES): New constant.
+ (regex): New member variable.
+ (flags): New member variable.
+ (Pattern): New method.
+ (compile): Documentation added.
+ (flags): New method.
+ (matches): Documentation added.
+ (matcher): Documentation added.
+ (split): Documentation added.
+ (pattern): New method.
+
2003-04-30 Michael Koch <konqueror@gmx.de>
* gnu/java/security/Engine.java,
obligated to do so. If you do not wish to do so, delete this
exception statement from your version. */
-// Stub class until java.util.regex is implemented.
+
package java.util.regex;
+/**
+ * @author Michael Koch
+ * @since 1.4
+ */
public class Matcher
{
- public String replaceFirst(String replacement)
+ private Pattern pattern;
+
+ /**
+ * @param sb The target string buffer
+ * @param replacement The replacement string
+ *
+ * @exception IllegalStateException If no match has yet been attempted,
+ * or if the previous match operation failed
+ * @exception IndexOutOfBoundsException If the replacement string refers
+ * to a capturing group that does not exist in the pattern
+ */
+ public Matcher appendReplacement (StringBuffer sb, String replacement)
+ throws IllegalStateException
+ {
+ throw new Error("Not implemented");
+ }
+
+ /**
+ * @param sb The target string buffer
+ */
+ public StringBuffer appendTail (StringBuffer sb)
+ {
+ throw new Error("Not implemented");
+ }
+
+ /**
+ * @exception IllegalStateException If no match has yet been attempted,
+ * or if the previous match operation failed
+ */
+ public int end ()
+ throws IllegalStateException
+ {
+ throw new Error ("Not implemented");
+ }
+
+ /**
+ * @param group The index of a capturing group in this matcher's pattern
+ *
+ * @exception IllegalStateException If no match has yet been attempted,
+ * or if the previous match operation failed
+ * @exception IndexOutOfBoundsException If the replacement string refers
+ * to a capturing group that does not exist in the pattern
+ */
+ public int end (int group)
+ throws IllegalStateException
+ {
+ throw new Error ("Not implemented");
+ }
+
+ public boolean find ()
+ {
+ throw new Error ("Not implemented");
+ }
+
+ /**
+ * @param start The index to start the new pattern matching
+ *
+ * @exception IndexOutOfBoundsException If the replacement string refers
+ * to a capturing group that does not exist in the pattern
+ */
+ public boolean find (int start)
+ {
+ throw new Error ("Not implemented");
+ }
+
+ /**
+ * @exception IllegalStateException If no match has yet been attempted,
+ * or if the previous match operation failed
+ */
+ public String group ()
+ {
+ throw new Error ("Not implemented");
+ }
+
+ /**
+ * @param group The index of a capturing group in this matcher's pattern
+ *
+ * @exception IllegalStateException If no match has yet been attempted,
+ * or if the previous match operation failed
+ * @exception IndexOutOfBoundsException If the replacement string refers
+ * to a capturing group that does not exist in the pattern
+ */
+ public String group (int group)
+ throws IllegalStateException
+ {
+ throw new Error ("Not implemented");
+ }
+
+ /**
+ * @param replacement The replacement string
+ */
+ public String replaceFirst (String replacement)
{
- throw new InternalError("Not implemented yet");
+ throw new Error ("Not implemented");
}
- public String replaceAll(String replacement)
+
+ /**
+ * @param replacement The replacement string
+ */
+ public String replaceAll (String replacement)
+ {
+ throw new Error ("Not implemented");
+ }
+
+ public int groupCount ()
+ {
+ throw new Error("Not implemented");
+ }
+
+ public boolean lookingAt ()
+ {
+ throw new Error("Not implemented");
+ }
+
+ /**
+ * Attempts to match the entire input sequence against the pattern.
+ *
+ * If the match succeeds then more information can be obtained via the
+ * start, end, and group methods.
+ *
+ * @see #start
+ * @see #end
+ * @see #group
+ */
+ public boolean matches ()
+ {
+ throw new Error("Not implemented");
+ }
+
+ /**
+ * Returns the Pattern that is interpreted by this Matcher
+ */
+ public Pattern pattern ()
+ {
+ return pattern;
+ }
+
+ public Matcher reset ()
+ {
+ throw new Error ("Not implemented");
+ }
+
+ /**
+ * @param input The new input character sequence
+ */
+ public Matcher reset (CharSequence input)
+ {
+ throw new Error ("Not implemented");
+ }
+
+ /**
+ * @param group The index of a capturing group in this matcher's pattern
+ *
+ * @exception IllegalStateException If no match has yet been attempted,
+ * or if the previous match operation failed
+ */
+ public int start ()
+ throws IllegalStateException
+ {
+ throw new Error("Not implemented");
+ }
+
+ /**
+ * @param group The index of a capturing group in this matcher's pattern
+ *
+ * @exception IllegalStateException If no match has yet been attempted,
+ * or if the previous match operation failed
+ * @exception IndexOutOfBoundsException If the replacement string refers
+ * to a capturing group that does not exist in the pattern
+ */
+ public int start (int group)
+ throws IllegalStateException
{
- throw new InternalError("Not implemented yet");
+ throw new Error("Not implemented");
}
}
import java.io.Serializable;
+/**
+ * @author Michael Koch
+ * @since 1.4
+ */
public class Pattern implements Serializable
{
- public static Pattern compile(String regex)
+ private static final long serialVersionUID = 5073258162644648461L;
+
+ public static final int CANON_EQ = 128;
+ public static final int CASE_INSENSITIVE = 2;
+ public static final int COMMENTS = 4;
+ public static final int DOTALL = 32;
+ public static final int MULTILINE = 8;
+ public static final int UNICODE_CASE = 64;
+ public static final int UNIX_LINES = 1;
+
+ private String regex;
+ private int flags;
+
+ private Pattern (String regex)
+ throws PatternSyntaxException
+ {
+ this (regex, 0);
+ }
+
+ private Pattern (String regex, int flags)
+ throws PatternSyntaxException
+ {
+ this.regex = regex;
+ this.flags = flags;
+
+ throw new Error ("Not implemented");
+ }
+
+ /**
+ * @param regex The regular expression
+ *
+ * @exception PatternSyntaxException If the expression's syntax is invalid
+ */
+ public static Pattern compile (String regex)
+ throws PatternSyntaxException
+ {
+ throw new Error ("Not implemented");
+ }
+
+ /**
+ * @param regex The regular expression
+ * @param flags The match flags, a bit mask
+ *
+ * @exception PatternSyntaxException If the expression's syntax is invalid
+ * @exception IllegalArgumentException If bit values other than those
+ * corresponding to the defined match flags are set in flags
+ */
+ public static Pattern compile (String regex, int flags)
+ throws PatternSyntaxException
+ {
+ // FIXME: check which flags are really accepted
+ if ((flags & ~0xEF) != 0)
+ throw new IllegalArgumentException ();
+
+ return new Pattern (regex, flags);
+ }
+
+ public int flags ()
+ {
+ return this.flags;
+ }
+
+ /**
+ * @param regex The regular expression
+ * @param input The character sequence to be matched
+ *
+ * @exception PatternSyntaxException If the expression's syntax is invalid
+ */
+ public static boolean matches (String regex, CharSequence input)
+ {
+ throw new Error ("Not implemented");
+ }
+
+ /**
+ * @param input The character sequence to be matched
+ */
+ public Matcher matcher (CharSequence input)
{
- throw new InternalError("Not implemented yet");
+ throw new Error ("Not implemented");
}
- public static boolean matches(String regex, CharSequence input)
+
+ /**
+ * @param input The character sequence to be matched
+ */
+ public String[] split (CharSequence input)
{
- throw new InternalError("Not implemented yet");
+ throw new Error ("Not implemented");
}
- public Matcher matcher(CharSequence input)
+
+ /**
+ * @param input The character sequence to be matched
+ * @param limit The result threshold
+ */
+ public String[] split (CharSequence input, int limit)
{
- throw new InternalError("Not implemented yet");
+ throw new Error ("Not implemented");
}
- public String[] split(CharSequence input, int limit)
+
+ public String pattern ()
{
- throw new InternalError("Not implemented yet");
+ throw new Error ("Not implemented");
}
}
projects / gcc.git / commitdiff