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", java.nio.charset.StandardCharsets.UTF_8);
87 map.put("iso-8859-1", java.nio.charset.StandardCharsets.ISO_8859_1);
88 map.put("us-ascii", java.nio.charset.StandardCharsets.US_ASCII);
89 map.put("utf-16", java.nio.charset.StandardCharsets.UTF_16);
90 map.put("utf-16be", java.nio.charset.StandardCharsets.UTF_16BE);
91 map.put("utf-16le", java.nio.charset.StandardCharsets.UTF_16LE);
92 cache = map;
93 }
94 return map;
95 }
96
97 // Private ASCII-only version, optimized for interpretation during startup
98 //
99 private static String toLower(String s) {
100 int n = s.length();
101 boolean allLower = true;
102 for (int i = 0; i < n; i++) {
103 int c = s.charAt(i);
104 if (((c - 'A') | ('Z' - c)) >= 0) {
105 allLower = false;
106 break;
107 }
108 }
109 if (allLower)
110 return s;
111 StringBuilder sb = new StringBuilder(n);
112 for (int i = 0; i < n; i++) {
113 int c = s.charAt(i);
114 if (((c - 'A') | ('Z' - c)) >= 0)
115 sb.append((char)(c + 0x20));
116 else
117 sb.append((char)c);
118 }
119 return sb.toString();
120 }
121
122 private Charset lookup(String charsetName) {
123 init();
124
125 // By checking these built-ins we can avoid initializing Aliases and
126 // Classes eagerly during bootstrap
127 String csn;
128 if (charsetName.equals("UTF-8")) {
129 return java.nio.charset.StandardCharsets.UTF_8;
130 } else if (charsetName.equals("US-ASCII")) {
131 return java.nio.charset.StandardCharsets.US_ASCII;
132 } else if (charsetName.equals("ISO-8859-1")) {
133 return java.nio.charset.StandardCharsets.ISO_8859_1;
134 } else {
135 csn = canonicalize(toLower(charsetName));
136 }
137
138 // Check cache first
139 Charset cs = cache().get(csn);
140 if (cs != null)
141 return cs;
142
143 // Do we even support this charset?
144 String cln = classMap().get(csn);
145 if (cln == null)
146 return null;
147
148 // Instantiate the charset and cache it
149 try {
150 @SuppressWarnings("deprecation")
151 Object o = Class.forName(packagePrefix + cln,
152 true,
153 this.getClass().getClassLoader()).newInstance();
154 return cache(csn, (Charset)o);
155 } catch (ClassNotFoundException |
156 IllegalAccessException |
157 InstantiationException x) {
158 return null;
159 }
160 }
161
162 private Charset cache(String csn, Charset cs) {
163 cache().put(csn, cs);
164 return cs;
165 }
166
167 public final Charset charsetForName(String charsetName) {
168 synchronized (this) {
169 return lookup(charsetName);
170 }
171 }
172
173 public final Iterator<Charset> charsets() {
174 Set<String> charsetNames;
175 synchronized (this) {
176 init();
177 // Ensure initialized in synchronized block
178 charsetNames = classMap().keySet();
179 aliasMap();
180 cache();
181 }
182 return new Iterator<Charset>() {
183
184 Iterator<String> i = charsetNames.iterator();
185
186 public boolean hasNext() {
187 return i.hasNext();
188 }
189
190 public Charset next() {
191 String csn = i.next();
192 return lookup(csn);
193 }
194
195 public void remove() {
196 throw new UnsupportedOperationException();
197 }
198
199 };
200 }
201
202 private boolean initialized = false;
203
204 /* provider the sun.nio.cs.map property fir sjis/ms932 mapping hack
205 */
206 private void init() {
207 if (initialized)
208 return;
209 if (!jdk.internal.misc.VM.isBooted())
210 return;
211 initialized = true;
212
213 String map = GetPropertyAction.privilegedGetProperty("sun.nio.cs.map");
214 if (map != null) {
215 Map<String,String> aliasMap = aliasMap();
216 Map<String,String> classMap = classMap();
217 String[] maps = map.split(",");
218 for (int i = 0; i < maps.length; i++) {
219 if (maps[i].equalsIgnoreCase("Windows-31J/Shift_JIS")) {
220 // if we dont have both sjis and ms932, do nothing
221 if (classMap.get("shift_jis") == null ||
222 classMap.get("windows-31j") == null) {
223 break;
224 }
225 aliases_MS932 = new String[] {
226 "MS932", // JDK historical
227 "windows-932",
228 "csWindows31J",
229 "shift-jis",
230 "ms_kanji",
231 "x-sjis",
232 "csShiftJIS",
233 // This alias takes precedence over the actual
234 // Shift_JIS charset itself since aliases are always
235 // resolved first, before looking up canonical names.
236 "shift_jis"
237 };
238 aliases_SJIS = new String[] { "sjis" };
239
240 for (String alias : aliases_MS932) {
241 aliasMap.put(toLower(alias), "windows-31j");
242 }
243 cache().put("shift_jis", null);
244 break;
245 }
246 }
247 }
248 }
249
250 }