forrest-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From stev...@apache.org
Subject cvs commit: xml-forrest/src/scratchpad/src/java/org/apache/forrest XNIWriter.java
Date Tue, 09 Jul 2002 16:05:02 GMT
stevenn     2002/07/09 09:05:02

  Modified:    .        build.xml
  Added:       lib/core nekodtd-20020615.jar
               src/scratchpad/src/java/org/apache/forrest XNIWriter.java
  Log:
  NekoDTD HTML DTD documentation generation - first step
  
  Revision  Changes    Path
  1.10      +24 -0     xml-forrest/build.xml
  
  Index: build.xml
  ===================================================================
  RCS file: /home/cvs/xml-forrest/build.xml,v
  retrieving revision 1.9
  retrieving revision 1.10
  diff -u -r1.9 -r1.10
  --- build.xml	9 Jul 2002 13:14:42 -0000	1.9
  +++ build.xml	9 Jul 2002 16:05:02 -0000	1.10
  @@ -348,6 +348,30 @@
   
   
     <!-- =================================================================== -->
  +  <!-- Generate DTD documentation                                          -->
  +  <!-- =================================================================== -->
  +  
  +  <!-- caution: unfinished work! -->
  +  
  +  <!-- part one: NekoDTD + resolver.jar support -->
  +  <target name="nekodtd" description="Transforms DTDs in the DTDx format." depends="init,
compile">
  +    <java classname="org.apache.forrest.XNIWriter" fork="true" failonerror="true">
  +      <classpath>
  +        <path refid="classpath"/>
  +        <pathelement location="build/scratchpad/classes"/>
  +        <pathelement location="src/resources/schema"/>
  +      </classpath>
  +      <arg line="-p org.cyberneko.dtd.DTDConfiguration"/>
  +      <arg line="-o ${build.context}/document-v11.dtdx.xml"/>
  +      <arg line="-cat src/resources/schema/catalog"/>
  +      <arg value="src/resources/schema/dtd/document-v11.dtd"/>
  +    </java>
  +  </target>
  +  
  +  <!-- part two (TBD): producing HTML output -->
  +
  +
  +  <!-- =================================================================== -->
     <!-- The documentation system                                            -->
     <!-- =================================================================== -->
     <target name="docs"
  
  
  
  1.1                  xml-forrest/lib/core/nekodtd-20020615.jar
  
  	<<Binary file>>
  
  
  1.1                  xml-forrest/src/scratchpad/src/java/org/apache/forrest/XNIWriter.java
  
  Index: XNIWriter.java
  ===================================================================
  /*
   * The Apache Software License, Version 1.1
   *
   *
   * Copyright (c) 2001, 2002 The Apache Software Foundation.  All rights
   * reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. The end-user documentation included with the redistribution,
   *    if any, must include the following acknowledgment:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowledgment may appear in the software itself,
   *    if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The names "Xerces" and "Apache Software Foundation" must
   *    not be used to endorse or promote products derived from this
   *    software without prior written permission. For written
   *    permission, please contact apache@apache.org.
   *
   * 5. Products derived from this software may not be called "Apache",
   *    nor may "Apache" appear in their name, without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Software Foundation and was
   * originally based on software copyright (c) 1999, International
   * Business Machines, Inc., http://www.apache.org.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  
  package org.apache.forrest;
  
  import java.io.*;
  
  import org.apache.xerces.parsers.XMLDocumentParser;
  import org.apache.xerces.util.XMLAttributesImpl;
  import org.apache.xerces.util.EntityResolverWrapper;
  import org.apache.xerces.xni.Augmentations;
  import org.apache.xerces.xni.QName;
  import org.apache.xerces.xni.XMLAttributes;
  import org.apache.xerces.xni.XMLLocator;
  import org.apache.xerces.xni.XMLString;
  import org.apache.xerces.xni.XNIException;
  import org.apache.xerces.xni.parser.XMLConfigurationException;
  import org.apache.xerces.xni.parser.XMLErrorHandler;
  import org.apache.xerces.xni.parser.XMLInputSource;
  import org.apache.xerces.xni.parser.XMLParseException;
  import org.apache.xerces.xni.parser.XMLParserConfiguration;
  import org.apache.xerces.xni.parser.XMLPullParserConfiguration;
  import org.apache.xerces.impl.Constants;
  import org.apache.xml.resolver.tools.CatalogResolver;
  
  /**
   * A sample XNI writer. This sample program illustrates how to
   * use the XNI XMLDocumentHandler callbacks in order to print a
   * document that is parsed.
   *
   * @author Andy Clark, IBM
   *
   * @version $Id: XNIWriter.java,v 1.1 2002/07/09 16:05:02 stevenn Exp $
   */
  public class XNIWriter
      extends XMLDocumentParser
      implements XMLErrorHandler {
  
      //
      // Constants
      //
  
      // feature ids
  
      /** Namespaces feature id (http://xml.org/sax/features/namespaces). */
      protected static final String NAMESPACES_FEATURE_ID =
          "http://xml.org/sax/features/namespaces";
  
      /** Validation feature id (http://xml.org/sax/features/validation). */
      protected static final String VALIDATION_FEATURE_ID =
          "http://xml.org/sax/features/validation";
  
      /** Schema validation feature id (http://apache.org/xml/features/validation/schema).
*/
      protected static final String SCHEMA_VALIDATION_FEATURE_ID =
          "http://apache.org/xml/features/validation/schema";
  
      /** Schema full checking feature id (http://apache.org/xml/features/validation/schema-full-checking).
*/
      protected static final String SCHEMA_FULL_CHECKING_FEATURE_ID =
          "http://apache.org/xml/features/validation/schema-full-checking";
  
      // default settings
  
      /** Default parser configuration (org.apache.xerces.parsers.StandardParserConfiguration).
*/
      protected static final String DEFAULT_PARSER_CONFIG =
          "org.apache.xerces.parsers.StandardParserConfiguration";
  
      /** Default namespaces support (true). */
      protected static final boolean DEFAULT_NAMESPACES = true;
  
      /** Default validation support (false). */
      protected static final boolean DEFAULT_VALIDATION = false;
  
      /** Default Schema validation support (false). */
      protected static final boolean DEFAULT_SCHEMA_VALIDATION = false;
  
      /** Default Schema full checking support (false). */
      protected static final boolean DEFAULT_SCHEMA_FULL_CHECKING = false;
  
      /** Default canonical output (false). */
      protected static final boolean DEFAULT_CANONICAL = false;
  
      /** Default incremental mode (false). */
      protected static final boolean DEFAULT_INCREMENTAL = false;
  
      protected static final String DEFAULT_CATALOG = "catalog";
  
      //
      // Data
      //
  
      /** Print writer. */
      protected PrintWriter fOut;
  
      /** Canonical output. */
      protected boolean fCanonical;
  
      /** Element depth. */
      protected int fElementDepth;
  
      /** Seen root element. */
      protected boolean fSeenRootElement;
  
      //
      // Constructors
      //
  
      /** Default constructor. */
      public XNIWriter(XMLParserConfiguration configuration) {
          super(configuration);
          fConfiguration.setErrorHandler(this);
      } // <init>(XMLParserConfiguration)
  
      //
      // Public methods
      //
  
      /** Sets whether output is canonical. */
      public void setCanonical(boolean canonical) {
          fCanonical = canonical;
      } // setCanonical(boolean)
  
      /** Sets the output stream for printing. */
      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);
  
      } // setOutput(OutputStream,String)
  
      /** Sets the output writer. */
      public void setOutput(java.io.Writer writer) {
  
          fOut = writer instanceof PrintWriter
               ? (PrintWriter)writer : new PrintWriter(writer);
  
      } // setOutput(java.io.Writer)
  
      //
      // XMLDocumentHandler methods
      //
  
      /** Start document. */
      public void startDocument(XMLLocator locator, String encoding, Augmentations augs)
          throws XNIException {
  
          fSeenRootElement = false;
          fElementDepth = 0;
  
          if (!fCanonical) {
              fOut.println("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
              fOut.flush();
          }
  
      } // startDocument(XMLLocator,String,Augmentations)
  
      /** Start element. */
      public void startElement(QName element, XMLAttributes attrs, Augmentations augs)
          throws XNIException {
  
          fSeenRootElement = true;
          fElementDepth++;
          fOut.print('<');
          fOut.print(element.rawname);
          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));
                  fOut.print('"');
              }
          }
          fOut.print('>');
          fOut.flush();
  
      } // startElement(QName,XMLAttributes,Augmentations)
  
      /** Empty element. */
      public void emptyElement(QName element, XMLAttributes attrs, Augmentations augs)
          throws XNIException {
  
          fSeenRootElement = true;
          fElementDepth++;
          fOut.print('<');
          fOut.print(element.rawname);
          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));
                  fOut.print('"');
              }
          }
          fOut.print("/>");
          fOut.flush();
  
      } // emptyElement(QName,XMLAttributes,Augmentations)
  
      /** Processing instruction. */
      public void processingInstruction(String target, XMLString data, Augmentations augs)
          throws XNIException {
  
          if (fSeenRootElement) {
              fOut.print('\n');
          }
          fOut.print("<?");
          fOut.print(target);
          if (data != null && data.length > 0) {
              fOut.print(' ');
              fOut.print(data.toString());
          }
          fOut.print("?>");
          if (!fSeenRootElement) {
              fOut.print('\n');
          }
          fOut.flush();
  
      } // processingInstruction(String,XMLString,Augmentations)
  
      /** Comment. */
      public void comment(XMLString text, Augmentations augs) throws XNIException {
          if (!fCanonical) {
              if (fSeenRootElement && fElementDepth == 0) {
                  fOut.print('\n');
              }
              fOut.print("<!--");
              fOut.print(text.toString());
              fOut.print("-->");
              if (!fSeenRootElement) {
                  fOut.print('\n');
              }
              fOut.flush();
          }
      } // comment(XMLString,Augmentations)
  
      /** Characters. */
      public void characters(XMLString text, Augmentations augs) throws XNIException {
  
          normalizeAndPrint(text);
          fOut.flush();
  
      } // characters(XMLString,Augmentations)
  
      /** Ignorable whitespace. */
      public void ignorableWhitespace(XMLString text, Augmentations augs) throws XNIException
{
  
          characters(text, augs);
          fOut.flush();
  
      } // ignorableWhitespace(XMLString,Augmentations)
  
      /** End element. */
      public void endElement(QName element, Augmentations augs) throws XNIException {
  
          fElementDepth--;
          fOut.print("</");
          fOut.print(element.rawname);
          fOut.print('>');
          fOut.flush();
  
      } // endElement(QName,Augmentations)
  
      /** Start CDATA section. */
      public void startCDATA(Augmentations augs) throws XNIException {
      } // startCDATA(Augmentations)
  
      /** End CDATA section. */
      public void endCDATA(Augmentations augs) throws XNIException {
      } // endCDATA(Augmentations)
  
      //
      // XMLDTDHandler methods
      //
  
      /** Processing instruction. */
      public void processingInstruction(String target, XMLString data)
          throws XNIException {
  
          if (fSeenRootElement) {
              fOut.print('\n');
          }
          fOut.print("<?");
          fOut.print(target);
          if (data != null && data.length > 0) {
              fOut.print(' ');
              fOut.print(data.toString());
          }
          fOut.print("?>");
          if (!fSeenRootElement) {
              fOut.print('\n');
          }
          fOut.flush();
  
      } // processingInstruction(String,XMLString)
  
      /** Comment. */
      public void comment(XMLString text) throws XNIException {
          if (!fCanonical) {
              if (fSeenRootElement) {
                  fOut.print('\n');
              }
              fOut.print("<!--");
              normalizeAndPrint(text);
              fOut.print("-->");
              if (!fSeenRootElement) {
                  fOut.print('\n');
              }
              fOut.flush();
          }
      } // comment(XMLString)
  
      //
      // XMLErrorHandler methods
      //
  
      /** Warning. */
      public void warning(String domain, String key, XMLParseException ex)
          throws XNIException {
          printError("Warning", ex);
      } // warning(String,String,XMLParseException)
  
      /** Error. */
      public void error(String domain, String key, XMLParseException ex)
          throws XNIException {
          printError("Error", ex);
      } // error(String,String,XMLParseException)
  
      /** Fatal error. */
      public void fatalError(String domain, String key, XMLParseException ex)
          throws XNIException {
          printError("Fatal Error", ex);
          throw ex;
      } // fatalError(String,String,XMLParseException)
  
      //
      // Protected methods
      //
  
      /** Returns a sorted list of attributes. */
      /***
      protected XMLAttributes sortAttributes(XMLAttributes attrs) {
  
          XMLAttributesImpl attributes = new XMLAttributesImpl();
  
          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;
  
      } // sortAttributes(XMLAttributeList):XMLAttributeList
      /***/
  
      /** Normalizes and prints the given string. */
      protected void normalizeAndPrint(String s) {
  
          int len = (s != null) ? s.length() : 0;
          for (int i = 0; i < len; i++) {
              char c = s.charAt(i);
              normalizeAndPrint(c);
          }
  
      } // normalizeAndPrint(String)
  
      /** Normalizes and prints the given array of characters. */
      protected void normalizeAndPrint(XMLString text) {
          for (int i = 0; i < text.length; i++) {
              normalizeAndPrint(text.ch[text.offset + i]);
          }
      } // normalizeAndPrint(XMLString)
  
      /** Normalizes and print the given character. */
      protected void normalizeAndPrint(char c) {
  
          switch (c) {
              case '<': {
                  fOut.print("&lt;");
                  break;
              }
              case '>': {
                  fOut.print("&gt;");
                  break;
              }
              case '&': {
                  fOut.print("&amp;");
                  break;
              }
              case '"': {
                  fOut.print("&quot;");
                  break;
              }
              case '\r':
              case '\n': {
                  if (fCanonical) {
                      fOut.print("&#");
                      fOut.print(Integer.toString(c));
                      fOut.print(';');
                      break;
                  }
                  // else, default print char
              }
              default: {
                  fOut.print(c);
              }
          }
  
      } // normalizeAndPrint(char)
  
      /** Prints the error message. */
      protected void printError(String type, XMLParseException ex) {
  
          System.err.print("[");
          System.err.print(type);
          System.err.print("] ");
          String systemId = ex.getExpandedSystemId();
          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();
  
      } // printError(String,XMLParseException)
  
      //
      // Main
      //
  
      /** Main program entry point. */
      public static void main(String argv[]) {
  
          // is there anything to do?
          if (argv.length == 0) {
              printUsage();
              System.exit(1);
          }
  
          // variables
          XNIWriter writer = null;
          XMLParserConfiguration parserConfig = null;
          boolean namespaces = DEFAULT_NAMESPACES;
          boolean validation = DEFAULT_VALIDATION;
          boolean schemaValidation = DEFAULT_SCHEMA_VALIDATION;
          boolean schemaFullChecking = DEFAULT_SCHEMA_FULL_CHECKING;
          boolean canonical = DEFAULT_CANONICAL;
          boolean incremental = DEFAULT_INCREMENTAL;
          String catalog = DEFAULT_CATALOG;
          String outFile = null;
  
          // 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 {
                          parserConfig = (XMLParserConfiguration)Class.forName(parserName).newInstance();
                          /***
                          parserConfig.addRecognizedFeatures(new String[] {
                              NAMESPACE_PREFIXES_FEATURE_ID,
                          });
                          /***/
                          writer = null;
                      }
                      catch (Exception e) {
                          parserConfig = null;
                          System.err.println("error: Unable to instantiate parser configuration
("+parserName+")");
                          e.printStackTrace(System.err);
                      }
                      continue;
                  }
                  if (option.equalsIgnoreCase("n")) {
                      namespaces = option.equals("n");
                      continue;
                  }
                  if (option.equalsIgnoreCase("v")) {
                      validation = option.equals("v");
                      continue;
                  }
                  if (option.equalsIgnoreCase("s")) {
                      schemaValidation = option.equals("s");
                      continue;
                  }
                  if (option.equalsIgnoreCase("f")) {
                      schemaFullChecking = option.equals("f");
                      continue;
                  }
                  if (option.equalsIgnoreCase("c")) {
                      canonical = option.equals("c");
                      continue;
                  }
                  if (option.equalsIgnoreCase("i")) {
                      incremental = option.equals("i");
                      continue;
                  }
                  if (option.equals("h")) {
                      printUsage();
                      continue;
                  }
  
                  if (option.equals("cat")) {
                      if (++i == argv.length) {
                          System.err.println("error: Missing argument to -cat option.");
                      }
                      catalog = argv[i];
                      continue;
                  }
                  if (option.equals("o")) {
                      if (++i == argv.length) {
                          System.err.println("error: Missing argument to -o option.");
                      }
                      outFile = argv[i];
                      continue;
                  }
              }
  
              // use default parser?
              if (parserConfig == null) {
  
                  // create parser
                  try {
                      parserConfig = (XMLParserConfiguration)Class.forName(DEFAULT_PARSER_CONFIG).newInstance();
                      /***
                      parserConfig.addRecognizedFeatures(new String[] {
                          NAMESPACE_PREFIXES_FEATURE_ID,
                      });
                      /***/
                  }
                  catch (Exception e) {
                      System.err.println("error: Unable to instantiate parser configuration
("+DEFAULT_PARSER_CONFIG+")");
                      e.printStackTrace(System.err);
                      continue;
                  }
              }
  
              // set parser features
              if (writer == null) {
                  writer = new XNIWriter(parserConfig);
              }
              try {
                  parserConfig.setFeature(NAMESPACES_FEATURE_ID, namespaces);
              }
              catch (XMLConfigurationException e) {
                  System.err.println("warning: Parser does not support feature ("+NAMESPACES_FEATURE_ID+")");
              }
              try {
                  parserConfig.setFeature(VALIDATION_FEATURE_ID, validation);
              }
              catch (XMLConfigurationException e) {
                  System.err.println("warning: Parser does not support feature ("+VALIDATION_FEATURE_ID+")");
              }
              try {
                  parserConfig.setFeature(SCHEMA_VALIDATION_FEATURE_ID, schemaValidation);
              }
              catch (XMLConfigurationException e) {
                  if (e.getType() == XMLConfigurationException.NOT_SUPPORTED) {
                      System.err.println("warning: Parser does not support feature ("+SCHEMA_VALIDATION_FEATURE_ID+")");
                  }
              }
              try {
                  parserConfig.setFeature(SCHEMA_FULL_CHECKING_FEATURE_ID, schemaFullChecking);
              }
              catch (XMLConfigurationException e) {
                  if (e.getType() == XMLConfigurationException.NOT_SUPPORTED) {
                      System.err.println("warning: Parser does not support feature ("+SCHEMA_FULL_CHECKING_FEATURE_ID+")");
                  }
              }
  
              try {
                  CatalogResolver catres = new CatalogResolver();
                  catres.getCatalog().parseCatalog(catalog);
                  parserConfig.setProperty(Constants.XERCES_PROPERTY_PREFIX+Constants.ENTITY_RESOLVER_PROPERTY,
                      new EntityResolverWrapper(catres));
              }
              catch (XMLConfigurationException e) {
                if (e.getType() == XMLConfigurationException.NOT_SUPPORTED) {
                    System.err.println("warning: Parser does not support property ("+Constants.ENTITY_RESOLVER_PROPERTY+")");
                }
              }
              catch (IOException e) {
                    e.printStackTrace();
              }
  
              // parse file
              try {
                  OutputStream out = System.out;
                try {
                  if (outFile != null && (new File(outFile)).getParentFile().mkdirs())
{
                    out = new FileOutputStream(outFile);
                  }
                } catch (FileNotFoundException e) {
                  System.err.println("Failed to create output file, will use stdout");
                }
                writer.setOutput(out, "UTF8");
              }
              catch (UnsupportedEncodingException e) {
                  System.err.println("error: Unable to set output. Exiting.");
                  System.exit(1);
              }
              writer.setCanonical(canonical);
              try {
                  if (incremental && parserConfig instanceof XMLPullParserConfiguration)
{
                      XMLPullParserConfiguration pullParserConfig = (XMLPullParserConfiguration)parserConfig;
                      pullParserConfig.setInputSource(new XMLInputSource(null, arg, null));
                      int step = 1;
                      do {
                          //System.err.println("# step "+step++);
                      } while (pullParserConfig.parse(false));
                  }
                  else {
                      writer.parse(new XMLInputSource(null, arg, null));
                  }
              }
              catch (XMLParseException e) {
                  // ignore
              }
              catch (Exception e) {
                  System.err.println("error: Parse error occurred - "+e.getMessage());
                  if (e instanceof XNIException) {
                      e = ((XNIException)e).getException();
                  }
                  e.printStackTrace(System.err);
              }
          }
  
      } // main(String[])
  
      //
      // Private static methods
      //
  
      /** Prints the usage. */
      private static void printUsage() {
  
          System.err.println("usage: java sax.Writer (options) uri ...");
          System.err.println();
  
          System.err.println("options:");
          System.err.println("  -p name  Select parser configuration by name.");
          System.err.println("  -n | -N  Turn on/off namespace processing.");
          System.err.println("  -v | -V  Turn on/off validation.");
          System.err.println("  -s | -S  Turn on/off Schema validation support.");
          System.err.println("           NOTE: Not supported by all parsers.");
          System.err.println("  -f  | -F Turn on/off Schema full checking.");
          System.err.println("           NOTE: Requires use of -s and not supported by all
parsers.");
          /***
          System.err.println("  -c | -C  Turn on/off Canonical XML output.");
          System.err.println("           NOTE: This is not W3C canonical output.");
          /***/
          System.err.println("  -i | -I  Incremental mode.");
          System.err.println("           NOTE: This feature only works if the configuration
used");
          System.err.println("                 implements XMLPullParserConfiguration.");
          System.err.println("  -h       This help screen.");
          System.err.println();
  
          System.err.println("defaults:");
          System.err.println("  Config:     "+DEFAULT_PARSER_CONFIG);
          System.err.print("  Namespaces: ");
          System.err.println(DEFAULT_NAMESPACES ? "on" : "off");
          System.err.print("  Validation: ");
          System.err.println(DEFAULT_VALIDATION ? "on" : "off");
          System.err.print("  Schema:     ");
          System.err.println(DEFAULT_SCHEMA_VALIDATION ? "on" : "off");
          System.err.print("  Schema full checking:     ");
          System.err.println(DEFAULT_SCHEMA_FULL_CHECKING ? "on" : "off");
          /***
          System.err.print("  Canonical:  ");
          System.err.println(DEFAULT_CANONICAL ? "on" : "off");
          /***/
          System.err.print("  Incremental:  ");
          System.err.println(DEFAULT_INCREMENTAL ? "on" : "off");
  
      } // printUsage()
  
  } // class Writer
  
  
  

Mime
View raw message