1 Clazz.declarePackage ("java.text");
\r
2 Clazz.load (["java.text.NumberFormat", "java.util.Hashtable", "java.text.DigitList"], "java.text.DecimalFormat", ["java.lang.Byte", "$.Character", "$.Double", "$.Float", "$.IllegalArgumentException", "$.InternalError", "$.Long", "$.NullPointerException", "$.Number", "$.Short", "$.StringBuffer", "java.util.ArrayList", "java.text.CharacterIteratorFieldDelegate", "$.DecimalFormatSymbols", "$.FieldPosition", "$.ParsePosition", "java.util.Locale", "jssun.util.resources.LocaleData"], function () {
\r
3 c$ = Clazz.decorateAsClass (function () {
\r
4 this.digitList = null;
\r
5 this.positivePrefix = "";
\r
6 this.positiveSuffix = "";
\r
7 this.negativePrefix = "-";
\r
8 this.negativeSuffix = "";
\r
9 this.posPrefixPattern = null;
\r
10 this.posSuffixPattern = null;
\r
11 this.negPrefixPattern = null;
\r
12 this.negSuffixPattern = null;
\r
13 this.multiplier = 1;
\r
14 this.groupingSize = 3;
\r
15 this.decimalSeparatorAlwaysShown = false;
\r
16 this.parseBigDecimal = false;
\r
17 this.isCurrencyFormat = false;
\r
18 this.symbols = null;
\r
19 this.useExponentialNotation = false;
\r
20 this.positivePrefixFieldPositions = null;
\r
21 this.positiveSuffixFieldPositions = null;
\r
22 this.negativePrefixFieldPositions = null;
\r
23 this.negativeSuffixFieldPositions = null;
\r
24 this.minExponentDigits = 0;
\r
25 this.$maximumIntegerDigits = 0;
\r
26 this.$minimumIntegerDigits = 0;
\r
27 this.$maximumFractionDigits = 0;
\r
28 this.$minimumFractionDigits = 0;
\r
29 this.roundingMode = null;
\r
30 Clazz.instantialize (this, arguments);
\r
31 }, java.text, "DecimalFormat", java.text.NumberFormat);
\r
32 Clazz.prepareFields (c$, function () {
\r
33 this.digitList = new java.text.DigitList ();
\r
34 this.$maximumIntegerDigits = Clazz.superCall (this, java.text.DecimalFormat, "getMaximumIntegerDigits", []);
\r
35 this.$minimumIntegerDigits = Clazz.superCall (this, java.text.DecimalFormat, "getMinimumIntegerDigits", []);
\r
36 this.$maximumFractionDigits = Clazz.superCall (this, java.text.DecimalFormat, "getMaximumFractionDigits", []);
\r
37 this.$minimumFractionDigits = Clazz.superCall (this, java.text.DecimalFormat, "getMinimumFractionDigits", []);
\r
39 Clazz.makeConstructor (c$,
\r
41 Clazz.superConstructor (this, java.text.DecimalFormat, []);
\r
42 var def = java.util.Locale.getDefault ();
\r
43 var pattern = java.text.DecimalFormat.$cachedLocaleData.get (def);
\r
44 if (pattern == null) {
\r
45 var rb = jssun.util.resources.LocaleData.getNumberFormatData (def);
\r
46 var all = rb.getStringArray ("NumberPatterns");
\r
48 java.text.DecimalFormat.$cachedLocaleData.put (def, pattern);
\r
49 }this.symbols = new java.text.DecimalFormatSymbols (def);
\r
50 this.applyPattern (pattern, false);
\r
52 Clazz.makeConstructor (c$,
\r
53 function (pattern) {
\r
54 Clazz.superConstructor (this, java.text.DecimalFormat, []);
\r
55 this.symbols = new java.text.DecimalFormatSymbols (java.util.Locale.getDefault ());
\r
56 this.applyPattern (pattern, false);
\r
58 Clazz.makeConstructor (c$,
\r
59 function (pattern, symbols) {
\r
60 Clazz.superConstructor (this, java.text.DecimalFormat, []);
\r
61 this.symbols = symbols.clone ();
\r
62 this.applyPattern (pattern, false);
\r
63 }, "~S,java.text.DecimalFormatSymbols");
\r
64 Clazz.defineMethod (c$, "format",
\r
65 function (number, toAppendTo, pos) {
\r
66 if (Clazz.instanceOf (number, Long) || Clazz.instanceOf (number, Integer) || Clazz.instanceOf (number, Short) || Clazz.instanceOf (number, Byte)) {
\r
67 return this.format ((number).longValue (), toAppendTo, pos);
\r
68 } else if (Clazz.instanceOf (number, Number)) {
\r
69 return this.format ((number).doubleValue (), toAppendTo, pos);
\r
71 throw new IllegalArgumentException ("Cannot format given Object as a Number");
\r
72 }}, "~O,StringBuffer,java.text.FieldPosition");
\r
73 Clazz.defineMethod (c$, "format",
\r
74 function (number, result, fieldPosition) {
\r
75 fieldPosition.setBeginIndex (0);
\r
76 fieldPosition.setEndIndex (0);
\r
77 var isInt = (number == Clazz.doubleToInt (number) && Math.abs (number) < 2147483647);
\r
78 if (isInt) return this.formatLong (Clazz.doubleToInt (number), result, fieldPosition.getFieldDelegate ());
\r
79 else return this.formatDouble (number, result, fieldPosition.getFieldDelegate ());
\r
80 }, "~N,StringBuffer,java.text.FieldPosition");
\r
81 Clazz.defineMethod (c$, "formatDouble",
\r
82 function (number, result, delegate) {
\r
83 if (Double.isNaN (number) || (Double.isInfinite (number) && this.multiplier == 0)) {
\r
84 var iFieldStart = result.length ();
\r
85 result.append (this.symbols.getNaN ());
\r
86 delegate.formatted (0, java.text.NumberFormat.Field.INTEGER, java.text.NumberFormat.Field.INTEGER, iFieldStart, result.length (), result);
\r
88 }var isNegative = new Boolean (((number < 0.0) || (number == 0.0 && 1 / number < 0.0)) ^ (this.multiplier < 0)).valueOf ();
\r
89 if (this.multiplier != 1) {
\r
90 number *= this.multiplier;
\r
91 }if (Double.isInfinite (number)) {
\r
93 this.append (result, this.negativePrefix, delegate, this.getNegativePrefixFieldPositions (), java.text.NumberFormat.Field.SIGN);
\r
95 this.append (result, this.positivePrefix, delegate, this.getPositivePrefixFieldPositions (), java.text.NumberFormat.Field.SIGN);
\r
96 }var iFieldStart = result.length ();
\r
97 result.append (this.symbols.getInfinity ());
\r
98 delegate.formatted (0, java.text.NumberFormat.Field.INTEGER, java.text.NumberFormat.Field.INTEGER, iFieldStart, result.length (), result);
\r
100 this.append (result, this.negativeSuffix, delegate, this.getNegativeSuffixFieldPositions (), java.text.NumberFormat.Field.SIGN);
\r
102 this.append (result, this.positiveSuffix, delegate, this.getPositiveSuffixFieldPositions (), java.text.NumberFormat.Field.SIGN);
\r
107 var maxIntDigits = Clazz.superCall (this, java.text.DecimalFormat, "getMaximumIntegerDigits", []);
\r
108 var minIntDigits = Clazz.superCall (this, java.text.DecimalFormat, "getMinimumIntegerDigits", []);
\r
109 var maxFraDigits = Clazz.superCall (this, java.text.DecimalFormat, "getMaximumFractionDigits", []);
\r
110 var minFraDigits = Clazz.superCall (this, java.text.DecimalFormat, "getMinimumFractionDigits", []);
\r
111 this.digitList.set (isNegative, number, this.useExponentialNotation ? maxIntDigits + maxFraDigits : maxFraDigits, !this.useExponentialNotation);
\r
112 return this.subformat (result, delegate, isNegative, false, maxIntDigits, minIntDigits, maxFraDigits, minFraDigits);
\r
113 }}, "~N,StringBuffer,java.text.Format.FieldDelegate");
\r
114 Clazz.defineMethod (c$, "formatLong",
\r
115 function (number, result, delegate) {
\r
116 var isNegative = (number < 0);
\r
120 } else if (this.multiplier != 1 && this.multiplier != 0) {
\r
121 var cutoff = Clazz.doubleToInt (9223372036854775807 / this.multiplier);
\r
124 }}number *= this.multiplier;
\r
126 isNegative = false;
\r
128 if (this.multiplier < 0) {
\r
130 isNegative = !isNegative;
\r
132 var maxIntDigits = Clazz.superCall (this, java.text.DecimalFormat, "getMaximumIntegerDigits", []);
\r
133 var minIntDigits = Clazz.superCall (this, java.text.DecimalFormat, "getMinimumIntegerDigits", []);
\r
134 var maxFraDigits = Clazz.superCall (this, java.text.DecimalFormat, "getMaximumFractionDigits", []);
\r
135 var minFraDigits = Clazz.superCall (this, java.text.DecimalFormat, "getMinimumFractionDigits", []);
\r
136 this.digitList.setLong (isNegative, number, this.useExponentialNotation ? maxIntDigits + maxFraDigits : 0);
\r
137 return this.subformat (result, delegate, isNegative, true, maxIntDigits, minIntDigits, maxFraDigits, minFraDigits);
\r
138 }}, "~N,StringBuffer,java.text.Format.FieldDelegate");
\r
139 Clazz.overrideMethod (c$, "formatToCharacterIterator",
\r
141 var delegate = new java.text.CharacterIteratorFieldDelegate ();
\r
142 var sb = new StringBuffer ();
\r
143 if (Clazz.instanceOf (obj, Double) || Clazz.instanceOf (obj, Float)) {
\r
144 this.formatDouble ((obj).doubleValue (), sb, delegate);
\r
145 } else if (Clazz.instanceOf (obj, Long) || Clazz.instanceOf (obj, Integer) || Clazz.instanceOf (obj, Short) || Clazz.instanceOf (obj, Byte)) {
\r
146 this.formatLong ((obj).longValue (), sb, delegate);
\r
147 } else if (obj == null) {
\r
148 throw new NullPointerException ("formatToCharacterIterator must be passed non-null object");
\r
150 throw new IllegalArgumentException ("Cannot format given Object as a Number");
\r
151 }return delegate.getIterator (sb.toString ());
\r
153 Clazz.defineMethod (c$, "subformat",
\r
154 function (result, delegate, isNegative, isInteger, maxIntDigits, minIntDigits, maxFraDigits, minFraDigits) {
\r
155 var zero = this.symbols.getZeroDigit ();
\r
156 var zeroDelta = zero.charCodeAt (0) - 48;
\r
157 var grouping = this.symbols.getGroupingSeparator ();
\r
158 var decimal = this.isCurrencyFormat ? this.symbols.getMonetaryDecimalSeparator () : this.symbols.getDecimalSeparator ();
\r
159 if (this.digitList.isZero ()) {
\r
160 this.digitList.decimalAt = 0;
\r
162 this.append (result, this.negativePrefix, delegate, this.getNegativePrefixFieldPositions (), java.text.NumberFormat.Field.SIGN);
\r
164 this.append (result, this.positivePrefix, delegate, this.getPositivePrefixFieldPositions (), java.text.NumberFormat.Field.SIGN);
\r
165 }if (this.useExponentialNotation) {
\r
166 var iFieldStart = result.length ();
\r
167 var iFieldEnd = -1;
\r
168 var fFieldStart = -1;
\r
169 var exponent = this.digitList.decimalAt;
\r
170 var repeat = maxIntDigits;
\r
171 var minimumIntegerDigits = minIntDigits;
\r
172 if (repeat > 1 && repeat > minIntDigits) {
\r
173 if (exponent >= 1) {
\r
174 exponent = (Clazz.doubleToInt ((exponent - 1) / repeat)) * repeat;
\r
176 exponent = (Clazz.doubleToInt ((exponent - repeat) / repeat)) * repeat;
\r
177 }minimumIntegerDigits = 1;
\r
179 exponent -= minimumIntegerDigits;
\r
180 }var minimumDigits = minIntDigits + minFraDigits;
\r
181 if (minimumDigits < 0) {
\r
182 minimumDigits = 2147483647;
\r
183 }var integerDigits = this.digitList.isZero () ? minimumIntegerDigits : this.digitList.decimalAt - exponent;
\r
184 if (minimumDigits < integerDigits) {
\r
185 minimumDigits = integerDigits;
\r
186 }var totalDigits = this.digitList.count;
\r
187 if (minimumDigits > totalDigits) {
\r
188 totalDigits = minimumDigits;
\r
189 }var addedDecimalSeparator = false;
\r
190 for (var i = 0; i < totalDigits; ++i) {
\r
191 if (i == integerDigits) {
\r
192 iFieldEnd = result.length ();
\r
193 result.append (decimal);
\r
194 addedDecimalSeparator = true;
\r
195 fFieldStart = result.length ();
\r
196 }result.append ((i < this.digitList.count) ? String.fromCharCode ((this.digitList.digits[i]).charCodeAt (0) + zeroDelta) : zero);
\r
198 if (this.decimalSeparatorAlwaysShown && totalDigits == integerDigits) {
\r
199 iFieldEnd = result.length ();
\r
200 result.append (decimal);
\r
201 addedDecimalSeparator = true;
\r
202 fFieldStart = result.length ();
\r
203 }if (iFieldEnd == -1) {
\r
204 iFieldEnd = result.length ();
\r
205 }delegate.formatted (0, java.text.NumberFormat.Field.INTEGER, java.text.NumberFormat.Field.INTEGER, iFieldStart, iFieldEnd, result);
\r
206 if (addedDecimalSeparator) {
\r
207 delegate.formatted (java.text.NumberFormat.Field.DECIMAL_SEPARATOR, java.text.NumberFormat.Field.DECIMAL_SEPARATOR, iFieldEnd, fFieldStart, result);
\r
208 }if (fFieldStart == -1) {
\r
209 fFieldStart = result.length ();
\r
210 }delegate.formatted (1, java.text.NumberFormat.Field.FRACTION, java.text.NumberFormat.Field.FRACTION, fFieldStart, result.length (), result);
\r
211 var fieldStart = result.length ();
\r
212 result.append (this.symbols.getExponentSeparator ());
\r
213 delegate.formatted (java.text.NumberFormat.Field.EXPONENT_SYMBOL, java.text.NumberFormat.Field.EXPONENT_SYMBOL, fieldStart, result.length (), result);
\r
214 if (this.digitList.isZero ()) {
\r
216 }var negativeExponent = exponent < 0;
\r
217 if (negativeExponent) {
\r
218 exponent = -exponent;
\r
219 fieldStart = result.length ();
\r
220 result.append (this.symbols.getMinusSign ());
\r
221 delegate.formatted (java.text.NumberFormat.Field.EXPONENT_SIGN, java.text.NumberFormat.Field.EXPONENT_SIGN, fieldStart, result.length (), result);
\r
222 }this.digitList.setExp (negativeExponent, exponent);
\r
223 var eFieldStart = result.length ();
\r
224 for (var i = this.digitList.decimalAt; i < this.minExponentDigits; ++i) {
\r
225 result.append (zero);
\r
227 for (var i = 0; i < this.digitList.decimalAt; ++i) {
\r
228 result.append ((i < this.digitList.count) ? String.fromCharCode ((this.digitList.digits[i]).charCodeAt (0) + zeroDelta) : zero);
\r
230 delegate.formatted (java.text.NumberFormat.Field.EXPONENT, java.text.NumberFormat.Field.EXPONENT, eFieldStart, result.length (), result);
\r
232 var iFieldStart = result.length ();
\r
233 var count = minIntDigits;
\r
234 var digitIndex = 0;
\r
235 if (this.digitList.decimalAt > 0 && count < this.digitList.decimalAt) {
\r
236 count = this.digitList.decimalAt;
\r
237 }if (count > maxIntDigits) {
\r
238 count = maxIntDigits;
\r
239 digitIndex = this.digitList.decimalAt - count;
\r
240 }var sizeBeforeIntegerPart = result.length ();
\r
241 for (var i = count - 1; i >= 0; --i) {
\r
242 if (i < this.digitList.decimalAt && digitIndex < this.digitList.count) {
\r
243 result.append (String.fromCharCode ((this.digitList.digits[digitIndex++]).charCodeAt (0) + zeroDelta));
\r
245 result.append (zero);
\r
246 }if (this.isGroupingUsed () && i > 0 && (this.groupingSize != 0) && (i % this.groupingSize == 0)) {
\r
247 var gStart = result.length ();
\r
248 result.append (grouping);
\r
249 delegate.formatted (java.text.NumberFormat.Field.GROUPING_SEPARATOR, java.text.NumberFormat.Field.GROUPING_SEPARATOR, gStart, result.length (), result);
\r
251 var fractionPresent = (minFraDigits > 0) || (!isInteger && digitIndex < this.digitList.count);
\r
252 if (!fractionPresent && result.length () == sizeBeforeIntegerPart) {
\r
253 result.append (zero);
\r
254 }delegate.formatted (0, java.text.NumberFormat.Field.INTEGER, java.text.NumberFormat.Field.INTEGER, iFieldStart, result.length (), result);
\r
255 var sStart = result.length ();
\r
256 if (this.decimalSeparatorAlwaysShown || fractionPresent) {
\r
257 result.append (decimal);
\r
258 }if (sStart != result.length ()) {
\r
259 delegate.formatted (java.text.NumberFormat.Field.DECIMAL_SEPARATOR, java.text.NumberFormat.Field.DECIMAL_SEPARATOR, sStart, result.length (), result);
\r
260 }var fFieldStart = result.length ();
\r
261 for (var i = 0; i < maxFraDigits; ++i) {
\r
262 if (i >= minFraDigits && (isInteger || digitIndex >= this.digitList.count)) {
\r
264 }if (-1 - i > (this.digitList.decimalAt - 1)) {
\r
265 result.append (zero);
\r
267 }if (!isInteger && digitIndex < this.digitList.count) {
\r
268 result.append (String.fromCharCode ((this.digitList.digits[digitIndex++]).charCodeAt (0) + zeroDelta));
\r
270 result.append (zero);
\r
272 delegate.formatted (1, java.text.NumberFormat.Field.FRACTION, java.text.NumberFormat.Field.FRACTION, fFieldStart, result.length (), result);
\r
274 this.append (result, this.negativeSuffix, delegate, this.getNegativeSuffixFieldPositions (), java.text.NumberFormat.Field.SIGN);
\r
276 this.append (result, this.positiveSuffix, delegate, this.getPositiveSuffixFieldPositions (), java.text.NumberFormat.Field.SIGN);
\r
278 }, "StringBuffer,java.text.Format.FieldDelegate,~B,~B,~N,~N,~N,~N");
\r
279 Clazz.defineMethod (c$, "append",
\r
280 function (result, string, delegate, positions, signAttribute) {
\r
281 var start = result.length ();
\r
282 if (string.length > 0) {
\r
283 result.append (string);
\r
284 for (var counter = 0, max = positions.length; counter < max; counter++) {
\r
285 var fp = positions[counter];
\r
286 var attribute = fp.getFieldAttribute ();
\r
287 if (attribute === java.text.NumberFormat.Field.SIGN) {
\r
288 attribute = signAttribute;
\r
289 }delegate.formatted (attribute, attribute, start + fp.getBeginIndex (), start + fp.getEndIndex (), result);
\r
291 }}, "StringBuffer,~S,java.text.Format.FieldDelegate,~A,java.text.Format.Field");
\r
292 Clazz.defineMethod (c$, "parse",
\r
293 function (text, pos) {
\r
294 if (text.regionMatches (pos.index, this.symbols.getNaN (), 0, this.symbols.getNaN ().length)) {
\r
295 pos.index = pos.index + this.symbols.getNaN ().length;
\r
296 return new Double (NaN);
\r
297 }var status = Clazz.newBooleanArray (2, false);
\r
298 if (!this.subparse (text, pos, this.positivePrefix, this.negativePrefix, this.digitList, false, status)) {
\r
301 if (status[1] == (this.multiplier >= 0)) {
\r
302 return new Double (Infinity);
\r
304 return new Double (-Infinity);
\r
305 }}if (this.multiplier == 0) {
\r
306 if (this.digitList.isZero ()) {
\r
307 return new Double (NaN);
\r
308 } else if (status[1]) {
\r
309 return new Double (Infinity);
\r
311 return new Double (-Infinity);
\r
312 }}var gotDouble = true;
\r
313 var gotLongMinimum = false;
\r
314 var doubleResult = 0.0;
\r
315 var longResult = 0;
\r
316 if (this.digitList.fitsIntoLong (status[1], this.isParseIntegerOnly ())) {
\r
318 longResult = this.digitList.getLong ();
\r
319 if (longResult < 0) {
\r
320 gotLongMinimum = true;
\r
322 doubleResult = this.digitList.getDouble ();
\r
323 }if (this.multiplier != 1) {
\r
325 doubleResult /= this.multiplier;
\r
327 if (longResult % this.multiplier == 0) {
\r
328 longResult = Clazz.doubleToInt (longResult / this.multiplier);
\r
330 doubleResult = (longResult) / this.multiplier;
\r
332 }}}if (!status[1] && !gotLongMinimum) {
\r
333 doubleResult = -doubleResult;
\r
334 longResult = -longResult;
\r
335 }if (this.multiplier != 1 && gotDouble) {
\r
336 longResult = Clazz.doubleToLong (doubleResult);
\r
337 gotDouble = ((doubleResult != longResult) || (doubleResult == 0.0 && 1 / doubleResult < 0.0)) && !this.isParseIntegerOnly ();
\r
338 }return gotDouble ? new Double (doubleResult) : new Long (longResult);
\r
339 }, "~S,java.text.ParsePosition");
\r
340 Clazz.defineMethod (c$, "subparse",
\r
341 function (text, parsePosition, positivePrefix, negativePrefix, digits, isExponent, status) {
\r
342 var position = parsePosition.index;
\r
343 var oldStart = parsePosition.index;
\r
347 gotPositive = text.regionMatches (position, positivePrefix, 0, positivePrefix.length);
\r
348 gotNegative = text.regionMatches (position, negativePrefix, 0, negativePrefix.length);
\r
349 if (gotPositive && gotNegative) {
\r
350 if (positivePrefix.length > negativePrefix.length) {
\r
351 gotNegative = false;
\r
352 } else if (positivePrefix.length < negativePrefix.length) {
\r
353 gotPositive = false;
\r
354 }}if (gotPositive) {
\r
355 position += positivePrefix.length;
\r
356 } else if (gotNegative) {
\r
357 position += negativePrefix.length;
\r
359 parsePosition.errorIndex = position;
\r
361 }status[0] = false;
\r
362 if (!isExponent && text.regionMatches (position, this.symbols.getInfinity (), 0, this.symbols.getInfinity ().length)) {
\r
363 position += this.symbols.getInfinity ().length;
\r
366 digits.decimalAt = digits.count = 0;
\r
367 var zero = this.symbols.getZeroDigit ();
\r
368 var decimal = this.isCurrencyFormat ? this.symbols.getMonetaryDecimalSeparator () : this.symbols.getDecimalSeparator ();
\r
369 var grouping = this.symbols.getGroupingSeparator ();
\r
370 var exponentString = this.symbols.getExponentSeparator ();
\r
371 var sawDecimal = false;
\r
372 var sawExponent = false;
\r
373 var sawDigit = false;
\r
375 var digitCount = 0;
\r
377 for (; position < text.length; ++position) {
\r
378 var ch = text.charAt (position);
\r
379 var digit = ch.charCodeAt (0) - zero.charCodeAt (0);
\r
380 if (digit < 0 || digit > 9) {
\r
381 digit = Character.digit (ch, 10);
\r
385 if (digits.count == 0) {
\r
388 }--digits.decimalAt;
\r
391 digits.append (String.fromCharCode (digit + 48));
\r
392 }} else if (digit > 0 && digit <= 9) {
\r
395 digits.append (String.fromCharCode (digit + 48));
\r
397 } else if (!isExponent && ch == decimal) {
\r
398 if (this.isParseIntegerOnly () || sawDecimal) {
\r
400 }digits.decimalAt = digitCount;
\r
402 } else if (!isExponent && ch == grouping && this.isGroupingUsed ()) {
\r
405 }backup = position;
\r
406 } else if (!isExponent && text.regionMatches (position, exponentString, 0, exponentString.length) && !sawExponent) {
\r
407 var pos = new java.text.ParsePosition (position + exponentString.length);
\r
408 var stat = Clazz.newBooleanArray (2, false);
\r
409 var exponentDigits = new java.text.DigitList ();
\r
410 if (this.subparse (text, pos, "", Character.toString (this.symbols.getMinusSign ()), exponentDigits, true, stat) && exponentDigits.fitsIntoLong (stat[1], true)) {
\r
411 position = pos.index;
\r
412 exponent = exponentDigits.getLong ();
\r
414 exponent = -exponent;
\r
415 }sawExponent = true;
\r
420 if (backup != -1) {
\r
422 }if (!sawDecimal) {
\r
423 digits.decimalAt = digitCount;
\r
424 }digits.decimalAt += exponent;
\r
425 if (!sawDigit && digitCount == 0) {
\r
426 parsePosition.index = oldStart;
\r
427 parsePosition.errorIndex = oldStart;
\r
429 }}if (!isExponent) {
\r
431 gotPositive = text.regionMatches (position, this.positiveSuffix, 0, this.positiveSuffix.length);
\r
432 }if (gotNegative) {
\r
433 gotNegative = text.regionMatches (position, this.negativeSuffix, 0, this.negativeSuffix.length);
\r
434 }if (gotPositive && gotNegative) {
\r
435 if (this.positiveSuffix.length > this.negativeSuffix.length) {
\r
436 gotNegative = false;
\r
437 } else if (this.positiveSuffix.length < this.negativeSuffix.length) {
\r
438 gotPositive = false;
\r
439 }}if (gotPositive == gotNegative) {
\r
440 parsePosition.errorIndex = position;
\r
442 }parsePosition.index = position + (gotPositive ? this.positiveSuffix.length : this.negativeSuffix.length);
\r
444 parsePosition.index = position;
\r
445 }status[1] = gotPositive;
\r
446 if (parsePosition.index == oldStart) {
\r
447 parsePosition.errorIndex = position;
\r
450 }, "~S,java.text.ParsePosition,~S,~S,java.text.DigitList,~B,~A");
\r
451 Clazz.defineMethod (c$, "getDecimalFormatSymbols",
\r
454 return this.symbols.clone ();
\r
456 if (Clazz.exceptionOf (foo, Exception)) {
\r
463 Clazz.defineMethod (c$, "setDecimalFormatSymbols",
\r
464 function (newSymbols) {
\r
466 this.symbols = newSymbols.clone ();
\r
467 this.expandAffixes ();
\r
469 if (Clazz.exceptionOf (foo, Exception)) {
\r
474 }, "java.text.DecimalFormatSymbols");
\r
475 Clazz.defineMethod (c$, "getPositivePrefix",
\r
477 return this.positivePrefix;
\r
479 Clazz.defineMethod (c$, "setPositivePrefix",
\r
480 function (newValue) {
\r
481 this.positivePrefix = newValue;
\r
482 this.posPrefixPattern = null;
\r
483 this.positivePrefixFieldPositions = null;
\r
485 Clazz.defineMethod (c$, "getPositivePrefixFieldPositions",
\r
487 if (this.positivePrefixFieldPositions == null) {
\r
488 if (this.posPrefixPattern != null) {
\r
489 this.positivePrefixFieldPositions = this.expandAffix (this.posPrefixPattern);
\r
491 this.positivePrefixFieldPositions = java.text.DecimalFormat.EmptyFieldPositionArray;
\r
492 }}return this.positivePrefixFieldPositions;
\r
494 Clazz.defineMethod (c$, "getNegativePrefix",
\r
496 return this.negativePrefix;
\r
498 Clazz.defineMethod (c$, "setNegativePrefix",
\r
499 function (newValue) {
\r
500 this.negativePrefix = newValue;
\r
501 this.negPrefixPattern = null;
\r
503 Clazz.defineMethod (c$, "getNegativePrefixFieldPositions",
\r
505 if (this.negativePrefixFieldPositions == null) {
\r
506 if (this.negPrefixPattern != null) {
\r
507 this.negativePrefixFieldPositions = this.expandAffix (this.negPrefixPattern);
\r
509 this.negativePrefixFieldPositions = java.text.DecimalFormat.EmptyFieldPositionArray;
\r
510 }}return this.negativePrefixFieldPositions;
\r
512 Clazz.defineMethod (c$, "getPositiveSuffix",
\r
514 return this.positiveSuffix;
\r
516 Clazz.defineMethod (c$, "setPositiveSuffix",
\r
517 function (newValue) {
\r
518 this.positiveSuffix = newValue;
\r
519 this.posSuffixPattern = null;
\r
521 Clazz.defineMethod (c$, "getPositiveSuffixFieldPositions",
\r
523 if (this.positiveSuffixFieldPositions == null) {
\r
524 if (this.posSuffixPattern != null) {
\r
525 this.positiveSuffixFieldPositions = this.expandAffix (this.posSuffixPattern);
\r
527 this.positiveSuffixFieldPositions = java.text.DecimalFormat.EmptyFieldPositionArray;
\r
528 }}return this.positiveSuffixFieldPositions;
\r
530 Clazz.defineMethod (c$, "getNegativeSuffix",
\r
532 return this.negativeSuffix;
\r
534 Clazz.defineMethod (c$, "setNegativeSuffix",
\r
535 function (newValue) {
\r
536 this.negativeSuffix = newValue;
\r
537 this.negSuffixPattern = null;
\r
539 Clazz.defineMethod (c$, "getNegativeSuffixFieldPositions",
\r
541 if (this.negativeSuffixFieldPositions == null) {
\r
542 if (this.negSuffixPattern != null) {
\r
543 this.negativeSuffixFieldPositions = this.expandAffix (this.negSuffixPattern);
\r
545 this.negativeSuffixFieldPositions = java.text.DecimalFormat.EmptyFieldPositionArray;
\r
546 }}return this.negativeSuffixFieldPositions;
\r
548 Clazz.defineMethod (c$, "getMultiplier",
\r
550 return this.multiplier;
\r
552 Clazz.defineMethod (c$, "setMultiplier",
\r
553 function (newValue) {
\r
554 this.multiplier = newValue;
\r
556 Clazz.defineMethod (c$, "getGroupingSize",
\r
558 return this.groupingSize;
\r
560 Clazz.defineMethod (c$, "setGroupingSize",
\r
561 function (newValue) {
\r
562 this.groupingSize = newValue;
\r
564 Clazz.defineMethod (c$, "isDecimalSeparatorAlwaysShown",
\r
566 return this.decimalSeparatorAlwaysShown;
\r
568 Clazz.defineMethod (c$, "setDecimalSeparatorAlwaysShown",
\r
569 function (newValue) {
\r
570 this.decimalSeparatorAlwaysShown = newValue;
\r
572 Clazz.defineMethod (c$, "isParseBigDecimal",
\r
574 return this.parseBigDecimal;
\r
576 Clazz.defineMethod (c$, "setParseBigDecimal",
\r
577 function (newValue) {
\r
578 this.parseBigDecimal = newValue;
\r
580 Clazz.defineMethod (c$, "clone",
\r
583 var other = Clazz.superCall (this, java.text.DecimalFormat, "clone", []);
\r
584 other.symbols = this.symbols.clone ();
\r
585 other.digitList = this.digitList.clone ();
\r
588 if (Clazz.exceptionOf (e, Exception)) {
\r
589 throw new InternalError ();
\r
595 Clazz.defineMethod (c$, "equals",
\r
597 if (obj == null) return false;
\r
598 if (!Clazz.superCall (this, java.text.DecimalFormat, "equals", [obj])) return false;
\r
600 return ((this.posPrefixPattern === other.posPrefixPattern && this.positivePrefix.equals (other.positivePrefix)) || (this.posPrefixPattern != null && this.posPrefixPattern.equals (other.posPrefixPattern))) && ((this.posSuffixPattern === other.posSuffixPattern && this.positiveSuffix.equals (other.positiveSuffix)) || (this.posSuffixPattern != null && this.posSuffixPattern.equals (other.posSuffixPattern))) && ((this.negPrefixPattern === other.negPrefixPattern && this.negativePrefix.equals (other.negativePrefix)) || (this.negPrefixPattern != null && this.negPrefixPattern.equals (other.negPrefixPattern))) && ((this.negSuffixPattern === other.negSuffixPattern && this.negativeSuffix.equals (other.negativeSuffix)) || (this.negSuffixPattern != null && this.negSuffixPattern.equals (other.negSuffixPattern))) && this.multiplier == other.multiplier && this.groupingSize == other.groupingSize && this.decimalSeparatorAlwaysShown == other.decimalSeparatorAlwaysShown && this.parseBigDecimal == other.parseBigDecimal && this.useExponentialNotation == other.useExponentialNotation && (!this.useExponentialNotation || this.minExponentDigits == other.minExponentDigits) && this.$maximumIntegerDigits == other.$maximumIntegerDigits && this.$minimumIntegerDigits == other.$minimumIntegerDigits && this.$maximumFractionDigits == other.$maximumFractionDigits && this.$minimumFractionDigits == other.$minimumFractionDigits && this.roundingMode === other.roundingMode && this.symbols.equals (other.symbols);
\r
602 Clazz.defineMethod (c$, "hashCode",
\r
604 return Clazz.superCall (this, java.text.DecimalFormat, "hashCode", []) * 37 + this.positivePrefix.hashCode ();
\r
606 Clazz.defineMethod (c$, "toPattern",
\r
608 return this.toPattern (false);
\r
610 Clazz.defineMethod (c$, "toLocalizedPattern",
\r
612 return this.toPattern (true);
\r
614 Clazz.defineMethod (c$, "expandAffixes",
\r
616 var buffer = new StringBuffer ();
\r
617 if (this.posPrefixPattern != null) {
\r
618 this.positivePrefix = this.expandAffix (this.posPrefixPattern, buffer);
\r
619 this.positivePrefixFieldPositions = null;
\r
620 }if (this.posSuffixPattern != null) {
\r
621 this.positiveSuffix = this.expandAffix (this.posSuffixPattern, buffer);
\r
622 this.positiveSuffixFieldPositions = null;
\r
623 }if (this.negPrefixPattern != null) {
\r
624 this.negativePrefix = this.expandAffix (this.negPrefixPattern, buffer);
\r
625 this.negativePrefixFieldPositions = null;
\r
626 }if (this.negSuffixPattern != null) {
\r
627 this.negativeSuffix = this.expandAffix (this.negSuffixPattern, buffer);
\r
628 this.negativeSuffixFieldPositions = null;
\r
630 Clazz.defineMethod (c$, "expandAffix",
\r
631 function (pattern, buffer) {
\r
632 buffer.setLength (0);
\r
633 for (var i = 0; i < pattern.length; ) {
\r
634 var c = pattern.charAt (i++);
\r
636 c = pattern.charAt (i++);
\r
639 if (i < pattern.length && pattern.charAt (i) == '\u00a4') {
\r
641 buffer.append (this.symbols.getInternationalCurrencySymbol ());
\r
643 buffer.append (this.symbols.getCurrencySymbol ());
\r
646 c = this.symbols.getPercent ();
\r
649 c = this.symbols.getPerMill ();
\r
652 c = this.symbols.getMinusSign ();
\r
655 }buffer.append (c);
\r
657 return buffer.toString ();
\r
658 }, "~S,StringBuffer");
\r
659 Clazz.defineMethod (c$, "expandAffix",
\r
660 function (pattern) {
\r
661 var positions = null;
\r
662 var stringIndex = 0;
\r
663 for (var i = 0; i < pattern.length; ) {
\r
664 var c = pattern.charAt (i++);
\r
667 var fieldID = null;
\r
668 c = pattern.charAt (i++);
\r
672 if (i < pattern.length && pattern.charAt (i) == '\u00a4') {
\r
674 string = this.symbols.getInternationalCurrencySymbol ();
\r
676 string = this.symbols.getCurrencySymbol ();
\r
677 }if (string.length > 0) {
\r
678 if (positions == null) {
\r
679 positions = new java.util.ArrayList (2);
\r
680 }var fp = new java.text.FieldPosition (java.text.NumberFormat.Field.CURRENCY);
\r
681 fp.setBeginIndex (stringIndex);
\r
682 fp.setEndIndex (stringIndex + string.length);
\r
683 positions.add (fp);
\r
684 stringIndex += string.length;
\r
687 c = this.symbols.getPercent ();
\r
689 fieldID = java.text.NumberFormat.Field.PERCENT;
\r
692 c = this.symbols.getPerMill ();
\r
694 fieldID = java.text.NumberFormat.Field.PERMILLE;
\r
697 c = this.symbols.getMinusSign ();
\r
699 fieldID = java.text.NumberFormat.Field.SIGN;
\r
702 if (fieldID != null) {
\r
703 if (positions == null) {
\r
704 positions = new java.util.ArrayList (2);
\r
705 }var fp = new java.text.FieldPosition (fieldID, field);
\r
706 fp.setBeginIndex (stringIndex);
\r
707 fp.setEndIndex (stringIndex + 1);
\r
708 positions.add (fp);
\r
711 if (positions != null) {
\r
712 return positions.toArray (java.text.DecimalFormat.EmptyFieldPositionArray);
\r
713 }return java.text.DecimalFormat.EmptyFieldPositionArray;
\r
715 Clazz.defineMethod (c$, "appendAffix",
\r
716 function (buffer, affixPattern, expAffix, localized) {
\r
717 if (affixPattern == null) {
\r
718 this.appendAffix (buffer, expAffix, localized);
\r
721 for (var pos = 0; pos < affixPattern.length; pos = i) {
\r
722 i = affixPattern.indexOf ('\'', pos);
\r
724 this.appendAffix (buffer, affixPattern.substring (pos), localized);
\r
727 this.appendAffix (buffer, affixPattern.substring (pos, i), localized);
\r
728 }var c = affixPattern.charAt (++i);
\r
732 } else if (c == '\u00a4' && i < affixPattern.length && affixPattern.charAt (i) == '\u00a4') {
\r
735 } else if (localized) {
\r
738 c = this.symbols.getPercent ();
\r
741 c = this.symbols.getPerMill ();
\r
744 c = this.symbols.getMinusSign ();
\r
747 }buffer.append (c);
\r
749 }}, "StringBuffer,~S,~S,~B");
\r
750 Clazz.defineMethod (c$, "appendAffix",
\r
751 function (buffer, affix, localized) {
\r
754 needQuote = affix.indexOf (this.symbols.getZeroDigit ()) >= 0 || affix.indexOf (this.symbols.getGroupingSeparator ()) >= 0 || affix.indexOf (this.symbols.getDecimalSeparator ()) >= 0 || affix.indexOf (this.symbols.getPercent ()) >= 0 || affix.indexOf (this.symbols.getPerMill ()) >= 0 || affix.indexOf (this.symbols.getDigit ()) >= 0 || affix.indexOf (this.symbols.getPatternSeparator ()) >= 0 || affix.indexOf (this.symbols.getMinusSign ()) >= 0 || affix.indexOf ('\u00a4') >= 0;
\r
756 needQuote = affix.indexOf ('0') >= 0 || affix.indexOf (',') >= 0 || affix.indexOf ('.') >= 0 || affix.indexOf ('%') >= 0 || affix.indexOf ('\u2030') >= 0 || affix.indexOf ('#') >= 0 || affix.indexOf (';') >= 0 || affix.indexOf ('-') >= 0 || affix.indexOf ('\u00a4') >= 0;
\r
757 }if (needQuote) buffer.append ('\'');
\r
758 if (affix.indexOf ('\'') < 0) buffer.append (affix);
\r
760 for (var j = 0; j < affix.length; ++j) {
\r
761 var c = affix.charAt (j);
\r
763 if (c == '\'') buffer.append (c);
\r
765 }if (needQuote) buffer.append ('\'');
\r
766 }, "StringBuffer,~S,~B");
\r
767 Clazz.defineMethod (c$, "toPattern",
\r
768 function (localized) {
\r
769 var result = new StringBuffer ();
\r
770 for (var j = 1; j >= 0; --j) {
\r
771 if (j == 1) this.appendAffix (result, this.posPrefixPattern, this.positivePrefix, localized);
\r
772 else this.appendAffix (result, this.negPrefixPattern, this.negativePrefix, localized);
\r
774 var digitCount = this.useExponentialNotation ? this.getMaximumIntegerDigits () : Math.max (this.groupingSize, this.getMinimumIntegerDigits ()) + 1;
\r
775 for (i = digitCount; i > 0; --i) {
\r
776 if (i != digitCount && this.isGroupingUsed () && this.groupingSize != 0 && i % this.groupingSize == 0) {
\r
777 result.append (localized ? this.symbols.getGroupingSeparator () : ',');
\r
778 }result.append (i <= this.getMinimumIntegerDigits () ? (localized ? this.symbols.getZeroDigit () : '0') : (localized ? this.symbols.getDigit () : '#'));
\r
780 if (this.getMaximumFractionDigits () > 0 || this.decimalSeparatorAlwaysShown) result.append (localized ? this.symbols.getDecimalSeparator () : '.');
\r
781 for (i = 0; i < this.getMaximumFractionDigits (); ++i) {
\r
782 if (i < this.getMinimumFractionDigits ()) {
\r
783 result.append (localized ? this.symbols.getZeroDigit () : '0');
\r
785 result.append (localized ? this.symbols.getDigit () : '#');
\r
787 if (this.useExponentialNotation) {
\r
788 result.append (localized ? this.symbols.getExponentSeparator () : "E");
\r
789 for (i = 0; i < this.minExponentDigits; ++i) result.append (localized ? this.symbols.getZeroDigit () : '0');
\r
792 this.appendAffix (result, this.posSuffixPattern, this.positiveSuffix, localized);
\r
793 if ((this.negSuffixPattern === this.posSuffixPattern && this.negativeSuffix.equals (this.positiveSuffix)) || (this.negSuffixPattern != null && this.negSuffixPattern.equals (this.posSuffixPattern))) {
\r
794 if ((this.negPrefixPattern != null && this.posPrefixPattern != null && this.negPrefixPattern.equals ("'-" + this.posPrefixPattern)) || (this.negPrefixPattern === this.posPrefixPattern && this.negativePrefix.equals (this.symbols.getMinusSign () + this.positivePrefix))) break;
\r
795 }result.append (localized ? this.symbols.getPatternSeparator () : ';');
\r
796 } else this.appendAffix (result, this.negSuffixPattern, this.negativeSuffix, localized);
\r
798 return result.toString ();
\r
800 Clazz.defineMethod (c$, "applyPattern",
\r
801 function (pattern) {
\r
802 this.applyPattern (pattern, false);
\r
804 Clazz.defineMethod (c$, "applyLocalizedPattern",
\r
805 function (pattern) {
\r
806 this.applyPattern (pattern, true);
\r
808 Clazz.defineMethod (c$, "applyPattern",
\r
809 function (pattern, localized) {
\r
810 var zeroDigit = '0';
\r
811 var groupingSeparator = ',';
\r
812 var decimalSeparator = '.';
\r
814 var perMill = '\u2030';
\r
816 var separator = ';';
\r
817 var exponent = "E";
\r
820 zeroDigit = this.symbols.getZeroDigit ();
\r
821 groupingSeparator = this.symbols.getGroupingSeparator ();
\r
822 decimalSeparator = this.symbols.getDecimalSeparator ();
\r
823 percent = this.symbols.getPercent ();
\r
824 perMill = this.symbols.getPerMill ();
\r
825 digit = this.symbols.getDigit ();
\r
826 separator = this.symbols.getPatternSeparator ();
\r
827 exponent = this.symbols.getExponentSeparator ();
\r
828 minus = this.symbols.getMinusSign ();
\r
829 }var gotNegative = false;
\r
830 this.decimalSeparatorAlwaysShown = false;
\r
831 this.isCurrencyFormat = false;
\r
832 this.useExponentialNotation = false;
\r
833 var phaseOneLength = 0;
\r
835 for (var j = 1; j >= 0 && start < pattern.length; --j) {
\r
836 var inQuote = false;
\r
837 var prefix = new StringBuffer ();
\r
838 var suffix = new StringBuffer ();
\r
839 var decimalPos = -1;
\r
840 var multiplier = 1;
\r
841 var digitLeftCount = 0;
\r
842 var zeroDigitCount = 0;
\r
843 var digitRightCount = 0;
\r
844 var groupingCount = -1;
\r
846 var affix = prefix;
\r
847 for (var pos = start; pos < pattern.length; ++pos) {
\r
848 var ch = pattern.charAt (pos);
\r
854 if ((pos + 1) < pattern.length && pattern.charAt (pos + 1) == '\'') {
\r
856 affix.append ("''");
\r
861 if (ch == digit || ch == zeroDigit || ch == groupingSeparator || ch == decimalSeparator) {
\r
865 } else if (ch == '\u00a4') {
\r
866 var doubled = (pos + 1) < pattern.length && pattern.charAt (pos + 1) == '\u00a4';
\r
869 }this.isCurrencyFormat = true;
\r
870 affix.append (doubled ? "'\u00A4\u00A4" : "'\u00A4");
\r
872 } else if (ch == '\'') {
\r
874 if ((pos + 1) < pattern.length && pattern.charAt (pos + 1) == '\'') {
\r
876 affix.append ("''");
\r
880 }} else if (ch == separator) {
\r
881 if (phase == 0 || j == 0) {
\r
882 throw new IllegalArgumentException ("Unquoted special character '" + ch + "' in pattern \"" + pattern + '"');
\r
884 pos = pattern.length;
\r
886 } else if (ch == percent) {
\r
887 if (multiplier != 1) {
\r
888 throw new IllegalArgumentException ("Too many percent/per mille characters in pattern \"" + pattern + '"');
\r
890 affix.append ("'%");
\r
892 } else if (ch == perMill) {
\r
893 if (multiplier != 1) {
\r
894 throw new IllegalArgumentException ("Too many percent/per mille characters in pattern \"" + pattern + '"');
\r
895 }multiplier = 1000;
\r
896 affix.append ("'\u2030");
\r
898 } else if (ch == minus) {
\r
899 affix.append ("'-");
\r
901 }}affix.append (ch);
\r
907 if (--phaseOneLength == 0) {
\r
911 }if (ch == digit) {
\r
912 if (zeroDigitCount > 0) {
\r
916 }if (groupingCount >= 0 && decimalPos < 0) {
\r
918 }} else if (ch == zeroDigit) {
\r
919 if (digitRightCount > 0) {
\r
920 throw new IllegalArgumentException ("Unexpected '0' in pattern \"" + pattern + '"');
\r
922 if (groupingCount >= 0 && decimalPos < 0) {
\r
924 }} else if (ch == groupingSeparator) {
\r
926 } else if (ch == decimalSeparator) {
\r
927 if (decimalPos >= 0) {
\r
928 throw new IllegalArgumentException ("Multiple decimal separators in pattern \"" + pattern + '"');
\r
929 }decimalPos = digitLeftCount + zeroDigitCount + digitRightCount;
\r
930 } else if (pattern.regionMatches (pos, exponent, 0, exponent.length)) {
\r
931 if (this.useExponentialNotation) {
\r
932 throw new IllegalArgumentException ("Multiple exponential symbols in pattern \"" + pattern + '"');
\r
933 }this.useExponentialNotation = true;
\r
934 this.minExponentDigits = 0;
\r
935 pos = pos + exponent.length;
\r
936 while (pos < pattern.length && pattern.charAt (pos) == zeroDigit) {
\r
937 ++this.minExponentDigits;
\r
941 if ((digitLeftCount + zeroDigitCount) < 1 || this.minExponentDigits < 1) {
\r
942 throw new IllegalArgumentException ("Malformed exponential pattern \"" + pattern + '"');
\r
956 if (zeroDigitCount == 0 && digitLeftCount > 0 && decimalPos >= 0) {
\r
957 var n = decimalPos;
\r
960 }digitRightCount = digitLeftCount - n;
\r
961 digitLeftCount = n - 1;
\r
962 zeroDigitCount = 1;
\r
963 }if ((decimalPos < 0 && digitRightCount > 0) || (decimalPos >= 0 && (decimalPos < digitLeftCount || decimalPos > (digitLeftCount + zeroDigitCount))) || groupingCount == 0 || inQuote) {
\r
964 throw new IllegalArgumentException ("Malformed pattern \"" + pattern + '"');
\r
966 this.posPrefixPattern = prefix.toString ();
\r
967 this.posSuffixPattern = suffix.toString ();
\r
968 this.negPrefixPattern = this.posPrefixPattern;
\r
969 this.negSuffixPattern = this.posSuffixPattern;
\r
970 var digitTotalCount = digitLeftCount + zeroDigitCount + digitRightCount;
\r
971 var effectiveDecimalPos = decimalPos >= 0 ? decimalPos : digitTotalCount;
\r
972 this.setMinimumIntegerDigits (effectiveDecimalPos - digitLeftCount);
\r
973 this.setMaximumIntegerDigits (this.useExponentialNotation ? digitLeftCount + this.getMinimumIntegerDigits () : 2147483647);
\r
974 this.setMaximumFractionDigits (decimalPos >= 0 ? (digitTotalCount - decimalPos) : 0);
\r
975 this.setMinimumFractionDigits (decimalPos >= 0 ? (digitLeftCount + zeroDigitCount - decimalPos) : 0);
\r
976 this.setGroupingUsed (groupingCount > 0);
\r
977 this.groupingSize = (groupingCount > 0) ? groupingCount : 0;
\r
978 this.multiplier = multiplier;
\r
979 this.setDecimalSeparatorAlwaysShown (decimalPos == 0 || decimalPos == digitTotalCount);
\r
981 this.negPrefixPattern = prefix.toString ();
\r
982 this.negSuffixPattern = suffix.toString ();
\r
983 gotNegative = true;
\r
985 if (pattern.length == 0) {
\r
986 this.posPrefixPattern = this.posSuffixPattern = "";
\r
987 this.setMinimumIntegerDigits (0);
\r
988 this.setMaximumIntegerDigits (2147483647);
\r
989 this.setMinimumFractionDigits (0);
\r
990 this.setMaximumFractionDigits (2147483647);
\r
991 }if (!gotNegative || (this.negPrefixPattern.equals (this.posPrefixPattern) && this.negSuffixPattern.equals (this.posSuffixPattern))) {
\r
992 this.negSuffixPattern = this.posSuffixPattern;
\r
993 this.negPrefixPattern = "'-" + this.posPrefixPattern;
\r
994 }this.expandAffixes ();
\r
996 Clazz.defineMethod (c$, "setMaximumIntegerDigits",
\r
997 function (newValue) {
\r
998 this.$maximumIntegerDigits = Math.min (Math.max (0, newValue), 2147483647);
\r
999 Clazz.superCall (this, java.text.DecimalFormat, "setMaximumIntegerDigits", [(this.$maximumIntegerDigits > 309) ? 309 : this.$maximumIntegerDigits]);
\r
1000 if (this.$minimumIntegerDigits > this.$maximumIntegerDigits) {
\r
1001 this.$minimumIntegerDigits = this.$maximumIntegerDigits;
\r
1002 Clazz.superCall (this, java.text.DecimalFormat, "setMinimumIntegerDigits", [(this.$minimumIntegerDigits > 309) ? 309 : this.$minimumIntegerDigits]);
\r
1004 Clazz.defineMethod (c$, "setMinimumIntegerDigits",
\r
1005 function (newValue) {
\r
1006 this.$minimumIntegerDigits = Math.min (Math.max (0, newValue), 2147483647);
\r
1007 Clazz.superCall (this, java.text.DecimalFormat, "setMinimumIntegerDigits", [(this.$minimumIntegerDigits > 309) ? 309 : this.$minimumIntegerDigits]);
\r
1008 if (this.$minimumIntegerDigits > this.$maximumIntegerDigits) {
\r
1009 this.$maximumIntegerDigits = this.$minimumIntegerDigits;
\r
1010 Clazz.superCall (this, java.text.DecimalFormat, "setMaximumIntegerDigits", [(this.$maximumIntegerDigits > 309) ? 309 : this.$maximumIntegerDigits]);
\r
1012 Clazz.defineMethod (c$, "setMaximumFractionDigits",
\r
1013 function (newValue) {
\r
1014 this.$maximumFractionDigits = Math.min (Math.max (0, newValue), 2147483647);
\r
1015 Clazz.superCall (this, java.text.DecimalFormat, "setMaximumFractionDigits", [(this.$maximumFractionDigits > 340) ? 340 : this.$maximumFractionDigits]);
\r
1016 if (this.$minimumFractionDigits > this.$maximumFractionDigits) {
\r
1017 this.$minimumFractionDigits = this.$maximumFractionDigits;
\r
1018 Clazz.superCall (this, java.text.DecimalFormat, "setMinimumFractionDigits", [(this.$minimumFractionDigits > 340) ? 340 : this.$minimumFractionDigits]);
\r
1020 Clazz.defineMethod (c$, "setMinimumFractionDigits",
\r
1021 function (newValue) {
\r
1022 this.$minimumFractionDigits = Math.min (Math.max (0, newValue), 2147483647);
\r
1023 Clazz.superCall (this, java.text.DecimalFormat, "setMinimumFractionDigits", [(this.$minimumFractionDigits > 340) ? 340 : this.$minimumFractionDigits]);
\r
1024 if (this.$minimumFractionDigits > this.$maximumFractionDigits) {
\r
1025 this.$maximumFractionDigits = this.$minimumFractionDigits;
\r
1026 Clazz.superCall (this, java.text.DecimalFormat, "setMaximumFractionDigits", [(this.$maximumFractionDigits > 340) ? 340 : this.$maximumFractionDigits]);
\r
1028 Clazz.defineMethod (c$, "getMaximumIntegerDigits",
\r
1030 return this.$maximumIntegerDigits;
\r
1032 Clazz.defineMethod (c$, "getMinimumIntegerDigits",
\r
1034 return this.$minimumIntegerDigits;
\r
1036 Clazz.defineMethod (c$, "getMaximumFractionDigits",
\r
1038 return this.$maximumFractionDigits;
\r
1040 Clazz.defineMethod (c$, "getMinimumFractionDigits",
\r
1042 return this.$minimumFractionDigits;
\r
1044 Clazz.overrideMethod (c$, "getRoundingMode",
\r
1046 return this.roundingMode;
\r
1048 Clazz.overrideMethod (c$, "setRoundingMode",
\r
1049 function (roundingMode) {
\r
1050 if (roundingMode == null) {
\r
1051 throw new NullPointerException ();
\r
1052 }this.roundingMode = roundingMode;
\r
1053 this.digitList.setRoundingMode (roundingMode);
\r
1054 }, "java.math.RoundingMode");
\r
1055 Clazz.defineMethod (c$, "adjustForCurrencyDefaultFractionDigits",
\r
1058 var oldMinDigits = this.getMinimumFractionDigits ();
\r
1059 if (oldMinDigits == this.getMaximumFractionDigits ()) {
\r
1060 this.setMinimumFractionDigits (digits);
\r
1061 this.setMaximumFractionDigits (digits);
\r
1063 this.setMinimumFractionDigits (Math.min (digits, oldMinDigits));
\r
1064 this.setMaximumFractionDigits (digits);
\r
1066 Clazz.defineStatics (c$,
\r
1067 "STATUS_INFINITE", 0,
\r
1068 "STATUS_POSITIVE", 1,
\r
1069 "STATUS_LENGTH", 2,
\r
1070 "PATTERN_ZERO_DIGIT", '0',
\r
1071 "PATTERN_GROUPING_SEPARATOR", ',',
\r
1072 "PATTERN_DECIMAL_SEPARATOR", '.',
\r
1073 "PATTERN_PER_MILLE", '\u2030',
\r
1074 "PATTERN_PERCENT", '%',
\r
1075 "PATTERN_DIGIT", '#',
\r
1076 "PATTERN_SEPARATOR", ';',
\r
1077 "PATTERN_EXPONENT", "E",
\r
1078 "PATTERN_MINUS", '-',
\r
1079 "CURRENCY_SIGN", '\u00A4',
\r
1081 c$.EmptyFieldPositionArray = c$.prototype.EmptyFieldPositionArray = new Array (0);
\r
1082 Clazz.defineStatics (c$,
\r
1083 "DOUBLE_INTEGER_DIGITS", 309,
\r
1084 "DOUBLE_FRACTION_DIGITS", 340,
\r
1085 "MAXIMUM_INTEGER_DIGITS", 2147483647,
\r
1086 "MAXIMUM_FRACTION_DIGITS", 2147483647);
\r
1087 c$.$cachedLocaleData = c$.prototype.$cachedLocaleData = new java.util.Hashtable (3);
\r