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.

From-SVN: r66285

2 files changed, 274 insertions, 13 deletions

diff --git a/libjava/java/util/regex/Matcher.java b/libjava/java/util/regex/Matcher.java
index a1f95db..ef65557 100644
--- a/libjava/java/util/regex/Matcher.java
+++ b/libjava/java/util/regex/Matcher.java
@@ -35,17 +35,188 @@ this exception to your version of the library, but you are not
 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");
   }
 }
diff --git a/libjava/java/util/regex/Pattern.java b/libjava/java/util/regex/Pattern.java
index 39a01ba..7d99b92 100644
--- a/libjava/java/util/regex/Pattern.java
+++ b/libjava/java/util/regex/Pattern.java
@@ -40,22 +40,112 @@ package java.util.regex;
 
 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");
   }
 }