anchor.diff:      return position + 5;
     }
   
  -  /** Parses a "null" literal starting at [position].
  +  /**
  +   * Parses a "null" literal starting at [position].
      *
      * [:source[position]:] must be "n".
      */
  
positive.code:     }
    }
  
    int _handleLiteral(start, position, isDouble) {
      String literal = source.substring(start, position);
      // This correctly creates -0 for doubles.
      num value = (isDouble ? double.parse(literal) : int.parse(literal));
      listener.handleNumber(value);
      return position;
    }
  
    int parseNumber(int char, int position) {
      // Format:
      //  '-'?('0'|[1-9][0-9]*)('.'[0-9]+)?([eE][+-]?[0-9]+)?
      int start = position;
      int length = source.length;
      bool isDouble = false;
      if (char == MINUS) {
        position++;
        if (position == length) fail(position, "Missing expected digit");
        char = source.codeUnitAt(position);
      }
      if (char < CHAR_0 || char > CHAR_9) {
        fail(position, "Missing expected digit");
      }
      if (char == CHAR_0) {
        position++;
        if (position == length) return _handleLiteral(start, position, false);
        char = source.codeUnitAt(position);
        if (CHAR_0 <= char && char <= CHAR_9) {
          fail(position);
        }
      } else {
        do {
          position++;
          if (position == length) return _handleLiteral(start, position, false);
          char = source.codeUnitAt(position);
        } while (CHAR_0 <= char && char <= CHAR_9);
      }
      if (char == DECIMALPOINT) {
        isDouble = true;
        position++;
        if (position == length) fail(position, "Missing expected digit");
        char = source.codeUnitAt(position);
        if (char < CHAR_0 || char > CHAR_9) fail(position);
        do {
          position++;
          if (position == length) return _handleLiteral(start, position, true);
          char = source.codeUnitAt(position);
        } while (CHAR_0 <= char && char <= CHAR_9);
      }
      if (char == CHAR_e || char == CHAR_E) {
        isDouble = true;
        position++;
        if (position == length) fail(position, "Missing expected digit");
        char = source.codeUnitAt(position);
        if (char == PLUS || char == MINUS) {
          position++;
          if (position == length) fail(position, "Missing expected digit");
          char = source.codeUnitAt(position);
  
negative.code:     return position + 4;
    }
  
    /**
     * Parses a string value.
     *
     * Initial [position] is right after the initial quote.
     * Returned position right after the final quote.
     */
    int parseString(int position) {
      // Format: '"'([^\x00-\x1f\\\"]|'\\'[bfnrt/\\"])*'"'
      // Initial position is right after first '"'.
      int start = position;
      while (position < source.length) {
        int char = source.codeUnitAt(position++);
        // BACKSLASH is larger than QUOTE and SPACE.
        if (char > BACKSLASH) {
          continue;
        }
        if (char == BACKSLASH) {
          return parseStringWithEscapes(start, position - 1);
        }
        if (char == QUOTE) {
          listener.handleString(source.substring(start, position - 1));
          return position;
        }
        if (char < SPACE) {
          fail(position - 1, "Control character in string");
        }
      }
      fail(start - 1, "Unterminated string");
    }
  
    int parseStringWithEscapes(start, position) {
      // Backslash escape detected. Collect character codes for rest of string.
      int firstEscape = position;
      List<int> chars = <int>[];
      for (int i = start; i < firstEscape; i++) {
        chars.add(source.codeUnitAt(i));
      }
      position++;
      while (true) {
        if (position == source.length) {
          fail(start - 1, "Unterminated string");
        }
        int char = source.codeUnitAt(position);
        switch (char) {
          case CHAR_b: char = BACKSPACE; break;
          case CHAR_f: char = FORM_FEED; break;
  