1 /* 2 * Copyright (c) 2005, 2009, 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 ******************************************************************************* 27 * (C) Copyright IBM Corp. and others, 1996-2009 - All Rights Reserved * 28 * * 29 * The original version of this source code and documentation is copyrighted * 30 * and owned by IBM, These materials are provided under terms of a License * 31 * Agreement between IBM and Sun. This technology is protected by multiple * 32 * US and International patents. This notice and attribution to IBM may not * 33 * to removed. * 34 ******************************************************************************* 35 */ 36 37 package sun.text.normalizer; 38 39 public final class Utility { 40 41 /** 42 * Convenience utility to compare two Object[]s 43 * Ought to be in System. 44 * @param len the length to compare. 45 * The start indices and start+len must be valid. 46 */ arrayRegionMatches(char[] source, int sourceStart, char[] target, int targetStart, int len)47 public final static boolean arrayRegionMatches(char[] source, int sourceStart, 48 char[] target, int targetStart, 49 int len) 50 { 51 int sourceEnd = sourceStart + len; 52 int delta = targetStart - sourceStart; 53 for (int i = sourceStart; i < sourceEnd; i++) { 54 if (source[i]!=target[i + delta]) 55 return false; 56 } 57 return true; 58 } 59 60 /** 61 * Convert characters outside the range U+0020 to U+007F to 62 * Unicode escapes, and convert backslash to a double backslash. 63 */ escape(String s)64 public static final String escape(String s) { 65 StringBuffer buf = new StringBuffer(); 66 for (int i=0; i<s.length(); ) { 67 int c = UTF16.charAt(s, i); 68 i += UTF16.getCharCount(c); 69 if (c >= ' ' && c <= 0x007F) { 70 if (c == '\\') { 71 buf.append("\\\\"); // That is, "\\" 72 } else { 73 buf.append((char)c); 74 } 75 } else { 76 boolean four = c <= 0xFFFF; 77 buf.append(four ? "\\u" : "\\U"); 78 hex(c, four ? 4 : 8, buf); 79 } 80 } 81 return buf.toString(); 82 } 83 84 /* This map must be in ASCENDING ORDER OF THE ESCAPE CODE */ 85 static private final char[] UNESCAPE_MAP = { 86 /*" 0x22, 0x22 */ 87 /*' 0x27, 0x27 */ 88 /*? 0x3F, 0x3F */ 89 /*\ 0x5C, 0x5C */ 90 /*a*/ 0x61, 0x07, 91 /*b*/ 0x62, 0x08, 92 /*e*/ 0x65, 0x1b, 93 /*f*/ 0x66, 0x0c, 94 /*n*/ 0x6E, 0x0a, 95 /*r*/ 0x72, 0x0d, 96 /*t*/ 0x74, 0x09, 97 /*v*/ 0x76, 0x0b 98 }; 99 100 /** 101 * Convert an escape to a 32-bit code point value. We attempt 102 * to parallel the icu4c unescapeAt() function. 103 * @param offset16 an array containing offset to the character 104 * <em>after</em> the backslash. Upon return offset16[0] will 105 * be updated to point after the escape sequence. 106 * @return character value from 0 to 10FFFF, or -1 on error. 107 */ unescapeAt(String s, int[] offset16)108 public static int unescapeAt(String s, int[] offset16) { 109 int c; 110 int result = 0; 111 int n = 0; 112 int minDig = 0; 113 int maxDig = 0; 114 int bitsPerDigit = 4; 115 int dig; 116 int i; 117 boolean braces = false; 118 119 /* Check that offset is in range */ 120 int offset = offset16[0]; 121 int length = s.length(); 122 if (offset < 0 || offset >= length) { 123 return -1; 124 } 125 126 /* Fetch first UChar after '\\' */ 127 c = UTF16.charAt(s, offset); 128 offset += UTF16.getCharCount(c); 129 130 /* Convert hexadecimal and octal escapes */ 131 switch (c) { 132 case 'u': 133 minDig = maxDig = 4; 134 break; 135 case 'U': 136 minDig = maxDig = 8; 137 break; 138 case 'x': 139 minDig = 1; 140 if (offset < length && UTF16.charAt(s, offset) == 0x7B /*{*/) { 141 ++offset; 142 braces = true; 143 maxDig = 8; 144 } else { 145 maxDig = 2; 146 } 147 break; 148 default: 149 dig = UCharacter.digit(c, 8); 150 if (dig >= 0) { 151 minDig = 1; 152 maxDig = 3; 153 n = 1; /* Already have first octal digit */ 154 bitsPerDigit = 3; 155 result = dig; 156 } 157 break; 158 } 159 if (minDig != 0) { 160 while (offset < length && n < maxDig) { 161 c = UTF16.charAt(s, offset); 162 dig = UCharacter.digit(c, (bitsPerDigit == 3) ? 8 : 16); 163 if (dig < 0) { 164 break; 165 } 166 result = (result << bitsPerDigit) | dig; 167 offset += UTF16.getCharCount(c); 168 ++n; 169 } 170 if (n < minDig) { 171 return -1; 172 } 173 if (braces) { 174 if (c != 0x7D /*}*/) { 175 return -1; 176 } 177 ++offset; 178 } 179 if (result < 0 || result >= 0x110000) { 180 return -1; 181 } 182 // If an escape sequence specifies a lead surrogate, see 183 // if there is a trail surrogate after it, either as an 184 // escape or as a literal. If so, join them up into a 185 // supplementary. 186 if (offset < length && 187 UTF16.isLeadSurrogate((char) result)) { 188 int ahead = offset+1; 189 c = s.charAt(offset); // [sic] get 16-bit code unit 190 if (c == '\\' && ahead < length) { 191 int o[] = new int[] { ahead }; 192 c = unescapeAt(s, o); 193 ahead = o[0]; 194 } 195 if (UTF16.isTrailSurrogate((char) c)) { 196 offset = ahead; 197 result = UCharacterProperty.getRawSupplementary( 198 (char) result, (char) c); 199 } 200 } 201 offset16[0] = offset; 202 return result; 203 } 204 205 /* Convert C-style escapes in table */ 206 for (i=0; i<UNESCAPE_MAP.length; i+=2) { 207 if (c == UNESCAPE_MAP[i]) { 208 offset16[0] = offset; 209 return UNESCAPE_MAP[i+1]; 210 } else if (c < UNESCAPE_MAP[i]) { 211 break; 212 } 213 } 214 215 /* Map \cX to control-X: X & 0x1F */ 216 if (c == 'c' && offset < length) { 217 c = UTF16.charAt(s, offset); 218 offset16[0] = offset + UTF16.getCharCount(c); 219 return 0x1F & c; 220 } 221 222 /* If no special forms are recognized, then consider 223 * the backslash to generically escape the next character. */ 224 offset16[0] = offset; 225 return c; 226 } 227 228 /** 229 * Convert a integer to size width hex uppercase digits. 230 * E.g., hex('a', 4, str) => "0041". 231 * Append the output to the given StringBuffer. 232 * If width is too small to fit, nothing will be appended to output. 233 */ hex(int ch, int width, StringBuffer output)234 public static StringBuffer hex(int ch, int width, StringBuffer output) { 235 return appendNumber(output, ch, 16, width); 236 } 237 238 /** 239 * Convert a integer to size width (minimum) hex uppercase digits. 240 * E.g., hex('a', 4, str) => "0041". If the integer requires more 241 * than width digits, more will be used. 242 */ hex(int ch, int width)243 public static String hex(int ch, int width) { 244 StringBuffer buf = new StringBuffer(); 245 return appendNumber(buf, ch, 16, width).toString(); 246 } 247 248 /** 249 * Skip over a sequence of zero or more white space characters 250 * at pos. Return the index of the first non-white-space character 251 * at or after pos, or str.length(), if there is none. 252 */ skipWhitespace(String str, int pos)253 public static int skipWhitespace(String str, int pos) { 254 while (pos < str.length()) { 255 int c = UTF16.charAt(str, pos); 256 if (!UCharacterProperty.isRuleWhiteSpace(c)) { 257 break; 258 } 259 pos += UTF16.getCharCount(c); 260 } 261 return pos; 262 } 263 264 static final char DIGITS[] = { 265 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 266 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 267 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 268 'U', 'V', 'W', 'X', 'Y', 'Z' 269 }; 270 271 /** 272 * Append the digits of a positive integer to the given 273 * <code>StringBuffer</code> in the given radix. This is 274 * done recursively since it is easiest to generate the low- 275 * order digit first, but it must be appended last. 276 * 277 * @param result is the <code>StringBuffer</code> to append to 278 * @param n is the positive integer 279 * @param radix is the radix, from 2 to 36 inclusive 280 * @param minDigits is the minimum number of digits to append. 281 */ recursiveAppendNumber(StringBuffer result, int n, int radix, int minDigits)282 private static void recursiveAppendNumber(StringBuffer result, int n, 283 int radix, int minDigits) 284 { 285 int digit = n % radix; 286 287 if (n >= radix || minDigits > 1) { 288 recursiveAppendNumber(result, n / radix, radix, minDigits - 1); 289 } 290 291 result.append(DIGITS[digit]); 292 } 293 294 /** 295 * Append a number to the given StringBuffer in the given radix. 296 * Standard digits '0'-'9' are used and letters 'A'-'Z' for 297 * radices 11 through 36. 298 * @param result the digits of the number are appended here 299 * @param n the number to be converted to digits; may be negative. 300 * If negative, a '-' is prepended to the digits. 301 * @param radix a radix from 2 to 36 inclusive. 302 * @param minDigits the minimum number of digits, not including 303 * any '-', to produce. Values less than 2 have no effect. One 304 * digit is always emitted regardless of this parameter. 305 * @return a reference to result 306 */ appendNumber(StringBuffer result, int n, int radix, int minDigits)307 public static StringBuffer appendNumber(StringBuffer result, int n, 308 int radix, int minDigits) 309 throws IllegalArgumentException 310 { 311 if (radix < 2 || radix > 36) { 312 throw new IllegalArgumentException("Illegal radix " + radix); 313 } 314 315 316 int abs = n; 317 318 if (n < 0) { 319 abs = -n; 320 result.append("-"); 321 } 322 323 recursiveAppendNumber(result, abs, radix, minDigits); 324 325 return result; 326 } 327 328 /** 329 * Return true if the character is NOT printable ASCII. The tab, 330 * newline and linefeed characters are considered unprintable. 331 */ isUnprintable(int c)332 public static boolean isUnprintable(int c) { 333 return !(c >= 0x20 && c <= 0x7E); 334 } 335 336 /** 337 * Escape unprintable characters using <backslash>uxxxx notation 338 * for U+0000 to U+FFFF and <backslash>Uxxxxxxxx for U+10000 and 339 * above. If the character is printable ASCII, then do nothing 340 * and return FALSE. Otherwise, append the escaped notation and 341 * return TRUE. 342 */ escapeUnprintable(StringBuffer result, int c)343 public static boolean escapeUnprintable(StringBuffer result, int c) { 344 if (isUnprintable(c)) { 345 result.append('\\'); 346 if ((c & ~0xFFFF) != 0) { 347 result.append('U'); 348 result.append(DIGITS[0xF&(c>>28)]); 349 result.append(DIGITS[0xF&(c>>24)]); 350 result.append(DIGITS[0xF&(c>>20)]); 351 result.append(DIGITS[0xF&(c>>16)]); 352 } else { 353 result.append('u'); 354 } 355 result.append(DIGITS[0xF&(c>>12)]); 356 result.append(DIGITS[0xF&(c>>8)]); 357 result.append(DIGITS[0xF&(c>>4)]); 358 result.append(DIGITS[0xF&c]); 359 return true; 360 } 361 return false; 362 } 363 364 /** 365 * Similar to StringBuffer.getChars, version 1.3. 366 * Since JDK 1.2 implements StringBuffer.getChars differently, this method 367 * is here to provide consistent results. 368 * To be removed after JDK 1.2 ceased to be the reference platform. 369 * @param src source string buffer 370 * @param srcBegin offset to the start of the src to retrieve from 371 * @param srcEnd offset to the end of the src to retrieve from 372 * @param dst char array to store the retrieved chars 373 * @param dstBegin offset to the start of the destination char array to 374 * store the retrieved chars 375 */ getChars(StringBuffer src, int srcBegin, int srcEnd, char dst[], int dstBegin)376 public static void getChars(StringBuffer src, int srcBegin, int srcEnd, 377 char dst[], int dstBegin) 378 { 379 if (srcBegin == srcEnd) { 380 return; 381 } 382 src.getChars(srcBegin, srcEnd, dst, dstBegin); 383 } 384 385 } 386