2005-01-16 Andrew John Hughes <gnu_andrew@member.fsf.org>

	Final merge of HEAD patches to generics branch
	All changes are listed in merged Changelog.
	In addition,
	* java/lang/System.java:
	(getenv()): changed Runtime.securityManager to
	SecurityManager.current
	(getenv(String)): likewise
	(remove(String)): pointed to SystemProperties
	* gnu/classpath/SystemProperties.java:
	(remove(String)): implemented and documented

1 files changed, 306 insertions, 0 deletions

diff --git a/gnu/xml/util/DoParse.java b/gnu/xml/util/DoParse.java
new file mode 100644
index 000000000..23721de76
--- /dev/null
+++ b/gnu/xml/util/DoParse.java
@@ -0,0 +1,306 @@
+/* DoParse.java -- 
+   Copyright (C) 1999,2000,2001 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING.  If not, write to the
+Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library.  Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module.  An independent module is a module which is not derived from
+or based on this library.  If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so.  If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.xml.util;
+
+import java.io.*;
+
+import org.xml.sax.*;
+import org.xml.sax.helpers.XMLReaderFactory;
+import org.xml.sax.ext.*;
+
+// import gnu.xml.pipeline.*;
+// Added imports directly to fix a GCJ problem.
+import gnu.xml.pipeline.CallFilter;
+import gnu.xml.pipeline.DomConsumer;
+import gnu.xml.pipeline.EventConsumer;
+import gnu.xml.pipeline.EventFilter;
+import gnu.xml.pipeline.LinkFilter;
+import gnu.xml.pipeline.NSFilter;
+import gnu.xml.pipeline.PipelineFactory;
+import gnu.xml.pipeline.TeeConsumer;
+import gnu.xml.pipeline.TextConsumer;
+import gnu.xml.pipeline.ValidationConsumer;
+import gnu.xml.pipeline.WellFormednessFilter;
+import gnu.xml.pipeline.XIncludeFilter;
+import gnu.xml.pipeline.XsltFilter;
+
+
+/**
+ * This class provides a driver which may be invoked from the command line
+ * to process a document using a SAX2 parser and a specified XML processing
+ * pipeline.
+ * This facilitates some common types of command line tools, such as parsing an
+ * XML document in order test it for well formedness or validity.
+ *
+ * <p>The SAX2 XMLReaderFactory should return a SAX2 XML parser which
+ * supports both of the standardized extension handlers (for declaration
+ * and lexical events).  That parser will be used to produce events.
+ *
+ * <p>The first parameter to the command gives the name of the document that
+ * will be given to that processor.  If it is a file name, it is converted
+ * to a URL first.
+ *
+ * <p>The second parameter describes a simple processing pipeline, and will
+ * be used as input to {@link gnu.xml.pipeline.PipelineFactory}
+ * methods which identify the processing to be done.  Examples of such a
+ * pipeline include <pre>
+ *
+ *    nsfix | validate                <em>to validate the input document </em>
+ *    nsfix | write ( stdout )        <em>to echo the file as XML text</em>
+ *    dom | nsfix | write ( stdout )  <em>parse into DOM, print the result</em>
+ * </pre>
+ *
+ * <p> Relatively complex pipelines can be described on the command line, but
+ * not all interesting ones will require as little configuration as can be done
+ * in that way.  Put filters like "nsfix", perhaps followed by "validate",
+ * at the front of the pipeline so they can be optimized out if a parser
+ * supports those modes natively.
+ *
+ * <p> If the parsing is aborted for any reason, the JVM will exit with a
+ * failure code.  If a validating parse was done then both validation and
+ * well formedness errors will cause a failure.  A non-validating parse
+ * will report failure on well formedness errors.
+ *
+ * @see gnu.xml.pipeline.PipelineFactory
+ *
+ * @author David Brownell
+ */
+final public class DoParse
+{
+    private DoParse () { /* no instances allowed */ }
+
+    // first reported nonrecoverable error
+    private static SAXParseException	fatal;
+
+    // error categories
+    private static int			errorCount;
+    private static int			fatalCount;
+
+    /**
+     * Command line invoker for this class; pass a filename or URL
+     * as the first argument, and a pipeline description as the second.
+     * Make sure to use filters to condition the input to stages that
+     * require it; an <em>nsfix</em> filter will be a common requirement,
+     * to restore syntax that SAX2 parsers delete by default.  Some
+     * conditioning filters may be eliminated by setting parser options.
+     * (For example, "nsfix" can set the "namespace-prefixes" feature to
+     * a non-default value of "true".  In the same way, "validate" can set
+     * the "validation" feature to "true".)
+     */
+    public static void main (String argv [])
+    throws IOException
+    {
+	int		exitStatus = 1;
+
+	if (argv.length != 2) {
+	    System.err.println ("Usage: DoParse [filename|URL] pipeline-spec");
+	    System.err.println ("Example pipeline specs:");
+	    System.err.println ("  'nsfix | validate'");
+	    System.err.println (
+		"       ... restore namespace syntax, validate");
+	    System.err.println ("  'nsfix | write ( stdout )'");
+	    System.err.println (
+		"       ... restore namespace syntax, write to stdout as XML"
+		);
+	    System.exit (1);
+	}
+
+	try {
+	    //
+	    // Get input source for specified document (or try ;-)
+	    //
+	    argv [0] = Resolver.getURL (argv [0]);
+	    InputSource input = new InputSource (argv [0]);
+
+	    //
+	    // Get the producer, using the system default parser (which
+	    // can be overridden for this particular invocation).
+	    //
+	    // And the pipeline, using commandline options.
+	    //
+	    XMLReader		producer;
+	    EventConsumer	consumer;
+
+	    producer = XMLReaderFactory.createXMLReader ();
+
+	    //
+	    // XXX pipeline factory now has a pre-tokenized input
+	    // method, use it ... that way at least some params
+	    // can be written using quotes (have spaces, ...)
+	    //
+	    consumer = PipelineFactory.createPipeline (argv [1]);
+
+	    //
+	    // XXX want commandline option for tweaking error handler.
+	    // Want to be able to present warnings.
+	    //
+	    producer.setErrorHandler (new MyErrorHandler ());
+
+	    // XXX need facility enabling resolving to local DTDs
+
+	    //
+	    // Parse.  The pipeline may get optimized a bit, so we
+	    // can't always fail cleanly for validation without taking
+	    // a look at the filter stages.
+	    //
+	    EventFilter.bind (producer, consumer);
+	    producer.parse (input);
+
+	    try {
+		if (producer.getFeature (
+			"http://org.xml/sax/features/validation"))
+		    exitStatus = ((errorCount + fatalCount) > 0) ? 1 : 0;
+		else if (fatalCount == 0)
+		    exitStatus = 0;
+	    } catch (SAXException e) {
+		if (hasValidator (consumer))
+		    exitStatus = ((errorCount + fatalCount) > 0) ? 1 : 0;
+		else if (fatalCount == 0)
+		    exitStatus = 0;
+	    }
+
+	} catch (java.net.MalformedURLException e) {
+	    System.err.println ("** Malformed URL: " + e.getMessage ());
+	    System.err.println ("Is '" + argv [0] + "' a non-existent file?");
+	    e.printStackTrace ();
+		// e.g. FNF
+
+	} catch (SAXParseException e) {
+	    if (e != fatal) {
+		System.err.print (printParseException ("Parsing Aborted", e));
+		e.printStackTrace ();
+		if (e.getException () != null) {
+		    System.err.println ("++ Wrapped exception:");
+		    e.getException ().printStackTrace ();
+		}
+	    }
+
+	} catch (SAXException e) {
+	    Exception	x = e;
+	    if (e.getException () != null)
+		x = e.getException ();
+	    x.printStackTrace ();
+
+	} catch (Throwable t) {
+	    t.printStackTrace ();
+	}
+
+	System.exit (exitStatus);
+    }
+
+    // returns true if saw a validator (before end or unrecognized node)
+    // false otherwise
+    private static boolean hasValidator (EventConsumer e)
+    {
+	if (e == null)
+	    return false;
+	if (e instanceof ValidationConsumer)
+	    return true;
+	if (e instanceof TeeConsumer) {
+	    TeeConsumer	t = (TeeConsumer) e;
+	    return hasValidator (t.getFirst ())
+		|| hasValidator (t.getRest ());
+	}
+	if (e instanceof WellFormednessFilter
+		|| e instanceof NSFilter
+		)
+	    return hasValidator (((EventFilter)e).getNext ());
+	
+	// else ... gee, we can't know.  Assume not.
+
+	return false;
+    }
+
+    static class MyErrorHandler implements ErrorHandler
+    {
+	// dump validation errors, but continue
+	public void error (SAXParseException e)
+	throws SAXParseException
+	{
+	    errorCount++;
+	    System.err.print (printParseException ("Error", e));
+	}
+
+	public void warning (SAXParseException e)
+	throws SAXParseException
+	{
+	    // System.err.print (printParseException ("Warning", e));
+	}
+
+	// try to continue fatal errors, in case a parser reports more
+	public void fatalError (SAXParseException e)
+	throws SAXParseException
+	{
+	    fatalCount++;
+	    if (fatal == null)
+		fatal = e;
+	    System.err.print (printParseException ("Nonrecoverable Error", e));
+	}
+    }
+
+    static private String printParseException (
+	String			label,
+	SAXParseException	e
+    ) {
+	StringBuffer	buf = new StringBuffer ();
+	int		temp;
+
+	buf.append ("** ");
+	buf.append (label);
+	buf.append (": ");
+	buf.append (e.getMessage ());
+	buf.append ('\n');
+	if (e.getSystemId () != null) {
+	    buf.append ("   URI:  ");
+	    buf.append (e.getSystemId ());
+	    buf.append ('\n');
+	}
+	if ((temp = e.getLineNumber ()) != -1) {
+	    buf.append ("   line: ");
+	    buf.append (temp);
+	    buf.append ('\n');
+	}
+	if ((temp = e.getColumnNumber ()) != -1) {
+	    buf.append ("   char: ");
+	    buf.append (temp);
+	    buf.append ('\n');
+	}
+
+	return buf.toString ();
+    }
+}