commit d3a78f9ccf07b926375eba782097153e5c472af2 Author: gil puntogil@libero.it Date: Wed Aug 8 17:08:55 2012 +0200
Initial import (#833494)
.gitignore | 1 + gshell-2.6.4-javacc.patch | 60 + gshell-2.6.5-build.patch | 261 + gshell-2.6.5-disable-gshell-bootstrap.patch | 25 + ...ll-2.6.5-dont-use-repackaged-plexus-utils.patch | 7624 ++++++++++++++++++++ gshell-2.6.5-remove-commons-jexl1.patch | 224 + gshell.spec | 262 + sources | 1 + 8 files changed, 8458 insertions(+), 0 deletions(-) --- diff --git a/.gitignore b/.gitignore index e69de29..b51694c 100644 --- a/.gitignore +++ b/.gitignore @@ -0,0 +1 @@ +/gshell-2.6.5-src-git.tar.gz diff --git a/gshell-2.6.4-javacc.patch b/gshell-2.6.4-javacc.patch new file mode 100644 index 0000000..9def9b7 --- /dev/null +++ b/gshell-2.6.4-javacc.patch @@ -0,0 +1,60 @@ +diff -Nru gshell-2.6.4/gshell-core/src/main/grammar/Parser.jjt gshell-2.6.4-gil/gshell-core/src/main/grammar/Parser.jjt +--- gshell-2.6.4/gshell-core/src/main/grammar/Parser.jjt 2011-03-30 20:10:00.000000000 +0200 ++++ gshell-2.6.4-gil/gshell-core/src/main/grammar/Parser.jjt 2011-08-12 17:42:38.102648204 +0200 +@@ -185,7 +185,7 @@ + { + t=<QUOTED_STRING> + { +- jjtThis.setValue(t.image); ++ jjtThis.jjtSetValue(t.image); + } + } + +@@ -196,7 +196,7 @@ + { + t=<OPAQUE_STRING> + { +- jjtThis.setValue(t.image); ++ jjtThis.jjtSetValue(t.image); + } + } + +@@ -207,7 +207,7 @@ + { + t=<STRING> + { +- jjtThis.setValue(t.image); ++ jjtThis.jjtSetValue(t.image); + } + } + +diff -Nru gshell-2.6.4/gshell-core/src/main/java/org/sonatype/gshell/parser/impl/visitor/ExecutingVisitor.java gshell-2.6.4-gil/gshell-core/src/main/java/org/sonatype/gshell/parser/impl/visitor/ExecutingVisitor.java +--- gshell-2.6.4/gshell-core/src/main/java/org/sonatype/gshell/parser/impl/visitor/ExecutingVisitor.java 2011-03-30 20:10:00.000000000 +0200 ++++ gshell-2.6.4-gil/gshell-core/src/main/java/org/sonatype/gshell/parser/impl/visitor/ExecutingVisitor.java 2011-08-12 17:42:38.103648204 +0200 +@@ -118,7 +118,7 @@ + assert data != null; + + ExpressionState state = (ExpressionState) data; +- String value = eval(node.getValue()); ++ String value = eval((String) node.jjtGetValue()); + return state.append(value); + } + +@@ -127,7 +127,7 @@ + assert data != null; + + ExpressionState state = (ExpressionState) data; +- String value = eval(node.getValue()); ++ String value = eval((String) node.jjtGetValue()); + return state.append(value); + } + +@@ -135,7 +135,7 @@ + assert node != null; + + ExpressionState state = (ExpressionState) data; +- return state.append(node.getValue()); ++ return state.append((String) node.jjtGetValue()); + } + + private String eval(final String expression) { diff --git a/gshell-2.6.5-build.patch b/gshell-2.6.5-build.patch new file mode 100644 index 0000000..ff5dcfd --- /dev/null +++ b/gshell-2.6.5-build.patch @@ -0,0 +1,261 @@ +diff -Nru gshell-2.6.5/gshell-commands/gshell-file/pom.xml gshell-2.6.5-gil/gshell-commands/gshell-file/pom.xml +--- gshell-2.6.5/gshell-commands/gshell-file/pom.xml 2011-12-28 20:41:12.000000000 +0100 ++++ gshell-2.6.5-gil/gshell-commands/gshell-file/pom.xml 2012-06-19 11:13:13.070752841 +0200 +@@ -37,7 +37,7 @@ + </dependency> + </dependencies> + +- <profiles> ++ <!--profiles> + <profile> + <id>assembly</id> + <activation> +@@ -61,7 +61,7 @@ + </plugins> + </build> + </profile> +- </profiles> ++ </profiles--> + + </project> + +diff -Nru gshell-2.6.5/gshell-commands/gshell-groovy/pom.xml gshell-2.6.5-gil/gshell-commands/gshell-groovy/pom.xml +--- gshell-2.6.5/gshell-commands/gshell-groovy/pom.xml 2011-12-28 20:41:12.000000000 +0100 ++++ gshell-2.6.5-gil/gshell-commands/gshell-groovy/pom.xml 2012-06-19 11:12:50.681752157 +0200 +@@ -42,7 +42,7 @@ + </dependency> + </dependencies> + +- <profiles> ++ <!--profiles> + <profile> + <id>assembly</id> + <activation> +@@ -66,7 +66,7 @@ + </plugins> + </build> + </profile> +- </profiles> ++ </profiles--> + + </project> + +diff -Nru gshell-2.6.5/gshell-commands/gshell-jetty/pom.xml gshell-2.6.5-gil/gshell-commands/gshell-jetty/pom.xml +--- gshell-2.6.5/gshell-commands/gshell-jetty/pom.xml 2011-12-28 20:41:12.000000000 +0100 ++++ gshell-2.6.5-gil/gshell-commands/gshell-jetty/pom.xml 2012-06-19 11:12:24.855751365 +0200 +@@ -76,7 +76,7 @@ + <!--</dependency>--> + </dependencies> + +- <profiles> ++ <!--profiles> + <profile> + <id>assembly</id> + <activation> +@@ -100,7 +100,7 @@ + </plugins> + </build> + </profile> +- </profiles> ++ </profiles--> + + </project> + +diff -Nru gshell-2.6.5/gshell-commands/gshell-logging/pom.xml gshell-2.6.5-gil/gshell-commands/gshell-logging/pom.xml +--- gshell-2.6.5/gshell-commands/gshell-logging/pom.xml 2011-12-28 20:41:12.000000000 +0100 ++++ gshell-2.6.5-gil/gshell-commands/gshell-logging/pom.xml 2012-06-19 11:13:54.851754120 +0200 +@@ -29,7 +29,7 @@ + <artifactId>gshell-logging</artifactId> + <name>GShell Commands :: Logging</name> + +- <profiles> ++ <!--profiles> + <profile> + <id>assembly</id> + <activation> +@@ -53,7 +53,7 @@ + </plugins> + </build> + </profile> +- </profiles> ++ </profiles--> + + </project> + +diff -Nru gshell-2.6.5/gshell-commands/gshell-network/pom.xml gshell-2.6.5-gil/gshell-commands/gshell-network/pom.xml +--- gshell-2.6.5/gshell-commands/gshell-network/pom.xml 2011-12-28 20:41:12.000000000 +0100 ++++ gshell-2.6.5-gil/gshell-commands/gshell-network/pom.xml 2012-06-19 11:13:35.109753516 +0200 +@@ -29,7 +29,7 @@ + <artifactId>gshell-network</artifactId> + <name>GShell Commands :: Network</name> + +- <profiles> ++ <!--profiles> + <profile> + <id>assembly</id> + <activation> +@@ -53,7 +53,7 @@ + </plugins> + </build> + </profile> +- </profiles> ++ </profiles--> + + </project> + +diff -Nru gshell-2.6.5/gshell-commands/gshell-pref/pom.xml gshell-2.6.5-gil/gshell-commands/gshell-pref/pom.xml +--- gshell-2.6.5/gshell-commands/gshell-pref/pom.xml 2011-12-28 20:41:12.000000000 +0100 ++++ gshell-2.6.5-gil/gshell-commands/gshell-pref/pom.xml 2012-06-19 11:24:14.445773079 +0200 +@@ -29,7 +29,7 @@ + <artifactId>gshell-pref</artifactId> + <name>GShell Commands :: Preferences</name> + +- <profiles> ++ <!--profiles> + <profile> + <id>assembly</id> + <activation> +@@ -53,7 +53,7 @@ + </plugins> + </build> + </profile> +- </profiles> ++ </profiles--> + + </project> + +diff -Nru gshell-2.6.5/gshell-commands/gshell-standard/pom.xml gshell-2.6.5-gil/gshell-commands/gshell-standard/pom.xml +--- gshell-2.6.5/gshell-commands/gshell-standard/pom.xml 2011-12-28 20:41:12.000000000 +0100 ++++ gshell-2.6.5-gil/gshell-commands/gshell-standard/pom.xml 2012-06-19 11:14:18.135754831 +0200 +@@ -43,7 +43,7 @@ + </dependency> + </dependencies> + +- <profiles> ++ <!--profiles> + <profile> + <id>assembly</id> + <activation> +@@ -81,7 +81,7 @@ + </plugins> + </build> + </profile> +- </profiles> ++ </profiles--> + + </project> + +diff -Nru gshell-2.6.5/gshell-core/pom.xml gshell-2.6.5-gil/gshell-core/pom.xml +--- gshell-2.6.5/gshell-core/pom.xml 2011-12-28 20:41:12.000000000 +0100 ++++ gshell-2.6.5-gil/gshell-core/pom.xml 2012-06-19 11:08:10.005743568 +0200 +@@ -45,6 +45,12 @@ + <artifactId>plexus-interpolation</artifactId> + </dependency> + ++ <dependency> ++ <groupId>com.google.inject</groupId> ++ <artifactId>guice</artifactId> ++ <version>3.0</version> ++ </dependency> ++ + <dependency> + <groupId>org.sonatype.sisu</groupId> + <artifactId>sisu-inject-bean</artifactId> +diff -Nru gshell-2.6.5/gshell-ext/gshell-plexus/pom.xml gshell-2.6.5-gil/gshell-ext/gshell-plexus/pom.xml +--- gshell-2.6.5/gshell-ext/gshell-plexus/pom.xml 2011-12-28 20:41:12.000000000 +0100 ++++ gshell-2.6.5-gil/gshell-ext/gshell-plexus/pom.xml 2012-06-19 11:09:37.646746249 +0200 +@@ -35,6 +35,12 @@ + <artifactId>slf4j-api</artifactId> + </dependency> + ++ <dependency> ++ <groupId>org.codehaus.plexus</groupId> ++ <artifactId>plexus-classworlds</artifactId> ++ <version>2.4</version> ++ </dependency> ++ + <dependency> + <groupId>org.codehaus.plexus</groupId> + <artifactId>plexus-container-default</artifactId> +diff -Nru gshell-2.6.5/pom.xml gshell-2.6.5-gil/pom.xml +--- gshell-2.6.5/pom.xml 2011-12-28 20:41:12.000000000 +0100 ++++ gshell-2.6.5-gil/pom.xml 2012-06-19 11:05:16.276738251 +0200 +@@ -81,8 +81,8 @@ + <properties> + <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> + <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> +- <sisu.assembler.tags>gshell</sisu.assembler.tags> +- <sisu.assembler.tags.plugins>gshell,gshell-plugins</sisu.assembler.tags.plugins> ++ <!--sisu.assembler.tags>gshell</sisu.assembler.tags> ++ <sisu.assembler.tags.plugins>gshell,gshell-plugins</sisu.assembler.tags.plugins--> + </properties> + + <repositories> +@@ -361,11 +361,11 @@ + + <pluginManagement> + <plugins> +- <plugin> ++ <!--plugin> + <groupId>org.codehaus.mojo</groupId> + <artifactId>versions-maven-plugin</artifactId> + <version>1.2</version> +- </plugin> ++ </plugin--> + + <plugin> + <groupId>org.apache.maven.plugins</groupId> +@@ -401,7 +401,7 @@ + </configuration> + </plugin> + +- <plugin> ++ <!--plugin> + <groupId>org.codehaus.gmaven</groupId> + <artifactId>gmaven-plugin</artifactId> + <version>1.3</version> +@@ -420,7 +420,7 @@ + <groupId>org.sonatype.plugins</groupId> + <artifactId>sisu-maven-plugin</artifactId> + <version>1.1</version> +- </plugin> ++ </plugin--> + </plugins> + </pluginManagement> + +@@ -491,7 +491,7 @@ + </configuration> + </plugin> + +- <plugin> ++ <!--plugin> + <groupId>org.sonatype.plugins</groupId> + <artifactId>sisu-maven-plugin</artifactId> + <executions> +@@ -502,7 +502,7 @@ + </goals> + </execution> + </executions> +- </plugin> ++ </plugin--> + + <!-- + mvn license:format -N +@@ -562,7 +562,7 @@ + </plugins> + </build> + +- <profiles> ++ <!--profiles> + <profile> + <id>assembly</id> + <activation> +@@ -574,7 +574,7 @@ + <module>gshell-dist</module> + </modules> + </profile> +- </profiles> ++ </profiles--> + + </project> + diff --git a/gshell-2.6.5-disable-gshell-bootstrap.patch b/gshell-2.6.5-disable-gshell-bootstrap.patch new file mode 100644 index 0000000..12190d6 --- /dev/null +++ b/gshell-2.6.5-disable-gshell-bootstrap.patch @@ -0,0 +1,25 @@ +--- pom.xml 2012-06-20 02:11:58.159977153 +0200 ++++ pom.xml-gil 2012-06-20 02:15:41.791983996 +0200 +@@ -251,11 +251,11 @@ + <version>2.6.5</version> + </dependency> + +- <dependency> ++ <!--dependency> + <groupId>org.sonatype.gshell</groupId> + <artifactId>gshell-bootstrap</artifactId> + <version>2.6.5</version> +- </dependency> ++ </dependency--> + + <!-- HACK: Duplicating for now, due to release plugin issue with scope=import --> + +@@ -317,7 +317,7 @@ + <module>gshell-core</module> + <module>gshell-commands</module> + <module>gshell-maven-plugin</module> +- <module>gshell-bootstrap</module> ++ <!--module>gshell-bootstrap</module--> + </modules> + + <build> diff --git a/gshell-2.6.5-dont-use-repackaged-plexus-utils.patch b/gshell-2.6.5-dont-use-repackaged-plexus-utils.patch new file mode 100644 index 0000000..3b1ef7b --- /dev/null +++ b/gshell-2.6.5-dont-use-repackaged-plexus-utils.patch @@ -0,0 +1,7624 @@ +diff -Nru gshell-2.6.5/gshell-util/pom.xml gshell-2.6.5-gil/gshell-util/pom.xml +--- gshell-2.6.5/gshell-util/pom.xml 2011-12-28 20:41:12.000000000 +0100 ++++ gshell-2.6.5-gil/gshell-util/pom.xml 2012-06-20 02:10:24.262974280 +0200 +@@ -62,6 +62,12 @@ + </dependency> + + <dependency> ++ <groupId>org.codehaus.plexus</groupId> ++ <artifactId>plexus-utils</artifactId> ++ <version>2.0.7</version> ++ </dependency> ++ ++ <dependency> + <groupId>junit</groupId> + <artifactId>junit</artifactId> + <scope>test</scope> +diff -Nru gshell-2.6.5/gshell-util/src/main/java/org/codehaus/plexus/util/ReaderFactory.java gshell-2.6.5-gil/gshell-util/src/main/java/org/codehaus/plexus/util/ReaderFactory.java +--- gshell-2.6.5/gshell-util/src/main/java/org/codehaus/plexus/util/ReaderFactory.java 2011-12-28 20:41:12.000000000 +0100 ++++ gshell-2.6.5-gil/gshell-util/src/main/java/org/codehaus/plexus/util/ReaderFactory.java 1970-01-01 01:00:00.000000000 +0100 +@@ -1,221 +0,0 @@ +-package org.codehaus.plexus.util; +- +-/* +- * Copyright The Codehaus Foundation. +- * +- * Licensed under the Apache License, Version 2.0 (the "License"); +- * you may not use this file except in compliance with the License. +- * You may obtain a copy of the License at +- * +- * http://www.apache.org/licenses/LICENSE-2.0 +- * +- * Unless required by applicable law or agreed to in writing, software +- * distributed under the License is distributed on an "AS IS" BASIS, +- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +- * See the License for the specific language governing permissions and +- * limitations under the License. +- */ +- +-import java.io.File; +-import java.io.FileInputStream; +-import java.io.FileNotFoundException; +-import java.io.FileReader; +-import java.io.IOException; +-import java.io.InputStream; +-import java.io.InputStreamReader; +-import java.io.Reader; +-import java.io.UnsupportedEncodingException; +-import java.net.URL; +-import java.nio.charset.Charset; +- +-import org.codehaus.plexus.util.xml.XmlStreamReader; +- +-/** +- * Utility to create Readers from streams, with explicit encoding choice: platform default, +- * XML, or specified. +- * +- * @author <a href="mailto:hboutemy@codehaus.org">Herve Boutemy</a> +- * @see Charset +- * @see <a href="http://java.sun.com/j2se/1.4.2/docs/guide/intl/encoding.doc.html">Supported encodings</a> +- * @version $Id: ReaderFactory.java 8010 2009-01-07 12:59:50Z vsiveton $ +- * @since 1.4.3 +- */ +-@Deprecated +-public class ReaderFactory +-{ +- /** +- * ISO Latin Alphabet #1, also known as ISO-LATIN-1. +- * Every implementation of the Java platform is required to support this character encoding. +- * @see Charset +- */ +- public static final String ISO_8859_1 = "ISO-8859-1"; +- +- /** +- * Seven-bit ASCII, also known as ISO646-US, also known as the Basic Latin block of the Unicode character set. +- * Every implementation of the Java platform is required to support this character encoding. +- * @see Charset +- */ +- public static final String US_ASCII = "US-ASCII"; +- +- /** +- * Sixteen-bit Unicode Transformation Format, byte order specified by a mandatory initial byte-order mark (either +- * order accepted on input, big-endian used on output). +- * Every implementation of the Java platform is required to support this character encoding. +- * @see Charset +- */ +- public static final String UTF_16 = "UTF-16"; +- +- /** +- * Sixteen-bit Unicode Transformation Format, big-endian byte order. +- * Every implementation of the Java platform is required to support this character encoding. +- * @see Charset +- */ +- public static final String UTF_16BE = "UTF-16BE"; +- +- /** +- * Sixteen-bit Unicode Transformation Format, little-endian byte order. +- * Every implementation of the Java platform is required to support this character encoding. +- * @see Charset +- */ +- public static final String UTF_16LE = "UTF-16LE"; +- +- /** +- * Eight-bit Unicode Transformation Format. +- * Every implementation of the Java platform is required to support this character encoding. +- * @see Charset +- */ +- public static final String UTF_8 = "UTF-8"; +- +- /** +- * The <code>file.encoding</code> System Property. +- */ +- public static final String FILE_ENCODING = System.getProperty( "file.encoding" ); +- +- /** +- * Create a new Reader with XML encoding detection rules. +- * +- * @param in not null input stream. +- * @return an XML reader instance for the input stream. +- * @throws IOException if any. +- * @see XmlStreamReader +- */ +- public static XmlStreamReader newXmlReader( InputStream in ) +- throws IOException +- { +- return new XmlStreamReader( in ); +- } +- +- /** +- * Create a new Reader with XML encoding detection rules. +- * +- * @param file not null file. +- * @return an XML reader instance for the input file. +- * @throws IOException if any. +- * @see XmlStreamReader +- */ +- public static XmlStreamReader newXmlReader( File file ) +- throws IOException +- { +- return new XmlStreamReader( file ); +- } +- +- /** +- * Create a new Reader with XML encoding detection rules. +- * +- * @param url not null url. +- * @return an XML reader instance for the input url. +- * @throws IOException if any. +- * @see XmlStreamReader +- */ +- public static XmlStreamReader newXmlReader( URL url ) +- throws IOException +- { +- return new XmlStreamReader( url ); +- } +- +- /** +- * Create a new Reader with default plaform encoding. +- * +- * @param in not null input stream. +- * @return a reader instance for the input stream using the default platform charset. +- * @see Charset#defaultCharset() +- */ +- public static Reader newPlatformReader( InputStream in ) +- { +- return new InputStreamReader( in ); +- } +- +- /** +- * Create a new Reader with default plaform encoding. +- * +- * @param file not null file. +- * @return a reader instance for the input file using the default platform charset. +- * @throws FileNotFoundException if any. +- * @see Charset#defaultCharset() +- */ +- public static Reader newPlatformReader( File file ) +- throws FileNotFoundException +- { +- return new FileReader( file ); +- } +- +- /** +- * Create a new Reader with default plaform encoding. +- * +- * @param url not null url. +- * @return a reader instance for the input url using the default platform charset. +- * @throws IOException if any. +- * @see Charset#defaultCharset() +- */ +- public static Reader newPlatformReader( URL url ) +- throws IOException +- { +- return new InputStreamReader( url.openStream() ); +- } +- +- /** +- * Create a new Reader with specified encoding. +- * +- * @param in not null input stream. +- * @param encoding not null supported encoding. +- * @return a reader instance for the input stream using the given encoding. +- * @throws UnsupportedEncodingException if any. +- * @see <a href="http://java.sun.com/j2se/1.4.2/docs/guide/intl/encoding.doc.html">Supported encodings</a> +- */ +- public static Reader newReader( InputStream in, String encoding ) +- throws UnsupportedEncodingException +- { +- return new InputStreamReader( in, encoding ); +- } +- +- /** +- * Create a new Reader with specified encoding. +- * +- * @param file not null file. +- * @param encoding not null supported encoding. +- * @return a reader instance for the input file using the given encoding. +- * @throws FileNotFoundException if any. +- * @throws UnsupportedEncodingException if any. +- * @see <a href="http://java.sun.com/j2se/1.4.2/docs/guide/intl/encoding.doc.html">Supported encodings</a> +- */ +- public static Reader newReader( File file, String encoding ) +- throws FileNotFoundException, UnsupportedEncodingException +- { +- return new InputStreamReader( new FileInputStream(file), encoding ); +- } +- +- /** +- * Create a new Reader with specified encoding. +- * +- * @param url not null url. +- * @param encoding not null supported encoding. +- * @return a reader instance for the input url using the given encoding. +- * @throws IOException if any. +- * @see <a href="http://java.sun.com/j2se/1.4.2/docs/guide/intl/encoding.doc.html">Supported encodings</a> +- */ +- public static Reader newReader( URL url, String encoding ) +- throws IOException +- { +- return new InputStreamReader( url.openStream(), encoding ); +- } +-} +diff -Nru gshell-2.6.5/gshell-util/src/main/java/org/codehaus/plexus/util/xml/pull/MXParser.java gshell-2.6.5-gil/gshell-util/src/main/java/org/codehaus/plexus/util/xml/pull/MXParser.java +--- gshell-2.6.5/gshell-util/src/main/java/org/codehaus/plexus/util/xml/pull/MXParser.java 2011-12-28 20:41:12.000000000 +0100 ++++ gshell-2.6.5-gil/gshell-util/src/main/java/org/codehaus/plexus/util/xml/pull/MXParser.java 1970-01-01 01:00:00.000000000 +0100 +@@ -1,3375 +0,0 @@ +-/* -*- c-basic-offset: 4; indent-tabs-mode: nil; -*- //------100-columns-wide------>|*/ +-/* +- * Copyright (c) 2003 Extreme! Lab, Indiana University. All rights reserved. +- * +- * This software is open source. See the bottom of this file for the licence. +- * +- * $Id: MXParser.java 8238 2009-05-28 23:51:31Z vsiveton $ +- */ +- +-package org.codehaus.plexus.util.xml.pull; +- +-import java.io.EOFException; +-import java.io.IOException; +-import java.io.Reader; +-import java.io.UnsupportedEncodingException; +- +-import org.codehaus.plexus.util.ReaderFactory; +- +-//import java.util.Hashtable; +- +-//TODO best handling of interning issues +-// have isAllNewStringInterned ??? +- +-//TODO handling surrogate pairs: http://www.unicode.org/unicode/faq/utf_bom.html#6 +- +-//TODO review code for use of bufAbsoluteStart when keeping pos between next()/fillBuf() +- +-/** +- * Absolutely minimal implementation of XMLPULL V1 API. Encoding handling done with XmlReader +- * +- * @see org.codehaus.plexus.util.xml.XmlReader +- * @author <a href="http://www.extreme.indiana.edu/~aslom/">Aleksander Slominski</a> +- */ +-@Deprecated +-public class MXParser +- implements XmlPullParser +-{ +- //NOTE: no interning of those strings --> by Java leng spec they MUST be already interned +- protected final static String XML_URI = "http://www.w3.org/XML/1998/namespace"; +- protected final static String XMLNS_URI = "http://www.w3.org/2000/xmlns/"; +- protected final static String FEATURE_XML_ROUNDTRIP= +- //"http://xmlpull.org/v1/doc/features.html#xml-roundtrip"; +- "http://xmlpull.org/v1/doc/features.html#xml-roundtrip"; +- protected final static String FEATURE_NAMES_INTERNED = +- "http://xmlpull.org/v1/doc/features.html#names-interned"; +- protected final static String PROPERTY_XMLDECL_VERSION = +- "http://xmlpull.org/v1/doc/properties.html#xmldecl-version"; +- protected final static String PROPERTY_XMLDECL_STANDALONE = +- "http://xmlpull.org/v1/doc/properties.html#xmldecl-standalone"; +- protected final static String PROPERTY_XMLDECL_CONTENT = +- "http://xmlpull.org/v1/doc/properties.html#xmldecl-content"; +- protected final static String PROPERTY_LOCATION = +- "http://xmlpull.org/v1/doc/properties.html#location"; +- +- /** +- * Implementation notice: +- * the is instance variable that controls if newString() is interning. +- * <p><b>NOTE:</b> newStringIntern <b>always</b> returns interned strings +- * and newString MAY return interned String depending on this variable. +- * <p><b>NOTE:</b> by default in this minimal implementation it is false! +- */ +- protected boolean allStringsInterned; +- +- protected void resetStringCache() { +- //System.out.println("resetStringCache() minimum called"); +- } +- +- protected String newString(char[] cbuf, int off, int len) { +- return new String(cbuf, off, len); +- } +- +- protected String newStringIntern(char[] cbuf, int off, int len) { +- return (new String(cbuf, off, len)).intern(); +- } +- +- private static final boolean TRACE_SIZING = false; +- +- // NOTE: features are not resetable and typically defaults to false ... +- protected boolean processNamespaces; +- protected boolean roundtripSupported; +- +- // global parser state +- protected String location; +- protected int lineNumber; +- protected int columnNumber; +- protected boolean seenRoot; +- protected boolean reachedEnd; +- protected int eventType; +- protected boolean emptyElementTag; +- // element stack +- protected int depth; +- protected char[] elRawName[]; +- protected int elRawNameEnd[]; +- protected int elRawNameLine[]; +- +- protected String elName[]; +- protected String elPrefix[]; +- protected String elUri[]; +- //protected String elValue[]; +- protected int elNamespaceCount[]; +- +- +- +- /** +- * Make sure that we have enough space to keep element stack if passed size. +- * It will always create one additional slot then current depth +- */ +- protected void ensureElementsCapacity() { +- final int elStackSize = elName != null ? elName.length : 0; +- if( (depth + 1) >= elStackSize) { +- // we add at least one extra slot ... +- final int newSize = (depth >= 7 ? 2 * depth : 8) + 2; // = lucky 7 + 1 //25 +- if(TRACE_SIZING) { +- System.err.println("TRACE_SIZING elStackSize "+elStackSize+" ==> "+newSize); +- } +- final boolean needsCopying = elStackSize > 0; +- String[] arr = null; +- // resue arr local variable slot +- arr = new String[newSize]; +- if(needsCopying) System.arraycopy(elName, 0, arr, 0, elStackSize); +- elName = arr; +- arr = new String[newSize]; +- if(needsCopying) System.arraycopy(elPrefix, 0, arr, 0, elStackSize); +- elPrefix = arr; +- arr = new String[newSize]; +- if(needsCopying) System.arraycopy(elUri, 0, arr, 0, elStackSize); +- elUri = arr; +- +- int[] iarr = new int[newSize]; +- if(needsCopying) { +- System.arraycopy(elNamespaceCount, 0, iarr, 0, elStackSize); +- } else { +- // special initialization +- iarr[0] = 0; +- } +- elNamespaceCount = iarr; +- +- //TODO: avoid using element raw name ... +- iarr = new int[newSize]; +- if(needsCopying) { +- System.arraycopy(elRawNameEnd, 0, iarr, 0, elStackSize); +- } +- elRawNameEnd = iarr; +- +- iarr = new int[newSize]; +- if(needsCopying) { +- System.arraycopy(elRawNameLine, 0, iarr, 0, elStackSize); +- } +- elRawNameLine = iarr; +- +- final char[][] carr = new char[newSize][]; +- if(needsCopying) { +- System.arraycopy(elRawName, 0, carr, 0, elStackSize); +- } +- elRawName = carr; +- // arr = new String[newSize]; +- // if(needsCopying) System.arraycopy(elLocalName, 0, arr, 0, elStackSize); +- // elLocalName = arr; +- // arr = new String[newSize]; +- // if(needsCopying) System.arraycopy(elDefaultNs, 0, arr, 0, elStackSize); +- // elDefaultNs = arr; +- // int[] iarr = new int[newSize]; +- // if(needsCopying) System.arraycopy(elNsStackPos, 0, iarr, 0, elStackSize); +- // for (int i = elStackSize; i < iarr.length; i++) +- // { +- // iarr[i] = (i > 0) ? -1 : 0; +- // } +- // elNsStackPos = iarr; +- //assert depth < elName.length; +- } +- } +- +- +- +- // attribute stack +- protected int attributeCount; +- protected String attributeName[]; +- protected int attributeNameHash[]; +- //protected int attributeNameStart[]; +- //protected int attributeNameEnd[]; +- protected String attributePrefix[]; +- protected String attributeUri[]; +- protected String attributeValue[]; +- //protected int attributeValueStart[]; +- //protected int attributeValueEnd[]; +- +- +- /** +- * Make sure that in attributes temporary array is enough space. +- */ +- protected void ensureAttributesCapacity(int size) { +- final int attrPosSize = attributeName != null ? attributeName.length : 0; +- if(size >= attrPosSize) { +- final int newSize = size > 7 ? 2 * size : 8; // = lucky 7 + 1 //25 +- if(TRACE_SIZING) { +- System.err.println("TRACE_SIZING attrPosSize "+attrPosSize+" ==> "+newSize); +- } +- final boolean needsCopying = attrPosSize > 0; +- String[] arr = null; +- +- arr = new String[newSize]; +- if(needsCopying) System.arraycopy(attributeName, 0, arr, 0, attrPosSize); +- attributeName = arr; +- +- arr = new String[newSize]; +- if(needsCopying) System.arraycopy(attributePrefix, 0, arr, 0, attrPosSize); +- attributePrefix = arr; +- +- arr = new String[newSize]; +- if(needsCopying) System.arraycopy(attributeUri, 0, arr, 0, attrPosSize); +- attributeUri = arr; +- +- arr = new String[newSize]; +- if(needsCopying) System.arraycopy(attributeValue, 0, arr, 0, attrPosSize); +- attributeValue = arr; +- +- if( ! allStringsInterned ) { +- final int[] iarr = new int[newSize]; +- if(needsCopying) System.arraycopy(attributeNameHash, 0, iarr, 0, attrPosSize); +- attributeNameHash = iarr; +- } +- +- arr = null; +- // //assert attrUri.length > size +- } +- } +- +- // namespace stack +- protected int namespaceEnd; +- protected String namespacePrefix[]; +- protected int namespacePrefixHash[]; +- protected String namespaceUri[]; +- +- protected void ensureNamespacesCapacity(int size) { +- final int namespaceSize = namespacePrefix != null ? namespacePrefix.length : 0; +- if(size >= namespaceSize) { +- final int newSize = size > 7 ? 2 * size : 8; // = lucky 7 + 1 //25 +- if(TRACE_SIZING) { +- System.err.println("TRACE_SIZING namespaceSize "+namespaceSize+" ==> "+newSize); +- } +- final String[] newNamespacePrefix = new String[newSize]; +- final String[] newNamespaceUri = new String[newSize]; +- if(namespacePrefix != null) { +- System.arraycopy( +- namespacePrefix, 0, newNamespacePrefix, 0, namespaceEnd); +- System.arraycopy( +- namespaceUri, 0, newNamespaceUri, 0, namespaceEnd); +- } +- namespacePrefix = newNamespacePrefix; +- namespaceUri = newNamespaceUri; +- +- +- if( ! allStringsInterned ) { +- final int[] newNamespacePrefixHash = new int[newSize]; +- if(namespacePrefixHash != null) { +- System.arraycopy( +- namespacePrefixHash, 0, newNamespacePrefixHash, 0, namespaceEnd); +- } +- namespacePrefixHash = newNamespacePrefixHash; +- } +- //prefixesSize = newSize; +- // //assert nsPrefixes.length > size && nsPrefixes.length == newSize +- } +- } +- +- /** +- * simplistic implementation of hash function that has <b>constant</b> +- * time to compute - so it also means diminishing hash quality for long strings +- * but for XML parsing it should be good enough ... +- */ +- protected static final int fastHash( char ch[], int off, int len ) { +- if(len == 0) return 0; +- //assert len >0 +- int hash = ch[off]; // hash at beginning +- //try { +- hash = (hash << 7) + ch[ off + len - 1 ]; // hash at the end +- //} catch(ArrayIndexOutOfBoundsException aie) { +- // aie.printStackTrace(); //should never happen ... +- // throw new RuntimeException("this is violation of pre-condition"); +- //} +- if(len > 16) hash = (hash << 7) + ch[ off + (len / 4)]; // 1/4 from beginning +- if(len > 8) hash = (hash << 7) + ch[ off + (len / 2)]; // 1/2 of string size ... +- // notice that hash is at most done 3 times <<7 so shifted by 21 bits 8 bit value +- // so max result == 29 bits so it is quite just below 31 bits for long (2^32) ... +- //assert hash >= 0; +- return hash; +- } +- +- // entity replacement stack +- protected int entityEnd; +- +- protected String entityName[]; +- protected char[] entityNameBuf[]; +- protected String entityReplacement[]; +- protected char[] entityReplacementBuf[]; +- +- protected int entityNameHash[]; +- +- protected void ensureEntityCapacity() { +- final int entitySize = entityReplacementBuf != null ? entityReplacementBuf.length : 0; +- if(entityEnd >= entitySize) { +- final int newSize = entityEnd > 7 ? 2 * entityEnd : 8; // = lucky 7 + 1 //25 +- if(TRACE_SIZING) { +- System.err.println("TRACE_SIZING entitySize "+entitySize+" ==> "+newSize); +- } +- final String[] newEntityName = new String[newSize]; +- final char[] newEntityNameBuf[] = new char[newSize][]; +- final String[] newEntityReplacement = new String[newSize]; +- final char[] newEntityReplacementBuf[] = new char[newSize][]; +- if(entityName != null) { +- System.arraycopy(entityName, 0, newEntityName, 0, entityEnd); +- System.arraycopy(entityNameBuf, 0, newEntityNameBuf, 0, entityEnd); +- System.arraycopy(entityReplacement, 0, newEntityReplacement, 0, entityEnd); +- System.arraycopy(entityReplacementBuf, 0, newEntityReplacementBuf, 0, entityEnd); +- } +- entityName = newEntityName; +- entityNameBuf = newEntityNameBuf; +- entityReplacement = newEntityReplacement; +- entityReplacementBuf = newEntityReplacementBuf; +- +- if( ! allStringsInterned ) { +- final int[] newEntityNameHash = new int[newSize]; +- if(entityNameHash != null) { +- System.arraycopy(entityNameHash, 0, newEntityNameHash, 0, entityEnd); +- } +- entityNameHash = newEntityNameHash; +- } +- } +- } +- +- // input buffer management +- protected static final int READ_CHUNK_SIZE = 8*1024; //max data chars in one read() call +- protected Reader reader; +- protected String inputEncoding; +- +- +- protected int bufLoadFactor = 95; // 99% +- //protected int bufHardLimit; // only matters when expanding +- +- protected char buf[] = new char[ +- Runtime.getRuntime().freeMemory() > 1000000L ? READ_CHUNK_SIZE : 256 ]; +- protected int bufSoftLimit = ( bufLoadFactor * buf.length ) /100; // desirable size of buffer +- protected boolean preventBufferCompaction; +- +- protected int bufAbsoluteStart; // this is buf +- protected int bufStart; +- protected int bufEnd; +- protected int pos; +- protected int posStart; +- protected int posEnd; +- +- protected char pc[] = new char[ +- Runtime.getRuntime().freeMemory() > 1000000L ? READ_CHUNK_SIZE : 64 ]; +- protected int pcStart; +- protected int pcEnd; +- +- +- // parsing state +- //protected boolean needsMore; +- //protected boolean seenMarkup; +- protected boolean usePC; +- +- +- protected boolean seenStartTag; +- protected boolean seenEndTag; +- protected boolean pastEndTag; +- protected boolean seenAmpersand; +- protected boolean seenMarkup; +- protected boolean seenDocdecl; +- +- // transient variable set during each call to next/Token() +- protected boolean tokenize; +- protected String text; +- protected String entityRefName; +- +- protected String xmlDeclVersion; +- protected Boolean xmlDeclStandalone; +- protected String xmlDeclContent; +- +- protected void reset() { +- //System.out.println("reset() called"); +- location = null; +- lineNumber = 1; +- columnNumber = 0; +- seenRoot = false; +- reachedEnd = false; +- eventType = START_DOCUMENT; +- emptyElementTag = false; +- +- depth = 0; +- +- attributeCount = 0; +- +- namespaceEnd = 0; +- +- entityEnd = 0; +- +- reader = null; +- inputEncoding = null; +- +- preventBufferCompaction = false; +- bufAbsoluteStart = 0; +- bufEnd = bufStart = 0; +- pos = posStart = posEnd = 0; +- +- pcEnd = pcStart = 0; +- +- usePC = false; +- +- seenStartTag = false; +- seenEndTag = false; +- pastEndTag = false; +- seenAmpersand = false; +- seenMarkup = false; +- seenDocdecl = false; +- +- xmlDeclVersion = null; +- xmlDeclStandalone = null; +- xmlDeclContent = null; +- +- resetStringCache(); +- } +- +- public MXParser() { +- } +- +- +- /** +- * Method setFeature +- * +- * @param name a String +- * @param state a boolean +- * +- * @throws XmlPullParserException +- * +- */ +- public void setFeature(String name, +- boolean state) throws XmlPullParserException +- { +- if(name == null) throw new IllegalArgumentException("feature name should not be null"); +- if(FEATURE_PROCESS_NAMESPACES.equals(name)) { +- if(eventType != START_DOCUMENT) throw new XmlPullParserException( +- "namespace processing feature can only be changed before parsing", this, null); +- processNamespaces = state; +- // } else if(FEATURE_REPORT_NAMESPACE_ATTRIBUTES.equals(name)) { +- // if(type != START_DOCUMENT) throw new XmlPullParserException( +- // "namespace reporting feature can only be changed before parsing", this, null); +- // reportNsAttribs = state; +- } else if(FEATURE_NAMES_INTERNED.equals(name)) { +- if(state != false) { +- throw new XmlPullParserException( +- "interning names in this implementation is not supported"); +- } +- } else if(FEATURE_PROCESS_DOCDECL.equals(name)) { +- if(state != false) { +- throw new XmlPullParserException( +- "processing DOCDECL is not supported"); +- } +- //} else if(REPORT_DOCDECL.equals(name)) { +- // paramNotifyDoctype = state; +- } else if(FEATURE_XML_ROUNDTRIP.equals(name)) { +- //if(state == false) { +- // throw new XmlPullParserException( +- // "roundtrip feature can not be switched off"); +- //} +- roundtripSupported = state; +- } else { +- throw new XmlPullParserException("unsupporte feature "+name); +- } +- } +- +- /** Unknown properties are <string>always</strong> returned as false */ +- public boolean getFeature(String name) +- { +- if(name == null) throw new IllegalArgumentException("feature name should not be nulll"); +- if(FEATURE_PROCESS_NAMESPACES.equals(name)) { +- return processNamespaces; +- // } else if(FEATURE_REPORT_NAMESPACE_ATTRIBUTES.equals(name)) { +- // return reportNsAttribs; +- } else if(FEATURE_NAMES_INTERNED.equals(name)) { +- return false; +- } else if(FEATURE_PROCESS_DOCDECL.equals(name)) { +- return false; +- //} else if(REPORT_DOCDECL.equals(name)) { +- // return paramNotifyDoctype; +- } else if(FEATURE_XML_ROUNDTRIP.equals(name)) { +- //return true; +- return roundtripSupported; +- } +- return false; +- } +- +- public void setProperty(String name, +- Object value) +- throws XmlPullParserException +- { +- if(PROPERTY_LOCATION.equals(name)) { +- location = (String) value; +- } else { +- throw new XmlPullParserException("unsupported property: '"+name+"'"); +- } +- } +- +- +- public Object getProperty(String name) +- { +- if(name == null) throw new IllegalArgumentException("property name should not be nulll"); +- if(PROPERTY_XMLDECL_VERSION.equals(name)) { +- return xmlDeclVersion; +- } else if(PROPERTY_XMLDECL_STANDALONE.equals(name)) { +- return xmlDeclStandalone; +- } else if(PROPERTY_XMLDECL_CONTENT.equals(name)) { +- return xmlDeclContent; +- } else if(PROPERTY_LOCATION.equals(name)) { +- return location; +- } +- return null; +- } +- +- +- public void setInput(Reader in) throws XmlPullParserException +- { +- reset(); +- reader = in; +- } +- +- +- public void setInput(java.io.InputStream inputStream, String inputEncoding) +- throws XmlPullParserException +- { +- if(inputStream == null) { +- throw new IllegalArgumentException("input stream can not be null"); +- } +- Reader reader; +- try { +- if(inputEncoding != null) { +- reader = ReaderFactory.newReader(inputStream, inputEncoding); +- } else { +- reader = ReaderFactory.newXmlReader(inputStream); +- } +- } catch (UnsupportedEncodingException une) { +- throw new XmlPullParserException( +- "could not create reader for encoding "+inputEncoding+" : "+une, this, une); +- } +- catch ( IOException e ) +- { +- throw new XmlPullParserException( +- "could not create reader : "+e, this, e); +- } +- setInput(reader); +- //must be here as reset() was called in setInput() and has set this.inputEncoding to null ... +- this.inputEncoding = inputEncoding; +- } +- +- public String getInputEncoding() { +- return inputEncoding; +- } +- +- public void defineEntityReplacementText(String entityName, +- String replacementText) +- throws XmlPullParserException +- { +- // throw new XmlPullParserException("not allowed"); +- +- if ( !replacementText.startsWith( "&#" ) && this.entityName != null && replacementText.length() > 1 ) +- { +- String tmp = replacementText.substring( 1, replacementText.length() - 1 ); +- for ( int i = 0; i < this.entityName.length; i++ ) +- { +- if ( this.entityName[i] != null && this.entityName[i].equals( tmp ) ) +- { +- replacementText = this.entityReplacement[i]; +- } +- } +- } +- +- //protected char[] entityReplacement[]; +- ensureEntityCapacity(); +- +- // this is to make sure that if interning works we will take advantage of it ... +- this.entityName[entityEnd] = newString(entityName.toCharArray(), 0, entityName.length()); +- entityNameBuf[entityEnd] = entityName.toCharArray(); +- +- entityReplacement[entityEnd] = replacementText; +- entityReplacementBuf[entityEnd] = replacementText.toCharArray(); +- if(!allStringsInterned) { +- entityNameHash[ entityEnd ] = +- fastHash(entityNameBuf[entityEnd], 0, entityNameBuf[entityEnd].length); +- } +- ++entityEnd; +- //TODO disallow < or & in entity replacement text (or ]]>???) +- // TOOD keepEntityNormalizedForAttributeValue cached as well ... +- } +- +- public int getNamespaceCount(int depth) +- throws XmlPullParserException +- { +- if(processNamespaces == false || depth == 0) { +- return 0; +- } +- //int maxDepth = eventType == END_TAG ? this.depth + 1 : this.depth; +- //if(depth < 0 || depth > maxDepth) throw new IllegalArgumentException( +- if(depth < 0 || depth > this.depth) throw new IllegalArgumentException( +- "napespace count mayt be for depth 0.."+this.depth+" not "+depth); +- return elNamespaceCount[ depth ]; +- } +- +- public String getNamespacePrefix(int pos) +- throws XmlPullParserException +- { +- +- //int end = eventType == END_TAG ? elNamespaceCount[ depth + 1 ] : namespaceEnd; +- //if(pos < end) { +- if(pos < namespaceEnd) { +- return namespacePrefix[ pos ]; +- } else { +- throw new XmlPullParserException( +- "position "+pos+" exceeded number of available namespaces "+namespaceEnd); +- } +- } +- +- public String getNamespaceUri(int pos) throws XmlPullParserException +- { +- //int end = eventType == END_TAG ? elNamespaceCount[ depth + 1 ] : namespaceEnd; +- //if(pos < end) { +- if(pos < namespaceEnd) { +- return namespaceUri[ pos ]; +- } else { +- throw new XmlPullParserException( +- "position "+pos+" exceedded number of available namespaces "+namespaceEnd); +- } +- } +- +- public String getNamespace( String prefix ) +- //throws XmlPullParserException +- { +- //int count = namespaceCount[ depth ]; +- if(prefix != null) { +- for( int i = namespaceEnd -1; i >= 0; i--) { +- if( prefix.equals( namespacePrefix[ i ] ) ) { +- return namespaceUri[ i ]; +- } +- } +- if("xml".equals( prefix )) { +- return XML_URI; +- } else if("xmlns".equals( prefix )) { +- return XMLNS_URI; +- } +- } else { +- for( int i = namespaceEnd -1; i >= 0; i--) { +- if( namespacePrefix[ i ] == null) { //"") { //null ) { //TODO check FIXME Alek +- return namespaceUri[ i ]; +- } +- } +- +- } +- return null; +- } +- +- +- public int getDepth() +- { +- return depth; +- } +- +- +- private static int findFragment(int bufMinPos, char[] b, int start, int end) { +- //System.err.println("bufStart="+bufStart+" b="+printable(new String(b, start, end - start))+" start="+start+" end="+end); +- if(start < bufMinPos) { +- start = bufMinPos; +- if(start > end) start = end; +- return start; +- } +- if(end - start > 65) { +- start = end - 10; // try to find good location +- } +- int i = start + 1; +- while(--i > bufMinPos) { +- if((end - i) > 65) break; +- final char c = b[i]; +- if(c == '<' && (start - i) > 10) break; +- } +- return i; +- } +- +- +- /** +- * Return string describing current position of parsers as +- * text 'STATE [seen %s...] @line:column'. +- */ +- public String getPositionDescription () +- { +- String fragment = null; +- if(posStart <= pos) { +- final int start = findFragment(0, buf, posStart, pos); +- //System.err.println("start="+start); +- if(start < pos) { +- fragment = new String(buf, start, pos - start); +- } +- if(bufAbsoluteStart > 0 || start > 0) fragment = "..." + fragment; +- } +- // return " at line "+tokenizerPosRow +- // +" and column "+(tokenizerPosCol-1) +- // +(fragment != null ? " seen "+printable(fragment)+"..." : ""); +- return " "+TYPES[ eventType ] + +- (fragment != null ? " seen "+printable(fragment)+"..." : "") +- +" "+(location != null ? location : "") +- +"@"+getLineNumber()+":"+getColumnNumber(); +- } +- +- public int getLineNumber() +- { +- return lineNumber; +- } +- +- public int getColumnNumber() +- { +- return columnNumber; +- } +- +- +- public boolean isWhitespace() throws XmlPullParserException +- { +- if(eventType == TEXT || eventType == CDSECT) { +- if(usePC) { +- for (int i = pcStart; i <pcEnd; i++) +- { +- if(!isS(pc[ i ])) return false; +- } +- return true; +- } else { +- for (int i = posStart; i <posEnd; i++) +- { +- if(!isS(buf[ i ])) return false; +- } +- return true; +- } +- } else if(eventType == IGNORABLE_WHITESPACE) { +- return true; +- } +- throw new XmlPullParserException("no content available to check for whitespaces"); +- } +- +- public String getText() +- { +- if(eventType == START_DOCUMENT || eventType == END_DOCUMENT) { +- //throw new XmlPullParserException("no content available to read"); +- // if(roundtripSupported) { +- // text = new String(buf, posStart, posEnd - posStart); +- // } else { +- return null; +- // } +- } else if(eventType == ENTITY_REF) { +- return text; +- } +- if(text == null) { +- if(!usePC || eventType == START_TAG || eventType == END_TAG) { +- text = new String(buf, posStart, posEnd - posStart); +- } else { +- text = new String(pc, pcStart, pcEnd - pcStart); +- } +- } +- return text; +- } +- +- public char[] getTextCharacters(int [] holderForStartAndLength) +- { +- if( eventType == TEXT ) { +- if(usePC) { +- holderForStartAndLength[0] = pcStart; +- holderForStartAndLength[1] = pcEnd - pcStart; +- return pc; +- } else { +- holderForStartAndLength[0] = posStart; +- holderForStartAndLength[1] = posEnd - posStart; +- return buf; +- +- } +- } else if( eventType == START_TAG +- || eventType == END_TAG +- || eventType == CDSECT +- || eventType == COMMENT +- || eventType == ENTITY_REF +- || eventType == PROCESSING_INSTRUCTION +- || eventType == IGNORABLE_WHITESPACE +- || eventType == DOCDECL) +- { +- holderForStartAndLength[0] = posStart; +- holderForStartAndLength[1] = posEnd - posStart; +- return buf; +- } else if(eventType == START_DOCUMENT +- || eventType == END_DOCUMENT) { +- //throw new XmlPullParserException("no content available to read"); +- holderForStartAndLength[0] = holderForStartAndLength[1] = -1; +- return null; +- } else { +- throw new IllegalArgumentException("unknown text eventType: "+eventType); +- } +- // String s = getText(); +- // char[] cb = null; +- // if(s!= null) { +- // cb = s.toCharArray(); +- // holderForStartAndLength[0] = 0; +- // holderForStartAndLength[1] = s.length(); +- // } else { +- // } +- // return cb; +- } +- +- public String getNamespace() +- { +- if(eventType == START_TAG) { +- //return processNamespaces ? elUri[ depth - 1 ] : NO_NAMESPACE; +- return processNamespaces ? elUri[ depth ] : NO_NAMESPACE; +- } else if(eventType == END_TAG) { +- return processNamespaces ? elUri[ depth ] : NO_NAMESPACE; +- } +- return null; +- // String prefix = elPrefix[ maxDepth ]; +- // if(prefix != null) { +- // for( int i = namespaceEnd -1; i >= 0; i--) { +- // if( prefix.equals( namespacePrefix[ i ] ) ) { +- // return namespaceUri[ i ]; +- // } +- // } +- // } else { +- // for( int i = namespaceEnd -1; i >= 0; i--) { +- // if( namespacePrefix[ i ] == null ) { +- // return namespaceUri[ i ]; +- // } +- // } +- // +- // } +- // return ""; +- } +- +- public String getName() +- { +- if(eventType == START_TAG) { +- //return elName[ depth - 1 ] ; +- return elName[ depth ] ; +- } else if(eventType == END_TAG) { +- return elName[ depth ] ; +- } else if(eventType == ENTITY_REF) { +- if(entityRefName == null) { +- entityRefName = newString(buf, posStart, posEnd - posStart); +- } +- return entityRefName; +- } else { +- return null; +- } +- } +- +- public String getPrefix() +- { +- if(eventType == START_TAG) { +- //return elPrefix[ depth - 1 ] ; +- return elPrefix[ depth ] ; +- } else if(eventType == END_TAG) { +- return elPrefix[ depth ] ; +- } +- return null; +- // if(eventType != START_TAG && eventType != END_TAG) return null; +- // int maxDepth = eventType == END_TAG ? depth : depth - 1; +- // return elPrefix[ maxDepth ]; +- } +- +- +- public boolean isEmptyElementTag() throws XmlPullParserException +- { +- if(eventType != START_TAG) throw new XmlPullParserException( +- "parser must be on START_TAG to check for empty element", this, null); +- return emptyElementTag; +- } +- +- public int getAttributeCount() +- { +- if(eventType != START_TAG) return -1; +- return attributeCount; +- } +- +- public String getAttributeNamespace(int index) +- { +- if(eventType != START_TAG) throw new IndexOutOfBoundsException( +- "only START_TAG can have attributes"); +- if(processNamespaces == false) return NO_NAMESPACE; +- if(index < 0 || index >= attributeCount) throw new IndexOutOfBoundsException( +- "attribute position must be 0.."+(attributeCount-1)+" and not "+index); +- return attributeUri[ index ]; +- } +- +- public String getAttributeName(int index) +- { +- if(eventType != START_TAG) throw new IndexOutOfBoundsException( +- "only START_TAG can have attributes"); +- if(index < 0 || index >= attributeCount) throw new IndexOutOfBoundsException( +- "attribute position must be 0.."+(attributeCount-1)+" and not "+index); +- return attributeName[ index ]; +- } +- +- public String getAttributePrefix(int index) +- { +- if(eventType != START_TAG) throw new IndexOutOfBoundsException( +- "only START_TAG can have attributes"); +- if(processNamespaces == false) return null; +- if(index < 0 || index >= attributeCount) throw new IndexOutOfBoundsException( +- "attribute position must be 0.."+(attributeCount-1)+" and not "+index); +- return attributePrefix[ index ]; +- } +- +- public String getAttributeType(int index) { +- if(eventType != START_TAG) throw new IndexOutOfBoundsException( +- "only START_TAG can have attributes"); +- if(index < 0 || index >= attributeCount) throw new IndexOutOfBoundsException( +- "attribute position must be 0.."+(attributeCount-1)+" and not "+index); +- return "CDATA"; +- } +- +- public boolean isAttributeDefault(int index) { +- if(eventType != START_TAG) throw new IndexOutOfBoundsException( +- "only START_TAG can have attributes"); +- if(index < 0 || index >= attributeCount) throw new IndexOutOfBoundsException( +- "attribute position must be 0.."+(attributeCount-1)+" and not "+index); +- return false; +- } +- +- public String getAttributeValue(int index) +- { +- if(eventType != START_TAG) throw new IndexOutOfBoundsException( +- "only START_TAG can have attributes"); +- if(index < 0 || index >= attributeCount) throw new IndexOutOfBoundsException( +- "attribute position must be 0.."+(attributeCount-1)+" and not "+index); +- return attributeValue[ index ]; +- } +- +- public String getAttributeValue(String namespace, +- String name) +- { +- if(eventType != START_TAG) throw new IndexOutOfBoundsException( +- "only START_TAG can have attributes"+getPositionDescription()); +- if(name == null) { +- throw new IllegalArgumentException("attribute name can not be null"); +- } +- // TODO make check if namespace is interned!!! etc. for names!!! +- if(processNamespaces) { +- if(namespace == null) { +- namespace = ""; +- } +- +- for(int i = 0; i < attributeCount; ++i) { +- if((namespace == attributeUri[ i ] || +- namespace.equals(attributeUri[ i ]) ) +- //(namespace != null && namespace.equals(attributeUri[ i ])) +- // taking advantage of String.intern() +- && name.equals(attributeName[ i ]) ) +- { +- return attributeValue[i]; +- } +- } +- } else { +- if(namespace != null && namespace.length() == 0) { +- namespace = null; +- } +- if(namespace != null) throw new IllegalArgumentException( +- "when namespaces processing is disabled attribute namespace must be null"); +- for(int i = 0; i < attributeCount; ++i) { +- if(name.equals(attributeName[i])) +- { +- return attributeValue[i]; +- } +- } +- } +- return null; +- } +- +- +- public int getEventType() +- throws XmlPullParserException +- { +- return eventType; +- } +- +- public void require(int type, String namespace, String name) +- throws XmlPullParserException, IOException +- { +- if(processNamespaces == false && namespace != null) { +- throw new XmlPullParserException( +- "processing namespaces must be enabled on parser (or factory)"+ +- " to have possible namespaces delcared on elements" +- +(" (postion:"+ getPositionDescription())+")"); +- } +- if (type != getEventType() +- || (namespace != null && !namespace.equals (getNamespace())) +- || (name != null && !name.equals (getName ())) ) +- { +- throw new XmlPullParserException ( +- "expected event "+TYPES[ type ] +- +(name != null ? " with name '"+name+"'" : "") +- +(namespace != null && name != null ? " and" : "") +- +(namespace != null ? " with namespace '"+namespace+"'" : "") +- +" but got" +- +(type != getEventType() ? " "+TYPES[ getEventType() ] : "") +- +(name != null && getName() != null && !name.equals (getName ()) +- ? " name '"+getName()+"'" : "") +- +(namespace != null && name != null +- && getName() != null && !name.equals (getName ()) +- && getNamespace() != null && !namespace.equals (getNamespace()) +- ? " and" : "") +- +(namespace != null && getNamespace() != null && !namespace.equals (getNamespace()) +- ? " namespace '"+getNamespace()+"'" : "") +- +(" (postion:"+ getPositionDescription())+")"); +- } +- } +- +- +- /** +- * Skip sub tree that is currently porser positioned on. +- * <br>NOTE: parser must be on START_TAG and when funtion returns +- * parser will be positioned on corresponding END_TAG +- */ +- public void skipSubTree() +- throws XmlPullParserException, IOException +- { +- require(START_TAG, null, null); +- int level = 1; +- while(level > 0) { +- int eventType = next(); +- if(eventType == END_TAG) { +- --level; +- } else if(eventType == START_TAG) { +- ++level; +- } +- } +- } +- +- // public String readText() throws XmlPullParserException, IOException +- // { +- // if (getEventType() != TEXT) return ""; +- // String result = getText(); +- // next(); +- // return result; +- // } +- +- public String nextText() throws XmlPullParserException, IOException +- { +- // String result = null; +- // boolean onStartTag = false; +- // if(eventType == START_TAG) { +- // onStartTag = true; +- // next(); +- // } +- // if(eventType == TEXT) { +- // result = getText(); +- // next(); +- // } else if(onStartTag && eventType == END_TAG) { +- // result = ""; +- // } else { +- // throw new XmlPullParserException( +- // "parser must be on START_TAG or TEXT to read text", this, null); +- // } +- // if(eventType != END_TAG) { +- // throw new XmlPullParserException( +- // "event TEXT it must be immediately followed by END_TAG", this, null); +- // } +- // return result; +- if(getEventType() != START_TAG) { +- throw new XmlPullParserException( +- "parser must be on START_TAG to read next text", this, null); +- } +- int eventType = next(); +- if(eventType == TEXT) { +- final String result = getText(); +- eventType = next(); +- if(eventType != END_TAG) { +- throw new XmlPullParserException( +- "TEXT must be immediately followed by END_TAG and not " +- +TYPES[ getEventType() ], this, null); +- } +- return result; +- } else if(eventType == END_TAG) { +- return ""; +- } else { +- throw new XmlPullParserException( +- "parser must be on START_TAG or TEXT to read text", this, null); +- } +- } +- +- public int nextTag() throws XmlPullParserException, IOException +- { +- next(); +- if(eventType == TEXT && isWhitespace()) { // skip whitespace +- next(); +- } +- if (eventType != START_TAG && eventType != END_TAG) { +- throw new XmlPullParserException("expected START_TAG or END_TAG not " +- +TYPES[ getEventType() ], this, null); +- } +- return eventType; +- } +- +- public int next() +- throws XmlPullParserException, IOException +- { +- tokenize = false; +- return nextImpl(); +- } +- +- public int nextToken() +- throws XmlPullParserException, IOException +- { +- tokenize = true; +- return nextImpl(); +- } +- +- +- protected int nextImpl() +- throws XmlPullParserException, IOException +- { +- text = null; +- pcEnd = pcStart = 0; +- usePC = false; +- bufStart = posEnd; +- if(pastEndTag) { +- pastEndTag = false; +- --depth; +- namespaceEnd = elNamespaceCount[ depth ]; // less namespaces available +- } +- if(emptyElementTag) { +- emptyElementTag = false; +- pastEndTag = true; +- return eventType = END_TAG; +- } +- +- // [1] document ::= prolog element Misc* +- if(depth > 0) { +- +- if(seenStartTag) { +- seenStartTag = false; +- return eventType = parseStartTag(); +- } +- if(seenEndTag) { +- seenEndTag = false; +- return eventType = parseEndTag(); +- } +- +- // ASSUMPTION: we are _on_ first character of content or markup!!!! +- // [43] content ::= CharData? ((element | Reference | CDSect | PI | Comment) CharData?)* +- char ch; +- if(seenMarkup) { // we have read ahead ... +- seenMarkup = false; +- ch = '<'; +- } else if(seenAmpersand) { +- seenAmpersand = false; +- ch = '&'; +- } else { +- ch = more(); +- } +- posStart = pos - 1; // VERY IMPORTANT: this is correct start of event!!! +- +- // when true there is some potential event TEXT to return - keep gathering +- boolean hadCharData = false; +- +- // when true TEXT data is not continuous (like <![CDATA[text]]>) and requires PC merging +- boolean needsMerging = false; +- +- MAIN_LOOP: +- while(true) { +- // work on MARKUP +- if(ch == '<') { +- if(hadCharData) { +- //posEnd = pos - 1; +- if(tokenize) { +- seenMarkup = true; +- return eventType = TEXT; +- } +- } +- ch = more(); +- if(ch == '/') { +- if(!tokenize && hadCharData) { +- seenEndTag = true; +- //posEnd = pos - 2; +- return eventType = TEXT; +- } +- return eventType = parseEndTag(); +- } else if(ch == '!') { +- ch = more(); +- if(ch == '-') { +- // note: if(tokenize == false) posStart/End is NOT changed!!!! +- parseComment(); +- if(tokenize) return eventType = COMMENT; +- if( !usePC && hadCharData ) { +- needsMerging = true; +- } else { +- posStart = pos; //completely ignore comment +- } +- } else if(ch == '[') { +- //posEnd = pos - 3; +- // must remember previous posStart/End as it merges with content of CDATA +- //int oldStart = posStart + bufAbsoluteStart; +- //int oldEnd = posEnd + bufAbsoluteStart; +- parseCDSect(hadCharData); +- if(tokenize) return eventType = CDSECT; +- final int cdStart = posStart; +- final int cdEnd = posEnd; +- final int cdLen = cdEnd - cdStart; +- +- +- if(cdLen > 0) { // was there anything inside CDATA section? +- hadCharData = true; +- if(!usePC) { +- needsMerging = true; +- } +- } +- +- // posStart = oldStart; +- // posEnd = oldEnd; +- // if(cdLen > 0) { // was there anything inside CDATA section? +- // if(hadCharData) { +- // // do merging if there was anything in CDSect!!!! +- // // if(!usePC) { +- // // // posEnd is correct already!!! +- // // if(posEnd > posStart) { +- // // joinPC(); +- // // } else { +- // // usePC = true; +- // // pcStart = pcEnd = 0; +- // // } +- // // } +- // // if(pcEnd + cdLen >= pc.length) ensurePC(pcEnd + cdLen); +- // // // copy [cdStart..cdEnd) into PC +- // // System.arraycopy(buf, cdStart, pc, pcEnd, cdLen); +- // // pcEnd += cdLen; +- // if(!usePC) { +- // needsMerging = true; +- // posStart = cdStart; +- // posEnd = cdEnd; +- // } +- // } else { +- // if(!usePC) { +- // needsMerging = true; +- // posStart = cdStart; +- // posEnd = cdEnd; +- // hadCharData = true; +- // } +- // } +- // //hadCharData = true; +- // } else { +- // if( !usePC && hadCharData ) { +- // needsMerging = true; +- // } +- // } +- } else { +- throw new XmlPullParserException( +- "unexpected character in markup "+printable(ch), this, null); +- } +- } else if(ch == '?') { +- parsePI(); +- if(tokenize) return eventType = PROCESSING_INSTRUCTION; +- if( !usePC && hadCharData ) { +- needsMerging = true; +- } else { +- posStart = pos; //completely ignore PI +- } +- +- } else if( isNameStartChar(ch) ) { +- if(!tokenize && hadCharData) { +- seenStartTag = true; +- //posEnd = pos - 2; +- return eventType = TEXT; +- } +- return eventType = parseStartTag(); +- } else { +- throw new XmlPullParserException( +- "unexpected character in markup "+printable(ch), this, null); +- } +- // do content comapctation if it makes sense!!!! +- +- } else if(ch == '&') { +- // work on ENTITTY +- //posEnd = pos - 1; +- if(tokenize && hadCharData) { +- seenAmpersand = true; +- return eventType = TEXT; +- } +- final int oldStart = posStart + bufAbsoluteStart; +- final int oldEnd = posEnd + bufAbsoluteStart; +- final char[] resolvedEntity = parseEntityRef(); +- if(tokenize) return eventType = ENTITY_REF; +- // check if replacement text can be resolved !!! +- if(resolvedEntity == null) { +- if(entityRefName == null) { +- entityRefName = newString(buf, posStart, posEnd - posStart); +- } +- throw new XmlPullParserException( +- "could not resolve entity named '"+printable(entityRefName)+"'", +- this, null); +- } +- //int entStart = posStart; +- //int entEnd = posEnd; +- posStart = oldStart - bufAbsoluteStart; +- posEnd = oldEnd - bufAbsoluteStart; +- if(!usePC) { +- if(hadCharData) { +- joinPC(); // posEnd is already set correctly!!! +- needsMerging = false; +- } else { +- usePC = true; +- pcStart = pcEnd = 0; +- } +- } +- //assert usePC == true; +- // write into PC replacement text - do merge for replacement text!!!! +- for (int i = 0; i < resolvedEntity.length; i++) +- { +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = resolvedEntity[ i ]; +- +- } +- hadCharData = true; +- //assert needsMerging == false; +- } else { +- +- if(needsMerging) { +- //assert usePC == false; +- joinPC(); // posEnd is already set correctly!!! +- //posStart = pos - 1; +- needsMerging = false; +- } +- +- +- //no MARKUP not ENTITIES so work on character data ... +- +- +- +- // [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*) +- +- +- hadCharData = true; +- +- boolean normalizedCR = false; +- final boolean normalizeInput = tokenize == false || roundtripSupported == false; +- // use loop locality here!!!! +- boolean seenBracket = false; +- boolean seenBracketBracket = false; +- do { +- +- // check that ]]> does not show in +- if(ch == ']') { +- if(seenBracket) { +- seenBracketBracket = true; +- } else { +- seenBracket = true; +- } +- } else if(seenBracketBracket && ch == '>') { +- throw new XmlPullParserException( +- "characters ]]> are not allowed in content", this, null); +- } else { +- if(seenBracket) { +- seenBracketBracket = seenBracket = false; +- } +- // assert seenTwoBrackets == seenBracket == false; +- } +- if(normalizeInput) { +- // deal with normalization issues ... +- if(ch == '\r') { +- normalizedCR = true; +- posEnd = pos -1; +- // posEnd is already set +- if(!usePC) { +- if(posEnd > posStart) { +- joinPC(); +- } else { +- usePC = true; +- pcStart = pcEnd = 0; +- } +- } +- //assert usePC == true; +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = '\n'; +- } else if(ch == '\n') { +- // if(!usePC) { joinPC(); } else { if(pcEnd >= pc.length) ensurePC(); } +- if(!normalizedCR && usePC) { +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = '\n'; +- } +- normalizedCR = false; +- } else { +- if(usePC) { +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = ch; +- } +- normalizedCR = false; +- } +- } +- +- ch = more(); +- } while(ch != '<' && ch != '&'); +- posEnd = pos - 1; +- continue MAIN_LOOP; // skip ch = more() from below - we are already ahead ... +- } +- ch = more(); +- } // endless while(true) +- } else { +- if(seenRoot) { +- return parseEpilog(); +- } else { +- return parseProlog(); +- } +- } +- } +- +- +- protected int parseProlog() +- throws XmlPullParserException, IOException +- { +- // [2] prolog: ::= XMLDecl? Misc* (doctypedecl Misc*)? and look for [39] element +- +- char ch; +- if(seenMarkup) { +- ch = buf[ pos - 1 ]; +- } else { +- ch = more(); +- } +- +- if(eventType == START_DOCUMENT) { +- // bootstrap parsing with getting first character input! +- // deal with BOM +- // detect BOM and crop it (Unicode int Order Mark) +- if(ch == '\uFFFE') { +- throw new XmlPullParserException( +- "first character in input was UNICODE noncharacter (0xFFFE)"+ +- "- input requires int swapping", this, null); +- } +- if(ch == '\uFEFF') { +- // skipping UNICODE int Order Mark (so called BOM) +- ch = more(); +- } +- } +- seenMarkup = false; +- boolean gotS = false; +- posStart = pos - 1; +- final boolean normalizeIgnorableWS = tokenize == true && roundtripSupported == false; +- boolean normalizedCR = false; +- while(true) { +- // deal with Misc +- // [27] Misc ::= Comment | PI | S +- // deal with docdecl --> mark it! +- // else parseStartTag seen <[^/] +- if(ch == '<') { +- if(gotS && tokenize) { +- posEnd = pos - 1; +- seenMarkup = true; +- return eventType = IGNORABLE_WHITESPACE; +- } +- ch = more(); +- if(ch == '?') { +- // check if it is 'xml' +- // deal with XMLDecl +- boolean isXMLDecl = parsePI(); +- if(tokenize) { +- if (isXMLDecl) { +- return eventType = START_DOCUMENT; +- } +- return eventType = PROCESSING_INSTRUCTION; +- } +- } else if(ch == '!') { +- ch = more(); +- if(ch == 'D') { +- if(seenDocdecl) { +- throw new XmlPullParserException( +- "only one docdecl allowed in XML document", this, null); +- } +- seenDocdecl = true; +- parseDocdecl(); +- if(tokenize) return eventType = DOCDECL; +- } else if(ch == '-') { +- parseComment(); +- if(tokenize) return eventType = COMMENT; +- } else { +- throw new XmlPullParserException( +- "unexpected markup <!"+printable(ch), this, null); +- } +- } else if(ch == '/') { +- throw new XmlPullParserException( +- "expected start tag name and not "+printable(ch), this, null); +- } else if(isNameStartChar(ch)) { +- seenRoot = true; +- return parseStartTag(); +- } else { +- throw new XmlPullParserException( +- "expected start tag name and not "+printable(ch), this, null); +- } +- } else if(isS(ch)) { +- gotS = true; +- if(normalizeIgnorableWS) { +- if(ch == '\r') { +- normalizedCR = true; +- //posEnd = pos -1; +- //joinPC(); +- // posEnd is already set +- if(!usePC) { +- posEnd = pos -1; +- if(posEnd > posStart) { +- joinPC(); +- } else { +- usePC = true; +- pcStart = pcEnd = 0; +- } +- } +- //assert usePC == true; +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = '\n'; +- } else if(ch == '\n') { +- if(!normalizedCR && usePC) { +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = '\n'; +- } +- normalizedCR = false; +- } else { +- if(usePC) { +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = ch; +- } +- normalizedCR = false; +- } +- } +- } else { +- throw new XmlPullParserException( +- "only whitespace content allowed before start tag and not "+printable(ch), +- this, null); +- } +- ch = more(); +- } +- } +- +- protected int parseEpilog() +- throws XmlPullParserException, IOException +- { +- if(eventType == END_DOCUMENT) { +- throw new XmlPullParserException("already reached end of XML input", this, null); +- } +- if(reachedEnd) { +- return eventType = END_DOCUMENT; +- } +- boolean gotS = false; +- final boolean normalizeIgnorableWS = tokenize == true && roundtripSupported == false; +- boolean normalizedCR = false; +- try { +- // epilog: Misc* +- char ch; +- if(seenMarkup) { +- ch = buf[ pos - 1 ]; +- } else { +- ch = more(); +- } +- seenMarkup = false; +- posStart = pos - 1; +- if(!reachedEnd) { +- while(true) { +- // deal with Misc +- // [27] Misc ::= Comment | PI | S +- if(ch == '<') { +- if(gotS && tokenize) { +- posEnd = pos - 1; +- seenMarkup = true; +- return eventType = IGNORABLE_WHITESPACE; +- } +- ch = more(); +- if(reachedEnd) { +- break; +- } +- if(ch == '?') { +- // check if it is 'xml' +- // deal with XMLDecl +- parsePI(); +- if(tokenize) return eventType = PROCESSING_INSTRUCTION; +- +- } else if(ch == '!') { +- ch = more(); +- if(reachedEnd) { +- break; +- } +- if(ch == 'D') { +- parseDocdecl(); //FIXME +- if(tokenize) return eventType = DOCDECL; +- } else if(ch == '-') { +- parseComment(); +- if(tokenize) return eventType = COMMENT; +- } else { +- throw new XmlPullParserException( +- "unexpected markup <!"+printable(ch), this, null); +- } +- } else if(ch == '/') { +- throw new XmlPullParserException( +- "end tag not allowed in epilog but got "+printable(ch), this, null); +- } else if(isNameStartChar(ch)) { +- throw new XmlPullParserException( +- "start tag not allowed in epilog but got "+printable(ch), this, null); +- } else { +- throw new XmlPullParserException( +- "in epilog expected ignorable content and not "+printable(ch), +- this, null); +- } +- } else if(isS(ch)) { +- gotS = true; +- if(normalizeIgnorableWS) { +- if(ch == '\r') { +- normalizedCR = true; +- //posEnd = pos -1; +- //joinPC(); +- // posEnd is already set +- if(!usePC) { +- posEnd = pos -1; +- if(posEnd > posStart) { +- joinPC(); +- } else { +- usePC = true; +- pcStart = pcEnd = 0; +- } +- } +- //assert usePC == true; +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = '\n'; +- } else if(ch == '\n') { +- if(!normalizedCR && usePC) { +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = '\n'; +- } +- normalizedCR = false; +- } else { +- if(usePC) { +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = ch; +- } +- normalizedCR = false; +- } +- } +- } else { +- throw new XmlPullParserException( +- "in epilog non whitespace content is not allowed but got "+printable(ch), +- this, null); +- } +- ch = more(); +- if(reachedEnd) { +- break; +- } +- +- } +- } +- +- // throw Exception("unexpected content in epilog +- // catch EOFException return END_DOCUMENT +- //try { +- } catch(EOFException ex) { +- reachedEnd = true; +- } +- if(reachedEnd) { +- if(tokenize && gotS) { +- posEnd = pos; // well - this is LAST available character pos +- return eventType = IGNORABLE_WHITESPACE; +- } +- return eventType = END_DOCUMENT; +- } else { +- throw new XmlPullParserException("internal error in parseEpilog"); +- } +- } +- +- +- public int parseEndTag() throws XmlPullParserException, IOException { +- //ASSUMPTION ch is past "</" +- // [42] ETag ::= '</' Name S? '>' +- char ch = more(); +- if(!isNameStartChar(ch)) { +- throw new XmlPullParserException( +- "expected name start and not "+printable(ch), this, null); +- } +- posStart = pos - 3; +- final int nameStart = pos - 1 + bufAbsoluteStart; +- do { +- ch = more(); +- } while(isNameChar(ch)); +- +- // now we go one level down -- do checks +- //--depth; //FIXME +- +- // check that end tag name is the same as start tag +- //String name = new String(buf, nameStart - bufAbsoluteStart, +- // (pos - 1) - (nameStart - bufAbsoluteStart)); +- //int last = pos - 1; +- int off = nameStart - bufAbsoluteStart; +- //final int len = last - off; +- final int len = (pos - 1) - off; +- final char[] cbuf = elRawName[depth]; +- if(elRawNameEnd[depth] != len) { +- // construct strings for exception +- final String startname = new String(cbuf, 0, elRawNameEnd[depth]); +- final String endname = new String(buf, off, len); +- throw new XmlPullParserException( +- "end tag name </"+endname+"> must match start tag name <"+startname+">" +- +" from line "+elRawNameLine[depth], this, null); +- } +- for (int i = 0; i < len; i++) +- { +- if(buf[off++] != cbuf[i]) { +- // construct strings for exception +- final String startname = new String(cbuf, 0, len); +- final String endname = new String(buf, off - i - 1, len); +- throw new XmlPullParserException( +- "end tag name </"+endname+"> must be the same as start tag <"+startname+">" +- +" from line "+elRawNameLine[depth], this, null); +- } +- } +- +- while(isS(ch)) { ch = more(); } // skip additional white spaces +- if(ch != '>') { +- throw new XmlPullParserException( +- "expected > to finsh end tag not "+printable(ch) +- +" from line "+elRawNameLine[depth], this, null); +- } +- +- +- //namespaceEnd = elNamespaceCount[ depth ]; //FIXME +- +- posEnd = pos; +- pastEndTag = true; +- return eventType = END_TAG; +- } +- +- public int parseStartTag() throws XmlPullParserException, IOException { +- //ASSUMPTION ch is past <T +- // [40] STag ::= '<' Name (S Attribute)* S? '>' +- // [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>' +- ++depth; //FIXME +- +- posStart = pos - 2; +- +- emptyElementTag = false; +- attributeCount = 0; +- // retrieve name +- final int nameStart = pos - 1 + bufAbsoluteStart; +- int colonPos = -1; +- char ch = buf[ pos - 1]; +- if(ch == ':' && processNamespaces) throw new XmlPullParserException( +- "when namespaces processing enabled colon can not be at element name start", +- this, null); +- while(true) { +- ch = more(); +- if(!isNameChar(ch)) break; +- if(ch == ':' && processNamespaces) { +- if(colonPos != -1) throw new XmlPullParserException( +- "only one colon is allowed in name of element when namespaces are enabled", +- this, null); +- colonPos = pos - 1 + bufAbsoluteStart; +- } +- } +- +- // retrieve name +- ensureElementsCapacity(); +- +- +- //TODO check for efficient interning and then use elRawNameInterned!!!! +- +- int elLen = (pos - 1) - (nameStart - bufAbsoluteStart); +- if(elRawName[ depth ] == null || elRawName[ depth ].length < elLen) { +- elRawName[ depth ] = new char[ 2 * elLen ]; +- } +- System.arraycopy(buf, nameStart - bufAbsoluteStart, elRawName[ depth ], 0, elLen); +- elRawNameEnd[ depth ] = elLen; +- elRawNameLine[ depth ] = lineNumber; +- +- String name = null; +- +- // work on prefixes and namespace URI +- String prefix = null; +- if(processNamespaces) { +- if(colonPos != -1) { +- prefix = elPrefix[ depth ] = newString(buf, nameStart - bufAbsoluteStart, +- colonPos - nameStart); +- name = elName[ depth ] = newString(buf, colonPos + 1 - bufAbsoluteStart, +- //(pos -1) - (colonPos + 1)); +- pos - 2 - (colonPos - bufAbsoluteStart)); +- } else { +- prefix = elPrefix[ depth ] = null; +- name = elName[ depth ] = newString(buf, nameStart - bufAbsoluteStart, elLen); +- } +- } else { +- +- name = elName[ depth ] = newString(buf, nameStart - bufAbsoluteStart, elLen); +- +- } +- +- +- while(true) { +- +- while(isS(ch)) { ch = more(); } // skip additional white spaces +- +- if(ch == '>') { +- break; +- } else if(ch == '/') { +- if(emptyElementTag) throw new XmlPullParserException( +- "repeated / in tag declaration", this, null); +- emptyElementTag = true; +- ch = more(); +- if(ch != '>') throw new XmlPullParserException( +- "expected > to end empty tag not "+printable(ch), this, null); +- break; +- } else if(isNameStartChar(ch)) { +- ch = parseAttribute(); +- ch = more(); +- continue; +- } else { +- throw new XmlPullParserException( +- "start tag unexpected character "+printable(ch), this, null); +- } +- //ch = more(); // skip space +- } +- +- // now when namespaces were declared we can resolve them +- if(processNamespaces) { +- String uri = getNamespace(prefix); +- if(uri == null) { +- if(prefix == null) { // no prefix and no uri => use default namespace +- uri = NO_NAMESPACE; +- } else { +- throw new XmlPullParserException( +- "could not determine namespace bound to element prefix "+prefix, +- this, null); +- } +- +- } +- elUri[ depth ] = uri; +- +- +- //String uri = getNamespace(prefix); +- //if(uri == null && prefix == null) { // no prefix and no uri => use default namespace +- // uri = ""; +- //} +- // resolve attribute namespaces +- for (int i = 0; i < attributeCount; i++) +- { +- final String attrPrefix = attributePrefix[ i ]; +- if(attrPrefix != null) { +- final String attrUri = getNamespace(attrPrefix); +- if(attrUri == null) { +- throw new XmlPullParserException( +- "could not determine namespace bound to attribute prefix "+attrPrefix, +- this, null); +- +- } +- attributeUri[ i ] = attrUri; +- } else { +- attributeUri[ i ] = NO_NAMESPACE; +- } +- } +- +- //TODO +- //[ WFC: Unique Att Spec ] +- // check namespaced attribute uniqueness contraint!!! +- +- for (int i = 1; i < attributeCount; i++) +- { +- for (int j = 0; j < i; j++) +- { +- if( attributeUri[j] == attributeUri[i] +- && (allStringsInterned && attributeName[j].equals(attributeName[i]) +- || (!allStringsInterned +- && attributeNameHash[ j ] == attributeNameHash[ i ] +- && attributeName[j].equals(attributeName[i])) ) +- +- ) { +- // prepare data for nice error messgae? +- String attr1 = attributeName[j]; +- if(attributeUri[j] != null) attr1 = attributeUri[j]+":"+attr1; +- String attr2 = attributeName[i]; +- if(attributeUri[i] != null) attr2 = attributeUri[i]+":"+attr2; +- throw new XmlPullParserException( +- "duplicated attributes "+attr1+" and "+attr2, this, null); +- } +- } +- } +- +- +- } else { // ! processNamespaces +- +- //[ WFC: Unique Att Spec ] +- // check raw attribute uniqueness contraint!!! +- for (int i = 1; i < attributeCount; i++) +- { +- for (int j = 0; j < i; j++) +- { +- if((allStringsInterned && attributeName[j].equals(attributeName[i]) +- || (!allStringsInterned +- && attributeNameHash[ j ] == attributeNameHash[ i ] +- && attributeName[j].equals(attributeName[i])) ) +- +- ) { +- // prepare data for nice error messgae? +- final String attr1 = attributeName[j]; +- final String attr2 = attributeName[i]; +- throw new XmlPullParserException( +- "duplicated attributes "+attr1+" and "+attr2, this, null); +- } +- } +- } +- } +- +- elNamespaceCount[ depth ] = namespaceEnd; +- posEnd = pos; +- return eventType = START_TAG; +- } +- +- protected char parseAttribute() throws XmlPullParserException, IOException +- { +- // parse attribute +- // [41] Attribute ::= Name Eq AttValue +- // [WFC: No External Entity References] +- // [WFC: No < in Attribute Values] +- final int prevPosStart = posStart + bufAbsoluteStart; +- final int nameStart = pos - 1 + bufAbsoluteStart; +- int colonPos = -1; +- char ch = buf[ pos - 1 ]; +- if(ch == ':' && processNamespaces) throw new XmlPullParserException( +- "when namespaces processing enabled colon can not be at attribute name start", +- this, null); +- +- +- boolean startsWithXmlns = processNamespaces && ch == 'x'; +- int xmlnsPos = 0; +- +- ch = more(); +- while(isNameChar(ch)) { +- if(processNamespaces) { +- if(startsWithXmlns && xmlnsPos < 5) { +- ++xmlnsPos; +- if(xmlnsPos == 1) { if(ch != 'm') startsWithXmlns = false; } +- else if(xmlnsPos == 2) { if(ch != 'l') startsWithXmlns = false; } +- else if(xmlnsPos == 3) { if(ch != 'n') startsWithXmlns = false; } +- else if(xmlnsPos == 4) { if(ch != 's') startsWithXmlns = false; } +- else if(xmlnsPos == 5) { +- if(ch != ':') throw new XmlPullParserException( +- "after xmlns in attribute name must be colon" +- +"when namespaces are enabled", this, null); +- //colonPos = pos - 1 + bufAbsoluteStart; +- } +- } +- if(ch == ':') { +- if(colonPos != -1) throw new XmlPullParserException( +- "only one colon is allowed in attribute name" +- +" when namespaces are enabled", this, null); +- colonPos = pos - 1 + bufAbsoluteStart; +- } +- } +- ch = more(); +- } +- +- ensureAttributesCapacity(attributeCount); +- +- // --- start processing attributes +- String name = null; +- String prefix = null; +- // work on prefixes and namespace URI +- if(processNamespaces) { +- if(xmlnsPos < 4) startsWithXmlns = false; +- if(startsWithXmlns) { +- if(colonPos != -1) { +- //prefix = attributePrefix[ attributeCount ] = null; +- final int nameLen = pos - 2 - (colonPos - bufAbsoluteStart); +- if(nameLen == 0) { +- throw new XmlPullParserException( +- "namespace prefix is required after xmlns: " +- +" when namespaces are enabled", this, null); +- } +- name = //attributeName[ attributeCount ] = +- newString(buf, colonPos - bufAbsoluteStart + 1, nameLen); +- //pos - 1 - (colonPos + 1 - bufAbsoluteStart) +- } +- } else { +- if(colonPos != -1) { +- int prefixLen = colonPos - nameStart; +- prefix = attributePrefix[ attributeCount ] = +- newString(buf, nameStart - bufAbsoluteStart,prefixLen); +- //colonPos - (nameStart - bufAbsoluteStart)); +- int nameLen = pos - 2 - (colonPos - bufAbsoluteStart); +- name = attributeName[ attributeCount ] = +- newString(buf, colonPos - bufAbsoluteStart + 1, nameLen); +- //pos - 1 - (colonPos + 1 - bufAbsoluteStart)); +- +- //name.substring(0, colonPos-nameStart); +- } else { +- prefix = attributePrefix[ attributeCount ] = null; +- name = attributeName[ attributeCount ] = +- newString(buf, nameStart - bufAbsoluteStart, +- pos - 1 - (nameStart - bufAbsoluteStart)); +- } +- if(!allStringsInterned) { +- attributeNameHash[ attributeCount ] = name.hashCode(); +- } +- } +- +- } else { +- // retrieve name +- name = attributeName[ attributeCount ] = +- newString(buf, nameStart - bufAbsoluteStart, +- pos - 1 - (nameStart - bufAbsoluteStart)); +- ////assert name != null; +- if(!allStringsInterned) { +- attributeNameHash[ attributeCount ] = name.hashCode(); +- } +- } +- +- // [25] Eq ::= S? '=' S? +- while(isS(ch)) { ch = more(); } // skip additional spaces +- if(ch != '=') throw new XmlPullParserException( +- "expected = after attribute name", this, null); +- ch = more(); +- while(isS(ch)) { ch = more(); } // skip additional spaces +- +- // [10] AttValue ::= '"' ([^<&"] | Reference)* '"' +- // | "'" ([^<&'] | Reference)* "'" +- final char delimit = ch; +- if(delimit != '"' && delimit != ''') throw new XmlPullParserException( +- "attribute value must start with quotation or apostrophe not " +- +printable(delimit), this, null); +- // parse until delimit or < and resolve Reference +- //[67] Reference ::= EntityRef | CharRef +- //int valueStart = pos + bufAbsoluteStart; +- +- +- boolean normalizedCR = false; +- usePC = false; +- pcStart = pcEnd; +- posStart = pos; +- +- while(true) { +- ch = more(); +- if(ch == delimit) { +- break; +- } if(ch == '<') { +- throw new XmlPullParserException( +- "markup not allowed inside attribute value - illegal < ", this, null); +- } if(ch == '&') { +- // extractEntityRef +- posEnd = pos - 1; +- if(!usePC) { +- final boolean hadCharData = posEnd > posStart; +- if(hadCharData) { +- // posEnd is already set correctly!!! +- joinPC(); +- } else { +- usePC = true; +- pcStart = pcEnd = 0; +- } +- } +- //assert usePC == true; +- +- final char[] resolvedEntity = parseEntityRef(); +- // check if replacement text can be resolved !!! +- if(resolvedEntity == null) { +- if(entityRefName == null) { +- entityRefName = newString(buf, posStart, posEnd - posStart); +- } +- throw new XmlPullParserException( +- "could not resolve entity named '"+printable(entityRefName)+"'", +- this, null); +- } +- // write into PC replacement text - do merge for replacement text!!!! +- for (int i = 0; i < resolvedEntity.length; i++) +- { +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = resolvedEntity[ i ]; +- } +- } else if(ch == '\t' || ch == '\n' || ch == '\r') { +- // do attribute value normalization +- // as described in http://www.w3.org/TR/REC-xml#AVNormalize +- // TODO add test for it form spec ... +- // handle EOL normalization ... +- if(!usePC) { +- posEnd = pos - 1; +- if(posEnd > posStart) { +- joinPC(); +- } else { +- usePC = true; +- pcEnd = pcStart = 0; +- } +- } +- //assert usePC == true; +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- if(ch != '\n' || !normalizedCR) { +- pc[pcEnd++] = ' '; //'\n'; +- } +- +- } else { +- if(usePC) { +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = ch; +- } +- } +- normalizedCR = ch == '\r'; +- } +- +- +- if(processNamespaces && startsWithXmlns) { +- String ns = null; +- if(!usePC) { +- ns = newStringIntern(buf, posStart, pos - 1 - posStart); +- } else { +- ns = newStringIntern(pc, pcStart, pcEnd - pcStart); +- } +- ensureNamespacesCapacity(namespaceEnd); +- int prefixHash = -1; +- if(colonPos != -1) { +- if(ns.length() == 0) { +- throw new XmlPullParserException( +- "non-default namespace can not be declared to be empty string", this, null); +- } +- // declare new namespace +- namespacePrefix[ namespaceEnd ] = name; +- if(!allStringsInterned) { +- prefixHash = namespacePrefixHash[ namespaceEnd ] = name.hashCode(); +- } +- } else { +- // declare new default namespace... +- namespacePrefix[ namespaceEnd ] = null; //""; //null; //TODO check FIXME Alek +- if(!allStringsInterned) { +- prefixHash = namespacePrefixHash[ namespaceEnd ] = -1; +- } +- } +- namespaceUri[ namespaceEnd ] = ns; +- +- // detect duplicate namespace declarations!!! +- final int startNs = elNamespaceCount[ depth - 1 ]; +- for (int i = namespaceEnd - 1; i >= startNs; --i) +- { +- if(((allStringsInterned || name == null) && namespacePrefix[ i ] == name) +- || (!allStringsInterned && name != null && +- namespacePrefixHash[ i ] == prefixHash +- && name.equals(namespacePrefix[ i ]) +- )) +- { +- final String s = name == null ? "default" : "'"+name+"'"; +- throw new XmlPullParserException( +- "duplicated namespace declaration for "+s+" prefix", this, null); +- } +- } +- +- ++namespaceEnd; +- +- } else { +- if(!usePC) { +- attributeValue[ attributeCount ] = +- new String(buf, posStart, pos - 1 - posStart); +- } else { +- attributeValue[ attributeCount ] = +- new String(pc, pcStart, pcEnd - pcStart); +- } +- ++attributeCount; +- } +- posStart = prevPosStart - bufAbsoluteStart; +- return ch; +- } +- +- protected char[] charRefOneCharBuf = new char[1]; +- +- protected char[] parseEntityRef() +- throws XmlPullParserException, IOException +- { +- // entity reference http://www.w3.org/TR/2000/REC-xml-20001006#NT-Reference +- // [67] Reference ::= EntityRef | CharRef +- +- // ASSUMPTION just after & +- entityRefName = null; +- posStart = pos; +- char ch = more(); +- StringBuffer sb = new StringBuffer(); +- if(ch == '#') { +- // parse character reference +- char charRef = 0; +- ch = more(); +- if(ch == 'x') { +- //encoded in hex +- while(true) { +- ch = more(); +- if(ch >= '0' && ch <= '9') { +- charRef = (char)(charRef * 16 + (ch - '0')); +- sb.append( ch ); +- } else if(ch >= 'a' && ch <= 'f') { +- charRef = (char)(charRef * 16 + (ch - ('a' - 10))); +- sb.append( ch ); +- } else if(ch >= 'A' && ch <= 'F') { +- charRef = (char)(charRef * 16 + (ch - ('A' - 10))); +- sb.append( ch ); +- } else if(ch == ';') { +- break; +- } else { +- throw new XmlPullParserException( +- "character reference (with hex value) may not contain " +- +printable(ch), this, null); +- } +- } +- } else { +- // encoded in decimal +- while(true) { +- if(ch >= '0' && ch <= '9') { +- charRef = (char)(charRef * 10 + (ch - '0')); +- } else if(ch == ';') { +- break; +- } else { +- throw new XmlPullParserException( +- "character reference (with decimal value) may not contain " +- +printable(ch), this, null); +- } +- ch = more(); +- } +- } +- posEnd = pos - 1; +- if ( sb.length() > 0 ) +- { +- char[] tmp = toChars( Integer.parseInt( sb.toString(), 16 ) ); +- charRefOneCharBuf = tmp; +- if ( tokenize ) +- { +- text = newString( charRefOneCharBuf, 0, charRefOneCharBuf.length ); +- } +- return charRefOneCharBuf; +- } +- charRefOneCharBuf[0] = charRef; +- if(tokenize) { +- text = newString(charRefOneCharBuf, 0, 1); +- } +- return charRefOneCharBuf; +- } else { +- // [68] EntityRef ::= '&' Name ';' +- // scan anem until ; +- if(!isNameStartChar(ch)) { +- throw new XmlPullParserException( +- "entity reference names can not start with character '" +- +printable(ch)+"'", this, null); +- } +- while(true) { +- ch = more(); +- if(ch == ';') { +- break; +- } +- if(!isNameChar(ch)) { +- throw new XmlPullParserException( +- "entity reference name can not contain character " +- +printable(ch)+"'", this, null); +- } +- } +- posEnd = pos - 1; +- // determine what name maps to +- final int len = posEnd - posStart; +- if(len == 2 && buf[posStart] == 'l' && buf[posStart+1] == 't') { +- if(tokenize) { +- text = "<"; +- } +- charRefOneCharBuf[0] = '<'; +- return charRefOneCharBuf; +- //if(paramPC || isParserTokenizing) { +- // if(pcEnd >= pc.length) ensurePC(); +- // pc[pcEnd++] = '<'; +- //} +- } else if(len == 3 && buf[posStart] == 'a' +- && buf[posStart+1] == 'm' && buf[posStart+2] == 'p') { +- if(tokenize) { +- text = "&"; +- } +- charRefOneCharBuf[0] = '&'; +- return charRefOneCharBuf; +- } else if(len == 2 && buf[posStart] == 'g' && buf[posStart+1] == 't') { +- if(tokenize) { +- text = ">"; +- } +- charRefOneCharBuf[0] = '>'; +- return charRefOneCharBuf; +- } else if(len == 4 && buf[posStart] == 'a' && buf[posStart+1] == 'p' +- && buf[posStart+2] == 'o' && buf[posStart+3] == 's') +- { +- if(tokenize) { +- text = "'"; +- } +- charRefOneCharBuf[0] = '''; +- return charRefOneCharBuf; +- } else if(len == 4 && buf[posStart] == 'q' && buf[posStart+1] == 'u' +- && buf[posStart+2] == 'o' && buf[posStart+3] == 't') +- { +- if(tokenize) { +- text = """; +- } +- charRefOneCharBuf[0] = '"'; +- return charRefOneCharBuf; +- } else { +- final char[] result = lookuEntityReplacement(len); +- if(result != null) { +- return result; +- } +- } +- if(tokenize) text = null; +- return null; +- } +- } +- +- protected char[] lookuEntityReplacement(int entitNameLen) +- throws XmlPullParserException, IOException +- +- { +- if(!allStringsInterned) { +- final int hash = fastHash(buf, posStart, posEnd - posStart); +- LOOP: +- for (int i = entityEnd - 1; i >= 0; --i) +- { +- if(hash == entityNameHash[ i ] && entitNameLen == entityNameBuf[ i ].length) { +- final char[] entityBuf = entityNameBuf[ i ]; +- for (int j = 0; j < entitNameLen; j++) +- { +- if(buf[posStart + j] != entityBuf[j]) continue LOOP; +- } +- if(tokenize) text = entityReplacement[ i ]; +- return entityReplacementBuf[ i ]; +- } +- } +- } else { +- entityRefName = newString(buf, posStart, posEnd - posStart); +- for (int i = entityEnd - 1; i >= 0; --i) +- { +- // take advantage that interning for newStirng is enforced +- if(entityRefName == entityName[ i ]) { +- if(tokenize) text = entityReplacement[ i ]; +- return entityReplacementBuf[ i ]; +- } +- } +- } +- return null; +- } +- +- +- protected void parseComment() +- throws XmlPullParserException, IOException +- { +- // implements XML 1.0 Section 2.5 Comments +- +- //ASSUMPTION: seen <!- +- char ch = more(); +- if(ch != '-') throw new XmlPullParserException( +- "expected <!-- for comment start", this, null); +- if(tokenize) posStart = pos; +- +- final int curLine = lineNumber; +- final int curColumn = columnNumber; +- try { +- final boolean normalizeIgnorableWS = tokenize == true && roundtripSupported == false; +- boolean normalizedCR = false; +- +- boolean seenDash = false; +- boolean seenDashDash = false; +- while(true) { +- // scan until it hits --> +- ch = more(); +- if(seenDashDash && ch != '>') { +- throw new XmlPullParserException( +- "in comment after two dashes (--) next character must be >" +- +" not "+printable(ch), this, null); +- } +- if(ch == '-') { +- if(!seenDash) { +- seenDash = true; +- } else { +- seenDashDash = true; +- seenDash = false; +- } +- } else if(ch == '>') { +- if(seenDashDash) { +- break; // found end sequence!!!! +- } else { +- seenDashDash = false; +- } +- seenDash = false; +- } else { +- seenDash = false; +- } +- if(normalizeIgnorableWS) { +- if(ch == '\r') { +- normalizedCR = true; +- //posEnd = pos -1; +- //joinPC(); +- // posEnd is alreadys set +- if(!usePC) { +- posEnd = pos -1; +- if(posEnd > posStart) { +- joinPC(); +- } else { +- usePC = true; +- pcStart = pcEnd = 0; +- } +- } +- //assert usePC == true; +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = '\n'; +- } else if(ch == '\n') { +- if(!normalizedCR && usePC) { +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = '\n'; +- } +- normalizedCR = false; +- } else { +- if(usePC) { +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = ch; +- } +- normalizedCR = false; +- } +- } +- } +- +- } catch(EOFException ex) { +- // detect EOF and create meaningful error ... +- throw new XmlPullParserException( +- "comment started on line "+curLine+" and column "+curColumn+" was not closed", +- this, ex); +- } +- if(tokenize) { +- posEnd = pos - 3; +- if(usePC) { +- pcEnd -= 2; +- } +- } +- } +- +- protected boolean parsePI() +- throws XmlPullParserException, IOException +- { +- // implements XML 1.0 Section 2.6 Processing Instructions +- +- // [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>' +- // [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l')) +- //ASSUMPTION: seen <? +- if(tokenize) posStart = pos; +- final int curLine = lineNumber; +- final int curColumn = columnNumber; +- int piTargetStart = pos + bufAbsoluteStart; +- int piTargetEnd = -1; +- final boolean normalizeIgnorableWS = tokenize == true && roundtripSupported == false; +- boolean normalizedCR = false; +- +- try { +- boolean seenQ = false; +- char ch = more(); +- if(isS(ch)) { +- throw new XmlPullParserException( +- "processing instruction PITarget must be exactly after <? and not white space character", +- this, null); +- } +- while(true) { +- // scan until it hits ?> +- //ch = more(); +- +- if(ch == '?') { +- seenQ = true; +- } else if(ch == '>') { +- if(seenQ) { +- break; // found end sequence!!!! +- } +- seenQ = false; +- } else { +- if(piTargetEnd == -1 && isS(ch)) { +- piTargetEnd = pos - 1 + bufAbsoluteStart; +- +- // [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l')) +- if((piTargetEnd - piTargetStart) == 3) { +- if((buf[piTargetStart] == 'x' || buf[piTargetStart] == 'X') +- && (buf[piTargetStart+1] == 'm' || buf[piTargetStart+1] == 'M') +- && (buf[piTargetStart+2] == 'l' || buf[piTargetStart+2] == 'L') +- ) +- { +- if(piTargetStart > 3) { //<?xml is allowed as first characters in input ... +- throw new XmlPullParserException( +- "processing instruction can not have PITarget with reserveld xml name", +- this, null); +- } else { +- if(buf[piTargetStart] != 'x' +- && buf[piTargetStart+1] != 'm' +- && buf[piTargetStart+2] != 'l') +- { +- throw new XmlPullParserException( +- "XMLDecl must have xml name in lowercase", +- this, null); +- } +- } +- parseXmlDecl(ch); +- if(tokenize) posEnd = pos - 2; +- final int off = piTargetStart - bufAbsoluteStart + 3; +- final int len = pos - 2 - off; +- xmlDeclContent = newString(buf, off, len); +- return false; +- } +- } +- } +- seenQ = false; +- } +- if(normalizeIgnorableWS) { +- if(ch == '\r') { +- normalizedCR = true; +- //posEnd = pos -1; +- //joinPC(); +- // posEnd is alreadys set +- if(!usePC) { +- posEnd = pos -1; +- if(posEnd > posStart) { +- joinPC(); +- } else { +- usePC = true; +- pcStart = pcEnd = 0; +- } +- } +- //assert usePC == true; +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = '\n'; +- } else if(ch == '\n') { +- if(!normalizedCR && usePC) { +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = '\n'; +- } +- normalizedCR = false; +- } else { +- if(usePC) { +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = ch; +- } +- normalizedCR = false; +- } +- } +- ch = more(); +- } +- } catch(EOFException ex) { +- // detect EOF and create meaningful error ... +- throw new XmlPullParserException( +- "processing instruction started on line "+curLine+" and column "+curColumn +- +" was not closed", +- this, ex); +- } +- if(piTargetEnd == -1) { +- piTargetEnd = pos - 2 + bufAbsoluteStart; +- //throw new XmlPullParserException( +- // "processing instruction must have PITarget name", this, null); +- } +- piTargetStart -= bufAbsoluteStart; +- piTargetEnd -= bufAbsoluteStart; +- if(tokenize) { +- posEnd = pos - 2; +- if(normalizeIgnorableWS) { +- --pcEnd; +- } +- } +- return true; +- } +- +- // protected final static char[] VERSION = {'v','e','r','s','i','o','n'}; +- // protected final static char[] NCODING = {'n','c','o','d','i','n','g'}; +- // protected final static char[] TANDALONE = {'t','a','n','d','a','l','o','n','e'}; +- // protected final static char[] YES = {'y','e','s'}; +- // protected final static char[] NO = {'n','o'}; +- +- protected final static char[] VERSION = "version".toCharArray(); +- protected final static char[] NCODING = "ncoding".toCharArray(); +- protected final static char[] TANDALONE = "tandalone".toCharArray(); +- protected final static char[] YES = "yes".toCharArray(); +- protected final static char[] NO = "no".toCharArray(); +- +- +- +- protected void parseXmlDecl(char ch) +- throws XmlPullParserException, IOException +- { +- // [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>' +- +- // first make sure that relative positions will stay OK +- preventBufferCompaction = true; +- bufStart = 0; // necessary to keep pos unchanged during expansion! +- +- // --- parse VersionInfo +- +- // [24] VersionInfo ::= S 'version' Eq ("'" VersionNum "'" | '"' VersionNum '"') +- // parse is positioned just on first S past <?xml +- ch = skipS(ch); +- ch = requireInput(ch, VERSION); +- // [25] Eq ::= S? '=' S? +- ch = skipS(ch); +- if(ch != '=') { +- throw new XmlPullParserException( +- "expected equals sign (=) after version and not "+printable(ch), this, null); +- } +- ch = more(); +- ch = skipS(ch); +- if(ch != '\'' && ch != '"') { +- throw new XmlPullParserException( +- "expected apostrophe (') or quotation mark (\") after version and not " +- +printable(ch), this, null); +- } +- final char quotChar = ch; +- //int versionStart = pos + bufAbsoluteStart; // required if preventBufferCompaction==false +- final int versionStart = pos; +- ch = more(); +- // [26] VersionNum ::= ([a-zA-Z0-9_.:] | '-')+ +- while(ch != quotChar) { +- if((ch < 'a' || ch > 'z') && (ch < 'A' || ch > 'Z') && (ch < '0' || ch > '9') +- && ch != '_' && ch != '.' && ch != ':' && ch != '-') +- { +- throw new XmlPullParserException( +- "<?xml version value expected to be in ([a-zA-Z0-9_.:] | '-')" +- +" not "+printable(ch), this, null); +- } +- ch = more(); +- } +- final int versionEnd = pos - 1; +- parseXmlDeclWithVersion(versionStart, versionEnd); +- preventBufferCompaction = false; // allow again buffer commpaction - pos MAY chnage +- } +- //protected String xmlDeclVersion; +- +- protected void parseXmlDeclWithVersion(int versionStart, int versionEnd) +- throws XmlPullParserException, IOException +- { +- // check version is "1.0" +- if((versionEnd - versionStart != 3) +- || buf[versionStart] != '1' +- || buf[versionStart+1] != '.' +- || buf[versionStart+2] != '0') +- { +- throw new XmlPullParserException( +- "only 1.0 is supported as <?xml version not '" +- +printable(new String(buf, versionStart, versionEnd - versionStart))+"'", this, null); +- } +- xmlDeclVersion = newString(buf, versionStart, versionEnd - versionStart); +- +- // [80] EncodingDecl ::= S 'encoding' Eq ('"' EncName '"' | "'" EncName "'" ) +- char ch = more(); +- ch = skipS(ch); +- if(ch == 'e') { +- ch = more(); +- ch = requireInput(ch, NCODING); +- ch = skipS(ch); +- if(ch != '=') { +- throw new XmlPullParserException( +- "expected equals sign (=) after encoding and not "+printable(ch), this, null); +- } +- ch = more(); +- ch = skipS(ch); +- if(ch != '\'' && ch != '"') { +- throw new XmlPullParserException( +- "expected apostrophe (') or quotation mark (\") after encoding and not " +- +printable(ch), this, null); +- } +- final char quotChar = ch; +- final int encodingStart = pos; +- ch = more(); +- // [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')* +- if((ch < 'a' || ch > 'z') && (ch < 'A' || ch > 'Z')) +- { +- throw new XmlPullParserException( +- "<?xml encoding name expected to start with [A-Za-z]" +- +" not "+printable(ch), this, null); +- } +- ch = more(); +- while(ch != quotChar) { +- if((ch < 'a' || ch > 'z') && (ch < 'A' || ch > 'Z') && (ch < '0' || ch > '9') +- && ch != '.' && ch != '_' && ch != '-') +- { +- throw new XmlPullParserException( +- "<?xml encoding value expected to be in ([A-Za-z0-9._] | '-')" +- +" not "+printable(ch), this, null); +- } +- ch = more(); +- } +- final int encodingEnd = pos - 1; +- +- +- // TODO reconcile with setInput encodingName +- inputEncoding = newString(buf, encodingStart, encodingEnd - encodingStart); +- ch = more(); +- } +- +- ch = skipS(ch); +- // [32] SDDecl ::= S 'standalone' Eq (("'" ('yes' | 'no') "'") | ('"' ('yes' | 'no') '"')) +- if(ch == 's') { +- ch = more(); +- ch = requireInput(ch, TANDALONE); +- ch = skipS(ch); +- if(ch != '=') { +- throw new XmlPullParserException( +- "expected equals sign (=) after standalone and not "+printable(ch), +- this, null); +- } +- ch = more(); +- ch = skipS(ch); +- if(ch != '\'' && ch != '"') { +- throw new XmlPullParserException( +- "expected apostrophe (') or quotation mark (\") after encoding and not " +- +printable(ch), this, null); +- } +- char quotChar = ch; +- int standaloneStart = pos; +- ch = more(); +- if(ch == 'y') { +- ch = requireInput(ch, YES); +- //Boolean standalone = new Boolean(true); +- xmlDeclStandalone = new Boolean(true); +- } else if(ch == 'n') { +- ch = requireInput(ch, NO); +- //Boolean standalone = new Boolean(false); +- xmlDeclStandalone = new Boolean(false); +- } else { +- throw new XmlPullParserException( +- "expected 'yes' or 'no' after standalone and not " +- +printable(ch), this, null); +- } +- if(ch != quotChar) { +- throw new XmlPullParserException( +- "expected "+quotChar+" after standalone value not " +- +printable(ch), this, null); +- } +- ch = more(); +- } +- +- +- ch = skipS(ch); +- if(ch != '?') { +- throw new XmlPullParserException( +- "expected ?> as last part of <?xml not " +- +printable(ch), this, null); +- } +- ch = more(); +- if(ch != '>') { +- throw new XmlPullParserException( +- "expected ?> as last part of <?xml not " +- +printable(ch), this, null); +- } +- +- } +- protected void parseDocdecl() +- throws XmlPullParserException, IOException +- { +- //ASSUMPTION: seen <!D +- char ch = more(); +- if(ch != 'O') throw new XmlPullParserException( +- "expected <!DOCTYPE", this, null); +- ch = more(); +- if(ch != 'C') throw new XmlPullParserException( +- "expected <!DOCTYPE", this, null); +- ch = more(); +- if(ch != 'T') throw new XmlPullParserException( +- "expected <!DOCTYPE", this, null); +- ch = more(); +- if(ch != 'Y') throw new XmlPullParserException( +- "expected <!DOCTYPE", this, null); +- ch = more(); +- if(ch != 'P') throw new XmlPullParserException( +- "expected <!DOCTYPE", this, null); +- ch = more(); +- if(ch != 'E') throw new XmlPullParserException( +- "expected <!DOCTYPE", this, null); +- posStart = pos; +- // do simple and crude scanning for end of doctype +- +- // [28] doctypedecl ::= '<!DOCTYPE' S Name (S ExternalID)? S? ('[' +- // (markupdecl | DeclSep)* ']' S?)? '>' +- int bracketLevel = 0; +- final boolean normalizeIgnorableWS = tokenize == true && roundtripSupported == false; +- boolean normalizedCR = false; +- while(true) { +- ch = more(); +- if(ch == '[') ++bracketLevel; +- if(ch == ']') --bracketLevel; +- if(ch == '>' && bracketLevel == 0) break; +- if(normalizeIgnorableWS) { +- if(ch == '\r') { +- normalizedCR = true; +- //posEnd = pos -1; +- //joinPC(); +- // posEnd is alreadys set +- if(!usePC) { +- posEnd = pos -1; +- if(posEnd > posStart) { +- joinPC(); +- } else { +- usePC = true; +- pcStart = pcEnd = 0; +- } +- } +- //assert usePC == true; +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = '\n'; +- } else if(ch == '\n') { +- if(!normalizedCR && usePC) { +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = '\n'; +- } +- normalizedCR = false; +- } else { +- if(usePC) { +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = ch; +- } +- normalizedCR = false; +- } +- } +- +- } +- posEnd = pos - 1; +- } +- +- protected void parseCDSect(boolean hadCharData) +- throws XmlPullParserException, IOException +- { +- // implements XML 1.0 Section 2.7 CDATA Sections +- +- // [18] CDSect ::= CDStart CData CDEnd +- // [19] CDStart ::= '<![CDATA[' +- // [20] CData ::= (Char* - (Char* ']]>' Char*)) +- // [21] CDEnd ::= ']]>' +- +- //ASSUMPTION: seen <![ +- char ch = more(); +- if(ch != 'C') throw new XmlPullParserException( +- "expected <[CDATA[ for comment start", this, null); +- ch = more(); +- if(ch != 'D') throw new XmlPullParserException( +- "expected <[CDATA[ for comment start", this, null); +- ch = more(); +- if(ch != 'A') throw new XmlPullParserException( +- "expected <[CDATA[ for comment start", this, null); +- ch = more(); +- if(ch != 'T') throw new XmlPullParserException( +- "expected <[CDATA[ for comment start", this, null); +- ch = more(); +- if(ch != 'A') throw new XmlPullParserException( +- "expected <[CDATA[ for comment start", this, null); +- ch = more(); +- if(ch != '[') throw new XmlPullParserException( +- "expected <![CDATA[ for comment start", this, null); +- +- //if(tokenize) { +- final int cdStart = pos + bufAbsoluteStart; +- final int curLine = lineNumber; +- final int curColumn = columnNumber; +- final boolean normalizeInput = tokenize == false || roundtripSupported == false; +- try { +- if(normalizeInput) { +- if(hadCharData) { +- if(!usePC) { +- // posEnd is correct already!!! +- if(posEnd > posStart) { +- joinPC(); +- } else { +- usePC = true; +- pcStart = pcEnd = 0; +- } +- } +- } +- } +- boolean seenBracket = false; +- boolean seenBracketBracket = false; +- boolean normalizedCR = false; +- while(true) { +- // scan until it hits "]]>" +- ch = more(); +- if(ch == ']') { +- if(!seenBracket) { +- seenBracket = true; +- } else { +- seenBracketBracket = true; +- //seenBracket = false; +- } +- } else if(ch == '>') { +- if(seenBracket && seenBracketBracket) { +- break; // found end sequence!!!! +- } else { +- seenBracketBracket = false; +- } +- seenBracket = false; +- } else { +- if(seenBracket) { +- seenBracket = false; +- } +- } +- if(normalizeInput) { +- // deal with normalization issues ... +- if(ch == '\r') { +- normalizedCR = true; +- posStart = cdStart - bufAbsoluteStart; +- posEnd = pos - 1; // posEnd is alreadys set +- if(!usePC) { +- if(posEnd > posStart) { +- joinPC(); +- } else { +- usePC = true; +- pcStart = pcEnd = 0; +- } +- } +- //assert usePC == true; +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = '\n'; +- } else if(ch == '\n') { +- if(!normalizedCR && usePC) { +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = '\n'; +- } +- normalizedCR = false; +- } else { +- if(usePC) { +- if(pcEnd >= pc.length) ensurePC(pcEnd); +- pc[pcEnd++] = ch; +- } +- normalizedCR = false; +- } +- } +- } +- } catch(EOFException ex) { +- // detect EOF and create meaningful error ... +- throw new XmlPullParserException( +- "CDATA section started on line "+curLine+" and column "+curColumn+" was not closed", +- this, ex); +- } +- if(normalizeInput) { +- if(usePC) { +- pcEnd = pcEnd - 2; +- } +- } +- posStart = cdStart - bufAbsoluteStart; +- posEnd = pos - 3; +- } +- +- protected void fillBuf() throws IOException, XmlPullParserException { +- if(reader == null) throw new XmlPullParserException( +- "reader must be set before parsing is started"); +- +- // see if we are in compaction area +- if(bufEnd > bufSoftLimit) { +- +- // expand buffer it makes sense!!!! +- boolean compact = bufStart > bufSoftLimit; +- boolean expand = false; +- if(preventBufferCompaction) { +- compact = false; +- expand = true; +- } else if(!compact) { +- //freeSpace +- if(bufStart < buf.length / 2) { +- // less then half buffer available forcompactin --> expand instead!!! +- expand = true; +- } else { +- // at least half of buffer can be reclaimed --> worthwhile effort!!! +- compact = true; +- } +- } +- +- // if buffer almost full then compact it +- if(compact) { +- //TODO: look on trashing +- // //assert bufStart > 0 +- System.arraycopy(buf, bufStart, buf, 0, bufEnd - bufStart); +- if(TRACE_SIZING) System.out.println( +- "TRACE_SIZING fillBuf() compacting "+bufStart +- +" bufEnd="+bufEnd +- +" pos="+pos+" posStart="+posStart+" posEnd="+posEnd +- +" buf first 100 chars:"+new String(buf, bufStart, +- bufEnd - bufStart < 100 ? bufEnd - bufStart : 100 )); +- +- } else if(expand) { +- final int newSize = 2 * buf.length; +- final char newBuf[] = new char[ newSize ]; +- if(TRACE_SIZING) System.out.println("TRACE_SIZING fillBuf() "+buf.length+" => "+newSize); +- System.arraycopy(buf, bufStart, newBuf, 0, bufEnd - bufStart); +- buf = newBuf; +- if(bufLoadFactor > 0) { +- bufSoftLimit = ( bufLoadFactor * buf.length ) /100; +- } +- +- } else { +- throw new XmlPullParserException("internal error in fillBuffer()"); +- } +- bufEnd -= bufStart; +- pos -= bufStart; +- posStart -= bufStart; +- posEnd -= bufStart; +- bufAbsoluteStart += bufStart; +- bufStart = 0; +- if(TRACE_SIZING) System.out.println( +- "TRACE_SIZING fillBuf() after bufEnd="+bufEnd +- +" pos="+pos+" posStart="+posStart+" posEnd="+posEnd +- +" buf first 100 chars:"+new String(buf, 0, bufEnd < 100 ? bufEnd : 100)); +- } +- // at least one charcter must be read or error +- final int len = buf.length - bufEnd > READ_CHUNK_SIZE ? READ_CHUNK_SIZE : buf.length - bufEnd; +- final int ret = reader.read(buf, bufEnd, len); +- if(ret > 0) { +- bufEnd += ret; +- if(TRACE_SIZING) System.out.println( +- "TRACE_SIZING fillBuf() after filling in buffer" +- +" buf first 100 chars:"+new String(buf, 0, bufEnd < 100 ? bufEnd : 100)); +- +- return; +- } +- if(ret == -1) { +- if(bufAbsoluteStart == 0 && pos == 0) { +- throw new EOFException("input contained no data"); +- } else { +- if(seenRoot && depth == 0) { // inside parsing epilog!!! +- reachedEnd = true; +- return; +- } else { +- StringBuffer expectedTagStack = new StringBuffer(); +- if(depth > 0) { +- //final char[] cbuf = elRawName[depth]; +- //final String startname = new String(cbuf, 0, elRawNameEnd[depth]); +- expectedTagStack.append(" - expected end tag"); +- if(depth > 1) { +- expectedTagStack.append("s"); //more than one end tag +- } +- expectedTagStack.append(" "); +- for (int i = depth; i > 0; i--) +- { +- String tagName = new String(elRawName[i], 0, elRawNameEnd[i]); +- expectedTagStack.append("</").append(tagName).append('>'); +- } +- expectedTagStack.append(" to close"); +- for (int i = depth; i > 0; i--) +- { +- if(i != depth) { +- expectedTagStack.append(" and"); //more than one end tag +- } +- String tagName = new String(elRawName[i], 0, elRawNameEnd[i]); +- expectedTagStack.append(" start tag <"+tagName+">"); +- expectedTagStack.append(" from line "+elRawNameLine[i]); +- } +- expectedTagStack.append(", parser stopped on"); +- } +- throw new EOFException("no more data available" +- +expectedTagStack.toString()+getPositionDescription()); +- } +- } +- } else { +- throw new IOException("error reading input, returned "+ret); +- } +- } +- +- protected char more() throws IOException, XmlPullParserException { +- if(pos >= bufEnd) { +- fillBuf(); +- // this return value should be ignonored as it is used in epilog parsing ... +- if(reachedEnd) return (char)-1; +- } +- final char ch = buf[pos++]; +- //line/columnNumber +- if(ch == '\n') { ++lineNumber; columnNumber = 1; } +- else { ++columnNumber; } +- //System.out.print(ch); +- return ch; +- } +- +- // /** +- // * This function returns position of parser in XML input stream +- // * (how many <b>characters</b> were processed. +- // * <p><b>NOTE:</b> this logical position and not byte offset as encodings +- // * such as UTF8 may use more than one byte to encode one character. +- // */ +- // public int getCurrentInputPosition() { +- // return pos + bufAbsoluteStart; +- // } +- +- protected void ensurePC(int end) { +- //assert end >= pc.length; +- final int newSize = end > READ_CHUNK_SIZE ? 2 * end : 2 * READ_CHUNK_SIZE; +- final char[] newPC = new char[ newSize ]; +- if(TRACE_SIZING) System.out.println("TRACE_SIZING ensurePC() "+pc.length+" ==> "+newSize+" end="+end); +- System.arraycopy(pc, 0, newPC, 0, pcEnd); +- pc = newPC; +- //assert end < pc.length; +- } +- +- protected void joinPC() { +- //assert usePC == false; +- //assert posEnd > posStart; +- final int len = posEnd - posStart; +- final int newEnd = pcEnd + len + 1; +- if(newEnd >= pc.length) ensurePC(newEnd); // add 1 for extra space for one char +- //assert newEnd < pc.length; +- System.arraycopy(buf, posStart, pc, pcEnd, len); +- pcEnd += len; +- usePC = true; +- +- } +- +- protected char requireInput(char ch, char[] input) +- throws XmlPullParserException, IOException +- { +- for (int i = 0; i < input.length; i++) +- { +- if(ch != input[i]) { +- throw new XmlPullParserException( +- "expected "+printable(input[i])+" in "+new String(input) +- +" and not "+printable(ch), this, null); +- } +- ch = more(); +- } +- return ch; +- } +- +- protected char requireNextS() +- throws XmlPullParserException, IOException +- { +- final char ch = more(); +- if(!isS(ch)) { +- throw new XmlPullParserException( +- "white space is required and not "+printable(ch), this, null); +- } +- return skipS(ch); +- } +- +- protected char skipS(char ch) +- throws XmlPullParserException, IOException +- { +- while(isS(ch)) { ch = more(); } // skip additional spaces +- return ch; +- } +- +- // nameStart / name lookup tables based on XML 1.1 http://www.w3.org/TR/2001/WD-xml11-20011213/ +- protected static final int LOOKUP_MAX = 0x400; +- protected static final char LOOKUP_MAX_CHAR = (char)LOOKUP_MAX; +- // protected static int lookupNameStartChar[] = new int[ LOOKUP_MAX_CHAR / 32 ]; +- // protected static int lookupNameChar[] = new int[ LOOKUP_MAX_CHAR / 32 ]; +- protected static boolean lookupNameStartChar[] = new boolean[ LOOKUP_MAX ]; +- protected static boolean lookupNameChar[] = new boolean[ LOOKUP_MAX ]; +- +- private static final void setName(char ch) +- //{ lookupNameChar[ (int)ch / 32 ] |= (1 << (ch % 32)); } +- { lookupNameChar[ ch ] = true; } +- private static final void setNameStart(char ch) +- //{ lookupNameStartChar[ (int)ch / 32 ] |= (1 << (ch % 32)); setName(ch); } +- { lookupNameStartChar[ ch ] = true; setName(ch); } +- +- static { +- setNameStart(':'); +- for (char ch = 'A'; ch <= 'Z'; ++ch) setNameStart(ch); +- setNameStart('_'); +- for (char ch = 'a'; ch <= 'z'; ++ch) setNameStart(ch); +- for (char ch = '\u00c0'; ch <= '\u02FF'; ++ch) setNameStart(ch); +- for (char ch = '\u0370'; ch <= '\u037d'; ++ch) setNameStart(ch); +- for (char ch = '\u037f'; ch < '\u0400'; ++ch) setNameStart(ch); +- +- setName('-'); +- setName('.'); +- for (char ch = '0'; ch <= '9'; ++ch) setName(ch); +- setName('\u00b7'); +- for (char ch = '\u0300'; ch <= '\u036f'; ++ch) setName(ch); +- } +- +- //private final static boolean isNameStartChar(char ch) { +- protected boolean isNameStartChar(char ch) { +- return (ch < LOOKUP_MAX_CHAR && lookupNameStartChar[ ch ]) +- || (ch >= LOOKUP_MAX_CHAR && ch <= '\u2027') +- || (ch >= '\u202A' && ch <= '\u218F') +- || (ch >= '\u2800' && ch <= '\uFFEF') +- ; +- +- // if(ch < LOOKUP_MAX_CHAR) return lookupNameStartChar[ ch ]; +- // else return ch <= '\u2027' +- // || (ch >= '\u202A' && ch <= '\u218F') +- // || (ch >= '\u2800' && ch <= '\uFFEF') +- // ; +- //return false; +- // return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == ':' +- // || (ch >= '0' && ch <= '9'); +- // if(ch < LOOKUP_MAX_CHAR) return (lookupNameStartChar[ (int)ch / 32 ] & (1 << (ch % 32))) != 0; +- // if(ch <= '\u2027') return true; +- // //[#x202A-#x218F] +- // if(ch < '\u202A') return false; +- // if(ch <= '\u218F') return true; +- // // added pairts [#x2800-#xD7FF] | [#xE000-#xFDCF] | [#xFDE0-#xFFEF] | [#x10000-#x10FFFF] +- // if(ch < '\u2800') return false; +- // if(ch <= '\uFFEF') return true; +- // return false; +- +- +- // else return (supportXml11 && ( (ch < '\u2027') || (ch > '\u2029' && ch < '\u2200') ... +- } +- +- //private final static boolean isNameChar(char ch) { +- protected boolean isNameChar(char ch) { +- //return isNameStartChar(ch); +- +- // if(ch < LOOKUP_MAX_CHAR) return (lookupNameChar[ (int)ch / 32 ] & (1 << (ch % 32))) != 0; +- +- return (ch < LOOKUP_MAX_CHAR && lookupNameChar[ ch ]) +- || (ch >= LOOKUP_MAX_CHAR && ch <= '\u2027') +- || (ch >= '\u202A' && ch <= '\u218F') +- || (ch >= '\u2800' && ch <= '\uFFEF') +- ; +- //return false; +- // return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == ':' +- // || (ch >= '0' && ch <= '9'); +- // if(ch < LOOKUP_MAX_CHAR) return (lookupNameStartChar[ (int)ch / 32 ] & (1 << (ch % 32))) != 0; +- +- //else return +- // else if(ch <= '\u2027') return true; +- // //[#x202A-#x218F] +- // else if(ch < '\u202A') return false; +- // else if(ch <= '\u218F') return true; +- // // added pairts [#x2800-#xD7FF] | [#xE000-#xFDCF] | [#xFDE0-#xFFEF] | [#x10000-#x10FFFF] +- // else if(ch < '\u2800') return false; +- // else if(ch <= '\uFFEF') return true; +- //else return false; +- } +- +- protected boolean isS(char ch) { +- return (ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t'); +- // || (supportXml11 && (ch == '\u0085' || ch == '\u2028'); +- } +- +- //protected boolean isChar(char ch) { return (ch < '\uD800' || ch > '\uDFFF') +- // ch != '\u0000' ch < '\uFFFE' +- +- +- //protected char printable(char ch) { return ch; } +- protected String printable(char ch) { +- if(ch == '\n') { +- return "\\n"; +- } else if(ch == '\r') { +- return "\\r"; +- } else if(ch == '\t') { +- return "\\t"; +- } else if(ch == '\'') { +- return "\\'"; +- } if(ch > 127 || ch < 32) { +- return "\\u"+Integer.toHexString((int)ch); +- } +- return ""+ch; +- } +- +- protected String printable(String s) { +- if(s == null) return null; +- final int sLen = s.length(); +- StringBuffer buf = new StringBuffer(sLen + 10); +- for(int i = 0; i < sLen; ++i) { +- buf.append(printable(s.charAt(i))); +- } +- s = buf.toString(); +- return s; +- } +- +-// +-// Imported code from ASF Harmony project rev 770909 +-// http://svn.apache.org/repos/asf/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/lang/Character.java +-// +- +- private static int toCodePoint( char high, char low ) +- { +- // See RFC 2781, Section 2.2 +- // http://www.faqs.org/rfcs/rfc2781.html +- int h = ( high & 0x3FF ) << 10; +- int l = low & 0x3FF; +- return ( h | l ) + 0x10000; +- } +- +- private static final char MIN_HIGH_SURROGATE = '\uD800'; +- private static final char MAX_HIGH_SURROGATE = '\uDBFF'; +- +- private static boolean isHighSurrogate( char ch ) +- { +- return ( MIN_HIGH_SURROGATE <= ch && MAX_HIGH_SURROGATE >= ch ); +- } +- +- private static final int MIN_CODE_POINT = 0x000000; +- private static final int MAX_CODE_POINT = 0x10FFFF; +- private static final int MIN_SUPPLEMENTARY_CODE_POINT = 0x10000; +- +- private static boolean isValidCodePoint( int codePoint ) +- { +- return ( MIN_CODE_POINT <= codePoint && MAX_CODE_POINT >= codePoint ); +- } +- +- private static boolean isSupplementaryCodePoint( int codePoint ) +- { +- return ( MIN_SUPPLEMENTARY_CODE_POINT <= codePoint && MAX_CODE_POINT >= codePoint ); +- } +- +- /** +- * TODO add javadoc +- * +- * @param codePoint +- * @return +- */ +- public static char[] toChars( int codePoint ) +- { +- if ( !isValidCodePoint( codePoint ) ) +- { +- throw new IllegalArgumentException(); +- } +- +- if ( isSupplementaryCodePoint( codePoint ) ) +- { +- int cpPrime = codePoint - 0x10000; +- int high = 0xD800 | ( ( cpPrime >> 10 ) & 0x3FF ); +- int low = 0xDC00 | ( cpPrime & 0x3FF ); +- return new char[] { (char) high, (char) low }; +- } +- +- return new char[] { (char) codePoint }; +- } +-} +- +- +-/* +- * Indiana University Extreme! Lab Software License, Version 1.2 +- * +- * Copyright (C) 2003 The Trustees of Indiana University. +- * 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) All redistributions of source code must retain the above +- * copyright notice, the list of authors in the original source +- * code, this list of conditions and the disclaimer listed in this +- * license; +- * +- * 2) All redistributions in binary form must reproduce the above +- * copyright notice, this list of conditions and the disclaimer +- * listed in this license in the documentation and/or other +- * materials provided with the distribution; +- * +- * 3) Any documentation included with all redistributions must include +- * the following acknowledgement: +- * +- * "This product includes software developed by the Indiana +- * University Extreme! Lab. For further information please visit +- * http://www.extreme.indiana.edu/" +- * +- * Alternatively, this acknowledgment may appear in the software +- * itself, and wherever such third-party acknowledgments normally +- * appear. +- * +- * 4) The name "Indiana University" or "Indiana University +- * Extreme! Lab" shall not be used to endorse or promote +- * products derived from this software without prior written +- * permission from Indiana University. For written permission, +- * please contact http://www.extreme.indiana.edu/. +- * +- * 5) Products derived from this software may not use "Indiana +- * University" name nor may "Indiana University" appear in their name, +- * without prior written permission of the Indiana University. +- * +- * Indiana University provides no reassurances that the source code +- * provided does not infringe the patent or any other intellectual +- * property rights of any other entity. Indiana University disclaims any +- * liability to any recipient for claims brought by any other entity +- * based on infringement of intellectual property rights or otherwise. +- * +- * LICENSEE UNDERSTANDS THAT SOFTWARE IS PROVIDED "AS IS" FOR WHICH +- * NO WARRANTIES AS TO CAPABILITIES OR ACCURACY ARE MADE. INDIANA +- * UNIVERSITY GIVES NO WARRANTIES AND MAKES NO REPRESENTATION THAT +- * SOFTWARE IS FREE OF INFRINGEMENT OF THIRD PARTY PATENT, COPYRIGHT, OR +- * OTHER PROPRIETARY RIGHTS. INDIANA UNIVERSITY MAKES NO WARRANTIES THAT +- * SOFTWARE IS FREE FROM "BUGS", "VIRUSES", "TROJAN HORSES", "TRAP +- * DOORS", "WORMS", OR OTHER HARMFUL CODE. LICENSEE ASSUMES THE ENTIRE +- * RISK AS TO THE PERFORMANCE OF SOFTWARE AND/OR ASSOCIATED MATERIALS, +- * AND TO THE PERFORMANCE AND VALIDITY OF INFORMATION GENERATED USING +- * SOFTWARE. +- */ +- +- +- +- +- +- +diff -Nru gshell-2.6.5/gshell-util/src/main/java/org/codehaus/plexus/util/xml/pull/MXSerializer.java gshell-2.6.5-gil/gshell-util/src/main/java/org/codehaus/plexus/util/xml/pull/MXSerializer.java +--- gshell-2.6.5/gshell-util/src/main/java/org/codehaus/plexus/util/xml/pull/MXSerializer.java 2011-12-28 20:41:12.000000000 +0100 ++++ gshell-2.6.5-gil/gshell-util/src/main/java/org/codehaus/plexus/util/xml/pull/MXSerializer.java 1970-01-01 01:00:00.000000000 +0100 +@@ -1,1122 +0,0 @@ +-/* -*- c-basic-offset: 4; indent-tabs-mode: nil; -*- //------100-columns-wide------>|*/ +-// for license please see accompanying LICENSE.txt file (available also at http://www.xmlpull.org/) +- +-package org.codehaus.plexus.util.xml.pull; +- +-import java.io.IOException; +-import java.io.OutputStream; +-import java.io.OutputStreamWriter; +-import java.io.Writer; +- +-/** +- * Implementation of XmlSerializer interface from XmlPull V1 API. +- * This implementation is optimized for performance and low memory footprint. +- * +- * <p>Implemented features:<ul> +- * <li> FEATURE_NAMES_INTERNED - when enabled all returned names +- * (namespaces, prefixes) will be interned and it is required that +- * all names passed as arguments MUST be interned +- * <li> FEATURE_SERIALIZER_ATTVALUE_USE_APOSTROPHE +- * </ul> +- * <p>Implemented properties:<ul> +- * <li> PROPERTY_SERIALIZER_INDENTATION +- * <li> PROPERTY_SERIALIZER_LINE_SEPARATOR +- * </ul> +- * +- */ +-@Deprecated +-public class MXSerializer implements XmlSerializer { +- protected final static String XML_URI = "http://www.w3.org/XML/1998/namespace"; +- protected final static String XMLNS_URI = "http://www.w3.org/2000/xmlns/"; +- private static final boolean TRACE_SIZING = false; +- +- protected final String FEATURE_SERIALIZER_ATTVALUE_USE_APOSTROPHE = +- "http://xmlpull.org/v1/doc/features.html#serializer-attvalue-use-apostrophe"; +- protected final String FEATURE_NAMES_INTERNED = +- "http://xmlpull.org/v1/doc/features.html#names-interned"; +- protected final String PROPERTY_SERIALIZER_INDENTATION = +- "http://xmlpull.org/v1/doc/properties.html#serializer-indentation"; +- protected final String PROPERTY_SERIALIZER_LINE_SEPARATOR = +- "http://xmlpull.org/v1/doc/properties.html#serializer-line-separator"; +- protected final static String PROPERTY_LOCATION = +- "http://xmlpull.org/v1/doc/properties.html#location"; +- +- // properties/features +- protected boolean namesInterned; +- protected boolean attributeUseApostrophe; +- protected String indentationString = null; //" "; +- protected String lineSeparator = "\n"; +- +- protected String location; +- protected Writer out; +- +- protected int autoDeclaredPrefixes; +- +- protected int depth = 0; +- +- // element stack +- protected String elNamespace[] = new String[ 2 ]; +- protected String elName[] = new String[ elNamespace.length ]; +- protected int elNamespaceCount[] = new int[ elNamespace.length ]; +- +- //namespace stack +- protected int namespaceEnd = 0; +- protected String namespacePrefix[] = new String[ 8 ]; +- protected String namespaceUri[] = new String[ namespacePrefix.length ]; +- +- protected boolean finished; +- protected boolean pastRoot; +- protected boolean setPrefixCalled; +- protected boolean startTagIncomplete; +- +- protected boolean doIndent; +- protected boolean seenTag; +- +- protected boolean seenBracket; +- protected boolean seenBracketBracket; +- +- // buffer output if needed to write escaped String see text(String) +- private static final int BUF_LEN = Runtime.getRuntime().freeMemory() > 1000000L ? 8*1024 : 256; +- protected char buf[] = new char[ BUF_LEN ]; +- +- +- protected static final String precomputedPrefixes[]; +- +- static { +- precomputedPrefixes = new String[32]; //arbitrary number ... +- for (int i = 0; i < precomputedPrefixes.length; i++) +- { +- precomputedPrefixes[i] = ("n"+i).intern(); +- } +- } +- +- private boolean checkNamesInterned = false; +- +- private void checkInterning(String name) { +- if(namesInterned && name != name.intern()) { +- throw new IllegalArgumentException( +- "all names passed as arguments must be interned" +- +"when NAMES INTERNED feature is enabled"); +- } +- } +- +- protected void reset() { +- location = null; +- out = null; +- autoDeclaredPrefixes = 0; +- depth = 0; +- +- // nullify references on all levels to allow it to be GCed +- for (int i = 0; i < elNamespaceCount.length; i++) +- { +- elName[ i ] = null; +- elNamespace[ i ] = null; +- elNamespaceCount[ i ] = 2; +- } +- +- +- namespaceEnd = 0; +- +- +- //NOTE: no need to intern() as all literal strings and string-valued constant expressions +- //are interned. String literals are defined in 3.10.5 of the Java Language Specification +- // just checking ... +- //assert "xmlns" == "xmlns".intern(); +- //assert XMLNS_URI == XMLNS_URI.intern(); +- +- //TODO: how to prevent from reporting this namespace? +- // this is special namespace declared for consistency with XML infoset +- namespacePrefix[ namespaceEnd ] = "xmlns"; +- namespaceUri[ namespaceEnd ] = XMLNS_URI; +- ++namespaceEnd; +- +- namespacePrefix[ namespaceEnd ] = "xml"; +- namespaceUri[ namespaceEnd ] = XML_URI; +- ++namespaceEnd; +- +- finished = false; +- pastRoot = false; +- setPrefixCalled = false; +- startTagIncomplete = false; +- //doIntent is not changed +- seenTag = false; +- +- seenBracket = false; +- seenBracketBracket = false; +- } +- +- +- protected void ensureElementsCapacity() { +- final int elStackSize = elName.length; +- //assert (depth + 1) >= elName.length; +- // we add at least one extra slot ... +- final int newSize = (depth >= 7 ? 2 * depth : 8) + 2; // = lucky 7 + 1 //25 +- if(TRACE_SIZING) { +- System.err.println( +- getClass().getName()+" elStackSize "+elStackSize+" ==> "+newSize); +- } +- final boolean needsCopying = elStackSize > 0; +- String[] arr = null; +- // reuse arr local variable slot +- arr = new String[newSize]; +- if(needsCopying) System.arraycopy(elName, 0, arr, 0, elStackSize); +- elName = arr; +- arr = new String[newSize]; +- if(needsCopying) System.arraycopy(elNamespace, 0, arr, 0, elStackSize); +- elNamespace = arr; +- +- final int[] iarr = new int[newSize]; +- if(needsCopying) { +- System.arraycopy(elNamespaceCount, 0, iarr, 0, elStackSize); +- } else { +- // special initialization +- iarr[0] = 0; +- } +- elNamespaceCount = iarr; +- } +- +- protected void ensureNamespacesCapacity() { //int size) { +- //int namespaceSize = namespacePrefix != null ? namespacePrefix.length : 0; +- //assert (namespaceEnd >= namespacePrefix.length); +- +- //if(size >= namespaceSize) { +- //int newSize = size > 7 ? 2 * size : 8; // = lucky 7 + 1 //25 +- final int newSize = namespaceEnd > 7 ? 2 * namespaceEnd : 8; +- if(TRACE_SIZING) { +- System.err.println( +- getClass().getName()+" namespaceSize "+namespacePrefix.length+" ==> "+newSize); +- } +- final String[] newNamespacePrefix = new String[newSize]; +- final String[] newNamespaceUri = new String[newSize]; +- if(namespacePrefix != null) { +- System.arraycopy( +- namespacePrefix, 0, newNamespacePrefix, 0, namespaceEnd); +- System.arraycopy( +- namespaceUri, 0, newNamespaceUri, 0, namespaceEnd); +- } +- namespacePrefix = newNamespacePrefix; +- namespaceUri = newNamespaceUri; +- +- // TODO use hashes for quick namespace->prefix lookups +- // if( ! allStringsInterned ) { +- // int[] newNamespacePrefixHash = new int[newSize]; +- // if(namespacePrefixHash != null) { +- // System.arraycopy( +- // namespacePrefixHash, 0, newNamespacePrefixHash, 0, namespaceEnd); +- // } +- // namespacePrefixHash = newNamespacePrefixHash; +- // } +- //prefixesSize = newSize; +- // ////assert nsPrefixes.length > size && nsPrefixes.length == newSize +- //} +- } +- +- +- public void setFeature(String name, +- boolean state) throws IllegalArgumentException, IllegalStateException +- { +- if(name == null) { +- throw new IllegalArgumentException("feature name can not be null"); +- } +- if(FEATURE_NAMES_INTERNED.equals(name)) { +- namesInterned = state; +- } else if(FEATURE_SERIALIZER_ATTVALUE_USE_APOSTROPHE.equals(name)) { +- attributeUseApostrophe = state; +- } else { +- throw new IllegalStateException("unsupported feature "+name); +- } +- } +- +- public boolean getFeature(String name) throws IllegalArgumentException +- { +- if(name == null) { +- throw new IllegalArgumentException("feature name can not be null"); +- } +- if(FEATURE_NAMES_INTERNED.equals(name)) { +- return namesInterned; +- } else if(FEATURE_SERIALIZER_ATTVALUE_USE_APOSTROPHE.equals(name)) { +- return attributeUseApostrophe; +- } else { +- return false; +- } +- } +- +- // precomputed variables to simplify writing indentation +- protected int offsetNewLine; +- protected int indentationJump; +- protected char[] indentationBuf; +- protected int maxIndentLevel; +- protected boolean writeLineSepartor; //should end-of-line be written +- protected boolean writeIndentation; // is indentation used? +- +- /** +- * For maximum efficiency when writing indents the required output is pre-computed +- * This is internal function that recomputes buffer after user requested chnages. +- */ +- protected void rebuildIndentationBuf() { +- if(doIndent == false) return; +- final int maxIndent = 65; //hardcoded maximum indentation size in characters +- int bufSize = 0; +- offsetNewLine = 0; +- if(writeLineSepartor) { +- offsetNewLine = lineSeparator.length(); +- bufSize += offsetNewLine; +- } +- maxIndentLevel = 0; +- if(writeIndentation) { +- indentationJump = indentationString.length(); +- maxIndentLevel = maxIndent / indentationJump; +- bufSize += maxIndentLevel * indentationJump; +- } +- if(indentationBuf == null || indentationBuf.length < bufSize) { +- indentationBuf = new char[bufSize + 8]; +- } +- int bufPos = 0; +- if(writeLineSepartor) { +- for (int i = 0; i < lineSeparator.length(); i++) +- { +- indentationBuf[ bufPos++ ] = lineSeparator.charAt(i); +- } +- } +- if(writeIndentation) { +- for (int i = 0; i < maxIndentLevel; i++) +- { +- for (int j = 0; j < indentationString.length(); j++) +- { +- indentationBuf[ bufPos++ ] = indentationString.charAt(j); +- } +- } +- } +- } +- +- // if(doIndent) writeIndent(); +- protected void writeIndent() throws IOException { +- final int start = writeLineSepartor ? 0 : offsetNewLine; +- final int level = (depth > maxIndentLevel) ? maxIndentLevel : depth; +- out.write( indentationBuf, start, (level * indentationJump) + offsetNewLine); +- } +- +- public void setProperty(String name, +- Object value) throws IllegalArgumentException, IllegalStateException +- { +- if(name == null) { +- throw new IllegalArgumentException("property name can not be null"); +- } +- if(PROPERTY_SERIALIZER_INDENTATION.equals(name)) { +- indentationString = (String)value; +- } else if(PROPERTY_SERIALIZER_LINE_SEPARATOR.equals(name)) { +- lineSeparator = (String)value; +- } else if(PROPERTY_LOCATION.equals(name)) { +- location = (String) value; +- } else { +- throw new IllegalStateException("unsupported property "+name); +- } +- writeLineSepartor = lineSeparator != null && lineSeparator.length() > 0; +- writeIndentation = indentationString != null && indentationString.length() > 0; +- // optimize - do not write when nothing to write ... +- doIndent = indentationString != null && (writeLineSepartor || writeIndentation); +- //NOTE: when indentationString == null there is no indentation +- // (even though writeLineSeparator may be true ...) +- rebuildIndentationBuf(); +- seenTag = false; // for consistency +- } +- +- public Object getProperty(String name) throws IllegalArgumentException +- { +- if(name == null) { +- throw new IllegalArgumentException("property name can not be null"); +- } +- if(PROPERTY_SERIALIZER_INDENTATION.equals(name)) { +- return indentationString; +- } else if(PROPERTY_SERIALIZER_LINE_SEPARATOR.equals(name)) { +- return lineSeparator; +- } else if(PROPERTY_LOCATION.equals(name)) { +- return location; +- } else { +- return null; +- } +- } +- +- private String getLocation() { +- return location != null ? " @"+location : ""; +- } +- +- // this is special method that can be accessed directly to retrieve Writer serializer is using +- public Writer getWriter() +- { +- return out; +- } +- +- public void setOutput(Writer writer) +- { +- reset(); +- out = writer; +- } +- +- public void setOutput(OutputStream os, String encoding) throws IOException +- { +- if(os == null) throw new IllegalArgumentException("output stream can not be null"); +- reset(); +- if(encoding != null) { +- out = new OutputStreamWriter(os, encoding); +- } else { +- out = new OutputStreamWriter(os); +- } +- } +- +- public void startDocument (String encoding, Boolean standalone) throws IOException +- { +- char apos = attributeUseApostrophe ? '\'' : '"'; +- if(attributeUseApostrophe) { +- out.write("<?xml version='1.0'"); +- } else { +- out.write("<?xml version=\"1.0\""); +- } +- if(encoding != null) { +- out.write(" encoding="); +- out.write(attributeUseApostrophe ? '\'' : '"'); +- out.write(encoding); +- out.write(attributeUseApostrophe ? '\'' : '"'); +- //out.write('\''); +- } +- if(standalone != null) { +- out.write(" standalone="); +- out.write(attributeUseApostrophe ? '\'' : '"'); +- if(standalone.booleanValue()) { +- out.write("yes"); +- } else { +- out.write("no"); +- } +- out.write(attributeUseApostrophe ? '\'' : '"'); +- // if(standalone.booleanValue()) { +- // out.write(" standalone='yes'"); +- // } else { +- // out.write(" standalone='no'"); +- // } +- } +- out.write("?>"); +- if(writeLineSepartor) { +- out.write(lineSeparator); +- } +- } +- +- public void endDocument() throws IOException +- { +- // close all unclosed tag; +- while(depth > 0) { +- endTag(elNamespace[ depth ], elName[ depth ]); +- } +- if(writeLineSepartor) { +- out.write(lineSeparator); +- } +- //assert depth == 0; +- //assert startTagIncomplete == false; +- finished = pastRoot = startTagIncomplete = true; +- out.flush(); +- } +- +- public void setPrefix(String prefix, String namespace) throws IOException +- { +- if(startTagIncomplete) closeStartTag(); +- //assert prefix != null; +- //assert namespace != null; +- if (prefix == null) { +- prefix = ""; +- } +- if(!namesInterned) { +- prefix = prefix.intern(); //will throw NPE if prefix==null +- } else if(checkNamesInterned) { +- checkInterning(prefix); +- } else if(prefix == null) { +- throw new IllegalArgumentException("prefix must be not null"+getLocation()); +- } +- +- //check that prefix is not duplicated ... +- for (int i = elNamespaceCount[ depth ]; i < namespaceEnd; i++) +- { +- if(prefix == namespacePrefix[ i ]) { +- throw new IllegalStateException("duplicated prefix "+printable(prefix)+getLocation()); +- } +- } +- +- if(!namesInterned) { +- namespace = namespace.intern(); +- } else if(checkNamesInterned) { +- checkInterning(namespace); +- } else if(namespace == null) { +- throw new IllegalArgumentException("namespace must be not null"+getLocation()); +- } +- +- if(namespaceEnd >= namespacePrefix.length) { +- ensureNamespacesCapacity(); +- } +- namespacePrefix[ namespaceEnd ] = prefix; +- namespaceUri[ namespaceEnd ] = namespace; +- ++namespaceEnd; +- setPrefixCalled = true; +- } +- +- protected String lookupOrDeclarePrefix( String namespace ) { +- return getPrefix(namespace, true); +- } +- +- public String getPrefix(String namespace, boolean generatePrefix) +- { +- //assert namespace != null; +- if(!namesInterned) { +- // when String is interned we can do much faster namespace stack lookups ... +- namespace = namespace.intern(); +- } else if(checkNamesInterned) { +- checkInterning(namespace); +- //assert namespace != namespace.intern(); +- } +- if(namespace == null) { +- throw new IllegalArgumentException("namespace must be not null"+getLocation()); +- } else if(namespace.length() == 0) { +- throw new IllegalArgumentException("default namespace cannot have prefix"+getLocation()); +- } +- +- // first check if namespace is already in scope +- for (int i = namespaceEnd - 1; i >= 0 ; --i) +- { +- if(namespace == namespaceUri[ i ]) { +- final String prefix = namespacePrefix[ i ]; +- // now check that prefix is still in scope +- for (int p = namespaceEnd - 1; p > i ; --p) +- { +- if(prefix == namespacePrefix[ p ]) +- continue; // too bad - prefix is redeclared with different namespace +- } +- return prefix; +- } +- } +- +- // so not found it ... +- if(!generatePrefix) { +- return null; +- } +- return generatePrefix(namespace); +- } +- +- private String generatePrefix(String namespace) { +- //assert namespace == namespace.intern(); +- while(true) { +- ++autoDeclaredPrefixes; +- //fast lookup uses table that was pre-initialized in static{} .... +- final String prefix = autoDeclaredPrefixes < precomputedPrefixes.length +- ? precomputedPrefixes[autoDeclaredPrefixes] : ("n"+autoDeclaredPrefixes).intern(); +- // make sure this prefix is not declared in any scope (avoid hiding in-scope prefixes)! +- for (int i = namespaceEnd - 1; i >= 0 ; --i) +- { +- if(prefix == namespacePrefix[ i ]) { +- continue; // prefix is already declared - generate new and try again +- } +- } +- // declare prefix +- +- if(namespaceEnd >= namespacePrefix.length) { +- ensureNamespacesCapacity(); +- } +- namespacePrefix[ namespaceEnd ] = prefix; +- namespaceUri[ namespaceEnd ] = namespace; +- ++namespaceEnd; +- +- return prefix; +- } +- } +- +- public int getDepth() +- { +- return depth; +- } +- +- public String getNamespace () +- { +- return elNamespace[depth]; +- } +- +- public String getName() +- { +- return elName[depth]; +- } +- +- public XmlSerializer startTag (String namespace, String name) throws IOException +- { +- +- if(startTagIncomplete) { +- closeStartTag(); +- } +- seenBracket = seenBracketBracket = false; +- if(doIndent && depth > 0 && seenTag) { +- writeIndent(); +- } +- seenTag = true; +- setPrefixCalled = false; +- startTagIncomplete = true; +- ++depth; +- if( (depth + 1) >= elName.length) { +- ensureElementsCapacity(); +- } +- ////assert namespace != null; +- +- if(checkNamesInterned && namesInterned) checkInterning(namespace); +- elNamespace[ depth ] = (namesInterned || namespace == null) ? namespace : namespace.intern(); +- //assert name != null; +- //elName[ depth ] = name; +- if(checkNamesInterned && namesInterned) checkInterning(name); +- elName[ depth ] = (namesInterned || name == null) ? name : name.intern(); +- if(out == null) { +- throw new IllegalStateException("setOutput() must called set before serialization can start"); +- } +- out.write('<'); +- if(namespace != null) { +- +- if(namespace.length() > 0) { +- //ALEK: in future make it as feature on serializer +- String prefix = null; +- if(depth > 0 && (namespaceEnd - elNamespaceCount[depth-1]) == 1) { +- // if only one prefix was declared un-declare it if prefix is already declared on parent el with the same URI +- String uri = namespaceUri[namespaceEnd-1]; +- if(uri == namespace || uri.equals(namespace)) { +- String elPfx = namespacePrefix[namespaceEnd-1]; +- // 2 == to skip predefined namespaces (xml and xmlns ...) +- for(int pos = elNamespaceCount[depth-1] - 1; pos >= 2; --pos ) { +- String pf = namespacePrefix[pos]; +- if(pf == elPfx || pf.equals(elPfx)) { +- String n = namespaceUri[pos]; +- if(n == uri || n.equals(uri)) { +- --namespaceEnd; //un-declare namespace +- prefix = elPfx; +- } +- break; +- } +- } +- } +- } +- if(prefix == null) { +- prefix = lookupOrDeclarePrefix( namespace ); +- } +- //assert prefix != null; +- // make sure that default ("") namespace to not print ":" +- if(prefix.length() > 0) { +- out.write(prefix); +- out.write(':'); +- } +- } else { +- // make sure that default namespace can be declared +- for (int i = namespaceEnd - 1; i >= 0 ; --i) +- { +- if(namespacePrefix[ i ] == "") { +- final String uri = namespaceUri[ i ]; +- if(uri == null) { +- // declare default namespace +- setPrefix("", ""); +- } else if(uri.length() > 0) { +- throw new IllegalStateException( +- "start tag can not be written in empty default namespace "+ +- "as default namespace is currently bound to '"+uri+"'"+getLocation()); +- } +- break; +- } +- } +- } +- +- } +- out.write(name); +- return this; +- } +- +- public XmlSerializer attribute (String namespace, String name, +- String value) throws IOException +- { +- if(!startTagIncomplete) { +- throw new IllegalArgumentException("startTag() must be called before attribute()"+getLocation()); +- } +- //assert setPrefixCalled == false; +- out.write(' '); +- ////assert namespace != null; +- if(namespace != null && namespace.length() > 0) { +- //namespace = namespace.intern(); +- if(!namesInterned) { +- namespace = namespace.intern(); +- } else if(checkNamesInterned) { +- checkInterning(namespace); +- } +- String prefix = lookupOrDeclarePrefix( namespace ); +- //assert( prefix != null); +- if(prefix.length() == 0) { +- // needs to declare prefix to hold default namespace +- //NOTE: attributes such as a='b' are in NO namespace +- prefix = generatePrefix(namespace); +- } +- out.write(prefix); +- out.write(':'); +- // if(prefix.length() > 0) { +- // out.write(prefix); +- // out.write(':'); +- // } +- } +- //assert name != null; +- out.write(name); +- out.write('='); +- //assert value != null; +- out.write( attributeUseApostrophe ? ''' : '"'); +- writeAttributeValue(value, out); +- out.write( attributeUseApostrophe ? ''' : '"'); +- return this; +- } +- +- protected void closeStartTag() throws IOException { +- if(finished) { +- throw new IllegalArgumentException("trying to write past already finished output"+getLocation()); +- } +- if(seenBracket) { +- seenBracket = seenBracketBracket = false; +- } +- if( startTagIncomplete || setPrefixCalled ) { +- if(setPrefixCalled) { +- throw new IllegalArgumentException( +- "startTag() must be called immediately after setPrefix()"+getLocation()); +- } +- if(!startTagIncomplete) { +- throw new IllegalArgumentException("trying to close start tag that is not opened"+getLocation()); +- } +- +- // write all namespace declarations! +- writeNamespaceDeclarations(); +- out.write('>'); +- elNamespaceCount[ depth ] = namespaceEnd; +- startTagIncomplete = false; +- } +- } +- +- private void writeNamespaceDeclarations() throws IOException +- { +- //int start = elNamespaceCount[ depth - 1 ]; +- for (int i = elNamespaceCount[ depth - 1 ]; i < namespaceEnd; i++) +- { +- if(doIndent && namespaceUri[ i ].length() > 40) { +- writeIndent(); +- out.write(" "); +- } +- if(namespacePrefix[ i ] != "") { +- out.write(" xmlns:"); +- out.write(namespacePrefix[ i ]); +- out.write('='); +- } else { +- out.write(" xmlns="); +- } +- out.write( attributeUseApostrophe ? ''' : '"'); +- +- //NOTE: escaping of namespace value the same way as attributes!!!! +- writeAttributeValue(namespaceUri[ i ], out); +- +- out.write( attributeUseApostrophe ? ''' : '"'); +- } +- } +- +- public XmlSerializer endTag(String namespace, String name) throws IOException +- { +- // check that level is valid +- ////assert namespace != null; +- //if(namespace != null) { +- // namespace = namespace.intern(); +- //} +- seenBracket = seenBracketBracket = false; +- if(namespace != null) { +- if(!namesInterned) { +- namespace = namespace.intern(); +- } else if(checkNamesInterned) { +- checkInterning(namespace); +- } +- } +- +- if(namespace != elNamespace[ depth ]) +- { +- throw new IllegalArgumentException( +- "expected namespace "+printable(elNamespace[ depth ]) +- +" and not "+printable(namespace)+getLocation()); +- } +- if(name == null) { +- throw new IllegalArgumentException("end tag name can not be null"+getLocation()); +- } +- if(checkNamesInterned && namesInterned) { +- checkInterning(name); +- } +- +- if((!namesInterned && !name.equals(elName[ depth ])) +- || (namesInterned && name != elName[ depth ])) +- { +- throw new IllegalArgumentException( +- "expected element name "+printable(elName[ depth ])+" and not "+printable(name)+getLocation()); +- } +- if(startTagIncomplete) { +- writeNamespaceDeclarations(); +- out.write(" />"); //space is added to make it easier to work in XHTML!!! +- --depth; +- } else { +- --depth; +- //assert startTagIncomplete == false; +- if(doIndent && seenTag) { writeIndent(); } +- out.write("</"); +- if(namespace != null && namespace.length() > 0) { +- //TODO prefix should be alredy known from matching start tag ... +- final String prefix = lookupOrDeclarePrefix( namespace ); +- //assert( prefix != null); +- if(prefix.length() > 0) { +- out.write(prefix); +- out.write(':'); +- } +- } +- out.write(name); +- out.write('>'); +- +- } +- namespaceEnd = elNamespaceCount[ depth ]; +- startTagIncomplete = false; +- seenTag = true; +- return this; +- } +- +- public XmlSerializer text (String text) throws IOException +- { +- //assert text != null; +- if(startTagIncomplete || setPrefixCalled) closeStartTag(); +- if(doIndent && seenTag) seenTag = false; +- writeElementContent(text, out); +- return this; +- } +- +- public XmlSerializer text (char [] buf, int start, int len) throws IOException +- { +- if(startTagIncomplete || setPrefixCalled) closeStartTag(); +- if(doIndent && seenTag) seenTag = false; +- writeElementContent(buf, start, len, out); +- return this; +- } +- +- public void cdsect (String text) throws IOException +- { +- if(startTagIncomplete || setPrefixCalled || seenBracket) closeStartTag(); +- if(doIndent && seenTag) seenTag = false; +- out.write("<![CDATA["); +- out.write(text); //escape? +- out.write("]]>"); +- } +- +- public void entityRef (String text) throws IOException +- { +- if(startTagIncomplete || setPrefixCalled || seenBracket) closeStartTag(); +- if(doIndent && seenTag) seenTag = false; +- out.write('&'); +- out.write(text); //escape? +- out.write(';'); +- } +- +- public void processingInstruction (String text) throws IOException +- { +- if(startTagIncomplete || setPrefixCalled || seenBracket) closeStartTag(); +- if(doIndent && seenTag) seenTag = false; +- out.write("<?"); +- out.write(text); //escape? +- out.write("?>"); +- } +- +- public void comment (String text) throws IOException +- { +- if(startTagIncomplete || setPrefixCalled || seenBracket) closeStartTag(); +- if(doIndent && seenTag) seenTag = false; +- out.write("<!--"); +- out.write(text); //escape? +- out.write("-->"); +- } +- +- public void docdecl (String text) throws IOException +- { +- if(startTagIncomplete || setPrefixCalled || seenBracket) closeStartTag(); +- if(doIndent && seenTag) seenTag = false; +- out.write("<!DOCTYPE "); +- out.write(text); //escape? +- out.write(">"); +- } +- +- public void ignorableWhitespace (String text) throws IOException +- { +- if(startTagIncomplete || setPrefixCalled || seenBracket) closeStartTag(); +- if(doIndent && seenTag) seenTag = false; +- if(text.length() == 0) { +- throw new IllegalArgumentException( +- "empty string is not allowed for ignorable whitespace"+getLocation()); +- } +- out.write(text); //no escape? +- } +- +- public void flush () throws IOException +- { +- if(!finished && startTagIncomplete) closeStartTag(); +- out.flush(); +- } +- +- // --- utility methods +- +- protected void writeAttributeValue(String value, Writer out) throws IOException +- { +- //.[apostrophe and <, & escaped], +- final char quot = attributeUseApostrophe ? ''' : '"'; +- final String quotEntity = attributeUseApostrophe ? "'" : """; +- +- int pos = 0; +- for (int i = 0; i < value.length(); i++) +- { +- char ch = value.charAt(i); +- if(ch == '&') { +- if(i > pos) out.write(value.substring(pos, i)); +- out.write("&"); +- pos = i + 1; +- } if(ch == '<') { +- if(i > pos) out.write(value.substring(pos, i)); +- out.write("<"); +- pos = i + 1; +- }else if(ch == quot) { +- if(i > pos) out.write(value.substring(pos, i)); +- out.write(quotEntity); +- pos = i + 1; +- } else if(ch < 32) { +- //in XML 1.0 only legal character are #x9 | #xA | #xD +- // and they must be escaped otherwise in attribute value they are normalized to spaces +- if(ch == 13 || ch == 10 || ch == 9) { +- if(i > pos) out.write(value.substring(pos, i)); +- out.write("&#"); +- out.write(Integer.toString(ch)); +- out.write(';'); +- pos = i + 1; +- } else { +- throw new IllegalStateException( +- "character "+Integer.toString(ch)+" is not allowed in output"+getLocation()); +- // in XML 1.1 legal are [#x1-#xD7FF] +- // if(ch > 0) { +- // if(i > pos) out.write(text.substring(pos, i)); +- // out.write("&#"); +- // out.write(Integer.toString(ch)); +- // out.write(';'); +- // pos = i + 1; +- // } else { +- // throw new IllegalStateException( +- // "character zero is not allowed in XML 1.1 output"+getLocation()); +- // } +- } +- } +- } +- if(pos > 0) { +- out.write(value.substring(pos)); +- } else { +- out.write(value); // this is shortcut to the most common case +- } +- +- } +- +- protected void writeElementContent(String text, Writer out) throws IOException +- { +- // escape '<', '&', ']]>', <32 if necessary +- int pos = 0; +- for (int i = 0; i < text.length(); i++) +- { +- //TODO: check if doing char[] text.getChars() would be faster than getCharAt(i) ... +- char ch = text.charAt(i); +- if(ch == ']') { +- if(seenBracket) { +- seenBracketBracket = true; +- } else { +- seenBracket = true; +- } +- } else { +- if(ch == '&') { +- if(i > pos) out.write(text.substring(pos, i)); +- out.write("&"); +- pos = i + 1; +- } else if(ch == '<') { +- if(i > pos) out.write(text.substring(pos, i)); +- out.write("<"); +- pos = i + 1; +- } else if(seenBracketBracket && ch == '>') { +- if(i > pos) out.write(text.substring(pos, i)); +- out.write(">"); +- pos = i + 1; +- } else if(ch < 32) { +- //in XML 1.0 only legal character are #x9 | #xA | #xD +- if( ch == 9 || ch == 10 || ch == 13) { +- // pass through +- +- // } else if(ch == 13) { //escape +- // if(i > pos) out.write(text.substring(pos, i)); +- // out.write("&#"); +- // out.write(Integer.toString(ch)); +- // out.write(';'); +- // pos = i + 1; +- } else { +- throw new IllegalStateException( +- "character "+Integer.toString(ch)+" is not allowed in output"+getLocation()); +- // in XML 1.1 legal are [#x1-#xD7FF] +- // if(ch > 0) { +- // if(i > pos) out.write(text.substring(pos, i)); +- // out.write("&#"); +- // out.write(Integer.toString(ch)); +- // out.write(';'); +- // pos = i + 1; +- // } else { +- // throw new IllegalStateException( +- // "character zero is not allowed in XML 1.1 output"+getLocation()); +- // } +- } +- } +- if(seenBracket) { +- seenBracketBracket = seenBracket = false; +- } +- +- } +- } +- if(pos > 0) { +- out.write(text.substring(pos)); +- } else { +- out.write(text); // this is shortcut to the most common case +- } +- +- +- +- } +- +- protected void writeElementContent(char[] buf, int off, int len, Writer out) throws IOException +- { +- // escape '<', '&', ']]>' +- final int end = off + len; +- int pos = off; +- for (int i = off; i < end; i++) +- { +- final char ch = buf[i]; +- if(ch == ']') { +- if(seenBracket) { +- seenBracketBracket = true; +- } else { +- seenBracket = true; +- } +- } else { +- if(ch == '&') { +- if(i > pos) { +- out.write(buf, pos, i - pos); +- } +- out.write("&"); +- pos = i + 1; +- } else if(ch == '<') { +- if(i > pos) { +- out.write(buf, pos, i - pos); +- } +- out.write("<"); +- pos = i + 1; +- +- } else if(seenBracketBracket && ch == '>') { +- if(i > pos) { +- out.write(buf, pos, i - pos); +- } +- out.write(">"); +- pos = i + 1; +- } else if(ch < 32) { +- //in XML 1.0 only legal character are #x9 | #xA | #xD +- if( ch == 9 || ch == 10 || ch == 13) { +- // pass through +- +- +- // } else if(ch == 13 ) { //if(ch == '\r') { +- // if(i > pos) { +- // out.write(buf, pos, i - pos); +- // } +- // out.write("&#"); +- // out.write(Integer.toString(ch)); +- // out.write(';'); +- // pos = i + 1; +- } else { +- throw new IllegalStateException( +- "character "+Integer.toString(ch)+" is not allowed in output"+getLocation()); +- // in XML 1.1 legal are [#x1-#xD7FF] +- // if(ch > 0) { +- // if(i > pos) out.write(text.substring(pos, i)); +- // out.write("&#"); +- // out.write(Integer.toString(ch)); +- // out.write(';'); +- // pos = i + 1; +- // } else { +- // throw new IllegalStateException( +- // "character zero is not allowed in XML 1.1 output"+getLocation()); +- // } +- } +- } +- if(seenBracket) { +- seenBracketBracket = seenBracket = false; +- } +- // assert seenBracketBracket == seenBracket == false; +- } +- } +- if(end > pos) { +- out.write(buf, pos, end - pos); +- } +- } +- +- /** simple utility method -- good for debugging */ +- protected static final String printable(String s) { +- if(s == null) return "null"; +- StringBuffer retval = new StringBuffer(s.length() + 16); +- retval.append("'"); +- char ch; +- for (int i = 0; i < s.length(); i++) { +- addPrintable(retval, s.charAt(i)); +- } +- retval.append("'"); +- return retval.toString(); +- } +- +- protected static final String printable(char ch) { +- StringBuffer retval = new StringBuffer(); +- addPrintable(retval, ch); +- return retval.toString(); +- } +- +- private static void addPrintable(StringBuffer retval, char ch) +- { +- switch (ch) +- { +- case '\b': +- retval.append("\b"); +- break; +- case '\t': +- retval.append("\t"); +- break; +- case '\n': +- retval.append("\n"); +- break; +- case '\f': +- retval.append("\f"); +- break; +- case '\r': +- retval.append("\r"); +- break; +- case '"': +- retval.append("\""); +- break; +- case ''': +- retval.append("\'"); +- break; +- case '\': +- retval.append("\\"); +- break; +- default: +- if (ch < 0x20 || ch > 0x7e) { +- final String ss = "0000" + Integer.toString(ch, 16); +- retval.append("\u" + ss.substring(ss.length() - 4, ss.length())); +- } else { +- retval.append(ch); +- } +- } +- } +- +-} +- +- +diff -Nru gshell-2.6.5/gshell-util/src/main/java/org/codehaus/plexus/util/xml/pull/XmlPullParserException.java gshell-2.6.5-gil/gshell-util/src/main/java/org/codehaus/plexus/util/xml/pull/XmlPullParserException.java +--- gshell-2.6.5/gshell-util/src/main/java/org/codehaus/plexus/util/xml/pull/XmlPullParserException.java 2011-12-28 20:41:12.000000000 +0100 ++++ gshell-2.6.5-gil/gshell-util/src/main/java/org/codehaus/plexus/util/xml/pull/XmlPullParserException.java 1970-01-01 01:00:00.000000000 +0100 +@@ -1,84 +0,0 @@ +-/* -*- c-basic-offset: 4; indent-tabs-mode: nil; -*- //------100-columns-wide------>|*/ +-// for license please see accompanying LICENSE.txt file (available also at http://www.xmlpull.org/) +- +-package org.codehaus.plexus.util.xml.pull; +- +-/** +- * This exception is thrown to signal XML Pull Parser related faults. +- * +- * @author <a href="http://www.extreme.indiana.edu/~aslom/">Aleksander Slominski</a> +- */ +-@Deprecated +-public class XmlPullParserException extends Exception { +- /** +- * @deprecated use generic getCause() method +- */ +- protected Throwable detail; +- protected int row = -1; +- protected int column = -1; +- +- /* public XmlPullParserException() { +- }*/ +- +- public XmlPullParserException(String s) { +- super(s); +- } +- +- /* +- public XmlPullParserException(String s, Throwable thrwble) { +- super(s); +- this.detail = thrwble; +- } +- +- public XmlPullParserException(String s, int row, int column) { +- super(s); +- this.row = row; +- this.column = column; +- } +- */ +- +- public XmlPullParserException(String msg, XmlPullParser parser, Throwable chain) { +- super ((msg == null ? "" : msg+" ") +- + (parser == null ? "" : "(position:"+parser.getPositionDescription()+") ") +- + (chain == null ? "" : "caused by: "+chain), chain); +- +- if (parser != null) { +- this.row = parser.getLineNumber(); +- this.column = parser.getColumnNumber(); +- } +- this.detail = chain; +- } +- +- /** +- * @deprecated Use the generic <code>getCause()</code> method +- * @return +- */ +- public Throwable getDetail() { return getCause(); } +- // public void setDetail(Throwable cause) { this.detail = cause; } +- public int getLineNumber() { return row; } +- public int getColumnNumber() { return column; } +- +- /* +- public String getMessage() { +- if(detail == null) +- return super.getMessage(); +- else +- return super.getMessage() + "; nested exception is: \n\t" +- + detail.getMessage(); +- } +- */ +- +- //NOTE: code that prints this and detail is difficult in J2ME +- public void printStackTrace() { +- if (getCause() == null) { +- super.printStackTrace(); +- } else { +- synchronized(System.err) { +- System.err.println(super.getMessage() + "; nested exception is:"); +- getCause().printStackTrace(); +- } +- } +- } +- +-} +- +diff -Nru gshell-2.6.5/gshell-util/src/main/java/org/codehaus/plexus/util/xml/pull/XmlPullParser.java gshell-2.6.5-gil/gshell-util/src/main/java/org/codehaus/plexus/util/xml/pull/XmlPullParser.java +--- gshell-2.6.5/gshell-util/src/main/java/org/codehaus/plexus/util/xml/pull/XmlPullParser.java 2011-12-28 20:41:12.000000000 +0100 ++++ gshell-2.6.5-gil/gshell-util/src/main/java/org/codehaus/plexus/util/xml/pull/XmlPullParser.java 1970-01-01 01:00:00.000000000 +0100 +@@ -1,1115 +0,0 @@ +-/* -*- c-basic-offset: 4; indent-tabs-mode: nil; -*- //------100-columns-wide------>|*/ +-// for license please see accompanying LICENSE.txt file (available also at http://www.xmlpull.org/) +- +-package org.codehaus.plexus.util.xml.pull; +- +-import java.io.InputStream; +-import java.io.IOException; +-import java.io.Reader; +- +-/** +- * XML Pull Parser is an interface that defines parsing functionality provided +- * in <a href="http://www.xmlpull.org/">XMLPULL V1 API</a> (visit this website to +- * learn more about API and its implementations). +- * +- * <p>There are following different +- * kinds of parser depending on which features are set:<ul> +- * <li><b>non-validating</b> parser as defined in XML 1.0 spec when +- * FEATURE_PROCESS_DOCDECL is set to true +- * <li><b>validating parser</b> as defined in XML 1.0 spec when +- * FEATURE_VALIDATION is true (and that implies that FEATURE_PROCESS_DOCDECL is true) +- * <li>when FEATURE_PROCESS_DOCDECL is false (this is default and +- * if different value is required necessary must be changed before parsing is started) +- * then parser behaves like XML 1.0 compliant non-validating parser under condition that +- * <em>no DOCDECL is present</em> in XML documents +- * (internal entities can still be defined with defineEntityReplacementText()). +- * This mode of operation is intended <b>for operation in constrained environments</b> such as J2ME. +- * </ul> +- * +- * +- * <p>There are two key methods: next() and nextToken(). While next() provides +- * access to high level parsing events, nextToken() allows access to lower +- * level tokens. +- * +- * <p>The current event state of the parser +- * can be determined by calling the +- * <a href="#getEventType()">getEventType()</a> method. +- * Initially, the parser is in the <a href="#START_DOCUMENT">START_DOCUMENT</a> +- * state. +- * +- * <p>The method <a href="#next()">next()</a> advances the parser to the +- * next event. The int value returned from next determines the current parser +- * state and is identical to the value returned from following calls to +- * getEventType (). +- * +- * <p>The following event types are seen by next()<dl> +- * <dt><a href="#START_TAG">START_TAG</a><dd> An XML start tag was read. +- * <dt><a href="#TEXT">TEXT</a><dd> Text content was read; +- * the text content can be retrieved using the getText() method. +- * (when in validating mode next() will not report ignorable whitespaces, use nextToken() instead) +- * <dt><a href="#END_TAG">END_TAG</a><dd> An end tag was read +- * <dt><a href="#END_DOCUMENT">END_DOCUMENT</a><dd> No more events are available +- * </dl> +- * +- * <p>after first next() or nextToken() (or any other next*() method) +- * is called user application can obtain +- * XML version, standalone and encoding from XML declaration +- * in following ways:<ul> +- * <li><b>version</b>: +- * getProperty("<a href="http://xmlpull.org/v1/doc/properties.html#xmldecl-version">http://xmlpull.org/v1/doc/properties.html#xmldecl-version</a>") +- * returns String ("1.0") or null if XMLDecl was not read or if property is not supported +- * <li><b>standalone</b>: +- * getProperty("<a href="http://xmlpull.org/v1/doc/features.html#xmldecl-standalone">http://xmlpull.org/v1/doc/features.html#xmldecl-standalone</a>") +- * returns Boolean: null if there was no standalone declaration +- * or if property is not supported +- * otherwise returns Boolean(true) if standalone="yes" and Boolean(false) when standalone="no" +- * <li><b>encoding</b>: obtained from getInputEncoding() +- * null if stream had unknown encoding (not set in setInputStream) +- * and it was not declared in XMLDecl +- * </ul> +- * +- * A minimal example for using this API may look as follows: +- * <pre> +- * import java.io.IOException; +- * import java.io.StringReader; +- * +- * import org.xmlpull.v1.XmlPullParser; +- * import org.xmlpull.v1.<a href="XmlPullParserException.html">XmlPullParserException.html</a>; +- * import org.xmlpull.v1.<a href="XmlPullParserFactory.html">XmlPullParserFactory</a>; +- * +- * public class SimpleXmlPullApp +- * { +- * +- * public static void main (String args[]) +- * throws XmlPullParserException, IOException +- * { +- * XmlPullParserFactory factory = XmlPullParserFactory.newInstance(); +- * factory.setNamespaceAware(true); +- * XmlPullParser xpp = factory.newPullParser(); +- * +- * xpp.<a href="#setInput">setInput</a>( new StringReader ( "<foo>Hello World!</foo>" ) ); +- * int eventType = xpp.getEventType(); +- * while (eventType != xpp.END_DOCUMENT) { +- * if(eventType == xpp.START_DOCUMENT) { +- * System.out.println("Start document"); +- * } else if(eventType == xpp.END_DOCUMENT) { +- * System.out.println("End document"); +- * } else if(eventType == xpp.START_TAG) { +- * System.out.println("Start tag "+xpp.<a href="#getName()">getName()</a>); +- * } else if(eventType == xpp.END_TAG) { +- * System.out.println("End tag "+xpp.getName()); +- * } else if(eventType == xpp.TEXT) { +- * System.out.println("Text "+xpp.<a href="#getText()">getText()</a>); +- * } +- * eventType = xpp.next(); +- * } +- * } +- * } +- * </pre> +- * +- * <p>The above example will generate the following output: +- * <pre> +- * Start document +- * Start tag foo +- * Text Hello World! +- * End tag foo +- * </pre> +- * +- * <p>For more details on API usage, please refer to the +- * quick Introduction available at <a href="http://www.xmlpull.org">http://www.xmlpull.org</a> +- * +- * @see #defineEntityReplacementText +- * @see #getName +- * @see #getNamespace +- * @see #getText +- * @see #next +- * @see #nextToken +- * @see #setInput +- * @see #FEATURE_PROCESS_DOCDECL +- * @see #FEATURE_VALIDATION +- * @see #START_DOCUMENT +- * @see #START_TAG +- * @see #TEXT +- * @see #END_TAG +- * @see #END_DOCUMENT +- * +- * @author <a href="http://www-ai.cs.uni-dortmund.de/PERSONAL/haustein.html">Stefan Haustein</a> +- * @author <a href="http://www.extreme.indiana.edu/~aslom/">Aleksander Slominski</a> +- */ +-@Deprecated +-public interface XmlPullParser { +- +- /** This constant represents the default namespace (empty string "") */ +- String NO_NAMESPACE = ""; +- +- // ---------------------------------------------------------------------------- +- // EVENT TYPES as reported by next() +- +- /** +- * Signalize that parser is at the very beginning of the document +- * and nothing was read yet. +- * This event type can only be observed by calling getEvent() +- * before the first call to next(), nextToken, or nextTag()</a>). +- * +- * @see #next +- * @see #nextToken +- */ +- int START_DOCUMENT = 0; +- +- /** +- * Logical end of the xml document. Returned from getEventType, next() +- * and nextToken() +- * when the end of the input document has been reached. +- * <p><strong>NOTE:</strong> calling again +- * <a href="#next()">next()</a> or <a href="#nextToken()">nextToken()</a> +- * will result in exception being thrown. +- * +- * @see #next +- * @see #nextToken +- */ +- int END_DOCUMENT = 1; +- +- /** +- * Returned from getEventType(), +- * <a href="#next()">next()</a>, <a href="#nextToken()">nextToken()</a> when +- * a start tag was read. +- * The name of start tag is available from getName(), its namespace and prefix are +- * available from getNamespace() and getPrefix() +- * if <a href='#FEATURE_PROCESS_NAMESPACES'>namespaces are enabled</a>. +- * See getAttribute* methods to retrieve element attributes. +- * See getNamespace* methods to retrieve newly declared namespaces. +- * +- * @see #next +- * @see #nextToken +- * @see #getName +- * @see #getPrefix +- * @see #getNamespace +- * @see #getAttributeCount +- * @see #getDepth +- * @see #getNamespaceCount +- * @see #getNamespace +- * @see #FEATURE_PROCESS_NAMESPACES +- */ +- int START_TAG = 2; +- +- /** +- * Returned from getEventType(), <a href="#next()">next()</a>, or +- * <a href="#nextToken()">nextToken()</a> when an end tag was read. +- * The name of start tag is available from getName(), its +- * namespace and prefix are +- * available from getNamespace() and getPrefix(). +- * +- * @see #next +- * @see #nextToken +- * @see #getName +- * @see #getPrefix +- * @see #getNamespace +- * @see #FEATURE_PROCESS_NAMESPACES +- */ +- int END_TAG = 3; +- +- +- /** +- * Character data was read and will is available by calling getText(). +- * <p><strong>Please note:</strong> <a href="#next()">next()</a> will +- * accumulate multiple +- * events into one TEXT event, skipping IGNORABLE_WHITESPACE, +- * PROCESSING_INSTRUCTION and COMMENT events, +- * In contrast, <a href="#nextToken()">nextToken()</a> will stop reading +- * text when any other event is observed. +- * Also, when the state was reached by calling next(), the text value will +- * be normalized, whereas getText() will +- * return unnormalized content in the case of nextToken(). This allows +- * an exact roundtrip without changing line ends when examining low +- * level events, whereas for high level applications the text is +- * normalized appropriately. +- * +- * @see #next +- * @see #nextToken +- * @see #getText +- */ +- int TEXT = 4; +- +- // ---------------------------------------------------------------------------- +- // additional events exposed by lower level nextToken() +- +- /** +- * A CDATA sections was just read; +- * this token is available only from calls to <a href="#nextToken()">nextToken()</a>. +- * A call to next() will accumulate various text events into a single event +- * of type TEXT. The text contained in the CDATA section is available +- * by calling getText(). +- * +- * @see #nextToken +- * @see #getText +- */ +- int CDSECT = 5; +- +- /** +- * An entity reference was just read; +- * this token is available from <a href="#nextToken()">nextToken()</a> +- * only. The entity name is available by calling getName(). If available, +- * the replacement text can be obtained by calling getTextt(); otherwise, +- * the user is responsible for resolving the entity reference. +- * This event type is never returned from next(); next() will +- * accumulate the replacement text and other text +- * events to a single TEXT event. +- * +- * @see #nextToken +- * @see #getText +- */ +- int ENTITY_REF = 6; +- +- /** +- * Ignorable whitespace was just read. +- * This token is available only from <a href="#nextToken()">nextToken()</a>). +- * For non-validating +- * parsers, this event is only reported by nextToken() when outside +- * the root element. +- * Validating parsers may be able to detect ignorable whitespace at +- * other locations. +- * The ignorable whitespace string is available by calling getText() +- * +- * <p><strong>NOTE:</strong> this is different from calling the +- * isWhitespace() method, since text content +- * may be whitespace but not ignorable. +- * +- * Ignorable whitespace is skipped by next() automatically; this event +- * type is never returned from next(). +- * +- * @see #nextToken +- * @see #getText +- */ +- int IGNORABLE_WHITESPACE = 7; +- +- /** +- * An XML processing instruction declaration was just read. This +- * event type is available only via <a href="#nextToken()">nextToken()</a>. +- * getText() will return text that is inside the processing instruction. +- * Calls to next() will skip processing instructions automatically. +- * @see #nextToken +- * @see #getText +- */ +- int PROCESSING_INSTRUCTION = 8; +- +- /** +- * An XML comment was just read. This event type is this token is +- * available via <a href="#nextToken()">nextToken()</a> only; +- * calls to next() will skip comments automatically. +- * The content of the comment can be accessed using the getText() +- * method. +- * +- * @see #nextToken +- * @see #getText +- */ +- int COMMENT = 9; +- +- /** +- * An XML document type declaration was just read. This token is +- * available from <a href="#nextToken()">nextToken()</a> only. +- * The unparsed text inside the doctype is available via +- * the getText() method. +- * +- * @see #nextToken +- * @see #getText +- */ +- int DOCDECL = 10; +- +- /** +- * This array can be used to convert the event type integer constants +- * such as START_TAG or TEXT to +- * to a string. For example, the value of TYPES[START_TAG] is +- * the string "START_TAG". +- * +- * This array is intended for diagnostic output only. Relying +- * on the contents of the array may be dangerous since malicious +- * applications may alter the array, although it is final, due +- * to limitations of the Java language. +- */ +- String [] TYPES = { +- "START_DOCUMENT", +- "END_DOCUMENT", +- "START_TAG", +- "END_TAG", +- "TEXT", +- "CDSECT", +- "ENTITY_REF", +- "IGNORABLE_WHITESPACE", +- "PROCESSING_INSTRUCTION", +- "COMMENT", +- "DOCDECL" +- }; +- +- +- // ---------------------------------------------------------------------------- +- // namespace related features +- +- /** +- * This feature determines whether the parser processes +- * namespaces. As for all features, the default value is false. +- * <p><strong>NOTE:</strong> The value can not be changed during +- * parsing an must be set before parsing. +- * +- * @see #getFeature +- * @see #setFeature +- */ +- String FEATURE_PROCESS_NAMESPACES = +- "http://xmlpull.org/v1/doc/features.html#process-namespaces"; +- +- /** +- * This feature determines whether namespace attributes are +- * exposed via the attribute access methods. Like all features, +- * the default value is false. This feature cannot be changed +- * during parsing. +- * +- * @see #getFeature +- * @see #setFeature +- */ +- String FEATURE_REPORT_NAMESPACE_ATTRIBUTES = +- "http://xmlpull.org/v1/doc/features.html#report-namespace-prefixes"; +- +- /** +- * This feature determines whether the document declaration +- * is processed. If set to false, +- * the DOCDECL event type is reported by nextToken() +- * and ignored by next(). +- * +- * If this featue is activated, then the document declaration +- * must be processed by the parser. +- * +- * <p><strong>Please note:</strong> If the document type declaration +- * was ignored, entity references may cause exceptions +- * later in the parsing process. +- * The default value of this feature is false. It cannot be changed +- * during parsing. +- * +- * @see #getFeature +- * @see #setFeature +- */ +- String FEATURE_PROCESS_DOCDECL = +- "http://xmlpull.org/v1/doc/features.html#process-docdecl"; +- +- /** +- * If this feature is activated, all validation errors as +- * defined in the XML 1.0 sepcification are reported. +- * This implies that FEATURE_PROCESS_DOCDECL is true and both, the +- * internal and external document type declaration will be processed. +- * <p><strong>Please Note:</strong> This feature can not be changed +- * during parsing. The default value is false. +- * +- * @see #getFeature +- * @see #setFeature +- */ +- String FEATURE_VALIDATION = +- "http://xmlpull.org/v1/doc/features.html#validation"; +- +- /** +- * Use this call to change the general behaviour of the parser, +- * such as namespace processing or doctype declaration handling. +- * This method must be called before the first call to next or +- * nextToken. Otherwise, an exception is thrown. +- * <p>Example: call setFeature(FEATURE_PROCESS_NAMESPACES, true) in order +- * to switch on namespace processing. The initial settings correspond +- * to the properties requested from the XML Pull Parser factory. +- * If none were requested, all feautures are deactivated by default. +- * +- * @exception XmlPullParserException If the feature is not supported or can not be set +- * @exception IllegalArgumentException If string with the feature name is null +- */ +- void setFeature(String name, +- boolean state) throws XmlPullParserException; +- +- /** +- * Returns the current value of the given feature. +- * <p><strong>Please note:</strong> unknown features are +- * <strong>always</strong> returned as false. +- * +- * @param name The name of feature to be retrieved. +- * @return The value of the feature. +- * @exception IllegalArgumentException if string the feature name is null +- */ +- +- boolean getFeature(String name); +- +- /** +- * Set the value of a property. +- * +- * The property name is any fully-qualified URI. +- * +- * @exception XmlPullParserException If the property is not supported or can not be set +- * @exception IllegalArgumentException If string with the property name is null +- */ +- void setProperty(String name, +- Object value) throws XmlPullParserException; +- +- /** +- * Look up the value of a property. +- * +- * The property name is any fully-qualified URI. +- * <p><strong>NOTE:</strong> unknown properties are <strong>always</strong> +- * returned as null. +- * +- * @param name The name of property to be retrieved. +- * @return The value of named property. +- */ +- Object getProperty(String name); +- +- +- /** +- * Set the input source for parser to the given reader and +- * resets the parser. The event type is set to the initial value +- * START_DOCUMENT. +- * Setting the reader to null will just stop parsing and +- * reset parser state, +- * allowing the parser to free internal resources +- * such as parsing buffers. +- */ +- void setInput(Reader in) throws XmlPullParserException; +- +- +- /** +- * Sets the input stream the parser is going to process. +- * This call resets the parser state and sets the event type +- * to the initial value START_DOCUMENT. +- * +- * <p><strong>NOTE:</strong> If an input encoding string is passed, +- * it MUST be used. Otherwise, +- * if inputEncoding is null, the parser SHOULD try to determine +- * input encoding following XML 1.0 specification (see below). +- * If encoding detection is supported then following feature +- * <a href="http://xmlpull.org/v1/doc/features.html#detect-encoding">http://xmlpull.org/v1/doc/features.html#detect-encoding</a> +- * MUST be true amd otherwise it must be false +- * +- * @param inputStream contains a raw byte input stream of possibly +- * unknown encoding (when inputEncoding is null). +- * +- * @param inputEncoding if not null it MUST be used as encoding for inputStream +- */ +- void setInput(InputStream inputStream, String inputEncoding) +- throws XmlPullParserException; +- +- /** +- * Returns the input encoding if known, null otherwise. +- * If setInput(InputStream, inputEncoding) was called with an inputEncoding +- * value other than null, this value must be returned +- * from this method. Otherwise, if inputEncoding is null and +- * the parser suppports the encoding detection feature +- * (http://xmlpull.org/v1/doc/features.html#detect-encoding), +- * it must return the detected encoding. +- * If setInput(Reader) was called, null is returned. +- * After first call to next if XML declaration was present this method +- * will return encoding declared. +- */ +- String getInputEncoding(); +- +- /** +- * Set new value for entity replacement text as defined in +- * <a href="http://www.w3.org/TR/REC-xml#intern-replacement">XML 1.0 Section 4.5 +- * Construction of Internal Entity Replacement Text</a>. +- * If FEATURE_PROCESS_DOCDECL or FEATURE_VALIDATION are set, calling this +- * function will result in an exception -- when processing of DOCDECL is +- * enabled, there is no need to the entity replacement text manually. +- * +- * <p>The motivation for this function is to allow very small +- * implementations of XMLPULL that will work in J2ME environments. +- * Though these implementations may not be able to process the document type +- * declaration, they still can work with known DTDs by using this function. +- * +- * <p><b>Please notes:</b> The given value is used literally as replacement text +- * and it corresponds to declaring entity in DTD that has all special characters +- * escaped: left angle bracket is replaced with &lt;, ampersnad with &amp; +- * and so on. +- * +- * <p><b>Note:</b> The given value is the literal replacement text and must not +- * contain any other entity reference (if it contains any entity reference +- * there will be no further replacement). +- * +- * <p><b>Note:</b> The list of pre-defined entity names will +- * always contain standard XML entities such as +- * amp (&amp;), lt (&lt;), gt (&gt;), quot (&quot;), and apos (&apos;). +- * Those cannot be redefined by this method! +- * +- * @see #setInput +- * @see #FEATURE_PROCESS_DOCDECL +- * @see #FEATURE_VALIDATION +- */ +- void defineEntityReplacementText( String entityName, +- String replacementText ) throws XmlPullParserException; +- +- /** +- * Returns the numbers of elements in the namespace stack for the given +- * depth. +- * If namespaces are not enabled, 0 is returned. +- * +- * <p><b>NOTE:</b> when parser is on END_TAG then it is allowed to call +- * this function with getDepth()+1 argument to retrieve position of namespace +- * prefixes and URIs that were declared on corresponding START_TAG. +- * <p><b>NOTE:</b> to retrieve lsit of namespaces declared in current element:<pre> +- * XmlPullParser pp = ... +- * int nsStart = pp.getNamespaceCount(pp.getDepth()-1); +- * int nsEnd = pp.getNamespaceCount(pp.getDepth()); +- * for (int i = nsStart; i < nsEnd; i++) { +- * String prefix = pp.getNamespacePrefix(i); +- * String ns = pp.getNamespaceUri(i); +- * // ... +- * } +- * </pre> +- * +- * @see #getNamespacePrefix +- * @see #getNamespaceUri +- * @see #getNamespace() +- * @see #getNamespace(String) +- */ +- int getNamespaceCount(int depth) throws XmlPullParserException; +- +- /** +- * Returns the namespace prefixe for the given position +- * in the namespace stack. +- * Default namespace declaration (xmlns='...') will have null as prefix. +- * If the given index is out of range, an exception is thrown. +- * <p><b>Please note:</b> when the parser is on an END_TAG, +- * namespace prefixes that were declared +- * in the corresponding START_TAG are still accessible +- * although they are no longer in scope. +- */ +- String getNamespacePrefix(int pos) throws XmlPullParserException; +- +- /** +- * Returns the namespace URI for the given position in the +- * namespace stack +- * If the position is out of range, an exception is thrown. +- * <p><b>NOTE:</b> when parser is on END_TAG then namespace prefixes that were declared +- * in corresponding START_TAG are still accessible even though they are not in scope +- */ +- String getNamespaceUri(int pos) throws XmlPullParserException; +- +- /** +- * Returns the URI corresponding to the given prefix, +- * depending on current state of the parser. +- * +- * <p>If the prefix was not declared in the current scope, +- * null is returned. The default namespace is included +- * in the namespace table and is available via +- * getNamespace (null). +- * +- * <p>This method is a convenience method for +- * +- * <pre> +- * for (int i = getNamespaceCount(getDepth ())-1; i >= 0; i--) { +- * if (getNamespacePrefix(i).equals( prefix )) { +- * return getNamespaceUri(i); +- * } +- * } +- * return null; +- * </pre> +- * +- * <p><strong>Please note:</strong> parser implementations +- * may provide more efifcient lookup, e.g. using a Hashtable. +- * The 'xml' prefix is bound to "http://www.w3.org/XML/1998/namespace", as +- * defined in the +- * <a href="http://www.w3.org/TR/REC-xml-names/#ns-using">Namespaces in XML</a> +- * specification. Analogous, the 'xmlns' prefix is resolved to +- * <a href="http://www.w3.org/2000/xmlns/">http://www.w3.org/2000/xmlns/</a> +- * +- * @see #getNamespaceCount +- * @see #getNamespacePrefix +- * @see #getNamespaceUri +- */ +- String getNamespace (String prefix); +- +- +- // -------------------------------------------------------------------------- +- // miscellaneous reporting methods +- +- /** +- * Returns the current depth of the element. +- * Outside the root element, the depth is 0. The +- * depth is incremented by 1 when a start tag is reached. +- * The depth is decremented AFTER the end tag +- * event was observed. +- * +- * <pre> +- * <!-- outside --> 0 +- * <root> 1 +- * sometext 1 +- * <foobar> 2 +- * </foobar> 2 +- * </root> 1 +- * <!-- outside --> 0 +- * </pre> +- */ +- int getDepth(); +- +- /** +- * Returns a short text describing the current parser state, including +- * the position, a +- * description of the current event and the data source if known. +- * This method is especially useful to provide meaningful +- * error messages and for debugging purposes. +- */ +- String getPositionDescription (); +- +- +- /** +- * Returns the current line number, starting from 1. +- * When the parser does not know the current line number +- * or can not determine it, -1 is returned (e.g. for WBXML). +- * +- * @return current line number or -1 if unknown. +- */ +- int getLineNumber(); +- +- /** +- * Returns the current column number, starting from 0. +- * When the parser does not know the current column number +- * or can not determine it, -1 is returned (e.g. for WBXML). +- * +- * @return current column number or -1 if unknown. +- */ +- int getColumnNumber(); +- +- +- // -------------------------------------------------------------------------- +- // TEXT related methods +- +- /** +- * Checks whether the current TEXT event contains only whitespace +- * characters. +- * For IGNORABLE_WHITESPACE, this is always true. +- * For TEXT and CDSECT, false is returned when the current event text +- * contains at least one non-white space character. For any other +- * event type an exception is thrown. +- * +- * <p><b>Please note:</b> non-validating parsers are not +- * able to distinguish whitespace and ignorable whitespace, +- * except from whitespace outside the root element. Ignorable +- * whitespace is reported as separate event, which is exposed +- * via nextToken only. +- * +- */ +- boolean isWhitespace() throws XmlPullParserException; +- +- /** +- * Returns the text content of the current event as String. +- * The value returned depends on current event type, +- * for example for TEXT event it is element content +- * (this is typical case when next() is used). +- * +- * See description of nextToken() for detailed description of +- * possible returned values for different types of events. +- * +- * <p><strong>NOTE:</strong> in case of ENTITY_REF, this method returns +- * the entity replacement text (or null if not available). This is +- * the only case where +- * getText() and getTextCharacters() return different values. +- * +- * @see #getEventType +- * @see #next +- * @see #nextToken +- */ +- String getText (); +- +- +- /** +- * Returns the buffer that contains the text of the current event, +- * as well as the start offset and length relevant for the current +- * event. See getText(), next() and nextToken() for description of possible returned values. +- * +- * <p><strong>Please note:</strong> this buffer must not +- * be modified and its content MAY change after a call to +- * next() or nextToken(). This method will always return the +- * same value as getText(), except for ENTITY_REF. In the case +- * of ENTITY ref, getText() returns the replacement text and +- * this method returns the actual input buffer containing the +- * entity name. +- * If getText() returns null, this method returns null as well and +- * the values returned in the holder array MUST be -1 (both start +- * and length). +- * +- * @see #getText +- * @see #next +- * @see #nextToken +- * +- * @param holderForStartAndLength Must hold an 2-element int array +- * into which the start offset and length values will be written. +- * @return char buffer that contains the text of the current event +- * (null if the current event has no text associated). +- */ +- char[] getTextCharacters(int [] holderForStartAndLength); +- +- // -------------------------------------------------------------------------- +- // START_TAG / END_TAG shared methods +- +- /** +- * Returns the namespace URI of the current element. +- * The default namespace is represented +- * as empty string. +- * If namespaces are not enabled, an empty String ("") is always returned. +- * The current event must be START_TAG or END_TAG; otherwise, +- * null is returned. +- */ +- String getNamespace (); +- +- /** +- * For START_TAG or END_TAG events, the (local) name of the current +- * element is returned when namespaces are enabled. When namespace +- * processing is disabled, the raw name is returned. +- * For ENTITY_REF events, the entity name is returned. +- * If the current event is not START_TAG, END_TAG, or ENTITY_REF, +- * null is returned. +- * <p><b>Please note:</b> To reconstruct the raw element name +- * when namespaces are enabled and the prefix is not null, +- * you will need to add the prefix and a colon to localName.. +- * +- */ +- String getName(); +- +- /** +- * Returns the prefix of the current element. +- * If the element is in the default namespace (has no prefix), +- * null is returned. +- * If namespaces are not enabled, or the current event +- * is not START_TAG or END_TAG, null is returned. +- */ +- String getPrefix(); +- +- /** +- * Returns true if the current event is START_TAG and the tag +- * is degenerated +- * (e.g. <foobar/>). +- * <p><b>NOTE:</b> if the parser is not on START_TAG, an exception +- * will be thrown. +- */ +- boolean isEmptyElementTag() throws XmlPullParserException; +- +- // -------------------------------------------------------------------------- +- // START_TAG Attributes retrieval methods +- +- /** +- * Returns the number of attributes of the current start tag, or +- * -1 if the current event type is not START_TAG +- * +- * @see #getAttributeNamespace +- * @see #getAttributeName +- * @see #getAttributePrefix +- * @see #getAttributeValue +- */ +- int getAttributeCount(); +- +- /** +- * Returns the namespace URI of the attribute +- * with the given index (starts from 0). +- * Returns an empty string ("") if namespaces are not enabled +- * or the attribute has no namespace. +- * Throws an IndexOutOfBoundsException if the index is out of range +- * or the current event type is not START_TAG. +- * +- * <p><strong>NOTE:</strong> if FEATURE_REPORT_NAMESPACE_ATTRIBUTES is set +- * then namespace attributes (xmlns:ns='...') must be reported +- * with namespace +- * <a href="http://www.w3.org/2000/xmlns/">http://www.w3.org/2000/xmlns/</a> +- * (visit this URL for description!). +- * The default namespace attribute (xmlns="...") will be reported with empty namespace. +- * <p><strong>NOTE:</strong>The xml prefix is bound as defined in +- * <a href="http://www.w3.org/TR/REC-xml-names/#ns-using">Namespaces in XML</a> +- * specification to "http://www.w3.org/XML/1998/namespace". +- * +- * @param index zero based index of attribute +- * @return attribute namespace, +- * empty string ("") is returned if namesapces processing is not enabled or +- * namespaces processing is enabled but attribute has no namespace (it has no prefix). +- */ +- String getAttributeNamespace (int index); +- +- /** +- * Returns the local name of the specified attribute +- * if namespaces are enabled or just attribute name if namespaces are disabled. +- * Throws an IndexOutOfBoundsException if the index is out of range +- * or current event type is not START_TAG. +- * +- * @param index zero based index of attribute +- * @return attribute name (null is never returned) +- */ +- String getAttributeName (int index); +- +- /** +- * Returns the prefix of the specified attribute +- * Returns null if the element has no prefix. +- * If namespaces are disabled it will always return null. +- * Throws an IndexOutOfBoundsException if the index is out of range +- * or current event type is not START_TAG. +- * +- * @param index zero based index of attribute +- * @return attribute prefix or null if namespaces processing is not enabled. +- */ +- String getAttributePrefix(int index); +- +- /** +- * Returns the type of the specified attribute +- * If parser is non-validating it MUST return CDATA. +- * +- * @param index zero based index of attribute +- * @return attribute type (null is never returned) +- */ +- String getAttributeType(int index); +- +- /** +- * Returns if the specified attribute was not in input was declared in XML. +- * If parser is non-validating it MUST always return false. +- * This information is part of XML infoset: +- * +- * @param index zero based index of attribute +- * @return false if attribute was in input +- */ +- boolean isAttributeDefault(int index); +- +- /** +- * Returns the given attributes value. +- * Throws an IndexOutOfBoundsException if the index is out of range +- * or current event type is not START_TAG. +- * +- * <p><strong>NOTE:</strong> attribute value must be normalized +- * (including entity replacement text if PROCESS_DOCDECL is false) as described in +- * <a href="http://www.w3.org/TR/REC-xml#AVNormalize">XML 1.0 section +- * 3.3.3 Attribute-Value Normalization</a> +- * +- * @see #defineEntityReplacementText +- * +- * @param index zero based index of attribute +- * @return value of attribute (null is never returned) +- */ +- String getAttributeValue(int index); +- +- /** +- * Returns the attributes value identified by namespace URI and namespace localName. +- * If namespaces are disabled namespace must be null. +- * If current event type is not START_TAG then IndexOutOfBoundsException will be thrown. +- * +- * <p><strong>NOTE:</strong> attribute value must be normalized +- * (including entity replacement text if PROCESS_DOCDECL is false) as described in +- * <a href="http://www.w3.org/TR/REC-xml#AVNormalize">XML 1.0 section +- * 3.3.3 Attribute-Value Normalization</a> +- * +- * @see #defineEntityReplacementText +- * +- * @param namespace Namespace of the attribute if namespaces are enabled otherwise must be null +- * @param name If namespaces enabled local name of attribute otherwise just attribute name +- * @return value of attribute or null if attribute with given name does not exist +- */ +- String getAttributeValue(String namespace, +- String name); +- +- // -------------------------------------------------------------------------- +- // actual parsing methods +- +- /** +- * Returns the type of the current event (START_TAG, END_TAG, TEXT, etc.) +- * +- * @see #next() +- * @see #nextToken() +- */ +- int getEventType() +- throws XmlPullParserException; +- +- /** +- * Get next parsing event - element content wil be coalesced and only one +- * TEXT event must be returned for whole element content +- * (comments and processing instructions will be ignored and emtity references +- * must be expanded or exception mus be thrown if entity reerence can not be exapnded). +- * If element content is empty (content is "") then no TEXT event will be reported. +- * +- * <p><b>NOTE:</b> empty element (such as <tag/>) will be reported +- * with two separate events: START_TAG, END_TAG - it must be so to preserve +- * parsing equivalency of empty element to <tag></tag>. +- * (see isEmptyElementTag ()) +- * +- * @see #isEmptyElementTag +- * @see #START_TAG +- * @see #TEXT +- * @see #END_TAG +- * @see #END_DOCUMENT +- */ +- +- int next() +- throws XmlPullParserException, IOException; +- +- +- /** +- * This method works similarly to next() but will expose +- * additional event types (COMMENT, CDSECT, DOCDECL, ENTITY_REF, PROCESSING_INSTRUCTION, or +- * IGNORABLE_WHITESPACE) if they are available in input. +- * +- * <p>If special feature +- * <a href="http://xmlpull.org/v1/doc/features.html#xml-roundtrip">FEATURE_XML_ROUNDTRIP</a> +- * (identified by URI: http://xmlpull.org/v1/doc/features.html#xml-roundtrip) +- * is enabled it is possible to do XML document round trip ie. reproduce +- * exectly on output the XML input using getText(): +- * returned content is always unnormalized (exactly as in input). +- * Otherwise returned content is end-of-line normalized as described +- * <a href="http://www.w3.org/TR/REC-xml#sec-line-ends">XML 1.0 End-of-Line Handling</a> +- * and. Also when this feature is enabled exact content of START_TAG, END_TAG, +- * DOCDECL and PROCESSING_INSTRUCTION is available. +- * +- * <p>Here is the list of tokens that can be returned from nextToken() +- * and what getText() and getTextCharacters() returns:<dl> +- * <dt>START_DOCUMENT<dd>null +- * <dt>END_DOCUMENT<dd>null +- * <dt>START_TAG<dd>null unless FEATURE_XML_ROUNDTRIP +- * enabled and then returns XML tag, ex: <tag attr='val'> +- * <dt>END_TAG<dd>null unless FEATURE_XML_ROUNDTRIP +- * id enabled and then returns XML tag, ex: </tag> +- * <dt>TEXT<dd>return element content. +- * <br>Note: that element content may be delivered in multiple consecutive TEXT events. +- * <dt>IGNORABLE_WHITESPACE<dd>return characters that are determined to be ignorable white +- * space. If the FEATURE_XML_ROUNDTRIP is enabled all whitespace content outside root +- * element will always reported as IGNORABLE_WHITESPACE otherise rteporting is optional. +- * <br>Note: that element content may be delevered in multiple consecutive IGNORABLE_WHITESPACE events. +- * <dt>CDSECT<dd> +- * return text <em>inside</em> CDATA +- * (ex. 'fo<o' from <!CDATA[fo<o]]>) +- * <dt>PROCESSING_INSTRUCTION<dd> +- * if FEATURE_XML_ROUNDTRIP is true +- * return exact PI content ex: 'pi foo' from <?pi foo?> +- * otherwise it may be exact PI content or concatenation of PI target, +- * space and data so for example for +- * <?target data?> string "target data" may +- * be returned if FEATURE_XML_ROUNDTRIP is false. +- * <dt>COMMENT<dd>return comment content ex. 'foo bar' from <!--foo bar--> +- * <dt>ENTITY_REF<dd>getText() MUST return entity replacement text if PROCESS_DOCDECL is false +- * otherwise getText() MAY return null, +- * additionally getTextCharacters() MUST return entity name +- * (for example 'entity_name' for &entity_name;). +- * <br><b>NOTE:</b> this is the only place where value returned from getText() and +- * getTextCharacters() <b>are different</b> +- * <br><b>NOTE:</b> it is user responsibility to resolve entity reference +- * if PROCESS_DOCDECL is false and there is no entity replacement text set in +- * defineEntityReplacementText() method (getText() will be null) +- * <br><b>NOTE:</b> character entities (ex. &#32;) and standard entities such as +- * &amp; &lt; &gt; &quot; &apos; are reported as well +- * and are <b>not</b> reported as TEXT tokens but as ENTITY_REF tokens! +- * This requirement is added to allow to do roundtrip of XML documents! +- * <dt>DOCDECL<dd> +- * if FEATURE_XML_ROUNDTRIP is true or PROCESS_DOCDECL is false +- * then return what is inside of DOCDECL for example it returns:<pre> +- * " titlepage SYSTEM "http://www.foo.bar/dtds/typo.dtd" +- * [<!ENTITY % active.links "INCLUDE">]"</pre> +- * <p>for input document that contained:<pre> +- * <!DOCTYPE titlepage SYSTEM "http://www.foo.bar/dtds/typo.dtd" +- * [<!ENTITY % active.links "INCLUDE">]></pre> +- * otherwise if FEATURE_XML_ROUNDTRIP is false and PROCESS_DOCDECL is true +- * then what is returned is undefined (it may be even null) +- * </dd> +- * </dl> +- * +- * <p><strong>NOTE:</strong> there is no gurantee that there will only one TEXT or +- * IGNORABLE_WHITESPACE event from nextToken() as parser may chose to deliver element content in +- * multiple tokens (dividing element content into chunks) +- * +- * <p><strong>NOTE:</strong> whether returned text of token is end-of-line normalized +- * is depending on FEATURE_XML_ROUNDTRIP. +- * +- * <p><strong>NOTE:</strong> XMLDecl (<?xml ...?>) is not reported but its content +- * is available through optional properties (see class description above). +- * +- * @see #next +- * @see #START_TAG +- * @see #TEXT +- * @see #END_TAG +- * @see #END_DOCUMENT +- * @see #COMMENT +- * @see #DOCDECL +- * @see #PROCESSING_INSTRUCTION +- * @see #ENTITY_REF +- * @see #IGNORABLE_WHITESPACE +- */ +- int nextToken() +- throws XmlPullParserException, IOException; +- +- //----------------------------------------------------------------------------- +- // utility methods to mak XML parsing easier ... +- +- /** +- * Test if the current event is of the given type and if the +- * namespace and name do match. null will match any namespace +- * and any name. If the test is not passed, an exception is +- * thrown. The exception text indicates the parser position, +- * the expected event and the current event that is not meeting the +- * requirement. +- * +- * <p>Essentially it does this +- * <pre> +- * if (type != getEventType() +- * || (namespace != null && !namespace.equals( getNamespace () ) ) +- * || (name != null && !name.equals( getName() ) ) ) +- * throw new XmlPullParserException( "expected "+ TYPES[ type ]+getPositionDescription()); +- * </pre> +- */ +- void require(int type, String namespace, String name) +- throws XmlPullParserException, IOException; +- +- /** +- * If current event is START_TAG then if next element is TEXT then element content is returned +- * or if next event is END_TAG then empty string is returned, otherwise exception is thrown. +- * After calling this function successfully parser will be positioned on END_TAG. +- * +- * <p>The motivation for this function is to allow to parse consistently both +- * empty elements and elements that has non empty content, for example for input: <ol> +- * <li><tag>foo</tag> +- * <li><tag></tag> (which is equivalent to <tag/> +- * both input can be parsed with the same code: +- * <pre> +- * p.nextTag() +- * p.requireEvent(p.START_TAG, "", "tag"); +- * String content = p.nextText(); +- * p.requireEvent(p.END_TAG, "", "tag"); +- * </pre> +- * This function together with nextTag make it very easy to parse XML that has +- * no mixed content. +- * +- * +- * <p>Essentially it does this +- * <pre> +- * if(getEventType() != START_TAG) { +- * throw new XmlPullParserException( +- * "parser must be on START_TAG to read next text", this, null); +- * } +- * int eventType = next(); +- * if(eventType == TEXT) { +- * String result = getText(); +- * eventType = next(); +- * if(eventType != END_TAG) { +- * throw new XmlPullParserException( +- * "event TEXT it must be immediately followed by END_TAG", this, null); +- * } +- * return result; +- * } else if(eventType == END_TAG) { +- * return ""; +- * } else { +- * throw new XmlPullParserException( +- * "parser must be on START_TAG or TEXT to read text", this, null); +- * } +- * </pre> +- */ +- String nextText() throws XmlPullParserException, IOException; +- +- /** +- * Call next() and return event if it is START_TAG or END_TAG +- * otherwise throw an exception. +- * It will skip whitespace TEXT before actual tag if any. +- * +- * <p>essentially it does this +- * <pre> +- * int eventType = next(); +- * if(eventType == TEXT && isWhitespace()) { // skip whitespace +- * eventType = next(); +- * } +- * if (eventType != START_TAG && eventType != END_TAG) { +- * throw new XmlPullParserException("expected start or end tag", this, null); +- * } +- * return eventType; +- * </pre> +- */ +- int nextTag() throws XmlPullParserException, IOException; +- +-} +- +diff -Nru gshell-2.6.5/gshell-util/src/main/java/org/codehaus/plexus/util/xml/pull/XmlSerializer.java gshell-2.6.5-gil/gshell-util/src/main/java/org/codehaus/plexus/util/xml/pull/XmlSerializer.java +--- gshell-2.6.5/gshell-util/src/main/java/org/codehaus/plexus/util/xml/pull/XmlSerializer.java 2011-12-28 20:41:12.000000000 +0100 ++++ gshell-2.6.5-gil/gshell-util/src/main/java/org/codehaus/plexus/util/xml/pull/XmlSerializer.java 1970-01-01 01:00:00.000000000 +0100 +@@ -1,329 +0,0 @@ +-/* -*- c-basic-offset: 4; indent-tabs-mode: nil; -*- //------100-columns-wide------>|*/ +-// for license please see accompanying LICENSE.txt file (available also at http://www.xmlpull.org/) +- +-package org.codehaus.plexus.util.xml.pull; +- +-import java.io.IOException; +-import java.io.OutputStream; +-import java.io.Writer; +- +-/** +- * Define an interface to serialization of XML Infoset. +- * This interface abstracts away if serialized XML is XML 1.0 compatible text or +- * other formats of XML 1.0 serializations (such as binary XML for example with WBXML). +- * +- * <p><b>PLEASE NOTE:</b> This interface will be part of XmlPull 1.2 API. +- * It is included as basis for discussion. It may change in any way. +- * +- * <p>Exceptions that may be thrown are: IOException or runtime exception +- * (more runtime exceptions can be thrown but are not declared and as such +- * have no semantics defined for this interface): +- * <ul> +- * <li><em>IllegalArgumentException</em> - for almost all methods to signal that +- * argument is illegal +- * <li><em>IllegalStateException</em> - to signal that call has good arguments but +- * is not expected here (violation of contract) and for features/properties +- * when requesting setting unimplemented feature/property +- * (UnsupportedOperationException would be better but it is not in MIDP) +- * </ul> +- * +- * <p><b>NOTE:</b> writing CDSECT, ENTITY_REF, IGNORABLE_WHITESPACE, +- * PROCESSING_INSTRUCTION, COMMENT, and DOCDECL in some implementations +- * may not be supported (for example when serializing to WBXML). +- * In such case IllegalStateException will be thrown and it is recommended +- * to use an optional feature to signal that implementation is not +- * supporting this kind of output. +- */ +-@Deprecated +-public interface XmlSerializer { +- +- /** +- * Set feature identified by name (recommended to be URI for uniqueness). +- * Some well known optional features are defined in +- * <a href="http://www.xmlpull.org/v1/doc/features.html"> +- * http://www.xmlpull.org/v1/doc/features.html</a>. +- * +- * If feature is not recognized or can not be set +- * then IllegalStateException MUST be thrown. +- * +- * @exception IllegalStateException If the feature is not supported or can not be set +- */ +- void setFeature(String name, +- boolean state) +- throws IllegalArgumentException, IllegalStateException; +- +- +- /** +- * Return the current value of the feature with given name. +- * <p><strong>NOTE:</strong> unknown properties are <strong>always</strong> returned as null +- * +- * @param name The name of feature to be retrieved. +- * @return The value of named feature. +- * @exception IllegalArgumentException if feature string is null +- */ +- boolean getFeature(String name); +- +- +- /** +- * Set the value of a property. +- * (the property name is recommended to be URI for uniqueness). +- * Some well known optional properties are defined in +- * <a href="http://www.xmlpull.org/v1/doc/properties.html"> +- * http://www.xmlpull.org/v1/doc/properties.html</a>. +- * +- * If property is not recognized or can not be set +- * then IllegalStateException MUST be thrown. +- * +- * @exception IllegalStateException if the property is not supported or can not be set +- */ +- void setProperty(String name, +- Object value) +- throws IllegalArgumentException, IllegalStateException; +- +- /** +- * Look up the value of a property. +- * +- * The property name is any fully-qualified URI. I +- * <p><strong>NOTE:</strong> unknown properties are <string>always</strong> returned as null +- * +- * @param name The name of property to be retrieved. +- * @return The value of named property. +- */ +- Object getProperty(String name); +- +- /** +- * Set to use binary output stream with given encoding. +- */ +- void setOutput (OutputStream os, String encoding) +- throws IOException, IllegalArgumentException, IllegalStateException; +- +- /** +- * Set the output to the given writer. +- * <p><b>WARNING</b> no information about encoding is available! +- */ +- void setOutput (Writer writer) +- throws IOException, IllegalArgumentException, IllegalStateException; +- +- /** +- * Write <?xml declaration with encoding (if encoding not null) +- * and standalone flag (if standalone not null) +- * This method can only be called just after setOutput. +- */ +- void startDocument (String encoding, Boolean standalone) +- throws IOException, IllegalArgumentException, IllegalStateException; +- +- /** +- * Finish writing. All unclosed start tags will be closed and output +- * will be flushed. After calling this method no more output can be +- * serialized until next call to setOutput() +- */ +- void endDocument () +- throws IOException, IllegalArgumentException, IllegalStateException; +- +- /** +- * Binds the given prefix to the given namespace. +- * This call is valid for the next element including child elements. +- * The prefix and namespace MUST be always declared even if prefix +- * is not used in element (startTag() or attribute()) - for XML 1.0 +- * it must result in declaring <code>xmlns:prefix='namespace'</code> +- * (or <code>xmlns:prefix="namespace"</code> depending what character is used +- * to quote attribute value). +- * +- * <p><b>NOTE:</b> this method MUST be called directly before startTag() +- * and if anything but startTag() or setPrefix() is called next there will be exception. +- * <p><b>NOTE:</b> prefixes "xml" and "xmlns" are already bound +- * and can not be redefined see: +- * <a href="http://www.w3.org/XML/xml-names-19990114-errata#NE05">Namespaces in XML Errata</a>. +- * <p><b>NOTE:</b> to set default namespace use as prefix empty string. +- * +- * @param prefix must be not null (or IllegalArgumentException is thrown) +- * @param namespace must be not null +- */ +- void setPrefix (String prefix, String namespace) +- throws IOException, IllegalArgumentException, IllegalStateException; +- +- /** +- * Return namespace that corresponds to given prefix +- * If there is no prefix bound to this namespace return null +- * but if generatePrefix is false then return generated prefix. +- * +- * <p><b>NOTE:</b> if the prefix is empty string "" and default namespace is bound +- * to this prefix then empty string ("") is returned. +- * +- * <p><b>NOTE:</b> prefixes "xml" and "xmlns" are already bound +- * will have values as defined +- * <a href="http://www.w3.org/TR/REC-xml-names/">Namespaces in XML specification</a> +- */ +- String getPrefix (String namespace, boolean generatePrefix) +- throws IllegalArgumentException; +- +- /** +- * Returns the current depth of the element. +- * Outside the root element, the depth is 0. The +- * depth is incremented by 1 when startTag() is called. +- * The depth is decremented after the call to endTag() +- * event was observed. +- * +- * <pre> +- * <!-- outside --> 0 +- * <root> 1 +- * sometext 1 +- * <foobar> 2 +- * </foobar> 2 +- * </root> 1 +- * <!-- outside --> 0 +- * </pre> +- */ +- int getDepth(); +- +- /** +- * Returns the namespace URI of the current element as set by startTag(). +- * +- * <p><b>NOTE:</b> that means in particular that: <ul> +- * <li>if there was startTag("", ...) then getNamespace() returns "" +- * <li>if there was startTag(null, ...) then getNamespace() returns null +- * </ul> +- * +- * @return namespace set by startTag() that is currently in scope +- */ +- String getNamespace (); +- +- /** +- * Returns the name of the current element as set by startTag(). +- * It can only be null before first call to startTag() +- * or when last endTag() is called to close first startTag(). +- * +- * @return namespace set by startTag() that is currently in scope +- */ +- String getName(); +- +- /** +- * Writes a start tag with the given namespace and name. +- * If there is no prefix defined for the given namespace, +- * a prefix will be defined automatically. +- * The explicit prefixes for namespaces can be established by calling setPrefix() +- * immediately before this method. +- * If namespace is null no namespace prefix is printed but just name. +- * If namespace is empty string then serializer will make sure that +- * default empty namespace is declared (in XML 1.0 xmlns='') +- * or throw IllegalStateException if default namespace is already bound +- * to non-empty string. +- */ +- XmlSerializer startTag (String namespace, String name) +- throws IOException, IllegalArgumentException, IllegalStateException; +- +- /** +- * Write an attribute. Calls to attribute() MUST follow a call to +- * startTag() immediately. If there is no prefix defined for the +- * given namespace, a prefix will be defined automatically. +- * If namespace is null or empty string +- * no namespace prefix is printed but just name. +- */ +- XmlSerializer attribute (String namespace, String name, String value) +- throws IOException, IllegalArgumentException, IllegalStateException; +- +- /** +- * Write end tag. Repetition of namespace and name is just for avoiding errors. +- * <p><b>Background:</b> in kXML endTag had no arguments, and non matching tags were +- * very difficult to find... +- * If namespace is null no namespace prefix is printed but just name. +- * If namespace is empty string then serializer will make sure that +- * default empty namespace is declared (in XML 1.0 xmlns=''). +- */ +- XmlSerializer endTag (String namespace, String name) +- throws IOException, IllegalArgumentException, IllegalStateException; +- +- +- // /** +- // * Writes a start tag with the given namespace and name. +- // * <br />If there is no prefix defined (prefix == null) for the given namespace, +- // * a prefix will be defined automatically. +- // * <br />If explicit prefixes is passed (prefix != null) then it will be used +- // *and namespace declared if not already declared or +- // * throw IllegalStateException the same prefix was already set on this +- // * element (setPrefix()) and was bound to different namespace. +- // * <br />If namespace is null then prefix must be null too or IllegalStateException is thrown. +- // * <br />If namespace is null then no namespace prefix is printed but just name. +- // * <br />If namespace is empty string then serializer will make sure that +- // * default empty namespace is declared (in XML 1.0 xmlns='') +- // * or throw IllegalStateException if default namespace is already bound +- // * to non-empty string. +- // */ +- // XmlSerializer startTag (String prefix, String namespace, String name) +- // throws IOException, IllegalArgumentException, IllegalStateException; +- // +- // /** +- // * Write an attribute. Calls to attribute() MUST follow a call to +- // * startTag() immediately. +- // * <br />If there is no prefix defined (prefix == null) for the given namespace, +- // * a prefix will be defined automatically. +- // * <br />If explicit prefixes is passed (prefix != null) then it will be used +- // * and namespace declared if not already declared or +- // * throw IllegalStateException the same prefix was already set on this +- // * element (setPrefix()) and was bound to different namespace. +- // * <br />If namespace is null then prefix must be null too or IllegalStateException is thrown. +- // * <br />If namespace is null then no namespace prefix is printed but just name. +- // * <br />If namespace is empty string then serializer will make sure that +- // * default empty namespace is declared (in XML 1.0 xmlns='') +- // * or throw IllegalStateException if default namespace is already bound +- // * to non-empty string. +- // */ +- // XmlSerializer attribute (String prefix, String namespace, String name, String value) +- // throws IOException, IllegalArgumentException, IllegalStateException; +- // +- // /** +- // * Write end tag. Repetition of namespace, prefix, and name is just for avoiding errors. +- // * <br />If namespace or name arguments are different from corresponding startTag call +- // * then IllegalArgumentException is thrown, if prefix argument is not null and is different +- // * from corresponding starTag then IllegalArgumentException is thrown. +- // * <br />If namespace is null then prefix must be null too or IllegalStateException is thrown. +- // * <br />If namespace is null then no namespace prefix is printed but just name. +- // * <br />If namespace is empty string then serializer will make sure that +- // * default empty namespace is declared (in XML 1.0 xmlns=''). +- // * <p><b>Background:</b> in kXML endTag had no arguments, and non matching tags were +- // * very difficult to find...</p> +- // */ +- // ALEK: This is really optional as prefix in end tag MUST correspond to start tag but good for error checking +- // XmlSerializer endTag (String prefix, String namespace, String name) +- // throws IOException, IllegalArgumentException, IllegalStateException; +- +- /** +- * Writes text, where special XML chars are escaped automatically +- */ +- XmlSerializer text (String text) +- throws IOException, IllegalArgumentException, IllegalStateException; +- +- /** +- * Writes text, where special XML chars are escaped automatically +- */ +- XmlSerializer text (char [] buf, int start, int len) +- throws IOException, IllegalArgumentException, IllegalStateException; +- +- void cdsect (String text) +- throws IOException, IllegalArgumentException, IllegalStateException; +- void entityRef (String text) throws IOException, +- IllegalArgumentException, IllegalStateException; +- void processingInstruction (String text) +- throws IOException, IllegalArgumentException, IllegalStateException; +- void comment (String text) +- throws IOException, IllegalArgumentException, IllegalStateException; +- void docdecl (String text) +- throws IOException, IllegalArgumentException, IllegalStateException; +- void ignorableWhitespace (String text) +- throws IOException, IllegalArgumentException, IllegalStateException; +- +- /** +- * Write all pending output to the stream. +- * If method startTag() or attribute() was called then start tag is closed (final >) +- * before flush() is called on underlying output stream. +- * +- * <p><b>NOTE:</b> if there is need to close start tag +- * (so no more attribute() calls are allowed) but without flushing output +- * call method text() with empty string (text("")). +- * +- */ +- void flush () +- throws IOException; +- +-} +- +diff -Nru gshell-2.6.5/gshell-util/src/main/java/org/codehaus/plexus/util/xml/XmlReaderException.java gshell-2.6.5-gil/gshell-util/src/main/java/org/codehaus/plexus/util/xml/XmlReaderException.java +--- gshell-2.6.5/gshell-util/src/main/java/org/codehaus/plexus/util/xml/XmlReaderException.java 2011-12-28 20:41:12.000000000 +0100 ++++ gshell-2.6.5-gil/gshell-util/src/main/java/org/codehaus/plexus/util/xml/XmlReaderException.java 1970-01-01 01:00:00.000000000 +0100 +@@ -1,179 +0,0 @@ +-/* +- * Copyright 2004 Sun Microsystems, Inc. +- * +- * Licensed under the Apache License, Version 2.0 (the "License"); +- * you may not use this file except in compliance with the License. +- * You may obtain a copy of the License at +- * +- * http://www.apache.org/licenses/LICENSE-2.0 +- * +- * Unless required by applicable law or agreed to in writing, software +- * distributed under the License is distributed on an "AS IS" BASIS, +- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +- * See the License for the specific language governing permissions and +- * limitations under the License. +- * +- */ +-package org.codehaus.plexus.util.xml; +- +-import java.io.InputStream; +-import java.io.IOException; +- +-/** +- * The XmlReaderException is thrown by the XmlReader constructors if the charset encoding can not be determined +- * according to the XML 1.0 specification and RFC 3023. +- * <p> +- * The exception returns the unconsumed InputStream to allow the application to do an alternate processing with the +- * stream. Note that the original InputStream given to the XmlReader cannot be used as that one has been already read. +- * <p> +- * +- * @author Alejandro Abdelnur +- * @version revision 1.1 taken on 26/06/2007 from Rome (see https://rome.dev.java.net/source/browse/rome/src/java/com/sun/syndication/io...) +- */ +-@Deprecated +-public class XmlReaderException extends IOException +-{ +- private String _bomEncoding; +- +- private String _xmlGuessEncoding; +- +- private String _xmlEncoding; +- +- private String _contentTypeMime; +- +- private String _contentTypeEncoding; +- +- private InputStream _is; +- +- /** +- * Creates an exception instance if the charset encoding could not be determined. +- * <p> +- * Instances of this exception are thrown by the XmlReader. +- * <p> +- * +- * @param msg +- * message describing the reason for the exception. +- * @param bomEnc +- * BOM encoding. +- * @param xmlGuessEnc +- * XML guess encoding. +- * @param xmlEnc +- * XML prolog encoding. +- * @param is +- * the unconsumed InputStream. +- * +- */ +- public XmlReaderException( String msg, String bomEnc, String xmlGuessEnc, String xmlEnc, InputStream is ) +- { +- this( msg, null, null, bomEnc, xmlGuessEnc, xmlEnc, is ); +- } +- +- /** +- * Creates an exception instance if the charset encoding could not be determined. +- * <p> +- * Instances of this exception are thrown by the XmlReader. +- * <p> +- * +- * @param msg +- * message describing the reason for the exception. +- * @param ctMime +- * MIME type in the content-type. +- * @param ctEnc +- * encoding in the content-type. +- * @param bomEnc +- * BOM encoding. +- * @param xmlGuessEnc +- * XML guess encoding. +- * @param xmlEnc +- * XML prolog encoding. +- * @param is +- * the unconsumed InputStream. +- * +- */ +- public XmlReaderException( String msg, String ctMime, String ctEnc, String bomEnc, String xmlGuessEnc, +- String xmlEnc, InputStream is ) +- { +- super( msg ); +- _contentTypeMime = ctMime; +- _contentTypeEncoding = ctEnc; +- _bomEncoding = bomEnc; +- _xmlGuessEncoding = xmlGuessEnc; +- _xmlEncoding = xmlEnc; +- _is = is; +- } +- +- /** +- * Returns the BOM encoding found in the InputStream. +- * <p> +- * +- * @return the BOM encoding, null if none. +- * +- */ +- public String getBomEncoding() +- { +- return _bomEncoding; +- } +- +- /** +- * Returns the encoding guess based on the first bytes of the InputStream. +- * <p> +- * +- * @return the encoding guess, null if it couldn't be guessed. +- * +- */ +- public String getXmlGuessEncoding() +- { +- return _xmlGuessEncoding; +- } +- +- /** +- * Returns the encoding found in the XML prolog of the InputStream. +- * <p> +- * +- * @return the encoding of the XML prolog, null if none. +- * +- */ +- public String getXmlEncoding() +- { +- return _xmlEncoding; +- } +- +- /** +- * Returns the MIME type in the content-type used to attempt determining the encoding. +- * <p> +- * +- * @return the MIME type in the content-type, null if there was not content-type or the encoding detection did not +- * involve HTTP. +- * +- */ +- public String getContentTypeMime() +- { +- return _contentTypeMime; +- } +- +- /** +- * Returns the encoding in the content-type used to attempt determining the encoding. +- * <p> +- * +- * @return the encoding in the content-type, null if there was not content-type, no encoding in it or the encoding +- * detection did not involve HTTP. +- * +- */ +- public String getContentTypeEncoding() +- { +- return _contentTypeEncoding; +- } +- +- /** +- * Returns the unconsumed InputStream to allow the application to do an alternate encoding detection on the +- * InputStream. +- * <p> +- * +- * @return the unconsumed InputStream. +- * +- */ +- public InputStream getInputStream() +- { +- return _is; +- } +-} +diff -Nru gshell-2.6.5/gshell-util/src/main/java/org/codehaus/plexus/util/xml/XmlReader.java gshell-2.6.5-gil/gshell-util/src/main/java/org/codehaus/plexus/util/xml/XmlReader.java +--- gshell-2.6.5/gshell-util/src/main/java/org/codehaus/plexus/util/xml/XmlReader.java 2011-12-28 20:41:12.000000000 +0100 ++++ gshell-2.6.5-gil/gshell-util/src/main/java/org/codehaus/plexus/util/xml/XmlReader.java 1970-01-01 01:00:00.000000000 +0100 +@@ -1,787 +0,0 @@ +-/* +- * Copyright 2004 Sun Microsystems, Inc. +- * +- * Licensed under the Apache License, Version 2.0 (the "License"); +- * you may not use this file except in compliance with the License. +- * You may obtain a copy of the License at +- * +- * http://www.apache.org/licenses/LICENSE-2.0 +- * +- * Unless required by applicable law or agreed to in writing, software +- * distributed under the License is distributed on an "AS IS" BASIS, +- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +- * See the License for the specific language governing permissions and +- * limitations under the License. +- * +- */ +-package org.codehaus.plexus.util.xml; +- +-import java.io.BufferedInputStream; +-import java.io.BufferedReader; +-import java.io.File; +-import java.io.FileInputStream; +-import java.io.IOException; +-import java.io.InputStream; +-import java.io.InputStreamReader; +-import java.io.Reader; +-import java.io.StringReader; +-import java.net.URL; +-import java.net.URLConnection; +-import java.net.HttpURLConnection; +-import java.util.Locale; +-import java.util.regex.Pattern; +-import java.util.regex.Matcher; +-import java.text.MessageFormat; +- +-/** +- * Character stream that handles (or at least attemtps to) all the necessary Voodo to figure out the charset encoding of +- * the XML document within the stream. +- * <p> +- * IMPORTANT: This class is not related in any way to the org.xml.sax.XMLReader. This one IS a character stream. +- * <p> +- * All this has to be done without consuming characters from the stream, if not the XML parser will not recognized the +- * document as a valid XML. This is not 100% true, but it's close enough (UTF-8 BOM is not handled by all parsers right +- * now, XmlReader handles it and things work in all parsers). +- * <p> +- * The XmlReader class handles the charset encoding of XML documents in Files, raw streams and HTTP streams by offering +- * a wide set of constructors. +- * <P> +- * By default the charset encoding detection is lenient, the constructor with the lenient flag can be used for an script +- * (following HTTP MIME and XML specifications). All this is nicely explained by Mark Pilgrim in his blog, <a +- * href="http://diveintomark.org/archives/2004/02/13/xml-media-types%22%3E Determining the character encoding of a feed</a>. +- * <p> +- * +- * @author Alejandro Abdelnur +- * @version revision 1.17 taken on 26/06/2007 from Rome (see https://rome.dev.java.net/source/browse/rome/src/java/com/sun/syndication/io...) +- * @deprecated use XmlStreamReader +- * @since 1.4.3 +- */ +-@Deprecated +-public class XmlReader extends Reader +-{ +- private static final int BUFFER_SIZE = 4096; +- +- private static final String UTF_8 = "UTF-8"; +- +- private static final String US_ASCII = "US-ASCII"; +- +- private static final String UTF_16BE = "UTF-16BE"; +- +- private static final String UTF_16LE = "UTF-16LE"; +- +- private static final String UTF_16 = "UTF-16"; +- +- private static final String EBCDIC = "CP1047"; +- +- private static String _staticDefaultEncoding = null; +- +- private Reader _reader; +- +- private String _encoding; +- +- private String _defaultEncoding; +- +- /** +- * Sets the default encoding to use if none is set in HTTP content-type, XML prolog and the rules based on +- * content-type are not adequate. <p/> If it is set to NULL the content-type based rules are used. <p/> By default +- * it is NULL. <p/> +- * +- * @param encoding +- * charset encoding to default to. +- */ +- public static void setDefaultEncoding( String encoding ) +- { +- _staticDefaultEncoding = encoding; +- } +- +- /** +- * Returns the default encoding to use if none is set in HTTP content-type, XML prolog and the rules based on +- * content-type are not adequate. <p/> If it is NULL the content-type based rules are used. <p/> +- * +- * @return the default encoding to use. +- */ +- public static String getDefaultEncoding() +- { +- return _staticDefaultEncoding; +- } +- +- /** +- * Creates a Reader for a File. +- * <p> +- * It looks for the UTF-8 BOM first, if none sniffs the XML prolog charset, if this is also missing defaults to +- * UTF-8. +- * <p> +- * It does a lenient charset encoding detection, check the constructor with the lenient parameter for details. +- * <p> +- * +- * @param file +- * File to create a Reader from. +- * @throws IOException +- * thrown if there is a problem reading the file. +- * +- */ +- public XmlReader( File file ) throws IOException +- { +- this( new FileInputStream( file ) ); +- } +- +- /** +- * Creates a Reader for a raw InputStream. +- * <p> +- * It follows the same logic used for files. +- * <p> +- * It does a lenient charset encoding detection, check the constructor with the lenient parameter for details. +- * <p> +- * +- * @param is +- * InputStream to create a Reader from. +- * @throws IOException +- * thrown if there is a problem reading the stream. +- * +- */ +- public XmlReader( InputStream is ) throws IOException +- { +- this( is, true ); +- } +- +- /** +- * Creates a Reader for a raw InputStream. +- * <p> +- * It follows the same logic used for files. +- * <p> +- * If lenient detection is indicated and the detection above fails as per specifications it then attempts the +- * following: +- * <p> +- * If the content type was 'text/html' it replaces it with 'text/xml' and tries the detection again. +- * <p> +- * Else if the XML prolog had a charset encoding that encoding is used. +- * <p> +- * Else if the content type had a charset encoding that encoding is used. +- * <p> +- * Else 'UTF-8' is used. +- * <p> +- * If lenient detection is indicated an XmlStreamReaderException is never thrown. +- * <p> +- * +- * @param is +- * InputStream to create a Reader from. +- * @param lenient +- * indicates if the charset encoding detection should be relaxed. +- * @throws IOException +- * thrown if there is a problem reading the stream. +- * @throws XmlStreamReaderException +- * thrown if the charset encoding could not be determined according to the specs. +- * +- */ +- public XmlReader( InputStream is, boolean lenient ) throws IOException, XmlStreamReaderException +- { +- _defaultEncoding = _staticDefaultEncoding; +- try +- { +- doRawStream( is, lenient ); +- } +- catch ( XmlStreamReaderException ex ) +- { +- if ( !lenient ) +- { +- throw ex; +- } +- else +- { +- doLenientDetection( null, ex ); +- } +- } +- } +- +- /** +- * Creates a Reader using the InputStream of a URL. +- * <p> +- * If the URL is not of type HTTP and there is not 'content-type' header in the fetched data it uses the same logic +- * used for Files. +- * <p> +- * If the URL is a HTTP Url or there is a 'content-type' header in the fetched data it uses the same logic used for +- * an InputStream with content-type. +- * <p> +- * It does a lenient charset encoding detection, check the constructor with the lenient parameter for details. +- * <p> +- * +- * @param url +- * URL to create a Reader from. +- * @throws IOException +- * thrown if there is a problem reading the stream of the URL. +- * +- */ +- public XmlReader( URL url ) throws IOException +- { +- this( url.openConnection() ); +- } +- +- /** +- * Creates a Reader using the InputStream of a URLConnection. +- * <p> +- * If the URLConnection is not of type HttpURLConnection and there is not 'content-type' header in the fetched data +- * it uses the same logic used for files. +- * <p> +- * If the URLConnection is a HTTP Url or there is a 'content-type' header in the fetched data it uses the same logic +- * used for an InputStream with content-type. +- * <p> +- * It does a lenient charset encoding detection, check the constructor with the lenient parameter for details. +- * <p> +- * +- * @param conn +- * URLConnection to create a Reader from. +- * @throws IOException +- * thrown if there is a problem reading the stream of the URLConnection. +- * +- */ +- public XmlReader( URLConnection conn ) throws IOException +- { +- _defaultEncoding = _staticDefaultEncoding; +- boolean lenient = true; +- if ( conn instanceof HttpURLConnection ) +- { +- try +- { +- doHttpStream( conn.getInputStream(), conn.getContentType(), lenient ); +- } +- catch ( XmlStreamReaderException ex ) +- { +- doLenientDetection( conn.getContentType(), ex ); +- } +- } +- else if ( conn.getContentType() != null ) +- { +- try +- { +- doHttpStream( conn.getInputStream(), conn.getContentType(), lenient ); +- } +- catch ( XmlStreamReaderException ex ) +- { +- doLenientDetection( conn.getContentType(), ex ); +- } +- } +- else +- { +- try +- { +- doRawStream( conn.getInputStream(), lenient ); +- } +- catch ( XmlStreamReaderException ex ) +- { +- doLenientDetection( null, ex ); +- } +- } +- } +- +- /** +- * Creates a Reader using an InputStream an the associated content-type header. +- * <p> +- * First it checks if the stream has BOM. If there is not BOM checks the content-type encoding. If there is not +- * content-type encoding checks the XML prolog encoding. If there is not XML prolog encoding uses the default +- * encoding mandated by the content-type MIME type. +- * <p> +- * It does a lenient charset encoding detection, check the constructor with the lenient parameter for details. +- * <p> +- * +- * @param is +- * InputStream to create the reader from. +- * @param httpContentType +- * content-type header to use for the resolution of the charset encoding. +- * @throws IOException +- * thrown if there is a problem reading the file. +- * +- */ +- public XmlReader( InputStream is, String httpContentType ) throws IOException +- { +- this( is, httpContentType, true ); +- } +- +- /** +- * Creates a Reader using an InputStream an the associated content-type header. This constructor is lenient +- * regarding the encoding detection. +- * <p> +- * First it checks if the stream has BOM. If there is not BOM checks the content-type encoding. If there is not +- * content-type encoding checks the XML prolog encoding. If there is not XML prolog encoding uses the default +- * encoding mandated by the content-type MIME type. +- * <p> +- * If lenient detection is indicated and the detection above fails as per specifications it then attempts the +- * following: +- * <p> +- * If the content type was 'text/html' it replaces it with 'text/xml' and tries the detection again. +- * <p> +- * Else if the XML prolog had a charset encoding that encoding is used. +- * <p> +- * Else if the content type had a charset encoding that encoding is used. +- * <p> +- * Else 'UTF-8' is used. +- * <p> +- * If lenient detection is indicated an XmlStreamReaderException is never thrown. +- * <p> +- * +- * @param is +- * InputStream to create the reader from. +- * @param httpContentType +- * content-type header to use for the resolution of the charset encoding. +- * @param lenient +- * indicates if the charset encoding detection should be relaxed. +- * @throws IOException +- * thrown if there is a problem reading the file. +- * @throws XmlStreamReaderException +- * thrown if the charset encoding could not be determined according to the specs. +- * +- */ +- public XmlReader( InputStream is, String httpContentType, boolean lenient, String defaultEncoding ) +- throws IOException, XmlStreamReaderException +- { +- _defaultEncoding = ( defaultEncoding == null ) ? _staticDefaultEncoding : defaultEncoding; +- try +- { +- doHttpStream( is, httpContentType, lenient ); +- } +- catch ( XmlStreamReaderException ex ) +- { +- if ( !lenient ) +- { +- throw ex; +- } +- else +- { +- doLenientDetection( httpContentType, ex ); +- } +- } +- } +- +- /** +- * Creates a Reader using an InputStream an the associated content-type header. This constructor is lenient +- * regarding the encoding detection. +- * <p> +- * First it checks if the stream has BOM. If there is not BOM checks the content-type encoding. If there is not +- * content-type encoding checks the XML prolog encoding. If there is not XML prolog encoding uses the default +- * encoding mandated by the content-type MIME type. +- * <p> +- * If lenient detection is indicated and the detection above fails as per specifications it then attempts the +- * following: +- * <p> +- * If the content type was 'text/html' it replaces it with 'text/xml' and tries the detection again. +- * <p> +- * Else if the XML prolog had a charset encoding that encoding is used. +- * <p> +- * Else if the content type had a charset encoding that encoding is used. +- * <p> +- * Else 'UTF-8' is used. +- * <p> +- * If lenient detection is indicated an XmlStreamReaderException is never thrown. +- * <p> +- * +- * @param is +- * InputStream to create the reader from. +- * @param httpContentType +- * content-type header to use for the resolution of the charset encoding. +- * @param lenient +- * indicates if the charset encoding detection should be relaxed. +- * @throws IOException +- * thrown if there is a problem reading the file. +- * @throws XmlStreamReaderException +- * thrown if the charset encoding could not be determined according to the specs. +- * +- */ +- public XmlReader( InputStream is, String httpContentType, boolean lenient ) throws IOException, XmlStreamReaderException +- { +- this( is, httpContentType, lenient, null ); +- } +- +- private void doLenientDetection( String httpContentType, XmlStreamReaderException ex ) throws IOException +- { +- if ( httpContentType != null ) +- { +- if ( httpContentType.startsWith( "text/html" ) ) +- { +- httpContentType = httpContentType.substring( "text/html".length() ); +- httpContentType = "text/xml" + httpContentType; +- try +- { +- doHttpStream( ex.getInputStream(), httpContentType, true ); +- ex = null; +- } +- catch ( XmlStreamReaderException ex2 ) +- { +- ex = ex2; +- } +- } +- } +- if ( ex != null ) +- { +- String encoding = ex.getXmlEncoding(); +- if ( encoding == null ) +- { +- encoding = ex.getContentTypeEncoding(); +- } +- if ( encoding == null ) +- { +- encoding = ( _defaultEncoding == null ) ? UTF_8 : _defaultEncoding; +- } +- prepareReader( ex.getInputStream(), encoding ); +- } +- } +- +- /** +- * Returns the charset encoding of the XmlReader. +- * <p> +- * +- * @return charset encoding. +- * +- */ +- public String getEncoding() +- { +- return _encoding; +- } +- +- public int read( char[] buf, int offset, int len ) throws IOException +- { +- return _reader.read( buf, offset, len ); +- } +- +- /** +- * Closes the XmlReader stream. +- * <p> +- * +- * @throws IOException +- * thrown if there was a problem closing the stream. +- * +- */ +- public void close() throws IOException +- { +- _reader.close(); +- } +- +- private void doRawStream( InputStream is, boolean lenient ) throws IOException +- { +- BufferedInputStream pis = new BufferedInputStream( is, BUFFER_SIZE ); +- String bomEnc = getBOMEncoding( pis ); +- String xmlGuessEnc = getXMLGuessEncoding( pis ); +- String xmlEnc = getXmlProlog( pis, xmlGuessEnc ); +- String encoding = calculateRawEncoding( bomEnc, xmlGuessEnc, xmlEnc, pis ); +- prepareReader( pis, encoding ); +- } +- +- private void doHttpStream( InputStream is, String httpContentType, boolean lenient ) throws IOException +- { +- BufferedInputStream pis = new BufferedInputStream( is, BUFFER_SIZE ); +- String cTMime = getContentTypeMime( httpContentType ); +- String cTEnc = getContentTypeEncoding( httpContentType ); +- String bomEnc = getBOMEncoding( pis ); +- String xmlGuessEnc = getXMLGuessEncoding( pis ); +- String xmlEnc = getXmlProlog( pis, xmlGuessEnc ); +- String encoding = calculateHttpEncoding( cTMime, cTEnc, bomEnc, xmlGuessEnc, xmlEnc, pis, lenient ); +- prepareReader( pis, encoding ); +- } +- +- private void prepareReader( InputStream is, String encoding ) throws IOException +- { +- _reader = new InputStreamReader( is, encoding ); +- _encoding = encoding; +- } +- +- // InputStream is passed for XmlStreamReaderException creation only +- private String calculateRawEncoding( String bomEnc, String xmlGuessEnc, String xmlEnc, InputStream is ) +- throws IOException +- { +- String encoding; +- if ( bomEnc == null ) +- { +- if ( xmlGuessEnc == null || xmlEnc == null ) +- { +- encoding = ( _defaultEncoding == null ) ? UTF_8 : _defaultEncoding; +- } +- else if ( xmlEnc.equals( UTF_16 ) && ( xmlGuessEnc.equals( UTF_16BE ) || xmlGuessEnc.equals( UTF_16LE ) ) ) +- { +- encoding = xmlGuessEnc; +- } +- else +- { +- encoding = xmlEnc; +- } +- } +- else if ( bomEnc.equals( UTF_8 ) ) +- { +- if ( xmlGuessEnc != null && !xmlGuessEnc.equals( UTF_8 ) ) +- { +- throw new XmlStreamReaderException( RAW_EX_1.format( new Object[] { bomEnc, xmlGuessEnc, xmlEnc } ), bomEnc, +- xmlGuessEnc, xmlEnc, is ); +- } +- if ( xmlEnc != null && !xmlEnc.equals( UTF_8 ) ) +- { +- throw new XmlStreamReaderException( RAW_EX_1.format( new Object[] { bomEnc, xmlGuessEnc, xmlEnc } ), bomEnc, +- xmlGuessEnc, xmlEnc, is ); +- } +- encoding = UTF_8; +- } +- else if ( bomEnc.equals( UTF_16BE ) || bomEnc.equals( UTF_16LE ) ) +- { +- if ( xmlGuessEnc != null && !xmlGuessEnc.equals( bomEnc ) ) +- { +- throw new IOException( RAW_EX_1.format( new Object[] { bomEnc, xmlGuessEnc, xmlEnc } ) ); +- } +- if ( xmlEnc != null && !xmlEnc.equals( UTF_16 ) && !xmlEnc.equals( bomEnc ) ) +- { +- throw new XmlStreamReaderException( RAW_EX_1.format( new Object[] { bomEnc, xmlGuessEnc, xmlEnc } ), bomEnc, +- xmlGuessEnc, xmlEnc, is ); +- } +- encoding = bomEnc; +- } +- else +- { +- throw new XmlStreamReaderException( RAW_EX_2.format( new Object[] { bomEnc, xmlGuessEnc, xmlEnc } ), bomEnc, +- xmlGuessEnc, xmlEnc, is ); +- } +- return encoding; +- } +- +- // InputStream is passed for XmlStreamReaderException creation only +- private String calculateHttpEncoding( String cTMime, String cTEnc, String bomEnc, String xmlGuessEnc, +- String xmlEnc, InputStream is, boolean lenient ) throws IOException +- { +- String encoding; +- if ( lenient & xmlEnc != null ) +- { +- encoding = xmlEnc; +- } +- else +- { +- boolean appXml = isAppXml( cTMime ); +- boolean textXml = isTextXml( cTMime ); +- if ( appXml || textXml ) +- { +- if ( cTEnc == null ) +- { +- if ( appXml ) +- { +- encoding = calculateRawEncoding( bomEnc, xmlGuessEnc, xmlEnc, is ); +- } +- else +- { +- encoding = ( _defaultEncoding == null ) ? US_ASCII : _defaultEncoding; +- } +- } +- else if ( bomEnc != null && ( cTEnc.equals( UTF_16BE ) || cTEnc.equals( UTF_16LE ) ) ) +- { +- throw new XmlStreamReaderException( HTTP_EX_1.format( new Object[] { cTMime, cTEnc, bomEnc, xmlGuessEnc, +- xmlEnc } ), cTMime, cTEnc, bomEnc, xmlGuessEnc, xmlEnc, is ); +- } +- else if ( cTEnc.equals( UTF_16 ) ) +- { +- if ( bomEnc != null && bomEnc.startsWith( UTF_16 ) ) +- { +- encoding = bomEnc; +- } +- else +- { +- throw new XmlStreamReaderException( HTTP_EX_2.format( new Object[] { cTMime, cTEnc, bomEnc, +- xmlGuessEnc, xmlEnc } ), cTMime, cTEnc, bomEnc, xmlGuessEnc, xmlEnc, is ); +- } +- } +- else +- { +- encoding = cTEnc; +- } +- } +- else +- { +- throw new XmlStreamReaderException( HTTP_EX_3.format( new Object[] { cTMime, cTEnc, bomEnc, xmlGuessEnc, +- xmlEnc } ), cTMime, cTEnc, bomEnc, xmlGuessEnc, xmlEnc, is ); +- } +- } +- return encoding; +- } +- +- // returns MIME type or NULL if httpContentType is NULL +- private static String getContentTypeMime( String httpContentType ) +- { +- String mime = null; +- if ( httpContentType != null ) +- { +- int i = httpContentType.indexOf( ";" ); +- mime = ( ( i == -1 ) ? httpContentType : httpContentType.substring( 0, i ) ).trim(); +- } +- return mime; +- } +- +- private static final Pattern CHARSET_PATTERN = Pattern.compile( "charset=([.[^; ]]*)" ); +- +- // returns charset parameter value, NULL if not present, NULL if httpContentType is NULL +- private static String getContentTypeEncoding( String httpContentType ) +- { +- String encoding = null; +- if ( httpContentType != null ) +- { +- int i = httpContentType.indexOf( ";" ); +- if ( i > -1 ) +- { +- String postMime = httpContentType.substring( i + 1 ); +- Matcher m = CHARSET_PATTERN.matcher( postMime ); +- encoding = ( m.find() ) ? m.group( 1 ) : null; +- encoding = ( encoding != null ) ? encoding.toUpperCase( Locale.ENGLISH ) : null; +- } +- } +- return encoding; +- } +- +- // returns the BOM in the stream, NULL if not present, +- // if there was BOM the in the stream it is consumed +- private static String getBOMEncoding( BufferedInputStream is ) throws IOException +- { +- String encoding = null; +- int[] bytes = new int[3]; +- is.mark( 3 ); +- bytes[0] = is.read(); +- bytes[1] = is.read(); +- bytes[2] = is.read(); +- +- if ( bytes[0] == 0xFE && bytes[1] == 0xFF ) +- { +- encoding = UTF_16BE; +- is.reset(); +- is.read(); +- is.read(); +- } +- else if ( bytes[0] == 0xFF && bytes[1] == 0xFE ) +- { +- encoding = UTF_16LE; +- is.reset(); +- is.read(); +- is.read(); +- } +- else if ( bytes[0] == 0xEF && bytes[1] == 0xBB && bytes[2] == 0xBF ) +- { +- encoding = UTF_8; +- } +- else +- { +- is.reset(); +- } +- return encoding; +- } +- +- // returns the best guess for the encoding by looking the first bytes of the stream, '<?' +- private static String getXMLGuessEncoding( BufferedInputStream is ) throws IOException +- { +- String encoding = null; +- int[] bytes = new int[4]; +- is.mark( 4 ); +- bytes[0] = is.read(); +- bytes[1] = is.read(); +- bytes[2] = is.read(); +- bytes[3] = is.read(); +- is.reset(); +- +- if ( bytes[0] == 0x00 && bytes[1] == 0x3C && bytes[2] == 0x00 && bytes[3] == 0x3F ) +- { +- encoding = UTF_16BE; +- } +- else if ( bytes[0] == 0x3C && bytes[1] == 0x00 && bytes[2] == 0x3F && bytes[3] == 0x00 ) +- { +- encoding = UTF_16LE; +- } +- else if ( bytes[0] == 0x3C && bytes[1] == 0x3F && bytes[2] == 0x78 && bytes[3] == 0x6D ) +- { +- encoding = UTF_8; +- } +- else if ( bytes[0] == 0x4C && bytes[1] == 0x6F && bytes[2] == 0xA7 && bytes[3] == 0x94 ) +- { +- encoding = EBCDIC; +- } +- return encoding; +- } +- +- static final Pattern ENCODING_PATTERN = +- Pattern.compile( "<\\?xml.*encoding[\\s]*=[\\s]*((?:\".[^\"]*\")|(?:'.[^']*'))", Pattern.MULTILINE ); +- +- // returns the encoding declared in the <?xml encoding=...?>, NULL if none +- private static String getXmlProlog( BufferedInputStream is, String guessedEnc ) throws IOException +- { +- String encoding = null; +- if ( guessedEnc != null ) +- { +- byte[] bytes = new byte[BUFFER_SIZE]; +- is.mark( BUFFER_SIZE ); +- int offset = 0; +- int max = BUFFER_SIZE; +- int c = is.read( bytes, offset, max ); +- int firstGT = -1; +- String xmlProlog = null; +- while ( c != -1 && firstGT == -1 && offset < BUFFER_SIZE ) +- { +- offset += c; +- max -= c; +- c = is.read( bytes, offset, max ); +- xmlProlog = new String( bytes, 0, offset, guessedEnc ); +- firstGT = xmlProlog.indexOf( '>' ); +- } +- if ( firstGT == -1 ) +- { +- if ( c == -1 ) +- { +- throw new IOException( "Unexpected end of XML stream" ); +- } +- else +- { +- throw new IOException( "XML prolog or ROOT element not found on first " + offset + " bytes" ); +- } +- } +- int bytesRead = offset; +- if ( bytesRead > 0 ) +- { +- is.reset(); +- BufferedReader bReader = new BufferedReader( new StringReader( xmlProlog.substring( 0, firstGT + 1 ) ) ); +- StringBuffer prolog = new StringBuffer(); +- String line = bReader.readLine(); +- while ( line != null ) +- { +- prolog.append( line ); +- line = bReader.readLine(); +- } +- Matcher m = ENCODING_PATTERN.matcher( prolog ); +- if ( m.find() ) +- { +- encoding = m.group( 1 ).toUpperCase( Locale.ENGLISH ); +- encoding = encoding.substring( 1, encoding.length() - 1 ); +- } +- } +- } +- return encoding; +- } +- +- // indicates if the MIME type belongs to the APPLICATION XML family +- private static boolean isAppXml( String mime ) +- { +- return mime != null +- && ( mime.equals( "application/xml" ) || mime.equals( "application/xml-dtd" ) +- || mime.equals( "application/xml-external-parsed-entity" ) || ( mime.startsWith( "application/" ) && mime.endsWith( "+xml" ) ) ); +- } +- +- // indicates if the MIME type belongs to the TEXT XML family +- private static boolean isTextXml( String mime ) +- { +- return mime != null +- && ( mime.equals( "text/xml" ) || mime.equals( "text/xml-external-parsed-entity" ) || ( mime.startsWith( "text/" ) && mime.endsWith( "+xml" ) ) ); +- } +- +- private static final MessageFormat RAW_EX_1 = +- new MessageFormat( "Invalid encoding, BOM [{0}] XML guess [{1}] XML prolog [{2}] encoding mismatch" ); +- +- private static final MessageFormat RAW_EX_2 = +- new MessageFormat( "Invalid encoding, BOM [{0}] XML guess [{1}] XML prolog [{2}] unknown BOM" ); +- +- private static final MessageFormat HTTP_EX_1 = +- new MessageFormat( +- "Invalid encoding, CT-MIME [{0}] CT-Enc [{1}] BOM [{2}] XML guess [{3}] XML prolog [{4}], BOM must be NULL" ); +- +- private static final MessageFormat HTTP_EX_2 = +- new MessageFormat( +- "Invalid encoding, CT-MIME [{0}] CT-Enc [{1}] BOM [{2}] XML guess [{3}] XML prolog [{4}], encoding mismatch" ); +- +- private static final MessageFormat HTTP_EX_3 = +- new MessageFormat( +- "Invalid encoding, CT-MIME [{0}] CT-Enc [{1}] BOM [{2}] XML guess [{3}] XML prolog [{4}], Invalid MIME" ); +- +-} +diff -Nru gshell-2.6.5/gshell-util/src/main/java/org/codehaus/plexus/util/xml/XmlStreamReaderException.java gshell-2.6.5-gil/gshell-util/src/main/java/org/codehaus/plexus/util/xml/XmlStreamReaderException.java +--- gshell-2.6.5/gshell-util/src/main/java/org/codehaus/plexus/util/xml/XmlStreamReaderException.java 2011-12-28 20:41:12.000000000 +0100 ++++ gshell-2.6.5-gil/gshell-util/src/main/java/org/codehaus/plexus/util/xml/XmlStreamReaderException.java 1970-01-01 01:00:00.000000000 +0100 +@@ -1,85 +0,0 @@ +-/* +- * Copyright 2004 Sun Microsystems, Inc. +- * +- * Licensed under the Apache License, Version 2.0 (the "License"); +- * you may not use this file except in compliance with the License. +- * You may obtain a copy of the License at +- * +- * http://www.apache.org/licenses/LICENSE-2.0 +- * +- * Unless required by applicable law or agreed to in writing, software +- * distributed under the License is distributed on an "AS IS" BASIS, +- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +- * See the License for the specific language governing permissions and +- * limitations under the License. +- * +- */ +-package org.codehaus.plexus.util.xml; +- +-import java.io.InputStream; +- +-/** +- * The XmlStreamReaderException is thrown by the XmlStreamReader constructors if the charset encoding can not be determined +- * according to the XML 1.0 specification and RFC 3023. +- * <p> +- * The exception returns the unconsumed InputStream to allow the application to do an alternate processing with the +- * stream. Note that the original InputStream given to the XmlStreamReader cannot be used as that one has been already read. +- * <p> +- * +- * @author Alejandro Abdelnur +- * @version revision 1.1 taken on 26/06/2007 from Rome (see https://rome.dev.java.net/source/browse/rome/src/java/com/sun/syndication/io...) +- */ +-@Deprecated +-public class XmlStreamReaderException extends XmlReaderException +-{ +- /** +- * Creates an exception instance if the charset encoding could not be determined. +- * <p> +- * Instances of this exception are thrown by the XmlReader. +- * <p> +- * +- * @param msg +- * message describing the reason for the exception. +- * @param bomEnc +- * BOM encoding. +- * @param xmlGuessEnc +- * XML guess encoding. +- * @param xmlEnc +- * XML prolog encoding. +- * @param is +- * the unconsumed InputStream. +- * +- */ +- public XmlStreamReaderException( String msg, String bomEnc, String xmlGuessEnc, String xmlEnc, InputStream is ) +- { +- super( msg, bomEnc, xmlGuessEnc, xmlEnc, is ); +- } +- +- /** +- * Creates an exception instance if the charset encoding could not be determined. +- * <p> +- * Instances of this exception are thrown by the XmlReader. +- * <p> +- * +- * @param msg +- * message describing the reason for the exception. +- * @param ctMime +- * MIME type in the content-type. +- * @param ctEnc +- * encoding in the content-type. +- * @param bomEnc +- * BOM encoding. +- * @param xmlGuessEnc +- * XML guess encoding. +- * @param xmlEnc +- * XML prolog encoding. +- * @param is +- * the unconsumed InputStream. +- * +- */ +- public XmlStreamReaderException( String msg, String ctMime, String ctEnc, String bomEnc, String xmlGuessEnc, +- String xmlEnc, InputStream is ) +- { +- super( msg, ctMime, ctEnc, bomEnc, xmlGuessEnc, xmlEnc, is ); +- } +-} +diff -Nru gshell-2.6.5/gshell-util/src/main/java/org/codehaus/plexus/util/xml/XmlStreamReader.java gshell-2.6.5-gil/gshell-util/src/main/java/org/codehaus/plexus/util/xml/XmlStreamReader.java +--- gshell-2.6.5/gshell-util/src/main/java/org/codehaus/plexus/util/xml/XmlStreamReader.java 2011-12-28 20:41:12.000000000 +0100 ++++ gshell-2.6.5-gil/gshell-util/src/main/java/org/codehaus/plexus/util/xml/XmlStreamReader.java 1970-01-01 01:00:00.000000000 +0100 +@@ -1,271 +0,0 @@ +-/* +- * Copyright 2004 Sun Microsystems, Inc. +- * +- * Licensed under the Apache License, Version 2.0 (the "License"); +- * you may not use this file except in compliance with the License. +- * You may obtain a copy of the License at +- * +- * http://www.apache.org/licenses/LICENSE-2.0 +- * +- * Unless required by applicable law or agreed to in writing, software +- * distributed under the License is distributed on an "AS IS" BASIS, +- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +- * See the License for the specific language governing permissions and +- * limitations under the License. +- * +- */ +-package org.codehaus.plexus.util.xml; +- +-import java.io.File; +-import java.io.IOException; +-import java.io.InputStream; +-import java.net.URL; +-import java.net.URLConnection; +- +-/** +- * Character stream that handles (or at least attemtps to) all the necessary Voodo to figure out the charset encoding of +- * the XML document within the stream. +- * <p> +- * IMPORTANT: This class is not related in any way to the org.xml.sax.XMLReader. This one IS a character stream. +- * <p> +- * All this has to be done without consuming characters from the stream, if not the XML parser will not recognized the +- * document as a valid XML. This is not 100% true, but it's close enough (UTF-8 BOM is not handled by all parsers right +- * now, XmlReader handles it and things work in all parsers). +- * <p> +- * The XmlReader class handles the charset encoding of XML documents in Files, raw streams and HTTP streams by offering +- * a wide set of constructors. +- * <P> +- * By default the charset encoding detection is lenient, the constructor with the lenient flag can be used for an script +- * (following HTTP MIME and XML specifications). All this is nicely explained by Mark Pilgrim in his blog, <a +- * href="http://diveintomark.org/archives/2004/02/13/xml-media-types%22%3E Determining the character encoding of a feed</a>. +- * <p> +- * +- * @author Alejandro Abdelnur +- * @version revision 1.17 taken on 26/06/2007 from Rome (see https://rome.dev.java.net/source/browse/rome/src/java/com/sun/syndication/io...) +- * @since 1.4.4 +- */ +-@Deprecated +-public class XmlStreamReader +-extends XmlReader +-{ +- /** +- * Creates a Reader for a File. +- * <p> +- * It looks for the UTF-8 BOM first, if none sniffs the XML prolog charset, if this is also missing defaults to +- * UTF-8. +- * <p> +- * It does a lenient charset encoding detection, check the constructor with the lenient parameter for details. +- * <p> +- * +- * @param file +- * File to create a Reader from. +- * @throws IOException +- * thrown if there is a problem reading the file. +- * +- */ +- public XmlStreamReader( File file ) throws IOException +- { +- super( file ); +- } +- +- /** +- * Creates a Reader for a raw InputStream. +- * <p> +- * It follows the same logic used for files. +- * <p> +- * It does a lenient charset encoding detection, check the constructor with the lenient parameter for details. +- * <p> +- * +- * @param is +- * InputStream to create a Reader from. +- * @throws IOException +- * thrown if there is a problem reading the stream. +- * +- */ +- public XmlStreamReader( InputStream is ) throws IOException +- { +- super( is ); +- } +- +- /** +- * Creates a Reader for a raw InputStream. +- * <p> +- * It follows the same logic used for files. +- * <p> +- * If lenient detection is indicated and the detection above fails as per specifications it then attempts the +- * following: +- * <p> +- * If the content type was 'text/html' it replaces it with 'text/xml' and tries the detection again. +- * <p> +- * Else if the XML prolog had a charset encoding that encoding is used. +- * <p> +- * Else if the content type had a charset encoding that encoding is used. +- * <p> +- * Else 'UTF-8' is used. +- * <p> +- * If lenient detection is indicated an XmlStreamReaderException is never thrown. +- * <p> +- * +- * @param is +- * InputStream to create a Reader from. +- * @param lenient +- * indicates if the charset encoding detection should be relaxed. +- * @throws IOException +- * thrown if there is a problem reading the stream. +- * @throws XmlStreamReaderException +- * thrown if the charset encoding could not be determined according to the specs. +- * +- */ +- public XmlStreamReader( InputStream is, boolean lenient ) throws IOException, XmlStreamReaderException +- { +- super( is, lenient ); +- } +- +- /** +- * Creates a Reader using the InputStream of a URL. +- * <p> +- * If the URL is not of type HTTP and there is not 'content-type' header in the fetched data it uses the same logic +- * used for Files. +- * <p> +- * If the URL is a HTTP Url or there is a 'content-type' header in the fetched data it uses the same logic used for +- * an InputStream with content-type. +- * <p> +- * It does a lenient charset encoding detection, check the constructor with the lenient parameter for details. +- * <p> +- * +- * @param url +- * URL to create a Reader from. +- * @throws IOException +- * thrown if there is a problem reading the stream of the URL. +- * +- */ +- public XmlStreamReader( URL url ) throws IOException +- { +- super( url ); +- } +- +- /** +- * Creates a Reader using the InputStream of a URLConnection. +- * <p> +- * If the URLConnection is not of type HttpURLConnection and there is not 'content-type' header in the fetched data +- * it uses the same logic used for files. +- * <p> +- * If the URLConnection is a HTTP Url or there is a 'content-type' header in the fetched data it uses the same logic +- * used for an InputStream with content-type. +- * <p> +- * It does a lenient charset encoding detection, check the constructor with the lenient parameter for details. +- * <p> +- * +- * @param conn +- * URLConnection to create a Reader from. +- * @throws IOException +- * thrown if there is a problem reading the stream of the URLConnection. +- * +- */ +- public XmlStreamReader( URLConnection conn ) throws IOException +- { +- super( conn ); +- } +- +- /** +- * Creates a Reader using an InputStream an the associated content-type header. +- * <p> +- * First it checks if the stream has BOM. If there is not BOM checks the content-type encoding. If there is not +- * content-type encoding checks the XML prolog encoding. If there is not XML prolog encoding uses the default +- * encoding mandated by the content-type MIME type. +- * <p> +- * It does a lenient charset encoding detection, check the constructor with the lenient parameter for details. +- * <p> +- * +- * @param is +- * InputStream to create the reader from. +- * @param httpContentType +- * content-type header to use for the resolution of the charset encoding. +- * @throws IOException +- * thrown if there is a problem reading the file. +- * +- */ +- public XmlStreamReader( InputStream is, String httpContentType ) throws IOException +- { +- super( is, httpContentType ); +- } +- +- /** +- * Creates a Reader using an InputStream an the associated content-type header. This constructor is lenient +- * regarding the encoding detection. +- * <p> +- * First it checks if the stream has BOM. If there is not BOM checks the content-type encoding. If there is not +- * content-type encoding checks the XML prolog encoding. If there is not XML prolog encoding uses the default +- * encoding mandated by the content-type MIME type. +- * <p> +- * If lenient detection is indicated and the detection above fails as per specifications it then attempts the +- * following: +- * <p> +- * If the content type was 'text/html' it replaces it with 'text/xml' and tries the detection again. +- * <p> +- * Else if the XML prolog had a charset encoding that encoding is used. +- * <p> +- * Else if the content type had a charset encoding that encoding is used. +- * <p> +- * Else 'UTF-8' is used. +- * <p> +- * If lenient detection is indicated an XmlStreamReaderException is never thrown. +- * <p> +- * +- * @param is +- * InputStream to create the reader from. +- * @param httpContentType +- * content-type header to use for the resolution of the charset encoding. +- * @param lenient +- * indicates if the charset encoding detection should be relaxed. +- * @throws IOException +- * thrown if there is a problem reading the file. +- * @throws XmlStreamReaderException +- * thrown if the charset encoding could not be determined according to the specs. +- * +- */ +- public XmlStreamReader( InputStream is, String httpContentType, boolean lenient, String defaultEncoding ) +- throws IOException, XmlStreamReaderException +- { +- super( is, httpContentType, lenient, defaultEncoding ); +- } +- +- /** +- * Creates a Reader using an InputStream an the associated content-type header. This constructor is lenient +- * regarding the encoding detection. +- * <p> +- * First it checks if the stream has BOM. If there is not BOM checks the content-type encoding. If there is not +- * content-type encoding checks the XML prolog encoding. If there is not XML prolog encoding uses the default +- * encoding mandated by the content-type MIME type. +- * <p> +- * If lenient detection is indicated and the detection above fails as per specifications it then attempts the +- * following: +- * <p> +- * If the content type was 'text/html' it replaces it with 'text/xml' and tries the detection again. +- * <p> +- * Else if the XML prolog had a charset encoding that encoding is used. +- * <p> +- * Else if the content type had a charset encoding that encoding is used. +- * <p> +- * Else 'UTF-8' is used. +- * <p> +- * If lenient detection is indicated an XmlStreamReaderException is never thrown. +- * <p> +- * +- * @param is +- * InputStream to create the reader from. +- * @param httpContentType +- * content-type header to use for the resolution of the charset encoding. +- * @param lenient +- * indicates if the charset encoding detection should be relaxed. +- * @throws IOException +- * thrown if there is a problem reading the file. +- * @throws XmlStreamReaderException +- * thrown if the charset encoding could not be determined according to the specs. +- * +- */ +- public XmlStreamReader( InputStream is, String httpContentType, boolean lenient ) throws IOException, XmlStreamReaderException +- { +- super( is, httpContentType, lenient ); +- } +-} diff --git a/gshell-2.6.5-remove-commons-jexl1.patch b/gshell-2.6.5-remove-commons-jexl1.patch new file mode 100644 index 0000000..39c8093 --- /dev/null +++ b/gshell-2.6.5-remove-commons-jexl1.patch @@ -0,0 +1,224 @@ +diff -Nru gshell-2.6.5/gshell-core/pom.xml gshell-2.6.5-gil/gshell-core/pom.xml +--- gshell-2.6.5/gshell-core/pom.xml 2012-06-19 13:21:39.778988659 +0200 ++++ gshell-2.6.5-gil/gshell-core/pom.xml 2012-06-19 13:16:22.927978964 +0200 +@@ -56,11 +56,11 @@ + <artifactId>sisu-inject-bean</artifactId> + </dependency> + +- <dependency> ++ <!--dependency> + <groupId>commons-jexl</groupId> + <artifactId>commons-jexl</artifactId> + <optional>true</optional> +- </dependency> ++ </dependency--> + + <dependency> + <groupId>junit</groupId> +diff -Nru gshell-2.6.5/gshell-core/src/main/java/org/sonatype/gshell/parser/impl/eval/EvaluatorFactory.java gshell-2.6.5-gil/gshell-core/src/main/java/org/sonatype/gshell/parser/impl/eval/EvaluatorFactory.java +--- gshell-2.6.5/gshell-core/src/main/java/org/sonatype/gshell/parser/impl/eval/EvaluatorFactory.java 2011-12-28 20:41:12.000000000 +0100 ++++ gshell-2.6.5-gil/gshell-core/src/main/java/org/sonatype/gshell/parser/impl/eval/EvaluatorFactory.java 2012-06-19 13:21:23.653988166 +0200 +@@ -48,14 +48,14 @@ + } + } + +- try { ++ /*try { + cl.loadClass("org.apache.commons.jexl.Expression"); + + return new JexlEvaluator(); + } + catch (Exception e) { + // ignore +- } ++ }*/ + + return new DefaultEvaluator(); + } +diff -Nru gshell-2.6.5/gshell-core/src/main/java/org/sonatype/gshell/parser/impl/eval/JexlEvaluator.java gshell-2.6.5-gil/gshell-core/src/main/java/org/sonatype/gshell/parser/impl/eval/JexlEvaluator.java +--- gshell-2.6.5/gshell-core/src/main/java/org/sonatype/gshell/parser/impl/eval/JexlEvaluator.java 2011-12-28 20:41:12.000000000 +0100 ++++ gshell-2.6.5-gil/gshell-core/src/main/java/org/sonatype/gshell/parser/impl/eval/JexlEvaluator.java 1970-01-01 01:00:00.000000000 +0100 +@@ -1,161 +0,0 @@ +-/** +- * Copyright (c) 2009-2011 the original author or authors. +- * +- * Licensed under the Apache License, Version 2.0 (the "License"); +- * you may not use this file except in compliance with the License. +- * You may obtain a copy of the License at +- * +- * http://www.apache.org/licenses/LICENSE-2.0 +- * +- * Unless required by applicable law or agreed to in writing, software +- * distributed under the License is distributed on an "AS IS" BASIS, +- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +- * See the License for the specific language governing permissions and +- * limitations under the License. +- */ +-package org.sonatype.gshell.parser.impl.eval; +- +-import org.apache.commons.jexl.Expression; +-import org.apache.commons.jexl.ExpressionFactory; +-import org.apache.commons.jexl.JexlContext; +-import org.apache.commons.jexl.resolver.FlatResolver; +-import org.slf4j.Logger; +-import org.slf4j.LoggerFactory; +-import org.sonatype.gshell.shell.ShellHolder; +-import org.sonatype.gshell.util.ReplacementParser; +-import org.sonatype.gshell.variables.Variables; +- +-import java.util.Collection; +-import java.util.Map; +-import java.util.Set; +- +-/** +- * Uses Commons Jexl to evaluate expressions. +- * +- * @author <a href="mailto:jason@planet57.com">Jason Dillon</a> +- * @since 2.0 +- */ +-public class JexlEvaluator +- implements Evaluator +-{ +- private final Logger log = LoggerFactory.getLogger(getClass()); +- +- private final ReplacementParser parser = new ReplacementParser() +- { +- @Override +- protected Object replace(final String key) throws Exception { +- assert key != null; +- +- log.debug("Evaluating: {}", key); +- +- JexlContext ctx = new Context(); +- Expression expr = ExpressionFactory.createExpression(key); +- expr.addPostResolver(resolver); +- +- Object result = expr.evaluate(ctx); +- +- log.debug("Result: {}", result); +- +- return result; +- } +- }; +- +- private final FlatResolver resolver = new FlatResolver(true); +- +- public Object eval(String expression) throws Exception { +- // expression could be null +- +- // Skip evaluation if null or there is no start token +- if (expression == null || !expression.contains("${")) { +- return expression; +- } +- +- return parser.parse(expression); +- } +- +- private static class Context +- implements JexlContext +- { +- private final ContextVariables vars = new ContextVariables(); +- +- public void setVars(final Map map) { +- throw new UnsupportedOperationException(); +- } +- +- public Map getVars() { +- return vars; +- } +- } +- +- private static class ContextVariables +- implements Map<String, Object> +- { +- private final Variables vars = ShellHolder.get().getVariables(); +- +- public Object get(final Object key) { +- assert key != null; +- +- String name = String.valueOf(key); +- Object value; +- +- value = vars.get(name); +- if (value == null) { +- value = System.getProperty(name); +- } +- +- return value; +- } +- +- public Object put(final String key, final Object value) { +- assert key != null; +- +- Object prev = get(key); +- +- vars.set(key, value); +- +- return prev; +- } +- +- // Jexl only uses Map.put() and Map.get() stub everything else +- +- public int size() { +- return 0; +- } +- +- public boolean isEmpty() { +- return false; +- } +- +- public boolean containsKey(Object key) { +- return false; +- } +- +- public boolean containsValue(Object value) { +- return false; +- } +- +- public Object remove(Object key) { +- return null; +- } +- +- public void putAll(Map<? extends String, ? extends Object> m) { +- // empty +- } +- +- public void clear() { +- // empty +- } +- +- public Set<String> keySet() { +- return null; +- } +- +- public Collection<Object> values() { +- return null; +- } +- +- public Set<Entry<String, Object>> entrySet() { +- return null; +- } +- } +-} +\ Manca newline alla fine del file +diff -Nru gshell-2.6.5/pom.xml gshell-2.6.5-gil/pom.xml +--- gshell-2.6.5/pom.xml 2012-06-19 13:21:39.780988659 +0200 ++++ gshell-2.6.5-gil/pom.xml 2012-06-19 13:15:51.034977988 +0200 +@@ -166,7 +166,7 @@ + <classifier>tests</classifier> + </dependency> + +- <dependency> ++ <!--dependency> + <groupId>commons-jexl</groupId> + <artifactId>commons-jexl</artifactId> + <version>1.1</version> +@@ -180,7 +180,7 @@ + <artifactId>junit</artifactId> + </exclusion> + </exclusions> +- </dependency> ++ </dependency--> + + <dependency> + <groupId>commons-cli</groupId> diff --git a/gshell.spec b/gshell.spec new file mode 100644 index 0000000..c74f2b4 --- /dev/null +++ b/gshell.spec @@ -0,0 +1,262 @@ +Name: gshell +Version: 2.6.5 +Release: 3%{?dist} +Summary: A command-line shell framework +Group: Development/Libraries +License: ASL 2.0 +URL: https://github.com/sonatype/gshell +# git clone git://github.com/sonatype/gshell.git gshell-2.6.5 +# cd gshell-2.6.5/ && git archive --format=tar --prefix=gshell-2.6.5/ gshell-2.6.5 | gzip > ../gshell-2.6.5-src-git.tar.gz +Source0: gshell-2.6.5-src-git.tar.gz +# remove +# org.codehaus.mojo versions-maven-plugin 1.2 +# org.codehaus.gmaven gmaven-plugin 1.3 +# org.sonatype.maven.plugins maven-sisu-assembler-plugin 1.0.7 +# org.sonatype.plugins sisu-maven-plugin 1.0 +# add plexus-classworlds +# add guice +Patch0: gshell-2.6.5-build.patch + +Patch1: gshell-2.6.4-javacc.patch +# remove commons-jexl 1.1 support +Patch2: gshell-2.6.5-remove-commons-jexl1.patch + +# use system plexus-utils +Patch3: gshell-2.6.5-dont-use-repackaged-plexus-utils.patch + +Patch4: gshell-2.6.5-disable-gshell-bootstrap.patch + +BuildRequires: forge-parent +BuildRequires: fusesource-pom +BuildRequires: java-devel +BuildRequires: jpackage-utils + +BuildRequires: apache-commons-cli +BuildRequires: google-guice +BuildRequires: groovy +BuildRequires: guava +#BuildRequires: jetty +BuildRequires: jetty-security +BuildRequires: jetty-server +BuildRequires: jetty-servlet +BuildRequires: jetty-webapp +BuildRequires: jetty-xml +BuildRequires: jline2 +BuildRequires: logback +BuildRequires: plexus-classworlds +BuildRequires: plexus-containers-container-default +BuildRequires: plexus-interpolation +BuildRequires: plexus-utils +BuildRequires: sisu +BuildRequires: slf4j +BuildRequires: sonatype-gossip +BuildRequires: xstream + +# test dep +BuildRequires: junit + +BuildRequires: animal-sniffer +BuildRequires: apache-resource-bundles +BuildRequires: javacc-maven-plugin +BuildRequires: maven +BuildRequires: maven-compiler-plugin +BuildRequires: maven-enforcer-plugin +BuildRequires: maven-install-plugin +BuildRequires: maven-jar-plugin +BuildRequires: maven-javadoc-plugin +BuildRequires: maven-plugin-plugin +BuildRequires: maven-remote-resources-plugin +BuildRequires: maven-resources-plugin +BuildRequires: maven-source-plugin +BuildRequires: maven-surefire-plugin +BuildRequires: maven-surefire-provider-junit4 +BuildRequires: modello +BuildRequires: mojo-signatures + +Requires: apache-commons-cli +Requires: google-guice +Requires: groovy +Requires: guava +#Requires: jetty +Requires: jetty-security +Requires: jetty-server +Requires: jetty-servlet +Requires: jetty-webapp +Requires: jetty-xml +Requires: jline2 +Requires: logback +Requires: plexus-classworlds +Requires: plexus-containers-container-default +Requires: plexus-interpolation +Requires: plexus-utils +Requires: sisu +Requires: slf4j +Requires: sonatype-gossip +Requires: xstream + +Requires: java +Requires: jpackage-utils +BuildArch: noarch + +%description +GShell is a framework for building rich command-line applications. The +core of GShell provides the basic features needed by most commands, +such as command-line argument/option processing, input/output redirection, +preferences handling, ANSI support and a whole lot more. + +%package maven-plugin +Group: Development/Libraries +Summary: GShell :: Maven Plugin +Requires: maven +Requires: sonatype-gossip +Requires: %{name} = %{version}-%{release} + +%description maven-plugin +This package provides GShell :: Maven Plugin. + +%package javadoc +Group: Documentation +Summary: Javadoc for %{name} +Requires: jpackage-utils + +%description javadoc +This package contains javadoc for %{name}. + +%prep +%setup -q -n gshell-%{version} +%patch0 -p1 +%patch1 -p1 +%patch2 -p1 +%patch3 -p1 + +# TODO bootstrap disable +# contains the bootstrap.properties and the same classes of the launcher artifact +%patch4 -p0 +#cp -p gshell-bootstrap/src/main/filtered-resources/bootstrap.properties gshell-launcher/src/main/resources + +# regenerate sources +rm -rf gshell-core/src/main/java/org/sonatype/gshell/parser/impl/AST*.java + +# Tests run: 8, Failures: 1, Errors: 0, Skipped: 0, Time elapsed: 0.103 sec <<< FAILURE! +# testEchoWithSpacePadding(org.sonatype.gshell.commands.standard.EchoCommandTest): expected:<[' foo '] +rm gshell-commands/gshell-standard/src/test/java/org/sonatype/gshell/commands/standard/EchoCommandTest.java + +# disabled for now animal-sniffer-maven-plugin build conflict with asm3 and asm4 +%pom_remove_plugin org.codehaus.mojo:animal-sniffer-maven-plugin + +%build + +mvn-rpmbuild -DskipAssembly=true install javadoc:aggregate + +%install + +mkdir -p %{buildroot}%{_javadir}/%{name} +mkdir -p %{buildroot}%{_mavenpomdir} + +install -pm 644 pom.xml %{buildroot}%{_mavenpomdir}/JPP.%{name}-%{name}.pom +%add_maven_depmap JPP.%{name}-%{name}.pom + +# TODO +#install -m 644 gshell-bootstrap/target/gshell-bootstrap-%%{version}-sources.jar %%{buildroot}%%{_javadir}/%%{name}/%%{name}-bootstrap.jar +#install -pm 644 gshell-bootstrap/pom.xml %%{buildroot}%%{_mavenpomdir}/JPP.%%{name}-%%{name}-bootstrap.pom +#dd_maven_depmap JPP.%%{name}-%%{name}-bootstrap.pom %%{name}/%%{name}-bootstrap.jar + +for p in core launcher ui util ; do + install -m 644 %{name}-$p/target/%{name}-$p-%{version}.jar %{buildroot}%{_javadir}/%{name}/%{name}-$p.jar + install -pm 644 %{name}-$p/pom.xml %{buildroot}%{_mavenpomdir}/JPP.%{name}-%{name}-$p.pom + %add_maven_depmap JPP.%{name}-%{name}-$p.pom %{name}/%{name}-$p.jar +done + +install -m 644 %{name}-core/target/%{name}-core-%{version}-tests.jar %{buildroot}%{_javadir}/%{name}/%{name}-core-tests.jar + +install -pm 644 %{name}-commands/pom.xml %{buildroot}%{_mavenpomdir}/JPP.%{name}-%{name}-commands.pom +%add_maven_depmap JPP.%{name}-%{name}-commands.pom + +for c in file \ + groovy \ + jetty \ + logging \ + network \ + pref \ + standard; do + install -m 644 %{name}-commands/%{name}-$c/target/%{name}-$c-%{version}.jar %{buildroot}%{_javadir}/%{name}/%{name}-$c.jar + install -pm 644 %{name}-commands/%{name}-$c/pom.xml %{buildroot}%{_mavenpomdir}/JPP.%{name}-%{name}-$c.pom + %add_maven_depmap JPP.%{name}-%{name}-$c.pom %{name}/%{name}-$c.jar +done + +install -pm 644 %{name}-ext/pom.xml %{buildroot}%{_mavenpomdir}/JPP.%{name}-%{name}-ext.pom +%add_maven_depmap JPP.%{name}-%{name}-ext.pom + +for e in gossip logback plexus ; do + install -m 644 %{name}-ext/%{name}-$e/target/%{name}-$e-%{version}.jar %{buildroot}%{_javadir}/%{name}/%{name}-$e.jar + install -pm 644 %{name}-ext/%{name}-$e/pom.xml %{buildroot}%{_mavenpomdir}/JPP.%{name}-%{name}-$e.pom + %add_maven_depmap JPP.%{name}-%{name}-$e.pom %{name}/%{name}-$e.jar +done + +install -m 644 %{name}-maven-plugin/target/%{name}-maven-plugin-%{version}.jar %{buildroot}%{_javadir}/%{name}/%{name}-maven-plugin.jar +install -pm 644 %{name}-maven-plugin/pom.xml %{buildroot}%{_mavenpomdir}/JPP.%{name}-%{name}-maven-plugin.pom +%add_maven_depmap -f maven-plugin JPP.%{name}-%{name}-maven-plugin.pom %{name}/%{name}-maven-plugin.jar + +mkdir -p %{buildroot}%{_javadocdir}/%{name} +cp -pr target/site/apidocs/* %{buildroot}%{_javadocdir}/%{name} + +cp -p target/maven-shared-archive-resources/META-INF/LICENSE.txt . +cp -p target/maven-shared-archive-resources/META-INF/NOTICE.txt . + +%files +%dir %{_javadir}/%{name} +%{_javadir}/%{name}/%{name}-core-tests.jar +%{_javadir}/%{name}/%{name}-core.jar +%{_javadir}/%{name}/%{name}-file.jar +%{_javadir}/%{name}/%{name}-gossip.jar +%{_javadir}/%{name}/%{name}-groovy.jar +%{_javadir}/%{name}/%{name}-launcher.jar +%{_javadir}/%{name}/%{name}-logback.jar +%{_javadir}/%{name}/%{name}-logging.jar +%{_javadir}/%{name}/%{name}-network.jar +%{_javadir}/%{name}/%{name}-plexus.jar +%{_javadir}/%{name}/%{name}-pref.jar +%{_javadir}/%{name}/%{name}-standard.jar +%{_javadir}/%{name}/%{name}-ui.jar +%{_javadir}/%{name}/%{name}-util.jar +%{_javadir}/%{name}/%{name}-jetty.jar +%{_mavenpomdir}/JPP.%{name}-%{name}-jetty.pom +%{_mavenpomdir}/JPP.%{name}-%{name}-commands.pom +%{_mavenpomdir}/JPP.%{name}-%{name}-core.pom +%{_mavenpomdir}/JPP.%{name}-%{name}-ext.pom +%{_mavenpomdir}/JPP.%{name}-%{name}-file.pom +%{_mavenpomdir}/JPP.%{name}-%{name}-gossip.pom +%{_mavenpomdir}/JPP.%{name}-%{name}-groovy.pom +%{_mavenpomdir}/JPP.%{name}-%{name}-launcher.pom +%{_mavenpomdir}/JPP.%{name}-%{name}-logback.pom +%{_mavenpomdir}/JPP.%{name}-%{name}-logging.pom +%{_mavenpomdir}/JPP.%{name}-%{name}-network.pom +%{_mavenpomdir}/JPP.%{name}-%{name}-plexus.pom +%{_mavenpomdir}/JPP.%{name}-%{name}-pref.pom +%{_mavenpomdir}/JPP.%{name}-%{name}-standard.pom +%{_mavenpomdir}/JPP.%{name}-%{name}-ui.pom +%{_mavenpomdir}/JPP.%{name}-%{name}-util.pom +%{_mavenpomdir}/JPP.%{name}-%{name}.pom +%{_mavendepmapfragdir}/%{name} +%doc README.md LICENSE.txt NOTICE.txt + +%files maven-plugin +%{_javadir}/%{name}/%{name}-maven-plugin.jar +%{_mavenpomdir}/JPP.%{name}-%{name}-maven-plugin.pom +%{_mavendepmapfragdir}/%{name}-maven-plugin +%doc LICENSE.txt NOTICE.txt + +%files javadoc +%{_javadocdir}/%{name} +%doc LICENSE.txt NOTICE.txt + +%changelog +* Wed Aug 08 2012 gil cattaneo puntogil@libero.it 2.6.5-3 +- Installed LICENSE.txt NOTICE.txt in each package + +* Wed Aug 08 2012 gil cattaneo puntogil@libero.it 2.6.5-2 +- Added missing buildrequires mojo-signatures +- Disabled animal-sniffer-maven-plugin (conflict with asm packages) + +* Tue Jun 19 2012 gil cattaneo puntogil@libero.it 2.6.5-1 +- initial rpm \ No newline at end of file diff --git a/sources b/sources index e69de29..7af55c9 100644 --- a/sources +++ b/sources @@ -0,0 +1 @@ +d53379a5da050c76aa91af8b14ff10c8 gshell-2.6.5-src-git.tar.gz
java-sig-commits@lists.fedoraproject.org