sl@0: /************************************************************************
sl@0:  *
sl@0:  * file.cpp - definitions of testsuite file I/O helpers
sl@0:  *
sl@0:  * $Id: file.cpp 290020 2005-09-18 23:58:30Z sebor $
sl@0:  *
sl@0:  ************************************************************************
sl@0:  *
sl@0:  * Copyright (c) 1994-2005 Quovadx,  Inc., acting through its  Rogue Wave
sl@0:  * Software division. Licensed under the Apache License, Version 2.0 (the
sl@0:  * "License");  you may  not use this file except  in compliance with the
sl@0:  * License.    You    may   obtain   a   copy   of    the   License    at
sl@0:  * http://www.apache.org/licenses/LICENSE-2.0.    Unless   required    by
sl@0:  * applicable law  or agreed to  in writing,  software  distributed under
sl@0:  * the License is distributed on an "AS IS" BASIS,  WITHOUT WARRANTIES OR
sl@0:  * CONDITIONS OF  ANY KIND, either  express or implied.  See  the License
sl@0:  * for the specific language governing permissions  and limitations under
sl@0:  * the License.
sl@0:  * 
sl@0:  **************************************************************************/
sl@0: 
sl@0: // expand _TEST_EXPORT macros
sl@0: #define _RWSTD_TEST_SRC
sl@0: #include <testdefs.h>
sl@0: #include <file.h>
sl@0: 
sl@0: #if defined __linux__
sl@0:    // on Linux define _XOPEN_SOURCE to get CODESET defined in <langinfo.h>
sl@0: #  define _XOPEN_SOURCE   500   /* Single Unix conformance */
sl@0:    // bring __int32_t into scope (otherwise <wctype.h> fails to compile)
sl@0: #  include <sys/types.h>
sl@0: #endif   // __linux__
sl@0: 
sl@0: #include <fcntl.h>
sl@0: #include <sys/stat.h>
sl@0: 
sl@0: #if (!defined  (_WIN32) && !defined (_WIN64)) || defined (__SYMBIAN32__)
sl@0: #  include <langinfo.h>   // for CODESET
sl@0: #  include <unistd.h>
sl@0: #else
sl@0: #  include <io.h>
sl@0: #endif
sl@0: 
sl@0: #include <assert.h>   // for assert
sl@0: #include <errno.h>    // for errno
sl@0: #include <locale.h>   // for LC_XXX macros
sl@0: #include <stdio.h>    // for sprintf, ...
sl@0: #include <stdlib.h>   // for free, malloc, realloc
sl@0: #include <string.h>   // for strcat, strcpy, strlen, ...
sl@0: #include <ctype.h>
sl@0: #include <wchar.h>    // for wcslen, ...
sl@0: 
sl@0: 
sl@0: #ifndef PATH_MAX
sl@0: #  define PATH_MAX   1024
sl@0: #endif
sl@0: 
sl@0: #ifndef P_tmpdir
sl@0: #  define P_tmpdir "/tmp/"
sl@0: #endif
sl@0: 
sl@0: #ifndef _RWSTD_NO_PURE_C_HEADERS
sl@0: 
sl@0: IMPORT_C int mkstemp (char*);
sl@0: 
sl@0: #endif   // _RWSTD_NO_PURE_C_HEADERS
sl@0: 
sl@0: // write `str' using symbolic names from the Portable Character Set (PCS)
sl@0: // or using the <U00XX> notations for narrow characters outside that set
sl@0: // if (0 == str), writes out the CHARMAP section of the locale definition
sl@0: // file for the Portable Character Set (in POSIX-compliant format) 
sl@0: _TEST_EXPORT void pcs_write (void *fpv, const char *str)
sl@0: {
sl@0:     FILE* const fp = _RWSTD_STATIC_CAST (FILE*, fpv);
sl@0: 
sl@0:     // ASCII (ISO-646) character map definition
sl@0:     static const char* charmap[] = {
sl@0:         "<NUL>", "<SOH>", "<STX>", "<ETX>", "<EOT>", "<ENQ>", "<ACK>", "<BEL>",
sl@0:         "<backspace>",
sl@0:         "<tab>",
sl@0:         "<newline>",
sl@0:         "<vertical-tab>",
sl@0:         "<form-feed>",
sl@0:         "<carriage-return>",
sl@0:         "<SO>", "<SI>", "<DLE>", "<DC1>", "<DC2>", "<DC3>", "<DC4>", "<NAK>",
sl@0:         "<SYN>","<ETB>", "<CAN>", "<EM>", "<SUB>", "<ESC>", "<IS4>", "<IS3>",
sl@0:         "<IS2>", "<IS1>",
sl@0:         "<space>",
sl@0:         /* ! */ "<exclamation-mark>",
sl@0:         /* " */ "<quotation-mark>",
sl@0:         /* # */ "<number-sign>",
sl@0:         /* $ */ "<dollar-sign>",
sl@0:         /* % */ "<percent-sign>",
sl@0:         /* & */ "<ampersand>",
sl@0:         /* ' */ "<apostrophe>",
sl@0:         /* ( */ "<left-parenthesis>",
sl@0:         /* ) */ "<right-parenthesis>",
sl@0:         /* * */ "<asterisk>",
sl@0:         /* + */ "<plus-sign>",
sl@0:         /* , */ "<comma>",
sl@0:         /* - */ "<hyphen>",
sl@0:         /* . */ "<period>",
sl@0:         /* / */ "<slash>",
sl@0:         /* 0 */ "<zero>",
sl@0:         /* 1 */ "<one>",
sl@0:         /* 2 */ "<two>",
sl@0:         /* 3 */ "<three>",
sl@0:         /* 4 */ "<four>",
sl@0:         /* 5 */ "<five>",
sl@0:         /* 6 */ "<six>",
sl@0:         /* 7 */ "<seven>",
sl@0:         /* 8 */ "<eight>",
sl@0:         /* 9 */ "<nine>",
sl@0:         /* : */ "<colon>",
sl@0:         /* ; */ "<semicolon>",
sl@0:         /* < */ "<less-than-sign>",
sl@0:         /* = */ "<equals-sign>",
sl@0:         /* > */ "<greater-than-sign>",
sl@0:         /* ? */ "<question-mark>",
sl@0:         /* @ */ "<commercial-at>",
sl@0:         "<A>", "<B>", "<C>", "<D>", "<E>", "<F>", "<G>", "<H>", "<I>", "<J>",
sl@0:         "<K>", "<L>", "<M>", "<N>", "<O>", "<P>", "<Q>", "<R>", "<S>", "<T>",
sl@0:         "<U>", "<V>", "<W>", "<X>", "<Y>", "<Z>",
sl@0:         /* [ */ "<left-square-bracket>",
sl@0:         /* \ */ "<backslash>",
sl@0:         /* ] */ "<right-square-bracket>",
sl@0:         /* ^ */ "<circumflex>",
sl@0:         /* _ */ "<underscore>",
sl@0:         /* ` */ "<grave-accent>",
sl@0:         "<a>", "<b>", "<c>", "<d>", "<e>", "<f>", "<g>", "<h>", "<i>", "<j>",
sl@0:         "<k>", "<l>", "<m>", "<n>", "<o>", "<p>", "<q>", "<r>", "<s>", "<t>",
sl@0:         "<u>", "<v>", "<w>", "<x>", "<y>", "<z>",
sl@0:         /* { */ "<left-brace>",
sl@0:         /* | */ "<vertical-line>",
sl@0:         /* } */ "<right-brace>",
sl@0:         /* ~ */ "<tilde>",
sl@0:         "<DEL>"
sl@0:     };
sl@0: 
sl@0:     if (str) {
sl@0:         // write out `str' using the charmap above
sl@0:         for (; *str; ++str) {
sl@0:             const unsigned char uc = _RWSTD_STATIC_CAST (unsigned char, *str);
sl@0: 
sl@0:             if (uc < sizeof charmap / sizeof *charmap)
sl@0:                 fprintf (fp, "%s", charmap [uc]);
sl@0:             else
sl@0:                 fprintf (fp, "<U%04X>", uc);
sl@0:         }
sl@0:     }
sl@0:     else {
sl@0: 
sl@0: #if !defined (_WIN32) && !defined (_WIN64)
sl@0:         const char* const codeset = nl_langinfo (CODESET);
sl@0: #else
sl@0:         // FIXME: determine the current code page
sl@0:         const char* const codeset = "UTF-8";
sl@0: #endif   // _WIN{32,64}
sl@0: 
sl@0:         fprintf (fp, "<code_set_name> \"%s\"\n", codeset);
sl@0:         fprintf (fp, "<mb_cur_max> 1\n");
sl@0:         fprintf (fp, "<mb_cur_min> 1\n");
sl@0: 
sl@0:         fprintf (fp, "CHARMAP\n");
sl@0: 
sl@0:         // write out the charmap above
sl@0:         for (unsigned i = 0; i != sizeof charmap / sizeof *charmap; ++i) {
sl@0:             fprintf (fp, "%s \\x%02x\n", charmap [i], i);
sl@0:         }
sl@0: 
sl@0:         // write out duplicate symbolic names to prevent warnings
sl@0:         fprintf (fp, "<alert> \\x%02x\n", '\a');
sl@0:         fprintf (fp, "<hyphen-minus> \\x%02x\n", '-');
sl@0:         fprintf (fp, "<full-stop> \\x%02x\n", '.');
sl@0:         fprintf (fp, "<solidus> \\x%02x\n", '/');
sl@0:         fprintf (fp, "<reverse-solidus> \\x%02x\n", '\\');
sl@0:         fprintf (fp, "<circumflex-accent> \\x%02x\n", '^');
sl@0:         fprintf (fp, "<underline> \\x%02x\n", '_');
sl@0:         fprintf (fp, "<low-line> \\x%02x\n", '_');
sl@0:         fprintf (fp, "<left-curly-bracket> \\x%02x\n", '{');
sl@0:         fprintf (fp, "<right-curly-bracket> \\x%02x\n", '}');
sl@0: 
sl@0:         fprintf (fp, "END CHARMAP\n");
sl@0:     }
sl@0: }
sl@0: 
sl@0: 
sl@0: _TEST_EXPORT
sl@0: const char* rw_tmpnam (char *buf)
sl@0: {
sl@0: #ifndef _RWSTD_NO_MKSTEMP
sl@0: #  define TMP_TEMPLATE      "tmpfile-XXXXXX"
sl@0: 
sl@0:     if (!buf) {
sl@0:         static char fname_buf [sizeof (P_tmpdir) + sizeof (TMP_TEMPLATE)];
sl@0: 
sl@0:         buf = fname_buf;
sl@0:         *buf = '\0';
sl@0:     }
sl@0: 
sl@0:     if ('\0' == *buf) {
sl@0:         // copy the template to the buffer; make sure there is exactly
sl@0:         // one path separator character between P_tmpdir and the file
sl@0:         // name template (it doesn't really matter how many there are
sl@0:         // as long as it's at least one, but one looks better than two
sl@0:         // in diagnostic messages)
sl@0:         size_t len = sizeof (P_tmpdir) - 1;
sl@0: 
sl@0:         memcpy (buf, P_tmpdir, len);
sl@0:         if (_RWSTD_PATH_SEP != buf [len - 1])
sl@0:             buf [len++] = _RWSTD_PATH_SEP;
sl@0: 
sl@0:         memcpy (buf + len, TMP_TEMPLATE, sizeof TMP_TEMPLATE);
sl@0:     }
sl@0: 
sl@0:     // prevent annoying glibc warnings (issued by the linker):
sl@0:     // the use of `tmpnam' is dangerous, better use `mkstemp'
sl@0: 
sl@0:     const int fd = mkstemp (buf);
sl@0: 
sl@0:     if (-1 == fd) {
sl@0:         fprintf (stderr, "%s:%d: mkstemp(\"%s\") failed: %s\n",
sl@0:                  __FILE__, __LINE__, buf, strerror (errno));
sl@0:         return 0;
sl@0:     }
sl@0: 
sl@0:     close (fd);
sl@0: 
sl@0:     const char* const fname = buf;
sl@0: 
sl@0: #  undef TMP_TEMPLATE
sl@0: #else   // if defined (_RWSTD_NO_MKSTEMP)
sl@0: 
sl@0: #  if defined (_WIN32) || defined (_WIN64)
sl@0: 
sl@0:     // create a temporary file name
sl@0:     char* fname = tempnam (P_tmpdir, ".rwtest-tmp");
sl@0: 
sl@0:     if (fname) {
sl@0: 
sl@0:         static char tmpbuf [256];
sl@0: 
sl@0:         if (0 == buf)
sl@0:             buf = tmpbuf;
sl@0: 
sl@0:         _RWSTD_ASSERT (strlen (fname) < sizeof (tmpbuf));
sl@0: 
sl@0:         // copy the generated temporary file name to the provided buffer
sl@0:         strcpy (buf, fname);
sl@0: 
sl@0:         // free the storage allocated by tempnam()
sl@0:         free (fname);
sl@0:         fname = buf;
sl@0:     }
sl@0:     else {
sl@0:         fprintf (stderr, "%s:%d: tempnam(\"%s\", \"%s\") failed: %s\n",
sl@0:                  __FILE__, __LINE__,
sl@0:                  P_tmpdir, ".rwtest-tmp", strerror (errno));
sl@0:     }
sl@0: 
sl@0: #  else
sl@0: #    if defined (__hpux) && defined (_RWSTD_REENTRANT)
sl@0: 
sl@0:     // on HP-UX, in reentrant mode, tmpnam(0) fails by design
sl@0: 
sl@0:     if (!buf) {
sl@0:         static char tmpbuf [L_tmpnam];
sl@0:         buf = tmpbuf;
sl@0:         *buf = '\0';
sl@0:     }
sl@0: 
sl@0: #    endif   // __hpux && _REENTRANT
sl@0: 
sl@0:     const char* const fname = tmpnam (buf);
sl@0: 
sl@0:     if (!fname)
sl@0:         fprintf (stderr, "%s:%d: tmpnam(\"%s\") failed: %s\n",
sl@0:                  __FILE__, __LINE__, buf, strerror (errno));
sl@0: 
sl@0: #  endif   // _WIN{32,64}
sl@0: #endif   // _RWSTD_NO_MKSTEMP
sl@0: 
sl@0:     return fname;
sl@0: }
sl@0: 
sl@0: 
sl@0: _TEST_EXPORT
sl@0: size_t rw_fsize (const char *fname)
sl@0: {
sl@0: #ifdef __SYMBIAN32__
sl@0: 
sl@0:     struct stat sb;
sl@0:     
sl@0:     #ifdef __ARMCC__
sl@0:     #pragma diag_suppress 63
sl@0:     #endif
sl@0:     if (-1 == stat (fname, &sb))
sl@0:         return _RWSTD_SIZE_MAX;
sl@0:        
sl@0: 
sl@0:     return sb.st_size;
sl@0: #elif defined (_WIN32) || defined (_WIN64)
sl@0: 
sl@0:     // note: both method of obtaining the size of a file
sl@0:     // just written by a process may fail (i.e., the size
sl@0:     // will be 0)
sl@0: 
sl@0: #  if 1
sl@0: 
sl@0:     struct _stat sb;
sl@0: 
sl@0:     if (-1 == _stat (fname, &sb))
sl@0:         return _RWSTD_SIZE_MAX;
sl@0: 
sl@0:     return sb.st_size;
sl@0: 
sl@0: #  else
sl@0: 
sl@0:     // #include <windows.h> for CreateFile() and GetFileSize()
sl@0:     const HANDLE hfile =
sl@0:         CreateFile (fname,
sl@0:                     GENERIC_READ,
sl@0:                     0,                     // dwShareMode,
sl@0:                     0,                     // lpSecurityAttributes,
sl@0:                     OPEN_EXISTING,         // dwCreationDisposition,
sl@0:                     FILE_ATTRIBUTE_NORMAL, // dwFlagsAndAttributes,
sl@0:                     0);                    // hTemplateFile
sl@0: 
sl@0:     if (INVALID_HANDLE_VALUE == hfile)
sl@0:         return _RWSTD_SIZE_MAX;
sl@0: 
sl@0:     const size_t size = GetFileSize (hfile, 0);
sl@0: 
sl@0:     CloseHandle (hfile);
sl@0: 
sl@0:     return size;
sl@0: 
sl@0: #  endif   // 0/1
sl@0: 
sl@0: #else   // if !defined (_WIN{32,64})
sl@0: 
sl@0:     struct stat sb;
sl@0: 
sl@0:     if (stat (fname, &sb) == -1)
sl@0:         return _RWSTD_SIZE_MAX;
sl@0: 
sl@0:     return sb.st_size;
sl@0: 
sl@0: #endif   // _WIN{32,64}
sl@0: 
sl@0: }
sl@0: 
sl@0: 
sl@0: _TEST_EXPORT
sl@0: void* rw_fread (const char *fname,
sl@0:                 size_t     *size   /* = 0 */,
sl@0:                 const char *mode   /* = "r" */)
sl@0: {
sl@0:     // buffer and size supplied by the user
sl@0:     static char*  usrbuf = 0;
sl@0:     static size_t usrsize = 0;
sl@0: 
sl@0:     // when called with 0 file name and non-0 size, set the static
sl@0:     // local buffer for the functions to use in subsequent calls
sl@0:     // with non-0 `fname' instead of dynamically allocating a new
sl@0:     // buffer
sl@0:     if (!fname && size) {
sl@0: 
sl@0:         char* const oldbuf = usrbuf;
sl@0: 
sl@0:         usrbuf  = _RWSTD_CONST_CAST (char*, mode);
sl@0:         usrsize = usrbuf ? *size : 0;
sl@0: 
sl@0:         return oldbuf;
sl@0:     }
sl@0: 
sl@0:     static char   buffer [1024];
sl@0:     static char*  buf     = usrbuf ? usrbuf : buffer;
sl@0:     static size_t bufsize = usrbuf ? usrsize : sizeof buffer;
sl@0: 
sl@0:     // open the file in the specified mode
sl@0:     FILE* const fp = fopen (fname, mode);
sl@0: 
sl@0:     if (!fp)
sl@0:         return 0;
sl@0: 
sl@0:     for (char *bufend = buf; ; ) {
sl@0:         // compute the total number of bytes read from the file so far
sl@0:         // and the number of bytes that are still available in the buffer
sl@0:         const size_t bytes_read  = size_t (bufend - buf);
sl@0:         const size_t bytes_avail = bufsize - bytes_read;
sl@0: 
sl@0:         // try to read the contents of the file into the buffer
sl@0:         const size_t nbytes = fread (bufend, 1, bytes_avail, fp);
sl@0: 
sl@0:         if (0 == nbytes) {
sl@0:             *bufend = '\0';
sl@0: 
sl@0:             // store the number of bytes read
sl@0:             if (size)
sl@0:                 *size = bytes_read;
sl@0: 
sl@0:             break;
sl@0:         }
sl@0: 
sl@0:         if (nbytes == bytes_avail) {
sl@0: 
sl@0:             // do not grow user-specified buffer
sl@0:             if (buf == usrbuf)
sl@0:                 break;
sl@0: 
sl@0:             const size_t newsize = (bufsize + 1) * 2;
sl@0: 
sl@0:             // increase the size of the buffer and continue reading
sl@0:             char *tmp = new char [newsize];
sl@0:             memcpy (tmp, buf, bufsize);
sl@0: 
sl@0:             // deallocate buffer only if it's been
sl@0:             // previously dynamically allocated
sl@0:             if (buf != buffer)
sl@0:                 delete[] buf;
sl@0: 
sl@0:             bufsize = newsize;
sl@0:             bufend  = tmp + bytes_read;
sl@0:             buf     = tmp;
sl@0:         }
sl@0: 
sl@0:         bufend += nbytes;
sl@0:     }
sl@0: 
sl@0:     fclose (fp);
sl@0: 
sl@0:     return buf;
sl@0: }
sl@0: 
sl@0: 
sl@0: _TEST_EXPORT
sl@0: size_t rw_fwrite (const char *fname,
sl@0:                   const void *buf,
sl@0:                   size_t      size /* = -1 */,
sl@0:                   const char *mode /* = "w" */)
sl@0: {
sl@0:     FILE *fp = 0;
sl@0: 
sl@0:     if (buf)
sl@0:         fp = fopen (fname, mode);
sl@0:     else {
sl@0:         remove (fname);
sl@0:         return 0;
sl@0:     }
sl@0: 
sl@0:     if (!fp)
sl@0:         return size_t (-1);
sl@0: 
sl@0:     if (size_t (-1) == size)
sl@0:         size = strlen (_RWSTD_STATIC_CAST (const char*, buf));
sl@0: 
sl@0:     // fwrite() returns the number of elements successfully written
sl@0:     // set it up so that the number of elements == the number of bytes
sl@0:     const size_t nbytes = fwrite (buf, 1 /* byte */, size, fp);
sl@0: 
sl@0:     fclose (fp);
sl@0: 
sl@0:     return nbytes;
sl@0: }