/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-06-10 06:33

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	51.3M	static void fileWrite(void stream, const char data, int len) {
39	51.3M	fwrite(data, 1, len, (FILE *)stream);
40	51.3M	}
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	11.4k	FT_Library libA) {
54	11.4k	FT_Int major, minor, patch;
55
56	11.4k	aa = aaA;
57	11.4k	flags = flagsA;
58	11.4k	lib = libA;
59
60		// as of FT 2.1.8, CID fonts are indexed by CID instead of GID
61	11.4k	FT_Library_Version(lib, &major, &minor, &patch);
62	11.4k	useCIDs = major > 2 \|\|
63	11.4k	(major == 2 && (minor > 1 \|\| (minor == 1 && patch > 7)));
64	11.4k	}
65
66	11.4k	SplashFTFontEngine *SplashFTFontEngine::init(GBool aaA, Guint flagsA) {
67	11.4k	FT_Library libA;
68
69	11.4k	if (FT_Init_FreeType(&libA)) {
70	0	return NULL;
71	0	}
72	11.4k	return new SplashFTFontEngine(aaA, flagsA, libA);
73	11.4k	}
74
75	11.4k	SplashFTFontEngine::~SplashFTFontEngine() {
76	11.4k	FT_Done_FreeType(lib);
77	11.4k	}
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	900	const char **enc) {
87	900	return SplashFTFontFile::loadType1Font(this, idA, splashFontType1,
88		#if LOAD_FONTS_FROM_MEM
89		fontBuf,
90		#else
91	900	fileName, deleteFile,
92	900	#endif
93	900	enc);
94	900	}
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.19k	const char **enc) {
104	1.19k	return SplashFTFontFile::loadType1Font(this, idA, splashFontType1C,
105		#if LOAD_FONTS_FROM_MEM
106		fontBuf,
107		#else
108	1.19k	fileName, deleteFile,
109	1.19k	#endif
110	1.19k	enc);
111	1.19k	}
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	467	const char **enc) {
121	467	FoFiTrueType *ff;
122		#if LOAD_FONTS_FROM_MEM
123		GString *fontBuf2;
124		#else
125	467	GString *tmpFileName;
126	467	FILE *tmpFile;
127	467	#endif
128	467	SplashFontFile *ret;
129
130		#if LOAD_FONTS_FROM_MEM
131		if (!(ff = FoFiTrueType::make(fontBuf->getCString(), fontBuf->getLength(),
132		0, gTrue))) {
133		#else
134	467	if (!(ff = FoFiTrueType::load(fileName, 0, gTrue))) {
135	4	#endif
136	4	return NULL;
137	4	}
138	463	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	417	tmpFileName = NULL;
152	417	if (!openTempFile(&tmpFileName, &tmpFile, "wb", NULL)) {
153	0	delete ff;
154	0	return NULL;
155	0	}
156	417	ff->convertToType1(NULL, enc, gFalse, &fileWrite, tmpFile);
157	417	delete ff;
158	417	fclose(tmpFile);
159	417	ret = SplashFTFontFile::loadType1Font(this, idA, splashFontType1,
160	417	tmpFileName->getCString(),
161	417	gTrue, enc);
162	417	if (ret) {
163	98	if (deleteFile) {
164	98	unlink(fileName);
165	98	}
166	319	} else {
167	319	unlink(tmpFileName->getCString());
168	319	}
169	417	delete tmpFileName;
170	417	#endif
171	417	} else {
172	46	delete ff;
173	46	ret = SplashFTFontFile::loadType1Font(this, idA, splashFontOpenTypeT1C,
174		#if LOAD_FONTS_FROM_MEM
175		fontBuf,
176		#else
177	46	fileName, deleteFile,
178	46	#endif
179	46	enc);
180	46	}
181	463	return ret;
182	463	}
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	34	int codeToGIDLen) {
193	34	FoFiType1C *ff;
194	34	int *cidToGIDMap;
195	34	int nCIDs;
196	34	SplashFontFile *ret;
197
198		// check for a CFF font
199	34	if (codeToGID) {
200	0	cidToGIDMap = NULL;
201	0	nCIDs = 0;
202	34	} else if (useCIDs) {
203	34	cidToGIDMap = NULL;
204	34	nCIDs = 0;
205		#if LOAD_FONTS_FROM_MEM
206		} else if ((ff = FoFiType1C::make(fontBuf->getCString(),
207		fontBuf->getLength()))) {
208		#else
209	34	} 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	34	ret = SplashFTFontFile::loadCIDFont(this, idA, splashFontCID,
218		#if LOAD_FONTS_FROM_MEM
219		fontBuf,
220		#else
221	34	fileName, deleteFile,
222	34	#endif
223	34	codeToGID ? codeToGID : cidToGIDMap,
224	34	codeToGID ? codeToGIDLen : nCIDs);
225	34	if (!ret) {
226	11	gfree(cidToGIDMap);
227	11	}
228	34	return ret;
229	34	}
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	34	int codeToGIDLen) {
240	34	FoFiTrueType *ff;
241		#if LOAD_FONTS_FROM_MEM
242		GString *fontBuf2;
243		#else
244	34	GString *tmpFileName;
245	34	FILE *tmpFile;
246	34	#endif
247	34	char *cffStart;
248	34	int cffLength;
249	34	int *cidToGIDMap;
250	34	int nCIDs;
251	34	SplashFontFile *ret;
252
253		#if LOAD_FONTS_FROM_MEM
254		if (!(ff = FoFiTrueType::make(fontBuf->getCString(), fontBuf->getLength(),
255		0, gTrue))) {
256		#else
257	34	if (!(ff = FoFiTrueType::load(fileName, 0, gTrue))) {
258	3	#endif
259	3	return NULL;
260	3	}
261	31	cidToGIDMap = NULL;
262	31	nCIDs = 0;
263	31	if (ff->isHeadlessCFF()) {
264	2	if (!ff->getCFFBlock(&cffStart, &cffLength)) {
265	0	return NULL;
266	0	}
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	2	tmpFileName = NULL;
281	2	if (!openTempFile(&tmpFileName, &tmpFile, "wb", NULL)) {
282	0	delete ff;
283	0	return NULL;
284	0	}
285	2	fwrite(cffStart, 1, cffLength, tmpFile);
286	2	fclose(tmpFile);
287	2	if (!useCIDs) {
288	0	cidToGIDMap = ff->getCIDToGIDMap(&nCIDs);
289	0	}
290	2	ret = SplashFTFontFile::loadCIDFont(this, idA, splashFontOpenTypeCFF,
291	2	tmpFileName->getCString(), gTrue,
292	2	cidToGIDMap, nCIDs);
293	2	if (ret) {
294	1	if (deleteFile) {
295	1	unlink(fileName);
296	1	}
297	1	} else {
298	1	unlink(tmpFileName->getCString());
299	1	}
300	2	delete tmpFileName;
301	2	#endif
302	29	} else {
303	29	if (!codeToGID && !useCIDs && ff->isOpenTypeCFF()) {
304	0	cidToGIDMap = ff->getCIDToGIDMap(&nCIDs);
305	0	}
306	29	ret = SplashFTFontFile::loadCIDFont(this, idA, splashFontOpenTypeCFF,
307		#if LOAD_FONTS_FROM_MEM
308		fontBuf,
309		#else
310	29	fileName, deleteFile,
311	29	#endif
312	29	codeToGID ? codeToGID : cidToGIDMap,
313	29	codeToGID ? codeToGIDLen : nCIDs);
314	29	}
315	31	delete ff;
316	31	if (!ret) {
317	12	gfree(cidToGIDMap);
318	12	}
319	31	return ret;
320	31	}
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	2.52k	int codeToGIDLen) {
332	2.52k	FoFiTrueType *ff;
333		#if LOAD_FONTS_FROM_MEM
334		GString *fontBuf2;
335		#else
336	2.52k	GString *tmpFileName;
337	2.52k	FILE *tmpFile;
338	2.52k	#endif
339	2.52k	SplashFontFile *ret;
340
341		#if LOAD_FONTS_FROM_MEM
342		if (!(ff = FoFiTrueType::make(fontBuf->getCString(), fontBuf->getLength(),
343		fontNum))) {
344		#else
345	2.52k	if (!(ff = FoFiTrueType::load(fileName, fontNum))) {
346	51	#endif
347	51	return NULL;
348	51	}
349		#if LOAD_FONTS_FROM_MEM
350		fontBuf2 = new GString;
351		ff->writeTTF(&gstringWrite, fontBuf2);
352		#else
353	2.47k	tmpFileName = NULL;
354	2.47k	if (!openTempFile(&tmpFileName, &tmpFile, "wb", NULL)) {
355	0	delete ff;
356	0	return NULL;
357	0	}
358	2.47k	ff->writeTTF(&fileWrite, tmpFile);
359	2.47k	fclose(tmpFile);
360	2.47k	#endif
361	2.47k	delete ff;
362	2.47k	ret = SplashFTFontFile::loadTrueTypeFont(this, idA, splashFontTrueType,
363		#if LOAD_FONTS_FROM_MEM
364		fontBuf2,
365		#else
366	2.47k	tmpFileName->getCString(), gTrue,
367	2.47k	#endif
368	2.47k	0, codeToGID, codeToGIDLen);
369		#if LOAD_FONTS_FROM_MEM
370		if (ret) {
371		delete fontBuf;
372		} else {
373		delete fontBuf2;
374		}
375		#else
376	2.47k	if (ret) {
377	2.30k	if (deleteFile) {
378	2.30k	unlink(fileName);
379	2.30k	}
380	2.30k	} else {
381	169	unlink(tmpFileName->getCString());
382	169	}
383	2.47k	delete tmpFileName;
384	2.47k	#endif
385	2.47k	return ret;
386	2.47k	}
387
388		#endif // HAVE_FREETYPE_H