source: trunk/poppler/mypoppler/fofi/FoFiType1C.cc @ 515

Last change on this file since 515 was 515, checked in by Silvan Scherrer, 9 years ago

updated poppler to 0.20.3

File size: 79.2 KB
Line 
1//========================================================================
2//
3// FoFiType1C.cc
4//
5// Copyright 1999-2003 Glyph & Cog, LLC
6//
7//========================================================================
8
9//========================================================================
10//
11// Modified under the Poppler project - http://poppler.freedesktop.org
12//
13// All changes made under the Poppler project to this file are licensed
14// under GPL version 2 or later
15//
16// Copyright (C) 2009, 2010 Albert Astals Cid <aacid@kde.org>
17//
18// To see a description of the changes please see the Changelog file that
19// came with your tarball or type make ChangeLog if you are building from git
20//
21//========================================================================
22
23#include <config.h>
24
25#ifdef USE_GCC_PRAGMAS
26#pragma implementation
27#endif
28
29#include <stdlib.h>
30#include <string.h>
31#include <math.h>
32#include "goo/gmem.h"
33#include "goo/gstrtod.h"
34#include "goo/GooString.h"
35#include "FoFiEncodings.h"
36#include "FoFiType1C.h"
37
38//------------------------------------------------------------------------
39
40static char hexChars[17] = "0123456789ABCDEF";
41
42//------------------------------------------------------------------------
43// FoFiType1C
44//------------------------------------------------------------------------
45
46FoFiType1C *FoFiType1C::make(char *fileA, int lenA) {
47  FoFiType1C *ff;
48
49  ff = new FoFiType1C(fileA, lenA, gFalse);
50  if (!ff->parse()) {
51    delete ff;
52    return NULL;
53  }
54  return ff;
55}
56
57FoFiType1C *FoFiType1C::load(char *fileName) {
58  FoFiType1C *ff;
59  char *fileA;
60  int lenA;
61
62  if (!(fileA = FoFiBase::readFile(fileName, &lenA))) {
63    return NULL;
64  }
65  ff = new FoFiType1C(fileA, lenA, gTrue);
66  if (!ff->parse()) {
67    delete ff;
68    return NULL;
69  }
70  return ff;
71}
72
73FoFiType1C::FoFiType1C(char *fileA, int lenA, GBool freeFileDataA):
74  FoFiBase(fileA, lenA, freeFileDataA)
75{
76  name = NULL;
77  encoding = NULL;
78  privateDicts = NULL;
79  fdSelect = NULL;
80  charset = NULL;
81}
82
83FoFiType1C::~FoFiType1C() {
84  int i;
85
86  if (name) {
87    delete name;
88  }
89  if (encoding &&
90      encoding != fofiType1StandardEncoding &&
91      encoding != fofiType1ExpertEncoding) {
92    for (i = 0; i < 256; ++i) {
93      gfree(encoding[i]);
94    }
95    gfree(encoding);
96  }
97  if (privateDicts) {
98    gfree(privateDicts);
99  }
100  if (fdSelect) {
101    gfree(fdSelect);
102  }
103  if (charset &&
104      charset != fofiType1CISOAdobeCharset &&
105      charset != fofiType1CExpertCharset &&
106      charset != fofiType1CExpertSubsetCharset) {
107    gfree(charset);
108  }
109}
110
111char *FoFiType1C::getName() {
112  return name ? name->getCString() : (char *)NULL;
113}
114
115char **FoFiType1C::getEncoding() {
116  return encoding;
117}
118
119GooString *FoFiType1C::getGlyphName(int gid) {
120  char buf[256];
121  GBool ok;
122
123  ok = gTrue;
124  getString(charset[gid], buf, &ok);
125  if (!ok) {
126    return NULL;
127  }
128  return new GooString(buf);
129}
130
131int *FoFiType1C::getCIDToGIDMap(int *nCIDs) {
132  int *map;
133  int n, i;
134
135  // a CID font's top dict has ROS as the first operator
136  if (topDict.firstOp != 0x0c1e) {
137    *nCIDs = 0;
138    return NULL;
139  }
140
141  // in a CID font, the charset data is the GID-to-CID mapping, so all
142  // we have to do is reverse it
143  n = 0;
144  for (i = 0; i < nGlyphs; ++i) {
145    if (charset[i] > n) {
146      n = charset[i];
147    }
148  }
149  ++n;
150  map = (int *)gmallocn(n, sizeof(int));
151  memset(map, 0, n * sizeof(int));
152  for (i = 0; i < nGlyphs; ++i) {
153    map[charset[i]] = i;
154  }
155  *nCIDs = n;
156  return map;
157}
158
159void FoFiType1C::getFontMatrix(double *mat) {
160  int i;
161
162  if (topDict.firstOp == 0x0c1e && privateDicts[0].hasFontMatrix) {
163    if (topDict.hasFontMatrix) {
164      mat[0] = topDict.fontMatrix[0] * privateDicts[0].fontMatrix[0] +
165               topDict.fontMatrix[1] * privateDicts[0].fontMatrix[2];
166      mat[1] = topDict.fontMatrix[0] * privateDicts[0].fontMatrix[1] +
167               topDict.fontMatrix[1] * privateDicts[0].fontMatrix[3];
168      mat[2] = topDict.fontMatrix[2] * privateDicts[0].fontMatrix[0] +
169               topDict.fontMatrix[3] * privateDicts[0].fontMatrix[2];
170      mat[3] = topDict.fontMatrix[2] * privateDicts[0].fontMatrix[1] +
171               topDict.fontMatrix[3] * privateDicts[0].fontMatrix[3];
172      mat[4] = topDict.fontMatrix[4] * privateDicts[0].fontMatrix[0] +
173               topDict.fontMatrix[5] * privateDicts[0].fontMatrix[2];
174      mat[5] = topDict.fontMatrix[4] * privateDicts[0].fontMatrix[1] +
175               topDict.fontMatrix[5] * privateDicts[0].fontMatrix[3];
176    } else {
177      for (i = 0; i < 6; ++i) {
178        mat[i] = privateDicts[0].fontMatrix[i];
179      }
180    }
181  } else {
182    for (i = 0; i < 6; ++i) {
183      mat[i] = topDict.fontMatrix[i];
184    }
185  }
186}
187
188void FoFiType1C::convertToType1(char *psName, const char **newEncoding, GBool ascii,
189                                FoFiOutputFunc outputFunc,
190                                void *outputStream) {
191  int psNameLen;
192  Type1CEexecBuf eb;
193  Type1CIndex subrIdx;
194  Type1CIndexVal val;
195  GooString *buf;
196  char buf2[256];
197  const char **enc;
198  GBool ok;
199  int i;
200
201  if (psName) {
202    psNameLen = strlen(psName);
203  } else {
204    psName = name->getCString();
205    psNameLen = name->getLength();
206  }
207
208  // write header and font dictionary, up to encoding
209  ok = gTrue;
210  (*outputFunc)(outputStream, "%!FontType1-1.0: ", 17);
211  (*outputFunc)(outputStream, psName, psNameLen);
212  if (topDict.versionSID != 0) {
213    getString(topDict.versionSID, buf2, &ok);
214    (*outputFunc)(outputStream, buf2, strlen(buf2));
215  }
216  (*outputFunc)(outputStream, "\n", 1);
217  // the dictionary needs room for 12 entries: the following 9, plus
218  // Private and CharStrings (in the eexec section) and FID (which is
219  // added by definefont)
220  (*outputFunc)(outputStream, "12 dict begin\n", 14);
221  (*outputFunc)(outputStream, "/FontInfo 10 dict dup begin\n", 28);
222  if (topDict.versionSID != 0) {
223    (*outputFunc)(outputStream, "/version ", 9);
224    writePSString(buf2, outputFunc, outputStream);
225    (*outputFunc)(outputStream, " readonly def\n", 14);
226  }
227  if (topDict.noticeSID != 0) {
228    getString(topDict.noticeSID, buf2, &ok);
229    (*outputFunc)(outputStream, "/Notice ", 8);
230    writePSString(buf2, outputFunc, outputStream);
231    (*outputFunc)(outputStream, " readonly def\n", 14);
232  }
233  if (topDict.copyrightSID != 0) {
234    getString(topDict.copyrightSID, buf2, &ok);
235    (*outputFunc)(outputStream, "/Copyright ", 11);
236    writePSString(buf2, outputFunc, outputStream);
237    (*outputFunc)(outputStream, " readonly def\n", 14);
238  }
239  if (topDict.fullNameSID != 0) {
240    getString(topDict.fullNameSID, buf2, &ok);
241    (*outputFunc)(outputStream, "/FullName ", 10);
242    writePSString(buf2, outputFunc, outputStream);
243    (*outputFunc)(outputStream, " readonly def\n", 14);
244  }
245  if (topDict.familyNameSID != 0) {
246    getString(topDict.familyNameSID, buf2, &ok);
247    (*outputFunc)(outputStream, "/FamilyName ", 12);
248    writePSString(buf2, outputFunc, outputStream);
249    (*outputFunc)(outputStream, " readonly def\n", 14);
250  }
251  if (topDict.weightSID != 0) {
252    getString(topDict.weightSID, buf2, &ok);
253    (*outputFunc)(outputStream, "/Weight ", 8);
254    writePSString(buf2, outputFunc, outputStream);
255    (*outputFunc)(outputStream, " readonly def\n", 14);
256  }
257  if (topDict.isFixedPitch) {
258    (*outputFunc)(outputStream, "/isFixedPitch true def\n", 23);
259  } else {
260    (*outputFunc)(outputStream, "/isFixedPitch false def\n", 24);
261  }
262  buf = GooString::format("/ItalicAngle {0:.4g} def\n", topDict.italicAngle);
263  (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
264  delete buf;
265  buf = GooString::format("/UnderlinePosition {0:.4g} def\n",
266                        topDict.underlinePosition);
267  (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
268  delete buf;
269  buf = GooString::format("/UnderlineThickness {0:.4g} def\n",
270                        topDict.underlineThickness);
271  (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
272  delete buf;
273  (*outputFunc)(outputStream, "end readonly def\n", 17);
274  (*outputFunc)(outputStream, "/FontName /", 11);
275  (*outputFunc)(outputStream, psName, psNameLen);
276  (*outputFunc)(outputStream, " def\n", 5);
277  buf = GooString::format("/PaintType {0:d} def\n", topDict.paintType);
278  (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
279  delete buf;
280  (*outputFunc)(outputStream, "/FontType 1 def\n", 16);
281  buf = GooString::format("/FontMatrix [{0:.8g} {1:.8g} {2:.8g} {3:.8g} {4:.8g} {5:.8g}] readonly def\n",
282                        topDict.fontMatrix[0], topDict.fontMatrix[1],
283                        topDict.fontMatrix[2], topDict.fontMatrix[3],
284                        topDict.fontMatrix[4], topDict.fontMatrix[5]);
285  (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
286  delete buf;
287  buf = GooString::format("/FontBBox [{0:.4g} {1:.4g} {2:.4g} {3:.4g}] readonly def\n",
288                        topDict.fontBBox[0], topDict.fontBBox[1],
289                        topDict.fontBBox[2], topDict.fontBBox[3]);
290  (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
291  delete buf;
292  buf = GooString::format("/StrokeWidth {0:.4g} def\n", topDict.strokeWidth);
293  (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
294  delete buf;
295  if (topDict.uniqueID != 0) {
296    buf = GooString::format("/UniqueID {0:d} def\n", topDict.uniqueID);
297    (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
298    delete buf;
299  }
300
301  // write the encoding
302  (*outputFunc)(outputStream, "/Encoding ", 10);
303  if (!newEncoding && encoding == fofiType1StandardEncoding) {
304    (*outputFunc)(outputStream, "StandardEncoding def\n", 21);
305  } else {
306    (*outputFunc)(outputStream, "256 array\n", 10);
307    (*outputFunc)(outputStream,
308                  "0 1 255 {1 index exch /.notdef put} for\n", 40);
309    enc = newEncoding ? newEncoding : (const char **)encoding;
310    for (i = 0; i < 256; ++i) {
311      if (enc[i]) {
312        buf = GooString::format("dup {0:d} /{1:s} put\n", i, enc[i]);
313        (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
314        delete buf;
315      }
316    }
317    (*outputFunc)(outputStream, "readonly def\n", 13);
318  }
319  (*outputFunc)(outputStream, "currentdict end\n", 16);
320
321  // start the binary section
322  (*outputFunc)(outputStream, "currentfile eexec\n", 18);
323  eb.outputFunc = outputFunc;
324  eb.outputStream = outputStream;
325  eb.ascii = ascii;
326  eb.r1 = 55665;
327  eb.line = 0;
328
329  // write the private dictionary
330  eexecWrite(&eb, "\x83\xca\x73\xd5");
331  eexecWrite(&eb, "dup /Private 32 dict dup begin\n");
332  eexecWrite(&eb, "/RD {string currentfile exch readstring pop}"
333             " executeonly def\n");
334  eexecWrite(&eb, "/ND {noaccess def} executeonly def\n");
335  eexecWrite(&eb, "/NP {noaccess put} executeonly def\n");
336  eexecWrite(&eb, "/MinFeature {16 16} def\n");
337  eexecWrite(&eb, "/password 5839 def\n");
338  if (privateDicts[0].nBlueValues) {
339    eexecWrite(&eb, "/BlueValues [");
340    for (i = 0; i < privateDicts[0].nBlueValues; ++i) {
341      buf = GooString::format("{0:s}{1:d}",
342                            i > 0 ? " " : "", privateDicts[0].blueValues[i]);
343      eexecWrite(&eb, buf->getCString());
344      delete buf;
345    }
346    eexecWrite(&eb, "] def\n");
347  }
348  if (privateDicts[0].nOtherBlues) {
349    eexecWrite(&eb, "/OtherBlues [");
350    for (i = 0; i < privateDicts[0].nOtherBlues; ++i) {
351      buf = GooString::format("{0:s}{1:d}",
352                            i > 0 ? " " : "", privateDicts[0].otherBlues[i]);
353      eexecWrite(&eb, buf->getCString());
354      delete buf;
355    }
356    eexecWrite(&eb, "] def\n");
357  }
358  if (privateDicts[0].nFamilyBlues) {
359    eexecWrite(&eb, "/FamilyBlues [");
360    for (i = 0; i < privateDicts[0].nFamilyBlues; ++i) {
361      buf = GooString::format("{0:s}{1:d}",
362                            i > 0 ? " " : "", privateDicts[0].familyBlues[i]);
363      eexecWrite(&eb, buf->getCString());
364      delete buf;
365    }
366    eexecWrite(&eb, "] def\n");
367  }
368  if (privateDicts[0].nFamilyOtherBlues) {
369    eexecWrite(&eb, "/FamilyOtherBlues [");
370    for (i = 0; i < privateDicts[0].nFamilyOtherBlues; ++i) {
371      buf = GooString::format("{0:s}{1:d}", i > 0 ? " " : "",
372                            privateDicts[0].familyOtherBlues[i]);
373      eexecWrite(&eb, buf->getCString());
374      delete buf;
375    }
376    eexecWrite(&eb, "] def\n");
377  }
378  if (privateDicts[0].blueScale != 0.039625) {
379    buf = GooString::format("/BlueScale {0:.4g} def\n",
380                          privateDicts[0].blueScale);
381    eexecWrite(&eb, buf->getCString());
382    delete buf;
383  }
384  if (privateDicts[0].blueShift != 7) {
385    buf = GooString::format("/BlueShift {0:d} def\n", privateDicts[0].blueShift);
386    eexecWrite(&eb, buf->getCString());
387    delete buf;
388  }
389  if (privateDicts[0].blueFuzz != 1) {
390    buf = GooString::format("/BlueFuzz {0:d} def\n", privateDicts[0].blueFuzz);
391    eexecWrite(&eb, buf->getCString());
392    delete buf;
393  }
394  if (privateDicts[0].hasStdHW) {
395    buf = GooString::format("/StdHW [{0:.4g}] def\n", privateDicts[0].stdHW);
396    eexecWrite(&eb, buf->getCString());
397    delete buf;
398  }
399  if (privateDicts[0].hasStdVW) {
400    buf = GooString::format("/StdVW [{0:.4g}] def\n", privateDicts[0].stdVW);
401    eexecWrite(&eb, buf->getCString());
402    delete buf;
403  }
404  if (privateDicts[0].nStemSnapH) {
405    eexecWrite(&eb, "/StemSnapH [");
406    for (i = 0; i < privateDicts[0].nStemSnapH; ++i) {
407      buf = GooString::format("{0:s}{1:.4g}",
408                            i > 0 ? " " : "", privateDicts[0].stemSnapH[i]);
409      eexecWrite(&eb, buf->getCString());
410      delete buf;
411    }
412    eexecWrite(&eb, "] def\n");
413  }
414  if (privateDicts[0].nStemSnapV) {
415    eexecWrite(&eb, "/StemSnapV [");
416    for (i = 0; i < privateDicts[0].nStemSnapV; ++i) {
417      buf = GooString::format("{0:s}{1:.4g}",
418                            i > 0 ? " " : "", privateDicts[0].stemSnapV[i]);
419      eexecWrite(&eb, buf->getCString());
420      delete buf;
421    }
422    eexecWrite(&eb, "] def\n");
423  }
424  if (privateDicts[0].hasForceBold) {
425    buf = GooString::format("/ForceBold {0:s} def\n",
426                          privateDicts[0].forceBold ? "true" : "false");
427    eexecWrite(&eb, buf->getCString());
428    delete buf;
429  }
430  if (privateDicts[0].forceBoldThreshold != 0) {
431    buf = GooString::format("/ForceBoldThreshold {0:.4g} def\n",
432                          privateDicts[0].forceBoldThreshold);
433    eexecWrite(&eb, buf->getCString());
434    delete buf;
435  }
436  if (privateDicts[0].languageGroup != 0) {
437    buf = GooString::format("/LanguageGroup {0:d} def\n",
438                          privateDicts[0].languageGroup);
439    eexecWrite(&eb, buf->getCString());
440    delete buf;
441  }
442  if (privateDicts[0].expansionFactor != 0.06) {
443    buf = GooString::format("/ExpansionFactor {0:.4g} def\n",
444                          privateDicts[0].expansionFactor);
445    eexecWrite(&eb, buf->getCString());
446    delete buf;
447  }
448
449  // set up subroutines
450  ok = gTrue;
451  getIndex(privateDicts[0].subrsOffset, &subrIdx, &ok);
452  if (!ok) {
453    subrIdx.pos = -1;
454  }
455
456  // write the CharStrings
457  buf = GooString::format("2 index /CharStrings {0:d} dict dup begin\n",
458                        nGlyphs);
459  eexecWrite(&eb, buf->getCString());
460  delete buf;
461  for (i = 0; i < nGlyphs; ++i) {
462    ok = gTrue;
463    getIndexVal(&charStringsIdx, i, &val, &ok);
464    if (ok) {
465      getString(charset[i], buf2, &ok);
466      if (ok) {
467        eexecCvtGlyph(&eb, buf2, val.pos, val.len, &subrIdx, &privateDicts[0]);
468      }
469    }
470  }
471  eexecWrite(&eb, "end\n");
472  eexecWrite(&eb, "end\n");
473  eexecWrite(&eb, "readonly put\n");
474  eexecWrite(&eb, "noaccess put\n");
475  eexecWrite(&eb, "dup /FontName get exch definefont pop\n");
476  eexecWrite(&eb, "mark currentfile closefile\n");
477
478  // trailer
479  if (ascii && eb.line > 0) {
480    (*outputFunc)(outputStream, "\n", 1);
481  }
482  for (i = 0; i < 8; ++i) {
483    (*outputFunc)(outputStream, "0000000000000000000000000000000000000000000000000000000000000000\n", 65);
484  }
485  (*outputFunc)(outputStream, "cleartomark\n", 12);
486}
487
488void FoFiType1C::convertToCIDType0(char *psName, int *codeMap, int nCodes,
489                                   FoFiOutputFunc outputFunc,
490                                   void *outputStream) {
491  int *cidMap;
492  GooString *charStrings;
493  int *charStringOffsets;
494  Type1CIndex subrIdx;
495  Type1CIndexVal val;
496  int nCIDs, gdBytes;
497  GooString *buf;
498  char buf2[256];
499  GBool ok;
500  int gid, offset, n, i, j, k;
501
502  // compute the CID count and build the CID-to-GID mapping
503  if (codeMap) {
504    nCIDs = nCodes;
505    cidMap = (int *)gmallocn(nCIDs, sizeof(int));
506    for (i = 0; i < nCodes; ++i) {
507      if (codeMap[i] >= 0 && codeMap[i] < nGlyphs) {
508        cidMap[i] = codeMap[i];
509      } else {
510        cidMap[i] = -1;
511      }
512    }
513  } else if (topDict.firstOp == 0x0c1e) {
514    nCIDs = 0;
515    for (i = 0; i < nGlyphs; ++i) {
516      if (charset[i] >= nCIDs) {
517        nCIDs = charset[i] + 1;
518      }
519    }
520    cidMap = (int *)gmallocn(nCIDs, sizeof(int));
521    for (i = 0; i < nCIDs; ++i) {
522      cidMap[i] = -1;
523    }
524    for (i = 0; i < nGlyphs; ++i) {
525      cidMap[charset[i]] = i;
526    }
527  } else {
528    nCIDs = nGlyphs;
529    cidMap = (int *)gmallocn(nCIDs, sizeof(int));
530    for (i = 0; i < nCIDs; ++i) {
531      cidMap[i] = i;
532    }
533  }
534
535  // build the charstrings
536  charStrings = new GooString();
537  charStringOffsets = (int *)gmallocn(nCIDs + 1, sizeof(int));
538  for (i = 0; i < nCIDs; ++i) {
539    charStringOffsets[i] = charStrings->getLength();
540    if ((gid = cidMap[i]) >= 0) {
541      ok = gTrue;
542      getIndexVal(&charStringsIdx, gid, &val, &ok);
543      if (ok) {
544        getIndex(privateDicts[fdSelect ? fdSelect[gid] : 0].subrsOffset,
545                 &subrIdx, &ok);
546        if (!ok) {
547          subrIdx.pos = -1;
548        }
549        cvtGlyph(val.pos, val.len, charStrings,
550                 &subrIdx, &privateDicts[fdSelect ? fdSelect[gid] : 0], gTrue);
551      }
552    }
553  }
554  charStringOffsets[nCIDs] = charStrings->getLength();
555
556  // compute gdBytes = number of bytes needed for charstring offsets
557  // (offset size needs to account for the charstring offset table,
558  // with a worst case of five bytes per entry, plus the charstrings
559  // themselves)
560  i = (nCIDs + 1) * 5 + charStrings->getLength();
561  if (i < 0x100) {
562    gdBytes = 1;
563  } else if (i < 0x10000) {
564    gdBytes = 2;
565  } else if (i < 0x1000000) {
566    gdBytes = 3;
567  } else {
568    gdBytes = 4;
569  }
570
571  // begin the font dictionary
572  (*outputFunc)(outputStream, "/CIDInit /ProcSet findresource begin\n", 37);
573  (*outputFunc)(outputStream, "20 dict begin\n", 14);
574  (*outputFunc)(outputStream, "/CIDFontName /", 14);
575  (*outputFunc)(outputStream, psName, strlen(psName));
576  (*outputFunc)(outputStream, " def\n", 5);
577  (*outputFunc)(outputStream, "/CIDFontType 0 def\n", 19);
578  (*outputFunc)(outputStream, "/CIDSystemInfo 3 dict dup begin\n", 32);
579  if (topDict.registrySID > 0 && topDict.orderingSID > 0) {
580    ok = gTrue;
581    getString(topDict.registrySID, buf2, &ok);
582    if (ok) {
583      (*outputFunc)(outputStream, "  /Registry (", 13);
584      (*outputFunc)(outputStream, buf2, strlen(buf2));
585      (*outputFunc)(outputStream, ") def\n", 6);
586    }
587    ok = gTrue;
588    getString(topDict.orderingSID, buf2, &ok);
589    if (ok) {
590      (*outputFunc)(outputStream, "  /Ordering (", 13);
591      (*outputFunc)(outputStream, buf2, strlen(buf2));
592      (*outputFunc)(outputStream, ") def\n", 6);
593    }
594  } else {
595    (*outputFunc)(outputStream, "  /Registry (Adobe) def\n", 24);
596    (*outputFunc)(outputStream, "  /Ordering (Identity) def\n", 27);
597  }
598  buf = GooString::format("  /Supplement {0:d} def\n", topDict.supplement);
599  (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
600  delete buf;
601  (*outputFunc)(outputStream, "end def\n", 8);
602  if (topDict.hasFontMatrix) {
603    buf = GooString::format("/FontMatrix [{0:.8g} {1:.8g} {2:.8g} {3:.8g} {4:.8g} {5:.8g}] def\n",
604                          topDict.fontMatrix[0], topDict.fontMatrix[1],
605                          topDict.fontMatrix[2], topDict.fontMatrix[3],
606                          topDict.fontMatrix[4], topDict.fontMatrix[5]);
607    (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
608    delete buf;
609  } else if (privateDicts[0].hasFontMatrix) {
610    (*outputFunc)(outputStream, "/FontMatrix [1 0 0 1 0 0] def\n", 30);
611  } else {
612    (*outputFunc)(outputStream,
613                  "/FontMatrix [0.001 0 0 0.001 0 0] def\n", 38);
614  }
615  buf = GooString::format("/FontBBox [{0:.4g} {1:.4g} {2:.4g} {3:.4g}] def\n",
616                        topDict.fontBBox[0], topDict.fontBBox[1],
617                        topDict.fontBBox[2], topDict.fontBBox[3]);
618  (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
619  delete buf;
620  (*outputFunc)(outputStream, "/FontInfo 1 dict dup begin\n", 27);
621  (*outputFunc)(outputStream, "  /FSType 8 def\n", 16);
622  (*outputFunc)(outputStream, "end def\n", 8);
623
624  // CIDFont-specific entries
625  buf = GooString::format("/CIDCount {0:d} def\n", nCIDs);
626  (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
627  delete buf;
628  (*outputFunc)(outputStream, "/FDBytes 1 def\n", 15);
629  buf = GooString::format("/GDBytes {0:d} def\n", gdBytes);
630  (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
631  delete buf;
632  (*outputFunc)(outputStream, "/CIDMapOffset 0 def\n", 20);
633  if (topDict.paintType != 0) {
634    buf = GooString::format("/PaintType {0:d} def\n", topDict.paintType);
635    (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
636    delete buf;
637    buf = GooString::format("/StrokeWidth {0:.4g} def\n", topDict.strokeWidth);
638    (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
639    delete buf;
640  }
641
642  // FDArray entry
643  buf = GooString::format("/FDArray {0:d} array\n", nFDs);
644  (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
645  delete buf;
646  for (i = 0; i < nFDs; ++i) {
647    buf = GooString::format("dup {0:d} 10 dict begin\n", i);
648    (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
649    delete buf;
650    (*outputFunc)(outputStream, "/FontType 1 def\n", 16);
651    if (privateDicts[i].hasFontMatrix) {
652      buf = GooString::format("/FontMatrix [{0:.8g} {1:.8g} {2:.8g} {3:.8g} {4:.8g} {5:.8g}] def\n",
653                            privateDicts[i].fontMatrix[0],
654                            privateDicts[i].fontMatrix[1],
655                            privateDicts[i].fontMatrix[2],
656                            privateDicts[i].fontMatrix[3],
657                            privateDicts[i].fontMatrix[4],
658                            privateDicts[i].fontMatrix[5]);
659      (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
660      delete buf;
661    } else {
662      (*outputFunc)(outputStream, "/FontMatrix [1 0 0 1 0 0] def\n", 30);
663    }
664    buf = GooString::format("/PaintType {0:d} def\n", topDict.paintType);
665    (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
666    delete buf;
667    (*outputFunc)(outputStream, "/Private 32 dict begin\n", 23);
668    if (privateDicts[i].nBlueValues) {
669      (*outputFunc)(outputStream, "/BlueValues [", 13);
670      for (j = 0; j < privateDicts[i].nBlueValues; ++j) {
671        buf = GooString::format("{0:s}{1:d}",
672                              j > 0 ? " " : "", privateDicts[i].blueValues[j]);
673        (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
674        delete buf;
675      }
676      (*outputFunc)(outputStream, "] def\n", 6);
677    }
678    if (privateDicts[i].nOtherBlues) {
679      (*outputFunc)(outputStream, "/OtherBlues [", 13);
680      for (j = 0; j < privateDicts[i].nOtherBlues; ++j) {
681        buf = GooString::format("{0:s}{1:d}",
682                              j > 0 ? " " : "", privateDicts[i].otherBlues[j]);
683        (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
684        delete buf;
685      }
686      (*outputFunc)(outputStream, "] def\n", 6);
687    }
688    if (privateDicts[i].nFamilyBlues) {
689      (*outputFunc)(outputStream, "/FamilyBlues [", 14);
690      for (j = 0; j < privateDicts[i].nFamilyBlues; ++j) {
691        buf = GooString::format("{0:s}{1:d}",
692                              j > 0 ? " " : "",
693                              privateDicts[i].familyBlues[j]);
694        (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
695        delete buf;
696      }
697      (*outputFunc)(outputStream, "] def\n", 6);
698    }
699    if (privateDicts[i].nFamilyOtherBlues) {
700      (*outputFunc)(outputStream, "/FamilyOtherBlues [", 19);
701      for (j = 0; j < privateDicts[i].nFamilyOtherBlues; ++j) {
702        buf = GooString::format("{0:s}{1:d}", j > 0 ? " " : "",
703                              privateDicts[i].familyOtherBlues[j]);
704        (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
705        delete buf;
706      }
707      (*outputFunc)(outputStream, "] def\n", 6);
708    }
709    if (privateDicts[i].blueScale != 0.039625) {
710      buf = GooString::format("/BlueScale {0:.4g} def\n",
711                            privateDicts[i].blueScale);
712      (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
713      delete buf;
714    }
715    if (privateDicts[i].blueShift != 7) {
716      buf = GooString::format("/BlueShift {0:d} def\n",
717                            privateDicts[i].blueShift);
718      (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
719      delete buf;
720    }
721    if (privateDicts[i].blueFuzz != 1) {
722      buf = GooString::format("/BlueFuzz {0:d} def\n", privateDicts[i].blueFuzz);
723      (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
724      delete buf;
725    }
726    if (privateDicts[i].hasStdHW) {
727      buf = GooString::format("/StdHW [{0:.4g}] def\n", privateDicts[i].stdHW);
728      (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
729      delete buf;
730    }
731    if (privateDicts[i].hasStdVW) {
732      buf = GooString::format("/StdVW [{0:.4g}] def\n", privateDicts[i].stdVW);
733      (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
734      delete buf;
735    }
736    if (privateDicts[i].nStemSnapH) {
737      (*outputFunc)(outputStream, "/StemSnapH [", 12);
738      for (j = 0; j < privateDicts[i].nStemSnapH; ++j) {
739        buf = GooString::format("{0:s}{1:.4g}",
740                              j > 0 ? " " : "", privateDicts[i].stemSnapH[j]);
741        (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
742        delete buf;
743      }
744      (*outputFunc)(outputStream, "] def\n", 6);
745    }
746    if (privateDicts[i].nStemSnapV) {
747      (*outputFunc)(outputStream, "/StemSnapV [", 12);
748      for (j = 0; j < privateDicts[i].nStemSnapV; ++j) {
749        buf = GooString::format("{0:s}{1:.4g}",
750                              j > 0 ? " " : "", privateDicts[i].stemSnapV[j]);
751        (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
752        delete buf;
753      }
754      (*outputFunc)(outputStream, "] def\n", 6);
755    }
756    if (privateDicts[i].hasForceBold) {
757      buf = GooString::format("/ForceBold {0:s} def\n",
758                            privateDicts[i].forceBold ? "true" : "false");
759      (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
760      delete buf;
761    }
762    if (privateDicts[i].forceBoldThreshold != 0) {
763      buf = GooString::format("/ForceBoldThreshold {0:.4g} def\n",
764                            privateDicts[i].forceBoldThreshold);
765      (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
766      delete buf;
767    }
768    if (privateDicts[i].languageGroup != 0) {
769      buf = GooString::format("/LanguageGroup {0:d} def\n",
770                            privateDicts[i].languageGroup);
771      (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
772      delete buf;
773    }
774    if (privateDicts[i].expansionFactor != 0.06) {
775      buf = GooString::format("/ExpansionFactor {0:.4g} def\n",
776                            privateDicts[i].expansionFactor);
777      (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
778      delete buf;
779    }
780    (*outputFunc)(outputStream, "currentdict end def\n", 20);
781    (*outputFunc)(outputStream, "currentdict end put\n", 20);
782  }
783  (*outputFunc)(outputStream, "def\n", 4);
784
785  // start the binary section
786  offset = (nCIDs + 1) * (1 + gdBytes);
787  buf = GooString::format("(Hex) {0:d} StartData\n",
788                        offset + charStrings->getLength());
789  (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
790  delete buf;
791
792  // write the charstring offset (CIDMap) table
793  for (i = 0; i <= nCIDs; i += 6) {
794    for (j = 0; j < 6 && i+j <= nCIDs; ++j) {
795      if (i+j < nCIDs && cidMap[i+j] >= 0 && fdSelect) {
796        buf2[0] = (char)fdSelect[cidMap[i+j]];
797      } else {
798        buf2[0] = (char)0;
799      }
800      n = offset + charStringOffsets[i+j];
801      for (k = gdBytes; k >= 1; --k) {
802        buf2[k] = (char)(n & 0xff);
803        n >>= 8;
804      }
805      for (k = 0; k <= gdBytes; ++k) {
806        buf = GooString::format("{0:02x}", buf2[k] & 0xff);
807        (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
808        delete buf;
809      }
810    }
811    (*outputFunc)(outputStream, "\n", 1);
812  }
813
814  // write the charstring data
815  n = charStrings->getLength();
816  for (i = 0; i < n; i += 32) {
817    for (j = 0; j < 32 && i+j < n; ++j) {
818      buf = GooString::format("{0:02x}", charStrings->getChar(i+j) & 0xff);
819      (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
820      delete buf;
821    }
822    if (i + 32 >= n) {
823      (*outputFunc)(outputStream, ">", 1);
824    }
825    (*outputFunc)(outputStream, "\n", 1);
826  }
827
828  gfree(charStringOffsets);
829  delete charStrings;
830  gfree(cidMap);
831}
832
833void FoFiType1C::convertToType0(char *psName, int *codeMap, int nCodes,
834                                FoFiOutputFunc outputFunc,
835                                void *outputStream) {
836  int *cidMap;
837  Type1CIndex subrIdx;
838  Type1CIndexVal val;
839  int nCIDs;
840  GooString *buf;
841  Type1CEexecBuf eb;
842  GBool ok;
843  int fd, i, j, k;
844
845  // compute the CID count and build the CID-to-GID mapping
846  if (codeMap) {
847    nCIDs = nCodes;
848    cidMap = (int *)gmallocn(nCIDs, sizeof(int));
849    for (i = 0; i < nCodes; ++i) {
850      if (codeMap[i] >= 0 && codeMap[i] < nGlyphs) {
851        cidMap[i] = codeMap[i];
852      } else {
853        cidMap[i] = -1;
854      }
855    }
856  } else if (topDict.firstOp == 0x0c1e) {
857    nCIDs = 0;
858    for (i = 0; i < nGlyphs; ++i) {
859      if (charset[i] >= nCIDs) {
860        nCIDs = charset[i] + 1;
861      }
862    }
863    cidMap = (int *)gmallocn(nCIDs, sizeof(int));
864    for (i = 0; i < nCIDs; ++i) {
865      cidMap[i] = -1;
866    }
867    for (i = 0; i < nGlyphs; ++i) {
868      cidMap[charset[i]] = i;
869    }
870  } else {
871    nCIDs = nGlyphs;
872    cidMap = (int *)gmallocn(nCIDs, sizeof(int));
873    for (i = 0; i < nCIDs; ++i) {
874      cidMap[i] = i;
875    }
876  }
877
878  // write the descendant Type 1 fonts
879  for (i = 0; i < nCIDs; i += 256) {
880
881    //~ this assumes that all CIDs in this block have the same FD --
882    //~ to handle multiple FDs correctly, need to somehow divide the
883    //~ font up by FD; as a kludge we ignore CID 0, which is .notdef
884    fd = 0;
885    // if fdSelect is NULL, we have an 8-bit font, so just leave fd=0
886    if (fdSelect) {
887      for (j = i==0 ? 1 : 0; j < 256 && i+j < nCIDs; ++j) {
888        if (cidMap[i+j] >= 0) {
889          fd = fdSelect[cidMap[i+j]];
890          break;
891        }
892      }
893    }
894
895    // font dictionary (unencrypted section)
896    (*outputFunc)(outputStream, "16 dict begin\n", 14);
897    (*outputFunc)(outputStream, "/FontName /", 11);
898    (*outputFunc)(outputStream, psName, strlen(psName));
899    buf = GooString::format("_{0:02x} def\n", i >> 8);
900    (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
901    delete buf;
902    (*outputFunc)(outputStream, "/FontType 1 def\n", 16);
903    if (privateDicts[fd].hasFontMatrix) {
904      buf = GooString::format("/FontMatrix [{0:.8g} {1:.8g} {2:.8g} {3:.8g} {4:.8g} {5:.8g}] def\n",
905                            privateDicts[fd].fontMatrix[0],
906                            privateDicts[fd].fontMatrix[1],
907                            privateDicts[fd].fontMatrix[2],
908                            privateDicts[fd].fontMatrix[3],
909                            privateDicts[fd].fontMatrix[4],
910                            privateDicts[fd].fontMatrix[5]);
911      (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
912      delete buf;
913    } else if (topDict.hasFontMatrix) {
914      (*outputFunc)(outputStream, "/FontMatrix [1 0 0 1 0 0] def\n", 30);
915    } else {
916      (*outputFunc)(outputStream,
917                    "/FontMatrix [0.001 0 0 0.001 0 0] def\n", 38);
918    }
919    buf = GooString::format("/FontBBox [{0:.4g} {1:.4g} {2:.4g} {3:.4g}] def\n",
920                          topDict.fontBBox[0], topDict.fontBBox[1],
921                          topDict.fontBBox[2], topDict.fontBBox[3]);
922    (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
923    delete buf;
924    buf = GooString::format("/PaintType {0:d} def\n", topDict.paintType);
925    (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
926    delete buf;
927    if (topDict.paintType != 0) {
928      buf = GooString::format("/StrokeWidth {0:.4g} def\n", topDict.strokeWidth);
929      (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
930      delete buf;
931    }
932    (*outputFunc)(outputStream, "/Encoding 256 array\n", 20);
933    for (j = 0; j < 256 && i+j < nCIDs; ++j) {
934      buf = GooString::format("dup {0:d} /c{1:02x} put\n", j, j);
935      (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
936      delete buf;
937    }
938    if (j < 256) {
939      buf = GooString::format("{0:d} 1 255 {{ 1 index exch /.notdef put }} for\n",
940                            j);
941      (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
942      delete buf;
943    }
944    (*outputFunc)(outputStream, "readonly def\n", 13);
945    (*outputFunc)(outputStream, "currentdict end\n", 16);
946
947    // start the binary section
948    (*outputFunc)(outputStream, "currentfile eexec\n", 18);
949    eb.outputFunc = outputFunc;
950    eb.outputStream = outputStream;
951    eb.ascii = gTrue;
952    eb.r1 = 55665;
953    eb.line = 0;
954
955    // start the private dictionary
956    eexecWrite(&eb, "\x83\xca\x73\xd5");
957    eexecWrite(&eb, "dup /Private 32 dict dup begin\n");
958    eexecWrite(&eb, "/RD {string currentfile exch readstring pop}"
959               " executeonly def\n");
960    eexecWrite(&eb, "/ND {noaccess def} executeonly def\n");
961    eexecWrite(&eb, "/NP {noaccess put} executeonly def\n");
962    eexecWrite(&eb, "/MinFeature {16 16} def\n");
963    eexecWrite(&eb, "/password 5839 def\n");
964    if (privateDicts[fd].nBlueValues) {
965      eexecWrite(&eb, "/BlueValues [");
966      for (k = 0; k < privateDicts[fd].nBlueValues; ++k) {
967        buf = GooString::format("{0:s}{1:d}",
968                              k > 0 ? " " : "",
969                              privateDicts[fd].blueValues[k]);
970        eexecWrite(&eb, buf->getCString());
971        delete buf;
972      }
973      eexecWrite(&eb, "] def\n");
974    }
975    if (privateDicts[fd].nOtherBlues) {
976      eexecWrite(&eb, "/OtherBlues [");
977      for (k = 0; k < privateDicts[fd].nOtherBlues; ++k) {
978        buf = GooString::format("{0:s}{1:d}",
979                              k > 0 ? " " : "",
980                              privateDicts[fd].otherBlues[k]);
981        eexecWrite(&eb, buf->getCString());
982        delete buf;
983      }
984      eexecWrite(&eb, "] def\n");
985    }
986    if (privateDicts[fd].nFamilyBlues) {
987      eexecWrite(&eb, "/FamilyBlues [");
988      for (k = 0; k < privateDicts[fd].nFamilyBlues; ++k) {
989        buf = GooString::format("{0:s}{1:d}", k > 0 ? " " : "",
990                              privateDicts[fd].familyBlues[k]);
991        eexecWrite(&eb, buf->getCString());
992        delete buf;
993      }
994      eexecWrite(&eb, "] def\n");
995    }
996    if (privateDicts[fd].nFamilyOtherBlues) {
997      eexecWrite(&eb, "/FamilyOtherBlues [");
998      for (k = 0; k < privateDicts[fd].nFamilyOtherBlues; ++k) {
999        buf = GooString::format("{0:s}{1:d}", k > 0 ? " " : "",
1000                              privateDicts[fd].familyOtherBlues[k]);
1001        eexecWrite(&eb, buf->getCString());
1002        delete buf;
1003      }
1004      eexecWrite(&eb, "] def\n");
1005    }
1006    if (privateDicts[fd].blueScale != 0.039625) {
1007      buf = GooString::format("/BlueScale {0:.4g} def\n",
1008                            privateDicts[fd].blueScale);
1009      eexecWrite(&eb, buf->getCString());
1010      delete buf;
1011    }
1012    if (privateDicts[fd].blueShift != 7) {
1013      buf = GooString::format("/BlueShift {0:d} def\n",
1014                            privateDicts[fd].blueShift);
1015      eexecWrite(&eb, buf->getCString());
1016      delete buf;
1017    }
1018    if (privateDicts[fd].blueFuzz != 1) {
1019      buf = GooString::format("/BlueFuzz {0:d} def\n",
1020                            privateDicts[fd].blueFuzz);
1021      eexecWrite(&eb, buf->getCString());
1022      delete buf;
1023    }
1024    if (privateDicts[fd].hasStdHW) {
1025      buf = GooString::format("/StdHW [{0:.4g}] def\n", privateDicts[fd].stdHW);
1026      eexecWrite(&eb, buf->getCString());
1027      delete buf;
1028    }
1029    if (privateDicts[fd].hasStdVW) {
1030      buf = GooString::format("/StdVW [{0:.4g}] def\n", privateDicts[fd].stdVW);
1031      eexecWrite(&eb, buf->getCString());
1032      delete buf;
1033    }
1034    if (privateDicts[fd].nStemSnapH) {
1035      eexecWrite(&eb, "/StemSnapH [");
1036      for (k = 0; k < privateDicts[fd].nStemSnapH; ++k) {
1037        buf = GooString::format("{0:s}{1:.4g}",
1038                              k > 0 ? " " : "", privateDicts[fd].stemSnapH[k]);
1039        eexecWrite(&eb, buf->getCString());
1040        delete buf;
1041      }
1042      eexecWrite(&eb, "] def\n");
1043    }
1044    if (privateDicts[fd].nStemSnapV) {
1045      eexecWrite(&eb, "/StemSnapV [");
1046      for (k = 0; k < privateDicts[fd].nStemSnapV; ++k) {
1047        buf = GooString::format("{0:s}{1:.4g}",
1048                              k > 0 ? " " : "", privateDicts[fd].stemSnapV[k]);
1049        eexecWrite(&eb, buf->getCString());
1050        delete buf;
1051      }
1052      eexecWrite(&eb, "] def\n");
1053    }
1054    if (privateDicts[fd].hasForceBold) {
1055      buf = GooString::format("/ForceBold {0:s} def\n",
1056                            privateDicts[fd].forceBold ? "true" : "false");
1057      eexecWrite(&eb, buf->getCString());
1058      delete buf;
1059    }
1060    if (privateDicts[fd].forceBoldThreshold != 0) {
1061      buf = GooString::format("/ForceBoldThreshold {0:.4g} def\n",
1062                            privateDicts[fd].forceBoldThreshold);
1063      eexecWrite(&eb, buf->getCString());
1064      delete buf;
1065    }
1066    if (privateDicts[fd].languageGroup != 0) {
1067      buf = GooString::format("/LanguageGroup {0:d} def\n",
1068                            privateDicts[fd].languageGroup);
1069      eexecWrite(&eb, buf->getCString());
1070      delete buf;
1071    }
1072    if (privateDicts[fd].expansionFactor != 0.06) {
1073      buf = GooString::format("/ExpansionFactor {0:.4g} def\n",
1074                            privateDicts[fd].expansionFactor);
1075      eexecWrite(&eb, buf->getCString());
1076      delete buf;
1077    }
1078
1079    // set up the subroutines
1080    ok = gTrue;
1081    getIndex(privateDicts[fd].subrsOffset, &subrIdx, &ok);
1082    if (!ok) {
1083      subrIdx.pos = -1;
1084    }
1085
1086    // start the CharStrings
1087    eexecWrite(&eb, "2 index /CharStrings 256 dict dup begin\n");
1088
1089    // write the .notdef CharString
1090    ok = gTrue;
1091    getIndexVal(&charStringsIdx, 0, &val, &ok);
1092    if (ok) {
1093      eexecCvtGlyph(&eb, ".notdef", val.pos, val.len,
1094                    &subrIdx, &privateDicts[fd]);
1095    }
1096
1097    // write the CharStrings
1098    for (j = 0; j < 256 && i+j < nCIDs; ++j) {
1099      if (cidMap[i+j] >= 0) {
1100        ok = gTrue;
1101        getIndexVal(&charStringsIdx, cidMap[i+j], &val, &ok);
1102        if (ok) {
1103          buf = GooString::format("c{0:02x}", j);
1104          eexecCvtGlyph(&eb, buf->getCString(), val.pos, val.len,
1105                        &subrIdx, &privateDicts[fd]);
1106          delete buf;
1107        }
1108      }
1109    }
1110    eexecWrite(&eb, "end\n");
1111    eexecWrite(&eb, "end\n");
1112    eexecWrite(&eb, "readonly put\n");
1113    eexecWrite(&eb, "noaccess put\n");
1114    eexecWrite(&eb, "dup /FontName get exch definefont pop\n");
1115    eexecWrite(&eb, "mark currentfile closefile\n");
1116
1117    // trailer
1118    if (eb.line > 0) {
1119      (*outputFunc)(outputStream, "\n", 1);
1120    }
1121    for (j = 0; j < 8; ++j) {
1122      (*outputFunc)(outputStream, "0000000000000000000000000000000000000000000000000000000000000000\n", 65);
1123    }
1124    (*outputFunc)(outputStream, "cleartomark\n", 12);
1125  }
1126
1127  // write the Type 0 parent font
1128  (*outputFunc)(outputStream, "16 dict begin\n", 14);
1129  (*outputFunc)(outputStream, "/FontName /", 11);
1130  (*outputFunc)(outputStream, psName, strlen(psName));
1131  (*outputFunc)(outputStream, " def\n", 5);
1132  (*outputFunc)(outputStream, "/FontType 0 def\n", 16);
1133  if (topDict.hasFontMatrix) {
1134    buf = GooString::format("/FontMatrix [{0:.8g} {1:.8g} {2:.8g} {3:.8g} {4:.8g} {5:.8g}] def\n",
1135                          topDict.fontMatrix[0], topDict.fontMatrix[1],
1136                          topDict.fontMatrix[2], topDict.fontMatrix[3],
1137                          topDict.fontMatrix[4], topDict.fontMatrix[5]);
1138    (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
1139    delete buf;
1140  } else {
1141    (*outputFunc)(outputStream, "/FontMatrix [1 0 0 1 0 0] def\n", 30);
1142  }
1143  (*outputFunc)(outputStream, "/FMapType 2 def\n", 16);
1144  (*outputFunc)(outputStream, "/Encoding [\n", 12);
1145  for (i = 0; i < nCIDs; i += 256) {
1146    buf = GooString::format("{0:d}\n", i >> 8);
1147    (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
1148    delete buf;
1149  }
1150  (*outputFunc)(outputStream, "] def\n", 6);
1151  (*outputFunc)(outputStream, "/FDepVector [\n", 14);
1152  for (i = 0; i < nCIDs; i += 256) {
1153    (*outputFunc)(outputStream, "/", 1);
1154    (*outputFunc)(outputStream, psName, strlen(psName));
1155    buf = GooString::format("_{0:02x} findfont\n", i >> 8);
1156    (*outputFunc)(outputStream, buf->getCString(), buf->getLength());
1157    delete buf;
1158  }
1159  (*outputFunc)(outputStream, "] def\n", 6);
1160  (*outputFunc)(outputStream, "FontName currentdict end definefont pop\n", 40);
1161
1162  gfree(cidMap);
1163}
1164
1165void FoFiType1C::eexecCvtGlyph(Type1CEexecBuf *eb, const char *glyphName,
1166                               int offset, int nBytes,
1167                               Type1CIndex *subrIdx,
1168                               Type1CPrivateDict *pDict) {
1169  GooString *buf;
1170  GooString *charBuf;
1171
1172  // generate the charstring
1173  charBuf = new GooString();
1174  cvtGlyph(offset, nBytes, charBuf, subrIdx, pDict, gTrue);
1175
1176  buf = GooString::format("/{0:s} {1:d} RD ", glyphName, charBuf->getLength());
1177  eexecWrite(eb, buf->getCString());
1178  delete buf;
1179  eexecWriteCharstring(eb, (Guchar *)charBuf->getCString(),
1180                       charBuf->getLength());
1181  eexecWrite(eb, " ND\n");
1182
1183  delete charBuf;
1184}
1185
1186void FoFiType1C::cvtGlyph(int offset, int nBytes, GooString *charBuf,
1187                          Type1CIndex *subrIdx, Type1CPrivateDict *pDict,
1188                          GBool top) {
1189  Type1CIndexVal val;
1190  GBool ok, dFP;
1191  double d, dx, dy;
1192  Gushort r2;
1193  Guchar byte;
1194  int pos, subrBias, start, i, k;
1195
1196  start = charBuf->getLength();
1197  if (top) {
1198    charBuf->append((char)73);
1199    charBuf->append((char)58);
1200    charBuf->append((char)147);
1201    charBuf->append((char)134);
1202    nOps = 0;
1203    nHints = 0;
1204    firstOp = gTrue;
1205    openPath = gFalse;
1206  }
1207
1208  pos = offset;
1209  while (pos < offset + nBytes) {
1210    ok = gTrue;
1211    pos = getOp(pos, gTrue, &ok);
1212    if (!ok) {
1213      break;
1214    }
1215    if (!ops[nOps - 1].isNum) {
1216      --nOps; // drop the operator
1217      switch (ops[nOps].op) {
1218      case 0x0001:              // hstem
1219        if (firstOp) {
1220          cvtGlyphWidth(nOps & 1, charBuf, pDict);
1221          firstOp = gFalse;
1222        }
1223        if (nOps & 1) {
1224          //~ error(-1, "Wrong number of args (%d) to Type 2 hstem", nOps);
1225        }
1226        d = 0;
1227        dFP = gFalse;
1228        for (k = 0; k < nOps; k += 2) {
1229          // convert Type 2 edge hints (-20 or -21) to Type 1 ghost hints
1230          if (ops[k+1].num < 0) {
1231            d += ops[k].num + ops[k+1].num;
1232            dFP |= ops[k].isFP | ops[k+1].isFP;
1233            cvtNum(d, dFP, charBuf);
1234            cvtNum(-ops[k+1].num, ops[k+1].isFP, charBuf);
1235          } else {
1236            d += ops[k].num;
1237            dFP |= ops[k].isFP;
1238            cvtNum(d, dFP, charBuf);
1239            cvtNum(ops[k+1].num, ops[k+1].isFP, charBuf);
1240            d += ops[k+1].num;
1241            dFP |= ops[k+1].isFP;
1242          }
1243          charBuf->append((char)1);
1244        }
1245        nHints += nOps / 2;
1246        nOps = 0;
1247        break;
1248      case 0x0003:              // vstem
1249        if (firstOp) {
1250          cvtGlyphWidth(nOps & 1, charBuf, pDict);
1251          firstOp = gFalse;
1252        }
1253        if (nOps & 1) {
1254          //~ error(-1, "Wrong number of args (%d) to Type 2 vstem", nOps);
1255        }
1256        d = 0;
1257        dFP = gFalse;
1258        for (k = 0; k < nOps; k += 2) {
1259          // convert Type 2 edge hints (-20 or -21) to Type 1 ghost hints
1260          if (ops[k+1].num < 0) {
1261            d += ops[k].num + ops[k+1].num;
1262            dFP |= ops[k].isFP | ops[k+1].isFP;
1263            cvtNum(d, dFP, charBuf);
1264            cvtNum(-ops[k+1].num, ops[k+1].isFP, charBuf);
1265          } else {
1266            d += ops[k].num;
1267            dFP |= ops[k].isFP;
1268            cvtNum(d, dFP, charBuf);
1269            cvtNum(ops[k+1].num, ops[k+1].isFP, charBuf);
1270            d += ops[k+1].num;
1271            dFP |= ops[k+1].isFP;
1272          }
1273          charBuf->append((char)3);
1274        }
1275        nHints += nOps / 2;
1276        nOps = 0;
1277        break;
1278      case 0x0004:              // vmoveto
1279        if (firstOp) {
1280          cvtGlyphWidth(nOps == 2, charBuf, pDict);
1281          firstOp = gFalse;
1282        }
1283        if (openPath) {
1284          charBuf->append((char)9);
1285          openPath = gFalse;
1286        }
1287        if (nOps != 1) {
1288          //~ error(-1, "Wrong number of args (%d) to Type 2 vmoveto", nOps);
1289        }
1290        cvtNum(ops[0].num, ops[0].isFP, charBuf);
1291        charBuf->append((char)4);
1292        nOps = 0;
1293        break;
1294      case 0x0005:              // rlineto
1295        if (nOps < 2 || nOps % 2 != 0) {
1296          //~ error(-1, "Wrong number of args (%d) to Type 2 rlineto", nOps);
1297        }
1298        for (k = 0; k < nOps; k += 2) {
1299          cvtNum(ops[k].num, ops[k].isFP, charBuf);
1300          cvtNum(ops[k+1].num, ops[k+1].isFP, charBuf);
1301          charBuf->append((char)5);
1302        }
1303        nOps = 0;
1304        openPath = gTrue;
1305        break;
1306      case 0x0006:              // hlineto
1307        if (nOps < 1) {
1308          //~ error(-1, "Wrong number of args (%d) to Type 2 hlineto", nOps);
1309        }
1310        for (k = 0; k < nOps; ++k) {
1311          cvtNum(ops[k].num, ops[k].isFP, charBuf);
1312          charBuf->append((char)((k & 1) ? 7 : 6));
1313        }
1314        nOps = 0;
1315        openPath = gTrue;
1316        break;
1317      case 0x0007:              // vlineto
1318        if (nOps < 1) {
1319          //~ error(-1, "Wrong number of args (%d) to Type 2 vlineto", nOps);
1320        }
1321        for (k = 0; k < nOps; ++k) {
1322          cvtNum(ops[k].num, ops[k].isFP, charBuf);
1323          charBuf->append((char)((k & 1) ? 6 : 7));
1324        }
1325        nOps = 0;
1326        openPath = gTrue;
1327        break;
1328      case 0x0008:              // rrcurveto
1329        if (nOps < 6 || nOps % 6 != 0) {
1330          //~ error(-1, "Wrong number of args (%d) to Type 2 rrcurveto", nOps);
1331        }
1332        for (k = 0; k < nOps; k += 6) {
1333          cvtNum(ops[k].num, ops[k].isFP, charBuf);
1334          cvtNum(ops[k+1].num, ops[k+1].isFP, charBuf);
1335          cvtNum(ops[k+2].num, ops[k+2].isFP, charBuf);
1336          cvtNum(ops[k+3].num, ops[k+3].isFP, charBuf);
1337          cvtNum(ops[k+4].num, ops[k+4].isFP, charBuf);
1338          cvtNum(ops[k+5].num, ops[k+5].isFP, charBuf);
1339          charBuf->append((char)8);
1340        }
1341        nOps = 0;
1342        openPath = gTrue;
1343        break;
1344      case 0x000a:              // callsubr
1345        if (nOps >= 1) {
1346          subrBias = (subrIdx->len < 1240)
1347                       ? 107 : (subrIdx->len < 33900) ? 1131 : 32768;
1348          k = subrBias + (int)ops[nOps - 1].num;
1349          --nOps;
1350          ok = gTrue;
1351          getIndexVal(subrIdx, k, &val, &ok);
1352          if (ok) {
1353            cvtGlyph(val.pos, val.len, charBuf, subrIdx, pDict, gFalse);
1354          }
1355        } else {
1356          //~ error(-1, "Too few args to Type 2 callsubr");
1357        }
1358        // don't clear the stack
1359        break;
1360      case 0x000b:              // return
1361        // don't clear the stack
1362        break;
1363      case 0x000e:              // endchar / seac
1364        if (firstOp) {
1365          cvtGlyphWidth(nOps == 1 || nOps == 5, charBuf, pDict);
1366          firstOp = gFalse;
1367        }
1368        if (openPath) {
1369          charBuf->append((char)9);
1370          openPath = gFalse;
1371        }
1372        if (nOps == 4) {
1373          cvtNum(0, gFalse, charBuf);
1374          cvtNum(ops[0].num, ops[0].isFP, charBuf);
1375          cvtNum(ops[1].num, ops[1].isFP, charBuf);
1376          cvtNum(ops[2].num, ops[2].isFP, charBuf);
1377          cvtNum(ops[3].num, ops[3].isFP, charBuf);
1378          charBuf->append((char)12)->append((char)6);
1379        } else if (nOps == 0) {
1380          charBuf->append((char)14);
1381        } else {
1382          //~ error(-1, "Wrong number of args (%d) to Type 2 endchar", nOps);
1383        }
1384        nOps = 0;
1385        break;
1386      case 0x000f:              // (obsolete)
1387        // this op is ignored, but we need the glyph width
1388        if (firstOp) {
1389          cvtGlyphWidth(nOps > 0, charBuf, pDict);
1390          firstOp = gFalse;
1391        }
1392        nOps = 0;
1393        break;
1394      case 0x0010:              // blend
1395        //~ error(-1, "Unimplemented Type 2 charstring op: %d", file[i]);
1396        nOps = 0;
1397        break;
1398      case 0x0012:              // hstemhm
1399        // ignored
1400        if (firstOp) {
1401          cvtGlyphWidth(nOps & 1, charBuf, pDict);
1402          firstOp = gFalse;
1403        }
1404        if (nOps & 1) {
1405          //~ error(-1, "Wrong number of args (%d) to Type 2 hstemhm", nOps);
1406        }
1407        nHints += nOps / 2;
1408        nOps = 0;
1409        break;
1410      case 0x0013:              // hintmask
1411        // ignored
1412        if (firstOp) {
1413          cvtGlyphWidth(nOps & 1, charBuf, pDict);
1414          firstOp = gFalse;
1415        }
1416        if (nOps > 0) {
1417          if (nOps & 1) {
1418            //~ error(-1, "Wrong number of args (%d) to Type 2 hintmask/vstemhm",
1419            //~       nOps);
1420          }
1421          nHints += nOps / 2;
1422        }
1423        pos += (nHints + 7) >> 3;
1424        nOps = 0;
1425        break;
1426      case 0x0014:              // cntrmask
1427        // ignored
1428        if (firstOp) {
1429          cvtGlyphWidth(nOps & 1, charBuf, pDict);
1430          firstOp = gFalse;
1431        }
1432        if (nOps > 0) {
1433          if (nOps & 1) {
1434            //~ error(-1, "Wrong number of args (%d) to Type 2 cntrmask/vstemhm",
1435            //~       nOps);
1436          }
1437          nHints += nOps / 2;
1438        }
1439        pos += (nHints + 7) >> 3;
1440        nOps = 0;
1441        break;
1442      case 0x0015:              // rmoveto
1443        if (firstOp) {
1444          cvtGlyphWidth(nOps == 3, charBuf, pDict);
1445          firstOp = gFalse;
1446        }
1447        if (openPath) {
1448          charBuf->append((char)9);
1449          openPath = gFalse;
1450        }
1451        if (nOps != 2) {
1452          //~ error(-1, "Wrong number of args (%d) to Type 2 rmoveto", nOps);
1453        }
1454        cvtNum(ops[0].num, ops[0].isFP, charBuf);
1455        cvtNum(ops[1].num, ops[1].isFP, charBuf);
1456        charBuf->append((char)21);
1457        nOps = 0;
1458        break;
1459      case 0x0016:              // hmoveto
1460        if (firstOp) {
1461          cvtGlyphWidth(nOps == 2, charBuf, pDict);
1462          firstOp = gFalse;
1463        }
1464        if (openPath) {
1465          charBuf->append((char)9);
1466          openPath = gFalse;
1467        }
1468        if (nOps != 1) {
1469          //~ error(-1, "Wrong number of args (%d) to Type 2 hmoveto", nOps);
1470        }
1471        cvtNum(ops[0].num, ops[0].isFP, charBuf);
1472        charBuf->append((char)22);
1473        nOps = 0;
1474        break;
1475      case 0x0017:              // vstemhm
1476        // ignored
1477        if (firstOp) {
1478          cvtGlyphWidth(nOps & 1, charBuf, pDict);
1479          firstOp = gFalse;
1480        }
1481        if (nOps & 1) {
1482          //~ error(-1, "Wrong number of args (%d) to Type 2 vstemhm", nOps);
1483        }
1484        nHints += nOps / 2;
1485        nOps = 0;
1486        break;
1487      case 0x0018:              // rcurveline
1488        if (nOps < 8 || (nOps - 2) % 6 != 0) {
1489          //~ error(-1, "Wrong number of args (%d) to Type 2 rcurveline", nOps);
1490        }
1491        for (k = 0; k < nOps - 2; k += 6) {
1492          cvtNum(ops[k].num, ops[k].isFP, charBuf);
1493          cvtNum(ops[k+1].num, ops[k+1].isFP, charBuf);
1494          cvtNum(ops[k+2].num, ops[k+2].isFP, charBuf);
1495          cvtNum(ops[k+3].num, ops[k+3].isFP, charBuf);
1496          cvtNum(ops[k+4].num, ops[k+4].isFP, charBuf);
1497          cvtNum(ops[k+5].num, ops[k+5].isFP, charBuf);
1498          charBuf->append((char)8);
1499        }
1500        cvtNum(ops[k].num, ops[k].isFP, charBuf);
1501        cvtNum(ops[k+1].num, ops[k].isFP, charBuf);
1502        charBuf->append((char)5);
1503        nOps = 0;
1504        openPath = gTrue;
1505        break;
1506      case 0x0019:              // rlinecurve
1507        if (nOps < 8 || (nOps - 6) % 2 != 0) {
1508          //~ error(-1, "Wrong number of args (%d) to Type 2 rlinecurve", nOps);
1509        }
1510        for (k = 0; k < nOps - 6; k += 2) {
1511          cvtNum(ops[k].num, ops[k].isFP, charBuf);
1512          cvtNum(ops[k+1].num, ops[k].isFP, charBuf);
1513          charBuf->append((char)5);
1514        }
1515        cvtNum(ops[k].num, ops[k].isFP, charBuf);
1516        cvtNum(ops[k+1].num, ops[k+1].isFP, charBuf);
1517        cvtNum(ops[k+2].num, ops[k+2].isFP, charBuf);
1518        cvtNum(ops[k+3].num, ops[k+3].isFP, charBuf);
1519        cvtNum(ops[k+4].num, ops[k+4].isFP, charBuf);
1520        cvtNum(ops[k+5].num, ops[k+5].isFP, charBuf);
1521        charBuf->append((char)8);
1522        nOps = 0;
1523        openPath = gTrue;
1524        break;
1525      case 0x001a:              // vvcurveto
1526        if (nOps < 4 || !(nOps % 4 == 0 || (nOps-1) % 4 == 0)) {
1527          //~ error(-1, "Wrong number of args (%d) to Type 2 vvcurveto", nOps);
1528        }
1529        if (nOps % 2 == 1) {
1530          cvtNum(ops[0].num, ops[0].isFP, charBuf);
1531          cvtNum(ops[1].num, ops[1].isFP, charBuf);
1532          cvtNum(ops[2].num, ops[2].isFP, charBuf);
1533          cvtNum(ops[3].num, ops[3].isFP, charBuf);
1534          cvtNum(0, gFalse, charBuf);
1535          cvtNum(ops[4].num, ops[4].isFP, charBuf);
1536          charBuf->append((char)8);
1537          k = 5;
1538        } else {
1539          k = 0;
1540        }
1541        for (; k < nOps; k += 4) {
1542          cvtNum(0, gFalse, charBuf);
1543          cvtNum(ops[k].num, ops[k].isFP, charBuf);
1544          cvtNum(ops[k+1].num, ops[k+1].isFP, charBuf);
1545          cvtNum(ops[k+2].num, ops[k+2].isFP, charBuf);
1546          cvtNum(0, gFalse, charBuf);
1547          cvtNum(ops[k+3].num, ops[k+3].isFP, charBuf);
1548          charBuf->append((char)8);
1549        }
1550        nOps = 0;
1551        openPath = gTrue;
1552        break;
1553      case 0x001b:              // hhcurveto
1554        if (nOps < 4 || !(nOps % 4 == 0 || (nOps-1) % 4 == 0)) {
1555          //~ error(-1, "Wrong number of args (%d) to Type 2 hhcurveto", nOps);
1556        }
1557        if (nOps % 2 == 1) {
1558          cvtNum(ops[1].num, ops[1].isFP, charBuf);
1559          cvtNum(ops[0].num, ops[0].isFP, charBuf);
1560          cvtNum(ops[2].num, ops[2].isFP, charBuf);
1561          cvtNum(ops[3].num, ops[3].isFP, charBuf);
1562          cvtNum(ops[4].num, ops[4].isFP, charBuf);
1563          cvtNum(0, gFalse, charBuf);
1564          charBuf->append((char)8);
1565          k = 5;
1566        } else {
1567          k = 0;
1568        }
1569        for (; k < nOps; k += 4) {
1570          cvtNum(ops[k].num, ops[k].isFP, charBuf);
1571          cvtNum(0, gFalse, charBuf);
1572          cvtNum(ops[k+1].num, ops[k+1].isFP, charBuf);
1573          cvtNum(ops[k+2].num, ops[k+2].isFP, charBuf);
1574          cvtNum(ops[k+3].num, ops[k+3].isFP, charBuf);
1575          cvtNum(0, gFalse, charBuf);
1576          charBuf->append((char)8);
1577        }
1578        nOps = 0;
1579        openPath = gTrue;
1580        break;
1581      case 0x001d:              // callgsubr
1582        if (nOps >= 1) {
1583          k = gsubrBias + (int)ops[nOps - 1].num;
1584          --nOps;
1585          ok = gTrue;
1586          getIndexVal(&gsubrIdx, k, &val, &ok);
1587          if (ok) {
1588            cvtGlyph(val.pos, val.len, charBuf, subrIdx, pDict, gFalse);
1589          }
1590        } else {
1591          //~ error(-1, "Too few args to Type 2 callgsubr");
1592        }
1593        // don't clear the stack
1594        break;
1595      case 0x001e:              // vhcurveto
1596        if (nOps < 4 || !(nOps % 4 == 0 || (nOps-1) % 4 == 0)) {
1597          //~ error(-1, "Wrong number of args (%d) to Type 2 vhcurveto", nOps);
1598        }
1599        for (k = 0; k < nOps && k != nOps-5; k += 4) {
1600          if (k % 8 == 0) {
1601            cvtNum(ops[k].num, ops[k].isFP, charBuf);
1602            cvtNum(ops[k+1].num, ops[k+1].isFP, charBuf);
1603            cvtNum(ops[k+2].num, ops[k+2].isFP, charBuf);
1604            cvtNum(ops[k+3].num, ops[k+3].isFP, charBuf);
1605            charBuf->append((char)30);
1606          } else {
1607            cvtNum(ops[k].num, ops[k].isFP, charBuf);
1608            cvtNum(ops[k+1].num, ops[k+1].isFP, charBuf);
1609            cvtNum(ops[k+2].num, ops[k+2].isFP, charBuf);
1610            cvtNum(ops[k+3].num, ops[k+3].isFP, charBuf);
1611            charBuf->append((char)31);
1612          }
1613        }
1614        if (k == nOps-5) {
1615          if (k % 8 == 0) {
1616            cvtNum(0, gFalse, charBuf);
1617            cvtNum(ops[k].num, ops[k].isFP, charBuf);
1618            cvtNum(ops[k+1].num, ops[k+1].isFP, charBuf);
1619            cvtNum(ops[k+2].num, ops[k+2].isFP, charBuf);
1620            cvtNum(ops[k+3].num, ops[k+3].isFP, charBuf);
1621            cvtNum(ops[k+4].num, ops[k+4].isFP, charBuf);
1622          } else {
1623            cvtNum(ops[k].num, ops[k].isFP, charBuf);
1624            cvtNum(0, gFalse, charBuf);
1625            cvtNum(ops[k+1].num, ops[k+1].isFP, charBuf);
1626            cvtNum(ops[k+2].num, ops[k+2].isFP, charBuf);
1627            cvtNum(ops[k+4].num, ops[k+4].isFP, charBuf);
1628            cvtNum(ops[k+3].num, ops[k+3].isFP, charBuf);
1629          }
1630          charBuf->append((char)8);
1631        }
1632        nOps = 0;
1633        openPath = gTrue;
1634        break;
1635      case 0x001f:              // hvcurveto
1636        if (nOps < 4 || !(nOps % 4 == 0 || (nOps-1) % 4 == 0)) {
1637          //~ error(-1, "Wrong number of args (%d) to Type 2 hvcurveto", nOps);
1638        }
1639        for (k = 0; k < nOps && k != nOps-5; k += 4) {
1640          if (k % 8 == 0) {
1641            cvtNum(ops[k].num, ops[k].isFP, charBuf);
1642            cvtNum(ops[k+1].num, ops[k+1].isFP, charBuf);
1643            cvtNum(ops[k+2].num, ops[k+2].isFP, charBuf);
1644            cvtNum(ops[k+3].num, ops[k+3].isFP, charBuf);
1645            charBuf->append((char)31);
1646          } else {
1647            cvtNum(ops[k].num, ops[k].isFP, charBuf);
1648            cvtNum(ops[k+1].num, ops[k+1].isFP, charBuf);
1649            cvtNum(ops[k+2].num, ops[k+2].isFP, charBuf);
1650            cvtNum(ops[k+3].num, ops[k+3].isFP, charBuf);
1651            charBuf->append((char)30);
1652          }
1653        }
1654        if (k == nOps-5) {
1655          if (k % 8 == 0) {
1656            cvtNum(ops[k].num, ops[k].isFP, charBuf);
1657            cvtNum(0, gFalse, charBuf);
1658            cvtNum(ops[k+1].num, ops[k+1].isFP, charBuf);
1659            cvtNum(ops[k+2].num, ops[k+2].isFP, charBuf);
1660            cvtNum(ops[k+4].num, ops[k+4].isFP, charBuf);
1661            cvtNum(ops[k+3].num, ops[k+3].isFP, charBuf);
1662          } else {
1663            cvtNum(0, gFalse, charBuf);
1664            cvtNum(ops[k].num, ops[k].isFP, charBuf);
1665            cvtNum(ops[k+1].num, ops[k+1].isFP, charBuf);
1666            cvtNum(ops[k+2].num, ops[k+2].isFP, charBuf);
1667            cvtNum(ops[k+3].num, ops[k+3].isFP, charBuf);
1668            cvtNum(ops[k+4].num, ops[k+4].isFP, charBuf);
1669          }
1670          charBuf->append((char)8);
1671        }
1672        nOps = 0;
1673        openPath = gTrue;
1674        break;
1675      case 0x0c00:              // dotsection (should be Type 1 only?)
1676        // ignored
1677        nOps = 0;
1678        break;
1679      case 0x0c03:              // and
1680      case 0x0c04:              // or
1681      case 0x0c05:              // not
1682      case 0x0c08:              // store
1683      case 0x0c09:              // abs
1684      case 0x0c0a:              // add
1685      case 0x0c0b:              // sub
1686      case 0x0c0c:              // div
1687      case 0x0c0d:              // load
1688      case 0x0c0e:              // neg
1689      case 0x0c0f:              // eq
1690      case 0x0c12:              // drop
1691      case 0x0c14:              // put
1692      case 0x0c15:              // get
1693      case 0x0c16:              // ifelse
1694      case 0x0c17:              // random
1695      case 0x0c18:              // mul
1696      case 0x0c1a:              // sqrt
1697      case 0x0c1b:              // dup
1698      case 0x0c1c:              // exch
1699      case 0x0c1d:              // index
1700      case 0x0c1e:              // roll
1701        //~ error(-1, "Unimplemented Type 2 charstring op: 12.%d", file[i+1]);
1702        nOps = 0;
1703        break;
1704      case 0x0c22:              // hflex
1705        if (nOps != 7) {
1706          //~ error(-1, "Wrong number of args (%d) to Type 2 hflex", nOps);
1707        }
1708        cvtNum(ops[0].num, ops[0].isFP, charBuf);
1709        cvtNum(0, gFalse, charBuf);
1710        cvtNum(ops[1].num, ops[1].isFP, charBuf);
1711        cvtNum(ops[2].num, ops[2].isFP, charBuf);
1712        cvtNum(ops[3].num, ops[3].isFP, charBuf);
1713        cvtNum(0, gFalse, charBuf);
1714        charBuf->append((char)8);
1715        cvtNum(ops[4].num, ops[4].isFP, charBuf);
1716        cvtNum(0, gFalse, charBuf);
1717        cvtNum(ops[5].num, ops[5].isFP, charBuf);
1718        cvtNum(-ops[2].num, ops[2].isFP, charBuf);
1719        cvtNum(ops[6].num, ops[6].isFP, charBuf);
1720        cvtNum(0, gFalse, charBuf);
1721        charBuf->append((char)8);
1722        nOps = 0;
1723        openPath = gTrue;
1724        break;
1725      case 0x0c23:              // flex
1726        if (nOps != 13) {
1727          //~ error(-1, "Wrong number of args (%d) to Type 2 flex", nOps);
1728        }
1729        cvtNum(ops[0].num, ops[0].isFP, charBuf);
1730        cvtNum(ops[1].num, ops[1].isFP, charBuf);
1731        cvtNum(ops[2].num, ops[2].isFP, charBuf);
1732        cvtNum(ops[3].num, ops[3].isFP, charBuf);
1733        cvtNum(ops[4].num, ops[4].isFP, charBuf);
1734        cvtNum(ops[5].num, ops[5].isFP, charBuf);
1735        charBuf->append((char)8);
1736        cvtNum(ops[6].num, ops[6].isFP, charBuf);
1737        cvtNum(ops[7].num, ops[7].isFP, charBuf);
1738        cvtNum(ops[8].num, ops[8].isFP, charBuf);
1739        cvtNum(ops[9].num, ops[9].isFP, charBuf);
1740        cvtNum(ops[10].num, ops[10].isFP, charBuf);
1741        cvtNum(ops[11].num, ops[11].isFP, charBuf);
1742        charBuf->append((char)8);
1743        nOps = 0;
1744        openPath = gTrue;
1745        break;
1746      case 0x0c24:              // hflex1
1747        if (nOps != 9) {
1748          //~ error(-1, "Wrong number of args (%d) to Type 2 hflex1", nOps);
1749        }
1750        cvtNum(ops[0].num, ops[0].isFP, charBuf);
1751        cvtNum(ops[1].num, ops[1].isFP, charBuf);
1752        cvtNum(ops[2].num, ops[2].isFP, charBuf);
1753        cvtNum(ops[3].num, ops[3].isFP, charBuf);
1754        cvtNum(ops[4].num, ops[4].isFP, charBuf);
1755        cvtNum(0, gFalse, charBuf);
1756        charBuf->append((char)8);
1757        cvtNum(ops[5].num, ops[5].isFP, charBuf);
1758        cvtNum(0, gFalse, charBuf);
1759        cvtNum(ops[6].num, ops[6].isFP, charBuf);
1760        cvtNum(ops[7].num, ops[7].isFP, charBuf);
1761        cvtNum(ops[8].num, ops[8].isFP, charBuf);
1762        cvtNum(-(ops[1].num + ops[3].num + ops[7].num),
1763               ops[1].isFP | ops[3].isFP | ops[7].isFP, charBuf);
1764        charBuf->append((char)8);
1765        nOps = 0;
1766        openPath = gTrue;
1767        break;
1768      case 0x0c25:              // flex1
1769        if (nOps != 11) {
1770          //~ error(-1, "Wrong number of args (%d) to Type 2 flex1", nOps);
1771        }
1772        cvtNum(ops[0].num, ops[0].isFP, charBuf);
1773        cvtNum(ops[1].num, ops[1].isFP, charBuf);
1774        cvtNum(ops[2].num, ops[2].isFP, charBuf);
1775        cvtNum(ops[3].num, ops[3].isFP, charBuf);
1776        cvtNum(ops[4].num, ops[4].isFP, charBuf);
1777        cvtNum(ops[5].num, ops[5].isFP, charBuf);
1778        charBuf->append((char)8);
1779        cvtNum(ops[6].num, ops[6].isFP, charBuf);
1780        cvtNum(ops[7].num, ops[7].isFP, charBuf);
1781        cvtNum(ops[8].num, ops[8].isFP, charBuf);
1782        cvtNum(ops[9].num, ops[9].isFP, charBuf);
1783        dx = ops[0].num + ops[2].num + ops[4].num + ops[6].num + ops[8].num;
1784        dy = ops[1].num + ops[3].num + ops[5].num + ops[7].num + ops[9].num;
1785        if (fabs(dx) > fabs(dy)) {
1786          cvtNum(ops[10].num, ops[10].isFP, charBuf);
1787          cvtNum(-dy, ops[1].isFP | ops[3].isFP | ops[5].isFP |
1788                      ops[7].isFP | ops[9].isFP, charBuf);
1789        } else {
1790          cvtNum(-dx, ops[0].isFP | ops[2].isFP | ops[4].isFP |
1791                      ops[6].isFP | ops[8].isFP, charBuf);
1792          cvtNum(ops[10].num, ops[10].isFP, charBuf);
1793        }
1794        charBuf->append((char)8);
1795        nOps = 0;
1796        openPath = gTrue;
1797        break;
1798      default:
1799        //~ error(-1, "Illegal Type 2 charstring op: %04x",
1800        //~       ops[nOps].op);
1801        nOps = 0;
1802        break;
1803      }
1804    }
1805  }
1806
1807  // charstring encryption
1808  if (top) {
1809    r2 = 4330;
1810    for (i = start; i < charBuf->getLength(); ++i) {
1811      byte = charBuf->getChar(i) ^ (r2 >> 8);
1812      charBuf->setChar(i, byte);
1813      r2 = (byte + r2) * 52845 + 22719;
1814    }
1815  }
1816}
1817
1818void FoFiType1C::cvtGlyphWidth(GBool useOp, GooString *charBuf,
1819                               Type1CPrivateDict *pDict) {
1820  double w;
1821  GBool wFP;
1822  int i;
1823
1824  if (useOp) {
1825    w = pDict->nominalWidthX + ops[0].num;
1826    wFP = pDict->nominalWidthXFP | ops[0].isFP;
1827    for (i = 1; i < nOps; ++i) {
1828      ops[i-1] = ops[i];
1829    }
1830    --nOps;
1831  } else {
1832    w = pDict->defaultWidthX;
1833    wFP = pDict->defaultWidthXFP;
1834  }
1835  cvtNum(0, gFalse, charBuf);
1836  cvtNum(w, wFP, charBuf);
1837  charBuf->append((char)13);
1838}
1839
1840void FoFiType1C::cvtNum(double x, GBool isFP, GooString *charBuf) {
1841  Guchar buf[12];
1842  int y, n;
1843
1844  n = 0;
1845  if (isFP) {
1846    if (x >= -32768 && x < 32768) {
1847      y = (int)(x * 256.0);
1848      buf[0] = 255;
1849      buf[1] = (Guchar)(y >> 24);
1850      buf[2] = (Guchar)(y >> 16);
1851      buf[3] = (Guchar)(y >> 8);
1852      buf[4] = (Guchar)y;
1853      buf[5] = 255;
1854      buf[6] = 0;
1855      buf[7] = 0;
1856      buf[8] = 1;
1857      buf[9] = 0;
1858      buf[10] = 12;
1859      buf[11] = 12;
1860      n = 12;
1861    } else {
1862      //~ error(-1, "Type 2 fixed point constant out of range");
1863    }
1864  } else {
1865    y = (int)x;
1866    if (y >= -107 && y <= 107) {
1867      buf[0] = (Guchar)(y + 139);
1868      n = 1;
1869    } else if (y > 107 && y <= 1131) {
1870      y -= 108;
1871      buf[0] = (Guchar)((y >> 8) + 247);
1872      buf[1] = (Guchar)(y & 0xff);
1873      n = 2;
1874    } else if (y < -107 && y >= -1131) {
1875      y = -y - 108;
1876      buf[0] = (Guchar)((y >> 8) + 251);
1877      buf[1] = (Guchar)(y & 0xff);
1878      n = 2;
1879    } else {
1880      buf[0] = 255;
1881      buf[1] = (Guchar)(y >> 24);
1882      buf[2] = (Guchar)(y >> 16);
1883      buf[3] = (Guchar)(y >> 8);
1884      buf[4] = (Guchar)y;
1885      n = 5;
1886    }
1887  }
1888  charBuf->append((char *)buf, n);
1889}
1890
1891void FoFiType1C::eexecWrite(Type1CEexecBuf *eb, const char *s) {
1892  Guchar *p;
1893  Guchar x;
1894
1895  for (p = (Guchar *)s; *p; ++p) {
1896    x = *p ^ (eb->r1 >> 8);
1897    eb->r1 = (x + eb->r1) * 52845 + 22719;
1898    if (eb->ascii) {
1899      (*eb->outputFunc)(eb->outputStream, &hexChars[x >> 4], 1);
1900      (*eb->outputFunc)(eb->outputStream, &hexChars[x & 0x0f], 1);
1901      eb->line += 2;
1902      if (eb->line == 64) {
1903        (*eb->outputFunc)(eb->outputStream, "\n", 1);
1904        eb->line = 0;
1905      }
1906    } else {
1907      (*eb->outputFunc)(eb->outputStream, (char *)&x, 1);
1908    }
1909  }
1910}
1911
1912void FoFiType1C::eexecWriteCharstring(Type1CEexecBuf *eb,
1913                                      Guchar *s, int n) {
1914  Guchar x;
1915  int i;
1916
1917  // eexec encryption
1918  for (i = 0; i < n; ++i) {
1919    x = s[i] ^ (eb->r1 >> 8);
1920    eb->r1 = (x + eb->r1) * 52845 + 22719;
1921    if (eb->ascii) {
1922      (*eb->outputFunc)(eb->outputStream, &hexChars[x >> 4], 1);
1923      (*eb->outputFunc)(eb->outputStream, &hexChars[x & 0x0f], 1);
1924      eb->line += 2;
1925      if (eb->line == 64) {
1926        (*eb->outputFunc)(eb->outputStream, "\n", 1);
1927        eb->line = 0;
1928      }
1929    } else {
1930      (*eb->outputFunc)(eb->outputStream, (char *)&x, 1);
1931    }
1932  }
1933}
1934
1935void FoFiType1C::writePSString(char *s, FoFiOutputFunc outputFunc,
1936                               void *outputStream) {
1937  char buf[80];
1938  char *p;
1939  int i, c;
1940
1941  i = 0;
1942  buf[i++] = '(';
1943  for (p = s; *p; ++p) {
1944    c = *p & 0xff;
1945    if (c == '(' || c == ')' || c == '\\') {
1946      buf[i++] = '\\';
1947      buf[i++] = c;
1948    } else if (c < 0x20 || c >= 0x80) {
1949      buf[i++] = '\\';
1950      buf[i++] = '0' + ((c >> 6) & 7);
1951      buf[i++] = '0' + ((c >> 3) & 7);
1952      buf[i++] = '0' + (c & 7);
1953    } else {
1954      buf[i++] = c;
1955    }
1956    if (i >= 64) {
1957      buf[i++] = '\\';
1958      buf[i++] = '\n';
1959      (*outputFunc)(outputStream, buf, i);
1960      i = 0;
1961    }
1962  }
1963  buf[i++] = ')';
1964  (*outputFunc)(outputStream, buf, i);
1965}
1966
1967GBool FoFiType1C::parse() {
1968  Type1CIndex fdIdx;
1969  Type1CIndexVal val;
1970  int i;
1971
1972  parsedOk = gTrue;
1973
1974  // some tools embed Type 1C fonts with an extra whitespace char at
1975  // the beginning
1976  if (len > 0 && file[0] != '\x01') {
1977    ++file;
1978    --len;
1979  }
1980
1981  // find the indexes
1982  getIndex(getU8(2, &parsedOk), &nameIdx, &parsedOk);
1983  getIndex(nameIdx.endPos, &topDictIdx, &parsedOk);
1984  getIndex(topDictIdx.endPos, &stringIdx, &parsedOk);
1985  getIndex(stringIdx.endPos, &gsubrIdx, &parsedOk);
1986  if (!parsedOk) {
1987    return gFalse;
1988  }
1989  gsubrBias = (gsubrIdx.len < 1240) ? 107
1990                                    : (gsubrIdx.len < 33900) ? 1131 : 32768;
1991
1992  // read the first font name
1993  getIndexVal(&nameIdx, 0, &val, &parsedOk);
1994  if (!parsedOk) {
1995    return gFalse;
1996  }
1997  name = new GooString((char *)&file[val.pos], val.len);
1998
1999  // read the top dict for the first font
2000  readTopDict();
2001
2002  // for CID fonts: read the FDArray dicts and private dicts
2003  if (topDict.firstOp == 0x0c1e) {
2004    if (topDict.fdArrayOffset == 0) {
2005      nFDs = 1;
2006      privateDicts = (Type1CPrivateDict *)gmalloc(sizeof(Type1CPrivateDict));
2007      readPrivateDict(0, 0, &privateDicts[0]);
2008    } else {
2009      getIndex(topDict.fdArrayOffset, &fdIdx, &parsedOk);
2010      if (!parsedOk) {
2011        return gFalse;
2012      }
2013      nFDs = fdIdx.len;
2014      privateDicts = (Type1CPrivateDict *)
2015                         gmallocn(nFDs, sizeof(Type1CPrivateDict));
2016      for (i = 0; i < nFDs; ++i) {
2017        getIndexVal(&fdIdx, i, &val, &parsedOk);
2018        if (!parsedOk) {
2019          return gFalse;
2020        }
2021        readFD(val.pos, val.len, &privateDicts[i]);
2022      }
2023    }
2024
2025  // for 8-bit fonts: read the private dict
2026  } else {
2027    nFDs = 1;
2028    privateDicts = (Type1CPrivateDict *)gmalloc(sizeof(Type1CPrivateDict));
2029    readPrivateDict(topDict.privateOffset, topDict.privateSize,
2030                    &privateDicts[0]);
2031  }
2032
2033  // check for parse errors in the private dict(s)
2034  if (!parsedOk) {
2035    return gFalse;
2036  }
2037
2038  // get the charstrings index
2039  if (topDict.charStringsOffset <= 0) {
2040    parsedOk = gFalse;
2041    return gFalse;
2042  }
2043  getIndex(topDict.charStringsOffset, &charStringsIdx, &parsedOk);
2044  if (!parsedOk) {
2045    return gFalse;
2046  }
2047  nGlyphs = charStringsIdx.len;
2048
2049  // for CID fonts: read the FDSelect table
2050  if (topDict.firstOp == 0x0c1e) {
2051    readFDSelect();
2052    if (!parsedOk) {
2053      return gFalse;
2054    }
2055  }
2056
2057  // read the charset
2058  if (!readCharset()) {
2059    parsedOk = gFalse;
2060    return gFalse;
2061  }
2062
2063  // for 8-bit fonts: build the encoding
2064  if (topDict.firstOp != 0x0c14 && topDict.firstOp != 0x0c1e) {
2065    buildEncoding();
2066    if (!parsedOk) {
2067      return gFalse;
2068    }
2069  }
2070
2071  return parsedOk;
2072}
2073
2074void FoFiType1C::readTopDict() {
2075  Type1CIndexVal topDictPtr;
2076  int pos;
2077
2078  topDict.firstOp = -1;
2079  topDict.versionSID = 0;
2080  topDict.noticeSID = 0;
2081  topDict.copyrightSID = 0;
2082  topDict.fullNameSID = 0;
2083  topDict.familyNameSID = 0;
2084  topDict.weightSID = 0;
2085  topDict.isFixedPitch = 0;
2086  topDict.italicAngle = 0;
2087  topDict.underlinePosition = -100;
2088  topDict.underlineThickness = 50;
2089  topDict.paintType = 0;
2090  topDict.charstringType = 2;
2091  topDict.fontMatrix[0] = 0.001;
2092  topDict.fontMatrix[1] = 0;
2093  topDict.fontMatrix[2] = 0;
2094  topDict.fontMatrix[3] = 0.001;
2095  topDict.fontMatrix[4] = 0;
2096  topDict.fontMatrix[5] = 0;
2097  topDict.hasFontMatrix = gFalse;
2098  topDict.uniqueID = 0;
2099  topDict.fontBBox[0] = 0;
2100  topDict.fontBBox[1] = 0;
2101  topDict.fontBBox[2] = 0;
2102  topDict.fontBBox[3] = 0;
2103  topDict.strokeWidth = 0;
2104  topDict.charsetOffset = 0;
2105  topDict.encodingOffset = 0;
2106  topDict.charStringsOffset = 0;
2107  topDict.privateSize = 0;
2108  topDict.privateOffset = 0;
2109  topDict.registrySID = 0;
2110  topDict.orderingSID = 0;
2111  topDict.supplement = 0;
2112  topDict.fdArrayOffset = 0;
2113  topDict.fdSelectOffset = 0;
2114
2115  getIndexVal(&topDictIdx, 0, &topDictPtr, &parsedOk);
2116  pos = topDictPtr.pos;
2117  nOps = 0;
2118  while (pos < topDictPtr.pos + topDictPtr.len) {
2119    pos = getOp(pos, gFalse, &parsedOk);
2120    if (!parsedOk) {
2121      break;
2122    }
2123    if (!ops[nOps - 1].isNum) {
2124      --nOps; // drop the operator
2125      if (topDict.firstOp < 0) {
2126        topDict.firstOp = ops[nOps].op;
2127      }
2128      switch (ops[nOps].op) {
2129      case 0x0000: topDict.versionSID = (int)ops[0].num; break;
2130      case 0x0001: topDict.noticeSID = (int)ops[0].num; break;
2131      case 0x0c00: topDict.copyrightSID = (int)ops[0].num; break;
2132      case 0x0002: topDict.fullNameSID = (int)ops[0].num; break;
2133      case 0x0003: topDict.familyNameSID = (int)ops[0].num; break;
2134      case 0x0004: topDict.weightSID = (int)ops[0].num; break;
2135      case 0x0c01: topDict.isFixedPitch = (int)ops[0].num; break;
2136      case 0x0c02: topDict.italicAngle = ops[0].num; break;
2137      case 0x0c03: topDict.underlinePosition = ops[0].num; break;
2138      case 0x0c04: topDict.underlineThickness = ops[0].num; break;
2139      case 0x0c05: topDict.paintType = (int)ops[0].num; break;
2140      case 0x0c06: topDict.charstringType = (int)ops[0].num; break;
2141      case 0x0c07: topDict.fontMatrix[0] = ops[0].num;
2142                   topDict.fontMatrix[1] = ops[1].num;
2143                   topDict.fontMatrix[2] = ops[2].num;
2144                   topDict.fontMatrix[3] = ops[3].num;
2145                   topDict.fontMatrix[4] = ops[4].num;
2146                   topDict.fontMatrix[5] = ops[5].num;
2147                   topDict.hasFontMatrix = gTrue; break;
2148      case 0x000d: topDict.uniqueID = (int)ops[0].num; break;
2149      case 0x0005: topDict.fontBBox[0] = ops[0].num;
2150                   topDict.fontBBox[1] = ops[1].num;
2151                   topDict.fontBBox[2] = ops[2].num;
2152                   topDict.fontBBox[3] = ops[3].num; break;
2153      case 0x0c08: topDict.strokeWidth = ops[0].num; break;
2154      case 0x000f: topDict.charsetOffset = (int)ops[0].num; break;
2155      case 0x0010: topDict.encodingOffset = (int)ops[0].num; break;
2156      case 0x0011: topDict.charStringsOffset = (int)ops[0].num; break;
2157      case 0x0012: topDict.privateSize = (int)ops[0].num;
2158                   topDict.privateOffset = (int)ops[1].num; break;
2159      case 0x0c1e: topDict.registrySID = (int)ops[0].num;
2160                   topDict.orderingSID = (int)ops[1].num;
2161                   topDict.supplement = (int)ops[2].num; break;
2162      case 0x0c24: topDict.fdArrayOffset = (int)ops[0].num; break;
2163      case 0x0c25: topDict.fdSelectOffset = (int)ops[0].num; break;
2164      }
2165      nOps = 0;
2166    }
2167  }
2168}
2169
2170// Read a CID font dict (FD) - this pulls out the private dict
2171// pointer, and reads the private dict.  It also pulls the FontMatrix
2172// (if any) out of the FD.
2173void FoFiType1C::readFD(int offset, int length, Type1CPrivateDict *pDict) {
2174  int pos, pSize, pOffset;
2175  double fontMatrix[6] = {0};
2176  GBool hasFontMatrix;
2177
2178  hasFontMatrix = gFalse;
2179  fontMatrix[0] = fontMatrix[1] = fontMatrix[2] = 0; // make gcc happy
2180  fontMatrix[3] = fontMatrix[4] = fontMatrix[5] = 0;
2181  pSize = pOffset = 0;
2182  pos = offset;
2183  nOps = 0;
2184  while (pos < offset + length) {
2185    pos = getOp(pos, gFalse, &parsedOk);
2186    if (!parsedOk) {
2187      return;
2188    }
2189    if (!ops[nOps - 1].isNum) {
2190      if (ops[nOps - 1].op == 0x0012) {
2191        if (nOps < 3) {
2192          parsedOk = gFalse;
2193          return;
2194        }
2195        pSize = (int)ops[0].num;
2196        pOffset = (int)ops[1].num;
2197        break;
2198      } else if (ops[nOps - 1].op == 0x0c07) {
2199        fontMatrix[0] = ops[0].num;
2200        fontMatrix[1] = ops[1].num;
2201        fontMatrix[2] = ops[2].num;
2202        fontMatrix[3] = ops[3].num;
2203        fontMatrix[4] = ops[4].num;
2204        fontMatrix[5] = ops[5].num;
2205        hasFontMatrix = gTrue;
2206      }
2207      nOps = 0;
2208    }
2209  }
2210  readPrivateDict(pOffset, pSize, pDict);
2211  if (hasFontMatrix) {
2212    pDict->fontMatrix[0] = fontMatrix[0];
2213    pDict->fontMatrix[1] = fontMatrix[1];
2214    pDict->fontMatrix[2] = fontMatrix[2];
2215    pDict->fontMatrix[3] = fontMatrix[3];
2216    pDict->fontMatrix[4] = fontMatrix[4];
2217    pDict->fontMatrix[5] = fontMatrix[5];
2218    pDict->hasFontMatrix = gTrue;
2219  }
2220}
2221
2222void FoFiType1C::readPrivateDict(int offset, int length,
2223                                 Type1CPrivateDict *pDict) {
2224  int pos;
2225
2226  pDict->hasFontMatrix = gFalse;
2227  pDict->nBlueValues = 0;
2228  pDict->nOtherBlues = 0;
2229  pDict->nFamilyBlues = 0;
2230  pDict->nFamilyOtherBlues = 0;
2231  pDict->blueScale = 0.039625;
2232  pDict->blueShift = 7;
2233  pDict->blueFuzz = 1;
2234  pDict->hasStdHW = gFalse;
2235  pDict->hasStdVW = gFalse;
2236  pDict->nStemSnapH = 0;
2237  pDict->nStemSnapV = 0;
2238  pDict->hasForceBold = gFalse;
2239  pDict->forceBoldThreshold = 0;
2240  pDict->languageGroup = 0;
2241  pDict->expansionFactor = 0.06;
2242  pDict->initialRandomSeed = 0;
2243  pDict->subrsOffset = 0;
2244  pDict->defaultWidthX = 0;
2245  pDict->defaultWidthXFP = gFalse;
2246  pDict->nominalWidthX = 0;
2247  pDict->nominalWidthXFP = gFalse;
2248
2249  // no dictionary
2250  if (offset == 0 || length == 0) {
2251    return;
2252  }
2253
2254  pos = offset;
2255  nOps = 0;
2256  while (pos < offset + length) {
2257    pos = getOp(pos, gFalse, &parsedOk);
2258    if (!parsedOk) {
2259      break;
2260    }
2261    if (!ops[nOps - 1].isNum) {
2262      --nOps; // drop the operator
2263      switch (ops[nOps].op) {
2264      case 0x0006:
2265        pDict->nBlueValues = getDeltaIntArray(pDict->blueValues,
2266                                              type1CMaxBlueValues);
2267        break;
2268      case 0x0007:
2269        pDict->nOtherBlues = getDeltaIntArray(pDict->otherBlues,
2270                                              type1CMaxOtherBlues);
2271        break;
2272      case 0x0008:
2273        pDict->nFamilyBlues = getDeltaIntArray(pDict->familyBlues,
2274                                               type1CMaxBlueValues);
2275        break;
2276      case 0x0009:
2277        pDict->nFamilyOtherBlues = getDeltaIntArray(pDict->familyOtherBlues,
2278                                                    type1CMaxOtherBlues);
2279        break;
2280      case 0x0c09:
2281        pDict->blueScale = ops[0].num;
2282        break;
2283      case 0x0c0a:
2284        pDict->blueShift = (int)ops[0].num;
2285        break;
2286      case 0x0c0b:
2287        pDict->blueFuzz = (int)ops[0].num;
2288        break;
2289      case 0x000a:
2290        pDict->stdHW = ops[0].num;
2291        pDict->hasStdHW = gTrue;
2292        break;
2293      case 0x000b:
2294        pDict->stdVW = ops[0].num;
2295        pDict->hasStdVW = gTrue;
2296        break;
2297      case 0x0c0c:
2298        pDict->nStemSnapH = getDeltaFPArray(pDict->stemSnapH,
2299                                            type1CMaxStemSnap);
2300        break;
2301      case 0x0c0d:
2302        pDict->nStemSnapV = getDeltaFPArray(pDict->stemSnapV,
2303                                            type1CMaxStemSnap);
2304        break;
2305      case 0x0c0e:
2306        pDict->forceBold = ops[0].num != 0;
2307        pDict->hasForceBold = gTrue;
2308        break;
2309      case 0x0c0f:
2310        pDict->forceBoldThreshold = ops[0].num;
2311        break;
2312      case 0x0c11:
2313        pDict->languageGroup = (int)ops[0].num;
2314        break;
2315      case 0x0c12:
2316        pDict->expansionFactor = ops[0].num;
2317        break;
2318      case 0x0c13:
2319        pDict->initialRandomSeed = (int)ops[0].num;
2320        break;
2321      case 0x0013:
2322        pDict->subrsOffset = offset + (int)ops[0].num;
2323        break;
2324      case 0x0014:
2325        pDict->defaultWidthX = ops[0].num;
2326        pDict->defaultWidthXFP = ops[0].isFP;
2327        break;
2328      case 0x0015:
2329        pDict->nominalWidthX = ops[0].num;
2330        pDict->nominalWidthXFP = ops[0].isFP;
2331        break;
2332      }
2333      nOps = 0;
2334    }
2335  }
2336}
2337
2338void FoFiType1C::readFDSelect() {
2339  int fdSelectFmt, pos, nRanges, gid0, gid1, fd, i, j;
2340
2341  fdSelect = (Guchar *)gmalloc(nGlyphs);
2342  if (topDict.fdSelectOffset == 0) {
2343    for (i = 0; i < nGlyphs; ++i) {
2344      fdSelect[i] = 0;
2345    }
2346  } else {
2347    pos = topDict.fdSelectOffset;
2348    fdSelectFmt = getU8(pos++, &parsedOk);
2349    if (!parsedOk) {
2350      return;
2351    }
2352    if (fdSelectFmt == 0) {
2353      if (!checkRegion(pos, nGlyphs)) {
2354        parsedOk = gFalse;
2355        return;
2356      }
2357      memcpy(fdSelect, file + pos, nGlyphs);
2358    } else if (fdSelectFmt == 3) {
2359      nRanges = getU16BE(pos, &parsedOk);
2360      pos += 2;
2361      gid0 = getU16BE(pos, &parsedOk);
2362      pos += 2;
2363      for (i = 1; i <= nRanges; ++i) {
2364        fd = getU8(pos++, &parsedOk);
2365        gid1 = getU16BE(pos, &parsedOk);
2366        if (!parsedOk) {
2367          return;
2368        }
2369        pos += 2;
2370        if (gid0 > gid1 || gid1 > nGlyphs) {
2371          //~ error(-1, "Bad FDSelect table in CID font");
2372          parsedOk = gFalse;
2373          return;
2374        }
2375        for (j = gid0; j < gid1; ++j) {
2376          fdSelect[j] = fd;
2377        }
2378        gid0 = gid1;
2379      }
2380    } else {
2381      //~ error(-1, "Unknown FDSelect table format in CID font");
2382      for (i = 0; i < nGlyphs; ++i) {
2383        fdSelect[i] = 0;
2384      }
2385    }
2386  }
2387}
2388
2389void FoFiType1C::buildEncoding() {
2390  char buf[256];
2391  int nCodes, nRanges, encFormat;
2392  int pos, c, sid, nLeft, nSups, i, j;
2393
2394  if (topDict.encodingOffset == 0) {
2395    encoding = (char **)fofiType1StandardEncoding;
2396
2397  } else if (topDict.encodingOffset == 1) {
2398    encoding = (char **)fofiType1ExpertEncoding;
2399
2400  } else {
2401    encoding = (char **)gmallocn(256, sizeof(char *));
2402    for (i = 0; i < 256; ++i) {
2403      encoding[i] = NULL;
2404    }
2405    pos = topDict.encodingOffset;
2406    encFormat = getU8(pos++, &parsedOk);
2407    if (!parsedOk) {
2408      return;
2409    }
2410    if ((encFormat & 0x7f) == 0) {
2411      nCodes = 1 + getU8(pos++, &parsedOk);
2412      if (!parsedOk) {
2413        return;
2414      }
2415      if (nCodes > nGlyphs) {
2416        nCodes = nGlyphs;
2417      }
2418      for (i = 1; i < nCodes; ++i) {
2419        c = getU8(pos++, &parsedOk);
2420        if (!parsedOk) {
2421          return;
2422        }
2423        if (encoding[c]) {
2424          gfree(encoding[c]);
2425        }
2426        encoding[c] = copyString(getString(charset[i], buf, &parsedOk));
2427      }
2428    } else if ((encFormat & 0x7f) == 1) {
2429      nRanges = getU8(pos++, &parsedOk);
2430      if (!parsedOk) {
2431        return;
2432      }
2433      nCodes = 1;
2434      for (i = 0; i < nRanges; ++i) {
2435        c = getU8(pos++, &parsedOk);
2436        nLeft = getU8(pos++, &parsedOk);
2437        if (!parsedOk) {
2438          return;
2439        }
2440        for (j = 0; j <= nLeft && nCodes < nGlyphs; ++j) {
2441          if (c < 256) {
2442            if (encoding[c]) {
2443              gfree(encoding[c]);
2444            }
2445            encoding[c] = copyString(getString(charset[nCodes], buf,
2446                                               &parsedOk));
2447          }
2448          ++nCodes;
2449          ++c;
2450        }
2451      }
2452    }
2453    if (encFormat & 0x80) {
2454      nSups = getU8(pos++, &parsedOk);
2455      if (!parsedOk) {
2456        return;
2457      }
2458      for (i = 0; i < nSups; ++i) {
2459        c = getU8(pos++, &parsedOk);;
2460        if (!parsedOk) {
2461          return;;
2462        }
2463        sid = getU16BE(pos, &parsedOk);
2464        pos += 2;
2465        if (!parsedOk) {
2466          return;
2467        }
2468        if (encoding[c]) {
2469          gfree(encoding[c]);
2470        }
2471        encoding[c] = copyString(getString(sid, buf, &parsedOk));
2472      }
2473    }
2474  }
2475}
2476
2477GBool FoFiType1C::readCharset() {
2478  int charsetFormat, c, pos;
2479  int nLeft, i, j;
2480
2481  if (topDict.charsetOffset == 0) {
2482    charset = fofiType1CISOAdobeCharset;
2483  } else if (topDict.charsetOffset == 1) {
2484    charset = fofiType1CExpertCharset;
2485  } else if (topDict.charsetOffset == 2) {
2486    charset = fofiType1CExpertSubsetCharset;
2487  } else {
2488    charset = (Gushort *)gmallocn(nGlyphs, sizeof(Gushort));
2489    for (i = 0; i < nGlyphs; ++i) {
2490      charset[i] = 0;
2491    }
2492    pos = topDict.charsetOffset;
2493    charsetFormat = getU8(pos++, &parsedOk);
2494    if (charsetFormat == 0) {
2495      for (i = 1; i < nGlyphs; ++i) {
2496        charset[i] = (Gushort)getU16BE(pos, &parsedOk);
2497        pos += 2;
2498        if (!parsedOk) {
2499          break;
2500        }
2501      }
2502    } else if (charsetFormat == 1) {
2503      i = 1;
2504      while (i < nGlyphs) {
2505        c = getU16BE(pos, &parsedOk);
2506        pos += 2;
2507        nLeft = getU8(pos++, &parsedOk);
2508        if (!parsedOk) {
2509          break;
2510        }
2511        for (j = 0; j <= nLeft && i < nGlyphs; ++j) {
2512          charset[i++] = (Gushort)c++;
2513        }
2514      }
2515    } else if (charsetFormat == 2) {
2516      i = 1;
2517      while (i < nGlyphs) {
2518        c = getU16BE(pos, &parsedOk);
2519        pos += 2;
2520        nLeft = getU16BE(pos, &parsedOk);
2521        pos += 2;
2522        if (!parsedOk) {
2523          break;
2524        }
2525        for (j = 0; j <= nLeft && i < nGlyphs; ++j) {
2526          charset[i++] = (Gushort)c++;
2527        }
2528      }
2529    }
2530    if (!parsedOk) {
2531      gfree(charset);
2532      charset = NULL;
2533      return gFalse;
2534    }
2535  }
2536  return gTrue;
2537}
2538
2539int FoFiType1C::getOp(int pos, GBool charstring, GBool *ok) {
2540  static char nybChars[16] = "0123456789.ee -";
2541  Type1COp op;
2542  char buf[65];
2543  int b0, b1, nyb0, nyb1, x, i;
2544
2545  b0 = getU8(pos++, ok);
2546  op.isNum = gTrue;
2547  op.isFP = gFalse;
2548
2549  if (b0 == 28) {
2550    x = getU8(pos++, ok);
2551    x = (x << 8) | getU8(pos++, ok);
2552    if (x & 0x8000) {
2553      x |= ~0xffff;
2554    }
2555    op.num = x;
2556
2557  } else if (!charstring && b0 == 29) {
2558    x = getU8(pos++, ok);
2559    x = (x << 8) | getU8(pos++, ok);
2560    x = (x << 8) | getU8(pos++, ok);
2561    x = (x << 8) | getU8(pos++, ok);
2562    if (x & 0x80000000) {
2563      x |= ~0xffffffff;
2564    }
2565    op.num = x;
2566
2567  } else if (!charstring && b0 == 30) {
2568    i = 0;
2569    do {
2570      b1 = getU8(pos++, ok);
2571      nyb0 = b1 >> 4;
2572      nyb1 = b1 & 0x0f;
2573      if (nyb0 == 0xf) {
2574        break;
2575      }
2576      buf[i++] = nybChars[nyb0];
2577      if (i == 64) {
2578        break;
2579      }
2580      if (nyb0 == 0xc) {
2581        buf[i++] = '-';
2582      }
2583      if (i == 64) {
2584        break;
2585      }
2586      if (nyb1 == 0xf) {
2587        break;
2588      }
2589      buf[i++] = nybChars[nyb1];
2590      if (i == 64) {
2591        break;
2592      }
2593      if (nyb1 == 0xc) {
2594        buf[i++] = '-';
2595      }
2596    } while (i < 64);
2597    buf[i] = '\0';
2598    op.num = gatof(buf);
2599    op.isFP = gTrue;
2600
2601  } else if (b0 >= 32 && b0 <= 246) {
2602    op.num = b0 - 139;
2603
2604  } else if (b0 >= 247 && b0 <= 250) {
2605    op.num = ((b0 - 247) << 8) + getU8(pos++, ok) + 108;
2606
2607  } else if (b0 >= 251 && b0 <= 254) {
2608    op.num = -((b0 - 251) << 8) - getU8(pos++, ok) - 108;
2609
2610  } else if (charstring && b0 == 255) {
2611    x = getU8(pos++, ok);
2612    x = (x << 8) | getU8(pos++, ok);
2613    x = (x << 8) | getU8(pos++, ok);
2614    x = (x << 8) | getU8(pos++, ok);
2615    if (x & 0x80000000) {
2616      x |= ~0xffffffff;
2617    }
2618    op.num = (double)x / 65536.0;
2619    op.isFP = gTrue;
2620
2621  } else if (b0 == 12) {
2622    op.isNum = gFalse;
2623    op.op = 0x0c00 + getU8(pos++, ok);
2624
2625  } else {
2626    op.isNum = gFalse;
2627    op.op = b0;
2628  }
2629
2630  if (nOps < 49) {
2631    ops[nOps++] = op;
2632  }
2633
2634  return pos;
2635}
2636
2637// Convert the delta-encoded ops array to an array of ints.
2638int FoFiType1C::getDeltaIntArray(int *arr, int maxLen) {
2639  int x;
2640  int n, i;
2641
2642  if ((n = nOps) > maxLen) {
2643    n = maxLen;
2644  }
2645  x = 0;
2646  for (i = 0; i < n; ++i) {
2647    x += (int)ops[i].num;
2648    arr[i] = x;
2649  }
2650  return n;
2651}
2652
2653// Convert the delta-encoded ops array to an array of doubles.
2654int FoFiType1C::getDeltaFPArray(double *arr, int maxLen) {
2655  double x;
2656  int n, i;
2657
2658  if ((n = nOps) > maxLen) {
2659    n = maxLen;
2660  }
2661  x = 0;
2662  for (i = 0; i < n; ++i) {
2663    x += ops[i].num;
2664    arr[i] = x;
2665  }
2666  return n;
2667}
2668
2669void FoFiType1C::getIndex(int pos, Type1CIndex *idx, GBool *ok) {
2670  idx->pos = pos;
2671  idx->len = getU16BE(pos, ok);
2672  if (idx->len == 0) {
2673    // empty indexes are legal and contain just the length field
2674    idx->offSize = 0;
2675    idx->startPos = idx->endPos = pos + 2;
2676  } else {
2677    idx->offSize = getU8(pos + 2, ok);
2678    if (idx->offSize < 1 || idx->offSize > 4) {
2679      *ok = gFalse;
2680    }
2681    idx->startPos = pos + 3 + (idx->len + 1) * idx->offSize - 1;
2682    if (idx->startPos < 0 || idx->startPos >= len) {
2683      *ok = gFalse;
2684    }
2685    idx->endPos = idx->startPos + getUVarBE(pos + 3 + idx->len * idx->offSize,
2686                                            idx->offSize, ok);
2687    if (idx->endPos < idx->startPos || idx->endPos > len) {
2688      *ok = gFalse;
2689    }
2690  }
2691}
2692
2693void FoFiType1C::getIndexVal(Type1CIndex *idx, int i,
2694                             Type1CIndexVal *val, GBool *ok) {
2695  int pos0, pos1;
2696
2697  if (i < 0 || i >= idx->len) {
2698    *ok = gFalse;
2699    return;
2700  }
2701  pos0 = idx->startPos + getUVarBE(idx->pos + 3 + i * idx->offSize,
2702                                   idx->offSize, ok);
2703  pos1 = idx->startPos + getUVarBE(idx->pos + 3 + (i + 1) * idx->offSize,
2704                                   idx->offSize, ok);
2705  if (pos0 < idx->startPos || pos0 > idx->endPos ||
2706      pos1 <= idx->startPos || pos1 > idx->endPos ||
2707      pos1 < pos0) {
2708    *ok = gFalse;
2709  }
2710  val->pos = pos0;
2711  val->len = pos1 - pos0;
2712}
2713
2714char *FoFiType1C::getString(int sid, char *buf, GBool *ok) {
2715  Type1CIndexVal val;
2716  int n;
2717
2718  if (sid < 0) {
2719    buf[0] = '\0';
2720  } else if (sid < 391) {
2721    strcpy(buf, fofiType1CStdStrings[sid]);
2722  } else {
2723    sid -= 391;
2724    getIndexVal(&stringIdx, sid, &val, ok);
2725    if (*ok) {
2726      if ((n = val.len) > 255) {
2727        n = 255;
2728      }
2729      strncpy(buf, (char *)&file[val.pos], n);
2730      buf[n] = '\0';
2731    } else {
2732      buf[0] = '\0';
2733    }
2734  }
2735  return buf;
2736}
Note: See TracBrowser for help on using the repository browser.