1 /*

     2  * Copyright 2004-2005 Sun Microsystems, Inc.  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.  Sun designates this

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

     9  * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22  * CA 95054 USA or visit www.sun.com if you need additional information or

    23  * have any questions.

    24  */

    25 

    26 /* Misc functions for conversion of Unicode and UTF-8 and platform encoding */

    27 

    28 #include <stdio.h>

    29 #include <stddef.h>

    30 #include <stdlib.h>

    31 #include <stdarg.h>

    32 #include <string.h>

    33 #include <ctype.h>

    34 

    35 #include "jni.h"

    36 

    37 #include "utf.h"

    38 

    39 /*

    40  * Error handler

    41  */

    42 void

    43 utfError(char *file, int line, char *message)

    44 {

    45     (void)fprintf(stderr, "UTF ERROR [\"%s\":%d]: %s\n", file, line, message);

    46     abort();

    47 }

    48 

    49 /*

    50  * Convert UTF-8 to UTF-16

    51  *    Returns length or -1 if output overflows.

    52  */

    53 int JNICALL

    54 utf8ToUtf16(struct UtfInst *ui, jbyte *utf8, int len, unsigned short *output, int outputMaxLen)

    55 {

    56     int outputLen;

    57     int i;

    58 

    59     UTF_ASSERT(utf8);

    60     UTF_ASSERT(len>=0);

    61     UTF_ASSERT(output);

    62     UTF_ASSERT(outputMaxLen>0);

    63 

    64     i = 0;

    65     outputLen = 0;

    66     while ( i<len ) {

    67         unsigned code, x, y, z;

    68 

    69         if ( outputLen >= outputMaxLen ) {

    70             return -1;

    71         }

    72         x = (unsigned char)utf8[i++];

    73         code = x;

    74         if ( (x & 0xE0)==0xE0 ) {

    75             y = (unsigned char)utf8[i++];

    76             z = (unsigned char)utf8[i++];

    77             code = ((x & 0xF)<<12) + ((y & 0x3F)<<6) + (z & 0x3F);

    78         } else if ( (x & 0xC0)==0xC0 ) {

    79             y = (unsigned char)utf8[i++];

    80             code = ((x & 0x1F)<<6) + (y & 0x3F);

    81         }

    82         output[outputLen++] = code;

    83     }

    84     return outputLen;

    85 }

    86 

    87 /*

    88  * Convert UTF-16 to UTF-8 Modified

    89  *    Returns length or -1 if output overflows.

    90  */

    91 int JNICALL

    92 utf16ToUtf8m(struct UtfInst *ui, unsigned short *utf16, int len, jbyte *output, int outputMaxLen)

    93 {

    94     int i;

    95     int outputLen;

    96 

    97     UTF_ASSERT(utf16);

    98     UTF_ASSERT(len>=0);

    99     UTF_ASSERT(output);

   100     UTF_ASSERT(outputMaxLen>0);

   101 

   102     outputLen = 0;

   103     for (i = 0; i < len; i++) {

   104         unsigned code;

   105 

   106         code = utf16[i];

   107         if ( code >= 0x0001 && code <= 0x007F ) {

   108             output[outputLen++] = code;

   109         } else if ( code == 0 || ( code >= 0x0080 && code <= 0x07FF ) ) {

   110             output[outputLen++] = ((code>>6) & 0x1F) | 0xC0;

   111             output[outputLen++] = (code & 0x3F) | 0x80;

   112         } else if ( code >= 0x0800 && code <= 0xFFFF ) {

   113             output[outputLen++] = ((code>>12) & 0x0F) | 0xE0;

   114             output[outputLen++] = ((code>>6) & 0x3F) | 0x80;

   115             output[outputLen++] = (code & 0x3F) | 0x80;

   116         }

   117         if ( outputLen > outputMaxLen ) {

   118             return -1;

   119         }

   120     }

   121     output[outputLen] = 0;

   122     return outputLen;

   123 }

   124 

   125 int JNICALL

   126 utf16ToUtf8s(struct UtfInst *ui, unsigned short *utf16, int len, jbyte *output, int outputMaxLen)

   127 {

   128     return -1; /* FIXUP */

   129 }

   130 

   131 /* Determine length of this Standard UTF-8 in Modified UTF-8.

   132  *    Validation is done of the basic UTF encoding rules, returns

   133  *    length (no change) when errors are detected in the UTF encoding.

   134  *

   135  *    Note: Accepts Modified UTF-8 also, no verification on the

   136  *          correctness of Standard UTF-8 is done. e,g, 0xC080 input is ok.

   137  */

   138 int JNICALL

   139 utf8sToUtf8mLength(struct UtfInst *ui, jbyte *string, int length)

   140 {

   141     int newLength;

   142     int i;

   143 

   144     newLength = 0;

   145     for ( i = 0 ; i < length ; i++ ) {

   146         unsigned byte;

   147 

   148         byte = (unsigned char)string[i];

   149         if ( (byte & 0x80) == 0 ) { /* 1byte encoding */

   150             newLength++;

   151             if ( byte == 0 ) {

   152                 newLength++; /* We gain one byte in length on NULL bytes */

   153             }

   154         } else if ( (byte & 0xE0) == 0xC0 ) { /* 2byte encoding */

   155             /* Check encoding of following bytes */

   156             if ( (i+1) >= length || (string[i+1] & 0xC0) != 0x80 ) {

   157                 break; /* Error condition */

   158             }

   159             i++; /* Skip next byte */

   160             newLength += 2;

   161         } else if ( (byte & 0xF0) == 0xE0 ) { /* 3byte encoding */

   162             /* Check encoding of following bytes */

   163             if ( (i+2) >= length || (string[i+1] & 0xC0) != 0x80

   164                                  || (string[i+2] & 0xC0) != 0x80 ) {

   165                 break; /* Error condition */

   166             }

   167             i += 2; /* Skip next two bytes */

   168             newLength += 3;

   169         } else if ( (byte & 0xF8) == 0xF0 ) { /* 4byte encoding */

   170             /* Check encoding of following bytes */

   171             if ( (i+3) >= length || (string[i+1] & 0xC0) != 0x80

   172                                  || (string[i+2] & 0xC0) != 0x80

   173                                  || (string[i+3] & 0xC0) != 0x80 ) {

   174                 break; /* Error condition */

   175             }

   176             i += 3; /* Skip next 3 bytes */

   177             newLength += 6; /* 4byte encoding turns into 2 3byte ones */

   178         } else {

   179             break; /* Error condition */

   180         }

   181     }

   182     if ( i != length ) {

   183         /* Error in finding new length, return old length so no conversion */

   184         /* FIXUP: ERROR_MESSAGE? */

   185         return length;

   186     }

   187     return newLength;

   188 }

   189 

   190 /* Convert Standard UTF-8 to Modified UTF-8.

   191  *    Assumes the UTF-8 encoding was validated by utf8mLength() above.

   192  *

   193  *    Note: Accepts Modified UTF-8 also, no verification on the

   194  *          correctness of Standard UTF-8 is done. e,g, 0xC080 input is ok.

   195  */

   196 void JNICALL

   197 utf8sToUtf8m(struct UtfInst *ui, jbyte *string, int length, jbyte *newString, int newLength)

   198 {

   199     int i;

   200     int j;

   201 

   202     j = 0;

   203     for ( i = 0 ; i < length ; i++ ) {

   204         unsigned byte1;

   205 

   206         byte1 = (unsigned char)string[i];

   207 

   208         /* NULL bytes and bytes starting with 11110xxx are special */

   209         if ( (byte1 & 0x80) == 0 ) { /* 1byte encoding */

   210             if ( byte1 == 0 ) {

   211                 /* Bits out: 11000000 10000000 */

   212                 newString[j++] = (jbyte)0xC0;

   213                 newString[j++] = (jbyte)0x80;

   214             } else {

   215                 /* Single byte */

   216                 newString[j++] = byte1;

   217             }

   218         } else if ( (byte1 & 0xE0) == 0xC0 ) { /* 2byte encoding */

   219             newString[j++] = byte1;

   220             newString[j++] = string[++i];

   221         } else if ( (byte1 & 0xF0) == 0xE0 ) { /* 3byte encoding */

   222             newString[j++] = byte1;

   223             newString[j++] = string[++i];

   224             newString[j++] = string[++i];

   225         } else if ( (byte1 & 0xF8) == 0xF0 ) { /* 4byte encoding */

   226             /* Beginning of 4byte encoding, turn into 2 3byte encodings */

   227             unsigned byte2, byte3, byte4, u21;

   228 

   229             /* Bits in: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */

   230             byte2 = (unsigned char)string[++i];

   231             byte3 = (unsigned char)string[++i];

   232             byte4 = (unsigned char)string[++i];

   233             /* Reconstruct full 21bit value */

   234             u21  = (byte1 & 0x07) << 18;

   235             u21 += (byte2 & 0x3F) << 12;

   236             u21 += (byte3 & 0x3F) << 6;

   237             u21 += (byte4 & 0x3F);

   238             /* Bits out: 11101101 1010xxxx 10xxxxxx */

   239             newString[j++] = (jbyte)0xED;

   240             newString[j++] = (jbyte)(0xA0 + (((u21 >> 16) - 1) & 0x0F));

   241             newString[j++] = (jbyte)(0x80 + ((u21 >> 10) & 0x3F));

   242             /* Bits out: 11101101 1011xxxx 10xxxxxx */

   243             newString[j++] = (jbyte)0xED;

   244             newString[j++] = (jbyte)(0xB0 + ((u21 >>  6) & 0x0F));

   245             newString[j++] = byte4;

   246         }

   247     }

   248     UTF_ASSERT(i==length);

   249     UTF_ASSERT(j==newLength);

   250     newString[j] = (jbyte)0;

   251 }

   252 

   253 /* Given a Modified UTF-8 string, calculate the Standard UTF-8 length.

   254  *   Basic validation of the UTF encoding rules is done, and length is

   255  *   returned (no change) when errors are detected.

   256  *

   257  *   Note: No validation is made that this is indeed Modified UTF-8 coming in.

   258  *

   259  */

   260 int JNICALL

   261 utf8mToUtf8sLength(struct UtfInst *ui, jbyte *string, int length)

   262 {

   263     int newLength;

   264     int i;

   265 

   266     newLength = 0;

   267     for ( i = 0 ; i < length ; i++ ) {

   268         unsigned byte1, byte2, byte3, byte4, byte5, byte6;

   269 

   270         byte1 = (unsigned char)string[i];

   271         if ( (byte1 & 0x80) == 0 ) { /* 1byte encoding */

   272             newLength++;

   273         } else if ( (byte1 & 0xE0) == 0xC0 ) { /* 2byte encoding */

   274             /* Check encoding of following bytes */

   275             if ( (i+1) >= length || (string[i+1] & 0xC0) != 0x80 ) {

   276                 break; /* Error condition */

   277             }

   278             byte2 = (unsigned char)string[++i];

   279             if ( byte1 != 0xC0 || byte2 != 0x80 ) {

   280                 newLength += 2; /* Normal 2byte encoding, not 0xC080 */

   281             } else {

   282                 newLength++;    /* We will turn 0xC080 into 0 */

   283             }

   284         } else if ( (byte1 & 0xF0) == 0xE0 ) { /* 3byte encoding */

   285             /* Check encoding of following bytes */

   286             if ( (i+2) >= length || (string[i+1] & 0xC0) != 0x80

   287                                  || (string[i+2] & 0xC0) != 0x80 ) {

   288                 break; /* Error condition */

   289             }

   290             byte2 = (unsigned char)string[++i];

   291             byte3 = (unsigned char)string[++i];

   292             newLength += 3;

   293             /* Possible process a second 3byte encoding */

   294             if ( (i+3) < length && byte1 == 0xED && (byte2 & 0xF0) == 0xA0 ) {

   295                 /* See if this is a pair of 3byte encodings */

   296                 byte4 = (unsigned char)string[i+1];

   297                 byte5 = (unsigned char)string[i+2];

   298                 byte6 = (unsigned char)string[i+3];

   299                 if ( byte4 == 0xED && (byte5 & 0xF0) == 0xB0 ) {

   300                     /* Check encoding of 3rd byte */

   301                     if ( (byte6 & 0xC0) != 0x80 ) {

   302                         break; /* Error condition */

   303                     }

   304                     newLength++; /* New string will have 4byte encoding */

   305                     i += 3;       /* Skip next 3 bytes */

   306                 }

   307             }

   308         } else {

   309             break; /* Error condition */

   310         }

   311     }

   312     if ( i != length ) {

   313         /* Error in UTF encoding */

   314         /*  FIXUP: ERROR_MESSAGE()? */

   315         return length;

   316     }

   317     return newLength;

   318 }

   319 

   320 /* Convert a Modified UTF-8 string into a Standard UTF-8 string

   321  *   It is assumed that this string has been validated in terms of the

   322  *   basic UTF encoding rules by utf8Length() above.

   323  *

   324  *   Note: No validation is made that this is indeed Modified UTF-8 coming in.

   325  *

   326  */

   327 void JNICALL

   328 utf8mToUtf8s(struct UtfInst *ui, jbyte *string, int length, jbyte *newString, int newLength)

   329 {

   330     int i;

   331     int j;

   332 

   333     j = 0;

   334     for ( i = 0 ; i < length ; i++ ) {

   335         unsigned byte1, byte2, byte3, byte4, byte5, byte6;

   336 

   337         byte1 = (unsigned char)string[i];

   338         if ( (byte1 & 0x80) == 0 ) { /* 1byte encoding */

   339             /* Single byte */

   340             newString[j++] = byte1;

   341         } else if ( (byte1 & 0xE0) == 0xC0 ) { /* 2byte encoding */

   342             byte2 = (unsigned char)string[++i];

   343             if ( byte1 != 0xC0 || byte2 != 0x80 ) {

   344                 newString[j++] = byte1;

   345                 newString[j++] = byte2;

   346             } else {

   347                 newString[j++] = 0;

   348             }

   349         } else if ( (byte1 & 0xF0) == 0xE0 ) { /* 3byte encoding */

   350             byte2 = (unsigned char)string[++i];

   351             byte3 = (unsigned char)string[++i];

   352             if ( i+3 < length && byte1 == 0xED && (byte2 & 0xF0) == 0xA0 ) {

   353                 /* See if this is a pair of 3byte encodings */

   354                 byte4 = (unsigned char)string[i+1];

   355                 byte5 = (unsigned char)string[i+2];

   356                 byte6 = (unsigned char)string[i+3];

   357                 if ( byte4 == 0xED && (byte5 & 0xF0) == 0xB0 ) {

   358                     unsigned u21;

   359 

   360                     /* Bits in: 11101101 1010xxxx 10xxxxxx */

   361                     /* Bits in: 11101101 1011xxxx 10xxxxxx */

   362                     i += 3;

   363 

   364                     /* Reconstruct 21 bit code */

   365                     u21  = ((byte2 & 0x0F) + 1) << 16;

   366                     u21 += (byte3 & 0x3F) << 10;

   367                     u21 += (byte5 & 0x0F) << 6;

   368                     u21 += (byte6 & 0x3F);

   369 

   370                     /* Bits out: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */

   371 

   372                     /* Convert to 4byte encoding */

   373                     newString[j++] = 0xF0 + ((u21 >> 18) & 0x07);

   374                     newString[j++] = 0x80 + ((u21 >> 12) & 0x3F);

   375                     newString[j++] = 0x80 + ((u21 >>  6) & 0x3F);

   376                     newString[j++] = 0x80 + (u21 & 0x3F);

   377                     continue;

   378                 }

   379             }

   380             /* Normal 3byte encoding */

   381             newString[j++] = byte1;

   382             newString[j++] = byte2;

   383             newString[j++] = byte3;

   384         }

   385     }

   386     UTF_ASSERT(i==length);

   387     UTF_ASSERT(j==newLength);

   388     newString[j] = 0;

   389 }

   390 

   391 /* ================================================================= */

   392 

   393 #if 1  /* Test program */

   394 

   395 /*

   396  * Convert any byte array into a printable string.

   397  *    Returns length or -1 if output overflows.

   398  */

   399 static int

   400 bytesToPrintable(struct UtfInst *ui, char *bytes, int len, char *output, int outputMaxLen)

   401 {

   402     int outputLen;

   403     int i;

   404 

   405     UTF_ASSERT(bytes);

   406     UTF_ASSERT(len>=0);

   407     UTF_ASSERT(output);

   408     UTF_ASSERT(outputMaxLen>=0);

   409 

   410     outputLen = 0;

   411     for ( i=0; i<len ; i++ ) {

   412         unsigned byte;

   413 

   414         byte = bytes[i];

   415         if ( outputLen >= outputMaxLen ) {

   416             return -1;

   417         }

   418         if ( byte <= 0x7f && isprint(byte) && !iscntrl(byte) ) {

   419             output[outputLen++] = (char)byte;

   420         } else {

   421             (void)sprintf(output+outputLen,"\\x%02x",byte);

   422             outputLen += 4;

   423         }

   424     }

   425     output[outputLen] = 0;

   426     return outputLen;

   427 }

   428 

   429 static void

   430 test(void)

   431 {

   432     static char *strings[] = {

   433                 "characters",

   434                 "abcdefghijklmnopqrstuvwxyz",

   435                 "0123456789",

   436                 "!@#$%^&*()_+=-{}[]:;",

   437                 NULL };

   438     int i;

   439     struct UtfInst *ui;

   440 

   441     ui = utfInitialize(NULL);

   442 

   443     i = 0;

   444     while ( strings[i] != NULL ) {

   445         char *str;

   446         #define MAX 1024

   447         char buf0[MAX];

   448         char buf1[MAX];

   449         char buf2[MAX];

   450         unsigned short buf3[MAX];

   451         int len1;

   452         int len2;

   453         int len3;

   454 

   455         str = strings[i];

   456 

   457         (void)bytesToPrintable(ui, str, (int)strlen(str), buf0, 1024);

   458 

   459         len1 = utf8FromPlatform(ui, str, (int)strlen(str), (jbyte*)buf1, 1024);

   460 

   461         UTF_ASSERT(len1==(int)strlen(str));

   462 

   463         len3 = utf8ToUtf16(ui, (jbyte*)buf1, len1, (jchar*)buf3, 1024);

   464 

   465         UTF_ASSERT(len3==len1);

   466 

   467         len1 = utf16ToUtf8m(ui, (jchar*)buf3, len3, (jbyte*)buf1, 1024);

   468 

   469         UTF_ASSERT(len1==len3);

   470         UTF_ASSERT(strcmp(str, buf1) == 0);

   471 

   472         len2 = utf8ToPlatform(ui, (jbyte*)buf1, len1, buf2, 1024);

   473 

   474         UTF_ASSERT(len2==len1);

   475         UTF_ASSERT(strcmp(str, buf2) == 0);

   476 

   477         i++;

   478     }

   479 

   480     utfTerminate(ui, NULL);

   481 

   482 }

   483 

   484 int

   485 main(int argc, char **argv)

   486 {

   487     test();

   488     return 0;

   489 }

   490 

   491 #endif