1 /*

     2  * Copyright (c) 1998, 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 import java.io.UnsupportedEncodingException;

    29 import java.lang.ref.SoftReference;

    30 import java.util.Properties;

    31 

    32 /**

    33  * Package-private utility class that caches the default converter classes and

    34  * provides other logic common to both the ByteToCharConverter and

    35  * CharToByteConverter classes.

    36  *

    37  * @author   Mark Reinhold

    38  * @since    1.2

    39  *

    40  * @deprecated Replaced by {@link java.nio.charset}.  THIS API WILL BE

    41  * REMOVED IN J2SE 1.6.

    42  */

    43 @Deprecated

    44 public class Converters {

    45 

    46     private Converters() { }    /* To prevent instantiation */

    47 

    48     /* Lock for all static fields in this class */

    49     private static Object lock = Converters.class;

    50 

    51     /* Cached values of system properties */

    52     private static String converterPackageName = null;  /* file.encoding.pkg */

    53     private static String defaultEncoding = null;       /* file.encoding */

    54 

    55     /* Converter type constants and names */

    56     public static final int BYTE_TO_CHAR = 0;

    57     public static final int CHAR_TO_BYTE = 1;

    58     private static final String[] converterPrefix = { "ByteToChar",

    59                                                       "CharToByte" };

    60 

    61 

    62     // -- Converter class cache --

    63 

    64     private static final int CACHE_SIZE = 3;

    65 

    66     /* For the default charset, whatever it turns out to be */

    67     private static final Object DEFAULT_NAME = new Object();

    68 

    69     /* Cached converter classes, CACHE_SIZE per converter type.  Each cache

    70      * entry is a soft reference to a two-object array; the first element of

    71      * the array is the converter class, the second is an object (typically a

    72      * string) representing the encoding name that was used to request the

    73      * converter, e.g.,

    74      *

    75      *     ((Object[])classCache[CHAR_TO_BYTE][i].get())[0]

    76      *

    77      * will be a CharToByteConverter and

    78      *

    79      *     ((Object[])classCache[CHAR_TO_BYTE][i].get())[1]

    80      *

    81      * will be the string encoding name used to request it, assuming that cache

    82      * entry i is valid.

    83      *

    84      * Ordinarily we'd do this with a private static utility class, but since

    85      * this code can be involved in the startup sequence it's important to keep

    86      * the footprint down.

    87      */

    88     @SuppressWarnings("unchecked")

    89     private static SoftReference<Object[]>[][] classCache

    90         = (SoftReference<Object[]>[][]) new SoftReference<?>[][] {

    91             new SoftReference<?>[CACHE_SIZE],

    92             new SoftReference<?>[CACHE_SIZE]

    93         };

    94 

    95     private static void moveToFront(Object[] oa, int i) {

    96         Object ob = oa[i];

    97         for (int j = i; j > 0; j--)

    98             oa[j] = oa[j - 1];

    99         oa[0] = ob;

   100     }

   101 

   102     private static Class<?> cache(int type, Object encoding) {

   103         SoftReference<Object[]>[] srs = classCache[type];

   104         for (int i = 0; i < CACHE_SIZE; i++) {

   105             SoftReference<Object[]> sr = srs[i];

   106             if (sr == null)

   107                 continue;

   108             Object[] oa = sr.get();

   109             if (oa == null) {

   110                 srs[i] = null;

   111                 continue;

   112             }

   113             if (oa[1].equals(encoding)) {

   114                 moveToFront(srs, i);

   115                 return (Class<?>)oa[0];

   116             }

   117         }

   118         return null;

   119     }

   120 

   121     private static Class<?> cache(int type, Object encoding, Class<?> c) {

   122         SoftReference<Object[]>[] srs = classCache[type];

   123         srs[CACHE_SIZE - 1] = new SoftReference<>(new Object[] { c, encoding });

   124         moveToFront(srs, CACHE_SIZE - 1);

   125         return c;

   126     }

   127 

   128     /* Used to avoid doing expensive charset lookups for charsets that are not

   129      * yet directly supported by NIO.

   130      */

   131     public static boolean isCached(int type, String encoding) {

   132         synchronized (lock) {

   133             SoftReference<Object[]>[] srs = classCache[type];

   134             for (int i = 0; i < CACHE_SIZE; i++) {

   135                 SoftReference<Object[]> sr = srs[i];

   136                 if (sr == null)

   137                     continue;

   138                 Object[] oa = sr.get();

   139                 if (oa == null) {

   140                     srs[i] = null;

   141                     continue;

   142                 }

   143                 if (oa[1].equals(encoding))

   144                     return true;

   145             }

   146             return false;

   147         }

   148     }

   149 

   150 

   151 

   152     /** Get the name of the converter package */

   153     private static String getConverterPackageName() {

   154         String cp = converterPackageName;

   155         if (cp != null) return cp;

   156         java.security.PrivilegedAction<String> pa =

   157             new sun.security.action.GetPropertyAction("file.encoding.pkg");

   158         cp = java.security.AccessController.doPrivileged(pa);

   159         if (cp != null) {

   160             /* Property is set, so take it as the true converter package */

   161             converterPackageName = cp;

   162         } else {

   163             /* Fall back to sun.io */

   164             cp = "sun.io";

   165         }

   166         return cp;

   167     }

   168 

   169     public static String getDefaultEncodingName() {

   170         synchronized (lock) {

   171             if (defaultEncoding == null) {

   172                 java.security.PrivilegedAction<String> pa =

   173                     new sun.security.action.GetPropertyAction("file.encoding");

   174                 defaultEncoding = java.security.AccessController.doPrivileged(pa);

   175             }

   176         }

   177         return defaultEncoding;

   178     }

   179 

   180     public static void resetDefaultEncodingName() {

   181         // This method should only be called during VM initialization.

   182         if (sun.misc.VM.isBooted())

   183             return;

   184 

   185         synchronized (lock) {

   186             defaultEncoding = "ISO-8859-1";

   187             Properties p = System.getProperties();

   188             p.setProperty("file.encoding", defaultEncoding);

   189             System.setProperties(p);

   190         }

   191     }

   192 

   193     /**

   194      * Get the class that implements the given type of converter for the named

   195      * encoding, or throw an UnsupportedEncodingException if no such class can

   196      * be found

   197      */

   198     private static Class<?> getConverterClass(int type, String encoding)

   199         throws UnsupportedEncodingException

   200     {

   201         String enc = null;

   202 

   203         /* "ISO8859_1" is the canonical name for the ISO-Latin-1 encoding.

   204            Native code in the JDK commonly uses the alias "8859_1" instead of

   205            "ISO8859_1".  We hardwire this alias here in order to avoid loading

   206            the full alias table just for this case. */

   207         if (!encoding.equals("ISO8859_1")) {

   208             if (encoding.equals("8859_1")) {

   209                 enc = "ISO8859_1";

   210             /*

   211              * On Solaris with nl_langinfo() called in GetJavaProperties():

   212              *

   213              *   locale undefined -> NULL -> hardcoded default

   214              *   "C" locale       -> "" -> hardcoded default    (on 2.6)

   215              *   "C" locale       -> "646"                      (on 2.7)

   216              *   "en_US" locale -> "ISO8859-1"

   217              *   "en_GB" locale -> "ISO8859-1"                  (on 2.7)

   218              *   "en_UK" locale -> "ISO8859-1"                  (on 2.6)

   219              */

   220             } else if (encoding.equals("ISO8859-1")) {

   221                 enc = "ISO8859_1";

   222             } else if (encoding.equals("646")) {

   223                 enc = "ASCII";

   224             } else {

   225                 enc = CharacterEncoding.aliasName(encoding);

   226             }

   227         }

   228         if (enc == null) {

   229             enc = encoding;

   230         }

   231 

   232         try {

   233             return Class.forName(getConverterPackageName()

   234                                  + "." + converterPrefix[type] + enc);

   235         } catch(ClassNotFoundException e) {

   236             throw new UnsupportedEncodingException(enc);

   237         }

   238 

   239     }

   240 

   241     /**

   242      * Instantiate the given converter class, or throw an

   243      * UnsupportedEncodingException if it cannot be instantiated

   244      */

   245     private static Object newConverter(String enc, Class<?> c)

   246         throws UnsupportedEncodingException

   247     {

   248         try {

   249             return c.newInstance();

   250         } catch(InstantiationException e) {

   251             throw new UnsupportedEncodingException(enc);

   252         } catch(IllegalAccessException e) {

   253             throw new UnsupportedEncodingException(enc);

   254         }

   255     }

   256 

   257     /**

   258      * Create a converter object that implements the given type of converter

   259      * for the given encoding, or throw an UnsupportedEncodingException if no

   260      * appropriate converter class can be found and instantiated

   261      */

   262     static Object newConverter(int type, String enc)

   263         throws UnsupportedEncodingException

   264     {

   265         Class<?> c;

   266         synchronized (lock) {

   267             c = cache(type, enc);

   268             if (c == null) {

   269                 c = getConverterClass(type, enc);

   270                 if (!c.getName().equals("sun.io.CharToByteUTF8"))

   271                     cache(type, enc, c);

   272             }

   273         }

   274         return newConverter(enc, c);

   275     }

   276 

   277     /**

   278      * Find the class that implements the given type of converter for the

   279      * default encoding.  If the default encoding cannot be determined or is

   280      * not yet defined, return a class that implements the fallback default

   281      * encoding, which is just ISO 8859-1.

   282      */

   283     private static Class<?> getDefaultConverterClass(int type) {

   284         boolean fillCache = false;

   285         Class<?> c;

   286 

   287         /* First check the class cache */

   288         c = cache(type, DEFAULT_NAME);

   289         if (c != null)

   290             return c;

   291 

   292         /* Determine the encoding name */

   293         String enc = getDefaultEncodingName();

   294         if (enc != null) {

   295             /* file.encoding has been set, so cache the converter class */

   296             fillCache = true;

   297         } else {

   298             /* file.encoding has not been set, so use a default encoding which

   299                will not be cached */

   300             enc = "ISO8859_1";

   301         }

   302 

   303         /* We have an encoding name; try to find its class */

   304         try {

   305             c = getConverterClass(type, enc);

   306             if (fillCache) {

   307                 cache(type, DEFAULT_NAME, c);

   308             }

   309         } catch (UnsupportedEncodingException x) {

   310             /* Can't find the default class, so fall back to ISO 8859-1 */

   311             try {

   312                 c = getConverterClass(type, "ISO8859_1");

   313             } catch (UnsupportedEncodingException y) {

   314                 throw new InternalError("Cannot find default "

   315                                         + converterPrefix[type]

   316                                         + " converter class");

   317             }

   318         }

   319         return c;

   320 

   321     }

   322 

   323     /**

   324      * Create a converter object that implements the given type of converter

   325      * for the default encoding, falling back to ISO 8859-1 if the default

   326      * encoding cannot be determined.

   327      */

   328     static Object newDefaultConverter(int type) {

   329         Class<?> c;

   330         synchronized (lock) {

   331             c = getDefaultConverterClass(type);

   332         }

   333         try {

   334             return newConverter("", c);

   335         } catch (UnsupportedEncodingException x) {

   336             throw new InternalError("Cannot instantiate default converter"

   337                                     + " class " + c.getName());

   338         }

   339     }

   340 

   341 }