procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

2003-04-30 Michael Koch <konqueror@gmx.de>

Browse source 
* 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
This commit is contained in:
Michael Koch 2003-04-30 08:57:04 +00:00 • committed by Michael Koch
parent 859a3d9a1d
commit ad03daf005
3 changed files with 309 additions and 13 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

35
libjava/ChangeLog
View file

@ -1,3 +1,38 @@
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,

181
libjava/java/util/regex/Matcher.java
View file

@ -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 InternalError("Not implemented yet");
throw new Error("Not implemented");
}
public String replaceAll(String replacement)
/**
* @param sb The target string buffer
*/
public StringBuffer appendTail (StringBuffer sb)
{
throw new InternalError("Not implemented yet");
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 Error ("Not implemented");
}
/**
* @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 Error("Not implemented");
}
}

106
libjava/java/util/regex/Pattern.java
View file

@ -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
{
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");
}
}