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

* java/util/Properties.java: Merged with Classpath version.

Browse source 
From-SVN: r36775
This commit is contained in:
Tom Tromey 2000-10-07 18:13:11 +00:00 • committed by Tom Tromey
parent 20d431c931
commit 43f8e39002
2 changed files with 463 additions and 364 deletions
Download patch file Download diff file Expand all files Collapse all files

4
libjava/ChangeLog
View file

@ -1,3 +1,7 @@
2000-10-07 Tom Tromey <tromey@cygnus.com>
* java/util/Properties.java: Merged with Classpath version.
2000-10-05 Tom Tromey <tromey@cygnus.com> 2000-10-05 Tom Tromey <tromey@cygnus.com>
* java/lang/reflect/natField.cc (BooleanClass): Don't define. * java/lang/reflect/natField.cc (BooleanClass): Don't define.

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

@ -1,393 +1,488 @@
// Properties - Property list representation. /* java.util.Properties
Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
/* Copyright (C) 1998, 1999, 2000 Free Software Foundation This file is part of GNU Classpath.
This file is part of libgcj. 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;
import java.io.*;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.PushbackReader;
/** /**
* @author Tom Tromey <tromey@cygnus.com> * An example of a properties file for the german language is given
* @date October 26, 1998. * here. This extends the example given in ListResourceBundle.
*/ * Create a file MyResource_de.properties with the following contents
* and put it in the CLASSPATH. (The character
* <code>\</code><code>u00e4</code> is the german &auml;)
*
* <pre>
* s1=3
* s2=MeineDisk
* s3=3. M\<code></code>u00e4rz 96
* s4=Die Diskette ''{1}'' enth\<code></code>u00e4lt {0} in {2}.
* s5=0
* s6=keine Dateien
* s7=1
* s8=eine Datei
* s9=2
* s10={0,number} Dateien
* s11=Das Formatieren schlug fehl mit folgender Exception: {0}
* s12=FEHLER
* s13=Ergebnis
* s14=Dialog
* s15=Auswahlkriterium
* s16=1,3
* </pre>
*
* Although this is a sub class of a hash table, you should never
* insert anything other than strings to this property, or several
* methods, that need string keys and values, will fail. To ensure
* this, you should use the <code>get/setProperty</code> method instead
* of <code>get/put</code>.
*
* @see PropertyResourceBundle
* @author Jochen Hoenicke */
public class Properties extends Hashtable {
/**
* The property list that contains default values for any keys not
* in this property list.
*/
protected Properties defaults;
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 private static final long serialVersionUID = 4112578634029874840L;
* Status: Complete to JDK 1.2.
*/
public class Properties extends Hashtable /**
{ * Creates a new empty property list.
protected Properties defaults; */
public Properties() {
private static final long serialVersionUID = 4112578634029874840L; this.defaults = null;
}
public String getProperty (String propName)
{ /**
return getProperty (propName, 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;
} }
public String getProperty (String propName, String defVal) /**
{ * Reads a property list from an input stream. The stream should
String r = (String) get (propName); * have the following format: <br>
if (r == null) *
{ * An empty line or a line starting with <code>#</code> or
if (defaults != null) * <code>!</code> is ignored. An backslash (<code>\</code>) at the
r = defaults.getProperty(propName, defVal); * end of the line makes the line continueing on the next line
else * (but make sure there is no whitespace after the backslash).
r = defVal; * Otherwise, each line describes a key/value pair. <br>
} *
return r; * 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,
// skip this line.
if (pos == line.length() || c == '#' || c == '!')
continue;
// The characaters up to the next Whitespace, ':', or '='
// describe the key. But look for escape sequences.
StringBuffer key = new StringBuffer();
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);
}
boolean isDelim = (c == ':' || c == '=');
while (pos < line.length()
&& Character.isWhitespace(c = line.charAt(pos)))
pos++;
if (!isDelim && (c == ':' || c == '=')) {
pos++;
while (pos < line.length()
&& Character.isWhitespace(c = line.charAt(pos)))
pos++;
}
StringBuffer element = new StringBuffer(line.length()-pos);
while (pos < line.length()) {
c = line.charAt(pos++);
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++;
element.ensureCapacity(line.length()-pos+element.length());
} else {
c = line.charAt(pos++);
switch (c) {
case 'n':
element.append('\n');
break;
case 't':
element.append('\t');
break;
case 'r':
element.append('\r');
break;
case 'u':
if (pos+4 <= line.length()) {
char uni = (char) Integer.parseInt
(line.substring(pos, pos+4), 16);
element.append(uni);
} // else throw exception?
break;
default:
element.append(c);
break;
}
}
} else
element.append(c);
}
put(key.toString(), element.toString());
}
} }
public Object setProperty (String key, String value) /**
{ * Calls <code>store(OutputStream out, String header)</code> and
return put (key, value); * ignores the IOException that may be thrown.
} * @deprecated use store instead.
* @exception ClassCastException if this property contains any key or
public void list (PrintStream out) * value that isn't a string.
{ */
Enumeration e = propertyNames (); public void save(OutputStream out, String header) {
while (e.hasMoreElements()) try {
{ store(out,header);
String key = (String) e.nextElement(); } catch (IOException ex) {
String value = getProperty(key); }
if (value != null) }
{
if (value.length() > 40) /**
{ * Writes the key/value pairs to the given output stream. <br>
// JDK compatibility. *
value = value.substring(0, 37) + "..."; * If header is not null, this method writes a comment containing
} * the header as first line to the stream. The next line (or first
out.print(key); * line if header is null) contains a comment with the current date.
out.print("="); * Afterwards the key/value pairs are written to the stream in the
out.println(value); * 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);
} }
public void list (PrintWriter writer) /**
{ * Gets the property with the specified key in this property list.
Enumeration e = propertyNames (); * If the key is not found, the default property list is searched.
while (e.hasMoreElements()) * If the property is not found in default or the default of
{ * default, null is returned.
String key = (String) e.nextElement(); * @param key The key for this property.
String value = getProperty(key); * @param defaulValue A default value
if (value != null) * @return The value for the given key, or null if not found.
{ * @exception ClassCastException if this property contains any key or
if (value.length() > 40) * value that isn't a string.
{ */
// JDK compatibility. public String getProperty(String key) {
value = value.substring(0, 37) + "..."; return getProperty(key, null);
}
writer.print(key);
writer.print("=");
writer.println(value);
}
}
} }
private final boolean skip_ws (PushbackReader reader) throws IOException /**
{ * Gets the property with the specified key in this property list. If
while (true) * 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
int c = reader.read(); * specified defaultValue is returned.
if (c == -1) * @param key The key for this property.
return false; * @param defaulValue A default value
// FIXME: we use our own definition of whitespace. * @return The value for the given key.
// Character.isWhitespace includes newlines, which we don't * @exception ClassCastException if this property contains any key or
// want. Character.isSpaceChar doesn't include \t. * value that isn't a string.
if (c != ' ' && c != '\t') */
{ public String getProperty(String key, String defaultValue) {
reader.unread(c); Properties prop = this;
return true; // Eliminate tail recursion.
} do {
} String value = (String) prop.get(key);
if (value != null)
return value;
prop = prop.defaults;
} while (prop != null);
return defaultValue;
} }
// Note: this method needs to be rewritten for JDK 1.2. private final void addHashEntries (Hashtable base) {
// We rather arbitrarily decide that an EOF in the middle of a line if (defaults != null)
// means that the whole line should be ignored. The spec doesn't defaults.addHashEntries(base);
// specifically address this, but this interpretation seems valid. Enumeration keys = keys ();
public synchronized void load (InputStream in) throws IOException while (keys.hasMoreElements())
{ base.put(keys.nextElement(), base);
PushbackReader reader = new PushbackReader (new InputStreamReader (in)); }
StringBuffer key = new StringBuffer (); /**
StringBuffer value = new StringBuffer (); * Returns an enumeration of all keys in this property list, including
* the keys in the default property list.
*/
public Enumeration propertyNames () {
// We make a new Hashtable that holds all the keys. Then we
// return an enumeration for this hash. We do this because we
// don't want modifications to be reflected in the enumeration
// (per JCL), and because there doesn't seem to be a
// particularly better way to ensure that duplicates are
// ignored.
Hashtable t = new Hashtable ();
addHashEntries (t);
return t.keys();
}
nextLine: /**
while (true) * Formats a key/value pair for output in a properties file.
{ * See store for a description of the format.
key.setLength(0); * @param key the key.
value.setLength(0); * @param value the value.
* @see #store
// Skip leading whitespace. */
if (! skip_ws (reader)) private String formatForOutput(String key, String value) {
return; // This is a simple approximation of the expected line size.
StringBuffer result = new StringBuffer(key.length()+value.length()+16);
// Read key until key terminator. boolean head = true;
boolean first_char = true; for (int i=0; i< key.length(); i++) {
int c; char c = key.charAt(i);
while (true) switch (c) {
{ case '\n':
c = reader.read(); result.append("\\n");
if (c == -1) break;
return; case '\r':
if (c == '\\') result.append("\\r");
{ break;
first_char = false; case '\t':
c = reader.read(); result.append("\\t");
if (c == -1) break;
return; case '\\':
} result.append("\\\\");
break;
// If we found a comment, just read to end of line and case '!':
// then keep going. result.append("\\!");
if (first_char == true && (c == '#' || c == '!')) break;
{ case '#':
while (c != -1 && c != '\r' && c != '\n') result.append("\\#");
c = reader.read(); break;
if (c == -1) case '=':
return; result.append("\\=");
continue nextLine; break;
} case ':':
result.append("\\:");
if (c == '\r' || c == '\n') break;
{ case ' ':
if (first_char) result.append("\\ ");
continue nextLine;
reader.unread(c);
break;
}
// FIXME: again, our own definition of whitespace.
if (c == ' ' || c == '\t' || c == ':' || c == '=')
break; break;
default:
first_char = false; if (c < 32 || c > '~') {
key.append((char) c); String hex = Integer.toHexString(c);
} result.append("\\u0000".substring(0, 6-hex.length()));
result.append(hex);
// Found end of key. Skip whitespace. If the terminator } else
// was whitespace, also skip a single instance of a "real" result.append(c);
// terminator, and then more whitespace. }
if (! skip_ws (reader)) if (c != 32)
return; head = false;
if (c != ':' && c != '=') }
{ result.append('=');
c = reader.read(); head=true;
if (c == -1) for (int i=0; i< value.length(); i++) {
return; char c = value.charAt(i);
if (c == ':' || c == '=') switch (c) {
{ case '\n':
// Skip more whitespace. result.append("\\n");
if (! skip_ws (reader)) break;
return; case '\r':
} result.append("\\r");
else break;
reader.unread(c); case '\t':
} result.append("\\t");
break;
// Now read the value. case '\\':
while (true) result.append("\\\\");
{ break;
c = reader.read(); case '!':
if (c == -1) result.append("\\!");
return; break;
if (c == '\r' || c == '\n') case '#':
result.append("\\#");
break;
case ' ':
result.append(head ? "\\ ": " ");
break; break;
if (c == '\\') default:
{ if (c < 32 || c > '~') {
c = reader.read(); String hex = Integer.toHexString(c);
switch (c) result.append("\\u0000".substring(0, 6-hex.length()));
{ result.append(hex);
case -1: } else
return; result.append(c);
case 't': }
c = '\t'; if (c != 32)
break; head = false;
case 'r': }
c = '\r'; return result.toString();
break;
case 'n':
c = '\n';
break;
case 'u':
c = 0;
for (int i = 0; i < 4; ++i)
{
int x = reader.read();
if (x == -1)
return;
int d = Character.digit((char) x, 16);
// We follow JDK here: invalid characters
// are treated as terminators.
if (d == -1)
{
value.append((char) c);
c = x;
break;
}
c <<= 4;
c |= d;
}
break;
default:
// Nothing.
}
}
value.append((char) c);
}
put (key.toString(), value.toString());
}
} }
public Properties () /**
{ * Writes the key/value pairs to the given print stream. They are
defaults = null; * 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);
}
} }
public Properties (Properties defs) /**
{ * Writes the key/value pairs to the given print writer. They are
defaults = defs; * 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);
}
} }
private final void addHashEntries (Hashtable base)
{
if (defaults != null)
defaults.addHashEntries(base);
Enumeration keys = keys ();
while (keys.hasMoreElements())
base.put(keys.nextElement(), base);
}
public Enumeration propertyNames ()
{
// We make a new Hashtable that holds all the keys. Then we
// return an enumeration for this hash. We do this because we
// don't want modifications to be reflected in the enumeration
// (per JCL), and because there doesn't seem to be a
// particularly better way to ensure that duplicates are
// ignored.
Hashtable t = new Hashtable ();
addHashEntries (t);
return t.keys();
}
public synchronized void save (OutputStream out, String comment)
{
try
{
store (out, comment);
}
catch (IOException _)
{
}
}
public synchronized void store (OutputStream out, String comment)
throws IOException
{
// Use a buffer because writing a single string through
// OutputStreamWriter is fairly expensive.
BufferedWriter output
= new BufferedWriter (new OutputStreamWriter (out));
String newline = System.getProperty("line.separator");
if (comment != null)
{
// We just lose if COMMENT contains a newline. This is
// what JDK 1.1 does.
output.write("#");
output.write(comment);
output.write(newline);
}
output.write("# ");
output.write(new Date().toString());
output.write(newline);
Enumeration keys = keys ();
while (keys.hasMoreElements())
{
String key = (String) keys.nextElement();
String value = (String) get (key);
// FIXME: JCL says that the key can contain many Unicode
// characters. But it also doesn't say we should encode
// it in any way.
// FIXME: if key contains ':', '=', or whitespace, must
// quote it here. Note that JDK 1.1 does not do this.
output.write(key);
output.write("=");
boolean leading = true;
for (int i = 0; i < value.length(); ++i)
{
boolean new_lead = false;
char c = value.charAt(i);
switch (c)
{
case '\n':
output.write("\\n");
break;
case '\r':
output.write("\\r");
break;
case '\t':
output.write("\\t");
break;
case '\\':
output.write("\\\\");
break;
case '#':
case '!':
case '=':
case ':':
output.write("\\");
output.write(c);
break;
case ' ':
new_lead = leading;
if (leading)
output.write("\\");
output.write(c);
break;
default:
if (c < '\u0020' || c > '\u007e')
{
output.write("\\u");
output.write(Character.forDigit(c >>> 12, 16));
output.write(Character.forDigit((c >>> 8) & 0xff,
16));
output.write(Character.forDigit((c >>> 4) & 0xff,
16));
output.write(Character.forDigit(c & 0xff, 16));
}
else
output.write(c);
}
leading = new_lead;
}
output.write(newline);
}
output.flush();
}
} }