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

ArrayList.java: Remove RCS keywords from comments

Browse source 
* java/util/ArrayList.java: Remove RCS keywords from comments
    * java/util/BasicMapEntry.java: idem
    * java/util/Dictionary.java: idem
    * java/util/HashSet.java: idem

    * java/util/EventObject.java: reindent
    * java/util/Properties.java: idem
    * java/util/SortedMap.java: idem

    * java/util/Enumeration.java: Merge with Classpath
    * java/util/EventListener.java: idem
    * java/util/Observable.java: idem
    * java/util/Observer.java: idem
    * java/util/Stack.java: idem

From-SVN: r40639
This commit is contained in:
Mark Wielaard 2001-03-19 23:00:18 +00:00 • committed by Mark Wielaard
parent 80fc2e84d9
commit 86c9776ba2
13 changed files with 802 additions and 533 deletions
Download patch file Download diff file Expand all files Collapse all files

17
libjava/ChangeLog
View file

@ -1,3 +1,20 @@
2001-03-19 Mark Wielaard <mark@klomp.org>
* java/util/ArrayList.java: Remove RCS keywords from comments
* java/util/BasicMapEntry.java: idem
* java/util/Dictionary.java: idem
* java/util/HashSet.java: idem
* java/util/EventObject.java: reindent
* java/util/Properties.java: idem
* java/util/SortedMap.java: idem
* java/util/Enumeration.java: Merge with Classpath
* java/util/EventListener.java: idem
* java/util/Observable.java: idem
* java/util/Observer.java: idem
* java/util/Stack.java: idem
2001-03-17 Tom Tromey <tromey@redhat.com> 2001-03-17 Tom Tromey <tromey@redhat.com>
* java/lang/natString.cc (rehash): Don't bother with memset; * java/lang/natString.cc (rehash): Don't bother with memset;

1
libjava/java/util/ArrayList.java
View file

@ -40,7 +40,6 @@ import java.io.ObjectOutputStream;
* to or removing from the end of a list, checking the size, &c. * to or removing from the end of a list, checking the size, &c.
* *
* @author Jon A. Zeppieri * @author Jon A. Zeppieri
* @version $Id: ArrayList.java,v 1.12 2000/12/17 07:54:39 cbj Exp $
* @see java.util.AbstractList * @see java.util.AbstractList
* @see java.util.List * @see java.util.List
*/ */

2
libjava/java/util/BasicMapEntry.java
View file

@ -33,8 +33,6 @@ package java.util;
* Hashtable. * Hashtable.
* *
* @author Jon Zeppieri * @author Jon Zeppieri
* @version $Revision: 1.5 $
* @modified $Id: BasicMapEntry.java,v 1.5 2000/10/26 10:19:00 bryce Exp $
*/ */
class BasicMapEntry implements Map.Entry class BasicMapEntry implements Map.Entry
{ {

2
libjava/java/util/Dictionary.java
View file

@ -40,8 +40,6 @@ package java.util;
* in the Collections framework. * in the Collections framework.
* *
* @author Jon Zeppieri * @author Jon Zeppieri
* @version $Revision: 1.4 $
* @modified $Id: Dictionary.java,v 1.4 2000/10/26 10:19:00 bryce Exp $
*/ */
public abstract class Dictionary extends Object public abstract class Dictionary extends Object
{ {

67
libjava/java/util/Enumeration.java
View file

@ -1,24 +1,65 @@
/* Copyright (C) 1998, 1999 Free Software Foundation /* Enumeration.java -- Interface for enumerating lists of objects
Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
This file is part of libgcj. This file is part of GNU Classpath.
This software is copyrighted work licensed under the terms of the GNU Classpath is free software; you can redistribute it and/or modify
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for it under the terms of the GNU General Public License as published by
details. */ the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
package java.util; package java.util;
/**
* @author Warren Levy <warrenl@cygnus.com>
* @date August 25, 1998.
*/
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 /* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
* "The Java Language Specification", ISBN 0-201-63451-1. * "The Java Language Specification", ISBN 0-201-63451-1.
* Status: Believed complete and correct * Status: Believed complete and correct
*/ */
/**
* Interface for lists of objects that can be returned in sequence. Successive
* objects are obtained by the nextElement method.
* <p>
* As of Java 1.2, the Iterator interface provides the same functionality, but
* with shorter method names and a new optional method to remove items from the
* list. If writing for 1.2, consider using Iterator instead. Enumerations over
* the new collections classes, for use with legacy APIs that require them, can
* be obtained by the enumeration method in class Collections.
*
* @author Warren Levy <warrenl@cygnus.com>
* @date August 25, 1998.
*/
public interface Enumeration public interface Enumeration
{ {
public boolean hasMoreElements(); /**
public Object nextElement() throws NoSuchElementException; * Tests whether there are elements remaining in the enumeration.
*
* @return true if there is at least one more element in the enumeration,
* that is, if the next call to nextElement will not throw a
* NoSuchElementException.
*/
boolean hasMoreElements();
/**
* Obtain the next element in the enumeration.
*
* @return the next element in the enumeration
* @exception NoSuchElementException if there are no more elements
*/
Object nextElement() throws NoSuchElementException;
} }

45
libjava/java/util/EventListener.java
View file

@ -1,24 +1,47 @@
// EventListener.java - Listen for events from event source. /* An interface that all event listener interfaces must extend
Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
/* Copyright (C) 1998, 1999 Free Software Foundation This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
This file is part of libgcj.
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
package java.util; package java.util;
/**
* @author Tom Tromey <tromey@cygnus.com>
* @date December 12, 1998
*/
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 /* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
* "The Java Language Specification", ISBN 0-201-63451-1 * "The Java Language Specification", ISBN 0-201-63451-1
* Status: Believed complete and correct. * Status: Believed complete and correct.
*/ */
/**
* Empty interface that is implemented by classes that need to receive
* events. Subinterfaces define methods that can be called to fire an
* event notification. Normally the name of these subinterfaces end in
* <code>Listener</code> and all method described by the subinterface
* take as argument an subclass of <code>EventObject</code>.
*
* @author Tom Tromey <tromey@cygnus.com>
* @date December 12, 1998
*/
public interface EventListener public interface EventListener
{ {
} }

36
libjava/java/util/EventObject.java
View file

@ -1,28 +1,28 @@
/* EventObject.java - Represent events fired by objects. /* EventObject.java - Represent events fired by objects.
Copyright (C) 1999, 2000 Free Software Foundation, Inc. Copyright (C) 1999, 2000 Free Software Foundation, Inc.
This file is part of GNU Classpath. This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option) the Free Software Foundation; either version 2, or (at your option)
any later version. any later version.
GNU Classpath is distributed in the hope that it will be useful, but GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details. General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. 02111-1307 USA.
As a special exception, if you link this library with other files to As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License. resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */ executable file might be covered by the GNU General Public License. */
package java.util; package java.util;

2
libjava/java/util/HashSet.java
View file

@ -45,8 +45,6 @@ import java.io.ObjectOutputStream;
* HashSet is a part of the JDK1.2 Collections API. * HashSet is a part of the JDK1.2 Collections API.
* *
* @author Jon Zeppieri * @author Jon Zeppieri
* @version $Revision: 1.3 $
* @modified $Id: HashSet.java,v 1.3 2001/02/15 05:12:05 bryce Exp $
*/ */
public class HashSet extends AbstractSet public class HashSet extends AbstractSet
implements Set, Cloneable, Serializable implements Set, Cloneable, Serializable

123
libjava/java/util/Observable.java
View file

@ -1,30 +1,49 @@
/* Copyright (C) 1998, 1999 Free Software Foundation /* java.util.Observable
Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
This file is part of libgcj. This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
package java.util; package java.util;
/**
* @author Warren Levy <warrenl@cygnus.com>
* @date September 2, 1998.
*/
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 /* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
* "The Java Language Specification", ISBN 0-201-63451-1 * "The Java Language Specification", ISBN 0-201-63451-1
* plus online API docs for JDK 1.2 beta from http://www.javasoft.com. * plus online API docs for JDK 1.2 beta from http://www.javasoft.com.
* Status: Believed complete and correct. * Status: Believed complete and correct.
*/ */
/**
* @author Warren Levy <warrenl@cygnus.com>
* @date September 2, 1998.
*/
public class Observable public class Observable
{ {
/* tracks whether this object has changed */ /** tracks whether this object has changed */
private boolean changed; private boolean changed;
/* list of the Observers registered as interested in this Observable */ /* list of the Observers registered as interested in this Observable */
private Vector observerVec; private Vector observers;
/* TBD: This might be better implemented as an Observer[] /* TBD: This might be better implemented as an Observer[]
* but that would mean writing more code rather than making use of * but that would mean writing more code rather than making use of
@ -34,63 +53,101 @@ public class Observable
* we may decide to make the tradeoff and reimplement with an Observer[]. * we may decide to make the tradeoff and reimplement with an Observer[].
*/ */
/**
* Constructs an Observable with zero Observers.
*/
public Observable() public Observable()
{ {
changed = false; changed = false;
observerVec = new Vector(); observers = new Vector();
} }
public synchronized void addObserver(Observer obs) /**
* Adds an Observer. If the observer was already added this method does
* nothing.
*
* @param observer Observer to add.
*/
public synchronized void addObserver(Observer observer)
{ {
// JDK 1.2 spec says not to add this if it is already there if (!observers.contains(observer))
if (!observerVec.contains(obs)) observers.addElement(observer);
observerVec.addElement(obs);
} }
/**
* Reset this Observable's state to unchanged.
*/
protected synchronized void clearChanged() protected synchronized void clearChanged()
{ {
changed = false; changed = false;
} }
/**
* @return Number of Observers for this Observable.
*/
public synchronized int countObservers() public synchronized int countObservers()
{ {
return observerVec.size(); return observers.size();
} }
public synchronized void deleteObserver(Observer obs) /**
* Deletes an Observer of this Observable.
*
* @param victim Observer to delete.
*/
public synchronized void deleteObserver(Observer victim)
{ {
observerVec.removeElement(obs); observers.removeElement(victim);
} }
/**
* Deletes all Observers of this Observable.
*/
public synchronized void deleteObservers() public synchronized void deleteObservers()
{ {
observerVec.removeAllElements(); observers.removeAllElements();
} }
/**
* @return Whether or not this Observable has changed.
*/
public synchronized boolean hasChanged() public synchronized boolean hasChanged()
{ {
return changed; return changed;
} }
/**
* If the Observable has actually changed then tell all Observers about it,
* then resets state to unchanged.
*/
public void notifyObservers() public void notifyObservers()
{ {
notifyObservers(null); notifyObservers(null);
} }
public void notifyObservers(Object arg) /**
* If the Observable has actually changed then tell all Observers about it,
* then resets state to unchanged.
* Note that though the order of notification is unspecified in subclasses,
* in Observable it is in the order of registration.
*
* @param obj Arguement to Observer's update method.
*/
public void notifyObservers(Object obj)
{ {
if (changed) if (!hasChanged())
{ return;
/* The JDK 1.2 spec states that though the order of notification Vector ob1 = (Vector) observers.clone();
* is unspecified in subclasses, in Observable it is in the order
* of registration. for (int i = 0; i < ob1.size(); i++)
*/ ((Observer) ob1.elementAt(i)).update(this, obj);
for (int i = 0, numObs = observerVec.size(); i < numObs; i++)
((Observer) (observerVec.elementAt(i))).update(this, arg); clearChanged();
changed = false;
}
} }
/**
* Marks this Observable as having changed.
*/
protected synchronized void setChanged() protected synchronized void setChanged()
{ {
changed = true; changed = true;

48
libjava/java/util/Observer.java
View file

@ -1,24 +1,48 @@
/* Copyright (C) 1998, 1999 Free Software Foundation /* Implemented when a class wants to be informed of changes in Observable
objects.
Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
This file is part of libgcj. This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
package java.util; package java.util;
/**
* @author Warren Levy <warrenl@cygnus.com>
* @date August 25, 1998.
*/
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 /* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
* "The Java Language Specification", ISBN 0-201-63451-1 * "The Java Language Specification", ISBN 0-201-63451-1
* plus online API docs for JDK 1.2 beta from http://www.javasoft.com. * plus online API docs for JDK 1.2 beta from http://www.javasoft.com.
* Status: Believed complete and correct * Status: Believed complete and correct
*/ */
/**
* Interface that is implemented when a class wants to be informed of changes
* in Observable objects.
*
* @see java.util.Observable
* @author Warren Levy <warrenl@cygnus.com>
* @date August 25, 1998.
*/
public interface Observer public interface Observer
{ {
public void update(Observable observed, Object arg); public void update(Observable observable, Object arg);
} }

866
libjava/java/util/Properties.java
View file

@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option) the Free Software Foundation; either version 2, or (at your option)
any later version. any later version.
GNU Classpath is distributed in the hope that it will be useful, but GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
@ -62,427 +62,477 @@ import java.io.*;
* *
* @see PropertyResourceBundle * @see PropertyResourceBundle
* @author Jochen Hoenicke */ * @author Jochen Hoenicke */
public class Properties extends Hashtable { public class Properties extends Hashtable
/** {
* The property list that contains default values for any keys not /**
* in this property list. * The property list that contains default values for any keys not
*/ * in this property list.
protected Properties defaults; */
protected Properties defaults;
private static final long serialVersionUID = 4112578634029874840L; private static final long serialVersionUID = 4112578634029874840L;
/** /**
* Creates a new empty property list. * Creates a new empty property list.
*/ */
public Properties() { public Properties()
this.defaults = null; {
} this.defaults = null;
}
/**
* Create a new empty property list with the specified default values.
* @param defaults a Properties object containing the default values.
*/
public Properties(Properties defaults)
{
this.defaults = defaults;
}
/**
* Reads a property list from an input stream. The stream should
* have the following format: <br>
*
* An empty line or a line starting with <code>#</code> or
* <code>!</code> is ignored. An backslash (<code>\</code>) at the
* end of the line makes the line continueing on the next line
* (but make sure there is no whitespace after the backslash).
* Otherwise, each line describes a key/value pair. <br>
*
* The chars up to the first whitespace, = or : are the key. You
* can include this caracters in the key, if you precede them with
* a backslash (<code>\</code>). The key is followed by optional
* whitespaces, optionally one <code>=</code> or <code>:</code>,
* and optionally some more whitespaces. The rest of the line is
* the resource belonging to the key. <br>
*
* Escape sequences <code>\t, \n, \r, \\, \", \', \!, \#, \ </code>(a
* space), and unicode characters with the
* <code>\</code><code>u</code>xxxx notation are detected, and
* converted to the corresponding single character. <br>
*
* <pre>
* # This is a comment
* key = value
* k\:5 \ a string starting with space and ending with newline\n
* # This is a multiline specification; note that the value contains
* # no white space.
* weekdays: Sunday,Monday,Tuesday,Wednesday,\
* Thursday,Friday,Saturday
* # The safest way to include a space at the end of a value:
* label = Name:\<code></code>u0020
* </pre>
*
* @param in the input stream
* @exception IOException if an error occured when reading
* from the input. */
public void load(InputStream inStream) throws IOException
{
BufferedReader reader =
new BufferedReader(new InputStreamReader(inStream));
String line;
/** while ((line = reader.readLine()) != null)
* Create a new empty property list with the specified default values. {
* @param defaults a Properties object containing the default values. char c = 0;
*/ int pos = 0;
public Properties(Properties defaults) { while (pos < line.length()
this.defaults = defaults; && Character.isWhitespace(c = line.charAt(pos)))
} pos++;
/** // If line is empty or begins with a comment character,
* Reads a property list from an input stream. The stream should // skip this line.
* have the following format: <br> if (pos == line.length() || c == '#' || c == '!')
* continue;
* An empty line or a line starting with <code>#</code> or
* <code>!</code> is ignored. An backslash (<code>\</code>) at the
* end of the line makes the line continueing on the next line
* (but make sure there is no whitespace after the backslash).
* Otherwise, each line describes a key/value pair. <br>
*
* The chars up to the first whitespace, = or : are the key. You
* can include this caracters in the key, if you precede them with
* a backslash (<code>\</code>). The key is followed by optional
* whitespaces, optionally one <code>=</code> or <code>:</code>,
* and optionally some more whitespaces. The rest of the line is
* the resource belonging to the key. <br>
*
* Escape sequences <code>\t, \n, \r, \\, \", \', \!, \#, \ </code>(a
* space), and unicode characters with the
* <code>\</code><code>u</code>xxxx notation are detected, and
* converted to the corresponding single character. <br>
*
* <pre>
* # This is a comment
* key = value
* k\:5 \ a string starting with space and ending with newline\n
* # This is a multiline specification; note that the value contains
* # no white space.
* weekdays: Sunday,Monday,Tuesday,Wednesday,\
* Thursday,Friday,Saturday
* # The safest way to include a space at the end of a value:
* label = Name:\<code></code>u0020
* </pre>
*
* @param in the input stream
* @exception IOException if an error occured when reading
* from the input. */
public void load(InputStream inStream) throws IOException {
BufferedReader reader =
new BufferedReader(new InputStreamReader(inStream));
String line;
while ((line = reader.readLine()) != null) {
char c = 0;
int pos = 0;
while (pos < line.length()
&& Character.isWhitespace(c = line.charAt(pos)))
pos++;
// If line is empty or begins with a comment character, // The characaters up to the next Whitespace, ':', or '='
// skip this line. // describe the key. But look for escape sequences.
if (pos == line.length() || c == '#' || c == '!') StringBuffer key = new StringBuffer();
continue; while (pos < line.length()
&& !Character.isWhitespace(c = line.charAt(pos++))
&& c != '=' && c != ':')
{
if (c == '\\')
{
if (pos == line.length())
{
// The line continues on the next line.
line = reader.readLine();
pos = 0;
while (pos < line.length()
&& Character.isWhitespace(c = line.charAt(pos)))
pos++;
}
else
{
c = line.charAt(pos++);
switch (c)
{
case 'n':
key.append('\n');
break;
case 't':
key.append('\t');
break;
case 'r':
key.append('\r');
break;
case 'u':
if (pos + 4 <= line.length())
{
char uni = (char) Integer.parseInt
(line.substring(pos, pos + 4), 16);
key.append(uni);
} // else throw exception?
break;
default:
key.append(c);
break;
}
}
}
else
key.append(c);
}
// The characaters up to the next Whitespace, ':', or '=' boolean isDelim = (c == ':' || c == '=');
// describe the key. But look for escape sequences. while (pos < line.length()
StringBuffer key = new StringBuffer(); && Character.isWhitespace(c = line.charAt(pos)))
while (pos < line.length() pos++;
&& !Character.isWhitespace(c = line.charAt(pos++))
&& c != '=' && c != ':') {
if (c == '\\') {
if (pos == line.length()) {
// The line continues on the next line.
line = reader.readLine();
pos = 0;
while (pos < line.length()
&& Character.isWhitespace(c = line.charAt(pos)))
pos++;
} else {
c = line.charAt(pos++);
switch (c) {
case 'n':
key.append('\n');
break;
case 't':
key.append('\t');
break;
case 'r':
key.append('\r');
break;
case 'u':
if (pos+4 <= line.length()) {
char uni = (char) Integer.parseInt
(line.substring(pos, pos+4), 16);
key.append(uni);
} // else throw exception?
break;
default:
key.append(c);
break;
}
}
} else
key.append(c);
}
boolean isDelim = (c == ':' || c == '=');
while (pos < line.length()
&& Character.isWhitespace(c = line.charAt(pos)))
pos++;
if (!isDelim && (c == ':' || c == '=')) { if (!isDelim && (c == ':' || c == '='))
pos++; {
while (pos < line.length() pos++;
&& Character.isWhitespace(c = line.charAt(pos))) while (pos < line.length()
pos++; && Character.isWhitespace(c = line.charAt(pos)))
} pos++;
}
StringBuffer element = new StringBuffer(line.length()-pos); StringBuffer element = new StringBuffer(line.length() - pos);
while (pos < line.length()) { while (pos < line.length())
c = line.charAt(pos++); {
if (c == '\\') { c = line.charAt(pos++);
if (pos == line.length()) { if (c == '\\')
// The line continues on the next line. {
line = reader.readLine(); if (pos == line.length())
pos = 0; {
while (pos < line.length() // The line continues on the next line.
&& Character.isWhitespace(c = line.charAt(pos))) line = reader.readLine();
pos++; pos = 0;
element.ensureCapacity(line.length()-pos+element.length()); while (pos < line.length()
} else { && Character.isWhitespace(c = line.charAt(pos)))
c = line.charAt(pos++); pos++;
switch (c) { element.ensureCapacity(line.length() - pos +
case 'n': element.length());
element.append('\n'); }
break; else
case 't': {
element.append('\t'); c = line.charAt(pos++);
break; switch (c)
case 'r': {
element.append('\r'); case 'n':
break; element.append('\n');
case 'u': break;
if (pos+4 <= line.length()) { case 't':
char uni = (char) Integer.parseInt element.append('\t');
(line.substring(pos, pos+4), 16); break;
element.append(uni); case 'r':
} // else throw exception? element.append('\r');
break; break;
default: case 'u':
element.append(c); if (pos + 4 <= line.length())
break; {
} char uni = (char) Integer.parseInt
} (line.substring(pos, pos + 4), 16);
} else element.append(uni);
element.append(c); } // else throw exception?
} break;
put(key.toString(), element.toString()); default:
} element.append(c);
} break;
}
}
}
else
element.append(c);
}
put(key.toString(), element.toString());
}
}
/** /**
* Calls <code>store(OutputStream out, String header)</code> and * Calls <code>store(OutputStream out, String header)</code> and
* ignores the IOException that may be thrown. * ignores the IOException that may be thrown.
* @deprecated use store instead. * @deprecated use store instead.
* @exception ClassCastException if this property contains any key or * @exception ClassCastException if this property contains any key or
* value that isn't a string. * value that isn't a string.
*/ */
public void save(OutputStream out, String header) { public void save(OutputStream out, String header)
try { {
store(out,header); try
} catch (IOException ex) { {
} store(out, header);
} }
catch (IOException ex)
/** {
* Writes the key/value pairs to the given output stream. <br> }
* }
* If header is not null, this method writes a comment containing
* the header as first line to the stream. The next line (or first
* line if header is null) contains a comment with the current date.
* Afterwards the key/value pairs are written to the stream in the
* following format. <br>
*
* Each line has the form <code>key = value</code>. Newlines,
* Returns and tabs are written as <code>\n,\t,\r</code> resp.
* The characters <code>\, !, #, =</code> and <code>:</code> are
* preceeded by a backslash. Spaces are preceded with a backslash,
* if and only if they are at the beginning of the key. Characters
* that are not in the ascii range 33 to 127 are written in the
* <code>\</code><code>u</code>xxxx Form.
*
* @param out the output stream
* @param header the header written in the first line, may be null.
* @exception ClassCastException if this property contains any key or
* value that isn't a string.
*/
public void store(OutputStream out, String header) throws IOException {
PrintWriter writer = new PrintWriter(out);
if (header != null)
writer.println("#"+header);
writer.println("#"+new Date().toString());
list(writer);
writer.flush();
}
/**
* Adds the given key/value pair to this properties. This calls
* the hashtable method put.
* @param key the key for this property
* @param value the value for this property
* @return The old value for the given key.
* @since JDK1.2 */
public Object setProperty(String key, String value) {
return put(key,value);
}
/** /**
* Gets the property with the specified key in this property list. * Writes the key/value pairs to the given output stream. <br>
* If the key is not found, the default property list is searched. *
* If the property is not found in default or the default of * If header is not null, this method writes a comment containing
* default, null is returned. * the header as first line to the stream. The next line (or first
* @param key The key for this property. * line if header is null) contains a comment with the current date.
* @param defaulValue A default value * Afterwards the key/value pairs are written to the stream in the
* @return The value for the given key, or null if not found. * following format. <br>
* @exception ClassCastException if this property contains any key or *
* value that isn't a string. * Each line has the form <code>key = value</code>. Newlines,
*/ * Returns and tabs are written as <code>\n,\t,\r</code> resp.
public String getProperty(String key) { * The characters <code>\, !, #, =</code> and <code>:</code> are
return getProperty(key, null); * preceeded by a backslash. Spaces are preceded with a backslash,
} * if and only if they are at the beginning of the key. Characters
* that are not in the ascii range 33 to 127 are written in the
* <code>\</code><code>u</code>xxxx Form.
*
* @param out the output stream
* @param header the header written in the first line, may be null.
* @exception ClassCastException if this property contains any key or
* value that isn't a string.
*/
public void store(OutputStream out, String header) throws IOException
{
PrintWriter writer = new PrintWriter(out);
if (header != null)
writer.println("#" + header);
writer.println("#" + new Date().toString());
list(writer);
writer.flush();
}
/** /**
* Gets the property with the specified key in this property list. If * Adds the given key/value pair to this properties. This calls
* the key is not found, the default property list is searched. If the * the hashtable method put.
* property is not found in default or the default of default, the * @param key the key for this property
* specified defaultValue is returned. * @param value the value for this property
* @param key The key for this property. * @return The old value for the given key.
* @param defaulValue A default value * @since JDK1.2 */
* @return The value for the given key. public Object setProperty(String key, String value)
* @exception ClassCastException if this property contains any key or {
* value that isn't a string. return put(key, value);
*/ }
public String getProperty(String key, String defaultValue) {
Properties prop = this;
// Eliminate tail recursion.
do {
String value = (String) prop.get(key);
if (value != null)
return value;
prop = prop.defaults;
} while (prop != null);
return defaultValue;
}
private final void addHashEntries (Hashtable base) { /**
if (defaults != null) * Gets the property with the specified key in this property list.
defaults.addHashEntries(base); * If the key is not found, the default property list is searched.
Enumeration keys = keys (); * If the property is not found in default or the default of
while (keys.hasMoreElements()) * default, null is returned.
base.put(keys.nextElement(), base); * @param key The key for this property.
} * @param defaulValue A default value
* @return The value for the given key, or null if not found.
* @exception ClassCastException if this property contains any key or
* value that isn't a string.
*/
public String getProperty(String key)
{
return getProperty(key, null);
}
/** /**
* Returns an enumeration of all keys in this property list, including * Gets the property with the specified key in this property list. If
* the keys in the default property list. * the key is not found, the default property list is searched. If the
*/ * property is not found in default or the default of default, the
public Enumeration propertyNames () { * specified defaultValue is returned.
// We make a new Hashtable that holds all the keys. Then we * @param key The key for this property.
// return an enumeration for this hash. We do this because we * @param defaulValue A default value
// don't want modifications to be reflected in the enumeration * @return The value for the given key.
// (per JCL), and because there doesn't seem to be a * @exception ClassCastException if this property contains any key or
// particularly better way to ensure that duplicates are * value that isn't a string.
// ignored. */
Hashtable t = new Hashtable (); public String getProperty(String key, String defaultValue)
addHashEntries (t); {
return t.keys(); Properties prop = this;
} // Eliminate tail recursion.
do
{
String value = (String) prop.get(key);
if (value != null)
return value;
prop = prop.defaults;
}
while (prop != null);
return defaultValue;
}
/** private final void addHashEntries(Hashtable base)
* Formats a key/value pair for output in a properties file. {
* See store for a description of the format. if (defaults != null)
* @param key the key. defaults.addHashEntries(base);
* @param value the value. Enumeration keys = keys();
* @see #store while (keys.hasMoreElements())
*/ base.put(keys.nextElement(), base);
private String formatForOutput(String key, String value) { }
// This is a simple approximation of the expected line size.
StringBuffer result = new StringBuffer(key.length()+value.length()+16);
boolean head = true;
for (int i=0; i< key.length(); i++) {
char c = key.charAt(i);
switch (c) {
case '\n':
result.append("\\n");
break;
case '\r':
result.append("\\r");
break;
case '\t':
result.append("\\t");
break;
case '\\':
result.append("\\\\");
break;
case '!':
result.append("\\!");
break;
case '#':
result.append("\\#");
break;
case '=':
result.append("\\=");
break;
case ':':
result.append("\\:");
break;
case ' ':
result.append("\\ ");
break;
default:
if (c < 32 || c > '~') {
String hex = Integer.toHexString(c);
result.append("\\u0000".substring(0, 6-hex.length()));
result.append(hex);
} else
result.append(c);
}
if (c != 32)
head = false;
}
result.append('=');
head=true;
for (int i=0; i< value.length(); i++) {
char c = value.charAt(i);
switch (c) {
case '\n':
result.append("\\n");
break;
case '\r':
result.append("\\r");
break;
case '\t':
result.append("\\t");
break;
case '\\':
result.append("\\\\");
break;
case '!':
result.append("\\!");
break;
case '#':
result.append("\\#");
break;
case ' ':
result.append(head ? "\\ ": " ");
break;
default:
if (c < 32 || c > '~') {
String hex = Integer.toHexString(c);
result.append("\\u0000".substring(0, 6-hex.length()));
result.append(hex);
} else
result.append(c);
}
if (c != 32)
head = false;
}
return result.toString();
}
/** /**
* Writes the key/value pairs to the given print stream. They are * Returns an enumeration of all keys in this property list, including
* written in the way, described in the method store. * the keys in the default property list.
* @param out the stream, where the key/value pairs are written to. */
* @exception ClassCastException if this property contains any key or public Enumeration propertyNames()
* value that isn't a string. {
* @see #store // We make a new Hashtable that holds all the keys. Then we
*/ // return an enumeration for this hash. We do this because we
public void list(PrintStream out) { // don't want modifications to be reflected in the enumeration
Enumeration keys = keys(); // (per JCL), and because there doesn't seem to be a
Enumeration elts = elements(); // particularly better way to ensure that duplicates are
while (keys.hasMoreElements()) { // ignored.
String key = (String) keys.nextElement(); Hashtable t = new Hashtable();
String elt = (String) elts.nextElement(); addHashEntries(t);
String output = formatForOutput(key,elt); return t.keys();
out.println(output); }
}
}
/** /**
* Writes the key/value pairs to the given print writer. They are * Formats a key/value pair for output in a properties file.
* written in the way, described in the method store. * See store for a description of the format.
* @param out the writer, where the key/value pairs are written to. * @param key the key.
* @exception ClassCastException if this property contains any key or * @param value the value.
* value that isn't a string. * @see #store
* @see #store */
* @see #list(java.io.PrintStream) private String formatForOutput(String key, String value)
* @since JDK1.1 {
*/ // This is a simple approximation of the expected line size.
public void list(PrintWriter out) { StringBuffer result =
Enumeration keys = keys(); new StringBuffer(key.length() + value.length() + 16);
Enumeration elts = elements(); boolean head = true;
while (keys.hasMoreElements()) { for (int i = 0; i < key.length(); i++)
String key = (String) keys.nextElement(); {
String elt = (String) elts.nextElement(); char c = key.charAt(i);
String output = formatForOutput(key,elt); switch (c)
out.println(output); {
} case '\n':
} result.append("\\n");
break;
case '\r':
result.append("\\r");
break;
case '\t':
result.append("\\t");
break;
case '\\':
result.append("\\\\");
break;
case '!':
result.append("\\!");
break;
case '#':
result.append("\\#");
break;
case '=':
result.append("\\=");
break;
case ':':
result.append("\\:");
break;
case ' ':
result.append("\\ ");
break;
default:
if (c < 32 || c > '~')
{
String hex = Integer.toHexString(c);
result.append("\\u0000".substring(0, 6 - hex.length()));
result.append(hex);
}
else
result.append(c);
}
if (c != 32)
head = false;
}
result.append('=');
head = true;
for (int i = 0; i < value.length(); i++)
{
char c = value.charAt(i);
switch (c)
{
case '\n':
result.append("\\n");
break;
case '\r':
result.append("\\r");
break;
case '\t':
result.append("\\t");
break;
case '\\':
result.append("\\\\");
break;
case '!':
result.append("\\!");
break;
case '#':
result.append("\\#");
break;
case ' ':
result.append(head ? "\\ " : " ");
break;
default:
if (c < 32 || c > '~')
{
String hex = Integer.toHexString(c);
result.append("\\u0000".substring(0, 6 - hex.length()));
result.append(hex);
}
else
result.append(c);
}
if (c != 32)
head = false;
}
return result.toString();
}
/**
* Writes the key/value pairs to the given print stream. They are
* written in the way, described in the method store.
* @param out the stream, where the key/value pairs are written to.
* @exception ClassCastException if this property contains any key or
* value that isn't a string.
* @see #store
*/
public void list(PrintStream out)
{
Enumeration keys = keys();
Enumeration elts = elements();
while (keys.hasMoreElements())
{
String key = (String) keys.nextElement();
String elt = (String) elts.nextElement();
String output = formatForOutput(key, elt);
out.println(output);
}
}
/**
* Writes the key/value pairs to the given print writer. They are
* written in the way, described in the method store.
* @param out the writer, where the key/value pairs are written to.
* @exception ClassCastException if this property contains any key or
* value that isn't a string.
* @see #store
* @see #list(java.io.PrintStream)
* @since JDK1.1
*/
public void list(PrintWriter out)
{
Enumeration keys = keys();
Enumeration elts = elements();
while (keys.hasMoreElements())
{
String key = (String) keys.nextElement();
String elt = (String) elts.nextElement();
String output = formatForOutput(key, elt);
out.println(output);
}
}
} }

5
libjava/java/util/SortedMap.java
View file

@ -7,7 +7,7 @@ GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option) the Free Software Foundation; either version 2, or (at your option)
any later version. any later version.
GNU Classpath is distributed in the hope that it will be useful, but GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
@ -30,7 +30,8 @@ executable file might be covered by the GNU General Public License. */
package java.util; package java.util;
public interface SortedMap extends Map { public interface SortedMap extends Map
{
Comparator comparator(); Comparator comparator();
Object firstKey(); Object firstKey();
SortedMap headMap(Object toKey); SortedMap headMap(Object toKey);

121
libjava/java/util/Stack.java
View file

@ -1,42 +1,89 @@
/* Copyright (C) 1998, 1999 Free Software Foundation /* Stack.java - Class that provides a Last In First Out (LIFO)
datatype, known more commonly as a Stack
Copyright (C) 1998, 1999, 2001 Free Software Foundation, Inc.
This file is part of libgcj. This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA.
As a special exception, if you link this library with other files to
produce an executable, this library does not by itself cause the
resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the
executable file might be covered by the GNU General Public License. */
This software is copyrighted work licensed under the terms of the
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
details. */
package java.util; package java.util;
/**
* @author Warren Levy <warrenl@cygnus.com>
* @date August 20, 1998.
*/
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 /* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
* "The Java Language Specification", ISBN 0-201-63451-1 * "The Java Language Specification", ISBN 0-201-63451-1
* plus online API docs for JDK 1.2 beta from http://www.javasoft.com. * plus online API docs for JDK 1.2 beta from http://www.javasoft.com.
* Status: Believed complete and correct * Status: Believed complete and correct
*/ */
/**
* Stack provides a Last In First Out (LIFO) data type, commonly known
* as a Stack.
*
* Stack itself extends Vector and provides the additional methods
* for stack manipulation (push, pop, peek).
*
* @author Warren Levy <warrenl@cygnus.com>
* @date August 20, 1998.
*/
public class Stack extends Vector public class Stack extends Vector
{ {
// Could use Vector methods internally for the following methods // Could use Vector methods internally for the following methods
// but have used Vector fields directly for efficiency (i.e. this // but have used Vector fields directly for efficiency (i.e. this
// often reduces out duplicate bounds checking). // often reduces out duplicate bounds checking).
public boolean empty() private static final long serialVersionUID = 1224463164541339165L;
/**
* This constructor creates a new Stack, initially empty
*/
public Stack()
{ {
return elementCount == 0; super();
} }
public synchronized Object peek() /**
* Pushes an Object onto the top of the stack. This method is effectively
* the same as addElement(item)
*
* @param item the Object to push onto the stack
* @returns the Object pushed onto the stack
* @see java.util.Vector#addElement(java.util.Object)
*/
public Object push(Object item)
{ {
if (elementCount == 0) // When growing the Stack, use the Vector routines in case more
throw new EmptyStackException(); // memory is needed.
// Note: spec indicates that this method *always* returns obj passed in!
return elementData[elementCount - 1]; addElement(item);
return item;
} }
/**
* Pops an item from the stack and returns it. The item popped is
* removed from the Stack
*
* @returns the Object popped from the stack
*/
public synchronized Object pop() public synchronized Object pop()
{ {
if (elementCount == 0) if (elementCount == 0)
@ -49,28 +96,44 @@ public class Stack extends Vector
return obj; return obj;
} }
public Object push(Object obj) /**
* Returns the top Object on the stack without removing it
*
* @returns the top Object on the stack
*/
public synchronized Object peek()
{ {
// When growing the Stack, use the Vector routines in case more if (elementCount == 0)
// memory is needed. throw new EmptyStackException();
// Note: spec indicates that this method *always* returns obj passed in!
addElement(obj); return elementData[elementCount - 1];
return obj;
} }
public synchronized int search(Object obj) /**
* Tests if the stack is empty
*
* @returns true if the stack contains no items, false otherwise
*/
public boolean empty()
{ {
// Return the position of obj on the stack as measured from the top; return elementCount == 0;
// i.e. the top element is 1, the next element down is 2, etc. }
// If obj is not on the stack, return -1
/**
* Returns the position of an Object on the stack, with the top
* most Object being at position 1, and each Object deeper in the
* stack at depth + 1
*
* @param o The object to search for
* @returns The 1 based depth of the Object, or -1 if the Object
* is not on the stack.
*/
public synchronized int search(Object o)
{
for (int i = elementCount-1; i >=0; --i) for (int i = elementCount-1; i >=0; --i)
if (elementData[i].equals(obj)) if (elementData[i].equals(o))
return elementCount - i; return elementCount - i;
return -1; return -1;
} }
private static final long serialVersionUID = 1224463164541339165L;
} }