Application: gvSIG desktop

<project name="Complete_build_system" basedir="." default="prepare-eclipse-workspace">

	<description>

		Builds and prepare folders to work with eclipse using maven.

		Also is able to generate a release of all system with binaries distribution

		and sources distribution.

	</description>

	<!-- set global properties for this build -->

	<dirname file="${ant.file.Complete_build_system}" property="ant.file.Complete_build_system.dir"/>

	<property name="mavendir" location="${ant.file.Complete_build_system.dir}/maven" />

	<property environment="environment"/>

	<condition property="mvn.executable" value="${mavendir}/bin/mvn.bat" else="${mavendir}/bin/mvn">

		<os family="windows" />

	</condition>

	<condition property="isLinux">

		<and>

			<os family="unix" />

			<not>

				<os family="mac" />

			</not>

		</and>

	</condition>

	<condition property="isWindows">

		<or>

			<os family="windows" />

			<os family="win9x" />

			<os name="Windows Vista" />

		</or>

	</condition>

	<condition property="isMac">

		<os family="mac" />

	</condition>

	<condition property="gvsig.os" value="w32">

		<os family="windows" />

	</condition>

	<condition property="gvsig.os" value="linux">

		<and>

			<os family="unix" />

			<not>

				<os family="mac" />

			</not>

		</and>

	</condition>

	<condition property="gvsig.os" value="mac">

		<os family="mac" />

	</condition>

	<property name="native-binaries-dir" value="../binaries" />

	<presetdef name="maven">

		<exec executable="${mvn.executable}">

			<env key="JAVA_HOME" value="${java.home}"/>

		</exec>

	</presetdef>

	<target name="prepare-eclipse-workspace" depends="mvn-clean,mvn-install-without-tests">

		<maven>

			<arg value="-Declipse.workspace=../" />

			<arg value="eclipse:add-maven-repo" />

		</maven>

		<maven>

			<arg value="eclipse:eclipse" />

		</maven>

	</target>

	<target name="mvn-clean">

		<maven>

			<arg value="clean" />

		</maven>

	</target>

	<target name="mvn-install-without-tests">

		<maven>

			<arg value="install" />

			<arg value="-Dmaven.test.skip=true" />

		</maven>

	</target>

	<target name="install-gvsig-base" depends="mvn-clean,mvn-install-extensions,mvn-eclipse-clean">

		<maven>

			<arg value="eclipse:eclipse" />

		</maven>

	</target>

	<target name="mvn-install-extensions">

		<maven>

			<arg value="install" />

			<arg value="-Dmaven.test.skip=true" />

			<arg value="-Dinstall-extension" />

		</maven>

	</target>

	<target name="mvn-install">

		<maven>

			<arg value="install" />

		</maven>

	</target>

	<target name="mvn-eclipse-clean">

		<maven>

			<arg value="eclipse:clean" />

		</maven>

	</target>

	<target name="mvn-eclipse-eclipse">

		<maven>

			<arg value="eclipse:eclipse" />

		</maven>

	</target>

	<!-- TODO: Target for make complete building of gvSIG, calling all enabled projects by default -->

	<!-- target name="work" description="prepares system to begin working with eclipse" depends="prepare-eclipse-workspace" / -->

</project>

/* XMLValidationException.java                                     NanoXML/Java

 *

 * $Revision: 5819 $

 * $Date: 2006-06-14 09:29:09 +0200 $

 * $Name$

 *

 * This file is part of NanoXML 2 for Java.

 * Copyright (C) 2001 Marc De Scheemaecker, All Rights Reserved.

 *

 * This software is provided 'as-is', without any express or implied warranty.

 * In no event will the authors be held liable for any damages arising from the

 * use of this software.

 *

 * Permission is granted to anyone to use this software for any purpose,

 * including commercial applications, and to alter it and redistribute it

 * freely, subject to the following restrictions:

 *

 *  1. The origin of this software must not be misrepresented; you must not

 *     claim that you wrote the original software. If you use this software in

 *     a product, an acknowledgment in the product documentation would be

 *     appreciated but is not required.

 *

 *  2. Altered source versions must be plainly marked as such, and must not be

 *     misrepresented as being the original software.

 *

 *  3. This notice may not be removed or altered from any source distribution.

 */

package net.n3.nanoxml;

/**

 * An XMLValidationException is thrown when the XML passed to the XML parser is

 * well-formed but not valid.

 *

 * @author Marc De Scheemaecker

 * @version $Name$, $Revision: 5819 $

 */

public class XMLValidationException

    extends XMLException

{

    /**

     * An element was missing.

     */

    public static final int MISSING_ELEMENT = 1;

    /**

     * An unexpected element was encountered.

     */

    public static final int UNEXPECTED_ELEMENT = 2;

    /**

     * An attribute was missing.

     */

    public static final int MISSING_ATTRIBUTE = 3;

    /**

     * An unexpected attribute was encountered.

     */

    public static final int UNEXPECTED_ATTRIBUTE = 4;

    /**

     * An attribute has an invalid value.

     */

    public static final int ATTRIBUTE_WITH_INVALID_VALUE = 5;

    /**

     * A PCDATA element was missing.

     */

    public static final int MISSING_PCDATA = 6;

    /**

     * An unexpected PCDATA element was encountered.

     */

    public static final int UNEXPECTED_PCDATA = 7;

    /**

     * Another error than those specified in this class was encountered.

     */

    public static final int MISC_ERROR = 0;

    /**

     * Which error occurred.

     */

    private int errorType;

    /**

     * The name of the element where the exception occurred.

     */

    private String elementName;

    /**

     * The name of the attribute where the exception occurred.

     */

    private String attributeName;

    /**

     * The value of the attribute where the exception occurred.

     */

    private String attributeValue;

    /**

     * Creates a new exception.

     *

     * @param errorType      the type of validity error

     * @param systemID       the system ID from where the data came

     * @param lineNr         the line number in the XML data where the

     *                       exception occurred.

     * @param elementName    the name of the offending element

     * @param attributeName  the name of the offending attribute

     * @param attributeValue the value of the offending attribute

     * @param msg            the message of the exception.

     */

    public XMLValidationException(int    errorType,

                                  String systemID,

                                  int    lineNr,

                                  String elementName,

                                  String attributeName,

                                  String attributeValue,

                                  String msg)

    {

        super(systemID, lineNr, null,

              msg + ((elementName == null) ? "" : (", element=" + elementName))

                  + ((attributeName == null) ? ""

                        : (", attribute=" + attributeName))

                  + ((attributeValue == null) ? ""

                        : (", value='" + attributeValue + "'")),

              false);

        this.elementName = elementName;

        this.attributeName = attributeName;

        this.attributeValue = attributeValue;

    }

    /**

     * Cleans up the object when it's destroyed.

     */

    protected void finalize()

        throws Throwable

    {

        this.elementName = null;

        this.attributeName = null;

        this.attributeValue = null;

        super.finalize();

    }

    /**

     * Returns the name of the element in which the validation is violated.

     * If there is no current element, null is returned.

     */

    public String getElementName()

    {

        return this.elementName;

    }

    /**

     * Returns the name of the attribute in which the validation is violated.

     * If there is no current attribute, null is returned.

     */

    public String getAttributeName()

    {

        return this.attributeName;

    }

    /**

     * Returns the value of the attribute in which the validation is violated.

     * If there is no current attribute, null is returned.

     */

    public String getAttributeValue()

    {

        return this.attributeValue;

    }

}

/* IXMLReader.java                                                 NanoXML/Java

 *

 * $Revision: 5819 $

 * $Date: 2006-06-14 09:29:09 +0200 $

 * $Name$

 *

 * This file is part of NanoXML 2 for Java.

 * Copyright (C) 2001 Marc De Scheemaecker, All Rights Reserved.

 *

 * This software is provided 'as-is', without any express or implied warranty.

 * In no event will the authors be held liable for any damages arising from the

 * use of this software.

 *

 * Permission is granted to anyone to use this software for any purpose,

 * including commercial applications, and to alter it and redistribute it

 * freely, subject to the following restrictions:

 *

 *  1. The origin of this software must not be misrepresented; you must not

 *     claim that you wrote the original software. If you use this software in

 *     a product, an acknowledgment in the product documentation would be

 *     appreciated but is not required.

 *

 *  2. Altered source versions must be plainly marked as such, and must not be

 *     misrepresented as being the original software.

 *

 *  3. This notice may not be removed or altered from any source distribution.

 */

package net.n3.nanoxml;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.Reader;

import java.net.MalformedURLException;

/**

 * IXMLReader reads the data to be parsed.

 *

 * @author Marc De Scheemaecker

 * @version $Name$, $Revision: 5819 $

 */

public interface IXMLReader

{

    /**

     * Reads a character.

     *

     * @return the character

     *

     * @throws java.io.IOException

     *		if no character could be read

     */

    public char read()

        throws IOException;

    /**

     * Returns true if the current stream has no more characters left to be

     * read.

     *

     * @throws java.io.IOException

     *		if an I/O error occurred

     */

    public boolean atEOFOfCurrentStream()

        throws IOException;

    /**

     * Returns true if there are no more characters left to be read.

     *

     * @throws java.io.IOException

     *		if an I/O error occurred

     */

    public boolean atEOF()

        throws IOException;

    /**

     * Pushes the last character read back to the stream.

     *

     * @param ch the character to push back

     *

     * @throws java.io.IOException

     *		if an I/O error occurred

     */

    public void unread(char ch)

        throws IOException;

    /**

     * Returns the line number of the data in the current stream.

     */

    public int getLineNr();

    /**

     * Opens a stream from a public and system ID.

     *

     * @param publicID the public ID, which may be null

     * @param systemID the system ID, which is never null

     *

     * @throws java.net.MalformedURLException

     *     if the system ID does not contain a valid URL

     * @throws java.io.FileNotFoundException

     *     if the system ID refers to a local file which does not exist

     * @throws java.io.IOException

     *     if an error occurred opening the stream

     */

    public Reader openStream(String publicID,

                             String systemID)

        throws MalformedURLException,

               FileNotFoundException,

               IOException;

    /**

     * Starts a new stream from a Java reader. The new stream is used

     * temporary to read data from. If that stream is exhausted, control

     * returns to the parent stream.

     *

     * @param reader the reader to read the new data from

     */

    public void startNewStream(Reader reader);

    /**

     * Sets the system ID of the current stream.

     *

     * @param systemID the system ID

     *

     * @throws java.net.MalformedURLException

     *     if the system ID does not contain a valid URL

     */

    public void setSystemID(String systemID)

        throws MalformedURLException;

    /**

     * Sets the public ID of the current stream.

     *

     * @param publicID the public ID

     */

    public void setPublicID(String publicID);

    /**

     * Returns the current system ID.

     */

    public String getSystemID();    

    /**

     * Returns the current public ID.

     */

    public String getPublicID();

}

/* XMLWriter.java                                                  NanoXML/Java

 *

 * $Revision: 5819 $

 * $Date: 2006-06-14 09:29:09 +0200 $

 * $Name$

 *

 * This file is part of NanoXML 2 for Java.

 * Copyright (C) 2001 Marc De Scheemaecker, All Rights Reserved.

 *

 * This software is provided 'as-is', without any express or implied warranty.

 * In no event will the authors be held liable for any damages arising from the

 * use of this software.

 *

 * Permission is granted to anyone to use this software for any purpose,

 * including commercial applications, and to alter it and redistribute it

 * freely, subject to the following restrictions:

 *

 *  1. The origin of this software must not be misrepresented; you must not

 *     claim that you wrote the original software. If you use this software in

 *     a product, an acknowledgment in the product documentation would be

 *     appreciated but is not required.

 *

 *  2. Altered source versions must be plainly marked as such, and must not be

 *     misrepresented as being the original software.

 *

 *  3. This notice may not be removed or altered from any source distribution.

 */

package net.n3.nanoxml;

import java.io.IOException;

import java.io.OutputStream;

import java.io.PrintWriter;

import java.io.Writer;

import java.util.Enumeration;

/**

 * An XMLWriter writes XML data to a stream.

 *

 * @see net.n3.nanoxml.XMLElement

 * @see java.io.Writer

 *

 * @author Marc De Scheemaecker

 * @version $Name$, $Revision: 5819 $

 */

public class XMLWriter

{

    /**

     * Where to write the output to.

     */

    private PrintWriter writer;

    /**

     * Creates a new XML writer.

     *

     * @param writer where to write the output to.

     */

    public XMLWriter(Writer writer)

    {

        if (writer instanceof PrintWriter) {

            this.writer = (PrintWriter) writer;

        } else {

            this.writer = new PrintWriter(writer);

        }

    }

    /**

     * Creates a new XML writer.

     *

     * @param stream where to write the output to.

     */

    public XMLWriter(OutputStream stream)

    {

        this.writer = new PrintWriter(stream);

    }

    /**

     * Cleans up the object when it's destroyed.

     */

    protected void finalize()

        throws Throwable

    {

        this.writer = null;

        super.finalize();

    }

    /**

     * Writes an XML element.

     *

     * @param xml the non-null XML element to write.

     */

    public void write(XMLElement xml)

        throws IOException

    {

        this.write(xml, true, 0);

    }

    /**

     * Writes an XML element.

     *

     * @param xml the non-null XML element to write.

     * @param prettyPrint if spaces need to be inserted to make the output more

     *                    readable

     */

    public void write(XMLElement xml,

                      boolean    prettyPrint)

        throws IOException

    {

        this.write(xml, prettyPrint, 0);

    }

    /**

     * Writes an XML element.

     *

     * @param xml the non-null XML element to write.

     * @param prettyPrint if spaces need to be inserted to make the output more

     *                    readable

     * @param indent how many spaces to indent the element.

     */

    public void write(XMLElement xml,

                      boolean    prettyPrint,

                      int        indent)

        throws IOException

    {

        if (prettyPrint) {

            for (int i = 0; i < indent; i++) {

                this.writer.print(' ');

            }

        }

        if (xml.getName() == null) {

            if (xml.getContent() != null) {

                if (prettyPrint) {

                    this.writeEncoded(xml.getContent().trim());

                    writer.println();

                } else {

                    this.writeEncoded(xml.getContent());

                }

            }

        } else {

            this.writer.print('<');

            this.writer.print(xml.getName());

            Enumeration enum = xml.enumerateAttributeNames();

            while (enum.hasMoreElements()) {

                String key = (String) enum.nextElement();

                String value = xml.getAttribute(key);

                this.writer.print(" " + key + "=\"");

                this.writeEncoded(value);

                this.writer.print('"');

            }

            if ((xml.getContent() != null)

                    && (xml.getContent().length() > 0)) {

                writer.print('>');

                this.writeEncoded(xml.getContent());

                writer.print("</" + xml.getName() + '>');

                if (prettyPrint) {

                    writer.println();

                }

            } else if (xml.hasChildren()) {

                writer.print('>');

                if (prettyPrint) {

                    writer.println();

                }

                enum = xml.enumerateChildren();

                while (enum.hasMoreElements()) {

                    XMLElement child = (XMLElement) enum.nextElement();

                    this.write(child, prettyPrint, indent + 4);

                }

                if (prettyPrint) {

                    for (int i = 0; i < indent; i++) {

                        this.writer.print(' ');

                    }

                }

                this.writer.print("</" + xml.getName() + ">");

                if (prettyPrint) {

                    writer.println();

                }

            } else {

                this.writer.print("/>");

                if (prettyPrint) {

                    writer.println();

                }

            }

        }

        this.writer.flush();

    }

    /**

     * Writes a string encoding reserved characters.

     *

     * @param str the string to write.

     */

    private void writeEncoded(String str)

    {

        for (int i = 0; i < str.length(); i++) {

            char c = str.charAt(i);

            switch (c) {

                case 0x0D:

                case 0x0A:

                    this.writer.print(c);

                    break;

                case '<':

                    this.writer.print("<");

                    break;

                case '>':

                    this.writer.print(">");

                    break;

                case '&':

                    this.writer.print("&");

                    break;

                case '\'':

                    this.writer.print("'");

                    break;

                case '"':

                    this.writer.print(""");

                    break;

                default:

                    if ((c < ' ') || (c > 0x7E)) {

                        this.writer.print("&#x");

                        this.writer.print(Integer.toString(c, 16));

                        this.writer.print(';');

                    } else {

                        this.writer.print(c);

                    }

            }

        }

    }

}

/* ContentReader.java                                              NanoXML/Java

 *

 * $Revision: 5819 $

 * $Date: 2006-06-14 09:29:09 +0200 $

 * $Name$

 *

 * This file is part of NanoXML 2 for Java.

 * Copyright (C) 2001 Marc De Scheemaecker, All Rights Reserved.

 *

 * This software is provided 'as-is', without any express or implied warranty.

 * In no event will the authors be held liable for any damages arising from the

 * use of this software.

 *

 * Permission is granted to anyone to use this software for any purpose,

 * including commercial applications, and to alter it and redistribute it

 * freely, subject to the following restrictions:

 *

 *  1. The origin of this software must not be misrepresented; you must not

 *     claim that you wrote the original software. If you use this software in

 *     a product, an acknowledgment in the product documentation would be

 *     appreciated but is not required.

 *

 *  2. Altered source versions must be plainly marked as such, and must not be

 *     misrepresented as being the original software.

 *

 *  3. This notice may not be removed or altered from any source distribution.

 */

package net.n3.nanoxml;

import java.io.IOException;

import java.io.Reader;

/**

 * This reader reads data from another reader until a certain string is

 * encountered.

 *

 * @author Marc De Scheemaecker

 * @version $Name$, $Version$

 */

class ContentReader

    extends Reader

{

    /**

     * The encapsulated reader.

     */

    private IXMLReader reader;

    /**

     * The encapsulated entityResolver.

     */

    private IXMLEntityResolver entityResolver;

    /**

     * The escape char (& or %).

     */

    private char escapeChar;

    /**

     * The delimiter that will indicate the end of the stream.

     */

    private char[] delimiter;

    /**

     * The characters that have been read too much.

     */

    private String charsReadTooMuch;

    /**

     * The number of characters in the delimiter that stil need to be

     * scanned.

     */

    private int charsToGo;

    /**

     * True if the escape char (& or %) needs to be left untouched.

     */

    private boolean useLowLevelReader;

    /**

     * True if we are passed the initial prefix.

     */

    private boolean pastInitialPrefix;

    /**

     * Creates the reader.

     *

     * @param reader the encapsulated reader

     * @param entityResolver resolves entities

     * @param escapeChar escape character (& or %)

     * @param delimiter the delimiter, as a backwards string, that will 

     *                  indicate the end of the stream

     * @param useLowLevelReader true if & needs to be left untouched;

     *                          false if entities need to be processed

     * @param prefix chars that are already read

     */

    ContentReader(IXMLReader         reader,

                  IXMLEntityResolver entityResolver,

                  char               escapeChar,

                  char[]             delimiter,

                  boolean            useLowLevelReader,

                  String             prefix)

    {

        this.delimiter = delimiter;

        this.charsToGo = this.delimiter.length;

        this.charsReadTooMuch = prefix;

        this.useLowLevelReader = useLowLevelReader;

        this.pastInitialPrefix = false;

        this.reader = reader;

        this.entityResolver = entityResolver;

        this.escapeChar = escapeChar;

    }

    /**

     * Cleans up the object when it's destroyed.

     */

    protected void finalize()

        throws Throwable

    {

        this.reader = null;

        this.entityResolver = null;

        this.delimiter = null;

        this.charsReadTooMuch = null;

        super.finalize();

    }

    /**

     * Reads a block of data.

     *

     * @param buffer where to put the read data

     * @param offset first position in buffer to put the data

     * @param size maximum number of chars to read

     *

     * @return the number of chars read, or -1 if at EOF

     *

     * @throws java.io.IOException

     *		if an error occurred reading the data

     */

    public int read(char[] buffer,

                    int    offset,

                    int    size)

        throws IOException

    {

        int charsRead = 0;

        boolean isEntity[] = new boolean[1];

        isEntity[0] = false;

        if ((offset + size) > buffer.length) {

            size = buffer.length - offset;

        }

        while ((this.charsToGo > 0) && (charsRead < size)) {

            char ch;

            if (this.charsReadTooMuch.length() > 0) {

                ch = this.charsReadTooMuch.charAt(0);

                this.charsReadTooMuch = this.charsReadTooMuch.substring(1);

            } else {

                this.pastInitialPrefix = true;

                try {

                    if (useLowLevelReader) {

                        ch = this.reader.read();

                    } else {

                        ch = XMLUtil.read(this.reader, isEntity,

                                          this.escapeChar,

                                          this.entityResolver);

                        if (! isEntity[0]) {

                            if (ch == '&') {

                                this.reader.startNewStream(

                                    XMLUtil.scanEntity(isEntity,

                                                       this.reader,

                                                       this.escapeChar,

                                                       this.entityResolver));

                                ch = this.reader.read();

                            }

                        }

                    }

                } catch (XMLParseException e) {

                    throw new RuntimeException(e.getMessage());

                    // necessary to be able to implement Reader

                }

            }

            if (isEntity[0]) {

                buffer[offset + charsRead] = ch;

                charsRead++;

            } else {

                if ((ch == (this.delimiter[this.charsToGo - 1]))

                        && pastInitialPrefix) {

                    --this.charsToGo;

                } else if (this.charsToGo < this.delimiter.length) {

                    this.charsReadTooMuch

                            = new String(this.delimiter, this.charsToGo + 1,

                                        this.delimiter.length - this.charsToGo)

                                   + ch;

                    this.charsToGo = this.delimiter.length;

                    buffer[offset + charsRead]

                            = this.delimiter[this.charsToGo - 1];

                    charsRead++;

                } else {

                    buffer[offset + charsRead] = ch;

                    charsRead++;

                }

            }

        }

        if (charsRead == 0) {

            charsRead = -1;

        }

        return charsRead;

    }

    /**

     * Skips remaining data and closes the stream.

     *

     * @throws java.io.IOException

     *		if an error occurred reading the data

     */

    public void close()

        throws IOException

    {

        while (this.charsToGo > 0) {

            char ch;

            if (this.charsReadTooMuch.length() > 0) {

                ch = this.charsReadTooMuch.charAt(0);

                this.charsReadTooMuch = this.charsReadTooMuch.substring(1);

            } else {

                if (useLowLevelReader) {

                    ch = this.reader.read();

                } else {

                    try {

                        ch = XMLUtil.read(this.reader, null, this.escapeChar,

                                        this.entityResolver);

                    } catch (XMLParseException e) {

                        throw new RuntimeException(e.getMessage());

                        // necessary to be able to implement Reader

                    }

                }

            }

            if (ch == (this.delimiter[this.charsToGo - 1])) {

                --this.charsToGo;

            } else if (this.charsToGo < this.delimiter.length) {

                this.charsReadTooMuch

                        = new String(this.delimiter, this.charsToGo + 1,

                                     this.delimiter.length - this.charsToGo)

                                + ch;

                this.charsToGo = this.delimiter.length;

            }

        }

    }

}

/* StdXMLReader.java                                               NanoXML/Java

 *

 * $Revision: 5819 $

 * $Date: 2006-06-14 09:29:09 +0200 $

 * $Name$

 *

 * This file is part of NanoXML 2 for Java.

 * Copyright (C) 2001 Marc De Scheemaecker, All Rights Reserved.

 *

 * This software is provided 'as-is', without any express or implied warranty.

 * In no event will the authors be held liable for any damages arising from the

 * use of this software.

 *

 * Permission is granted to anyone to use this software for any purpose,

 * including commercial applications, and to alter it and redistribute it

 * freely, subject to the following restrictions:

 *

 *  1. The origin of this software must not be misrepresented; you must not

 *     claim that you wrote the original software. If you use this software in

 *     a product, an acknowledgment in the product documentation would be

 *     appreciated but is not required.

 *

 *  2. Altered source versions must be plainly marked as such, and must not be

 *     misrepresented as being the original software.

 *

 *  3. This notice may not be removed or altered from any source distribution.

 */

package net.n3.nanoxml;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.LineNumberReader;

import java.io.PushbackInputStream;

import java.io.PushbackReader;

import java.io.Reader;

import java.io.StringReader;

import java.io.UnsupportedEncodingException;

import java.net.MalformedURLException;

import java.net.URL;

import java.util.Stack;

/**

 * StdXMLReader reads the data to be parsed.

 *

 * @author Marc De Scheemaecker

 * @version $Name$, $Revision: 5819 $

 */

public class StdXMLReader

    implements IXMLReader

{

    /**

     * The stack of push-back readers.

     */

    private Stack pbreaders;

    /**

     * The stack of line-number readers.

     */

    private Stack linereaders;

    /**

     * The stack of system ids.

     */

    private Stack systemIds;

    /**

     * The stack of public ids.

     */

    private Stack publicIds;

    /**

     * The current push-back reader.

     */

    private PushbackReader currentPbReader;

    /**

     * The current line-number reader.

     */

    private LineNumberReader currentLineReader;

    /**

     * The current system ID.

     */

    private URL currentSystemID;

    /**

     * The current public ID.

     */

    private String currentPublicID;

    /**

     * Creates a new reader using a string as input.

     *

     * @param str the string containing the XML data

     */

    public static IXMLReader stringReader(String str)

    {

        return new StdXMLReader(new StringReader(str));

    }

    /**

     * Creates a new reader using a file as input.

     *

     * @param filename the name of the file containing the XML data

     *

     * @throws java.io.FileNotFoundException

     *     if the file could not be found

     * @throws java.io.IOException

     *     if an I/O error occurred

     */

    public static IXMLReader fileReader(String filename)

        throws FileNotFoundException,

               IOException

    {

        IXMLReader reader = new StdXMLReader(new FileInputStream(filename));

        reader.setSystemID(filename);

        return reader;

    }

    /**

     * Initializes the reader from a system and public ID.

     *

     * @param publicID the public ID which may be null.

     * @param systemID the non-null system ID.

     *

     * @throws MalformedURLException

     *     if the system ID does not contain a valid URL

     * @throws FileNotFoundException

     *     if the system ID refers to a local file which does not exist

     * @throws IOException

     *     if an error occurred opening the stream

     */

    public StdXMLReader(String publicID,

                        String systemID)

        throws MalformedURLException,

               FileNotFoundException,

               IOException

    {

        URL systemIDasURL = null;

        try {

            systemIDasURL = new URL(systemID);

        } catch (MalformedURLException e) {

            systemID = "file:" + systemID;

            try {

                systemIDasURL = new URL(systemID);

            } catch (MalformedURLException e2) {

                throw e;

            }

        }

        Reader reader = this.openStream(publicID, systemIDasURL.toString());

        this.currentLineReader = new LineNumberReader(reader);

        this.currentPbReader = new PushbackReader(this.currentLineReader, 2);

        this.pbreaders = new Stack();

        this.linereaders = new Stack();

        this.publicIds = new Stack();

        this.systemIds = new Stack();

        this.currentPublicID = publicID;

        this.currentSystemID = systemIDasURL;

    }

    /**

     * Initializes the XML reader.

     *

     * @param reader the input for the XML data.

     */

    public StdXMLReader(Reader reader)

    {

        this.currentLineReader = new LineNumberReader(reader);

        this.currentPbReader = new PushbackReader(this.currentLineReader, 2);

        this.pbreaders = new Stack();

        this.linereaders = new Stack();

        this.publicIds = new Stack();

        this.systemIds = new Stack();

        this.currentPublicID = "";

        try {

            this.currentSystemID = new URL("file:.");

        } catch (MalformedURLException e) {

            // never happens

        }

    }

    /**

     * Cleans up the object when it's destroyed.

     */

    protected void finalize()

        throws Throwable

    {

        this.currentLineReader = null;

        this.currentPbReader = null;

        this.pbreaders.clear();

        this.pbreaders = null;

        this.linereaders.clear();

        this.linereaders = null;

        this.publicIds.clear();

        this.publicIds = null;

        this.systemIds.clear();

        this.systemIds = null;

        this.currentPublicID = null;

        super.finalize();

    }

    /**

     * Scans the encoding from an <?xml?> tag.

     *

     * @param str the first tag in the XML data.

     *

     * @return the encoding, or null if no encoding has been specified.

     */

    protected String getEncoding(String str)

    {

        if (! str.startsWith("<?xml")) {

            return null;

        }

        int index = 5;

        while (index < str.length()) {

            StringBuffer key = new StringBuffer();

            while ((index < str.length()) && (str.charAt(index) <= ' ')) {

                index++;

            }

            while ((index < str.length())

                   && (str.charAt(index) >= 'a')

                   && (str.charAt(index) <= 'z')) {

                key.append(str.charAt(index));

                index++;

            }

            while ((index < str.length()) && (str.charAt(index) <= ' ')) {

                index++;

            }

            if ((index >= str.length()) || (str.charAt(index) != '=')) {

                break;

            }

            while ((index < str.length()) && (str.charAt(index) != '\'')

                   && (str.charAt(index) != '"')) {

                index++;

            }

            if (index >= str.length()) {

                break;

            }

            char delimiter = str.charAt(index);

            index++;

            int index2 = str.indexOf(delimiter, index);

            if (index2 < 0) {

                break;

            }

            if (key.toString().equals("encoding")) {

                return str.substring(index, index2);

            }

            index = index2 + 1;

        }

        return null;

    }

    /**

     * Converts a stream to a reader while detecting the encoding.

     *

     * @param stream    the input for the XML data.

     * @param charsRead buffer where to put characters that have been read

     *

     * @throws java.io.IOException

     *     if an I/O error occurred

     */

    protected Reader stream2reader(InputStream  stream,

                                   StringBuffer charsRead)

        throws IOException

    {

        PushbackInputStream pbstream = new PushbackInputStream(stream);

        int b = pbstream.read();

        switch (b) {

            case 0x00:

            case 0xFE:

            case 0xFF:

                pbstream.unread(b);

                return new InputStreamReader(pbstream, "UTF-16");

            case 0xEF:

                for (int i = 0; i < 2; i++) {

                    pbstream.read();

                }

                return new InputStreamReader(pbstream, "UTF-8");

            case 0x3C:

                b = pbstream.read();

                charsRead.append('<');

                while ((b > 0) && (b != 0x3E)) {

                    charsRead.append((char) b);

                    b = pbstream.read();

                }

                if (b > 0) {

                    charsRead.append((char) b);

                }

                String encoding = this.getEncoding(charsRead.toString());

                if (encoding == null) {

                    return new InputStreamReader(pbstream, "UTF-8");

                }

                charsRead.setLength(0);

                try {

                    return new InputStreamReader(pbstream, encoding);

                } catch (UnsupportedEncodingException e) {

                    return new InputStreamReader(pbstream, "UTF-8");

                }

            default:

                charsRead.append((char) b);

                return new InputStreamReader(pbstream, "UTF-8");

        }

    }

    /**

     * Initializes the XML reader.

     *

     * @param stream the input for the XML data.

     *

     * @throws java.io.IOException

     *		if an I/O error occurred

     */

    public StdXMLReader(InputStream stream)

        throws IOException

    {

        PushbackInputStream pbstream = new PushbackInputStream(stream);

        StringBuffer charsRead = new StringBuffer();

        Reader reader = this.stream2reader(stream, charsRead);

        this.currentLineReader = new LineNumberReader(reader);

        this.currentPbReader = new PushbackReader(this.currentLineReader, 2);

        this.pbreaders = new Stack();

        this.linereaders = new Stack();

        this.publicIds = new Stack();

        this.systemIds = new Stack();

        this.currentPublicID = "";

        try {

            this.currentSystemID = new URL("file:.");

        } catch (MalformedURLException e) {

            // never happens

        }

        this.startNewStream(new StringReader(charsRead.toString()));

    }

    /**

     * Reads a character.

     *

     * @return the character

     *

     * @throws java.io.IOException

     *		if no character could be read

     */

    public char read()

        throws IOException

    {

        int ch = this.currentPbReader.read();

        while (ch < 0) {

            if (this.pbreaders.empty()) {

                throw new IOException("Unexpected EOF");

            }

            this.currentPbReader.close();

            this.currentPbReader = (PushbackReader) this.pbreaders.pop();

            this.currentLineReader = (LineNumberReader) this.linereaders.pop();

            this.currentSystemID = (URL) this.systemIds.pop();

            this.currentPublicID = (String) this.publicIds.pop();

            ch = this.currentPbReader.read();

        }

        if (ch == 0x0D) { // CR

            // using recursion could convert "\r\r\n" to "\n" (wrong),

            // newline combo "\r\n" isn't normalized if it spans streams

            // next 'read()' will pop pbreaders stack appropriately

            ch = this.currentPbReader.read();

            if (ch != 0x0A && ch > 0) { // LF

                this.currentPbReader.unread(ch);

            }

            return (char) 0x0A; // normalized: always LF

        }

        return (char) ch;

    }

    /**

     * Returns true if the current stream has no more characters left to be

     * read.

     *

     * @throws java.io.IOException

     *		if an I/O error occurred

     */

    public boolean atEOFOfCurrentStream()

        throws IOException

    {

        int ch = this.currentPbReader.read();

        if (ch < 0) {

            return true;

        } else {

            this.currentPbReader.unread(ch);

            return false;

        }

    }

    /**

     * Returns true if there are no more characters left to be read.

     *

     * @throws java.io.IOException

     *		if an I/O error occurred

     */

    public boolean atEOF()

        throws IOException

    {

        int ch = this.currentPbReader.read();

        while (ch < 0) {

            if (this.pbreaders.empty()) {

                return true;

            }

            this.currentPbReader.close();

            this.currentPbReader = (PushbackReader) this.pbreaders.pop();

            this.currentLineReader = (LineNumberReader) this.linereaders.pop();

            this.currentSystemID = (URL) this.systemIds.pop();

            this.currentPublicID = (String) this.publicIds.pop();

            ch = this.currentPbReader.read();

        }

        this.currentPbReader.unread(ch);

        return false;

    }