330 lines
12 KiB
Java
330 lines
12 KiB
Java
/*
|
|
* 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'
|
|
};
|
|
}
|