View Javadoc
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       */
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       */
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      */
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      */
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      */
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      */
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      */
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      */
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      */
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      */
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     */
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 }