Example #1
0
  /**
   * Generic parsing routine that can parse out a Quoted-String, Literal or Atom and return the
   * parsed token as a String or a ByteArray. Errors or NIL data will return null.
   */
  private Object parseString(boolean parseAtoms, boolean returnString) {
    byte b;

    // Skip leading spaces
    skipSpaces();

    b = buffer[index];
    if (b == '"') { // QuotedString
      index++; // skip the quote
      int start = index;
      int copyto = index;

      while ((b = buffer[index]) != '"') {
        if (b == '\\') // skip escaped byte
        index++;
        if (index != copyto) { // only copy if we need to
          // Beware: this is a destructive copy. I'm
          // pretty sure this is OK, but ... ;>
          buffer[copyto] = buffer[index];
        }
        copyto++;
        index++;
      }
      index++; // skip past the terminating quote

      if (returnString) return ASCIIUtility.toString(buffer, start, copyto);
      else return new ByteArray(buffer, start, copyto - start);
    } else if (b == '{') { // Literal
      int start = ++index; // note the start position

      while (buffer[index] != '}') index++;

      int count = 0;
      try {
        count = ASCIIUtility.parseInt(buffer, start, index);
      } catch (NumberFormatException nex) {
        // throw new ParsingException();
        return null;
      }

      start = index + 3; // skip "}\r\n"
      index = start + count; // position index to beyond the literal

      if (returnString) // return as String
      return ASCIIUtility.toString(buffer, start, start + count);
      else return new ByteArray(buffer, start, count);
    } else if (parseAtoms) { // parse as an ATOM
      int start = index; // track this, so that we can use to
      // creating ByteArrayInputStream below.
      String s = readAtom();
      if (returnString) return s;
      else // *very* unlikely
      return new ByteArray(buffer, start, index);
    } else if (b == 'N' || b == 'n') { // the only valid value is 'NIL'
      index += 3; // skip past NIL
      return null;
    }
    return null; // Error
  }
Example #2
0
  /**
   * Extract an integer, starting at the current position. Updates the internal index to beyond the
   * number. Returns -1 if a number was not found.
   *
   * @return a number
   */
  public int readNumber() {
    // Skip leading spaces
    skipSpaces();

    int start = index;
    while (index < size && Character.isDigit((char) buffer[index])) index++;

    if (index > start) {
      try {
        return ASCIIUtility.parseInt(buffer, start, index);
      } catch (NumberFormatException nex) {
      }
    }

    return -1;
  }