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