| /* |
| * The Apache Software License, Version 1.1 |
| * |
| * |
| * Copyright (c) 1999 The Apache Software Foundation. All rights |
| * reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * 3. The end-user documentation included with the redistribution, |
| * if any, must include the following acknowledgment: |
| * "This product includes software developed by the |
| * Apache Software Foundation (http://www.apache.org/)." |
| * Alternately, this acknowledgment may appear in the software itself, |
| * if and wherever such third-party acknowledgments normally appear. |
| * |
| * 4. The names "Xerces" and "Apache Software Foundation" must |
| * not be used to endorse or promote products derived from this |
| * software without prior written permission. For written |
| * permission, please contact apache@apache.org. |
| * |
| * 5. Products derived from this software may not be called "Apache", |
| * nor may "Apache" appear in their name, without prior written |
| * permission of the Apache Software Foundation. |
| * |
| * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR |
| * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF |
| * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT |
| * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| * ==================================================================== |
| * |
| * This software consists of voluntary contributions made by many |
| * individuals on behalf of the Apache Software Foundation and was |
| * originally based on software copyright (c) 1999, International |
| * Business Machines, Inc., http://www.apache.org. For more |
| * information on the Apache Software Foundation, please see |
| * <http://www.apache.org/>. |
| */ |
| |
| package org.apache.xerces.readers; |
| |
| import org.apache.xerces.framework.XMLErrorReporter; |
| import org.apache.xerces.utils.CharDataChunk; |
| import org.apache.xerces.utils.StringPool; |
| import org.apache.xerces.utils.ImplementationMessages; |
| import java.io.InputStream; |
| |
| /** |
| * Simple character-based version of a UTF8 reader. |
| * |
| * This class is not commonly used, but is provided as a much simplified |
| * example of the UTF8Reader class that uses the AbstractCharReader to |
| * perform all of the reader functions except for filling each buffer |
| * of the character data when needed (fillCurrentChunk). We read the |
| * input data from an InputStream and perform end-of-line normalization |
| * as we process that data. |
| * |
| * @version |
| */ |
| final class UTF8CharReader extends AbstractCharReader { |
| // |
| // |
| // |
| UTF8CharReader(XMLEntityHandler entityHandler, XMLErrorReporter errorReporter, boolean sendCharDataAsCharArray, InputStream dataStream, StringPool stringPool) throws Exception { |
| super(entityHandler, errorReporter, sendCharDataAsCharArray, stringPool); |
| fInputStream = dataStream; |
| fillCurrentChunk(); |
| } |
| // |
| // |
| // |
| private InputStream fInputStream = null; |
| // |
| // When we fill a chunk there may be data that was read from the |
| // input stream that has not been "processed". We need to save |
| // that data, and any in-progress state, between the calls to |
| // fillCurrentChunk() in these instance variables. |
| // |
| private boolean fCheckOverflow = false; |
| private byte[] fOverflow = null; |
| private int fOverflowOffset = 0; |
| private int fOverflowEnd = 0; |
| private int fOutputOffset = 0; |
| private boolean fSkipLinefeed = false; |
| private int fPartialMultiByteIn = 0; |
| private byte[] fPartialMultiByteChar = new byte[3]; |
| private int fPartialSurrogatePair = 0; |
| private boolean fPartialMultiByteResult = false; |
| // |
| // |
| // |
| protected int fillCurrentChunk() throws Exception { |
| // |
| // See if we can find a way to reuse the buffer that may have been returned |
| // with a recyled data chunk. |
| // |
| char[] recycledData = fCurrentChunk.toCharArray(); |
| // |
| // If we have overflow from the last call, normalize from where |
| // we left off, copying into the front of the output buffer. |
| // |
| fOutputOffset = 0; |
| if (fCheckOverflow) { |
| // |
| // The fOverflowEnd should always be equal to CHUNK_SIZE, unless we hit |
| // EOF during the previous call. Copy the remaining data to the front |
| // of the buffer and return it as the final chunk. |
| // |
| fMostRecentData = recycledData; |
| if (fOverflowEnd < CharDataChunk.CHUNK_SIZE) { |
| recycledData = null; |
| if (fOverflowEnd > 0) { |
| if (fMostRecentData == null || fMostRecentData.length < 1 + fOverflowEnd - fOverflowOffset) |
| fMostRecentData = new char[1 + fOverflowEnd - fOverflowOffset]; |
| copyNormalize(fOverflow, fOverflowOffset, fMostRecentData, fOutputOffset); |
| } else { |
| if (fMostRecentData == null) |
| fMostRecentData = new char[1]; |
| } |
| fMostRecentData[fOutputOffset] = 0; |
| // |
| // Update our instance variables |
| // |
| fOverflow = null; |
| fLength += fOutputOffset; |
| fCurrentIndex = 0; |
| fCurrentChunk.setCharArray(fMostRecentData); |
| return (fMostRecentChar = fMostRecentData[0]); |
| } |
| if (fMostRecentData == null || fMostRecentData.length < CharDataChunk.CHUNK_SIZE) |
| fMostRecentData = new char[CharDataChunk.CHUNK_SIZE]; |
| else |
| recycledData = null; |
| copyNormalize(fOverflow, fOverflowOffset, fMostRecentData, fOutputOffset); |
| fCheckOverflow = false; |
| } else { |
| if (fOverflow == null) |
| fOverflow = new byte[CharDataChunk.CHUNK_SIZE]; |
| fMostRecentData = null; |
| } |
| while (true) { |
| fOverflowOffset = 0; |
| fOverflowEnd = 0; |
| int capacity = CharDataChunk.CHUNK_SIZE; |
| int result = 0; |
| do { |
| try { |
| result = fInputStream.read(fOverflow, fOverflowEnd, capacity); |
| } catch (java.io.IOException ex) { |
| result = -1; |
| } |
| if (result == -1) { |
| // |
| // We have reached the end of the stream. |
| // |
| fInputStream.close(); |
| fInputStream = null; |
| if (fMostRecentData == null) { |
| // |
| // There is no previous output data, so we know that all of the |
| // new input data will fit. |
| // |
| fMostRecentData = recycledData; |
| if (fMostRecentData == null || fMostRecentData.length < 1 + fOverflowEnd) |
| fMostRecentData = new char[1 + fOverflowEnd]; |
| else |
| recycledData = null; |
| copyNormalize(fOverflow, fOverflowOffset, fMostRecentData, fOutputOffset); |
| fOverflow = null; |
| fMostRecentData[fOutputOffset] = 0; |
| } else { |
| // |
| // Copy the input data to the end of the output buffer. |
| // |
| boolean alldone = copyNormalize(fOverflow, fOverflowOffset, fMostRecentData, fOutputOffset); |
| if (alldone) { |
| if (fOverflowEnd == CharDataChunk.CHUNK_SIZE) { |
| // |
| // Special case - everything fit into the overflow buffer, |
| // except that there is no room for the nul char we use to |
| // indicate EOF. Set the overflow buffer length to zero. |
| // On the next call to this method, we will detect this |
| // case and which we will handle above . |
| // |
| fCheckOverflow = true; |
| fOverflowOffset = 0; |
| fOverflowEnd = 0; |
| } else { |
| // |
| // It all fit into the output buffer. |
| // |
| fOverflow = null; |
| fMostRecentData[fOutputOffset] = 0; |
| } |
| } else { |
| // |
| // There is still input data left over, save the remaining data as |
| // the overflow buffer for the next call. |
| // |
| fCheckOverflow = true; |
| } |
| } |
| break; |
| } |
| if (result > 0) { |
| fOverflowEnd += result; |
| capacity -= result; |
| } |
| } while (capacity > 0); |
| // |
| // |
| // |
| if (result == -1) |
| break; |
| if (fMostRecentData != null) { |
| boolean alldone = copyNormalize(fOverflow, fOverflowOffset, fMostRecentData, fOutputOffset); |
| if (fOutputOffset == CharDataChunk.CHUNK_SIZE) { |
| // |
| // We filled the output buffer. |
| // |
| if (!alldone) { |
| // |
| // The input buffer will become the next overflow buffer. |
| // |
| fCheckOverflow = true; |
| } |
| break; |
| } |
| } else { |
| // |
| // Now normalize the end-of-line characters and see if we need to read more |
| // bytes to fill up the buffer. |
| // |
| fMostRecentData = recycledData; |
| if (fMostRecentData == null || fMostRecentData.length < CharDataChunk.CHUNK_SIZE) |
| fMostRecentData = new char[CharDataChunk.CHUNK_SIZE]; |
| else |
| recycledData = null; |
| copyNormalize(fOverflow, fOverflowOffset, fMostRecentData, fOutputOffset); |
| if (fOutputOffset == CharDataChunk.CHUNK_SIZE) { |
| // |
| // The output buffer is full. We can return now. |
| // |
| break; |
| } |
| } |
| // |
| // We will need to get another intput buffer to be able to fill the |
| // overflow buffer completely. |
| // |
| } |
| // |
| // Update our instance variables |
| // |
| fLength += fOutputOffset; |
| fCurrentIndex = 0; |
| fCurrentChunk.setCharArray(fMostRecentData); |
| return (fMostRecentChar = fMostRecentData[0]); |
| } |
| // |
| // Copy and normalize bytes from the overflow buffer into chars in our data buffer. |
| // |
| private boolean copyNormalize(byte[] in, int inOffset, char[] out, int outOffset) throws Exception { |
| // |
| // Handle all edge cases before dropping into the inner loop. |
| // |
| int inEnd = fOverflowEnd; |
| int outEnd = out.length; |
| if (inOffset == inEnd) |
| return true; |
| byte b = in[inOffset]; |
| if (fSkipLinefeed) { |
| fSkipLinefeed = false; |
| if (b == 0x0A) { |
| if (++inOffset == inEnd) |
| return exitNormalize(inOffset, outOffset, true); |
| b = in[inOffset]; |
| } |
| } else if (fPartialMultiByteIn > 0) { |
| if (!handlePartialMultiByteChar(b, in, inOffset, inEnd, out, outOffset, outEnd)) |
| return fPartialMultiByteResult; |
| inOffset = fOverflowOffset; |
| outOffset = fOutputOffset; |
| b = in[inOffset]; |
| } |
| while (outOffset < outEnd) { |
| // |
| // Find the longest run that we can guarantee will not exceed the |
| // bounds of the outer loop. |
| // |
| int inCount = inEnd - inOffset; |
| int outCount = outEnd - outOffset; |
| if (inCount > outCount) |
| inCount = outCount; |
| inOffset++; |
| while (true) { |
| while (b == 0x0D || b < 0) { |
| if (b == 0x0D) { |
| out[outOffset++] = 0x0A; |
| if (inOffset == inEnd) { |
| fSkipLinefeed = true; |
| return exitNormalize(inOffset, outOffset, true); |
| } |
| b = in[inOffset]; |
| if (b == 0x0A) { |
| if (++inOffset == inEnd) |
| return exitNormalize(inOffset, outOffset, true); |
| b = in[inOffset]; |
| } |
| if (outOffset == outEnd) |
| return exitNormalize(inOffset, outOffset, false); |
| } else { |
| if (!handleMultiByteChar(b, in, inOffset, inEnd, out, outOffset, outEnd)) |
| return fPartialMultiByteResult; |
| inOffset = fOverflowOffset; |
| outOffset = fOutputOffset; |
| b = in[inOffset]; |
| } |
| inCount = inEnd - inOffset; |
| outCount = outEnd - outOffset; |
| if (inCount > outCount) |
| inCount = outCount; |
| inOffset++; |
| } |
| while (true) { |
| out[outOffset++] = (char)b; |
| if (--inCount == 0) |
| break; |
| b = in[inOffset++]; |
| if (b == 0x0D || b < 0) |
| break; |
| } |
| if (inCount == 0) |
| break; |
| } |
| if (inOffset == inEnd) |
| break; |
| } |
| return exitNormalize(inOffset, outOffset, inOffset == inEnd); |
| } |
| // |
| // |
| // |
| private boolean exitNormalize(int inOffset, int outOffset, boolean result) { |
| fOverflowOffset = inOffset; |
| fOutputOffset = outOffset; |
| return result; |
| } |
| // |
| // |
| // |
| private void savePartialMultiByte(int inCount, byte bz, byte by, byte bx) { |
| fPartialMultiByteIn = inCount; |
| fPartialMultiByteChar[--inCount] = bz; |
| fPartialMultiByteChar[--inCount] = by; |
| fPartialMultiByteChar[--inCount] = bx; |
| } |
| private void savePartialMultiByte(int inCount, byte bz, byte by) { |
| fPartialMultiByteIn = inCount; |
| fPartialMultiByteChar[--inCount] = bz; |
| fPartialMultiByteChar[--inCount] = by; |
| } |
| private void savePartialMultiByte(int inCount, byte bz) { |
| fPartialMultiByteIn = inCount; |
| fPartialMultiByteChar[--inCount] = bz; |
| } |
| private boolean handleMultiByteChar(byte b, byte[] in, int inOffset, int inEnd, char[] out, int outOffset, int outEnd) throws Exception { |
| if (inOffset == inEnd) { |
| savePartialMultiByte(1, b); |
| fPartialMultiByteResult = exitNormalize(inOffset, outOffset, true); |
| return false; |
| } |
| byte b1 = in[inOffset++]; |
| if ((b1 & 0xc0) != 0x80) { |
| Object[] args = { |
| Integer.toHexString(b & 0xff), |
| Integer.toHexString(b1 & 0xff) |
| }; |
| deferException(ImplementationMessages.ENC5, args, outOffset); |
| out[outOffset++] = 0; |
| return exitNormalize(inOffset, outOffset, true); |
| } |
| if ((b & 0xe0) == 0xc0) { // 110yyyyy 10xxxxxx |
| int ch = ((0x1f & b)<<6) + (0x3f & b1); |
| out[outOffset++] = (char)ch; |
| if (inOffset == inEnd || outOffset == outEnd) { |
| fPartialMultiByteResult = exitNormalize(inOffset, outOffset, inOffset == inEnd); |
| return false; |
| } |
| } else { |
| if (inOffset == inEnd) { |
| savePartialMultiByte(2, b1, b); |
| fPartialMultiByteResult = exitNormalize(inOffset, outOffset, true); |
| return false; |
| } |
| byte b2 = in[inOffset++]; |
| if ((b2 & 0xc0) != 0x80) { |
| Object[] args = { |
| Integer.toHexString(b & 0xff), |
| Integer.toHexString(b1 & 0xff), |
| Integer.toHexString(b2 & 0xff) |
| }; |
| deferException(ImplementationMessages.ENC6, args, outOffset); |
| out[outOffset++] = 0; |
| return exitNormalize(inOffset, outOffset, true); |
| } |
| if ((b & 0xf0) == 0xe0) { // 1110zzzz 10yyyyyy 10xxxxxx |
| int ch = ((0x0f & b)<<12) + ((0x3f & b1)<<6) + (0x3f & b2); |
| out[outOffset++] = (char)ch; |
| if (inOffset == inEnd || outOffset == outEnd) { |
| fPartialMultiByteResult = exitNormalize(inOffset, outOffset, inOffset == inEnd); |
| return false; |
| } |
| } else { |
| if ((b & 0xf8) != 0xf0) { |
| Object[] args = { Integer.toHexString(b & 0xff) }; |
| deferException(ImplementationMessages.ENC4, args, outOffset); |
| out[outOffset++] = 0; |
| return exitNormalize(inOffset, outOffset, true); |
| } |
| if (inOffset == inEnd) { |
| savePartialMultiByte(3, b2, b1, b); |
| fPartialMultiByteResult = exitNormalize(inOffset, outOffset, true); |
| return false; |
| } |
| byte b3 = in[inOffset++]; |
| if ((b3 & 0xc0) != 0x80) { |
| Object[] args = { |
| Integer.toHexString(b & 0xff), |
| Integer.toHexString(b1 & 0xff), |
| Integer.toHexString(b2 & 0xff), |
| Integer.toHexString(b3 & 0xff) |
| }; |
| deferException(ImplementationMessages.ENC7, args, outOffset); |
| out[outOffset++] = 0; |
| return exitNormalize(inOffset, outOffset, true); |
| } |
| int ch = ((0x0f & b)<<18) + ((0x3f & b1)<<12) + ((0x3f & b2)<<6) + (0x3f & b3); |
| if (ch >= 0x10000) { |
| out[outOffset++] = (char)(((ch-0x00010000)>>10)+0xd800); |
| ch = (((ch-0x00010000)&0x3ff)+0xdc00); |
| if (outOffset == outEnd) { |
| fPartialSurrogatePair = ch; |
| fPartialMultiByteResult = exitNormalize(inOffset, outOffset, inOffset == inEnd); |
| return false; |
| } |
| } |
| out[outOffset++] = (char)ch; |
| if (inOffset == inEnd || outOffset == outEnd) { |
| fPartialMultiByteResult = exitNormalize(inOffset, outOffset, inOffset == inEnd); |
| return false; |
| } |
| } |
| } |
| return exitNormalize(inOffset, outOffset, true); |
| } |
| private boolean handlePartialMultiByteChar(byte b, byte[] in, int inOffset, int inEnd, char[] out, int outOffset, int outEnd) throws Exception { |
| if (outOffset == outEnd) { |
| fPartialMultiByteResult = exitNormalize(inOffset, outOffset, inOffset == inEnd); |
| return false; |
| } |
| if (fPartialMultiByteIn == 4) { |
| out[outOffset++] = (char)fPartialSurrogatePair; |
| if (outOffset == outEnd) { |
| fPartialMultiByteResult = exitNormalize(inOffset, outOffset, false); |
| return false; |
| } |
| fOutputOffset = outOffset; |
| return true; |
| } |
| int byteIn = fPartialMultiByteIn; |
| fPartialMultiByteIn = 0; |
| byte b1 = 0; |
| byte b2 = 0; |
| byte b3 = 0; |
| switch (byteIn) { |
| case 1: b1 = b; break; |
| case 2: b2 = b; break; |
| case 3: b3 = b; break; |
| } |
| int i = byteIn; |
| switch (byteIn) { |
| case 3: |
| b2 = fPartialMultiByteChar[--i]; |
| case 2: |
| b1 = fPartialMultiByteChar[--i]; |
| case 1: |
| b = fPartialMultiByteChar[--i]; |
| } |
| switch (byteIn) { |
| case 1: |
| if ((b1 & 0xc0) != 0x80) { |
| Object[] args = { |
| Integer.toHexString(b), |
| Integer.toHexString(b1) |
| }; |
| deferException(ImplementationMessages.ENC5, args, outOffset); |
| out[outOffset++] = 0; |
| break; |
| } |
| // fall through |
| case 2: |
| if ((b & 0xe0) == 0xc0) { // 110yyyyy 10xxxxxx |
| int ch = ((0x1f & b)<<6) + (0x3f & b1); |
| out[outOffset++] = (char)ch; |
| if (outOffset == outEnd) { |
| fPartialMultiByteResult = exitNormalize(inOffset, outOffset, false); |
| return false; |
| } |
| if (byteIn < 2 && ++inOffset == inEnd) { |
| fPartialMultiByteResult = exitNormalize(inOffset, outOffset, true); |
| return false; |
| } |
| break; |
| } |
| if (byteIn < 2) { |
| if (++inOffset == inEnd) { |
| savePartialMultiByte(2, b1); |
| fPartialMultiByteResult = exitNormalize(inOffset, outOffset, true); |
| return false; |
| } |
| b2 = in[inOffset]; |
| } |
| if ((b2 & 0xc0) != 0x80) { |
| Object[] args = { |
| Integer.toHexString(b), |
| Integer.toHexString(b1), |
| Integer.toHexString(b2) |
| }; |
| deferException(ImplementationMessages.ENC6, args, outOffset); |
| out[outOffset++] = 0; |
| break; |
| } |
| // fall through |
| case 3: |
| if ((b & 0xf0) == 0xe0) { // 1110zzzz 10yyyyyy 10xxxxxx |
| int ch = ((0x0f & b)<<12) + ((0x3f & b1)<<6) + (0x3f & b2); |
| out[outOffset++] = (char)ch; |
| if (outOffset == outEnd) { |
| fPartialMultiByteResult = exitNormalize(inOffset, outOffset, false); |
| return false; |
| } |
| if (byteIn < 3 && ++inOffset == inEnd) { |
| fPartialMultiByteResult = exitNormalize(inOffset, outOffset, true); |
| return false; |
| } |
| break; |
| } |
| if (byteIn < 3) { |
| if ((b & 0xf8) != 0xf0) { |
| Object[] args = { Integer.toHexString(b) }; |
| deferException(ImplementationMessages.ENC4, args, outOffset); |
| out[outOffset++] = 0; |
| break; |
| } |
| if (++inOffset == inEnd) { |
| savePartialMultiByte(3, b2, b1); |
| fPartialMultiByteResult = exitNormalize(inOffset, outOffset, true); |
| return false; |
| } |
| b3 = in[inOffset]; |
| } |
| if ((b3 & 0xc0) != 0x80) { |
| Object[] args = { |
| Integer.toHexString(b), |
| Integer.toHexString(b1), |
| Integer.toHexString(b2), |
| Integer.toHexString(b3) |
| }; |
| deferException(ImplementationMessages.ENC7, args, outOffset); |
| out[outOffset++] = 0; |
| break; |
| } |
| int ch = ((0x0f & b)<<18) + ((0x3f & b1)<<12) + ((0x3f & b2)<<6) + (0x3f & b3); |
| if (ch >= 0x10000) { |
| out[outOffset++] = (char)(((ch-0x00010000)>>10)+0xd800); |
| ch = (((ch-0x00010000)&0x3ff)+0xdc00); |
| if (outOffset == outEnd) { |
| fPartialSurrogatePair = ch; |
| fPartialMultiByteResult = exitNormalize(inOffset, outOffset, false); |
| return false; |
| } |
| } |
| out[outOffset++] = (char)ch; |
| if (outOffset == outEnd) { |
| fPartialMultiByteResult = exitNormalize(inOffset, outOffset, false); |
| return false; |
| } |
| if (++inOffset == inEnd) { |
| fPartialMultiByteResult = exitNormalize(inOffset, outOffset, true); |
| return false; |
| } |
| break; |
| } |
| return exitNormalize(inOffset, outOffset, true); |
| } |
| } |
