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