1 /*

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

    26 package sun.io;

    27 

    28 public class ByteToCharISO2022JP extends ByteToCharJIS0208 {

    29 

    30     private static final int ASCII = 0;                 // ESC ( B

    31     private static final int JISX0201_1976 = 1;         // ESC ( J

    32     private static final int JISX0208_1978 = 2;         // ESC $ @

    33     private static final int JISX0208_1983 = 3;         // ESC $ B

    34     private static final int JISX0201_1976_KANA = 4;    // ESC ( I

    35     private static final int SHIFTOUT = 5;              // SO (0x0e)

    36 

    37     private int currentState;

    38     private int savedSize;

    39     private byte[] savedBytes;

    40 

    41     public ByteToCharISO2022JP() {

    42         super();

    43         savedBytes = new byte[2];

    44         currentState = ASCII;

    45         savedSize = 0;

    46     }

    47 

    48     public int flush(char [] output, int outStart, int outEnd)

    49         throws MalformedInputException

    50     {

    51         if (savedSize != 0) {

    52             savedSize = 0;

    53             currentState = ASCII;

    54             badInputLength = 0;

    55             throw new MalformedInputException();

    56         }

    57         byteOff = charOff = 0;

    58         return 0;

    59     }

    60 

    61 

    62     /**

    63      * Character conversion

    64      */

    65     public int convert(byte[] input, int inOff, int inEnd,

    66                        char[] output, int outOff, int outEnd)

    67         throws UnknownCharacterException, MalformedInputException,

    68                ConversionBufferFullException

    69     {

    70         int previousState = ASCII;

    71         int inputSize = 0;

    72         char outputChar = '\uFFFD';

    73         // readOff keeps the actual buffer's pointer.

    74         // byteOff keeps original buffer's pointer.

    75         int readOff = byteOff = inOff;

    76 

    77         if (savedSize != 0) {

    78             if (savedBytes[0] == 0x1b) { // ESC

    79                 if ((savedSize == 2 &&

    80                      (savedBytes[1] == 0x28 &&

    81                       input[0] != 'B' &&

    82                       input[0] != 'J' &&

    83                       input[0] != 'I') &&

    84                      (savedBytes[1] == 0x24 &&

    85                       input[0] != '@' &&

    86                       input[0] != 'B')) ||

    87                     ((savedSize == 1) &&

    88                      (input[0] != 0x28 &&

    89                       input[0] != 0x24))) {

    90                     badInputLength = 0;

    91                     throw new MalformedInputException();

    92                 }

    93                 if ((inEnd - inOff) == 1 && savedSize == 1 &&

    94                     savedBytes[0] == 0x1b) {

    95                     savedSize = 2;

    96                     savedBytes[1] = input[0];

    97                     byteOff++;

    98                     return 0;

    99                 }

   100             }

   101             byte[] newBuf = new byte[inEnd - inOff + savedSize];

   102             for (int i = 0; i < savedSize; i++) {

   103                 newBuf[i] = savedBytes[i];

   104             }

   105             System.arraycopy(input, inOff, newBuf, savedSize, inEnd - inOff);

   106             byteOff -= savedSize;

   107             input = newBuf;

   108             inOff = 0;

   109             inEnd = newBuf.length;

   110             savedSize = 0;

   111         }

   112 

   113         charOff = outOff;

   114         readOff = inOff;

   115 

   116         while(readOff < inEnd) {

   117             int byte1, byte2, byte3;

   118             boolean noOutput = false;

   119 

   120             // Is there room in the output buffer for the result?

   121             if (charOff >= outEnd) {

   122                 throw new ConversionBufferFullException();

   123             }

   124 

   125             // Get the input byte

   126             byte1 = input[readOff] & 0xFF;

   127             inputSize = 1;

   128 

   129             if ((byte1 & (byte)0x80) != 0){

   130                 badInputLength = 1;

   131                 throw new MalformedInputException();

   132             }

   133 

   134             // Is this a escape sequence?

   135             while (byte1 == 0x1b || byte1 == 0x0e || byte1 == 0x0f) {

   136                 if (byte1 == 0x1b){  // ESC

   137                     if (readOff + inputSize + 1 >= inEnd) {

   138                         if (readOff + inputSize >= inEnd) {

   139                             savedSize = 1;

   140                             savedBytes[0] = (byte)byte1;

   141                         } else {

   142                             savedSize = 2;

   143                             savedBytes[0] = (byte)byte1;

   144                             savedBytes[1] = input[readOff + inputSize];

   145                             inputSize++;

   146                         }

   147                         break;

   148                     }

   149                     byte2 = input[readOff + inputSize] & 0xFF;

   150                     inputSize++;

   151                     if ((byte2 & (byte)0x80) != 0){

   152                         badInputLength = 2;

   153                         throw new MalformedInputException();

   154                     }

   155                     if (byte2 == 0x28){

   156                         byte3 = input[readOff + inputSize] & 0xFF;

   157                         inputSize++;

   158                         if (byte3 == 'B'){

   159                             currentState = ASCII;

   160                         } else if (byte3 == 'J'){

   161                             currentState = JISX0201_1976;

   162                         } else if (byte3 == 'I'){

   163                             currentState = JISX0201_1976_KANA;

   164                         } else {

   165                             // illegal ESC sequence

   166                             badInputLength = 3;

   167                             throw new MalformedInputException();

   168                         }

   169                     } else if (byte2 == '$'){

   170                         byte3 = input[readOff + inputSize] & 0xFF;

   171                         inputSize++;

   172                         if ((byte3 & (byte)0x80) != 0){

   173                             badInputLength = 3;

   174                             throw new MalformedInputException();

   175                         }

   176                         if (byte3 == '@'){

   177                             currentState = JISX0208_1978;

   178                         } else if (byte3 == 'B'){

   179                             currentState = JISX0208_1983;

   180                         } else {

   181                             // illegal ESC sequence

   182                             badInputLength = 3;

   183                             throw new MalformedInputException();

   184                         }

   185                     } else {

   186                         // illegal ESC sequence

   187                         badInputLength = 2;

   188                         throw new MalformedInputException();

   189                     }

   190                     if (readOff + inputSize >= inEnd) {

   191                         noOutput = true;

   192                         break;

   193                     } else {

   194                         byte1 = input[readOff + inputSize];

   195                         inputSize++;

   196                     }

   197                 } else if (byte1 == 0x0e){  // shift out for one byte kana

   198                     previousState = currentState;

   199                     currentState = SHIFTOUT;

   200                     if (readOff + inputSize >= inEnd) {

   201                         noOutput = true;

   202                         break;

   203                     }

   204                     byte1 = input[readOff + inputSize];

   205                     inputSize++;

   206                     if ((byte1 & (byte)0x80) != 0){

   207                         badInputLength = 1;

   208                         throw new MalformedInputException();

   209                     }

   210                 } else if (byte1 == 0x0f){  // shift in for previous mode

   211                     currentState = previousState;

   212                     if (readOff + inputSize >= inEnd) {

   213                         noOutput = true;

   214                         break;

   215                     }

   216                     byte1 = input[readOff + inputSize];

   217                     inputSize++;

   218                     if ((byte1 & (byte)0x80) != 0){

   219                         badInputLength = 1;

   220                         throw new MalformedInputException();

   221                     }

   222                 }

   223             }

   224             if (noOutput || savedSize != 0) {

   225                 byteOff += inputSize;

   226                 break;

   227             }

   228             noOutput = false;

   229             switch (currentState){

   230               case ASCII:

   231                 outputChar = (char)(byte1 & 0xff);

   232                 break;

   233               case JISX0201_1976:

   234                 switch (byte1) {

   235                   case 0x5c:

   236                     outputChar = '\u00a5';

   237                     break;

   238                   case 0x7e:

   239                     outputChar = '\u203e';

   240                     break;

   241                   default:

   242                     outputChar = (char)byte1;

   243                     break;

   244                 }

   245                 break;

   246               case JISX0208_1978:

   247               case JISX0208_1983:

   248                 if (readOff + inputSize >= inEnd) {

   249                     savedSize = 1;

   250                     savedBytes[0] = (byte)byte1;

   251                     break;

   252                 }

   253                 byte2 = input[readOff + inputSize] & 0xff;

   254                 inputSize++;

   255                 if ((byte2 & (byte)0x80) != 0){

   256                     badInputLength = 1;

   257                     throw new MalformedInputException();

   258                 }

   259                 // jisx0208Chars table convert FULLWIDTH_REVERSE_SOLIDUS

   260                 // 0x2140 to REVERSE_SOLIDUS (BACKSLASH) 0x5c.

   261                 // This behavior causes problem because

   262                 // 0x5c is special escape character for java.

   263                 if (byte1 == 0x21 && byte2 == 0x40) {

   264                     outputChar = '\uFF3C';

   265                 } else {

   266                     try {

   267                         outputChar = getUnicode(byte1, byte2);

   268                     } catch (ArrayIndexOutOfBoundsException e) {

   269                         outputChar = '\uFFFD';

   270                     }

   271                 }

   272                 break;

   273               case JISX0201_1976_KANA:

   274               case SHIFTOUT:

   275                 if (byte1 > 0x60) {

   276                     badInputLength = 1;

   277                     throw new MalformedInputException();

   278                 }

   279                 outputChar = (char)(byte1 + 0xff40);

   280                 break;

   281             }

   282 

   283             if (savedSize != 0) {

   284                 byteOff += inputSize;

   285                 break;

   286             }

   287 

   288             if (outputChar == '\uFFFD') {

   289                 if (subMode)

   290                     outputChar = subChars[0];

   291                 else {

   292                     badInputLength = inputSize;

   293                     throw new UnknownCharacterException();

   294                 }

   295             }

   296             readOff += inputSize;

   297             byteOff += inputSize;

   298             output[charOff++] = outputChar;

   299         }

   300 

   301         return charOff - outOff;

   302     }

   303 

   304     public void reset() {

   305         byteOff = charOff = 0;

   306         currentState = ASCII;

   307         savedSize = 0;

   308     }

   309 

   310     public String getCharacterEncoding() {

   311         return "ISO2022JP";

   312     }

   313 }