1/*
2 * Copyright (c) 2002, 2013, 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
26package build.tools.generatecharacter;
27
28import java.io.*;
29import java.util.*;
30import java.lang.*;
31
32/**
33 * SpecialCaseMap has the responsibility of storing the
34 * 1:M, locale-sensitive, and context sensitive case mappings
35 * that occur when uppercasing Unicode 4.0 characters. This class can
36 * read and parse the SpecialCasing.txt file that contains those mappings.
37 * <p>
38 * A single SpecialCaseMap contains the mapping for one character.
39 * <p>
40 * @author John O'Conner
41 */
42public class SpecialCaseMap implements Comparable<SpecialCaseMap> {
43
44    SpecialCaseMap() {
45        chSource = 0xFFFF;
46    }
47
48
49    /**
50     * Read and parse a Unicode special case map file.
51     *
52     * @param file   a file specifying the Unicode special case mappings
53     * @return  an array of SpecialCaseMap objects, one for each line of the
54     *          special case map data file that could be successfully parsed
55     */
56
57    public static SpecialCaseMap[] readSpecFile(File file, int plane) throws FileNotFoundException {
58        ArrayList<SpecialCaseMap> caseMaps = new ArrayList<>(150);
59        int count = 0;
60        BufferedReader f = new BufferedReader(new FileReader(file));
61                String line = null;
62        loop:
63        while(true) {
64            try {
65                line = f.readLine();
66            }
67            catch (IOException e) { break loop; }
68                if (line == null) break loop;
69                SpecialCaseMap item = parse(line.trim());
70                if (item != null) {
71                                if(item.getCharSource() >> 16 < plane) continue;
72                                if(item.getCharSource() >> 16 > plane) break;
73                                caseMaps.add(item);
74                ++count;
75            }
76
77        }
78        caseMaps.trimToSize();
79        SpecialCaseMap[] result = new SpecialCaseMap[caseMaps.size()];
80        caseMaps.toArray(result);
81        Arrays.sort(result);
82        return result;
83
84    }
85
86   /**
87    * Given one line of a Unicode special casing data file as a String, parse the line
88    * and return a SpecialCaseMap object that contains the case mapping.
89    *
90    * @param s a line of the Unicode special case map data file to be parsed
91    * @return a SpecialCaseMap object, or null if the parsing process failed for some reason
92    */
93    public static SpecialCaseMap parse(String s) {
94        SpecialCaseMap spec = null;
95        String[] tokens = new String[REQUIRED_FIELDS];
96        if ( s != null && s.length() != 0 && s.charAt(0) != '#') {
97            try {
98                int x = 0, tokenStart = 0, tokenEnd = 0;
99                for (x=0; x<REQUIRED_FIELDS-1; x++) {
100                    tokenEnd = s.indexOf(';', tokenStart);
101                    tokens[x] = s.substring(tokenStart, tokenEnd);
102                    tokenStart = tokenEnd+1;
103                }
104                tokens[x] = s.substring(tokenStart);
105
106                if(tokens[FIELD_CONDITIONS].indexOf(';') == -1) {
107                    spec = new SpecialCaseMap();
108                    spec.setCharSource(parseChar(tokens[FIELD_SOURCE]));
109                    spec.setUpperCaseMap(parseCaseMap(tokens[FIELD_UPPERCASE]));
110                    spec.setLowerCaseMap(parseCaseMap(tokens[FIELD_LOWERCASE]));
111                    spec.setTitleCaseMap(parseCaseMap(tokens[FIELD_TITLECASE]));
112                    spec.setLocale(parseLocale(tokens[FIELD_CONDITIONS]));
113                    spec.setContext(parseContext(tokens[FIELD_CONDITIONS]));
114                }
115            }
116            catch(Exception e) {
117                spec = null;
118                System.out.println("Error parsing spec line.");
119            }
120        }
121        return spec;
122    }
123
124    static int parseChar(String token) throws NumberFormatException {
125        return Integer.parseInt(token, 16);
126    }
127
128    static char[] parseCaseMap(String token ) throws NumberFormatException {
129        int pos = 0;
130        StringBuffer buff = new StringBuffer();
131        int start = 0, end = 0;
132        while(pos < token.length() ){
133            while(Character.isSpaceChar(token.charAt(pos++)));
134            --pos;
135            start = pos;
136            while(pos < token.length() && !Character.isSpaceChar(token.charAt(pos))) pos++;
137            end = pos;
138            int ch = parseChar(token.substring(start,end));
139                        if (ch > 0xFFFF) {
140                                buff.append(getHighSurrogate(ch));
141                                buff.append(getLowSurrogate(ch));
142                        } else {
143                                buff.append((char)ch);
144                        }
145        }
146        char[] map = new char[buff.length()];
147        buff.getChars(0, buff.length(), map, 0);
148        return map;
149    }
150
151    static Locale parseLocale(String token) {
152        return null;
153    }
154
155    static String[] parseContext(String token) {
156        return null;
157    }
158
159    static  int find(int ch, SpecialCaseMap[] map) {
160        if ((map == null) || (map.length == 0)) {
161            return -1;
162        }
163        int top, bottom, current;
164        bottom = 0;
165        top = map.length;
166        current = top/2;
167        // invariant: top > current >= bottom && ch >= map.chSource
168        while (top - bottom > 1) {
169            if (ch >= map[current].getCharSource()) {
170                bottom = current;
171            } else {
172                top = current;
173            }
174            current = (top + bottom) / 2;
175        }
176        if (ch == map[current].getCharSource()) return current;
177        else return -1;
178    }
179
180    /*
181     * Extracts and returns the high surrogate value from a UTF-32 code point.
182     * If argument is a BMP character, then it is converted to a char and returned;
183     * otherwise the high surrogate value is extracted.
184     * @param codePoint a UTF-32 codePoint with value greater than 0xFFFF.
185     * @return the high surrogate value that helps create <code>codePoint</code>; else
186     *         the char representation of <code>codePoint</code> if it is a BMP character.
187     * @since 1.5
188     */
189    static char getHighSurrogate(int codePoint) {
190        char high = (char)codePoint;
191        if (codePoint > 0xFFFF) {
192            high = (char)((codePoint - 0x10000)/0x0400 + 0xD800);
193        }
194        return high;
195    }
196
197
198    /*
199     * Extracts and returns the low surrogate value from a UTF-32 code point.
200     * If argument is a BMP character, then it is converted to a char and returned;
201     * otherwise the high surrogate value is extracted.
202     * @param codePoint a UTF-32 codePoint with value greater than 0xFFFF.
203     * @return the low surrogate value that helps create <code>codePoint</code>; else
204     *         the char representation of <code>codePoint</code> if it is a BMP character.
205     * @since 1.5
206     */
207    static char getLowSurrogate(int codePoint) {
208        char low = (char)codePoint;
209        if(codePoint > 0xFFFF) {
210                low = (char)((codePoint - 0x10000)%0x0400 + 0xDC00);
211        }
212        return low;
213    }
214
215    static String hex6(int n) {
216        String str = Integer.toHexString(n & 0xFFFFFF).toUpperCase();
217        return "000000".substring(Math.min(6, str.length())) + str;
218    }
219
220    static String hex6(char[] map){
221        StringBuffer buff = new StringBuffer();
222        int x=0;
223        buff.append(hex6(map[x++]));
224        while(x<map.length) {
225            buff.append(" " + hex6(map[x++]));
226        }
227        return buff.toString();
228    }
229
230    void setCharSource(int ch) {
231        chSource = ch;
232    }
233
234    void setLowerCaseMap(char[] map) {
235        lowerCaseMap = map;
236    }
237
238    void setUpperCaseMap(char[] map) {
239        upperCaseMap = map;
240    }
241
242    void setTitleCaseMap(char[] map) {
243        titleCaseMap = map;
244    }
245
246    void setLocale(Locale locale) {
247        this.locale = locale;
248    }
249
250    void setContext(String[] context) {
251        this.context = context;
252    }
253
254    public int getCharSource() {
255        return chSource;
256    }
257
258    public char[] getLowerCaseMap() {
259        return lowerCaseMap;
260    }
261
262    public char[] getUpperCaseMap() {
263        return upperCaseMap;
264    }
265
266    public char[] getTitleCaseMap() {
267        return titleCaseMap;
268    }
269
270    public Locale getLocale() {
271        return locale;
272    }
273
274    public String[] getContext() {
275        return context;
276    }
277
278
279    int chSource;
280    Locale locale;
281    char[] lowerCaseMap;
282    char[] upperCaseMap;
283    char[] titleCaseMap;
284    String[] context;
285
286    /**
287     * Fields that can be found in the SpecialCasing.txt file.
288     */
289    static int REQUIRED_FIELDS = 5;
290    static int FIELD_SOURCE = 0;
291    static int FIELD_LOWERCASE = 1;
292    static int FIELD_TITLECASE = 2;
293    static int FIELD_UPPERCASE = 3;
294    static int FIELD_CONDITIONS = 4;
295
296    /**
297     * Context values
298     */
299    static String CONTEXT_FINAL = "FINAL";
300    static String CONTEXT_NONFINAL = "NON_FINAL";
301    static String CONTEXT_MODERN = "MODERN";
302    static String CONTEXT_NONMODERN = "NON_MODERN";
303
304    public int compareTo(SpecialCaseMap otherObject) {
305        if (chSource < otherObject.chSource) {
306            return -1;
307        }
308        else if (chSource > otherObject.chSource) {
309            return 1;
310        }
311        else return 0;
312    }
313
314    public boolean equals(Object o1) {
315        if (this == o1) {
316            return true;
317        }
318        if (o1 == null || !(o1 instanceof SpecialCaseMap)) {
319            return false;
320        }
321        SpecialCaseMap other = (SpecialCaseMap)o1;
322        boolean bEqual = false;
323        if (0 == compareTo(other)) {
324            bEqual = true;
325        }
326        return bEqual;
327    }
328
329    public String toString() {
330        StringBuffer buff = new StringBuffer();
331        buff.append(hex6(getCharSource()));
332        buff.append("|" + hex6(lowerCaseMap));
333        buff.append("|" + hex6(upperCaseMap));
334        buff.append("|" + hex6(titleCaseMap));
335        buff.append("|" + context);
336        return buff.toString();
337    }
338
339    public int hashCode() {
340        return chSource;
341    }
342
343    public static void main(String[] args) {
344        SpecialCaseMap[] spec = null;
345        if (args.length == 2 ) {
346            try {
347                File file = new File(args[0]);
348                int plane = Integer.parseInt(args[1]);
349                spec = SpecialCaseMap.readSpecFile(file, plane);
350                System.out.println("SpecialCaseMap[" + spec.length + "]:");
351                for (int x=0; x<spec.length; x++) {
352                    System.out.println(spec[x].toString());
353                }
354            }
355            catch(Exception e) {
356                e.printStackTrace();
357            }
358        }
359
360    }
361
362}
363