1 /*

     2  * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 package sun.nio.cs.ext;

    26 

    27 import java.io.ByteArrayOutputStream;

    28 import java.nio.ByteBuffer;

    29 import java.nio.CharBuffer;

    30 import java.nio.charset.*;

    31 

    32 import java.util.Collections;

    33 import java.util.HashMap;

    34 import java.util.Iterator;

    35 import java.util.List;

    36 import java.util.Map;

    37 

    38 public class COMPOUND_TEXT_Encoder extends CharsetEncoder {

    39 

    40     /**

    41      * NOTE: The following four static variables should be used *only* for

    42      * testing whether a encoder can encode a specific character. They

    43      * cannot be used for actual encoding because they are shared across all

    44      * COMPOUND_TEXT encoders and may be stateful.

    45      */

    46     private static final Map<String,CharsetEncoder> encodingToEncoderMap =

    47       Collections.synchronizedMap(new HashMap<String,CharsetEncoder>(21, 1.0f));

    48     private static final CharsetEncoder latin1Encoder;

    49     private static final CharsetEncoder defaultEncoder;

    50     private static final boolean defaultEncodingSupported;

    51 

    52     static {

    53         CharsetEncoder encoder = Charset.defaultCharset().newEncoder();

    54         String encoding = encoder.charset().name();

    55         if ("ISO8859_1".equals(encoding)) {

    56             latin1Encoder = encoder;

    57             defaultEncoder = encoder;

    58             defaultEncodingSupported = true;

    59         } else {

    60             try {

    61                 latin1Encoder =

    62                     Charset.forName("ISO8859_1").newEncoder();

    63             } catch (IllegalArgumentException e) {

    64                 throw new ExceptionInInitializerError

    65                     ("ISO8859_1 unsupported");

    66             }

    67             defaultEncoder = encoder;

    68             defaultEncodingSupported = CompoundTextSupport.getEncodings().

    69                 contains(defaultEncoder.charset().name());

    70         }

    71     }

    72 

    73     private CharsetEncoder encoder;

    74     private char[] charBuf = new char[1];

    75     private CharBuffer charbuf = CharBuffer.wrap(charBuf);

    76     private ByteArrayOutputStream nonStandardCharsetBuffer;

    77     private byte[] byteBuf;

    78     private ByteBuffer bytebuf;

    79     private int numNonStandardChars, nonStandardEncodingLen;

    80 

    81     public COMPOUND_TEXT_Encoder(Charset cs) {

    82         super(cs,

    83               (float)(CompoundTextSupport.MAX_CONTROL_SEQUENCE_LEN + 2),

    84               (float)(CompoundTextSupport.MAX_CONTROL_SEQUENCE_LEN + 2));

    85         try {

    86             encoder = Charset.forName("ISO8859_1").newEncoder();

    87         } catch (IllegalArgumentException cannotHappen) {}

    88         initEncoder(encoder);

    89     }

    90 

    91     protected CoderResult encodeLoop(CharBuffer src, ByteBuffer des) {

    92         CoderResult cr = CoderResult.UNDERFLOW;

    93         char[] input = src.array();

    94         int inOff = src.arrayOffset() + src.position();

    95         int inEnd = src.arrayOffset() + src.limit();

    96 

    97         try {

    98             while (inOff < inEnd && cr.isUnderflow()) {

    99                 charBuf[0] = input[inOff];

   100                 if (charBuf[0] <= '\u0008' ||

   101                     (charBuf[0] >= '\u000B' && charBuf[0] <= '\u001F') ||

   102                     (charBuf[0] >= '\u0080' && charBuf[0] <= '\u009F')) {

   103                     // The compound text specification only permits the octets

   104                     // 0x09, 0x0A, 0x1B, and 0x9B in C0 and C1. Of these, 1B and

   105                     // 9B must also be removed because they initiate control

   106                     // sequences.

   107                     charBuf[0] = '?';

   108                 }

   109 

   110                 CharsetEncoder enc = getEncoder(charBuf[0]);

   111                 //System.out.println("char=" + charBuf[0] + ", enc=" + enc);

   112                 if (enc == null) {

   113                     if (unmappableCharacterAction()

   114                         == CodingErrorAction.REPORT) {

   115                         charBuf[0] = '?';

   116                         enc = latin1Encoder;

   117                     } else {

   118                         return CoderResult.unmappableForLength(1);

   119                     }

   120                 }

   121                 if (enc != encoder) {

   122                     if (nonStandardCharsetBuffer != null) {

   123                         cr = flushNonStandardCharsetBuffer(des);

   124                     } else {

   125                         //cr= encoder.flush(des);

   126                         flushEncoder(encoder, des);

   127                     }

   128                     if (!cr.isUnderflow())

   129                         return cr;

   130                     byte[] escSequence = CompoundTextSupport.

   131                         getEscapeSequence(enc.charset().name());

   132                     if (escSequence == null) {

   133                         throw new InternalError("Unknown encoding: " +

   134                                                 enc.charset().name());

   135                     } else if (escSequence[1] == (byte)0x25 &&

   136                                escSequence[2] == (byte)0x2F) {

   137                         initNonStandardCharsetBuffer(enc, escSequence);

   138                     } else if (des.remaining() >= escSequence.length) {

   139                         des.put(escSequence, 0, escSequence.length);

   140                     } else {

   141                         return CoderResult.OVERFLOW;

   142                     }

   143                     encoder = enc;

   144                     continue;

   145                 }

   146                 charbuf.rewind();

   147                 if (nonStandardCharsetBuffer == null) {

   148                     cr = encoder.encode(charbuf, des, false);

   149                 } else {

   150                     bytebuf.clear();

   151                     cr = encoder.encode(charbuf, bytebuf, false);

   152                     bytebuf.flip();

   153                     nonStandardCharsetBuffer.write(byteBuf,

   154                                                    0, bytebuf.limit());

   155                     numNonStandardChars++;

   156                 }

   157                 inOff++;

   158             }

   159             return cr;

   160         } finally {

   161             src.position(inOff - src.arrayOffset());

   162         }

   163     }

   164 

   165     protected CoderResult implFlush(ByteBuffer out) {

   166         CoderResult cr = (nonStandardCharsetBuffer != null)

   167             ? flushNonStandardCharsetBuffer(out)

   168             //: encoder.flush(out);

   169             : flushEncoder(encoder, out);

   170         reset();

   171         return cr;

   172     }

   173 

   174     private void initNonStandardCharsetBuffer(CharsetEncoder c,

   175                                               byte[] escSequence)

   176     {

   177         nonStandardCharsetBuffer = new ByteArrayOutputStream();

   178         byteBuf = new byte[(int)c.maxBytesPerChar()];

   179         bytebuf = ByteBuffer.wrap(byteBuf);

   180         nonStandardCharsetBuffer.write(escSequence, 0, escSequence.length);

   181         nonStandardCharsetBuffer.write(0); // M placeholder

   182         nonStandardCharsetBuffer.write(0); // L placeholder

   183         byte[] encoding = CompoundTextSupport.

   184             getEncoding(c.charset().name());

   185         if (encoding == null) {

   186             throw new InternalError

   187                 ("Unknown encoding: " + encoder.charset().name());

   188         }

   189         nonStandardCharsetBuffer.write(encoding, 0, encoding.length);

   190         nonStandardCharsetBuffer.write(0x02); // divider

   191         nonStandardEncodingLen = encoding.length + 1;

   192     }

   193 

   194     private CoderResult flushNonStandardCharsetBuffer(ByteBuffer out) {

   195         if (numNonStandardChars > 0) {

   196             byte[] flushBuf = new byte[(int)encoder.maxBytesPerChar() *

   197                                        numNonStandardChars];

   198             ByteBuffer bb = ByteBuffer.wrap(flushBuf);

   199             flushEncoder(encoder, bb);

   200             bb.flip();

   201             nonStandardCharsetBuffer.write(flushBuf, 0, bb.limit());

   202             numNonStandardChars = 0;

   203         }

   204 

   205         int numBytes = nonStandardCharsetBuffer.size();

   206         int nonStandardBytesOff = 6 + nonStandardEncodingLen;

   207 

   208         if (out.remaining() < (numBytes - nonStandardBytesOff) +

   209             nonStandardBytesOff * (((numBytes - nonStandardBytesOff) /

   210                                     ((1 << 14) - 1)) + 1))

   211         {

   212             return CoderResult.OVERFLOW;

   213         }

   214 

   215         byte[] nonStandardBytes =

   216             nonStandardCharsetBuffer.toByteArray();

   217 

   218         // The non-standard charset header only supports 2^14-1 bytes of data.

   219         // If we have more than that, we have to repeat the header.

   220         do {

   221             out.put((byte)0x1B);

   222             out.put((byte)0x25);

   223             out.put((byte)0x2F);

   224             out.put(nonStandardBytes[3]);

   225 

   226             int toWrite = Math.min(numBytes - nonStandardBytesOff,

   227                                    (1 << 14) - 1 - nonStandardEncodingLen);

   228 

   229             out.put((byte)

   230                 (((toWrite + nonStandardEncodingLen) / 0x80) | 0x80)); // M

   231             out.put((byte)

   232                 (((toWrite + nonStandardEncodingLen) % 0x80) | 0x80)); // L

   233             out.put(nonStandardBytes, 6, nonStandardEncodingLen);

   234             out.put(nonStandardBytes, nonStandardBytesOff, toWrite);

   235             nonStandardBytesOff += toWrite;

   236         } while (nonStandardBytesOff < numBytes);

   237 

   238         nonStandardCharsetBuffer = null;

   239         byteBuf = null;

   240         nonStandardEncodingLen = 0;

   241         return CoderResult.UNDERFLOW;

   242     }

   243 

   244     /**

   245      * Resets the encoder.

   246      * Call this method to reset the encoder to its initial state

   247      */

   248     protected void implReset() {

   249         numNonStandardChars = nonStandardEncodingLen = 0;

   250         nonStandardCharsetBuffer = null;

   251         byteBuf = null;

   252         try {

   253             encoder = Charset.forName("ISO8859_1").newEncoder();

   254         } catch (IllegalArgumentException cannotHappen) {

   255         }

   256         initEncoder(encoder);

   257     }

   258 

   259     /**

   260      * Return whether a character is mappable or not

   261      * @return true if a character is mappable

   262      */

   263     public boolean canEncode(char ch) {

   264         return getEncoder(ch) != null;

   265     }

   266 

   267     protected void implOnMalformedInput(CodingErrorAction newAction) {

   268         encoder.onUnmappableCharacter(newAction);

   269     }

   270 

   271     protected void implOnUnmappableCharacter(CodingErrorAction newAction) {

   272         encoder.onUnmappableCharacter(newAction);

   273     }

   274 

   275     protected void implReplaceWith(byte[] newReplacement) {

   276         if (encoder != null)

   277             encoder.replaceWith(newReplacement);

   278     }

   279 

   280     /**

   281      * Try to figure out which CharsetEncoder to use for conversion

   282      * of the specified Unicode character. The target character encoding

   283      * of the returned encoder is approved to be used with Compound Text.

   284      *

   285      * @param ch Unicode character

   286      * @return CharsetEncoder to convert the given character

   287      */

   288     private CharsetEncoder getEncoder(char ch) {

   289         // 1. Try the current encoder.

   290         if (encoder.canEncode(ch)) {

   291             return encoder;

   292         }

   293 

   294         // 2. Try the default encoder.

   295         if (defaultEncodingSupported && defaultEncoder.canEncode(ch)) {

   296             CharsetEncoder retval = null;

   297             try {

   298                 retval = defaultEncoder.charset().newEncoder();

   299             } catch (UnsupportedOperationException cannotHappen) {

   300             }

   301             initEncoder(retval);

   302             return retval;

   303         }

   304 

   305         // 3. Try ISO8859-1.

   306         if (latin1Encoder.canEncode(ch)) {

   307             CharsetEncoder retval = null;

   308             try {

   309                 retval = latin1Encoder.charset().newEncoder();

   310             } catch (UnsupportedOperationException cannotHappen) {}

   311             initEncoder(retval);

   312             return retval;

   313         }

   314 

   315         // 4. Brute force search of all supported encodings.

   316         for (String encoding : CompoundTextSupport.getEncodings())

   317         {

   318             CharsetEncoder enc = encodingToEncoderMap.get(encoding);

   319             if (enc == null) {

   320                 enc = CompoundTextSupport.getEncoder(encoding);

   321                 if (enc == null) {

   322                     throw new InternalError("Unsupported encoding: " +

   323                                             encoding);

   324                 }

   325                 encodingToEncoderMap.put(encoding, enc);

   326             }

   327             if (enc.canEncode(ch)) {

   328                 CharsetEncoder retval = CompoundTextSupport.getEncoder(encoding);

   329                 initEncoder(retval);

   330                 return retval;

   331             }

   332         }

   333 

   334         return null;

   335     }

   336 

   337     private void initEncoder(CharsetEncoder enc) {

   338         try {

   339             enc.onUnmappableCharacter(CodingErrorAction.REPLACE)

   340                 .replaceWith(replacement());

   341         } catch (IllegalArgumentException x) {}

   342     }

   343 

   344     private CharBuffer fcb= CharBuffer.allocate(0);

   345     private CoderResult flushEncoder(CharsetEncoder enc, ByteBuffer bb) {

   346         enc.encode(fcb, bb, true);

   347         return enc.flush(bb);

   348     }

   349 }