pdf2swf/xpdf/GlobalParams.cc

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