diff options
Diffstat (limited to 'Build/source/libs/poppler/poppler-0.35.0/poppler/GfxFont.cc')
| -rw-r--r-- | Build/source/libs/poppler/poppler-0.35.0/poppler/GfxFont.cc | 2620 |
1 files changed, 2620 insertions, 0 deletions
diff --git a/Build/source/libs/poppler/poppler-0.35.0/poppler/GfxFont.cc b/Build/source/libs/poppler/poppler-0.35.0/poppler/GfxFont.cc new file mode 100644 index 00000000000..81f59037f7f --- /dev/null +++ b/Build/source/libs/poppler/poppler-0.35.0/poppler/GfxFont.cc @@ -0,0 +1,2620 @@ +//======================================================================== +// +// GfxFont.cc +// +// Copyright 1996-2003 Glyph & Cog, LLC +// +//======================================================================== + +//======================================================================== +// +// Modified under the Poppler project - http://poppler.freedesktop.org +// +// All changes made under the Poppler project to this file are licensed +// under GPL version 2 or later +// +// Copyright (C) 2005, 2006, 2008-2010, 2012, 2014, 2015 Albert Astals Cid <aacid@kde.org> +// Copyright (C) 2005, 2006 Kristian Høgsberg <krh@redhat.com> +// Copyright (C) 2006 Takashi Iwai <tiwai@suse.de> +// Copyright (C) 2007 Julien Rebetez <julienr@svn.gnome.org> +// Copyright (C) 2007 Jeff Muizelaar <jeff@infidigm.net> +// Copyright (C) 2007 Koji Otani <sho@bbr.jp> +// Copyright (C) 2007 Ed Catmur <ed@catmur.co.uk> +// Copyright (C) 2008 Jonathan Kew <jonathan_kew@sil.org> +// Copyright (C) 2008 Ed Avis <eda@waniasset.com> +// Copyright (C) 2008, 2010 Hib Eris <hib@hiberis.nl> +// Copyright (C) 2009 Peter Kerzum <kerzum@yandex-team.ru> +// Copyright (C) 2009, 2010 David Benjamin <davidben@mit.edu> +// Copyright (C) 2011 Axel Strübing <axel.struebing@freenet.de> +// Copyright (C) 2011, 2012, 2014 Adrian Johnson <ajohnson@redneon.com> +// Copyright (C) 2012 Yi Yang <ahyangyi@gmail.com> +// Copyright (C) 2012 Suzuki Toshiya <mpsuzuki@hiroshima-u.ac.jp> +// Copyright (C) 2012 Thomas Freitag <Thomas.Freitag@alfa.de> +// Copyright (C) 2013-2015 Jason Crain <jason@aquaticape.us> +// Copyright (C) 2014 Olly Betts <olly@survex.com> +// +// To see a description of the changes please see the Changelog file that +// came with your tarball or type make ChangeLog if you are building from git +// +//======================================================================== + +#include <config.h> + +#ifdef USE_GCC_PRAGMAS +#pragma implementation +#endif + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <ctype.h> +#include <math.h> +#include <limits.h> +#include <algorithm> +#include "goo/gmem.h" +#include "Error.h" +#include "Object.h" +#include "Dict.h" +#include "GlobalParams.h" +#include "CMap.h" +#include "CharCodeToUnicode.h" +#include "FontEncodingTables.h" +#include "BuiltinFontTables.h" +#include "UnicodeTypeTable.h" +#include <fofi/FoFiIdentifier.h> +#include <fofi/FoFiType1.h> +#include <fofi/FoFiType1C.h> +#include <fofi/FoFiTrueType.h> +#include "GfxFont.h" +#include "PSOutputDev.h" + +//------------------------------------------------------------------------ + +struct Base14FontMapEntry { + const char *altName; + const char *base14Name; +}; + +static const Base14FontMapEntry base14FontMap[] = { + { "Arial", "Helvetica" }, + { "Arial,Bold", "Helvetica-Bold" }, + { "Arial,BoldItalic", "Helvetica-BoldOblique" }, + { "Arial,Italic", "Helvetica-Oblique" }, + { "Arial-Bold", "Helvetica-Bold" }, + { "Arial-BoldItalic", "Helvetica-BoldOblique" }, + { "Arial-BoldItalicMT", "Helvetica-BoldOblique" }, + { "Arial-BoldMT", "Helvetica-Bold" }, + { "Arial-Italic", "Helvetica-Oblique" }, + { "Arial-ItalicMT", "Helvetica-Oblique" }, + { "ArialMT", "Helvetica" }, + { "Courier", "Courier" }, + { "Courier,Bold", "Courier-Bold" }, + { "Courier,BoldItalic", "Courier-BoldOblique" }, + { "Courier,Italic", "Courier-Oblique" }, + { "Courier-Bold", "Courier-Bold" }, + { "Courier-BoldOblique", "Courier-BoldOblique" }, + { "Courier-Oblique", "Courier-Oblique" }, + { "CourierNew", "Courier" }, + { "CourierNew,Bold", "Courier-Bold" }, + { "CourierNew,BoldItalic", "Courier-BoldOblique" }, + { "CourierNew,Italic", "Courier-Oblique" }, + { "CourierNew-Bold", "Courier-Bold" }, + { "CourierNew-BoldItalic", "Courier-BoldOblique" }, + { "CourierNew-Italic", "Courier-Oblique" }, + { "CourierNewPS-BoldItalicMT", "Courier-BoldOblique" }, + { "CourierNewPS-BoldMT", "Courier-Bold" }, + { "CourierNewPS-ItalicMT", "Courier-Oblique" }, + { "CourierNewPSMT", "Courier" }, + { "Helvetica", "Helvetica" }, + { "Helvetica,Bold", "Helvetica-Bold" }, + { "Helvetica,BoldItalic", "Helvetica-BoldOblique" }, + { "Helvetica,Italic", "Helvetica-Oblique" }, + { "Helvetica-Bold", "Helvetica-Bold" }, + { "Helvetica-BoldItalic", "Helvetica-BoldOblique" }, + { "Helvetica-BoldOblique", "Helvetica-BoldOblique" }, + { "Helvetica-Italic", "Helvetica-Oblique" }, + { "Helvetica-Oblique", "Helvetica-Oblique" }, + { "Symbol", "Symbol" }, + { "Symbol,Bold", "Symbol" }, + { "Symbol,BoldItalic", "Symbol" }, + { "Symbol,Italic", "Symbol" }, + { "Times-Bold", "Times-Bold" }, + { "Times-BoldItalic", "Times-BoldItalic" }, + { "Times-Italic", "Times-Italic" }, + { "Times-Roman", "Times-Roman" }, + { "TimesNewRoman", "Times-Roman" }, + { "TimesNewRoman,Bold", "Times-Bold" }, + { "TimesNewRoman,BoldItalic", "Times-BoldItalic" }, + { "TimesNewRoman,Italic", "Times-Italic" }, + { "TimesNewRoman-Bold", "Times-Bold" }, + { "TimesNewRoman-BoldItalic", "Times-BoldItalic" }, + { "TimesNewRoman-Italic", "Times-Italic" }, + { "TimesNewRomanPS", "Times-Roman" }, + { "TimesNewRomanPS-Bold", "Times-Bold" }, + { "TimesNewRomanPS-BoldItalic", "Times-BoldItalic" }, + { "TimesNewRomanPS-BoldItalicMT", "Times-BoldItalic" }, + { "TimesNewRomanPS-BoldMT", "Times-Bold" }, + { "TimesNewRomanPS-Italic", "Times-Italic" }, + { "TimesNewRomanPS-ItalicMT", "Times-Italic" }, + { "TimesNewRomanPSMT", "Times-Roman" }, + { "TimesNewRomanPSMT,Bold", "Times-Bold" }, + { "TimesNewRomanPSMT,BoldItalic", "Times-BoldItalic" }, + { "TimesNewRomanPSMT,Italic", "Times-Italic" }, + { "ZapfDingbats", "ZapfDingbats" } +}; + +//------------------------------------------------------------------------ + +// index: {fixed:0, sans-serif:4, serif:8} + bold*2 + italic +// NB: must be in same order as psSubstFonts in PSOutputDev.cc +static const char *base14SubstFonts[14] = { + "Courier", + "Courier-Oblique", + "Courier-Bold", + "Courier-BoldOblique", + "Helvetica", + "Helvetica-Oblique", + "Helvetica-Bold", + "Helvetica-BoldOblique", + "Times-Roman", + "Times-Italic", + "Times-Bold", + "Times-BoldItalic", + // the last two are never used for substitution + "Symbol", + "ZapfDingbats" +}; + +//------------------------------------------------------------------------ + +static int parseCharName(char *charName, Unicode *uBuf, int uLen, + GBool names, GBool ligatures, + GBool numeric, GBool hex, GBool variants); + +//------------------------------------------------------------------------ + +static int readFromStream(void *data) { + return ((Stream *)data)->getChar(); +} + +//------------------------------------------------------------------------ +// GfxFontLoc +//------------------------------------------------------------------------ + +GfxFontLoc::GfxFontLoc() { + path = NULL; + fontNum = 0; + encoding = NULL; + substIdx = -1; +} + +GfxFontLoc::~GfxFontLoc() { + if (path) { + delete path; + } + if (encoding) { + delete encoding; + } +} + +//------------------------------------------------------------------------ +// GfxFont +//------------------------------------------------------------------------ + +GfxFont *GfxFont::makeFont(XRef *xref, const char *tagA, Ref idA, Dict *fontDict) { + GooString *nameA; + Ref embFontIDA; + GfxFontType typeA; + GfxFont *font; + Object obj1; + + // get base font name + nameA = NULL; + fontDict->lookup("BaseFont", &obj1); + if (obj1.isName()) { + nameA = new GooString(obj1.getName()); + } + obj1.free(); + + // get embedded font ID and font type + typeA = getFontType(xref, fontDict, &embFontIDA); + + // create the font object + font = NULL; + if (typeA < fontCIDType0) { + font = new Gfx8BitFont(xref, tagA, idA, nameA, typeA, embFontIDA, + fontDict); + } else { + font = new GfxCIDFont(xref, tagA, idA, nameA, typeA, embFontIDA, + fontDict); + } + + return font; +} + +GfxFont::GfxFont(const char *tagA, Ref idA, GooString *nameA, + GfxFontType typeA, Ref embFontIDA) { + ok = gFalse; + tag = new GooString(tagA); + id = idA; + name = nameA; + type = typeA; + embFontID = embFontIDA; + embFontName = NULL; + family = NULL; + stretch = StretchNotDefined; + weight = WeightNotDefined; + refCnt = 1; + encodingName = new GooString(""); + hasToUnicode = gFalse; +} + +GfxFont::~GfxFont() { + delete tag; + delete family; + if (name) { + delete name; + } + if (embFontName) { + delete embFontName; + } + if (encodingName) { + delete encodingName; + } +} + +void GfxFont::incRefCnt() { + refCnt++; +} + +void GfxFont::decRefCnt() { + if (--refCnt == 0) + delete this; +} + +// This function extracts three pieces of information: +// 1. the "expected" font type, i.e., the font type implied by +// Font.Subtype, DescendantFont.Subtype, and +// FontDescriptor.FontFile3.Subtype +// 2. the embedded font object ID +// 3. the actual font type - determined by examining the embedded font +// if there is one, otherwise equal to the expected font type +// If the expected and actual font types don't match, a warning +// message is printed. The expected font type is not used for +// anything else. +GfxFontType GfxFont::getFontType(XRef *xref, Dict *fontDict, Ref *embID) { + GfxFontType t, expectedType; + FoFiIdentifierType fft; + Dict *fontDict2; + Object subtype, fontDesc, obj1, obj2, obj3, obj4; + GBool isType0, err; + + t = fontUnknownType; + embID->num = embID->gen = -1; + err = gFalse; + + fontDict->lookup("Subtype", &subtype); + expectedType = fontUnknownType; + isType0 = gFalse; + if (subtype.isName("Type1") || subtype.isName("MMType1")) { + expectedType = fontType1; + } else if (subtype.isName("Type1C")) { + expectedType = fontType1C; + } else if (subtype.isName("Type3")) { + expectedType = fontType3; + } else if (subtype.isName("TrueType")) { + expectedType = fontTrueType; + } else if (subtype.isName("Type0")) { + isType0 = gTrue; + } else { + error(errSyntaxWarning, -1, "Unknown font type: '{0:s}'", + subtype.isName() ? subtype.getName() : "???"); + } + subtype.free(); + + fontDict2 = fontDict; + if (fontDict->lookup("DescendantFonts", &obj1)->isArray()) { + if (obj1.arrayGetLength() == 0) { + error(errSyntaxWarning, -1, "Empty DescendantFonts array in font"); + obj2.initNull(); + } else if (obj1.arrayGet(0, &obj2)->isDict()) { + if (!isType0) { + error(errSyntaxWarning, -1, "Non-CID font with DescendantFonts array"); + } + fontDict2 = obj2.getDict(); + fontDict2->lookup("Subtype", &subtype); + if (subtype.isName("CIDFontType0")) { + if (isType0) { + expectedType = fontCIDType0; + } + } else if (subtype.isName("CIDFontType2")) { + if (isType0) { + expectedType = fontCIDType2; + } + } + subtype.free(); + } + } else { + obj2.initNull(); + } + + if (fontDict2->lookup("FontDescriptor", &fontDesc)->isDict()) { + if (fontDesc.dictLookupNF("FontFile", &obj3)->isRef()) { + *embID = obj3.getRef(); + if (expectedType != fontType1) { + err = gTrue; + } + } + obj3.free(); + if (embID->num == -1 && + fontDesc.dictLookupNF("FontFile2", &obj3)->isRef()) { + *embID = obj3.getRef(); + if (isType0) { + expectedType = fontCIDType2; + } else if (expectedType != fontTrueType) { + err = gTrue; + } + } + obj3.free(); + if (embID->num == -1 && + fontDesc.dictLookupNF("FontFile3", &obj3)->isRef()) { + *embID = obj3.getRef(); + if (obj3.fetch(xref, &obj4)->isStream()) { + obj4.streamGetDict()->lookup("Subtype", &subtype); + if (subtype.isName("Type1")) { + if (expectedType != fontType1) { + err = gTrue; + expectedType = isType0 ? fontCIDType0 : fontType1; + } + } else if (subtype.isName("Type1C")) { + if (expectedType == fontType1) { + expectedType = fontType1C; + } else if (expectedType != fontType1C) { + err = gTrue; + expectedType = isType0 ? fontCIDType0C : fontType1C; + } + } else if (subtype.isName("TrueType")) { + if (expectedType != fontTrueType) { + err = gTrue; + expectedType = isType0 ? fontCIDType2 : fontTrueType; + } + } else if (subtype.isName("CIDFontType0C")) { + if (expectedType == fontCIDType0) { + expectedType = fontCIDType0C; + } else { + err = gTrue; + expectedType = isType0 ? fontCIDType0C : fontType1C; + } + } else if (subtype.isName("OpenType")) { + if (expectedType == fontTrueType) { + expectedType = fontTrueTypeOT; + } else if (expectedType == fontType1) { + expectedType = fontType1COT; + } else if (expectedType == fontCIDType0) { + expectedType = fontCIDType0COT; + } else if (expectedType == fontCIDType2) { + expectedType = fontCIDType2OT; + } else { + err = gTrue; + } + } else { + error(errSyntaxError, -1, "Unknown font type '{0:s}'", + subtype.isName() ? subtype.getName() : "???"); + } + subtype.free(); + } + obj4.free(); + } + obj3.free(); + } + fontDesc.free(); + + t = fontUnknownType; + if (embID->num >= 0) { + obj3.initRef(embID->num, embID->gen); + obj3.fetch(xref, &obj4); + if (obj4.isStream()) { + obj4.streamReset(); + fft = FoFiIdentifier::identifyStream(&readFromStream, obj4.getStream()); + obj4.streamClose(); + switch (fft) { + case fofiIdType1PFA: + case fofiIdType1PFB: + t = fontType1; + break; + case fofiIdCFF8Bit: + t = isType0 ? fontCIDType0C : fontType1C; + break; + case fofiIdCFFCID: + t = fontCIDType0C; + break; + case fofiIdTrueType: + case fofiIdTrueTypeCollection: + t = isType0 ? fontCIDType2 : fontTrueType; + break; + case fofiIdOpenTypeCFF8Bit: + t = expectedType; // hack: open type always == expected type? s. bug-poppler20605.pdf + break; + case fofiIdOpenTypeCFFCID: + t = fontCIDType0COT; + break; + default: + error(errSyntaxError, -1, "Embedded font file may be invalid"); + break; + } + } + obj4.free(); + obj3.free(); + } + + if (t == fontUnknownType) { + t = expectedType; + } + + if (t != expectedType) { + err = gTrue; + } + + if (err) { + error(errSyntaxWarning, -1, + "Mismatch between font type and embedded font file"); + } + + obj2.free(); + obj1.free(); + + return t; +} + +void GfxFont::readFontDescriptor(XRef *xref, Dict *fontDict) { + Object obj1, obj2, obj3, obj4; + double t; + int i; + + // assume Times-Roman by default (for substitution purposes) + flags = fontSerif; + + missingWidth = 0; + + if (fontDict->lookup("FontDescriptor", &obj1)->isDict()) { + + // get flags + if (obj1.dictLookup("Flags", &obj2)->isInt()) { + flags = obj2.getInt(); + } + obj2.free(); + + // get name + obj1.dictLookup("FontName", &obj2); + if (obj2.isName()) { + embFontName = new GooString(obj2.getName()); + } + obj2.free(); + if (embFontName == NULL) { + // get name with typo + obj1.dictLookup("Fontname", &obj2); + if (obj2.isName()) { + embFontName = new GooString(obj2.getName()); + error(errSyntaxWarning, -1, "The file uses Fontname instead of FontName please notify the creator that the file is broken"); + } + obj2.free(); + } + + // get family + obj1.dictLookup("FontFamily", &obj2); + if (obj2.isString()) family = new GooString(obj2.getString()); + obj2.free(); + + // get stretch + obj1.dictLookup("FontStretch", &obj2); + if (obj2.isName()) { + if (strcmp(obj2.getName(), "UltraCondensed") == 0) stretch = UltraCondensed; + else if (strcmp(obj2.getName(), "ExtraCondensed") == 0) stretch = ExtraCondensed; + else if (strcmp(obj2.getName(), "Condensed") == 0) stretch = Condensed; + else if (strcmp(obj2.getName(), "SemiCondensed") == 0) stretch = SemiCondensed; + else if (strcmp(obj2.getName(), "Normal") == 0) stretch = Normal; + else if (strcmp(obj2.getName(), "SemiExpanded") == 0) stretch = SemiExpanded; + else if (strcmp(obj2.getName(), "Expanded") == 0) stretch = Expanded; + else if (strcmp(obj2.getName(), "ExtraExpanded") == 0) stretch = ExtraExpanded; + else if (strcmp(obj2.getName(), "UltraExpanded") == 0) stretch = UltraExpanded; + else error(errSyntaxWarning, -1, "Invalid Font Stretch"); + } + obj2.free(); + + // get weight + obj1.dictLookup("FontWeight", &obj2); + if (obj2.isNum()) { + if (obj2.getNum() == 100) weight = W100; + else if (obj2.getNum() == 200) weight = W200; + else if (obj2.getNum() == 300) weight = W300; + else if (obj2.getNum() == 400) weight = W400; + else if (obj2.getNum() == 500) weight = W500; + else if (obj2.getNum() == 600) weight = W600; + else if (obj2.getNum() == 700) weight = W700; + else if (obj2.getNum() == 800) weight = W800; + else if (obj2.getNum() == 900) weight = W900; + else error(errSyntaxWarning, -1, "Invalid Font Weight"); + } + obj2.free(); + + // look for MissingWidth + obj1.dictLookup("MissingWidth", &obj2); + if (obj2.isNum()) { + missingWidth = obj2.getNum(); + } + obj2.free(); + + // get Ascent and Descent + obj1.dictLookup("Ascent", &obj2); + if (obj2.isNum()) { + t = 0.001 * obj2.getNum(); + // some broken font descriptors specify a negative ascent + if (t < 0) { + t = -t; + } + // some broken font descriptors set ascent and descent to 0; + // others set it to ridiculous values (e.g., 32768) + if (t != 0 && t < 3) { + ascent = t; + } + } + obj2.free(); + obj1.dictLookup("Descent", &obj2); + if (obj2.isNum()) { + t = 0.001 * obj2.getNum(); + // some broken font descriptors specify a positive descent + if (t > 0) { + t = -t; + } + // some broken font descriptors set ascent and descent to 0 + if (t != 0 && t > -3) { + descent = t; + } + } + obj2.free(); + + // font FontBBox + if (obj1.dictLookup("FontBBox", &obj2)->isArray()) { + for (i = 0; i < 4 && i < obj2.arrayGetLength(); ++i) { + if (obj2.arrayGet(i, &obj3)->isNum()) { + fontBBox[i] = 0.001 * obj3.getNum(); + } + obj3.free(); + } + } + obj2.free(); + + } + obj1.free(); +} + +CharCodeToUnicode *GfxFont::readToUnicodeCMap(Dict *fontDict, int nBits, + CharCodeToUnicode *ctu) { + GooString *buf; + Object obj1; + + if (!fontDict->lookup("ToUnicode", &obj1)->isStream()) { + obj1.free(); + return NULL; + } + buf = new GooString(); + obj1.getStream()->fillGooString(buf); + obj1.streamClose(); + obj1.free(); + if (ctu) { + ctu->mergeCMap(buf, nBits); + } else { + ctu = CharCodeToUnicode::parseCMap(buf, nBits); + } + hasToUnicode = gTrue; + delete buf; + return ctu; +} + +GfxFontLoc *GfxFont::locateFont(XRef *xref, PSOutputDev *ps) { + GfxFontLoc *fontLoc; + SysFontType sysFontType; + GooString *path, *base14Name, *substName; + PSFontParam16 *psFont16; + Object refObj, embFontObj; + int substIdx, fontNum; + GBool embed; + + if (type == fontType3) { + return NULL; + } + + //----- embedded font + if (embFontID.num >= 0) { + embed = gTrue; + refObj.initRef(embFontID.num, embFontID.gen); + refObj.fetch(xref, &embFontObj); + if (!embFontObj.isStream()) { + error(errSyntaxError, -1, "Embedded font object is wrong type"); + embed = gFalse; + } + embFontObj.free(); + refObj.free(); + if (embed) { + if (ps) { + switch (type) { + case fontType1: + case fontType1C: + case fontType1COT: + embed = ps->getEmbedType1(); + break; + case fontTrueType: + case fontTrueTypeOT: + embed = ps->getEmbedTrueType(); + break; + case fontCIDType0C: + case fontCIDType0COT: + embed = ps->getEmbedCIDPostScript(); + break; + case fontCIDType2: + case fontCIDType2OT: + embed = ps->getEmbedCIDTrueType(); + break; + default: + break; + } + } + if (embed) { + fontLoc = new GfxFontLoc(); + fontLoc->locType = gfxFontLocEmbedded; + fontLoc->fontType = type; + fontLoc->embFontID = embFontID; + return fontLoc; + } + } + } + + //----- PS passthrough + if (ps && !isCIDFont() && ps->getFontPassthrough()) { + fontLoc = new GfxFontLoc(); + fontLoc->locType = gfxFontLocResident; + fontLoc->fontType = fontType1; + fontLoc->path = name->copy(); + return fontLoc; + } + + //----- PS resident Base-14 font + if (ps && !isCIDFont() && ((Gfx8BitFont *)this)->base14) { + fontLoc = new GfxFontLoc(); + fontLoc->locType = gfxFontLocResident; + fontLoc->fontType = fontType1; + fontLoc->path = new GooString(((Gfx8BitFont *)this)->base14->base14Name); + return fontLoc; + } + + //----- external font file (fontFile, fontDir) + if (name && (path = globalParams->findFontFile(name))) { + if ((fontLoc = getExternalFont(path, isCIDFont()))) { + return fontLoc; + } + } + + //----- external font file for Base-14 font + if (!ps && !isCIDFont() && ((Gfx8BitFont *)this)->base14) { + base14Name = new GooString(((Gfx8BitFont *)this)->base14->base14Name); + if ((path = globalParams->findBase14FontFile(base14Name, this))) { + if ((fontLoc = getExternalFont(path, gFalse))) { + delete base14Name; + return fontLoc; + } + } + delete base14Name; + } + + //----- system font + if ((path = globalParams->findSystemFontFile(this, &sysFontType, + &fontNum))) { + if (isCIDFont()) { + if (sysFontType == sysFontTTF || sysFontType == sysFontTTC) { + fontLoc = new GfxFontLoc(); + fontLoc->locType = gfxFontLocExternal; + fontLoc->fontType = fontCIDType2; + fontLoc->path = path; + fontLoc->fontNum = fontNum; + return fontLoc; + } + } else { + if (sysFontType == sysFontTTF || sysFontType == sysFontTTC) { + fontLoc = new GfxFontLoc(); + fontLoc->locType = gfxFontLocExternal; + fontLoc->fontType = fontTrueType; + fontLoc->path = path; + return fontLoc; + } else if (sysFontType == sysFontPFA || sysFontType == sysFontPFB) { + fontLoc = new GfxFontLoc(); + fontLoc->locType = gfxFontLocExternal; + fontLoc->fontType = fontType1; + fontLoc->path = path; + fontLoc->fontNum = fontNum; + return fontLoc; + } + } + delete path; + } + + if (!isCIDFont()) { + + //----- 8-bit PS resident font + if (name && ps) { + if ((path = globalParams->getPSResidentFont(name))) { + fontLoc = new GfxFontLoc(); + fontLoc->locType = gfxFontLocResident; + fontLoc->fontType = fontType1; + fontLoc->path = path; + return fontLoc; + } + } + + //----- 8-bit font substitution + if (flags & fontFixedWidth) { + substIdx = 0; + } else if (flags & fontSerif) { + substIdx = 8; + } else { + substIdx = 4; + } + if (isBold()) { + substIdx += 2; + } + if (isItalic()) { + substIdx += 1; + } + substName = new GooString(base14SubstFonts[substIdx]); + if (ps) { + error(errSyntaxWarning, -1, "Substituting font '{0:s}' for '{1:s}'", + base14SubstFonts[substIdx], name ? name->getCString() : "null"); + fontLoc = new GfxFontLoc(); + fontLoc->locType = gfxFontLocResident; + fontLoc->fontType = fontType1; + fontLoc->path = substName; + fontLoc->substIdx = substIdx; + return fontLoc; + } else { + path = globalParams->findFontFile(substName); + delete substName; + if (path) { + if ((fontLoc = getExternalFont(path, gFalse))) { + error(errSyntaxWarning, -1, "Substituting font '{0:s}' for '{1:s}'", + base14SubstFonts[substIdx], name ? name->getCString() : ""); + name = new GooString(base14SubstFonts[substIdx]); + fontLoc->substIdx = substIdx; + return fontLoc; + } + } + } + + // failed to find a substitute font + return NULL; + } + + //----- 16-bit PS resident font + if (ps && ((psFont16 = globalParams->getPSResidentFont16( + name, + ((GfxCIDFont *)this)->getWMode())))) { + fontLoc = new GfxFontLoc(); + fontLoc->locType = gfxFontLocResident; + fontLoc->fontType = fontCIDType0; // this is not used + fontLoc->path = psFont16->psFontName->copy(); + fontLoc->encoding = psFont16->encoding->copy(); + fontLoc->wMode = psFont16->wMode; + return fontLoc; + } + if (ps && ((psFont16 = globalParams->getPSResidentFontCC( + ((GfxCIDFont *)this)->getCollection(), + ((GfxCIDFont *)this)->getWMode())))) { + error(errSyntaxWarning, -1, "Substituting font '{0:t}' for '{1:t}'", + psFont16->psFontName, name); + fontLoc = new GfxFontLoc(); + fontLoc->locType = gfxFontLocResident; + fontLoc->fontType = fontCIDType0; // this is not used + fontLoc->path = psFont16->psFontName->copy(); + fontLoc->encoding = psFont16->encoding->copy(); + fontLoc->wMode = psFont16->wMode; + return fontLoc; + } + + //----- CID font substitution + if ((path = globalParams->findCCFontFile( + ((GfxCIDFont *)this)->getCollection()))) { + if ((fontLoc = getExternalFont(path, gTrue))) { + error(errSyntaxWarning, -1, "Substituting font '{0:t}' for '{1:t}'", + fontLoc->path, name); + return fontLoc; + } + } + + // failed to find a substitute font + return NULL; +} + +GfxFontLoc *GfxFont::locateBase14Font(GooString *base14Name) { + GooString *path; + + path = globalParams->findFontFile(base14Name); + if (!path) { + return NULL; + } + return getExternalFont(path, gFalse); +} + +GfxFontLoc *GfxFont::getExternalFont(GooString *path, GBool cid) { + FoFiIdentifierType fft; + GfxFontType fontType; + GfxFontLoc *fontLoc; + + fft = FoFiIdentifier::identifyFile(path->getCString()); + switch (fft) { + case fofiIdType1PFA: + case fofiIdType1PFB: + fontType = fontType1; + break; + case fofiIdCFF8Bit: + fontType = fontType1C; + break; + case fofiIdCFFCID: + fontType = fontCIDType0C; + break; + case fofiIdTrueType: + case fofiIdTrueTypeCollection: + fontType = cid ? fontCIDType2 : fontTrueType; + break; + case fofiIdOpenTypeCFF8Bit: + fontType = fontType1COT; + break; + case fofiIdOpenTypeCFFCID: + fontType = fontCIDType0COT; + break; + case fofiIdUnknown: + case fofiIdError: + default: + fontType = fontUnknownType; + break; + } + if (fontType == fontUnknownType || + (cid ? (fontType < fontCIDType0) + : (fontType >= fontCIDType0))) { + delete path; + return NULL; + } + fontLoc = new GfxFontLoc(); + fontLoc->locType = gfxFontLocExternal; + fontLoc->fontType = fontType; + fontLoc->path = path; + return fontLoc; +} + +char *GfxFont::readEmbFontFile(XRef *xref, int *len) { + char *buf; + Object obj1, obj2; + Stream *str; + + obj1.initRef(embFontID.num, embFontID.gen); + obj1.fetch(xref, &obj2); + if (!obj2.isStream()) { + error(errSyntaxError, -1, "Embedded font file is not a stream"); + obj2.free(); + obj1.free(); + embFontID.num = -1; + *len = 0; + return NULL; + } + str = obj2.getStream(); + + buf = (char*)str->toUnsignedChars(len); + str->close(); + + obj2.free(); + obj1.free(); + + return buf; +} + + +struct AlternateNameMap { + const char *name; + const char *alt; +}; + +static const AlternateNameMap alternateNameMap[] = +{ + { "fi", "f_i" }, + { "fl", "f_l" }, + { "ff", "f_f" }, + { "ffi", "f_f_i" }, + { "ffl", "f_f_l" }, + { 0, 0 } +}; + +const char *GfxFont::getAlternateName(const char *name) { + const AlternateNameMap *map = alternateNameMap; + while (map->name) { + if (strcmp(name, map->name) == 0) { + return map->alt; + } + map++; + } + return 0; +} + +//------------------------------------------------------------------------ +// Gfx8BitFont +//------------------------------------------------------------------------ + +// Parse character names of the form 'Axx', 'xx', 'Ann', 'ABnn', or +// 'nn', where 'A' and 'B' are any letters, 'xx' is two hex digits, +// and 'nn' is decimal digits. +static GBool parseNumericName(char *s, GBool hex, unsigned int *u) { + char *endptr; + + // Strip leading alpha characters. + if (hex) { + int n = 0; + + // Get string length while ignoring junk at end. + while (isalnum(s[n])) + ++n; + + // Only 2 hex characters with optional leading alpha is allowed. + if (n == 3 && isalpha(*s)) { + ++s; + } else if (n != 2) { + return gFalse; + } + } else { + // Strip up to two alpha characters. + for (int i = 0; i < 2 && isalpha(*s); ++i) + ++s; + } + + int v = strtol(s, &endptr, hex ? 16 : 10); + + if (endptr == s) + return gFalse; + + // Skip trailing junk characters. + while (*endptr != '\0' && !isalnum(*endptr)) + ++endptr; + + if (*endptr == '\0') { + if (u) + *u = v; + return gTrue; + } + return gFalse; +} + +// Returns gTrue if the font has character names like xx or Axx which +// should be parsed for hex or decimal values. +static GBool testForNumericNames(Dict *fontDict, GBool hex) { + Object enc, diff, obj; + GBool numeric = gTrue; + + fontDict->lookup("Encoding", &enc); + if (!enc.isDict()) { + enc.free(); + return gFalse; + } + + enc.dictLookup("Differences", &diff); + enc.free(); + if (!diff.isArray()) { + diff.free(); + return gFalse; + } + + for (int i = 0; i < diff.arrayGetLength() && numeric; ++i) { + diff.arrayGet(i, &obj); + if (obj.isInt()) { + // All sequences must start between character codes 0 and 5. + if (obj.getInt() > 5) + numeric = gFalse; + } else if (obj.isName()) { + // All character names must sucessfully parse. + if (!parseNumericName(obj.getName(), hex, NULL)) + numeric = gFalse; + } else { + numeric = gFalse; + } + obj.free(); + } + + diff.free(); + return numeric; +} + +Gfx8BitFont::Gfx8BitFont(XRef *xref, const char *tagA, Ref idA, GooString *nameA, + GfxFontType typeA, Ref embFontIDA, Dict *fontDict): + GfxFont(tagA, idA, nameA, typeA, embFontIDA) { + GooString *name2; + BuiltinFont *builtinFont; + const char **baseEnc; + GBool baseEncFromFontFile; + char *buf; + int len; + FoFiType1 *ffT1; + FoFiType1C *ffT1C; + int code; + char *charName; + GBool missing, hex; + GBool numeric; + Unicode toUnicode[256]; + CharCodeToUnicode *utu, *ctu2; + Unicode uBuf[8]; + double mul; + int firstChar, lastChar; + Gushort w; + Object obj1, obj2, obj3; + int n, i, a, b, m; + + refCnt = 1; + ctu = NULL; + + // do font name substitution for various aliases of the Base 14 font + // names + base14 = NULL; + if (name) { + name2 = name->copy(); + i = 0; + while (i < name2->getLength()) { + if (name2->getChar(i) == ' ') { + name2->del(i); + } else { + ++i; + } + } + a = 0; + b = sizeof(base14FontMap) / sizeof(Base14FontMapEntry); + // invariant: base14FontMap[a].altName <= name2 < base14FontMap[b].altName + while (b - a > 1) { + m = (a + b) / 2; + if (name2->cmp(base14FontMap[m].altName) >= 0) { + a = m; + } else { + b = m; + } + } + if (!name2->cmp(base14FontMap[a].altName)) { + base14 = &base14FontMap[a]; + } + delete name2; + } + + // is it a built-in font? + builtinFont = NULL; + if (base14) { + for (i = 0; i < nBuiltinFonts; ++i) { + if (!strcmp(base14->base14Name, builtinFonts[i].name)) { + builtinFont = &builtinFonts[i]; + break; + } + } + } + + // default ascent/descent values + if (builtinFont) { + ascent = 0.001 * builtinFont->ascent; + descent = 0.001 * builtinFont->descent; + fontBBox[0] = 0.001 * builtinFont->bbox[0]; + fontBBox[1] = 0.001 * builtinFont->bbox[1]; + fontBBox[2] = 0.001 * builtinFont->bbox[2]; + fontBBox[3] = 0.001 * builtinFont->bbox[3]; + } else { + ascent = 0.95; + descent = -0.35; + fontBBox[0] = fontBBox[1] = fontBBox[2] = fontBBox[3] = 0; + } + + // get info from font descriptor + readFontDescriptor(xref, fontDict); + + // for non-embedded fonts, don't trust the ascent/descent/bbox + // values from the font descriptor + if (builtinFont && embFontID.num < 0) { + ascent = 0.001 * builtinFont->ascent; + descent = 0.001 * builtinFont->descent; + fontBBox[0] = 0.001 * builtinFont->bbox[0]; + fontBBox[1] = 0.001 * builtinFont->bbox[1]; + fontBBox[2] = 0.001 * builtinFont->bbox[2]; + fontBBox[3] = 0.001 * builtinFont->bbox[3]; + } + + // get font matrix + fontMat[0] = fontMat[3] = 1; + fontMat[1] = fontMat[2] = fontMat[4] = fontMat[5] = 0; + if (fontDict->lookup("FontMatrix", &obj1)->isArray()) { + for (i = 0; i < 6 && i < obj1.arrayGetLength(); ++i) { + if (obj1.arrayGet(i, &obj2)->isNum()) { + fontMat[i] = obj2.getNum(); + } + obj2.free(); + } + } + obj1.free(); + + // get Type 3 bounding box, font definition, and resources + if (type == fontType3) { + if (fontDict->lookup("FontBBox", &obj1)->isArray()) { + for (i = 0; i < 4 && i < obj1.arrayGetLength(); ++i) { + if (obj1.arrayGet(i, &obj2)->isNum()) { + fontBBox[i] = obj2.getNum(); + } + obj2.free(); + } + } + obj1.free(); + if (!fontDict->lookup("CharProcs", &charProcs)->isDict()) { + error(errSyntaxError, -1, + "Missing or invalid CharProcs dictionary in Type 3 font"); + charProcs.free(); + } + if (!fontDict->lookup("Resources", &resources)->isDict()) { + resources.free(); + } + } + + //----- build the font encoding ----- + + // Encodings start with a base encoding, which can come from + // (in order of priority): + // 1. FontDict.Encoding or FontDict.Encoding.BaseEncoding + // - MacRoman / MacExpert / WinAnsi / Standard + // 2. embedded or external font file + // 3. default: + // - builtin --> builtin encoding + // - TrueType --> WinAnsiEncoding + // - others --> StandardEncoding + // and then add a list of differences (if any) from + // FontDict.Encoding.Differences. + + // check FontDict for base encoding + hasEncoding = gFalse; + usesMacRomanEnc = gFalse; + baseEnc = NULL; + baseEncFromFontFile = gFalse; + fontDict->lookup("Encoding", &obj1); + if (obj1.isDict()) { + obj1.dictLookup("BaseEncoding", &obj2); + if (obj2.isName("MacRomanEncoding")) { + hasEncoding = gTrue; + usesMacRomanEnc = gTrue; + baseEnc = macRomanEncoding; + } else if (obj2.isName("MacExpertEncoding")) { + hasEncoding = gTrue; + baseEnc = macExpertEncoding; + } else if (obj2.isName("WinAnsiEncoding")) { + hasEncoding = gTrue; + baseEnc = winAnsiEncoding; + } + obj2.free(); + } else if (obj1.isName("MacRomanEncoding")) { + hasEncoding = gTrue; + usesMacRomanEnc = gTrue; + baseEnc = macRomanEncoding; + } else if (obj1.isName("MacExpertEncoding")) { + hasEncoding = gTrue; + baseEnc = macExpertEncoding; + } else if (obj1.isName("WinAnsiEncoding")) { + hasEncoding = gTrue; + baseEnc = winAnsiEncoding; + } + + // check embedded font file for base encoding + // (only for Type 1 fonts - trying to get an encoding out of a + // TrueType font is a losing proposition) + ffT1 = NULL; + ffT1C = NULL; + buf = NULL; + if (type == fontType1 && embFontID.num >= 0) { + if ((buf = readEmbFontFile(xref, &len))) { + if ((ffT1 = FoFiType1::make(buf, len))) { + if (ffT1->getName()) { + if (embFontName) { + delete embFontName; + } + embFontName = new GooString(ffT1->getName()); + } + if (!baseEnc) { + baseEnc = (const char **)ffT1->getEncoding(); + baseEncFromFontFile = gTrue; + } + } + gfree(buf); + } + } else if (type == fontType1C && embFontID.num >= 0) { + if ((buf = readEmbFontFile(xref, &len))) { + if ((ffT1C = FoFiType1C::make(buf, len))) { + if (ffT1C->getName()) { + if (embFontName) { + delete embFontName; + } + embFontName = new GooString(ffT1C->getName()); + } + if (!baseEnc) { + baseEnc = (const char **)ffT1C->getEncoding(); + baseEncFromFontFile = gTrue; + } + } + gfree(buf); + } + } + + // get default base encoding + if (!baseEnc) { + if (builtinFont && embFontID.num < 0) { + baseEnc = builtinFont->defaultBaseEnc; + hasEncoding = gTrue; + } else if (type == fontTrueType) { + baseEnc = winAnsiEncoding; + } else { + baseEnc = standardEncoding; + } + } + + if (baseEncFromFontFile) { + encodingName->Set("Builtin"); + } else if (baseEnc == winAnsiEncoding) { + encodingName->Set("WinAnsi"); + } else if (baseEnc == macRomanEncoding) { + encodingName->Set("MacRoman"); + } else if (baseEnc == macExpertEncoding) { + encodingName->Set("MacExpert"); + } else if (baseEnc == symbolEncoding) { + encodingName->Set("Symbol"); + } else if (baseEnc == zapfDingbatsEncoding) { + encodingName->Set("ZapfDingbats"); + } else { + encodingName->Set("Standard"); + } + + // copy the base encoding + for (i = 0; i < 256; ++i) { + enc[i] = (char *)baseEnc[i]; + if ((encFree[i] = baseEncFromFontFile) && enc[i]) { + enc[i] = copyString(baseEnc[i]); + } + } + + // some Type 1C font files have empty encodings, which can break the + // T1C->T1 conversion (since the 'seac' operator depends on having + // the accents in the encoding), so we fill in any gaps from + // StandardEncoding + if (type == fontType1C && embFontID.num >= 0 && baseEncFromFontFile) { + for (i = 0; i < 256; ++i) { + if (!enc[i] && standardEncoding[i]) { + enc[i] = (char *)standardEncoding[i]; + encFree[i] = gFalse; + } + } + } + + // merge differences into encoding + if (obj1.isDict()) { + obj1.dictLookup("Differences", &obj2); + if (obj2.isArray()) { + encodingName->Set("Custom"); + hasEncoding = gTrue; + code = 0; + for (i = 0; i < obj2.arrayGetLength(); ++i) { + obj2.arrayGet(i, &obj3); + if (obj3.isInt()) { + code = obj3.getInt(); + } else if (obj3.isName()) { + if (code >= 0 && code < 256) { + if (encFree[code]) { + gfree(enc[code]); + } + enc[code] = copyString(obj3.getName()); + encFree[code] = gTrue; + } + ++code; + } else { + error(errSyntaxError, -1, + "Wrong type in font encoding resource differences ({0:s})", + obj3.getTypeName()); + } + obj3.free(); + } + } + obj2.free(); + } + obj1.free(); + if (ffT1) { + delete ffT1; + } + if (ffT1C) { + delete ffT1C; + } + + //----- build the mapping to Unicode ----- + + // pass 1: use the name-to-Unicode mapping table + missing = hex = gFalse; + GBool isZapfDingbats = name && name->endsWith("ZapfDingbats"); + for (code = 0; code < 256; ++code) { + if ((charName = enc[code])) { + if (isZapfDingbats) { + // include ZapfDingbats names + toUnicode[code] = globalParams->mapNameToUnicodeAll(charName); + } else { + toUnicode[code] = globalParams->mapNameToUnicodeText(charName); + } + if (!toUnicode[code] && strcmp(charName, ".notdef")) { + // if it wasn't in the name-to-Unicode table, check for a + // name that looks like 'Axx' or 'xx', where 'A' is any letter + // and 'xx' is two hex digits + if ((strlen(charName) == 3 && + isalpha(charName[0]) && + isxdigit(charName[1]) && isxdigit(charName[2]) && + ((charName[1] >= 'a' && charName[1] <= 'f') || + (charName[1] >= 'A' && charName[1] <= 'F') || + (charName[2] >= 'a' && charName[2] <= 'f') || + (charName[2] >= 'A' && charName[2] <= 'F'))) || + (strlen(charName) == 2 && + isxdigit(charName[0]) && isxdigit(charName[1]) && + // Only check idx 1 to avoid misidentifying a decimal + // number like a0 + ((charName[1] >= 'a' && charName[1] <= 'f') || + (charName[1] >= 'A' && charName[1] <= 'F')))) { + hex = gTrue; + } + missing = gTrue; + } + } else { + toUnicode[code] = 0; + } + } + + numeric = testForNumericNames(fontDict, hex); + + // construct the char code -> Unicode mapping object + ctu = CharCodeToUnicode::make8BitToUnicode(toUnicode); + + // pass 1a: Expand ligatures in the Alphabetic Presentation Form + // block (eg "fi", "ffi") to normal form + for (code = 0; code < 256; ++code) { + if (unicodeIsAlphabeticPresentationForm(toUnicode[code])) { + Unicode *normalized = unicodeNormalizeNFKC(&toUnicode[code], 1, &len, NULL); + if (len > 1) + ctu->setMapping((CharCode)code, normalized, len); + gfree(normalized); + } + } + + // pass 2: try to fill in the missing chars, looking for ligatures, numeric + // references and variants + if (missing) { + for (code = 0; code < 256; ++code) { + if (!toUnicode[code]) { + if ((charName = enc[code]) && strcmp(charName, ".notdef") + && (n = parseCharName(charName, uBuf, sizeof(uBuf)/sizeof(*uBuf), + gFalse, // don't check simple names (pass 1) + gTrue, // do check ligatures + numeric, + hex, + gTrue))) { // do check variants + ctu->setMapping((CharCode)code, uBuf, n); + continue; + } + + // if the 'mapUnknownCharNames' flag is set, do a simple pass-through + // mapping for unknown character names + if (globalParams->getMapUnknownCharNames()) { + uBuf[0] = code; + ctu->setMapping((CharCode)code, uBuf, 1); + } + } + } + } + + // merge in a ToUnicode CMap, if there is one -- this overwrites + // existing entries in ctu, i.e., the ToUnicode CMap takes + // precedence, but the other encoding info is allowed to fill in any + // holes + readToUnicodeCMap(fontDict, 16, ctu); + + // look for a Unicode-to-Unicode mapping + if (name && (utu = globalParams->getUnicodeToUnicode(name))) { + Unicode *uAux; + for (i = 0; i < 256; ++i) { + toUnicode[i] = 0; + } + ctu2 = CharCodeToUnicode::make8BitToUnicode(toUnicode); + for (i = 0; i < 256; ++i) { + n = ctu->mapToUnicode((CharCode)i, &uAux); + if (n >= 1) { + n = utu->mapToUnicode((CharCode)uAux[0], &uAux); + if (n >= 1) { + ctu2->setMapping((CharCode)i, uAux, n); + } + } + } + utu->decRefCnt(); + delete ctu; + ctu = ctu2; + } + + //----- get the character widths ----- + + // initialize all widths + for (code = 0; code < 256; ++code) { + widths[code] = missingWidth * 0.001; + } + + // use widths from font dict, if present + fontDict->lookup("FirstChar", &obj1); + firstChar = obj1.isInt() ? obj1.getInt() : 0; + obj1.free(); + if (firstChar < 0 || firstChar > 255) { + firstChar = 0; + } + fontDict->lookup("LastChar", &obj1); + lastChar = obj1.isInt() ? obj1.getInt() : 255; + obj1.free(); + if (lastChar < 0 || lastChar > 255) { + lastChar = 255; + } + mul = (type == fontType3) ? fontMat[0] : 0.001; + fontDict->lookup("Widths", &obj1); + if (obj1.isArray()) { + flags |= fontFixedWidth; + if (obj1.arrayGetLength() < lastChar - firstChar + 1) { + lastChar = firstChar + obj1.arrayGetLength() - 1; + } + for (code = firstChar; code <= lastChar; ++code) { + obj1.arrayGet(code - firstChar, &obj2); + if (obj2.isNum()) { + widths[code] = obj2.getNum() * mul; + if (fabs(widths[code] - widths[firstChar]) > 0.00001) { + flags &= ~fontFixedWidth; + } + } + obj2.free(); + } + + // use widths from built-in font + } else if (builtinFont) { + // this is a kludge for broken PDF files that encode char 32 + // as .notdef + if (builtinFont->widths->getWidth("space", &w)) { + widths[32] = 0.001 * w; + } + for (code = 0; code < 256; ++code) { + if (enc[code] && builtinFont->widths->getWidth(enc[code], &w)) { + widths[code] = 0.001 * w; + } + } + + // couldn't find widths -- use defaults + } else { + // this is technically an error -- the Widths entry is required + // for all but the Base-14 fonts -- but certain PDF generators + // apparently don't include widths for Arial and TimesNewRoman + if (isFixedWidth()) { + i = 0; + } else if (isSerif()) { + i = 8; + } else { + i = 4; + } + if (isBold()) { + i += 2; + } + if (isItalic()) { + i += 1; + } + builtinFont = builtinFontSubst[i]; + // this is a kludge for broken PDF files that encode char 32 + // as .notdef + if (builtinFont->widths->getWidth("space", &w)) { + widths[32] = 0.001 * w; + } + for (code = 0; code < 256; ++code) { + if (enc[code] && builtinFont->widths->getWidth(enc[code], &w)) { + widths[code] = 0.001 * w; + } + } + } + obj1.free(); + + ok = gTrue; +} + +Gfx8BitFont::~Gfx8BitFont() { + int i; + + for (i = 0; i < 256; ++i) { + if (encFree[i] && enc[i]) { + gfree(enc[i]); + } + } + ctu->decRefCnt(); + if (charProcs.isDict()) { + charProcs.free(); + } + if (resources.isDict()) { + resources.free(); + } +} + +// This function is in part a derived work of the Adobe Glyph Mapping +// Convention: http://www.adobe.com/devnet/opentype/archives/glyph.html +// Algorithmic comments are excerpted from that document to aid +// maintainability. +static int parseCharName(char *charName, Unicode *uBuf, int uLen, + GBool names, GBool ligatures, + GBool numeric, GBool hex, GBool variants) +{ + if (uLen <= 0) { + error(errInternal, -1, "Zero-length output buffer (recursion overflow?) in " + "parseCharName, component \"{0:s}\"", charName); + return 0; + } + // Step 1: drop all the characters from the glyph name starting with the + // first occurrence of a period (U+002E FULL STOP), if any. + if (variants) { + char *var_part = strchr(charName, '.'); + if (var_part == charName) { + return 0; // .notdef or similar + } else if (var_part != NULL) { + // parse names of the form 7.oldstyle, P.swash, s.sc, etc. + char *main_part = gstrndup(charName, var_part - charName); + GBool namesRecurse = gTrue, variantsRecurse = gFalse; + int n = parseCharName(main_part, uBuf, uLen, namesRecurse, ligatures, + numeric, hex, variantsRecurse); + gfree(main_part); + return n; + } + } + // Step 2: split the remaining string into a sequence of components, using + // underscore (U+005F LOW LINE) as the delimiter. + if (ligatures && strchr(charName, '_')) { + // parse names of the form A_a (e.g. f_i, T_h, l_quotesingle) + char *lig_part, *lig_end, *lig_copy; + int n = 0, m; + lig_part = lig_copy = copyString(charName); + do { + if ((lig_end = strchr(lig_part, '_'))) + *lig_end = '\0'; + if (lig_part[0] != '\0') { + GBool namesRecurse = gTrue, ligaturesRecurse = gFalse; + if ((m = parseCharName(lig_part, uBuf + n, uLen - n, namesRecurse, + ligaturesRecurse, numeric, hex, variants))) + n += m; + else + error(errSyntaxWarning, -1, "Could not parse ligature component \"{0:s}\" of \"{1:s}\" in " + "parseCharName", lig_part, charName); + } + lig_part = lig_end + 1; + } while (lig_end && n < uLen); + gfree(lig_copy); + return n; + } + // Step 3: map each component to a character string according to the + // procedure below, and concatenate those strings; the result is the + // character string to which the glyph name is mapped. + // 3.1. if the font is Zapf Dingbats (PostScript FontName ZapfDingbats), and + // the component is in the ZapfDingbats list, then map it to the + // corresponding character in that list. + // 3.2. otherwise, if the component is in the Adobe Glyph List, then map it + // to the corresponding character in that list. + if (names && (uBuf[0] = globalParams->mapNameToUnicodeText(charName))) { + return 1; + } + if (globalParams->getMapNumericCharNames()) { + unsigned int n = strlen(charName); + // 3.3. otherwise, if the component is of the form "uni" (U+0075 U+006E + // U+0069) followed by a sequence of uppercase hexadecimal digits (0 .. 9, + // A .. F, i.e. U+0030 .. U+0039, U+0041 .. U+0046), the length of that + // sequence is a multiple of four, and each group of four digits represents + // a number in the set {0x0000 .. 0xD7FF, 0xE000 .. 0xFFFF}, then interpret + // each such number as a Unicode scalar value and map the component to the + // string made of those scalar values. Note that the range and digit length + // restrictions mean that the "uni" prefix can be used only with Unicode + // values from the Basic Multilingual Plane (BMP). + if (n >= 7 && (n % 4) == 3 && !strncmp(charName, "uni", 3)) { + int i; + unsigned int m; + for (i = 0, m = 3; i < uLen && m < n; m += 4) { + if (isxdigit(charName[m]) && isxdigit(charName[m + 1]) && + isxdigit(charName[m + 2]) && isxdigit(charName[m + 3])) { + unsigned int u; + sscanf(charName + m, "%4x", &u); + if (u <= 0xD7FF || (0xE000 <= u && u <= 0xFFFF)) { + uBuf[i++] = u; + } + } + } + return i; + } + // 3.4. otherwise, if the component is of the form "u" (U+0075) followed by + // a sequence of four to six uppercase hexadecimal digits {0 .. 9, A .. F} + // (U+0030 .. U+0039, U+0041 .. U+0046), and those digits represent a + // number in {0x0000 .. 0xD7FF, 0xE000 .. 0x10FFFF}, then interpret this + // number as a Unicode scalar value and map the component to the string + // made of this scalar value. + if (n >= 5 && n <= 7 && charName[0] == 'u' && isxdigit(charName[1]) && + isxdigit(charName[2]) && isxdigit(charName[3]) && isxdigit(charName[4]) + && (n <= 5 || isxdigit(charName[5])) + && (n <= 6 || isxdigit(charName[6]))) { + unsigned int u; + sscanf(charName + 1, "%x", &u); + if (u <= 0xD7FF || (0xE000 <= u && u <= 0x10FFFF)) { + uBuf[0] = u; + return 1; + } + } + // Not in Adobe Glyph Mapping convention: look for names like xx + // or Axx and parse for hex or decimal values. + if (numeric && parseNumericName(charName, hex, uBuf)) + return 1; + } + // 3.5. otherwise, map the component to the empty string + return 0; +} + +int Gfx8BitFont::getNextChar(char *s, int len, CharCode *code, + Unicode **u, int *uLen, + double *dx, double *dy, double *ox, double *oy) { + CharCode c; + + *code = c = (CharCode)(*s & 0xff); + *uLen = ctu->mapToUnicode(c, u); + *dx = widths[c]; + *dy = *ox = *oy = 0; + return 1; +} + +CharCodeToUnicode *Gfx8BitFont::getToUnicode() { + ctu->incRefCnt(); + return ctu; +} + +int *Gfx8BitFont::getCodeToGIDMap(FoFiTrueType *ff) { + int *map; + int cmapPlatform, cmapEncoding; + int unicodeCmap, macRomanCmap, msSymbolCmap, cmap; + GBool useMacRoman, useUnicode; + char *charName; + Unicode u; + int code, i, n; + + map = (int *)gmallocn(256, sizeof(int)); + for (i = 0; i < 256; ++i) { + map[i] = 0; + } + + // To match up with the Adobe-defined behaviour, we choose a cmap + // like this: + // 1. If the PDF font has an encoding: + // 1a. If the PDF font specified MacRomanEncoding and the + // TrueType font has a Macintosh Roman cmap, use it, and + // reverse map the char names through MacRomanEncoding to + // get char codes. + // 1b. If the PDF font is not symbolic or the PDF font is not + // embedded, and the TrueType font has a Microsoft Unicode + // cmap or a non-Microsoft Unicode cmap, use it, and use the + // Unicode indexes, not the char codes. + // 1c. If the PDF font is symbolic and the TrueType font has a + // Microsoft Symbol cmap, use it, and use char codes + // directly (possibly with an offset of 0xf000). + // 1d. If the TrueType font has a Macintosh Roman cmap, use it, + // as in case 1a. + // 2. If the PDF font does not have an encoding or the PDF font is + // symbolic: + // 2a. If the TrueType font has a Macintosh Roman cmap, use it, + // and use char codes directly (possibly with an offset of + // 0xf000). + // 2b. If the TrueType font has a Microsoft Symbol cmap, use it, + // and use char codes directly (possible with an offset of + // 0xf000). + // 3. If none of these rules apply, use the first cmap and hope for + // the best (this shouldn't happen). + unicodeCmap = macRomanCmap = msSymbolCmap = -1; + for (i = 0; i < ff->getNumCmaps(); ++i) { + cmapPlatform = ff->getCmapPlatform(i); + cmapEncoding = ff->getCmapEncoding(i); + if ((cmapPlatform == 3 && cmapEncoding == 1) || + cmapPlatform == 0) { + unicodeCmap = i; + } else if (cmapPlatform == 1 && cmapEncoding == 0) { + macRomanCmap = i; + } else if (cmapPlatform == 3 && cmapEncoding == 0) { + msSymbolCmap = i; + } + } + cmap = 0; + useMacRoman = gFalse; + useUnicode = gFalse; + if (hasEncoding || type == fontType1) { + if (usesMacRomanEnc && macRomanCmap >= 0) { + cmap = macRomanCmap; + useMacRoman = gTrue; + } else if ((!(flags & fontSymbolic) || embFontID.num < 0) && + unicodeCmap >= 0) { + cmap = unicodeCmap; + useUnicode = gTrue; + } else if ((flags & fontSymbolic) && msSymbolCmap >= 0) { + cmap = msSymbolCmap; + } else if ((flags & fontSymbolic) && macRomanCmap >= 0) { + cmap = macRomanCmap; + } else if (macRomanCmap >= 0) { + cmap = macRomanCmap; + useMacRoman = gTrue; + } + } else { + if (msSymbolCmap >= 0) { + cmap = msSymbolCmap; + } else if (macRomanCmap >= 0) { + cmap = macRomanCmap; + } + } + + // reverse map the char names through MacRomanEncoding, then map the + // char codes through the cmap + if (useMacRoman) { + for (i = 0; i < 256; ++i) { + if ((charName = enc[i])) { + if ((code = globalParams->getMacRomanCharCode(charName))) { + map[i] = ff->mapCodeToGID(cmap, code); + } + } else { + map[i] = -1; + } + } + + // map Unicode through the cmap + } else if (useUnicode) { + Unicode *uAux; + for (i = 0; i < 256; ++i) { + if (((charName = enc[i]) && (u = globalParams->mapNameToUnicodeAll(charName)))) + map[i] = ff->mapCodeToGID(cmap, u); + else + { + n = ctu->mapToUnicode((CharCode)i, &uAux); + if (n > 0) map[i] = ff->mapCodeToGID(cmap, uAux[0]); + else map[i] = -1; + } + } + + // map the char codes through the cmap, possibly with an offset of + // 0xf000 + } else { + for (i = 0; i < 256; ++i) { + if (!(map[i] = ff->mapCodeToGID(cmap, i))) { + map[i] = ff->mapCodeToGID(cmap, 0xf000 + i); + } + } + } + + // try the TrueType 'post' table to handle any unmapped characters + for (i = 0; i < 256; ++i) { + if (map[i] <= 0 && (charName = enc[i])) { + map[i] = ff->mapNameToGID(charName); + } + } + + return map; +} + +Dict *Gfx8BitFont::getCharProcs() { + return charProcs.isDict() ? charProcs.getDict() : (Dict *)NULL; +} + +Object *Gfx8BitFont::getCharProc(int code, Object *proc) { + if (enc[code] && charProcs.isDict()) { + charProcs.dictLookup(enc[code], proc); + } else { + proc->initNull(); + } + return proc; +} + +Dict *Gfx8BitFont::getResources() { + return resources.isDict() ? resources.getDict() : (Dict *)NULL; +} + +//------------------------------------------------------------------------ +// GfxCIDFont +//------------------------------------------------------------------------ + +struct cmpWidthExcepFunctor { + bool operator()(const GfxFontCIDWidthExcep &w1, + const GfxFontCIDWidthExcep &w2) { + return w1.first < w2.first; + } +}; + +struct cmpWidthExcepVFunctor { + bool operator()(const GfxFontCIDWidthExcepV &w1, + const GfxFontCIDWidthExcepV &w2) { + return w1.first < w2.first; + } +}; + +GfxCIDFont::GfxCIDFont(XRef *xref, const char *tagA, Ref idA, GooString *nameA, + GfxFontType typeA, Ref embFontIDA, Dict *fontDict): + GfxFont(tagA, idA, nameA, typeA, embFontIDA) +{ + Dict *desFontDict; + Object desFontDictObj; + Object obj1, obj2, obj3, obj4, obj5, obj6; + CharCodeToUnicode *utu; + CharCode c; + Unicode *uBuf; + int c1, c2; + int excepsSize, i, j, k, n; + + refCnt = 1; + ascent = 0.95; + descent = -0.35; + fontBBox[0] = fontBBox[1] = fontBBox[2] = fontBBox[3] = 0; + collection = NULL; + cMap = NULL; + ctu = NULL; + ctuUsesCharCode = gTrue; + widths.defWidth = 1.0; + widths.defHeight = -1.0; + widths.defVY = 0.880; + widths.exceps = NULL; + widths.nExceps = 0; + widths.excepsV = NULL; + widths.nExcepsV = 0; + cidToGID = NULL; + cidToGIDLen = 0; + + // get the descendant font + if (!fontDict->lookup("DescendantFonts", &obj1)->isArray() || + obj1.arrayGetLength() == 0) { + error(errSyntaxError, -1, "Missing or empty DescendantFonts entry in Type 0 font"); + obj1.free(); + goto err1; + } + if (!obj1.arrayGet(0, &desFontDictObj)->isDict()) { + error(errSyntaxError, -1, "Bad descendant font in Type 0 font"); + goto err3; + } + obj1.free(); + desFontDict = desFontDictObj.getDict(); + + // get info from font descriptor + readFontDescriptor(xref, desFontDict); + + //----- encoding info ----- + + // char collection + if (!desFontDict->lookup("CIDSystemInfo", &obj1)->isDict()) { + error(errSyntaxError, -1, "Missing CIDSystemInfo dictionary in Type 0 descendant font"); + goto err3; + } + obj1.dictLookup("Registry", &obj2); + obj1.dictLookup("Ordering", &obj3); + if (!obj2.isString() || !obj3.isString()) { + error(errSyntaxError, -1, "Invalid CIDSystemInfo dictionary in Type 0 descendant font"); + goto err3; + } + collection = obj2.getString()->copy()->append('-')->append(obj3.getString()); + obj3.free(); + obj2.free(); + obj1.free(); + + // look for a ToUnicode CMap + if (!(ctu = readToUnicodeCMap(fontDict, 16, NULL))) { + ctuUsesCharCode = gFalse; + + // use an identity mapping for the "Adobe-Identity" and + // "Adobe-UCS" collections + if (!collection->cmp("Adobe-Identity") || + !collection->cmp("Adobe-UCS")) { + ctu = CharCodeToUnicode::makeIdentityMapping(); + } else { + // look for a user-supplied .cidToUnicode file + if (!(ctu = globalParams->getCIDToUnicode(collection))) { + // I'm not completely sure that this is the best thing to do + // but it seems to produce better results when the .cidToUnicode + // files from the poppler-data package are missing. At least + // we know that assuming the Identity mapping is definitely wrong. + // -- jrmuizel + static const char * knownCollections [] = { + "Adobe-CNS1", + "Adobe-GB1", + "Adobe-Japan1", + "Adobe-Japan2", + "Adobe-Korea1", + }; + for (size_t i = 0; i < sizeof(knownCollections)/sizeof(knownCollections[0]); i++) { + if (collection->cmp(knownCollections[i]) == 0) { + error(errSyntaxError, -1, "Missing language pack for '{0:t}' mapping", collection); + goto err2; + } + } + error(errSyntaxError, -1, "Unknown character collection '{0:t}'", + collection); + // fall-through, assuming the Identity mapping -- this appears + // to match Adobe's behavior + } + } + } + + // look for a Unicode-to-Unicode mapping + if (name && (utu = globalParams->getUnicodeToUnicode(name))) { + if (ctu) { + for (c = 0; c < ctu->getLength(); ++c) { + n = ctu->mapToUnicode(c, &uBuf); + if (n >= 1) { + n = utu->mapToUnicode((CharCode)uBuf[0], &uBuf); + if (n >= 1) { + ctu->setMapping(c, uBuf, n); + } + } + } + utu->decRefCnt(); + } else { + ctu = utu; + } + } + + // encoding (i.e., CMap) + if (fontDict->lookup("Encoding", &obj1)->isNull()) { + error(errSyntaxError, -1, "Missing Encoding entry in Type 0 font"); + goto err2; + } + if (!(cMap = CMap::parse(NULL, collection, &obj1))) { + goto err2; + } + obj1.free(); + if (cMap->getCMapName()) { + encodingName->Set(cMap->getCMapName()->getCString()); + } else { + encodingName->Set("Custom"); + } + + // CIDToGIDMap (for embedded TrueType fonts) + if (type == fontCIDType2 || type == fontCIDType2OT) { + desFontDict->lookup("CIDToGIDMap", &obj1); + if (obj1.isStream()) { + cidToGIDLen = 0; + i = 64; + cidToGID = (int *)gmallocn(i, sizeof(int)); + obj1.streamReset(); + while ((c1 = obj1.streamGetChar()) != EOF && + (c2 = obj1.streamGetChar()) != EOF) { + if (cidToGIDLen == i) { + i *= 2; + cidToGID = (int *)greallocn(cidToGID, i, sizeof(int)); + } + cidToGID[cidToGIDLen++] = (c1 << 8) + c2; + } + } else if (!obj1.isName("Identity") && !obj1.isNull()) { + error(errSyntaxError, -1, "Invalid CIDToGIDMap entry in CID font"); + } + obj1.free(); + } + + //----- character metrics ----- + + // default char width + if (desFontDict->lookup("DW", &obj1)->isInt()) { + widths.defWidth = obj1.getInt() * 0.001; + } + obj1.free(); + + // char width exceptions + if (desFontDict->lookup("W", &obj1)->isArray()) { + excepsSize = 0; + i = 0; + while (i + 1 < obj1.arrayGetLength()) { + obj1.arrayGet(i, &obj2); + obj1.arrayGet(i + 1, &obj3); + if (obj2.isInt() && obj3.isInt() && i + 2 < obj1.arrayGetLength()) { + if (obj1.arrayGet(i + 2, &obj4)->isNum()) { + if (widths.nExceps == excepsSize) { + excepsSize += 16; + widths.exceps = (GfxFontCIDWidthExcep *) + greallocn(widths.exceps, + excepsSize, sizeof(GfxFontCIDWidthExcep)); + } + widths.exceps[widths.nExceps].first = obj2.getInt(); + widths.exceps[widths.nExceps].last = obj3.getInt(); + widths.exceps[widths.nExceps].width = obj4.getNum() * 0.001; + ++widths.nExceps; + } else { + error(errSyntaxError, -1, "Bad widths array in Type 0 font"); + } + obj4.free(); + i += 3; + } else if (obj2.isInt() && obj3.isArray()) { + if (widths.nExceps + obj3.arrayGetLength() > excepsSize) { + excepsSize = (widths.nExceps + obj3.arrayGetLength() + 15) & ~15; + widths.exceps = (GfxFontCIDWidthExcep *) + greallocn(widths.exceps, + excepsSize, sizeof(GfxFontCIDWidthExcep)); + } + j = obj2.getInt(); + for (k = 0; k < obj3.arrayGetLength(); ++k) { + if (obj3.arrayGet(k, &obj4)->isNum()) { + widths.exceps[widths.nExceps].first = j; + widths.exceps[widths.nExceps].last = j; + widths.exceps[widths.nExceps].width = obj4.getNum() * 0.001; + ++j; + ++widths.nExceps; + } else { + error(errSyntaxError, -1, "Bad widths array in Type 0 font"); + } + obj4.free(); + } + i += 2; + } else { + error(errSyntaxError, -1, "Bad widths array in Type 0 font"); + ++i; + } + obj3.free(); + obj2.free(); + } + std::sort(widths.exceps, widths.exceps + widths.nExceps, + cmpWidthExcepFunctor()); + } + obj1.free(); + + // default metrics for vertical font + if (desFontDict->lookup("DW2", &obj1)->isArray() && + obj1.arrayGetLength() == 2) { + if (obj1.arrayGet(0, &obj2)->isNum()) { + widths.defVY = obj2.getNum() * 0.001; + } + obj2.free(); + if (obj1.arrayGet(1, &obj2)->isNum()) { + widths.defHeight = obj2.getNum() * 0.001; + } + obj2.free(); + } + obj1.free(); + + // char metric exceptions for vertical font + if (desFontDict->lookup("W2", &obj1)->isArray()) { + excepsSize = 0; + i = 0; + while (i + 1 < obj1.arrayGetLength()) { + obj1.arrayGet(i, &obj2); + obj1.arrayGet(i+ 1, &obj3); + if (obj2.isInt() && obj3.isInt() && i + 4 < obj1.arrayGetLength()) { + if (obj1.arrayGet(i + 2, &obj4)->isNum() && + obj1.arrayGet(i + 3, &obj5)->isNum() && + obj1.arrayGet(i + 4, &obj6)->isNum()) { + if (widths.nExcepsV == excepsSize) { + excepsSize += 16; + widths.excepsV = (GfxFontCIDWidthExcepV *) + greallocn(widths.excepsV, + excepsSize, sizeof(GfxFontCIDWidthExcepV)); + } + widths.excepsV[widths.nExcepsV].first = obj2.getInt(); + widths.excepsV[widths.nExcepsV].last = obj3.getInt(); + widths.excepsV[widths.nExcepsV].height = obj4.getNum() * 0.001; + widths.excepsV[widths.nExcepsV].vx = obj5.getNum() * 0.001; + widths.excepsV[widths.nExcepsV].vy = obj6.getNum() * 0.001; + ++widths.nExcepsV; + } else { + error(errSyntaxError, -1, "Bad widths (W2) array in Type 0 font"); + } + obj6.free(); + obj5.free(); + obj4.free(); + i += 5; + } else if (obj2.isInt() && obj3.isArray()) { + if (widths.nExcepsV + obj3.arrayGetLength() / 3 > excepsSize) { + excepsSize = + (widths.nExcepsV + obj3.arrayGetLength() / 3 + 15) & ~15; + widths.excepsV = (GfxFontCIDWidthExcepV *) + greallocn(widths.excepsV, + excepsSize, sizeof(GfxFontCIDWidthExcepV)); + } + j = obj2.getInt(); + for (k = 0; k < obj3.arrayGetLength(); k += 3) { + if (obj3.arrayGet(k, &obj4)->isNum() && + obj3.arrayGet(k+1, &obj5)->isNum() && + obj3.arrayGet(k+2, &obj6)->isNum()) { + widths.excepsV[widths.nExcepsV].first = j; + widths.excepsV[widths.nExcepsV].last = j; + widths.excepsV[widths.nExcepsV].height = obj4.getNum() * 0.001; + widths.excepsV[widths.nExcepsV].vx = obj5.getNum() * 0.001; + widths.excepsV[widths.nExcepsV].vy = obj6.getNum() * 0.001; + ++j; + ++widths.nExcepsV; + } else { + error(errSyntaxError, -1, "Bad widths (W2) array in Type 0 font"); + } + obj6.free(); + obj5.free(); + obj4.free(); + } + i += 2; + } else { + error(errSyntaxError, -1, "Bad widths (W2) array in Type 0 font"); + ++i; + } + obj3.free(); + obj2.free(); + } + std::sort(widths.excepsV, widths.excepsV + widths.nExcepsV, + cmpWidthExcepVFunctor()); + } + obj1.free(); + + desFontDictObj.free(); + ok = gTrue; + return; + + err3: + obj3.free(); + obj2.free(); + err2: + obj1.free(); + desFontDictObj.free(); + err1:; +} + +GfxCIDFont::~GfxCIDFont() { + if (collection) { + delete collection; + } + if (cMap) { + cMap->decRefCnt(); + } + if (ctu) { + ctu->decRefCnt(); + } + gfree(widths.exceps); + gfree(widths.excepsV); + if (cidToGID) { + gfree(cidToGID); + } +} + +int GfxCIDFont::getNextChar(char *s, int len, CharCode *code, + Unicode **u, int *uLen, + double *dx, double *dy, double *ox, double *oy) { + CID cid; + CharCode c; + double w, h, vx, vy; + int n, a, b, m; + + if (!cMap) { + *code = 0; + *uLen = 0; + *dx = *dy = 0; + return 1; + } + + *code = (CharCode)(cid = cMap->getCID(s, len, &c, &n)); + if (ctu) { + if (hasToUnicode) { + int i = 0, c = 0; + while (i < n) { + c = (c << 8 ) + (s[i] & 0xff); + ++i; + } + *uLen = ctu->mapToUnicode(c, u); + } else { + *uLen = ctu->mapToUnicode(cid, u); + } + } else { + *uLen = 0; + } + + // horizontal + if (cMap->getWMode() == 0) { + w = getWidth(cid); + h = vx = vy = 0; + + // vertical + } else { + w = 0; + h = widths.defHeight; + vx = getWidth(cid) / 2; + vy = widths.defVY; + if (widths.nExcepsV > 0 && cid >= widths.excepsV[0].first) { + a = 0; + b = widths.nExcepsV; + // invariant: widths.excepsV[a].first <= cid < widths.excepsV[b].first + while (b - a > 1) { + m = (a + b) / 2; + if (widths.excepsV[m].last <= cid) { + a = m; + } else { + b = m; + } + } + if (cid <= widths.excepsV[a].last) { + h = widths.excepsV[a].height; + vx = widths.excepsV[a].vx; + vy = widths.excepsV[a].vy; + } + } + } + + *dx = w; + *dy = h; + *ox = vx; + *oy = vy; + + return n; +} + +int GfxCIDFont::getWMode() { + return cMap ? cMap->getWMode() : 0; +} + +CharCodeToUnicode *GfxCIDFont::getToUnicode() { + if (ctu) { + ctu->incRefCnt(); + } + return ctu; +} + +GooString *GfxCIDFont::getCollection() { + return cMap ? cMap->getCollection() : (GooString *)NULL; +} + +int GfxCIDFont::mapCodeToGID(FoFiTrueType *ff, int cmapi, + Unicode unicode, GBool wmode) { + Gushort gid = ff->mapCodeToGID(cmapi,unicode); + if (wmode) { + Gushort vgid = ff->mapToVertGID(gid); + if (vgid != 0) gid = vgid; + } + return gid; +} + +int *GfxCIDFont::getCodeToGIDMap(FoFiTrueType *ff, int *mapsizep) { +#define N_UCS_CANDIDATES 2 + /* space characters */ + static const unsigned long spaces[] = { + 0x2000,0x2001,0x2002,0x2003,0x2004,0x2005,0x2006,0x2007, + 0x2008,0x2009,0x200A,0x00A0,0x200B,0x2060,0x3000,0xFEFF, + 0 + }; + static const char *adobe_cns1_cmaps[] = { + "UniCNS-UTF32-V", + "UniCNS-UCS2-V", + "UniCNS-UTF32-H", + "UniCNS-UCS2-H", + 0 + }; + static const char *adobe_gb1_cmaps[] = { + "UniGB-UTF32-V", + "UniGB-UCS2-V", + "UniGB-UTF32-H", + "UniGB-UCS2-H", + 0 + }; + static const char *adobe_japan1_cmaps[] = { + "UniJIS-UTF32-V", + "UniJIS-UCS2-V", + "UniJIS-UTF32-H", + "UniJIS-UCS2-H", + 0 + }; + static const char *adobe_japan2_cmaps[] = { + "UniHojo-UTF32-V", + "UniHojo-UCS2-V", + "UniHojo-UTF32-H", + "UniHojo-UCS2-H", + 0 + }; + static const char *adobe_korea1_cmaps[] = { + "UniKS-UTF32-V", + "UniKS-UCS2-V", + "UniKS-UTF32-H", + "UniKS-UCS2-H", + 0 + }; + static struct CMapListEntry { + const char *collection; + const char *scriptTag; + const char *languageTag; + const char *toUnicodeMap; + const char **CMaps; + } CMapList[] = { + { + "Adobe-CNS1", + "hani", "CHN ", + "Adobe-CNS1-UCS2", + adobe_cns1_cmaps, + }, + { + "Adobe-GB1", + "hani", "CHN ", + "Adobe-GB1-UCS2", + adobe_gb1_cmaps, + }, + { + "Adobe-Japan1", + "kana", "JAN ", + "Adobe-Japan1-UCS2", + adobe_japan1_cmaps, + }, + { + "Adobe-Japan2", + "kana", "JAN ", + "Adobe-Japan2-UCS2", + adobe_japan2_cmaps, + }, + { + "Adobe-Korea1", + "hang", "KOR ", + "Adobe-Korea1-UCS2", + adobe_korea1_cmaps, + }, + {0, 0, 0, 0} + }; + Unicode *humap = 0; + Unicode *vumap = 0; + Unicode *tumap = 0; + int *codeToGID = 0; + unsigned long n; + int i; + unsigned long code; + int wmode; + const char **cmapName; + CMap *cMap; + CMapListEntry *lp; + int cmap; + int cmapPlatform, cmapEncoding; + Ref embID; + + *mapsizep = 0; + if (!ctu) return NULL; + if (getCollection()->cmp("Adobe-Identity") == 0) return NULL; + if (getEmbeddedFontID(&embID)) { + /* if this font is embedded font, + * CIDToGIDMap should be embedded in PDF file + * and already set. So return it. + */ + *mapsizep = getCIDToGIDLen(); + return getCIDToGID(); + } + + /* we use only unicode cmap */ + cmap = -1; + for (i = 0; i < ff->getNumCmaps(); ++i) { + cmapPlatform = ff->getCmapPlatform(i); + cmapEncoding = ff->getCmapEncoding(i); + if (cmapPlatform == 3 && cmapEncoding == 10) { + /* UCS-4 */ + cmap = i; + /* use UCS-4 cmap */ + break; + } else if (cmapPlatform == 3 && cmapEncoding == 1) { + /* Unicode */ + cmap = i; + } else if (cmapPlatform == 0 && cmap < 0) { + cmap = i; + } + } + if (cmap < 0) + return NULL; + + wmode = getWMode(); + for (lp = CMapList;lp->collection != 0;lp++) { + if (strcmp(lp->collection,getCollection()->getCString()) == 0) { + break; + } + } + n = 65536; + tumap = new Unicode[n]; + humap = new Unicode[n*N_UCS_CANDIDATES]; + memset(humap,0,sizeof(Unicode)*n*N_UCS_CANDIDATES); + if (lp->collection != 0) { + CharCodeToUnicode *tctu; + GooString tname(lp->toUnicodeMap); + + if ((tctu = CharCodeToUnicode::parseCMapFromFile(&tname,16)) != 0) { + CharCode cid; + for (cid = 0;cid < n ;cid++) { + int len; + Unicode *ucodes; + + len = tctu->mapToUnicode(cid,&ucodes); + if (len == 1) { + tumap[cid] = ucodes[0]; + } else { + /* if not single character, ignore it */ + tumap[cid] = 0; + } + } + delete tctu; + } + vumap = new Unicode[n]; + memset(vumap,0,sizeof(Unicode)*n); + for (cmapName = lp->CMaps;*cmapName != 0;cmapName++) { + GooString cname(*cmapName); + + if ((cMap = globalParams->getCMap(getCollection(),&cname)) + != 0) { + if (cMap->getWMode()) { + cMap->setReverseMap(vumap,n,1); + } else { + cMap->setReverseMap(humap,n,N_UCS_CANDIDATES); + } + cMap->decRefCnt(); + } + } + ff->setupGSUB(lp->scriptTag, lp->languageTag); + } else { + error(errSyntaxError, -1, "Unknown character collection {0:t}\n", + getCollection()); + if ((ctu = getToUnicode()) != 0) { + CharCode cid; + for (cid = 0;cid < n ;cid++) { + Unicode *ucode; + + if (ctu->mapToUnicode(cid, &ucode)) + humap[cid*N_UCS_CANDIDATES] = ucode[0]; + else + humap[cid*N_UCS_CANDIDATES] = 0; + for (i = 1;i < N_UCS_CANDIDATES;i++) { + humap[cid*N_UCS_CANDIDATES+i] = 0; + } + } + ctu->decRefCnt(); + } + } + // map CID -> Unicode -> GID + codeToGID = (int *)gmallocn(n, sizeof(int)); + for (code = 0; code < n; ++code) { + Unicode unicode; + unsigned long gid; + + unicode = 0; + gid = 0; + if (humap != 0) { + for (i = 0;i < N_UCS_CANDIDATES + && gid == 0 && (unicode = humap[code*N_UCS_CANDIDATES+i]) != 0;i++) { + gid = mapCodeToGID(ff,cmap,unicode,gFalse); + } + } + if (gid == 0 && vumap != 0) { + unicode = vumap[code]; + if (unicode != 0) { + gid = mapCodeToGID(ff,cmap,unicode,gTrue); + if (gid == 0 && tumap != 0) { + if ((unicode = tumap[code]) != 0) { + gid = mapCodeToGID(ff,cmap,unicode,gTrue); + } + } + } + } + if (gid == 0 && tumap != 0) { + if ((unicode = tumap[code]) != 0) { + gid = mapCodeToGID(ff,cmap,unicode,gFalse); + } + } + if (gid == 0) { + /* special handling space characters */ + const unsigned long *p; + + if (humap != 0) unicode = humap[code]; + if (unicode != 0) { + /* check if code is space character , so map code to 0x0020 */ + for (p = spaces;*p != 0;p++) { + if (*p == unicode) { + unicode = 0x20; + gid = mapCodeToGID(ff,cmap,unicode,wmode); + break; + } + } + } + } + codeToGID[code] = gid; + } + *mapsizep = n; + if (humap != 0) delete[] humap; + if (tumap != 0) delete[] tumap; + if (vumap != 0) delete[] vumap; + return codeToGID; +} + +double GfxCIDFont::getWidth(CID cid) { + double w; + int a, b, m; + + w = widths.defWidth; + if (widths.nExceps > 0 && cid >= widths.exceps[0].first) { + a = 0; + b = widths.nExceps; + // invariant: widths.exceps[a].first <= cid < widths.exceps[b].first + while (b - a > 1) { + m = (a + b) / 2; + if (widths.exceps[m].first <= cid) { + a = m; + } else { + b = m; + } + } + if (cid <= widths.exceps[a].last) { + w = widths.exceps[a].width; + } + } + return w; +} + +double GfxCIDFont::getWidth (char* s, int len) { + int nUsed; + CharCode c; + + CID cid = cMap->getCID(s, len, &c, &nUsed); + return getWidth(cid); +} + +//------------------------------------------------------------------------ +// GfxFontDict +//------------------------------------------------------------------------ + +GfxFontDict::GfxFontDict(XRef *xref, Ref *fontDictRef, Dict *fontDict) { + int i; + Object obj1, obj2; + Ref r; + + numFonts = fontDict->getLength(); + fonts = (GfxFont **)gmallocn(numFonts, sizeof(GfxFont *)); + for (i = 0; i < numFonts; ++i) { + fontDict->getValNF(i, &obj1); + obj1.fetch(xref, &obj2); + if (obj2.isDict()) { + if (obj1.isRef()) { + r = obj1.getRef(); + } else { + // no indirect reference for this font, so invent a unique one + // (legal generation numbers are five digits, so any 6-digit + // number would be safe) + r.num = i; + if (fontDictRef) { + r.gen = 100000 + fontDictRef->num; + } else { + r.gen = 999999; + } + } + fonts[i] = GfxFont::makeFont(xref, fontDict->getKey(i), + r, obj2.getDict()); + if (fonts[i] && !fonts[i]->isOk()) { + // XXX: it may be meaningful to distinguish between + // NULL and !isOk() so that when we do lookups + // we can tell the difference between a missing font + // and a font that is just !isOk() + fonts[i]->decRefCnt(); + fonts[i] = NULL; + } + } else { + error(errSyntaxError, -1, "font resource is not a dictionary"); + fonts[i] = NULL; + } + obj1.free(); + obj2.free(); + } +} + +GfxFontDict::~GfxFontDict() { + int i; + + for (i = 0; i < numFonts; ++i) { + if (fonts[i]) { + fonts[i]->decRefCnt(); + } + } + gfree(fonts); +} + +GfxFont *GfxFontDict::lookup(char *tag) { + int i; + + for (i = 0; i < numFonts; ++i) { + if (fonts[i] && fonts[i]->matches(tag)) { + return fonts[i]; + } + } + return NULL; +} |