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

Source (jump to first uncovered line)
//========================================================================
//
// 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: 2025-07-11 07:47

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