public static void main(String argv[]) {
RTConfig.setCommandLineArgs(argv);
long now = DateTime.getCurrentTimeSec();
long sts = now - DateTime.DaySeconds(3);
long ets = now;
GoogleChartTemperature gct = new GoogleChartTemperature();
try {
gct.setSize(700, 400);
gct.setTitle(Color.black, 16, "Temperature");
gct.setTemperatureRange(1, F2C(0.0), F2C(130.0), 10);
gct.setDateRange(new DateTime(sts), new DateTime(ets), 8);
gct.setDateFormat("MM/dd");
gct.setTimeFormat("HH:mm:ss");
int setCount = 3;
int tempCount = 15;
gct._addRandomSampleData(setCount, tempCount);
System.out.println(gct.toString());
} catch (Throwable th) {
Print.logException("Error", th);
System.exit(1);
}
}
/** ** Main entery point for debugging/testing */
public static void main(String argv[]) {
RTConfig.setCommandLineArgs(argv);
Print.setAllOutputToStdout(true);
Print.setEncoding(ENCODING_UTF8);
String accountID = RTConfig.getString(ARG_ACCOUNT, "demo");
GoogleGeocodeV2 gn = new GoogleGeocodeV2("google", null, null);
/* reverse geocode */
if (RTConfig.hasProperty(ARG_REVGEOCODE)) {
GeoPoint gp = new GeoPoint(RTConfig.getString(ARG_REVGEOCODE, null));
if (!gp.isValid()) {
Print.logInfo("Invalid GeoPoint specified");
System.exit(1);
}
Print.logInfo("Reverse-Geocoding GeoPoint: " + gp);
Print.sysPrintln(
"RevGeocode = " + gn.getReverseGeocode(gp, null /*localeStr*/, false /*cache*/));
// Note: Even though the values are printed in UTF-8 character encoding, the
// characters may not appear to be property displayed if the console display
// does not support UTF-8.
System.exit(0);
}
/* no options */
Print.sysPrintln("No options specified");
System.exit(1);
}
public static void main(String argv[]) {
RTConfig.setCommandLineArgs(argv);
InitJ1587DescriptionProvider();
RTProperties cmdLineProps = RTConfig.getCommandLineProperties();
long fault = EncodeFault(cmdLineProps);
Print.sysPrintln("Fault : " + fault + " [0x" + StringTools.toHexString(fault) + "]");
Print.sysPrintln("String: " + GetPropertyString(fault));
Print.sysPrintln("Desc : " + GetFaultDescription(fault, null));
}
/** ** Main entry point for testing/debugging ** @param argv Comand-line arguments */
public static void main(String argv[]) {
RTConfig.setCommandLineArgs(argv);
String host = RTConfig.getString(ARG_HOST, null);
int port = RTConfig.getInt(ARG_PORT, 0);
/* send data */
if (RTConfig.hasProperty(ARG_SEND)) {
if (StringTools.isBlank(host)) {
Print.logError("Target host not specified");
usage();
}
if (port <= 0) {
Print.logError("Target port not specified");
usage();
}
String dataStr = RTConfig.getString(ARG_SEND, "hello");
byte data[] =
dataStr.startsWith("0x") ? StringTools.parseHex(dataStr, null) : dataStr.getBytes();
ClientSocketThread cst = new ClientSocketThread(host, port);
try {
cst.openSocket();
cst.socketWriteBytes(data);
} catch (Throwable t) {
Print.logException("Error", t);
} finally {
cst.closeSocket();
}
System.exit(0);
}
/* receive data */
if (RTConfig.hasProperty(ARG_RECEIVE)) {
if (port <= 0) {
Print.logError("Target port not specified");
usage();
}
if (!StringTools.isBlank(host)) {
Print.logWarn("Specified 'host' will be ignored");
}
Print.logError("Receive not yet implemented ...");
System.exit(99);
}
/* show usage */
usage();
}
public static void main(String argv[]) {
RTConfig.setCommandLineArgs(argv);
long ts = DateTime.getCurrentTimeSec();
double C = -5.6;
TemperatureSet TSList[] = new TemperatureSet[3];
for (int s = 0; s < TSList.length; s++) {
TemperatureSet TS = new TemperatureSet();
for (int i = 0; i < 10; i++) {
long tempTS = ts + (12345L * (i + 1) * (s + 1));
double tempC = C + (2.3 * i) + (1.1 * s);
Print.logInfo(s + ":" + i + "] Adding " + tempTS + ", " + tempC);
TS.addTemperature(tempTS, tempC);
}
TSList[s] = TS;
}
String t = TemperatureSet.CreateGoogleDataTableJavaScript(false, TSList);
Print.sysPrintln(t);
}
/** ** Debug/Testing entry point ** @param argv The command-line args */
public static void main(String argv[]) {
RTConfig.setCommandLineArgs(argv);
if (RTConfig.hasProperty(ARG_PACKAGE)) {
String pkg = RTConfig.getString(ARG_PACKAGE, "org.opengts.util");
String loc = RTConfig.getString(ARG_LOCALE, "en");
String key = RTConfig.getString(ARG_KEY, "");
Locale locale = I18N.getLocale(loc);
Print.sysPrintln("Package: " + pkg);
Print.sysPrintln("Locale : " + locale + " [" + loc + "]");
Print.sysPrintln("Key : " + key);
I18N i18n = I18N.getI18N(pkg, locale);
if (i18n != null) {
Print.sysPrintln("String : " + i18n.getString(key, "Undefined"));
} else {
Print.sysPrintln("Package resource not found");
}
System.exit(0);
}
if (RTConfig.hasProperty("test")) {
I18N i18n = getI18N(I18N.class, null);
i18n.printKeyValues();
String m3 =
i18n.getString(
"m.m3",
"{0}",
new Object() {
public String toString() {
return mainStr;
}
});
String m2 = i18n.getString("m.m2", "How Now Brown {0}", m3);
String m1 = i18n.getString("m.m1", "Message: \\n{0}", m2);
Print.sysPrintln(m1);
mainStr = "Horse";
Print.sysPrintln(m1);
}
}
/** ** Main entry point for testing/debugging ** @param argv Comand-line arguments */
public static void main(String argv[]) {
RTConfig.setCommandLineArgs(argv);
/* decode URI argument strings */
if (RTConfig.hasProperty(ARG_DECODE)) {
String a = RTConfig.getString(ARG_DECODE, "");
String s = URIArg.decodeArg(new StringBuffer(), a).toString();
Print.sysPrintln("ASCII: " + s);
System.exit(0);
}
/* encode Base64 strings */
if (RTConfig.hasProperty(ARG_ENCODE)) {
String s = RTConfig.getString(ARG_ENCODE, "");
String a = URIArg.encodeArg(new StringBuffer(), s).toString();
Print.sysPrintln("Args: " + a);
System.exit(0);
}
/* RTP decode */
if (RTConfig.hasProperty(ARG_RTPDEC)) {
URIArg rtpUrl = new URIArg(RTConfig.getString(ARG_RTPDEC, ""));
URIArg decUrl = rtpUrl.rtpDecode("rtp");
Print.sysPrintln("URL: " + decUrl.toString());
System.exit(0);
}
/* RTP encode */
if (RTConfig.hasProperty(ARG_RTPENC)) {
URIArg decUrl = new URIArg(RTConfig.getString(ARG_RTPENC, ""));
URIArg rtpUrl = decUrl.rtpEncode("rtp");
Print.sysPrintln("URL: " + rtpUrl.toString());
System.exit(0);
}
/* no options */
usage();
}
/** ** Main entry point for testing/debugging ** @param argv Comand-line arguments */
public static void main(String argv[]) {
RTConfig.setCommandLineArgs(argv);
/* help */
if (RTConfig.hasProperty(ARG_HELP)) {
_usage();
System.exit(1); // control does not reach here
}
/* extra args */
String extraArgs = RTConfig.getString(ARG_EXTRA, "");
if (!StringTools.isBlank(extraArgs)) {
// Print.logInfo("Extra: " + extraArgs);
RTProperties cfgProps = RTConfig.getConfigFileProperties();
if (extraArgs.indexOf(",") > 0) {
cfgProps.setProperties(extraArgs, ',');
} else {
cfgProps.setProperties(extraArgs);
}
// cfgProps.printProperties("");
}
/* special case "expire" */
String ARG_EXPIRE = "expire";
RTProperties expireRTP = RTConfig.getPropertiesForKey(ARG_EXPIRE, false);
if (expireRTP != null) {
Print.errPrintln("\n'expire' cannot be defined.");
System.exit(1);
}
/* args */
File directory = RTConfig.getFile(ARG_DIR, null);
String templateName =
StringTools.trim(RTConfig.getString(ARG_OPTIONAL, RTConfig.getString(ARG_TEMPLATE, "")));
boolean isOptional = RTConfig.hasProperty(ARG_OPTIONAL);
String packageName = StringTools.trim(RTConfig.getString(ARG_PACKAGE, null));
String outputName = RTConfig.getString(ARG_OUTPUT, "");
boolean overwrite = RTConfig.getBoolean(ARG_OVERWRITE, false);
/* cannot specify "-output=inline" if internal template specified */
if (StringTools.isBlank(outputName) || outputName.equalsIgnoreCase("stdout")) {
// -- output will be to "stdout"
outputName = "";
} else if (outputName.equalsIgnoreCase("inline")) {
// -- output will be to input file
if (templateName.startsWith(TEMPLATE_)) {
// -- @template not allowed with "inline"
Print.errPrintln("\nError: Cannot specify '-output=inline' with internal template");
_usage();
System.exit(1); // control does not reach here
} else if (isOptional) {
// -- optional not allowed with "inline"
Print.errPrintln("\nError: Cannot specify '-output=inline' with optional template");
_usage();
System.exit(1); // control does not reach here
} else if (!templateName.startsWith("*")) {
// -- output to input file
outputName = templateName;
}
} else {
// -- output to specified file
if (templateName.startsWith("*")) {
// -- template specifies a file-glob
Print.errPrintln(
"\nError: Cannot specify '-output=FILE' for recursize template specification");
_usage();
System.exit(1); // control does not reach here
}
}
/* template name file? */
if (templateName.startsWith("*")) {
if (isOptional) {
// -- optional not allowed with glob file specification
Print.errPrintln("\nError: Cannot specify optional '-template?=[**/]*.java'");
_usage();
System.exit(1); // control does not reach here
}
} else {
File file = (directory != null) ? new File(directory, templateName) : new File(templateName);
if (!file.isFile() && isOptional) {
// -- templateName doesn't exist and is optional
templateName = TEMPLATE_DEFAULT;
}
}
/* random */
Random rand = new Random();
if (!RTConfig.hasProperty("random.16")) {
RTConfig.setString("random.16", "0x" + StringTools.toHexString(rand.nextInt() & 0xFFFF, 16));
}
if (!RTConfig.hasProperty("random.32")) {
RTConfig.setString("random.32", "0x" + StringTools.toHexString(rand.nextInt(), 32));
}
if (!RTConfig.hasProperty("random.64")) {
RTConfig.setString("random.64", "0x" + StringTools.toHexString(rand.nextLong(), 64));
}
/* set current time (subject to change) */
String tzStr = RTConfig.getString("timezone", null);
TimeZone tz =
!StringTools.isBlank(tzStr) ? DateTime.getTimeZone(tzStr) : DateTime.getDefaultTimeZone();
DateTime now = new DateTime(tz);
if (!RTConfig.hasProperty("timetamp")) {
RTConfig.setLong("timestamp", now.getTimeSec());
}
if (!RTConfig.hasProperty("datetime")) {
RTConfig.setString("datetime", now.format("yyyy/MM/dd HH:mm:ss z"));
}
if (!RTConfig.hasProperty("date")) {
RTConfig.setString("date", now.format("yyyy/MM/dd"));
}
if (!RTConfig.hasProperty("time")) {
RTConfig.setString("time", now.format("HH:mm:ss"));
}
if (!RTConfig.hasProperty("timezone")) {
RTConfig.setString("timezone", now.format("z"));
}
/* special case "daysUntil" */
// %{daysUntil=2012:02:20} <== fixed time
String ARG_daysUntil_ = "daysUntil";
Set<String> daysUntil_keys = RTConfig.getPropertyKeys(ARG_daysUntil_, false);
for (String daysUntil_key : daysUntil_keys) {
String daysUntil_key_date = daysUntil_key + ".date";
RTProperties daysUntilRTP = RTConfig.getPropertiesForKey(daysUntil_key, false);
if (daysUntilRTP != null) {
// -- get/update the RTProperties where "daysUntil" is defined
String daysUntil = daysUntilRTP.getString(daysUntil_key, "");
if (StringTools.isBlank(daysUntil)) {
// -- remove keys
daysUntilRTP.removeProperty(daysUntil_key);
daysUntilRTP.removeProperty(daysUntil_key_date);
// Print.sysPrintln(daysUntil_key + " ==> <removed>");
// Print.sysPrintln(daysUntil_key_date + " ==> <removed>");
} else if ((daysUntil.indexOf("/") >= 0) || (daysUntil.indexOf(":") >= 0)) {
// -- Change "yyyy:mm:dd" to "DD"
// Note: The ':' separator should be used instead of '/', because "2010/10/01" is
// syntactically correct (ie. division) and can be compiled into a valid value,
// while "2010:10:01" is not, and will be caught by the compiler.
if (daysUntil.startsWith("'") || daysUntil.startsWith("\"")) {
daysUntil = daysUntil.substring(1); // remove prefixing quote
}
if (daysUntil.endsWith("'") || daysUntil.endsWith("\"")) {
daysUntil = daysUntil.substring(0, daysUntil.length() - 1); // remove trailing quote
}
try {
DateTime nowDT = new DateTime(DateTime.getGMTTimeZone());
DateTime futDT = DateTime.parseArgumentDate(daysUntil, null, true);
long nowDay = DateTime.getDayNumberFromDate(nowDT);
long futDay = DateTime.getDayNumberFromDate(futDT);
long deltaD = futDay - nowDay;
if (deltaD == 0L) {
// -- today
deltaD = 1L; // make it tomorrow
} else if (deltaD < 0L) {
// -- this means that the date has already passed
// deltaD = -1L; // already negative
} else {
deltaD += 1L; // add one more day
}
daysUntilRTP.setString(daysUntil_key, String.valueOf(deltaD));
daysUntilRTP.setString(daysUntil_key_date, futDT.format(DateTime.DEFAULT_DATE_FORMAT));
} catch (DateTime.DateParseException dpe) {
Print.logException("Unable to parse Date: " + daysUntil, dpe);
System.exit(1);
}
// Print.sysPrintln(daysUntil_key + " ==> " + daysUntilRTP.getString(daysUntil_key
// ,"?"));
// Print.sysPrintln(daysUntil_key_date + " ==> " +
// daysUntilRTP.getString(daysUntil_key_date,"?"));
} else {
long futSec =
DateTime.getCurrentTimeSec()
+ DateTime.DaySeconds(StringTools.parseLong(daysUntil, 0L));
daysUntilRTP.setString(
daysUntil_key_date, (new DateTime(futSec)).format(DateTime.DEFAULT_DATE_FORMAT));
// Print.sysPrintln(daysUntil_key + " ==> " + daysUntilRTP.getString(daysUntil_key
// ,"?"));
// Print.sysPrintln(daysUntil_key_date + " ==> " +
// daysUntilRTP.getString(daysUntil_key_date,"?"));
}
}
}
/* special case "daysFromNow" */
// %{daysFromNow=30} <== 30 days from now
String ARG_daysFromNow_ = "daysFromNow";
Set<String> daysFromNow_keys = RTConfig.getPropertyKeys(ARG_daysFromNow_, false);
for (String daysFromNow_key : daysFromNow_keys) {
String daysFromNow_key_date = daysFromNow_key + ".date";
RTProperties daysFromNowRTP = RTConfig.getPropertiesForKey(daysFromNow_key, false);
if (daysFromNowRTP != null) {
// -- get/update the RTProperties where "daysFromNow" is defined
String daysFromNow = daysFromNowRTP.getString(daysFromNow_key, "");
if (StringTools.isBlank(daysFromNow)) {
// -- remove keys
daysFromNowRTP.removeProperty(daysFromNow_key);
daysFromNowRTP.removeProperty(daysFromNow_key_date);
// Print.sysPrintln(daysFromNow_key + " ==> <removed>");
// Print.sysPrintln(daysFromNow_key_date + " ==> <removed>");
} else {
long futSec =
DateTime.getCurrentTimeSec()
+ DateTime.DaySeconds(StringTools.parseLong(daysFromNow, 0L));
daysFromNowRTP.setString(daysFromNow_key, String.valueOf(futSec));
daysFromNowRTP.setString(
daysFromNow_key_date, (new DateTime(futSec)).format(DateTime.DEFAULT_DATE_FORMAT));
// Print.sysPrintln(daysFromNow_key + " ==> " +
// daysFromNowRTP.getString(daysFromNow_key ,"?"));
// Print.sysPrintln(daysFromNow_key_date + " ==> " +
// daysFromNowRTP.getString(daysFromNow_key_date,"?"));
}
}
}
/* special case "secondsUntil" */
// %{secondsUntil_abc=2012:02:20} <== fixed time
// %{secondsUntil_abc=86400} <== relative time (86400 seconds from now)
String ARG_secondsUntil_ = "secondsUntil";
Set<String> secUntil_keys = RTConfig.getPropertyKeys(ARG_secondsUntil_, false);
for (String secUntil_key : secUntil_keys) {
String secUntil_key_date = secUntil_key + ".date";
RTProperties secUntilRTP = RTConfig.getPropertiesForKey(secUntil_key, false);
if (secUntilRTP != null) {
// -- get/update the RTProperties where "secondsUntil" is defined
String secUntil = secUntilRTP.getString(secUntil_key, "");
if (StringTools.isBlank(secUntil)) {
// remove keys
secUntilRTP.removeProperty(secUntil_key);
secUntilRTP.removeProperty(secUntil_key_date);
// Print.sysPrintln(secUntil_key + " ==> <removed>");
// Print.sysPrintln(secUntil_key_date + " ==> <removed>");
} else if ((secUntil.indexOf("/") >= 0) || (secUntil.indexOf(":") >= 0)) {
// -- Change "yyyy:mm:dd:HH:MM:SS" to "ssssss"
// Note: The ':' separator should be used instead of '/', because "2010/10/01" is
// syntactically correct (ie. division) and can be compiled into a valid value,
// while "2010:10:01" is not, and will be caught by the compiler.
if (secUntil.startsWith("'") || secUntil.startsWith("\"")) {
secUntil = secUntil.substring(1); // remove prefixing quote
}
if (secUntil.endsWith("'") || secUntil.endsWith("\"")) {
secUntil = secUntil.substring(0, secUntil.length() - 1); // remove trailing quote
}
try {
long nowSec = DateTime.getCurrentTimeSec();
DateTime futDT = DateTime.parseArgumentDate(secUntil, null, true);
long futSec = futDT.getTimeSec();
long deltaS = futSec - nowSec;
if (deltaS == 0L) {
// -- now
deltaS = 1L; // make it 1 second from now
} else if (deltaS < 0L) {
// -- this means that the time has already passed
// deltaS = -1L; // already negative
} else {
deltaS += 1L; // add one more second
}
secUntilRTP.setString(secUntil_key, String.valueOf(deltaS));
secUntilRTP.setString(secUntil_key_date, futDT.toString());
} catch (DateTime.DateParseException dpe) {
Print.logException("Unable to parse Date: " + secUntil, dpe);
System.exit(1);
}
// Print.sysPrintln(secUntil_key + " ==> " + secUntilRTP.getString(secUntil_key
// ,"?"));
// Print.sysPrintln(secUntil_key_date + " ==> " +
// secUntilRTP.getString(secUntil_key_date,"?"));
} else {
long futSec = DateTime.getCurrentTimeSec() + StringTools.parseLong(secUntil, 0L);
secUntilRTP.setString(secUntil_key_date, (new DateTime(futSec)).toString());
// Print.sysPrintln(secUntil_key + " ==> " + secUntilRTP.getString(secUntil_key
// ,"?"));
// Print.sysPrintln(secUntil_key_date + " ==> " +
// secUntilRTP.getString(secUntil_key_date,"?"));
}
}
}
/* special case "secondsFromNow" */
// %{secondsFromNow=30} <== 30 seconds from now
String ARG_secondsFromNow_ = "secondsFromNow";
Set<String> secondsFromNow_keys = RTConfig.getPropertyKeys(ARG_secondsFromNow_, false);
for (String secondsFromNow_key : secondsFromNow_keys) {
String secondsFromNow_key_date = secondsFromNow_key + ".date";
RTProperties secondsFromNowRTP = RTConfig.getPropertiesForKey(secondsFromNow_key, false);
if (secondsFromNowRTP != null) {
// -- get/update the RTProperties where "secondsFromNow" is defined
String secondsFromNow = secondsFromNowRTP.getString(secondsFromNow_key, "");
if (StringTools.isBlank(secondsFromNow)) {
// -- remove keys
secondsFromNowRTP.removeProperty(secondsFromNow_key);
secondsFromNowRTP.removeProperty(secondsFromNow_key_date);
// Print.sysPrintln(secondsFromNow_key + " ==> <removed>");
// Print.sysPrintln(secondsFromNow_key_date + " ==> <removed>");
} else {
long futSec = DateTime.getCurrentTimeSec() + StringTools.parseLong(secondsFromNow, 0L);
secondsFromNowRTP.setString(secondsFromNow_key, String.valueOf(futSec));
secondsFromNowRTP.setString(
secondsFromNow_key_date, (new DateTime(futSec)).format(DateTime.DEFAULT_DATE_FORMAT));
// Print.sysPrintln(secondsFromNow_key + " ==> " +
// secondsFromNowRTP.getString(secondsFromNow_key ,"?"));
// Print.sysPrintln(secondsFromNow_key_date + " ==> " +
// secondsFromNowRTP.getString(secondsFromNow_key_date,"?"));
}
}
}
/* special case "limit" */
String ARG_limit_ = "limit";
Set<String> limit_keys = RTConfig.getPropertyKeys(ARG_limit_, false);
for (String limit_key : limit_keys) {
RTProperties limitRTP = RTConfig.getPropertiesForKey(limit_key, false);
if (limitRTP != null) {
String limit = limitRTP.getString(limit_key, "");
if (StringTools.isBlank(limit)) {
limitRTP.removeProperty(limit_key);
// Print.sysPrintln(limit_key + " ==> <removed>");
} else {
// Print.sysPrintln(limit_key + " ==> " + limit);
}
}
}
/* adjust packageName */
if (packageName.equals(JAVA_PACKAGE)) {
Print.errPrintln(
"\nWarning: 'package' argument cannot equal \"package\" (setting to empty string).");
packageName = "";
}
// --------------------------------------
/* internal template (single pass only) */
if (StringTools.isBlank(templateName) || templateName.startsWith(TEMPLATE_)) {
try {
// -- input source
String inputSource = standardTemplate(templateName, packageName);
if (StringTools.isBlank(inputSource)) {
if (isOptional) {
// -- optional "templateName" not defined, use default template
inputSource = standardTemplate(null, packageName); // non-blank
} else {
throw new IOException("Standard template not found: " + templateName);
}
}
// -- write template output
File outputFile = CompiletimeVars.getOutputFile(directory, outputName, overwrite);
CompiletimeVars.writeOutputSource(inputSource, outputFile);
} catch (NoOverwriteException noe) {
// -- outputFile exists, quietly ignore
Print.sysPrintln(noe.getMessage());
System.exit(0);
} catch (IOException ioe) {
// -- error writin file
Print.errPrintln("\nError writing template: " + ioe.getMessage());
System.exit(1);
}
System.exit(0);
}
// --------------------------------------
/* get input file(s) */
File inputFileArray[] = null;
if (templateName.startsWith("**/*.")) {
// -- all files, in all directories (recursive)
String fileGlob = templateName.substring(3);
File files[] = FileTools.getFiles(directory, fileGlob, true);
inputFileArray = files;
} else if (templateName.startsWith("*.")) {
// -- all files in specified directory
String fileGlob = templateName;
File files[] = FileTools.getFiles(directory, fileGlob, false);
inputFileArray = files;
} else {
// -- single specific file
File file = (directory != null) ? new File(directory, templateName) : new File(templateName);
inputFileArray = new File[] {file};
}
/* loop through input files */
boolean singlePass = false;
for (File inputFile : inputFileArray) {
/* file must exist here */
if (!inputFile.isFile()) {
// -- not a file
continue;
}
/* get input source from template file */
String inputSource = CompiletimeVars.readTemplate(inputFile, packageName);
if (StringTools.isBlank(inputSource)) {
// -- inputSource not available?
continue;
}
/* precheck output file */
File outputFile = null;
try {
if (StringTools.isBlank(outputName) || outputName.equalsIgnoreCase("stdout")) {
// -- output to stdout (multi-pass ok)
} else if (outputName.equalsIgnoreCase("inline")) {
// -- write back to template file (multi-pass ok)
overwrite = true; // assume implied overwrite
outputFile = inputFile;
} else {
// -- output to specified file (single-pass only)
outputFile = getOutputFile(directory, outputName, overwrite);
singlePass = true;
}
} catch (NoOverwriteException noe) {
// -- outputFile exists, quietly ignore
Print.sysPrintln(noe.getMessage());
System.exit(0);
} catch (IOException ioe) {
Print.errPrintln("\nInvalid output file: " + ioe.getMessage());
System.exit(1);
}
/* adjust source and write output */
try {
CompiletimeVars.writeOutputSource(inputSource, outputFile);
if (singlePass) {
break;
}
} catch (IOException ioe) {
Print.errPrintln("\nError writing file: " + ioe.getMessage());
System.exit(1);
}
}
/* success */
System.exit(0);
}
/** ** Main entry point for testing/debugging ** @param argv Comand-line arguments */
public static void main(String argv[]) {
RTConfig.setCommandLineArgs(argv);
printDefaults(System.out);
}
