pdf2swf/xpdf/GfxFont.cc

   1 //========================================================================
   2 //
   3 // GfxFont.cc
   4 //
   5 // Copyright 1996-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 <stdio.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include <ctype.h>
  19 #include "gmem.h"
  20 #include "Error.h"
  21 #include "Object.h"
  22 #include "Dict.h"
  23 #include "GlobalParams.h"
  24 #include "CMap.h"
  25 #include "CharCodeToUnicode.h"
  26 #include "FontEncodingTables.h"
  27 #include "BuiltinFontTables.h"
  28 #include "FoFiType1.h"
  29 #include "FoFiType1C.h"
  30 #include "FoFiTrueType.h"
  31 #include "GfxFont.h"
  32
  33 //------------------------------------------------------------------------
  34
  35 struct StdFontMapEntry {
  36   char *altName;
  37   char *properName;
  38 };
  39
  40 // Acrobat 4.0 and earlier substituted Base14-compatible fonts without
  41 // providing Widths and a FontDescriptor, so we munge the names into
  42 // the proper Base14 names.  This table is from implementation note 44
  43 // in the PDF 1.4 spec, with some additions based on empirical
  44 // evidence.
  45 static StdFontMapEntry stdFontMap[] = {
  46   { "Arial",                        "Helvetica" },
  47   { "Arial,Bold",                   "Helvetica-Bold" },
  48   { "Arial,BoldItalic",             "Helvetica-BoldOblique" },
  49   { "Arial,Italic",                 "Helvetica-Oblique" },
  50   { "Arial-Bold",                   "Helvetica-Bold" },
  51   { "Arial-BoldItalic",             "Helvetica-BoldOblique" },
  52   { "Arial-BoldItalicMT",           "Helvetica-BoldOblique" },
  53   { "Arial-BoldMT",                 "Helvetica-Bold" },
  54   { "Arial-Italic",                 "Helvetica-Oblique" },
  55   { "Arial-ItalicMT",               "Helvetica-Oblique" },
  56   { "ArialMT",                      "Helvetica" },
  57   { "Courier,Bold",                 "Courier-Bold" },
  58   { "Courier,Italic",               "Courier-Oblique" },
  59   { "Courier,BoldItalic",           "Courier-BoldOblique" },
  60   { "CourierNew",                   "Courier" },
  61   { "CourierNew,Bold",              "Courier-Bold" },
  62   { "CourierNew,BoldItalic",        "Courier-BoldOblique" },
  63   { "CourierNew,Italic",            "Courier-Oblique" },
  64   { "CourierNew-Bold",              "Courier-Bold" },
  65   { "CourierNew-BoldItalic",        "Courier-BoldOblique" },
  66   { "CourierNew-Italic",            "Courier-Oblique" },
  67   { "CourierNewPS-BoldItalicMT",    "Courier-BoldOblique" },
  68   { "CourierNewPS-BoldMT",          "Courier-Bold" },
  69   { "CourierNewPS-ItalicMT",        "Courier-Oblique" },
  70   { "CourierNewPSMT",               "Courier" },
  71   { "Helvetica,Bold",               "Helvetica-Bold" },
  72   { "Helvetica,BoldItalic",         "Helvetica-BoldOblique" },
  73   { "Helvetica,Italic",             "Helvetica-Oblique" },
  74   { "Helvetica-BoldItalic",         "Helvetica-BoldOblique" },
  75   { "Helvetica-Italic",             "Helvetica-Oblique" },
  76   { "Symbol,Bold",                  "Symbol" },
  77   { "Symbol,BoldItalic",            "Symbol" },
  78   { "Symbol,Italic",                "Symbol" },
  79   { "TimesNewRoman",                "Times-Roman" },
  80   { "TimesNewRoman,Bold",           "Times-Bold" },
  81   { "TimesNewRoman,BoldItalic",     "Times-BoldItalic" },
  82   { "TimesNewRoman,Italic",         "Times-Italic" },
  83   { "TimesNewRoman-Bold",           "Times-Bold" },
  84   { "TimesNewRoman-BoldItalic",     "Times-BoldItalic" },
  85   { "TimesNewRoman-Italic",         "Times-Italic" },
  86   { "TimesNewRomanPS",              "Times-Roman" },
  87   { "TimesNewRomanPS-Bold",         "Times-Bold" },
  88   { "TimesNewRomanPS-BoldItalic",   "Times-BoldItalic" },
  89   { "TimesNewRomanPS-BoldItalicMT", "Times-BoldItalic" },
  90   { "TimesNewRomanPS-BoldMT",       "Times-Bold" },
  91   { "TimesNewRomanPS-Italic",       "Times-Italic" },
  92   { "TimesNewRomanPS-ItalicMT",     "Times-Italic" },
  93   { "TimesNewRomanPSMT",            "Times-Roman" },
  94   { "TimesNewRomanPSMT,Bold",       "Times-Bold" },
  95   { "TimesNewRomanPSMT,BoldItalic", "Times-BoldItalic" },
  96   { "TimesNewRomanPSMT,Italic",     "Times-Italic" }
  97 };
  98
  99 //------------------------------------------------------------------------
 100 // GfxFont
 101 //------------------------------------------------------------------------
 102
 103 GfxFont *GfxFont::makeFont(XRef *xref, char *tagA, Ref idA, Dict *fontDict) {
 104   GString *nameA;
 105   GfxFont *font;
 106   Object obj1;
 107
 108   // get base font name
 109   nameA = NULL;
 110   fontDict->lookup("BaseFont", &obj1);
 111   if (obj1.isName()) {
 112     nameA = new GString(obj1.getName());
 113   }
 114   obj1.free();
 115
 116   // get font type
 117   font = NULL;
 118   fontDict->lookup("Subtype", &obj1);
 119   if (obj1.isName("Type1") || obj1.isName("MMType1")) {
 120     font = new Gfx8BitFont(xref, tagA, idA, nameA, fontType1, fontDict);
 121   } else if (obj1.isName("Type1C")) {
 122     font = new Gfx8BitFont(xref, tagA, idA, nameA, fontType1C, fontDict);
 123   } else if (obj1.isName("Type3")) {
 124     font = new Gfx8BitFont(xref, tagA, idA, nameA, fontType3, fontDict);
 125   } else if (obj1.isName("TrueType")) {
 126     font = new Gfx8BitFont(xref, tagA, idA, nameA, fontTrueType, fontDict);
 127   } else if (obj1.isName("Type0")) {
 128     font = new GfxCIDFont(xref, tagA, idA, nameA, fontDict);
 129   } else {
 130     error(-1, "Unknown font type: '%s'",
 131           obj1.isName() ? obj1.getName() : "???");
 132     font = new Gfx8BitFont(xref, tagA, idA, nameA, fontUnknownType, fontDict);
 133   }
 134   obj1.free();
 135
 136   return font;
 137 }
 138
 139 GfxFont::GfxFont(char *tagA, Ref idA, GString *nameA) {
 140   ok = gFalse;
 141   tag = new GString(tagA);
 142   id = idA;
 143   name = nameA;
 144   origName = nameA;
 145   embFontName = NULL;
 146   extFontFile = NULL;
 147 }
 148
 149 GfxFont::~GfxFont() {
 150   delete tag;
 151   if (origName && origName != name) {
 152     delete origName;
 153   }
 154   if (name) {
 155     delete name;
 156   }
 157   if (embFontName) {
 158     delete embFontName;
 159   }
 160   if (extFontFile) {
 161     delete extFontFile;
 162   }
 163 }
 164
 165 void GfxFont::readFontDescriptor(XRef *xref, Dict *fontDict) {
 166   Object obj1, obj2, obj3, obj4;
 167   double t;
 168   int i;
 169
 170   // assume Times-Roman by default (for substitution purposes)
 171   flags = fontSerif;
 172
 173   embFontID.num = -1;
 174   embFontID.gen = -1;
 175   missingWidth = 0;
 176
 177   if (fontDict->lookup("FontDescriptor", &obj1)->isDict()) {
 178
 179     // get flags
 180     if (obj1.dictLookup("Flags", &obj2)->isInt()) {
 181       flags = obj2.getInt();
 182     }
 183     obj2.free();
 184
 185     // get name
 186     obj1.dictLookup("FontName", &obj2);
 187     if (obj2.isName()) {
 188       embFontName = new GString(obj2.getName());
 189     }
 190     obj2.free();
 191
 192     // look for embedded font file
 193     if (obj1.dictLookupNF("FontFile", &obj2)->isRef()) {
 194       if (type == fontType1) {
 195         embFontID = obj2.getRef();
 196       } else {
 197         error(-1, "Mismatch between font type and embedded font file");
 198       }
 199     }
 200     obj2.free();
 201     if (embFontID.num == -1 &&
 202         obj1.dictLookupNF("FontFile2", &obj2)->isRef()) {
 203       if (type == fontTrueType || type == fontCIDType2) {
 204         embFontID = obj2.getRef();
 205       } else {
 206         error(-1, "Mismatch between font type and embedded font file");
 207       }
 208     }
 209     obj2.free();
 210     if (embFontID.num == -1 &&
 211         obj1.dictLookupNF("FontFile3", &obj2)->isRef()) {
 212       if (obj2.fetch(xref, &obj3)->isStream()) {
 213         obj3.streamGetDict()->lookup("Subtype", &obj4);
 214         if (obj4.isName("Type1")) {
 215           if (type == fontType1) {
 216             embFontID = obj2.getRef();
 217           } else {
 218             error(-1, "Mismatch between font type and embedded font file");
 219           }
 220         } else if (obj4.isName("Type1C")) {
 221           if (type == fontType1) {
 222             type = fontType1C;
 223             embFontID = obj2.getRef();
 224           } else if (type == fontType1C) {
 225             embFontID = obj2.getRef();
 226           } else {
 227             error(-1, "Mismatch between font type and embedded font file");
 228           }
 229         } else if (obj4.isName("TrueType")) {
 230           if (type == fontTrueType) {
 231             embFontID = obj2.getRef();
 232           } else {
 233             error(-1, "Mismatch between font type and embedded font file");
 234           }
 235         } else if (obj4.isName("CIDFontType0C")) {
 236           if (type == fontCIDType0) {
 237             type = fontCIDType0C;
 238             embFontID = obj2.getRef();
 239           } else {
 240             error(-1, "Mismatch between font type and embedded font file");
 241           }
 242         } else {
 243           error(-1, "Unknown embedded font type '%s'",
 244                 obj4.isName() ? obj4.getName() : "???");
 245         }
 246         obj4.free();
 247       }
 248       obj3.free();
 249     }
 250     obj2.free();
 251
 252     // look for MissingWidth
 253     obj1.dictLookup("MissingWidth", &obj2);
 254     if (obj2.isNum()) {
 255       missingWidth = obj2.getNum();
 256     }
 257     obj2.free();
 258
 259     // get Ascent and Descent
 260     obj1.dictLookup("Ascent", &obj2);
 261     if (obj2.isNum()) {
 262       t = 0.001 * obj2.getNum();
 263       // some broken font descriptors set ascent and descent to 0
 264       if (t != 0) {
 265         ascent = t;
 266       }
 267     }
 268     obj2.free();
 269     obj1.dictLookup("Descent", &obj2);
 270     if (obj2.isNum()) {
 271       t = 0.001 * obj2.getNum();
 272       // some broken font descriptors set ascent and descent to 0
 273       if (t != 0) {
 274         descent = t;
 275       }
 276       // some broken font descriptors specify a positive descent
 277       if (descent > 0) {
 278         descent = -descent;
 279       }
 280     }
 281     obj2.free();
 282
 283     // font FontBBox
 284     if (obj1.dictLookup("FontBBox", &obj2)->isArray()) {
 285       for (i = 0; i < 4 && i < obj2.arrayGetLength(); ++i) {
 286         if (obj2.arrayGet(i, &obj3)->isNum()) {
 287           fontBBox[i] = 0.001 * obj3.getNum();
 288         }
 289         obj3.free();
 290       }
 291     }
 292     obj2.free();
 293
 294   }
 295   obj1.free();
 296 }
 297
 298 CharCodeToUnicode *GfxFont::readToUnicodeCMap(Dict *fontDict, int nBits,
 299                                               CharCodeToUnicode *ctu) {
 300   GString *buf;
 301   Object obj1;
 302   int c;
 303
 304   if (!fontDict->lookup("ToUnicode", &obj1)->isStream()) {
 305     obj1.free();
 306     return NULL;
 307   }
 308   buf = new GString();
 309   obj1.streamReset();
 310   while ((c = obj1.streamGetChar()) != EOF) {
 311     buf->append(c);
 312   }
 313   obj1.streamClose();
 314   obj1.free();
 315   if (ctu) {
 316     ctu->mergeCMap(buf, nBits);
 317   } else {
 318     ctu = CharCodeToUnicode::parseCMap(buf, nBits);
 319   }
 320   delete buf;
 321   return ctu;
 322 }
 323
 324 void GfxFont::findExtFontFile() {
 325   static char *type1Exts[] = { ".pfa", ".pfb", ".ps", "", NULL };
 326   static char *ttExts[] = { ".ttf", NULL };
 327
 328   if (name) {
 329     if (type == fontType1) {
 330       extFontFile = globalParams->findFontFile(name, type1Exts);
 331     } else if (type == fontTrueType) {
 332       extFontFile = globalParams->findFontFile(name, ttExts);
 333     }
 334   }
 335 }
 336
 337 char *GfxFont::readExtFontFile(int *len) {
 338   FILE *f;
 339   char *buf;
 340
 341   if (!(f = fopen(extFontFile->getCString(), "rb"))) {
 342     error(-1, "External font file '%s' vanished", extFontFile->getCString());
 343     return NULL;
 344   }
 345   fseek(f, 0, SEEK_END);
 346   *len = (int)ftell(f);
 347   fseek(f, 0, SEEK_SET);
 348   buf = (char *)gmalloc(*len);
 349   if ((int)fread(buf, 1, *len, f) != *len) {
 350     error(-1, "Error reading external font file '%s'",
 351           extFontFile->getCString());
 352   }
 353   fclose(f);
 354   return buf;
 355 }
 356
 357 char *GfxFont::readEmbFontFile(XRef *xref, int *len) {
 358   char *buf;
 359   Object obj1, obj2;
 360   Stream *str;
 361   int c;
 362   int size, i;
 363
 364   obj1.initRef(embFontID.num, embFontID.gen);
 365   obj1.fetch(xref, &obj2);
 366   if (!obj2.isStream()) {
 367     error(-1, "Embedded font file is not a stream");
 368     obj2.free();
 369     obj1.free();
 370     embFontID.num = -1;
 371     return NULL;
 372   }
 373   str = obj2.getStream();
 374
 375   buf = NULL;
 376   i = size = 0;
 377   str->reset();
 378   while ((c = str->getChar()) != EOF) {
 379     if (i == size) {
 380       size += 4096;
 381       buf = (char *)grealloc(buf, size);
 382     }
 383     buf[i++] = c;
 384   }
 385   *len = i;
 386   str->close();
 387
 388   obj2.free();
 389   obj1.free();
 390
 391   return buf;
 392 }
 393
 394 //------------------------------------------------------------------------
 395 // Gfx8BitFont
 396 //------------------------------------------------------------------------
 397
 398 Gfx8BitFont::Gfx8BitFont(XRef *xref, char *tagA, Ref idA, GString *nameA,
 399                          GfxFontType typeA, Dict *fontDict):
 400   GfxFont(tagA, idA, nameA)
 401 {
 402   BuiltinFont *builtinFont;
 403   char **baseEnc;
 404   GBool baseEncFromFontFile;
 405   char *buf;
 406   int len;
 407   FoFiType1 *ffT1;
 408   FoFiType1C *ffT1C;
 409   int code, code2;
 410   char *charName;
 411   GBool missing, hex;
 412   Unicode toUnicode[256];
 413   CharCodeToUnicode *utu, *ctu2;
 414   Unicode uBuf[8];
 415   double mul;
 416   int firstChar, lastChar;
 417   Gushort w;
 418   Object obj1, obj2, obj3;
 419   int n, i, a, b, m;
 420
 421   type = typeA;
 422   ctu = NULL;
 423
 424   // do font name substitution for various aliases of the Base 14 font
 425   // names
 426   if (name) {
 427     a = 0;
 428     b = sizeof(stdFontMap) / sizeof(StdFontMapEntry);
 429     // invariant: stdFontMap[a].altName <= name < stdFontMap[b].altName
 430     while (b - a > 1) {
 431       m = (a + b) / 2;
 432       if (name->cmp(stdFontMap[m].altName) >= 0) {
 433         a = m;
 434       } else {
 435         b = m;
 436       }
 437     }
 438     if (!name->cmp(stdFontMap[a].altName)) {
 439       name = new GString(stdFontMap[a].properName);
 440     }
 441   }
 442
 443   // is it a built-in font?
 444   builtinFont = NULL;
 445   if (name) {
 446     for (i = 0; i < nBuiltinFonts; ++i) {
 447       if (!name->cmp(builtinFonts[i].name)) {
 448         builtinFont = &builtinFonts[i];
 449         break;
 450       }
 451     }
 452   }
 453
 454   // default ascent/descent values
 455   if (builtinFont) {
 456     ascent = 0.001 * builtinFont->ascent;
 457     descent = 0.001 * builtinFont->descent;
 458     fontBBox[0] = 0.001 * builtinFont->bbox[0];
 459     fontBBox[1] = 0.001 * builtinFont->bbox[1];
 460     fontBBox[2] = 0.001 * builtinFont->bbox[2];
 461     fontBBox[3] = 0.001 * builtinFont->bbox[3];
 462   } else {
 463     ascent = 0.95;
 464     descent = -0.35;
 465     fontBBox[0] = fontBBox[1] = fontBBox[2] = fontBBox[3] = 0;
 466   }
 467
 468   // get info from font descriptor
 469   readFontDescriptor(xref, fontDict);
 470
 471   // look for an external font file
 472   findExtFontFile();
 473
 474   // get font matrix
 475   fontMat[0] = fontMat[3] = 1;
 476   fontMat[1] = fontMat[2] = fontMat[4] = fontMat[5] = 0;
 477   if (fontDict->lookup("FontMatrix", &obj1)->isArray()) {
 478     for (i = 0; i < 6 && i < obj1.arrayGetLength(); ++i) {
 479       if (obj1.arrayGet(i, &obj2)->isNum()) {
 480         fontMat[i] = obj2.getNum();
 481       }
 482       obj2.free();
 483     }
 484   }
 485   obj1.free();
 486
 487   // get Type 3 bounding box, font definition, and resources
 488   if (type == fontType3) {
 489     if (fontDict->lookup("FontBBox", &obj1)->isArray()) {
 490       for (i = 0; i < 4 && i < obj1.arrayGetLength(); ++i) {
 491         if (obj1.arrayGet(i, &obj2)->isNum()) {
 492           fontBBox[i] = obj2.getNum();
 493         }
 494         obj2.free();
 495       }
 496     }
 497     obj1.free();
 498     if (!fontDict->lookup("CharProcs", &charProcs)->isDict()) {
 499       error(-1, "Missing or invalid CharProcs dictionary in Type 3 font");
 500       charProcs.free();
 501     }
 502     if (!fontDict->lookup("Resources", &resources)->isDict()) {
 503       resources.free();
 504     }
 505   }
 506
 507   //----- build the font encoding -----
 508
 509   // Encodings start with a base encoding, which can come from
 510   // (in order of priority):
 511   //   1. FontDict.Encoding or FontDict.Encoding.BaseEncoding
 512   //        - MacRoman / MacExpert / WinAnsi / Standard
 513   //   2. embedded or external font file
 514   //   3. default:
 515   //        - builtin --> builtin encoding
 516   //        - TrueType --> MacRomanEncoding
 517   //        - others --> StandardEncoding
 518   // and then add a list of differences (if any) from
 519   // FontDict.Encoding.Differences.
 520
 521   // check FontDict for base encoding
 522   hasEncoding = gFalse;
 523   usesMacRomanEnc = gFalse;
 524   baseEnc = NULL;
 525   baseEncFromFontFile = gFalse;
 526   fontDict->lookup("Encoding", &obj1);
 527   if (obj1.isDict()) {
 528     obj1.dictLookup("BaseEncoding", &obj2);
 529     if (obj2.isName("MacRomanEncoding")) {
 530       hasEncoding = gTrue;
 531       usesMacRomanEnc = gTrue;
 532       baseEnc = macRomanEncoding;
 533     } else if (obj2.isName("MacExpertEncoding")) {
 534       hasEncoding = gTrue;
 535       baseEnc = macExpertEncoding;
 536     } else if (obj2.isName("WinAnsiEncoding")) {
 537       hasEncoding = gTrue;
 538       baseEnc = winAnsiEncoding;
 539     } else if (obj2.isName("StandardEncoding")) {
 540       hasEncoding = gTrue;
 541       baseEnc = standardEncoding;
 542     }
 543     obj2.free();
 544   } else if (obj1.isName("MacRomanEncoding")) {
 545     hasEncoding = gTrue;
 546     usesMacRomanEnc = gTrue;
 547     baseEnc = macRomanEncoding;
 548   } else if (obj1.isName("MacExpertEncoding")) {
 549     hasEncoding = gTrue;
 550     baseEnc = macExpertEncoding;
 551   } else if (obj1.isName("WinAnsiEncoding")) {
 552     hasEncoding = gTrue;
 553     baseEnc = winAnsiEncoding;
 554   } else if (obj1.isName("StandardEncoding")) {
 555     hasEncoding = gTrue;
 556     baseEnc = standardEncoding;
 557   }
 558
 559   // check embedded or external font file for base encoding
 560   // (only for Type 1 fonts - trying to get an encoding out of a
 561   // TrueType font is a losing proposition)
 562   ffT1 = NULL;
 563   ffT1C = NULL;
 564   buf = NULL;
 565   if (type == fontType1 && (extFontFile || embFontID.num >= 0)) {
 566     if (extFontFile) {
 567       ffT1 = FoFiType1::load(extFontFile->getCString());
 568     } else {
 569       buf = readEmbFontFile(xref, &len);
 570       ffT1 = FoFiType1::make(buf, len);
 571     }
 572     if (ffT1) {
 573       if (ffT1->getName()) {
 574         if (embFontName) {
 575           delete embFontName;
 576         }
 577         embFontName = new GString(ffT1->getName());
 578       }
 579       if (!baseEnc) {
 580         baseEnc = ffT1->getEncoding();
 581         baseEncFromFontFile = gTrue;
 582       }
 583     }
 584   } else if (type == fontType1C && (extFontFile || embFontID.num >= 0)) {
 585     if (extFontFile) {
 586       ffT1C = FoFiType1C::load(extFontFile->getCString());
 587     } else {
 588       buf = readEmbFontFile(xref, &len);
 589       ffT1C = FoFiType1C::make(buf, len);
 590     }
 591     if (ffT1C) {
 592       if (ffT1C->getName()) {
 593         if (embFontName) {
 594           delete embFontName;
 595         }
 596         embFontName = new GString(ffT1C->getName());
 597       }
 598       if (!baseEnc) {
 599         baseEnc = ffT1C->getEncoding();
 600         baseEncFromFontFile = gTrue;
 601       }
 602     }
 603   }
 604   if (buf) {
 605     gfree(buf);
 606   }
 607
 608   // get default base encoding
 609   if (!baseEnc) {
 610     if (builtinFont) {
 611       baseEnc = builtinFont->defaultBaseEnc;
 612       hasEncoding = gTrue;
 613     } else if (type == fontTrueType) {
 614       baseEnc = winAnsiEncoding;
 615     } else {
 616       baseEnc = standardEncoding;
 617     }
 618   }
 619
 620   // copy the base encoding
 621   for (i = 0; i < 256; ++i) {
 622     enc[i] = baseEnc[i];
 623     if ((encFree[i] = baseEncFromFontFile) && enc[i]) {
 624       enc[i] = copyString(baseEnc[i]);
 625     }
 626   }
 627
 628   // some Type 1C font files have empty encodings, which can break the
 629   // T1C->T1 conversion (since the 'seac' operator depends on having
 630   // the accents in the encoding), so we fill in any gaps from
 631   // StandardEncoding
 632   if (type == fontType1C && (extFontFile || embFontID.num >= 0) &&
 633       baseEncFromFontFile) {
 634     for (i = 0; i < 256; ++i) {
 635       if (!enc[i] && standardEncoding[i]) {
 636         enc[i] = standardEncoding[i];
 637         encFree[i] = gFalse;
 638       }
 639     }
 640   }
 641
 642   // merge differences into encoding
 643   if (obj1.isDict()) {
 644     obj1.dictLookup("Differences", &obj2);
 645     if (obj2.isArray()) {
 646       hasEncoding = gTrue;
 647       code = 0;
 648       for (i = 0; i < obj2.arrayGetLength(); ++i) {
 649         obj2.arrayGet(i, &obj3);
 650         if (obj3.isInt()) {
 651           code = obj3.getInt();
 652         } else if (obj3.isName()) {
 653           if (code >= 0 && code < 256) {
 654             if (encFree[code]) {
 655               gfree(enc[code]);
 656             }
 657             enc[code] = copyString(obj3.getName());
 658             encFree[code] = gTrue;
 659           }
 660           ++code;
 661         } else {
 662           error(-1, "Wrong type in font encoding resource differences (%s)",
 663                 obj3.getTypeName());
 664         }
 665         obj3.free();
 666       }
 667     }
 668     obj2.free();
 669   }
 670   obj1.free();
 671   if (ffT1) {
 672     delete ffT1;
 673   }
 674   if (ffT1C) {
 675     delete ffT1C;
 676   }
 677
 678   //----- build the mapping to Unicode -----
 679
 680   // pass 1: use the name-to-Unicode mapping table
 681   missing = hex = gFalse;
 682   for (code = 0; code < 256; ++code) {
 683     if ((charName = enc[code])) {
 684       if (!(toUnicode[code] = globalParams->mapNameToUnicode(charName)) &&
 685           strcmp(charName, ".notdef")) {
 686         // if it wasn't in the name-to-Unicode table, check for a
 687         // name that looks like 'Axx' or 'xx', where 'A' is any letter
 688         // and 'xx' is two hex digits
 689         if ((strlen(charName) == 3 &&
 690              isalpha(charName[0]) &&
 691              isxdigit(charName[1]) && isxdigit(charName[2]) &&
 692              ((charName[1] >= 'a' && charName[1] <= 'f') ||
 693               (charName[1] >= 'A' && charName[1] <= 'F') ||
 694               (charName[2] >= 'a' && charName[2] <= 'f') ||
 695               (charName[2] >= 'A' && charName[2] <= 'F'))) ||
 696             (strlen(charName) == 2 &&
 697              isxdigit(charName[0]) && isxdigit(charName[1]) &&
 698              ((charName[0] >= 'a' && charName[0] <= 'f') ||
 699               (charName[0] >= 'A' && charName[0] <= 'F') ||
 700               (charName[1] >= 'a' && charName[1] <= 'f') ||
 701               (charName[1] >= 'A' && charName[1] <= 'F')))) {
 702           hex = gTrue;
 703         }
 704         missing = gTrue;
 705       }
 706     } else {
 707       toUnicode[code] = 0;
 708     }
 709   }
 710
 711   // pass 2: try to fill in the missing chars, looking for names of
 712   // the form 'Axx', 'xx', 'Ann', 'ABnn', or 'nn', where 'A' and 'B'
 713   // are any letters, 'xx' is two hex digits, and 'nn' is 2-4
 714   // decimal digits
 715   if (missing && globalParams->getMapNumericCharNames()) {
 716     for (code = 0; code < 256; ++code) {
 717       if ((charName = enc[code]) && !toUnicode[code] &&
 718           strcmp(charName, ".notdef")) {
 719         n = strlen(charName);
 720         code2 = -1;
 721         if (hex && n == 3 && isalpha(charName[0]) &&
 722             isxdigit(charName[1]) && isxdigit(charName[2])) {
 723           sscanf(charName+1, "%x", &code2);
 724         } else if (hex && n == 2 &&
 725                    isxdigit(charName[0]) && isxdigit(charName[1])) {
 726           sscanf(charName, "%x", &code2);
 727         } else if (!hex && n >= 2 && n <= 4 &&
 728                    isdigit(charName[0]) && isdigit(charName[1])) {
 729           code2 = atoi(charName);
 730         } else if (n >= 3 && n <= 5 &&
 731                    isdigit(charName[1]) && isdigit(charName[2])) {
 732           code2 = atoi(charName+1);
 733         } else if (n >= 4 && n <= 6 &&
 734                    isdigit(charName[2]) && isdigit(charName[3])) {
 735           code2 = atoi(charName+2);
 736         }
 737         if (code2 >= 0 && code2 <= 0xff) {
 738           toUnicode[code] = (Unicode)code2;
 739         }
 740       }
 741     }
 742   }
 743
 744   // construct the char code -> Unicode mapping object
 745   ctu = CharCodeToUnicode::make8BitToUnicode(toUnicode);
 746
 747   // merge in a ToUnicode CMap, if there is one -- this overwrites
 748   // existing entries in ctu, i.e., the ToUnicode CMap takes
 749   // precedence, but the other encoding info is allowed to fill in any
 750   // holes
 751   readToUnicodeCMap(fontDict, 8, ctu);
 752
 753   // look for a Unicode-to-Unicode mapping
 754   if (name && (utu = globalParams->getUnicodeToUnicode(name))) {
 755     for (i = 0; i < 256; ++i) {
 756       toUnicode[i] = 0;
 757     }
 758     ctu2 = CharCodeToUnicode::make8BitToUnicode(toUnicode);
 759     for (i = 0; i < 256; ++i) {
 760       n = ctu->mapToUnicode((CharCode)i, uBuf, 8);
 761       if (n >= 1) {
 762         n = utu->mapToUnicode((CharCode)uBuf[0], uBuf, 8);
 763         if (n >= 1) {
 764           ctu2->setMapping((CharCode)i, uBuf, n);
 765         }
 766       }
 767     }
 768     utu->decRefCnt();
 769     delete ctu;
 770     ctu = ctu2;
 771   }
 772
 773   //----- get the character widths -----
 774
 775   // initialize all widths
 776   for (code = 0; code < 256; ++code) {
 777     widths[code] = missingWidth * 0.001;
 778   }
 779
 780   // use widths from font dict, if present
 781   fontDict->lookup("FirstChar", &obj1);
 782   firstChar = obj1.isInt() ? obj1.getInt() : 0;
 783   obj1.free();
 784   if (firstChar < 0 || firstChar > 255) {
 785     firstChar = 0;
 786   }
 787   fontDict->lookup("LastChar", &obj1);
 788   lastChar = obj1.isInt() ? obj1.getInt() : 255;
 789   obj1.free();
 790   if (lastChar < 0 || lastChar > 255) {
 791     lastChar = 255;
 792   }
 793   mul = (type == fontType3) ? fontMat[0] : 0.001;
 794   fontDict->lookup("Widths", &obj1);
 795   if (obj1.isArray()) {
 796     flags |= fontFixedWidth;
 797     if (obj1.arrayGetLength() < lastChar - firstChar + 1) {
 798       lastChar = firstChar + obj1.arrayGetLength() - 1;
 799     }
 800     for (code = firstChar; code <= lastChar; ++code) {
 801       obj1.arrayGet(code - firstChar, &obj2);
 802       if (obj2.isNum()) {
 803         widths[code] = obj2.getNum() * mul;
 804         if (widths[code] != widths[firstChar]) {
 805           flags &= ~fontFixedWidth;
 806         }
 807       }
 808       obj2.free();
 809     }
 810
 811   // use widths from built-in font
 812   } else if (builtinFont) {
 813     // this is a kludge for broken PDF files that encode char 32
 814     // as .notdef
 815     if (builtinFont->widths->getWidth("space", &w)) {
 816       widths[32] = 0.001 * w;
 817     }
 818     for (code = 0; code < 256; ++code) {
 819       if (enc[code] && builtinFont->widths->getWidth(enc[code], &w)) {
 820         widths[code] = 0.001 * w;
 821       }
 822     }
 823
 824   // couldn't find widths -- use defaults
 825   } else {
 826     // this is technically an error -- the Widths entry is required
 827     // for all but the Base-14 fonts -- but certain PDF generators
 828     // apparently don't include widths for Arial and TimesNewRoman
 829     if (isFixedWidth()) {
 830       i = 0;
 831     } else if (isSerif()) {
 832       i = 8;
 833     } else {
 834       i = 4;
 835     }
 836     if (isBold()) {
 837       i += 2;
 838     }
 839     if (isItalic()) {
 840       i += 1;
 841     }
 842     builtinFont = builtinFontSubst[i];
 843     // this is a kludge for broken PDF files that encode char 32
 844     // as .notdef
 845     if (builtinFont->widths->getWidth("space", &w)) {
 846       widths[32] = 0.001 * w;
 847     }
 848     for (code = 0; code < 256; ++code) {
 849       if (enc[code] && builtinFont->widths->getWidth(enc[code], &w)) {
 850         widths[code] = 0.001 * w;
 851       }
 852     }
 853   }
 854   obj1.free();
 855
 856   ok = gTrue;
 857 }
 858
 859 Gfx8BitFont::~Gfx8BitFont() {
 860   int i;
 861
 862   for (i = 0; i < 256; ++i) {
 863     if (encFree[i] && enc[i]) {
 864       gfree(enc[i]);
 865     }
 866   }
 867   ctu->decRefCnt();
 868   if (charProcs.isDict()) {
 869     charProcs.free();
 870   }
 871   if (resources.isDict()) {
 872     resources.free();
 873   }
 874 }
 875
 876 int Gfx8BitFont::getNextChar(char *s, int len, CharCode *code,
 877                              Unicode *u, int uSize, int *uLen,
 878                              double *dx, double *dy, double *ox, double *oy) {
 879   CharCode c;
 880
 881   *code = c = (CharCode)(*s & 0xff);
 882   *uLen = ctu->mapToUnicode(c, u, uSize);
 883   *dx = widths[c];
 884   *dy = *ox = *oy = 0;
 885   return 1;
 886 }
 887
 888 CharCodeToUnicode *Gfx8BitFont::getToUnicode() {
 889   ctu->incRefCnt();
 890   return ctu;
 891 }
 892
 893 Gushort *Gfx8BitFont::getCodeToGIDMap(FoFiTrueType *ff) {
 894   Gushort *map;
 895   int cmapPlatform, cmapEncoding;
 896   int unicodeCmap, macRomanCmap, msSymbolCmap, cmap;
 897   GBool useMacRoman, useUnicode;
 898   char *charName;
 899   Unicode u;
 900   int code, i, n;
 901
 902   map = (Gushort *)gmalloc(256 * sizeof(Gushort));
 903   for (i = 0; i < 256; ++i) {
 904     map[i] = 0;
 905   }
 906
 907   // To match up with the Adobe-defined behaviour, we choose a cmap
 908   // like this:
 909   // 1. If the PDF font has an encoding:
 910   //    1a. If the PDF font specified MacRomanEncoding and the
 911   //        TrueType font has a Macintosh Roman cmap, use it, and
 912   //        reverse map the char names through MacRomanEncoding to
 913   //        get char codes.
 914   //    1b. If the TrueType font has a Microsoft Unicode cmap or a
 915   //        non-Microsoft Unicode cmap, use it, and use the Unicode
 916   //        indexes, not the char codes.
 917   //    1c. If the PDF font is symbolic and the TrueType font has a
 918   //        Microsoft Symbol cmap, use it, and use char codes
 919   //        directly (possibly with an offset of 0xf000).
 920   //    1d. If the TrueType font has a Macintosh Roman cmap, use it,
 921   //        as in case 1a.
 922   // 2. If the PDF font does not have an encoding:
 923   //    2a. If the TrueType font has a Macintosh Roman cmap, use it,
 924   //        and use char codes directly (possibly with an offset of
 925   //        0xf000).
 926   //    2b. If the TrueType font has a Microsoft Symbol cmap, use it,
 927   //        and use char codes directly (possible with an offset of
 928   //        0xf000).
 929   // 3. If none of these rules apply, use the first cmap and hope for
 930   //    the best (this shouldn't happen).
 931   unicodeCmap = macRomanCmap = msSymbolCmap = -1;
 932   for (i = 0; i < ff->getNumCmaps(); ++i) {
 933     cmapPlatform = ff->getCmapPlatform(i);
 934     cmapEncoding = ff->getCmapEncoding(i);
 935     if ((cmapPlatform == 3 && cmapEncoding == 1) ||
 936         cmapPlatform == 0) {
 937       unicodeCmap = i;
 938     } else if (cmapPlatform == 1 && cmapEncoding == 0) {
 939       macRomanCmap = i;
 940     } else if (cmapPlatform == 3 && cmapEncoding == 0) {
 941       msSymbolCmap = i;
 942     }
 943   }
 944   cmap = 0;
 945   useMacRoman = gFalse;
 946   useUnicode = gFalse;
 947   if (hasEncoding) {
 948     if (usesMacRomanEnc && macRomanCmap >= 0) {
 949       cmap = macRomanCmap;
 950       useMacRoman = gTrue;
 951     } else if (unicodeCmap >= 0) {
 952       cmap = unicodeCmap;
 953       useUnicode = gTrue;
 954     } else if ((flags & fontSymbolic) && msSymbolCmap >= 0) {
 955       cmap = msSymbolCmap;
 956     } else if (macRomanCmap >= 0) {
 957       cmap = macRomanCmap;
 958       useMacRoman = gTrue;
 959     }
 960   } else {
 961     if (macRomanCmap >= 0) {
 962       cmap = macRomanCmap;
 963     } else if (msSymbolCmap >= 0) {
 964       cmap = msSymbolCmap;
 965     }
 966   }
 967
 968   // reverse map the char names through MacRomanEncoding, then map the
 969   // char codes through the cmap
 970   if (useMacRoman) {
 971     for (i = 0; i < 256; ++i) {
 972       if ((charName = enc[i])) {
 973         if ((code = globalParams->getMacRomanCharCode(charName))) {
 974           map[i] = ff->mapCodeToGID(cmap, code);
 975         }
 976       }
 977     }
 978
 979   // map Unicode through the cmap
 980   } else if (useUnicode) {
 981     for (i = 0; i < 256; ++i) {
 982       if ((n = ctu->mapToUnicode((CharCode)i, &u, 1))) {
 983         map[i] = ff->mapCodeToGID(cmap, u);
 984       }
 985     }
 986
 987   // map the char codes through the cmap, possibly with an offset of
 988   // 0xf000
 989   } else {
 990     for (i = 0; i < 256; ++i) {
 991       if (!(map[i] = ff->mapCodeToGID(cmap, i))) {
 992         map[i] = ff->mapCodeToGID(cmap, 0xf000 + i);
 993       }
 994     }
 995   }
 996
 997   // try the TrueType 'post' table to handle any unmapped characters
 998   for (i = 0; i < 256; ++i) {
 999     if (!map[i] && (charName = enc[i])) {
1000       map[i] = (Gushort)(int)ff->mapNameToGID(charName);
1001     }
1002   }
1003
1004   return map;
1005 }
1006
1007 Dict *Gfx8BitFont::getCharProcs() {
1008   return charProcs.isDict() ? charProcs.getDict() : (Dict *)NULL;
1009 }
1010
1011 Object *Gfx8BitFont::getCharProc(int code, Object *proc) {
1012   if (enc[code] && charProcs.isDict()) {
1013     charProcs.dictLookup(enc[code], proc);
1014   } else {
1015     proc->initNull();
1016   }
1017   return proc;
1018 }
1019
1020 Dict *Gfx8BitFont::getResources() {
1021   return resources.isDict() ? resources.getDict() : (Dict *)NULL;
1022 }
1023
1024 //------------------------------------------------------------------------
1025 // GfxCIDFont
1026 //------------------------------------------------------------------------
1027
1028 static int CDECL cmpWidthExcep(const void *w1, const void *w2) {
1029   return ((GfxFontCIDWidthExcep *)w1)->first -
1030          ((GfxFontCIDWidthExcep *)w2)->first;
1031 }
1032
1033 static int CDECL cmpWidthExcepV(const void *w1, const void *w2) {
1034   return ((GfxFontCIDWidthExcepV *)w1)->first -
1035          ((GfxFontCIDWidthExcepV *)w2)->first;
1036 }
1037
1038 GfxCIDFont::GfxCIDFont(XRef *xref, char *tagA, Ref idA, GString *nameA,
1039                        Dict *fontDict):
1040   GfxFont(tagA, idA, nameA)
1041 {
1042   Dict *desFontDict;
1043   GString *collection, *cMapName;
1044   Object desFontDictObj;
1045   Object obj1, obj2, obj3, obj4, obj5, obj6;
1046   int c1, c2;
1047   int excepsSize, i, j, k;
1048
1049   ascent = 0.95;
1050   descent = -0.35;
1051   fontBBox[0] = fontBBox[1] = fontBBox[2] = fontBBox[3] = 0;
1052   cMap = NULL;
1053   ctu = NULL;
1054   widths.defWidth = 1.0;
1055   widths.defHeight = -1.0;
1056   widths.defVY = 0.880;
1057   widths.exceps = NULL;
1058   widths.nExceps = 0;
1059   widths.excepsV = NULL;
1060   widths.nExcepsV = 0;
1061   cidToGID = NULL;
1062   cidToGIDLen = 0;
1063
1064   // get the descendant font
1065   if (!fontDict->lookup("DescendantFonts", &obj1)->isArray()) {
1066     error(-1, "Missing DescendantFonts entry in Type 0 font");
1067     obj1.free();
1068     goto err1;
1069   }
1070   if (!obj1.arrayGet(0, &desFontDictObj)->isDict()) {
1071     error(-1, "Bad descendant font in Type 0 font");
1072     goto err3;
1073   }
1074   obj1.free();
1075   desFontDict = desFontDictObj.getDict();
1076
1077   // font type
1078   if (!desFontDict->lookup("Subtype", &obj1)) {
1079     error(-1, "Missing Subtype entry in Type 0 descendant font");
1080     goto err3;
1081   }
1082   if (obj1.isName("CIDFontType0")) {
1083     type = fontCIDType0;
1084   } else if (obj1.isName("CIDFontType2")) {
1085     type = fontCIDType2;
1086   } else {
1087     error(-1, "Unknown Type 0 descendant font type '%s'",
1088           obj1.isName() ? obj1.getName() : "???");
1089     goto err3;
1090   }
1091   obj1.free();
1092
1093   // get info from font descriptor
1094   readFontDescriptor(xref, desFontDict);
1095
1096   // look for an external font file
1097   findExtFontFile();
1098
1099   //----- encoding info -----
1100
1101   // char collection
1102   if (!desFontDict->lookup("CIDSystemInfo", &obj1)->isDict()) {
1103     error(-1, "Missing CIDSystemInfo dictionary in Type 0 descendant font");
1104     goto err3;
1105   }
1106   obj1.dictLookup("Registry", &obj2);
1107   obj1.dictLookup("Ordering", &obj3);
1108   if (!obj2.isString() || !obj3.isString()) {
1109     error(-1, "Invalid CIDSystemInfo dictionary in Type 0 descendant font");
1110     goto err4;
1111   }
1112   collection = obj2.getString()->copy()->append('-')->append(obj3.getString());
1113   obj3.free();
1114   obj2.free();
1115   obj1.free();
1116
1117   // look for a ToUnicode CMap
1118   if (!(ctu = readToUnicodeCMap(fontDict, 16, NULL))) {
1119
1120     // the "Adobe-Identity" and "Adobe-UCS" collections don't have
1121     // cidToUnicode files
1122     if (collection->cmp("Adobe-Identity") &&
1123         collection->cmp("Adobe-UCS")) {
1124
1125       // look for a user-supplied .cidToUnicode file
1126       if (!(ctu = globalParams->getCIDToUnicode(collection))) {
1127         error(-1, "Unknown character collection '%s'",
1128               collection->getCString());
1129         delete collection;
1130         goto err2;
1131       }
1132     }
1133   }
1134
1135   // encoding (i.e., CMap)
1136   //~ need to handle a CMap stream here
1137   //~ also need to deal with the UseCMap entry in the stream dict
1138   if (!fontDict->lookup("Encoding", &obj1)->isName()) {
1139     error(-1, "Missing or invalid Encoding entry in Type 0 font");
1140     delete collection;
1141     goto err3;
1142   }
1143   cMapName = new GString(obj1.getName());
1144   obj1.free();
1145   if (!(cMap = globalParams->getCMap(collection, cMapName))) {
1146     error(-1, "Unknown CMap '%s' for character collection '%s'",
1147           cMapName->getCString(), collection->getCString());
1148     delete collection;
1149     delete cMapName;
1150     goto err2;
1151   }
1152   delete collection;
1153   delete cMapName;
1154
1155   // CIDToGIDMap (for embedded TrueType fonts)
1156   if (type == fontCIDType2) {
1157     desFontDict->lookup("CIDToGIDMap", &obj1);
1158     if (obj1.isStream()) {
1159       cidToGIDLen = 0;
1160       i = 64;
1161       cidToGID = (Gushort *)gmalloc(i * sizeof(Gushort));
1162       obj1.streamReset();
1163       while ((c1 = obj1.streamGetChar()) != EOF &&
1164              (c2 = obj1.streamGetChar()) != EOF) {
1165         if (cidToGIDLen == i) {
1166           i *= 2;
1167           cidToGID = (Gushort *)grealloc(cidToGID, i * sizeof(Gushort));
1168         }
1169         cidToGID[cidToGIDLen++] = (Gushort)((c1 << 8) + c2);
1170       }
1171     } else if (!obj1.isName("Identity") && !obj1.isNull()) {
1172       error(-1, "Invalid CIDToGIDMap entry in CID font");
1173     }
1174     obj1.free();
1175   }
1176
1177   //----- character metrics -----
1178
1179   // default char width
1180   if (desFontDict->lookup("DW", &obj1)->isInt()) {
1181     widths.defWidth = obj1.getInt() * 0.001;
1182   }
1183   obj1.free();
1184
1185   // char width exceptions
1186   if (desFontDict->lookup("W", &obj1)->isArray()) {
1187     excepsSize = 0;
1188     i = 0;
1189     while (i + 1 < obj1.arrayGetLength()) {
1190       obj1.arrayGet(i, &obj2);
1191       obj1.arrayGet(i + 1, &obj3);
1192       if (obj2.isInt() && obj3.isInt() && i + 2 < obj1.arrayGetLength()) {
1193         if (obj1.arrayGet(i + 2, &obj4)->isNum()) {
1194           if (widths.nExceps == excepsSize) {
1195             excepsSize += 16;
1196             widths.exceps = (GfxFontCIDWidthExcep *)
1197               grealloc(widths.exceps,
1198                        excepsSize * sizeof(GfxFontCIDWidthExcep));
1199           }
1200           widths.exceps[widths.nExceps].first = obj2.getInt();
1201           widths.exceps[widths.nExceps].last = obj3.getInt();
1202           widths.exceps[widths.nExceps].width = obj4.getNum() * 0.001;
1203           ++widths.nExceps;
1204         } else {
1205           error(-1, "Bad widths array in Type 0 font");
1206         }
1207         obj4.free();
1208         i += 3;
1209       } else if (obj2.isInt() && obj3.isArray()) {
1210         if (widths.nExceps + obj3.arrayGetLength() > excepsSize) {
1211           excepsSize = (widths.nExceps + obj3.arrayGetLength() + 15) & ~15;
1212           widths.exceps = (GfxFontCIDWidthExcep *)
1213             grealloc(widths.exceps,
1214                      excepsSize * sizeof(GfxFontCIDWidthExcep));
1215         }
1216         j = obj2.getInt();
1217         for (k = 0; k < obj3.arrayGetLength(); ++k) {
1218           if (obj3.arrayGet(k, &obj4)->isNum()) {
1219             widths.exceps[widths.nExceps].first = j;
1220             widths.exceps[widths.nExceps].last = j;
1221             widths.exceps[widths.nExceps].width = obj4.getNum() * 0.001;
1222             ++j;
1223             ++widths.nExceps;
1224           } else {
1225             error(-1, "Bad widths array in Type 0 font");
1226           }
1227           obj4.free();
1228         }
1229         i += 2;
1230       } else {
1231         error(-1, "Bad widths array in Type 0 font");
1232         ++i;
1233       }
1234       obj3.free();
1235       obj2.free();
1236     }
1237     qsort(widths.exceps, widths.nExceps, sizeof(GfxFontCIDWidthExcep),
1238           &cmpWidthExcep);
1239   }
1240   obj1.free();
1241
1242   // default metrics for vertical font
1243   if (desFontDict->lookup("DW2", &obj1)->isArray() &&
1244       obj1.arrayGetLength() == 2) {
1245     if (obj1.arrayGet(0, &obj2)->isNum()) {
1246       widths.defVY = obj2.getNum() * 0.001;
1247     }
1248     obj2.free();
1249     if (obj1.arrayGet(1, &obj2)->isNum()) {
1250       widths.defHeight = obj2.getNum() * 0.001;
1251     }
1252     obj2.free();
1253   }
1254   obj1.free();
1255
1256   // char metric exceptions for vertical font
1257   if (desFontDict->lookup("W2", &obj1)->isArray()) {
1258     excepsSize = 0;
1259     i = 0;
1260     while (i + 1 < obj1.arrayGetLength()) {
1261       obj1.arrayGet(i, &obj2);
1262       obj1.arrayGet(i+ 1, &obj3);
1263       if (obj2.isInt() && obj3.isInt() && i + 4 < obj1.arrayGetLength()) {
1264         if (obj1.arrayGet(i + 2, &obj4)->isNum() &&
1265             obj1.arrayGet(i + 3, &obj5)->isNum() &&
1266             obj1.arrayGet(i + 4, &obj6)->isNum()) {
1267           if (widths.nExcepsV == excepsSize) {
1268             excepsSize += 16;
1269             widths.excepsV = (GfxFontCIDWidthExcepV *)
1270               grealloc(widths.excepsV,
1271                        excepsSize * sizeof(GfxFontCIDWidthExcepV));
1272           }
1273           widths.excepsV[widths.nExcepsV].first = obj2.getInt();
1274           widths.excepsV[widths.nExcepsV].last = obj3.getInt();
1275           widths.excepsV[widths.nExcepsV].height = obj4.getNum() * 0.001;
1276           widths.excepsV[widths.nExcepsV].vx = obj5.getNum() * 0.001;
1277           widths.excepsV[widths.nExcepsV].vy = obj6.getNum() * 0.001;
1278           ++widths.nExcepsV;
1279         } else {
1280           error(-1, "Bad widths (W2) array in Type 0 font");
1281         }
1282         obj6.free();
1283         obj5.free();
1284         obj4.free();
1285         i += 5;
1286       } else if (obj2.isInt() && obj3.isArray()) {
1287         if (widths.nExcepsV + obj3.arrayGetLength() / 3 > excepsSize) {
1288           excepsSize =
1289             (widths.nExcepsV + obj3.arrayGetLength() / 3 + 15) & ~15;
1290           widths.excepsV = (GfxFontCIDWidthExcepV *)
1291             grealloc(widths.excepsV,
1292                      excepsSize * sizeof(GfxFontCIDWidthExcepV));
1293         }
1294         j = obj2.getInt();
1295         for (k = 0; k < obj3.arrayGetLength(); k += 3) {
1296           if (obj3.arrayGet(k, &obj4)->isNum() &&
1297               obj3.arrayGet(k+1, &obj5)->isNum() &&
1298               obj3.arrayGet(k+2, &obj6)->isNum()) {
1299             widths.excepsV[widths.nExceps].first = j;
1300             widths.excepsV[widths.nExceps].last = j;
1301             widths.excepsV[widths.nExceps].height = obj4.getNum() * 0.001;
1302             widths.excepsV[widths.nExceps].vx = obj5.getNum() * 0.001;
1303             widths.excepsV[widths.nExceps].vy = obj6.getNum() * 0.001;
1304             ++j;
1305             ++widths.nExcepsV;
1306           } else {
1307             error(-1, "Bad widths (W2) array in Type 0 font");
1308           }
1309           obj6.free();
1310           obj5.free();
1311           obj4.free();
1312         }
1313         i += 2;
1314       } else {
1315         error(-1, "Bad widths (W2) array in Type 0 font");
1316         ++i;
1317       }
1318       obj3.free();
1319       obj2.free();
1320     }
1321     qsort(widths.excepsV, widths.nExcepsV, sizeof(GfxFontCIDWidthExcepV),
1322           &cmpWidthExcepV);
1323   }
1324   obj1.free();
1325
1326   desFontDictObj.free();
1327   ok = gTrue;
1328   return;
1329
1330  err4:
1331   obj3.free();
1332   obj2.free();
1333  err3:
1334   obj1.free();
1335  err2:
1336   desFontDictObj.free();
1337  err1:;
1338 }
1339
1340 GfxCIDFont::~GfxCIDFont() {
1341   if (cMap) {
1342     cMap->decRefCnt();
1343   }
1344   if (ctu) {
1345     ctu->decRefCnt();
1346   }
1347   gfree(widths.exceps);
1348   gfree(widths.excepsV);
1349   if (cidToGID) {
1350     gfree(cidToGID);
1351   }
1352 }
1353
1354 int GfxCIDFont::getNextChar(char *s, int len, CharCode *code,
1355                             Unicode *u, int uSize, int *uLen,
1356                             double *dx, double *dy, double *ox, double *oy) {
1357   CID cid;
1358   double w, h, vx, vy;
1359   int n, a, b, m;
1360
1361   if (!cMap) {
1362     *code = 0;
1363     *uLen = 0;
1364     *dx = *dy = 0;
1365     return 1;
1366   }
1367
1368   *code = (CharCode)(cid = cMap->getCID(s, len, &n));
1369   if (ctu) {
1370     *uLen = ctu->mapToUnicode(cid, u, uSize);
1371   } else {
1372     *uLen = 0;
1373   }
1374
1375   // horizontal
1376   if (cMap->getWMode() == 0) {
1377     w = widths.defWidth;
1378     h = vx = vy = 0;
1379     if (widths.nExceps > 0 && cid >= widths.exceps[0].first) {
1380       a = 0;
1381       b = widths.nExceps;
1382       // invariant: widths.exceps[a].first <= cid < widths.exceps[b].first
1383       while (b - a > 1) {
1384         m = (a + b) / 2;
1385         if (widths.exceps[m].first <= cid) {
1386           a = m;
1387         } else {
1388           b = m;
1389         }
1390       }
1391       if (cid <= widths.exceps[a].last) {
1392         w = widths.exceps[a].width;
1393       }
1394     }
1395
1396   // vertical
1397   } else {
1398     w = 0;
1399     h = widths.defHeight;
1400     vx = widths.defWidth / 2;
1401     vy = widths.defVY;
1402     if (widths.nExcepsV > 0 && cid >= widths.excepsV[0].first) {
1403       a = 0;
1404       b = widths.nExcepsV;
1405       // invariant: widths.excepsV[a].first <= cid < widths.excepsV[b].first
1406       while (b - a > 1) {
1407         m = (a + b) / 2;
1408         if (widths.excepsV[m].last <= cid) {
1409           a = m;
1410         } else {
1411           b = m;
1412         }
1413       }
1414       if (cid <= widths.excepsV[a].last) {
1415         h = widths.excepsV[a].height;
1416         vx = widths.excepsV[a].vx;
1417         vy = widths.excepsV[a].vy;
1418       }
1419     }
1420   }
1421
1422   *dx = w;
1423   *dy = h;
1424   *ox = vx;
1425   *oy = vy;
1426
1427   return n;
1428 }
1429
1430 int GfxCIDFont::getWMode() {
1431   return cMap ? cMap->getWMode() : 0;
1432 }
1433
1434 CharCodeToUnicode *GfxCIDFont::getToUnicode() {
1435   if (ctu) {
1436     ctu->incRefCnt();
1437   }
1438   return ctu;
1439 }
1440
1441 GString *GfxCIDFont::getCollection() {
1442   return cMap ? cMap->getCollection() : (GString *)NULL;
1443 }
1444
1445 //------------------------------------------------------------------------
1446 // GfxFontDict
1447 //------------------------------------------------------------------------
1448
1449 GfxFontDict::GfxFontDict(XRef *xref, Ref *fontDictRef, Dict *fontDict) {
1450   int i;
1451   Object obj1, obj2;
1452   Ref r;
1453
1454   numFonts = fontDict->getLength();
1455   fonts = (GfxFont **)gmalloc(numFonts * sizeof(GfxFont *));
1456   for (i = 0; i < numFonts; ++i) {
1457     fontDict->getValNF(i, &obj1);
1458     obj1.fetch(xref, &obj2);
1459     if (obj2.isDict()) {
1460       if (obj1.isRef()) {
1461         r = obj1.getRef();
1462       } else {
1463         // no indirect reference for this font, so invent a unique one
1464         // (legal generation numbers are five digits, so any 6-digit
1465         // number would be safe)
1466         r.num = i;
1467         if (fontDictRef) {
1468           r.gen = 100000 + fontDictRef->num;
1469         } else {
1470           r.gen = 999999;
1471         }
1472       }
1473       fonts[i] = GfxFont::makeFont(xref, fontDict->getKey(i),
1474                                    r, obj2.getDict());
1475       if (fonts[i] && !fonts[i]->isOk()) {
1476         delete fonts[i];
1477         fonts[i] = NULL;
1478       }
1479     } else {
1480       error(-1, "font resource is not a dictionary");
1481       fonts[i] = NULL;
1482     }
1483     obj1.free();
1484     obj2.free();
1485   }
1486 }
1487
1488 GfxFontDict::~GfxFontDict() {
1489   int i;
1490
1491   for (i = 0; i < numFonts; ++i) {
1492     if (fonts[i]) {
1493       delete fonts[i];
1494     }
1495   }
1496   gfree(fonts);
1497 }
1498
1499 GfxFont *GfxFontDict::lookup(char *tag) {
1500   int i;
1501
1502   for (i = 0; i < numFonts; ++i) {
1503     if (fonts[i] && fonts[i]->matches(tag)) {
1504       return fonts[i];
1505     }
1506   }
1507   return NULL;
1508 }