/*
* snprintf.c - a portable implementation of snprintf
*
THIS MODULE WAS ADAPTED FOR NETPBM BY BRYAN HENDERSON ON 2002.03.24.
Bryan got the base from
http://www.ijs.si/software/snprintf/snprintf-2.2.tar.gz, but made
a lot of changes and additions.
* AUTHOR
* Mark Martinec <mark.martinec@ijs.si>, April 1999.
*
* Copyright 1999, Mark Martinec. All rights reserved.
*
* TERMS AND CONDITIONS
* This program is free software; you can redistribute it and/or modify
* it under the terms of the "Frontier Artistic License" which comes
* with this Kit.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the Frontier Artistic License for more details.
*
* You should have received a copy of the Frontier Artistic License
* with this Kit in the file named LICENSE.txt .
* If not, I'll be glad to provide one.
*
* FEATURES
* - careful adherence to specs regarding flags, field width and precision;
* - good performance for large string handling (large format, large
* argument or large paddings). Performance is similar to system's sprintf
* and in several cases significantly better (make sure you compile with
* optimizations turned on, tell the compiler the code is strict ANSI
* if necessary to give it more freedom for optimizations);
* - return value semantics per ISO/IEC 9899:1999 ("ISO C99");
* - written in standard ISO/ANSI C - requires an ANSI C compiler.
*
* IMPLEMENTED CONVERSION SPECIFIERS AND DATA TYPES
*
* This snprintf implements only the following conversion specifiers:
* s, c, d, u, o, x, X, p (and synonyms: i, D, U, O - see below)
* with flags: '-', '+', ' ', '0' and '#'.
* An asterisk is acceptable for field width as well as precision.
*
* Length modifiers 'h' (short int), 'l' (long int),
* and 'll' (long long int) are implemented.
*
* Conversion of numeric data (conversion specifiers d, u, o, x, X, p)
* with length modifiers (none or h, l, ll) is left to the system routine
* sprintf, but all handling of flags, field width and precision as well as
* c and s conversions is done very carefully by this portable routine.
* If a string precision (truncation) is specified (e.g. %.8s) it is
* guaranteed the string beyond the specified precision will not be referenced.
*
* Length modifiers h, l and ll are ignored for c and s conversions (you
* can't use data types wint_t and wchar_t).
*
* The following common synonyms for conversion characters are acceptable:
* - i is a synonym for d
* - D is a synonym for ld, explicit length modifiers are ignored
* - U is a synonym for lu, explicit length modifiers are ignored
* - O is a synonym for lo, explicit length modifiers are ignored
* The D, O and U conversion characters are nonstandard, they are accepted
* for backward compatibility only, and should not be used for new code.
*
* The following is specifically NOT implemented:
* - flag ' (thousands' grouping character) is recognized but ignored
* - numeric conversion specifiers: f, e, E, g, G and synonym F,
* as well as the new a and A conversion specifiers
* - length modifier 'L' (long double) and 'q' (quad - use 'll' instead)
* - wide character/string conversions: lc, ls, and nonstandard
* synonyms C and S
* - writeback of converted string length: conversion character n
* - the n$ specification for direct reference to n-th argument
* - locales
*
* It is permitted for str_m to be zero, and it is permitted to specify NULL
* pointer for resulting string argument if str_m is zero (as per ISO C99).
*
* The return value is the number of characters which would be generated
* for the given input, excluding the trailing null. If this value
* is greater or equal to str_m, not all characters from the result
* have been stored in str, output bytes beyond the (str_m-1) -th character
* are discarded. If str_m is greater than zero it is guaranteed
* the resulting string will be null-terminated.
*
* NOTE that this matches the ISO C99, OpenBSD, and GNU C library 2.1,
* but is different from some older and vendor implementations,
* and is also different from XPG, XSH5, SUSv2 specifications.
* For historical discussion on changes in the semantics and standards
* of snprintf see printf(3) man page in the Linux programmers manual.
*
* Routines asprintf and vasprintf return a pointer (in the ptr argument)
* to a buffer sufficiently large to hold the resulting string. This pointer
* should be passed to free(3) to release the allocated storage when it is
* no longer needed. If sufficient space cannot be allocated, these functions
* will return -1 and set ptr to be a NULL pointer. These two routines are a
* GNU C library extensions (glibc).
*
* Routines asnprintf and vasnprintf are similar to asprintf and vasprintf,
* yet, like snprintf and vsnprintf counterparts, will write at most str_m-1
* characters into the allocated output string, the last character in the
* allocated buffer then gets the terminating null. If the formatted string
* length (the return value) is greater than or equal to the str_m argument,
* the resulting string was truncated and some of the formatted characters
* were discarded. These routines present a handy way to limit the amount
* of allocated memory to some sane value.
*
* AVAILABILITY
* http://www.ijs.si/software/snprintf/
*
*/
#define _GNU_SOURCE
/* Due to conditional compilation, this is GNU source only if the C library
is GNU.
*/
#define PORTABLE_SNPRINTF_VERSION_MAJOR 2
#define PORTABLE_SNPRINTF_VERSION_MINOR 2
#include <sys/types.h>
#include <limits.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <assert.h>
#include <errno.h>
#include "pm.h"
#include "pm_c_util.h"
#include "nstring.h"
#if (defined(__GLIBC__) || defined(__GNU_LIBRARY__))
#define HAVE_VASPRINTF 1
#else
#define HAVE_VASPRINTF 0
#endif
#ifdef isdigit
#undef isdigit
#endif
#define isdigit(c) ((c) >= '0' && (c) <= '9')
/* For copying strings longer or equal to 'breakeven_point'
* it is more efficient to call memcpy() than to do it inline.
* The value depends mostly on the processor architecture,
* but also on the compiler and its optimization capabilities.
* The value is not critical, some small value greater than zero
* will be just fine if you don't care to squeeze every drop
* of performance out of the code.
*
* Small values favor memcpy, large values favor inline code.
*/
#if defined(__alpha__) || defined(__alpha)
# define breakeven_point 2 /* AXP (DEC Alpha) - gcc or cc or egcs */
#endif
#if defined(__i386__) || defined(__i386)
# define breakeven_point 12 /* Intel Pentium/Linux - gcc 2.96 */
#endif
#if defined(__hppa)
# define breakeven_point 10 /* HP-PA - gcc */
#endif
#if defined(__sparc__) || defined(__sparc)
# define breakeven_point 33 /* Sun Sparc 5 - gcc 2.8.1 */
#endif
/* some other values of possible interest: */
/* #define breakeven_point 8 */ /* VAX 4000 - vaxc */
/* #define breakeven_point 19 */ /* VAX 4000 - gcc 2.7.0 */
#ifndef breakeven_point
# define breakeven_point 6 /* some reasonable one-size-fits-all value */
#endif
#define fast_memcpy(d,s,n) \
{ register size_t nn = (size_t)(n); \
if (nn >= breakeven_point) memcpy((d), (s), nn); \
else if (nn > 0) { /* proc call overhead is worth only for large strings*/\
register char *dd; register const char *ss; \
for (ss=(s), dd=(d); nn>0; nn--) *dd++ = *ss++; } }
#define fast_memset(d,c,n) \
{ register size_t nn = (size_t)(n); \
if (nn >= breakeven_point) memset((d), (int)(c), nn); \
else if (nn > 0) { /* proc call overhead is worth only for large strings*/\
register char *dd; register const int cc=(int)(c); \
for (dd=(d); nn>0; nn--) *dd++ = cc; } }
/* declarations */
static char credits[] = "\n\
@(#)snprintf.c, v2.2: Mark Martinec, <mark.martinec@ijs.si>\n\
@(#)snprintf.c, v2.2: Copyright 1999, Mark Martinec. Frontier Artistic License applies.\n\
@(#)snprintf.c, v2.2: http://www.ijs.si/software/snprintf/\n";
void
pm_vsnprintf(char * const str,
size_t const str_m,
const char * const fmt,
va_list ap,
size_t * const sizeP) {
size_t str_l = 0;
const char *p = fmt;
/* In contrast with POSIX, the ISO C99 now says that str can be
NULL and str_m can be 0. This is more useful than the old:
if (str_m < 1) return -1;
*/
if (!p) p = "";
while (*p) {
if (*p != '%') {
/* if (str_l < str_m) str[str_l++] = *p++; -- this would
be sufficient but the following code achieves better
performance for cases * where format string is long and
contains few conversions
*/
const char *q = strchr(p + 1,'%');
size_t n = !q ? strlen(p) : (q - p);
if (str_l < str_m) {
size_t avail = str_m - str_l;
fast_memcpy(str + str_l, p, (n > avail ? avail : n));
}
p += n; str_l += n;
} else {
size_t min_field_width = 0, precision = 0;
int zero_padding = 0, precision_specified = 0, justify_left = 0;
int alternate_form = 0, force_sign = 0;
int space_for_positive = 1;
/* If both the ' ' and '+' flags appear,
the ' ' flag should be ignored.
*/
char length_modifier = '\0'; /* allowed values: \0, h, l, L */
char tmp[32];
/* temporary buffer for simple numeric->string conversion */
const char *str_arg;
/* string address in case of string argument */
size_t str_arg_l;
/* natural field width of arg without padding and sign */
unsigned char uchar_arg;
/* unsigned char argument value - only defined for c
conversion. N.B. standard explicitly states the char
argument for the c conversion is unsigned.
*/
size_t number_of_zeros_to_pad = 0;
/* number of zeros to be inserted for numeric
conversions as required by the precision or minimal
field width
*/
size_t zero_padding_insertion_ind = 0;
/* index into tmp where zero padding is to be inserted */
char fmt_spec = '\0';
/* current conversion specifier character */
str_arg = credits;
/* just to make compiler happy (defined but not used) */
str_arg = NULL;
++p; /* skip '%' */
/* parse flags */
while (*p == '0' || *p == '-' || *p == '+' ||
*p == ' ' || *p == '#' || *p == '\'') {
switch (*p) {
case '0': zero_padding = 1; break;
case '-': justify_left = 1; break;
case '+': force_sign = 1; space_for_positive = 0; break;
case ' ': force_sign = 1; break;
/* If both the ' ' and '+' flags appear, the ' '
flag should be ignored
*/
case '#': alternate_form = 1; break;
case '\'': break;
}
++p;
}
/* If the '0' and '-' flags both appear, the '0' flag
should be ignored.
*/
/* parse field width */
if (*p == '*') {
int j;
p++; j = va_arg(ap, int);
if (j >= 0) min_field_width = j;
else { min_field_width = -j; justify_left = 1; }
} else if (isdigit((int)(*p))) {
/* size_t could be wider than unsigned int; make sure
we treat argument like common implementations do
*/
unsigned int uj = *p++ - '0';
while (isdigit((int)(*p)))
uj = 10*uj + (unsigned int)(*p++ - '0');
min_field_width = uj;
}
/* parse precision */
if (*p == '.') {
p++; precision_specified = 1;
if (*p == '*') {
int j = va_arg(ap, int);
p++;
if (j >= 0) precision = j;
else {
precision_specified = 0; precision = 0;
/* NOTE: Solaris 2.6 man page claims that in
this case the precision should be set to 0.
Digital Unix 4.0, HPUX 10 and BSD man page
claim that this case should be treated as
unspecified precision, which is what we do
here.
*/
}
} else if (isdigit((int)(*p))) {
/* size_t could be wider than unsigned int; make
sure we treat argument like common
implementations do
*/
unsigned int uj = *p++ - '0';
while (isdigit((int)(*p)))
uj = 10*uj + (unsigned int)(*p++ - '0');
precision = uj;
}
}
/* parse 'h', 'l' and 'll' length modifiers */
if (*p == 'h' || *p == 'l') {
length_modifier = *p; p++;
if (length_modifier == 'l' && *p == 'l') {
/* double l = long long */
length_modifier = 'l'; /* treat it as a single 'l' */
p++;
}
}
fmt_spec = *p;
/* common synonyms: */
switch (fmt_spec) {
case 'i': fmt_spec = 'd'; break;
case 'D': fmt_spec = 'd'; length_modifier = 'l'; break;
case 'U': fmt_spec = 'u'; length_modifier = 'l'; break;
case 'O': fmt_spec = 'o'; length_modifier = 'l'; break;
default: break;
}
/* get parameter value, do initial processing */
switch (fmt_spec) {
case '%':
/* % behaves similar to 's' regarding flags and field widths */
case 'c':
/* c behaves similar to 's' regarding flags and field widths */
case 's':
/* wint_t and wchar_t not handled */
length_modifier = '\0';
/* the result of zero padding flag with non-numeric
conversion specifier is undefined. Solaris and
HPUX 10 does zero padding in this case, Digital
Unix and Linux does not.
*/
zero_padding = 0;
/* turn zero padding off for string conversions */
str_arg_l = 1;
switch (fmt_spec) {
case '%':
str_arg = p; break;
case 'c': {
int j = va_arg(ap, int);
uchar_arg = (unsigned char) j;
/* standard demands unsigned char */
str_arg = (const char *) &uchar_arg;
break;
}
case 's':
str_arg = va_arg(ap, const char *);
if (!str_arg)
/* make sure not to address string beyond the
specified precision !!!
*/
str_arg_l = 0;
else if (!precision_specified)
/* truncate string if necessary as requested by
precision
*/
str_arg_l = strlen(str_arg);
else if (precision == 0)
str_arg_l = 0;
else {
/* memchr on HP does not like n > 2^31 !!! */
const char * q =
memchr(str_arg, '\0',
precision <= 0x7fffffff ?
precision : 0x7fffffff);
str_arg_l = !q ? precision : (q-str_arg);
}
break;
default: break;
}
break;
case 'd': case 'u': case 'o': case 'x': case 'X': case 'p': {
/* NOTE: the u, o, x, X and p conversion specifiers imply
the value is unsigned; d implies a signed value
*/
int arg_sign = 0;
/* 0 if numeric argument is zero (or if pointer is NULL
for 'p'),
+1 if greater than zero (or nonzero for unsigned arguments),
-1 if negative (unsigned argument is never negative)
*/
int int_arg = 0;
unsigned int uint_arg = 0;
/* defined only for length modifier h, or for no
length modifiers
*/
long int long_arg = 0; unsigned long int ulong_arg = 0;
/* only defined for length modifier l */
void *ptr_arg = NULL;
/* pointer argument value -only defined for p conversion */
if (fmt_spec == 'p') {
/* HPUX 10: An l, h, ll or L before any other
conversion character (other than d, i, u, o,
x, or X) is ignored.
Digital Unix: not specified, but seems to behave
as HPUX does.
Solaris: If an h, l, or L appears before any
other conversion specifier (other than d, i, u,
o, x, or X), the behavior is
undefined. (Actually %hp converts only 16-bits
of address and %llp treats address as 64-bit
data which is incompatible with (void *)
argument on a 32-bit system).
*/
length_modifier = '\0';
ptr_arg = va_arg(ap, void *);
if (ptr_arg != NULL) arg_sign = 1;
} else if (fmt_spec == 'd') { /* signed */
switch (length_modifier) {
case '\0':
case 'h':
/* It is non-portable to specify a second
argument of char or short to va_arg,
because arguments seen by the called
function are not char or short. C converts
char and short arguments to int before
passing them to a function.
*/
int_arg = va_arg(ap, int);
if (int_arg > 0) arg_sign = 1;
else if (int_arg < 0) arg_sign = -1;
break;
case 'l':
long_arg = va_arg(ap, long int);
if (long_arg > 0) arg_sign = 1;
else if (long_arg < 0) arg_sign = -1;
break;
}
} else { /* unsigned */
switch (length_modifier) {
case '\0':
case 'h':
uint_arg = va_arg(ap, unsigned int);
if (uint_arg)
arg_sign = 1;
break;
case 'l':
ulong_arg = va_arg(ap, unsigned long int);
if (ulong_arg)
arg_sign = 1;
break;
}
}
str_arg = tmp; str_arg_l = 0;
/* NOTE: For d, i, u, o, x, and X conversions, if
precision is specified, the '0' flag should be
ignored. This is so with Solaris 2.6, Digital UNIX
4.0, HPUX 10, Linux, FreeBSD, NetBSD; but not with
Perl.
*/
if (precision_specified)
zero_padding = 0;
if (fmt_spec == 'd') {
if (force_sign && arg_sign >= 0)
tmp[str_arg_l++] = space_for_positive ? ' ' : '+';
/* leave negative numbers for sprintf to handle,
to avoid handling tricky cases like (short
int)(-32768)
*/
} else if (alternate_form) {
if (arg_sign != 0 && (fmt_spec == 'x' ||
fmt_spec == 'X')) {
tmp[str_arg_l++] = '0';
tmp[str_arg_l++] = fmt_spec;
}
/* alternate form should have no effect for p
conversion, but ...
*/
}
zero_padding_insertion_ind = str_arg_l;
if (!precision_specified)
precision = 1; /* default precision is 1 */
if (precision == 0 && arg_sign == 0) {
/* converted to null string */
/* When zero value is formatted with an explicit
precision 0, the resulting formatted string is
empty (d, i, u, o, x, X, p).
*/
} else {
char f[5]; int f_l = 0;
f[f_l++] = '%';
/* construct a simple format string for sprintf */
if (!length_modifier) { }
else if (length_modifier=='2') {
f[f_l++] = 'l'; f[f_l++] = 'l';
}
else
f[f_l++] = length_modifier;
f[f_l++] = fmt_spec; f[f_l++] = '\0';
if (fmt_spec == 'p')
str_arg_l += sprintf(tmp+str_arg_l, f, ptr_arg);
else if (fmt_spec == 'd') { /* signed */
switch (length_modifier) {
case '\0':
case 'h':
str_arg_l+=sprintf(tmp+str_arg_l, f, int_arg);
break;
case 'l':
str_arg_l+=sprintf(tmp+str_arg_l, f, long_arg);
break;
}
} else { /* unsigned */
switch (length_modifier) {
case '\0':
case 'h':
str_arg_l += sprintf(tmp+str_arg_l, f, uint_arg);
break;
case 'l':
str_arg_l += sprintf(tmp+str_arg_l, f, ulong_arg);
break;
}
}
/* include the optional minus sign and possible "0x"
in the region before the zero padding insertion point
*/
if (zero_padding_insertion_ind < str_arg_l &&
tmp[zero_padding_insertion_ind] == '-') {
zero_padding_insertion_ind++;
}
if (zero_padding_insertion_ind+1 < str_arg_l &&
tmp[zero_padding_insertion_ind] == '0' &&
(tmp[zero_padding_insertion_ind+1] == 'x' ||
tmp[zero_padding_insertion_ind+1] == 'X') ) {
zero_padding_insertion_ind += 2;
}
}
{
size_t num_of_digits =
str_arg_l - zero_padding_insertion_ind;
if (alternate_form && fmt_spec == 'o'
/* unless zero is already the first character */
&& !(zero_padding_insertion_ind < str_arg_l
&& tmp[zero_padding_insertion_ind] == '0')) {
/* assure leading zero for alternate-form
octal numbers
*/
if (!precision_specified ||
precision < num_of_digits+1) {
/* precision is increased to force the
first character to be zero, except if a
zero value is formatted with an
explicit precision of zero
*/
precision = num_of_digits+1;
precision_specified = 1;
}
}
/* zero padding to specified precision? */
if (num_of_digits < precision)
number_of_zeros_to_pad = precision - num_of_digits;
}
/* zero padding to specified minimal field width? */
if (!justify_left && zero_padding) {
int n =
min_field_width - (str_arg_l+number_of_zeros_to_pad);
if (n > 0) number_of_zeros_to_pad += n;
}
} break;
default:
/* unrecognized conversion specifier, keep format
string as-is
*/
zero_padding = 0;
/* turn zero padding off for non-numeric convers. */
/* reset flags */
justify_left = 1;
min_field_width = 0;
/* discard the unrecognized conversion, just keep the
unrecognized conversion character
*/
str_arg = p;
str_arg_l = 0;
if (*p)
/* include invalid conversion specifier unchanged
if not at end-of-string
*/
++str_arg_l;
break;
}
if (*p)
p++; /* step over the just processed conversion specifier */
/* insert padding to the left as requested by
min_field_width; this does not include the zero padding
in case of numerical conversions
*/
if (!justify_left) {
/* left padding with blank or zero */
int n = min_field_width - (str_arg_l+number_of_zeros_to_pad);
if (n > 0) {
if (str_l < str_m) {
size_t avail = str_m-str_l;
fast_memset(str+str_l, (zero_padding ? '0' : ' '),
(n > avail ? avail : n));
}
str_l += n;
}
}
/* zero padding as requested by the precision or by the
minimal field width for numeric conversions required?
*/
if (number_of_zeros_to_pad <= 0) {
/* will not copy first part of numeric right now,
force it to be copied later in its entirety
*/
zero_padding_insertion_ind = 0;
} else {
/* insert first part of numerics (sign or '0x') before
zero padding
*/
int n = zero_padding_insertion_ind;
if (n > 0) {
if (str_l < str_m) {
size_t avail = str_m-str_l;
fast_memcpy(str+str_l, str_arg, (n>avail?avail:n));
}
str_l += n;
}
/* insert zero padding as requested by the precision
or min field width
*/
n = number_of_zeros_to_pad;
if (n > 0) {
if (str_l < str_m) {
size_t avail = str_m - str_l;
fast_memset(str + str_l, '0', (n > avail ? avail : n));
}
str_l += n;
}
}
/* insert formatted string (or as-is conversion specifier
for unknown conversions)
*/
{
int n = str_arg_l - zero_padding_insertion_ind;
if (n > 0) {
if (str_l < str_m) {
size_t avail = str_m-str_l;
fast_memcpy(str + str_l,
str_arg + zero_padding_insertion_ind,
(n > avail ? avail : n));
}
str_l += n;
}
}
/* insert right padding */
if (justify_left) {
/* right blank padding to the field width */
int n = min_field_width - (str_arg_l+number_of_zeros_to_pad);
if (n > 0) {
if (str_l < str_m) {
size_t avail = str_m-str_l;
fast_memset(str+str_l, ' ', (n>avail?avail:n));
}
str_l += n;
}
}
}
}
if (str_m > 0) {
/* make sure the string is null-terminated even at the expense
of overwriting the last character (shouldn't happen, but
just in case)
*/
str[str_l <= str_m-1 ? str_l : str_m-1] = '\0';
}
*sizeP = str_l;
}
#ifdef NETPBM_NOTDEF
int
pm_snprintf(char * const dest,
size_t const str_m,
const char * const fmt,
...) {
size_t size;
va_list ap;
va_start(ap, fmt);
pm_vsnprintf(dest, str_m, fmt, ap, &size);
va_end(ap);
assert(size <= INT_MAX);
return size;
}
#endif
/* When a function that is supposed to return a malloc'ed string cannot
get the memory for it, it should return 'pm_strsol'. That has a much
better effect on the caller, if the caller doesn't explicitly allow for
the out of memory case, than returning NULL. Note that it is very
rare for the system not to have enough memory to return a small string,
so it's OK to have somewhat nonsensical behavior when it happens. We
just don't want catastrophic behavior.
'pm_strsol' is an external symbol, so if Caller wants to detect the
out-of-memory failure, he certainly can.
*/
const char * const pm_strsol = "NO MEMORY TO CREATE STRING!";
const char *
pm_strdup(const char * const arg) {
const char * const dup = strdup(arg);
return dup ? dup : pm_strsol;
}
void PM_GNU_PRINTF_ATTR(2,3)
pm_asprintf(const char ** const resultP,
const char * const fmt,
...) {
char * result;
va_list varargs;
#if HAVE_VASPRINTF
va_start(varargs, fmt);
vasprintf((char **)&result, fmt, varargs);
va_end(varargs);
#else
size_t dryRunLen;
va_start(varargs, fmt);
pm_vsnprintf(NULL, 0, fmt, varargs, &dryRunLen);
va_end(varargs);
if (dryRunLen + 1 < dryRunLen)
/* arithmetic overflow */
result = NULL;
else {
size_t const allocSize = dryRunLen + 1;
result = malloc(allocSize);
if (result != NULL) {
size_t realLen;
va_start(varargs, fmt);
pm_vsnprintf(result, allocSize, fmt, varargs, &realLen);
assert(realLen == dryRunLen);
va_end(varargs);
}
}
#endif
if (result == NULL)
*resultP = pm_strsol;
else
*resultP = result;
}
void
pm_strfree(const char * const string) {
if (string != pm_strsol)
free((void *) string);
}
#ifdef NETPBM_NOTDEF
const char *
pm_strsep(char ** const stringP, const char * const delim) {
const char * retval;
if (stringP == NULL || *stringP == NULL)
retval = NULL;
else {
char * p;
retval = *stringP;
for (p = *stringP; *p && strchr(delim, *p) == NULL; ++p);
if (*p) {
/* We hit a delimiter, not end-of-string. So null out the
delimiter and advance user's pointer to the next token
*/
*p++ = '\0';
*stringP = p;
} else {
/* We ran out of string. So the end-of-string delimiter is
already there, and we set the user's pointer to NULL to
indicate there are no more tokens.
*/
*stringP = NULL;
}
}
return retval;
}
#endif
int
pm_stripeq(const char * const comparand,
const char * const comparator) {
/*----------------------------------------------------------------------------
Compare two strings, ignoring leading and trailing white space.
Return 1 (true) if the strings are identical; 0 (false) otherwise.
-----------------------------------------------------------------------------*/
char *p, *q, *px, *qx;
char equal;
/* Make p and q point to the first non-blank character in each string.
If there are no non-blank characters, make them point to the terminating
NULL.
*/
p = (char *) comparand;
while (ISSPACE(*p)) p++;
q = (char *) comparator;
while (ISSPACE(*q)) q++;
/* Make px and qx point to the last non-blank character in each string.
If there are no nonblank characters (which implies the string is
null), make them point to the terminating NULL.
*/
if (*p == '\0') px = p;
else {
px = p + strlen(p) - 1;
while (ISSPACE(*px)) px--;
}
if (*q == '\0') qx = q;
else {
qx = q + strlen(q) - 1;
while (ISSPACE(*qx)) qx--;
}
equal = 1; /* initial assumption */
/* If the stripped strings aren't the same length,
we know they aren't equal
*/
if (px - p != qx - q) equal = 0;
while (p <= px) {
if (*p != *q) equal = 0;
p++; q++;
}
return equal;
}
#ifdef NETPBM_NOTDEF
const void *
pm_memmem(const void * const haystackArg,
size_t const haystacklen,
const void * const needleArg,
size_t const needlelen) {
const unsigned char * const haystack = haystackArg;
const unsigned char * const needle = needleArg;
/* This does the same as the function of the same name in the GNU
C library
*/
const unsigned char * p;
for (p = haystack; p <= haystack + haystacklen - needlelen; ++p)
if (memeq(p, needle, needlelen))
return p;
return NULL;
}
#endif
bool
pm_strishex(const char * const subject) {
bool retval;
unsigned int i;
retval = TRUE; /* initial assumption */
for (i = 0; i < strlen(subject); ++i)
if (!ISXDIGIT(subject[i]))
retval = FALSE;
return retval;
}
#ifdef NETPBM_NOTDEF
void
pm_interpret_uint(const char * const string,
unsigned int * const valueP,
const char ** const errorP) {
if (string[0] == '\0')
pm_asprintf(errorP, "Null string.");
else {
/* strtoul() does a bizarre thing where if the number is out
of range, it returns a clamped value but tells you about it
by setting errno = ERANGE. If it is not out of range,
strtoul() leaves errno alone.
*/
char * tail;
unsigned long ulongValue;
errno = 0; /* So we can tell if strtoul() overflowed */
ulongValue = strtoul(string, &tail, 10);
if (tail[0] != '\0')
pm_asprintf(errorP, "Non-digit stuff in string: %s", tail);
else if (errno == ERANGE)
pm_asprintf(errorP, "Number too large");
else if (ulongValue > UINT_MAX)
pm_asprintf(errorP, "Number too large");
else if (string[0] == '-')
pm_asprintf(errorP, "Negative number");
/* Sleazy code; string may have leading spaces. */
else {
*valueP = ulongValue;
*errorP = NULL;
}
}
}
#endif