1 /*

     2  * Copyright (c) 2002, 2006, 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 

    26 /*

    27  */

    28 

    29 package sun.nio.cs.ext;

    30 

    31 import java.nio.ByteBuffer;

    32 import java.nio.CharBuffer;

    33 import java.nio.charset.Charset;

    34 import java.nio.charset.CharsetEncoder;

    35 import java.nio.charset.CoderResult;

    36 import sun.nio.cs.Surrogate;

    37 

    38 public abstract class DoubleByteEncoder

    39     extends CharsetEncoder

    40 {

    41 

    42     private short index1[];

    43     private String index2[];

    44 

    45     private final Surrogate.Parser sgp = new Surrogate.Parser();

    46 

    47     protected DoubleByteEncoder(Charset cs,

    48                                 short[] index1, String[] index2)

    49     {

    50         super(cs, 2.0f, 2.0f);

    51         this.index1 = index1;

    52         this.index2 = index2;

    53     }

    54 

    55     protected DoubleByteEncoder(Charset cs,

    56                                 short[] index1, String[] index2,

    57                                 float avg, float max)

    58     {

    59         super(cs, avg, max);

    60         this.index1 = index1;

    61         this.index2 = index2;

    62     }

    63 

    64     protected DoubleByteEncoder(Charset cs,

    65                                 short[] index1, String[] index2, byte[] repl)

    66     {

    67         super(cs, 2.0f, 2.0f, repl);

    68         this.index1 = index1;

    69         this.index2 = index2;

    70     }

    71 

    72 

    73     protected DoubleByteEncoder(Charset cs,

    74                                 short[] index1, String[] index2,

    75                                 byte[] repl, float avg, float max)

    76     {

    77         super(cs, avg, max,repl);

    78         this.index1 = index1;

    79         this.index2 = index2;

    80     }

    81 

    82     public boolean canEncode(char c) {

    83         return (encodeSingle(c) != -1 ||

    84                 encodeDouble(c) != 0);

    85     }

    86 

    87     private CoderResult encodeArrayLoop(CharBuffer src, ByteBuffer dst) {

    88         char[] sa = src.array();

    89         int sp = src.arrayOffset() + src.position();

    90         int sl = src.arrayOffset() + src.limit();

    91         byte[] da = dst.array();

    92         int dp = dst.arrayOffset() + dst.position();

    93         int dl = dst.arrayOffset() + dst.limit();

    94 

    95         try {

    96             while (sp < sl) {

    97                 char c = sa[sp];

    98                 if (Character.isSurrogate(c)) {

    99                     if (sgp.parse(c, sa, sp, sl) < 0)

   100                         return sgp.error();

   101                     if (sl - sp < 2)

   102                         return CoderResult.UNDERFLOW;

   103                     char c2 = sa[sp + 1];

   104 

   105                     byte[] outputBytes = new byte[2];

   106                     outputBytes = encodeSurrogate(c, c2);

   107 

   108                     if (outputBytes == null) {

   109                         return sgp.unmappableResult();

   110                     }

   111                     else {

   112                         if (dl - dp < 2)

   113                             return CoderResult.OVERFLOW;

   114                         da[dp++] = outputBytes[0];

   115                         da[dp++] = outputBytes[1];

   116                         sp += 2;

   117                         continue;

   118                     }

   119                 }

   120                 if (c >= '\uFFFE')

   121                     return CoderResult.unmappableForLength(1);

   122 

   123                 int b = encodeSingle(c);

   124                 if (b != -1) { // Single Byte

   125                     if (dl - dp < 1)

   126                         return CoderResult.OVERFLOW;

   127                     da[dp++] = (byte)b;

   128                     sp++;

   129                     continue;

   130                 }

   131 

   132                 int ncode  = encodeDouble(c);

   133                 if (ncode != 0 && c != '\u0000' ) {

   134                     if (dl - dp < 2)

   135                         return CoderResult.OVERFLOW;

   136                     da[dp++] = (byte) ((ncode & 0xff00) >> 8);

   137                     da[dp++] = (byte) (ncode & 0xff);

   138                     sp++;

   139                     continue;

   140                 }

   141                 return CoderResult.unmappableForLength(1);

   142                 }

   143             return CoderResult.UNDERFLOW;

   144         } finally {

   145             src.position(sp - src.arrayOffset());

   146             dst.position(dp - dst.arrayOffset());

   147         }

   148     }

   149 

   150     private CoderResult encodeBufferLoop(CharBuffer src, ByteBuffer dst) {

   151         int mark = src.position();

   152 

   153         try {

   154             while (src.hasRemaining()) {

   155                 char c = src.get();

   156                 if (Character.isSurrogate(c)) {

   157                     int surr;

   158                     if ((surr = sgp.parse(c, src)) < 0)

   159                         return sgp.error();

   160                     char c2 = Surrogate.low(surr);

   161                     byte[] outputBytes = new byte[2];

   162                     outputBytes = encodeSurrogate(c, c2);

   163 

   164                     if (outputBytes == null) {

   165                         return sgp.unmappableResult();

   166                     } else {

   167                         if (dst.remaining() < 2)

   168                             return CoderResult.OVERFLOW;

   169                         mark += 2;

   170                         dst.put(outputBytes[0]);

   171                         dst.put(outputBytes[1]);

   172                         continue;

   173                     }

   174                 }

   175                 if (c >= '\uFFFE')

   176                     return CoderResult.unmappableForLength(1);

   177                 int b = encodeSingle(c);

   178 

   179                 if (b != -1) { // Single-byte character

   180                     if (dst.remaining() < 1)

   181                         return CoderResult.OVERFLOW;

   182                     mark++;

   183                     dst.put((byte)b);

   184                     continue;

   185                 }

   186                 // Double Byte character

   187 

   188                 int ncode = encodeDouble(c);

   189                 if (ncode != 0 && c != '\u0000') {

   190                     if (dst.remaining() < 2)

   191                         return CoderResult.OVERFLOW;

   192                     mark++;

   193                     dst.put((byte) ((ncode & 0xff00) >> 8));

   194                     dst.put((byte) ncode);

   195                     continue;

   196                 }

   197                 return CoderResult.unmappableForLength(1);

   198             }

   199 

   200             return CoderResult.UNDERFLOW;

   201         } finally {

   202             src.position(mark);

   203         }

   204     }

   205 

   206     protected CoderResult encodeLoop(CharBuffer src, ByteBuffer dst) {

   207         if (true && src.hasArray() && dst.hasArray())

   208             return encodeArrayLoop(src, dst);

   209         else

   210             return encodeBufferLoop(src, dst);

   211     }

   212 

   213     /*

   214      * Can be changed by subclass

   215      */

   216     protected int encodeDouble(char ch) {

   217         int offset = index1[((ch & 0xff00) >> 8 )] << 8;

   218         return index2[offset >> 12].charAt((offset & 0xfff) + (ch & 0xff));

   219     }

   220 

   221     /*

   222      * Can be changed by subclass

   223      */

   224     protected int encodeSingle(char inputChar) {

   225         if (inputChar < 0x80)

   226             return (byte)inputChar;

   227         else

   228             return -1;

   229     }

   230 

   231     /**

   232      *  Protected method which should be overridden by concrete DBCS

   233      *  CharsetEncoder classes which included supplementary characters

   234      *  within their mapping coverage.

   235      *  null return value indicates surrogate values could not be

   236      *  handled or encoded.

   237      */

   238     protected byte[] encodeSurrogate(char highSurrogate, char lowSurrogate) {

   239         return null;

   240     }

   241 }