bin/javajs/util/PT.js

   1 Clazz.declarePackage ("javajs.util");
   2 Clazz.load (null, "javajs.util.PT", ["java.lang.Boolean", "$.Double", "$.Float", "$.Number", "java.util.Map", "javajs.api.JSONEncodable", "javajs.util.AU", "$.DF", "$.Lst", "$.M34", "$.M4", "$.SB"], function () {
   3 c$ = Clazz.declareType (javajs.util, "PT");
   4 c$.parseInt = Clazz.defineMethod (c$, "parseInt",
   5 function (str) {
   6 return javajs.util.PT.parseIntNext (str,  Clazz.newIntArray (-1, [0]));
   7 }, "~S");
   8 c$.parseIntNext = Clazz.defineMethod (c$, "parseIntNext",
   9 function (str, next) {
  10 var cch = str.length;
  11 if (next[0] < 0 || next[0] >= cch) return -2147483648;
  12 return javajs.util.PT.parseIntChecked (str, cch, next);
  13 }, "~S,~A");
  14 c$.parseIntChecked = Clazz.defineMethod (c$, "parseIntChecked",
  15 function (str, ichMax, next) {
  16 var digitSeen = false;
  17 var value = 0;
  18 var ich = next[0];
  19 if (ich < 0) return -2147483648;
  20 var ch;
  21 while (ich < ichMax && javajs.util.PT.isWhiteSpace (str, ich)) ++ich;
  22
  23 var negative = false;
  24 if (ich < ichMax && str.charCodeAt (ich) == 45) {
  25 negative = true;
  26 ++ich;
  27 }while (ich < ichMax && (ch = str.charCodeAt (ich)) >= 48 && ch <= 57) {
  28 value = value * 10 + (ch - 48);
  29 digitSeen = true;
  30 ++ich;
  31 }
  32 if (!digitSeen) value = -2147483648;
  33  else if (negative) value = -value;
  34 next[0] = ich;
  35 return value;
  36 }, "~S,~N,~A");
  37 c$.isWhiteSpace = Clazz.defineMethod (c$, "isWhiteSpace",
  38 function (str, ich) {
  39 var ch;
  40 return (ich >= 0 && ((ch = str.charAt (ich)) == ' ' || ch == '\t' || ch == '\n'));
  41 }, "~S,~N");
  42 c$.parseFloatChecked = Clazz.defineMethod (c$, "parseFloatChecked",
  43 function (str, ichMax, next, isStrict) {
  44 var digitSeen = false;
  45 var ich = next[0];
  46 if (isStrict && str.indexOf ('\n') != str.lastIndexOf ('\n')) return NaN;
  47 while (ich < ichMax && javajs.util.PT.isWhiteSpace (str, ich)) ++ich;
  48
  49 var negative = false;
  50 if (ich < ichMax && str.charAt (ich) == '-') {
  51 ++ich;
  52 negative = true;
  53 }var ch = 0;
  54 var ival = 0;
  55 var ival2 = 0;
  56 while (ich < ichMax && (ch = str.charCodeAt (ich)) >= 48 && ch <= 57) {
  57 ival = (ival * 10) + (ch - 48) * 1;
  58 ++ich;
  59 digitSeen = true;
  60 }
  61 var isDecimal = false;
  62 var iscale = 0;
  63 var nzero = (ival == 0 ? -1 : 0);
  64 if (ch == 46) {
  65 isDecimal = true;
  66 while (++ich < ichMax && (ch = str.charCodeAt (ich)) >= 48 && ch <= 57) {
  67 digitSeen = true;
  68 if (nzero < 0) {
  69 if (ch == 48) {
  70 nzero--;
  71 continue;
  72 }nzero = -nzero;
  73 }if (iscale < javajs.util.PT.decimalScale.length) {
  74 ival2 = (ival2 * 10) + (ch - 48) * 1;
  75 iscale++;
  76 }}
  77 }var value;
  78 if (!digitSeen) {
  79 value = NaN;
  80 } else if (ival2 > 0) {
  81 value = ival2 * javajs.util.PT.decimalScale[iscale - 1];
  82 if (nzero > 1) {
  83 if (nzero - 2 < javajs.util.PT.decimalScale.length) {
  84 value *= javajs.util.PT.decimalScale[nzero - 2];
  85 } else {
  86 value *= Math.pow (10, 1 - nzero);
  87 }} else {
  88 value += ival;
  89 }} else {
  90 value = ival;
  91 }var isExponent = false;
  92 if (ich < ichMax && (ch == 69 || ch == 101 || ch == 68)) {
  93 isExponent = true;
  94 if (++ich >= ichMax) return NaN;
  95 ch = str.charCodeAt (ich);
  96 if ((ch == 43) && (++ich >= ichMax)) return NaN;
  97 next[0] = ich;
  98 var exponent = javajs.util.PT.parseIntChecked (str, ichMax, next);
  99 if (exponent == -2147483648) return NaN;
 100 if (exponent > 0 && exponent <= javajs.util.PT.tensScale.length) value *= javajs.util.PT.tensScale[exponent - 1];
 101  else if (exponent < 0 && -exponent <= javajs.util.PT.decimalScale.length) value *= javajs.util.PT.decimalScale[-exponent - 1];
 102  else if (exponent != 0) value *= Math.pow (10, exponent);
 103 } else {
 104 next[0] = ich;
 105 }if (negative) value = -value;
 106 if (value == Infinity) value = 3.4028235E38;
 107 return (!isStrict || (!isExponent || isDecimal) && javajs.util.PT.checkTrailingText (str, next[0], ichMax) ? value : NaN);
 108 }, "~S,~N,~A,~B");
 109 c$.checkTrailingText = Clazz.defineMethod (c$, "checkTrailingText",
 110 function (str, ich, ichMax) {
 111 var ch;
 112 while (ich < ichMax && (javajs.util.PT.isWhitespace (ch = str.charAt (ich)) || ch == ';')) ++ich;
 113
 114 return (ich == ichMax);
 115 }, "~S,~N,~N");
 116 c$.parseFloatArray = Clazz.defineMethod (c$, "parseFloatArray",
 117 function (str) {
 118 return javajs.util.PT.parseFloatArrayNext (str,  Clazz.newIntArray (1, 0), null, null, null);
 119 }, "~S");
 120 c$.parseFloatArrayInfested = Clazz.defineMethod (c$, "parseFloatArrayInfested",
 121 function (tokens, data) {
 122 var len = data.length;
 123 var nTokens = tokens.length;
 124 var n = 0;
 125 var max = 0;
 126 for (var i = 0; i >= 0 && i < len && n < nTokens; i++) {
 127 var f;
 128 while (Float.isNaN (f = javajs.util.PT.parseFloat (tokens[n++])) && n < nTokens) {
 129 }
 130 if (!Float.isNaN (f)) data[(max = i)] = f;
 131 if (n == nTokens) break;
 132 }
 133 return max + 1;
 134 }, "~A,~A");
 135 c$.parseFloatArrayNext = Clazz.defineMethod (c$, "parseFloatArrayNext",
 136 function (str, next, f, strStart, strEnd) {
 137 var n = 0;
 138 var pt = next[0];
 139 if (pt >= 0) {
 140 if (strStart != null) {
 141 var p = str.indexOf (strStart, pt);
 142 if (p >= 0) next[0] = p + strStart.length;
 143 }str = str.substring (next[0]);
 144 pt = (strEnd == null ? -1 : str.indexOf (strEnd));
 145 if (pt < 0) pt = str.length;
 146  else str = str.substring (0, pt);
 147 next[0] += pt + 1;
 148 var tokens = javajs.util.PT.getTokens (str);
 149 if (f == null) f =  Clazz.newFloatArray (tokens.length, 0);
 150 n = javajs.util.PT.parseFloatArrayInfested (tokens, f);
 151 }if (f == null) return  Clazz.newFloatArray (0, 0);
 152 for (var i = n; i < f.length; i++) f[i] = NaN;
 153
 154 return f;
 155 }, "~S,~A,~A,~S,~S");
 156 c$.parseFloatRange = Clazz.defineMethod (c$, "parseFloatRange",
 157 function (str, ichMax, next) {
 158 var cch = str.length;
 159 if (ichMax > cch) ichMax = cch;
 160 if (next[0] < 0 || next[0] >= ichMax) return NaN;
 161 return javajs.util.PT.parseFloatChecked (str, ichMax, next, false);
 162 }, "~S,~N,~A");
 163 c$.parseFloatNext = Clazz.defineMethod (c$, "parseFloatNext",
 164 function (str, next) {
 165 var cch = (str == null ? -1 : str.length);
 166 return (next[0] < 0 || next[0] >= cch ? NaN : javajs.util.PT.parseFloatChecked (str, cch, next, false));
 167 }, "~S,~A");
 168 c$.parseFloatStrict = Clazz.defineMethod (c$, "parseFloatStrict",
 169 function (str) {
 170 var cch = str.length;
 171 if (cch == 0) return NaN;
 172 return javajs.util.PT.parseFloatChecked (str, cch,  Clazz.newIntArray (-1, [0]), true);
 173 }, "~S");
 174 c$.parseFloat = Clazz.defineMethod (c$, "parseFloat",
 175 function (str) {
 176 return javajs.util.PT.parseFloatNext (str,  Clazz.newIntArray (-1, [0]));
 177 }, "~S");
 178 c$.parseIntRadix = Clazz.defineMethod (c$, "parseIntRadix",
 179 function (s, i) {
 180 {
 181 return Integer.parseIntRadix(s, i);
 182 }}, "~S,~N");
 183 c$.getTokens = Clazz.defineMethod (c$, "getTokens",
 184 function (line) {
 185 return javajs.util.PT.getTokensAt (line, 0);
 186 }, "~S");
 187 c$.parseToken = Clazz.defineMethod (c$, "parseToken",
 188 function (str) {
 189 return javajs.util.PT.parseTokenNext (str,  Clazz.newIntArray (-1, [0]));
 190 }, "~S");
 191 c$.parseTrimmed = Clazz.defineMethod (c$, "parseTrimmed",
 192 function (str) {
 193 return javajs.util.PT.parseTrimmedRange (str, 0, str.length);
 194 }, "~S");
 195 c$.parseTrimmedAt = Clazz.defineMethod (c$, "parseTrimmedAt",
 196 function (str, ichStart) {
 197 return javajs.util.PT.parseTrimmedRange (str, ichStart, str.length);
 198 }, "~S,~N");
 199 c$.parseTrimmedRange = Clazz.defineMethod (c$, "parseTrimmedRange",
 200 function (str, ichStart, ichMax) {
 201 var cch = str.length;
 202 if (ichMax < cch) cch = ichMax;
 203 if (cch < ichStart) return "";
 204 return javajs.util.PT.parseTrimmedChecked (str, ichStart, cch);
 205 }, "~S,~N,~N");
 206 c$.getTokensAt = Clazz.defineMethod (c$, "getTokensAt",
 207 function (line, ich) {
 208 if (line == null) return null;
 209 var cchLine = line.length;
 210 if (ich < 0 || ich > cchLine) return null;
 211 var tokenCount = javajs.util.PT.countTokens (line, ich);
 212 var tokens =  new Array (tokenCount);
 213 var next =  Clazz.newIntArray (1, 0);
 214 next[0] = ich;
 215 for (var i = 0; i < tokenCount; ++i) tokens[i] = javajs.util.PT.parseTokenChecked (line, cchLine, next);
 216
 217 return tokens;
 218 }, "~S,~N");
 219 c$.countChar = Clazz.defineMethod (c$, "countChar",
 220 function (line, c) {
 221 var tokenCount = 0;
 222 var pt = -1;
 223 while ((pt = line.indexOf (c, pt + 1)) >= 0) tokenCount++;
 224
 225 return tokenCount;
 226 }, "~S,~S");
 227 c$.countTokens = Clazz.defineMethod (c$, "countTokens",
 228 function (line, ich) {
 229 var tokenCount = 0;
 230 if (line != null) {
 231 var ichMax = line.length;
 232 while (true) {
 233 while (ich < ichMax && javajs.util.PT.isWhiteSpace (line, ich)) ++ich;
 234
 235 if (ich == ichMax) break;
 236 ++tokenCount;
 237 do {
 238 ++ich;
 239 } while (ich < ichMax && !javajs.util.PT.isWhiteSpace (line, ich));
 240 }
 241 }return tokenCount;
 242 }, "~S,~N");
 243 c$.parseTokenNext = Clazz.defineMethod (c$, "parseTokenNext",
 244 function (str, next) {
 245 var cch = str.length;
 246 return (next[0] < 0 || next[0] >= cch ? null : javajs.util.PT.parseTokenChecked (str, cch, next));
 247 }, "~S,~A");
 248 c$.parseTokenRange = Clazz.defineMethod (c$, "parseTokenRange",
 249 function (str, ichMax, next) {
 250 var cch = str.length;
 251 if (ichMax > cch) ichMax = cch;
 252 return (next[0] < 0 || next[0] >= ichMax ? null : javajs.util.PT.parseTokenChecked (str, ichMax, next));
 253 }, "~S,~N,~A");
 254 c$.parseTokenChecked = Clazz.defineMethod (c$, "parseTokenChecked",
 255 function (str, ichMax, next) {
 256 var ich = next[0];
 257 while (ich < ichMax && javajs.util.PT.isWhiteSpace (str, ich)) ++ich;
 258
 259 var ichNonWhite = ich;
 260 while (ich < ichMax && !javajs.util.PT.isWhiteSpace (str, ich)) ++ich;
 261
 262 next[0] = ich;
 263 return (ichNonWhite == ich ? null : str.substring (ichNonWhite, ich));
 264 }, "~S,~N,~A");
 265 c$.parseTrimmedChecked = Clazz.defineMethod (c$, "parseTrimmedChecked",
 266 function (str, ich, ichMax) {
 267 while (ich < ichMax && javajs.util.PT.isWhiteSpace (str, ich)) ++ich;
 268
 269 var ichLast = ichMax - 1;
 270 while (ichLast >= ich && javajs.util.PT.isWhiteSpace (str, ichLast)) --ichLast;
 271
 272 return (ichLast < ich ? "" : str.substring (ich, ichLast + 1));
 273 }, "~S,~N,~N");
 274 c$.dVal = Clazz.defineMethod (c$, "dVal",
 275 function (s) {
 276 {
 277 if(s==null)
 278 throw new NumberFormatException("null");
 279 var d=parseFloat(s);
 280 if(isNaN(d))
 281 throw new NumberFormatException("Not a Number : "+s);
 282 return d
 283 }}, "~S");
 284 c$.fVal = Clazz.defineMethod (c$, "fVal",
 285 function (s) {
 286 {
 287 return this.dVal(s);
 288 }}, "~S");
 289 c$.parseIntRange = Clazz.defineMethod (c$, "parseIntRange",
 290 function (str, ichMax, next) {
 291 var cch = str.length;
 292 if (ichMax > cch) ichMax = cch;
 293 return (next[0] < 0 || next[0] >= ichMax ? -2147483648 : javajs.util.PT.parseIntChecked (str, ichMax, next));
 294 }, "~S,~N,~A");
 295 c$.parseFloatArrayData = Clazz.defineMethod (c$, "parseFloatArrayData",
 296 function (tokens, data) {
 297 javajs.util.PT.parseFloatArrayDataN (tokens, data, data.length);
 298 }, "~A,~A");
 299 c$.parseFloatArrayDataN = Clazz.defineMethod (c$, "parseFloatArrayDataN",
 300 function (tokens, data, nData) {
 301 for (var i = nData; --i >= 0; ) data[i] = (i >= tokens.length ? NaN : javajs.util.PT.parseFloat (tokens[i]));
 302
 303 }, "~A,~A,~N");
 304 c$.split = Clazz.defineMethod (c$, "split",
 305 function (text, run) {
 306 if (text.length == 0) return  new Array (0);
 307 var n = 1;
 308 var i = text.indexOf (run);
 309 var lines;
 310 var runLen = run.length;
 311 if (i < 0 || runLen == 0) {
 312 lines =  new Array (1);
 313 lines[0] = text;
 314 return lines;
 315 }var len = text.length - runLen;
 316 for (; i >= 0 && i < len; n++) i = text.indexOf (run, i + runLen);
 317
 318 lines =  new Array (n);
 319 i = 0;
 320 var ipt = 0;
 321 var pt = 0;
 322 for (; (ipt = text.indexOf (run, i)) >= 0 && pt + 1 < n; ) {
 323 lines[pt++] = text.substring (i, ipt);
 324 i = ipt + runLen;
 325 }
 326 if (text.indexOf (run, len) != len) len += runLen;
 327 lines[pt] = text.substring (i, len);
 328 return lines;
 329 }, "~S,~S");
 330 c$.getQuotedStringAt = Clazz.defineMethod (c$, "getQuotedStringAt",
 331 function (line, ipt0) {
 332 var next =  Clazz.newIntArray (-1, [ipt0]);
 333 return javajs.util.PT.getQuotedStringNext (line, next);
 334 }, "~S,~N");
 335 c$.getQuotedStringNext = Clazz.defineMethod (c$, "getQuotedStringNext",
 336 function (line, next) {
 337 var i = next[0];
 338 if (i < 0 || (i = line.indexOf ("\"", i)) < 0) return "";
 339 var pt = i + 1;
 340 var len = line.length;
 341 while (++i < len && line.charAt (i) != '"') if (line.charAt (i) == '\\') i++;
 342
 343 next[0] = i + 1;
 344 return line.substring (pt, i);
 345 }, "~S,~A");
 346 c$.getCSVString = Clazz.defineMethod (c$, "getCSVString",
 347 function (line, next) {
 348 var i = next[1];
 349 if (i < 0 || (i = line.indexOf ("\"", i)) < 0) return null;
 350 var pt = next[0] = i;
 351 var len = line.length;
 352 var escaped = false;
 353 var haveEscape = false;
 354 while (++i < len && (line.charAt (i) != '"' || (escaped = (i + 1 < len && line.charAt (i + 1) == '"')))) if (escaped) {
 355 escaped = false;
 356 haveEscape = true;
 357 i++;
 358 }
 359 if (i >= len) {
 360 next[1] = -1;
 361 return null;
 362 }next[1] = i + 1;
 363 var s = line.substring (pt + 1, i);
 364 return (haveEscape ? javajs.util.PT.rep (javajs.util.PT.rep (s, "\"\"", "\0"), "\0", "\"") : s);
 365 }, "~S,~A");
 366 c$.isOneOf = Clazz.defineMethod (c$, "isOneOf",
 367 function (key, semiList) {
 368 if (semiList.length == 0) return false;
 369 if (semiList.charAt (0) != ';') semiList = ";" + semiList + ";";
 370 return key.indexOf (";") < 0 && semiList.indexOf (';' + key + ';') >= 0;
 371 }, "~S,~S");
 372 c$.getQuotedAttribute = Clazz.defineMethod (c$, "getQuotedAttribute",
 373 function (info, name) {
 374 var i = info.indexOf (name + "=");
 375 return (i < 0 ? null : javajs.util.PT.getQuotedStringAt (info, i));
 376 }, "~S,~S");
 377 c$.approx = Clazz.defineMethod (c$, "approx",
 378 function (f, n) {
 379 return Math.round (f * n) / n;
 380 }, "~N,~N");
 381 c$.rep = Clazz.defineMethod (c$, "rep",
 382 function (str, strFrom, strTo) {
 383 if (str == null || strFrom.length == 0 || str.indexOf (strFrom) < 0) return str;
 384 var isOnce = (strTo.indexOf (strFrom) >= 0);
 385 do {
 386 str = str.$replace (strFrom, strTo);
 387 } while (!isOnce && str.indexOf (strFrom) >= 0);
 388 return str;
 389 }, "~S,~S,~S");
 390 c$.formatF = Clazz.defineMethod (c$, "formatF",
 391 function (value, width, precision, alignLeft, zeroPad) {
 392 return javajs.util.PT.formatS (javajs.util.DF.formatDecimal (value, precision), width, 0, alignLeft, zeroPad);
 393 }, "~N,~N,~N,~B,~B");
 394 c$.formatD = Clazz.defineMethod (c$, "formatD",
 395 function (value, width, precision, alignLeft, zeroPad, allowOverflow) {
 396 return javajs.util.PT.formatS (javajs.util.DF.formatDecimal (value, -1 - precision), width, 0, alignLeft, zeroPad);
 397 }, "~N,~N,~N,~B,~B,~B");
 398 c$.formatS = Clazz.defineMethod (c$, "formatS",
 399 function (value, width, precision, alignLeft, zeroPad) {
 400 if (value == null) return "";
 401 var len = value.length;
 402 if (precision != 2147483647 && precision > 0 && precision < len) value = value.substring (0, precision);
 403  else if (precision < 0 && len + precision >= 0) value = value.substring (len + precision + 1);
 404 var padLength = width - value.length;
 405 if (padLength <= 0) return value;
 406 var isNeg = (zeroPad && !alignLeft && value.charAt (0) == '-');
 407 var padChar = (zeroPad ? '0' : ' ');
 408 var padChar0 = (isNeg ? '-' : padChar);
 409 var sb =  new javajs.util.SB ();
 410 if (alignLeft) sb.append (value);
 411 sb.appendC (padChar0);
 412 for (var i = padLength; --i > 0; ) sb.appendC (padChar);
 413
 414 if (!alignLeft) sb.append (isNeg ? padChar + value.substring (1) : value);
 415 return sb.toString ();
 416 }, "~S,~N,~N,~B,~B");
 417 c$.replaceWithCharacter = Clazz.defineMethod (c$, "replaceWithCharacter",
 418 function (str, strFrom, chTo) {
 419 if (str == null) return null;
 420 for (var i = strFrom.length; --i >= 0; ) str = str.$replace (strFrom.charAt (i), chTo);
 421
 422 return str;
 423 }, "~S,~S,~S");
 424 c$.replaceAllCharacters = Clazz.defineMethod (c$, "replaceAllCharacters",
 425 function (str, strFrom, strTo) {
 426 for (var i = strFrom.length; --i >= 0; ) {
 427 var chFrom = strFrom.substring (i, i + 1);
 428 str = javajs.util.PT.rep (str, chFrom, strTo);
 429 }
 430 return str;
 431 }, "~S,~S,~S");
 432 c$.trim = Clazz.defineMethod (c$, "trim",
 433 function (str, chars) {
 434 if (str == null || str.length == 0) return str;
 435 if (chars.length == 0) return str.trim ();
 436 var len = str.length;
 437 var k = 0;
 438 while (k < len && chars.indexOf (str.charAt (k)) >= 0) k++;
 439
 440 var m = str.length - 1;
 441 while (m > k && chars.indexOf (str.charAt (m)) >= 0) m--;
 442
 443 return str.substring (k, m + 1);
 444 }, "~S,~S");
 445 c$.trimQuotes = Clazz.defineMethod (c$, "trimQuotes",
 446 function (value) {
 447 return (value != null && value.length > 1 && value.startsWith ("\"") && value.endsWith ("\"") ? value.substring (1, value.length - 1) : value);
 448 }, "~S");
 449 c$.isNonStringPrimitive = Clazz.defineMethod (c$, "isNonStringPrimitive",
 450 function (info) {
 451 return Clazz.instanceOf (info, Number) || Clazz.instanceOf (info, Boolean);
 452 }, "~O");
 453 c$.arrayGet = Clazz.defineMethod (c$, "arrayGet",
 454 ($fz = function (info, i) {
 455 {
 456 return info[i];
 457 }}, $fz.isPrivate = true, $fz), "~O,~N");
 458 c$.toJSON = Clazz.defineMethod (c$, "toJSON",
 459 function (infoType, info) {
 460 if (info == null) return javajs.util.PT.packageJSON (infoType, null);
 461 if (javajs.util.PT.isNonStringPrimitive (info)) return javajs.util.PT.packageJSON (infoType, info.toString ());
 462 var s = null;
 463 var sb = null;
 464 while (true) {
 465 if (Clazz.instanceOf (info, String)) {
 466 s = info;
 467 {
 468 if (typeof s == "undefined") s = "null"
 469 }if (s.indexOf ("{\"") != 0) {
 470 s = javajs.util.PT.rep (s, "\"", "\\\"");
 471 s = javajs.util.PT.rep (s, "\n", "\\n");
 472 s = "\"" + s + "\"";
 473 }break;
 474 }if (Clazz.instanceOf (info, javajs.api.JSONEncodable)) {
 475 if ((s = (info).toJSON ()) == null) s = "null";
 476 break;
 477 }sb =  new javajs.util.SB ();
 478 if (Clazz.instanceOf (info, java.util.Map)) {
 479 sb.append ("{ ");
 480 var sep = "";
 481 for (var key, $key = (info).keySet ().iterator (); $key.hasNext () && ((key = $key.next ()) || true);) {
 482 sb.append (sep).append (javajs.util.PT.packageJSON (key, javajs.util.PT.toJSON (null, (info).get (key))));
 483 sep = ",";
 484 }
 485 sb.append (" }");
 486 break;
 487 }if (Clazz.instanceOf (info, javajs.util.Lst)) {
 488 sb.append ("[ ");
 489 var n = (info).size ();
 490 for (var i = 0; i < n; i++) {
 491 if (i > 0) sb.appendC (',');
 492 sb.append (javajs.util.PT.toJSON (null, (info).get (i)));
 493 }
 494 sb.append (" ]");
 495 break;
 496 }if (Clazz.instanceOf (info, javajs.util.M34)) {
 497 var len = (Clazz.instanceOf (info, javajs.util.M4) ? 4 : 3);
 498 var x =  Clazz.newFloatArray (len, 0);
 499 var m = info;
 500 sb.appendC ('[');
 501 for (var i = 0; i < len; i++) {
 502 if (i > 0) sb.appendC (',');
 503 m.getRow (i, x);
 504 sb.append (javajs.util.PT.toJSON (null, x));
 505 }
 506 sb.appendC (']');
 507 break;
 508 }s = javajs.util.PT.nonArrayString (info);
 509 if (s == null) {
 510 sb.append ("[");
 511 var n = javajs.util.AU.getLength (info);
 512 for (var i = 0; i < n; i++) {
 513 if (i > 0) sb.appendC (',');
 514 sb.append (javajs.util.PT.toJSON (null, javajs.util.PT.arrayGet (info, i)));
 515 }
 516 sb.append ("]");
 517 break;
 518 }info = info.toString ();
 519 }
 520 return javajs.util.PT.packageJSON (infoType, (s == null ? sb.toString () : s));
 521 }, "~S,~O");
 522 c$.nonArrayString = Clazz.defineMethod (c$, "nonArrayString",
 523 function (x) {
 524 {
 525 var s = x.toString(); return (s.startsWith("[object") &&
 526 s.endsWith("Array]") ? null : s);
 527 }}, "~O");
 528 c$.byteArrayToJSON = Clazz.defineMethod (c$, "byteArrayToJSON",
 529 function (data) {
 530 var sb =  new javajs.util.SB ();
 531 sb.append ("[");
 532 var n = data.length;
 533 for (var i = 0; i < n; i++) {
 534 if (i > 0) sb.appendC (',');
 535 sb.appendI (data[i] & 0xFF);
 536 }
 537 sb.append ("]");
 538 return sb.toString ();
 539 }, "~A");
 540 c$.packageJSON = Clazz.defineMethod (c$, "packageJSON",
 541 function (infoType, info) {
 542 return (infoType == null ? info : "\"" + infoType + "\": " + info);
 543 }, "~S,~S");
 544 c$.escapeUrl = Clazz.defineMethod (c$, "escapeUrl",
 545 function (url) {
 546 url = javajs.util.PT.rep (url, "\n", "");
 547 url = javajs.util.PT.rep (url, "%", "%25");
 548 url = javajs.util.PT.rep (url, "#", "%23");
 549 url = javajs.util.PT.rep (url, "[", "%5B");
 550 url = javajs.util.PT.rep (url, "]", "%5D");
 551 url = javajs.util.PT.rep (url, " ", "%20");
 552 return url;
 553 }, "~S");
 554 c$.esc = Clazz.defineMethod (c$, "esc",
 555 function (str) {
 556 if (str == null || str.length == 0) return "\"\"";
 557 var haveEscape = false;
 558 var i = 0;
 559 for (; i < "\\\\\tt\rr\nn\"\"".length; i += 2) if (str.indexOf ("\\\\\tt\rr\nn\"\"".charAt (i)) >= 0) {
 560 haveEscape = true;
 561 break;
 562 }
 563 if (haveEscape) while (i < "\\\\\tt\rr\nn\"\"".length) {
 564 var pt = -1;
 565 var ch = "\\\\\tt\rr\nn\"\"".charAt (i++);
 566 var ch2 = "\\\\\tt\rr\nn\"\"".charAt (i++);
 567 var sb =  new javajs.util.SB ();
 568 var pt0 = 0;
 569 while ((pt = str.indexOf (ch, pt + 1)) >= 0) {
 570 sb.append (str.substring (pt0, pt)).appendC ('\\').appendC (ch2);
 571 pt0 = pt + 1;
 572 }
 573 sb.append (str.substring (pt0, str.length));
 574 str = sb.toString ();
 575 }
 576 return "\"" + javajs.util.PT.escUnicode (str) + "\"";
 577 }, "~S");
 578 c$.escUnicode = Clazz.defineMethod (c$, "escUnicode",
 579 function (str) {
 580 for (var i = str.length; --i >= 0; ) if (str.charCodeAt (i) > 0x7F) {
 581 var s = "0000" + Integer.toHexString (str.charCodeAt (i));
 582 str = str.substring (0, i) + "\\u" + s.substring (s.length - 4) + str.substring (i + 1);
 583 }
 584 return str;
 585 }, "~S");
 586 c$.escF = Clazz.defineMethod (c$, "escF",
 587 function (f) {
 588 var sf = "" + f;
 589 {
 590 if (sf.indexOf(".") < 0 && sf.indexOf("e") < 0)
 591 sf += ".0";
 592 }return sf;
 593 }, "~N");
 594 c$.join = Clazz.defineMethod (c$, "join",
 595 function (s, c, i0) {
 596 if (s.length < i0) return null;
 597 var sb =  new javajs.util.SB ();
 598 sb.append (s[i0++]);
 599 for (var i = i0; i < s.length; i++) sb.appendC (c).append (s[i]);
 600
 601 return sb.toString ();
 602 }, "~A,~S,~N");
 603 c$.isLike = Clazz.defineMethod (c$, "isLike",
 604 function (a, b) {
 605 var areEqual = a.equals (b);
 606 if (areEqual) return true;
 607 var isStart = b.startsWith ("*");
 608 var isEnd = b.endsWith ("*");
 609 return (!isStart && !isEnd) ? areEqual : isStart && isEnd ? b.length == 1 || a.contains (b.substring (1, b.length - 1)) : isStart ? a.endsWith (b.substring (1)) : a.startsWith (b.substring (0, b.length - 1));
 610 }, "~S,~S");
 611 c$.getMapValueNoCase = Clazz.defineMethod (c$, "getMapValueNoCase",
 612 function (h, key) {
 613 if ("this".equals (key)) return h;
 614 var val = h.get (key);
 615 if (val == null) for (var e, $e = h.entrySet ().iterator (); $e.hasNext () && ((e = $e.next ()) || true);) if (e.getKey ().equalsIgnoreCase (key)) return e.getValue ();
 616
 617 return val;
 618 }, "java.util.Map,~S");
 619 c$.clean = Clazz.defineMethod (c$, "clean",
 620 function (s) {
 621 return javajs.util.PT.rep (javajs.util.PT.replaceAllCharacters (s, " \t\n\r", " "), "  ", " ").trim ();
 622 }, "~S");
 623 c$.fdup = Clazz.defineMethod (c$, "fdup",
 624 function (f, pt, n) {
 625 var ch;
 626 var count = 0;
 627 for (var i = pt; --i >= 1; ) {
 628 if (javajs.util.PT.isDigit (ch = f.charAt (i))) continue;
 629 switch (ch) {
 630 case '.':
 631 if (count++ != 0) return f;
 632 continue;
 633 case '-':
 634 if (i != 1 && f.charAt (i - 1) != '.') return f;
 635 continue;
 636 default:
 637 return f;
 638 }
 639 }
 640 var s = f.substring (0, pt + 1);
 641 var sb =  new javajs.util.SB ();
 642 for (var i = 0; i < n; i++) sb.append (s);
 643
 644 sb.append (f.substring (pt + 1));
 645 return sb.toString ();
 646 }, "~S,~N,~N");
 647 c$.formatString = Clazz.defineMethod (c$, "formatString",
 648 function (strFormat, key, strT, floatT, doubleT, doOne) {
 649 if (strFormat == null) return null;
 650 if ("".equals (strFormat)) return "";
 651 var len = key.length;
 652 if (strFormat.indexOf ("%") < 0 || len == 0 || strFormat.indexOf (key) < 0) return strFormat;
 653 var strLabel = "";
 654 var ich;
 655 var ichPercent;
 656 var ichKey;
 657 for (ich = 0; (ichPercent = strFormat.indexOf ('%', ich)) >= 0 && (ichKey = strFormat.indexOf (key, ichPercent + 1)) >= 0; ) {
 658 if (ich != ichPercent) strLabel += strFormat.substring (ich, ichPercent);
 659 ich = ichPercent + 1;
 660 if (ichKey > ichPercent + 6) {
 661 strLabel += '%';
 662 continue;
 663 }try {
 664 var alignLeft = false;
 665 if (strFormat.charAt (ich) == '-') {
 666 alignLeft = true;
 667 ++ich;
 668 }var zeroPad = false;
 669 if (strFormat.charAt (ich) == '0') {
 670 zeroPad = true;
 671 ++ich;
 672 }var ch;
 673 var width = 0;
 674 while ((ch = strFormat.charAt (ich)) >= '0' && (ch <= '9')) {
 675 width = (10 * width) + (ch.charCodeAt (0) - 48);
 676 ++ich;
 677 }
 678 var precision = 2147483647;
 679 var isExponential = false;
 680 if (strFormat.charAt (ich) == '.') {
 681 ++ich;
 682 if ((ch = strFormat.charAt (ich)) == '-') {
 683 isExponential = true;
 684 ++ich;
 685 }if ((ch = strFormat.charAt (ich)) >= '0' && ch <= '9') {
 686 precision = ch.charCodeAt (0) - 48;
 687 ++ich;
 688 }if (isExponential) precision = -precision - (strT == null ? 1 : 0);
 689 }var st = strFormat.substring (ich, ich + len);
 690 if (!st.equals (key)) {
 691 ich = ichPercent + 1;
 692 strLabel += '%';
 693 continue;
 694 }ich += len;
 695 if (!Float.isNaN (floatT)) strLabel += javajs.util.PT.formatF (floatT, width, precision, alignLeft, zeroPad);
 696  else if (strT != null) strLabel += javajs.util.PT.formatS (strT, width, precision, alignLeft, zeroPad);
 697  else if (!Double.isNaN (doubleT)) strLabel += javajs.util.PT.formatD (doubleT, width, precision, alignLeft, zeroPad, true);
 698 if (doOne) break;
 699 } catch (ioobe) {
 700 if (Clazz.exceptionOf (ioobe, IndexOutOfBoundsException)) {
 701 ich = ichPercent;
 702 break;
 703 } else {
 704 throw ioobe;
 705 }
 706 }
 707 }
 708 strLabel += strFormat.substring (ich);
 709 return strLabel;
 710 }, "~S,~S,~S,~N,~N,~B");
 711 c$.formatStringS = Clazz.defineMethod (c$, "formatStringS",
 712 function (strFormat, key, strT) {
 713 return javajs.util.PT.formatString (strFormat, key, strT, NaN, NaN, false);
 714 }, "~S,~S,~S");
 715 c$.formatStringF = Clazz.defineMethod (c$, "formatStringF",
 716 function (strFormat, key, floatT) {
 717 return javajs.util.PT.formatString (strFormat, key, null, floatT, NaN, false);
 718 }, "~S,~S,~N");
 719 c$.formatStringI = Clazz.defineMethod (c$, "formatStringI",
 720 function (strFormat, key, intT) {
 721 return javajs.util.PT.formatString (strFormat, key, "" + intT, NaN, NaN, false);
 722 }, "~S,~S,~N");
 723 c$.sprintf = Clazz.defineMethod (c$, "sprintf",
 724 function (strFormat, list, values) {
 725 if (values == null) return strFormat;
 726 var n = list.length;
 727 if (n == values.length) try {
 728 for (var o = 0; o < n; o++) {
 729 if (values[o] == null) continue;
 730 switch (list.charAt (o)) {
 731 case 's':
 732 strFormat = javajs.util.PT.formatString (strFormat, "s", values[o], NaN, NaN, true);
 733 break;
 734 case 'f':
 735 strFormat = javajs.util.PT.formatString (strFormat, "f", null, (values[o]).floatValue (), NaN, true);
 736 break;
 737 case 'i':
 738 strFormat = javajs.util.PT.formatString (strFormat, "d", "" + values[o], NaN, NaN, true);
 739 strFormat = javajs.util.PT.formatString (strFormat, "i", "" + values[o], NaN, NaN, true);
 740 break;
 741 case 'd':
 742 strFormat = javajs.util.PT.formatString (strFormat, "e", null, NaN, (values[o]).doubleValue (), true);
 743 break;
 744 case 'p':
 745 var pVal = values[o];
 746 strFormat = javajs.util.PT.formatString (strFormat, "p", null, pVal.x, NaN, true);
 747 strFormat = javajs.util.PT.formatString (strFormat, "p", null, pVal.y, NaN, true);
 748 strFormat = javajs.util.PT.formatString (strFormat, "p", null, pVal.z, NaN, true);
 749 break;
 750 case 'q':
 751 var qVal = values[o];
 752 strFormat = javajs.util.PT.formatString (strFormat, "q", null, qVal.x, NaN, true);
 753 strFormat = javajs.util.PT.formatString (strFormat, "q", null, qVal.y, NaN, true);
 754 strFormat = javajs.util.PT.formatString (strFormat, "q", null, qVal.z, NaN, true);
 755 strFormat = javajs.util.PT.formatString (strFormat, "q", null, qVal.w, NaN, true);
 756 break;
 757 case 'S':
 758 var sVal = values[o];
 759 for (var i = 0; i < sVal.length; i++) strFormat = javajs.util.PT.formatString (strFormat, "s", sVal[i], NaN, NaN, true);
 760
 761 break;
 762 case 'F':
 763 var fVal = values[o];
 764 for (var i = 0; i < fVal.length; i++) strFormat = javajs.util.PT.formatString (strFormat, "f", null, fVal[i], NaN, true);
 765
 766 break;
 767 case 'I':
 768 var iVal = values[o];
 769 for (var i = 0; i < iVal.length; i++) strFormat = javajs.util.PT.formatString (strFormat, "d", "" + iVal[i], NaN, NaN, true);
 770
 771 for (var i = 0; i < iVal.length; i++) strFormat = javajs.util.PT.formatString (strFormat, "i", "" + iVal[i], NaN, NaN, true);
 772
 773 break;
 774 case 'D':
 775 var dVal = values[o];
 776 for (var i = 0; i < dVal.length; i++) strFormat = javajs.util.PT.formatString (strFormat, "e", null, NaN, dVal[i], true);
 777
 778 }
 779 }
 780 return javajs.util.PT.rep (strFormat, "%%", "%");
 781 } catch (e) {
 782 if (Clazz.exceptionOf (e, Exception)) {
 783 } else {
 784 throw e;
 785 }
 786 }
 787 System.out.println ("TextFormat.sprintf error " + list + " " + strFormat);
 788 return javajs.util.PT.rep (strFormat, "%", "?");
 789 }, "~S,~S,~A");
 790 c$.formatCheck = Clazz.defineMethod (c$, "formatCheck",
 791 function (strFormat) {
 792 if (strFormat == null || strFormat.indexOf ('p') < 0 && strFormat.indexOf ('q') < 0) return strFormat;
 793 strFormat = javajs.util.PT.rep (strFormat, "%%", "\1");
 794 strFormat = javajs.util.PT.rep (strFormat, "%p", "%6.2p");
 795 strFormat = javajs.util.PT.rep (strFormat, "%q", "%6.2q");
 796 var format = javajs.util.PT.split (strFormat, "%");
 797 var sb =  new javajs.util.SB ();
 798 sb.append (format[0]);
 799 for (var i = 1; i < format.length; i++) {
 800 var f = "%" + format[i];
 801 var pt;
 802 if (f.length >= 3) {
 803 if ((pt = f.indexOf ('p')) >= 0) f = javajs.util.PT.fdup (f, pt, 3);
 804 if ((pt = f.indexOf ('q')) >= 0) f = javajs.util.PT.fdup (f, pt, 4);
 805 }sb.append (f);
 806 }
 807 return sb.toString ().$replace ('\1', '%');
 808 }, "~S");
 809 c$.leftJustify = Clazz.defineMethod (c$, "leftJustify",
 810 function (s, s1, s2) {
 811 s.append (s2);
 812 var n = s1.length - s2.length;
 813 if (n > 0) s.append (s1.substring (0, n));
 814 }, "javajs.util.SB,~S,~S");
 815 c$.rightJustify = Clazz.defineMethod (c$, "rightJustify",
 816 function (s, s1, s2) {
 817 var n = s1.length - s2.length;
 818 if (n > 0) s.append (s1.substring (0, n));
 819 s.append (s2);
 820 }, "javajs.util.SB,~S,~S");
 821 c$.safeTruncate = Clazz.defineMethod (c$, "safeTruncate",
 822 function (f, n) {
 823 if (f > -0.001 && f < 0.001) f = 0;
 824 return (f + "         ").substring (0, n);
 825 }, "~N,~N");
 826 c$.isWild = Clazz.defineMethod (c$, "isWild",
 827 function (s) {
 828 return s != null && (s.indexOf ("*") >= 0 || s.indexOf ("?") >= 0);
 829 }, "~S");
 830 c$.isMatch = Clazz.defineMethod (c$, "isMatch",
 831 function (search, match, checkStar, allowInitialStar) {
 832 if (search.equals (match)) return true;
 833 var mLen = match.length;
 834 if (mLen == 0) return false;
 835 var isStar0 = (checkStar && allowInitialStar ? match.charAt (0) == '*' : false);
 836 if (mLen == 1 && isStar0) return true;
 837 var isStar1 = (checkStar && match.endsWith ("*"));
 838 var haveQ = (match.indexOf ('?') >= 0);
 839 if (!haveQ) {
 840 if (isStar0) return (isStar1 ? (mLen < 3 || search.indexOf (match.substring (1, mLen - 1)) >= 0) : search.endsWith (match.substring (1)));
 841  else if (isStar1) return search.startsWith (match.substring (0, mLen - 1));
 842 }var sLen = search.length;
 843 var qqqq = "????";
 844 var nq = 4;
 845 while (nq < sLen) {
 846 qqqq += qqqq;
 847 nq += 4;
 848 }
 849 if (checkStar) {
 850 if (isStar0) {
 851 match = qqqq + match.substring (1);
 852 mLen += nq - 1;
 853 }if (isStar1) {
 854 match = match.substring (0, mLen - 1) + qqqq;
 855 mLen += nq - 1;
 856 }}if (mLen < sLen) return false;
 857 var ich = 0;
 858 while (mLen > sLen) {
 859 if (allowInitialStar && match.charAt (ich) == '?') {
 860 ++ich;
 861 } else if (match.charAt (ich + mLen - 1) != '?') {
 862 return false;
 863 }--mLen;
 864 }
 865 for (var i = sLen; --i >= 0; ) {
 866 var chm = match.charAt (ich + i);
 867 if (chm == '?') continue;
 868 var chs = search.charAt (i);
 869 if (chm != chs && (chm != '\1' || chs != '?')) return false;
 870 }
 871 return true;
 872 }, "~S,~S,~B,~B");
 873 c$.replaceQuotedStrings = Clazz.defineMethod (c$, "replaceQuotedStrings",
 874 function (s, list, newList) {
 875 var n = list.size ();
 876 for (var i = 0; i < n; i++) {
 877 var name = list.get (i);
 878 var newName = newList.get (i);
 879 if (!newName.equals (name)) s = javajs.util.PT.rep (s, "\"" + name + "\"", "\"" + newName + "\"");
 880 }
 881 return s;
 882 }, "~S,javajs.util.Lst,javajs.util.Lst");
 883 c$.replaceStrings = Clazz.defineMethod (c$, "replaceStrings",
 884 function (s, list, newList) {
 885 var n = list.size ();
 886 for (var i = 0; i < n; i++) {
 887 var name = list.get (i);
 888 var newName = newList.get (i);
 889 if (!newName.equals (name)) s = javajs.util.PT.rep (s, name, newName);
 890 }
 891 return s;
 892 }, "~S,javajs.util.Lst,javajs.util.Lst");
 893 c$.isDigit = Clazz.defineMethod (c$, "isDigit",
 894 function (ch) {
 895 var c = (ch).charCodeAt (0);
 896 return (48 <= c && c <= 57);
 897 }, "~S");
 898 c$.isUpperCase = Clazz.defineMethod (c$, "isUpperCase",
 899 function (ch) {
 900 var c = (ch).charCodeAt (0);
 901 return (65 <= c && c <= 90);
 902 }, "~S");
 903 c$.isLowerCase = Clazz.defineMethod (c$, "isLowerCase",
 904 function (ch) {
 905 var c = (ch).charCodeAt (0);
 906 return (97 <= c && c <= 122);
 907 }, "~S");
 908 c$.isLetter = Clazz.defineMethod (c$, "isLetter",
 909 function (ch) {
 910 var c = (ch).charCodeAt (0);
 911 return (65 <= c && c <= 90 || 97 <= c && c <= 122);
 912 }, "~S");
 913 c$.isLetterOrDigit = Clazz.defineMethod (c$, "isLetterOrDigit",
 914 function (ch) {
 915 var c = (ch).charCodeAt (0);
 916 return (65 <= c && c <= 90 || 97 <= c && c <= 122 || 48 <= c && c <= 57);
 917 }, "~S");
 918 c$.isWhitespace = Clazz.defineMethod (c$, "isWhitespace",
 919 function (ch) {
 920 var c = (ch).charCodeAt (0);
 921 return (c >= 0x1c && c <= 0x20 || c >= 0x9 && c <= 0xd);
 922 }, "~S");
 923 c$.fixPtFloats = Clazz.defineMethod (c$, "fixPtFloats",
 924 function (pt, f) {
 925 pt.x = Math.round (pt.x * f) / f;
 926 pt.y = Math.round (pt.y * f) / f;
 927 pt.z = Math.round (pt.z * f) / f;
 928 }, "javajs.util.T3,~N");
 929 c$.fixDouble = Clazz.defineMethod (c$, "fixDouble",
 930 function (d, f) {
 931 return Math.round (d * f) / f;
 932 }, "~N,~N");
 933 c$.parseFloatFraction = Clazz.defineMethod (c$, "parseFloatFraction",
 934 function (s) {
 935 var pt = s.indexOf ("/");
 936 return (pt < 0 ? javajs.util.PT.parseFloat (s) : javajs.util.PT.parseFloat (s.substring (0, pt)) / javajs.util.PT.parseFloat (s.substring (pt + 1)));
 937 }, "~S");
 938 Clazz.defineStatics (c$,
 939 "tensScale",  Clazz.newFloatArray (-1, [10, 100, 1000, 10000, 100000, 1000000]),
 940 "decimalScale",  Clazz.newFloatArray (-1, [0.1, 0.01, 0.001, 0.0001, 0.00001, 0.000001, 0.0000001, 0.00000001, 0.000000001]),
 941 "FLOAT_MIN_SAFE", 2E-45,
 942 "escapable", "\\\\\tt\rr\nn\"\"",
 943 "FRACTIONAL_PRECISION", 100000,
 944 "CARTESIAN_PRECISION", 10000);
 945 });