home *** CD-ROM | disk | FTP | other *** search
/ S283 Planetary Science &n…he Search for Life DVD 2 / DVD-ROM.iso / install / jre1_3 / lib / rt.jar / java / text / DecimalFormat.class (.txt) < prev    next >
Encoding:
Java Class File  |  1979-12-31  |  14.0 KB  |  1,091 lines
  1. package java.text;
  2.  
  3. import java.io.IOException;
  4. import java.io.InvalidObjectException;
  5. import java.io.ObjectInputStream;
  6. import java.util.Hashtable;
  7. import java.util.Locale;
  8. import java.util.ResourceBundle;
  9.  
  10. public class DecimalFormat extends NumberFormat {
  11.    private static final int STATUS_INFINITE = 0;
  12.    private static final int STATUS_POSITIVE = 1;
  13.    private static final int STATUS_LENGTH = 2;
  14.    private transient DigitList digitList = new DigitList();
  15.    private String positivePrefix = "";
  16.    private String positiveSuffix = "";
  17.    private String negativePrefix = "-";
  18.    private String negativeSuffix = "";
  19.    private String posPrefixPattern;
  20.    private String posSuffixPattern;
  21.    private String negPrefixPattern;
  22.    private String negSuffixPattern;
  23.    private int multiplier = 1;
  24.    private byte groupingSize = 3;
  25.    private boolean decimalSeparatorAlwaysShown = false;
  26.    private transient boolean isCurrencyFormat = false;
  27.    private DecimalFormatSymbols symbols = null;
  28.    private boolean useExponentialNotation;
  29.    private byte minExponentDigits;
  30.    static final int currentSerialVersion = 2;
  31.    private int serialVersionOnStream = 2;
  32.    private static final char PATTERN_ZERO_DIGIT = '0';
  33.    private static final char PATTERN_GROUPING_SEPARATOR = ',';
  34.    private static final char PATTERN_DECIMAL_SEPARATOR = '.';
  35.    private static final char PATTERN_PER_MILLE = 'ΓÇ░';
  36.    private static final char PATTERN_PERCENT = '%';
  37.    private static final char PATTERN_DIGIT = '#';
  38.    private static final char PATTERN_SEPARATOR = ';';
  39.    private static final char PATTERN_EXPONENT = 'E';
  40.    private static final char PATTERN_MINUS = '-';
  41.    private static final char CURRENCY_SIGN = '┬ñ';
  42.    private static final char QUOTE = '\'';
  43.    static final int DOUBLE_INTEGER_DIGITS = 309;
  44.    static final int DOUBLE_FRACTION_DIGITS = 340;
  45.    static final long serialVersionUID = 864413376551465018L;
  46.    private static Hashtable cachedLocaleData = new Hashtable(3);
  47.  
  48.    public DecimalFormat() {
  49.       Locale var1 = Locale.getDefault();
  50.       String var2 = (String)cachedLocaleData.get(var1);
  51.       if (var2 == null) {
  52.          ResourceBundle var3 = ResourceBundle.getBundle("java.text.resources.LocaleElements", var1);
  53.          String[] var4 = var3.getStringArray("NumberPatterns");
  54.          var2 = var4[0];
  55.          cachedLocaleData.put(var1, var2);
  56.       }
  57.  
  58.       this.symbols = new DecimalFormatSymbols(var1);
  59.       this.applyPattern(var2, false);
  60.    }
  61.  
  62.    public DecimalFormat(String var1) {
  63.       this.symbols = new DecimalFormatSymbols(Locale.getDefault());
  64.       this.applyPattern(var1, false);
  65.    }
  66.  
  67.    public DecimalFormat(String var1, DecimalFormatSymbols var2) {
  68.       this.symbols = (DecimalFormatSymbols)var2.clone();
  69.       this.applyPattern(var1, false);
  70.    }
  71.  
  72.    public StringBuffer format(double var1, StringBuffer var3, FieldPosition var4) {
  73.       var4.setBeginIndex(0);
  74.       var4.setEndIndex(0);
  75.       if (Double.isNaN(var1)) {
  76.          if (var4.getField() == 0) {
  77.             var4.setBeginIndex(var3.length());
  78.          }
  79.  
  80.          var3.append(this.symbols.getNaN());
  81.          if (var4.getField() == 0) {
  82.             var4.setEndIndex(var3.length());
  83.          }
  84.  
  85.          return var3;
  86.       } else {
  87.          boolean var5 = var1 < (double)0.0F || var1 == (double)0.0F && (double)1.0F / var1 < (double)0.0F;
  88.          if (var5) {
  89.             var1 = -var1;
  90.          }
  91.  
  92.          if (this.multiplier != 1) {
  93.             var1 *= (double)this.multiplier;
  94.          }
  95.  
  96.          if (Double.isInfinite(var1)) {
  97.             var3.append(var5 ? this.negativePrefix : this.positivePrefix);
  98.             if (var4.getField() == 0) {
  99.                var4.setBeginIndex(var3.length());
  100.             }
  101.  
  102.             var3.append(this.symbols.getInfinity());
  103.             if (var4.getField() == 0) {
  104.                var4.setEndIndex(var3.length());
  105.             }
  106.  
  107.             var3.append(var5 ? this.negativeSuffix : this.positiveSuffix);
  108.             return var3;
  109.          } else {
  110.             DigitList var6 = this.digitList;
  111.             synchronized(var6) {
  112.                this.digitList.set(var1, this.useExponentialNotation ? ((NumberFormat)this).getMaximumIntegerDigits() + ((NumberFormat)this).getMaximumFractionDigits() : ((NumberFormat)this).getMaximumFractionDigits(), !this.useExponentialNotation);
  113.                StringBuffer var7 = this.subformat(var3, var4, var5, false);
  114.                return var7;
  115.             }
  116.          }
  117.       }
  118.    }
  119.  
  120.    public StringBuffer format(long var1, StringBuffer var3, FieldPosition var4) {
  121.       var4.setBeginIndex(0);
  122.       var4.setEndIndex(0);
  123.       boolean var5 = var1 < 0L;
  124.       if (var5) {
  125.          var1 = -var1;
  126.       }
  127.  
  128.       if (this.multiplier != 1 && this.multiplier != 0) {
  129.          boolean var6 = false;
  130.          if (var1 < 0L) {
  131.             long var7 = Long.MIN_VALUE / (long)this.multiplier;
  132.             var6 = var1 < var7;
  133.          } else {
  134.             long var14 = Long.MAX_VALUE / (long)this.multiplier;
  135.             var6 = var1 > var14;
  136.          }
  137.  
  138.          if (var6) {
  139.             double var16 = var5 ? (double)(-var1) : (double)var1;
  140.             return this.format(var16, var3, var4);
  141.          }
  142.       }
  143.  
  144.       var1 *= (long)this.multiplier;
  145.       DigitList var13 = this.digitList;
  146.       synchronized(var13) {
  147.          this.digitList.set(var1, this.useExponentialNotation ? ((NumberFormat)this).getMaximumIntegerDigits() + ((NumberFormat)this).getMaximumFractionDigits() : 0);
  148.          StringBuffer var15 = this.subformat(var3, var4, var5, true);
  149.          return var15;
  150.       }
  151.    }
  152.  
  153.    private StringBuffer subformat(StringBuffer var1, FieldPosition var2, boolean var3, boolean var4) {
  154.       char var5 = this.symbols.getZeroDigit();
  155.       int var6 = var5 - 48;
  156.       char var7 = this.symbols.getGroupingSeparator();
  157.       char var8 = this.isCurrencyFormat ? this.symbols.getMonetaryDecimalSeparator() : this.symbols.getDecimalSeparator();
  158.       if (this.digitList.isZero()) {
  159.          this.digitList.decimalAt = 0;
  160.       }
  161.  
  162.       var1.append(var3 ? this.negativePrefix : this.positivePrefix);
  163.       if (this.useExponentialNotation) {
  164.          if (var2.getField() == 0) {
  165.             var2.setBeginIndex(var1.length());
  166.             var2.setEndIndex(-1);
  167.          } else if (var2.getField() == 1) {
  168.             var2.setBeginIndex(-1);
  169.          }
  170.  
  171.          int var9 = this.digitList.decimalAt;
  172.          int var10 = ((NumberFormat)this).getMaximumIntegerDigits();
  173.          if (var10 > 1 && var10 != ((NumberFormat)this).getMinimumIntegerDigits()) {
  174.             var9 -= var9 < 0 ? var10 : 1;
  175.             var9 = var9 / var10 * var10;
  176.          } else {
  177.             var9 -= ((NumberFormat)this).getMinimumIntegerDigits();
  178.          }
  179.  
  180.          int var11 = ((NumberFormat)this).getMinimumIntegerDigits() + ((NumberFormat)this).getMinimumFractionDigits();
  181.          int var12 = this.digitList.isZero() ? ((NumberFormat)this).getMinimumIntegerDigits() : this.digitList.decimalAt - var9;
  182.          int var13 = this.digitList.count;
  183.          if (var11 > var13) {
  184.             var13 = var11;
  185.          }
  186.  
  187.          for(int var14 = 0; var14 < var13; ++var14) {
  188.             if (var14 == var12) {
  189.                if (var2.getField() == 0) {
  190.                   var2.setEndIndex(var1.length());
  191.                }
  192.  
  193.                var1.append(var8);
  194.                if (var2.getField() == 1) {
  195.                   var2.setBeginIndex(var1.length());
  196.                }
  197.             }
  198.  
  199.             var1.append(var14 < this.digitList.count ? (char)(this.digitList.digits[var14] + var6) : var5);
  200.          }
  201.  
  202.          if (var2.getField() == 0) {
  203.             if (var2.getEndIndex() < 0) {
  204.                var2.setEndIndex(var1.length());
  205.             }
  206.          } else if (var2.getField() == 1) {
  207.             if (var2.getBeginIndex() < 0) {
  208.                var2.setBeginIndex(var1.length());
  209.             }
  210.  
  211.             var2.setEndIndex(var1.length());
  212.          }
  213.  
  214.          var1.append(this.symbols.getExponentialSymbol());
  215.          if (this.digitList.isZero()) {
  216.             var9 = 0;
  217.          }
  218.  
  219.          boolean var15 = var9 < 0;
  220.          if (var15) {
  221.             var9 = -var9;
  222.          }
  223.  
  224.          var1.append(var15 ? this.negativePrefix : this.positivePrefix);
  225.          this.digitList.set((long)var9);
  226.  
  227.          for(int var16 = this.digitList.decimalAt; var16 < this.minExponentDigits; ++var16) {
  228.             var1.append(var5);
  229.          }
  230.  
  231.          for(int var17 = 0; var17 < this.digitList.decimalAt; ++var17) {
  232.             var1.append(var17 < this.digitList.count ? (char)(this.digitList.digits[var17] + var6) : var5);
  233.          }
  234.  
  235.          var1.append(var15 ? this.negativeSuffix : this.positiveSuffix);
  236.       } else {
  237.          if (var2.getField() == 0) {
  238.             var2.setBeginIndex(var1.length());
  239.          }
  240.  
  241.          int var20 = ((NumberFormat)this).getMinimumIntegerDigits();
  242.          int var21 = 0;
  243.          if (this.digitList.decimalAt > 0 && var20 < this.digitList.decimalAt) {
  244.             var20 = this.digitList.decimalAt;
  245.          }
  246.  
  247.          if (var20 > ((NumberFormat)this).getMaximumIntegerDigits()) {
  248.             var20 = ((NumberFormat)this).getMaximumIntegerDigits();
  249.             var21 = this.digitList.decimalAt - var20;
  250.          }
  251.  
  252.          int var22 = var1.length();
  253.  
  254.          for(int var23 = var20 - 1; var23 >= 0; --var23) {
  255.             if (var23 < this.digitList.decimalAt && var21 < this.digitList.count) {
  256.                var1.append((char)(this.digitList.digits[var21++] + var6));
  257.             } else {
  258.                var1.append(var5);
  259.             }
  260.  
  261.             if (((NumberFormat)this).isGroupingUsed() && var23 > 0 && this.groupingSize != 0 && var23 % this.groupingSize == 0) {
  262.                var1.append(var7);
  263.             }
  264.          }
  265.  
  266.          if (var2.getField() == 0) {
  267.             var2.setEndIndex(var1.length());
  268.          }
  269.  
  270.          boolean var24 = ((NumberFormat)this).getMinimumFractionDigits() > 0 || !var4 && var21 < this.digitList.count;
  271.          if (!var24 && var1.length() == var22) {
  272.             var1.append(var5);
  273.          }
  274.  
  275.          if (this.decimalSeparatorAlwaysShown || var24) {
  276.             var1.append(var8);
  277.          }
  278.  
  279.          if (var2.getField() == 1) {
  280.             var2.setBeginIndex(var1.length());
  281.          }
  282.  
  283.          for(int var25 = 0; var25 < ((NumberFormat)this).getMaximumFractionDigits() && (var25 < ((NumberFormat)this).getMinimumFractionDigits() || !var4 && var21 < this.digitList.count); ++var25) {
  284.             if (-1 - var25 > this.digitList.decimalAt - 1) {
  285.                var1.append(var5);
  286.             } else if (!var4 && var21 < this.digitList.count) {
  287.                var1.append((char)(this.digitList.digits[var21++] + var6));
  288.             } else {
  289.                var1.append(var5);
  290.             }
  291.          }
  292.  
  293.          if (var2.getField() == 1) {
  294.             var2.setEndIndex(var1.length());
  295.          }
  296.       }
  297.  
  298.       var1.append(var3 ? this.negativeSuffix : this.positiveSuffix);
  299.       return var1;
  300.    }
  301.  
  302.    public Number parse(String var1, ParsePosition var2) {
  303.       if (var1.regionMatches(var2.index, this.symbols.getNaN(), 0, this.symbols.getNaN().length())) {
  304.          var2.index += this.symbols.getNaN().length();
  305.          return new Double(Double.NaN);
  306.       } else {
  307.          boolean[] var3 = new boolean[2];
  308.          if (!this.subparse(var1, var2, this.digitList, false, var3)) {
  309.             return null;
  310.          } else {
  311.             double var4 = (double)0.0F;
  312.             long var6 = 0L;
  313.             boolean var8 = true;
  314.             if (var3[0]) {
  315.                var4 = Double.POSITIVE_INFINITY;
  316.             } else if (this.digitList.fitsIntoLong(var3[1], ((NumberFormat)this).isParseIntegerOnly())) {
  317.                var8 = false;
  318.                var6 = this.digitList.getLong();
  319.             } else {
  320.                var4 = this.digitList.getDouble();
  321.             }
  322.  
  323.             if (this.multiplier != 1) {
  324.                if (var8) {
  325.                   var4 /= (double)this.multiplier;
  326.                } else if (var6 % (long)this.multiplier == 0L) {
  327.                   var6 /= (long)this.multiplier;
  328.                } else {
  329.                   var4 = (double)var6 / (double)this.multiplier;
  330.                   if (var4 < (double)0.0F) {
  331.                      var4 = -var4;
  332.                   }
  333.  
  334.                   var8 = true;
  335.                }
  336.             }
  337.  
  338.             if (!var3[1]) {
  339.                var4 = -var4;
  340.                if (var6 > 0L) {
  341.                   var6 = -var6;
  342.                }
  343.             }
  344.  
  345.             if (this.multiplier != 1 && var8) {
  346.                var6 = (long)var4;
  347.                var8 = var4 != (double)var6 || var4 == (double)0.0F && !var3[1] && !((NumberFormat)this).isParseIntegerOnly();
  348.             }
  349.  
  350.             return (Number)(var8 ? new Double(var4) : new Long(var6));
  351.          }
  352.       }
  353.    }
  354.  
  355.    private final boolean subparse(String var1, ParsePosition var2, DigitList var3, boolean var4, boolean[] var5) {
  356.       int var6 = var2.index;
  357.       int var7 = var2.index;
  358.       boolean var9 = var1.regionMatches(var6, this.positivePrefix, 0, this.positivePrefix.length());
  359.       boolean var10 = var1.regionMatches(var6, this.negativePrefix, 0, this.negativePrefix.length());
  360.       if (var9 && var10) {
  361.          if (this.positivePrefix.length() > this.negativePrefix.length()) {
  362.             var10 = false;
  363.          } else if (this.positivePrefix.length() < this.negativePrefix.length()) {
  364.             var9 = false;
  365.          }
  366.       }
  367.  
  368.       if (var9) {
  369.          var6 += this.positivePrefix.length();
  370.       } else {
  371.          if (!var10) {
  372.             var2.errorIndex = var6;
  373.             return false;
  374.          }
  375.  
  376.          var6 += this.negativePrefix.length();
  377.       }
  378.  
  379.       var5[0] = false;
  380.       if (!var4 && var1.regionMatches(var6, this.symbols.getInfinity(), 0, this.symbols.getInfinity().length())) {
  381.          var6 += this.symbols.getInfinity().length();
  382.          var5[0] = true;
  383.       } else {
  384.          var3.decimalAt = var3.count = 0;
  385.          char var11 = this.symbols.getZeroDigit();
  386.          char var12 = this.isCurrencyFormat ? this.symbols.getMonetaryDecimalSeparator() : this.symbols.getDecimalSeparator();
  387.          char var13 = this.symbols.getGroupingSeparator();
  388.          char var14 = this.symbols.getExponentialSymbol();
  389.          boolean var15 = false;
  390.          boolean var16 = false;
  391.          boolean var17 = false;
  392.          int var18 = 0;
  393.          int var19 = 0;
  394.  
  395.          int var8;
  396.          for(var8 = -1; var6 < var1.length(); ++var6) {
  397.             char var20 = var1.charAt(var6);
  398.             int var21 = var20 - var11;
  399.             if (var21 < 0 || var21 > 9) {
  400.                var21 = Character.digit(var20, 10);
  401.             }
  402.  
  403.             if (var21 == 0) {
  404.                var8 = -1;
  405.                var17 = true;
  406.                if (var3.count == 0) {
  407.                   if (var15) {
  408.                      --var3.decimalAt;
  409.                   }
  410.                } else {
  411.                   ++var19;
  412.                   var3.append((char)(var21 + 48));
  413.                }
  414.             } else if (var21 > 0 && var21 <= 9) {
  415.                var17 = true;
  416.                ++var19;
  417.                var3.append((char)(var21 + 48));
  418.                var8 = -1;
  419.             } else if (!var4 && var20 == var12) {
  420.                if (((NumberFormat)this).isParseIntegerOnly() || var15) {
  421.                   break;
  422.                }
  423.  
  424.                var3.decimalAt = var19;
  425.                var15 = true;
  426.             } else {
  427.                if (var4 || var20 != var13 || !((NumberFormat)this).isGroupingUsed()) {
  428.                   if (!var4 && var20 == var14 && !var16) {
  429.                      ParsePosition var22 = new ParsePosition(var6 + 1);
  430.                      boolean[] var23 = new boolean[2];
  431.                      DigitList var24 = new DigitList();
  432.                      if (this.subparse(var1, var22, var24, true, var23) && var24.fitsIntoLong(var23[1], true)) {
  433.                         var6 = var22.index;
  434.                         var18 = (int)var24.getLong();
  435.                         if (!var23[1]) {
  436.                            var18 = -var18;
  437.                         }
  438.  
  439.                         var16 = true;
  440.                      }
  441.                   }
  442.                   break;
  443.                }
  444.  
  445.                if (var15) {
  446.                   break;
  447.                }
  448.  
  449.                var8 = var6;
  450.             }
  451.          }
  452.  
  453.          if (var8 != -1) {
  454.             var6 = var8;
  455.          }
  456.  
  457.          if (!var15) {
  458.             var3.decimalAt = var19;
  459.          }
  460.  
  461.          var3.decimalAt += var18;
  462.          if (!var17 && var19 == 0) {
  463.             var2.index = var7;
  464.             var2.errorIndex = var7;
  465.             return false;
  466.          }
  467.       }
  468.  
  469.       if (var9) {
  470.          var9 = var1.regionMatches(var6, this.positiveSuffix, 0, this.positiveSuffix.length());
  471.       }
  472.  
  473.       if (var10) {
  474.          var10 = var1.regionMatches(var6, this.negativeSuffix, 0, this.negativeSuffix.length());
  475.       }
  476.  
  477.       if (var9 && var10) {
  478.          if (this.positiveSuffix.length() > this.negativeSuffix.length()) {
  479.             var10 = false;
  480.          } else if (this.positiveSuffix.length() < this.negativeSuffix.length()) {
  481.             var9 = false;
  482.          }
  483.       }
  484.  
  485.       if (var9 == var10) {
  486.          var2.errorIndex = var6;
  487.          return false;
  488.       } else {
  489.          var2.index = var6 + (var9 ? this.positiveSuffix.length() : this.negativeSuffix.length());
  490.          var5[1] = var9;
  491.          if (var2.index == var7) {
  492.             var2.errorIndex = var6;
  493.             return false;
  494.          } else {
  495.             return true;
  496.          }
  497.       }
  498.    }
  499.  
  500.    public DecimalFormatSymbols getDecimalFormatSymbols() {
  501.       try {
  502.          return (DecimalFormatSymbols)this.symbols.clone();
  503.       } catch (Exception var2) {
  504.          return null;
  505.       }
  506.    }
  507.  
  508.    public void setDecimalFormatSymbols(DecimalFormatSymbols var1) {
  509.       try {
  510.          this.symbols = (DecimalFormatSymbols)var1.clone();
  511.          this.expandAffixes();
  512.       } catch (Exception var3) {
  513.       }
  514.  
  515.    }
  516.  
  517.    public String getPositivePrefix() {
  518.       return this.positivePrefix;
  519.    }
  520.  
  521.    public void setPositivePrefix(String var1) {
  522.       this.positivePrefix = var1;
  523.       this.posPrefixPattern = null;
  524.    }
  525.  
  526.    public String getNegativePrefix() {
  527.       return this.negativePrefix;
  528.    }
  529.  
  530.    public void setNegativePrefix(String var1) {
  531.       this.negativePrefix = var1;
  532.       this.negPrefixPattern = null;
  533.    }
  534.  
  535.    public String getPositiveSuffix() {
  536.       return this.positiveSuffix;
  537.    }
  538.  
  539.    public void setPositiveSuffix(String var1) {
  540.       this.positiveSuffix = var1;
  541.       this.posSuffixPattern = null;
  542.    }
  543.  
  544.    public String getNegativeSuffix() {
  545.       return this.negativeSuffix;
  546.    }
  547.  
  548.    public void setNegativeSuffix(String var1) {
  549.       this.negativeSuffix = var1;
  550.       this.negSuffixPattern = null;
  551.    }
  552.  
  553.    public int getMultiplier() {
  554.       return this.multiplier;
  555.    }
  556.  
  557.    public void setMultiplier(int var1) {
  558.       this.multiplier = var1;
  559.    }
  560.  
  561.    public int getGroupingSize() {
  562.       return this.groupingSize;
  563.    }
  564.  
  565.    public void setGroupingSize(int var1) {
  566.       this.groupingSize = (byte)var1;
  567.    }
  568.  
  569.    public boolean isDecimalSeparatorAlwaysShown() {
  570.       return this.decimalSeparatorAlwaysShown;
  571.    }
  572.  
  573.    public void setDecimalSeparatorAlwaysShown(boolean var1) {
  574.       this.decimalSeparatorAlwaysShown = var1;
  575.    }
  576.  
  577.    public Object clone() {
  578.       try {
  579.          DecimalFormat var1 = (DecimalFormat)super.clone();
  580.          var1.symbols = (DecimalFormatSymbols)this.symbols.clone();
  581.          return var1;
  582.       } catch (Exception var2) {
  583.          throw new InternalError();
  584.       }
  585.    }
  586.  
  587.    public boolean equals(Object var1) {
  588.       if (var1 == null) {
  589.          return false;
  590.       } else if (!super.equals(var1)) {
  591.          return false;
  592.       } else {
  593.          DecimalFormat var2 = (DecimalFormat)var1;
  594.          return (this.posPrefixPattern == var2.posPrefixPattern && this.positivePrefix.equals(var2.positivePrefix) || this.posPrefixPattern != null && this.posPrefixPattern.equals(var2.posPrefixPattern)) && (this.posSuffixPattern == var2.posSuffixPattern && this.positiveSuffix.equals(var2.positiveSuffix) || this.posSuffixPattern != null && this.posSuffixPattern.equals(var2.posSuffixPattern)) && (this.negPrefixPattern == var2.negPrefixPattern && this.negativePrefix.equals(var2.negativePrefix) || this.negPrefixPattern != null && this.negPrefixPattern.equals(var2.negPrefixPattern)) && (this.negSuffixPattern == var2.negSuffixPattern && this.negativeSuffix.equals(var2.negativeSuffix) || this.negSuffixPattern != null && this.negSuffixPattern.equals(var2.negSuffixPattern)) && this.multiplier == var2.multiplier && this.groupingSize == var2.groupingSize && this.decimalSeparatorAlwaysShown == var2.decimalSeparatorAlwaysShown && this.useExponentialNotation == var2.useExponentialNotation && (!this.useExponentialNotation || this.minExponentDigits == var2.minExponentDigits) && this.symbols.equals(var2.symbols);
  595.       }
  596.    }
  597.  
  598.    public int hashCode() {
  599.       return super.hashCode() * 37 + this.positivePrefix.hashCode();
  600.    }
  601.  
  602.    public String toPattern() {
  603.       return this.toPattern(false);
  604.    }
  605.  
  606.    public String toLocalizedPattern() {
  607.       return this.toPattern(true);
  608.    }
  609.  
  610.    private void expandAffixes() {
  611.       StringBuffer var1 = new StringBuffer();
  612.       if (this.posPrefixPattern != null) {
  613.          this.positivePrefix = this.expandAffix(this.posPrefixPattern, var1);
  614.       }
  615.  
  616.       if (this.posSuffixPattern != null) {
  617.          this.positiveSuffix = this.expandAffix(this.posSuffixPattern, var1);
  618.       }
  619.  
  620.       if (this.negPrefixPattern != null) {
  621.          this.negativePrefix = this.expandAffix(this.negPrefixPattern, var1);
  622.       }
  623.  
  624.       if (this.negSuffixPattern != null) {
  625.          this.negativeSuffix = this.expandAffix(this.negSuffixPattern, var1);
  626.       }
  627.  
  628.    }
  629.  
  630.    private String expandAffix(String var1, StringBuffer var2) {
  631.       var2.setLength(0);
  632.       int var3 = 0;
  633.  
  634.       while(var3 < var1.length()) {
  635.          char var4 = var1.charAt(var3++);
  636.          if (var4 == '\'') {
  637.             var4 = var1.charAt(var3++);
  638.             switch (var4) {
  639.                case '%':
  640.                   var4 = this.symbols.getPercent();
  641.                   break;
  642.                case '-':
  643.                   var4 = this.symbols.getMinusSign();
  644.                   break;
  645.                case '┬ñ':
  646.                   if (var3 < var1.length() && var1.charAt(var3) == 164) {
  647.                      ++var3;
  648.                      var2.append(this.symbols.getInternationalCurrencySymbol());
  649.                      continue;
  650.                   }
  651.  
  652.                   var2.append(this.symbols.getCurrencySymbol());
  653.                   continue;
  654.                case 'ΓÇ░':
  655.                   var4 = this.symbols.getPerMill();
  656.             }
  657.          }
  658.  
  659.          var2.append(var4);
  660.       }
  661.  
  662.       return var2.toString();
  663.    }
  664.  
  665.    private void appendAffix(StringBuffer var1, String var2, String var3, boolean var4) {
  666.       int var5;
  667.       if (var2 == null) {
  668.          this.appendAffix(var1, var3, var4);
  669.       } else {
  670.          for(int var6 = 0; var6 < var2.length(); var6 = var5) {
  671.             var5 = var2.indexOf(39, var6);
  672.             if (var5 < 0) {
  673.                this.appendAffix(var1, var2.substring(var6), var4);
  674.                break;
  675.             }
  676.  
  677.             if (var5 > var6) {
  678.                this.appendAffix(var1, var2.substring(var6, var5), var4);
  679.             }
  680.  
  681.             ++var5;
  682.             char var7 = var2.charAt(var5);
  683.             ++var5;
  684.             if (var7 == '\'') {
  685.                var1.append(var7);
  686.             } else if (var7 == 164 && var5 < var2.length() && var2.charAt(var5) == 164) {
  687.                ++var5;
  688.                var1.append(var7);
  689.             } else if (var4) {
  690.                switch (var7) {
  691.                   case '%':
  692.                      var7 = this.symbols.getPercent();
  693.                      break;
  694.                   case '-':
  695.                      var7 = this.symbols.getMinusSign();
  696.                      break;
  697.                   case 'ΓÇ░':
  698.                      var7 = this.symbols.getPerMill();
  699.                }
  700.             }
  701.  
  702.             var1.append(var7);
  703.          }
  704.       }
  705.  
  706.    }
  707.  
  708.    private void appendAffix(StringBuffer var1, String var2, boolean var3) {
  709.       boolean var4;
  710.       if (var3) {
  711.          var4 = var2.indexOf(this.symbols.getZeroDigit()) >= 0 || var2.indexOf(this.symbols.getGroupingSeparator()) >= 0 || var2.indexOf(this.symbols.getDecimalSeparator()) >= 0 || var2.indexOf(this.symbols.getPercent()) >= 0 || var2.indexOf(this.symbols.getPerMill()) >= 0 || var2.indexOf(this.symbols.getDigit()) >= 0 || var2.indexOf(this.symbols.getPatternSeparator()) >= 0 || var2.indexOf(this.symbols.getMinusSign()) >= 0 || var2.indexOf(164) >= 0;
  712.       } else {
  713.          var4 = var2.indexOf(48) >= 0 || var2.indexOf(44) >= 0 || var2.indexOf(46) >= 0 || var2.indexOf(37) >= 0 || var2.indexOf(8240) >= 0 || var2.indexOf(35) >= 0 || var2.indexOf(59) >= 0 || var2.indexOf(45) >= 0 || var2.indexOf(164) >= 0;
  714.       }
  715.  
  716.       if (var4) {
  717.          var1.append('\'');
  718.       }
  719.  
  720.       if (var2.indexOf(39) < 0) {
  721.          var1.append(var2);
  722.       } else {
  723.          for(int var5 = 0; var5 < var2.length(); ++var5) {
  724.             char var6 = var2.charAt(var5);
  725.             var1.append(var6);
  726.             if (var6 == '\'') {
  727.                var1.append(var6);
  728.             }
  729.          }
  730.       }
  731.  
  732.       if (var4) {
  733.          var1.append('\'');
  734.       }
  735.  
  736.    }
  737.  
  738.    private String toPattern(boolean var1) {
  739.       StringBuffer var2 = new StringBuffer();
  740.  
  741.       for(int var3 = 1; var3 >= 0; --var3) {
  742.          if (var3 == 1) {
  743.             this.appendAffix(var2, this.posPrefixPattern, this.positivePrefix, var1);
  744.          } else {
  745.             this.appendAffix(var2, this.negPrefixPattern, this.negativePrefix, var1);
  746.          }
  747.  
  748.          int var5 = this.useExponentialNotation ? ((NumberFormat)this).getMaximumIntegerDigits() : Math.max(this.groupingSize, ((NumberFormat)this).getMinimumIntegerDigits()) + 1;
  749.  
  750.          for(int var4 = var5; var4 > 0; --var4) {
  751.             if (var4 != var5 && ((NumberFormat)this).isGroupingUsed() && this.groupingSize != 0 && var4 % this.groupingSize == 0) {
  752.                var2.append(var1 ? this.symbols.getGroupingSeparator() : ',');
  753.             }
  754.  
  755.             var2.append(var4 <= ((NumberFormat)this).getMinimumIntegerDigits() ? (var1 ? this.symbols.getZeroDigit() : '0') : (var1 ? this.symbols.getDigit() : '#'));
  756.          }
  757.  
  758.          if (((NumberFormat)this).getMaximumFractionDigits() > 0 || this.decimalSeparatorAlwaysShown) {
  759.             var2.append(var1 ? this.symbols.getDecimalSeparator() : '.');
  760.          }
  761.  
  762.          for(int var6 = 0; var6 < ((NumberFormat)this).getMaximumFractionDigits(); ++var6) {
  763.             if (var6 < ((NumberFormat)this).getMinimumFractionDigits()) {
  764.                var2.append(var1 ? this.symbols.getZeroDigit() : '0');
  765.             } else {
  766.                var2.append(var1 ? this.symbols.getDigit() : '#');
  767.             }
  768.          }
  769.  
  770.          if (this.useExponentialNotation) {
  771.             var2.append(var1 ? this.symbols.getExponentialSymbol() : 'E');
  772.  
  773.             for(int var7 = 0; var7 < this.minExponentDigits; ++var7) {
  774.                var2.append(var1 ? this.symbols.getZeroDigit() : '0');
  775.             }
  776.          }
  777.  
  778.          if (var3 == 1) {
  779.             this.appendAffix(var2, this.posSuffixPattern, this.positiveSuffix, var1);
  780.             if ((this.negSuffixPattern == this.posSuffixPattern && this.negativeSuffix.equals(this.positiveSuffix) || this.negSuffixPattern != null && this.negSuffixPattern.equals(this.posSuffixPattern)) && (this.negPrefixPattern != null && this.posPrefixPattern != null && this.negPrefixPattern.equals("'-" + this.posPrefixPattern) || this.negPrefixPattern == this.posPrefixPattern && this.negativePrefix.equals(this.symbols.getMinusSign() + this.positivePrefix))) {
  781.                break;
  782.             }
  783.  
  784.             var2.append(var1 ? this.symbols.getPatternSeparator() : ';');
  785.          } else {
  786.             this.appendAffix(var2, this.negSuffixPattern, this.negativeSuffix, var1);
  787.          }
  788.       }
  789.  
  790.       return var2.toString();
  791.    }
  792.  
  793.    public void applyPattern(String var1) {
  794.       this.applyPattern(var1, false);
  795.    }
  796.  
  797.    public void applyLocalizedPattern(String var1) {
  798.       this.applyPattern(var1, true);
  799.    }
  800.  
  801.    private void applyPattern(String var1, boolean var2) {
  802.       char var3 = '0';
  803.       char var4 = ',';
  804.       char var5 = '.';
  805.       char var6 = '%';
  806.       char var7 = 8240;
  807.       char var8 = '#';
  808.       char var9 = ';';
  809.       char var10 = 'E';
  810.       char var11 = '-';
  811.       if (var2) {
  812.          var3 = this.symbols.getZeroDigit();
  813.          var4 = this.symbols.getGroupingSeparator();
  814.          var5 = this.symbols.getDecimalSeparator();
  815.          var6 = this.symbols.getPercent();
  816.          var7 = this.symbols.getPerMill();
  817.          var8 = this.symbols.getDigit();
  818.          var9 = this.symbols.getPatternSeparator();
  819.          var10 = this.symbols.getExponentialSymbol();
  820.          var11 = this.symbols.getMinusSign();
  821.       }
  822.  
  823.       boolean var12 = false;
  824.       this.decimalSeparatorAlwaysShown = false;
  825.       this.isCurrencyFormat = false;
  826.       this.useExponentialNotation = false;
  827.       boolean var13 = false;
  828.       int var14 = 0;
  829.       int var15 = 0;
  830.       int var16 = 1;
  831.  
  832.       while(true) {
  833.          if (var16 >= 0 && var15 < var1.length()) {
  834.             boolean var17 = false;
  835.             StringBuffer var18 = new StringBuffer();
  836.             StringBuffer var19 = new StringBuffer();
  837.             int var20 = -1;
  838.             short var21 = 1;
  839.             int var22 = 0;
  840.             int var23 = 0;
  841.             int var24 = 0;
  842.             byte var25 = -1;
  843.             byte var26 = 0;
  844.             StringBuffer var27 = var18;
  845.  
  846.             for(int var28 = var15; var28 < var1.length(); ++var28) {
  847.                char var29 = var1.charAt(var28);
  848.                switch (var26) {
  849.                   case 0:
  850.                   case 2:
  851.                      if (var17) {
  852.                         if (var29 == '\'') {
  853.                            if (var28 + 1 < var1.length() && var1.charAt(var28 + 1) == '\'') {
  854.                               ++var28;
  855.                               var27.append("''");
  856.                            } else {
  857.                               var17 = false;
  858.                            }
  859.                            break;
  860.                         }
  861.                      } else {
  862.                         if (var29 == var8 || var29 == var3 || var29 == var4 || var29 == var5) {
  863.                            var26 = 1;
  864.                            if (var16 == 1) {
  865.                               ;
  866.                            }
  867.  
  868.                            --var28;
  869.                            break;
  870.                         }
  871.  
  872.                         if (var29 == 164) {
  873.                            boolean var30 = var28 + 1 < var1.length() && var1.charAt(var28 + 1) == 164;
  874.                            if (var30) {
  875.                               ++var28;
  876.                            }
  877.  
  878.                            this.isCurrencyFormat = true;
  879.                            var27.append(var30 ? "'┬ñ┬ñ" : "'┬ñ");
  880.                            break;
  881.                         }
  882.  
  883.                         if (var29 == '\'') {
  884.                            if (var29 == '\'') {
  885.                               if (var28 + 1 < var1.length() && var1.charAt(var28 + 1) == '\'') {
  886.                                  ++var28;
  887.                                  var27.append("''");
  888.                               } else {
  889.                                  var17 = true;
  890.                               }
  891.                               break;
  892.                            }
  893.                         } else {
  894.                            if (var29 == var9) {
  895.                               if (var26 == 0 || var16 == 0) {
  896.                                  throw new IllegalArgumentException("Unquoted special character '" + var29 + "' in pattern \"" + var1 + '"');
  897.                               }
  898.  
  899.                               var15 = var28 + 1;
  900.                               var28 = var1.length();
  901.                               break;
  902.                            }
  903.  
  904.                            if (var29 == var6) {
  905.                               if (var21 != 1) {
  906.                                  throw new IllegalArgumentException("Too many percent/permille characters in pattern \"" + var1 + '"');
  907.                               }
  908.  
  909.                               var21 = 100;
  910.                               var27.append("'%");
  911.                               break;
  912.                            }
  913.  
  914.                            if (var29 == var7) {
  915.                               if (var21 != 1) {
  916.                                  throw new IllegalArgumentException("Too many percent/permille characters in pattern \"" + var1 + '"');
  917.                               }
  918.  
  919.                               var21 = 1000;
  920.                               var27.append("'ΓÇ░");
  921.                               break;
  922.                            }
  923.  
  924.                            if (var29 == var11) {
  925.                               var27.append("'-");
  926.                               break;
  927.                            }
  928.                         }
  929.                      }
  930.  
  931.                      var27.append(var29);
  932.                      break;
  933.                   case 1:
  934.                      if (var16 == 1) {
  935.                         ++var14;
  936.                         if (var29 == var8) {
  937.                            if (var23 > 0) {
  938.                               ++var24;
  939.                            } else {
  940.                               ++var22;
  941.                            }
  942.  
  943.                            if (var25 >= 0 && var20 < 0) {
  944.                               ++var25;
  945.                            }
  946.                         } else if (var29 == var3) {
  947.                            if (var24 > 0) {
  948.                               throw new IllegalArgumentException("Unexpected '0' in pattern \"" + var1 + '"');
  949.                            }
  950.  
  951.                            ++var23;
  952.                            if (var25 >= 0 && var20 < 0) {
  953.                               ++var25;
  954.                            }
  955.                         } else if (var29 == var4) {
  956.                            var25 = 0;
  957.                         } else if (var29 == var5) {
  958.                            if (var20 >= 0) {
  959.                               throw new IllegalArgumentException("Multiple decimal separators in pattern \"" + var1 + '"');
  960.                            }
  961.  
  962.                            var20 = var22 + var23 + var24;
  963.                         } else if (var29 != var10) {
  964.                            var26 = 2;
  965.                            var27 = var19;
  966.                            --var28;
  967.                            --var14;
  968.                         } else {
  969.                            if (this.useExponentialNotation) {
  970.                               throw new IllegalArgumentException("Multiple exponential symbols in pattern \"" + var1 + '"');
  971.                            }
  972.  
  973.                            this.useExponentialNotation = true;
  974.                            this.minExponentDigits = 0;
  975.  
  976.                            while(true) {
  977.                               ++var28;
  978.                               if (var28 >= var1.length() || var1.charAt(var28) != var3) {
  979.                                  if (var22 + var23 < 1 || this.minExponentDigits < 1) {
  980.                                     throw new IllegalArgumentException("Malformed exponential pattern \"" + var1 + '"');
  981.                                  }
  982.  
  983.                                  var26 = 2;
  984.                                  var27 = var19;
  985.                                  --var28;
  986.                                  break;
  987.                               }
  988.  
  989.                               ++this.minExponentDigits;
  990.                               ++var14;
  991.                            }
  992.                         }
  993.                      } else {
  994.                         --var14;
  995.                         if (var14 == 0) {
  996.                            var26 = 2;
  997.                            var27 = var19;
  998.                         }
  999.                      }
  1000.                }
  1001.             }
  1002.  
  1003.             if (var23 == 0 && var22 > 0 && var20 >= 0) {
  1004.                int var31 = var20;
  1005.                if (var20 == 0) {
  1006.                   var31 = var20 + 1;
  1007.                }
  1008.  
  1009.                var24 = var22 - var31;
  1010.                var22 = var31 - 1;
  1011.                var23 = 1;
  1012.             }
  1013.  
  1014.             if ((var20 >= 0 || var24 <= 0) && (var20 < 0 || var20 >= var22 && var20 <= var22 + var23) && var25 != 0 && !var17) {
  1015.                if (var16 == 1) {
  1016.                   this.posPrefixPattern = var18.toString();
  1017.                   this.posSuffixPattern = var19.toString();
  1018.                   this.negPrefixPattern = this.posPrefixPattern;
  1019.                   this.negSuffixPattern = this.posSuffixPattern;
  1020.                   int var32 = var22 + var23 + var24;
  1021.                   int var33 = var20 >= 0 ? var20 : var32;
  1022.                   this.setMinimumIntegerDigits(var33 - var22);
  1023.                   this.setMaximumIntegerDigits(this.useExponentialNotation ? var22 + ((NumberFormat)this).getMinimumIntegerDigits() : 309);
  1024.                   this.setMaximumFractionDigits(var20 >= 0 ? var32 - var20 : 0);
  1025.                   this.setMinimumFractionDigits(var20 >= 0 ? var22 + var23 - var20 : 0);
  1026.                   ((NumberFormat)this).setGroupingUsed(var25 > 0);
  1027.                   this.groupingSize = var25 > 0 ? var25 : 0;
  1028.                   this.multiplier = var21;
  1029.                   this.setDecimalSeparatorAlwaysShown(var20 == 0 || var20 == var32);
  1030.                } else {
  1031.                   this.negPrefixPattern = var18.toString();
  1032.                   this.negSuffixPattern = var19.toString();
  1033.                   var12 = true;
  1034.                }
  1035.  
  1036.                --var16;
  1037.                continue;
  1038.             }
  1039.  
  1040.             throw new IllegalArgumentException("Malformed pattern \"" + var1 + '"');
  1041.          }
  1042.  
  1043.          if (var1.length() == 0) {
  1044.             this.posPrefixPattern = this.posSuffixPattern = "";
  1045.             this.setMinimumIntegerDigits(0);
  1046.             this.setMaximumIntegerDigits(309);
  1047.             this.setMinimumFractionDigits(0);
  1048.             this.setMaximumFractionDigits(340);
  1049.          }
  1050.  
  1051.          if (!var12 || this.negPrefixPattern.equals(this.posPrefixPattern) && this.negSuffixPattern.equals(this.posSuffixPattern)) {
  1052.             this.negSuffixPattern = this.posSuffixPattern;
  1053.             this.negPrefixPattern = "'-" + this.posPrefixPattern;
  1054.          }
  1055.  
  1056.          this.expandAffixes();
  1057.          return;
  1058.       }
  1059.    }
  1060.  
  1061.    public void setMaximumIntegerDigits(int var1) {
  1062.       super.setMaximumIntegerDigits(Math.min(var1, 309));
  1063.    }
  1064.  
  1065.    public void setMinimumIntegerDigits(int var1) {
  1066.       super.setMinimumIntegerDigits(Math.min(var1, 309));
  1067.    }
  1068.  
  1069.    public void setMaximumFractionDigits(int var1) {
  1070.       super.setMaximumFractionDigits(Math.min(var1, 340));
  1071.    }
  1072.  
  1073.    public void setMinimumFractionDigits(int var1) {
  1074.       super.setMinimumFractionDigits(Math.min(var1, 340));
  1075.    }
  1076.  
  1077.    private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
  1078.       var1.defaultReadObject();
  1079.       if (((NumberFormat)this).getMaximumIntegerDigits() <= 309 && ((NumberFormat)this).getMaximumFractionDigits() <= 340) {
  1080.          if (this.serialVersionOnStream < 1) {
  1081.             this.useExponentialNotation = false;
  1082.          }
  1083.  
  1084.          this.serialVersionOnStream = 2;
  1085.          this.digitList = new DigitList();
  1086.       } else {
  1087.          throw new InvalidObjectException("Digit count out of range");
  1088.       }
  1089.    }
  1090. }
  1091.