kmadej_fast_excel_fork 0.2.2

data/libxlsxwriter/third_party/minizip/zip.h

@@ -0,0 +1,367 @@
+/* zip.h -- IO on .zip files using zlib
+   Version 1.1, February 14h, 2010
+   part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+         Modifications for Zip64 support
+         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+         For more info read MiniZip_info.txt
+
+         ---------------------------------------------------------------------------
+
+   Condition of use and distribution are the same than zlib :
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+        ---------------------------------------------------------------------------
+
+        Changes
+
+        See header of zip.h
+
+*/
+
+/* Pragma added by libxlsxwriter project to avoid warnings with -pedantic -ansi. */
+#ifndef _WIN32
+#pragma GCC system_header
+#endif
+
+#ifndef _zip12_H
+#define _zip12_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* #define HAVE_BZIP2 */
+
+#ifndef _ZLIB_H
+#include "zlib.h"
+#endif
+
+#ifndef _ZLIBIOAPI_H
+#include "ioapi.h"
+#endif
+
+#ifdef HAVE_BZIP2
+#include "bzlib.h"
+#endif
+
+#define Z_BZIP2ED 12
+
+#if defined(STRICTZIP) || defined(STRICTZIPUNZIP)
+/* like the STRICT of WIN32, we define a pointer that cannot be converted
+    from (void*) without cast */
+typedef struct TagzipFile__ { int unused; } zipFile__;
+typedef zipFile__ *zipFile;
+#else
+typedef voidp zipFile;
+#endif
+
+#define ZIP_OK                          (0)
+#define ZIP_EOF                         (0)
+#define ZIP_ERRNO                       (Z_ERRNO)
+#define ZIP_PARAMERROR                  (-102)
+#define ZIP_BADZIPFILE                  (-103)
+#define ZIP_INTERNALERROR               (-104)
+
+#ifndef DEF_MEM_LEVEL
+#  if MAX_MEM_LEVEL >= 8
+#    define DEF_MEM_LEVEL 8
+#  else
+#    define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#  endif
+#endif
+/* default memLevel */
+
+/* tm_zip contain date/time info */
+typedef struct tm_zip_s
+{
+    uInt tm_sec;            /* seconds after the minute - [0,59] */
+    uInt tm_min;            /* minutes after the hour - [0,59] */
+    uInt tm_hour;           /* hours since midnight - [0,23] */
+    uInt tm_mday;           /* day of the month - [1,31] */
+    uInt tm_mon;            /* months since January - [0,11] */
+    uInt tm_year;           /* years - [1980..2044] */
+} tm_zip;
+
+typedef struct
+{
+    tm_zip      tmz_date;       /* date in understandable format           */
+    uLong       dosDate;       /* if dos_date == 0, tmu_date is used      */
+/*    uLong       flag;        */   /* general purpose bit flag        2 bytes */
+
+    uLong       internal_fa;    /* internal file attributes        2 bytes */
+    uLong       external_fa;    /* external file attributes        4 bytes */
+} zip_fileinfo;
+
+typedef const char* zipcharpc;
+
+
+#define APPEND_STATUS_CREATE        (0)
+#define APPEND_STATUS_CREATEAFTER   (1)
+#define APPEND_STATUS_ADDINZIP      (2)
+
+extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append));
+extern zipFile ZEXPORT zipOpen64 OF((const void *pathname, int append));
+/*
+  Create a zipfile.
+     pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on
+       an Unix computer "zlib/zlib113.zip".
+     if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip
+       will be created at the end of the file.
+         (useful if the file contain a self extractor code)
+     if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will
+       add files in existing zip (be sure you don't add file that doesn't exist)
+     If the zipfile cannot be opened, the return value is NULL.
+     Else, the return value is a zipFile Handle, usable with other function
+       of this zip package.
+*/
+
+/* Note : there is no delete function into a zipfile.
+   If you want delete file into a zipfile, you must open a zipfile, and create another
+   Of couse, you can use RAW reading and writing to copy the file you did not want delte
+*/
+
+extern zipFile ZEXPORT zipOpen2 OF((const char *pathname,
+                                   int append,
+                                   zipcharpc* globalcomment,
+                                   zlib_filefunc_def* pzlib_filefunc_def));
+
+extern zipFile ZEXPORT zipOpen2_64 OF((const void *pathname,
+                                   int append,
+                                   zipcharpc* globalcomment,
+                                   zlib_filefunc64_def* pzlib_filefunc_def));
+
+extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file,
+                       const char* filename,
+                       const zip_fileinfo* zipfi,
+                       const void* extrafield_local,
+                       uInt size_extrafield_local,
+                       const void* extrafield_global,
+                       uInt size_extrafield_global,
+                       const char* comment,
+                       int method,
+                       int level));
+
+extern int ZEXPORT zipOpenNewFileInZip64 OF((zipFile file,
+                       const char* filename,
+                       const zip_fileinfo* zipfi,
+                       const void* extrafield_local,
+                       uInt size_extrafield_local,
+                       const void* extrafield_global,
+                       uInt size_extrafield_global,
+                       const char* comment,
+                       int method,
+                       int level,
+                       int zip64));
+
+/*
+  Open a file in the ZIP for writing.
+  filename : the filename in zip (if NULL, '-' without quote will be used
+  *zipfi contain supplemental information
+  if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local
+    contains the extrafield data the the local header
+  if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global
+    contains the extrafield data the the local header
+  if comment != NULL, comment contain the comment string
+  method contain the compression method (0 for store, Z_DEFLATED for deflate)
+  level contain the level of compression (can be Z_DEFAULT_COMPRESSION)
+  zip64 is set to 1 if a zip64 extended information block should be added to the local file header.
+                    this MUST be '1' if the uncompressed size is >= 0xffffffff.
+
+*/
+
+
+extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file,
+                                            const char* filename,
+                                            const zip_fileinfo* zipfi,
+                                            const void* extrafield_local,
+                                            uInt size_extrafield_local,
+                                            const void* extrafield_global,
+                                            uInt size_extrafield_global,
+                                            const char* comment,
+                                            int method,
+                                            int level,
+                                            int raw));
+
+
+extern int ZEXPORT zipOpenNewFileInZip2_64 OF((zipFile file,
+                                            const char* filename,
+                                            const zip_fileinfo* zipfi,
+                                            const void* extrafield_local,
+                                            uInt size_extrafield_local,
+                                            const void* extrafield_global,
+                                            uInt size_extrafield_global,
+                                            const char* comment,
+                                            int method,
+                                            int level,
+                                            int raw,
+                                            int zip64));
+/*
+  Same than zipOpenNewFileInZip, except if raw=1, we write raw file
+ */
+
+extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file,
+                                            const char* filename,
+                                            const zip_fileinfo* zipfi,
+                                            const void* extrafield_local,
+                                            uInt size_extrafield_local,
+                                            const void* extrafield_global,
+                                            uInt size_extrafield_global,
+                                            const char* comment,
+                                            int method,
+                                            int level,
+                                            int raw,
+                                            int windowBits,
+                                            int memLevel,
+                                            int strategy,
+                                            const char* password,
+                                            uLong crcForCrypting));
+
+extern int ZEXPORT zipOpenNewFileInZip3_64 OF((zipFile file,
+                                            const char* filename,
+                                            const zip_fileinfo* zipfi,
+                                            const void* extrafield_local,
+                                            uInt size_extrafield_local,
+                                            const void* extrafield_global,
+                                            uInt size_extrafield_global,
+                                            const char* comment,
+                                            int method,
+                                            int level,
+                                            int raw,
+                                            int windowBits,
+                                            int memLevel,
+                                            int strategy,
+                                            const char* password,
+                                            uLong crcForCrypting,
+                                            int zip64
+                                            ));
+
+/*
+  Same than zipOpenNewFileInZip2, except
+    windowBits,memLevel,,strategy : see parameter strategy in deflateInit2
+    password : crypting password (NULL for no crypting)
+    crcForCrypting : crc of file to compress (needed for crypting)
+ */
+
+extern int ZEXPORT zipOpenNewFileInZip4 OF((zipFile file,
+                                            const char* filename,
+                                            const zip_fileinfo* zipfi,
+                                            const void* extrafield_local,
+                                            uInt size_extrafield_local,
+                                            const void* extrafield_global,
+                                            uInt size_extrafield_global,
+                                            const char* comment,
+                                            int method,
+                                            int level,
+                                            int raw,
+                                            int windowBits,
+                                            int memLevel,
+                                            int strategy,
+                                            const char* password,
+                                            uLong crcForCrypting,
+                                            uLong versionMadeBy,
+                                            uLong flagBase
+                                            ));
+
+
+extern int ZEXPORT zipOpenNewFileInZip4_64 OF((zipFile file,
+                                            const char* filename,
+                                            const zip_fileinfo* zipfi,
+                                            const void* extrafield_local,
+                                            uInt size_extrafield_local,
+                                            const void* extrafield_global,
+                                            uInt size_extrafield_global,
+                                            const char* comment,
+                                            int method,
+                                            int level,
+                                            int raw,
+                                            int windowBits,
+                                            int memLevel,
+                                            int strategy,
+                                            const char* password,
+                                            uLong crcForCrypting,
+                                            uLong versionMadeBy,
+                                            uLong flagBase,
+                                            int zip64
+                                            ));
+/*
+  Same than zipOpenNewFileInZip4, except
+    versionMadeBy : value for Version made by field
+    flag : value for flag field (compression level info will be added)
+ */
+
+
+extern int ZEXPORT zipWriteInFileInZip OF((zipFile file,
+                       const void* buf,
+                       unsigned len));
+/*
+  Write data in the zipfile
+*/
+
+extern int ZEXPORT zipCloseFileInZip OF((zipFile file));
+/*
+  Close the current file in the zipfile
+*/
+
+extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file,
+                                            uLong uncompressed_size,
+                                            uLong crc32));
+
+extern int ZEXPORT zipCloseFileInZipRaw64 OF((zipFile file,
+                                            ZPOS64_T uncompressed_size,
+                                            uLong crc32));
+
+/*
+  Close the current file in the zipfile, for file opened with
+    parameter raw=1 in zipOpenNewFileInZip2
+  uncompressed_size and crc32 are value for the uncompressed size
+*/
+
+extern int ZEXPORT zipClose OF((zipFile file,
+                const char* global_comment));
+/*
+  Close the zipfile
+*/
+
+
+extern int ZEXPORT zipRemoveExtraInfoBlock OF((char* pData, int* dataLen, short sHeader));
+/*
+  zipRemoveExtraInfoBlock -  Added by Mathias Svensson
+
+  Remove extra information block from a extra information data for the local file header or central directory header
+
+  It is needed to remove ZIP64 extra information blocks when before data is written if using RAW mode.
+
+  0x0001 is the signature header for the ZIP64 extra information blocks
+
+  usage.
+                        Remove ZIP64 Extra information from a central director extra field data
+              zipRemoveExtraInfoBlock(pCenDirExtraFieldData, &nCenDirExtraFieldDataLen, 0x0001);
+
+                        Remove ZIP64 Extra information from a Local File Header extra field data
+        zipRemoveExtraInfoBlock(pLocalHeaderExtraFieldData, &nLocalHeaderExtraFieldDataLen, 0x0001);
+*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _zip64_H */

data/libxlsxwriter/third_party/tmpfileplus/Makefile

@@ -0,0 +1,42 @@
+###############################################################################
+#
+# Simplied Makefile to build tmpfileplus for the libxlsxwriter library.
+#
+
+# Keep the output quiet by default.
+Q=@
+ifdef V
+Q=
+endif
+
+UNAME := $(shell uname)
+
+# Check for MinGW/MinGW64/Cygwin environments.
+ifneq (,$(findstring MINGW, $(UNAME)))
+MING_LIKE = y
+endif
+ifneq (,$(findstring MSYS, $(UNAME)))
+MING_LIKE = y
+endif
+ifneq (,$(findstring CYGWIN, $(UNAME)))
+MING_LIKE = y
+endif
+
+FPIC = -fPIC
+
+# Change make options on MinGW/MinGW64/Cygwin.
+ifdef MING_LIKE
+FPIC =
+CC = gcc
+endif
+
+all: tmpfileplus.o tmpfileplus.so
+
+%.o  : %.c
+	$(Q)$(CC)         -c $(CFLAGS) $<
+
+%.so : %.c
+	$(Q)$(CC) $(FPIC) -c $(CFLAGS) $< -o $@
+
+clean:
+	$(Q)/bin/rm -f *.o *.so

data/libxlsxwriter/third_party/tmpfileplus/tmpfileplus.c

@@ -0,0 +1,342 @@
+/* $Id: tmpfileplus.c $ */
+/*
+ * $Date: 2016-06-01 03:31Z $
+ * $Revision: 2.0.0 $
+ * $Author: dai $
+ */
+
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) 2012-16 David Ireland, DI Management Services Pty Ltd
+ * <http://www.di-mgt.com.au/contact/>.
+ */
+
+
+/*
+* NAME
+*        tmpfileplus - create a unique temporary file
+*
+* SYNOPSIS
+*        FILE *tmpfileplus(const char *dir, const char *prefix, char **pathname, int keep)
+*
+* DESCRIPTION
+*        The tmpfileplus() function opens a unique temporary file in binary
+*        read/write (w+b) mode. The file is opened with the O_EXCL flag,
+*        guaranteeing that the caller is the only user. The filename will consist
+*        of the string given by `prefix` followed by 10 random characters. If
+*        `prefix` is NULL, then the string "tmp." will be used instead. The file
+*        will be created in an appropriate directory chosen by the first
+*        successful attempt in the following sequence:
+*
+*        a) The directory given by the `dir` argument (so the caller can specify
+*        a secure directory to take precedence).
+*
+*        b) The directory name in the environment variables:
+*
+*          (i)   "TMP" [Windows only]
+*          (ii)  "TEMP" [Windows only]
+*          (iii) "TMPDIR" [Unix only]
+*
+*        c) `P_tmpdir` as defined in <stdio.h> [Unix only] (in Windows, this is
+*        usually "\", which is no good).
+*
+*        d) The current working directory.
+*
+*        If a file cannot be created in any of the above directories, then the
+*        function fails and NULL is returned.
+*
+*        If the argument `pathname` is not a null pointer, then it will point to
+*        the full pathname of the file. The pathname is allocated using `malloc`
+*        and therefore should be freed by `free`.
+*
+*        If `keep` is nonzero and `pathname` is not a null pointer, then the file
+*        will be kept after it is closed. Otherwise the file will be
+*        automatically deleted when it is closed or the program terminates.
+*
+*
+* RETURN VALUE
+*        The tmpfileplus() function returns a pointer to the open file stream,
+*        or NULL if a unique file cannot be opened.
+*
+*
+* ERRORS
+*        ENOMEM Not enough memory to allocate filename.
+*
+*/
+
+/* ADDED IN v2.0 */
+
+/*
+* NAME
+*        tmpfileplus_f - create a unique temporary file with filename stored in a fixed-length buffer
+*
+* SYNOPSIS
+*        FILE *tmpfileplus_f(const char *dir, const char *prefix, char *pathnamebuf, size_t pathsize, int keep);
+*
+* DESCRIPTION
+*        Same as tmpfileplus() except receives filename in a fixed-length buffer. No allocated memory to free.
+
+* ERRORS
+*        E2BIG Resulting filename is too big for the buffer `pathnamebuf`.
+
+*/
+
+#include "tmpfileplus.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <errno.h>
+
+/* Non-ANSI include files that seem to work in both MSVC and Linux */
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#ifdef _WIN32
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+
+#ifdef _WIN32
+/* MSVC nags to enforce ISO C++ conformant function names with leading "_",
+ * so we define our own function names to avoid whingeing compilers...
+ */
+#define OPEN_ _open
+#define FDOPEN_ _fdopen
+#else
+#define OPEN_ open
+#define FDOPEN_ fdopen
+#endif
+
+
+/* DEBUGGING STUFF */
+#if defined(_DEBUG) && defined(SHOW_DPRINTF)
+#define DPRINTF1(s, a1) printf(s, a1)
+#else
+#define DPRINTF1(s, a1)
+#endif
+
+
+#ifdef _WIN32
+#define FILE_SEPARATOR "\\"
+#else
+#define FILE_SEPARATOR "/"
+#endif
+
+#define RANDCHARS	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
+#define NRANDCHARS	(sizeof(RANDCHARS) - 1)
+
+/** Replace each byte in string s with a random character from TEMPCHARS */
+static char *set_randpart(char *s)
+{
+	size_t i;
+	unsigned int r;
+	static unsigned int seed;	/* NB static */
+
+	if (seed == 0)
+	{	/* First time set our seed using current time and clock */
+		seed = ((unsigned)time(NULL)<<8) ^ (unsigned)clock();
+	}
+	srand(seed++);
+	for (i = 0; i < strlen(s); i++)
+	{
+		r = rand() % NRANDCHARS;
+		s[i] = (RANDCHARS)[r];
+	}
+	return s;
+}
+
+/** Return 1 if path is a valid directory otherwise 0 */
+static int is_valid_dir(const char *path)
+{
+	struct stat st;
+	if ((stat(path, &st) == 0) && (st.st_mode & S_IFDIR))
+		return 1;
+
+	return 0;
+}
+
+/** Call getenv and save a copy in buf */
+static char *getenv_save(const char *varname, char *buf, size_t bufsize)
+{
+	char *ptr = getenv(varname);
+	buf[0] = '\0';
+	if (ptr)
+	{
+		strncpy(buf, ptr, bufsize);
+		buf[bufsize-1] = '\0';
+		return buf;
+	}
+	return NULL;
+}
+
+/**
+ * Try and create a randomly-named file in directory `tmpdir`.
+ * If successful, allocate memory and set `tmpname_ptr` to full filepath, and return file pointer;
+ * otherwise return NULL.
+ * If `keep` is zero then create the file as temporary and it should not exist once closed.
+ */
+static FILE *mktempfile_internal(const char *tmpdir, const char *pfx, char **tmpname_ptr, int keep)
+/* PRE:
+ * pfx is not NULL and points to a valid null-terminated string
+ * tmpname_ptr is not NULL.
+ */
+{
+	FILE *fp;
+	int fd;
+	char randpart[] = "1234567890";
+	size_t lentempname;
+	int i;
+	char *tmpname = NULL;
+	int oflag, pmode;
+
+/* In Windows, we use the _O_TEMPORARY flag with `open` to ensure the file is deleted when closed.
+ * In Unix, we use the unlink function after opening the file. (This does not work in Windows,
+ * which does not allow an open file to be unlinked.)
+ */
+#ifdef _WIN32
+	/* MSVC flags */
+	oflag =  _O_BINARY|_O_CREAT|_O_EXCL|_O_RDWR;
+	if (!keep)
+		oflag |= _O_TEMPORARY;
+	pmode = _S_IREAD | _S_IWRITE;
+#else
+	/* Standard POSIX flags */
+	oflag = O_CREAT|O_EXCL|O_RDWR;
+	pmode = S_IRUSR|S_IWUSR;
+#endif
+
+	if (!tmpdir || !is_valid_dir(tmpdir)) {
+		errno = ENOENT;
+		return NULL;
+	}
+
+	lentempname = strlen(tmpdir) + strlen(FILE_SEPARATOR) + strlen(pfx) + strlen(randpart);
+	DPRINTF1("lentempname=%d\n", lentempname);
+	tmpname = malloc(lentempname + 1);
+	if (!tmpname)
+	{
+		errno = ENOMEM;
+		return NULL;
+	}
+	/* If we don't manage to create a file after 10 goes, there is something wrong... */
+	for (i = 0; i < 10; i++)
+	{
+		sprintf(tmpname, "%s%s%s%s", tmpdir, FILE_SEPARATOR, pfx, set_randpart(randpart));
+		DPRINTF1("[%s]\n", tmpname);
+		fd = OPEN_(tmpname, oflag, pmode);
+		if (fd != -1) break;
+	}
+	DPRINTF1("strlen(tmpname)=%d\n", strlen(tmpname));
+	if (fd != -1)
+	{	/* Success, so return user a proper ANSI C file pointer */
+		fp = FDOPEN_(fd, "w+b");
+		errno = 0;
+
+#ifndef _WIN32
+		/* [Unix only] And make sure the file will be deleted once closed */
+		if (!keep) unlink(tmpname);
+#endif
+
+	}
+	else
+	{	/* We failed */
+		fp = NULL;
+	}
+	if (!fp)
+	{
+		free(tmpname);
+		tmpname = NULL;
+	}
+
+	*tmpname_ptr = tmpname;
+	return fp;
+}
+
+/**********************/
+/* EXPORTED FUNCTIONS */
+/**********************/
+
+FILE *tmpfileplus(const char *dir, const char *prefix, char **pathname, int keep)
+{
+	FILE *fp = NULL;
+	char *tmpname = NULL;
+	char *tmpdir = NULL;
+	const char *pfx = (prefix ? prefix : "tmp.");
+	char *tempdirs[12] = { 0 };
+#ifdef _WIN32
+	char env1[FILENAME_MAX+1] = { 0 };
+	char env2[FILENAME_MAX+1] = { 0 };
+#else
+	char env3[FILENAME_MAX+1] = { 0 };
+#endif
+	int ntempdirs = 0;
+	int i;
+
+	/* Set up a list of temp directories we will try in order */
+	i = 0;
+	tempdirs[i++] = (char *)dir;
+#ifdef _WIN32
+	tempdirs[i++] = getenv_save("TMP", env1, sizeof(env1));
+	tempdirs[i++] = getenv_save("TEMP", env2, sizeof(env2));
+#else
+	tempdirs[i++] = getenv_save("TMPDIR", env3, sizeof(env3));
+	tempdirs[i++] = P_tmpdir;
+#endif
+	tempdirs[i++] = ".";
+	ntempdirs = i;
+
+	errno = 0;
+
+	/* Work through list we set up before, and break once we are successful */
+	for (i = 0; i < ntempdirs; i++)
+	{
+		tmpdir = tempdirs[i];
+		DPRINTF1("Trying tmpdir=[%s]\n", tmpdir);
+		fp = mktempfile_internal(tmpdir, pfx, &tmpname, keep);
+		if (fp) break;
+	}
+	/* If we succeeded and the user passed a pointer, set it to the alloc'd pathname: the user must free this */
+	if (fp && pathname)
+		*pathname = tmpname;
+	else	/* Otherwise, free the alloc'd memory */
+		free(tmpname);
+
+	return fp;
+}
+
+/* Same as tmpfileplus() but with fixed length buffer for output filename and no memory allocation */
+FILE *tmpfileplus_f(const char *dir, const char *prefix, char *pathnamebuf, size_t pathsize, int keep)
+{
+	char *tmpbuf = NULL;
+	FILE *fp;
+
+	/* If no buffer provided, do the normal way */
+	if (!pathnamebuf || (int)pathsize <= 0) {
+		return tmpfileplus(dir, prefix, NULL, keep);
+	}
+	/* Call with a temporary buffer */
+	fp = tmpfileplus(dir, prefix, &tmpbuf, keep);
+	if (fp && strlen(tmpbuf) > pathsize - 1) {
+		/* Succeeded but not enough room in output buffer, so clean up and return an error */
+		pathnamebuf[0] = 0;
+		fclose(fp);
+		if (keep) remove(tmpbuf);
+		free(tmpbuf);
+		errno = E2BIG;
+		return NULL;
+	}
+	/* Copy name into buffer */
+	strcpy(pathnamebuf, tmpbuf);
+	free(tmpbuf);
+
+	return fp;
+}
+
+