Code cleanup in _NumberFormatParser

pkg/intl/lib/number_format.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of intl;
 /**
  * Provides the ability to format a number in a locale-specific way. The
  * format is specified as a pattern using a subset of the ICU formatting
  * patterns.
  *
@@ skipping 64 matching lines @@
   /** Caches the symbols used for our locale. */
   NumberSymbols _symbols;
 
   /**
    * Transient internal state in which to build up the result of the format
    * operation. We can have this be just an instance variable because Dart is
    * single-threaded and unless we do an asynchronous operation in the process
    * of formatting then there will only ever be one number being formatted
    * at a time. In languages with threads we'd need to pass this on the stack.
    */
-  StringBuffer _buffer;
+  final StringBuffer _buffer = new StringBuffer();
 
   /**
    * Create a number format that prints using [newPattern] as it applies in
    * [locale].
    */
   factory NumberFormat([String newPattern, String locale]) =>
       new NumberFormat._forPattern(locale, (x) => newPattern);
 
   /** Create a number format that prints as DECIMAL_PATTERN. */
   NumberFormat.decimalPattern([String locale]) :
@@ skipping 43 matching lines @@
 
   /**
    * Format [number] according to our pattern and return the formatted string.
    */
   String format(num number) {
     // TODO(alanknight): Do we have to do anything for printing numbers bidi?
     // Or are they always printed left to right?
     if (number.isNaN) return symbols.NAN;
     if (number.isInfinite) return "${_signPrefix(number)}${symbols.INFINITY}";
 
-    _newBuffer();
     _add(_signPrefix(number));
     _formatNumber(number.abs() * _multiplier);
     _add(_signSuffix(number));
 
     var result = _buffer.toString();
-    _buffer = null;
+    _buffer.clear();
     return result;
   }
 
   /**
    * Format the main part of the number in the form dictated by the pattern.
    */
   void _formatNumber(num number) {
     if (_useExponentialNotation) {
       _formatExponential(number);
     } else {
@@ skipping 77 matching lines @@
       fracValue = 0;
     } else {
       intValue = shiftedNumber.round() ~/ power;
       fracValue = (shiftedNumber - intValue * power).floor();
     }
     var fractionPresent = minimumFractionDigits > 0 || fracValue > 0;
 
     // If the int part is larger than 2^52 and we're on Javascript (so it's
     // really a float) it will lose precision, so pad out the rest of it
     // with zeros. Check for Javascript by seeing if an integer is double.
-    var paddingDigits = new StringBuffer();
+    var paddingDigits = '';
     if (1 is double && intValue > _maxInt) {
         var howManyDigitsTooBig = (log(intValue) / LN10).ceil() - 16;
         var divisor = pow(10, howManyDigitsTooBig).round();
-        for (var each in new List(howManyDigitsTooBig.toInt())) {
-          paddingDigits.write(symbols.ZERO_DIGIT);
-        }
+        paddingDigits = symbols.ZERO_DIGIT * howManyDigitsTooBig.toInt();
+
         intValue = (intValue / divisor).truncate();
     }
     var integerDigits = "${intValue}${paddingDigits}".codeUnits;
     var digitLength = integerDigits.length;
 
     if (_hasPrintableIntegerPart(intValue)) {
       _pad(minimumIntegerDigits - digitLength);
       for (var i = 0; i < digitLength; i++) {
         _addDigit(integerDigits[i]);
         _group(digitLength, i);
@@ skipping 30 matching lines @@
   }
 
   /**
    * Return true if we have a main integer part which is printable, either
    * because we have digits left of the decimal point, or because there are
    * a minimum number of printable digits greater than 1.
    */
   bool _hasPrintableIntegerPart(int intValue) =>
       intValue > 0 || minimumIntegerDigits > 0;
 
-  /**
-   * Create a new empty buffer. See comment on [_buffer] variable for why
-   * we have it as an instance variable rather than passing it on the stack.
-   */
-  void _newBuffer() { _buffer = new StringBuffer(); }
-
   /** A group of methods that provide support for writing digits and other
    * required characters into [_buffer] easily.
    */
   void _add(String x) { _buffer.write(x);}
   void _addCharCode(int x) { _buffer.writeCharCode(x); }
   void _addZero() { _buffer.write(symbols.ZERO_DIGIT); }
   void _addDigit(int x) { _buffer.writeCharCode(_localeZero + x - _zero); }
 
   /** Print padding up to [numberOfDigits] above what's included in [basic]. */
   void _pad(int numberOfDigits, [String basic = '']) {
@@ skipping 114 matching lines @@
         pattern.moveNext();
       }
       format._negativeSuffix = _parseAffix();
     } else {
       // If no negative affix is specified, they share the same positive affix.
       format._negativePrefix = format._positivePrefix + format._negativePrefix;
       format._negativeSuffix = format._negativeSuffix + format._positiveSuffix;
     }
   }
 
-  /** Variable used in parsing prefixes and suffixes to keep track of
-   * whether or not we are in a quoted region. */
+  /**
+   * Variable used in parsing prefixes and suffixes to keep track of
+   * whether or not we are in a quoted region.
+   */
   bool inQuote = false;
 
   /**
    * Parse a prefix or suffix and return the prefix/suffix string. Note that
    * this also may modify the state of [format].
    */
   String _parseAffix() {
     var affix = new StringBuffer();
     inQuote = false;
     while (parseCharacterAffix(affix) && pattern.moveNext());
@@ skipping 47 matching lines @@
           affix.write(symbols.PERMILL);
           break;
         default:
           affix.write(ch);
       }
     }
     return true;
   }
 
   /** Variables used in [_parseTrunk] and [parseTrunkCharacter]. */
-  var decimalPos;
-  var digitLeftCount;
-  var zeroDigitCount;
-  var digitRightCount;
-  var groupingCount;
-  var trunk;
+  var decimalPos = -1;
+  var digitLeftCount = 0;
+  var zeroDigitCount = 0;
+  var digitRightCount = 0;
+  var groupingCount = -1;
 
   /**
    * Parse the "trunk" portion of the pattern, the piece that doesn't include
    * positive or negative prefixes or suffixes.
    */
   String _parseTrunk() {
-    decimalPos = -1;
-    digitLeftCount = 0;
-    zeroDigitCount = 0;
-    digitRightCount = 0;
-    groupingCount = -1;
-
     var loop = true;
-    trunk = new StringBuffer();
+    var trunk = new StringBuffer();
     while (pattern.current != null && loop) {
-      loop = parseTrunkCharacter();
+      loop = parseTrunkCharacter(trunk);
     }
 
     if (zeroDigitCount == 0 && digitLeftCount > 0 && decimalPos >= 0) {
       // Handle '###.###' and '###.' and '.###'
       // Handle '.###'
       var n = decimalPos == 0 ? 1 : decimalPos;
       digitRightCount = digitLeftCount - n;
       digitLeftCount = n - 1;
       zeroDigitCount = 1;
     }
@@ skipping 38 matching lines @@
         decimalPos == totalDigits;
 
     return trunk.toString();
   }
 
   /**
    * Parse an individual character of the trunk. Return true if we should
    * continue to look for additional trunk characters or false if we have
    * reached the end.
    */
-  bool parseTrunkCharacter() {
+  bool parseTrunkCharacter(trunk) {
     var ch = pattern.current;
     switch (ch) {
       case _PATTERN_DIGIT:
         if (zeroDigitCount > 0) {
           digitRightCount++;
         } else {
           digitLeftCount++;
         }
         if (groupingCount >= 0 && decimalPos < 0) {
           groupingCount++;
@@ skipping 80 matching lines @@
 
   _StringIterable(String s) : iterator = _iterator(s);
 }
 
 /**
  * Provides an iterator over a string as a list of substrings, and also
  * gives us a lookahead of one via the [peek] method.
  */
 class _StringIterator implements Iterator<String> {
   final String input;
-  int index = -1;
-  inBounds(i) => i >= 0 && i < input.length;
-  _StringIterator(this.input);
-  String get current => inBounds(index) ? input[index] : null;
+  int nextIndex = 0;
+  String _current = null;
 
-  bool moveNext() => inBounds(++index);
-  String get peek => inBounds(index + 1) ? input[index + 1] : null;
+  _StringIterator(input) : input = _validate(input);
+
+  String get current => _current;
+
+  bool moveNext() {
+    if (nextIndex >= input.length) {
+      _current = null;
+      return false;
+    }
+    _current = input[nextIndex++];
+    return true;
+  }
+
+  String get peek => nextIndex >= input.length ? null : input[nextIndex];
+
   Iterator<String> get iterator => this;
+
+  static String _validate(input) {
+    if (input is! String) throw new ArgumentError(input);
+    return input;
+  }
+
 }