/** ** 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)); }
/** ** Apply replacements/conditionals and write output */ public static void writeOutputSource(String inputSource, File outputFile) throws IOException { String outputSource = inputSource; if (StringTools.isBlank(outputSource)) { // throw new IOException("Output Source is empty"); return; } /* custom map */ Map<String, String> customMap = new HashMap<String, String>() { @Override public String get(Object key) { String ks = StringTools.trim(key); if (ks.toLowerCase().endsWith(".md5")) { String K = ks.substring(0, ks.length() - ".md5".length()); String V = RTConfig._getString(K, null, true /*dftOK*/); if (V != null) { return StringTools.trim(FileTools.getHash_MD5(V.getBytes())).toUpperCase(); } else { return null; } } else { return null; } } }; /* replace standard runtime vars in text (ie. %{var=value}) */ // -- replace %{var=value} outputSource = RTConfig.insertKeyValues(outputSource, STR_DELIM, END_DELIM, DFT_DELIM, customMap); // -- replace /#{var=value}#/ outputSource = RTConfig.insertKeyValues(outputSource, STR_CDELIM, END_CDELIM, DFT_CDELIM, customMap); /* conditional code? */ outputSource = CompiletimeVars.getConditionalSource(outputSource); /* write output */ if (outputFile != null) { Print.sysPrintln("Output to file: " + outputFile); boolean didWrite = FileTools.writeFile(outputSource.getBytes(), outputFile); if (!didWrite) { throw new IOException("Unable to write output file."); } } else { // -- write to stdout Print.sysPrintln(outputSource); } }
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); } }
protected String getStringProperty(Device device, String key, String dft) { DCServerConfig dcs = (device != null) ? DCServerFactory.getServerConfig(device.getDeviceCode()) : null; String prop = null; if (dcs != null) { prop = dcs.getStringProperty(key, dft); Print.logInfo("DCServerConfig property '" + key + "' ==> " + prop); if (StringTools.isBlank(prop) && RTConfig.hasProperty(key)) { Print.logInfo("(RTConfig property '" + key + "' ==> " + RTConfig.getString(key, "") + ")"); } } else { prop = RTConfig.getString(key, dft); Print.logInfo("RTConfig property '" + key + "' ==> " + prop); } return prop; }
/** * ** Prints all the default values from <code>RTKey</code> and {@link RTConfig} ** to the * specified <code>PrintStream</code>. Used for debugging/testing ** @param out The <code> * PrintStream</code> */ public static void printDefaults(PrintStream out) { /* print standard runtime entries */ Set<String> keyList = new OrderedSet<String>(); String keyGrp = null; for (Iterator<Entry> v = RTKey.getRuntimeEntryMap().values().iterator(); v.hasNext(); ) { Entry rtk = v.next(); if (rtk.isHelp()) { out.println(""); out.println("# ===== " + rtk.getHelp()); } else { Object dft = rtk.getDefault(); out.println("# --- " + rtk.getHelp()); out.println("# " + rtk.toString(dft)); String key = rtk.getKey(); keyList.add(key); if (!key.equals(CONFIG_FILE) && RTConfig.hasProperty(key)) { String val = RTConfig.getString(key, null); // if ((val != null) && ((dft == null) || !val.equals(dft.toString()))) { out.println(rtk.toString(val)); // } } } } /* orphaned entries */ RTProperties cmdLineProps = RTConfig.getConfigFileProperties(); if (cmdLineProps != null) { boolean orphanHeader = false; for (Iterator i = cmdLineProps.keyIterator(); i.hasNext(); ) { Object k = i.next(); if (!k.equals(COMMAND_LINE_CONF) && !keyList.contains(k)) { if (!orphanHeader) { out.println(""); out.println("# ===== Other entries"); orphanHeader = true; } Object v = cmdLineProps.getProperty(k, null); out.println(k + "=" + ((v != null) ? v : NULL_VALUE)); } } } /* final blank line */ out.println(""); }
public String toString() { String locStr = RTConfig.getString(RTKey.SESSION_LOCALE, null); if (StringTools.isBlank(locStr)) { return this.getDefault(); } else { Locale loc = I18N.getLocale(locStr); return this.toString(loc); } }
/** ** Gets the scrambled Base64 alphabet ** @return The scrambled Base64 alphabet */ private static char[] getBase64Alphabet() { if (Base64Alphabet == null) { BigInteger seed = RTConfig.getBigInteger(PROP_uriArgScrambleSeed, DefaultScrambleSeed); Base64Alphabet = Base64.shuffleAlphabet(seed); for (int i = 0; i < Base64Alphabet.length; i++) { if (Base64Alphabet[i] == '+') { Base64Alphabet[i] = '-'; } else if (Base64Alphabet[i] == '/') { Base64Alphabet[i] = '_'; } } // Print.logInfo("Base64 Alpha ["+seed+"]: "+StringTools.toStringValue(Base64Alphabet)); } return Base64Alphabet; };
/** ** 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(); }
/** * ** Gets the Localized value for the specified key. The default String text is returned ** if * the specified key does not exist ** @param key The LocalStrings key ** @param dft The default * String text to return if the LocalStrings key does not exist ** @return The Localized String * text */ public String getString(String key, String dft) { if (!StringTools.isBlank(key) && (this.resBundle != null)) { RTProperties cfgProps = RTConfig.getConfigFileProperties(); if (!cfgProps.hasProperty(key) || cfgProps.getBoolean(key, true)) { try { String s = this.resBundle.getString(key); if (s != null) { return I18N.decodeNewLine(s); } } catch (Throwable th) { // Print.logException("",th); // MissingResourceException - if no object for the given key can be found // ClassCastException - if the object found for the given key is not a string } } } return I18N.decodeNewLine(dft); }
/** * ** Gets the Java Locale instance based on the specified locale name ** @param loc The name of * the Locale ** @param dft The default Locale returned ** @return The Java Locale instance */ public static Locale getLocale(String loc, Locale dft) { String locale = !StringTools.isBlank(loc) ? loc : RTConfig.getString(RTKey.LOCALE, ""); if (StringTools.isBlank(locale)) { return dft; } else { int p = locale.indexOf("_"); try { if (p < 0) { String language = locale; return new Locale(language); } else { String language = locale.substring(0, p); String country = locale.substring(p + 1); return new Locale(language, country); } } catch (Throwable th) { return dft; } } }
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); }
/** ** 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(); }
/** ** 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); } }
public static void main(String args[]) { DBConfig.cmdLineInit(args, true); // main String acctID = RTConfig.getString(ARG_ACCOUNT, ""); String roleID = RTConfig.getString(ARG_ROLE, ""); String aclID = RTConfig.getString(ARG_ACL, ""); /* account-id specified? */ if ((acctID == null) || acctID.equals("")) { Print.logError("Account-ID not specified."); usage(); } /* get account */ Account acct = null; try { acct = Account.getAccount(acctID); // may return DBException if (acct == null) { Print.logError("Account-ID does not exist: " + acctID); usage(); } } catch (DBException dbe) { Print.logException("Error loading Account: " + acctID, dbe); // dbe.printException(); System.exit(99); } /* role-id specified? */ if ((roleID == null) || roleID.equals("")) { Print.logError("Role-ID not specified."); usage(); } /* get role */ Role role = null; try { role = Role.getRole(acct, roleID); // may return DBException if (role == null) { Print.logError("Role-ID does not exist: " + acctID + "/" + roleID); usage(); } } catch (DBException dbe) { Print.logException("Error loading Role: " + acctID + "/" + roleID, dbe); // dbe.printException(); System.exit(99); } /* RoleAcl exists? */ boolean aclExists = false; if ((aclID != null) && !aclID.equals("")) { try { aclExists = RoleAcl.exists(acctID, roleID, aclID); } catch (DBException dbe) { Print.logError( "Error determining if RoleAcl exists: " + acctID + "/" + roleID + "/" + aclID); System.exit(99); } } /* option count */ int opts = 0; /* list */ if (RTConfig.getBoolean(ARG_LIST, false)) { opts++; try { String aclList[] = role.getAclsForRole(); for (int i = 0; i < aclList.length; i++) { AccessLevel level = RoleAcl.getAccessLevel(role, aclList[i], AccessLevel.NONE); Print.sysPrintln(" " + aclList[i] + " ==> " + level); } } catch (DBException dbe) { Print.logError("Error getting Acl list: " + dbe); System.exit(99); } System.exit(0); } /* delete */ if (RTConfig.getBoolean(ARG_DELETE, false) && !acctID.equals("") && !roleID.equals("")) { opts++; if (!aclExists) { Print.logWarn("RoleAcl does not exist: " + acctID + "/" + roleID + "/" + aclID); Print.logWarn("Continuing with delete process ..."); } try { RoleAcl.Key aclKey = new RoleAcl.Key(acctID, roleID, aclID); aclKey.delete(true); // also delete dependencies Print.logInfo("RoleAcl deleted: " + acctID + "/" + roleID + "/" + aclID); } catch (DBException dbe) { Print.logError("Error deleting RoleAcl: " + acctID + "/" + roleID + "/" + aclID); dbe.printException(); System.exit(99); } System.exit(0); } /* create */ if (RTConfig.getBoolean(ARG_CREATE, false)) { opts++; if (aclExists) { Print.logWarn("RoleAcl already exists: " + acctID + "/" + roleID + "/" + aclID); } else { try { RoleAcl.createNewRoleAcl(role, aclID); Print.logInfo("Created RoleAcl: " + acctID + "/" + roleID + "/" + aclID); aclExists = true; } catch (DBException dbe) { Print.logError("Error creating RoleAcl: " + acctID + "/" + roleID + "/" + aclID); dbe.printException(); System.exit(99); } } } /* set */ if (RTConfig.hasProperty(ARG_SET)) { opts++; AccessLevel aclLevel = EnumTools.getValueOf(AccessLevel.class, RTConfig.getInt(ARG_SET, -1)); try { RoleAcl.setAccessLevel(role, aclID, aclLevel); Print.logInfo( "Set RoleAcl '" + acctID + "/" + roleID + "/" + aclID + "' to level " + aclLevel); } catch (DBException dbe) { Print.logError("Error setting RoleAcl: " + acctID + "/" + roleID + "/" + aclID); dbe.printException(); System.exit(99); } System.exit(0); } /* edit */ if (RTConfig.getBoolean(ARG_EDIT, false)) { opts++; if (!aclExists) { Print.logError("RoleAcl does not exist: " + acctID + "/" + roleID + "/" + aclID); } else { try { RoleAcl roleAcl = RoleAcl.getRoleAcl(role, aclID, false); // may throw DBException DBEdit editor = new DBEdit(roleAcl); editor.edit(); // may throw IOException } catch (IOException ioe) { if (ioe instanceof EOFException) { Print.logError("End of input"); } else { Print.logError("IO Error"); } } catch (DBException dbe) { Print.logError("Error editing RoleAcl: " + acctID + "/" + roleID + "/" + aclID); dbe.printException(); } } System.exit(0); } /* no options specified */ if (opts == 0) { Print.logWarn("Missing options ..."); usage(); } }
public static void main(String argv[]) { DBConfig.cmdLineInit(argv, true); // main String accountID = RTConfig.getString(ARG_ACCOUNT, ""); String deviceID = RTConfig.getString(ARG_DEVICE, ""); int statusCode = RTConfig.getInt(ARG_CODE, 0); boolean anyCode = true; // RTConfig.hasProperty(ARG_ECODE); /* account-id specified? */ if (StringTools.isBlank(accountID)) { Print.logError("Account-ID not specified."); usage(); } /* get account */ Account account = null; try { account = Account.getAccount(accountID); // may throw DBException if (account == null) { Print.logError("Account-ID does not exist: " + accountID); usage(); } } catch (DBException dbe) { Print.logException("Error loading Account: " + accountID, dbe); // dbe.printException(); System.exit(99); } /* device-id specified? */ if (StringTools.isBlank(deviceID) || deviceID.startsWith("/")) { deviceID = ALL_DEVICES; } /* check device existance */ if (!deviceID.equals(ALL_DEVICES)) { try { Device device = Device.getDevice(account, deviceID); // may throw DBException if (device == null) { Print.logError("Device-ID does not exist: " + accountID + " / " + deviceID); usage(); } } catch (DBException dbe) { Print.logException("Error loading Device: " + accountID + " / " + deviceID, dbe); System.exit(99); } } /* status-code specified? */ if ((statusCode > 0) && !anyCode && !StatusCodes.IsValid(statusCode, account.getPrivateLabel())) { Print.logError("Invalid Status Code specified."); usage(); } /* statusCode specified? */ if (statusCode <= 0) { Print.logError("StatusCode not specified."); usage(); } /* statusCode exists? */ boolean statusCodeExists = false; try { statusCodeExists = StatusCode.exists(accountID, deviceID, statusCode); } catch (DBException dbe) { Print.logError( "Error determining if StatusCode exists: " + accountID + "/" + deviceID + "/" + statusCode); System.exit(99); } /* option count */ int opts = 0; /* delete */ if (RTConfig.getBoolean(ARG_DELETE, false)) { opts++; if (!statusCodeExists) { Print.logWarn( "StatusCode does not exist: " + accountID + "/" + deviceID + "/" + statusCode); Print.logWarn("Continuing with delete process ..."); } try { StatusCode.Key scKey = new StatusCode.Key(accountID, deviceID, statusCode); scKey.delete(true); // also delete dependencies (if any) Print.logInfo("StatusCode deleted: " + accountID + "/" + deviceID + "/" + statusCode); statusCodeExists = false; } catch (DBException dbe) { Print.logError( "Error deleting StatusCode: " + accountID + "/" + deviceID + "/" + statusCode); dbe.printException(); System.exit(99); } System.exit(0); } /* create */ if (RTConfig.getBoolean(ARG_CREATE, false)) { opts++; if (statusCodeExists) { Print.logWarn( "StatusCode already exists: " + accountID + "/" + deviceID + "/" + statusCode); } else { try { StatusCode.createNewStatusCode(account, deviceID, statusCode); Print.logInfo("Created StatusCode: " + accountID + "/" + deviceID + "/" + statusCode); statusCodeExists = true; } catch (DBException dbe) { Print.logError( "Error creating StatusCode: " + accountID + "/" + deviceID + "/" + statusCode); dbe.printException(); System.exit(99); } } } /* edit */ if (RTConfig.getBoolean(ARG_EDIT, false)) { opts++; if (!statusCodeExists) { Print.logError( "StatusCode does not exist: " + accountID + "/" + deviceID + "/" + statusCode); } else { try { StatusCode sc = StatusCode.getStatusCode(account, deviceID, statusCode); // may throw DBException DBEdit editor = new DBEdit(sc); editor.edit(); // may throw IOException } catch (IOException ioe) { if (ioe instanceof EOFException) { Print.logError("End of input"); } else { Print.logError("IO Error"); } } catch (DBException dbe) { Print.logError( "Error editing StatusCode: " + accountID + "/" + deviceID + "/" + statusCode); dbe.printException(); } } System.exit(0); } /* list */ if (RTConfig.hasProperty(ARG_LIST)) { opts++; String listType = RTConfig.getString(ARG_LIST, null); // TODO: complete ... } /* no options specified */ if (opts == 0) { Print.logWarn("Missing options ..."); usage(); } }
public boolean insertEventData() { /* valid device? */ if (this.device == null) { return false; } /* debug message */ if (RTConfig.isDebugMode()) { Print.logDebug("Inserting EventData ...\n" + this.toString()); } /* EventData key */ String acctID = this.device.getAccountID(); String devID = this.device.getDeviceID(); long fixtime = this.getTimestamp(); int statusCode = this.getStatusCode(); EventData.Key evKey = new EventData.Key(acctID, devID, fixtime, statusCode); EventData evdb = evKey.getDBRecord(); /* set EventData field values */ if (USE_EVENTDATA_SETVALUE) { for (Object fldn : this.fieldValues.getPropertyKeys()) { if (fldn.equals(EventData.FLD_timestamp)) { continue; // already set above } else if (fldn.equals(EventData.FLD_statusCode)) { continue; // already set above } Object fldv = this.fieldValues.getProperty(fldn, null); if (fldv != null) { evdb.setValue((String) fldn, fldv); // attempts to use "setter" methods } } } else { if (this.hasLatitude()) { evdb.setLatitude(this.getLatitude()); } if (this.hasLongitude()) { evdb.setLongitude(this.getLongitude()); } if (this.hasGpsAge()) { evdb.setGpsAge(this.getGpsAge()); } if (this.hasHDOP()) { evdb.setHDOP(this.getHDOP()); } if (this.hasSatelliteCount()) { evdb.setSatelliteCount(this.getSatelliteCount()); } if (this.hasSpeedKPH()) { evdb.setSpeedKPH(this.getSpeedKPH()); } if (this.hasHeading()) { evdb.setHeading(this.getHeading()); } if (this.hasAltitude()) { evdb.setAltitude(this.getAltitude()); } if (this.hasInputMask()) { evdb.setInputMask(this.getInputMask()); } if (this.hasBatteryLevel()) { evdb.setBatteryLevel(this.getBatteryLevel()); } if (this.hasSignalStrength()) { evdb.setSignalStrength(this.getSignalStrength()); } if (this.hasOdometerKM()) { evdb.setOdometerKM(this.getOdometerKM()); } if (this.hasEngineHours()) { evdb.setEngineHours(this.getEngineHours()); } if (this.hasPtoHours()) { evdb.setPtoHours(this.getPtoHours()); } if (this.hasFuelTotal()) { evdb.setFuelTotal(this.getFuelTotal()); } if (this.hasGeozoneID()) { evdb.setGeozoneID(this.getGeozoneID()); } } /* other fields (if available) */ if (this.otherValues != null) { for (String fldn : this.otherValues.keySet()) { if (fldn.equals(EventData.FLD_timestamp)) { continue; } else if (fldn.equals(EventData.FLD_statusCode)) { continue; } Object fldv = this.otherValues.get(fldn); if (fldv != null) { evdb.setValue(fldn, fldv); // attempts to use "setter" methods } } } /* insert event */ // this will display an error if it was unable to store the event Print.logInfo( "Event : [0x" + StringTools.toHexString(statusCode, 16) + "] " + StatusCodes.GetDescription(statusCode, null)); this.device.insertEventData( evdb); // FLD_lastValidLatitude,FLD_lastValidLongitude,FLD_lastGPSTimestamp,FLD_lastOdometerKM this.eventTotalCount++; return true; }
/** ** Main entry point for testing/debugging ** @param argv Comand-line arguments */ public static void main(String argv[]) { RTConfig.setCommandLineArgs(argv); printDefaults(System.out); }
/** ** Apply conditionals to specified source */ public static String getConditionalSource(String outputText) { // - must have at least one "//#" in this template // - This conditional line-inclusion checker is not designed to be a comprehensive // precompiler, but just a simple single-level pre-compile-time template processor. // - Will not process conditionals if no 'if' is found // - The String " #" is not allow in a specified value (ambiguous with invalid comment) // - Does NOT currently support nested IF..ELSE..ENDIF !!! // - Prefixing spaces are allowed // - If anything other than a spece preceeds the '//#' the conditional will be ignored /* exit now if "//#" is not present in template */ if (outputText.indexOf(COND_) < 0) { return outputText; } /* convert to lines */ String s[] = StringTools.parseStringArray(outputText, "\n", false); // "\r\n" /* loop through code, replacing conditional code */ StringBuffer sb = new StringBuffer(); int ifLevel = 0; boolean saveLine = true; boolean okSave = true; checkConditional: for (int i = 0; i < s.length; i++) { /* current line contains conditional? */ if (s[i].indexOf(COND_) >= 0) { // -- this line contains "//#" String S = s[i].trim(); // remove leading space // -- remove any trailing comments; ## this is a comment int c = S.indexOf(COND_COMMENT); if (c > 0) { S = S.substring(0, c).trim(); } // -- look for IF..ELSE..ENDIF if (S.startsWith(COND_U_IF) || S.startsWith(COND_L_IF)) { // //#IF [key[=value]] if (ifLevel > 0) { // -- already encounted an "if" Print.errPrintln("\nNested 'if' encountered"); okSave = false; break checkConditional; } String cond = S.substring(COND_U_IF.length()).trim(); int p = cond.indexOf("="); String key = (p >= 0) ? cond.substring(0, p).trim() : cond.trim(); String val = (p >= 0) ? cond.substring(p + 1).trim() : null; if (StringTools.isBlank(key)) { // //#IF // -- no condition, assume "true" saveLine = true; } else if (val == null) { // //#IF [!]key // //#IF [!]true // //#IF [!]false // -- check for prefixing "!" boolean not = false; if (key.startsWith("!")) { not = true; key = key.substring(1); } // -- parse boolean boolean bool = false; if (key.equalsIgnoreCase("true")) { bool = true; } else if (key.equalsIgnoreCase("false")) { bool = false; } else { bool = RTConfig.getBoolean(key, false); } // -- save line? saveLine = not ? !bool : bool; } else { // //#IF key=value // -- compare key=value (case insensitive) // -- compare key==value (case sensitive) String rtpVal = RTConfig.getString(key, "").trim(); if (val.indexOf(" #") >= 0) { Print.errPrintln("\nValue contains invalid comment specification: " + val); okSave = false; break checkConditional; } if (val.startsWith("=")) { // -- case-sensitive compare saveLine = val.substring(1).equals(rtpVal); } else { // -- case-insensitive compare saveLine = val.equalsIgnoreCase(rtpVal); } } ifLevel++; continue; } else if (S.startsWith(COND_U_ELSE) || S.startsWith(COND_L_ELSE)) { // //#ELSE if (ifLevel <= 0) { // -- found an 'ELSE' without a previous 'IF' Print.errPrintln("\n'ELSE' without 'IF' encountered"); okSave = false; break checkConditional; } saveLine = !saveLine; continue; } else if (S.startsWith(COND_U_ENDIF) || S.startsWith(COND_L_ENDIF)) { // //#ENDIF if (ifLevel <= 0) { // -- found an 'ENDIF' without a previous 'IF' Print.errPrintln("\n'ENDIF' without 'IF' encountered"); okSave = false; break checkConditional; } ifLevel--; saveLine = true; continue; } else if (S.startsWith(COND_)) { // //#??? Print.errPrintln("\nUnrecognized conditional: " + S); continue; } else { // -- embedded '//#' } } /* save current line? */ if (saveLine) { sb.append(s[i]).append("\n"); } } /* save if no errors */ if (okSave) { outputText = sb.toString(); } else { Print.errPrintln("\nConditional code ignored due to previous errors"); } return outputText; }
public static void main(String args[]) { DBConfig.cmdLineInit(args, true); // main String acctID = RTConfig.getString(ARG_ACCOUNT, ""); String strID = RTConfig.getString(ARG_STRING, ""); /* account-id specified? */ if (StringTools.isBlank(acctID)) { Print.logError("Account-ID not specified."); usage(); } /* get account */ Account acct = null; try { acct = Account.getAccount(acctID); // may throw DBException if (acct == null) { Print.logError("Account-ID does not exist: " + acctID); usage(); } } catch (DBException dbe) { Print.logException("Error loading Account: " + acctID, dbe); // dbe.printException(); System.exit(99); } /* string-id specified? */ if ((strID == null) || strID.equals("")) { Print.logError("String-ID not specified."); usage(); } /* string exists? */ boolean stringExists = false; try { stringExists = AccountString.exists(acctID, strID); } catch (DBException dbe) { Print.logError("Error determining if AccountString exists: " + _fmtStrID(acctID, strID)); System.exit(99); } /* option count */ int opts = 0; /* delete */ if (RTConfig.getBoolean(ARG_DELETE, false) && !acctID.equals("") && !strID.equals("")) { opts++; if (!stringExists) { Print.logWarn("AccountString does not exist: " + _fmtStrID(acctID, strID)); Print.logWarn("Continuing with delete process ..."); } try { AccountString.Key strKey = new AccountString.Key(acctID, strID); strKey.delete(true); // also delete dependencies Print.logInfo("AccountString deleted: " + _fmtStrID(acctID, strID)); stringExists = false; } catch (DBException dbe) { Print.logError("Error deleting AccountString: " + _fmtStrID(acctID, strID)); dbe.printException(); System.exit(99); } System.exit(0); } /* create */ if (RTConfig.getBoolean(ARG_CREATE, false)) { opts++; if (stringExists) { Print.logWarn("AccountString already exists: " + _fmtStrID(acctID, strID)); } else { try { AccountString.createNewAccountString(acct, strID); Print.logInfo("Created AccountString: " + _fmtStrID(acctID, strID)); stringExists = true; } catch (DBException dbe) { Print.logError("Error creating AccountString: " + _fmtStrID(acctID, strID)); dbe.printException(); System.exit(99); } } } /* edit */ if (RTConfig.getBoolean(ARG_EDIT, false)) { opts++; if (!stringExists) { Print.logError("AccountString does not exist: " + _fmtStrID(acctID, strID)); } else { try { AccountString str = AccountString.getAccountString(acct, strID, false); // may throw DBException DBEdit editor = new DBEdit(str); editor.edit(true); // may throw IOException } catch (IOException ioe) { if (ioe instanceof EOFException) { Print.logError("End of input"); } else { Print.logError("IO Error"); } } catch (DBException dbe) { Print.logError("Error editing AccountString: " + _fmtStrID(acctID, strID)); dbe.printException(); } } System.exit(0); } /* no options specified */ if (opts == 0) { Print.logWarn("Missing 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); }