.
+ static final HashSet suppressLinebreakTags = new HashSet ();
+ static {
+ suppressLinebreakTags.add ("table");
+ suppressLinebreakTags.add ("ul");
+ suppressLinebreakTags.add ("ol");
+ suppressLinebreakTags.add ("pre");
+ }
+
+ // tags which signal us to stop suppressing \n ->
encoding
+ // these usually signal transition from structural tags to normal
+ // HTML text, e.g.
+ static final HashSet encodeLinebreakTags = new HashSet ();
+ static {
+ encodeLinebreakTags.add ("td");
+ encodeLinebreakTags.add ("th");
+ encodeLinebreakTags.add ("li");
+ }
+
/**
- *
- */
+ *
+ */
public final static String encode (String str) {
// try to make stringbuffer large enough from the start
StringBuffer ret = new StringBuffer (Math.round (str.length()*1.4f));
encode (str, ret);
- return ret.toString();
+ return ret.toString();
}
-
+
/**
- *
- */
+ *
+ */
public final static void encode (String str, StringBuffer ret) {
if (str == null)
return;
-
- int l = str.length();
-
- boolean closeTag=false, readTag=false, tagOpen=false;
- // the difference between swallowOneNewline and ignoreNewline is that swallowOneNewline is just effective once (for the next newline)
+
+ char[] chars = str.toCharArray ();
+ int l = chars.length;
+
+ // are we currently within a < and a >?
+ boolean insideTag=false;
+ // if we are inside a tag, we encode everything to make
+ // documentation work easier
+ boolean insideCodeTag = false;
+ // the difference between swallowOneNewline and ignoreNewline is that
+ // swallowOneNewline is just effective once (for the next newline)
boolean ignoreNewline = false;
boolean swallowOneNewline = false;
- StringBuffer tag = new StringBuffer ();
-
+
for (int i=0; i");
- if (!tagOpen)
- swallowOneNewline = false;
+ case '&':
+ // check if this is an HTML entity already, in which case we pass it though unchanged
+ if (i < l-4 && !insideCodeTag) {
+ // is this a numeric entity?
+ if (chars[i+1] == '#' ) {
+ int j = i+2;
+ while (j tagStart && j < l) {
+ String tagName = new String (chars, tagStart, j-tagStart).toLowerCase ();
+ if ("code".equals (tagName) && insideCloseTag && insideCodeTag)
+ insideCodeTag = false;
+ if (allTags.contains (tagName) && !insideCodeTag) {
+ insideTag = true;
+ ret.append ('<');
+ // set ignoreNewline on some tags, depending on wheather they're
+ // being opened or closed.
+ // what's going on here? we switch newline encoding on inside some tags, for
+ // others we switch it on when they're closed
+ if (encodeLinebreakTags.contains (tagName)) {
+ ignoreNewline = insideCloseTag;
+ swallowOneNewline = true;
+ } else if (suppressLinebreakTags.contains (tagName)) {
+ ignoreNewline = !insideCloseTag;
+ swallowOneNewline = true;
+ } else if ("p".equalsIgnoreCase (tagName) ||
+ "blockquote".equalsIgnoreCase (tagName) ||
+ "bq".equalsIgnoreCase (tagName)) {
+ swallowOneNewline = true;
+ }
+ if ("code".equals (tagName) && !insideCloseTag)
+ insideCodeTag = true;
+ break;
+ }
+ }
+ } // if (i < l-2)
+ ret.append ("<");
+ break;
+ case '\n':
+ ret.append ('\n');
+ if (!insideTag && !ignoreNewline && !swallowOneNewline)
+ ret.append ("
");
+ if (!insideTag)
+ swallowOneNewline = false;
break;
case '>':
- tagOpen = false;
- ret.append ('>');
+ if (insideTag)
+ ret.append ('>');
+ else
+ ret.append (">");
+ insideTag = false;
break;
default:
- // ret.append (c);
- if (c < 128)
- ret.append (c);
- else if (c >= 128 && c < 256)
- ret.append (transform[c-128]);
- else {
- ret.append ("&#");
- ret.append ((int) c);
- ret.append (";");
- }
- if (!tagOpen && !Character.isWhitespace (c))
- swallowOneNewline = false;
+ // ret.append (c);
+ if (c < 128)
+ ret.append (c);
+ else if (c >= 128 && c < 256)
+ ret.append (transform[c-128]);
+ else {
+ ret.append ("&#");
+ ret.append ((int) c);
+ ret.append (";");
+ }
+ if (!insideTag && !Character.isWhitespace (c))
+ swallowOneNewline = false;
}
}
}
|