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

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