1 /*
   2  * Copyright (c) 2003, 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 
  26 package sun.font;
  27 
  28 import java.nio.ByteBuffer;
  29 import java.nio.CharBuffer;
  30 import java.nio.IntBuffer;
  31 import java.util.Locale;
  32 import java.nio.charset.*;
  33 
  34 /*
  35  * A tt font has a CMAP table which is in turn made up of sub-tables which
  36  * describe the char to glyph mapping in (possibly) multiple ways.
  37  * CMAP subtables are described by 3 values.
  38  * 1. Platform ID (eg 3=Microsoft, which is the id we look for in JDK)
  39  * 2. Encoding (eg 0=symbol, 1=unicode)
  40  * 3. TrueType subtable format (how the char->glyph mapping for the encoding
  41  * is stored in the subtable). See the TrueType spec. Format 4 is required
  42  * by MS in fonts for windows. Its uses segmented mapping to delta values.
  43  * Most typically we see are (3,1,4) :
  44  * CMAP Platform ID=3 is what we use.
  45  * Encodings that are used in practice by JDK on Solaris are
  46  *  symbol (3,0)
  47  *  unicode (3,1)
  48  *  GBK (3,5) (note that solaris zh fonts report 3,4 but are really 3,5)
  49  * The format for almost all subtables is 4. However the solaris (3,5)
  50  * encodings are typically in format 2.
  51  */
  52 abstract class CMap {
  53 
  54 //     static char WingDings_b2c[] = {
  55 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  56 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  57 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  58 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  59 //         0xfffd, 0xfffd, 0x2702, 0x2701, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  60 //         0xfffd, 0x2706, 0x2709, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  61 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  62 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0x2707, 0x270d,
  63 //         0xfffd, 0x270c, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  64 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  65 //         0xfffd, 0x2708, 0xfffd, 0xfffd, 0x2744, 0xfffd, 0x271e, 0xfffd,
  66 //         0x2720, 0x2721, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  67 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  68 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  69 //         0xfffd, 0x2751, 0x2752, 0xfffd, 0xfffd, 0x2756, 0xfffd, 0xfffd,
  70 //         0xfffd, 0xfffd, 0xfffd, 0x2740, 0x273f, 0x275d, 0x275e, 0xfffd,
  71 //         0xfffd, 0x2780, 0x2781, 0x2782, 0x2783, 0x2784, 0x2785, 0x2786,
  72 //         0x2787, 0x2788, 0x2789, 0xfffd, 0x278a, 0x278b, 0x278c, 0x278d,
  73 //         0x278e, 0x278f, 0x2790, 0x2791, 0x2792, 0x2793, 0xfffd, 0xfffd,
  74 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  75 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0x274d, 0xfffd,
  76 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0x2736, 0x2734, 0xfffd, 0x2735,
  77 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0x272a, 0x2730, 0xfffd,
  78 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  79 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0x27a5, 0xfffd, 0x27a6, 0xfffd,
  80 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  81 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  82 //         0x27a2, 0xfffd, 0xfffd, 0xfffd, 0x27b3, 0xfffd, 0xfffd, 0xfffd,
  83 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  84 //         0x27a1, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  85 //         0x27a9, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  86 //         0xfffd, 0xfffd, 0xfffd, 0x2717, 0x2713, 0xfffd, 0xfffd, 0xfffd,
  87 //    };
  88 
  89 //     static char Symbols_b2c[] = {
  90 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  91 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  92 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  93 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  94 //         0xfffd, 0xfffd, 0x2200, 0xfffd, 0x2203, 0xfffd, 0xfffd, 0x220d,
  95 //         0xfffd, 0xfffd, 0x2217, 0xfffd, 0xfffd, 0x2212, 0xfffd, 0xfffd,
  96 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  97 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
  98 //         0x2245, 0x0391, 0x0392, 0x03a7, 0x0394, 0x0395, 0x03a6, 0x0393,
  99 //         0x0397, 0x0399, 0x03d1, 0x039a, 0x039b, 0x039c, 0x039d, 0x039f,
 100 //         0x03a0, 0x0398, 0x03a1, 0x03a3, 0x03a4, 0x03a5, 0x03c2, 0x03a9,
 101 //         0x039e, 0x03a8, 0x0396, 0xfffd, 0x2234, 0xfffd, 0x22a5, 0xfffd,
 102 //         0xfffd, 0x03b1, 0x03b2, 0x03c7, 0x03b4, 0x03b5, 0x03c6, 0x03b3,
 103 //         0x03b7, 0x03b9, 0x03d5, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03bf,
 104 //         0x03c0, 0x03b8, 0x03c1, 0x03c3, 0x03c4, 0x03c5, 0x03d6, 0x03c9,
 105 //         0x03be, 0x03c8, 0x03b6, 0xfffd, 0xfffd, 0xfffd, 0x223c, 0xfffd,
 106 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
 107 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
 108 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
 109 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
 110 //         0xfffd, 0x03d2, 0xfffd, 0x2264, 0x2215, 0x221e, 0xfffd, 0xfffd,
 111 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
 112 //         0x2218, 0xfffd, 0xfffd, 0x2265, 0xfffd, 0x221d, 0xfffd, 0x2219,
 113 //         0xfffd, 0x2260, 0x2261, 0x2248, 0x22ef, 0x2223, 0xfffd, 0xfffd,
 114 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0x2297, 0x2295, 0x2205, 0x2229,
 115 //         0x222a, 0x2283, 0x2287, 0x2284, 0x2282, 0x2286, 0x2208, 0x2209,
 116 //         0xfffd, 0x2207, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0x221a, 0x22c5,
 117 //         0xfffd, 0x2227, 0x2228, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
 118 //         0x22c4, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0x2211, 0xfffd, 0xfffd,
 119 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
 120 //         0xfffd, 0xfffd, 0x222b, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
 121 //         0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd, 0xfffd,
 122 //     };
 123 
 124     static final short ShiftJISEncoding = 2;
 125     static final short GBKEncoding      = 3;
 126     static final short Big5Encoding     = 4;
 127     static final short WansungEncoding  = 5;
 128     static final short JohabEncoding    = 6;
 129     static final short MSUnicodeSurrogateEncoding = 10;
 130 
 131     static final char noSuchChar = (char)0xfffd;
 132     static final int SHORTMASK = 0x0000ffff;
 133     static final int INTMASK   = 0xffffffff;
 134 
 135     static final char[][] converterMaps = new char[7][];
 136 
 137     /*
 138      * Unicode->other encoding translation array. A pre-computed look up
 139      * which can be shared across all fonts using that encoding.
 140      * Using this saves running character coverters repeatedly.
 141      */
 142     char[] xlat;
 143     UVS uvs = null;
 144 
 145     static CMap initialize(TrueTypeFont font) {
 146 
 147         CMap cmap = null;
 148 
 149         int offset, platformID, encodingID=-1;
 150 
 151         int three0=0, three1=0, three2=0, three3=0, three4=0, three5=0,
 152             three6=0, three10=0;
 153         int zero5 = 0; // for Unicode Variation Sequences
 154         boolean threeStar = false;
 155 
 156         ByteBuffer cmapBuffer = font.getTableBuffer(TrueTypeFont.cmapTag);
 157         int cmapTableOffset = font.getTableSize(TrueTypeFont.cmapTag);
 158         short numberSubTables = cmapBuffer.getShort(2);
 159 
 160         /* locate the offsets of all 3,*  (ie Microsoft platform) encodings */
 161         for (int i=0; i<numberSubTables; i++) {
 162             cmapBuffer.position(i * 8 + 4);
 163             platformID = cmapBuffer.getShort();
 164             if (platformID == 3) {
 165                 threeStar = true;
 166                 encodingID = cmapBuffer.getShort();
 167                 offset     = cmapBuffer.getInt();
 168                 switch (encodingID) {
 169                 case 0:  three0  = offset; break; // MS Symbol encoding
 170                 case 1:  three1  = offset; break; // MS Unicode cmap
 171                 case 2:  three2  = offset; break; // ShiftJIS cmap.
 172                 case 3:  three3  = offset; break; // GBK cmap
 173                 case 4:  three4  = offset; break; // Big 5 cmap
 174                 case 5:  three5  = offset; break; // Wansung
 175                 case 6:  three6  = offset; break; // Johab
 176                 case 10: three10 = offset; break; // MS Unicode surrogates
 177                 }
 178             } else if (platformID == 0) {
 179                 encodingID = cmapBuffer.getShort();
 180                 offset     = cmapBuffer.getInt();
 181                 if (encodingID == 5) {
 182                     zero5 = offset;
 183                 } 
 184             }
 185         }
 186 
 187         /* This defines the preference order for cmap subtables */
 188         if (threeStar) {
 189             if (three10 != 0) {
 190                 cmap = createCMap(cmapBuffer, three10, null);
 191             }
 192             else if  (three0 != 0) {
 193                 /* The special case treatment of these fonts leads to
 194                  * anomalies where a user can view "wingdings" and "wingdings2"
 195                  * and the latter shows all its code points in the unicode
 196                  * private use area at 0xF000->0XF0FF and the former shows
 197                  * a scattered subset of its glyphs that are known mappings to
 198                  * unicode code points.
 199                  * The primary purpose of these mappings was to facilitate
 200                  * display of symbol chars etc in composite fonts, however
 201                  * this is not needed as all these code points are covered
 202                  * by Lucida Sans Regular.
 203                  * Commenting this out reduces the role of these two files
 204                  * (assuming that they continue to be used in font.properties)
 205                  * to just one of contributing to the overall composite
 206                  * font metrics, and also AWT can still access the fonts.
 207                  * Clients which explicitly accessed these fonts as names
 208                  * "Symbol" and "Wingdings" (ie as physical fonts) and
 209                  * expected to see a scattering of these characters will
 210                  * see them now as missing. How much of a problem is this?
 211                  * Perhaps we could still support this mapping just for
 212                  * "Symbol.ttf" but I suspect some users would prefer it
 213                  * to be mapped in to the Latin range as that is how
 214                  * the "symbol" font is used in native apps.
 215                  */
 216 //              String name = font.platName.toLowerCase(Locale.ENGLISH);
 217 //              if (name.endsWith("symbol.ttf")) {
 218 //                  cmap = createSymbolCMap(cmapBuffer, three0, Symbols_b2c);
 219 //              } else if (name.endsWith("wingding.ttf")) {
 220 //                  cmap = createSymbolCMap(cmapBuffer, three0, WingDings_b2c);
 221 //              } else {
 222                     cmap = createCMap(cmapBuffer, three0, null);
 223 //              }
 224             }
 225             else if (three1 != 0) {
 226                 cmap = createCMap(cmapBuffer, three1, null);
 227             }
 228             else if (three2 != 0) {
 229                 cmap = createCMap(cmapBuffer, three2,
 230                                   getConverterMap(ShiftJISEncoding));
 231             }
 232             else if (three3 != 0) {
 233                 cmap = createCMap(cmapBuffer, three3,
 234                                   getConverterMap(GBKEncoding));
 235             }
 236             else if (three4 != 0) {
 237                 /* GB2312 TrueType fonts on Solaris have wrong encoding ID for
 238                  * cmap table, these fonts have EncodingID 4 which is Big5
 239                  * encoding according the TrueType spec, but actually the
 240                  * fonts are using gb2312 encoding, have to use this
 241                  * workaround to make Solaris zh_CN locale work.  -sherman
 242                  */
 243                 if (FontUtilities.isSolaris && font.platName != null &&
 244                     (font.platName.startsWith(
 245                      "/usr/openwin/lib/locale/zh_CN.EUC/X11/fonts/TrueType") ||
 246                      font.platName.startsWith(
 247                      "/usr/openwin/lib/locale/zh_CN/X11/fonts/TrueType") ||
 248                      font.platName.startsWith(
 249                      "/usr/openwin/lib/locale/zh/X11/fonts/TrueType"))) {
 250                     cmap = createCMap(cmapBuffer, three4,
 251                                        getConverterMap(GBKEncoding));
 252                 }
 253                 else {
 254                     cmap = createCMap(cmapBuffer, three4,
 255                                       getConverterMap(Big5Encoding));
 256                 }
 257             }
 258             else if (three5 != 0) {
 259                 cmap = createCMap(cmapBuffer, three5,
 260                                   getConverterMap(WansungEncoding));
 261             }
 262             else if (three6 != 0) {
 263                 cmap = createCMap(cmapBuffer, three6,
 264                                   getConverterMap(JohabEncoding));
 265             }
 266         } else {
 267             /* No 3,* subtable was found. Just use whatever is the first
 268              * table listed. Not very useful but maybe better than
 269              * rejecting the font entirely?
 270              */
 271             cmap = createCMap(cmapBuffer, cmapBuffer.getInt(8), null);
 272         }
 273         // For Unicode Variation Sequences
 274         if (cmap != null && zero5 != 0) {
 275             cmap.createUVS(cmapBuffer, zero5);
 276         }
 277         return cmap;
 278     }
 279 
 280     /* speed up the converting by setting the range for double
 281      * byte characters;
 282      */
 283     static char[] getConverter(short encodingID) {
 284         int dBegin = 0x8000;
 285         int dEnd   = 0xffff;
 286         String encoding;
 287 
 288         switch (encodingID) {
 289         case ShiftJISEncoding:
 290             dBegin = 0x8140;
 291             dEnd   = 0xfcfc;
 292             encoding = "SJIS";
 293             break;
 294         case GBKEncoding:
 295             dBegin = 0x8140;
 296             dEnd   = 0xfea0;
 297             encoding = "GBK";
 298             break;
 299         case Big5Encoding:
 300             dBegin = 0xa140;
 301             dEnd   = 0xfefe;
 302             encoding = "Big5";
 303             break;
 304         case WansungEncoding:
 305             dBegin = 0xa1a1;
 306             dEnd   = 0xfede;
 307             encoding = "EUC_KR";
 308             break;
 309         case JohabEncoding:
 310             dBegin = 0x8141;
 311             dEnd   = 0xfdfe;
 312             encoding = "Johab";
 313             break;
 314         default:
 315             return null;
 316         }
 317 
 318         try {
 319             char[] convertedChars = new char[65536];
 320             for (int i=0; i<65536; i++) {
 321                 convertedChars[i] = noSuchChar;
 322             }
 323 
 324             byte[] inputBytes = new byte[(dEnd-dBegin+1)*2];
 325             char[] outputChars = new char[(dEnd-dBegin+1)];
 326 
 327             int j = 0;
 328             int firstByte;
 329             if (encodingID == ShiftJISEncoding) {
 330                 for (int i = dBegin; i <= dEnd; i++) {
 331                     firstByte = (i >> 8 & 0xff);
 332                     if (firstByte >= 0xa1 && firstByte <= 0xdf) {
 333                         //sjis halfwidth katakana
 334                         inputBytes[j++] = (byte)0xff;
 335                         inputBytes[j++] = (byte)0xff;
 336                     } else {
 337                         inputBytes[j++] = (byte)firstByte;
 338                         inputBytes[j++] = (byte)(i & 0xff);
 339                     }
 340                 }
 341             } else {
 342                 for (int i = dBegin; i <= dEnd; i++) {
 343                     inputBytes[j++] = (byte)(i>>8 & 0xff);
 344                     inputBytes[j++] = (byte)(i & 0xff);
 345                 }
 346             }
 347 
 348             Charset.forName(encoding).newDecoder()
 349             .onMalformedInput(CodingErrorAction.REPLACE)
 350             .onUnmappableCharacter(CodingErrorAction.REPLACE)
 351             .replaceWith("\u0000")
 352             .decode(ByteBuffer.wrap(inputBytes, 0, inputBytes.length),
 353                     CharBuffer.wrap(outputChars, 0, outputChars.length),
 354                     true);
 355 
 356             // ensure single byte ascii
 357             for (int i = 0x20; i <= 0x7e; i++) {
 358                 convertedChars[i] = (char)i;
 359             }
 360 
 361             //sjis halfwidth katakana
 362             if (encodingID == ShiftJISEncoding) {
 363                 for (int i = 0xa1; i <= 0xdf; i++) {
 364                     convertedChars[i] = (char)(i - 0xa1 + 0xff61);
 365                 }
 366             }
 367 
 368             /* It would save heap space (approx 60Kbytes for each of these
 369              * converters) if stored only valid ranges (ie returned
 370              * outputChars directly. But this is tricky since want to
 371              * include the ASCII range too.
 372              */
 373 //          System.err.println("oc.len="+outputChars.length);
 374 //          System.err.println("cc.len="+convertedChars.length);
 375 //          System.err.println("dbegin="+dBegin);
 376             System.arraycopy(outputChars, 0, convertedChars, dBegin,
 377                              outputChars.length);
 378 
 379             //return convertedChars;
 380             /* invert this map as now want it to map from Unicode
 381              * to other encoding.
 382              */
 383             char [] invertedChars = new char[65536];
 384             for (int i=0;i<65536;i++) {
 385                 if (convertedChars[i] != noSuchChar) {
 386                     invertedChars[convertedChars[i]] = (char)i;
 387                 }
 388             }
 389             return invertedChars;
 390 
 391         } catch (Exception e) {
 392             e.printStackTrace();
 393         }
 394         return null;
 395     }
 396 
 397     /*
 398      * The returned array maps to unicode from some other 2 byte encoding
 399      * eg for a 2byte index which represents a SJIS char, the indexed
 400      * value is the corresponding unicode char.
 401      */
 402     static char[] getConverterMap(short encodingID) {
 403         if (converterMaps[encodingID] == null) {
 404            converterMaps[encodingID] = getConverter(encodingID);
 405         }
 406         return converterMaps[encodingID];
 407     }
 408 
 409 
 410     static CMap createCMap(ByteBuffer buffer, int offset, char[] xlat) {
 411         /* First do a sanity check that this cmap subtable is contained
 412          * within the cmap table.
 413          */
 414         int subtableFormat = buffer.getChar(offset);
 415         long subtableLength;
 416         if (subtableFormat < 8) {
 417             subtableLength = buffer.getChar(offset+2);
 418         } else {
 419             subtableLength = buffer.getInt(offset+4) & INTMASK;
 420         }
 421         if (offset+subtableLength > buffer.capacity()) {
 422             if (FontUtilities.isLogging()) {
 423                 FontUtilities.getLogger().warning("Cmap subtable overflows buffer.");
 424             }
 425         }
 426         switch (subtableFormat) {
 427         case 0:  return new CMapFormat0(buffer, offset);
 428         case 2:  return new CMapFormat2(buffer, offset, xlat);
 429         case 4:  return new CMapFormat4(buffer, offset, xlat);
 430         case 6:  return new CMapFormat6(buffer, offset, xlat);
 431         case 8:  return new CMapFormat8(buffer, offset, xlat);
 432         case 10: return new CMapFormat10(buffer, offset, xlat);
 433         case 12: return new CMapFormat12(buffer, offset, xlat);
 434         default: throw new RuntimeException("Cmap format unimplemented: " +
 435                                             (int)buffer.getChar(offset));
 436         }
 437     }
 438 
 439     private void createUVS(ByteBuffer buffer, int offset) {
 440         int subtableFormat = buffer.getChar(offset);
 441         if (subtableFormat == 14) {
 442             long subtableLength = buffer.getInt(offset + 2) & INTMASK;
 443             if (offset + subtableLength > buffer.capacity()) {
 444                 if (FontUtilities.isLogging()) {
 445                     FontUtilities.getLogger()
 446                             .warning("Cmap UVS subtable overflows buffer.");
 447                 }
 448             }
 449             try {
 450                 this.uvs = new UVS(buffer, offset);
 451             } catch (Throwable t) {
 452                 t.printStackTrace();
 453             }
 454         }
 455         return;
 456     }
 457 
 458 /*
 459     final char charVal(byte[] cmap, int index) {
 460         return (char)(((0xff & cmap[index]) << 8)+(0xff & cmap[index+1]));
 461     }
 462 
 463     final short shortVal(byte[] cmap, int index) {
 464         return (short)(((0xff & cmap[index]) << 8)+(0xff & cmap[index+1]));
 465     }
 466 */
 467     abstract char getGlyph(int charCode);
 468 
 469     /* Format 4 Header is
 470      * ushort format (off=0)
 471      * ushort length (off=2)
 472      * ushort language (off=4)
 473      * ushort segCountX2 (off=6)
 474      * ushort searchRange (off=8)
 475      * ushort entrySelector (off=10)
 476      * ushort rangeShift (off=12)
 477      * ushort endCount[segCount] (off=14)
 478      * ushort reservedPad
 479      * ushort startCount[segCount]
 480      * short idDelta[segCount]
 481      * idRangeOFfset[segCount]
 482      * ushort glyphIdArray[]
 483      */
 484     static class CMapFormat4 extends CMap {
 485         int segCount;
 486         int entrySelector;
 487         int rangeShift;
 488         char[] endCount;
 489         char[] startCount;
 490         short[] idDelta;
 491         char[] idRangeOffset;
 492         char[] glyphIds;
 493 
 494         CMapFormat4(ByteBuffer bbuffer, int offset, char[] xlat) {
 495 
 496             this.xlat = xlat;
 497 
 498             bbuffer.position(offset);
 499             CharBuffer buffer = bbuffer.asCharBuffer();
 500             buffer.get(); // skip, we already know format=4
 501             int subtableLength = buffer.get();
 502             /* Try to recover from some bad fonts which specify a subtable
 503              * length that would overflow the byte buffer holding the whole
 504              * cmap table. If this isn't a recoverable situation an exception
 505              * may be thrown which is caught higher up the call stack.
 506              * Whilst this may seem lenient, in practice, unless the "bad"
 507              * subtable we are using is the last one in the cmap table we
 508              * would have no way of knowing about this problem anyway.
 509              */
 510             if (offset+subtableLength > bbuffer.capacity()) {
 511                 subtableLength = bbuffer.capacity() - offset;
 512             }
 513             buffer.get(); // skip language
 514             segCount = buffer.get()/2;
 515             int searchRange = buffer.get();
 516             entrySelector = buffer.get();
 517             rangeShift    = buffer.get()/2;
 518             startCount = new char[segCount];
 519             endCount = new char[segCount];
 520             idDelta = new short[segCount];
 521             idRangeOffset = new char[segCount];
 522 
 523             for (int i=0; i<segCount; i++) {
 524                 endCount[i] = buffer.get();
 525             }
 526             buffer.get(); // 2 bytes for reserved pad
 527             for (int i=0; i<segCount; i++) {
 528                 startCount[i] = buffer.get();
 529             }
 530 
 531             for (int i=0; i<segCount; i++) {
 532                 idDelta[i] = (short)buffer.get();
 533             }
 534 
 535             for (int i=0; i<segCount; i++) {
 536                 char ctmp = buffer.get();
 537                 idRangeOffset[i] = (char)((ctmp>>1)&0xffff);
 538             }
 539             /* Can calculate the number of glyph IDs by subtracting
 540              * "pos" from the length of the cmap
 541              */
 542             int pos = (segCount*8+16)/2;
 543             buffer.position(pos);
 544             int numGlyphIds = (subtableLength/2 - pos);
 545             glyphIds = new char[numGlyphIds];
 546             for (int i=0;i<numGlyphIds;i++) {
 547                 glyphIds[i] = buffer.get();
 548             }
 549 /*
 550             System.err.println("segcount="+segCount);
 551             System.err.println("entrySelector="+entrySelector);
 552             System.err.println("rangeShift="+rangeShift);
 553             for (int j=0;j<segCount;j++) {
 554               System.err.println("j="+j+ " sc="+(int)(startCount[j]&0xffff)+
 555                                  " ec="+(int)(endCount[j]&0xffff)+
 556                                  " delta="+idDelta[j] +
 557                                  " ro="+(int)idRangeOffset[j]);
 558             }
 559 
 560             //System.err.println("numglyphs="+glyphIds.length);
 561             for (int i=0;i<numGlyphIds;i++) {
 562                   System.err.println("gid["+i+"]="+(int)glyphIds[i]);
 563             }
 564 */
 565         }
 566 
 567         char getGlyph(int charCode) {
 568 
 569             int index = 0;
 570             char glyphCode = 0;
 571 
 572             int controlGlyph = getControlCodeGlyph(charCode, true);
 573             if (controlGlyph >= 0) {
 574                 return (char)controlGlyph;
 575             }
 576 
 577             /* presence of translation array indicates that this
 578              * cmap is in some other (non-unicode encoding).
 579              * In order to look-up a char->glyph mapping we need to
 580              * translate the unicode code point to the encoding of
 581              * the cmap.
 582              * REMIND: VALID CHARCODES??
 583              */
 584             if (xlat != null) {
 585                 charCode = xlat[charCode];
 586             }
 587 
 588             /*
 589              * Citation from the TrueType (and OpenType) spec:
 590              *   The segments are sorted in order of increasing endCode
 591              *   values, and the segment values are specified in four parallel
 592              *   arrays. You search for the first endCode that is greater than
 593              *   or equal to the character code you want to map. If the
 594              *   corresponding startCode is less than or equal to the
 595              *   character code, then you use the corresponding idDelta and
 596              *   idRangeOffset to map the character code to a glyph index
 597              *   (otherwise, the missingGlyph is returned).
 598              */
 599 
 600             /*
 601              * CMAP format4 defines several fields for optimized search of
 602              * the segment list (entrySelector, searchRange, rangeShift).
 603              * However, benefits are neglible and some fonts have incorrect
 604              * data - so we use straightforward binary search (see bug 6247425)
 605              */
 606             int left = 0, right = startCount.length;
 607             index = startCount.length >> 1;
 608             while (left < right) {
 609                 if (endCount[index] < charCode) {
 610                     left = index + 1;
 611                 } else {
 612                     right = index;
 613                 }
 614                 index = (left + right) >> 1;
 615             }
 616 
 617             if (charCode >= startCount[index] && charCode <= endCount[index]) {
 618                 int rangeOffset = idRangeOffset[index];
 619 
 620                 if (rangeOffset == 0) {
 621                     glyphCode = (char)(charCode + idDelta[index]);
 622                 } else {
 623                     /* Calculate an index into the glyphIds array */
 624 
 625 /*
 626                     System.err.println("rangeoffset="+rangeOffset+
 627                                        " charCode=" + charCode +
 628                                        " scnt["+index+"]="+(int)startCount[index] +
 629                                        " segCnt="+segCount);
 630 */
 631 
 632                     int glyphIDIndex = rangeOffset - segCount + index
 633                                          + (charCode - startCount[index]);
 634                     glyphCode = glyphIds[glyphIDIndex];
 635                     if (glyphCode != 0) {
 636                         glyphCode = (char)(glyphCode + idDelta[index]);
 637                     }
 638                 }
 639             }
 640             if (glyphCode != 0) {
 641             //System.err.println("cc="+Integer.toHexString((int)charCode) + " gc="+(int)glyphCode);
 642             }
 643             return glyphCode;
 644         }
 645     }
 646 
 647     // Format 0: Byte Encoding table
 648     static class CMapFormat0 extends CMap {
 649         byte [] cmap;
 650 
 651         CMapFormat0(ByteBuffer buffer, int offset) {
 652 
 653             /* skip 6 bytes of format, length, and version */
 654             int len = buffer.getChar(offset+2);
 655             cmap = new byte[len-6];
 656             buffer.position(offset+6);
 657             buffer.get(cmap);
 658         }
 659 
 660         char getGlyph(int charCode) {
 661             if (charCode < 256) {
 662                 if (charCode < 0x0010) {
 663                     switch (charCode) {
 664                     case 0x0009:
 665                     case 0x000a:
 666                     case 0x000d: return CharToGlyphMapper.INVISIBLE_GLYPH_ID;
 667                     }
 668                 }
 669                 return (char)(0xff & cmap[charCode]);
 670             } else {
 671                 return 0;
 672             }
 673         }
 674     }
 675 
 676 //     static CMap createSymbolCMap(ByteBuffer buffer, int offset, char[] syms) {
 677 
 678 //      CMap cmap = createCMap(buffer, offset, null);
 679 //      if (cmap == null) {
 680 //          return null;
 681 //      } else {
 682 //          return new CMapFormatSymbol(cmap, syms);
 683 //      }
 684 //     }
 685 
 686 //     static class CMapFormatSymbol extends CMap {
 687 
 688 //      CMap cmap;
 689 //      static final int NUM_BUCKETS = 128;
 690 //      Bucket[] buckets = new Bucket[NUM_BUCKETS];
 691 
 692 //      class Bucket {
 693 //          char unicode;
 694 //          char glyph;
 695 //          Bucket next;
 696 
 697 //          Bucket(char u, char g) {
 698 //              unicode = u;
 699 //              glyph = g;
 700 //          }
 701 //      }
 702 
 703 //      CMapFormatSymbol(CMap cmap, char[] syms) {
 704 
 705 //          this.cmap = cmap;
 706 
 707 //          for (int i=0;i<syms.length;i++) {
 708 //              char unicode = syms[i];
 709 //              if (unicode != noSuchChar) {
 710 //                  char glyph = cmap.getGlyph(i + 0xf000);
 711 //                  int hash = unicode % NUM_BUCKETS;
 712 //                  Bucket bucket = new Bucket(unicode, glyph);
 713 //                  if (buckets[hash] == null) {
 714 //                      buckets[hash] = bucket;
 715 //                  } else {
 716 //                      Bucket b = buckets[hash];
 717 //                      while (b.next != null) {
 718 //                          b = b.next;
 719 //                      }
 720 //                      b.next = bucket;
 721 //                  }
 722 //              }
 723 //          }
 724 //      }
 725 
 726 //      char getGlyph(int unicode) {
 727 //          if (unicode >= 0x1000) {
 728 //              return 0;
 729 //          }
 730 //          else if (unicode >=0xf000 && unicode < 0xf100) {
 731 //              return cmap.getGlyph(unicode);
 732 //          } else {
 733 //              Bucket b = buckets[unicode % NUM_BUCKETS];
 734 //              while (b != null) {
 735 //                  if (b.unicode == unicode) {
 736 //                      return b.glyph;
 737 //                  } else {
 738 //                      b = b.next;
 739 //                  }
 740 //              }
 741 //              return 0;
 742 //          }
 743 //      }
 744 //     }
 745 
 746     // Format 2: High-byte mapping through table
 747     static class CMapFormat2 extends CMap {
 748 
 749         char[] subHeaderKey = new char[256];
 750          /* Store subheaders in individual arrays
 751           * A SubHeader entry theortically looks like {
 752           *   char firstCode;
 753           *   char entryCount;
 754           *   short idDelta;
 755           *   char idRangeOffset;
 756           * }
 757           */
 758         char[] firstCodeArray;
 759         char[] entryCountArray;
 760         short[] idDeltaArray;
 761         char[] idRangeOffSetArray;
 762 
 763         char[] glyphIndexArray;
 764 
 765         CMapFormat2(ByteBuffer buffer, int offset, char[] xlat) {
 766 
 767             this.xlat = xlat;
 768 
 769             int tableLen = buffer.getChar(offset+2);
 770             buffer.position(offset+6);
 771             CharBuffer cBuffer = buffer.asCharBuffer();
 772             char maxSubHeader = 0;
 773             for (int i=0;i<256;i++) {
 774                 subHeaderKey[i] = cBuffer.get();
 775                 if (subHeaderKey[i] > maxSubHeader) {
 776                     maxSubHeader = subHeaderKey[i];
 777                 }
 778             }
 779             /* The value of the subHeaderKey is 8 * the subHeader index,
 780              * so the number of subHeaders can be obtained by dividing
 781              * this value bv 8 and adding 1.
 782              */
 783             int numSubHeaders = (maxSubHeader >> 3) +1;
 784             firstCodeArray = new char[numSubHeaders];
 785             entryCountArray = new char[numSubHeaders];
 786             idDeltaArray  = new short[numSubHeaders];
 787             idRangeOffSetArray  = new char[numSubHeaders];
 788             for (int i=0; i<numSubHeaders; i++) {
 789                 firstCodeArray[i] = cBuffer.get();
 790                 entryCountArray[i] = cBuffer.get();
 791                 idDeltaArray[i] = (short)cBuffer.get();
 792                 idRangeOffSetArray[i] = cBuffer.get();
 793 //              System.out.println("sh["+i+"]:fc="+(int)firstCodeArray[i]+
 794 //                                 " ec="+(int)entryCountArray[i]+
 795 //                                 " delta="+(int)idDeltaArray[i]+
 796 //                                 " offset="+(int)idRangeOffSetArray[i]);
 797             }
 798 
 799             int glyphIndexArrSize = (tableLen-518-numSubHeaders*8)/2;
 800             glyphIndexArray = new char[glyphIndexArrSize];
 801             for (int i=0; i<glyphIndexArrSize;i++) {
 802                 glyphIndexArray[i] = cBuffer.get();
 803             }
 804         }
 805 
 806         char getGlyph(int charCode) {
 807             int controlGlyph = getControlCodeGlyph(charCode, true);
 808             if (controlGlyph >= 0) {
 809                 return (char)controlGlyph;
 810             }
 811 
 812             if (xlat != null) {
 813                 charCode = xlat[charCode];
 814             }
 815 
 816             char highByte = (char)(charCode >> 8);
 817             char lowByte = (char)(charCode & 0xff);
 818             int key = subHeaderKey[highByte]>>3; // index into subHeaders
 819             char mapMe;
 820 
 821             if (key != 0) {
 822                 mapMe = lowByte;
 823             } else {
 824                 mapMe = highByte;
 825                 if (mapMe == 0) {
 826                     mapMe = lowByte;
 827                 }
 828             }
 829 
 830 //          System.err.println("charCode="+Integer.toHexString(charCode)+
 831 //                             " key="+key+ " mapMe="+Integer.toHexString(mapMe));
 832             char firstCode = firstCodeArray[key];
 833             if (mapMe < firstCode) {
 834                 return 0;
 835             } else {
 836                 mapMe -= firstCode;
 837             }
 838 
 839             if (mapMe < entryCountArray[key]) {
 840                 /* "address" arithmetic is needed to calculate the offset
 841                  * into glyphIndexArray. "idRangeOffSetArray[key]" specifies
 842                  * the number of bytes from that location in the table where
 843                  * the subarray of glyphIndexes starting at "firstCode" begins.
 844                  * Each entry in the subHeader table is 8 bytes, and the
 845                  * idRangeOffSetArray field is at offset 6 in the entry.
 846                  * The glyphIndexArray immediately follows the subHeaders.
 847                  * So if there are "N" entries then the number of bytes to the
 848                  * start of glyphIndexArray is (N-key)*8-6.
 849                  * Subtract this from the idRangeOffSetArray value to get
 850                  * the number of bytes into glyphIndexArray and divide by 2 to
 851                  * get the (char) array index.
 852                  */
 853                 int glyphArrayOffset = ((idRangeOffSetArray.length-key)*8)-6;
 854                 int glyphSubArrayStart =
 855                         (idRangeOffSetArray[key] - glyphArrayOffset)/2;
 856                 char glyphCode = glyphIndexArray[glyphSubArrayStart+mapMe];
 857                 if (glyphCode != 0) {
 858                     glyphCode += idDeltaArray[key]; //idDelta
 859                     return glyphCode;
 860                 }
 861             }
 862             return 0;
 863         }
 864     }
 865 
 866     // Format 6: Trimmed table mapping
 867     static class CMapFormat6 extends CMap {
 868 
 869         char firstCode;
 870         char entryCount;
 871         char[] glyphIdArray;
 872 
 873         CMapFormat6(ByteBuffer bbuffer, int offset, char[] xlat) {
 874 
 875              bbuffer.position(offset+6);
 876              CharBuffer buffer = bbuffer.asCharBuffer();
 877              firstCode = buffer.get();
 878              entryCount = buffer.get();
 879              glyphIdArray = new char[entryCount];
 880              for (int i=0; i< entryCount; i++) {
 881                  glyphIdArray[i] = buffer.get();
 882              }
 883          }
 884 
 885          char getGlyph(int charCode) {
 886             int controlGlyph = getControlCodeGlyph(charCode, true);
 887             if (controlGlyph >= 0) {
 888                 return (char)controlGlyph;
 889             }
 890 
 891              if (xlat != null) {
 892                  charCode = xlat[charCode];
 893              }
 894 
 895              charCode -= firstCode;
 896              if (charCode < 0 || charCode >= entryCount) {
 897                   return 0;
 898              } else {
 899                   return glyphIdArray[charCode];
 900              }
 901          }
 902     }
 903 
 904     // Format 8: mixed 16-bit and 32-bit coverage
 905     // Seems unlikely this code will ever get tested as we look for
 906     // MS platform Cmaps and MS states (in the Opentype spec on their website)
 907     // that MS doesn't support this format
 908     static class CMapFormat8 extends CMap {
 909          byte[] is32 = new byte[8192];
 910          int nGroups;
 911          int[] startCharCode;
 912          int[] endCharCode;
 913          int[] startGlyphID;
 914 
 915          CMapFormat8(ByteBuffer bbuffer, int offset, char[] xlat) {
 916 
 917              bbuffer.position(12);
 918              bbuffer.get(is32);
 919              nGroups = bbuffer.getInt();
 920              startCharCode = new int[nGroups];
 921              endCharCode   = new int[nGroups];
 922              startGlyphID  = new int[nGroups];
 923          }
 924 
 925         char getGlyph(int charCode) {
 926             if (xlat != null) {
 927                 throw new RuntimeException("xlat array for cmap fmt=8");
 928             }
 929             return 0;
 930         }
 931 
 932     }
 933 
 934 
 935     // Format 4-byte 10: Trimmed table mapping
 936     // Seems unlikely this code will ever get tested as we look for
 937     // MS platform Cmaps and MS states (in the Opentype spec on their website)
 938     // that MS doesn't support this format
 939     static class CMapFormat10 extends CMap {
 940 
 941          long firstCode;
 942          int entryCount;
 943          char[] glyphIdArray;
 944 
 945          CMapFormat10(ByteBuffer bbuffer, int offset, char[] xlat) {
 946 
 947              firstCode = bbuffer.getInt() & INTMASK;
 948              entryCount = bbuffer.getInt() & INTMASK;
 949              bbuffer.position(offset+20);
 950              CharBuffer buffer = bbuffer.asCharBuffer();
 951              glyphIdArray = new char[entryCount];
 952              for (int i=0; i< entryCount; i++) {
 953                  glyphIdArray[i] = buffer.get();
 954              }
 955          }
 956 
 957          char getGlyph(int charCode) {
 958 
 959              if (xlat != null) {
 960                  throw new RuntimeException("xlat array for cmap fmt=10");
 961              }
 962 
 963              int code = (int)(charCode - firstCode);
 964              if (code < 0 || code >= entryCount) {
 965                  return 0;
 966              } else {
 967                  return glyphIdArray[code];
 968              }
 969          }
 970     }
 971 
 972     // Format 12: Segmented coverage for UCS-4 (fonts supporting
 973     // surrogate pairs)
 974     static class CMapFormat12 extends CMap {
 975 
 976         int numGroups;
 977         int highBit =0;
 978         int power;
 979         int extra;
 980         long[] startCharCode;
 981         long[] endCharCode;
 982         int[] startGlyphID;
 983 
 984         CMapFormat12(ByteBuffer buffer, int offset, char[] xlat) {
 985             if (xlat != null) {
 986                 throw new RuntimeException("xlat array for cmap fmt=12");
 987             }
 988 
 989             numGroups = buffer.getInt(offset+12);
 990             startCharCode = new long[numGroups];
 991             endCharCode = new long[numGroups];
 992             startGlyphID = new int[numGroups];
 993             buffer.position(offset+16);
 994             buffer = buffer.slice();
 995             IntBuffer ibuffer = buffer.asIntBuffer();
 996             for (int i=0; i<numGroups; i++) {
 997                 startCharCode[i] = ibuffer.get() & INTMASK;
 998                 endCharCode[i] = ibuffer.get() & INTMASK;
 999                 startGlyphID[i] = ibuffer.get() & INTMASK;
1000             }
1001 
1002             /* Finds the high bit by binary searching through the bits */
1003             int value = numGroups;
1004 
1005             if (value >= 1 << 16) {
1006                 value >>= 16;
1007                 highBit += 16;
1008             }
1009 
1010             if (value >= 1 << 8) {
1011                 value >>= 8;
1012                 highBit += 8;
1013             }
1014 
1015             if (value >= 1 << 4) {
1016                 value >>= 4;
1017                 highBit += 4;
1018             }
1019 
1020             if (value >= 1 << 2) {
1021                 value >>= 2;
1022                 highBit += 2;
1023             }
1024 
1025             if (value >= 1 << 1) {
1026                 value >>= 1;
1027                 highBit += 1;
1028             }
1029 
1030             power = 1 << highBit;
1031             extra = numGroups - power;
1032         }
1033 
1034         char getGlyph(int charCode) {
1035             int controlGlyph = getControlCodeGlyph(charCode, false);
1036             if (controlGlyph >= 0) {
1037                 return (char)controlGlyph;
1038             }
1039             int probe = power;
1040             int range = 0;
1041 
1042             if (startCharCode[extra] <= charCode) {
1043                 range = extra;
1044             }
1045 
1046             while (probe > 1) {
1047                 probe >>= 1;
1048 
1049                 if (startCharCode[range+probe] <= charCode) {
1050                     range += probe;
1051                 }
1052             }
1053 
1054             if (startCharCode[range] <= charCode &&
1055                   endCharCode[range] >= charCode) {
1056                 return (char)
1057                     (startGlyphID[range] + (charCode - startCharCode[range]));
1058             }
1059 
1060             return 0;
1061         }
1062 
1063     }
1064 
1065     /* Used to substitute for bad Cmaps. */
1066     static class NullCMapClass extends CMap {
1067 
1068         char getGlyph(int charCode) {
1069             return 0;
1070         }
1071     }
1072 
1073     public static final NullCMapClass theNullCmap = new NullCMapClass();
1074 
1075     final int getControlCodeGlyph(int charCode, boolean noSurrogates) {
1076         if (charCode < 0x0010) {
1077             switch (charCode) {
1078             case 0x0009:
1079             case 0x000a:
1080             case 0x000d: return CharToGlyphMapper.INVISIBLE_GLYPH_ID;
1081             }
1082         } else if (charCode >= 0x200c) {
1083             if ((charCode <= 0x200f) ||
1084                 (charCode >= 0x2028 && charCode <= 0x202e) ||
1085                 (charCode >= 0x206a && charCode <= 0x206f)) {
1086                 return CharToGlyphMapper.INVISIBLE_GLYPH_ID;
1087             } else if (noSurrogates && charCode >= 0xFFFF) {
1088                 return 0;
1089             }
1090         }
1091         return -1;
1092     }
1093 
1094     static class UVS {
1095         int numSelectors;
1096         int[] selector;
1097 
1098         //for Default UVS Table
1099         int[] numUnicodeValueRanges;
1100         int[][] startUnicodeValue;
1101         short[][] additionalCount;
1102         //for Non-Default UVS Table
1103         int[] numUVSMapping;
1104         int[][] unicodeValue;
1105         char[][] glyphID;
1106 
1107         UVS(ByteBuffer buffer, int offset) {
1108             numSelectors = buffer.getInt(offset+6);
1109             selector = new int[numSelectors];
1110             numUnicodeValueRanges = new int[numSelectors];
1111             startUnicodeValue = new int[numSelectors][];
1112             additionalCount = new short[numSelectors][];
1113             numUVSMapping = new int[numSelectors];
1114             unicodeValue = new int[numSelectors][];
1115             glyphID = new char[numSelectors][];
1116 
1117             for (int i = 0; i < numSelectors; i++) {
1118                 buffer.position(offset + 10 + i * 11);
1119                 selector[i] = (buffer.get() & 0xff) << 16; //UINT24
1120                 selector[i] += (buffer.get() & 0xff) << 8;
1121                 selector[i] += buffer.get() & 0xff;
1122 
1123                 //for Default UVS Table
1124                 int tableOffset = buffer.getInt(offset + 10 + i * 11 + 3);
1125                 if (tableOffset == 0) {
1126                     numUnicodeValueRanges[i] = 0;
1127                 } else if (tableOffset > 0) {
1128                     buffer.position(offset+tableOffset);
1129                     numUnicodeValueRanges[i] = buffer.getInt() & INTMASK;
1130 
1131                     startUnicodeValue[i] = new int[numUnicodeValueRanges[i]];
1132                     additionalCount[i] = new short[numUnicodeValueRanges[i]];
1133 
1134                     for (int j = 0; j < numUnicodeValueRanges[i]; j++) {
1135                         int temp = (buffer.get() & 0xff) << 16; //UINT24
1136                         temp += (buffer.get() & 0xff) << 8;
1137                         temp += buffer.get() & 0xff;
1138                         startUnicodeValue[i][j] = temp;
1139                         additionalCount[i][j] = (short)(buffer.get() & 0xff);
1140                     }
1141                 }
1142 
1143                 //for Non-Default UVS Table
1144                 tableOffset = buffer.getInt(offset + 10 + i * 11 + 7);
1145                 if (tableOffset == 0) {
1146                     numUVSMapping[i] = 0;
1147                 } else if (tableOffset > 0) {
1148                     buffer.position(offset+tableOffset);
1149                     numUVSMapping[i] = buffer.getInt() & INTMASK;
1150                     unicodeValue[i] = new int[numUVSMapping[i]];
1151                     glyphID[i] = new char[numUVSMapping[i]];
1152 
1153                     for (int j = 0; j < numUVSMapping[i]; j++) {
1154                         int temp = (buffer.get() & 0xff) << 16; //UINT24
1155                         temp += (buffer.get() & 0xff) << 8;
1156                         temp += buffer.get() & 0xff;
1157                         unicodeValue[i][j] = temp;
1158                         glyphID[i][j] = buffer.getChar();
1159                     }
1160                 }
1161             }
1162         }
1163 
1164         /* getGlyph for Variation selector
1165            return value:
1166             0: A special glyph for the variation selector is Not found
1167            -1: Default glyph should be used
1168            0>: A special glyph is found
1169         */
1170         static final int VS_NOGLYPH = 0;
1171         static final int VS_DEFAULT_GLYPH = -1;
1172         private int getGlyph(int charCode, int variationSelector) {
1173             int targetSelector = -1;
1174             for (int i = 0; i < numSelectors; i++) {
1175                 if (selector[i] == variationSelector) {
1176                     targetSelector = i;
1177                     break;
1178                 }
1179             }
1180             if (targetSelector == -1) {
1181                 return VS_NOGLYPH;
1182             }
1183             if (numUnicodeValueRanges[targetSelector] > 0) {
1184                 int index = java.util.Arrays.binarySearch(
1185                                 startUnicodeValue[targetSelector], charCode);
1186                 if (index >= 0) {
1187                     return VS_DEFAULT_GLYPH;
1188                 } else {
1189                     index = -index - 2;
1190                     if (index >= 0 &&
1191                         charCode >= startUnicodeValue[targetSelector][index] &&
1192                         charCode <= startUnicodeValue[targetSelector][index]
1193                                     +additionalCount[targetSelector][index]) {
1194                         return VS_DEFAULT_GLYPH;
1195                     }
1196                 }
1197             }
1198             if (numUVSMapping[targetSelector] > 0) {
1199                 int index = java.util.Arrays.binarySearch(
1200                                 unicodeValue[targetSelector], charCode);
1201                 if (index >= 0) {
1202                     return glyphID[targetSelector][index];
1203                 }
1204             }
1205             return VS_NOGLYPH;
1206         }
1207     }
1208 
1209     char getGlyph(int charCode, int variationSelector, boolean allowFallback) {
1210         char glyph = 0;
1211         if (uvs == null) {
1212             if (allowFallback) {
1213                 glyph = getGlyph(charCode);
1214             }
1215         } else {
1216             int result = uvs.getGlyph(charCode, variationSelector);
1217             if (result > 0) {
1218                 glyph = (char)(result & 0xFFFF);
1219             } else if (result == UVS.VS_DEFAULT_GLYPH ||
1220                        allowFallback) {
1221                 glyph = getGlyph(charCode);
1222             }
1223         }
1224         return glyph;
1225     }
1226 }