site/j2s/JU/PT.js

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