utils2.c

Go to the documentation of this file.

/*====================================================================*
 -  Copyright (C) 2001 Leptonica.  All rights reserved.
 -
 -  Redistribution and use in source and binary forms, with or without
 -  modification, are permitted provided that the following conditions
 -  are met:
 -  1. Redistributions of source code must retain the above copyright
 -     notice, this list of conditions and the following disclaimer.
 -  2. Redistributions in binary form must reproduce the above
 -     copyright notice, this list of conditions and the following
 -     disclaimer in the documentation and/or other materials
 -     provided with the distribution.
 -
 -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 -  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 -  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 -  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ANY
 -  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 -  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 -  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 -  OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 -  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 -  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *====================================================================*/
 
#ifdef HAVE_CONFIG_H
#include <config_auto.h>
#endif  /* HAVE_CONFIG_H */
 
#ifdef _MSC_VER
#include <process.h>
#include <direct.h>
#define getcwd _getcwd  /* fix MSVC warning */
#else
#include <unistd.h>
#endif   /* _MSC_VER */
 
#ifdef _WIN32
#include <windows.h>
#include <fcntl.h>     /* _O_CREAT, ... */
#include <io.h>        /* _open */
#include <sys/stat.h>  /* _S_IREAD, _S_IWRITE */
#else
#include <sys/stat.h>  /* for stat, mkdir(2) */
#include <sys/types.h>
#endif
 
#ifdef __APPLE__
#include <unistd.h>
#include <errno.h>
#endif
 
#include <string.h>
#include <stddef.h>
#include "allheaders.h"
 
 
/*--------------------------------------------------------------------*
 *                       Safe string operations                       *
 *--------------------------------------------------------------------*/
char *
stringNew(const char  *src)
{
l_int32  len;
char    *dest;
 
    PROCNAME("stringNew");
 
    if (!src) {
        L_WARNING("src not defined\n", procName);
        return NULL;
    }
 
    len = strlen(src);
    if ((dest = (char *)LEPT_CALLOC(len + 1, sizeof(char))) == NULL)
        return (char *)ERROR_PTR("dest not made", procName, NULL);
 
    stringCopy(dest, src, len);
    return dest;
}
 
 
l_ok
stringCopy(char        *dest,
           const char  *src,
           l_int32      n)
{
l_int32  i;
 
    PROCNAME("stringCopy");
 
    if (!dest)
        return ERROR_INT("dest not defined", procName, 1);
    if (!src || n < 1)
        return 0;
 
        /* Implementation of strncpy that valgrind doesn't complain about */
    for (i = 0; i < n && src[i] != '\0'; i++)
        dest[i] = src[i];
    for (; i < n; i++)
        dest[i] = '\0';
    return 0;
}
 
 
char *
stringCopySegment(const char  *src,
                  l_int32      start,
                  l_int32      nbytes)
{
char    *dest;
l_int32  len;
 
    PROCNAME("stringCopySegment");
 
    if (!src)
        return (char *)ERROR_PTR("src not defined", procName, NULL);
    len = strlen(src);
    if (start < 0 || start > len - 1)
        return (char *)ERROR_PTR("invalid start", procName, NULL);
    if (nbytes <= 0)  /* copy to the end */
        nbytes = len - start;
    if (start + nbytes > len)  /* truncate to the end */
        nbytes = len - start;
    if ((dest = (char *)LEPT_CALLOC(nbytes + 1, sizeof(char))) == NULL)
        return (char *)ERROR_PTR("dest not made", procName, NULL);
    stringCopy(dest, src + start, nbytes);
    return dest;
}
 
 
l_ok
stringReplace(char       **pdest,
              const char  *src)
{
    PROCNAME("stringReplace");
 
    if (!pdest)
        return ERROR_INT("pdest not defined", procName, 1);
 
    if (*pdest)
        LEPT_FREE(*pdest);
 
    if (src)
        *pdest = stringNew(src);
    else
        *pdest = NULL;
    return 0;
}
 
 
l_int32
stringLength(const char  *src,
             size_t       size)
{
l_int32  i;
 
    PROCNAME("stringLength");
 
    if (!src)
        return ERROR_INT("src not defined", procName, 0);
    if (size < 1)
        return 0;
 
    for (i = 0; i < size; i++) {
        if (src[i] == '\0')
            return i;
    }
    return size;  /* didn't find a NUL byte */
}
 
 
l_int32
stringCat(char        *dest,
          size_t       size,
          const char  *src)
{
l_int32  i, n;
l_int32  lendest, lensrc;
 
    PROCNAME("stringCat");
 
    if (!dest)
        return ERROR_INT("dest not defined", procName, -1);
    if (size < 1)
        return ERROR_INT("size < 1; too small", procName, -1);
    if (!src)
        return 0;
 
    lendest = stringLength(dest, size);
    if (lendest == size)
        return ERROR_INT("no terminating nul byte", procName, -1);
    lensrc = stringLength(src, size);
    if (lensrc == 0)
        return 0;
    n = (lendest + lensrc > size - 1 ? 0 : lensrc);
    if (n < 1)
        return ERROR_INT("dest too small for append", procName, -1);
 
    for (i = 0; i < n; i++)
        dest[lendest + i] = src[i];
    dest[lendest + n] = '\0';
    return n;
}
 
 
char *
stringConcatNew(const char  *first, ...)
{
size_t       len;
char        *result, *ptr;
const char  *arg;
va_list      args;
 
    if (!first) return NULL;
 
        /* Find the length of the output string */
    va_start(args, first);
    len = strlen(first);
    while ((arg = va_arg(args, const char *)) != NULL)
        len += strlen(arg);
    va_end(args);
    result = (char *)LEPT_CALLOC(len + 1, sizeof(char));
 
        /* Concatenate the args */
    va_start(args, first);
    ptr = result;
    arg = first;
    while (*arg)
        *ptr++ = *arg++;
    while ((arg = va_arg(args, const char *)) != NULL) {
        while (*arg)
            *ptr++ = *arg++;
    }
    va_end(args);
    return result;
}
 
 
char *
stringJoin(const char  *src1,
           const char  *src2)
{
char    *dest;
l_int32  srclen1, srclen2, destlen;
 
    PROCNAME("stringJoin");
 
    srclen1 = (src1) ? strlen(src1) : 0;
    srclen2 = (src2) ? strlen(src2) : 0;
    destlen = srclen1 + srclen2 + 3;
 
    if ((dest = (char *)LEPT_CALLOC(destlen, sizeof(char))) == NULL)
        return (char *)ERROR_PTR("calloc fail for dest", procName, NULL);
 
    if (src1)
        stringCat(dest, destlen, src1);
    if (src2)
        stringCat(dest, destlen, src2);
    return dest;
}
 
 
l_ok
stringJoinIP(char       **psrc1,
             const char  *src2)
{
char  *tmpstr;
 
    PROCNAME("stringJoinIP");
 
    if (!psrc1)
        return ERROR_INT("&src1 not defined", procName, 1);
 
    tmpstr = stringJoin(*psrc1, src2);
    LEPT_FREE(*psrc1);
    *psrc1 = tmpstr;
    return 0;
}
 
 
char *
stringReverse(const char  *src)
{
char    *dest;
l_int32  i, len;
 
    PROCNAME("stringReverse");
 
    if (!src)
        return (char *)ERROR_PTR("src not defined", procName, NULL);
    len = strlen(src);
    if ((dest = (char *)LEPT_CALLOC(len + 1, sizeof(char))) == NULL)
        return (char *)ERROR_PTR("calloc fail for dest", procName, NULL);
    for (i = 0; i < len; i++)
        dest[i] = src[len - 1 - i];
 
    return dest;
}
 
 
char *
strtokSafe(char        *cstr,
           const char  *seps,
           char       **psaveptr)
{
char     nextc;
char    *start, *substr;
l_int32  istart, i, j, nchars;
 
    PROCNAME("strtokSafe");
 
    if (!seps)
        return (char *)ERROR_PTR("seps not defined", procName, NULL);
    if (!psaveptr)
        return (char *)ERROR_PTR("&saveptr not defined", procName, NULL);
 
    if (!cstr) {
        start = *psaveptr;
    } else {
        start = cstr;
        *psaveptr = NULL;
    }
    if (!start)  /* nothing to do */
        return NULL;
 
        /* First time, scan for the first non-sep character */
    istart = 0;
    if (cstr) {
        for (istart = 0;; istart++) {
            if ((nextc = start[istart]) == '\0') {
                *psaveptr = NULL;  /* in case caller doesn't check ret value */
                return NULL;
            }
            if (!strchr(seps, nextc))
                break;
        }
    }
 
        /* Scan through, looking for a sep character; if none is
         * found, 'i' will be at the end of the string. */
    for (i = istart;; i++) {
        if ((nextc = start[i]) == '\0')
            break;
        if (strchr(seps, nextc))
            break;
    }
 
        /* Save the substring */
    nchars = i - istart;
    substr = (char *)LEPT_CALLOC(nchars + 1, sizeof(char));
    stringCopy(substr, start + istart, nchars);
 
        /* Look for the next non-sep character.
         * If this is the last substring, return a null saveptr. */
    for (j = i;; j++) {
        if ((nextc = start[j]) == '\0') {
            *psaveptr = NULL;  /* no more non-sep characters */
            break;
        }
        if (!strchr(seps, nextc)) {
            *psaveptr = start + j;  /* start here on next call */
                break;
        }
    }
 
    return substr;
}
 
 
l_ok
stringSplitOnToken(char        *cstr,
                   const char  *seps,
                   char       **phead,
                   char       **ptail)
{
char  *saveptr;
 
    PROCNAME("stringSplitOnToken");
 
    if (!phead)
        return ERROR_INT("&head not defined", procName, 1);
    if (!ptail)
        return ERROR_INT("&tail not defined", procName, 1);
    *phead = *ptail = NULL;
    if (!cstr)
        return ERROR_INT("cstr not defined", procName, 1);
    if (!seps)
        return ERROR_INT("seps not defined", procName, 1);
 
    *phead = strtokSafe(cstr, seps, &saveptr);
    if (saveptr)
        *ptail = stringNew(saveptr);
    return 0;
}
 
 
/*--------------------------------------------------------------------*
 *                       Find and replace procs                       *
 *--------------------------------------------------------------------*/
l_ok
stringCheckForChars(const char  *src,
                    const char  *chars,
                    l_int32     *pfound)
{
char     ch;
l_int32  i, n;
 
    PROCNAME("stringCheckForChars");
 
    if (!pfound)
        return ERROR_INT("&found not defined", procName, 1);
    *pfound = FALSE;
    if (!src || !chars)
        return ERROR_INT("src and chars not both defined", procName, 1);
 
    n = strlen(src);
    for (i = 0; i < n; i++) {
        ch = src[i];
        if (strchr(chars, ch)) {
            *pfound = TRUE;
            break;
        }
    }
    return 0;
}
 
 
char *
stringRemoveChars(const char  *src,
                  const char  *remchars)
{
char     ch;
char    *dest;
l_int32  nsrc, i, k;
 
    PROCNAME("stringRemoveChars");
 
    if (!src)
        return (char *)ERROR_PTR("src not defined", procName, NULL);
    if (!remchars)
        return stringNew(src);
 
    if ((dest = (char *)LEPT_CALLOC(strlen(src) + 1, sizeof(char))) == NULL)
        return (char *)ERROR_PTR("dest not made", procName, NULL);
    nsrc = strlen(src);
    for (i = 0, k = 0; i < nsrc; i++) {
        ch = src[i];
        if (!strchr(remchars, ch))
            dest[k++] = ch;
    }
 
    return dest;
}
 
 
char *
stringReplaceEachSubstr(const char  *src,
                        const char  *sub1,
                        const char  *sub2,
                        l_int32     *pcount)
{
size_t  datalen;
 
    PROCNAME("stringReplaceEachSubstr");
 
    if (pcount) *pcount = 0;
    if (!src || !sub1 || !sub2)
        return (char *)ERROR_PTR("src, sub1, sub2 not all defined",
                                 procName, NULL);
 
    if (strlen(sub2) > 0) {
        return (char *)arrayReplaceEachSequence(
                               (const l_uint8 *)src, strlen(src),
                               (const l_uint8 *)sub1, strlen(sub1),
                               (const l_uint8 *)sub2, strlen(sub2),
                               &datalen, pcount);
    } else {  /* empty replacement string; removal only */
        return (char *)arrayReplaceEachSequence(
                               (const l_uint8 *)src, strlen(src),
                               (const l_uint8 *)sub1, strlen(sub1),
                               NULL, 0, &datalen, pcount);
    }
}
 
 
char *
stringReplaceSubstr(const char  *src,
                    const char  *sub1,
                    const char  *sub2,
                    l_int32     *ploc,
                    l_int32     *pfound)
{
const char  *ptr;
char        *dest;
l_int32      nsrc, nsub1, nsub2, len, npre, loc;
 
    PROCNAME("stringReplaceSubstr");
 
    if (pfound) *pfound = 0;
    if (!src || !sub1 || !sub2)
        return (char *)ERROR_PTR("src, sub1, sub2 not all defined",
                                 procName, NULL);
 
    if (ploc)
        loc = *ploc;
    else
        loc = 0;
    if (!strcmp(sub1, sub2))
        return stringNew(src);
    if ((ptr = strstr(src + loc, sub1)) == NULL)
        return stringNew(src);
    if (pfound) *pfound = 1;
 
    nsrc = strlen(src);
    nsub1 = strlen(sub1);
    nsub2 = strlen(sub2);
    len = nsrc + nsub2 - nsub1;
    if ((dest = (char *)LEPT_CALLOC(len + 1, sizeof(char))) == NULL)
        return (char *)ERROR_PTR("dest not made", procName, NULL);
    npre = ptr - src;
    memcpy(dest, src, npre);
    strcpy(dest + npre, sub2);
    strcpy(dest + npre + nsub2, ptr + nsub1);
    if (ploc) *ploc = npre + nsub2;
    return dest;
}
 
 
L_DNA *
stringFindEachSubstr(const char  *src,
                     const char  *sub)
{
    PROCNAME("stringFindEachSubstr");
 
    if (!src || !sub)
        return (L_DNA *)ERROR_PTR("src, sub not both defined", procName, NULL);
 
    return arrayFindEachSequence((const l_uint8 *)src, strlen(src),
                                 (const l_uint8 *)sub, strlen(sub));
}
 
 
l_int32
stringFindSubstr(const char  *src,
                 const char  *sub,
                 l_int32     *ploc)
{
const char *ptr;
 
    PROCNAME("stringFindSubstr");
 
    if (ploc) *ploc = -1;
    if (!src || !sub)
        return ERROR_INT("src and sub not both defined", procName, 0);
    if (strlen(sub) == 0)
        return ERROR_INT("substring length 0", procName, 0);
    if (strlen(src) == 0)
        return 0;
 
    if ((ptr = strstr(src, sub)) == NULL)  /* not found */
        return 0;
 
    if (ploc)
        *ploc = ptr - src;
    return 1;
}
 
 
l_uint8 *
arrayReplaceEachSequence(const l_uint8  *datas,
                         size_t          dataslen,
                         const l_uint8  *seq,
                         size_t          seqlen,
                         const l_uint8  *newseq,
                         size_t          newseqlen,
                         size_t         *pdatadlen,
                         l_int32        *pcount)
{
l_uint8  *datad;
size_t    newsize;
l_int32   n, i, j, di, si, index, incr;
L_DNA    *da;
 
    PROCNAME("arrayReplaceEachSequence");
 
    if (pcount) *pcount = 0;
    if (!datas || !seq)
        return (l_uint8 *)ERROR_PTR("datas & seq not both defined",
                                    procName, NULL);
    if (!pdatadlen)
        return (l_uint8 *)ERROR_PTR("&datadlen not defined", procName, NULL);
    *pdatadlen = 0;
 
        /* Identify the locations of the sequence.  If there are none,
         * return a copy of %datas. */
    if ((da = arrayFindEachSequence(datas, dataslen, seq, seqlen)) == NULL) {
        *pdatadlen = dataslen;
        return l_binaryCopy(datas, dataslen);
    }
 
        /* Allocate the output data; insure null termination */
    n = l_dnaGetCount(da);
    if (pcount) *pcount = n;
    if (!newseq) newseqlen = 0;
    newsize = dataslen + n * (newseqlen - seqlen) + 4;
    if ((datad = (l_uint8 *)LEPT_CALLOC(newsize, sizeof(l_uint8))) == NULL) {
        l_dnaDestroy(&da);
        return (l_uint8 *)ERROR_PTR("datad not made", procName, NULL);
    }
 
        /* Replace each sequence instance with a new sequence */
    l_dnaGetIValue(da, 0, &si);
    for (i = 0, di = 0, index = 0; i < dataslen; i++) {
        if (i == si) {
            index++;
            if (index < n) {
                l_dnaGetIValue(da, index, &si);
                incr = L_MIN(seqlen, si - i);  /* amount to remove from datas */
            } else {
                incr = seqlen;
            }
            i += incr - 1;  /* jump over the matched sequence in datas */
            if (newseq) {  /* add new sequence to datad */
                for (j = 0; j < newseqlen; j++)
                    datad[di++] = newseq[j];
            }
        } else {
            datad[di++] = datas[i];
        }
    }
 
    *pdatadlen = di;
    l_dnaDestroy(&da);
    return datad;
}
 
 
L_DNA *
arrayFindEachSequence(const l_uint8  *data,
                      size_t          datalen,
                      const l_uint8  *sequence,
                      size_t          seqlen)
{
l_int32  start, offset, realoffset, found;
L_DNA   *da;
 
    PROCNAME("arrayFindEachSequence");
 
    if (!data || !sequence)
        return (L_DNA *)ERROR_PTR("data & sequence not both defined",
                                  procName, NULL);
 
    da = l_dnaCreate(0);
    start = 0;
    while (1) {
        arrayFindSequence(data + start, datalen - start, sequence, seqlen,
                          &offset, &found);
        if (found == FALSE)
            break;
 
        realoffset = start + offset;
        l_dnaAddNumber(da, realoffset);
        start = realoffset + seqlen;
        if (start >= datalen)
            break;
    }
 
    if (l_dnaGetCount(da) == 0)
        l_dnaDestroy(&da);
    return da;
}
 
 
l_ok
arrayFindSequence(const l_uint8  *data,
                  size_t          datalen,
                  const l_uint8  *sequence,
                  size_t          seqlen,
                  l_int32        *poffset,
                  l_int32        *pfound)
{
l_int32  i, j, found, lastpos;
 
    PROCNAME("arrayFindSequence");
 
    if (poffset) *poffset = 0;
    if (pfound) *pfound = FALSE;
    if (!data || !sequence)
        return ERROR_INT("data & sequence not both defined", procName, 1);
    if (!poffset || !pfound)
        return ERROR_INT("&offset and &found not defined", procName, 1);
 
    lastpos = datalen - seqlen + 1;
    found = FALSE;
    for (i = 0; i < lastpos; i++) {
        for (j = 0; j < seqlen; j++) {
            if (data[i + j] != sequence[j])
                 break;
            if (j == seqlen - 1)
                 found = TRUE;
        }
        if (found == TRUE)
            break;
    }
 
    if (found == TRUE) {
        *poffset = i;
        *pfound = TRUE;
    }
    return 0;
}
 
 
/*--------------------------------------------------------------------*
 *                             Safe realloc                           *
 *--------------------------------------------------------------------*/
void *
reallocNew(void  **pindata,
           size_t  oldsize,
           size_t  newsize)
{
size_t   minsize;
void    *indata;
void    *newdata;
 
    PROCNAME("reallocNew");
 
    if (!pindata)
        return ERROR_PTR("input data not defined", procName, NULL);
    indata = *pindata;
 
    if (newsize == 0) {   /* nonstandard usage */
        if (indata) {
            LEPT_FREE(indata);
            *pindata = NULL;
        }
        return NULL;
    }
 
    if (!indata) {  /* nonstandard usage */
        if ((newdata = (void *)LEPT_CALLOC(1, newsize)) == NULL)
            return ERROR_PTR("newdata not made", procName, NULL);
        return newdata;
    }
 
        /* Standard usage */
    if ((newdata = (void *)LEPT_CALLOC(1, newsize)) == NULL)
        return ERROR_PTR("newdata not made", procName, NULL);
    minsize = L_MIN(oldsize, newsize);
    memcpy(newdata, indata, minsize);
    LEPT_FREE(indata);
    *pindata = NULL;
    return newdata;
}
 
 
/*--------------------------------------------------------------------*
 *                 Read and write between file and memory             *
 *--------------------------------------------------------------------*/
l_uint8 *
l_binaryRead(const char  *filename,
             size_t      *pnbytes)
{
l_uint8  *data;
FILE     *fp;
 
    PROCNAME("l_binaryRead");
 
    if (!pnbytes)
        return (l_uint8 *)ERROR_PTR("pnbytes not defined", procName, NULL);
    *pnbytes = 0;
    if (!filename)
        return (l_uint8 *)ERROR_PTR("filename not defined", procName, NULL);
 
    if ((fp = fopenReadStream(filename)) == NULL)
        return (l_uint8 *)ERROR_PTR("file stream not opened", procName, NULL);
    data = l_binaryReadStream(fp, pnbytes);
    fclose(fp);
    return data;
}
 
 
l_uint8 *
l_binaryReadStream(FILE    *fp,
                   size_t  *pnbytes)
{
l_uint8    *data;
l_int32     seekable, navail, nadd, nread;
L_BBUFFER  *bb;
 
    PROCNAME("l_binaryReadStream");
 
    if (!pnbytes)
        return (l_uint8 *)ERROR_PTR("&nbytes not defined", procName, NULL);
    *pnbytes = 0;
    if (!fp)
        return (l_uint8 *)ERROR_PTR("fp not defined", procName, NULL);
 
        /* Test if the stream is seekable, by attempting to seek to
         * the start of data.  This is a no-op.  If it is seekable, use
         * l_binaryReadSelectStream() to determine the size of the
         * data to be read in advance. */
    seekable = (ftell(fp) == 0) ? 1 : 0;
    if (seekable)
        return l_binaryReadSelectStream(fp, 0, 0, pnbytes);
 
        /* If it is not seekable, use the bbuffer to realloc memory
         * as needed during reading. */
    bb = bbufferCreate(NULL, 4096);
    while (1) {
        navail = bb->nalloc - bb->n;
        if (navail < 4096) {
             nadd = L_MAX(bb->nalloc, 4096);
             bbufferExtendArray(bb, nadd);
        }
        nread = fread((void *)(bb->array + bb->n), 1, 4096, fp);
        bb->n += nread;
        if (nread != 4096) break;
    }
 
        /* Copy the data to a new array sized for the data, because
         * the bbuffer array can be nearly twice the size we need. */
    if ((data = (l_uint8 *)LEPT_CALLOC(bb->n + 1, sizeof(l_uint8))) != NULL) {
        memcpy(data, bb->array, bb->n);
        *pnbytes = bb->n;
    } else {
        L_ERROR("calloc fail for data\n", procName);
    }
 
    bbufferDestroy(&bb);
    return data;
}
 
 
l_uint8 *
l_binaryReadSelect(const char  *filename,
                   size_t       start,
                   size_t       nbytes,
                   size_t      *pnread)
{
l_uint8  *data;
FILE     *fp;
 
    PROCNAME("l_binaryReadSelect");
 
    if (!pnread)
        return (l_uint8 *)ERROR_PTR("pnread not defined", procName, NULL);
    *pnread = 0;
    if (!filename)
        return (l_uint8 *)ERROR_PTR("filename not defined", procName, NULL);
 
    if ((fp = fopenReadStream(filename)) == NULL)
        return (l_uint8 *)ERROR_PTR("file stream not opened", procName, NULL);
    data = l_binaryReadSelectStream(fp, start, nbytes, pnread);
    fclose(fp);
    return data;
}
 
 
l_uint8 *
l_binaryReadSelectStream(FILE    *fp,
                         size_t   start,
                         size_t   nbytes,
                         size_t  *pnread)
{
l_uint8  *data;
size_t    bytesleft, bytestoread, nread, filebytes;
 
    PROCNAME("l_binaryReadSelectStream");
 
    if (!pnread)
        return (l_uint8 *)ERROR_PTR("&nread not defined", procName, NULL);
    *pnread = 0;
    if (!fp)
        return (l_uint8 *)ERROR_PTR("stream not defined", procName, NULL);
 
        /* Verify and adjust the parameters if necessary */
    fseek(fp, 0, SEEK_END);  /* EOF */
    filebytes = ftell(fp);
    fseek(fp, 0, SEEK_SET);
    if (start > filebytes) {
        L_ERROR("start = %zu but filebytes = %zu\n", procName,
                start, filebytes);
        return NULL;
    }
    if (filebytes == 0)  /* start == 0; nothing to read; return null byte */
        return (l_uint8 *)LEPT_CALLOC(1, 1);
    bytesleft = filebytes - start;  /* greater than 0 */
    if (nbytes == 0) nbytes = bytesleft;
    bytestoread = (bytesleft >= nbytes) ? nbytes : bytesleft;
 
        /* Read the data */
    if ((data = (l_uint8 *)LEPT_CALLOC(1, bytestoread + 1)) == NULL)
        return (l_uint8 *)ERROR_PTR("calloc fail for data", procName, NULL);
    fseek(fp, start, SEEK_SET);
    nread = fread(data, 1, bytestoread, fp);
    if (nbytes != nread)
        L_INFO("%zu bytes requested; %zu bytes read\n", procName,
               nbytes, nread);
    *pnread = nread;
    fseek(fp, 0, SEEK_SET);
    return data;
}
 
 
l_ok
l_binaryWrite(const char  *filename,
              const char  *operation,
              const void  *data,
              size_t       nbytes)
{
char   actualOperation[20];
FILE  *fp;
 
    PROCNAME("l_binaryWrite");
 
    if (!filename)
        return ERROR_INT("filename not defined", procName, 1);
    if (!operation)
        return ERROR_INT("operation not defined", procName, 1);
    if (!data)
        return ERROR_INT("data not defined", procName, 1);
    if (nbytes <= 0)
        return ERROR_INT("nbytes must be > 0", procName, 1);
 
    if (strcmp(operation, "w") && strcmp(operation, "a"))
        return ERROR_INT("operation not one of {'w','a'}", procName, 1);
 
        /* The 'b' flag to fopen() is ignored for all POSIX
         * conforming systems.  However, Windows needs the 'b' flag. */
    stringCopy(actualOperation, operation, 2);
    stringCat(actualOperation, 20, "b");
 
    if ((fp = fopenWriteStream(filename, actualOperation)) == NULL)
        return ERROR_INT("stream not opened", procName, 1);
    fwrite(data, 1, nbytes, fp);
    fclose(fp);
    return 0;
}
 
 
size_t
nbytesInFile(const char  *filename)
{
size_t  nbytes;
FILE   *fp;
 
    PROCNAME("nbytesInFile");
 
    if (!filename)
        return ERROR_INT("filename not defined", procName, 0);
    if ((fp = fopenReadStream(filename)) == NULL)
        return ERROR_INT("stream not opened", procName, 0);
    nbytes = fnbytesInFile(fp);
    fclose(fp);
    return nbytes;
}
 
 
size_t
fnbytesInFile(FILE  *fp)
{
l_int64  pos, nbytes;
 
    PROCNAME("fnbytesInFile");
 
    if (!fp)
        return ERROR_INT("stream not open", procName, 0);
 
    pos = ftell(fp);          /* initial position */
    if (pos < 0)
        return ERROR_INT("seek position must be > 0", procName, 0);
    fseek(fp, 0, SEEK_END);   /* EOF */
    nbytes = ftell(fp);
    if (nbytes < 0)
        return ERROR_INT("nbytes is < 0", procName, 0);
    fseek(fp, pos, SEEK_SET);        /* back to initial position */
    return nbytes;
}
 
 
/*--------------------------------------------------------------------*
 *                     Copy and compare in memory                     *
 *--------------------------------------------------------------------*/
l_uint8 *
l_binaryCopy(const l_uint8  *datas,
             size_t          size)
{
l_uint8  *datad;
 
    PROCNAME("l_binaryCopy");
 
    if (!datas)
        return (l_uint8 *)ERROR_PTR("datas not defined", procName, NULL);
 
    if ((datad = (l_uint8 *)LEPT_CALLOC(size + 4, sizeof(l_uint8))) == NULL)
        return (l_uint8 *)ERROR_PTR("datad not made", procName, NULL);
    memcpy(datad, datas, size);
    return datad;
}
 
 
l_ok
l_binaryCompare(const l_uint8  *data1,
                size_t          size1,
                const l_uint8  *data2,
                size_t          size2,
                l_int32        *psame)
{
l_int32  i;
 
    PROCNAME("l_binaryCompare");
 
    if (!psame)
        return ERROR_INT("&same not defined", procName, 1);
    *psame = FALSE;
    if (!data1 || !data2)
        return ERROR_INT("data1 and data2 not both defined", procName, 1);
    if (size1 != size2) return 0;
    for (i = 0; i < size1; i++) {
        if (data1[i] != data2[i])
            return 0;
    }
    *psame = TRUE;
    return 0;
}
 
 
/*--------------------------------------------------------------------*
 *                         File copy operations                       *
 *--------------------------------------------------------------------*/
l_ok
fileCopy(const char  *srcfile,
         const char  *newfile)
{
l_int32   ret;
size_t    nbytes;
l_uint8  *data;
 
    PROCNAME("fileCopy");
 
    if (!srcfile)
        return ERROR_INT("srcfile not defined", procName, 1);
    if (!newfile)
        return ERROR_INT("newfile not defined", procName, 1);
 
    if ((data = l_binaryRead(srcfile, &nbytes)) == NULL)
        return ERROR_INT("data not returned", procName, 1);
    ret = l_binaryWrite(newfile, "w", data, nbytes);
    LEPT_FREE(data);
    return ret;
}
 
 
l_ok
fileConcatenate(const char  *srcfile,
                const char  *destfile)
{
size_t    nbytes;
l_uint8  *data;
 
    PROCNAME("fileConcatenate");
 
    if (!srcfile)
        return ERROR_INT("srcfile not defined", procName, 1);
    if (!destfile)
        return ERROR_INT("destfile not defined", procName, 1);
 
    data = l_binaryRead(srcfile, &nbytes);
    l_binaryWrite(destfile, "a", data, nbytes);
    LEPT_FREE(data);
    return 0;
}
 
 
l_ok
fileAppendString(const char  *filename,
                 const char  *str)
{
FILE  *fp;
 
    PROCNAME("fileAppendString");
 
    if (!filename)
        return ERROR_INT("filename not defined", procName, 1);
    if (!str)
        return ERROR_INT("str not defined", procName, 1);
 
    if ((fp = fopenWriteStream(filename, "a")) == NULL)
        return ERROR_INT("stream not opened", procName, 1);
    fprintf(fp, "%s", str);
    fclose(fp);
    return 0;
}
 
 
/*--------------------------------------------------------------------*
 *                         File split operations                      *
 *--------------------------------------------------------------------*/
l_ok
fileSplitLinesUniform(const char  *filename,
                      l_int32      n,
                      l_int32      save_empty,
                      const char  *rootpath,
                      const char  *ext)
{
l_int32   i, totlines, nlines, index;
size_t    nbytes;
l_uint8  *data;
char     *str;
char      outname[512];
NUMA     *na;
SARRAY   *sa;
 
    PROCNAME("fileSplitLinesUniform");
 
    if (!filename)
        return ERROR_INT("filename not defined", procName, 1);
    if (!rootpath)
        return ERROR_INT("rootpath not defined", procName, 1);
    if (n <= 0)
        return ERROR_INT("n must be > 0", procName, 1);
    if (save_empty != 0 && save_empty != 1)
        return ERROR_INT("save_empty not 0 or 1", procName, 1);
 
        /* Make sarray of lines; the newlines are stripped off */
    if ((data = l_binaryRead(filename, &nbytes)) == NULL)
        return ERROR_INT("data not read", procName, 1);
    sa = sarrayCreateLinesFromString((const char *)data, save_empty);
    LEPT_FREE(data);
    if (!sa)
        return ERROR_INT("sa not made", procName, 1);
    totlines = sarrayGetCount(sa);
    if (n > totlines) {
        sarrayDestroy(&sa);
        L_ERROR("num files = %d > num lines = %d\n", procName, n, totlines);
        return 1;
    }
 
        /* Write n sets of lines to n files, adding the newlines back */
    na = numaGetUniformBinSizes(totlines, n);
    index = 0;
    for (i = 0; i < n; i++) {
        if (ext == NULL)
            snprintf(outname, sizeof(outname), "%s_%d", rootpath, i);
        else
            snprintf(outname, sizeof(outname), "%s_%d%s", rootpath, i, ext);
        numaGetIValue(na, i, &nlines);
        str = sarrayToStringRange(sa, index, nlines, 1);  /* add newlines */
        l_binaryWrite(outname, "w", str, strlen(str));
        LEPT_FREE(str);
        index += nlines;
    }
    numaDestroy(&na);
    sarrayDestroy(&sa);
    return 0;
}
 
 
/*--------------------------------------------------------------------*
 *          Multi-platform functions for opening file streams         *
 *--------------------------------------------------------------------*/
FILE *
fopenReadStream(const char  *filename)
{
char  *fname, *tail;
FILE  *fp;
 
    PROCNAME("fopenReadStream");
 
    if (!filename)
        return (FILE *)ERROR_PTR("filename not defined", procName, NULL);
 
        /* Try input filename */
    fname = genPathname(filename, NULL);
    fp = fopen(fname, "rb");
    LEPT_FREE(fname);
    if (fp) return fp;
 
        /* Else, strip directory and try locally */
    splitPathAtDirectory(filename, NULL, &tail);
    fp = fopen(tail, "rb");
    LEPT_FREE(tail);
 
    if (!fp)
        return (FILE *)ERROR_PTR("file not found", procName, NULL);
    return fp;
}
 
 
FILE *
fopenWriteStream(const char  *filename,
                 const char  *modestring)
{
char  *fname;
FILE  *fp;
 
    PROCNAME("fopenWriteStream");
 
    if (!filename)
        return (FILE *)ERROR_PTR("filename not defined", procName, NULL);
 
    fname = genPathname(filename, NULL);
    fp = fopen(fname, modestring);
    LEPT_FREE(fname);
    if (!fp)
        return (FILE *)ERROR_PTR("stream not opened", procName, NULL);
    return fp;
}
 
 
FILE *
fopenReadFromMemory(const l_uint8  *data,
                    size_t          size)
{
FILE  *fp;
 
    PROCNAME("fopenReadFromMemory");
 
    if (!data)
        return (FILE *)ERROR_PTR("data not defined", procName, NULL);
 
#if HAVE_FMEMOPEN
    if ((fp = fmemopen((void *)data, size, "rb")) == NULL)
        return (FILE *)ERROR_PTR("stream not opened", procName, NULL);
#else  /* write to tmp file */
    L_INFO("work-around: writing to a temp file\n", procName);
  #ifdef _WIN32
    if ((fp = fopenWriteWinTempfile()) == NULL)
        return (FILE *)ERROR_PTR("tmpfile stream not opened", procName, NULL);
  #else
    if ((fp = tmpfile()) == NULL)
        return (FILE *)ERROR_PTR("tmpfile stream not opened", procName, NULL);
  #endif  /*  _WIN32 */
    fwrite(data, 1, size, fp);
    rewind(fp);
#endif  /* HAVE_FMEMOPEN */
 
    return fp;
}
 
 
/*--------------------------------------------------------------------*
 *                Opening a windows tmpfile for writing               *
 *--------------------------------------------------------------------*/
FILE *
fopenWriteWinTempfile(void)
{
#ifdef _WIN32
l_int32  handle;
FILE    *fp;
char    *filename;
 
    PROCNAME("fopenWriteWinTempfile");
 
    if ((filename = l_makeTempFilename()) == NULL) {
        L_ERROR("l_makeTempFilename failed, %s\n", procName, strerror(errno));
        return NULL;
    }
 
    handle = _open(filename, _O_CREAT | _O_RDWR | _O_SHORT_LIVED |
                   _O_TEMPORARY | _O_BINARY, _S_IREAD | _S_IWRITE);
    lept_free(filename);
    if (handle == -1) {
        L_ERROR("_open failed, %s\n", procName, strerror(errno));
        return NULL;
    }
 
    if ((fp = _fdopen(handle, "r+b")) == NULL) {
        L_ERROR("_fdopen failed, %s\n", procName, strerror(errno));
        return NULL;
    }
 
    return fp;
#else
    return NULL;
#endif  /*  _WIN32 */
}
 
 
/*--------------------------------------------------------------------*
 *       Multi-platform functions that avoid C-runtime boundary       *
 *             crossing for applications with Windows DLLs            *
 *--------------------------------------------------------------------*/
/*
 *  Problems arise when pointers to streams and data are passed
 *  between two Windows DLLs that have been generated with different
 *  C runtimes.  To avoid this, leptonica provides wrappers for
 *  several C library calls.
 */
FILE *
lept_fopen(const char  *filename,
           const char  *mode)
{
    PROCNAME("lept_fopen");
 
    if (!filename)
        return (FILE *)ERROR_PTR("filename not defined", procName, NULL);
    if (!mode)
        return (FILE *)ERROR_PTR("mode not defined", procName, NULL);
 
    if (stringFindSubstr(mode, "r", NULL))
        return fopenReadStream(filename);
    else
        return fopenWriteStream(filename, mode);
}
 
 
l_ok
lept_fclose(FILE *fp)
{
    PROCNAME("lept_fclose");
 
    if (!fp)
        return ERROR_INT("stream not defined", procName, 1);
 
    return fclose(fp);
}
 
 
void *
lept_calloc(size_t  nmemb,
            size_t  size)
{
    if (nmemb <= 0 || size <= 0)
        return NULL;
    return LEPT_CALLOC(nmemb, size);
}
 
 
void
lept_free(void *ptr)
{
    if (!ptr) return;
    LEPT_FREE(ptr);
}
 
 
/*--------------------------------------------------------------------*
 *                Multi-platform file system operations               *
 *         [ These only write to /tmp or its subdirectories ]         *
 *--------------------------------------------------------------------*/
l_int32
lept_mkdir(const char  *subdir)
{
char     *dir, *tmpdir;
l_int32   i, n;
l_int32   ret = 0;
SARRAY   *sa;
#ifdef  _WIN32
l_uint32  attributes;
#endif  /* _WIN32 */
 
    PROCNAME("lept_mkdir");
 
    if (!LeptDebugOK) {
        L_INFO("making named temp subdirectory %s is disabled\n",
               procName, subdir);
        return 0;
    }
 
    if (!subdir)
        return ERROR_INT("subdir not defined", procName, 1);
    if ((strlen(subdir) == 0) || (subdir[0] == '.') || (subdir[0] == '/'))
        return ERROR_INT("subdir not an actual subdirectory", procName, 1);
 
    sa = sarrayCreate(0);
    sarraySplitString(sa, subdir, "/");
    n = sarrayGetCount(sa);
    dir = genPathname("/tmp", NULL);
       /* Make sure the tmp directory exists */
#ifndef _WIN32
    ret = mkdir(dir, 0777);
#else
    attributes = GetFileAttributes(dir);
    if (attributes == INVALID_FILE_ATTRIBUTES)
        ret = (CreateDirectory(dir, NULL) ? 0 : 1);
#endif
        /* Make all the subdirectories */
    for (i = 0; i < n; i++) {
        tmpdir = pathJoin(dir, sarrayGetString(sa, i, L_NOCOPY));
#ifndef _WIN32
        ret += mkdir(tmpdir, 0777);
#else
        if (CreateDirectory(tmpdir, NULL) == 0)
            ret += (GetLastError () != ERROR_ALREADY_EXISTS);
#endif
        LEPT_FREE(dir);
        dir = tmpdir;
    }
    LEPT_FREE(dir);
    sarrayDestroy(&sa);
    if (ret > 0)
        L_ERROR("failure to create %d directories\n", procName, ret);
    return ret;
}
 
 
l_int32
lept_rmdir(const char  *subdir)
{
char    *dir, *realdir, *fname, *fullname;
l_int32  exists, ret, i, nfiles;
SARRAY  *sa;
#ifdef _WIN32
char    *newpath;
#endif  /* _WIN32 */
 
    PROCNAME("lept_rmdir");
 
    if (!subdir)
        return ERROR_INT("subdir not defined", procName, 1);
    if ((strlen(subdir) == 0) || (subdir[0] == '.') || (subdir[0] == '/'))
        return ERROR_INT("subdir not an actual subdirectory", procName, 1);
 
        /* Find the temp subdirectory */
    dir = pathJoin("/tmp", subdir);
    if (!dir)
        return ERROR_INT("directory name not made", procName, 1);
    lept_direxists(dir, &exists);
    if (!exists) {  /* fail silently */
        LEPT_FREE(dir);
        return 0;
    }
 
        /* List all the files in that directory */
    if ((sa = getFilenamesInDirectory(dir)) == NULL) {
        L_ERROR("directory %s does not exist!\n", procName, dir);
        LEPT_FREE(dir);
        return 1;
    }
    nfiles = sarrayGetCount(sa);
 
    for (i = 0; i < nfiles; i++) {
        fname = sarrayGetString(sa, i, L_NOCOPY);
        fullname = genPathname(dir, fname);
        remove(fullname);
        LEPT_FREE(fullname);
    }
 
#ifndef _WIN32
    realdir = genPathname("/tmp", subdir);
    ret = rmdir(realdir);
    LEPT_FREE(realdir);
#else
    newpath = genPathname(dir, NULL);
    ret = (RemoveDirectory(newpath) ? 0 : 1);
    LEPT_FREE(newpath);
#endif  /* !_WIN32 */
 
    sarrayDestroy(&sa);
    LEPT_FREE(dir);
    return ret;
}
 
 
void
lept_direxists(const char  *dir,
               l_int32     *pexists)
{
char  *realdir;
 
    if (!pexists) return;
    *pexists = 0;
    if (!dir) return;
    if ((realdir = genPathname(dir, NULL)) == NULL)
        return;
 
#ifndef _WIN32
    {
    struct stat s;
    l_int32 err = stat(realdir, &s);
    if (err != -1 && S_ISDIR(s.st_mode))
        *pexists = 1;
    }
#else  /* _WIN32 */
    {
    l_uint32  attributes;
    attributes = GetFileAttributes(realdir);
    if (attributes != INVALID_FILE_ATTRIBUTES &&
        (attributes & FILE_ATTRIBUTE_DIRECTORY))
        *pexists = 1;
    }
#endif  /* _WIN32 */
 
    LEPT_FREE(realdir);
}
 
 
l_int32
lept_rm_match(const char  *subdir,
              const char  *substr)
{
char    *path, *fname;
char     tempdir[256];
l_int32  i, n, ret;
SARRAY  *sa;
 
    PROCNAME("lept_rm_match");
 
    makeTempDirname(tempdir, sizeof(tempdir), subdir);
    if ((sa = getSortedPathnamesInDirectory(tempdir, substr, 0, 0)) == NULL)
        return ERROR_INT("sa not made", procName, -1);
    n = sarrayGetCount(sa);
    if (n == 0) {
        L_WARNING("no matching files found\n", procName);
        sarrayDestroy(&sa);
        return 0;
    }
 
    ret = 0;
    for (i = 0; i < n; i++) {
        fname = sarrayGetString(sa, i, L_NOCOPY);
        path = genPathname(fname, NULL);
        if (lept_rmfile(path) != 0) {
            L_ERROR("failed to remove %s\n", procName, path);
            ret++;
        }
        LEPT_FREE(path);
    }
    sarrayDestroy(&sa);
    return ret;
}
 
 
l_int32
lept_rm(const char  *subdir,
        const char  *tail)
{
char    *path;
char     newtemp[256];
l_int32  ret;
 
    PROCNAME("lept_rm");
 
    if (!tail || strlen(tail) == 0)
        return ERROR_INT("tail undefined or empty", procName, 1);
 
    if (makeTempDirname(newtemp, sizeof(newtemp), subdir))
        return ERROR_INT("temp dirname not made", procName, 1);
    path = genPathname(newtemp, tail);
    ret = lept_rmfile(path);
    LEPT_FREE(path);
    return ret;
}
 
 
l_int32
lept_rmfile(const char  *filepath)
{
l_int32  ret;
 
    PROCNAME("lept_rmfile");
 
    if (!filepath || strlen(filepath) == 0)
        return ERROR_INT("filepath undefined or empty", procName, 1);
 
#ifndef _WIN32
    ret = remove(filepath);
#else
        /* Set attributes to allow deletion of read-only files */
    SetFileAttributes(filepath, FILE_ATTRIBUTE_NORMAL);
    ret = DeleteFile(filepath) ? 0 : 1;
#endif  /* !_WIN32 */
 
    return ret;
}
 
 
l_int32
lept_mv(const char  *srcfile,
        const char  *newdir,
        const char  *newtail,
        char       **pnewpath)
{
char    *srcpath, *newpath, *dir, *srctail;
char     newtemp[256];
l_int32  ret;
 
    PROCNAME("lept_mv");
 
    if (!srcfile)
        return ERROR_INT("srcfile not defined", procName, 1);
 
        /* Require output pathname to be in /tmp/ or a subdirectory */
    if (makeTempDirname(newtemp, sizeof(newtemp), newdir) == 1)
        return ERROR_INT("newdir not NULL or a subdir of /tmp", procName, 1);
 
        /* Get canonical src pathname */
    splitPathAtDirectory(srcfile, &dir, &srctail);
 
#ifndef _WIN32
    srcpath = pathJoin(dir, srctail);
    LEPT_FREE(dir);
 
        /* Generate output pathname */
    if (!newtail || newtail[0] == '\0')
        newpath = pathJoin(newtemp, srctail);
    else
        newpath = pathJoin(newtemp, newtail);
    LEPT_FREE(srctail);
 
        /* Overwrite any existing file at 'newpath' */
    ret = fileCopy(srcpath, newpath);
    if (!ret) {  /* and remove srcfile */
        char *realpath = genPathname(srcpath, NULL);
        remove(realpath);
        LEPT_FREE(realpath);
    }
#else
    srcpath = genPathname(dir, srctail);
    LEPT_FREE(dir);
 
        /* Generate output pathname */
    if (!newtail || newtail[0] == '\0')
        newpath = genPathname(newtemp, srctail);
    else
        newpath = genPathname(newtemp, newtail);
    LEPT_FREE(srctail);
 
        /* Overwrite any existing file at 'newpath' */
    ret = MoveFileEx(srcpath, newpath,
                     MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING) ? 0 : 1;
#endif  /* ! _WIN32 */
 
    LEPT_FREE(srcpath);
    if (pnewpath)
        *pnewpath = newpath;
    else
        LEPT_FREE(newpath);
    return ret;
}
 
 
l_int32
lept_cp(const char  *srcfile,
        const char  *newdir,
        const char  *newtail,
        char       **pnewpath)
{
char    *srcpath, *newpath, *dir, *srctail;
char     newtemp[256];
l_int32  ret;
 
    PROCNAME("lept_cp");
 
    if (!srcfile)
        return ERROR_INT("srcfile not defined", procName, 1);
 
        /* Require output pathname to be in /tmp or a subdirectory */
    if (makeTempDirname(newtemp, sizeof(newtemp), newdir) == 1)
        return ERROR_INT("newdir not NULL or a subdir of /tmp", procName, 1);
 
       /* Get canonical src pathname */
    splitPathAtDirectory(srcfile, &dir, &srctail);
 
#ifndef _WIN32
    srcpath = pathJoin(dir, srctail);
    LEPT_FREE(dir);
 
        /* Generate output pathname */
    if (!newtail || newtail[0] == '\0')
        newpath = pathJoin(newtemp, srctail);
    else
        newpath = pathJoin(newtemp, newtail);
    LEPT_FREE(srctail);
 
        /* Overwrite any existing file at 'newpath' */
    ret = fileCopy(srcpath, newpath);
#else
    srcpath = genPathname(dir, srctail);
    LEPT_FREE(dir);
 
        /* Generate output pathname */
    if (!newtail || newtail[0] == '\0')
        newpath = genPathname(newtemp, srctail);
    else
        newpath = genPathname(newtemp, newtail);
    LEPT_FREE(srctail);
 
        /* Overwrite any existing file at 'newpath' */
    ret = CopyFile(srcpath, newpath, FALSE) ? 0 : 1;
#endif   /* !_WIN32 */
 
    LEPT_FREE(srcpath);
    if (pnewpath)
        *pnewpath = newpath;
    else
        LEPT_FREE(newpath);
    return ret;
}
 
 
/*--------------------------------------------------------------------*
 *          Special debug/test function for calling 'system'          *
 *--------------------------------------------------------------------*/
#if defined(__APPLE__)
  #include "TargetConditionals.h"
#endif  /* __APPLE__ */
 
void
callSystemDebug(const char *cmd)
{
l_int32  ret;
 
    PROCNAME("callSystemDebug");
 
    if (!cmd) {
        L_ERROR("cmd not defined\n", procName);
        return;
    }
    if (LeptDebugOK == FALSE) {
        L_INFO("'system' calls are disabled\n", procName);
        return;
    }
 
#if defined(__APPLE__)  /* iOS 11 does not support system() */
 
  #if (defined(TARGET_OS_OSX) && TARGET_OS_OSX == 1)  /* Mac OS X */
    ret = system(cmd);
  #elif TARGET_OS_IPHONE || defined(OS_IOS)  /* iOS */
    L_ERROR("iOS 11 does not support system()\n", procName);
  #endif  /* TARGET_OS_OSX */
 
#else /* ! __APPLE__ */
 
   ret = system(cmd);
 
#endif /* __APPLE__ */
}
 
 
/*--------------------------------------------------------------------*
 *                     General file name operations                   *
 *--------------------------------------------------------------------*/
l_ok
splitPathAtDirectory(const char  *pathname,
                     char       **pdir,
                     char       **ptail)
{
char  *cpathname, *lastslash;
 
    PROCNAME("splitPathAtDirectory");
 
    if (!pdir && !ptail)
        return ERROR_INT("null input for both strings", procName, 1);
    if (pdir) *pdir = NULL;
    if (ptail) *ptail = NULL;
    if (!pathname)
        return ERROR_INT("pathname not defined", procName, 1);
 
    cpathname = stringNew(pathname);
    convertSepCharsInPath(cpathname, UNIX_PATH_SEPCHAR);
    lastslash = strrchr(cpathname, '/');
    if (lastslash) {
        if (ptail)
            *ptail = stringNew(lastslash + 1);
        if (pdir) {
            *(lastslash + 1) = '\0';
            *pdir = cpathname;
        } else {
            LEPT_FREE(cpathname);
        }
    } else {  /* no directory */
        if (pdir)
            *pdir = stringNew("");
        if (ptail)
            *ptail = cpathname;
        else
            LEPT_FREE(cpathname);
    }
 
    return 0;
}
 
 
l_ok
splitPathAtExtension(const char  *pathname,
                     char       **pbasename,
                     char       **pextension)
{
char  *tail, *dir, *lastdot;
char   empty[4] = "";
 
    PROCNAME("splitPathExtension");
 
    if (!pbasename && !pextension)
        return ERROR_INT("null input for both strings", procName, 1);
    if (pbasename) *pbasename = NULL;
    if (pextension) *pextension = NULL;
    if (!pathname)
        return ERROR_INT("pathname not defined", procName, 1);
 
        /* Split out the directory first */
    splitPathAtDirectory(pathname, &dir, &tail);
 
        /* Then look for a "." in the tail part.
         * This way we ignore all "." in the directory. */
    if ((lastdot = strrchr(tail, '.'))) {
        if (pextension)
            *pextension = stringNew(lastdot);
        if (pbasename) {
            *lastdot = '\0';
            *pbasename = stringJoin(dir, tail);
        }
    } else {
        if (pextension)
            *pextension = stringNew(empty);
        if (pbasename)
            *pbasename = stringNew(pathname);
    }
    LEPT_FREE(dir);
    LEPT_FREE(tail);
    return 0;
}
 
 
char *
pathJoin(const char  *dir,
         const char  *fname)
{
const char *slash = "/";
char       *str, *dest;
l_int32     i, n1, n2, emptydir;
size_t      size;
SARRAY     *sa1, *sa2;
L_BYTEA    *ba;
 
    PROCNAME("pathJoin");
 
    if (!dir && !fname)
        return stringNew("");
    if (dir && strlen(dir) >= 2 && dir[0] == '.' && dir[1] == '.')
        return (char *)ERROR_PTR("dir starts with '..'", procName, NULL);
    if (fname && strlen(fname) >= 2 && fname[0] == '.' && fname[1] == '.')
        return (char *)ERROR_PTR("fname starts with '..'", procName, NULL);
 
    sa1 = sarrayCreate(0);
    sa2 = sarrayCreate(0);
    ba = l_byteaCreate(4);
 
        /* Process %dir */
    if (dir && strlen(dir) > 0) {
        if (dir[0] == '/')
            l_byteaAppendString(ba, slash);
        sarraySplitString(sa1, dir, "/");  /* removes all slashes */
        n1 = sarrayGetCount(sa1);
        for (i = 0; i < n1; i++) {
            str = sarrayGetString(sa1, i, L_NOCOPY);
            l_byteaAppendString(ba, str);
            l_byteaAppendString(ba, slash);
        }
    }
 
        /* Special case to add leading slash: dir NULL or empty string  */
    emptydir = dir && strlen(dir) == 0;
    if ((!dir || emptydir) && fname && strlen(fname) > 0 && fname[0] == '/')
        l_byteaAppendString(ba, slash);
 
        /* Process %fname */
    if (fname && strlen(fname) > 0) {
        sarraySplitString(sa2, fname, "/");
        n2 = sarrayGetCount(sa2);
        for (i = 0; i < n2; i++) {
            str = sarrayGetString(sa2, i, L_NOCOPY);
            l_byteaAppendString(ba, str);
            l_byteaAppendString(ba, slash);
        }
    }
 
        /* Remove trailing slash */
    dest = (char *)l_byteaCopyData(ba, &size);
    if (size > 1 && dest[size - 1] == '/')
        dest[size - 1] = '\0';
 
    sarrayDestroy(&sa1);
    sarrayDestroy(&sa2);
    l_byteaDestroy(&ba);
    return dest;
}
 
 
char *
appendSubdirs(const char  *basedir,
              const char  *subdirs)
{
char   *newdir;
size_t  len1, len2, len3, len4;
 
    PROCNAME("appendSubdirs");
 
    if (!basedir || !subdirs)
        return (char *)ERROR_PTR("basedir and subdirs not both defined",
                                 procName, NULL);
 
    len1 = strlen(basedir);
    len2 = strlen(subdirs);
    len3 = len1 + len2 + 8;
    if ((newdir = (char *)LEPT_CALLOC(len3, 1)) == NULL)
        return (char *)ERROR_PTR("newdir not made", procName, NULL);
    stringCat(newdir, len3, basedir);
    if (newdir[len1 - 1] != '/')  /* add '/' if necessary */
        newdir[len1] = '/';
    if (subdirs[0] == '/')  /* add subdirs, stripping leading '/' */
        stringCat(newdir, len3, subdirs + 1);
    else
        stringCat(newdir, len3, subdirs);
    len4 = strlen(newdir);
    if (newdir[len4 - 1] == '/')  /* strip trailing '/' */
        newdir[len4 - 1] = '\0';
 
    return newdir;
}
 
 
/*--------------------------------------------------------------------*
 *                     Special file name operations                   *
 *--------------------------------------------------------------------*/
l_ok
convertSepCharsInPath(char    *path,
                      l_int32  type)
{
l_int32  i;
size_t   len;
 
    PROCNAME("convertSepCharsInPath");
    if (!path)
        return ERROR_INT("path not defined", procName, 1);
    if (type != UNIX_PATH_SEPCHAR && type != WIN_PATH_SEPCHAR)
        return ERROR_INT("invalid type", procName, 1);
 
    len = strlen(path);
    if (type == UNIX_PATH_SEPCHAR) {
#ifdef _WIN32  /* only convert on windows */
        for (i = 0; i < len; i++) {
            if (path[i] == '\\')
                path[i] = '/';
        }
#endif  /* _WIN32 */
    } else {  /* WIN_PATH_SEPCHAR */
        for (i = 0; i < len; i++) {
            if (path[i] == '/')
                path[i] = '\\';
        }
    }
    return 0;
}
 
 
char *
genPathname(const char  *dir,
            const char  *fname)
{
l_int32  is_win32 = FALSE;
char    *cdir, *pathout;
l_int32  dirlen, namelen;
size_t   size;
 
    PROCNAME("genPathname");
 
    if (!dir && !fname)
        return (char *)ERROR_PTR("no input", procName, NULL);
 
        /* Handle the case where we start from the current directory */
    if (!dir || dir[0] == '\0') {
        if ((cdir = getcwd(NULL, 0)) == NULL)
            return (char *)ERROR_PTR("no current dir found", procName, NULL);
    } else {
        cdir = stringNew(dir);
    }
 
        /* Convert to unix path separators, and remove the trailing
         * slash in the directory, except when dir == "/"  */
    convertSepCharsInPath(cdir, UNIX_PATH_SEPCHAR);
    dirlen = strlen(cdir);
    if (cdir[dirlen - 1] == '/' && dirlen != 1) {
        cdir[dirlen - 1] = '\0';
        dirlen--;
    }
 
    namelen = (fname) ? strlen(fname) : 0;
    size = dirlen + namelen + 256;
    if ((pathout = (char *)LEPT_CALLOC(size, sizeof(char))) == NULL) {
        LEPT_FREE(cdir);
        return (char *)ERROR_PTR("pathout not made", procName, NULL);
    }
 
#ifdef _WIN32
    is_win32 = TRUE;
#endif  /* _WIN32 */
 
        /* First handle %dir (which may be a full pathname).
         * There is no path rewriting on unix, and on win32, we do not
         * rewrite unless the specified directory is /tmp or
         * a subdirectory of /tmp */
    if (!is_win32 || dirlen < 4 ||
        (dirlen == 4 && strncmp(cdir, "/tmp", 4) != 0) ||  /* not in "/tmp" */
        (dirlen > 4 && strncmp(cdir, "/tmp/", 5) != 0)) {  /* not in "/tmp/" */
        stringCopy(pathout, cdir, dirlen);
    } else {  /* Rewrite for win32 with "/tmp" specified for the directory. */
#ifdef _WIN32
        l_int32 tmpdirlen;
        char tmpdir[MAX_PATH];
        GetTempPath(sizeof(tmpdir), tmpdir);  /* get the windows temp dir */
        tmpdirlen = strlen(tmpdir);
        if (tmpdirlen > 0 && tmpdir[tmpdirlen - 1] == '\\') {
            tmpdir[tmpdirlen - 1] = '\0';  /* trim the trailing '\' */
        }
        tmpdirlen = strlen(tmpdir);
        stringCopy(pathout, tmpdir, tmpdirlen);
 
            /* Add the rest of cdir */
        if (dirlen > 4)
            stringCat(pathout, size, cdir + 4);
#endif  /* _WIN32 */
    }
 
        /* Now handle %fname */
    if (fname && strlen(fname) > 0) {
        dirlen = strlen(pathout);
        pathout[dirlen] = '/';
        stringCat(pathout, size, fname);
    }
 
    LEPT_FREE(cdir);
    return pathout;
}
 
 
l_ok
makeTempDirname(char        *result,
                size_t       nbytes,
                const char  *subdir)
{
char    *dir, *path;
l_int32  ret = 0;
size_t   pathlen;
 
    PROCNAME("makeTempDirname");
 
    if (!result)
        return ERROR_INT("result not defined", procName, 1);
    if (subdir && ((subdir[0] == '.') || (subdir[0] == '/')))
        return ERROR_INT("subdir not an actual subdirectory", procName, 1);
 
    memset(result, 0, nbytes);
 
#ifdef __APPLE__
    {
        size_t n = confstr(_CS_DARWIN_USER_TEMP_DIR, result, nbytes);
        if (n == 0) {
            L_ERROR("failed to find tmp dir, %s\n", procName, strerror(errno));
            return 1;
        } else if (n > nbytes) {
            return ERROR_INT("result array too small for path\n", procName, 1);
        }
        dir = pathJoin(result, subdir);
    }
#else
    dir = pathJoin("/tmp", subdir);
#endif /*  ~ __APPLE__ */
 
#ifndef _WIN32
    path = stringNew(dir);
#else
    path = genPathname(dir, NULL);
#endif  /*  ~ _WIN32 */
    pathlen = strlen(path);
    if (pathlen < nbytes - 1) {
        stringCopy(result, path, nbytes);
    } else {
        L_ERROR("result array too small for path\n", procName);
        ret = 1;
    }
 
    LEPT_FREE(dir);
    LEPT_FREE(path);
    return ret;
}
 
 
l_ok
modifyTrailingSlash(char    *path,
                    size_t   nbytes,
                    l_int32  flag)
{
char    lastchar;
size_t  len;
 
    PROCNAME("modifyTrailingSlash");
 
    if (!path)
        return ERROR_INT("path not defined", procName, 1);
    if (flag != L_ADD_TRAIL_SLASH && flag != L_REMOVE_TRAIL_SLASH)
        return ERROR_INT("invalid flag", procName, 1);
 
    len = strlen(path);
    lastchar = path[len - 1];
    if (flag == L_ADD_TRAIL_SLASH && lastchar != '/' && len < nbytes - 2) {
        path[len] = '/';
        path[len + 1] = '\0';
    } else if (flag == L_REMOVE_TRAIL_SLASH && lastchar == '/') {
        path[len - 1] = '\0';
    }
    return 0;
}
 
 
char *
l_makeTempFilename(void)
{
char  dirname[240];
 
    PROCNAME("l_makeTempFilename");
 
    if (makeTempDirname(dirname, sizeof(dirname), NULL) == 1)
        return (char *)ERROR_PTR("failed to make dirname", procName, NULL);
 
#ifndef _WIN32
{
    char    *pattern;
    l_int32  fd;
    pattern = stringConcatNew(dirname, "/lept.XXXXXX", NULL);
    fd = mkstemp(pattern);
    if (fd == -1) {
        LEPT_FREE(pattern);
        return (char *)ERROR_PTR("mkstemp failed", procName, NULL);
    }
    close(fd);
    return pattern;
}
#else
{
    char  fname[MAX_PATH];
    FILE *fp;
    if (GetTempFileName(dirname, "lp.", 0, fname) == 0)
        return (char *)ERROR_PTR("GetTempFileName failed", procName, NULL);
    if ((fp = fopen(fname, "wb")) == NULL)
        return (char *)ERROR_PTR("file cannot be written to", procName, NULL);
    fclose(fp);
    return stringNew(fname);
}
#endif  /*  ~ _WIN32 */
}
 
 
l_int32
extractNumberFromFilename(const char  *fname,
                          l_int32      numpre,
                          l_int32      numpost)
{
char    *tail, *basename;
l_int32  len, nret, num;
 
    PROCNAME("extractNumberFromFilename");
 
    if (!fname)
        return ERROR_INT("fname not defined", procName, -1);
 
    splitPathAtDirectory(fname, NULL, &tail);
    splitPathAtExtension(tail, &basename, NULL);
    LEPT_FREE(tail);
 
    len = strlen(basename);
    if (numpre + numpost > len - 1) {
        LEPT_FREE(basename);
        return ERROR_INT("numpre + numpost too big", procName, -1);
    }
 
    basename[len - numpost] = '\0';
    nret = sscanf(basename + numpre, "%d", &num);
    LEPT_FREE(basename);
 
    if (nret == 1)
        return num;
    else
        return -1;  /* not found */
}