pdftops/GlobalParams.cxx

   1 //========================================================================
   2 //
   3 // GlobalParams.cc
   4 //
   5 // Copyright 2001-2003 Glyph & Cog, LLC
   6 //
   7 //========================================================================
   8
   9 #include <config.h>
  10
  11 #ifdef USE_GCC_PRAGMAS
  12 #pragma implementation
  13 #endif
  14
  15 #include <string.h>
  16 #include <stdio.h>
  17 #include <ctype.h>
  18 #ifdef ENABLE_PLUGINS
  19 #  ifndef WIN32
  20 #    include <dlfcn.h>
  21 #  endif
  22 #endif
  23 #ifdef WIN32
  24 #  include <shlobj.h>
  25 #endif
  26 #if HAVE_PAPER_H
  27 #include <paper.h>
  28 #endif
  29 #include "gmem.h"
  30 #include "GString.h"
  31 #include "GList.h"
  32 #include "GHash.h"
  33 #include "gfile.h"
  34 #include "Error.h"
  35 #include "NameToCharCode.h"
  36 #include "CharCodeToUnicode.h"
  37 #include "UnicodeMap.h"
  38 #include "CMap.h"
  39 #include "BuiltinFontTables.h"
  40 #include "FontEncodingTables.h"
  41 #ifdef ENABLE_PLUGINS
  42 #  include "XpdfPluginAPI.h"
  43 #endif
  44 #include "GlobalParams.h"
  45
  46 #if MULTITHREADED
  47 #  define lockGlobalParams            gLockMutex(&mutex)
  48 #  define lockUnicodeMapCache         gLockMutex(&unicodeMapCacheMutex)
  49 #  define lockCMapCache               gLockMutex(&cMapCacheMutex)
  50 #  define unlockGlobalParams          gUnlockMutex(&mutex)
  51 #  define unlockUnicodeMapCache       gUnlockMutex(&unicodeMapCacheMutex)
  52 #  define unlockCMapCache             gUnlockMutex(&cMapCacheMutex)
  53 #else
  54 #  define lockGlobalParams
  55 #  define lockUnicodeMapCache
  56 #  define lockCMapCache
  57 #  define unlockGlobalParams
  58 #  define unlockUnicodeMapCache
  59 #  define unlockCMapCache
  60 #endif
  61
  62 #include "NameToUnicodeTable.h"
  63 #include "UnicodeMapTables.h"
  64 #include "UTF8.h"
  65
  66 #ifdef ENABLE_PLUGINS
  67 #  ifdef WIN32
  68 extern XpdfPluginVecTable xpdfPluginVecTable;
  69 #  endif
  70 #endif
  71
  72 //------------------------------------------------------------------------
  73
  74 #define cidToUnicodeCacheSize     4
  75 #define unicodeToUnicodeCacheSize 4
  76
  77 //------------------------------------------------------------------------
  78
  79 static struct {
  80   char *name;
  81   char *t1FileName;
  82   char *ttFileName;
  83 } displayFontTab[] = {
  84   {"Courier",               "n022003l.pfb", "cour.ttf"},
  85   {"Courier-Bold",          "n022004l.pfb", "courbd.ttf"},
  86   {"Courier-BoldOblique",   "n022024l.pfb", "courbi.ttf"},
  87   {"Courier-Oblique",       "n022023l.pfb", "couri.ttf"},
  88   {"Helvetica",             "n019003l.pfb", "arial.ttf"},
  89   {"Helvetica-Bold",        "n019004l.pfb", "arialbd.ttf"},
  90   {"Helvetica-BoldOblique", "n019024l.pfb", "arialbi.ttf"},
  91   {"Helvetica-Oblique",     "n019023l.pfb", "ariali.ttf"},
  92   {"Symbol",                "s050000l.pfb", NULL},
  93   {"Times-Bold",            "n021004l.pfb", "timesbd.ttf"},
  94   {"Times-BoldItalic",      "n021024l.pfb", "timesbi.ttf"},
  95   {"Times-Italic",          "n021023l.pfb", "timesi.ttf"},
  96   {"Times-Roman",           "n021003l.pfb", "times.ttf"},
  97   {"ZapfDingbats",          "d050000l.pfb", NULL},
  98   {NULL}
  99 };
 100
 101 #ifdef WIN32
 102 static char *displayFontDirs[] = {
 103   "c:/windows/fonts",
 104   "c:/winnt/fonts",
 105   NULL
 106 };
 107 #else
 108 static char *displayFontDirs[] = {
 109   "/usr/share/ghostscript/fonts",
 110   "/usr/local/share/ghostscript/fonts",
 111   "/usr/share/fonts/default/Type1",
 112   "/usr/share/fonts/default/ghostscript",
 113   "/usr/share/fonts/type1/gsfonts",
 114   NULL
 115 };
 116 #endif
 117
 118 //------------------------------------------------------------------------
 119
 120 GlobalParams *globalParams = NULL;
 121
 122 //------------------------------------------------------------------------
 123 // DisplayFontParam
 124 //------------------------------------------------------------------------
 125
 126 DisplayFontParam::DisplayFontParam(GString *nameA,
 127                                    DisplayFontParamKind kindA) {
 128   name = nameA;
 129   kind = kindA;
 130   switch (kind) {
 131   case displayFontT1:
 132     t1.fileName = NULL;
 133     break;
 134   case displayFontTT:
 135     tt.fileName = NULL;
 136     break;
 137   }
 138 }
 139
 140 DisplayFontParam::~DisplayFontParam() {
 141   delete name;
 142   switch (kind) {
 143   case displayFontT1:
 144     if (t1.fileName) {
 145       delete t1.fileName;
 146     }
 147     break;
 148   case displayFontTT:
 149     if (tt.fileName) {
 150       delete tt.fileName;
 151     }
 152     break;
 153   }
 154 }
 155
 156 //------------------------------------------------------------------------
 157 // PSFontParam
 158 //------------------------------------------------------------------------
 159
 160 PSFontParam::PSFontParam(GString *pdfFontNameA, int wModeA,
 161                          GString *psFontNameA, GString *encodingA) {
 162   pdfFontName = pdfFontNameA;
 163   wMode = wModeA;
 164   psFontName = psFontNameA;
 165   encoding = encodingA;
 166 }
 167
 168 PSFontParam::~PSFontParam() {
 169   delete pdfFontName;
 170   delete psFontName;
 171   if (encoding) {
 172     delete encoding;
 173   }
 174 }
 175
 176 #ifdef ENABLE_PLUGINS
 177 //------------------------------------------------------------------------
 178 // Plugin
 179 //------------------------------------------------------------------------
 180
 181 class Plugin {
 182 public:
 183
 184   static Plugin *load(char *type, char *name);
 185   ~Plugin();
 186
 187 private:
 188
 189 #ifdef WIN32
 190   Plugin(HMODULE libA);
 191   HMODULE lib;
 192 #else
 193   Plugin(void *dlA);
 194   void *dl;
 195 #endif
 196 };
 197
 198 Plugin *Plugin::load(char *type, char *name) {
 199   GString *path;
 200   Plugin *plugin;
 201   XpdfPluginVecTable *vt;
 202   XpdfBool (*xpdfInitPlugin)(void);
 203 #ifdef WIN32
 204   HMODULE libA;
 205 #else
 206   void *dlA;
 207 #endif
 208
 209   path = globalParams->getBaseDir();
 210   appendToPath(path, "plugins");
 211   appendToPath(path, type);
 212   appendToPath(path, name);
 213
 214 #ifdef WIN32
 215   path->append(".dll");
 216   if (!(libA = LoadLibrary(path->getCString()))) {
 217     error(-1, "Failed to load plugin '%s'",
 218           path->getCString());
 219     goto err1;
 220   }
 221   if (!(vt = (XpdfPluginVecTable *)
 222                  GetProcAddress(libA, "xpdfPluginVecTable"))) {
 223     error(-1, "Failed to find xpdfPluginVecTable in plugin '%s'",
 224           path->getCString());
 225     goto err2;
 226   }
 227 #else
 228   //~ need to deal with other extensions here
 229   path->append(".so");
 230   if (!(dlA = dlopen(path->getCString(), RTLD_NOW))) {
 231     error(-1, "Failed to load plugin '%s': %s",
 232           path->getCString(), dlerror());
 233     goto err1;
 234   }
 235   if (!(vt = (XpdfPluginVecTable *)dlsym(dlA, "xpdfPluginVecTable"))) {
 236     error(-1, "Failed to find xpdfPluginVecTable in plugin '%s'",
 237           path->getCString());
 238     goto err2;
 239   }
 240 #endif
 241
 242   if (vt->version != xpdfPluginVecTable.version) {
 243     error(-1, "Plugin '%s' is wrong version", path->getCString());
 244     goto err2;
 245   }
 246   memcpy(vt, &xpdfPluginVecTable, sizeof(xpdfPluginVecTable));
 247
 248 #ifdef WIN32
 249   if (!(xpdfInitPlugin = (XpdfBool (*)(void))
 250                              GetProcAddress(libA, "xpdfInitPlugin"))) {
 251     error(-1, "Failed to find xpdfInitPlugin in plugin '%s'",
 252           path->getCString());
 253     goto err2;
 254   }
 255 #else
 256   if (!(xpdfInitPlugin = (XpdfBool (*)(void))dlsym(dlA, "xpdfInitPlugin"))) {
 257     error(-1, "Failed to find xpdfInitPlugin in plugin '%s'",
 258           path->getCString());
 259     goto err2;
 260   }
 261 #endif
 262
 263   if (!(*xpdfInitPlugin)()) {
 264     error(-1, "Initialization of plugin '%s' failed",
 265           path->getCString());
 266     goto err2;
 267   }
 268
 269 #ifdef WIN32
 270   plugin = new Plugin(libA);
 271 #else
 272   plugin = new Plugin(dlA);
 273 #endif
 274
 275   delete path;
 276   return plugin;
 277
 278  err2:
 279 #ifdef WIN32
 280   FreeLibrary(libA);
 281 #else
 282   dlclose(dlA);
 283 #endif
 284  err1:
 285   delete path;
 286   return NULL;
 287 }
 288
 289 #ifdef WIN32
 290 Plugin::Plugin(HMODULE libA) {
 291   lib = libA;
 292 }
 293 #else
 294 Plugin::Plugin(void *dlA) {
 295   dl = dlA;
 296 }
 297 #endif
 298
 299 Plugin::~Plugin() {
 300   void (*xpdfFreePlugin)(void);
 301
 302 #ifdef WIN32
 303   if ((xpdfFreePlugin = (void (*)(void))
 304                             GetProcAddress(lib, "xpdfFreePlugin"))) {
 305     (*xpdfFreePlugin)();
 306   }
 307   FreeLibrary(lib);
 308 #else
 309   if ((xpdfFreePlugin = (void (*)(void))dlsym(dl, "xpdfFreePlugin"))) {
 310     (*xpdfFreePlugin)();
 311   }
 312   dlclose(dl);
 313 #endif
 314 }
 315
 316 #endif // ENABLE_PLUGINS
 317
 318 //------------------------------------------------------------------------
 319 // parsing
 320 //------------------------------------------------------------------------
 321
 322 GlobalParams::GlobalParams(char *cfgFileName) {
 323   UnicodeMap *map;
 324   GString *fileName;
 325   FILE *f;
 326   int i;
 327
 328 #if MULTITHREADED
 329   gInitMutex(&mutex);
 330   gInitMutex(&unicodeMapCacheMutex);
 331   gInitMutex(&cMapCacheMutex);
 332 #endif
 333
 334   initBuiltinFontTables();
 335
 336   // scan the encoding in reverse because we want the lowest-numbered
 337   // index for each char name ('space' is encoded twice)
 338   macRomanReverseMap = new NameToCharCode();
 339   for (i = 255; i >= 0; --i) {
 340     if (macRomanEncoding[i]) {
 341       macRomanReverseMap->add(macRomanEncoding[i], (CharCode)i);
 342     }
 343   }
 344
 345 #ifdef WIN32
 346   // baseDir will be set by a call to setBaseDir
 347   baseDir = new GString();
 348 #else
 349   baseDir = appendToPath(getHomeDir(), ".xpdf");
 350 #endif
 351   nameToUnicode = new NameToCharCode();
 352   cidToUnicodes = new GHash(gTrue);
 353   unicodeToUnicodes = new GHash(gTrue);
 354   residentUnicodeMaps = new GHash();
 355   unicodeMaps = new GHash(gTrue);
 356   cMapDirs = new GHash(gTrue);
 357   toUnicodeDirs = new GList();
 358   displayFonts = new GHash();
 359   displayCIDFonts = new GHash();
 360   displayNamedCIDFonts = new GHash();
 361 #if HAVE_PAPER_H
 362   char *paperName;
 363   const struct paper *paperType;
 364   paperinit();
 365   if ((paperName = systempapername())) {
 366     paperType = paperinfo(paperName);
 367     psPaperWidth = (int)paperpswidth(paperType);
 368     psPaperHeight = (int)paperpsheight(paperType);
 369   } else {
 370     error(-1, "No paper information available - using defaults");
 371     psPaperWidth = defPaperWidth;
 372     psPaperHeight = defPaperHeight;
 373   }
 374   paperdone();
 375 #else
 376   psPaperWidth = defPaperWidth;
 377   psPaperHeight = defPaperHeight;
 378 #endif
 379   psImageableLLX = psImageableLLY = 0;
 380   psImageableURX = psPaperWidth;
 381   psImageableURY = psPaperHeight;
 382   psCrop = gTrue;
 383   psExpandSmaller = gFalse;
 384   psShrinkLarger = gTrue;
 385   psCenter = gTrue;
 386   psDuplex = gFalse;
 387   psLevel = psLevel2;
 388   psFile = NULL;
 389   psFonts = new GHash();
 390   psNamedFonts16 = new GList();
 391   psFonts16 = new GList();
 392   psEmbedType1 = gTrue;
 393   psEmbedTrueType = gTrue;
 394   psEmbedCIDPostScript = gTrue;
 395   psEmbedCIDTrueType = gTrue;
 396   psOPI = gFalse;
 397   psASCIIHex = gFalse;
 398   textEncoding = new GString("Latin1");
 399 #if defined(WIN32)
 400   textEOL = eolDOS;
 401 #elif defined(MACOS)
 402   textEOL = eolMac;
 403 #else
 404   textEOL = eolUnix;
 405 #endif
 406   textPageBreaks = gTrue;
 407   textKeepTinyChars = gFalse;
 408   fontDirs = new GList();
 409   initialZoom = new GString("125");
 410   continuousView = gFalse;
 411   enableT1lib = gTrue;
 412   enableFreeType = gTrue;
 413   antialias = gTrue;
 414   urlCommand = NULL;
 415   movieCommand = NULL;
 416   mapNumericCharNames = gTrue;
 417   printCommands = gFalse;
 418   errQuiet = gFalse;
 419
 420   cidToUnicodeCache = new CharCodeToUnicodeCache(cidToUnicodeCacheSize);
 421   unicodeToUnicodeCache =
 422       new CharCodeToUnicodeCache(unicodeToUnicodeCacheSize);
 423   unicodeMapCache = new UnicodeMapCache();
 424   cMapCache = new CMapCache();
 425
 426 #ifdef ENABLE_PLUGINS
 427   plugins = new GList();
 428   securityHandlers = new GList();
 429 #endif
 430
 431   // set up the initial nameToUnicode table
 432   for (i = 0; nameToUnicodeTab[i].name; ++i) {
 433     nameToUnicode->add(nameToUnicodeTab[i].name, nameToUnicodeTab[i].u);
 434   }
 435
 436   // set up the residentUnicodeMaps table
 437   map = new UnicodeMap("Latin1", gFalse,
 438                        latin1UnicodeMapRanges, latin1UnicodeMapLen);
 439   residentUnicodeMaps->add(map->getEncodingName(), map);
 440   map = new UnicodeMap("ASCII7", gFalse,
 441                        ascii7UnicodeMapRanges, ascii7UnicodeMapLen);
 442   residentUnicodeMaps->add(map->getEncodingName(), map);
 443   map = new UnicodeMap("Symbol", gFalse,
 444                        symbolUnicodeMapRanges, symbolUnicodeMapLen);
 445   residentUnicodeMaps->add(map->getEncodingName(), map);
 446   map = new UnicodeMap("ZapfDingbats", gFalse, zapfDingbatsUnicodeMapRanges,
 447                        zapfDingbatsUnicodeMapLen);
 448   residentUnicodeMaps->add(map->getEncodingName(), map);
 449   map = new UnicodeMap("UTF-8", gTrue, &mapUTF8);
 450   residentUnicodeMaps->add(map->getEncodingName(), map);
 451   map = new UnicodeMap("UCS-2", gTrue, &mapUCS2);
 452   residentUnicodeMaps->add(map->getEncodingName(), map);
 453
 454   // look for a user config file, then a system-wide config file
 455   f = NULL;
 456   fileName = NULL;
 457   if (cfgFileName && cfgFileName[0]) {
 458     fileName = new GString(cfgFileName);
 459     if (!(f = fopen(fileName->getCString(), "r"))) {
 460       delete fileName;
 461     }
 462   }
 463   if (!f) {
 464     fileName = appendToPath(getHomeDir(), xpdfUserConfigFile);
 465     if (!(f = fopen(fileName->getCString(), "r"))) {
 466       delete fileName;
 467     }
 468   }
 469   if (!f) {
 470 #if defined(WIN32) && !defined(__CYGWIN32__)
 471     char buf[512];
 472     i = GetModuleFileName(NULL, buf, sizeof(buf));
 473     if (i <= 0 || i >= sizeof(buf)) {
 474       // error or path too long for buffer - just use the current dir
 475       buf[0] = '\0';
 476     }
 477     fileName = grabPath(buf);
 478     appendToPath(fileName, xpdfSysConfigFile);
 479 #else
 480     fileName = new GString(xpdfSysConfigFile);
 481 #endif
 482     if (!(f = fopen(fileName->getCString(), "r"))) {
 483       delete fileName;
 484     }
 485   }
 486   if (f) {
 487     parseFile(fileName, f);
 488     delete fileName;
 489     fclose(f);
 490   }
 491 }
 492
 493 void GlobalParams::parseFile(GString *fileName, FILE *f) {
 494   int line;
 495   GList *tokens;
 496   GString *cmd, *incFile;
 497   char *p1, *p2;
 498   char buf[512];
 499   FILE *f2;
 500
 501   line = 1;
 502   while (getLine(buf, sizeof(buf) - 1, f)) {
 503
 504     // break the line into tokens
 505     tokens = new GList();
 506     p1 = buf;
 507     while (*p1) {
 508       for (; *p1 && isspace(*p1); ++p1) ;
 509       if (!*p1) {
 510         break;
 511       }
 512       if (*p1 == '"' || *p1 == '\'') {
 513         for (p2 = p1 + 1; *p2 && *p2 != *p1; ++p2) ;
 514         ++p1;
 515       } else {
 516         for (p2 = p1 + 1; *p2 && !isspace(*p2); ++p2) ;
 517       }
 518       tokens->append(new GString(p1, p2 - p1));
 519       p1 = *p2 ? p2 + 1 : p2;
 520     }
 521
 522     if (tokens->getLength() > 0 &&
 523         ((GString *)tokens->get(0))->getChar(0) != '#') {
 524       cmd = (GString *)tokens->get(0);
 525       if (!cmd->cmp("include")) {
 526         if (tokens->getLength() == 2) {
 527           incFile = (GString *)tokens->get(1);
 528           if ((f2 = fopen(incFile->getCString(), "r"))) {
 529             parseFile(incFile, f2);
 530             fclose(f2);
 531           } else {
 532             error(-1, "Couldn't find included config file: '%s' (%s:%d)",
 533                   incFile->getCString(), fileName->getCString(), line);
 534           }
 535         } else {
 536           error(-1, "Bad 'include' config file command (%s:%d)",
 537                 fileName->getCString(), line);
 538         }
 539       } else if (!cmd->cmp("nameToUnicode")) {
 540         parseNameToUnicode(tokens, fileName, line);
 541       } else if (!cmd->cmp("cidToUnicode")) {
 542         parseCIDToUnicode(tokens, fileName, line);
 543       } else if (!cmd->cmp("unicodeToUnicode")) {
 544         parseUnicodeToUnicode(tokens, fileName, line);
 545       } else if (!cmd->cmp("unicodeMap")) {
 546         parseUnicodeMap(tokens, fileName, line);
 547       } else if (!cmd->cmp("cMapDir")) {
 548         parseCMapDir(tokens, fileName, line);
 549       } else if (!cmd->cmp("toUnicodeDir")) {
 550         parseToUnicodeDir(tokens, fileName, line);
 551       } else if (!cmd->cmp("displayFontT1")) {
 552         parseDisplayFont(tokens, displayFonts, displayFontT1, fileName, line);
 553       } else if (!cmd->cmp("displayFontTT")) {
 554         parseDisplayFont(tokens, displayFonts, displayFontTT, fileName, line);
 555       } else if (!cmd->cmp("displayNamedCIDFontT1")) {
 556         parseDisplayFont(tokens, displayNamedCIDFonts,
 557                          displayFontT1, fileName, line);
 558       } else if (!cmd->cmp("displayCIDFontT1")) {
 559         parseDisplayFont(tokens, displayCIDFonts,
 560                          displayFontT1, fileName, line);
 561       } else if (!cmd->cmp("displayNamedCIDFontTT")) {
 562         parseDisplayFont(tokens, displayNamedCIDFonts,
 563                          displayFontTT, fileName, line);
 564       } else if (!cmd->cmp("displayCIDFontTT")) {
 565         parseDisplayFont(tokens, displayCIDFonts,
 566                          displayFontTT, fileName, line);
 567       } else if (!cmd->cmp("psFile")) {
 568         parsePSFile(tokens, fileName, line);
 569       } else if (!cmd->cmp("psFont")) {
 570         parsePSFont(tokens, fileName, line);
 571       } else if (!cmd->cmp("psNamedFont16")) {
 572         parsePSFont16("psNamedFont16", psNamedFonts16,
 573                       tokens, fileName, line);
 574       } else if (!cmd->cmp("psFont16")) {
 575         parsePSFont16("psFont16", psFonts16, tokens, fileName, line);
 576       } else if (!cmd->cmp("psPaperSize")) {
 577         parsePSPaperSize(tokens, fileName, line);
 578       } else if (!cmd->cmp("psImageableArea")) {
 579         parsePSImageableArea(tokens, fileName, line);
 580       } else if (!cmd->cmp("psCrop")) {
 581         parseYesNo("psCrop", &psCrop, tokens, fileName, line);
 582       } else if (!cmd->cmp("psExpandSmaller")) {
 583         parseYesNo("psExpandSmaller", &psExpandSmaller,
 584                    tokens, fileName, line);
 585       } else if (!cmd->cmp("psShrinkLarger")) {
 586         parseYesNo("psShrinkLarger", &psShrinkLarger, tokens, fileName, line);
 587       } else if (!cmd->cmp("psCenter")) {
 588         parseYesNo("psCenter", &psCenter, tokens, fileName, line);
 589       } else if (!cmd->cmp("psDuplex")) {
 590         parseYesNo("psDuplex", &psDuplex, tokens, fileName, line);
 591       } else if (!cmd->cmp("psLevel")) {
 592         parsePSLevel(tokens, fileName, line);
 593       } else if (!cmd->cmp("psEmbedType1Fonts")) {
 594         parseYesNo("psEmbedType1", &psEmbedType1, tokens, fileName, line);
 595       } else if (!cmd->cmp("psEmbedTrueTypeFonts")) {
 596         parseYesNo("psEmbedTrueType", &psEmbedTrueType,
 597                    tokens, fileName, line);
 598       } else if (!cmd->cmp("psEmbedCIDPostScriptFonts")) {
 599         parseYesNo("psEmbedCIDPostScript", &psEmbedCIDPostScript,
 600                    tokens, fileName, line);
 601       } else if (!cmd->cmp("psEmbedCIDTrueTypeFonts")) {
 602         parseYesNo("psEmbedCIDTrueType", &psEmbedCIDTrueType,
 603                    tokens, fileName, line);
 604       } else if (!cmd->cmp("psOPI")) {
 605         parseYesNo("psOPI", &psOPI, tokens, fileName, line);
 606       } else if (!cmd->cmp("psASCIIHex")) {
 607         parseYesNo("psASCIIHex", &psASCIIHex, tokens, fileName, line);
 608       } else if (!cmd->cmp("textEncoding")) {
 609         parseTextEncoding(tokens, fileName, line);
 610       } else if (!cmd->cmp("textEOL")) {
 611         parseTextEOL(tokens, fileName, line);
 612       } else if (!cmd->cmp("textPageBreaks")) {
 613         parseYesNo("textPageBreaks", &textPageBreaks,
 614                    tokens, fileName, line);
 615       } else if (!cmd->cmp("textKeepTinyChars")) {
 616         parseYesNo("textKeepTinyChars", &textKeepTinyChars,
 617                    tokens, fileName, line);
 618       } else if (!cmd->cmp("fontDir")) {
 619         parseFontDir(tokens, fileName, line);
 620       } else if (!cmd->cmp("initialZoom")) {
 621         parseInitialZoom(tokens, fileName, line);
 622       } else if (!cmd->cmp("continuousView")) {
 623         parseYesNo("continuousView", &continuousView, tokens, fileName, line);
 624       } else if (!cmd->cmp("enableT1lib")) {
 625         parseYesNo("enableT1lib", &enableT1lib, tokens, fileName, line);
 626       } else if (!cmd->cmp("enableFreeType")) {
 627         parseYesNo("enableFreeType", &enableFreeType, tokens, fileName, line);
 628       } else if (!cmd->cmp("antialias")) {
 629         parseYesNo("antialias", &antialias, tokens, fileName, line);
 630       } else if (!cmd->cmp("urlCommand")) {
 631         parseCommand("urlCommand", &urlCommand, tokens, fileName, line);
 632       } else if (!cmd->cmp("movieCommand")) {
 633         parseCommand("movieCommand", &movieCommand, tokens, fileName, line);
 634       } else if (!cmd->cmp("mapNumericCharNames")) {
 635         parseYesNo("mapNumericCharNames", &mapNumericCharNames,
 636                    tokens, fileName, line);
 637       } else if (!cmd->cmp("printCommands")) {
 638         parseYesNo("printCommands", &printCommands, tokens, fileName, line);
 639       } else if (!cmd->cmp("errQuiet")) {
 640         parseYesNo("errQuiet", &errQuiet, tokens, fileName, line);
 641       } else {
 642         error(-1, "Unknown config file command '%s' (%s:%d)",
 643               cmd->getCString(), fileName->getCString(), line);
 644         if (!cmd->cmp("displayFontX") ||
 645             !cmd->cmp("displayNamedCIDFontX") ||
 646             !cmd->cmp("displayCIDFontX")) {
 647           error(-1, "-- Xpdf no longer supports X fonts");
 648         } else if (!cmd->cmp("t1libControl") || !cmd->cmp("freetypeControl")) {
 649           error(-1, "-- The t1libControl and freetypeControl options have been replaced");
 650           error(-1, "   by the enableT1lib, enableFreeType, and antialias options");
 651         } else if (!cmd->cmp("fontpath") || !cmd->cmp("fontmap")) {
 652           error(-1, "-- the config file format has changed since Xpdf 0.9x");
 653         }
 654       }
 655     }
 656
 657     deleteGList(tokens, GString);
 658     ++line;
 659   }
 660 }
 661
 662 void GlobalParams::parseNameToUnicode(GList *tokens, GString *fileName,
 663                                          int line) {
 664   GString *name;
 665   char *tok1, *tok2;
 666   FILE *f;
 667   char buf[256];
 668   int line2;
 669   Unicode u;
 670
 671   if (tokens->getLength() != 2) {
 672     error(-1, "Bad 'nameToUnicode' config file command (%s:%d)",
 673           fileName->getCString(), line);
 674     return;
 675   }
 676   name = (GString *)tokens->get(1);
 677   if (!(f = fopen(name->getCString(), "r"))) {
 678     error(-1, "Couldn't open 'nameToUnicode' file '%s'",
 679           name->getCString());
 680     return;
 681   }
 682   line2 = 1;
 683   while (getLine(buf, sizeof(buf), f)) {
 684     tok1 = strtok(buf, " \t\r\n");
 685     tok2 = strtok(NULL, " \t\r\n");
 686     if (tok1 && tok2) {
 687       sscanf(tok1, "%x", &u);
 688       nameToUnicode->add(tok2, u);
 689     } else {
 690       error(-1, "Bad line in 'nameToUnicode' file (%s:%d)", name, line2);
 691     }
 692     ++line2;
 693   }
 694   fclose(f);
 695 }
 696
 697 void GlobalParams::parseCIDToUnicode(GList *tokens, GString *fileName,
 698                                      int line) {
 699   GString *collection, *name, *old;
 700
 701   if (tokens->getLength() != 3) {
 702     error(-1, "Bad 'cidToUnicode' config file command (%s:%d)",
 703           fileName->getCString(), line);
 704     return;
 705   }
 706   collection = (GString *)tokens->get(1);
 707   name = (GString *)tokens->get(2);
 708   if ((old = (GString *)cidToUnicodes->remove(collection))) {
 709     delete old;
 710   }
 711   cidToUnicodes->add(collection->copy(), name->copy());
 712 }
 713
 714 void GlobalParams::parseUnicodeToUnicode(GList *tokens, GString *fileName,
 715                                          int line) {
 716   GString *font, *file, *old;
 717
 718   if (tokens->getLength() != 3) {
 719     error(-1, "Bad 'unicodeToUnicode' config file command (%s:%d)",
 720           fileName->getCString(), line);
 721     return;
 722   }
 723   font = (GString *)tokens->get(1);
 724   file = (GString *)tokens->get(2);
 725   if ((old = (GString *)unicodeToUnicodes->remove(font))) {
 726     delete old;
 727   }
 728   unicodeToUnicodes->add(font->copy(), file->copy());
 729 }
 730
 731 void GlobalParams::parseUnicodeMap(GList *tokens, GString *fileName,
 732                                    int line) {
 733   GString *encodingName, *name, *old;
 734
 735   if (tokens->getLength() != 3) {
 736     error(-1, "Bad 'unicodeMap' config file command (%s:%d)",
 737           fileName->getCString(), line);
 738     return;
 739   }
 740   encodingName = (GString *)tokens->get(1);
 741   name = (GString *)tokens->get(2);
 742   if ((old = (GString *)unicodeMaps->remove(encodingName))) {
 743     delete old;
 744   }
 745   unicodeMaps->add(encodingName->copy(), name->copy());
 746 }
 747
 748 void GlobalParams::parseCMapDir(GList *tokens, GString *fileName, int line) {
 749   GString *collection, *dir;
 750   GList *list;
 751
 752   if (tokens->getLength() != 3) {
 753     error(-1, "Bad 'cMapDir' config file command (%s:%d)",
 754           fileName->getCString(), line);
 755     return;
 756   }
 757   collection = (GString *)tokens->get(1);
 758   dir = (GString *)tokens->get(2);
 759   if (!(list = (GList *)cMapDirs->lookup(collection))) {
 760     list = new GList();
 761     cMapDirs->add(collection->copy(), list);
 762   }
 763   list->append(dir->copy());
 764 }
 765
 766 void GlobalParams::parseToUnicodeDir(GList *tokens, GString *fileName,
 767                                      int line) {
 768   if (tokens->getLength() != 2) {
 769     error(-1, "Bad 'toUnicodeDir' config file command (%s:%d)",
 770           fileName->getCString(), line);
 771     return;
 772   }
 773   toUnicodeDirs->append(((GString *)tokens->get(1))->copy());
 774 }
 775
 776 void GlobalParams::parseDisplayFont(GList *tokens, GHash *fontHash,
 777                                     DisplayFontParamKind kind,
 778                                     GString *fileName, int line) {
 779   DisplayFontParam *param, *old;
 780
 781   if (tokens->getLength() < 2) {
 782     goto err1;
 783   }
 784   param = new DisplayFontParam(((GString *)tokens->get(1))->copy(), kind);
 785
 786   switch (kind) {
 787   case displayFontT1:
 788     if (tokens->getLength() != 3) {
 789       goto err2;
 790     }
 791     param->t1.fileName = ((GString *)tokens->get(2))->copy();
 792     break;
 793   case displayFontTT:
 794     if (tokens->getLength() != 3) {
 795       goto err2;
 796     }
 797     param->tt.fileName = ((GString *)tokens->get(2))->copy();
 798     break;
 799   }
 800
 801   if ((old = (DisplayFontParam *)fontHash->remove(param->name))) {
 802     delete old;
 803   }
 804   fontHash->add(param->name, param);
 805   return;
 806
 807  err2:
 808   delete param;
 809  err1:
 810   error(-1, "Bad 'display*Font*' config file command (%s:%d)",
 811         fileName->getCString(), line);
 812 }
 813
 814 void GlobalParams::parsePSPaperSize(GList *tokens, GString *fileName,
 815                                     int line) {
 816   GString *tok;
 817
 818   if (tokens->getLength() == 2) {
 819     tok = (GString *)tokens->get(1);
 820     if (!setPSPaperSize(tok->getCString())) {
 821       error(-1, "Bad 'psPaperSize' config file command (%s:%d)",
 822             fileName->getCString(), line);
 823     }
 824   } else if (tokens->getLength() == 3) {
 825     tok = (GString *)tokens->get(1);
 826     psPaperWidth = atoi(tok->getCString());
 827     tok = (GString *)tokens->get(2);
 828     psPaperHeight = atoi(tok->getCString());
 829     psImageableLLX = psImageableLLY = 0;
 830     psImageableURX = psPaperWidth;
 831     psImageableURY = psPaperHeight;
 832   } else {
 833     error(-1, "Bad 'psPaperSize' config file command (%s:%d)",
 834           fileName->getCString(), line);
 835   }
 836 }
 837
 838 void GlobalParams::parsePSImageableArea(GList *tokens, GString *fileName,
 839                                         int line) {
 840   if (tokens->getLength() != 5) {
 841     error(-1, "Bad 'psImageableArea' config file command (%s:%d)",
 842           fileName->getCString(), line);
 843     return;
 844   }
 845   psImageableLLX = atoi(((GString *)tokens->get(1))->getCString());
 846   psImageableLLY = atoi(((GString *)tokens->get(2))->getCString());
 847   psImageableURX = atoi(((GString *)tokens->get(3))->getCString());
 848   psImageableURY = atoi(((GString *)tokens->get(4))->getCString());
 849 }
 850
 851 void GlobalParams::parsePSLevel(GList *tokens, GString *fileName, int line) {
 852   GString *tok;
 853
 854   if (tokens->getLength() != 2) {
 855     error(-1, "Bad 'psLevel' config file command (%s:%d)",
 856           fileName->getCString(), line);
 857     return;
 858   }
 859   tok = (GString *)tokens->get(1);
 860   if (!tok->cmp("level1")) {
 861     psLevel = psLevel1;
 862   } else if (!tok->cmp("level1sep")) {
 863     psLevel = psLevel1Sep;
 864   } else if (!tok->cmp("level2")) {
 865     psLevel = psLevel2;
 866   } else if (!tok->cmp("level2sep")) {
 867     psLevel = psLevel2Sep;
 868   } else if (!tok->cmp("level3")) {
 869     psLevel = psLevel3;
 870   } else if (!tok->cmp("level3Sep")) {
 871     psLevel = psLevel3Sep;
 872   } else {
 873     error(-1, "Bad 'psLevel' config file command (%s:%d)",
 874           fileName->getCString(), line);
 875   }
 876 }
 877
 878 void GlobalParams::parsePSFile(GList *tokens, GString *fileName, int line) {
 879   if (tokens->getLength() != 2) {
 880     error(-1, "Bad 'psFile' config file command (%s:%d)",
 881           fileName->getCString(), line);
 882     return;
 883   }
 884   if (psFile) {
 885     delete psFile;
 886   }
 887   psFile = ((GString *)tokens->get(1))->copy();
 888 }
 889
 890 void GlobalParams::parsePSFont(GList *tokens, GString *fileName, int line) {
 891   PSFontParam *param;
 892
 893   if (tokens->getLength() != 3) {
 894     error(-1, "Bad 'psFont' config file command (%s:%d)",
 895           fileName->getCString(), line);
 896     return;
 897   }
 898   param = new PSFontParam(((GString *)tokens->get(1))->copy(), 0,
 899                           ((GString *)tokens->get(2))->copy(), NULL);
 900   psFonts->add(param->pdfFontName, param);
 901 }
 902
 903 void GlobalParams::parsePSFont16(char *cmdName, GList *fontList,
 904                                  GList *tokens, GString *fileName, int line) {
 905   PSFontParam *param;
 906   int wMode;
 907   GString *tok;
 908
 909   if (tokens->getLength() != 5) {
 910     error(-1, "Bad '%s' config file command (%s:%d)",
 911           cmdName, fileName->getCString(), line);
 912     return;
 913   }
 914   tok = (GString *)tokens->get(2);
 915   if (!tok->cmp("H")) {
 916     wMode = 0;
 917   } else if (!tok->cmp("V")) {
 918     wMode = 1;
 919   } else {
 920     error(-1, "Bad '%s' config file command (%s:%d)",
 921           cmdName, fileName->getCString(), line);
 922     return;
 923   }
 924   param = new PSFontParam(((GString *)tokens->get(1))->copy(),
 925                           wMode,
 926                           ((GString *)tokens->get(3))->copy(),
 927                           ((GString *)tokens->get(4))->copy());
 928   fontList->append(param);
 929 }
 930
 931 void GlobalParams::parseTextEncoding(GList *tokens, GString *fileName,
 932                                      int line) {
 933   if (tokens->getLength() != 2) {
 934     error(-1, "Bad 'textEncoding' config file command (%s:%d)",
 935           fileName->getCString(), line);
 936     return;
 937   }
 938   delete textEncoding;
 939   textEncoding = ((GString *)tokens->get(1))->copy();
 940 }
 941
 942 void GlobalParams::parseTextEOL(GList *tokens, GString *fileName, int line) {
 943   GString *tok;
 944
 945   if (tokens->getLength() != 2) {
 946     error(-1, "Bad 'textEOL' config file command (%s:%d)",
 947           fileName->getCString(), line);
 948     return;
 949   }
 950   tok = (GString *)tokens->get(1);
 951   if (!tok->cmp("unix")) {
 952     textEOL = eolUnix;
 953   } else if (!tok->cmp("dos")) {
 954     textEOL = eolDOS;
 955   } else if (!tok->cmp("mac")) {
 956     textEOL = eolMac;
 957   } else {
 958     error(-1, "Bad 'textEOL' config file command (%s:%d)",
 959           fileName->getCString(), line);
 960   }
 961 }
 962
 963 void GlobalParams::parseFontDir(GList *tokens, GString *fileName, int line) {
 964   if (tokens->getLength() != 2) {
 965     error(-1, "Bad 'fontDir' config file command (%s:%d)",
 966           fileName->getCString(), line);
 967     return;
 968   }
 969   fontDirs->append(((GString *)tokens->get(1))->copy());
 970 }
 971
 972 void GlobalParams::parseInitialZoom(GList *tokens,
 973                                     GString *fileName, int line) {
 974   if (tokens->getLength() != 2) {
 975     error(-1, "Bad 'initialZoom' config file command (%s:%d)",
 976           fileName->getCString(), line);
 977     return;
 978   }
 979   delete initialZoom;
 980   initialZoom = ((GString *)tokens->get(1))->copy();
 981 }
 982
 983 void GlobalParams::parseCommand(char *cmdName, GString **val,
 984                                 GList *tokens, GString *fileName, int line) {
 985   if (tokens->getLength() != 2) {
 986     error(-1, "Bad '%s' config file command (%s:%d)",
 987           cmdName, fileName->getCString(), line);
 988     return;
 989   }
 990   if (*val) {
 991     delete *val;
 992   }
 993   *val = ((GString *)tokens->get(1))->copy();
 994 }
 995
 996 void GlobalParams::parseYesNo(char *cmdName, GBool *flag,
 997                               GList *tokens, GString *fileName, int line) {
 998   GString *tok;
 999
1000   if (tokens->getLength() != 2) {
1001     error(-1, "Bad '%s' config file command (%s:%d)",
1002           cmdName, fileName->getCString(), line);
1003     return;
1004   }
1005   tok = (GString *)tokens->get(1);
1006   if (!parseYesNo2(tok->getCString(), flag)) {
1007     error(-1, "Bad '%s' config file command (%s:%d)",
1008           cmdName, fileName->getCString(), line);
1009   }
1010 }
1011
1012 GBool GlobalParams::parseYesNo2(char *token, GBool *flag) {
1013   if (!strcmp(token, "yes")) {
1014     *flag = gTrue;
1015   } else if (!strcmp(token, "no")) {
1016     *flag = gFalse;
1017   } else {
1018     return gFalse;
1019   }
1020   return gTrue;
1021 }
1022
1023 GlobalParams::~GlobalParams() {
1024   GHashIter *iter;
1025   GString *key;
1026   GList *list;
1027
1028   freeBuiltinFontTables();
1029
1030   delete macRomanReverseMap;
1031
1032   delete baseDir;
1033   delete nameToUnicode;
1034   deleteGHash(cidToUnicodes, GString);
1035   deleteGHash(unicodeToUnicodes, GString);
1036   deleteGHash(residentUnicodeMaps, UnicodeMap);
1037   deleteGHash(unicodeMaps, GString);
1038   deleteGList(toUnicodeDirs, GString);
1039   deleteGHash(displayFonts, DisplayFontParam);
1040   deleteGHash(displayCIDFonts, DisplayFontParam);
1041   deleteGHash(displayNamedCIDFonts, DisplayFontParam);
1042   if (psFile) {
1043     delete psFile;
1044   }
1045   deleteGHash(psFonts, PSFontParam);
1046   deleteGList(psNamedFonts16, PSFontParam);
1047   deleteGList(psFonts16, PSFontParam);
1048   delete textEncoding;
1049   deleteGList(fontDirs, GString);
1050   delete initialZoom;
1051   if (urlCommand) {
1052     delete urlCommand;
1053   }
1054   if (movieCommand) {
1055     delete movieCommand;
1056   }
1057
1058   cMapDirs->startIter(&iter);
1059   while (cMapDirs->getNext(&iter, &key, (void **)&list)) {
1060     deleteGList(list, GString);
1061   }
1062   delete cMapDirs;
1063
1064   delete cidToUnicodeCache;
1065   delete unicodeToUnicodeCache;
1066   delete unicodeMapCache;
1067   delete cMapCache;
1068
1069 #ifdef ENABLE_PLUGINS
1070   delete securityHandlers;
1071   deleteGList(plugins, Plugin);
1072 #endif
1073
1074 #if MULTITHREADED
1075   gDestroyMutex(&mutex);
1076   gDestroyMutex(&unicodeMapCacheMutex);
1077   gDestroyMutex(&cMapCacheMutex);
1078 #endif
1079 }
1080
1081 //------------------------------------------------------------------------
1082
1083 void GlobalParams::setBaseDir(char *dir) {
1084   delete baseDir;
1085   baseDir = new GString(dir);
1086 }
1087
1088 void GlobalParams::setupBaseFonts(char *dir) {
1089   GString *fontName;
1090   GString *fileName;
1091 #ifdef WIN32
1092   HMODULE shell32Lib;
1093   BOOL (__stdcall *SHGetSpecialFolderPathFunc)(HWND hwndOwner,
1094                                                LPTSTR lpszPath,
1095                                                int nFolder,
1096                                                BOOL fCreate);
1097   char winFontDir[MAX_PATH];
1098 #endif
1099   FILE *f;
1100   DisplayFontParamKind kind;
1101   DisplayFontParam *dfp;
1102   int i, j;
1103
1104 #ifdef WIN32
1105   // SHGetSpecialFolderPath isn't available in older versions of
1106   // shell32.dll (Win95 and WinNT4), so do a dynamic load
1107   winFontDir[0] = '\0';
1108   if ((shell32Lib = LoadLibrary("shell32.dll"))) {
1109     if ((SHGetSpecialFolderPathFunc =
1110          (BOOL (__stdcall *)(HWND hwndOwner, LPTSTR lpszPath,
1111                              int nFolder, BOOL fCreate))
1112          GetProcAddress(shell32Lib, "SHGetSpecialFolderPath"))) {
1113       if (!(*SHGetSpecialFolderPathFunc)(NULL, winFontDir,
1114                                          CSIDL_FONTS, FALSE)) {
1115         winFontDir[0] = '\0';
1116       }
1117     }
1118   }
1119 #endif
1120   for (i = 0; displayFontTab[i].name; ++i) {
1121     fontName = new GString(displayFontTab[i].name);
1122     if (getDisplayFont(fontName)) {
1123       delete fontName;
1124       continue;
1125     }
1126     fileName = NULL;
1127     kind = displayFontT1; // make gcc happy
1128     if (dir) {
1129       fileName = appendToPath(new GString(dir), displayFontTab[i].t1FileName);
1130       kind = displayFontT1;
1131       if ((f = fopen(fileName->getCString(), "rb"))) {
1132         fclose(f);
1133       } else {
1134         delete fileName;
1135         fileName = NULL;
1136       }
1137     }
1138 #ifdef WIN32
1139     if (!fileName && winFontDir[0] && displayFontTab[i].ttFileName) {
1140       fileName = appendToPath(new GString(winFontDir),
1141                               displayFontTab[i].ttFileName);
1142       kind = displayFontTT;
1143       if ((f = fopen(fileName->getCString(), "rb"))) {
1144         fclose(f);
1145       } else {
1146         delete fileName;
1147         fileName = NULL;
1148       }
1149     }
1150     // SHGetSpecialFolderPath(CSIDL_FONTS) doesn't work on Win 2k Server
1151     // or Win2003 Server, or with older versions of shell32.dll, so check
1152     // the "standard" directories
1153     if (displayFontTab[i].ttFileName) {
1154       for (j = 0; !fileName && displayFontDirs[j]; ++j) {
1155         fileName = appendToPath(new GString(displayFontDirs[j]),
1156                                 displayFontTab[i].ttFileName);
1157         kind = displayFontTT;
1158         if ((f = fopen(fileName->getCString(), "rb"))) {
1159           fclose(f);
1160         } else {
1161           delete fileName;
1162           fileName = NULL;
1163         }
1164       }
1165     }
1166 #else
1167     for (j = 0; !fileName && displayFontDirs[j]; ++j) {
1168       fileName = appendToPath(new GString(displayFontDirs[j]),
1169                               displayFontTab[i].t1FileName);
1170       kind = displayFontT1;
1171       if ((f = fopen(fileName->getCString(), "rb"))) {
1172         fclose(f);
1173       } else {
1174         delete fileName;
1175         fileName = NULL;
1176       }
1177     }
1178 #endif
1179     if (!fileName) {
1180       error(-1, "No display font for '%s'", displayFontTab[i].name);
1181       delete fontName;
1182       continue;
1183     }
1184     dfp = new DisplayFontParam(fontName, kind);
1185     dfp->t1.fileName = fileName;
1186     globalParams->addDisplayFont(dfp);
1187   }
1188 }
1189
1190 //------------------------------------------------------------------------
1191 // accessors
1192 //------------------------------------------------------------------------
1193
1194 CharCode GlobalParams::getMacRomanCharCode(char *charName) {
1195   // no need to lock - macRomanReverseMap is constant
1196   return macRomanReverseMap->lookup(charName);
1197 }
1198
1199 GString *GlobalParams::getBaseDir() {
1200   GString *s;
1201
1202   lockGlobalParams;
1203   s = baseDir->copy();
1204   unlockGlobalParams;
1205   return s;
1206 }
1207
1208 Unicode GlobalParams::mapNameToUnicode(char *charName) {
1209   // no need to lock - nameToUnicode is constant
1210   return nameToUnicode->lookup(charName);
1211 }
1212
1213 UnicodeMap *GlobalParams::getResidentUnicodeMap(GString *encodingName) {
1214   UnicodeMap *map;
1215
1216   lockGlobalParams;
1217   map = (UnicodeMap *)residentUnicodeMaps->lookup(encodingName);
1218   unlockGlobalParams;
1219   if (map) {
1220     map->incRefCnt();
1221   }
1222   return map;
1223 }
1224
1225 FILE *GlobalParams::getUnicodeMapFile(GString *encodingName) {
1226   GString *fileName;
1227   FILE *f;
1228
1229   lockGlobalParams;
1230   if ((fileName = (GString *)unicodeMaps->lookup(encodingName))) {
1231     f = fopen(fileName->getCString(), "r");
1232   } else {
1233     f = NULL;
1234   }
1235   unlockGlobalParams;
1236   return f;
1237 }
1238
1239 FILE *GlobalParams::findCMapFile(GString *collection, GString *cMapName) {
1240   GList *list;
1241   GString *dir;
1242   GString *fileName;
1243   FILE *f;
1244   int i;
1245
1246   lockGlobalParams;
1247   if (!(list = (GList *)cMapDirs->lookup(collection))) {
1248     unlockGlobalParams;
1249     return NULL;
1250   }
1251   for (i = 0; i < list->getLength(); ++i) {
1252     dir = (GString *)list->get(i);
1253     fileName = appendToPath(dir->copy(), cMapName->getCString());
1254     f = fopen(fileName->getCString(), "r");
1255     delete fileName;
1256     if (f) {
1257       unlockGlobalParams;
1258       return f;
1259     }
1260   }
1261   unlockGlobalParams;
1262   return NULL;
1263 }
1264
1265 FILE *GlobalParams::findToUnicodeFile(GString *name) {
1266   GString *dir, *fileName;
1267   FILE *f;
1268   int i;
1269
1270   lockGlobalParams;
1271   for (i = 0; i < toUnicodeDirs->getLength(); ++i) {
1272     dir = (GString *)toUnicodeDirs->get(i);
1273     fileName = appendToPath(dir->copy(), name->getCString());
1274     f = fopen(fileName->getCString(), "r");
1275     delete fileName;
1276     if (f) {
1277       unlockGlobalParams;
1278       return f;
1279     }
1280   }
1281   unlockGlobalParams;
1282   return NULL;
1283 }
1284
1285 DisplayFontParam *GlobalParams::getDisplayFont(GString *fontName) {
1286   DisplayFontParam *dfp;
1287
1288   lockGlobalParams;
1289   dfp = (DisplayFontParam *)displayFonts->lookup(fontName);
1290   unlockGlobalParams;
1291   return dfp;
1292 }
1293
1294 DisplayFontParam *GlobalParams::getDisplayCIDFont(GString *fontName,
1295                                                   GString *collection) {
1296   DisplayFontParam *dfp;
1297
1298   lockGlobalParams;
1299   if (!fontName ||
1300       !(dfp = (DisplayFontParam *)displayNamedCIDFonts->lookup(fontName))) {
1301     dfp = (DisplayFontParam *)displayCIDFonts->lookup(collection);
1302   }
1303   unlockGlobalParams;
1304   return dfp;
1305 }
1306
1307 GString *GlobalParams::getPSFile() {
1308   GString *s;
1309
1310   lockGlobalParams;
1311   s = psFile ? psFile->copy() : (GString *)NULL;
1312   unlockGlobalParams;
1313   return s;
1314 }
1315
1316 int GlobalParams::getPSPaperWidth() {
1317   int w;
1318
1319   lockGlobalParams;
1320   w = psPaperWidth;
1321   unlockGlobalParams;
1322   return w;
1323 }
1324
1325 int GlobalParams::getPSPaperHeight() {
1326   int h;
1327
1328   lockGlobalParams;
1329   h = psPaperHeight;
1330   unlockGlobalParams;
1331   return h;
1332 }
1333
1334 void GlobalParams::getPSImageableArea(int *llx, int *lly, int *urx, int *ury) {
1335   lockGlobalParams;
1336   *llx = psImageableLLX;
1337   *lly = psImageableLLY;
1338   *urx = psImageableURX;
1339   *ury = psImageableURY;
1340   unlockGlobalParams;
1341 }
1342
1343 GBool GlobalParams::getPSCrop() {
1344   GBool f;
1345
1346   lockGlobalParams;
1347   f = psCrop;
1348   unlockGlobalParams;
1349   return f;
1350 }
1351
1352 GBool GlobalParams::getPSExpandSmaller() {
1353   GBool f;
1354
1355   lockGlobalParams;
1356   f = psExpandSmaller;
1357   unlockGlobalParams;
1358   return f;
1359 }
1360
1361 GBool GlobalParams::getPSShrinkLarger() {
1362   GBool f;
1363
1364   lockGlobalParams;
1365   f = psShrinkLarger;
1366   unlockGlobalParams;
1367   return f;
1368 }
1369
1370 GBool GlobalParams::getPSCenter() {
1371   GBool f;
1372
1373   lockGlobalParams;
1374   f = psCenter;
1375   unlockGlobalParams;
1376   return f;
1377 }
1378
1379 GBool GlobalParams::getPSDuplex() {
1380   GBool d;
1381
1382   lockGlobalParams;
1383   d = psDuplex;
1384   unlockGlobalParams;
1385   return d;
1386 }
1387
1388 PSLevel GlobalParams::getPSLevel() {
1389   PSLevel level;
1390
1391   lockGlobalParams;
1392   level = psLevel;
1393   unlockGlobalParams;
1394   return level;
1395 }
1396
1397 PSFontParam *GlobalParams::getPSFont(GString *fontName) {
1398   PSFontParam *p;
1399
1400   lockGlobalParams;
1401   p = (PSFontParam *)psFonts->lookup(fontName);
1402   unlockGlobalParams;
1403   return p;
1404 }
1405
1406 PSFontParam *GlobalParams::getPSFont16(GString *fontName,
1407                                        GString *collection, int wMode) {
1408   PSFontParam *p;
1409   int i;
1410
1411   lockGlobalParams;
1412   p = NULL;
1413   if (fontName) {
1414     for (i = 0; i < psNamedFonts16->getLength(); ++i) {
1415       p = (PSFontParam *)psNamedFonts16->get(i);
1416       if (!p->pdfFontName->cmp(fontName) &&
1417           p->wMode == wMode) {
1418         break;
1419       }
1420       p = NULL;
1421     }
1422   }
1423   if (!p && collection) {
1424     for (i = 0; i < psFonts16->getLength(); ++i) {
1425       p = (PSFontParam *)psFonts16->get(i);
1426       if (!p->pdfFontName->cmp(collection) &&
1427           p->wMode == wMode) {
1428         break;
1429       }
1430       p = NULL;
1431     }
1432   }
1433   unlockGlobalParams;
1434   return p;
1435 }
1436
1437 GBool GlobalParams::getPSEmbedType1() {
1438   GBool e;
1439
1440   lockGlobalParams;
1441   e = psEmbedType1;
1442   unlockGlobalParams;
1443   return e;
1444 }
1445
1446 GBool GlobalParams::getPSEmbedTrueType() {
1447   GBool e;
1448
1449   lockGlobalParams;
1450   e = psEmbedTrueType;
1451   unlockGlobalParams;
1452   return e;
1453 }
1454
1455 GBool GlobalParams::getPSEmbedCIDPostScript() {
1456   GBool e;
1457
1458   lockGlobalParams;
1459   e = psEmbedCIDPostScript;
1460   unlockGlobalParams;
1461   return e;
1462 }
1463
1464 GBool GlobalParams::getPSEmbedCIDTrueType() {
1465   GBool e;
1466
1467   lockGlobalParams;
1468   e = psEmbedCIDTrueType;
1469   unlockGlobalParams;
1470   return e;
1471 }
1472
1473 GBool GlobalParams::getPSOPI() {
1474   GBool opi;
1475
1476   lockGlobalParams;
1477   opi = psOPI;
1478   unlockGlobalParams;
1479   return opi;
1480 }
1481
1482 GBool GlobalParams::getPSASCIIHex() {
1483   GBool ah;
1484
1485   lockGlobalParams;
1486   ah = psASCIIHex;
1487   unlockGlobalParams;
1488   return ah;
1489 }
1490
1491 GString *GlobalParams::getTextEncodingName() {
1492   GString *s;
1493
1494   lockGlobalParams;
1495   s = textEncoding->copy();
1496   unlockGlobalParams;
1497   return s;
1498 }
1499
1500 EndOfLineKind GlobalParams::getTextEOL() {
1501   EndOfLineKind eol;
1502
1503   lockGlobalParams;
1504   eol = textEOL;
1505   unlockGlobalParams;
1506   return eol;
1507 }
1508
1509 GBool GlobalParams::getTextPageBreaks() {
1510   GBool pageBreaks;
1511
1512   lockGlobalParams;
1513   pageBreaks = textPageBreaks;
1514   unlockGlobalParams;
1515   return pageBreaks;
1516 }
1517
1518 GBool GlobalParams::getTextKeepTinyChars() {
1519   GBool tiny;
1520
1521   lockGlobalParams;
1522   tiny = textKeepTinyChars;
1523   unlockGlobalParams;
1524   return tiny;
1525 }
1526
1527 GString *GlobalParams::findFontFile(GString *fontName, char **exts) {
1528   GString *dir, *fileName;
1529   char **ext;
1530   FILE *f;
1531   int i;
1532
1533   lockGlobalParams;
1534   for (i = 0; i < fontDirs->getLength(); ++i) {
1535     dir = (GString *)fontDirs->get(i);
1536     for (ext = exts; *ext; ++ext) {
1537       fileName = appendToPath(dir->copy(), fontName->getCString());
1538       fileName->append(*ext);
1539       if ((f = fopen(fileName->getCString(), "rb"))) {
1540         fclose(f);
1541         unlockGlobalParams;
1542         return fileName;
1543       }
1544       delete fileName;
1545     }
1546   }
1547   unlockGlobalParams;
1548   return NULL;
1549 }
1550
1551 GString *GlobalParams::getInitialZoom() {
1552   GString *s;
1553
1554   lockGlobalParams;
1555   s = initialZoom->copy();
1556   unlockGlobalParams;
1557   return s;
1558 }
1559
1560 GBool GlobalParams::getContinuousView() {
1561   GBool f;
1562
1563   lockGlobalParams;
1564   f = continuousView;
1565   unlockGlobalParams;
1566   return f;
1567 }
1568
1569 GBool GlobalParams::getEnableT1lib() {
1570   GBool f;
1571
1572   lockGlobalParams;
1573   f = enableT1lib;
1574   unlockGlobalParams;
1575   return f;
1576 }
1577
1578 GBool GlobalParams::getEnableFreeType() {
1579   GBool f;
1580
1581   lockGlobalParams;
1582   f = enableFreeType;
1583   unlockGlobalParams;
1584   return f;
1585 }
1586
1587
1588 GBool GlobalParams::getAntialias() {
1589   GBool f;
1590
1591   lockGlobalParams;
1592   f = antialias;
1593   unlockGlobalParams;
1594   return f;
1595 }
1596
1597 GBool GlobalParams::getMapNumericCharNames() {
1598   GBool map;
1599
1600   lockGlobalParams;
1601   map = mapNumericCharNames;
1602   unlockGlobalParams;
1603   return map;
1604 }
1605
1606 GBool GlobalParams::getPrintCommands() {
1607   GBool p;
1608
1609   lockGlobalParams;
1610   p = printCommands;
1611   unlockGlobalParams;
1612   return p;
1613 }
1614
1615 GBool GlobalParams::getErrQuiet() {
1616   GBool q;
1617
1618   lockGlobalParams;
1619   q = errQuiet;
1620   unlockGlobalParams;
1621   return q;
1622 }
1623
1624 CharCodeToUnicode *GlobalParams::getCIDToUnicode(GString *collection) {
1625   GString *fileName;
1626   CharCodeToUnicode *ctu;
1627
1628   lockGlobalParams;
1629   if (!(ctu = cidToUnicodeCache->getCharCodeToUnicode(collection))) {
1630     if ((fileName = (GString *)cidToUnicodes->lookup(collection)) &&
1631         (ctu = CharCodeToUnicode::parseCIDToUnicode(fileName, collection))) {
1632       cidToUnicodeCache->add(ctu);
1633     }
1634   }
1635   unlockGlobalParams;
1636   return ctu;
1637 }
1638
1639 CharCodeToUnicode *GlobalParams::getUnicodeToUnicode(GString *fontName) {
1640   CharCodeToUnicode *ctu;
1641   GHashIter *iter;
1642   GString *fontPattern, *fileName;
1643
1644   lockGlobalParams;
1645   fileName = NULL;
1646   unicodeToUnicodes->startIter(&iter);
1647   while (unicodeToUnicodes->getNext(&iter, &fontPattern, (void **)&fileName)) {
1648     if (strstr(fontName->getCString(), fontPattern->getCString())) {
1649       unicodeToUnicodes->killIter(&iter);
1650       break;
1651     }
1652     fileName = NULL;
1653   }
1654   if (fileName) {
1655     if (!(ctu = unicodeToUnicodeCache->getCharCodeToUnicode(fileName))) {
1656       if ((ctu = CharCodeToUnicode::parseUnicodeToUnicode(fileName))) {
1657         unicodeToUnicodeCache->add(ctu);
1658       }
1659     }
1660   } else {
1661     ctu = NULL;
1662   }
1663   unlockGlobalParams;
1664   return ctu;
1665 }
1666
1667 UnicodeMap *GlobalParams::getUnicodeMap(GString *encodingName) {
1668   return getUnicodeMap2(encodingName);
1669 }
1670
1671 UnicodeMap *GlobalParams::getUnicodeMap2(GString *encodingName) {
1672   UnicodeMap *map;
1673
1674   if (!(map = getResidentUnicodeMap(encodingName))) {
1675     lockUnicodeMapCache;
1676     map = unicodeMapCache->getUnicodeMap(encodingName);
1677     unlockUnicodeMapCache;
1678   }
1679   return map;
1680 }
1681
1682 CMap *GlobalParams::getCMap(GString *collection, GString *cMapName) {
1683   CMap *cMap;
1684
1685   lockCMapCache;
1686   cMap = cMapCache->getCMap(collection, cMapName);
1687   unlockCMapCache;
1688   return cMap;
1689 }
1690
1691 UnicodeMap *GlobalParams::getTextEncoding() {
1692   return getUnicodeMap2(textEncoding);
1693 }
1694
1695 //------------------------------------------------------------------------
1696 // functions to set parameters
1697 //------------------------------------------------------------------------
1698
1699 void GlobalParams::addDisplayFont(DisplayFontParam *param) {
1700   DisplayFontParam *old;
1701
1702   lockGlobalParams;
1703   if ((old = (DisplayFontParam *)displayFonts->remove(param->name))) {
1704     delete old;
1705   }
1706   displayFonts->add(param->name, param);
1707   unlockGlobalParams;
1708 }
1709
1710 void GlobalParams::setPSFile(char *file) {
1711   lockGlobalParams;
1712   if (psFile) {
1713     delete psFile;
1714   }
1715   psFile = new GString(file);
1716   unlockGlobalParams;
1717 }
1718
1719 GBool GlobalParams::setPSPaperSize(char *size) {
1720   lockGlobalParams;
1721   if (!strcmp(size, "match")) {
1722     psPaperWidth = psPaperHeight = -1;
1723   } else if (!strcmp(size, "letter")) {
1724     psPaperWidth = 612;
1725     psPaperHeight = 792;
1726   } else if (!strcmp(size, "legal")) {
1727     psPaperWidth = 612;
1728     psPaperHeight = 1008;
1729   } else if (!strcmp(size, "A4")) {
1730     psPaperWidth = 595;
1731     psPaperHeight = 842;
1732   } else if (!strcmp(size, "A3")) {
1733     psPaperWidth = 842;
1734     psPaperHeight = 1190;
1735   } else {
1736     unlockGlobalParams;
1737     return gFalse;
1738   }
1739   psImageableLLX = psImageableLLY = 0;
1740   psImageableURX = psPaperWidth;
1741   psImageableURY = psPaperHeight;
1742   unlockGlobalParams;
1743   return gTrue;
1744 }
1745
1746 void GlobalParams::setPSPaperWidth(int width) {
1747   lockGlobalParams;
1748   psPaperWidth = width;
1749   psImageableLLX = 0;
1750   psImageableURX = psPaperWidth;
1751   unlockGlobalParams;
1752 }
1753
1754 void GlobalParams::setPSPaperHeight(int height) {
1755   lockGlobalParams;
1756   psPaperHeight = height;
1757   psImageableLLY = 0;
1758   psImageableURY = psPaperHeight;
1759   unlockGlobalParams;
1760 }
1761
1762 void GlobalParams::setPSImageableArea(int llx, int lly, int urx, int ury) {
1763   lockGlobalParams;
1764   psImageableLLX = llx;
1765   psImageableLLY = lly;
1766   psImageableURX = urx;
1767   psImageableURY = ury;
1768   unlockGlobalParams;
1769 }
1770
1771 void GlobalParams::setPSCrop(GBool crop) {
1772   lockGlobalParams;
1773   psCrop = crop;
1774   unlockGlobalParams;
1775 }
1776
1777 void GlobalParams::setPSExpandSmaller(GBool expand) {
1778   lockGlobalParams;
1779   psExpandSmaller = expand;
1780   unlockGlobalParams;
1781 }
1782
1783 void GlobalParams::setPSShrinkLarger(GBool shrink) {
1784   lockGlobalParams;
1785   psShrinkLarger = shrink;
1786   unlockGlobalParams;
1787 }
1788
1789 void GlobalParams::setPSCenter(GBool center) {
1790   lockGlobalParams;
1791   psCenter = center;
1792   unlockGlobalParams;
1793 }
1794
1795 void GlobalParams::setPSDuplex(GBool duplex) {
1796   lockGlobalParams;
1797   psDuplex = duplex;
1798   unlockGlobalParams;
1799 }
1800
1801 void GlobalParams::setPSLevel(PSLevel level) {
1802   lockGlobalParams;
1803   psLevel = level;
1804   unlockGlobalParams;
1805 }
1806
1807 void GlobalParams::setPSEmbedType1(GBool embed) {
1808   lockGlobalParams;
1809   psEmbedType1 = embed;
1810   unlockGlobalParams;
1811 }
1812
1813 void GlobalParams::setPSEmbedTrueType(GBool embed) {
1814   lockGlobalParams;
1815   psEmbedTrueType = embed;
1816   unlockGlobalParams;
1817 }
1818
1819 void GlobalParams::setPSEmbedCIDPostScript(GBool embed) {
1820   lockGlobalParams;
1821   psEmbedCIDPostScript = embed;
1822   unlockGlobalParams;
1823 }
1824
1825 void GlobalParams::setPSEmbedCIDTrueType(GBool embed) {
1826   lockGlobalParams;
1827   psEmbedCIDTrueType = embed;
1828   unlockGlobalParams;
1829 }
1830
1831 void GlobalParams::setPSOPI(GBool opi) {
1832   lockGlobalParams;
1833   psOPI = opi;
1834   unlockGlobalParams;
1835 }
1836
1837 void GlobalParams::setPSASCIIHex(GBool hex) {
1838   lockGlobalParams;
1839   psASCIIHex = hex;
1840   unlockGlobalParams;
1841 }
1842
1843 void GlobalParams::setTextEncoding(char *encodingName) {
1844   lockGlobalParams;
1845   delete textEncoding;
1846   textEncoding = new GString(encodingName);
1847   unlockGlobalParams;
1848 }
1849
1850 GBool GlobalParams::setTextEOL(char *s) {
1851   lockGlobalParams;
1852   if (!strcmp(s, "unix")) {
1853     textEOL = eolUnix;
1854   } else if (!strcmp(s, "dos")) {
1855     textEOL = eolDOS;
1856   } else if (!strcmp(s, "mac")) {
1857     textEOL = eolMac;
1858   } else {
1859     unlockGlobalParams;
1860     return gFalse;
1861   }
1862   unlockGlobalParams;
1863   return gTrue;
1864 }
1865
1866 void GlobalParams::setTextPageBreaks(GBool pageBreaks) {
1867   lockGlobalParams;
1868   textPageBreaks = pageBreaks;
1869   unlockGlobalParams;
1870 }
1871
1872 void GlobalParams::setTextKeepTinyChars(GBool keep) {
1873   lockGlobalParams;
1874   textKeepTinyChars = keep;
1875   unlockGlobalParams;
1876 }
1877
1878 void GlobalParams::setInitialZoom(char *s) {
1879   lockGlobalParams;
1880   delete initialZoom;
1881   initialZoom = new GString(s);
1882   unlockGlobalParams;
1883 }
1884
1885 void GlobalParams::setContinuousView(GBool cont) {
1886   lockGlobalParams;
1887   continuousView = cont;
1888   unlockGlobalParams;
1889 }
1890
1891 GBool GlobalParams::setEnableT1lib(char *s) {
1892   GBool ok;
1893
1894   lockGlobalParams;
1895   ok = parseYesNo2(s, &enableT1lib);
1896   unlockGlobalParams;
1897   return ok;
1898 }
1899
1900 GBool GlobalParams::setEnableFreeType(char *s) {
1901   GBool ok;
1902
1903   lockGlobalParams;
1904   ok = parseYesNo2(s, &enableFreeType);
1905   unlockGlobalParams;
1906   return ok;
1907 }
1908
1909
1910 GBool GlobalParams::setAntialias(char *s) {
1911   GBool ok;
1912
1913   lockGlobalParams;
1914   ok = parseYesNo2(s, &antialias);
1915   unlockGlobalParams;
1916   return ok;
1917 }
1918
1919 void GlobalParams::setMapNumericCharNames(GBool map) {
1920   lockGlobalParams;
1921   mapNumericCharNames = map;
1922   unlockGlobalParams;
1923 }
1924
1925 void GlobalParams::setPrintCommands(GBool printCommandsA) {
1926   lockGlobalParams;
1927   printCommands = printCommandsA;
1928   unlockGlobalParams;
1929 }
1930
1931 void GlobalParams::setErrQuiet(GBool errQuietA) {
1932   lockGlobalParams;
1933   errQuiet = errQuietA;
1934   unlockGlobalParams;
1935 }
1936
1937 void GlobalParams::addSecurityHandler(XpdfSecurityHandler *handler) {
1938 #ifdef ENABLE_PLUGINS
1939   lockGlobalParams;
1940   securityHandlers->append(handler);
1941   unlockGlobalParams;
1942 #endif
1943 }
1944
1945 XpdfSecurityHandler *GlobalParams::getSecurityHandler(char *name) {
1946 #ifdef ENABLE_PLUGINS
1947   XpdfSecurityHandler *hdlr;
1948   int i;
1949
1950   lockGlobalParams;
1951   for (i = 0; i < securityHandlers->getLength(); ++i) {
1952     hdlr = (XpdfSecurityHandler *)securityHandlers->get(i);
1953     if (!stricmp(hdlr->name, name)) {
1954       unlockGlobalParams;
1955       return hdlr;
1956     }
1957   }
1958   unlockGlobalParams;
1959
1960   if (!loadPlugin("security", name)) {
1961     return NULL;
1962   }
1963
1964   lockGlobalParams;
1965   for (i = 0; i < securityHandlers->getLength(); ++i) {
1966     hdlr = (XpdfSecurityHandler *)securityHandlers->get(i);
1967     if (!strcmp(hdlr->name, name)) {
1968       unlockGlobalParams;
1969       return hdlr;
1970     }
1971   }
1972   unlockGlobalParams;
1973 #endif
1974
1975   return NULL;
1976 }
1977
1978 #ifdef ENABLE_PLUGINS
1979 //------------------------------------------------------------------------
1980 // plugins
1981 //------------------------------------------------------------------------
1982
1983 GBool GlobalParams::loadPlugin(char *type, char *name) {
1984   Plugin *plugin;
1985
1986   if (!(plugin = Plugin::load(type, name))) {
1987     return gFalse;
1988   }
1989   lockGlobalParams;
1990   plugins->append(plugin);
1991   unlockGlobalParams;
1992   return gTrue;
1993 }
1994
1995 #endif // ENABLE_PLUGINS