package doglet.text; import nova.Machine; import nova.Store; import nova.eval; import nova.special; import java.math.RoundingMode; import java.text.DecimalFormat; import java.text.NumberFormat; import java.util.Locale; /** * Warranty & Liability * To the extent permitted by applicable law and unless explicitly * otherwise agreed upon, XLOG Technologies AG makes no warranties * regarding the provided information. XLOG Technologies AG assumes * no liability that any problems might be solved with the information * provided by XLOG Technologies AG. * * Rights & License * All industrial property rights regarding the information - copyright * and patent rights in particular - are the sole property of XLOG * Technologies AG. If the company was not the originator of some * excerpts, XLOG Technologies AG has at least obtained the right to * reproduce, change and translate the information. * * Reproduction is restricted to the whole unaltered document. Reproduction * of the information is only allowed for non-commercial uses. Selling, * giving away or letting of the execution of the library is prohibited. * The library can be distributed as part of your applications and libraries * for execution provided this comment remains unchanged. * * Restrictions * Only to be distributed with programs that add significant and primary * functionality to the library. Not to be distributed with additional * software intended to replace any components of the library. * * Trademarks * Jekejeke is a registered trademark of XLOG Technologies AG. */ public final class strlib { /*******************************************************************/ /* Number Formatting */ /*******************************************************************/ /** * sys_number_atom(F, S, N, A): internal only * The built-in succeeds in A with the number F formatted according * to the format specifier S and the number of digits N. */ private static boolean test_sys_number_atom(Object[] args) { Object num = Machine.exec_build(args[0]); special.check_number(num); Object spec = Machine.exec_build(args[1]); special.check_atom(spec); Object alpha = Machine.exec_build(args[2]); special.check_integer(alpha); if (Machine.is_bigint(alpha)) throw Machine.make_error(new Store.Compound("representation_error", new Object[]{"int"})); int digs = ((Integer) alpha).intValue(); if (digs < 0) throw Machine.make_error(new Store.Compound("domain_error", new Object[]{"not_less_than_zero", alpha})); String text; double value = num instanceof Double ? ((Double) num).doubleValue() : special.narrow_float((Number) num); if ("fF".contains((String)spec)) { text = floatAtom(value, digs, "0.0"); text = shapeFloat(text, (String)spec); } else if ("eE".contains((String)spec)) { text = floatAtom(value, digs, "0.0E00"); text = shapeFloat(text, (String)spec); } else if ("gG".contains((String)spec)) { int mag = (value != 0 ? (int)Math.floor(Math.log10( Math.abs(value))) : 0); if (mag >= digs || mag < -4) { text = floatAtom(value, digs - 1, "0.0E00"); } else { text = floatAtom(value, digs - 1 - mag, "0.0"); } text = shapeFloat(text, (String)spec); } else { throw Machine.make_error(new Store.Compound("existence_error", new Object[]{"format_character", spec})); } return Machine.exec_unify(args[3], text); } private static String floatAtom(double value, int digs, String type) { DecimalFormat fmt = (DecimalFormat)NumberFormat.getInstance(Locale.UK); fmt.applyPattern(type); fmt.setMaximumFractionDigits(digs); fmt.setMinimumFractionDigits(digs); fmt.setRoundingMode(RoundingMode.HALF_EVEN); fmt.setGroupingUsed(false); return fmt.format(value); } /** * Shape the number string. * * @param res The number string. * @param spec The format specifier. * @return The shaped number string. */ public static String shapeFloat(String res, String spec) { int peek = res.indexOf('E'); if (peek != -1) { res = shapeFloatMantissa(res.substring(0, peek), spec) + ("FEG".contains(spec) ? "E": "e") + shapeFloatExponent(res.substring(peek + 1)); } else { res = shapeFloatMantissa(res, spec); } return res; } private static String shapeFloatMantissa(String res, String spec) { if ("gG".contains(spec)) { if (res.indexOf('.') != -1) { int pos = res.length(); while (res.charAt(pos - 1) == '0') pos--; if (res.charAt(pos - 1) == '.') pos--; if (pos != res.length()) res = res.substring(0, pos); } } return res; } private static String shapeFloatExponent(String res) { if (res.startsWith("-")) return res; return "+"+res; } /*******************************************************************/ /* Integer Formatting */ /*******************************************************************/ /** * sys_integer_atom(F, S, N, A): internal only * The built-in succeeds in A with the integer F formatted according * to the format specifier S and the radix N. */ private static boolean test_sys_integer_atom(Object[] args) { Object num = Machine.exec_build(args[0]); special.check_integer(num); Object spec = Machine.exec_build(args[1]); special.check_atom(spec); Object alpha = Machine.exec_build(args[2]); special.check_integer(alpha); if (Machine.is_bigint(alpha)) throw Machine.make_error(new Store.Compound("representation_error", new Object[]{"int"})); int radix = ((Integer) alpha).intValue(); if (radix < 2 || radix > 36) throw Machine.make_error(new Store.Compound("domain_error", new Object[]{"radix", alpha})); String text; if ("r".equals(spec)) { text = special.atom_integer_encode(num, radix); } else if ("R".equals(spec)) { text = special.atom_integer_encode(num, radix); text = text.toUpperCase(); } else { throw Machine.make_error(new Store.Compound("existence_error", new Object[]{"format_character", spec})); } return Machine.exec_unify(args[3], text); } /*******************************************************************/ /* Str Lib Init */ /*******************************************************************/ public static void main() { Store.set("sys_number_atom", 4, special.make_check(strlib::test_sys_number_atom)); Store.set("sys_integer_atom", 4, special.make_check(strlib::test_sys_integer_atom)); } }