ohair@286: /*
mkos@397:  * Copyright (c) 2009, Oracle and/or its affiliates. All rights reserved.
ohair@286:  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
ohair@286:  *
ohair@286:  * This code is free software; you can redistribute it and/or modify it
ohair@286:  * under the terms of the GNU General Public License version 2 only, as
ohair@286:  * published by the Free Software Foundation.  Oracle designates this
ohair@286:  * particular file as subject to the "Classpath" exception as provided
ohair@286:  * by Oracle in the LICENSE file that accompanied this code.
ohair@286:  *
ohair@286:  * This code is distributed in the hope that it will be useful, but WITHOUT
ohair@286:  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
ohair@286:  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
ohair@286:  * version 2 for more details (a copy is included in the LICENSE file that
ohair@286:  * accompanied this code).
ohair@286:  *
ohair@286:  * You should have received a copy of the GNU General Public License version
ohair@286:  * 2 along with this work; if not, write to the Free Software Foundation,
ohair@286:  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
ohair@286:  *
ohair@286:  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
ohair@286:  * or visit www.oracle.com if you need additional information or have any
ohair@286:  * questions.
ohair@286:  */
ohair@286: 
ohair@286: package com.sun.xml.internal.dtdparser;
ohair@286: 
ohair@286: import java.io.ByteArrayInputStream;
ohair@286: import java.io.CharConversionException;
ohair@286: import java.io.IOException;
ohair@286: import java.io.InputStream;
ohair@286: import java.io.InputStreamReader;
ohair@286: import java.io.PushbackInputStream;
ohair@286: import java.io.Reader;
ohair@286: import java.util.Hashtable;
ohair@286: 
ohair@286: 
ohair@286: // NOTE:  Add I18N support to this class when JDK gets the ability to
ohair@286: // defer selection of locale for exception messages ... use the same
ohair@286: // technique for both.
ohair@286: 
ohair@286: 
ohair@286: /**
ohair@286:  * This handles several XML-related tasks that normal java.io Readers
ohair@286:  * don't support, inluding use of IETF standard encoding names and
ohair@286:  * automatic detection of most XML encodings.  The former is needed
ohair@286:  * for interoperability; the latter is needed to conform with the XML
ohair@286:  * spec.  This class also optimizes reading some common encodings by
ohair@286:  * providing low-overhead unsynchronized Reader support.
ohair@286:  * <p/>
ohair@286:  * <P> Note that the autodetection facility should be used only on
ohair@286:  * data streams which have an unknown character encoding.  For example,
ohair@286:  * it should never be used on MIME text/xml entities.
ohair@286:  * <p/>
ohair@286:  * <P> Note that XML processors are only required to support UTF-8 and
ohair@286:  * UTF-16 character encodings.  Autodetection permits the underlying Java
ohair@286:  * implementation to provide support for many other encodings, such as
ohair@286:  * US-ASCII, ISO-8859-5, Shift_JIS, EUC-JP, and ISO-2022-JP.
ohair@286:  *
ohair@286:  * @author David Brownell
ohair@286:  * @author Janet Koenig
ohair@286:  * @version 1.3 00/02/24
ohair@286:  */
ohair@286: // package private
ohair@286: final class XmlReader extends Reader {
ohair@286:     private static final int MAXPUSHBACK = 512;
ohair@286: 
ohair@286:     private Reader in;
ohair@286:     private String assignedEncoding;
ohair@286:     private boolean closed;
ohair@286: 
ohair@286:     //
ohair@286:     // This class always delegates I/O to a reader, which gets
ohair@286:     // its data from the very beginning of the XML text.  It needs
ohair@286:     // to use a pushback stream since (a) autodetection can read
ohair@286:     // partial UTF-8 characters which need to be fully processed,
ohair@286:     // (b) the "Unicode" readers swallow characters that they think
ohair@286:     // are byte order marks, so tests fail if they don't see the
ohair@286:     // real byte order mark.
ohair@286:     //
ohair@286:     // It's got do this efficiently:  character I/O is solidly on the
ohair@286:     // critical path.  (So keep buffer length over 2 Kbytes to avoid
ohair@286:     // excess buffering. Many URL handlers stuff a BufferedInputStream
ohair@286:     // between here and the real data source, and larger buffers keep
ohair@286:     // that from slowing you down.)
ohair@286:     //
ohair@286: 
ohair@286:     /**
mkos@397:      * Constructs the reader from an input stream, autodetecting
ohair@286:      * the encoding to use according to the heuristic specified
ohair@286:      * in the XML 1.0 recommendation.
ohair@286:      *
ohair@286:      * @param in the input stream from which the reader is constructed
ohair@286:      * @throws IOException on error, such as unrecognized encoding
ohair@286:      */
ohair@286:     public static Reader createReader(InputStream in) throws IOException {
ohair@286:         return new XmlReader(in);
ohair@286:     }
ohair@286: 
ohair@286:     /**
ohair@286:      * Creates a reader supporting the given encoding, mapping
ohair@286:      * from standard encoding names to ones that understood by
ohair@286:      * Java where necessary.
ohair@286:      *
ohair@286:      * @param in       the input stream from which the reader is constructed
ohair@286:      * @param encoding the IETF standard name of the encoding to use;
mkos@397:      *                 if null, autodetection is used.
ohair@286:      * @throws IOException on error, including unrecognized encoding
ohair@286:      */
ohair@286:     public static Reader createReader(InputStream in, String encoding)
ohair@286:             throws IOException {
ohair@286:         if (encoding == null)
ohair@286:             return new XmlReader(in);
ohair@286:         if ("UTF-8".equalsIgnoreCase(encoding)
ohair@286:                 || "UTF8".equalsIgnoreCase(encoding))
ohair@286:             return new Utf8Reader(in);
ohair@286:         if ("US-ASCII".equalsIgnoreCase(encoding)
ohair@286:                 || "ASCII".equalsIgnoreCase(encoding))
ohair@286:             return new AsciiReader(in);
ohair@286:         if ("ISO-8859-1".equalsIgnoreCase(encoding)
ohair@286:         // plus numerous aliases ...
ohair@286:         )
ohair@286:             return new Iso8859_1Reader(in);
ohair@286: 
ohair@286:         //
ohair@286:         // What we really want is an administerable resource mapping
ohair@286:         // encoding names/aliases to classnames.  For example a property
ohair@286:         // file resource, "readers/mapping.props", holding and a set
ohair@286:         // of readers in that (sub)package... defaulting to this call
ohair@286:         // only if no better choice is available.
ohair@286:         //
ohair@286:         return new InputStreamReader(in, std2java(encoding));
ohair@286:     }
ohair@286: 
ohair@286:     //
ohair@286:     // JDK doesn't know all of the standard encoding names, and
ohair@286:     // in particular none of the EBCDIC ones IANA defines (and
ohair@286:     // which IBM encourages).
ohair@286:     //
ohair@286:     static private final Hashtable charsets = new Hashtable(31);
ohair@286: 
ohair@286:     static {
ohair@286:         charsets.put("UTF-16", "Unicode");
ohair@286:         charsets.put("ISO-10646-UCS-2", "Unicode");
ohair@286: 
ohair@286:         // NOTE: no support for ISO-10646-UCS-4 yet.
ohair@286: 
ohair@286:         charsets.put("EBCDIC-CP-US", "cp037");
ohair@286:         charsets.put("EBCDIC-CP-CA", "cp037");
ohair@286:         charsets.put("EBCDIC-CP-NL", "cp037");
ohair@286:         charsets.put("EBCDIC-CP-WT", "cp037");
ohair@286: 
ohair@286:         charsets.put("EBCDIC-CP-DK", "cp277");
ohair@286:         charsets.put("EBCDIC-CP-NO", "cp277");
ohair@286:         charsets.put("EBCDIC-CP-FI", "cp278");
ohair@286:         charsets.put("EBCDIC-CP-SE", "cp278");
ohair@286: 
ohair@286:         charsets.put("EBCDIC-CP-IT", "cp280");
ohair@286:         charsets.put("EBCDIC-CP-ES", "cp284");
ohair@286:         charsets.put("EBCDIC-CP-GB", "cp285");
ohair@286:         charsets.put("EBCDIC-CP-FR", "cp297");
ohair@286: 
ohair@286:         charsets.put("EBCDIC-CP-AR1", "cp420");
ohair@286:         charsets.put("EBCDIC-CP-HE", "cp424");
ohair@286:         charsets.put("EBCDIC-CP-BE", "cp500");
ohair@286:         charsets.put("EBCDIC-CP-CH", "cp500");
ohair@286: 
ohair@286:         charsets.put("EBCDIC-CP-ROECE", "cp870");
ohair@286:         charsets.put("EBCDIC-CP-YU", "cp870");
ohair@286:         charsets.put("EBCDIC-CP-IS", "cp871");
ohair@286:         charsets.put("EBCDIC-CP-AR2", "cp918");
ohair@286: 
ohair@286:         // IANA also defines two that JDK 1.2 doesn't handle:
ohair@286:         //    EBCDIC-CP-GR        --> CP423
ohair@286:         //    EBCDIC-CP-TR        --> CP905
ohair@286:     }
ohair@286: 
ohair@286:     // returns an encoding name supported by JDK >= 1.1.6
ohair@286:     // for some cases required by the XML spec
ohair@286:     private static String std2java(String encoding) {
ohair@286:         String temp = encoding.toUpperCase();
ohair@286:         temp = (String) charsets.get(temp);
ohair@286:         return temp != null ? temp : encoding;
ohair@286:     }
ohair@286: 
ohair@286:     /**
ohair@286:      * Returns the standard name of the encoding in use
ohair@286:      */
ohair@286:     public String getEncoding() {
ohair@286:         return assignedEncoding;
ohair@286:     }
ohair@286: 
ohair@286:     private XmlReader(InputStream stream) throws IOException {
ohair@286:         super(stream);
ohair@286: 
ohair@286:         PushbackInputStream pb;
ohair@286:         byte buf [];
ohair@286:         int len;
ohair@286: 
ohair@286:         if (stream instanceof PushbackInputStream)
ohair@286:             pb = (PushbackInputStream) stream;
ohair@286:         else
ohair@286:             pb = new PushbackInputStream(stream, MAXPUSHBACK);
ohair@286: 
ohair@286:         //
ohair@286:         // See if we can figure out the character encoding used
ohair@286:         // in this file by peeking at the first few bytes.
ohair@286:         //
ohair@286:         buf = new byte[4];
ohair@286:         len = pb.read(buf);
ohair@286:         if (len > 0)
ohair@286:             pb.unread(buf, 0, len);
ohair@286: 
ohair@286:         if (len == 4)
ohair@286:             switch (buf[0] & 0x0ff) {
ohair@286:             case 0:
ohair@286:                 // 00 3c 00 3f == illegal UTF-16 big-endian
ohair@286:                 if (buf[1] == 0x3c && buf[2] == 0x00 && buf[3] == 0x3f) {
ohair@286:                     setEncoding(pb, "UnicodeBig");
ohair@286:                     return;
ohair@286:                 }
ohair@286:                 // else it's probably UCS-4
ohair@286:                 break;
ohair@286: 
ohair@286:             case '<':      // 0x3c: the most common cases!
ohair@286:                 switch (buf[1] & 0x0ff) {
ohair@286:                 // First character is '<'; could be XML without
ohair@286:                 // an XML directive such as "<hello>", "<!-- ...",
ohair@286:                 // and so on.
ohair@286:                 default:
ohair@286:                     break;
ohair@286: 
ohair@286:                     // 3c 00 3f 00 == illegal UTF-16 little endian
ohair@286:                 case 0x00:
ohair@286:                     if (buf[2] == 0x3f && buf[3] == 0x00) {
ohair@286:                         setEncoding(pb, "UnicodeLittle");
ohair@286:                         return;
ohair@286:                     }
ohair@286:                     // else probably UCS-4
ohair@286:                     break;
ohair@286: 
ohair@286:                     // 3c 3f 78 6d == ASCII and supersets '<?xm'
ohair@286:                 case '?':
ohair@286:                     if (buf[2] != 'x' || buf[3] != 'm')
ohair@286:                         break;
ohair@286:                     //
ohair@286:                     // One of several encodings could be used:
ohair@286:                     // Shift-JIS, ASCII, UTF-8, ISO-8859-*, etc
ohair@286:                     //
ohair@286:                     useEncodingDecl(pb, "UTF8");
ohair@286:                     return;
ohair@286:                 }
ohair@286:                 break;
ohair@286: 
ohair@286:                 // 4c 6f a7 94 ... some EBCDIC code page
ohair@286:             case 0x4c:
ohair@286:                 if (buf[1] == 0x6f
ohair@286:                         && (0x0ff & buf[2]) == 0x0a7
ohair@286:                         && (0x0ff & buf[3]) == 0x094) {
ohair@286:                     useEncodingDecl(pb, "CP037");
ohair@286:                     return;
ohair@286:                 }
ohair@286:                 // whoops, treat as UTF-8
ohair@286:                 break;
ohair@286: 
ohair@286:                 // UTF-16 big-endian
ohair@286:             case 0xfe:
ohair@286:                 if ((buf[1] & 0x0ff) != 0xff)
ohair@286:                     break;
ohair@286:                 setEncoding(pb, "UTF-16");
ohair@286:                 return;
ohair@286: 
ohair@286:                 // UTF-16 little-endian
ohair@286:             case 0xff:
ohair@286:                 if ((buf[1] & 0x0ff) != 0xfe)
ohair@286:                     break;
ohair@286:                 setEncoding(pb, "UTF-16");
ohair@286:                 return;
ohair@286: 
ohair@286:                 // default ... no XML declaration
ohair@286:             default:
ohair@286:                 break;
ohair@286:             }
ohair@286: 
ohair@286:         //
ohair@286:         // If all else fails, assume XML without a declaration, and
ohair@286:         // using UTF-8 encoding.
ohair@286:         //
ohair@286:         setEncoding(pb, "UTF-8");
ohair@286:     }
ohair@286: 
ohair@286:     /*
ohair@286:      * Read the encoding decl on the stream, knowing that it should
ohair@286:      * be readable using the specified encoding (basically, ASCII or
ohair@286:      * EBCDIC).  The body of the document may use a wider range of
ohair@286:      * characters than the XML/Text decl itself, so we switch to use
ohair@286:      * the specified encoding as soon as we can.  (ASCII is a subset
ohair@286:      * of UTF-8, ISO-8859-*, ISO-2022-JP, EUC-JP, and more; EBCDIC
ohair@286:      * has a variety of "code pages" that have these characters as
ohair@286:      * a common subset.)
ohair@286:      */
ohair@286:     private void useEncodingDecl(PushbackInputStream pb, String encoding)
ohair@286:             throws IOException {
ohair@286:         byte buffer [] = new byte[MAXPUSHBACK];
ohair@286:         int len;
ohair@286:         Reader r;
ohair@286:         int c;
ohair@286: 
ohair@286:         //
ohair@286:         // Buffer up a bunch of input, and set up to read it in
ohair@286:         // the specified encoding ... we can skip the first four
ohair@286:         // bytes since we know that "<?xm" was read to determine
ohair@286:         // what encoding to use!
ohair@286:         //
ohair@286:         len = pb.read(buffer, 0, buffer.length);
ohair@286:         pb.unread(buffer, 0, len);
ohair@286:         r = new InputStreamReader(new ByteArrayInputStream(buffer, 4, len),
ohair@286:                 encoding);
ohair@286: 
ohair@286:         //
ohair@286:         // Next must be "l" (and whitespace) else we conclude
ohair@286:         // error and choose UTF-8.
ohair@286:         //
ohair@286:         if ((c = r.read()) != 'l') {
ohair@286:             setEncoding(pb, "UTF-8");
ohair@286:             return;
ohair@286:         }
ohair@286: 
ohair@286:         //
ohair@286:         // Then, we'll skip any
ohair@286:         //     S version="..."     [or single quotes]
ohair@286:         // bit and get any subsequent
ohair@286:         //     S encoding="..."     [or single quotes]
ohair@286:         //
ohair@286:         // We put an arbitrary size limit on how far we read; lots
ohair@286:         // of space will break this algorithm.
ohair@286:         //
ohair@286:         StringBuffer buf = new StringBuffer();
ohair@286:         StringBuffer keyBuf = null;
ohair@286:         String key = null;
ohair@286:         boolean sawEq = false;
ohair@286:         char quoteChar = 0;
ohair@286:         boolean sawQuestion = false;
ohair@286: 
ohair@286:         XmlDecl:
ohair@286:         for (int i = 0; i < MAXPUSHBACK - 5; ++i) {
ohair@286:             if ((c = r.read()) == -1)
ohair@286:                 break;
ohair@286: 
ohair@286:             // ignore whitespace before/between "key = 'value'"
ohair@286:             if (c == ' ' || c == '\t' || c == '\n' || c == '\r')
ohair@286:                 continue;
ohair@286: 
ohair@286:             // ... but require at least a little!
ohair@286:             if (i == 0)
ohair@286:                 break;
ohair@286: 
ohair@286:             // terminate the loop ASAP
ohair@286:             if (c == '?')
ohair@286:                 sawQuestion = true;
ohair@286:             else if (sawQuestion) {
ohair@286:                 if (c == '>')
ohair@286:                     break;
ohair@286:                 sawQuestion = false;
ohair@286:             }
ohair@286: 
ohair@286:             // did we get the "key =" bit yet?
ohair@286:             if (key == null || !sawEq) {
ohair@286:                 if (keyBuf == null) {
ohair@286:                     if (Character.isWhitespace((char) c))
ohair@286:                         continue;
ohair@286:                     keyBuf = buf;
ohair@286:                     buf.setLength(0);
ohair@286:                     buf.append((char) c);
ohair@286:                     sawEq = false;
ohair@286:                 } else if (Character.isWhitespace((char) c)) {
ohair@286:                     key = keyBuf.toString();
ohair@286:                 } else if (c == '=') {
ohair@286:                     if (key == null)
ohair@286:                         key = keyBuf.toString();
ohair@286:                     sawEq = true;
ohair@286:                     keyBuf = null;
ohair@286:                     quoteChar = 0;
ohair@286:                 } else
ohair@286:                     keyBuf.append((char) c);
ohair@286:                 continue;
ohair@286:             }
ohair@286: 
ohair@286:             // space before quoted value
ohair@286:             if (Character.isWhitespace((char) c))
ohair@286:                 continue;
ohair@286:             if (c == '"' || c == '\'') {
ohair@286:                 if (quoteChar == 0) {
ohair@286:                     quoteChar = (char) c;
ohair@286:                     buf.setLength(0);
ohair@286:                     continue;
ohair@286:                 } else if (c == quoteChar) {
ohair@286:                     if ("encoding".equals(key)) {
ohair@286:                         assignedEncoding = buf.toString();
ohair@286: 
ohair@286:                         // [81] Encname ::= [A-Za-z] ([A-Za-z0-9._]|'-')*
ohair@286:                         for (i = 0; i < assignedEncoding.length(); i++) {
ohair@286:                             c = assignedEncoding.charAt(i);
ohair@286:                             if ((c >= 'A' && c <= 'Z')
ohair@286:                                     || (c >= 'a' && c <= 'z'))
ohair@286:                                 continue;
ohair@286:                             if (i == 0)
ohair@286:                                 break XmlDecl;
ohair@286:                             if (i > 0 && (c == '-'
ohair@286:                                     || (c >= '0' && c <= '9')
ohair@286:                                     || c == '.' || c == '_'))
ohair@286:                                 continue;
ohair@286:                             // map illegal names to UTF-8 default
ohair@286:                             break XmlDecl;
ohair@286:                         }
ohair@286: 
ohair@286:                         setEncoding(pb, assignedEncoding);
ohair@286:                         return;
ohair@286: 
ohair@286:                     } else {
ohair@286:                         key = null;
ohair@286:                         continue;
ohair@286:                     }
ohair@286:                 }
ohair@286:             }
ohair@286:             buf.append((char) c);
ohair@286:         }
ohair@286: 
ohair@286:         setEncoding(pb, "UTF-8");
ohair@286:     }
ohair@286: 
ohair@286:     private void setEncoding(InputStream stream, String encoding)
ohair@286:             throws IOException {
ohair@286:         assignedEncoding = encoding;
ohair@286:         in = createReader(stream, encoding);
ohair@286:     }
ohair@286: 
ohair@286:     /**
ohair@286:      * Reads the number of characters read into the buffer, or -1 on EOF.
ohair@286:      */
ohair@286:     public int read(char buf [], int off, int len) throws IOException {
ohair@286:         int val;
ohair@286: 
ohair@286:         if (closed)
ohair@286:             return -1;        // throw new IOException ("closed");
ohair@286:         val = in.read(buf, off, len);
ohair@286:         if (val == -1)
ohair@286:             close();
ohair@286:         return val;
ohair@286:     }
ohair@286: 
ohair@286:     /**
ohair@286:      * Reads a single character.
ohair@286:      */
ohair@286:     public int read() throws IOException {
ohair@286:         int val;
ohair@286: 
ohair@286:         if (closed)
ohair@286:             throw new IOException("closed");
ohair@286:         val = in.read();
ohair@286:         if (val == -1)
ohair@286:             close();
ohair@286:         return val;
ohair@286:     }
ohair@286: 
ohair@286:     /**
ohair@286:      * Returns true iff the reader supports mark/reset.
ohair@286:      */
ohair@286:     public boolean markSupported() {
ohair@286:         return in == null ? false : in.markSupported();
ohair@286:     }
ohair@286: 
ohair@286:     /**
ohair@286:      * Sets a mark allowing a limited number of characters to
ohair@286:      * be "peeked", by reading and then resetting.
ohair@286:      *
ohair@286:      * @param value how many characters may be "peeked".
ohair@286:      */
ohair@286:     public void mark(int value) throws IOException {
ohair@286:         if (in != null) in.mark(value);
ohair@286:     }
ohair@286: 
ohair@286:     /**
ohair@286:      * Resets the current position to the last marked position.
ohair@286:      */
ohair@286:     public void reset() throws IOException {
ohair@286:         if (in != null) in.reset();
ohair@286:     }
ohair@286: 
ohair@286:     /**
ohair@286:      * Skips a specified number of characters.
ohair@286:      */
ohair@286:     public long skip(long value) throws IOException {
ohair@286:         return in == null ? 0 : in.skip(value);
ohair@286:     }
ohair@286: 
ohair@286:     /**
ohair@286:      * Returns true iff input characters are known to be ready.
ohair@286:      */
ohair@286:     public boolean ready() throws IOException {
ohair@286:         return in == null ? false : in.ready();
ohair@286:     }
ohair@286: 
ohair@286:     /**
ohair@286:      * Closes the reader.
ohair@286:      */
ohair@286:     public void close() throws IOException {
ohair@286:         if (closed)
ohair@286:             return;
ohair@286:         in.close();
ohair@286:         in = null;
ohair@286:         closed = true;
ohair@286:     }
ohair@286: 
ohair@286:     //
ohair@286:     // Delegating to a converter module will always be slower than
ohair@286:     // direct conversion.  Use a similar approach for any other
ohair@286:     // readers that need to be particularly fast; only block I/O
ohair@286:     // speed matters to this package.  For UTF-16, separate readers
ohair@286:     // for big and little endian streams make a difference, too;
ohair@286:     // fewer conditionals in the critical path!
ohair@286:     //
ohair@286:     static abstract class BaseReader extends Reader {
ohair@286:         protected InputStream instream;
ohair@286:         protected byte buffer [];
ohair@286:         protected int start, finish;
ohair@286: 
ohair@286:         BaseReader(InputStream stream) {
ohair@286:             super(stream);
ohair@286: 
ohair@286:             instream = stream;
ohair@286:             buffer = new byte[8192];
ohair@286:         }
ohair@286: 
ohair@286:         public boolean ready() throws IOException {
ohair@286:             return instream == null
ohair@286:                     || (finish - start) > 0
ohair@286:                     || instream.available() != 0;
ohair@286:         }
ohair@286: 
ohair@286:         // caller shouldn't read again
ohair@286:         public void close() throws IOException {
ohair@286:             if (instream != null) {
ohair@286:                 instream.close();
ohair@286:                 start = finish = 0;
ohair@286:                 buffer = null;
ohair@286:                 instream = null;
ohair@286:             }
ohair@286:         }
ohair@286:     }
ohair@286: 
ohair@286:     //
ohair@286:     // We want this reader, to make the default encoding be as fast
ohair@286:     // as we can make it.  JDK's "UTF8" (not "UTF-8" till JDK 1.2)
ohair@286:     // InputStreamReader works, but 20+% slower speed isn't OK for
ohair@286:     // the default/primary encoding.
ohair@286:     //
ohair@286:     static final class Utf8Reader extends BaseReader {
ohair@286:         // 2nd half of UTF-8 surrogate pair
ohair@286:         private char nextChar;
ohair@286: 
ohair@286:         Utf8Reader(InputStream stream) {
ohair@286:             super(stream);
ohair@286:         }
ohair@286: 
ohair@286:         public int read(char buf [], int offset, int len) throws IOException {
ohair@286:             int i = 0, c = 0;
ohair@286: 
ohair@286:             if (len <= 0)
ohair@286:                 return 0;
ohair@286: 
ohair@286:             // Consume remaining half of any surrogate pair immediately
ohair@286:             if (nextChar != 0) {
ohair@286:                 buf[offset + i++] = nextChar;
ohair@286:                 nextChar = 0;
ohair@286:             }
ohair@286: 
ohair@286:             while (i < len) {
ohair@286:                 // stop or read data if needed
ohair@286:                 if (finish <= start) {
ohair@286:                     if (instream == null) {
ohair@286:                         c = -1;
ohair@286:                         break;
ohair@286:                     }
ohair@286:                     start = 0;
ohair@286:                     finish = instream.read(buffer, 0, buffer.length);
ohair@286:                     if (finish <= 0) {
ohair@286:                         this.close();
ohair@286:                         c = -1;
ohair@286:                         break;
ohair@286:                     }
ohair@286:                 }
ohair@286: 
ohair@286:                 //
ohair@286:                 // RFC 2279 describes UTF-8; there are six encodings.
ohair@286:                 // Each encoding takes a fixed number of characters
ohair@286:                 // (1-6 bytes) and is flagged by a bit pattern in the
ohair@286:                 // first byte.  The five and six byte-per-character
ohair@286:                 // encodings address characters which are disallowed
ohair@286:                 // in XML documents, as do some four byte ones.
ohair@286:                 //
ohair@286: 
ohair@286:                 //
ohair@286:                 // Single byte == ASCII.  Common; optimize.
ohair@286:                 //
ohair@286:                 c = buffer[start] & 0x0ff;
ohair@286:                 if ((c & 0x80) == 0x00) {
ohair@286:                     // 0x0000 <= c <= 0x007f
ohair@286:                     start++;
ohair@286:                     buf[offset + i++] = (char) c;
ohair@286:                     continue;
ohair@286:                 }
ohair@286: 
ohair@286:                 //
ohair@286:                 // Multibyte chars -- check offsets optimistically,
ohair@286:                 // ditto the "10xx xxxx" format for subsequent bytes
ohair@286:                 //
ohair@286:                 int off = start;
ohair@286: 
ohair@286:                 try {
ohair@286:                     // 2 bytes
ohair@286:                     if ((buffer[off] & 0x0E0) == 0x0C0) {
ohair@286:                         c = (buffer[off++] & 0x1f) << 6;
ohair@286:                         c += buffer[off++] & 0x3f;
ohair@286: 
ohair@286:                         // 0x0080 <= c <= 0x07ff
ohair@286: 
ohair@286:                         // 3 bytes
ohair@286:                     } else if ((buffer[off] & 0x0F0) == 0x0E0) {
ohair@286:                         c = (buffer[off++] & 0x0f) << 12;
ohair@286:                         c += (buffer[off++] & 0x3f) << 6;
ohair@286:                         c += buffer[off++] & 0x3f;
ohair@286: 
ohair@286:                         // 0x0800 <= c <= 0xffff
ohair@286: 
ohair@286:                         // 4 bytes
ohair@286:                     } else if ((buffer[off] & 0x0f8) == 0x0F0) {
ohair@286:                         c = (buffer[off++] & 0x07) << 18;
ohair@286:                         c += (buffer[off++] & 0x3f) << 12;
ohair@286:                         c += (buffer[off++] & 0x3f) << 6;
ohair@286:                         c += buffer[off++] & 0x3f;
ohair@286: 
ohair@286:                         // 0x0001 0000  <= c  <= 0x001f ffff
ohair@286: 
ohair@286:                         // Unicode supports c <= 0x0010 ffff ...
ohair@286:                         if (c > 0x0010ffff)
ohair@286:                             throw new CharConversionException("UTF-8 encoding of character 0x00"
ohair@286:                                     + Integer.toHexString(c)
ohair@286:                                     + " can't be converted to Unicode.");
ohair@286: 
ohair@286:                         // Convert UCS-4 char to surrogate pair (UTF-16)
ohair@286:                         c -= 0x10000;
ohair@286:                         nextChar = (char) (0xDC00 + (c & 0x03ff));
ohair@286:                         c = 0xD800 + (c >> 10);
ohair@286: 
ohair@286:                         // 5 and 6 byte versions are XML WF errors, but
ohair@286:                         // typically come from mislabeled encodings
ohair@286:                     } else
ohair@286:                         throw new CharConversionException("Unconvertible UTF-8 character"
ohair@286:                                 + " beginning with 0x"
ohair@286:                                 + Integer.toHexString(buffer[start] & 0xff));
ohair@286: 
ohair@286:                 } catch (ArrayIndexOutOfBoundsException e) {
ohair@286:                     // off > length && length >= buffer.length
ohair@286:                     c = 0;
ohair@286:                 }
ohair@286: 
ohair@286:                 //
ohair@286:                 // if the buffer held only a partial character,
ohair@286:                 // compact it and try to read the rest of the
ohair@286:                 // character.  worst case involves three
ohair@286:                 // single-byte reads -- quite rare.
ohair@286:                 //
ohair@286:                 if (off > finish) {
ohair@286:                     System.arraycopy(buffer, start,
ohair@286:                             buffer, 0, finish - start);
ohair@286:                     finish -= start;
ohair@286:                     start = 0;
ohair@286:                     off = instream.read(buffer, finish,
ohair@286:                             buffer.length - finish);
ohair@286:                     if (off < 0) {
ohair@286:                         this.close();
ohair@286:                         throw new CharConversionException("Partial UTF-8 char");
ohair@286:                     }
ohair@286:                     finish += off;
ohair@286:                     continue;
ohair@286:                 }
ohair@286: 
ohair@286:                 //
ohair@286:                 // check the format of the non-initial bytes
ohair@286:                 //
ohair@286:                 for (start++; start < off; start++) {
ohair@286:                     if ((buffer[start] & 0xC0) != 0x80) {
ohair@286:                         this.close();
ohair@286:                         throw new CharConversionException("Malformed UTF-8 char -- "
ohair@286:                                 + "is an XML encoding declaration missing?");
ohair@286:                     }
ohair@286:                 }
ohair@286: 
ohair@286:                 //
ohair@286:                 // If this needed a surrogate pair, consume ASAP
ohair@286:                 //
ohair@286:                 buf[offset + i++] = (char) c;
ohair@286:                 if (nextChar != 0 && i < len) {
ohair@286:                     buf[offset + i++] = nextChar;
ohair@286:                     nextChar = 0;
ohair@286:                 }
ohair@286:             }
ohair@286:             if (i > 0)
ohair@286:                 return i;
ohair@286:             return (c == -1) ? -1 : 0;
ohair@286:         }
ohair@286:     }
ohair@286: 
ohair@286:     //
ohair@286:     // We want ASCII and ISO-8859 Readers since they're the most common
ohair@286:     // encodings in the US and Europe, and we don't want performance
ohair@286:     // regressions for them.  They're also easy to implement efficiently,
ohair@286:     // since they're bitmask subsets of UNICODE.
ohair@286:     //
ohair@286:     // XXX haven't benchmarked these readers vs what we get out of JDK.
ohair@286:     //
ohair@286:     static final class AsciiReader extends BaseReader {
ohair@286:         AsciiReader(InputStream in) {
ohair@286:             super(in);
ohair@286:         }
ohair@286: 
ohair@286:         public int read(char buf [], int offset, int len) throws IOException {
ohair@286:             int i, c;
ohair@286: 
ohair@286:             if (instream == null)
ohair@286:                 return -1;
ohair@286: 
ohair@286:             for (i = 0; i < len; i++) {
ohair@286:                 if (start >= finish) {
ohair@286:                     start = 0;
ohair@286:                     finish = instream.read(buffer, 0, buffer.length);
ohair@286:                     if (finish <= 0) {
ohair@286:                         if (finish <= 0)
ohair@286:                             this.close();
ohair@286:                         break;
ohair@286:                     }
ohair@286:                 }
ohair@286:                 c = buffer[start++];
ohair@286:                 if ((c & 0x80) != 0)
ohair@286:                     throw new CharConversionException("Illegal ASCII character, 0x"
ohair@286:                             + Integer.toHexString(c & 0xff));
ohair@286:                 buf[offset + i] = (char) c;
ohair@286:             }
ohair@286:             if (i == 0 && finish <= 0)
ohair@286:                 return -1;
ohair@286:             return i;
ohair@286:         }
ohair@286:     }
ohair@286: 
ohair@286:     static final class Iso8859_1Reader extends BaseReader {
ohair@286:         Iso8859_1Reader(InputStream in) {
ohair@286:             super(in);
ohair@286:         }
ohair@286: 
ohair@286:         public int read(char buf [], int offset, int len) throws IOException {
ohair@286:             int i;
ohair@286: 
ohair@286:             if (instream == null)
ohair@286:                 return -1;
ohair@286: 
ohair@286:             for (i = 0; i < len; i++) {
ohair@286:                 if (start >= finish) {
ohair@286:                     start = 0;
ohair@286:                     finish = instream.read(buffer, 0, buffer.length);
ohair@286:                     if (finish <= 0) {
ohair@286:                         if (finish <= 0)
ohair@286:                             this.close();
ohair@286:                         break;
ohair@286:                     }
ohair@286:                 }
ohair@286:                 buf[offset + i] = (char) (0x0ff & buffer[start++]);
ohair@286:             }
ohair@286:             if (i == 0 && finish <= 0)
ohair@286:                 return -1;
ohair@286:             return i;
ohair@286:         }
ohair@286:     }
ohair@286: }