--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jaxp/make/tools/StripProperties/StripProperties.java Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,329 @@
+/*
+ * Copyright 2001 Sun Microsystems, Inc. All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ */
+
+import java.io.BufferedInputStream;
+import java.io.BufferedWriter;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.Properties;
+
+/**
+ * Reads a properties file from standard input and writes an equivalent
+ * properties file without comments to standard output.
+ */
+public class StripProperties {
+
+ public static void main(String[] args) {
+ StripProperties sp = new StripProperties();
+ boolean ok = sp.run(args);
+ if ( !ok ) {
+ System.exit(1);
+ }
+ }
+
+ static interface Log {
+ void info(String msg);
+ void verbose(String msg);
+ void error(String msg, Exception e);
+ }
+
+ private String propfiles[];
+ private String outfiles[] ;
+ private int stripCount = 0;
+ private boolean quiet = false;
+ private Log log;
+
+ public void setLog(Log log) {
+ this.log = log;
+ }
+
+ private boolean parseOptions(String args[]) {
+ boolean ok = true;
+ if ( stripCount > 0 ) {
+ String new_propfiles[] = new String[stripCount + args.length];
+ String new_outfiles[] = new String[stripCount + args.length];
+ System.arraycopy(propfiles, 0, new_propfiles, 0, stripCount);
+ System.arraycopy(outfiles, 0, new_outfiles, 0, stripCount);
+ propfiles = new_propfiles;
+ outfiles = new_outfiles;
+ } else {
+ propfiles = new String[args.length];
+ outfiles = new String[args.length];
+ }
+
+ for ( int i = 0; i < args.length ; i++ ) {
+ if ( "-strip".equals(args[i]) && i+2 < args.length ) {
+ propfiles[stripCount] = args[++i];
+ outfiles[stripCount] = args[++i];
+ stripCount++;
+ } else if ( "-optionsfile".equals(args[i]) && i+1 < args.length ) {
+ String filename = args[++i];
+ FileInputStream finput = null;
+ byte contents[] = null;
+ try {
+ finput = new FileInputStream(filename);
+ int byteCount = finput.available();
+ if ( byteCount <= 0 ) {
+ log.error("The -optionsfile file is empty", null);
+ ok = false;
+ } else {
+ contents = new byte[byteCount];
+ int bytesRead = finput.read(contents);
+ if ( byteCount != bytesRead ) {
+ log.error("Cannot read all of -optionsfile file", null);
+ ok = false;
+ }
+ }
+ } catch ( IOException e ) {
+ log.error("cannot open " + filename, e);
+ ok = false;
+ }
+ if ( finput != null ) {
+ try {
+ finput.close();
+ } catch ( IOException e ) {
+ ok = false;
+ log.error("cannot close " + filename, e);
+ }
+ }
+ if ( ok = true && contents != null ) {
+ String tokens[] = (new String(contents)).split("\\s+");
+ if ( tokens.length > 0 ) {
+ ok = parseOptions(tokens);
+ }
+ }
+ if ( !ok ) {
+ break;
+ }
+ } else if ( "-quiet".equals(args[i]) ) {
+ quiet = true;
+ } else {
+ log.error("argument error", null);
+ ok = false;
+ }
+ }
+ return ok;
+ }
+
+ private boolean stripFiles(String propertiesPath, String outputPath) {
+ boolean ok = true;
+ Properties prop = new Properties();
+ InputStream in = null;
+ try {
+ in = new BufferedInputStream(new FileInputStream(propertiesPath));
+ prop.load(in);
+ } catch ( FileNotFoundException e ) {
+ log.error("Cannot access file " + propertiesPath, e);
+ ok = false;
+ } catch ( IOException e ) {
+ log.error("IO exception processing file " + propertiesPath, e);
+ ok = false;
+ }
+ if ( in != null ) {
+ try {
+ in.close();
+ } catch ( IOException e ) {
+ log.error("IO exception closing file " + propertiesPath, e);
+ ok = false;
+ }
+ }
+
+ OutputStream out = null;
+ try {
+ out = new FileOutputStream(outputPath);
+ storeProperties(prop, out);
+ out.flush();
+ } catch ( IOException e ) {
+ log.error("IO exception processing file " + outputPath, e);
+ e.printStackTrace();
+ ok = false;
+ }
+ if ( out != null ) {
+ try {
+ out.close();
+ } catch ( IOException e ) {
+ log.error("IO exception closing file " + outputPath, e);
+ ok = false;
+ }
+ }
+ return ok;
+ }
+
+ /**
+ * Strip the properties filenames supplied, replacing their contents.
+ * @param args Names of properties files to process and replace contents
+ */
+ public boolean run(String args[]) {
+ if (log == null) {
+ log = new Log() {
+ public void error(String msg, Exception e) {
+ System.err.println("ERROR: StripProperties: " + msg);
+ if ( e != null ) {
+ System.err.println("EXCEPTION: " + e.toString());
+ e.printStackTrace();
+ }
+ }
+ public void info(String msg) {
+ System.out.println(msg);
+ }
+ public void verbose(String msg) {
+ if (!quiet)
+ System.out.println(msg);
+ }
+ };
+ }
+
+ boolean ok = true;
+ ok = parseOptions(args);
+ if ( ok && stripCount == 0 ) {
+ log.error("options parsed but no files to compile", null);
+ ok = false;
+ }
+ /* Need at least one file. */
+ if ( !ok ) {
+ //usage(log);
+ } else {
+ /* Process files */
+ for ( int i = 0; i < stripCount && ok ; i++ ) {
+ ok = stripFiles(propfiles[i], outfiles[i]);
+ }
+ }
+ return ok;
+ }
+
+ // --- code below here is adapted from java.util.Properties ---
+
+ private static final String specialSaveChars = "=: \t\r\n\f#!";
+
+ /*
+ * Converts unicodes to encoded \uxxxx
+ * and writes out any of the characters in specialSaveChars
+ * with a preceding slash
+ */
+ private static String saveConvert(String theString, boolean escapeSpace) {
+ int len = theString.length();
+ StringBuffer outBuffer = new StringBuffer(len*2);
+
+ for(int x=0; x<len; x++) {
+ char aChar = theString.charAt(x);
+ switch(aChar) {
+ case ' ':
+ if (x == 0 || escapeSpace) {
+ outBuffer.append('\\');
+ }
+ outBuffer.append(' ');
+ break;
+ case '\\':
+ outBuffer.append('\\');
+ outBuffer.append('\\');
+ break;
+ case '\t':
+ outBuffer.append('\\');
+ outBuffer.append('t');
+ break;
+ case '\n':
+ outBuffer.append('\\');
+ outBuffer.append('n');
+ break;
+ case '\r':
+ outBuffer.append('\\');
+ outBuffer.append('r');
+ break;
+ case '\f':
+ outBuffer.append('\\');
+ outBuffer.append('f');
+ break;
+ default:
+ if ((aChar < 0x0020) || (aChar == 0x007e) || (aChar > 0x00ff)) {
+ outBuffer.append('\\');
+ outBuffer.append('u');
+ outBuffer.append(toHex((aChar >> 12) & 0xF));
+ outBuffer.append(toHex((aChar >> 8) & 0xF));
+ outBuffer.append(toHex((aChar >> 4) & 0xF));
+ outBuffer.append(toHex( aChar & 0xF));
+ } else {
+ if (specialSaveChars.indexOf(aChar) != -1) {
+ outBuffer.append('\\');
+ }
+ outBuffer.append(aChar);
+ }
+ }
+ }
+ return outBuffer.toString();
+ }
+
+ /**
+ * Writes the content of <code>properties</code> to <code>out</code>.
+ * The format is that of Properties.store with the following modifications:
+ * <ul>
+ * <li>No header or date is written
+ * <li>Latin-1 characters are written as single bytes, not escape sequences
+ * <li>Line breaks are indicated by a single \n independent of platform
+ * <ul>
+ */
+ private static void storeProperties(Properties properties, OutputStream out)
+ throws IOException {
+ BufferedWriter awriter;
+ awriter = new BufferedWriter(new OutputStreamWriter(out, "8859_1"));
+ for (Enumeration e = properties.keys(); e.hasMoreElements();) {
+ String key = (String)e.nextElement();
+ String val = (String)properties.get(key);
+ key = saveConvert(key, true);
+
+ /* No need to escape embedded and trailing spaces for value, hence
+ * pass false to flag.
+ */
+ val = saveConvert(val, false);
+ writeln(awriter, key + "=" + val);
+ }
+ awriter.flush();
+ }
+
+ private static void writeln(BufferedWriter bw, String s) throws IOException {
+ bw.write(s);
+ bw.write("\n");
+ }
+
+ /**
+ * Convert a nibble to a hex character
+ * @param nibble the nibble to convert.
+ */
+ private static char toHex(int nibble) {
+ return hexDigit[(nibble & 0xF)];
+ }
+
+ /** A table of hex digits */
+ private static final char[] hexDigit = {
+ '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'
+ };
+}