/src/xpdf-4.06/splash/SplashFTFontEngine.cc

Source
//========================================================================
//
// SplashFTFontEngine.cc
//
// Copyright 2003-2013 Glyph & Cog, LLC
//
//========================================================================

#include <aconf.h>

#if HAVE_FREETYPE_H

#include <stdio.h>
#ifndef _WIN32
#  include <unistd.h>
#endif
#include "gmem.h"
#include "gmempp.h"
#include "GString.h"
#include "gfile.h"
#include "FoFiTrueType.h"
#include "FoFiType1C.h"
#include "SplashFTFontFile.h"
#include "SplashFTFontEngine.h"
#include FT_MODULE_H
#ifdef FT_CFF_DRIVER_H
#  include FT_CFF_DRIVER_H
#endif

#ifdef VMS
#if (__VMS_VER < 70000000)
extern "C" int unlink(char *filename);
#endif
#endif

//------------------------------------------------------------------------

static void fileWrite(void *stream, const char *data, int len) {
  fwrite(data, 1, len, (FILE *)stream);
}

#if LOAD_FONTS_FROM_MEM
static void gstringWrite(void *stream, const char *data, int len) {
  ((GString *)stream)->append(data, len);
}
#endif

//------------------------------------------------------------------------
// SplashFTFontEngine
//------------------------------------------------------------------------

SplashFTFontEngine::SplashFTFontEngine(GBool aaA, Guint flagsA,
               FT_Library libA) {
  FT_Int major, minor, patch;

  aa = aaA;
  flags = flagsA;
  lib = libA;

  // as of FT 2.1.8, CID fonts are indexed by CID instead of GID
  FT_Library_Version(lib, &major, &minor, &patch);
  useCIDs = major > 2 ||
            (major == 2 && (minor > 1 || (minor == 1 && patch > 7)));
}

SplashFTFontEngine *SplashFTFontEngine::init(GBool aaA, Guint flagsA) {
  FT_Library libA;

  if (FT_Init_FreeType(&libA)) {
    return NULL;
  }
  return new SplashFTFontEngine(aaA, flagsA, libA);
}

SplashFTFontEngine::~SplashFTFontEngine() {
  FT_Done_FreeType(lib);
}

SplashFontFile *SplashFTFontEngine::loadType1Font(SplashFontFileID *idA,
#if LOAD_FONTS_FROM_MEM
              GString *fontBuf,
#else
              char *fileName,
              GBool deleteFile,
#endif
              const char **enc) {
  return SplashFTFontFile::loadType1Font(this, idA, splashFontType1,
#if LOAD_FONTS_FROM_MEM
           fontBuf,
#else
           fileName, deleteFile,
#endif
           enc);
}

SplashFontFile *SplashFTFontEngine::loadType1CFont(SplashFontFileID *idA,
#if LOAD_FONTS_FROM_MEM
               GString *fontBuf,
#else
               char *fileName,
               GBool deleteFile,
#endif
               const char **enc) {
  return SplashFTFontFile::loadType1Font(this, idA, splashFontType1C,
#if LOAD_FONTS_FROM_MEM
           fontBuf,
#else
           fileName, deleteFile,
#endif
           enc);
}

SplashFontFile *SplashFTFontEngine::loadOpenTypeT1CFont(SplashFontFileID *idA,
#if LOAD_FONTS_FROM_MEM
              GString *fontBuf,
#else
              char *fileName,
              GBool deleteFile,
#endif
              const char **enc) {
  FoFiTrueType *ff;
#if LOAD_FONTS_FROM_MEM
  GString *fontBuf2;
#else
  GString *tmpFileName;
  FILE *tmpFile;
#endif
  SplashFontFile *ret;

#if LOAD_FONTS_FROM_MEM
  if (!(ff = FoFiTrueType::make(fontBuf->getCString(), fontBuf->getLength(),
        0, gTrue))) {
#else
  if (!(ff = FoFiTrueType::load(fileName, 0, gTrue))) {
#endif
    return NULL;
  }
  if (ff->isHeadlessCFF()) {
#if LOAD_FONTS_FROM_MEM
    fontBuf2 = new GString();
    ff->convertToType1(NULL, enc, gFalse, &gstringWrite, fontBuf2);
    delete ff;
    ret = SplashFTFontFile::loadType1Font(this, idA, splashFontType1,
            fontBuf2, enc);
    if (ret) {
      delete fontBuf;
    } else {
      delete fontBuf2;
    }
#else
    tmpFileName = NULL;
    if (!openTempFile(&tmpFileName, &tmpFile, "wb", NULL)) {
      delete ff;
      return NULL;
    }
    ff->convertToType1(NULL, enc, gFalse, &fileWrite, tmpFile);
    delete ff;
    fclose(tmpFile);
    ret = SplashFTFontFile::loadType1Font(this, idA, splashFontType1,
            tmpFileName->getCString(),
            gTrue, enc);
    if (ret) {
      if (deleteFile) {
  unlink(fileName);
      }
    } else {
      unlink(tmpFileName->getCString());
    }
    delete tmpFileName;
#endif
  } else {
    delete ff;
    ret = SplashFTFontFile::loadType1Font(this, idA, splashFontOpenTypeT1C,
#if LOAD_FONTS_FROM_MEM
            fontBuf,
#else
            fileName, deleteFile,
#endif
            enc);
  }
  return ret;
}

SplashFontFile *SplashFTFontEngine::loadCIDFont(SplashFontFileID *idA,
#if LOAD_FONTS_FROM_MEM
            GString *fontBuf,
#else
            char *fileName,
            GBool deleteFile,
#endif
            int *codeToGID,
            int codeToGIDLen) {
  FoFiType1C *ff;
  int *cidToGIDMap;
  int nCIDs;
  SplashFontFile *ret;

  // check for a CFF font
  if (codeToGID) {
    cidToGIDMap = NULL;
    nCIDs = 0;
  } else if (useCIDs) {
    cidToGIDMap = NULL;
    nCIDs = 0;
#if LOAD_FONTS_FROM_MEM
  } else if ((ff = FoFiType1C::make(fontBuf->getCString(),
            fontBuf->getLength()))) {
#else
  } else if ((ff = FoFiType1C::load(fileName))) {
#endif
    cidToGIDMap = ff->getCIDToGIDMap(&nCIDs);
    delete ff;
  } else {
    cidToGIDMap = NULL;
    nCIDs = 0;
  }
  ret = SplashFTFontFile::loadCIDFont(this, idA, splashFontCID,
#if LOAD_FONTS_FROM_MEM
              fontBuf,
#else
              fileName, deleteFile,
#endif
              codeToGID ? codeToGID : cidToGIDMap,
              codeToGID ? codeToGIDLen : nCIDs);
  if (!ret) {
    gfree(cidToGIDMap);
  }
  return ret;
}

SplashFontFile *SplashFTFontEngine::loadOpenTypeCFFFont(SplashFontFileID *idA,
#if LOAD_FONTS_FROM_MEM
              GString *fontBuf,
#else
              char *fileName,
              GBool deleteFile,
#endif
              int *codeToGID,
              int codeToGIDLen) {
  FoFiTrueType *ff;
#if LOAD_FONTS_FROM_MEM
  GString *fontBuf2;
#else
  GString *tmpFileName;
  FILE *tmpFile;
#endif
  char *cffStart;
  int cffLength;
  int *cidToGIDMap;
  int nCIDs;
  SplashFontFile *ret;

#if LOAD_FONTS_FROM_MEM
  if (!(ff = FoFiTrueType::make(fontBuf->getCString(), fontBuf->getLength(),
        0, gTrue))) {
#else
  if (!(ff = FoFiTrueType::load(fileName, 0, gTrue))) {
#endif
    return NULL;
  }
  cidToGIDMap = NULL;
  nCIDs = 0;
  if (ff->isHeadlessCFF()) {
    if (!ff->getCFFBlock(&cffStart, &cffLength)) {
      return NULL;
    }
#if LOAD_FONTS_FROM_MEM
    fontBuf2 = new GString(cffStart, cffLength);
    if (!useCIDs) {
      cidToGIDMap = ff->getCIDToGIDMap(&nCIDs);
    }
    ret = SplashFTFontFile::loadCIDFont(this, idA, splashFontOpenTypeCFF,
          fontBuf2, cidToGIDMap, nCIDs);
    if (ret) {
      delete fontBuf;
    } else {
      delete fontBuf2;
    }
#else
    tmpFileName = NULL;
    if (!openTempFile(&tmpFileName, &tmpFile, "wb", NULL)) {
      delete ff;
      return NULL;
    }
    fwrite(cffStart, 1, cffLength, tmpFile);
    fclose(tmpFile);
    if (!useCIDs) {
      cidToGIDMap = ff->getCIDToGIDMap(&nCIDs);
    }
    ret = SplashFTFontFile::loadCIDFont(this, idA, splashFontOpenTypeCFF,
          tmpFileName->getCString(), gTrue,
          cidToGIDMap, nCIDs);
    if (ret) {
      if (deleteFile) {
  unlink(fileName);
      }
    } else {
      unlink(tmpFileName->getCString());
    }
    delete tmpFileName;
#endif
  } else {
    if (!codeToGID && !useCIDs && ff->isOpenTypeCFF()) {
      cidToGIDMap = ff->getCIDToGIDMap(&nCIDs);
    }
    ret = SplashFTFontFile::loadCIDFont(this, idA, splashFontOpenTypeCFF,
#if LOAD_FONTS_FROM_MEM
          fontBuf,
#else
          fileName, deleteFile,
#endif
          codeToGID ? codeToGID : cidToGIDMap,
          codeToGID ? codeToGIDLen : nCIDs);
  }
  delete ff;
  if (!ret) {
    gfree(cidToGIDMap);
  }
  return ret;
}

SplashFontFile *SplashFTFontEngine::loadTrueTypeFont(SplashFontFileID *idA,
#if LOAD_FONTS_FROM_MEM
                 GString *fontBuf,
#else
                 char *fileName,
                 GBool deleteFile,
#endif
                 int fontNum,
                 int *codeToGID,
                 int codeToGIDLen) {
  FoFiTrueType *ff;
#if LOAD_FONTS_FROM_MEM
  GString *fontBuf2;
#else
  GString *tmpFileName;
  FILE *tmpFile;
#endif
  SplashFontFile *ret;

#if LOAD_FONTS_FROM_MEM
  if (!(ff = FoFiTrueType::make(fontBuf->getCString(), fontBuf->getLength(),
        fontNum))) {
#else
  if (!(ff = FoFiTrueType::load(fileName, fontNum))) {
#endif
    return NULL;
  }
#if LOAD_FONTS_FROM_MEM
  fontBuf2 = new GString;
  ff->writeTTF(&gstringWrite, fontBuf2);
#else
  tmpFileName = NULL;
  if (!openTempFile(&tmpFileName, &tmpFile, "wb", NULL)) {
    delete ff;
    return NULL;
  }
  ff->writeTTF(&fileWrite, tmpFile);
  fclose(tmpFile);
#endif
  delete ff;
  ret = SplashFTFontFile::loadTrueTypeFont(this, idA, splashFontTrueType,
#if LOAD_FONTS_FROM_MEM
             fontBuf2,
#else
             tmpFileName->getCString(), gTrue,
#endif
             0, codeToGID, codeToGIDLen);
#if LOAD_FONTS_FROM_MEM
  if (ret) {
    delete fontBuf;
  } else {
    delete fontBuf2;
  }
#else
  if (ret) {
    if (deleteFile) {
      unlink(fileName);
    }
  } else {
    unlink(tmpFileName->getCString());
  }
  delete tmpFileName;
#endif
  return ret;
}

#endif // HAVE_FREETYPE_H

Coverage Report

Created: 2026-08-22 06:39

Line	Count	Source
1		//========================================================================
2		//
3		// SplashFTFontEngine.cc
4		//
5		// Copyright 2003-2013 Glyph & Cog, LLC
6		//
7		//========================================================================
8
9		#include <aconf.h>
10
11		#if HAVE_FREETYPE_H
12
13		#include <stdio.h>
14		#ifndef _WIN32
15		# include <unistd.h>
16		#endif
17		#include "gmem.h"
18		#include "gmempp.h"
19		#include "GString.h"
20		#include "gfile.h"
21		#include "FoFiTrueType.h"
22		#include "FoFiType1C.h"
23		#include "SplashFTFontFile.h"
24		#include "SplashFTFontEngine.h"
25		#include FT_MODULE_H
26		#ifdef FT_CFF_DRIVER_H
27		# include FT_CFF_DRIVER_H
28		#endif
29
30		#ifdef VMS
31		#if (__VMS_VER < 70000000)
32		extern "C" int unlink(char *filename);
33		#endif
34		#endif
35
36		//------------------------------------------------------------------------
37
38	148M	static void fileWrite(void stream, const char data, int len) {
39	148M	fwrite(data, 1, len, (FILE *)stream);
40	148M	}
41
42		#if LOAD_FONTS_FROM_MEM
43		static void gstringWrite(void stream, const char data, int len) {
44		((GString *)stream)->append(data, len);
45		}
46		#endif
47
48		//------------------------------------------------------------------------
49		// SplashFTFontEngine
50		//------------------------------------------------------------------------
51
52		SplashFTFontEngine::SplashFTFontEngine(GBool aaA, Guint flagsA,
53	15.1k	FT_Library libA) {
54	15.1k	FT_Int major, minor, patch;
55
56	15.1k	aa = aaA;
57	15.1k	flags = flagsA;
58	15.1k	lib = libA;
59
60		// as of FT 2.1.8, CID fonts are indexed by CID instead of GID
61	15.1k	FT_Library_Version(lib, &major, &minor, &patch);
62	15.1k	useCIDs = major > 2 \|\|
63	15.1k	(major == 2 && (minor > 1 \|\| (minor == 1 && patch > 7)));
64	15.1k	}
65
66	15.1k	SplashFTFontEngine *SplashFTFontEngine::init(GBool aaA, Guint flagsA) {
67	15.1k	FT_Library libA;
68
69	15.1k	if (FT_Init_FreeType(&libA)) {
70	0	return NULL;
71	0	}
72	15.1k	return new SplashFTFontEngine(aaA, flagsA, libA);
73	15.1k	}
74
75	15.1k	SplashFTFontEngine::~SplashFTFontEngine() {
76	15.1k	FT_Done_FreeType(lib);
77	15.1k	}
78
79		SplashFontFile SplashFTFontEngine::loadType1Font(SplashFontFileID idA,
80		#if LOAD_FONTS_FROM_MEM
81		GString *fontBuf,
82		#else
83		char *fileName,
84		GBool deleteFile,
85		#endif
86	1.24k	const char **enc) {
87	1.24k	return SplashFTFontFile::loadType1Font(this, idA, splashFontType1,
88		#if LOAD_FONTS_FROM_MEM
89		fontBuf,
90		#else
91	1.24k	fileName, deleteFile,
92	1.24k	#endif
93	1.24k	enc);
94	1.24k	}
95
96		SplashFontFile SplashFTFontEngine::loadType1CFont(SplashFontFileID idA,
97		#if LOAD_FONTS_FROM_MEM
98		GString *fontBuf,
99		#else
100		char *fileName,
101		GBool deleteFile,
102		#endif
103	1.73k	const char **enc) {
104	1.73k	return SplashFTFontFile::loadType1Font(this, idA, splashFontType1C,
105		#if LOAD_FONTS_FROM_MEM
106		fontBuf,
107		#else
108	1.73k	fileName, deleteFile,
109	1.73k	#endif
110	1.73k	enc);
111	1.73k	}
112
113		SplashFontFile SplashFTFontEngine::loadOpenTypeT1CFont(SplashFontFileID idA,
114		#if LOAD_FONTS_FROM_MEM
115		GString *fontBuf,
116		#else
117		char *fileName,
118		GBool deleteFile,
119		#endif
120	737	const char **enc) {
121	737	FoFiTrueType *ff;
122		#if LOAD_FONTS_FROM_MEM
123		GString *fontBuf2;
124		#else
125	737	GString *tmpFileName;
126	737	FILE *tmpFile;
127	737	#endif
128	737	SplashFontFile *ret;
129
130		#if LOAD_FONTS_FROM_MEM
131		if (!(ff = FoFiTrueType::make(fontBuf->getCString(), fontBuf->getLength(),
132		0, gTrue))) {
133		#else
134	737	if (!(ff = FoFiTrueType::load(fileName, 0, gTrue))) {
135	6	#endif
136	6	return NULL;
137	6	}
138	731	if (ff->isHeadlessCFF()) {
139		#if LOAD_FONTS_FROM_MEM
140		fontBuf2 = new GString();
141		ff->convertToType1(NULL, enc, gFalse, &gstringWrite, fontBuf2);
142		delete ff;
143		ret = SplashFTFontFile::loadType1Font(this, idA, splashFontType1,
144		fontBuf2, enc);
145		if (ret) {
146		delete fontBuf;
147		} else {
148		delete fontBuf2;
149		}
150		#else
151	663	tmpFileName = NULL;
152	663	if (!openTempFile(&tmpFileName, &tmpFile, "wb", NULL)) {
153	0	delete ff;
154	0	return NULL;
155	0	}
156	663	ff->convertToType1(NULL, enc, gFalse, &fileWrite, tmpFile);
157	663	delete ff;
158	663	fclose(tmpFile);
159	663	ret = SplashFTFontFile::loadType1Font(this, idA, splashFontType1,
160	663	tmpFileName->getCString(),
161	663	gTrue, enc);
162	663	if (ret) {
163	168	if (deleteFile) {
164	168	unlink(fileName);
165	168	}
166	495	} else {
167	495	unlink(tmpFileName->getCString());
168	495	}
169	663	delete tmpFileName;
170	663	#endif
171	663	} else {
172	68	delete ff;
173	68	ret = SplashFTFontFile::loadType1Font(this, idA, splashFontOpenTypeT1C,
174		#if LOAD_FONTS_FROM_MEM
175		fontBuf,
176		#else
177	68	fileName, deleteFile,
178	68	#endif
179	68	enc);
180	68	}
181	731	return ret;
182	731	}
183
184		SplashFontFile SplashFTFontEngine::loadCIDFont(SplashFontFileID idA,
185		#if LOAD_FONTS_FROM_MEM
186		GString *fontBuf,
187		#else
188		char *fileName,
189		GBool deleteFile,
190		#endif
191		int *codeToGID,
192	38	int codeToGIDLen) {
193	38	FoFiType1C *ff;
194	38	int *cidToGIDMap;
195	38	int nCIDs;
196	38	SplashFontFile *ret;
197
198		// check for a CFF font
199	38	if (codeToGID) {
200	0	cidToGIDMap = NULL;
201	0	nCIDs = 0;
202	38	} else if (useCIDs) {
203	38	cidToGIDMap = NULL;
204	38	nCIDs = 0;
205		#if LOAD_FONTS_FROM_MEM
206		} else if ((ff = FoFiType1C::make(fontBuf->getCString(),
207		fontBuf->getLength()))) {
208		#else
209	38	} else if ((ff = FoFiType1C::load(fileName))) {
210	0	#endif
211	0	cidToGIDMap = ff->getCIDToGIDMap(&nCIDs);
212	0	delete ff;
213	0	} else {
214	0	cidToGIDMap = NULL;
215	0	nCIDs = 0;
216	0	}
217	38	ret = SplashFTFontFile::loadCIDFont(this, idA, splashFontCID,
218		#if LOAD_FONTS_FROM_MEM
219		fontBuf,
220		#else
221	38	fileName, deleteFile,
222	38	#endif
223	38	codeToGID ? codeToGID : cidToGIDMap,
224	38	codeToGID ? codeToGIDLen : nCIDs);
225	38	if (!ret) {
226	12	gfree(cidToGIDMap);
227	12	}
228	38	return ret;
229	38	}
230
231		SplashFontFile SplashFTFontEngine::loadOpenTypeCFFFont(SplashFontFileID idA,
232		#if LOAD_FONTS_FROM_MEM
233		GString *fontBuf,
234		#else
235		char *fileName,
236		GBool deleteFile,
237		#endif
238		int *codeToGID,
239	42	int codeToGIDLen) {
240	42	FoFiTrueType *ff;
241		#if LOAD_FONTS_FROM_MEM
242		GString *fontBuf2;
243		#else
244	42	GString *tmpFileName;
245	42	FILE *tmpFile;
246	42	#endif
247	42	char *cffStart;
248	42	int cffLength;
249	42	int *cidToGIDMap;
250	42	int nCIDs;
251	42	SplashFontFile *ret;
252
253		#if LOAD_FONTS_FROM_MEM
254		if (!(ff = FoFiTrueType::make(fontBuf->getCString(), fontBuf->getLength(),
255		0, gTrue))) {
256		#else
257	42	if (!(ff = FoFiTrueType::load(fileName, 0, gTrue))) {
258	3	#endif
259	3	return NULL;
260	3	}
261	39	cidToGIDMap = NULL;
262	39	nCIDs = 0;
263	39	if (ff->isHeadlessCFF()) {
264	4	if (!ff->getCFFBlock(&cffStart, &cffLength)) {
265	1	return NULL;
266	1	}
267		#if LOAD_FONTS_FROM_MEM
268		fontBuf2 = new GString(cffStart, cffLength);
269		if (!useCIDs) {
270		cidToGIDMap = ff->getCIDToGIDMap(&nCIDs);
271		}
272		ret = SplashFTFontFile::loadCIDFont(this, idA, splashFontOpenTypeCFF,
273		fontBuf2, cidToGIDMap, nCIDs);
274		if (ret) {
275		delete fontBuf;
276		} else {
277		delete fontBuf2;
278		}
279		#else
280	3	tmpFileName = NULL;
281	3	if (!openTempFile(&tmpFileName, &tmpFile, "wb", NULL)) {
282	0	delete ff;
283	0	return NULL;
284	0	}
285	3	fwrite(cffStart, 1, cffLength, tmpFile);
286	3	fclose(tmpFile);
287	3	if (!useCIDs) {
288	0	cidToGIDMap = ff->getCIDToGIDMap(&nCIDs);
289	0	}
290	3	ret = SplashFTFontFile::loadCIDFont(this, idA, splashFontOpenTypeCFF,
291	3	tmpFileName->getCString(), gTrue,
292	3	cidToGIDMap, nCIDs);
293	3	if (ret) {
294	2	if (deleteFile) {
295	2	unlink(fileName);
296	2	}
297	2	} else {
298	1	unlink(tmpFileName->getCString());
299	1	}
300	3	delete tmpFileName;
301	3	#endif
302	35	} else {
303	35	if (!codeToGID && !useCIDs && ff->isOpenTypeCFF()) {
304	0	cidToGIDMap = ff->getCIDToGIDMap(&nCIDs);
305	0	}
306	35	ret = SplashFTFontFile::loadCIDFont(this, idA, splashFontOpenTypeCFF,
307		#if LOAD_FONTS_FROM_MEM
308		fontBuf,
309		#else
310	35	fileName, deleteFile,
311	35	#endif
312	35	codeToGID ? codeToGID : cidToGIDMap,
313	35	codeToGID ? codeToGIDLen : nCIDs);
314	35	}
315	38	delete ff;
316	38	if (!ret) {
317	11	gfree(cidToGIDMap);
318	11	}
319	38	return ret;
320	39	}
321
322		SplashFontFile SplashFTFontEngine::loadTrueTypeFont(SplashFontFileID idA,
323		#if LOAD_FONTS_FROM_MEM
324		GString *fontBuf,
325		#else
326		char *fileName,
327		GBool deleteFile,
328		#endif
329		int fontNum,
330		int *codeToGID,
331	3.88k	int codeToGIDLen) {
332	3.88k	FoFiTrueType *ff;
333		#if LOAD_FONTS_FROM_MEM
334		GString *fontBuf2;
335		#else
336	3.88k	GString *tmpFileName;
337	3.88k	FILE *tmpFile;
338	3.88k	#endif
339	3.88k	SplashFontFile *ret;
340
341		#if LOAD_FONTS_FROM_MEM
342		if (!(ff = FoFiTrueType::make(fontBuf->getCString(), fontBuf->getLength(),
343		fontNum))) {
344		#else
345	3.88k	if (!(ff = FoFiTrueType::load(fileName, fontNum))) {
346	73	#endif
347	73	return NULL;
348	73	}
349		#if LOAD_FONTS_FROM_MEM
350		fontBuf2 = new GString;
351		ff->writeTTF(&gstringWrite, fontBuf2);
352		#else
353	3.81k	tmpFileName = NULL;
354	3.81k	if (!openTempFile(&tmpFileName, &tmpFile, "wb", NULL)) {
355	0	delete ff;
356	0	return NULL;
357	0	}
358	3.81k	ff->writeTTF(&fileWrite, tmpFile);
359	3.81k	fclose(tmpFile);
360	3.81k	#endif
361	3.81k	delete ff;
362	3.81k	ret = SplashFTFontFile::loadTrueTypeFont(this, idA, splashFontTrueType,
363		#if LOAD_FONTS_FROM_MEM
364		fontBuf2,
365		#else
366	3.81k	tmpFileName->getCString(), gTrue,
367	3.81k	#endif
368	3.81k	0, codeToGID, codeToGIDLen);
369		#if LOAD_FONTS_FROM_MEM
370		if (ret) {
371		delete fontBuf;
372		} else {
373		delete fontBuf2;
374		}
375		#else
376	3.81k	if (ret) {
377	3.51k	if (deleteFile) {
378	3.51k	unlink(fileName);
379	3.51k	}
380	3.51k	} else {
381	299	unlink(tmpFileName->getCString());
382	299	}
383	3.81k	delete tmpFileName;
384	3.81k	#endif
385	3.81k	return ret;
386	3.81k	}
387
388		#endif // HAVE_FREETYPE_H