/*====================================================================*
- Copyright (C) 2001 Leptonica. All rights reserved.
- This software is distributed in the hope that it will be
- useful, but with NO WARRANTY OF ANY KIND.
- No author or distributor accepts responsibility to anyone for the
- consequences of using this software, or for whether it serves any
- particular purpose or works at all, unless he or she says so in
- writing. Everyone is granted permission to copy, modify and
- redistribute this source code, for commercial or non-commercial
- purposes, with the following restrictions: (1) the origin of this
- source code must not be misrepresented; (2) modified versions must
- be plainly marked as such; and (3) this notice may not be removed
- or altered from any source or modified source distribution.
*====================================================================*/
/*
* utils.c
*
* error, warning and info procs; all invoked by macros
* l_int32 returnErrorInt()
* l_float32 returnErrorFloat()
* void *returnErrorPtr()
* void returnErrorVoid()
* void l_error()
* void l_errorString()
* void l_errorInt()
* void l_errorFloat()
* void l_warning()
* void l_warningString()
* void l_warningInt()
* void l_warningFloat()
* void l_info()
* void l_infoString()
* void l_infoInt()
* void l_infoInt2()
* void l_infoFloat()
* void l_infoFloat2()
*
* safe string procs
* char *stringNew()
* l_int32 stringReplace()
* char *stringJoin()
* char *stringReverse()
* char *strtokSafe()
* l_int32 stringSplitOnToken()
*
* find and replace procs
* char *stringRemoveChars()
* l_int32 stringFindSubstr()
* char *stringReplaceSubstr()
* char *stringReplaceEachSubstr()
* l_int32 arrayFindSequence()
*
* safe realloc
* void *reallocNew()
*
* read file to memory
* l_uint8 *arrayRead()
* l_uint8 *arrayReadStream()
* l_int32 nbytesInFile()
* l_int32 fnbytesInFile()
*
* write memory to file
* l_int32 arrayWrite()
*
* byte-swapping data conversion
* l_uint16 convertOnBigEnd16()
* l_uint32 convertOnBigEnd32()
* l_uint16 convertOnLittleEnd16()
* l_uint32 convertOnLittleEnd32()
*
* file opening
* FILE *fopenReadStream()
*
* file name operations
* l_int32 splitPathAtDirectory()
* l_int32 splitPathAtExtension()
* char *genPathname()
* char *genTempFilename()
* l_int32 extractNumberFromFilename()
*
* timing
* void startTimer()
* l_float32 stopTimer()
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include "allheaders.h"
#if COMPILER_MSVC
static const char sepchar = '\\';
#else
static const char sepchar = '/';
#endif
/*----------------------------------------------------------------------*
* Error, warning and info message procs *
* *
* --------------------- N.B. --------------------- *
* *
* (1) These functions all print messages to stderr. *
* *
* (2) They must be invoked only by macros, which are in *
* environ.h, so that the print output can be disabled *
* at compile time, using -DNO_CONSOLE_IO. *
* *
*----------------------------------------------------------------------*/
/*!
* returnErrorInt()
*
* Input: msg (error message)
* procname
* ival (return val)
* Return: ival (typically 1)
*/
l_int32
returnErrorInt(const char *msg,
const char *procname,
l_int32 ival)
{
fprintf(stderr, "Error in %s: %s\n", procname, msg);
return ival;
}
/*!
* returnErrorFloat()
*
* Input: msg (error message)
* procname
* fval (return val)
* Return: fval
*/
l_float32
returnErrorFloat(const char *msg,
const char *procname,
l_float32 fval)
{
fprintf(stderr, "Error in %s: %s\n", procname, msg);
return fval;
}
/*!
* returnErrorPtr()
*
* Input: msg (error message)
* procname
* pval (return val)
* Return: pval (typically null)
*/
void *
returnErrorPtr(const char *msg,
const char *procname,
void *pval)
{
fprintf(stderr, "Error in %s: %s\n", procname, msg);
return pval;
}
/*!
* returnErrorVoid()
*
* Input: msg (error message)
* procname
*/
void
returnErrorVoid(const char *msg,
const char *procname)
{
fprintf(stderr, "Error in %s: %s\n", procname, msg);
return;
}
/*!
* l_error()
*
* Input: msg (error message)
* procname
*/
void
l_error(const char *msg,
const char *procname)
{
fprintf(stderr, "Error in %s: %s\n", procname, msg);
return;
}
/*!
* l_errorString()
*
* Input: msg (error message; must include '%s')
* procname
* str (embedded in error message via %s)
*/
void
l_errorString(const char *msg,
const char *procname,
const char *str)
{
l_int32 bufsize;
char *charbuf;
if (!msg || !procname || !str) {
ERROR_VOID("msg, procname or str not defined in l_errorString()",
procname);
return;
}
bufsize = strlen(msg) + strlen(procname) + 128;
if ((charbuf = (char *)CALLOC(bufsize, sizeof(char))) == NULL) {
ERROR_VOID("charbuf not made in l_errorString()", procname);
return;
}
sprintf(charbuf, "Error in %s: %s\n", procname, msg);
fprintf(stderr, charbuf, str);
FREE(charbuf);
return;
}
/*!
* l_errorInt()
*
* Input: msg (error message; must include '%d')
* procname
* ival (embedded in error message via %d)
*/
void
l_errorInt(const char *msg,
const char *procname,
l_int32 ival)
{
l_int32 bufsize;
char *charbuf;
if (!msg || !procname) {
ERROR_VOID("msg or procname not defined in l_errorInt()", procname);
return;
}
bufsize = strlen(msg) + strlen(procname) + 128;
if ((charbuf = (char *)CALLOC(bufsize, sizeof(char))) == NULL) {
ERROR_VOID("charbuf not made in l_errorInt()", procname);
return;
}
sprintf(charbuf, "Error in %s: %s\n", procname, msg);
fprintf(stderr, charbuf, ival);
FREE(charbuf);
return;
}
/*!
* l_errorFloat()
*
* Input: msg (error message; must include '%f')
* procname
* fval (embedded in error message via %f)
*/
void
l_errorFloat(const char *msg,
const char *procname,
l_float32 fval)
{
l_int32 bufsize;
char *charbuf;
if (!msg || !procname) {
ERROR_VOID("msg or procname not defined in l_errorFloat()", procname);
return;
}
bufsize = strlen(msg) + strlen(procname) + 128;
if ((charbuf = (char *)CALLOC(bufsize, sizeof(char))) == NULL) {
ERROR_VOID("charbuf not made in l_errorFloat()", procname);
return;
}
sprintf(charbuf, "Error in %s: %s\n", procname, msg);
fprintf(stderr, charbuf, fval);
FREE(charbuf);
return;
}
/*!
* l_warning()
*
* Input: msg (warning message)
* procname
*/
void
l_warning(const char *msg,
const char *procname)
{
fprintf(stderr, "Warning in %s: %s\n", procname, msg);
return;
}
/*!
* l_warningString()
*
* Input: msg (warning message; must include '%s')
* procname
* str (embedded in warning message via %s)
*/
void
l_warningString(const char *msg,
const char *procname,
const char *str)
{
l_int32 bufsize;
char *charbuf;
if (!msg || !procname || !str) {
ERROR_VOID("msg, procname or str not defined in l_warningString()",
procname);
return;
}
bufsize = strlen(msg) + strlen(procname) + 128;
if ((charbuf = (char *)CALLOC(bufsize, sizeof(char))) == NULL) {
ERROR_VOID("charbuf not made in l_warningString()", procname);
return;
}
sprintf(charbuf, "Warning in %s: %s\n", procname, msg);
fprintf(stderr, charbuf, str);
FREE(charbuf);
return;
}
/*!
* l_warningInt()
*
* Input: msg (warning message; must include '%d')
* procname
* ival (embedded in warning message via %d)
*/
void
l_warningInt(const char *msg,
const char *procname,
l_int32 ival)
{
l_int32 bufsize;
char *charbuf;
if (!msg || !procname) {
ERROR_VOID("msg or procname not defined in l_warningInt()", procname);
return;
}
bufsize = strlen(msg) + strlen(procname) + 128;
if ((charbuf = (char *)CALLOC(bufsize, sizeof(char))) == NULL) {
ERROR_VOID("charbuf not made in l_warningInt()", procname);
return;
}
sprintf(charbuf, "Warning in %s: %s\n", procname, msg);
fprintf(stderr, charbuf, ival);
FREE(charbuf);
return;
}
/*!
* l_warningFloat()
*
* Input: msg (warning message; must include '%f')
* procname
* fval (embedded in warning message via %f)
*/
void
l_warningFloat(const char *msg,
const char *procname,
l_float32 fval)
{
l_int32 bufsize;
char *charbuf;
if (!msg || !procname) {
ERROR_VOID("msg or procname not defined in l_warningFloat()", procname);
return;
}
bufsize = strlen(msg) + strlen(procname) + 128;
if ((charbuf = (char *)CALLOC(bufsize, sizeof(char))) == NULL) {
ERROR_VOID("charbuf not made in l_warningFloat()", procname);
return;
}
sprintf(charbuf, "Warning in %s: %s\n", procname, msg);
fprintf(stderr, charbuf, fval);
FREE(charbuf);
return;
}
/*!
* l_info()
*
* Input: msg (info message)
* procname
*/
void
l_info(const char *msg,
const char *procname)
{
fprintf(stderr, "Info in %s: %s\n", procname, msg);
return;
}
/*!
* l_infoString()
*
* Input: msg (info message; must include '%s')
* procname
* str (embedded in warning message via %s)
*/
void
l_infoString(const char *msg,
const char *procname,
const char *str)
{
l_int32 bufsize;
char *charbuf;
if (!msg || !procname || !str) {
ERROR_VOID("msg, procname or str not defined in l_infoString()",
procname);
return;
}
bufsize = strlen(msg) + strlen(procname) + 128;
if ((charbuf = (char *)CALLOC(bufsize, sizeof(char))) == NULL) {
ERROR_VOID("charbuf not made in l_infoString()", procname);
return;
}
sprintf(charbuf, "Info in %s: %s\n", procname, msg);
fprintf(stderr, charbuf, str);
FREE(charbuf);
return;
}
/*!
* l_infoInt()
*
* Input: msg (info message; must include '%d')
* procname
* ival (embedded in info message via %d)
*/
void
l_infoInt(const char *msg,
const char *procname,
l_int32 ival)
{
l_int32 bufsize;
char *charbuf;
if (!msg || !procname) {
ERROR_VOID("msg or procname not defined in l_infoInt()", procname);
return;
}
bufsize = strlen(msg) + strlen(procname) + 128;
if ((charbuf = (char *)CALLOC(bufsize, sizeof(char))) == NULL) {
ERROR_VOID("charbuf not made in l_infoInt()", procname);
return;
}
sprintf(charbuf, "Info in %s: %s\n", procname, msg);
fprintf(stderr, charbuf, ival);
FREE(charbuf);
return;
}
/*!
* l_infoInt2()
*
* Input: msg (info message; must include two '%d')
* procname
* ival1, ival2 (two args, embedded in info message via %d)
*/
void
l_infoInt2(const char *msg,
const char *procname,
l_int32 ival1,
l_int32 ival2)
{
l_int32 bufsize;
char *charbuf;
if (!msg || !procname) {
ERROR_VOID("msg or procname not defined in l_infoInt2()", procname);
return;
}
bufsize = strlen(msg) + strlen(procname) + 128;
if ((charbuf = (char *)CALLOC(bufsize, sizeof(char))) == NULL) {
ERROR_VOID("charbuf not made in l_infoInt2()", procname);
return;
}
sprintf(charbuf, "Info in %s: %s\n", procname, msg);
fprintf(stderr, charbuf, ival1, ival2);
FREE(charbuf);
return;
}
/*!
* l_infoFloat()
*
* Input: msg (info message; must include '%f')
* procname
* fval (embedded in info message via %f)
*/
void
l_infoFloat(const char *msg,
const char *procname,
l_float32 fval)
{
l_int32 bufsize;
char *charbuf;
if (!msg || !procname) {
ERROR_VOID("msg or procname not defined in l_infoFloat()", procname);
return;
}
bufsize = strlen(msg) + strlen(procname) + 128;
if ((charbuf = (char *)CALLOC(bufsize, sizeof(char))) == NULL) {
ERROR_VOID("charbuf not made in l_infoFloat()", procname);
return;
}
sprintf(charbuf, "Info in %s: %s\n", procname, msg);
fprintf(stderr, charbuf, fval);
FREE(charbuf);
return;
}
/*!
* l_infoFloat2()
*
* Input: msg (info message; must include two '%f')
* procname
* fval1, fval2 (two args, embedded in info message via %f)
*/
void
l_infoFloat2(const char *msg,
const char *procname,
l_float32 fval1,
l_float32 fval2)
{
l_int32 bufsize;
char *charbuf;
if (!msg || !procname) {
ERROR_VOID("msg or procname not defined in l_infoFloat2()", procname);
return;
}
bufsize = strlen(msg) + strlen(procname) + 128;
if ((charbuf = (char *)CALLOC(bufsize, sizeof(char))) == NULL) {
ERROR_VOID("charbuf not made in l_infoFloat()", procname);
return;
}
sprintf(charbuf, "Info in %s: %s\n", procname, msg);
fprintf(stderr, charbuf, fval1, fval2);
FREE(charbuf);
return;
}
/*--------------------------------------------------------------------*
* Safe string operations *
*--------------------------------------------------------------------*/
/*!
* stringNew()
*
* Input: src string
* Return: dest copy of src string, or null on error
*/
char *
stringNew(const char *src)
{
char *dest;
PROCNAME("stringNew");
if (!src)
return (char *)ERROR_PTR("src not defined", procName, NULL);
if ((dest = (char *)CALLOC(strlen(src) + 2, sizeof(char))) == NULL)
return (char *)ERROR_PTR("dest not made", procName, NULL);
strcpy(dest, src);
return dest;
}
/*!
* stringReplace()
*
* Input: &dest string (<return> copy)
* src string
* Return: 0 if OK; 1 on error
*
* Notes:
* (1) Frees any existing dest string
* (2) Puts a copy of src string in the dest
* (3) If either or both strings are null, does the reasonable thing.
*/
l_int32
stringReplace(char **pdest,
const char *src)
{
char *scopy;
PROCNAME("stringReplace");
if (!pdest)
return ERROR_INT("pdest not defined", procName, 1);
if (*pdest)
FREE(*pdest);
if (src) {
if ((scopy = (char *)CALLOC(strlen(src) + 2, sizeof(char))) == NULL)
return ERROR_INT("scopy not made", procName, 1);
strcpy(scopy, src);
*pdest = scopy;
}
else
*pdest = NULL;
return 0;
}
/*!
* stringJoin()
*
* Input: src1 string (<optional>)
* src2 string (<optional>)
* Return: concatenated string, or null on error
*
* Notes:
* (1) This is the safe version of strcat; it makes a new string.
* (2) It is not an error if either or both of the strings
* are empty, or if either or both the pointers are null.
*/
char *
stringJoin(const char *src1,
const char *src2)
{
char *dest;
l_int32 srclen1, srclen2, destlen;
PROCNAME("stringJoin");
srclen1 = srclen2 = 0;
if (src1)
srclen1 = strlen(src1);
if (src2)
srclen2 = strlen(src2);
destlen = srclen1 + srclen2 + 3;
if ((dest = (char *)CALLOC(destlen, sizeof(char))) == NULL)
return (char *)ERROR_PTR("calloc fail for dest", procName, NULL);
if (src1)
strcpy(dest, src1);
if (src2)
strcat(dest, src2);
return dest;
}
/*!
* stringReverse()
*
* Input: src (string)
* Return: dest (newly-allocated reversed string)
*/
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 *)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;
}
/*!
* strtokSafe()
*
* Input: cstr (input string to be sequentially parsed;
* use NULL after the first call)
* seps (a string of character separators)
* &saveptr (<return> ptr to the next char after
* the last encountered separator)
* Return: substr (a new string that is copied from the previous
* saveptr up to but not including the next
* separator character), or NULL if end of cstr.
*
* Notes:
* (1) This is a thread-safe implementation of strtok.
* (2) It has the same interface as strtok_r.
* (3) It differs from strtok_r in usage in two respects:
* (a) the input string is not altered
* (b) each returned substring is newly allocated and must
* be freed after use.
* (4) Let me repeat that. This is "safe" because the input
* string is not altered and because each returned string
* is newly allocated on the heap.
* (5) It is here because, surprisingly, some C libraries don't
* include strtok_r.
* (6) Important usage points:
* - Input the string to be parsed on the first invocation.
* - Then input NULL after that; the value returned in saveptr
* is used in all subsequent calls.
* (7) This is only slightly slower than strtok_k.
*/
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;
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 *)CALLOC(nchars + 1, sizeof(char));
strncpy(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;
}
/*!
* stringSplitOnToken()
*
* Input: cstr (input string to be split; not altered)
* seps (a string of character separators)
* &head (<return> ptr to copy of the input string, up to
* the first separator token encountered)
* &tail (<return> ptr to copy of the part of the input string
* starting with the first non-separator character
* that occurs after the first separator is found)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) The input string is not altered; all split parts are new strings.
* (2) The split occurs around the first consecutive sequence of
* tokens encountered.
* (3) The head goes from the beginning of the string up to
* but not including the first token found.
* (4) The tail contains the second part of the string, starting
* with the first char in that part that is NOT a token.
* (5) If no separator token is found, 'head' contains a copy
* of the input string and 'tail' is null.
*/
l_int32
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 *
*--------------------------------------------------------------------*/
/*!
* stringRemoveChars()
*
* Input: src (input string; can be of zero length)
* remchars (string of chars to be removed from src)
* Return: dest (string with specified chars removed), or null on error
*/
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 *)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;
}
/*!
* stringFindSubstr()
*
* Input: src (input string; can be of zero length)
* sub (substring to be searched for)
* &loc (<return optional> location of substring in src)
* Return: 1 if found; 0 if not found or on error
*
* Notes:
* (1) This is a wrapper around strstr().
* (2) Both @src and @sub must be defined, and @sub must have
* length of at least 1.
* (3) If the substring is not found and loc is returned, it has
* the value -1.
*/
l_int32
stringFindSubstr(const char *src,
const char *sub,
l_int32 *ploc)
{
char *ptr;
PROCNAME("stringFindSubstr");
if (!src)
return ERROR_INT("src not defined", procName, 0);
if (!sub)
return ERROR_INT("sub not defined", procName, 0);
if (ploc) *ploc = -1;
if (strlen(sub) == 0)
return ERROR_INT("substring length 0", procName, 0);
if (strlen(src) == 0)
return 0;
if ((ptr = (char *)strstr(src, sub)) == NULL) /* not found */
return 0;
if (*ploc)
*ploc = ptr - src;
return 1;
}
/*!
* stringReplaceSubstr()
*
* Input: src (input string; can be of zero length)
* sub1 (substring to be replaced)
* sub2 (substring to put in; can be "")
* &found (<return optional> 1 if sub1 is found; 0 otherwise)
* &loc (<return optional> location of ptr after replacement)
* Return: dest (string with substring replaced), or null if the
* substring not found or on error.
*
* Notes:
* (1) Replaces the first instance.
* (2) To only remove sub1, use "" for sub2
* (3) Returns a new string if sub1 and sub2 are the same.
* (4) The optional loc is input as the byte offset within the src
* from which the search starts, and after the search it is the
* char position in the string of the next character after
* the substituted string.
* (5) N.B. If ploc is not null, loc must always be initialized.
* To search the string from the beginning, set loc = 0.
*/
char *
stringReplaceSubstr(const char *src,
const char *sub1,
const char *sub2,
l_int32 *pfound,
l_int32 *ploc)
{
char *ptr, *dest;
l_int32 nsrc, nsub1, nsub2, len, npre, loc;
PROCNAME("stringReplaceSubstr");
if (!src)
return (char *)ERROR_PTR("src not defined", procName, NULL);
if (!sub1)
return (char *)ERROR_PTR("sub1 not defined", procName, NULL);
if (!sub2)
return (char *)ERROR_PTR("sub2 not defined", procName, NULL);
if (pfound)
*pfound = 0;
if (ploc)
loc = *ploc;
else
loc = 0;
if ((ptr = (char *)strstr(src + loc, sub1)) == NULL) {
return NULL;
}
if (pfound)
*pfound = 1;
nsrc = strlen(src);
nsub1 = strlen(sub1);
nsub2 = strlen(sub2);
len = nsrc + nsub2 - nsub1;
if ((dest = (char *)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;
}
/*!
* stringReplaceEachSubstr()
*
* Input: src (input string; can be of zero length)
* sub1 (substring to be replaced)
* sub2 (substring to put in; can be "")
* &count (<optional return > the number of times that sub1
* is found in src; 0 if not found)
* Return: dest (string with substring replaced), or null if the
* substring not found or on error.
*
* Notes:
* (1) Replaces every instance.
* (2) To only remove each instance of sub1, use "" for sub2
* (3) Returns NULL if sub1 and sub2 are the same.
*/
char *
stringReplaceEachSubstr(const char *src,
const char *sub1,
const char *sub2,
l_int32 *pcount)
{
char *currstr, *newstr;
l_int32 loc;
PROCNAME("stringReplaceEachSubstr");
if (!src)
return (char *)ERROR_PTR("src not defined", procName, NULL);
if (!sub1)
return (char *)ERROR_PTR("sub1 not defined", procName, NULL);
if (!sub2)
return (char *)ERROR_PTR("sub2 not defined", procName, NULL);
if (pcount)
*pcount = 0;
loc = 0;
if ((newstr = stringReplaceSubstr(src, sub1, sub2, NULL, &loc)) == NULL)
return NULL;
if (pcount)
(*pcount)++;
while (1) {
currstr = newstr;
newstr = stringReplaceSubstr(currstr, sub1, sub2, NULL, &loc);
if (!newstr)
return currstr;
FREE(currstr);
if (pcount)
(*pcount)++;
}
}
/*!
* arrayFindSequence()
*
* Input: data (byte array)
* datalen (length of data, in bytes)
* sequence (subarray of bytes to find in data)
* seqlen (length of sequence, in bytes)
* &offset (return> offset from beginning of
* data where the sequence begins)
* &found (<return> 1 if sequence is found; 0 otherwise)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) The byte arrays 'data' and 'sequence' are not C strings,
* as they can contain null bytes. Therefore, for each
* we must give the length of the array.
* (2) This searches for the first occurrence in 'data' of
* the first 'seqlen' bytes of 'sequence'. The parameter 'seqlen'
* must not exceed the actual length of the 'sequence' byte array.
* (3) If the sequence is not found, the offset will be set to -1.
*/
l_int32
arrayFindSequence(const l_uint8 *data,
l_int32 datalen,
const l_uint8 *sequence,
l_int32 seqlen,
l_int32 *poffset,
l_int32 *pfound)
{
l_int32 i, j, found, lastpos;
PROCNAME("arrayFindSequence");
if (!data || !sequence)
return ERROR_INT("data & sequence not both defined", procName, 1);
if (!poffset || !pfound)
return ERROR_INT("&offset and &found not both defined", procName, 1);
*pfound = 0;
*poffset = -1;
lastpos = datalen - seqlen + 1;
found = 0;
for (i = 0; i < lastpos; i++) {
for (j = 0; j < seqlen; j++) {
if (data[i + j] != sequence[j])
break;
if (j == seqlen - 1)
found = 1;
}
if (found)
break;
}
if (found) {
*pfound = 1;
*poffset = i;
}
return 0;
}
/*--------------------------------------------------------------------*
* Safe realloc *
*--------------------------------------------------------------------*/
/*!
* reallocNew()
*
* Input: &indata (<optional>; nulls indata)
* size of input data to be copied (bytes)
* size of data to be reallocated (bytes)
* Return: ptr to new data, or null on error
*
* Action: !N.B. (3) and (4)!
* (1) Allocates memory, initialized to 0
* (2) Copies as much of the input data as possible
* to the new block, truncating the copy if necessary
* (3) Frees the input data
* (4) Zeroes the input data ptr
*
* Notes:
* (1) If newsize <=0, just frees input data and nulls ptr
* (2) If input ptr is null, just callocs new memory
* (3) This differs from realloc in that it always allocates
* new memory (if newsize > 0) and initializes it to 0,
* it requires the amount of old data to be copied,
* and it takes the address of the input ptr and
* nulls the handle.
*/
void *
reallocNew(void **pindata,
l_int32 oldsize,
l_int32 newsize)
{
l_int32 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) {
FREE(indata);
*pindata = NULL;
}
return NULL;
}
if (!indata) /* nonstandard usage */
{
if ((newdata = (void *)CALLOC(1, newsize)) == NULL)
return ERROR_PTR("newdata not made", procName, NULL);
return newdata;
}
/* Standard usage */
if ((newdata = (void *)CALLOC(1, newsize)) == NULL)
return ERROR_PTR("newdata not made", procName, NULL);
minsize = L_MIN(oldsize, newsize);
memcpy((char *)newdata, (char *)indata, minsize);
FREE(indata);
*pindata = NULL;
return newdata;
}
/*--------------------------------------------------------------------*
* Reading bytes from file *
*--------------------------------------------------------------------*/
/*!
* arrayRead()
*
* Input: filename
* &nbytes (<return> number of bytes read)
* Return: array, or null on error
*/
l_uint8 *
arrayRead(const char *fname,
l_int32 *pnbytes)
{
l_uint8 *data;
FILE *fp;
PROCNAME("arrayRead");
if (!fname)
return (l_uint8 *)ERROR_PTR("fname not defined", procName, NULL);
if (!pnbytes)
return (l_uint8 *)ERROR_PTR("pnbytes not defined", procName, NULL);
*pnbytes = 0;
if ((fp = fopen(fname, "r")) == NULL)
return (l_uint8 *)ERROR_PTR("file stream not opened", procName, NULL);
data = arrayReadStream(fp, pnbytes);
fclose(fp);
return data;
}
/*!
* arrayReadStream()
*
* Input: stream
* &nbytes (<return> number of bytes read)
* Return: null-terminated array, or null on error
* (reading 0 bytes is not an error)
*
* Notes:
* (1) N.B.: as a side effect, this always re-positions the
* stream ptr to the beginning of the file.
*/
l_uint8 *
arrayReadStream(FILE *fp,
l_int32 *pnbytes)
{
l_uint8 *data;
PROCNAME("arrayReadStream");
if (!fp)
return (l_uint8 *)ERROR_PTR("stream not defined", procName, NULL);
if (!pnbytes)
return (l_uint8 *)ERROR_PTR("ptr to nbytes not defined", procName, NULL);
*pnbytes = fnbytesInFile(fp);
if ((data = (l_uint8 *)CALLOC(1, *pnbytes + 1)) == NULL)
return (l_uint8 *)ERROR_PTR("CALLOC fail for data", procName, NULL);
fread(data, *pnbytes, 1, fp);
return data;
}
/*!
* nbytesInFile()
*
* Input: filename
* Return: nbytes in file; 0 on error
*/
l_int32
nbytesInFile(const char *filename)
{
l_int32 nbytes;
FILE *fp;
PROCNAME("nbytesInFile");
if (!filename)
return ERROR_INT("filename not defined", procName, 0);
fp = fopen(filename, "r");
nbytes = fnbytesInFile(fp);
fclose(fp);
return nbytes;
}
/*!
* fnbytesInFile()
*
* Input: file stream
* Return: nbytes in file; 0 on error
*/
l_int32
fnbytesInFile(FILE *fp)
{
l_int32 nbytes, pos;
PROCNAME("fnbytesInFile");
if (!fp)
return ERROR_INT("stream not open", procName, 0);
pos = ftell(fp); /* initial position */
fseek(fp, 0, SEEK_END); /* EOF */
nbytes = ftell(fp);
fseek(fp, 0, pos); /* back to initial position */
return nbytes;
}
/*--------------------------------------------------------------------*
* Writing bytes to file *
*--------------------------------------------------------------------*/
/*!
* arrayWrite()
*
* Input: filename (output)
* operation ("w" for write; "a" for append)
* data (binary data to be written)
* nbytes (size of data array)
* Return: 0 if OK; 1 on error
*/
l_int32
arrayWrite(const char *filename,
const char *operation,
void *data,
l_int32 nbytes)
{
FILE *fp;
PROCNAME("arrayWrite");
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);
if ((fp = fopen(filename, operation)) == NULL)
return ERROR_INT("stream not opened", procName, 1);
fwrite(data, 1, nbytes, fp);
fclose(fp);
return 0;
}
/*--------------------------------------------------------------------------*
* 16 and 32 bit byte-swapping on big endian and little endian machines *
* *
* These are typically used for I/O conversions: *
* (1) endian conversion for data that was read from a file *
* (2) endian conversion on data before it is written to a file *
*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------*
* 16-bit byte swapping *
*--------------------------------------------------------------------*/
#ifdef L_BIG_ENDIAN
l_uint16
convertOnBigEnd16(l_uint16 shortin)
{
return ((shortin << 8) | (shortin >> 8));
}
l_uint16
convertOnLittleEnd16(l_uint16 shortin)
{
return shortin;
}
#else /* L_LITTLE_ENDIAN */
l_uint16
convertOnLittleEnd16(l_uint16 shortin)
{
return ((shortin << 8) | (shortin >> 8));
}
l_uint16
convertOnBigEnd16(l_uint16 shortin)
{
return shortin;
}
#endif /* L_BIG_ENDIAN */
/*--------------------------------------------------------------------*
* 32-bit byte swapping *
*--------------------------------------------------------------------*/
#ifdef L_BIG_ENDIAN
l_uint32
convertOnBigEnd32(l_uint32 wordin)
{
return ((wordin << 24) | ((wordin << 8) & 0x00ff0000) |
((wordin >> 8) & 0x0000ff00) | (wordin >> 24));
}
l_uint32
convertOnLittleEnd32(l_uint32 wordin)
{
return wordin;
}
#else /* L_LITTLE_ENDIAN */
l_uint32
convertOnLittleEnd32(l_uint32 wordin)
{
return ((wordin << 24) | ((wordin << 8) & 0x00ff0000) |
((wordin >> 8) & 0x0000ff00) | (wordin >> 24));
}
l_uint32
convertOnBigEnd32(l_uint32 wordin)
{
return wordin;
}
#endif /* L_BIG_ENDIAN */
/*--------------------------------------------------------------------*
* Opening read stream *
*--------------------------------------------------------------------*/
/*!
* fopenReadStream()
*
* Input: filename
* Return: stream or null on error
*/
FILE *
fopenReadStream(const char *filename)
{
char *tail;
FILE *fp;
PROCNAME("fopenReadStream");
if (!filename)
return (FILE *)ERROR_PTR("filename not defined", procName, NULL);
/* Try input filename */
if ((fp = fopen(filename, "rb")))
return fp;
/* Else, strip directory and try locally */
splitPathAtDirectory(filename, NULL, &tail);
if ((fp = fopen(tail, "rb"))) {
FREE(tail);
return fp;
}
FREE(tail);
return (FILE *)ERROR_PTR("file not found", procName, NULL);
}
/*--------------------------------------------------------------------*
* File name operations *
*--------------------------------------------------------------------*/
/*!
* splitPathAtDirectory()
*
* Input: pathname (full path; can be a directory)
* &dir (<optional return> root directory name of
* input path, including trailing '/')
* &tail (<optional return> path tail, which is either
* the file name within the root directory or
* the last sub-directory in the path)
* Return: 0 if OK, 1 on error
*
* Note: (1) if you only want the tail, input null for
* the root directory ptr.
* (2) if you only want the root directory name,
* input null for the tail ptr.
* (3) This function makes decisions based only on the lexical
* structure of the input. Examples:
* /usr/tmp/abc --> dir: /usr/tmp/ tail: abc
* /usr/tmp/ --> dir: /usr/tmp/ tail: [empty string]
* /usr/tmp --> dir: /usr/ tail: tmp
*/
l_int32
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);
if ((lastslash = strrchr(cpathname, '/'))) {
if (ptail)
*ptail = stringNew(lastslash + 1);
if (pdir) {
*(lastslash + 1) = '\0';
*pdir = cpathname;
}
else
FREE(cpathname);
}
else { /* no directory */
if (pdir)
*pdir = stringNew("");
if (ptail)
*ptail = cpathname;
else
FREE(cpathname);
}
return 0;
}
/*!
* splitPathAtExtension()
*
* Input: pathname (full path; can be a directory)
* &basename (<optional return> pathname not including the
* last dot and characters after that)
* &extension (<optional return> path extension, which is
* the last dot and the characters after it. If
* there is no extension, it returns the empty string)
* Return: 0 if OK, 1 on error
*
* Notes:
* (1) If you only want the extension, input null for the basename ptr.
* (2) If you only want the basename without extension, input null
* for the extension ptr.
* (3) This function makes decisions based only on the lexical
* structure of the input. Examples:
* /usr/tmp/abc.jpg --> basename: /usr/tmp/abc ext: .jpg
* /usr/tmp/.jpg --> basename: /usr/tmp/ tail: .jpg
* /usr/tmp.jpg/ --> basename: /usr/tmp.jpg/ tail: [empty str]
* ./.jpg --> basename: ./ tail: .jpg
*/
l_int32
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);
}
FREE(dir);
FREE(tail);
return 0;
}
/*!
* genPathname()
*
* Input: dir (directory name, with or without trailing '/')
* fname (file name within the directory)
* Return: full pathname, or null on error
*/
char *
genPathname(const char *dir,
const char *fname)
{
char *charbuf;
l_int32 dirlen, namelen;
PROCNAME("genPathname");
if (!dir)
return (char *)ERROR_PTR("dir not defined", procName, NULL);
if (!fname)
return (char *)ERROR_PTR("fname not defined", procName, NULL);
dirlen = strlen(dir);
namelen = strlen(fname);
if ((charbuf = (char *)CALLOC(dirlen + namelen + 10, sizeof(char)))
== NULL)
return (char *)ERROR_PTR("charbuf not made", procName, NULL);
if (dir[dirlen - 1] != sepchar)
#if COMPILER_MSVC
sprintf(charbuf, "%s\\", dir);
#else
sprintf(charbuf, "%s/", dir);
#endif
else
strcpy(charbuf, dir);
strcat(charbuf, fname);
return charbuf;
}
/*!
* genTempFilename()
*
* Input: dir (directory name; use '.' for local dir; no trailing '/')
* extension (<optional> filename extention with '.'; can be null)
* Return: tempname (with pid embedded in file name), or null on error
*
* Notes:
* (1) This function is useful when there can be more than one
* process writing and reading temporary files. It will not
* work properly when multiple threads from a single process call
* this function. Furthermore, as with any function that
* provides easily guessed temporary filenames, it is not designed
* to be safe from an attack where the intruder is logged onto
* the server.
*/
char *
genTempFilename(const char *dir,
const char *extension)
{
char buf[256];
char *tempname;
l_int32 pid, nchars;
PROCNAME("genTempFilename");
if (!dir)
return (char *)ERROR_PTR("dir not defined", procName, NULL);
pid = getpid();
if (extension)
nchars = strlen(extension);
else
nchars = 0;
#if COMPILER_MSVC
snprintf(buf, 255 - nchars, "%s\\%d", dir, pid);
#else
snprintf(buf, 25 - nchars, "%s/%d", dir, pid);
#endif
tempname = stringJoin(buf, extension);
return tempname;
}
/*!
* extractNumberFromFilename()
*
* Input: fname
* numpre (number of characters before the digits to be found)
* numpost (number of characters after the digits to be found)
* Return: num (number embedded in the filename); -1 on error or if
* not found
*/
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);
FREE(tail);
len = strlen(basename);
if (numpre + numpost > len - 1) {
FREE(basename);
return ERROR_INT("numpre + numpost too big", procName, -1);
}
basename[len - numpost] = '\n';
nret = sscanf(basename + numpre, "%d", &num);
FREE(basename);
if (nret == 1)
return num;
else
return ERROR_INT("no number found", procName, -1);
}
/*---------------------------------------------------------------------*
* Timing procs *
*---------------------------------------------------------------------*/
/*
* Example of use:
*
* startTimer();
* ....
* fprintf(stderr, "Elapsed time = %7.3f sec\n", stopTimer());
*/
#if !defined(__MINGW32__) && !defined(_WIN32)
#include <sys/time.h>
#include <sys/resource.h>
static struct rusage rusage_before;
static struct rusage rusage_after;
void
startTimer(void)
{
getrusage(RUSAGE_SELF, &rusage_before);
}
l_float32
stopTimer(void)
{
l_int32 tsec, tusec;
getrusage(RUSAGE_SELF, &rusage_after);
tsec = rusage_after.ru_utime.tv_sec - rusage_before.ru_utime.tv_sec;
tusec = rusage_after.ru_utime.tv_usec - rusage_before.ru_utime.tv_usec;
return (tsec + ((l_float32)tusec) / 1000000.0);
}
#else /* __MINGW32__ : resource.h not implemented under MINGW */
#include <windows.h>
static ULARGE_INTEGER utime_before;
static ULARGE_INTEGER utime_after;
void
startTimer(void)
{
HANDLE this_process;
FILETIME start, stop, kernel, user;
this_process = GetCurrentProcess ();
GetProcessTimes (this_process, &start, &stop, &kernel, &user);
utime_before.LowPart = user.dwLowDateTime;
utime_before.HighPart = user.dwHighDateTime;
}
l_float32
stopTimer(void)
{
HANDLE this_process;
FILETIME start, stop, kernel, user;
this_process = GetCurrentProcess ();
GetProcessTimes (this_process, &start, &stop, &kernel, &user);
utime_after.LowPart = user.dwLowDateTime;
utime_after.HighPart = user.dwHighDateTime;
return ((l_float32)(signed)(utime_after.QuadPart - utime_before.QuadPart) /
10000000.0);
}
#endif