Pretty printing XML

[William Barnes]

Has anyone seen code that will pretty print my XML? Something with less over-head than a real parser? Thanks.

[Balaji Loganathan]

Hi,
One of the IBM DOM tutorial says that
System.out.println(root.toString()); will print the XML in a non-normalized way,its also say that you may not see the output pretty printed due to version conflict,you can give a try with ur java version.

System.out.println("***************Non-Normalized************");
System.out.println(root.toString());
System.out.println("***************Normalized************");
root.normalize();
System.out.println(root.toString());

[William Barnes]

Really?
And 'root' is the xml string? Or a DOM thing? (I am new to DOM/SAX)

[Balaji Loganathan]

The tutorial(understanding DOM) is at DOM tutorial,you can good intro to DOM there.

[William Barnes]

That tutorial was very helpful.
But the print out is giving me [<the doc root>: null] which isn't even ugly.
A note on one of the pages says: "If the application does not print out the structure of the root element, check the CLASSPATH. The JAXP jar files must appear first if other XML implementations are also present. If you are using Java 2 SDK version 1.4, the output may look "pretty printed"."
I am not running 1.4, do you know what they mean by JAXP?
My code:

  
import javax.xml.parsers.DocumentBuilder ;
import javax.xml.parsers.DocumentBuilderFactory ;
import java.io.File ;
import org.w3c.dom.Document ;
import org.w3c.dom.Element ;
public class dom_test
{
    public static void main( String Args[])
    {
        if( Args.length == 0)
        {
            System.out.println("Usage: dom_test <xml file>") ;
            System.exit(1) ;
        }
        String xmlFile = Args[ 0 ] ;
        
        File docFile = new File( xmlFile) ;
        if( !docFile.exists())
        {
            System.out.println("File " + xmlFile + " doesn't exist.") ;
            System.exit(1) ;
        }
        if( !docFile.canRead())
        {
            System.out.println("File " + xmlFile + " not read-able.") ;
            System.exit(1) ;
        }
        Document doc = null ;
        try
        {
            DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance() ;
            DocumentBuilder db = dbf.newDocumentBuilder() ;
            doc = db.parse( docFile) ;
            Element root = doc.getDocumentElement() ;
            System.out.println("The root element is " + root.getNodeName()) ;
            System.out.println("Non normilized xml pretty print") ;
            System.out.println( root.toString()) ;
            System.out.println("Normilized xml pretty print") ;
            root.normalize() ;
            System.out.println( root.toString()) ;
        }
        catch( javax.xml.parsers.ParserConfigurationException pce) 
        {
            System.out.println("The parser was not configured correctly.");
            System.exit(1);
        } 
        catch( java.io.IOException ie) 
        {
            System.out.println("Cannot read input file.");
            System.exit(1);
        } 
        catch( org.xml.sax.SAXException se) 
        {
            System.out.println("Problem parsing the file.");
            se.printStackTrace() ;
            System.exit(1);
        } 
        catch( java.lang.IllegalArgumentException ae) 
        {
            System.out.println("Please specify an XML source.");
            System.exit(1);
        }
    }
}

[William Barnes]

Related thread
I tried lots of different solutions, not all of them I am sure, but I ended up writing my own. It is a basic state engine, no tree or anything like that. It handles attributes and subscripts.

  
   private static final char LESSTHAN      = '<' ;
    private static final char GREATERTHAN   = '>' ;
    private static final char SLASH         = '/' ;
    private static final char SPACE         = ' ' ;
    private static final char DOUBLE_QUOTES = '"' ;
    private static final String RESET     = "Reset" ;
    private static final String BEGIN_TAG = "Begin_tag" ;
    private static final String END_TAG   = "End_tag" ;
    private static final String DATA      = "Data" ;
    private static final String ATTR      = "Attr" ;
    private static final String XML_TAG   = "Xml_Tag" ;
    private static final String DOC_TAG   = "Doc_Tag" ;

    private void PrettyPrintXml( String p_Response)
    {
        String BeginTagName = "" ;
        String EndTagName = "" ;
        String Attri = "" ;            // Data in begin tag.
        String Data = "" ;             // Data between begin and end tags.
        String DocumentTag = "" ;
        String XmlTag = "" ;
        boolean SkippedOverSlash = false ;
        String State = RESET ;
        int IndentLevel = 0 ;
        int i, j ;
        int len = p_Response.length() ;
        for( i=0; i < len; i++)
        {
            // m_Out.println(" =] " + XmlInput.charAt(i) + " [= ") ;
            if( State == RESET)
            {
                if( p_Response.charAt(i) == ' ') 
                {
                    continue ;                              // Ignore space
                }
                if( p_Response.charAt(i) == LESSTHAN)         
                {
                    if( p_Response.charAt(i+1) == SLASH)        
                    {
                        State = END_TAG ;                      // END_TAG
                        continue ;
                    }
                    else if( p_Response.charAt(i+1) == '?')
                    {
                        State = XML_TAG ;                      // XML_TAG
                        continue ;
                    }
                    else if( p_Response.charAt(i+1) == '!')
                    {
                        State = DOC_TAG ;                      // DOC_TAG
                        continue ;
                    }
                    else 
                    {
                        State = BEGIN_TAG ;                    // BEGIN_TAG
                        continue ;
                    }
                }
                else // We have data
                {
                    State = DATA ;                             // DATA
                    Data += p_Response.charAt(i) ;
                    continue ;
                }
            }
            //----------------------------------------
            // Process the start tag.
            //
            if( State == BEGIN_TAG)
            {
                if(( p_Response.charAt(i) != ' ') &&
                   ( p_Response.charAt(i) != GREATERTHAN))     
                {
                    BeginTagName += p_Response.charAt( i ) ;
                }
                else // Done reading in begin tag.
                {
                    if( p_Response.charAt(i) == ' ')
                    {
                        // There is data in this tag.
                        //
                        State = ATTR ;                             // ATTR
                    }
                    else
                    {
                        State = RESET ;                            // RESET
                    }
                        
                    for( j=0; j < IndentLevel; j++)
                    {
                        m_Out.print("   ") ;
                    }
                    if( State == RESET)
                    {
                        m_Out.println("<" + BeginTagName + ">") ;
                    }
                    else // ATTR
                    {
                        m_Out.print("<" + BeginTagName + " ") ;
                    }
                    BeginTagName = "" ;
                    IndentLevel++ ;
                }
                continue ;
            }
            //----------------------------------------
            // Process the end tag.
            //
            if( State == END_TAG)
            {
                if( !SkippedOverSlash)
                {
                    SkippedOverSlash = true ;
                    continue ;
                }
                else
                {
                    if( p_Response.charAt(i) != GREATERTHAN)        
                    {
                        EndTagName += p_Response.charAt(i) ;
                    }
                    else // Done reading in end tag.
                    {
                        IndentLevel-- ;
                        for( j=0; j < IndentLevel; j++)
                        {
                            m_Out.print("   ") ;
                        }
                        m_Out.println("</" + EndTagName + ">") ;
                        EndTagName = "" ;
                        SkippedOverSlash = false ;
                        State = RESET ;                            // RESET
                    }
                    continue ;
                }
            }
            //----------------------------------------
            // Process attributes (stuff found inside of start tag)
            //
            // Examples of data (in start tag):
            //
            // <customer_idx count="6"/>
            // <customerid limit="1000">12341</customerid>
            // <xmldata one="A B C" two="D E"/>
            //
            // Example of subscripts:
            //
            // <BROKERAGE_POSITION SUBSCR="[3]">
            //    <LIST_ACCT_NUM SUBSCR="[3]">014TS0060</LIST_ACCT_NUM>
            //    <CUSIP SUBSCR="[3]">3169103</CUSIP>
            // </BROKERAGE_POSITION>
            // 
            //
            if( State == ATTR)
            {
                if( p_Response.charAt(i) != GREATERTHAN)
                {
                    // As long as '>' not seen keep reading in attribute
                    //
                    Attri += p_Response.charAt(i) ;
                }
                else
                {
                    // Reached end of start tag, print out all attributes
                    // found.  This can be on one or more lines.
                    //
                    if( Attri.length() >= 6)
                    {
                        String subStr = Attri.substring( 0, 6) ;
                        if( subStr.compareToIgnoreCase("SUBSCR") == 0) 
                        {
                            // Subscript attribute found.
                            //
                            m_Out.println( Attri + ">") ;
                            Attri = "" ;
                            State = RESET ;                            // RESET
                            continue ;
                        }
                    }
                    // Non-subscript attribute processing follows:
                    //
                    boolean InsideValue = false ;
                    int attrLen = Attri.length() ;
                    m_Out.println() ;            
                    for( j=0; j < IndentLevel; j++)
                    {
                        m_Out.print("   ") ;
                    }
                    for( j=0; j < attrLen; j++)
                    {
                        // In many cases there will only be one
                        // attribute so this loop only gets done once.
                        //
                        if( Attri.charAt(j) == SLASH)
                        {
                            break ; 
                        }
                        if( Attri.charAt(j) == DOUBLE_QUOTES)
                        {
                            InsideValue = !InsideValue ;
                        }
                        if(( Attri.charAt(j) != SPACE) ||
                           ( Attri.charAt(j) == SPACE) &&
                           ( InsideValue))
                        {
                            // If this isn't a space OR 
                            // if it is a space as part of a value 
                            // than print it.
                            //
                            m_Out.print( Attri.charAt(j)) ;
                        }
                        else 
                        {
                            // There is more than one attribute, so
                            // need to start on a new live and indent.
                            //
                            m_Out.println() ;
                            for( int inden=0; inden < IndentLevel; inden++)
                            {
                                m_Out.print("   ") ;
                            }
                        }
                    }                                           // End for
                    if( Attri.charAt( attrLen-1) == SLASH)
                    {
                        // If the last char was '/' than there will be no
                        // END tag for this, so adjust the indent level.
                        //
                        IndentLevel-- ;
                        m_Out.println() ;
                        for( int inden=0; inden < IndentLevel; inden++)
                        {
                            m_Out.print("   ") ;
                        }
                        m_Out.println("/>") ;
                    }
                    else // Normal end of begin tag.
                    {
                        m_Out.println(">") ;
                    }
                    Attri = "" ;
                    State = RESET ;                                  // RESET
                }
                continue ;
            }
            //----------------------------------------
            // Process data
            //
            if( State == DATA)
            {
                if( p_Response.charAt(i) != LESSTHAN)
                {
                    Data += p_Response.charAt(i) ;
                }
                else 
                {
                    for( j=0; j < IndentLevel; j++)
                    {
                        m_Out.print("   ") ;
                    }
                    m_Out.println( Data ) ;
                    Data = "" ;
                    State = END_TAG ;                            // END_TAG
                }
                continue ;
            }
            //----------------------------------------
            // Process xml tag
            //
            // Example: <?xml version="1.0" encoding="UTF-8"?>
            //
            if( State == XML_TAG)
            {
                if( p_Response.charAt(i) != GREATERTHAN)
                {
                    XmlTag += p_Response.charAt(i) ;
                }
                else
                {
                    for( j=0; j < IndentLevel; j++)
                    {
                        m_Out.print("   ") ;
                    }
                    m_Out.println("<" + XmlTag + ">") ;
                    XmlTag = "" ;
                    State = RESET ;                                // RESET
                }
                continue ;
            }
            //----------------------------------------
            // Process doc type tag
            //
            // Example: <!DOCTYPE ORDERS SYSTEM "orders.dtd">
            //
            if( State == DOC_TAG)
            {
                if( p_Response.charAt(i) != GREATERTHAN)
                {
                    DocumentTag += p_Response.charAt(i) ;
                }
                else
                {
                    for( j=0; j < IndentLevel; j++)
                    {
                        m_Out.print("   ") ;
                    }
                    m_Out.println("<" + DocumentTag + ">") ;
                    DocumentTag = "" ;
                    State = RESET ;                                // RESET
                }
                continue ;
            }
        }          // End for
    }              // End PrettyPrintXml()

[ October 08, 2002: Message edited by: William Barnes ]
[ October 08, 2002: Message edited by: William Barnes ]