From 3831381763ca5f41d6f7406d590e1e38a8531e1c Mon Sep 17 00:00:00 2001
From: Tom Tromey <tromey@redhat.com>
Date: Tue, 18 Jun 2002 15:40:16 +0000
Subject: javaprims.h: Updated class declaration list.
* gcj/javaprims.h: Updated class declaration list.
* Makefile.in: Rebuilt.
* Makefile.am (core_java_source_files): Added
PropertyPermissionCollection.java.
* java/lang/Thread.java (group, name): Now package-private.
* java/lang/ThreadGroup.java: Re-merge with Classpath.
* java/util/AbstractList.java: Likewise.
* java/util/AbstractMap.java: Likewise.
* java/util/Calendar.java: Likewise.
* java/util/Collections.java: Likewise.
* java/util/HashMap.java: Likewise.
* java/util/Hashtable.java: Likewise.
* java/util/LinkedHashMap.java: Likewise.
* java/util/LinkedList.java: Likewise.
* java/util/List.java: Likewise.
* java/util/ListResourceBundle.java: Likewise.
* java/util/Map.java: Likewise.
* java/util/Observable.java: Likewise.
* java/util/Properties.java: Likewise.
* java/util/PropertyPermission.java: Likewise.
* java/util/PropertyPermissionCollection.java: Likewise.
* java/util/PropertyResourceBundle.java: Likewise.
* java/util/Random.java: Likewise.
* java/util/SimpleTimeZone.java: Likewise.
* java/util/StringTokenizer.java: Likewise.
* java/util/TimerTask.java: Likewise.
* java/util/TreeMap.java: Likewise.
* java/util/WeakHashMap.java: Likewise.
* java/util/jar/Attributes.java: Likewise.
* java/util/jar/JarException.java: Likewise.
* java/util/jar/Manifest.java: Likewise.
From-SVN: r54743
---
libjava/java/util/StringTokenizer.java | 191 ++++++++++++++++-----------------
1 file changed, 93 insertions(+), 98 deletions(-)
(limited to 'libjava/java/util/StringTokenizer.java')
diff --git a/libjava/java/util/StringTokenizer.java b/libjava/java/util/StringTokenizer.java
index 707ddd4..e7fc6fd 100644
--- a/libjava/java/util/StringTokenizer.java
+++ b/libjava/java/util/StringTokenizer.java
@@ -1,5 +1,5 @@
-/* java.util.StringTokenizer
- Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
+/* StringTokenizer -- breaks a String into tokens
+ Copyright (C) 1998, 1999, 2001, 2002 Free Software Foundation, Inc.
This file is part of GNU Classpath.
@@ -39,75 +39,79 @@ exception statement from your version. */
package java.util;
/**
- * This class splits a string into tokens. The caller can set on which
+ * This class splits a string into tokens. The caller can set on which
* delimiters the string should be split and if the delimiters should be
- * returned.
+ * returned. This is much simpler than {@link java.io.StreamTokenizer}.
*
- * You may change the delimiter set on the fly by calling
+ * <p>You may change the delimiter set on the fly by calling
* nextToken(String). But the semantic is quite difficult; it even
* depends on calling <code>hasMoreTokens()</code>. You should call
* <code>hasMoreTokens()</code> before, otherwise the old delimiters
- * after the last token are returned.
+ * after the last token are candidates for being returned.
*
- * If you want to get the delimiters, you have to use the three argument
+ * <p>If you want to get the delimiters, you have to use the three argument
* constructor. The delimiters are returned as token consisting of a
- * single character.
+ * single character.
*
* @author Jochen Hoenicke
* @author Warren Levy <warrenl@cygnus.com>
+ * @see java.io.StreamTokenizer
+ * @status updated to 1.4
*/
public class StringTokenizer implements Enumeration
{
+ // WARNING: StringTokenizer is a CORE class in the bootstrap cycle. See the
+ // comments in vm/reference/java/lang/Runtime for implications of this fact.
+
/**
* The position in the str, where we currently are.
*/
private int pos;
+
/**
* The string that should be split into tokens.
*/
- private String str;
+ private final String str;
+
+ /**
+ * The length of the string.
+ */
+ private final int len;
+
/**
* The string containing the delimiter characters.
*/
private String delim;
+
/**
* Tells, if we should return the delimiters.
*/
- private boolean retDelims;
-
- /*{
- invariant {
- pos >= 0 :: "position is negative";
- pos <= str.length() :: "position is out of string";
- str != null :: "String is null";
- delim != null :: "Delimiters are null";
- }
- } */
+ private final boolean retDelims;
/**
* Creates a new StringTokenizer for the string <code>str</code>,
- * that should split on the default delimiter set (space, tap,
+ * that should split on the default delimiter set (space, tab,
* newline, return and formfeed), and which doesn't return the
* delimiters.
- * @param str The string to split.
+ *
+ * @param str The string to split
+ * @throws NullPointerException if str is null
*/
public StringTokenizer(String str)
- /*{ require { str != null :: "str must not be null"; } } */
{
this(str, " \t\n\r\f", false);
}
/**
- * Create a new StringTokenizer, that splits the given string on
+ * Create a new StringTokenizer, that splits the given string on
* the given delimiter characters. It doesn't return the delimiter
* characters.
*
- * @param str The string to split.
- * @param delim A string containing all delimiter characters.
+ * @param str the string to split
+ * @param delim a string containing all delimiter characters
+ * @throws NullPointerException if either argument is null
*/
public StringTokenizer(String str, String delim)
- /*{ require { str != null :: "str must not be null";
- delim != null :: "delim must not be null"; } } */
{
this(str, delim, false);
}
@@ -119,34 +123,34 @@ public class StringTokenizer implements Enumeration
* characters are returned as tokens of their own. The delimiter
* tokens always consist of a single character.
*
- * @param str The string to split.
- * @param delim A string containing all delimiter characters.
- * @param returnDelims Tells, if you want to get the delimiters.
+ * @param str the string to split
+ * @param delim a string containing all delimiter characters
+ * @param returnDelims tells, if you want to get the delimiters
+ * @throws NullPointerException if str or delim is null
*/
public StringTokenizer(String str, String delim, boolean returnDelims)
- /*{ require { str != null :: "str must not be null";
- delim != null :: "delim must not be null"; } } */
{
+ len = str.length();
this.str = str;
- this.delim = delim;
+ // The toString() hack causes the NullPointerException.
+ this.delim = delim.toString();
this.retDelims = returnDelims;
this.pos = 0;
}
/**
* Tells if there are more tokens.
- * @return True, if the next call of nextToken() succeeds, false otherwise.
+ *
+ * @return true if the next call of nextToken() will succeed
*/
public boolean hasMoreTokens()
{
- if (!retDelims)
+ if (! retDelims)
{
- while (pos < str.length() && delim.indexOf(str.charAt(pos)) > -1)
- {
- pos++;
- }
+ while (pos < len && delim.indexOf(str.charAt(pos)) >= 0)
+ pos++;
}
- return pos < str.length();
+ return pos < len;
}
/**
@@ -154,13 +158,13 @@ public class StringTokenizer implements Enumeration
* <code>delim</code>. The change of the delimiter set is
* permanent, ie. the next call of nextToken(), uses the same
* delimiter set.
- * @param delim a string containing the new delimiter characters.
- * @return the next token with respect to the new delimiter characters.
- * @exception NoSuchElementException if there are no more tokens.
+ *
+ * @param delim a string containing the new delimiter characters
+ * @return the next token with respect to the new delimiter characters
+ * @throws NoSuchElementException if there are no more tokens
+ * @throws NullPointerException if delim is null
*/
public String nextToken(String delim) throws NoSuchElementException
- /*{ require { hasMoreTokens() :: "no more Tokens available";
- ensure { $return != null && $return.length() > 0; } } */
{
this.delim = delim;
return nextToken();
@@ -168,32 +172,24 @@ public class StringTokenizer implements Enumeration
/**
* Returns the nextToken of the string.
- * @param delim a string containing the new delimiter characters.
- * @return the next token with respect to the new delimiter characters.
- * @exception NoSuchElementException if there are no more tokens.
+ *
+ * @return the next token with respect to the current delimiter characters
+ * @throws NoSuchElementException if there are no more tokens
*/
public String nextToken() throws NoSuchElementException
- /*{ require { hasMoreTokens() :: "no more Tokens available";
- ensure { $return != null && $return.length() > 0; } } */
{
- if (pos < str.length() && delim.indexOf(str.charAt(pos)) > -1)
+ if (pos < len && delim.indexOf(str.charAt(pos)) >= 0)
{
- if (retDelims)
- return str.substring(pos, ++pos);
-
- while (++pos < str.length() && delim.indexOf(str.charAt(pos)) > -1)
- {
- /* empty */
- }
+ if (retDelims)
+ return str.substring(pos, ++pos);
+ while (++pos < len && delim.indexOf(str.charAt(pos)) >= 0);
}
- if (pos < str.length())
+ if (pos < len)
{
- int start = pos;
- while (++pos < str.length() && delim.indexOf(str.charAt(pos)) == -1)
- {
- /* empty */
- }
- return str.substring(start, pos);
+ int start = pos;
+ while (++pos < len && delim.indexOf(str.charAt(pos)) < 0);
+
+ return str.substring(start, pos);
}
throw new NoSuchElementException();
}
@@ -201,9 +197,9 @@ public class StringTokenizer implements Enumeration
/**
* This does the same as hasMoreTokens. This is the
* <code>Enumeration</code interface method.
- * @return True, if the next call of nextElement() succeeds, false
- * otherwise.
- * @see #hasMoreTokens
+ *
+ * @return true, if the next call of nextElement() will succeed
+ * @see #hasMoreTokens()
*/
public boolean hasMoreElements()
{
@@ -213,9 +209,10 @@ public class StringTokenizer implements Enumeration
/**
* This does the same as nextTokens. This is the
* <code>Enumeration</code interface method.
- * @return the next token with respect to the new delimiter characters.
- * @exception NoSuchElementException if there are no more tokens.
- * @see #nextToken
+ *
+ * @return the next token with respect to the current delimiter characters
+ * @throws NoSuchElementException if there are no more tokens
+ * @see #nextToken()
*/
public Object nextElement() throws NoSuchElementException
{
@@ -225,49 +222,47 @@ public class StringTokenizer implements Enumeration
/**
* This counts the number of remaining tokens in the string, with
* respect to the current delimiter set.
- * @return the number of times <code>nextTokens()</code> will
- * succeed.
- * @see #nextToken
+ *
+ * @return the number of times <code>nextTokens()</code> will succeed
+ * @see #nextToken()
*/
public int countTokens()
{
int count = 0;
int delimiterCount = 0;
- boolean tokenFound = false; // Set when a non-delimiter is found
+ boolean tokenFound = false; // Set when a non-delimiter is found
int tmpPos = pos;
// Note for efficiency, we count up the delimiters rather than check
// retDelims every time we encounter one. That way, we can
// just do the conditional once at the end of the method
- while (tmpPos < str.length())
+ while (tmpPos < len)
{
- if (delim.indexOf(str.charAt(tmpPos++)) > -1)
- {
- if (tokenFound)
- {
- // Got to the end of a token
- count++;
- tokenFound = false;
- }
-
- delimiterCount++; // Increment for this delimiter
- }
- else
- {
- tokenFound = true;
-
- // Get to the end of the token
- while (tmpPos < str.length()
- && delim.indexOf(str.charAt(tmpPos)) == -1)
- ++tmpPos;
- }
+ if (delim.indexOf(str.charAt(tmpPos++)) >= 0)
+ {
+ if (tokenFound)
+ {
+ // Got to the end of a token
+ count++;
+ tokenFound = false;
+ }
+ delimiterCount++; // Increment for this delimiter
+ }
+ else
+ {
+ tokenFound = true;
+ // Get to the end of the token
+ while (tmpPos < len
+ && delim.indexOf(str.charAt(tmpPos)) < 0)
+ ++tmpPos;
+ }
}
- // Make sure to count the last token
+ // Make sure to count the last token
if (tokenFound)
count++;
// if counting delmiters add them into the token count
return retDelims ? count + delimiterCount : count;
}
-}
+} // class StringTokenizer
--
cgit v1.1