Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.w3c.tidy5.PPrint Maven / Gradle / Ivy
/*
* Java HTML Tidy - JTidy
* HTML parser and pretty printer
*
* Copyright (c) 1998-2000 World Wide Web Consortium (Massachusetts
* Institute of Technology, Institut National de Recherche en
* Informatique et en Automatique, Keio University). All Rights
* Reserved.
*
* Contributing Author(s):
*
* Dave Raggett
* Andy Quick (translation to Java)
* Gary L Peskin (Java development)
* Sami Lempinen (release management)
* Fabrizio Giustina
*
* The contributing author(s) would like to thank all those who
* helped with testing, bug fixes, and patience. This wouldn't
* have been possible without all of you.
*
* COPYRIGHT NOTICE:
*
* This software and documentation is provided "as is," and
* the copyright holders and contributing author(s) make no
* representations or warranties, express or implied, including
* but not limited to, warranties of merchantability or fitness
* for any particular purpose or that the use of the software or
* documentation will not infringe any third party patents,
* copyrights, trademarks or other rights.
*
* The copyright holders and contributing author(s) will not be
* liable for any direct, indirect, special or consequential damages
* arising out of any use of the software or documentation, even if
* advised of the possibility of such damage.
*
* Permission is hereby granted to use, copy, modify, and distribute
* this source code, or portions hereof, documentation and executables,
* for any purpose, without fee, subject to the following restrictions:
*
* 1. The origin of this source code must not be misrepresented.
* 2. Altered versions must be plainly marked as such and must
* not be misrepresented as being the original source.
* 3. This Copyright notice may not be removed or altered from any
* source or altered source distribution.
*
* The copyright holders and contributing author(s) specifically
* permit, without fee, and encourage the use of this source code
* as a component for supporting the Hypertext Markup Language in
* commercial products. If you use this source code in a product,
* acknowledgment is not required but would be appreciated.
*
*/
package org.w3c.tidy5;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.NumberFormat;
/**
* Pretty print parse tree. Block-level and unknown elements are printed on new lines and their contents indented 2
* spaces Inline elements are printed inline. Inline content is wrapped on spaces (except in attribute values or
* preformatted text, after start tags and before end tags.
* @author Dave Raggett [email protected] [email protected] true if the current char follows a space
*/
private static boolean afterSpace(Node node)
{
Node prev;
int c;
if (node == null || node.tag == null || !TidyUtils.toBoolean(node.tag.model & Dict.CM_INLINE))
{
return true;
}
prev = node.prev;
if (prev != null)
{
if (prev.type == Node.TEXT_NODE && prev.end > prev.start)
{
c = (prev.textarray[prev.end - 1]) & 0xFF; // Convert to unsigned.
if (c == 160 || c == ' ' || c == '\n')
{
return true;
}
}
return false;
}
return afterSpace(node.parent);
}
/**
* @param lexer
* @param fout
* @param mode
* @param indent
* @param node
*/
private void printTag(Lexer lexer, Out fout, short mode, int indent, Node node)
{
String p;
TagTable tt = this.configuration.tt;
addC('<', linelen++);
if (node.type == Node.END_TAG)
{
addC('/', linelen++);
}
p = node.element;
for (int i = 0; i < p.length(); i++)
{
addC(
TidyUtils.foldCase(p.charAt(i), this.configuration.upperCaseTags, this.configuration.xmlTags),
linelen++);
}
printAttrs(fout, indent, node, node.attributes);
if ((this.configuration.xmlOut || this.configuration.xHTML)
&& (node.type == Node.START_END_TAG || TidyUtils.toBoolean(node.tag.model & Dict.CM_EMPTY)))
{
addC(' ', linelen++); // Space is NS compatibility hack true if node is inside an HEAD tag
*/
private boolean insideHead(Node node)
{
if (node.tag == this.configuration.tt.tagHead)
{
return true;
}
if (node.parent != null)
{
return insideHead(node.parent);
}
return false;
}
/**
* Is text node and already ends w/ a newline? Used to pretty print CDATA/PRE text content. If it already ends on a
* newline, it is not necessary to print another before printing end tag.
* @param lexer Lexer
* @param node text node
* @return text indent
*/
private int textEndsWithNewline(Lexer lexer, Node node)
{
if (node.type == Node.TEXT_NODE && node.end > node.start)
{
int ch, ix = node.end - 1;
// Skip non-newline whitespace
while (ix >= node.start
&& TidyUtils.toBoolean(ch = (node.textarray[ix] & 0xff))
&& (ch == ' ' || ch == '\t' || ch == '\r'))
{
--ix;
}
if (ix >= 0 && node.textarray[ix] == '\n')
{
return node.end - ix - 1; // #543262 tidy eats all memory
}
}
return -1;
}
/**
* Does the current node contain a CDATA section?
* @param lexer Lexer
* @param node Node
* @return true if node contains a CDATA section
*/
static boolean hasCDATA(Lexer lexer, Node node)
{
// Scan forward through the textarray. Since the characters we're
// looking for are < 0x7f, we don't have to do any UTF-8 decoding.
if (node.type != Node.TEXT_NODE)
{
return false;
}
int len = node.end - node.start + 1;
String start = TidyUtils.getString(node.textarray, node.start, len);
int indexOfCData = start.indexOf(CDATA_START);
return indexOfCData > -1 && indexOfCData <= len;
}
/**
* Print script and style elements. For XHTML, wrap the content as follows:
*
*
* JavaScript:
* //<![CDATA[
* content
* //]]>
* VBScript:
* '<![CDATA[
* content
* ']]>
* CSS:
* /*<![CDATA[* /
* content
* /*]]>* /
* other:
* <![CDATA[
* content
* ]]>
*
*
* @param fout
* @param mode
* @param indent
* @param lexer
* @param node
*/
private void printScriptStyle(Out fout, short mode, int indent, Lexer lexer, Node node)
{
Node content;
String commentStart = DEFAULT_COMMENT_START;
String commentEnd = DEFAULT_COMMENT_END;
boolean hasCData = false;
int contentIndent = -1;
if (insideHead(node))
{
// flushLine(fout, indent);
}
indent = 0;
// start script
printTag(lexer, fout, mode, indent, node);
// flushLine(fout, indent); // extra newline
if (lexer.configuration.xHTML && node.content != null)
{
AttVal type = node.getAttrByName("type");
if (type != null)
{
if ("text/javascript".equalsIgnoreCase(type.value))
{
commentStart = JS_COMMENT_START;
commentEnd = JS_COMMENT_END;
}
else if ("text/css".equalsIgnoreCase(type.value))
{
commentStart = CSS_COMMENT_START;
commentEnd = CSS_COMMENT_END;
}
else if ("text/vbscript".equalsIgnoreCase(type.value))
{
commentStart = VB_COMMENT_START;
commentEnd = VB_COMMENT_END;
}
}
hasCData = hasCDATA(lexer, node.content);
if (!hasCData)
{
// disable wrapping
int savewraplen = lexer.configuration.wraplen;
lexer.configuration.wraplen = 0xFFFFFF; // a very large number
linelen = addAsciiString(commentStart, linelen);
linelen = addAsciiString(CDATA_START, linelen);
linelen = addAsciiString(commentEnd, linelen);
condFlushLine(fout, indent);
// restore wrapping
lexer.configuration.wraplen = savewraplen;
}
}
for (content = node.content; content != null; content = content.next)
{
printTree(fout, (short) (mode | PREFORMATTED | NOWRAP | CDATA), 0, lexer, content);
if (content.next == null)
{
contentIndent = textEndsWithNewline(lexer, content);
}
}
if (contentIndent < 0)
{
condFlushLine(fout, indent);
contentIndent = 0;
}
if (lexer.configuration.xHTML && node.content != null)
{
if (!hasCData)
{
// disable wrapping
int ix, savewraplen = lexer.configuration.wraplen;
lexer.configuration.wraplen = 0xFFFFFF; // a very large number
// Add spaces to last text node to align w/ indent
if (contentIndent > 0 && linelen < contentIndent)
{
linelen = contentIndent;
}
for (ix = 0; contentIndent < indent && ix < indent - contentIndent; ++ix)
{
addC(' ', linelen++);
}
linelen = addAsciiString(commentStart, linelen);
linelen = addAsciiString(CDATA_END, linelen);
linelen = addAsciiString(commentEnd, linelen);
// restore wrapping
lexer.configuration.wraplen = savewraplen;
condFlushLine(fout, 0);
}
}
printEndTag(mode, indent, node);
if (!lexer.configuration.indentContent && node.next != null
&& !((node.tag != null && TidyUtils.toBoolean(node.tag.model & Dict.CM_INLINE))
|| node.type != Node.TEXT_NODE
))
{
flushLine(fout, indent);
}
flushLine(fout, indent);
}
/**
* Should tidy indent the give tag?
* @param node actual node
* @return true if line should be indented
*/
private boolean shouldIndent(Node node)
{
TagTable tt = this.configuration.tt;
if (!this.configuration.indentContent)
{
return false;
}
if (this.configuration.smartIndent)
{
if (node.content != null && TidyUtils.toBoolean(node.tag.model & Dict.CM_NO_INDENT))
{
for (node = node.content; node != null; node = node.next)
{
if (node.tag != null && TidyUtils.toBoolean(node.tag.model & Dict.CM_BLOCK))
{
return true;
}
}
return false;
}
if (TidyUtils.toBoolean(node.tag.model & Dict.CM_HEADING))
{
return false;
}
if (node.tag == tt.tagP)
{
return false;
}
if (node.tag == tt.tagTitle)
{
return false;
}
}
if (TidyUtils.toBoolean(node.tag.model & (Dict.CM_FIELD | Dict.CM_OBJECT)))
{
return true;
}
if (node.tag == tt.tagMap)
{
return true;
}
return !TidyUtils.toBoolean(node.tag.model & Dict.CM_INLINE);
}
/**
* Print just the content of the body element. Useful when you want to reuse material from other documents.
* @param fout
* @param lexer
* @param root
* @param xml
*/
void printBody(Out fout, Lexer lexer, Node root, boolean xml)
{
if (root == null)
{
return;
}
// Feature request #434940 - fix by Dave Raggett/Ignacio Vazquez-Abrams 21 Jun 01
// Sebastiano Vigna
Node body = root.findBody(lexer.configuration.tt);
if (body != null)
{
Node content;
for (content = body.content; content != null; content = content.next)
{
if (xml)
{
printXMLTree(fout, (short) 0, 0, lexer, content);
}
else
{
printTree(fout, (short) 0, 0, lexer, content);
}
}
}
}
/**
* @param fout
* @param mode
* @param indent
* @param lexer
* @param node
*/
public void printTree(Out fout, short mode, int indent, Lexer lexer, Node node)
{
Node content, last;
TagTable tt = this.configuration.tt;
if (node == null)
{
return;
}
if (node.type == Node.TEXT_NODE || (node.type == Node.CDATA_TAG && lexer.configuration.escapeCdata))
{
printText(fout, mode, indent, node.textarray, node.start, node.end);
}
else if (node.type == Node.COMMENT_TAG)
{
printComment(fout, indent, node);
}
else if (node.type == Node.ROOT_NODE)
{
for (content = node.content; content != null; content = content.next)
{
printTree(fout, mode, indent, lexer, content);
}
}
else if (node.type == Node.DOCTYPE_TAG)
{
printDocType(fout, indent, lexer, node);
}
else if (node.type == Node.PROC_INS_TAG)
{
printPI(fout, indent, node);
}
else if (node.type == Node.XML_DECL)
{
printXmlDecl(fout, indent, node);
}
else if (node.type == Node.CDATA_TAG)
{
printCDATA(fout, indent, node);
}
else if (node.type == Node.SECTION_TAG)
{
printSection(fout, indent, node);
}
else if (node.type == Node.ASP_TAG)
{
printAsp(fout, indent, node);
}
else if (node.type == Node.JSTE_TAG)
{
printJste(fout, indent, node);
}
else if (node.type == Node.PHP_TAG)
{
printPhp(fout, indent, node);
}
else if (TidyUtils.toBoolean(node.tag.model & Dict.CM_EMPTY)
|| (node.type == Node.START_END_TAG && !configuration.xHTML))
{
if (!TidyUtils.toBoolean(node.tag.model & Dict.CM_INLINE))
{
condFlushLine(fout, indent);
}
if (node.tag == tt.tagBr
&& node.prev != null
&& node.prev.tag != tt.tagBr
&& this.configuration.breakBeforeBR)
{
flushLine(fout, indent);
}
if (this.configuration.makeClean && node.tag == tt.tagWbr)
{
printString(" ");
}
else
{
printTag(lexer, fout, mode, indent, node);
}
if (node.tag == tt.tagParam || node.tag == tt.tagArea)
{
condFlushLine(fout, indent);
}
else if (node.tag == tt.tagBr || node.tag == tt.tagHr)
{
flushLine(fout, indent);
}
}
else
{
if (node.type == Node.START_END_TAG)
{
node.type = Node.START_TAG;
}
// some kind of container element
if (node.tag != null && node.tag.getParser() == ParserImpl.PRE)
{
condFlushLine(fout, indent);
indent = 0;
condFlushLine(fout, indent);
printTag(lexer, fout, mode, indent, node);
flushLine(fout, indent);
for (content = node.content; content != null; content = content.next)
{
printTree(fout, (short) (mode | PREFORMATTED | NOWRAP), indent, lexer, content);
}
condFlushLine(fout, indent);
printEndTag(mode, indent, node);
flushLine(fout, indent);
if (!this.configuration.indentContent && node.next != null)
{
flushLine(fout, indent);
}
}
else if (node.tag == tt.tagStyle || node.tag == tt.tagScript)
{
printScriptStyle(fout, (short) (mode | PREFORMATTED | NOWRAP | CDATA), indent, lexer, node);
}
else if (TidyUtils.toBoolean(node.tag.model & Dict.CM_INLINE))
{
if (this.configuration.makeClean)
{
// discards and tags
if (node.tag == tt.tagFont)
{
for (content = node.content; content != null; content = content.next)
{
printTree(fout, mode, indent, lexer, content);
}
return;
}
// replace ... by or etc.
if (node.tag == tt.tagNobr)
{
for (content = node.content; content != null; content = content.next)
{
printTree(fout, (short) (mode | NOWRAP), indent, lexer, content);
}
return;
}
}
// otherwise a normal inline element
printTag(lexer, fout, mode, indent, node);
// indent content for SELECT, TEXTAREA, MAP, OBJECT and APPLET
if (shouldIndent(node))
{
condFlushLine(fout, indent);
indent += this.configuration.spaces;
for (content = node.content; content != null; content = content.next)
{
printTree(fout, mode, indent, lexer, content);
}
condFlushLine(fout, indent);
indent -= this.configuration.spaces;
condFlushLine(fout, indent);
}
else
{
for (content = node.content; content != null; content = content.next)
{
printTree(fout, mode, indent, lexer, content);
}
}
printEndTag(mode, indent, node);
}
else
{
// other tags
condFlushLine(fout, indent);
if (this.configuration.smartIndent && node.prev != null)
{
flushLine(fout, indent);
}
// do not omit elements with attributes
if (!this.configuration.hideEndTags
|| !(node.tag != null && TidyUtils.toBoolean(node.tag.model & Dict.CM_OMITST))
|| node.attributes != null)
{
printTag(lexer, fout, mode, indent, node);
if (shouldIndent(node))
{
condFlushLine(fout, indent);
}
else if (TidyUtils.toBoolean(node.tag.model & Dict.CM_HTML)
|| node.tag == tt.tagNoframes
|| (TidyUtils.toBoolean(node.tag.model & Dict.CM_HEAD) && !(node.tag == tt.tagTitle)))
{
flushLine(fout, indent);
}
}
if (node.tag == tt.tagBody && this.configuration.burstSlides)
{
printSlide(fout, mode, (this.configuration.indentContent
? indent + this.configuration.spaces
: indent), lexer);
}
else
{
last = null;
for (content = node.content; content != null; content = content.next)
{
// kludge for naked text before block level tag
if (last != null
&& !this.configuration.indentContent
&& last.type == Node.TEXT_NODE
&& content.tag != null
&& !TidyUtils.toBoolean(content.tag.model & Dict.CM_INLINE))
{
flushLine(fout, indent);
}
printTree(
fout,
mode,
(shouldIndent(node) ? indent + this.configuration.spaces : indent),
lexer,
content);
last = content;
}
}
// don't flush line for td and th
if (shouldIndent(node)
|| ((TidyUtils.toBoolean(node.tag.model & Dict.CM_HTML) || node.tag == tt.tagNoframes || //
(TidyUtils.toBoolean(node.tag.model & Dict.CM_HEAD) && !(node.tag == tt.tagTitle))) && //
!this.configuration.hideEndTags))
{
condFlushLine(
fout,
(this.configuration.indentContent ? indent + this.configuration.spaces : indent));
if (!this.configuration.hideEndTags || !TidyUtils.toBoolean(node.tag.model & Dict.CM_OPT))
{
printEndTag(mode, indent, node);
// #603128 tidy adds newslines after 