public Writer() 
{
    //
    // Constructors
    //
}

Default constructor.

 public  void characters(char[] ch,
    int start,
    int length) throws SAXException 
{
        if (!fInCDATA) {
            normalizeAndPrint(ch, start, length, false);
        }
        else {
            for (int i = 0; i <  length; ++i) {
            	fOut.print(ch[start+i]);
            }
        }
        fOut.flush();
}

Characters.

 public  void comment(char[] ch,
    int start,
    int length) throws SAXException 
{
        if (!fCanonical && fElementDepth  > 0) {
            fOut.print("< !--");
            for (int i = 0; i <  length; ++i) {
                fOut.print(ch[start+i]);
            }
            fOut.print("-- >");
            fOut.flush();
        }
}

Comment.

 public  void endCDATA() throws SAXException 
{
        if (!fCanonical) {
            fInCDATA = false;
            fOut.print("]] >");
        }
}

End CDATA section.

 public  void endDTD() throws SAXException 
{

}

End DTD.

 public  void endElement(String uri,
    String local,
    String raw) throws SAXException 
{
        fElementDepth--;
        fOut.print("< /");
        fOut.print(raw);
        fOut.print(' >");
        fOut.flush();
}

End element.

 public  void endEntity(String name) throws SAXException 
{

}

End entity.

 public  void error(SAXParseException ex) throws SAXException 
{
        printError("Error", ex);
}

Error.

 public  void fatalError(SAXParseException ex) throws SAXException 
{
        printError("Fatal Error", ex);
        throw ex;
}

Fatal error.

 protected String getVersion() 
{
        if (fLocator == null) {
            return null;
        }
        String version = null;
        Method getXMLVersion = null;
        try {
            getXMLVersion = fLocator.getClass().getMethod("getXMLVersion", new Class[]{});
            // If Locator implements Locator2, this method will exist.
            if (getXMLVersion != null) {
                version = (String) getXMLVersion.invoke(fLocator, (Object[]) null);
            }
        } 
        catch (Exception e) { 
            // Either this locator object doesn't have 
            // this method, or we're on an old JDK.
        }
        return version;
}

Extracts the XML version from the Locator.

 public  void ignorableWhitespace(char[] ch,
    int start,
    int length) throws SAXException 
{
        characters(ch, start, length);
        fOut.flush();
}

Ignorable whitespace.

 public static  void main(String[] argv) 
{
        // is there anything to do?
        if (argv.length == 0) {
            printUsage();
            System.exit(1);
        }
        // variables
        Writer writer = null;
        XMLReader parser = null;
        boolean namespaces = DEFAULT_NAMESPACES;
        boolean namespacePrefixes = DEFAULT_NAMESPACE_PREFIXES;
        boolean validation = DEFAULT_VALIDATION;
        boolean externalDTD = DEFAULT_LOAD_EXTERNAL_DTD;
        boolean schemaValidation = DEFAULT_SCHEMA_VALIDATION;
        boolean schemaFullChecking = DEFAULT_SCHEMA_FULL_CHECKING;
        boolean honourAllSchemaLocations = DEFAULT_HONOUR_ALL_SCHEMA_LOCATIONS;
        boolean validateAnnotations = DEFAULT_VALIDATE_ANNOTATIONS;
        boolean generateSyntheticAnnotations = DEFAULT_GENERATE_SYNTHETIC_ANNOTATIONS;
        boolean dynamicValidation = DEFAULT_DYNAMIC_VALIDATION;
        boolean xincludeProcessing = DEFAULT_XINCLUDE;
        boolean xincludeFixupBaseURIs = DEFAULT_XINCLUDE_FIXUP_BASE_URIS;
        boolean xincludeFixupLanguage = DEFAULT_XINCLUDE_FIXUP_LANGUAGE;
        boolean canonical = DEFAULT_CANONICAL;
        // process arguments
        for (int i = 0; i <  argv.length; i++) {
            String arg = argv[i];
            if (arg.startsWith("-")) {
                String option = arg.substring(1);
                if (option.equals("p")) {
                    // get parser name
                    if (++i == argv.length) {
                        System.err.println("error: Missing argument to -p option.");
                    }
                    String parserName = argv[i];
                    // create parser
                    try {
                        parser = XMLReaderFactory.createXMLReader(parserName);
                    }
                    catch (Exception e) {
                        try {
                            Parser sax1Parser = ParserFactory.makeParser(parserName);
                            parser = new ParserAdapter(sax1Parser);
                            System.err.println("warning: Features and properties not supported on SAX1 parsers.");
                        }
                        catch (Exception ex) {
                            parser = null;
                            System.err.println("error: Unable to instantiate parser ("+parserName+")");
                            e.printStackTrace(System.err);
                        }
                    }
                    continue;
                }
                if (option.equalsIgnoreCase("n")) {
                    namespaces = option.equals("n");
                    continue;
                }
                if (option.equalsIgnoreCase("np")) {
                    namespacePrefixes = option.equals("np");
                    continue;
                }
                if (option.equalsIgnoreCase("v")) {
                    validation = option.equals("v");
                    continue;
                }
                if (option.equalsIgnoreCase("xd")) {
                    externalDTD = option.equals("xd");
                    continue;
                }
                if (option.equalsIgnoreCase("s")) {
                    schemaValidation = option.equals("s");
                    continue;
                }
                if (option.equalsIgnoreCase("f")) {
                    schemaFullChecking = option.equals("f");
                    continue;
                }
                if (option.equalsIgnoreCase("hs")) {
                    honourAllSchemaLocations = option.equals("hs");
                    continue;
                }
                if (option.equalsIgnoreCase("va")) {
                    validateAnnotations = option.equals("va");
                    continue;
                }
                if (option.equalsIgnoreCase("ga")) {
                    generateSyntheticAnnotations = option.equals("ga");
                    continue;
                }
                if (option.equalsIgnoreCase("dv")) {
                    dynamicValidation = option.equals("dv");
                    continue;
                }
                if (option.equalsIgnoreCase("xi")) {
                    xincludeProcessing = option.equals("xi");
                    continue;
                }
                if (option.equalsIgnoreCase("xb")) {
                    xincludeFixupBaseURIs = option.equals("xb");
                    continue;
                }
                if (option.equalsIgnoreCase("xl")) {
                    xincludeFixupLanguage = option.equals("xl");
                    continue;
                }
                if (option.equalsIgnoreCase("c")) {
                    canonical = option.equals("c");
                    continue;
                }
                if (option.equals("h")) {
                    printUsage();
                    continue;
                }
            }
            // use default parser?
            if (parser == null) {
                // create parser
                try {
                    parser = XMLReaderFactory.createXMLReader(DEFAULT_PARSER_NAME);
                }
                catch (Exception e) {
                    System.err.println("error: Unable to instantiate parser ("+DEFAULT_PARSER_NAME+")");
                    e.printStackTrace(System.err);
                    continue;
                }
            }
            // set parser features
            try {
                parser.setFeature(NAMESPACES_FEATURE_ID, namespaces);
            }
            catch (SAXException e) {
                System.err.println("warning: Parser does not support feature ("+NAMESPACES_FEATURE_ID+")");
            }
            try {
                parser.setFeature(NAMESPACE_PREFIXES_FEATURE_ID, namespacePrefixes);
            }
            catch (SAXException e) {
                System.err.println("warning: Parser does not support feature ("+NAMESPACE_PREFIXES_FEATURE_ID+")");
            }
            try {
                parser.setFeature(VALIDATION_FEATURE_ID, validation);
            }
            catch (SAXException e) {
                System.err.println("warning: Parser does not support feature ("+VALIDATION_FEATURE_ID+")");
            }
            try {
                parser.setFeature(LOAD_EXTERNAL_DTD_FEATURE_ID, externalDTD);
            }
            catch (SAXNotRecognizedException e) {
                System.err.println("warning: Parser does not recognize feature ("+LOAD_EXTERNAL_DTD_FEATURE_ID+")");
            }
            catch (SAXNotSupportedException e) {
                System.err.println("warning: Parser does not support feature ("+LOAD_EXTERNAL_DTD_FEATURE_ID+")");
            }
            try {
                parser.setFeature(SCHEMA_VALIDATION_FEATURE_ID, schemaValidation);
            }
            catch (SAXNotRecognizedException e) {
                System.err.println("warning: Parser does not recognize feature ("+SCHEMA_VALIDATION_FEATURE_ID+")");
            }
            catch (SAXNotSupportedException e) {
                System.err.println("warning: Parser does not support feature ("+SCHEMA_VALIDATION_FEATURE_ID+")");
            }
            try {
                parser.setFeature(SCHEMA_FULL_CHECKING_FEATURE_ID, schemaFullChecking);
            }
            catch (SAXNotRecognizedException e) {
                System.err.println("warning: Parser does not recognize feature ("+SCHEMA_FULL_CHECKING_FEATURE_ID+")");
            }
            catch (SAXNotSupportedException e) {
                System.err.println("warning: Parser does not support feature ("+SCHEMA_FULL_CHECKING_FEATURE_ID+")");
            }
            try {
                parser.setFeature(HONOUR_ALL_SCHEMA_LOCATIONS_ID, honourAllSchemaLocations);
            }
            catch (SAXNotRecognizedException e) {
                System.err.println("warning: Parser does not recognize feature ("+HONOUR_ALL_SCHEMA_LOCATIONS_ID+")");
            }
            catch (SAXNotSupportedException e) {
                System.err.println("warning: Parser does not support feature ("+HONOUR_ALL_SCHEMA_LOCATIONS_ID+")");
            }
            try {
                parser.setFeature(VALIDATE_ANNOTATIONS_ID, validateAnnotations);
            }
            catch (SAXNotRecognizedException e) {
                System.err.println("warning: Parser does not recognize feature ("+VALIDATE_ANNOTATIONS_ID+")");
            }
            catch (SAXNotSupportedException e) {
                System.err.println("warning: Parser does not support feature ("+VALIDATE_ANNOTATIONS_ID+")");
            }
            try {
                parser.setFeature(GENERATE_SYNTHETIC_ANNOTATIONS_ID, generateSyntheticAnnotations);
            }
            catch (SAXNotRecognizedException e) {
                System.err.println("warning: Parser does not recognize feature ("+GENERATE_SYNTHETIC_ANNOTATIONS_ID+")");
            }
            catch (SAXNotSupportedException e) {
                System.err.println("warning: Parser does not support feature ("+GENERATE_SYNTHETIC_ANNOTATIONS_ID+")");
            }
            try {
                parser.setFeature(DYNAMIC_VALIDATION_FEATURE_ID, dynamicValidation);
            }
            catch (SAXNotRecognizedException e) {
                System.err.println("warning: Parser does not recognize feature ("+DYNAMIC_VALIDATION_FEATURE_ID+")");
            }
            catch (SAXNotSupportedException e) {
                System.err.println("warning: Parser does not support feature ("+DYNAMIC_VALIDATION_FEATURE_ID+")");
            }
            try {
                parser.setFeature(XINCLUDE_FEATURE_ID, xincludeProcessing);
            }
            catch (SAXNotRecognizedException e) {
                System.err.println("warning: Parser does not recognize feature ("+XINCLUDE_FEATURE_ID+")");
            }
            catch (SAXNotSupportedException e) {
                System.err.println("warning: Parser does not support feature ("+XINCLUDE_FEATURE_ID+")");
            }
            try {
                parser.setFeature(XINCLUDE_FIXUP_BASE_URIS_FEATURE_ID, xincludeFixupBaseURIs);
            }
            catch (SAXNotRecognizedException e) {
                System.err.println("warning: Parser does not recognize feature ("+XINCLUDE_FIXUP_BASE_URIS_FEATURE_ID+")");
            }
            catch (SAXNotSupportedException e) {
                System.err.println("warning: Parser does not support feature ("+XINCLUDE_FIXUP_BASE_URIS_FEATURE_ID+")");
            }
            try {
                parser.setFeature(XINCLUDE_FIXUP_LANGUAGE_FEATURE_ID, xincludeFixupLanguage);
            }
            catch (SAXNotRecognizedException e) {
                System.err.println("warning: Parser does not recognize feature ("+XINCLUDE_FIXUP_LANGUAGE_FEATURE_ID+")");
            }
            catch (SAXNotSupportedException e) {
                System.err.println("warning: Parser does not support feature ("+XINCLUDE_FIXUP_LANGUAGE_FEATURE_ID+")");
            }
            // setup writer
            if (writer == null) {
                writer = new Writer();
                try {
                    writer.setOutput(System.out, "UTF8");
                }
                catch (UnsupportedEncodingException e) {
                    System.err.println("error: Unable to set output. Exiting.");
                    System.exit(1);
                }
            }
            // set parser
            parser.setContentHandler(writer);
            parser.setErrorHandler(writer);
            try {
                parser.setProperty(LEXICAL_HANDLER_PROPERTY_ID, writer);
            }
            catch (SAXException e) {
                // ignore
            }
            // parse file
            writer.setCanonical(canonical);
            try {
                parser.parse(arg);
            }
            catch (SAXParseException e) {
                // ignore
            }
            catch (Exception e) {
                System.err.println("error: Parse error occurred - "+e.getMessage());
                if (e instanceof SAXException) {
                    Exception nested = ((SAXException)e).getException();
                    if (nested != null) {
                        e = nested;
                    } 
                }
                e.printStackTrace(System.err);
            }
        }
}

Main program entry point.

 protected  void normalizeAndPrint(String s,
    boolean isAttValue) 
{
        int len = (s != null) ? s.length() : 0;
        for (int i = 0; i <  len; i++) {
            char c = s.charAt(i);
            normalizeAndPrint(c, isAttValue);
        }
}

Normalizes and prints the given string.

 protected  void normalizeAndPrint(char c,
    boolean isAttValue) 
{
        switch (c) {
            case '< ": {
                fOut.print("<");
                break;
            }
            case ' >": {
                fOut.print(">");
                break;
            }
            case '&": {
                fOut.print("&");
                break;
            }
            case '"": {
                // A '"' that appears in character data 
                // does not need to be escaped.
                if (isAttValue) {
                    fOut.print(""");
                }
                else {
                    fOut.print("\"");
                }
                break;
            }
            case '\r": {
            	// If CR is part of the document's content, it
            	// must not be printed as a literal otherwise
            	// it would be normalized to LF when the document
            	// is reparsed.
            	fOut.print("
");
            	break;
            }
            case '\n": {
                if (fCanonical) {
                    fOut.print("
");
                    break;
                }
                // else, default print char
            }
            default: {
                // In XML 1.1, control chars in the ranges [#x1-#x1F, #x7F-#x9F] must be escaped.
            	//
            	// Escape space characters that would be normalized to #x20 in attribute values
            	// when the document is reparsed.
            	//
            	// Escape NEL (0x85) and LSEP (0x2028) that appear in content 
            	// if the document is XML 1.1, since they would be normalized to LF 
            	// when the document is reparsed.
            	if (fXML11 && ((c  >= 0x01 && c < = 0x1F && c != 0x09 && c != 0x0A) 
            	    || (c  >= 0x7F && c < = 0x9F) || c == 0x2028)
            	    || isAttValue && (c == 0x09 || c == 0x0A)) {
            	    fOut.print("&#x");
            	    fOut.print(Integer.toHexString(c).toUpperCase());
            	    fOut.print(";");
                }
                else {
                    fOut.print(c);
                }        
            }
        }
}

Normalizes and print the given character.

 protected  void normalizeAndPrint(char[] ch,
    int offset,
    int length,
    boolean isAttValue) 
{
        for (int i = 0; i <  length; i++) {
            normalizeAndPrint(ch[offset + i], isAttValue);
        }
}

Normalizes and prints the given array of characters.

 protected  void printError(String type,
    SAXParseException ex) 
{
        System.err.print("[");
        System.err.print(type);
        System.err.print("] ");
        String systemId = ex.getSystemId();
        if (systemId != null) {
            int index = systemId.lastIndexOf('/");
            if (index != -1)
                systemId = systemId.substring(index + 1);
            System.err.print(systemId);
        }
        System.err.print(':");
        System.err.print(ex.getLineNumber());
        System.err.print(':");
        System.err.print(ex.getColumnNumber());
        System.err.print(": ");
        System.err.print(ex.getMessage());
        System.err.println();
        System.err.flush();
}

Prints the error message.

 public  void processingInstruction(String target,
    String data) throws SAXException 
{
        if (fElementDepth  > 0) {
            fOut.print("< ?");
            fOut.print(target);
            if (data != null && data.length()  > 0) {
                fOut.print(' ");
                fOut.print(data);
            }
            fOut.print("? >");
            fOut.flush();
        }
}

Processing instruction.

 public  void setCanonical(boolean canonical) 
{
        fCanonical = canonical;
}

Sets whether output is canonical.

 public  void setDocumentLocator(Locator locator) 
{
    	fLocator = locator;
}

Set Document Locator.

 public  void setOutput(Writer writer) 
{
        fOut = writer instanceof PrintWriter
             ? (PrintWriter)writer : new PrintWriter(writer);
}

Sets the output writer.

 public  void setOutput(OutputStream stream,
    String encoding) throws UnsupportedEncodingException 
{
        if (encoding == null) {
            encoding = "UTF8";
        }
        java.io.Writer writer = new OutputStreamWriter(stream, encoding);
        fOut = new PrintWriter(writer);
}

Sets the output stream for printing.

 protected Attributes sortAttributes(Attributes attrs) 
{
        AttributesImpl attributes = new AttributesImpl();
        int len = (attrs != null) ? attrs.getLength() : 0;
        for (int i = 0; i <  len; i++) {
            String name = attrs.getQName(i);
            int count = attributes.getLength();
            int j = 0;
            while (j <  count) {
                if (name.compareTo(attributes.getQName(j)) <  0) {
                    break;
                }
                j++;
            }
            attributes.insertAttributeAt(j, name, attrs.getType(i),
                                         attrs.getValue(i));
        }
        return attributes;
}

Returns a sorted list of attributes.

 public  void startCDATA() throws SAXException 
{
        if (!fCanonical) {
            fOut.print("< ![CDATA[");
            fInCDATA = true;
        }
}

Start CDATA section.

 public  void startDTD(String name,
    String publicId,
    String systemId) throws SAXException 
{

}

Start DTD.

 public  void startDocument() throws SAXException 
{
        fElementDepth = 0;
        fXML11 = false;
        fInCDATA = false;
}

Start document.

 public  void startElement(String uri,
    String local,
    String raw,
    Attributes attrs) throws SAXException 
{
        // Root Element
        if (fElementDepth == 0) {
            if (fLocator != null) {
                fXML11 = "1.1".equals(getVersion());
                fLocator = null;
            }
            // The XML declaration cannot be printed in startDocument because
            // the version reported by the Locator cannot be relied on until after
            // the XML declaration in the instance document has been read.
            if (!fCanonical) {
                if (fXML11) {
                    fOut.println("< ?xml version=\"1.1\" encoding=\"UTF-8\"? >");
                }
                else {
                    fOut.println("< ?xml version=\"1.0\" encoding=\"UTF-8\"? >");
                }
                fOut.flush();
            }
        }
        fElementDepth++;
        fOut.print('< ");
        fOut.print(raw);
        if (attrs != null) {
            attrs = sortAttributes(attrs);
            int len = attrs.getLength();
            for (int i = 0; i <  len; i++) {
                fOut.print(' ");
                fOut.print(attrs.getQName(i));
                fOut.print("=\"");
                normalizeAndPrint(attrs.getValue(i), true);
                fOut.print('"");
            }
        }
        fOut.print(' >");
        fOut.flush();
}

Start element.

 public  void startEntity(String name) throws SAXException 
{

}

Start entity.

 public  void warning(SAXParseException ex) throws SAXException 
{
        printError("Warning", ex);
}

Warning.