stringutil.java

google的gdata api包

        if (!Character.isLetterOrDigit(chars[j]))
          break;
        }

      boolean replaced = false;
      if (j < chars.length && chars[j] == ';') {
        if (s.charAt(i + 1) == '#') { // Check for &#D; and &#xD; pattern
          try {
            long charcode = 0;
            char ch = s.charAt(i + 2);
            if (ch == 'x' || ch == 'X') {
              charcode = Long.parseLong(new String(chars, i + 3, j - i - 3),
                                        16);
            } else if (Character.isDigit(ch)) {
              charcode = Long.parseLong(new String(chars, i + 2, j - i - 2));
            }
            if (charcode > 0 && charcode < 65536) {
              escaped[pos++] = (char) charcode;
              replaced = true;
            }
          } catch (NumberFormatException ex) {
            // Failed, not replaced.
          }

        } else {
          String key = new String(chars, i, j - i + 1);
          Character repl = escapeStrings.get(key);
          if (repl != null) {
            escaped[pos++] = repl.charValue();
            replaced = true;
          }
        }
        j++;                            // Skip over ';'
      }

      if (!replaced) {
        // Not a recognized escape sequence, leave as-is
        System.arraycopy(chars, i, escaped, pos, j - i);
        pos += j - i;
      }
      i = j;
    }
    return new String(escaped, 0, pos);
  }

  /**
   * Given a <code>String</code>, returns an equivalent <code>String</code> with
   * all HTML tags stripped. Note that HTML entities, such as "&amp;amp;" will
   * still be preserved.
   */
  public static String stripHtmlTags(String string) {
    if ((string == null) || "".equals(string)) {
      return string;
    }
    return htmlTagPattern.matcher(string).replaceAll("");
  }

  /**
   * We escape some characters in s to be able to make the string executable
   * from a python string
   */
  public static String pythonEscape(String s) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < s.length(); i++) {
      char c = s.charAt(i);
      switch (c) {
        case '\n': sb.append("\\n"); break;
        case '\r': sb.append("\\r"); break;
        case '\t': sb.append("\\t"); break;
        case '\\': sb.append("\\\\"); break;
        case '\"': sb.append("\\\""); break;
        case '\'': sb.append("\\\'"); break;
        default:   sb.append(c);
      }
    }
    return sb.toString();
  }

  /**
   * We escape some characters in s to be able to insert strings into JavaScript
   * code. Also, make sure that we don't write out --> or </scrip, which may
   * close a script tag.
   */
  public static String javaScriptEscape(String s) {
    return javaScriptEscapeHelper(s, false);
  }

  /**
   * We escape some characters in s to be able to insert strings into JavaScript
   * code. Also, make sure that we don't write out --> or &lt;/scrip, which may
   * close a script tag. Turns all non-ascii characters into ASCII javascript
   * escape sequences (eg \udddd)
   */
  public static String javaScriptEscapeToAscii(String s) {
    return javaScriptEscapeHelper(s, true);
  }

  private static final String[] UNSAFE_TAGS = { "script", "style",
                                                "object", "applet", "!--" };

  /**
   * Helper for javaScriptEscape and javaScriptEscapeToAscii
   */
  private static String javaScriptEscapeHelper(String s,
                                               boolean escapeToAscii) {

    /*
     * IMPORTANT: If you change the semantics of this method (by escaping
     * extra characters, for example), please make similar changes to
     *   com.google.javascript.util.Escape.toJsString
     */
    StringBuilder sb = new StringBuilder(s.length() * 9 / 8);
    for (int i = 0; i < s.length(); i++) {
      char c = s.charAt(i);
      switch (c) {
        case '\n': sb.append("\\n"); break;
        case '\r': sb.append("\\r"); break;
        case '\t': sb.append("\\t"); break;
        case '\\': sb.append("\\\\"); break;
        case '\"': sb.append("\\\""); break;
        case '\'': sb.append("\\\'"); break;

        // escape '=' so that javascript won't be executed within tags
        case '=': appendHexJavaScriptRepresentation(sb, c); break;

        case '<':  // for text that could potentially be interpreted as an
        case '/':  // unsafe opening or closing tag, escape the char to hex
          boolean isUnsafe = false;
          for (String tag : UNSAFE_TAGS) {
            if (s.regionMatches(true, i + 1, tag, 0, tag.length())) {
              isUnsafe = true;
              break;
            }
          }
          if (isUnsafe) {
            appendHexJavaScriptRepresentation(sb, c);
          } else {
            sb.append(c);
          }
          break;
        case '>' :
          if (sb.length() > 0 && sb.charAt(sb.length() - 1) == '-') {
            sb.append('\\');
          }
          sb.append(c);
          break;
        // Note: Mozilla browser treats the line/paragraph separator
        // as string terminators, so we need to escape them.
        case '\u2028': sb.append("\\u2028"); break;
        case '\u2029': sb.append("\\u2029"); break;
        default:
          if (c >= 128 && escapeToAscii) {
            appendHexJavaScriptRepresentation(sb, c);
          } else {
            sb.append(c);
          }
      }
    }
    return sb.toString();
  }

  /**
   * Returns a javascript representation of the character in a hex escaped
   * format. Although this is a rather specific method, it is made public
   * because it is also used by the JSCompiler.
   *
   *
   * @param sb The buffer to which the hex representation should be appended.
   * @param c The character to be appended.
   */
  public static void appendHexJavaScriptRepresentation(StringBuilder sb,
                                                       char c) {
    sb.append("\\u");
    String val = Integer.toHexString(c);
    for (int j = val.length(); j < 4; j++) {
      sb.append('0');
    }
    sb.append(val);
  }


  /**
   * Undo escaping as performed in javaScriptEscape(.)
   * Throws an IllegalArgumentException if the string contains
   * bad escaping.
   */
  public static String javaScriptUnescape(String s) {
    StringBuilder sb = new StringBuilder(s.length());
    for (int i = 0; i < s.length(); ) {
      char c = s.charAt(i);
      if (c == '\\') {
        i = javaScriptUnescapeHelper(s, i + 1, sb);
      } else {
        sb.append(c);
        i++;
      }
    }
    return sb.toString();
  }

  /**
   * Looks for an escape code starting at index i of s,
   * and appends it to sb.
   * @return the index of the first character in s
   * after the escape code.
   * @throws IllegalArgumentException if the escape code
   * is invalid
   */
  private static int javaScriptUnescapeHelper(String s, int i,
                                              StringBuilder sb) {
    if (i >= s.length()) {
      throw new IllegalArgumentException(
          "End-of-string after escape character in [" + s + "]");
    }

    char c = s.charAt(i++);
    switch (c) {
      case 'n': sb.append('\n'); break;
      case 'r': sb.append('\r'); break;
      case 't': sb.append('\t'); break;
      case '\\':
      case '\"':
      case '\'':
      case '>':
        sb.append(c);
        break;
      case 'u':
        String hexCode;
        try {
          hexCode = s.substring(i, i + 4);
        } catch (IndexOutOfBoundsException ioobe) {
          throw new IllegalArgumentException(
              "Invalid unicode sequence [" + s.substring(i) + "] at index " + i +
              " in [" + s + "]");
        }
        int unicodeValue;
        try {
          unicodeValue = Integer.parseInt(hexCode, 16);
        } catch (NumberFormatException nfe) {
          throw new IllegalArgumentException(
              "Invalid unicode sequence [" + hexCode + "] at index " + i +
              " in [" + s + "]");
        }
        sb.append((char)unicodeValue);
        i += 4;
        break;
      default:
        throw new IllegalArgumentException(
            "Unknown escape code [" + c + "] at index " + i + " in [" + s + "]");
    }

    return i;
  }

  /**
   * Escape a string for use inside as XML element content. This escapes
   * less-than and ampersand, only.
   */
  public static String xmlContentEscape(String s) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < s.length(); i++) {
      char c = s.charAt(i);
      switch (c) {
        case '&': sb.append("&amp;"); break;
        case '<': sb.append("&lt;"); break;

        case '\000': case '\001': case '\002': case '\003': case '\004':
        case '\005': case '\006': case '\007': case '\010': case '\013':
        case '\014': case '\016': case '\017': case '\020': case '\021':
        case '\022': case '\023': case '\024': case '\025': case '\026':
        case '\027': case '\030': case '\031': case '\032': case '\033':
        case '\034': case '\035': case '\036': case '\037':
          // do nothing, these are disallowed characters
          break;
        default:   sb.append(c);
      }
    }
    return sb.toString();
  }

  /**
   * Escape a string for use inside as XML single-quoted attributes. This
   * escapes less-than, single-quote, ampersand, and (not strictly necessary)
   * newlines.
   */
  public static String xmlSingleQuotedEscape(String s) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < s.length(); i++) {
      char c = s.charAt(i);
      switch (c) {
        case '\'': sb.append("&quot;"); break;
        case '&': sb.append("&amp;"); break;
        case '<': sb.append("&lt;"); break;
        case '\n': sb.append("&#xA;"); break;

        case '\000': case '\001': case '\002': case '\003': case '\004':
        case '\005': case '\006': case '\007': case '\010': case '\013':
        case '\014': case '\016': case '\017': case '\020': case '\021':
        case '\022': case '\023': case '\024': case '\025': case '\026':
        case '\027': case '\030': case '\031': case '\032': case '\033':
        case '\034': case '\035': case '\036': case '\037':
          // do nothing, these are disallowed characters
          break;
        default:   sb.append(c);
      }
    }
    return sb.toString();
  }

  /**
   * We escape some characters in s to be able to insert strings into Java code
   */
  public static String javaEscape(String s) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < s.length(); i++) {
      char c = s.charAt(i);
      switch (c) {
        case '\n': sb.append("\\n"); break;
        case '\r': sb.append("\\r"); break;
        case '\t': sb.append("\\t"); break;
        case '\\': sb.append("\\\\"); break;
        case '\"': sb.append("\\\""); break;
        case '&': sb.append("&amp;"); break;
        case '<': sb.append("&lt;"); break;
        case '>': sb.append("&gt;"); break;
        case '\'': sb.append("\\\'"); break;
        default:   sb.append(c);
      }
    }
    return sb.toString();
  }

  /**
   * Escape a string so that it can be safely placed as value of an
   * attribute.  This is essentially similar to the {@link
   * javaEscape(java.lang.String)} except that it escapes double quote
   * to the HTML literal &amp;quot;. This is to prevent the double
   * quote from being interpreted as the character closing the
   * attribute.
   */
  public static String javaEscapeWithinAttribute(String s) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < s.length(); i++) {
      char c = s.charAt(i);
      switch (c) {
        case '\n': sb.append("\\n"); break;
        case '\r': sb.append("\\r"); break;
        case '\t': sb.append("\\t"); break;
        case '\\': sb.append("\\\\"); break;
        case '\"': sb.append("&quot;"); break;
        case '&': sb.append("&amp;"); break;
        case '<': sb.append("&lt;"); break;
        case '>': sb.append("&gt;"); break;
        case '\'': sb.append("\\\'"); break;
        default:   sb.append(c);
      }
    }
    return sb.toString();
  }

  /**
   * Returns a form of "s" appropriate for including in an XML document, after
   * escaping certain special characters (e.g. '&' => '&amp;', etc.)
   */
  public static String xmlEscape(String s) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < s.length(); i++) {
      char ch = s.charAt(i);
      switch (ch) {
        case '"':
          sb.append("&quot;");
          break;
        case '&':
          sb.append("&amp;");
          break;
        case '\'':
          sb.append("&apos;");