1 /*
2 * $Id$
3 *
4 * Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
5 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 *
7 * This code is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License version 2 only, as
9 * published by the Free Software Foundation. Oracle designates this
10 * particular file as subject to the "Classpath" exception as provided
11 * by Oracle in the LICENSE file that accompanied this code.
12 *
13 * This code is distributed in the hope that it will be useful, but WITHOUT
14 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 * version 2 for more details (a copy is included in the LICENSE file that
17 * accompanied this code).
18 *
19 * You should have received a copy of the GNU General Public License version
20 * 2 along with this work; if not, write to the Free Software Foundation,
21 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
22 *
23 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
24 * or visit www.oracle.com if you need additional information or have any
25 * questions.
26 */
27 package com.sun.javatest.util;
28
29 // Modified from JDK java.util.Properties to use Reader/Writer as well as
30 // InputStream/OutputStream
31
32 import java.io.*;
33 import java.util.*;
34
35 /**
36 * The <code>Properties</code> class represents a persistent set of
37 * properties. The <code>Properties</code> can be saved to a stream
38 * or loaded from a stream. Each key and its corresponding value in
39 * the property list is a string.
40 * <p>
41 * A property list can contain another property list as its
42 * "defaults"; this second property list is searched if
43 * the property key is not found in the original property list.
44 *
45 * <p>
46 * Modified from JDK java.util.Properties to use Reader/Writer as well as
47 * InputStream/OutputStream, to fix locale/codepage problems.
48 */
49 public
50 class Properties extends Hashtable<String, String> {
51 /**
52 * A property list that contains default values for any keys not
53 * found in this property list.
54 *
55 * @since JDK1.0
56 */
57 protected Properties defaults;
58
59 /**
60 * Creates an empty property list with no default values.
61 *
62 * @since JDK1.0
63 */
64 public Properties() {
65 this(null);
66 }
67
68 /**
69 * Creates an empty property list with the specified defaults.
70 *
71 * @param defaults the defaults.
72 * @since JDK1.0
73 */
74 public Properties(Properties defaults) {
75 this.defaults = defaults;
76 }
77
78 /**
79 * Utility method that writes the given map of strings to the given output stream with provided comments
80 * using {@code java.util.Properties.store(java.io.OutputStream, String)} method.
81 */
82 public static void store(Map<String, String> stringProps, OutputStream out, String comments) throws IOException {
83 java.util.Properties properties = new java.util.Properties();
84 properties.putAll(stringProps);
85 properties.store(out, comments);
86 }
87
88 /**
89 * Reads a property list from the given input stream
90 * using {@code java.util.Properties.load(java.io.InputStream inStream)} method
91 * and stores properties into a {@code Map<String, String>} that is returned.
92 */
93 public static Map<String, String> load(InputStream inputStream) throws IOException {
94 return populate(new HashMap<String, String>(), inputStream);
95 }
96
97 /**
98 * Reads a property list from the given input stream
99 * using {@code java.util.Properties.load(java.io.InputStream inStream)} method
100 * and stores string properties into a {@code SortedMap<String, String>} that is returned.
101 */
102 public static SortedMap<String, String> loadSorted(InputStream inputStream) throws IOException {
103 return populate(new TreeMap<String, String>(), inputStream);
104 }
105
106 /**
107 * Populated a map of strings using {@code java.util.Properties.load(java.io.InputStream)} method
108 */
109 private static <M extends Map<String, String>> M populate(M stringProps, InputStream inputStream) throws IOException {
110 java.util.Properties p = new java.util.Properties();
111 p.load(inputStream);
112 return extractStringPropsTo(stringProps, p);
113 }
114
115 /**
116 * Converts the given properties to {@code Map<String, String>} instance
117 * picking only string properties from the given {@code java.util.Properties} instance.
118 */
119 public static Map<String, String> convertToStringProps(java.util.Properties properties) {
120 return extractStringPropsTo(new HashMap<String, String>(), properties);
121 }
122
123 private static <M extends Map<String, String>> M extractStringPropsTo(M stringProps, java.util.Properties p) {
124 for (String name : p.stringPropertyNames()) {
125 stringProps.put(name, p.getProperty(name));
126 }
127 return stringProps;
128 }
129
130 // /**
131 // * Reads a property list from an input stream.
132 // *
133 // * @param in the input stream.
134 // * @exception IOException if an error occurred when reading from the
135 // * input stream.
136 // * @since JDK1.0
137 // */
138 // public synchronized void load(InputStream in) throws IOException {
139 // in = Runtime.getRuntime().getLocalizedInputStream(in);
140 // load(new InputStreamReader(in));
141 // }
142
143
144 /**
145 * Reads a property list from an input stream.
146 *
147 * @param in the input stream.
148 * @exception IOException if an error occurred when reading from the
149 * input stream.
150 */
151 public synchronized void load(Reader in) throws IOException {
152 Vector<String> v = load0(in, false);
153 for (int i = 0; i < v.size(); i+=2) {
154 put(v.elementAt(i), v.elementAt(i + 1));
155 }
156 }
157
158
159 static Vector<String> load0(Reader in, boolean breakOnEmptyLine) throws IOException {
160
161 // This could be used if we switch to JDK 1.6, where Properties support I/O
162 // through Reader and Writer
163 // StringBuffer buff = new StringBuffer();
164 // int lineCount = 0;
165 // int ch = '\n';
166 //
167 // while (ch >= 0) {
168 // buff.append((char)ch);
169 // if (ch == '\n') {
170 // if (++lineCount > 1) {
171 // break;
172 // }
173 // }
174 // else if (ch != '\r' && ch != '\t' && ch != ' ') {
175 // lineCount = 0;
176 // }
177 // ch = in.read();
178 // }
179 // Reader r = new StringReader(buff.toString());
180 // java.util.Properties props = new java.util.Properties();
181 // props.load(r);
182 //
183 // return getArray(props);
184 //
185 //
186 //
187
188 Vector<String> v = new Vector<>();
189 int ch = 0;
190
191 //// eat any preceding whitespace
192 //do {
193 // ch = in.read();
194 //} while ((ch == '\n') || (ch == '\r') || (ch == '\t') || (ch == ' '));
195
196 ch = '\n';
197 // pretend to have read newline, so that if an initial
198 // blank line is read, it is treated as the end of an empty props object
199
200 parsing:
201 while (true) {
202 // parse until EOF or a blank line
203 switch (ch) {
204 case -1:
205 // EOF
206 break parsing;
207
208 case '#':
209 case '!':
210 // comment: skip to end of line
211 do {
212 ch = in.read();
213 } while ((ch >= 0) && (ch != '\n') && (ch != '\r'));
214 continue;
215
216 case '\n':
217 case '\t':
218 case '\r':
219 case ' ':
220 // skip whitespace but count newlines along the way;
221 // if there is more than one, we're done. This is intended
222 // to work on both \n and \r\n systems
223 int lines = 0;
224 do {
225 if (breakOnEmptyLine && ch == '\n' && (++lines > 1))
226 break parsing;
227 ch = in.read();
228 } while ((ch == '\n') || (ch == '\r') || (ch == '\t') || (ch == ' '));
229 continue;
230
231 default:
232
233
234
235 // key=value
236 // start by reading the key; stop at newline (unless escaped in value)
237 StringBuffer key = new StringBuffer();
238 StringBuffer val = new StringBuffer();
239
240 boolean hasSep = false;
241 boolean precedingBackslash = false;
242 while (ch >=0 && (ch != '\n') && (ch != '\r')) {
243 //need check if escaped.
244 if ((ch == '=' || ch == ':') && !precedingBackslash) {
245 // valueStart = keyLen + 1;
246 ch = in.read();
247 hasSep = true;
248 break;
249 } else if ((ch == ' ' || ch == '\t' || ch == '\f') && !precedingBackslash) {
250 // valueStart = keyLen + 1;
251 ch = in.read();
252 break;
253 }
254 if (ch == '\\') {
255 precedingBackslash = !precedingBackslash;
256 } else {
257 precedingBackslash = false;
258 }
259 // keyLen++;
260 key.append((char)ch);
261 ch = in.read();
262 }
263
264 // handle multi-char separator: prop = value
265 while (ch >=0 && (ch != '\n') && (ch != '\r')) {
266 // c = lr.lineBuf[valueStart];
267 if (ch != ' ' && ch != '\t' && ch != '\f') {
268 if (!hasSep && (ch == '=' || ch == ':')) {
269 hasSep = true;
270 } else {
271 break;
272 }
273 }
274 // valueStart++;
275 ch = in.read();
276 }
277 // while (ch >=0 && (ch != '\n') && (ch != '\r')) {
278 // val.append((char)ch);
279 // ch = in.read();
280 // }
281
282 // Read the value
283 while ((ch >= 0) && (ch != '\n') && (ch != '\r')) {
284 if (ch == '\\') {
285 switch (ch = in.read()) {
286 case '\r':
287 if (((ch = in.read()) == '\n') ||
288 (ch == ' ') || (ch == '\t')) {
289 // fall thru to '\n' case
290 } else continue;
291 case '\n':
292 while (((ch = in.read()) == ' ') || (ch == '\t'));
293 continue;
294 default:
295 val.append('\\');
296 break;
297 }
298 }
299 val.append((char)ch);
300 ch = in.read();
301 }
302
303 char[] cKey = new char[key.length()];
304 char[] cVal = new char[val.length()];
305 key.getChars(0, key.length(), cKey, 0);
306 val.getChars(0, val.length(), cVal, 0);
307
308 v.add(loadConvert(cKey));
309 v.add(loadConvert(cVal));
310
311 }
312 }
313
314 return v;
315 }
316
317
318
319
320 private static String loadConvert (char[] in/*, int off, int len, char[] convtBuf*/) {
321 // if (convtBuf.length < len) {
322 // int newLen = len * 2;
323 // if (newLen < 0) {
324 // newLen = Integer.MAX_VALUE;
325 // }
326 // convtBuf = new char[newLen];
327 // }
328 // char aChar;
329 // char[] out = convtBuf;
330 // int outLen = 0;
331 // int end = off + len;
332 char aChar;
333 int len = in.length;
334 char[] out = new char[len];
335 int outLen = 0;
336 int off = 0;
337
338 while (off < len) {
339 aChar = in[off++];
340 if (aChar == '\\') {
341 aChar = in[off++];
342 if(aChar == 'u') {
343 // Read the xxxx
344 int value=0;
345 for (int i=0; i<4; i++) {
346 aChar = in[off++];
347 switch (aChar) {
348 case '0': case '1': case '2': case '3': case '4':
349 case '5': case '6': case '7': case '8': case '9':
350 value = (value << 4) + aChar - '0';
351 break;
352 case 'a': case 'b': case 'c':
353 case 'd': case 'e': case 'f':
354 value = (value << 4) + 10 + aChar - 'a';
355 break;
356 case 'A': case 'B': case 'C':
357 case 'D': case 'E': case 'F':
358 value = (value << 4) + 10 + aChar - 'A';
359 break;
360 default:
361 throw new IllegalArgumentException(
362 "Malformed \\uxxxx encoding.");
363 }
364 }
365 out[outLen++] = (char)value;
366 } else {
367 if (aChar == 't') aChar = '\t';
368 else if (aChar == 'r') aChar = '\r';
369 else if (aChar == 'n') aChar = '\n';
370 else if (aChar == 'f') aChar = '\f';
371 out[outLen++] = aChar;
372 }
373 } else {
374 out[outLen++] = aChar;
375 }
376 }
377 return new String (out, 0, outLen);
378 }
379
380
381
382
383
384
385 // /**
386 // * Stores this property list to the specified output stream. The
387 // * string header is printed as a comment at the beginning of the stream.
388 // *
389 // * @param out an output stream.
390 // * @param header a description of the property list.
391 // * @since JDK1.0
392 // */
393 // public synchronized void save(OutputStream out, String header) {
394 // OutputStream localOut = Runtime.getRuntime().getLocalizedOutputStream(out);
395 // boolean localize = localOut != out;
396 // save(new OutputStreamWriter(localOut), header, localize);
397 // }
398
399 /**
400 * Stores this property list to the specified output stream. The
401 * string header is printed as a comment at the beginning of the stream.
402 *
403 * @param out an output stream.
404 * @param header a description of the property list.
405 * @since JDK1.0
406 */
407 public synchronized void save(Writer out, String header) throws IOException {
408 // From JDK 1.6 java.util.Properties
409 BufferedWriter bout = (out instanceof BufferedWriter)?(BufferedWriter)out
410 : new BufferedWriter(out);
411
412 PrintWriter prnt = new PrintWriter(bout);
413 if (header != null) {
414 prnt.write('#');
415 prnt.println(header);
416 }
417 prnt.write('#');
418 prnt.println(new Date());
419
420 for (Enumeration<String> e = keys() ; e.hasMoreElements() ;) {
421 String key = e.nextElement();
422 String val = get(key);
423 key = saveConvert(key, true, false);
424 /* No need to escape embedded and trailing spaces for value, hence
425 * pass false to flag.
426 */
427 val = saveConvert(val, false, false);
428 bout.write(key + "=" + val);
429 bout.newLine();
430 }
431 bout.flush();
432 }
433
434 // Copied from JDK 1.6
435 static String saveConvert(String theString,
436 boolean escapeSpace,
437 boolean escapeUnicode) {
438 int len = theString.length();
439 int bufLen = len * 2;
440 if (bufLen < 0) {
441 bufLen = Integer.MAX_VALUE;
442 }
443 StringBuffer outBuffer = new StringBuffer(bufLen);
444
445 for(int x=0; x<len; x++) {
446 char aChar = theString.charAt(x);
447 // Handle common case first, selecting largest block that
448 // avoids the specials below
449 if ((aChar > 61) && (aChar < 127)) {
450 if (aChar == '\\') {
451 outBuffer.append('\\'); outBuffer.append('\\');
452 continue;
453 }
454 outBuffer.append(aChar);
455 continue;
456 }
457 switch(aChar) {
458 case ' ':
459 if (x == 0 || escapeSpace)
460 outBuffer.append('\\');
461 outBuffer.append(' ');
462 break;
463 case '\t':outBuffer.append('\\'); outBuffer.append('t');
464 break;
465 case '\n':outBuffer.append('\\'); outBuffer.append('n');
466 break;
467 case '\r':outBuffer.append('\\'); outBuffer.append('r');
468 break;
469 case '\f':outBuffer.append('\\'); outBuffer.append('f');
470 break;
471 case '=': // Fall through
472 case ':': // Fall through
473 case '#': // Fall through
474 case '!':
475 outBuffer.append('\\'); outBuffer.append(aChar);
476 break;
477 default:
478 if (((aChar < 0x0020) || (aChar > 0x007e)) & escapeUnicode ) {
479 outBuffer.append('\\');
480 outBuffer.append('u');
481 outBuffer.append(toHex((aChar >> 12) & 0xF));
482 outBuffer.append(toHex((aChar >> 8) & 0xF));
483 outBuffer.append(toHex((aChar >> 4) & 0xF));
484 outBuffer.append(toHex( aChar & 0xF));
485 } else {
486 outBuffer.append(aChar);
487 }
488 }
489 }
490 return outBuffer.toString();
491 }
492
493
494 /**
495 * Searches for the property with the specified key in this property list.
496 * If the key is not found in this property list, the default property list,
497 * and its defaults, recursively, are then checked. The method returns
498 * <code>null</code> if the property is not found.
499 *
500 * @param key the property key.
501 * @return the value in this property list with the specified key value.
502 * @see com.sun.javatest.util.Properties#defaults
503 * @since JDK1.0
504 */
505 public String getProperty(String key) {
506 Object oval = super.get(key);
507 String sval = (oval instanceof String) ? (String)oval : null;
508 return ((sval == null) && (defaults != null)) ? defaults.getProperty(key) : sval;
509 }
510
511 /**
512 * Searches for the property with the specified key in this property list.
513 * If the key is not found in this property list, the default property list,
514 * and its defaults, recursively, are then checked. The method returns the
515 * default value argument if the property is not found.
516 *
517 * @param key the hashtable key.
518 * @param defaultValue a default value.
519 *
520 * @return the value in this property list with the specified key value.
521 * @see com.sun.javatest.util.Properties#defaults
522 * @since JDK1.0
523 */
524 public String getProperty(String key, String defaultValue) {
525 String val = getProperty(key);
526 return (val == null) ? defaultValue : val;
527 }
528
529 /**
530 * Returns an enumeration of all the keys in this property list, including
531 * the keys in the default property list.
532 *
533 * @return an enumeration of all the keys in this property list, including
534 * the keys in the default property list.
535 * @see java.util.Enumeration
536 * @see com.sun.javatest.util.Properties#defaults
537 * @since JDK1.0
538 */
539 public Enumeration<String> propertyNames() {
540 Hashtable<String, String> h = new Hashtable<>();
541 enumerate(h);
542 return h.keys();
543 }
544
545 // /**
546 // * Prints this property list out to the specified output stream.
547 // * This method is useful for debugging.
548 // *
549 // * @param out an output stream.
550 // * @since JDK1.0
551 // */
552 // public void list(PrintStream out) {
553 // list(new PrintWriter(out));
554 // }
555
556 /**
557 * Prints this property list out to the specified output stream.
558 * This method is useful for debugging.
559 *
560 * @param out an output stream.
561 * @since JDK1.1
562 */
563 /*
564 * Rather than use an anonymous inner class to share common code, this
565 * method is duplicated in order to ensure that a non-1.1 compiler can
566 * compile this file.
567 */
568 public void list(PrintWriter out) {
569 out.println("-- listing properties --");
570 Hashtable<String, String> h = new Hashtable<>();
571 enumerate(h);
572 for (Enumeration<String> e = h.keys() ; e.hasMoreElements() ;) {
573 String key = e.nextElement();
574 String val = h.get(key);
575 if (val.length() > 40) {
576 val = val.substring(0, 37) + "...";
577 }
578 out.println(key + "=" + val);
579 }
580 }
581
582 /**
583 * Enumerates all key/value pairs in the specified hastable.
584 * @param h the hashtable
585 */
586 private synchronized void enumerate(Map<String, String> h) {
587 if (defaults != null) {
588 defaults.enumerate(h);
589 }
590 for (Enumeration<String> e = keys() ; e.hasMoreElements() ;) {
591 String key = e.nextElement();
592 h.put(key, get(key));
593 }
594 }
595
596 /**
597 * Convert a nibble to a hex character
598 * @param nibble the nibble to convert.
599 */
600 private static char toHex(int nibble) {
601 return hexDigit[(nibble & 0xF)];
602 }
603
604 /** A table of hex digits */
605 private static char[] hexDigit = {
606 '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'
607 };
608 }