This is the mail archive of the
java-patches@gcc.gnu.org
mailing list for the Java project.
FYI: Patch: java.util.regex
- From: Michael Koch <konqueror at gmx dot de>
- To: java-patches at gcc dot gnu dot org
- Date: Wed, 30 Apr 2003 10:58:14 +0200
- Subject: FYI: Patch: java.util.regex
-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
Hi list,
I commited the attached patch to trunk to make the API of
java.util.regex compatible with JDK 1.4. The methods are mostly only
stubs. The real implementation needs still to be done.
Michael
- --
Homepage: http://www.worldforge.org/
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.1 (GNU/Linux)
iD8DBQE+r5AmWSOgCCdjSDsRAqDeAJ96eOPFpvEi/V/x7n4J4A7pKvFFiwCfaa/J
nTBQeaouKKLiqpcWXaVkbok=
=txtR
-----END PGP SIGNATURE-----
Index: ChangeLog
===================================================================
RCS file: /cvs/gcc/gcc/libjava/ChangeLog,v
retrieving revision 1.1863
diff -u -r1.1863 ChangeLog
--- ChangeLog 30 Apr 2003 07:23:37 -0000 1.1863
+++ ChangeLog 30 Apr 2003 08:53:33 -0000
@@ -1,5 +1,40 @@
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,
gnu/java/security/OID.java,
gnu/java/security/der/BitString.java,
Index: java/util/regex/Matcher.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/util/regex/Matcher.java,v
retrieving revision 1.1
diff -u -r1.1 Matcher.java
--- java/util/regex/Matcher.java 18 Sep 2002 10:15:52 -0000 1.1
+++ java/util/regex/Matcher.java 30 Apr 2003 08:53:33 -0000
@@ -35,17 +35,188 @@
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");
}
}
Index: java/util/regex/Pattern.java
===================================================================
RCS file: /cvs/gcc/gcc/libjava/java/util/regex/Pattern.java,v
retrieving revision 1.2
diff -u -r1.2 Pattern.java
--- java/util/regex/Pattern.java 24 Mar 2003 13:56:57 -0000 1.2
+++ java/util/regex/Pattern.java 30 Apr 2003 08:53:33 -0000
@@ -40,22 +40,112 @@
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
{
- throw new InternalError("Not implemented yet");
+ this (regex, 0);
}
- public static boolean matches(String regex, CharSequence input)
+
+ private Pattern (String regex, int flags)
+ throws PatternSyntaxException
{
- throw new InternalError("Not implemented yet");
+ this.regex = regex;
+ this.flags = flags;
+
+ throw new Error ("Not implemented");
}
- public Matcher matcher(CharSequence input)
+
+ /**
+ * @param regex The regular expression
+ *
+ * @exception PatternSyntaxException If the expression's syntax is invalid
+ */
+ public static Pattern compile (String regex)
+ throws PatternSyntaxException
{
- throw new InternalError("Not implemented yet");
+ throw new Error ("Not implemented");
}
- public String[] split(CharSequence input, int limit)
+
+ /**
+ * @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
{
- throw new InternalError("Not implemented yet");
+ // 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 Error ("Not implemented");
+ }
+
+ /**
+ * @param input The character sequence to be matched
+ */
+ public String[] split (CharSequence input)
+ {
+ throw new Error ("Not implemented");
+ }
+
+ /**
+ * @param input The character sequence to be matched
+ * @param limit The result threshold
+ */
+ public String[] split (CharSequence input, int limit)
+ {
+ throw new Error ("Not implemented");
+ }
+
+ public String pattern ()
+ {
+ throw new Error ("Not implemented");
}
}