1 /*

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

     3  *

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

     5  *

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

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

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

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

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

    11  *

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

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

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

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

    16  * accompanied this code).

    17  *

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

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

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

    21  *

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

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

    24  * questions.

    25  *

    26  */

    27 

    28 // -- This file was mechanically generated: Do not edit! -- //

    29 

    30 package sun.nio.cs;

    31 

    32 import java.nio.charset.Charset;

    33 import java.nio.charset.spi.CharsetProvider;

    34 import java.util.Iterator;

    35 import java.util.Map;

    36 import java.util.Set;

    37 import jdk.internal.vm.annotation.Stable;

    38 import sun.security.action.GetPropertyAction;

    39 

    40 public class StandardCharsets extends CharsetProvider {

    41 

    42     _INCLUDE_ALIASES_TABLES_

    43     _INCLUDE_ALIASES_MAP_

    44     _INCLUDE_CLASSES_MAP_

    45     _INCLUDE_CACHE_MAP_

    46 

    47     // Maps canonical names to class names

    48     private @Stable Map<String,String> classMap;

    49 

    50     // Maps alias names to canonical names

    51     private @Stable Map<String,String> aliasMap;

    52 

    53     // Maps canonical names to cached instances

    54     private @Stable Map<String,Charset> cache;

    55 

    56     private static final String packagePrefix = "sun.nio.cs.";

    57 

    58     public StandardCharsets() {

    59     }

    60 

    61     private String canonicalize(String csn) {

    62         String acn = aliasMap().get(csn);

    63         return (acn != null) ? acn : csn;

    64     }

    65 

    66     private Map<String,String> aliasMap() {

    67         Map<String,String> map = aliasMap;

    68         if (map == null) {

    69             aliasMap = map = new Aliases();

    70         }

    71         return map;

    72     }

    73 

    74     private Map<String,String> classMap() {

    75         Map<String,String> map = classMap;

    76         if (map == null) {

    77             classMap = map = new Classes();

    78         }

    79         return map;

    80     }

    81 

    82     private Map<String,Charset> cache() {

    83         Map<String,Charset> map = cache;

    84         if (map == null) {

    85             map = new Cache();

    86             map.put("utf-8", UTF_8.INSTANCE);

    87             map.put("iso-8859-1", ISO_8859_1.INSTANCE);

    88             map.put("us-ascii", US_ASCII.INSTANCE);

    89             cache = map;

    90         }

    91         return map;

    92     }

    93 

    94     // Private ASCII-only version, optimized for interpretation during startup

    95     //

    96     private static String toLower(String s) {

    97         int n = s.length();

    98         boolean allLower = true;

    99         for (int i = 0; i < n; i++) {

   100             int c = s.charAt(i);

   101             if (((c - 'A') | ('Z' - c)) >= 0) {

   102                 allLower = false;

   103                 break;

   104             }

   105         }

   106         if (allLower)

   107             return s;

   108         StringBuilder sb = new StringBuilder(n);

   109         for (int i = 0; i < n; i++) {

   110             int c = s.charAt(i);

   111             if (((c - 'A') | ('Z' - c)) >= 0)

   112                 sb.append((char)(c + 0x20));

   113             else

   114                 sb.append((char)c);

   115         }

   116         return sb.toString();

   117     }

   118 

   119     private Charset lookup(String charsetName) {

   120         init();

   121 

   122         // By checking these built-ins we can avoid initializing Aliases and

   123         // Classes eagerly during bootstrap

   124         String csn;

   125         if (charsetName.equals("UTF-8")) {

   126             return UTF_8.INSTANCE;

   127         } else if (charsetName.equals("US-ASCII")) {

   128             return US_ASCII.INSTANCE;

   129         } else if (charsetName.equals("ISO-8859-1")) {

   130             return ISO_8859_1.INSTANCE;

   131         } else {

   132             csn = canonicalize(toLower(charsetName));

   133         }

   134 

   135         // Check cache first

   136         Charset cs = cache().get(csn);

   137         if (cs != null)

   138             return cs;

   139 

   140         // Do we even support this charset?

   141         String cln = classMap().get(csn);

   142         if (cln == null)

   143             return null;

   144 

   145         // Instantiate the charset and cache it

   146         try {

   147             @SuppressWarnings("deprecation")

   148             Object o = Class.forName(packagePrefix + cln,

   149                                      true,

   150                                      this.getClass().getClassLoader()).newInstance();

   151             return cache(csn, (Charset)o);

   152         } catch (ClassNotFoundException |

   153                  IllegalAccessException |

   154                  InstantiationException x) {

   155             return null;

   156         }

   157     }

   158 

   159     private Charset cache(String csn, Charset cs) {

   160         cache().put(csn, cs);

   161         return cs;

   162     }

   163 

   164     public final Charset charsetForName(String charsetName) {

   165         synchronized (this) {

   166             return lookup(charsetName);

   167         }

   168     }

   169 

   170     public final Iterator<Charset> charsets() {

   171         Set<String> charsetNames;

   172         synchronized (this) {

   173             init();

   174             // Ensure initialized in synchronized block

   175             charsetNames = classMap().keySet();

   176             aliasMap();

   177             cache();

   178         }

   179         return new Iterator<Charset>() {

   180 

   181                 Iterator<String> i = charsetNames.iterator();

   182 

   183                 public boolean hasNext() {

   184                     return i.hasNext();

   185                 }

   186 

   187                 public Charset next() {

   188                     String csn = i.next();

   189                     return lookup(csn);

   190                 }

   191 

   192                 public void remove() {

   193                     throw new UnsupportedOperationException();

   194                 }

   195 

   196             };

   197     }

   198 

   199     private boolean initialized = false;

   200 

   201     /*   provider the sun.nio.cs.map property fir sjis/ms932 mapping hack

   202      */

   203     private void init() {

   204         if (initialized)

   205             return;

   206         if (!jdk.internal.misc.VM.isBooted())

   207             return;

   208         initialized = true;

   209 

   210         String map = GetPropertyAction.privilegedGetProperty("sun.nio.cs.map");

   211         if (map != null) {

   212             Map<String,String> aliasMap = aliasMap();

   213             Map<String,String> classMap = classMap();

   214             String[] maps = map.split(",");

   215             for (int i = 0; i < maps.length; i++) {

   216                 if (maps[i].equalsIgnoreCase("Windows-31J/Shift_JIS")) {

   217                     // if we dont have both sjis and ms932, do nothing

   218                     if (classMap.get("shift_jis") == null ||

   219                         classMap.get("windows-31j") == null) {

   220                         break;

   221                     }

   222                     aliases_MS932 = new String[] {

   223                         "MS932",        // JDK historical

   224                         "windows-932",

   225                         "csWindows31J",

   226                         "shift-jis",

   227                         "ms_kanji",

   228                         "x-sjis",

   229                         "csShiftJIS",

   230                         // This alias takes precedence over the actual

   231                         // Shift_JIS charset itself since aliases are always

   232                         // resolved first, before looking up canonical names.

   233                         "shift_jis"

   234                     };

   235                     aliases_SJIS = new String[] { "sjis" };

   236 

   237                     for (String alias : aliases_MS932) {

   238                         aliasMap.put(toLower(alias), "windows-31j");

   239                     }

   240                     cache().put("shift_jis", null);

   241                     break;

   242                 }

   243             }

   244         }

   245     }

   246 

   247 }