1 /*
   2  * Copyright (c) 1996, 2014, 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.awt;
  27 
  28 import java.awt.Font;
  29 import java.io.DataInputStream;
  30 import java.io.DataOutputStream;
  31 import java.io.File;
  32 import java.io.FileInputStream;
  33 import java.io.InputStream;
  34 import java.io.IOException;
  35 import java.io.OutputStream;
  36 import java.nio.charset.Charset;
  37 import java.nio.charset.CharsetEncoder;
  38 import java.security.AccessController;
  39 import java.security.PrivilegedAction;
  40 import java.util.Arrays;
  41 import java.util.HashMap;
  42 import java.util.HashSet;
  43 import java.util.Hashtable;
  44 import java.util.Locale;
  45 import java.util.Map.Entry;
  46 import java.util.Properties;
  47 import java.util.Set;
  48 import java.util.Vector;
  49 import sun.font.CompositeFontDescriptor;
  50 import sun.font.SunFontManager;
  51 import sun.font.FontManagerFactory;
  52 import sun.font.FontUtilities;
  53 import sun.util.logging.PlatformLogger;
  54 
  55 /**
  56  * Provides the definitions of the five logical fonts: Serif, SansSerif,
  57  * Monospaced, Dialog, and DialogInput. The necessary information
  58  * is obtained from fontconfig files.
  59  */
  60 public abstract class FontConfiguration {
  61 
  62     //static global runtime env
  63     protected static String osVersion;
  64     protected static String osName;
  65     protected static String encoding; // canonical name of default nio charset
  66     protected static Locale startupLocale = null;
  67     protected static Hashtable<String, String> localeMap = null;
  68     private static FontConfiguration fontConfig;
  69     private static PlatformLogger logger;
  70     protected static boolean isProperties = true;
  71 
  72     protected SunFontManager fontManager;
  73     protected boolean preferLocaleFonts;
  74     protected boolean preferPropFonts;
  75 
  76     private File fontConfigFile;
  77     private boolean foundOsSpecificFile;
  78     private boolean inited;
  79     private String javaLib;
  80 
  81     /* A default FontConfiguration must be created before an alternate
  82      * one to ensure proper static initialisation takes place.
  83      */
  84     public FontConfiguration(SunFontManager fm) {
  85         if (FontUtilities.debugFonts()) {
  86             FontUtilities.getLogger()
  87                 .info("Creating standard Font Configuration");
  88         }
  89         if (FontUtilities.debugFonts() && logger == null) {
  90             logger = PlatformLogger.getLogger("sun.awt.FontConfiguration");
  91         }
  92         fontManager = fm;
  93         setOsNameAndVersion();  /* static initialization */
  94         setEncoding();          /* static initialization */
  95         /* Separating out the file location from the rest of the
  96          * initialisation, so the caller has the option of doing
  97          * something else if a suitable file isn't found.
  98          */
  99         findFontConfigFile();
 100     }
 101 
 102     public synchronized boolean init() {
 103         if (!inited) {
 104             this.preferLocaleFonts = false;
 105             this.preferPropFonts = false;
 106             setFontConfiguration();
 107             readFontConfigFile(fontConfigFile);
 108             initFontConfig();
 109             inited = true;
 110         }
 111         return true;
 112     }
 113 
 114     public FontConfiguration(SunFontManager fm,
 115                              boolean preferLocaleFonts,
 116                              boolean preferPropFonts) {
 117         fontManager = fm;
 118         if (FontUtilities.debugFonts()) {
 119             FontUtilities.getLogger()
 120                 .info("Creating alternate Font Configuration");
 121         }
 122         this.preferLocaleFonts = preferLocaleFonts;
 123         this.preferPropFonts = preferPropFonts;
 124         /* fontConfig should be initialised by default constructor, and
 125          * its data tables can be shared, since readFontConfigFile doesn't
 126          * update any other state. Also avoid a doPrivileged block.
 127          */
 128         initFontConfig();
 129     }
 130 
 131     /**
 132      * Fills in this instance's osVersion and osName members. By
 133      * default uses the system properties os.name and os.version;
 134      * subclasses may override.
 135      */
 136     protected void setOsNameAndVersion() {
 137         osName = System.getProperty("os.name");
 138         osVersion = System.getProperty("os.version");
 139     }
 140 
 141     private void setEncoding() {
 142         encoding = Charset.defaultCharset().name();
 143         startupLocale = SunToolkit.getStartupLocale();
 144     }
 145 
 146     /////////////////////////////////////////////////////////////////////
 147     // methods for loading the FontConfig file                         //
 148     /////////////////////////////////////////////////////////////////////
 149 
 150     public boolean foundOsSpecificFile() {
 151         return foundOsSpecificFile;
 152     }
 153 
 154     /* Smoke test to see if we can trust this configuration by testing if
 155      * the first slot of a composite font maps to an installed file.
 156      */
 157     public boolean fontFilesArePresent() {
 158         init();
 159         short fontNameID = compFontNameIDs[0][0][0];
 160         short fileNameID = getComponentFileID(fontNameID);
 161         final String fileName = mapFileName(getComponentFileName(fileNameID));
 162         Boolean exists = java.security.AccessController.doPrivileged(
 163             new java.security.PrivilegedAction<Boolean>() {
 164                  public Boolean run() {
 165                      try {
 166                          File f = new File(fileName);
 167                          return Boolean.valueOf(f.exists());
 168                      }
 169                      catch (Exception e) {
 170                          return Boolean.FALSE;
 171                      }
 172                  }
 173                 });
 174         return exists.booleanValue();
 175     }
 176 
 177     private void findFontConfigFile() {
 178 
 179         foundOsSpecificFile = true; // default assumption.
 180         String javaHome = System.getProperty("java.home");
 181         if (javaHome == null) {
 182             throw new Error("java.home property not set");
 183         }
 184         javaLib = javaHome + File.separator + "lib";
 185         String userConfigFile = System.getProperty("sun.awt.fontconfig");
 186         if (userConfigFile != null) {
 187             fontConfigFile = new File(userConfigFile);
 188         } else {
 189             fontConfigFile = findFontConfigFile(javaLib);
 190         }
 191     }
 192 
 193     private void readFontConfigFile(File f) {
 194         /* This is invoked here as readFontConfigFile is only invoked
 195          * once per VM, and always in a privileged context, thus the
 196          * directory containing installed fall back fonts is accessed
 197          * from this context
 198          */
 199         getInstalledFallbackFonts(javaLib);
 200 
 201         if (f != null) {
 202             try {
 203                 FileInputStream in = new FileInputStream(f.getPath());
 204                 if (isProperties) {
 205                     loadProperties(in);
 206                 } else {
 207                     loadBinary(in);
 208                 }
 209                 in.close();
 210                 if (FontUtilities.debugFonts()) {
 211                     logger.config("Read logical font configuration from " + f);
 212                 }
 213             } catch (IOException e) {
 214                 if (FontUtilities.debugFonts()) {
 215                     logger.config("Failed to read logical font configuration from " + f);
 216                 }
 217             }
 218         }
 219         String version = getVersion();
 220         if (!"1".equals(version) && FontUtilities.debugFonts()) {
 221             logger.config("Unsupported fontconfig version: " + version);
 222         }
 223     }
 224 
 225     protected void getInstalledFallbackFonts(String javaLib) {
 226         String fallbackDirName = javaLib + File.separator +
 227             "fonts" + File.separator + "fallback";
 228 
 229         File fallbackDir = new File(fallbackDirName);
 230         if (fallbackDir.exists() && fallbackDir.isDirectory()) {
 231             String[] ttfs = fallbackDir.list(fontManager.getTrueTypeFilter());
 232             String[] t1s = fallbackDir.list(fontManager.getType1Filter());
 233             int numTTFs = (ttfs == null) ? 0 : ttfs.length;
 234             int numT1s = (t1s == null) ? 0 : t1s.length;
 235             int len = numTTFs + numT1s;
 236             if (numTTFs + numT1s == 0) {
 237                 return;
 238             }
 239             installedFallbackFontFiles = new String[len];
 240             for (int i=0; i<numTTFs; i++) {
 241                 installedFallbackFontFiles[i] =
 242                     fallbackDir + File.separator + ttfs[i];
 243             }
 244             for (int i=0; i<numT1s; i++) {
 245                 installedFallbackFontFiles[i+numTTFs] =
 246                     fallbackDir + File.separator + t1s[i];
 247             }
 248             fontManager.registerFontsInDir(fallbackDirName);
 249         }
 250     }
 251 
 252     private File findImpl(String fname) {
 253         File f = new File(fname + ".properties");
 254         if (FontUtilities.debugFonts()) {
 255             logger.info("Looking for text fontconfig file : " + f);
 256         }
 257         if (f.canRead()) {
 258             if (FontUtilities.debugFonts()) {
 259                 logger.info("Found file : " + f);
 260             }
 261             isProperties = true;
 262             return f;
 263         }
 264         f = new File(fname + ".bfc");
 265         if (FontUtilities.debugFonts()) {
 266             logger.info("Looking for binary fontconfig file : " + f);
 267         }
 268         if (f.canRead()) {
 269             if (FontUtilities.debugFonts()) {
 270                 logger.info("Found file : " + f);
 271             }
 272             isProperties = false;
 273             return f;
 274         }
 275         return null;
 276     }
 277 
 278     private File findFontConfigFile(String javaLib) {
 279         String baseName = javaLib + File.separator + "fontconfig";
 280         File configFile;
 281         String osMajorVersion = null;
 282         if (osVersion != null && osName != null) {
 283             configFile = findImpl(baseName + "." + osName + "." + osVersion);
 284             if (configFile != null) {
 285                 return configFile;
 286             }
 287             int decimalPointIndex = osVersion.indexOf('.');
 288             if (decimalPointIndex != -1) {
 289                 osMajorVersion = osVersion.substring(0, osVersion.indexOf('.'));
 290                 configFile = findImpl(baseName + "." + osName + "." + osMajorVersion);
 291                 if (configFile != null) {
 292                     return configFile;
 293                 }
 294             }
 295         }
 296         if (osName != null) {
 297             configFile = findImpl(baseName + "." + osName);
 298             if (configFile != null) {
 299                 return configFile;
 300             }
 301         }
 302         if (osVersion != null) {
 303             configFile = findImpl(baseName + "." + osVersion);
 304             if (configFile != null) {
 305                 return configFile;
 306             }
 307             if (osMajorVersion != null) {
 308                 configFile = findImpl(baseName + "." + osMajorVersion);
 309                 if (configFile != null) {
 310                     return configFile;
 311                 }
 312             }
 313         }
 314         foundOsSpecificFile = false;
 315 
 316         configFile = findImpl(baseName);
 317         if (configFile != null) {
 318             return configFile;
 319         }
 320         if (FontUtilities.debugFonts()) {
 321             logger.info("Did not find a fontconfig file.");
 322         }
 323         return null;
 324     }
 325 
 326     /* Initialize the internal data tables from binary format font
 327      * configuration file.
 328      */
 329     public static void loadBinary(InputStream inStream) throws IOException {
 330         DataInputStream in = new DataInputStream(inStream);
 331         head = readShortTable(in, HEAD_LENGTH);
 332         int[] tableSizes = new int[INDEX_TABLEEND];
 333         for (int i = 0; i < INDEX_TABLEEND; i++) {
 334             tableSizes[i] = head[i + 1] - head[i];
 335         }
 336         table_scriptIDs       = readShortTable(in, tableSizes[INDEX_scriptIDs]);
 337         table_scriptFonts     = readShortTable(in, tableSizes[INDEX_scriptFonts]);
 338         table_elcIDs          = readShortTable(in, tableSizes[INDEX_elcIDs]);
 339         table_sequences        = readShortTable(in, tableSizes[INDEX_sequences]);
 340         table_fontfileNameIDs = readShortTable(in, tableSizes[INDEX_fontfileNameIDs]);
 341         table_componentFontNameIDs = readShortTable(in, tableSizes[INDEX_componentFontNameIDs]);
 342         table_filenames       = readShortTable(in, tableSizes[INDEX_filenames]);
 343         table_awtfontpaths    = readShortTable(in, tableSizes[INDEX_awtfontpaths]);
 344         table_exclusions      = readShortTable(in, tableSizes[INDEX_exclusions]);
 345         table_proportionals   = readShortTable(in, tableSizes[INDEX_proportionals]);
 346         table_scriptFontsMotif   = readShortTable(in, tableSizes[INDEX_scriptFontsMotif]);
 347         table_alphabeticSuffix   = readShortTable(in, tableSizes[INDEX_alphabeticSuffix]);
 348         table_stringIDs       = readShortTable(in, tableSizes[INDEX_stringIDs]);
 349 
 350         //StringTable cache
 351         stringCache = new String[table_stringIDs.length + 1];
 352 
 353         int len = tableSizes[INDEX_stringTable];
 354         byte[] bb = new byte[len * 2];
 355         table_stringTable = new char[len];
 356         in.read(bb);
 357         int i = 0, j = 0;
 358         while (i < len) {
 359            table_stringTable[i++] = (char)(bb[j++] << 8 | (bb[j++] & 0xff));
 360         }
 361         if (verbose) {
 362             dump();
 363         }
 364     }
 365 
 366     /* Generate a binary format font configuration from internal data
 367      * tables.
 368      */
 369     public static void saveBinary(OutputStream out) throws IOException {
 370         sanityCheck();
 371 
 372         DataOutputStream dataOut = new DataOutputStream(out);
 373         writeShortTable(dataOut, head);
 374         writeShortTable(dataOut, table_scriptIDs);
 375         writeShortTable(dataOut, table_scriptFonts);
 376         writeShortTable(dataOut, table_elcIDs);
 377         writeShortTable(dataOut, table_sequences);
 378         writeShortTable(dataOut, table_fontfileNameIDs);
 379         writeShortTable(dataOut, table_componentFontNameIDs);
 380         writeShortTable(dataOut, table_filenames);
 381         writeShortTable(dataOut, table_awtfontpaths);
 382         writeShortTable(dataOut, table_exclusions);
 383         writeShortTable(dataOut, table_proportionals);
 384         writeShortTable(dataOut, table_scriptFontsMotif);
 385         writeShortTable(dataOut, table_alphabeticSuffix);
 386         writeShortTable(dataOut, table_stringIDs);
 387         //stringTable
 388         dataOut.writeChars(new String(table_stringTable));
 389         out.close();
 390         if (verbose) {
 391             dump();
 392         }
 393     }
 394 
 395     //private static boolean loadingProperties;
 396     private static short stringIDNum;
 397     private static short[] stringIDs;
 398     private static StringBuilder stringTable;
 399 
 400     public static void loadProperties(InputStream in) throws IOException {
 401         //loadingProperties = true;
 402         //StringID starts from "1", "0" is reserved for "not defined"
 403         stringIDNum = 1;
 404         stringIDs = new short[1000];
 405         stringTable = new StringBuilder(4096);
 406 
 407         if (verbose && logger == null) {
 408             logger = PlatformLogger.getLogger("sun.awt.FontConfiguration");
 409         }
 410         new PropertiesHandler().load(in);
 411 
 412         //loadingProperties = false;
 413         stringIDs = null;
 414         stringTable = null;
 415     }
 416 
 417 
 418     /////////////////////////////////////////////////////////////////////
 419     // methods for initializing the FontConfig                         //
 420     /////////////////////////////////////////////////////////////////////
 421 
 422     /**
 423      *  set initLocale, initEncoding and initELC for this FontConfig object
 424      *  currently we just simply use the startup locale and encoding
 425      */
 426     private void initFontConfig() {
 427         initLocale = startupLocale;
 428         initEncoding = encoding;
 429         if (preferLocaleFonts && !willReorderForStartupLocale()) {
 430             preferLocaleFonts = false;
 431         }
 432         initELC = getInitELC();
 433         initAllComponentFonts();
 434     }
 435 
 436     //"ELC" stands for "Encoding.Language.Country". This method returns
 437     //the ID of the matched elc setting of "initLocale" in elcIDs table.
 438     //If no match is found, it returns the default ID, which is
 439     //"NULL.NULL.NULL" in elcIDs table.
 440     private short getInitELC() {
 441         if (initELC != -1) {
 442             return initELC;
 443         }
 444         HashMap <String, Integer> elcIDs = new HashMap<String, Integer>();
 445         for (int i = 0; i < table_elcIDs.length; i++) {
 446             elcIDs.put(getString(table_elcIDs[i]), i);
 447         }
 448         String language = initLocale.getLanguage();
 449         String country = initLocale.getCountry();
 450         String elc;
 451         if (elcIDs.containsKey(elc=initEncoding + "." + language + "." + country)
 452             || elcIDs.containsKey(elc=initEncoding + "." + language)
 453             || elcIDs.containsKey(elc=initEncoding)) {
 454             initELC = elcIDs.get(elc).shortValue();
 455         } else {
 456             initELC = elcIDs.get("NULL.NULL.NULL").shortValue();
 457         }
 458         int i = 0;
 459         while (i < table_alphabeticSuffix.length) {
 460             if (initELC == table_alphabeticSuffix[i]) {
 461                 alphabeticSuffix = getString(table_alphabeticSuffix[i + 1]);
 462                 return initELC;
 463             }
 464             i += 2;
 465         }
 466         return initELC;
 467     }
 468 
 469     public static boolean verbose;
 470     private short    initELC = -1;
 471     private Locale   initLocale;
 472     private String   initEncoding;
 473     private String   alphabeticSuffix;
 474 
 475     private short[][][] compFontNameIDs = new short[NUM_FONTS][NUM_STYLES][];
 476     private int[][][] compExclusions = new int[NUM_FONTS][][];
 477     private int[] compCoreNum = new int[NUM_FONTS];
 478 
 479     private Set<Short> coreFontNameIDs = new HashSet<Short>();
 480     private Set<Short> fallbackFontNameIDs = new HashSet<Short>();
 481 
 482     private void initAllComponentFonts() {
 483         short[] fallbackScripts = getFallbackScripts();
 484         for (int fontIndex = 0; fontIndex < NUM_FONTS; fontIndex++) {
 485             short[] coreScripts = getCoreScripts(fontIndex);
 486             compCoreNum[fontIndex] = coreScripts.length;
 487             /*
 488             System.out.println("coreScriptID=" + table_sequences[initELC * 5 + fontIndex]);
 489             for (int i = 0; i < coreScripts.length; i++) {
 490             System.out.println("  " + i + " :" + getString(table_scriptIDs[coreScripts[i]]));
 491             }
 492             */
 493             //init exclusionRanges
 494             int[][] exclusions = new int[coreScripts.length][];
 495             for (int i = 0; i < coreScripts.length; i++) {
 496                 exclusions[i] = getExclusionRanges(coreScripts[i]);
 497             }
 498             compExclusions[fontIndex] = exclusions;
 499             //init componentFontNames
 500             for (int styleIndex = 0; styleIndex < NUM_STYLES; styleIndex++) {
 501                 int index;
 502                 short[] nameIDs = new short[coreScripts.length + fallbackScripts.length];
 503                 //core
 504                 for (index = 0; index < coreScripts.length; index++) {
 505                     nameIDs[index] = getComponentFontID(coreScripts[index],
 506                                                fontIndex, styleIndex);
 507                     if (preferLocaleFonts && localeMap != null &&
 508                             fontManager.usingAlternateFontforJALocales()) {
 509                         nameIDs[index] = remapLocaleMap(fontIndex, styleIndex,
 510                                                         coreScripts[index], nameIDs[index]);
 511                     }
 512                     if (preferPropFonts) {
 513                         nameIDs[index] = remapProportional(fontIndex, nameIDs[index]);
 514                     }
 515                     //System.out.println("nameid=" + nameIDs[index]);
 516                     coreFontNameIDs.add(nameIDs[index]);
 517                 }
 518                 //fallback
 519                 for (int i = 0; i < fallbackScripts.length; i++) {
 520                     short id = getComponentFontID(fallbackScripts[i],
 521                                                fontIndex, styleIndex);
 522                     if (preferLocaleFonts && localeMap != null &&
 523                             fontManager.usingAlternateFontforJALocales()) {
 524                         id = remapLocaleMap(fontIndex, styleIndex, fallbackScripts[i], id);
 525                     }
 526                     if (preferPropFonts) {
 527                         id = remapProportional(fontIndex, id);
 528                     }
 529                     if (contains(nameIDs, id, index)) {
 530                         continue;
 531                     }
 532                     /*
 533                       System.out.println("fontIndex=" + fontIndex + ", styleIndex=" + styleIndex
 534                            + ", fbIndex=" + i + ",fbS=" + fallbackScripts[i] + ", id=" + id);
 535                     */
 536                     fallbackFontNameIDs.add(id);
 537                     nameIDs[index++] = id;
 538                 }
 539                 if (index < nameIDs.length) {
 540                     short[] newNameIDs = new short[index];
 541                     System.arraycopy(nameIDs, 0, newNameIDs, 0, index);
 542                     nameIDs = newNameIDs;
 543                 }
 544                 compFontNameIDs[fontIndex][styleIndex] = nameIDs;
 545             }
 546         }
 547    }
 548 
 549    private short remapLocaleMap(int fontIndex, int styleIndex, short scriptID, short fontID) {
 550         String scriptName = getString(table_scriptIDs[scriptID]);
 551 
 552         String value = localeMap.get(scriptName);
 553         if (value == null) {
 554             String fontName = fontNames[fontIndex];
 555             String styleName = styleNames[styleIndex];
 556             value = localeMap.get(fontName + "." + styleName + "." + scriptName);
 557         }
 558         if (value == null) {
 559             return fontID;
 560         }
 561 
 562         for (int i = 0; i < table_componentFontNameIDs.length; i++) {
 563             String name = getString(table_componentFontNameIDs[i]);
 564             if (value.equalsIgnoreCase(name)) {
 565                 fontID = (short)i;
 566                 break;
 567             }
 568         }
 569         return fontID;
 570     }
 571 
 572     public static boolean hasMonoToPropMap() {
 573         return table_proportionals != null && table_proportionals.length != 0;
 574     }
 575 
 576     private short remapProportional(int fontIndex, short id) {
 577     if (preferPropFonts &&
 578         table_proportionals.length != 0 &&
 579         fontIndex != 2 &&         //"monospaced"
 580         fontIndex != 4) {         //"dialoginput"
 581             int i = 0;
 582             while (i < table_proportionals.length) {
 583                 if (table_proportionals[i] == id) {
 584                     return table_proportionals[i + 1];
 585                 }
 586                 i += 2;
 587             }
 588         }
 589         return id;
 590     }
 591 
 592     /////////////////////////////////////////////////////////////////////
 593     // Methods for handling font and style names                       //
 594     /////////////////////////////////////////////////////////////////////
 595     protected static final int NUM_FONTS = 5;
 596     protected static final int NUM_STYLES = 4;
 597     protected static final String[] fontNames
 598             = {"serif", "sansserif", "monospaced", "dialog", "dialoginput"};
 599     protected static final String[] publicFontNames
 600             = {Font.SERIF, Font.SANS_SERIF, Font.MONOSPACED, Font.DIALOG,
 601                Font.DIALOG_INPUT};
 602     protected static final String[] styleNames
 603             = {"plain", "bold", "italic", "bolditalic"};
 604 
 605     /**
 606      * Checks whether the given font family name is a valid logical font name.
 607      * The check is case insensitive.
 608      */
 609     public static boolean isLogicalFontFamilyName(String fontName) {
 610         return isLogicalFontFamilyNameLC(fontName.toLowerCase(Locale.ENGLISH));
 611     }
 612 
 613     /**
 614      * Checks whether the given font family name is a valid logical font name.
 615      * The check is case sensitive.
 616      */
 617     public static boolean isLogicalFontFamilyNameLC(String fontName) {
 618         for (int i = 0; i < fontNames.length; i++) {
 619             if (fontName.equals(fontNames[i])) {
 620                 return true;
 621             }
 622         }
 623         return false;
 624     }
 625 
 626     /**
 627      * Checks whether the given style name is a valid logical font style name.
 628      */
 629     private static boolean isLogicalFontStyleName(String styleName) {
 630         for (int i = 0; i < styleNames.length; i++) {
 631             if (styleName.equals(styleNames[i])) {
 632                 return true;
 633             }
 634         }
 635         return false;
 636     }
 637 
 638     /**
 639      * Checks whether the given font face name is a valid logical font name.
 640      * The check is case insensitive.
 641      */
 642     public static boolean isLogicalFontFaceName(String fontName) {
 643         return isLogicalFontFaceNameLC(fontName.toLowerCase(Locale.ENGLISH));
 644     }
 645 
 646    /**
 647     * Checks whether the given font face name is a valid logical font name.
 648     * The check is case sensitive.
 649     */
 650     public static boolean isLogicalFontFaceNameLC(String fontName) {
 651         int period = fontName.indexOf('.');
 652         if (period >= 0) {
 653             String familyName = fontName.substring(0, period);
 654             String styleName = fontName.substring(period + 1);
 655             return isLogicalFontFamilyName(familyName) &&
 656                     isLogicalFontStyleName(styleName);
 657         } else {
 658             return isLogicalFontFamilyName(fontName);
 659         }
 660     }
 661 
 662     protected static int getFontIndex(String fontName) {
 663         return getArrayIndex(fontNames, fontName);
 664     }
 665 
 666     protected static int getStyleIndex(String styleName) {
 667         return getArrayIndex(styleNames, styleName);
 668     }
 669 
 670     private static int getArrayIndex(String[] names, String name) {
 671         for (int i = 0; i < names.length; i++) {
 672             if (name.equals(names[i])) {
 673                 return i;
 674             }
 675         }
 676         assert false;
 677         return 0;
 678     }
 679 
 680     protected static int getStyleIndex(int style) {
 681         switch (style) {
 682             case Font.PLAIN:
 683                 return 0;
 684             case Font.BOLD:
 685                 return 1;
 686             case Font.ITALIC:
 687                 return 2;
 688             case Font.BOLD | Font.ITALIC:
 689                 return 3;
 690             default:
 691                 return 0;
 692         }
 693     }
 694 
 695     protected static String getFontName(int fontIndex) {
 696         return fontNames[fontIndex];
 697     }
 698 
 699     protected static String getStyleName(int styleIndex) {
 700         return styleNames[styleIndex];
 701     }
 702 
 703     /**
 704      * Returns the font face name for the given logical font
 705      * family name and style.
 706      * The style argument is interpreted as in java.awt.Font.Font.
 707      */
 708     public static String getLogicalFontFaceName(String familyName, int style) {
 709         assert isLogicalFontFamilyName(familyName);
 710         return familyName.toLowerCase(Locale.ENGLISH) + "." + getStyleString(style);
 711     }
 712 
 713     /**
 714      * Returns the string typically used in properties files
 715      * for the given style.
 716      * The style argument is interpreted as in java.awt.Font.Font.
 717      */
 718     public static String getStyleString(int style) {
 719         return getStyleName(getStyleIndex(style));
 720     }
 721 
 722     /**
 723      * Returns a fallback name for the given font name. For a few known
 724      * font names, matching logical font names are returned. For all
 725      * other font names, defaultFallback is returned.
 726      * defaultFallback differs between AWT and 2D.
 727      */
 728     public abstract String getFallbackFamilyName(String fontName, String defaultFallback);
 729 
 730     /**
 731      * Returns the 1.1 equivalent for some old 1.0 font family names for
 732      * which we need to maintain compatibility in some configurations.
 733      * Returns null for other font names.
 734      */
 735     protected String getCompatibilityFamilyName(String fontName) {
 736         fontName = fontName.toLowerCase(Locale.ENGLISH);
 737         if (fontName.equals("timesroman")) {
 738             return "serif";
 739         } else if (fontName.equals("helvetica")) {
 740             return "sansserif";
 741         } else if (fontName.equals("courier")) {
 742             return "monospaced";
 743         }
 744         return null;
 745     }
 746 
 747     protected static String[] installedFallbackFontFiles = null;
 748 
 749     /**
 750      * Maps a file name given in the font configuration file
 751      * to a format appropriate for the platform.
 752      */
 753     protected String mapFileName(String fileName) {
 754         return fileName;
 755     }
 756 
 757     //////////////////////////////////////////////////////////////////////
 758     //  reordering                                                      //
 759     //////////////////////////////////////////////////////////////////////
 760 
 761     /* Mappings from file encoding to font config name for font supporting
 762      * the corresponding language. This is filled in by initReorderMap()
 763      */
 764     protected HashMap<String, Object> reorderMap = null;
 765 
 766     /* Platform-specific mappings */
 767     protected abstract void initReorderMap();
 768 
 769     /* Move item at index "src" to "dst", shuffling all values in
 770      * between down
 771      */
 772     private void shuffle(String[] seq, int src, int dst) {
 773         if (dst >= src) {
 774             return;
 775         }
 776         String tmp = seq[src];
 777         for (int i=src; i>dst; i--) {
 778             seq[i] = seq[i-1];
 779         }
 780         seq[dst] = tmp;
 781     }
 782 
 783     /* Called to determine if there's a re-order sequence for this locale/
 784      * encoding. If there's none then the caller can "bail" and avoid
 785      * unnecessary work
 786      */
 787     public static boolean willReorderForStartupLocale() {
 788         return getReorderSequence() != null;
 789     }
 790 
 791     private static Object getReorderSequence() {
 792         if (fontConfig.reorderMap == null) {
 793              fontConfig.initReorderMap();
 794         }
 795         HashMap<String, Object> reorderMap = fontConfig.reorderMap;
 796 
 797         /* Find the most specific mapping */
 798         String language = startupLocale.getLanguage();
 799         String country = startupLocale.getCountry();
 800         Object val = reorderMap.get(encoding + "." + language + "." + country);
 801         if (val == null) {
 802             val = reorderMap.get(encoding + "." + language);
 803         }
 804         if (val == null) {
 805             val = reorderMap.get(encoding);
 806         }
 807         return val;
 808     }
 809 
 810     /* This method reorders the sequence such that the matches for the
 811      * file encoding are moved ahead of other elements.
 812      * If an encoding uses more than one font, they are all moved up.
 813      */
 814      private void reorderSequenceForLocale(String[] seq) {
 815         Object val =  getReorderSequence();
 816         if (val instanceof String) {
 817             for (int i=0; i< seq.length; i++) {
 818                 if (seq[i].equals(val)) {
 819                     shuffle(seq, i, 0);
 820                     return;
 821                 }
 822             }
 823         } else if (val instanceof String[]) {
 824             String[] fontLangs = (String[])val;
 825             for (int l=0; l<fontLangs.length;l++) {
 826                 for (int i=0; i<seq.length;i++) {
 827                     if (seq[i].equals(fontLangs[l])) {
 828                         shuffle(seq, i, l);
 829                     }
 830                 }
 831             }
 832         }
 833     }
 834 
 835     private static Vector<String> splitSequence(String sequence) {
 836         //String.split would be more convenient, but incurs big performance penalty
 837         Vector<String> parts = new Vector<>();
 838         int start = 0;
 839         int end;
 840         while ((end = sequence.indexOf(',', start)) >= 0) {
 841             parts.add(sequence.substring(start, end));
 842             start = end + 1;
 843         }
 844         if (sequence.length() > start) {
 845             parts.add(sequence.substring(start, sequence.length()));
 846         }
 847         return parts;
 848     }
 849 
 850     protected String[] split(String sequence) {
 851         Vector<String> v = splitSequence(sequence);
 852         return v.toArray(new String[0]);
 853     }
 854 
 855     ////////////////////////////////////////////////////////////////////////
 856     // Methods for extracting information from the fontconfig data for AWT//
 857     ////////////////////////////////////////////////////////////////////////
 858     private Hashtable<String, Charset> charsetRegistry = new Hashtable<>(5);
 859 
 860     /**
 861      * Returns FontDescriptors describing the physical fonts used for the
 862      * given logical font name and style. The font name is interpreted
 863      * in a case insensitive way.
 864      * The style argument is interpreted as in java.awt.Font.Font.
 865      */
 866     public FontDescriptor[] getFontDescriptors(String fontName, int style) {
 867         assert isLogicalFontFamilyName(fontName);
 868         fontName = fontName.toLowerCase(Locale.ENGLISH);
 869         int fontIndex = getFontIndex(fontName);
 870         int styleIndex = getStyleIndex(style);
 871         return getFontDescriptors(fontIndex, styleIndex);
 872     }
 873     private FontDescriptor[][][] fontDescriptors =
 874         new FontDescriptor[NUM_FONTS][NUM_STYLES][];
 875 
 876     private FontDescriptor[] getFontDescriptors(int fontIndex, int styleIndex) {
 877         FontDescriptor[] descriptors = fontDescriptors[fontIndex][styleIndex];
 878         if (descriptors == null) {
 879             descriptors = buildFontDescriptors(fontIndex, styleIndex);
 880             fontDescriptors[fontIndex][styleIndex] = descriptors;
 881         }
 882         return descriptors;
 883     }
 884 
 885     protected FontDescriptor[] buildFontDescriptors(int fontIndex, int styleIndex) {
 886         String fontName = fontNames[fontIndex];
 887         String styleName = styleNames[styleIndex];
 888 
 889         short[] scriptIDs = getCoreScripts(fontIndex);
 890         short[] nameIDs = compFontNameIDs[fontIndex][styleIndex];
 891         String[] sequence = new String[scriptIDs.length];
 892         String[] names = new String[scriptIDs.length];
 893         for (int i = 0; i < sequence.length; i++) {
 894             names[i] = getComponentFontName(nameIDs[i]);
 895             sequence[i] = getScriptName(scriptIDs[i]);
 896             if (alphabeticSuffix != null && "alphabetic".equals(sequence[i])) {
 897                 sequence[i] = sequence[i] + "/" + alphabeticSuffix;
 898             }
 899         }
 900         int[][] fontExclusionRanges = compExclusions[fontIndex];
 901 
 902         FontDescriptor[] descriptors = new FontDescriptor[names.length];
 903 
 904         for (int i = 0; i < names.length; i++) {
 905             String awtFontName;
 906             String encoding;
 907 
 908             awtFontName = makeAWTFontName(names[i], sequence[i]);
 909 
 910             // look up character encoding
 911             encoding = getEncoding(names[i], sequence[i]);
 912             if (encoding == null) {
 913                 encoding = "default";
 914             }
 915             CharsetEncoder enc
 916                     = getFontCharsetEncoder(encoding.trim(), awtFontName);
 917 
 918             // we already have the exclusion ranges
 919             int[] exclusionRanges = fontExclusionRanges[i];
 920 
 921             // create descriptor
 922             descriptors[i] = new FontDescriptor(awtFontName, enc, exclusionRanges);
 923         }
 924         return descriptors;
 925     }
 926 
 927     /**
 928      * Returns the AWT font name for the given platform font name and
 929      * character subset.
 930      */
 931     protected String makeAWTFontName(String platformFontName,
 932             String characterSubsetName) {
 933         return platformFontName;
 934     }
 935 
 936     /**
 937      * Returns the java.io name of the platform character encoding for the
 938      * given AWT font name and character subset. May return "default"
 939      * to indicate that getDefaultFontCharset should be called to obtain
 940      * a charset encoder.
 941      */
 942     protected abstract String getEncoding(String awtFontName,
 943             String characterSubsetName);
 944 
 945     private CharsetEncoder getFontCharsetEncoder(final String charsetName,
 946             String fontName) {
 947 
 948         Charset fc = null;
 949         if (charsetName.equals("default")) {
 950             fc = charsetRegistry.get(fontName);
 951         } else {
 952             fc = charsetRegistry.get(charsetName);
 953         }
 954         if (fc != null) {
 955             return fc.newEncoder();
 956         }
 957 
 958         if (!charsetName.startsWith("sun.awt.") && !charsetName.equals("default")) {
 959             fc = Charset.forName(charsetName);
 960         } else {
 961             Class<?> fcc = AccessController.doPrivileged(new PrivilegedAction<Class<?>>() {
 962                     public Class<?> run() {
 963                         try {
 964                             return Class.forName(charsetName, true,
 965                                                  ClassLoader.getSystemClassLoader());
 966                         } catch (ClassNotFoundException e) {
 967                         }
 968                         return null;
 969                     }
 970                 });
 971 
 972             if (fcc != null) {
 973                 try {
 974                     fc = (Charset) fcc.getDeclaredConstructor().newInstance();
 975                 } catch (Exception e) {
 976                 }
 977             }
 978         }
 979         if (fc == null) {
 980             fc = getDefaultFontCharset(fontName);
 981         }
 982 
 983         if (charsetName.equals("default")){
 984             charsetRegistry.put(fontName, fc);
 985         } else {
 986             charsetRegistry.put(charsetName, fc);
 987         }
 988         return fc.newEncoder();
 989     }
 990 
 991     protected abstract Charset getDefaultFontCharset(
 992             String fontName);
 993 
 994     /* This retrieves the platform font directories (path) calculated
 995      * by setAWTFontPathSequence(String[]). The default implementation
 996      * returns null, its expected that X11 platforms may return
 997      * non-null.
 998      */
 999     public HashSet<String> getAWTFontPathSet() {
1000         return null;
1001     }
1002 
1003     ////////////////////////////////////////////////////////////////////////
1004     // methods for extracting information from the fontconfig data for 2D //
1005     ////////////////////////////////////////////////////////////////////////
1006 
1007     /**
1008      * Returns an array of composite font descriptors for all logical font
1009      * faces.
1010      * If the font configuration file doesn't specify Lucida Sans Regular
1011      * or the given fallback font as component fonts, they are added here.
1012      */
1013     public CompositeFontDescriptor[] get2DCompositeFontInfo() {
1014         CompositeFontDescriptor[] result =
1015                 new CompositeFontDescriptor[NUM_FONTS * NUM_STYLES];
1016         String defaultFontFile = fontManager.getDefaultFontFile();
1017         String defaultFontFaceName = fontManager.getDefaultFontFaceName();
1018 
1019         for (int fontIndex = 0; fontIndex < NUM_FONTS; fontIndex++) {
1020             String fontName = publicFontNames[fontIndex];
1021 
1022             // determine exclusion ranges for font
1023             // AWT uses separate exclusion range array per component font.
1024             // 2D packs all range boundaries into one array.
1025             // Both use separate entries for lower and upper boundary.
1026             int[][] exclusions = compExclusions[fontIndex];
1027             int numExclusionRanges = 0;
1028             for (int i = 0; i < exclusions.length; i++) {
1029                 numExclusionRanges += exclusions[i].length;
1030             }
1031             int[] exclusionRanges = new int[numExclusionRanges];
1032             int[] exclusionRangeLimits = new int[exclusions.length];
1033             int exclusionRangeIndex = 0;
1034             int exclusionRangeLimitIndex = 0;
1035             for (int i = 0; i < exclusions.length; i++) {
1036                 int[] componentRanges = exclusions[i];
1037                 for (int j = 0; j < componentRanges.length; ) {
1038                     int value = componentRanges[j];
1039                     exclusionRanges[exclusionRangeIndex++] = componentRanges[j++];
1040                     exclusionRanges[exclusionRangeIndex++] = componentRanges[j++];
1041                 }
1042                 exclusionRangeLimits[i] = exclusionRangeIndex;
1043             }
1044             // other info is per style
1045             for (int styleIndex = 0; styleIndex < NUM_STYLES; styleIndex++) {
1046                 int maxComponentFontCount = compFontNameIDs[fontIndex][styleIndex].length;
1047                 boolean sawDefaultFontFile = false;
1048                 // fall back fonts listed in the lib/fonts/fallback directory
1049                 if (installedFallbackFontFiles != null) {
1050                     maxComponentFontCount += installedFallbackFontFiles.length;
1051                 }
1052                 String faceName = fontName + "." + styleNames[styleIndex];
1053 
1054                 // determine face names and file names of component fonts
1055                 String[] componentFaceNames = new String[maxComponentFontCount];
1056                 String[] componentFileNames = new String[maxComponentFontCount];
1057 
1058                 int index;
1059                 for (index = 0; index < compFontNameIDs[fontIndex][styleIndex].length; index++) {
1060                     short fontNameID = compFontNameIDs[fontIndex][styleIndex][index];
1061                     short fileNameID = getComponentFileID(fontNameID);
1062                     componentFaceNames[index] = getFaceNameFromComponentFontName(getComponentFontName(fontNameID));
1063                     componentFileNames[index] = mapFileName(getComponentFileName(fileNameID));
1064                     if (componentFileNames[index] == null ||
1065                         needToSearchForFile(componentFileNames[index])) {
1066                         componentFileNames[index] = getFileNameFromComponentFontName(getComponentFontName(fontNameID));
1067                     }
1068                     if (!sawDefaultFontFile &&
1069                         defaultFontFile.equals(componentFileNames[index])) {
1070                         sawDefaultFontFile = true;
1071                     }
1072                     /*
1073                     System.out.println(publicFontNames[fontIndex] + "." + styleNames[styleIndex] + "."
1074                         + getString(table_scriptIDs[coreScripts[index]]) + "=" + componentFileNames[index]);
1075                     */
1076                 }
1077 
1078                 //"Lucida Sans Regular" is not in the list, we add it here
1079                 if (!sawDefaultFontFile) {
1080                     int len = 0;
1081                     if (installedFallbackFontFiles != null) {
1082                         len = installedFallbackFontFiles.length;
1083                     }
1084                     if (index + len == maxComponentFontCount) {
1085                         String[] newComponentFaceNames = new String[maxComponentFontCount + 1];
1086                         System.arraycopy(componentFaceNames, 0, newComponentFaceNames, 0, index);
1087                         componentFaceNames = newComponentFaceNames;
1088                         String[] newComponentFileNames = new String[maxComponentFontCount + 1];
1089                         System.arraycopy(componentFileNames, 0, newComponentFileNames, 0, index);
1090                         componentFileNames = newComponentFileNames;
1091                     }
1092                     componentFaceNames[index] = defaultFontFaceName;
1093                     componentFileNames[index] = defaultFontFile;
1094                     index++;
1095                 }
1096 
1097                 if (installedFallbackFontFiles != null) {
1098                     for (int ifb=0; ifb<installedFallbackFontFiles.length; ifb++) {
1099                         componentFaceNames[index] = null;
1100                         componentFileNames[index] = installedFallbackFontFiles[ifb];
1101                         index++;
1102                     }
1103                 }
1104 
1105                 if (index < maxComponentFontCount) {
1106                     String[] newComponentFaceNames = new String[index];
1107                     System.arraycopy(componentFaceNames, 0, newComponentFaceNames, 0, index);
1108                     componentFaceNames = newComponentFaceNames;
1109                     String[] newComponentFileNames = new String[index];
1110                     System.arraycopy(componentFileNames, 0, newComponentFileNames, 0, index);
1111                     componentFileNames = newComponentFileNames;
1112                 }
1113                 // exclusion range limit array length must match component face name
1114                 // array length - native code relies on this
1115 
1116                 int[] clippedExclusionRangeLimits = exclusionRangeLimits;
1117                 if (index != clippedExclusionRangeLimits.length) {
1118                     int len = exclusionRangeLimits.length;
1119                     clippedExclusionRangeLimits = new int[index];
1120                     System.arraycopy(exclusionRangeLimits, 0, clippedExclusionRangeLimits, 0, len);
1121                     //padding for various fallback fonts
1122                     for (int i = len; i < index; i++) {
1123                         clippedExclusionRangeLimits[i] = exclusionRanges.length;
1124                     }
1125                 }
1126                 /*
1127                 System.out.println(faceName + ":");
1128                 for (int i = 0; i < componentFileNames.length; i++) {
1129                     System.out.println("    " + componentFaceNames[i]
1130                          + "  -> " + componentFileNames[i]);
1131                 }
1132                 */
1133                 result[fontIndex * NUM_STYLES + styleIndex]
1134                         = new CompositeFontDescriptor(
1135                             faceName,
1136                             compCoreNum[fontIndex],
1137                             componentFaceNames,
1138                             componentFileNames,
1139                             exclusionRanges,
1140                             clippedExclusionRangeLimits);
1141             }
1142         }
1143         return result;
1144     }
1145 
1146     protected abstract String getFaceNameFromComponentFontName(String componentFontName);
1147     protected abstract String getFileNameFromComponentFontName(String componentFontName);
1148 
1149     /*
1150     public class 2dFont {
1151         public String platformName;
1152         public String fontfileName;
1153     }
1154     private 2dFont [] componentFonts = null;
1155     */
1156 
1157     /* Used on Linux to test if a file referenced in a font configuration
1158      * file exists in the location that is expected. If it does, no need
1159      * to search for it. If it doesn't then unless its a fallback font,
1160      * return that expensive code should be invoked to search for the font.
1161      */
1162     HashMap<String, Boolean> existsMap;
1163     public boolean needToSearchForFile(String fileName) {
1164         if (!FontUtilities.isLinux) {
1165             return false;
1166         } else if (existsMap == null) {
1167            existsMap = new HashMap<String, Boolean>();
1168         }
1169         Boolean exists = existsMap.get(fileName);
1170         if (exists == null) {
1171             /* call getNumberCoreFonts() to ensure these are initialised, and
1172              * if this file isn't for a core component, ie, is a for a fallback
1173              * font which very typically isn't available, then can't afford
1174              * to take the start-up penalty to search for it.
1175              */
1176             getNumberCoreFonts();
1177             if (!coreFontFileNames.contains(fileName)) {
1178                 exists = Boolean.TRUE;
1179             } else {
1180                 exists = Boolean.valueOf((new File(fileName)).exists());
1181                 existsMap.put(fileName, exists);
1182                 if (FontUtilities.debugFonts() &&
1183                     exists == Boolean.FALSE) {
1184                     logger.warning("Couldn't locate font file " + fileName);
1185                 }
1186             }
1187         }
1188         return exists == Boolean.FALSE;
1189     }
1190 
1191     private int numCoreFonts = -1;
1192     private String[] componentFonts = null;
1193     HashMap <String, String> filenamesMap = new HashMap<String, String>();
1194     HashSet <String> coreFontFileNames = new HashSet<String>();
1195 
1196     /* Return the number of core fonts. Note this isn't thread safe but
1197      * a calling thread can call this and getPlatformFontNames() in either
1198      * order.
1199      */
1200     public int getNumberCoreFonts() {
1201         if (numCoreFonts == -1) {
1202             numCoreFonts = coreFontNameIDs.size();
1203             Short[] emptyShortArray = new Short[0];
1204             Short[] core = coreFontNameIDs.toArray(emptyShortArray);
1205             Short[] fallback = fallbackFontNameIDs.toArray(emptyShortArray);
1206 
1207             int numFallbackFonts = 0;
1208             int i;
1209             for (i = 0; i < fallback.length; i++) {
1210                 if (coreFontNameIDs.contains(fallback[i])) {
1211                     fallback[i] = null;
1212                     continue;
1213                 }
1214                 numFallbackFonts++;
1215             }
1216             componentFonts = new String[numCoreFonts + numFallbackFonts];
1217             String filename = null;
1218             for (i = 0; i < core.length; i++) {
1219                 short fontid = core[i];
1220                 short fileid = getComponentFileID(fontid);
1221                 componentFonts[i] = getComponentFontName(fontid);
1222                 String compFileName = getComponentFileName(fileid);
1223                 if (compFileName != null) {
1224                     coreFontFileNames.add(compFileName);
1225                 }
1226                 filenamesMap.put(componentFonts[i], mapFileName(compFileName));
1227             }
1228             for (int j = 0; j < fallback.length; j++) {
1229                 if (fallback[j] != null) {
1230                     short fontid = fallback[j];
1231                     short fileid = getComponentFileID(fontid);
1232                     componentFonts[i] = getComponentFontName(fontid);
1233                     filenamesMap.put(componentFonts[i],
1234                                      mapFileName(getComponentFileName(fileid)));
1235                     i++;
1236                 }
1237             }
1238         }
1239         return numCoreFonts;
1240     }
1241 
1242     /* Return all platform font names used by this font configuration.
1243      * The first getNumberCoreFonts() entries are guaranteed to be the
1244      * core fonts - ie no fall back only fonts.
1245      */
1246     public String[] getPlatformFontNames() {
1247         if (numCoreFonts == -1) {
1248             getNumberCoreFonts();
1249         }
1250         return componentFonts;
1251     }
1252 
1253     /**
1254      * Returns a file name for the physical font represented by this platform font name,
1255      * if the font configuration has such information available, or null if the
1256      * information is unavailable. The file name returned is just a hint; a null return
1257      * value doesn't necessarily mean that the font is unavailable, nor does a non-null
1258      * return value guarantee that the file exists and contains the physical font.
1259      * The file name can be an absolute or a relative path name.
1260      */
1261     public String getFileNameFromPlatformName(String platformName) {
1262         // get2DCompositeFontInfo
1263         //     ->  getFileNameFromComponentfontName()  (W/M)
1264         //       ->   getFileNameFromPlatformName()
1265         // it's a waste of time on Win32, but I have to give X11 a chance to
1266         // call getFileNameFromXLFD()
1267         return filenamesMap.get(platformName);
1268     }
1269 
1270     /**
1271      * Returns a configuration specific path to be appended to the font
1272      * search path.
1273      */
1274     public String getExtraFontPath() {
1275         return getString(head[INDEX_appendedfontpath]);
1276     }
1277 
1278     public String getVersion() {
1279         return getString(head[INDEX_version]);
1280     }
1281 
1282     /* subclass support */
1283     protected static FontConfiguration getFontConfiguration() {
1284         return fontConfig;
1285     }
1286 
1287     protected void setFontConfiguration() {
1288         fontConfig = this;      /* static initialization */
1289     }
1290 
1291     //////////////////////////////////////////////////////////////////////
1292     // FontConfig data tables and the index constants in binary file    //
1293     //////////////////////////////////////////////////////////////////////
1294     /* The binary font configuration file begins with a short[] "head", which
1295      * contains the offsets to the starts of the individual data table which
1296      * immediately follow. The current implementation includes the tables shown
1297      * below.
1298      *
1299      * (00) table_scriptIDs    :stringIDs of all defined CharacterSubsetNames
1300      * (01) table_scriptFonts  :scriptID x fontIndex x styleIndex->
1301      *                          PlatformFontNameID mapping. Each scriptID might
1302      *                          have 1 or 20 entries depends on if it is defined
1303      *                          via a "allfonts.CharacterSubsetname" or a list of
1304      *                          "LogicalFontName.StyleName.CharacterSubsetName"
1305      *                          entries, positive entry means it's a "allfonts"
1306      *                          entry, a negative value means this is a offset to
1307      *                          a NUM_FONTS x NUM_STYLES subtable.
1308      * (02) table_elcIDs       :stringIDs of all defined ELC names, string
1309      *                          "NULL.NULL.NULL" is used for "default"
1310      * (03) table_sequences    :elcID x logicalFont -> scriptIDs table defined
1311      *                          by "sequence.allfonts/LogicalFontName.ELC" in
1312      *                          font configuration file, each "elcID" has
1313      *                          NUM_FONTS (5) entries in this table.
1314      * (04) table_fontfileNameIDs
1315      *                         :stringIDs of all defined font file names
1316      * (05) table_componentFontNameIDs
1317      *                         :stringIDs of all defined PlatformFontNames
1318      * (06) table_filenames    :platformFontNamesID->fontfileNameID mapping
1319      *                          table, the index is the platformFontNamesID.
1320      * (07) table_awtfontpaths :CharacterSubsetNames->awtfontpaths mapping table,
1321      *                          the index is the CharacterSubsetName's stringID
1322      *                          and content is the stringID of awtfontpath.
1323      * (08) table_exclusions   :scriptID -> exclusionRanges mapping table,
1324      *                          the index is the scriptID and the content is
1325                                 a id of an exclusionRanges int[].
1326      * (09) table_proportionals:list of pairs of PlatformFontNameIDs, stores
1327      *                          the replacement info defined by "proportional"
1328      *                          keyword.
1329      * (10) table_scriptFontsMotif
1330      *                         :same as (01) except this table stores the
1331      *                          info defined with ".motif" keyword
1332      * (11) table_alphabeticSuffix
1333      *                         :elcID -> stringID of alphabetic/XXXX entries
1334      * (12) table_stringIDs    :The index of this table is the string ID, the
1335      *                          content is the "start index" of this string in
1336      *                          stringTable, use the start index of next entry
1337      *                          as the "end index".
1338      * (13) table_stringTable  :The real storage of all character strings defined
1339      *                          /used this font configuration, need a pair of
1340      *                          "start" and "end" indices to access.
1341      * (14) reserved
1342      * (15) table_fallbackScripts
1343      *                         :stringIDs of fallback CharacterSubsetnames, stored
1344      *                          in the order of they are defined in sequence.fallback.
1345      * (16) table_appendedfontpath
1346      *                         :stringtID of the "appendedfontpath" defined.
1347      * (17) table_version   :stringID of the version number of this fontconfig file.
1348      */
1349     private static final int HEAD_LENGTH = 20;
1350     private static final int INDEX_scriptIDs = 0;
1351     private static final int INDEX_scriptFonts = 1;
1352     private static final int INDEX_elcIDs = 2;
1353     private static final int INDEX_sequences = 3;
1354     private static final int INDEX_fontfileNameIDs = 4;
1355     private static final int INDEX_componentFontNameIDs = 5;
1356     private static final int INDEX_filenames = 6;
1357     private static final int INDEX_awtfontpaths = 7;
1358     private static final int INDEX_exclusions = 8;
1359     private static final int INDEX_proportionals = 9;
1360     private static final int INDEX_scriptFontsMotif = 10;
1361     private static final int INDEX_alphabeticSuffix = 11;
1362     private static final int INDEX_stringIDs = 12;
1363     private static final int INDEX_stringTable = 13;
1364     private static final int INDEX_TABLEEND = 14;
1365     private static final int INDEX_fallbackScripts = 15;
1366     private static final int INDEX_appendedfontpath = 16;
1367     private static final int INDEX_version = 17;
1368 
1369     private static short[] head;
1370     private static short[] table_scriptIDs;
1371     private static short[] table_scriptFonts;
1372     private static short[] table_elcIDs;
1373     private static short[] table_sequences;
1374     private static short[] table_fontfileNameIDs;
1375     private static short[] table_componentFontNameIDs;
1376     private static short[] table_filenames;
1377     protected static short[] table_awtfontpaths;
1378     private static short[] table_exclusions;
1379     private static short[] table_proportionals;
1380     private static short[] table_scriptFontsMotif;
1381     private static short[] table_alphabeticSuffix;
1382     private static short[] table_stringIDs;
1383     private static char[]  table_stringTable;
1384 
1385     /**
1386      * Checks consistencies of complied fontconfig data. This method
1387      * is called only at the build-time from
1388      * build.tools.compilefontconfig.CompileFontConfig.
1389      */
1390     private static void sanityCheck() {
1391         int errors = 0;
1392 
1393         //This method will only be called during build time, do we
1394         //need do PrivilegedAction?
1395         String osName = java.security.AccessController.doPrivileged(
1396                             new java.security.PrivilegedAction<String>() {
1397             public String run() {
1398                 return System.getProperty("os.name");
1399             }
1400         });
1401 
1402         //componentFontNameID starts from "1"
1403         for (int ii = 1; ii < table_filenames.length; ii++) {
1404             if (table_filenames[ii] == -1) {
1405                 // The corresponding finename entry for a component
1406                 // font name is mandatory on Windows, but it's
1407                 // optional on Solaris and Linux.
1408                 if (osName.contains("Windows")) {
1409                     System.err.println("\n Error: <filename."
1410                                        + getString(table_componentFontNameIDs[ii])
1411                                        + "> entry is missing!!!");
1412                     errors++;
1413                 } else {
1414                     if (verbose && !isEmpty(table_filenames)) {
1415                         System.err.println("\n Note: 'filename' entry is undefined for \""
1416                                            + getString(table_componentFontNameIDs[ii])
1417                                            + "\"");
1418                     }
1419                 }
1420             }
1421         }
1422         for (int ii = 0; ii < table_scriptIDs.length; ii++) {
1423             short fid = table_scriptFonts[ii];
1424             if (fid == 0) {
1425                 System.out.println("\n Error: <allfonts."
1426                                    + getString(table_scriptIDs[ii])
1427                                    + "> entry is missing!!!");
1428                 errors++;
1429                 continue;
1430             } else if (fid < 0) {
1431                 fid = (short)-fid;
1432                 for (int iii = 0; iii < NUM_FONTS; iii++) {
1433                     for (int iij = 0; iij < NUM_STYLES; iij++) {
1434                         int jj = iii * NUM_STYLES + iij;
1435                         short ffid = table_scriptFonts[fid + jj];
1436                         if (ffid == 0) {
1437                             System.err.println("\n Error: <"
1438                                            + getFontName(iii) + "."
1439                                            + getStyleName(iij) + "."
1440                                            + getString(table_scriptIDs[ii])
1441                                            + "> entry is missing!!!");
1442                             errors++;
1443                         }
1444                     }
1445                 }
1446             }
1447         }
1448         if ("SunOS".equals(osName)) {
1449             for (int ii = 0; ii < table_awtfontpaths.length; ii++) {
1450                 if (table_awtfontpaths[ii] == 0) {
1451                     String script = getString(table_scriptIDs[ii]);
1452                     if (script.contains("lucida") ||
1453                         script.contains("dingbats") ||
1454                         script.contains("symbol")) {
1455                         continue;
1456                     }
1457                     System.err.println("\nError: "
1458                                        + "<awtfontpath."
1459                                        + script
1460                                        + "> entry is missing!!!");
1461                     errors++;
1462                 }
1463             }
1464         }
1465         if (errors != 0) {
1466             System.err.println("!!THERE ARE " + errors + " ERROR(S) IN "
1467                                + "THE FONTCONFIG FILE, PLEASE CHECK ITS CONTENT!!\n");
1468             System.exit(1);
1469         }
1470     }
1471 
1472     private static boolean isEmpty(short[] a) {
1473         for (short s : a) {
1474             if (s != -1) {
1475                 return false;
1476             }
1477         }
1478         return true;
1479     }
1480 
1481     //dump the fontconfig data tables
1482     private static void dump() {
1483         System.out.println("\n----Head Table------------");
1484         for (int ii = 0; ii < HEAD_LENGTH; ii++) {
1485             System.out.println("  " + ii + " : " + head[ii]);
1486         }
1487         System.out.println("\n----scriptIDs-------------");
1488         printTable(table_scriptIDs, 0);
1489         System.out.println("\n----scriptFonts----------------");
1490         for (int ii = 0; ii < table_scriptIDs.length; ii++) {
1491             short fid = table_scriptFonts[ii];
1492             if (fid >= 0) {
1493                 System.out.println("  allfonts."
1494                                    + getString(table_scriptIDs[ii])
1495                                    + "="
1496                                    + getString(table_componentFontNameIDs[fid]));
1497             }
1498         }
1499         for (int ii = 0; ii < table_scriptIDs.length; ii++) {
1500             short fid = table_scriptFonts[ii];
1501             if (fid < 0) {
1502                 fid = (short)-fid;
1503                 for (int iii = 0; iii < NUM_FONTS; iii++) {
1504                     for (int iij = 0; iij < NUM_STYLES; iij++) {
1505                         int jj = iii * NUM_STYLES + iij;
1506                         short ffid = table_scriptFonts[fid + jj];
1507                         System.out.println("  "
1508                                            + getFontName(iii) + "."
1509                                            + getStyleName(iij) + "."
1510                                            + getString(table_scriptIDs[ii])
1511                                            + "="
1512                                            + getString(table_componentFontNameIDs[ffid]));
1513                     }
1514                 }
1515 
1516             }
1517         }
1518         System.out.println("\n----elcIDs----------------");
1519         printTable(table_elcIDs, 0);
1520         System.out.println("\n----sequences-------------");
1521         for (int ii = 0; ii< table_elcIDs.length; ii++) {
1522             System.out.println("  " + ii + "/" + getString(table_elcIDs[ii]));
1523             short[] ss = getShortArray(table_sequences[ii * NUM_FONTS + 0]);
1524             for (int jj = 0; jj < ss.length; jj++) {
1525                 System.out.println("     " + getString(table_scriptIDs[ss[jj]]));
1526             }
1527         }
1528         System.out.println("\n----fontfileNameIDs-------");
1529         printTable(table_fontfileNameIDs, 0);
1530 
1531         System.out.println("\n----componentFontNameIDs--");
1532         printTable(table_componentFontNameIDs, 1);
1533         System.out.println("\n----filenames-------------");
1534         for (int ii = 0; ii < table_filenames.length; ii++) {
1535             if (table_filenames[ii] == -1) {
1536                 System.out.println("  " + ii + " : null");
1537             } else {
1538                 System.out.println("  " + ii + " : "
1539                    + getString(table_fontfileNameIDs[table_filenames[ii]]));
1540             }
1541         }
1542         System.out.println("\n----awtfontpaths---------");
1543         for (int ii = 0; ii < table_awtfontpaths.length; ii++) {
1544             System.out.println("  " + getString(table_scriptIDs[ii])
1545                                + " : "
1546                                + getString(table_awtfontpaths[ii]));
1547         }
1548         System.out.println("\n----proportionals--------");
1549         for (int ii = 0; ii < table_proportionals.length; ii++) {
1550             System.out.println("  "
1551                    + getString(table_componentFontNameIDs[table_proportionals[ii++]])
1552                    + " -> "
1553                    + getString(table_componentFontNameIDs[table_proportionals[ii]]));
1554         }
1555         int i = 0;
1556         System.out.println("\n----alphabeticSuffix----");
1557         while (i < table_alphabeticSuffix.length) {
1558           System.out.println("    " + getString(table_elcIDs[table_alphabeticSuffix[i++]])
1559                              + " -> " + getString(table_alphabeticSuffix[i++]));
1560         }
1561         System.out.println("\n----String Table---------");
1562         System.out.println("    stringID:    Num =" + table_stringIDs.length);
1563         System.out.println("    stringTable: Size=" + table_stringTable.length * 2);
1564 
1565         System.out.println("\n----fallbackScriptIDs---");
1566         short[] fbsIDs = getShortArray(head[INDEX_fallbackScripts]);
1567         for (int ii = 0; ii < fbsIDs.length; ii++) {
1568           System.out.println("  " + getString(table_scriptIDs[fbsIDs[ii]]));
1569         }
1570         System.out.println("\n----appendedfontpath-----");
1571         System.out.println("  " + getString(head[INDEX_appendedfontpath]));
1572         System.out.println("\n----Version--------------");
1573         System.out.println("  " + getString(head[INDEX_version]));
1574     }
1575 
1576 
1577     //////////////////////////////////////////////////////////////////////
1578     // Data table access methods                                        //
1579     //////////////////////////////////////////////////////////////////////
1580 
1581     /* Return the fontID of the platformFontName defined in this font config
1582      * by "LogicalFontName.StyleName.CharacterSubsetName" entry or
1583      * "allfonts.CharacterSubsetName" entry in properties format fc file.
1584      */
1585     protected static short getComponentFontID(short scriptID, int fontIndex, int styleIndex) {
1586         short fid = table_scriptFonts[scriptID];
1587         //System.out.println("fid=" + fid + "/ scriptID=" + scriptID + ", fi=" + fontIndex + ", si=" + styleIndex);
1588         if (fid >= 0) {
1589             //"allfonts"
1590             return fid;
1591         } else {
1592             return table_scriptFonts[-fid + fontIndex * NUM_STYLES + styleIndex];
1593         }
1594     }
1595 
1596     /* Same as getCompoentFontID() except this method returns the fontID define by
1597      * "xxxx.motif" entry.
1598      */
1599     protected static short getComponentFontIDMotif(short scriptID, int fontIndex, int styleIndex) {
1600         if (table_scriptFontsMotif.length == 0) {
1601             return 0;
1602         }
1603         short fid = table_scriptFontsMotif[scriptID];
1604         if (fid >= 0) {
1605             //"allfonts" > 0 or "not defined" == 0
1606             return fid;
1607         } else {
1608             return table_scriptFontsMotif[-fid + fontIndex * NUM_STYLES + styleIndex];
1609         }
1610     }
1611 
1612     private static int[] getExclusionRanges(short scriptID) {
1613         short exID = table_exclusions[scriptID];
1614         if (exID == 0) {
1615             return EMPTY_INT_ARRAY;
1616         } else {
1617             char[] exChar = getString(exID).toCharArray();
1618             int[] exInt = new int[exChar.length / 2];
1619             int i = 0;
1620             for (int j = 0; j < exInt.length; j++) {
1621                 exInt[j] = (exChar[i++] << 16) + (exChar[i++] & 0xffff);
1622             }
1623             return exInt;
1624         }
1625     }
1626 
1627     private static boolean contains(short IDs[], short id, int limit) {
1628         for (int i = 0; i < limit; i++) {
1629             if (IDs[i] == id) {
1630                 return true;
1631             }
1632         }
1633         return false;
1634     }
1635 
1636     /* Return the PlatformFontName from its fontID*/
1637     protected static String getComponentFontName(short id) {
1638         if (id < 0) {
1639             return null;
1640         }
1641         return getString(table_componentFontNameIDs[id]);
1642     }
1643 
1644     private static String getComponentFileName(short id) {
1645         if (id < 0) {
1646             return null;
1647         }
1648         return getString(table_fontfileNameIDs[id]);
1649     }
1650 
1651     //componentFontID -> componentFileID
1652     private static short getComponentFileID(short nameID) {
1653         return table_filenames[nameID];
1654     }
1655 
1656     private static String getScriptName(short scriptID) {
1657         return getString(table_scriptIDs[scriptID]);
1658     }
1659 
1660    private HashMap<String, Short> reorderScripts;
1661    protected short[] getCoreScripts(int fontIndex) {
1662         short elc = getInitELC();
1663         /*
1664           System.out.println("getCoreScripts: elc=" + elc + ", fontIndex=" + fontIndex);
1665           short[] ss = getShortArray(table_sequences[elc * NUM_FONTS + fontIndex]);
1666           for (int i = 0; i < ss.length; i++) {
1667               System.out.println("     " + getString((short)table_scriptIDs[ss[i]]));
1668           }
1669           */
1670         short[] scripts = getShortArray(table_sequences[elc * NUM_FONTS + fontIndex]);
1671         if (preferLocaleFonts) {
1672             if (reorderScripts == null) {
1673                 reorderScripts = new HashMap<String, Short>();
1674             }
1675             String[] ss = new String[scripts.length];
1676             for (int i = 0; i < ss.length; i++) {
1677                 ss[i] = getScriptName(scripts[i]);
1678                 reorderScripts.put(ss[i], scripts[i]);
1679             }
1680             reorderSequenceForLocale(ss);
1681             for (int i = 0; i < ss.length; i++) {
1682                 scripts[i] = reorderScripts.get(ss[i]);
1683             }
1684         }
1685          return scripts;
1686     }
1687 
1688     private static short[] getFallbackScripts() {
1689         return getShortArray(head[INDEX_fallbackScripts]);
1690     }
1691 
1692     private static void printTable(short[] list, int start) {
1693         for (int i = start; i < list.length; i++) {
1694             System.out.println("  " + i + " : " + getString(list[i]));
1695         }
1696     }
1697 
1698     private static short[] readShortTable(DataInputStream in, int len )
1699         throws IOException {
1700         if (len == 0) {
1701             return EMPTY_SHORT_ARRAY;
1702         }
1703         short[] data = new short[len];
1704         byte[] bb = new byte[len * 2];
1705         in.read(bb);
1706         int i = 0,j = 0;
1707         while (i < len) {
1708             data[i++] = (short)(bb[j++] << 8 | (bb[j++] & 0xff));
1709         }
1710         return data;
1711     }
1712 
1713     private static void writeShortTable(DataOutputStream out, short[] data)
1714         throws IOException {
1715         for (short val : data) {
1716             out.writeShort(val);
1717         }
1718     }
1719 
1720     private static short[] toList(HashMap<String, Short> map) {
1721         short[] list = new short[map.size()];
1722         Arrays.fill(list, (short) -1);
1723         for (Entry<String, Short> entry : map.entrySet()) {
1724             list[entry.getValue()] = getStringID(entry.getKey());
1725         }
1726         return list;
1727     }
1728 
1729     //runtime cache
1730     private static String[] stringCache;
1731     protected static String getString(short stringID) {
1732         if (stringID == 0)
1733             return null;
1734         /*
1735         if (loadingProperties) {
1736             return stringTable.substring(stringIDs[stringID],
1737                                          stringIDs[stringID+1]);
1738         }
1739         */
1740         //sync if we want it to be MT-enabled
1741         if (stringCache[stringID] == null){
1742             stringCache[stringID] =
1743               new String (table_stringTable,
1744                           table_stringIDs[stringID],
1745                           table_stringIDs[stringID+1] - table_stringIDs[stringID]);
1746         }
1747         return stringCache[stringID];
1748     }
1749 
1750     private static short[] getShortArray(short shortArrayID) {
1751         String s = getString(shortArrayID);
1752         char[] cc = s.toCharArray();
1753         short[] ss = new short[cc.length];
1754         for (int i = 0; i < cc.length; i++) {
1755             ss[i] = (short)(cc[i] & 0xffff);
1756         }
1757         return ss;
1758     }
1759 
1760     private static short getStringID(String s) {
1761         if (s == null) {
1762             return (short)0;
1763         }
1764         short pos0 = (short)stringTable.length();
1765         stringTable.append(s);
1766         short pos1 = (short)stringTable.length();
1767 
1768         stringIDs[stringIDNum] = pos0;
1769         stringIDs[stringIDNum + 1] = pos1;
1770         stringIDNum++;
1771         if (stringIDNum + 1 >= stringIDs.length) {
1772             short[] tmp = new short[stringIDNum + 1000];
1773             System.arraycopy(stringIDs, 0, tmp, 0, stringIDNum);
1774             stringIDs = tmp;
1775         }
1776         return (short)(stringIDNum - 1);
1777     }
1778 
1779     private static short getShortArrayID(short sa[]) {
1780         char[] cc = new char[sa.length];
1781         for (int i = 0; i < sa.length; i ++) {
1782             cc[i] = (char)sa[i];
1783         }
1784         String s = new String(cc);
1785         return getStringID(s);
1786     }
1787 
1788     //utility "empty" objects
1789     private static final int[] EMPTY_INT_ARRAY = new int[0];
1790     private static final String[] EMPTY_STRING_ARRAY = new String[0];
1791     private static final short[] EMPTY_SHORT_ARRAY = new short[0];
1792     private static final String UNDEFINED_COMPONENT_FONT = "unknown";
1793 
1794     //////////////////////////////////////////////////////////////////////////
1795     //Convert the FontConfig data in Properties file to binary data tables  //
1796     //////////////////////////////////////////////////////////////////////////
1797     static class PropertiesHandler {
1798         public void load(InputStream in) throws IOException {
1799             initLogicalNameStyle();
1800             initHashMaps();
1801             FontProperties fp = new FontProperties();
1802             fp.load(in);
1803             initBinaryTable();
1804         }
1805 
1806         private void initBinaryTable() {
1807             //(0)
1808             head = new short[HEAD_LENGTH];
1809             head[INDEX_scriptIDs] = (short)HEAD_LENGTH;
1810 
1811             table_scriptIDs = toList(scriptIDs);
1812             //(1)a: scriptAllfonts scriptID/allfonts -> componentFontNameID
1813             //   b: scriptFonts    scriptID -> componentFontNameID[20]
1814             //if we have a "allfonts.script" def, then we just put
1815             //the "-platformFontID" value in the slot, otherwise the slot
1816             //value is "offset" which "offset" is where 20 entries located
1817             //in the table attached.
1818             head[INDEX_scriptFonts] = (short)(head[INDEX_scriptIDs]  + table_scriptIDs.length);
1819             int len = table_scriptIDs.length + scriptFonts.size() * 20;
1820             table_scriptFonts = new short[len];
1821 
1822             for (Entry<Short, Short> entry : scriptAllfonts.entrySet()) {
1823                 table_scriptFonts[entry.getKey().intValue()] = entry.getValue();
1824             }
1825             int off = table_scriptIDs.length;
1826             for (Entry<Short, Short[]> entry : scriptFonts.entrySet()) {
1827                 table_scriptFonts[entry.getKey().intValue()] = (short)-off;
1828                 Short[] v = entry.getValue();
1829                 for (int i = 0; i < 20; i++) {
1830                     if (v[i] != null) {
1831                         table_scriptFonts[off++] = v[i];
1832                     } else {
1833                         table_scriptFonts[off++] = 0;
1834                     }
1835                 }
1836             }
1837 
1838             //(2)
1839             head[INDEX_elcIDs] = (short)(head[INDEX_scriptFonts]  + table_scriptFonts.length);
1840             table_elcIDs = toList(elcIDs);
1841 
1842             //(3) sequences  elcID -> XXXX[1|5] -> scriptID[]
1843             head[INDEX_sequences] = (short)(head[INDEX_elcIDs]  + table_elcIDs.length);
1844             table_sequences = new short[elcIDs.size() * NUM_FONTS];
1845             for (Entry<Short, short[]> entry : sequences.entrySet()) {
1846                 //table_sequences[entry.getKey().intValue()] = (short)-off;
1847                 int k = entry.getKey().intValue();
1848                 short[] v = entry.getValue();
1849                 /*
1850                   System.out.println("elc=" + k + "/" + getString((short)table_elcIDs[k]));
1851                   short[] ss = getShortArray(v[0]);
1852                   for (int i = 0; i < ss.length; i++) {
1853                   System.out.println("     " + getString((short)table_scriptIDs[ss[i]]));
1854                   }
1855                   */
1856                 if (v.length == 1) {
1857                     //the "allfonts" entries
1858                     for (int i = 0; i < NUM_FONTS; i++) {
1859                         table_sequences[k * NUM_FONTS + i] = v[0];
1860                     }
1861                 } else {
1862                     for (int i = 0; i < NUM_FONTS; i++) {
1863                         table_sequences[k * NUM_FONTS + i] = v[i];
1864                     }
1865                 }
1866             }
1867             //(4)
1868             head[INDEX_fontfileNameIDs] = (short)(head[INDEX_sequences]  + table_sequences.length);
1869             table_fontfileNameIDs = toList(fontfileNameIDs);
1870 
1871             //(5)
1872             head[INDEX_componentFontNameIDs] = (short)(head[INDEX_fontfileNameIDs]  + table_fontfileNameIDs.length);
1873             table_componentFontNameIDs = toList(componentFontNameIDs);
1874 
1875             //(6)componentFontNameID -> filenameID
1876             head[INDEX_filenames] = (short)(head[INDEX_componentFontNameIDs]  + table_componentFontNameIDs.length);
1877             table_filenames = new short[table_componentFontNameIDs.length];
1878             Arrays.fill(table_filenames, (short) -1);
1879 
1880             for (Entry<Short, Short> entry : filenames.entrySet()) {
1881                 table_filenames[entry.getKey()] = entry.getValue();
1882             }
1883 
1884             //(7)scriptID-> awtfontpath
1885             //the paths are stored as scriptID -> stringID in awtfontpahts
1886             head[INDEX_awtfontpaths] = (short)(head[INDEX_filenames]  + table_filenames.length);
1887             table_awtfontpaths = new short[table_scriptIDs.length];
1888             for (Entry<Short, Short> entry : awtfontpaths.entrySet()) {
1889                 table_awtfontpaths[entry.getKey()] = entry.getValue();
1890             }
1891 
1892             //(8)exclusions
1893             head[INDEX_exclusions] = (short)(head[INDEX_awtfontpaths]  + table_awtfontpaths.length);
1894             table_exclusions = new short[scriptIDs.size()];
1895             for (Entry<Short, int[]> entry : exclusions.entrySet()) {
1896                 int[] exI = entry.getValue();
1897                 char[] exC = new char[exI.length * 2];
1898                 int j = 0;
1899                 for (int i = 0; i < exI.length; i++) {
1900                     exC[j++] = (char) (exI[i] >> 16);
1901                     exC[j++] = (char) (exI[i] & 0xffff);
1902                 }
1903                 table_exclusions[entry.getKey()] = getStringID(new String (exC));
1904             }
1905             //(9)proportionals
1906             head[INDEX_proportionals] = (short)(head[INDEX_exclusions]  + table_exclusions.length);
1907             table_proportionals = new short[proportionals.size() * 2];
1908             int j = 0;
1909             for (Entry<Short, Short> entry : proportionals.entrySet()) {
1910                 table_proportionals[j++] = entry.getKey();
1911                 table_proportionals[j++] = entry.getValue();
1912             }
1913 
1914             //(10) see (1) for info, the only difference is "xxx.motif"
1915             head[INDEX_scriptFontsMotif] = (short)(head[INDEX_proportionals] + table_proportionals.length);
1916             if (scriptAllfontsMotif.size() != 0 || scriptFontsMotif.size() != 0) {
1917                 len = table_scriptIDs.length + scriptFontsMotif.size() * 20;
1918                 table_scriptFontsMotif = new short[len];
1919 
1920                 for (Entry<Short, Short> entry : scriptAllfontsMotif.entrySet()) {
1921                     table_scriptFontsMotif[entry.getKey().intValue()] =
1922                       (short)entry.getValue();
1923                 }
1924                 off = table_scriptIDs.length;
1925                 for (Entry<Short, Short[]> entry : scriptFontsMotif.entrySet()) {
1926                     table_scriptFontsMotif[entry.getKey().intValue()] = (short)-off;
1927                     Short[] v = entry.getValue();
1928                     int i = 0;
1929                     while (i < 20) {
1930                         if (v[i] != null) {
1931                             table_scriptFontsMotif[off++] = v[i];
1932                         } else {
1933                             table_scriptFontsMotif[off++] = 0;
1934                         }
1935                         i++;
1936                     }
1937                 }
1938             } else {
1939                 table_scriptFontsMotif = EMPTY_SHORT_ARRAY;
1940             }
1941 
1942             //(11)short[] alphabeticSuffix
1943             head[INDEX_alphabeticSuffix] = (short)(head[INDEX_scriptFontsMotif] + table_scriptFontsMotif.length);
1944             table_alphabeticSuffix = new short[alphabeticSuffix.size() * 2];
1945             j = 0;
1946             for (Entry<Short, Short> entry : alphabeticSuffix.entrySet()) {
1947                 table_alphabeticSuffix[j++] = entry.getKey();
1948                 table_alphabeticSuffix[j++] = entry.getValue();
1949             }
1950 
1951             //(15)short[] fallbackScriptIDs; just put the ID in head
1952             head[INDEX_fallbackScripts] = getShortArrayID(fallbackScriptIDs);
1953 
1954             //(16)appendedfontpath
1955             head[INDEX_appendedfontpath] = getStringID(appendedfontpath);
1956 
1957             //(17)version
1958             head[INDEX_version] = getStringID(version);
1959 
1960             //(12)short[] StringIDs
1961             head[INDEX_stringIDs] = (short)(head[INDEX_alphabeticSuffix] + table_alphabeticSuffix.length);
1962             table_stringIDs = new short[stringIDNum + 1];
1963             System.arraycopy(stringIDs, 0, table_stringIDs, 0, stringIDNum + 1);
1964 
1965             //(13)StringTable
1966             head[INDEX_stringTable] = (short)(head[INDEX_stringIDs] + stringIDNum + 1);
1967             table_stringTable = stringTable.toString().toCharArray();
1968             //(14)
1969             head[INDEX_TABLEEND] = (short)(head[INDEX_stringTable] + stringTable.length());
1970 
1971             //StringTable cache
1972             stringCache = new String[table_stringIDs.length];
1973         }
1974 
1975         //////////////////////////////////////////////
1976         private HashMap<String, Short> scriptIDs;
1977         //elc -> Encoding.Language.Country
1978         private HashMap<String, Short> elcIDs;
1979         //componentFontNameID starts from "1", "0" reserves for "undefined"
1980         private HashMap<String, Short> componentFontNameIDs;
1981         private HashMap<String, Short> fontfileNameIDs;
1982         private HashMap<String, Integer> logicalFontIDs;
1983         private HashMap<String, Integer> fontStyleIDs;
1984 
1985         //componentFontNameID -> fontfileNameID
1986         private HashMap<Short, Short>  filenames;
1987 
1988         //elcID -> allfonts/logicalFont -> scriptID list
1989         //(1)if we have a "allfonts", then the length of the
1990         //   value array is "1", otherwise it's 5, each font
1991         //   must have their own individual entry.
1992         //scriptID list "short[]" is stored as an ID
1993         private HashMap<Short, short[]> sequences;
1994 
1995         //scriptID ->logicFontID/fontStyleID->componentFontNameID,
1996         //a 20-entry array (5-name x 4-style) for each script
1997         private HashMap<Short, Short[]> scriptFonts;
1998 
1999         //scriptID -> componentFontNameID
2000         private HashMap<Short, Short> scriptAllfonts;
2001 
2002         //scriptID -> exclusionRanges[]
2003         private HashMap<Short, int[]> exclusions;
2004 
2005         //scriptID -> fontpath
2006         private HashMap<Short, Short> awtfontpaths;
2007 
2008         //fontID -> fontID
2009         private HashMap<Short, Short> proportionals;
2010 
2011         //scriptID -> componentFontNameID
2012         private HashMap<Short, Short> scriptAllfontsMotif;
2013 
2014         //scriptID ->logicFontID/fontStyleID->componentFontNameID,
2015         private HashMap<Short, Short[]> scriptFontsMotif;
2016 
2017         //elcID -> stringID of alphabetic/XXXX
2018         private HashMap<Short, Short> alphabeticSuffix;
2019 
2020         private short[] fallbackScriptIDs;
2021         private String version;
2022         private String appendedfontpath;
2023 
2024         private void initLogicalNameStyle() {
2025             logicalFontIDs = new HashMap<String, Integer>();
2026             fontStyleIDs = new HashMap<String, Integer>();
2027             logicalFontIDs.put("serif",      0);
2028             logicalFontIDs.put("sansserif",  1);
2029             logicalFontIDs.put("monospaced", 2);
2030             logicalFontIDs.put("dialog",     3);
2031             logicalFontIDs.put("dialoginput",4);
2032             fontStyleIDs.put("plain",      0);
2033             fontStyleIDs.put("bold",       1);
2034             fontStyleIDs.put("italic",     2);
2035             fontStyleIDs.put("bolditalic", 3);
2036         }
2037 
2038         private void initHashMaps() {
2039             scriptIDs = new HashMap<String, Short>();
2040             elcIDs = new HashMap<String, Short>();
2041             componentFontNameIDs = new HashMap<String, Short>();
2042             /*Init these tables to allow componentFontNameID, fontfileNameIDs
2043               to start from "1".
2044             */
2045             componentFontNameIDs.put("", Short.valueOf((short)0));
2046 
2047             fontfileNameIDs = new HashMap<String, Short>();
2048             filenames = new HashMap<Short, Short>();
2049             sequences = new HashMap<Short, short[]>();
2050             scriptFonts = new HashMap<Short, Short[]>();
2051             scriptAllfonts = new HashMap<Short, Short>();
2052             exclusions = new HashMap<Short, int[]>();
2053             awtfontpaths = new HashMap<Short, Short>();
2054             proportionals = new HashMap<Short, Short>();
2055             scriptFontsMotif = new HashMap<Short, Short[]>();
2056             scriptAllfontsMotif = new HashMap<Short, Short>();
2057             alphabeticSuffix = new HashMap<Short, Short>();
2058             fallbackScriptIDs = EMPTY_SHORT_ARRAY;
2059             /*
2060               version
2061               appendedfontpath
2062             */
2063         }
2064 
2065         private int[] parseExclusions(String key, String exclusions) {
2066             if (exclusions == null) {
2067                 return EMPTY_INT_ARRAY;
2068             }
2069             // range format is xxxx-XXXX,yyyyyy-YYYYYY,.....
2070             int numExclusions = 1;
2071             int pos = 0;
2072             while ((pos = exclusions.indexOf(',', pos)) != -1) {
2073                 numExclusions++;
2074                 pos++;
2075             }
2076             int[] exclusionRanges = new int[numExclusions * 2];
2077             pos = 0;
2078             int newPos = 0;
2079             for (int j = 0; j < numExclusions * 2; ) {
2080                 String lower, upper;
2081                 int lo = 0, up = 0;
2082                 try {
2083                     newPos = exclusions.indexOf('-', pos);
2084                     lower = exclusions.substring(pos, newPos);
2085                     pos = newPos + 1;
2086                     newPos = exclusions.indexOf(',', pos);
2087                     if (newPos == -1) {
2088                         newPos = exclusions.length();
2089                     }
2090                     upper = exclusions.substring(pos, newPos);
2091                     pos = newPos + 1;
2092                     int lowerLength = lower.length();
2093                     int upperLength = upper.length();
2094                     if (lowerLength != 4 && lowerLength != 6
2095                         || upperLength != 4 && upperLength != 6) {
2096                         throw new Exception();
2097                     }
2098                     lo = Integer.parseInt(lower, 16);
2099                     up = Integer.parseInt(upper, 16);
2100                     if (lo > up) {
2101                         throw new Exception();
2102                     }
2103                 } catch (Exception e) {
2104                     if (FontUtilities.debugFonts() &&
2105                         logger != null) {
2106                         logger.config("Failed parsing " + key +
2107                                   " property of font configuration.");
2108 
2109                     }
2110                     return EMPTY_INT_ARRAY;
2111                 }
2112                 exclusionRanges[j++] = lo;
2113                 exclusionRanges[j++] = up;
2114             }
2115             return exclusionRanges;
2116         }
2117 
2118         private Short getID(HashMap<String, Short> map, String key) {
2119             Short ret = map.get(key);
2120             if ( ret == null) {
2121                 map.put(key, (short)map.size());
2122                 return map.get(key);
2123             }
2124             return ret;
2125         }
2126 
2127         @SuppressWarnings("serial") // JDK-implementation class
2128         class FontProperties extends Properties {
2129             public synchronized Object put(Object k, Object v) {
2130                 parseProperty((String)k, (String)v);
2131                 return null;
2132             }
2133         }
2134 
2135         private void parseProperty(String key, String value) {
2136             if (key.startsWith("filename.")) {
2137                 //the only special case is "MingLiu_HKSCS" which has "_" in its
2138                 //facename, we don't want to replace the "_" with " "
2139                 key = key.substring(9);
2140                 if (!"MingLiU_HKSCS".equals(key)) {
2141                     key = key.replace('_', ' ');
2142                 }
2143                 Short faceID = getID(componentFontNameIDs, key);
2144                 Short fileID = getID(fontfileNameIDs, value);
2145                 //System.out.println("faceID=" + faceID + "/" + key + " -> "
2146                 //    + "fileID=" + fileID + "/" + value);
2147                 filenames.put(faceID, fileID);
2148             } else if (key.startsWith("exclusion.")) {
2149                 key = key.substring(10);
2150                 exclusions.put(getID(scriptIDs,key), parseExclusions(key,value));
2151             } else if (key.startsWith("sequence.")) {
2152                 key = key.substring(9);
2153                 boolean hasDefault = false;
2154                 boolean has1252 = false;
2155 
2156                 //get the scriptID list
2157                 String[] ss = splitSequence(value).toArray(EMPTY_STRING_ARRAY);
2158                 short [] sa = new short[ss.length];
2159                 for (int i = 0; i < ss.length; i++) {
2160                     if ("alphabetic/default".equals(ss[i])) {
2161                         //System.out.println(key + " -> " + ss[i]);
2162                         ss[i] = "alphabetic";
2163                         hasDefault = true;
2164                     } else if ("alphabetic/1252".equals(ss[i])) {
2165                         //System.out.println(key + " -> " + ss[i]);
2166                         ss[i] = "alphabetic";
2167                         has1252 = true;
2168                     }
2169                     sa[i] = getID(scriptIDs, ss[i]).shortValue();
2170                     //System.out.println("scriptID=" + si[i] + "/" + ss[i]);
2171                 }
2172                 //convert the "short[] -> string -> stringID"
2173                 short scriptArrayID = getShortArrayID(sa);
2174                 Short elcID = null;
2175                 int dot = key.indexOf('.');
2176                 if (dot == -1) {
2177                     if ("fallback".equals(key)) {
2178                         fallbackScriptIDs = sa;
2179                         return;
2180                     }
2181                     if ("allfonts".equals(key)) {
2182                         elcID = getID(elcIDs, "NULL.NULL.NULL");
2183                     } else {
2184                         if (logger != null) {
2185                             logger.config("Error sequence def: <sequence." + key + ">");
2186                         }
2187                         return;
2188                     }
2189                 } else {
2190                     elcID = getID(elcIDs, key.substring(dot + 1));
2191                     //System.out.println("elcID=" + elcID + "/" + key.substring(dot + 1));
2192                     key = key.substring(0, dot);
2193                 }
2194                 short[] scriptArrayIDs = null;
2195                 if ("allfonts".equals(key)) {
2196                     scriptArrayIDs = new short[1];
2197                     scriptArrayIDs[0] = scriptArrayID;
2198                 } else {
2199                     scriptArrayIDs = sequences.get(elcID);
2200                     if (scriptArrayIDs == null) {
2201                        scriptArrayIDs = new short[5];
2202                     }
2203                     Integer fid = logicalFontIDs.get(key);
2204                     if (fid == null) {
2205                         if (logger != null) {
2206                             logger.config("Unrecognizable logicfont name " + key);
2207                         }
2208                         return;
2209                     }
2210                     //System.out.println("sequence." + key + "/" + id);
2211                     scriptArrayIDs[fid.intValue()] = scriptArrayID;
2212                 }
2213                 sequences.put(elcID, scriptArrayIDs);
2214                 if (hasDefault) {
2215                     alphabeticSuffix.put(elcID, getStringID("default"));
2216                 } else
2217                 if (has1252) {
2218                     alphabeticSuffix.put(elcID, getStringID("1252"));
2219                 }
2220             } else if (key.startsWith("allfonts.")) {
2221                 key = key.substring(9);
2222                 if (key.endsWith(".motif")) {
2223                     key = key.substring(0, key.length() - 6);
2224                     //System.out.println("motif: all." + key + "=" + value);
2225                     scriptAllfontsMotif.put(getID(scriptIDs,key), getID(componentFontNameIDs,value));
2226                 } else {
2227                     scriptAllfonts.put(getID(scriptIDs,key), getID(componentFontNameIDs,value));
2228                 }
2229             } else if (key.startsWith("awtfontpath.")) {
2230                 key = key.substring(12);
2231                 //System.out.println("scriptID=" + getID(scriptIDs, key) + "/" + key);
2232                 awtfontpaths.put(getID(scriptIDs, key), getStringID(value));
2233             } else if ("version".equals(key)) {
2234                 version = value;
2235             } else if ("appendedfontpath".equals(key)) {
2236                 appendedfontpath = value;
2237             } else if (key.startsWith("proportional.")) {
2238                 key = key.substring(13).replace('_', ' ');
2239                 //System.out.println(key + "=" + value);
2240                 proportionals.put(getID(componentFontNameIDs, key),
2241                                   getID(componentFontNameIDs, value));
2242             } else {
2243                 //"name.style.script(.motif)", we don't care anything else
2244                 int dot1, dot2;
2245                 boolean isMotif = false;
2246 
2247                 dot1 = key.indexOf('.');
2248                 if (dot1 == -1) {
2249                     if (logger != null) {
2250                         logger.config("Failed parsing " + key +
2251                                   " property of font configuration.");
2252 
2253                     }
2254                     return;
2255                 }
2256                 dot2 = key.indexOf('.', dot1 + 1);
2257                 if (dot2 == -1) {
2258                     if (logger != null) {
2259                         logger.config("Failed parsing " + key +
2260                                   " property of font configuration.");
2261 
2262                     }
2263                     return;
2264                 }
2265                 if (key.endsWith(".motif")) {
2266                     key = key.substring(0, key.length() - 6);
2267                     isMotif = true;
2268                     //System.out.println("motif: " + key + "=" + value);
2269                 }
2270                 Integer nameID = logicalFontIDs.get(key.substring(0, dot1));
2271                 Integer styleID = fontStyleIDs.get(key.substring(dot1+1, dot2));
2272                 Short scriptID = getID(scriptIDs, key.substring(dot2 + 1));
2273                 if (nameID == null || styleID == null) {
2274                     if (logger != null) {
2275                         logger.config("unrecognizable logicfont name/style at " + key);
2276                     }
2277                     return;
2278                 }
2279                 Short[] pnids;
2280                 if (isMotif) {
2281                     pnids = scriptFontsMotif.get(scriptID);
2282                 } else {
2283                     pnids = scriptFonts.get(scriptID);
2284                 }
2285                 if (pnids == null) {
2286                     pnids =  new Short[20];
2287                 }
2288                 pnids[nameID.intValue() * NUM_STYLES + styleID.intValue()]
2289                   = getID(componentFontNameIDs, value);
2290                 /*
2291                 System.out.println("key=" + key + "/<" + nameID + "><" + styleID
2292                                      + "><" + scriptID + ">=" + value
2293                                      + "/" + getID(componentFontNameIDs, value));
2294                 */
2295                 if (isMotif) {
2296                     scriptFontsMotif.put(scriptID, pnids);
2297                 } else {
2298                     scriptFonts.put(scriptID, pnids);
2299                 }
2300             }
2301         }
2302     }
2303 }
--- EOF ---