/*
* 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'
};
}