/*
Copyright (c) 2019-2019, David Anderson
All rights reserved.
Redistribution and use in source and binary forms, with
or without modification, are permitted provided that the
following conditions are met:
Redistributions of source code must retain the above
copyright notice, this list of conditions and the following
disclaimer.
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 THE COPYRIGHT HOLDER OR
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.
*/
/* A lighly generalized data buffer.
Works for more than just strings,
but has features (such as ensuring
data always has a NUL byte following
the data area used) most useful for C strings.
All these return either TRUE (the values altered)
or FALSE (something went wrong, quite likely
the caller presented a bad format string for the
value). Normally a string like
DWARFSTRINGERR is stuck in the output in case of error.
*/
#include <config.h>
#include <stdlib.h> /* free() malloc() strtol() */
#include <string.h> /* memcpy() strlen() */
#include "libdwarf_private.h"
#include "dwarf_string.h"
/* m must be a string, like "DWARFSTRINGERR..." for this to work */
#define DWSERR(m) dwarfstring_append_length(data,(m),sizeof(m)-1)
static unsigned long minimumnewlen = 30;
/* Here we set s_data to a valid pointer to a null byte, though
the s_size and s_avail are set to zero. */
int
dwarfstring_constructor(struct dwarfstring_s *g)
{
g->s_data = "";
g->s_size = 0;
g->s_avail = 0;
g->s_malloc = FALSE;
return TRUE;
}
/* We only increase the s_data space.
Only calling dwarfstring_destructor
eliminates space. */
static int
dwarfstring_add_to(struct dwarfstring_s *g,size_t newlen)
{
char *b = 0;
/* s_size - s_avail is the string without counting
the null following the string. So, is strlen() */
size_t lastpos = g->s_size - g->s_avail;
size_t malloclen = newlen+1;
/* ASSERT: newlen as well as malloclen are
greater than g->s_size at both call points */
if (malloclen < minimumnewlen) {
malloclen = minimumnewlen;
}
/* Not zeroing the new buffer block. */
b = malloc(malloclen);
if (!b) {
return FALSE;
}
if (lastpos > 0) {
/* Copying the non-null bytes in s_data. */
memcpy(b,g->s_data,lastpos);
}
if (g->s_malloc) {
free(g->s_data);
g->s_data = 0;
}
g->s_data = b;
/* s_data[lastpos] is one past the end of anything
counted as string
in s_data at the point of call, and is guaranteed
to be safe as we increased the size of s_data, we did not
shrink. And, too, we add 1 to newlen, always,
so space for a terminating null byte is guaranteed
available. */
g->s_data[lastpos] = 0;
g->s_size = newlen;
g->s_avail = newlen - lastpos;
g->s_malloc = TRUE;
return TRUE;
}
int
dwarfstring_reset(struct dwarfstring_s *g)
{
if (!g->s_size) {
/* In initial condition, nothing to do. */
return TRUE;
}
g->s_avail = g->s_size;
g->s_data[0] = 0;
return TRUE;
}
int
dwarfstring_constructor_fixed(struct dwarfstring_s *g,
size_t len)
{
int r = FALSE;
dwarfstring_constructor(g);
if (len == 0) {
return TRUE;
}
r = dwarfstring_add_to(g,len);
if (!r) {
return FALSE;
}
return TRUE;
}
int
dwarfstring_constructor_static(struct dwarfstring_s *g,
char * space,
size_t len)
{
dwarfstring_constructor(g);
g->s_data = space;
g->s_data[0] = 0;
g->s_size = len;
g->s_avail = len;
g->s_malloc = FALSE;
return TRUE;
}
void
dwarfstring_destructor(struct dwarfstring_s *g)
{
if (g->s_malloc) {
free(g->s_data);
g->s_data = 0;
g->s_malloc = 0;
}
/* The constructor sets all the fields, most to zero.
s_data is set to point to static string ""
s_malloc set to FALSE. */
dwarfstring_constructor(g);
}
/* For the case where one wants just the first 'len'
characters of 'str'. NUL terminator provided
for you in s_data.
*/
int
dwarfstring_append_length(struct dwarfstring_s *g,char *str,
size_t slen)
{
/* lastpos is the length of characters
without the null-terminator we call it strlen */
size_t lastpos = g->s_size - g->s_avail;
int r = 0;
if (!str || slen ==0) {
return TRUE;
}
if (slen >= g->s_avail) {
size_t newlen = 0;
newlen = g->s_size + slen+2;
r = dwarfstring_add_to(g,newlen);
if (!r) {
/* Unable to resize, dare not do anything. */
return FALSE;
}
}
memcpy(g->s_data + lastpos,str,slen);
g->s_avail -= slen;
/* Adding string terminating null byte.
Space is guaranteed available to do this.*/
g->s_data[g->s_size - g->s_avail] = 0;
return TRUE;
}
int
dwarfstring_append(struct dwarfstring_s *g,char *str)
{
size_t dlenszt = 0;
if (!str) {
return TRUE;
}
dlenszt = strlen(str);
return dwarfstring_append_length(g,str,dlenszt);
}
char *
dwarfstring_string(struct dwarfstring_s *g)
{
return g->s_data;
}
size_t
dwarfstring_strlen(struct dwarfstring_s *g)
{
return g->s_size - g->s_avail;
}
static int
_dwarfstring_append_spaces(dwarfstring *data,
size_t count)
{
int res = 0;
char spacebuf[] = {" "};
size_t charct = sizeof(spacebuf)-1;
size_t l = count;
while (l > charct) {
res = dwarfstring_append_length(data,spacebuf,charct);
l -= charct;
if (res != TRUE) {
return res;
}
}
/* ASSERT: l > 0 */
res = dwarfstring_append_length(data,spacebuf,l);
return res;
}
static int
_dwarfstring_append_zeros(dwarfstring *data, size_t l)
{
int res = 0;
static char zeros[] = {
"0000000000000000000000000000000000000000"};
size_t charct = sizeof(zeros)-1;
while (l > charct) {
res = dwarfstring_append_length(data,zeros,charct);
l -= charct;
if (res != TRUE) {
return res;
}
}
/* ASSERT: l > 0 */
dwarfstring_append_length(data,zeros,l);
return res;
}
int dwarfstring_append_printf_s(dwarfstring *data,
char *format,char *s)
{
size_t stringlenszt = 0;
size_t next = 0;
long val = 0;
char *endptr = 0;
const char *numptr = 0;
/* was %[-]fixedlen. Zero means no len provided. */
size_t fixedlen = 0;
/* was %-, nonzero means left-justify */
long leftjustify = 0;
size_t prefixlen = 0;
int res = 0;
if (!s) {
DWSERR("<DWARFSTRINGERR: null string pointer to "
"dwarfstring_append_printf_s>");
return FALSE;
}
stringlenszt = strlen(s);
if (!format) {
DWSERR("<DWARFSTRINGERR: null format pointer to "
"dwarfstring_append_printf_s>");
return FALSE;
}
while (format[next] && format[next] != '%') {
++next;
++prefixlen;
}
if (prefixlen) {
dwarfstring_append_length(data,format,prefixlen);
/* Fall through whether return value TRUE or FALSE */
}
if (format[next] != '%') {
/* No % operator found, we are done */
DWSERR("<DWARFSTRINGERR: no percent passed to "
"dwarfstring_append_printf_s>");
return FALSE;
}
next++;
if (!format[next]) {
DWSERR("<DWARFSTRINGERR: empty percent to "
"dwarfstring_append_printf_s>");
return FALSE;
}
if (format[next] == ' ') {
DWSERR("<DWARFSTRINGERR: empty percent to "
"dwarfstring_append_printf_s>");
return FALSE;
}
if (format[next] == '-') {
leftjustify++;
next++;
}
numptr = format+next;
val = strtol(numptr,&endptr,10);
if ( endptr != numptr) {
fixedlen = val;
}
next = (endptr - format);
if (format[next] != 's') {
DWSERR("<DWARFSTRINGERR: no percent-s to "
"dwarfstring_append_printf_s>");
return FALSE;
}
next++;
if (fixedlen && (stringlenszt >= fixedlen)) {
/* Ignore leftjustify (if any) and the stringlenszt
as the actual string overrides those. */
leftjustify = 0;
}
if (leftjustify) {
dwarfstring_append_length(data,s,stringlenszt);
/* Ignore return value */
if (fixedlen) {
size_t trailingspaces = fixedlen - stringlenszt;
_dwarfstring_append_spaces(data,trailingspaces);
}
} else {
if (fixedlen && fixedlen < stringlenszt) {
/* This lets us have fixedlen < stringlenszt by
taking all the chars from s*/
dwarfstring_append_length(data,s,stringlenszt);
/* Ignore return value, just keep going */
} else {
if (fixedlen) {
size_t leadingspaces = fixedlen - stringlenszt;
size_t k = 0;
for ( ; k < leadingspaces; ++k) {
dwarfstring_append_length(data," ",1);
}
}
res = dwarfstring_append_length(data,s,stringlenszt);
if (res == FALSE) {
return res;
}
}
}
if (!format[next]) {
return TRUE;
}
{
char * startpt = format+next;
size_t suffixlen = strlen(startpt);
res = dwarfstring_append_length(data,startpt,suffixlen);
}
return res;
}
static char v32m[] = {"-2147483648"};
static char v64m[] = {"-9223372036854775808"};
static char dtable[10] = {
'0','1','2','3','4','5','6','7','8','9'
};
static char xtable[16] = {
'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'
};
static char Xtable[16] = {
'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'
};
/* We deal with formats like:
%d %5d %05d %+d %+5d %-5d (and ld and lld too). */
int dwarfstring_append_printf_i(dwarfstring *data,
char *format,
dwarfstring_i v)
{
int res = TRUE;
size_t next = 0;
long val = 0;
char *endptr = 0;
const char *numptr = 0;
size_t fixedlen = 0;
int leadingzero = 0;
int minuscount = 0; /*left justify */
int pluscount = 0;
int lcount = 0;
int ucount = 0;
int dcount = 0;
int xcount = 0;
int Xcount = 0;
char *ctable = dtable;
size_t prefixlen = 0;
int done = 0;
if (!format) {
DWSERR("<DWARFSTRINGERR: null format pointer to "
"dwarfstring_append_printf_i>");
return FALSE;
}
while (format[next] && format[next] != '%') {
++next;
++prefixlen;
}
dwarfstring_append_length(data,format,prefixlen);
if (format[next] != '%') {
/* No % operator found, we are done */
DWSERR("<DWARFSTRINGERR: no percent passed to "
"dwarfstring_append_printf_i>");
return FALSE;
}
next++;
if (!format[next]) {
DWSERR("<DWARFSTRINGERR: empty percent to "
"dwarfstring_append_printf_i>");
return FALSE;
}
if (format[next] == ' ') {
DWSERR("<DWARFSTRINGERR: empty percent to "
"dwarfstring_append_printf_i>");
return FALSE;
}
if (format[next] == '-') {
minuscount++;
next++;
}
if (format[next] == '+') {
pluscount++;
next++;
}
if (format[next] == '-') {
minuscount++;
next++;
}
if (format[next] == '0') {
leadingzero = 1;
next++;
}
numptr = format+next;
val = strtol(numptr,&endptr,10);
if ( endptr != numptr) {
fixedlen = val;
}
next = (endptr - format);
/* Following is lx lu or u or llx llu , we take
all this to mean 64 bits, */
#ifdef _WIN32
if (format[next] == 'I') {
/*lcount++;*/
next++;
}
if (format[next] == '6') {
/*lcount++;*/
next++;
}
if (format[next] == '4') {
/*lcount++;*/
next++;
}
#endif /* _WIN32 */
if (format[next] == 'l') {
lcount++;
next++;
}
if (format[next] == 'l') {
lcount++;
next++;
}
if (format[next] == 'l') {
lcount++;
next++;
}
if (format[next] == 'u') {
ucount++;
next++;
}
if (format[next] == 'd') {
dcount++;
next++;
}
if (format[next] == 'x') {
xcount++;
next++;
}
if (format[next] == 'X') {
Xcount++;
next++;
}
if (format[next] == 's') {
DWSERR( "<DWARFSTRINGERR: format percent s passed to "
"dwarfstring_append_printf_i>");
return FALSE;
}
if (xcount || Xcount) {
/* Use the printf_u for %x and the like
just copying the entire format makes
it easier for coders to understand
nothing much was done */
DWSERR("<DWARFSTRINGERR: format %x or %X passed to "
"dwarfstring_append_printf_i>");
return FALSE;
}
if (!dcount || (lcount >2) ||
(Xcount+xcount+dcount+ucount) > 1) {
/* error */
DWSERR( "<DWARFSTRINGERR: format has too many "
"percent x/d/u/l passed to "
"dwarfstring_append_printf_i>");
return FALSE;
}
if (pluscount && minuscount) {
/* We don't allow format +- */
DWSERR("<DWARFSTRINGERR: format disallowed. +- passed to "
"dwarfstring_append_printf_i>");
return FALSE;
}
{
char digbuf[36];
char *digptr = digbuf+sizeof(digbuf) -1;
size_t digcharlen = 0;
dwarfstring_i remaining = v;
int vissigned = 0;
dwarfstring_i divisor = 10;
*digptr = 0;
--digptr;
if (v < 0) {
vissigned = 1;
/* This test is for twos-complement
machines and would be better done via
configure with a compile-time check
so we do not need a size test at runtime. */
if (sizeof(v) == 8) {
dwarfstring_u vm = 0x7fffffffffffffffULL;
if (vm == (dwarfstring_u)~v) {
memcpy(digbuf,v64m,sizeof(v64m));
digcharlen = sizeof(v64m)-1;
digptr = digbuf;
done = 1;
} else {
remaining = -v;
}
} else if (sizeof(v) == 4) {
dwarfstring_u vm = 0x7fffffffL;
if (vm == (dwarfstring_u)~v) {
memcpy(digbuf,v32m,sizeof(v32m));
digcharlen = sizeof(v32m)-1;
digptr = digbuf;
done = 1;
} else {
remaining = -v;
}
}else {
DWSERR("<DWARFSTRINGERR: v passed to "
"dwarfstring_append_printf_i "
"cannot be handled:integer size>");
return FALSE;
}
}
if (!done) {
for ( ;; ) {
dwarfstring_u dig = 0;
dig = remaining % divisor;
remaining /= divisor;
*digptr = ctable[dig];
digcharlen++;
if (!remaining) {
break;
}
--digptr;
}
if (vissigned) { /* could check minuscount instead */
--digptr;
digcharlen++;
*digptr = '-';
} else if (pluscount) {
--digptr;
digcharlen++;
*digptr = '+';
} else { /* Fall through */ }
}
if (fixedlen > 0) {
if (fixedlen <= digcharlen) {
dwarfstring_append_length(data,digptr,digcharlen);
} else {
size_t prefixcount = fixedlen - digcharlen;
if (!leadingzero) {
_dwarfstring_append_spaces(data,prefixcount);
dwarfstring_append_length(data,digptr,digcharlen);
} else {
if (*digptr == '-') {
dwarfstring_append_length(data,"-",1);
_dwarfstring_append_zeros(data,prefixcount);
digptr++;
dwarfstring_append_length(data,digptr,
digcharlen-1);
} else if (*digptr == '+') {
dwarfstring_append_length(data,"+",1);
_dwarfstring_append_zeros(data,prefixcount);
digptr++;
dwarfstring_append_length(data,digptr,
digcharlen-1);
} else {
_dwarfstring_append_zeros(data,prefixcount);
dwarfstring_append_length(data,digptr,
digcharlen);
}
}
}
} else {
res = dwarfstring_append_length(data,digptr,digcharlen);
}
}
if (format[next]) {
size_t trailinglen = strlen(format+next);
res = dwarfstring_append_length(data,format+next,trailinglen);
}
return res;
}
#if 0 /* Unused trimleadingzeros */
/* Counts hex chars. divide by two to get bytes from input
integer. */
static unsigned
trimleadingzeros(char *ptr,size_t digits,unsigned keepcount)
{
char *cp = ptr;
size_t leadzeroscount = 0;
size_t trimoff = 0;
for (; *cp; ++cp) {
if (*cp == '0') {
leadzeroscount++;
continue;
}
}
trimoff = keepcount - digits;
if (trimoff&1) {
trimoff--;
}
return trimoff;
}
#endif /*0*/
/* With gcc version 5.4.0 20160609 a version using
const char *formatp instead of format[next]
and deleting the 'next' variable
is a few hundredths of a second slower, repeatably.
We deal with formats like:
%u %5u %05u (and ld and lld too).
%x %5x %05x (and ld and lld too). */
int dwarfstring_append_printf_u(dwarfstring *data,
char *format,
dwarfstring_u v)
{
size_t next = 0;
long val = 0;
char *endptr = 0;
const char *numptr = 0;
size_t fixedlen = 0;
int leadingzero = 0;
int lcount = 0;
int ucount = 0;
int dcount = 0;
int xcount = 0;
int Xcount = 0;
char *ctable = 0;
size_t divisor = 0;
size_t prefixlen = 0;
if (!format) {
DWSERR("<DWARFSTRINGERR: null format pointer to "
"dwarfstring_append_printf_u>");
return FALSE;
}
while (format[next] && format[next] != '%') {
++next;
++prefixlen;
}
dwarfstring_append_length(data,format,prefixlen);
if (format[next] != '%') {
/* No % operator found, we are done */
DWSERR("<DWARFSTRINGERR: no percent passed to "
"dwarfstring_append_printf_u>");
return FALSE;
}
next++;
if (!format[next]) {
DWSERR("<DWARFSTRINGERR: empty percent to "
"dwarfstring_append_printf_u>");
return FALSE;
}
if (format[next] == ' ') {
DWSERR("<DWARFSTRINGERR: empty percent to "
"dwarfstring_append_printf_u>");
return FALSE;
}
if (format[next] == '-') {
DWSERR("<DWARFSTRINGERR: format - passed to "
"dwarfstring_append_printf_u "
"cannot be handled>");
return FALSE;
}
if (format[next] == '0') {
leadingzero = 1;
next++;
}
numptr = format+next;
val = strtol(numptr,&endptr,10);
if ( endptr != numptr) {
fixedlen = val;
}
next = (endptr - format);
/* Following is lx lu or u or llx llu , we take
all this to mean 64 bits, */
#ifdef _WIN32
if (format[next] == 'I') {
/*lcount++;*/
next++;
}
if (format[next] == '6') {
/*lcount++;*/
next++;
}
if (format[next] == '4') {
/*lcount++;*/
next++;
}
#endif /* _WIN32 */
if (format[next] == 'l') {
lcount++;
next++;
}
if (format[next] == 'l') {
lcount++;
next++;
}
if (format[next] == 'l') {
lcount++;
next++;
}
if (format[next] == 'u') {
ucount++;
next++;
}
if (format[next] == 'd') {
dcount++;
next++;
}
if (format[next] == 'x') {
xcount++;
next++;
}
if (format[next] == 'X') {
Xcount++;
next++;
}
if (format[next] == 's') {
DWSERR("<DWARFSTRINGERR: format percent-s passed to "
"dwarfstring_append_printf_u "
"cannot be handled>");
return FALSE;
}
if ( (Xcount +xcount+dcount+ucount) > 1) {
DWSERR("<DWARFSTRINGERR: format percent -x X d u repeats to "
"dwarfstring_append_printf_u "
"cannot be handled>");
return FALSE;
}
if ( (Xcount +xcount+dcount+ucount) == 0) {
DWSERR("<DWARFSTRINGERR: format percent x X d u missing to "
"dwarfstring_append_printf_u "
"cannot be handled>");
return FALSE;
}
if (lcount > 2) {
DWSERR("<DWARFSTRINGERR: format percent lll to "
"dwarfstring_append_printf_u "
"cannot be handled>");
return FALSE;
}
if (dcount > 0) {
DWSERR("<DWARFSTRINGERR: format percent-d to "
"dwarfstring_append_printf_u "
"cannot be handled>");
return FALSE;
}
if (ucount) {
divisor = 10;
ctable = dtable;
} else {
divisor = 16;
if (xcount) {
ctable = xtable;
} else {
ctable = Xtable;
}
}
{
char digbuf[36];
char *digptr = 0;
unsigned digcharlen = 0;
dwarfstring_u remaining = v;
if (divisor == 16) {
digptr = digbuf+sizeof(digbuf) -1;
for ( ;; ) {
dwarfstring_u dig;
dig = remaining & 0xf;
remaining = remaining >> 4;
*digptr = ctable[dig];
++digcharlen;
if (!remaining) {
break;
}
--digptr;
}
} else {
digptr = digbuf+sizeof(digbuf) -1;
*digptr = 0;
--digptr;
for ( ;; ) {
dwarfstring_u dig;
dig = remaining % divisor;
remaining /= divisor;
*digptr = ctable[dig];
++digcharlen;
if (!remaining) {
break;
}
--digptr;
}
}
if (fixedlen <= digcharlen) {
dwarfstring_append_length(data,digptr,digcharlen);
} else {
if (!leadingzero) {
size_t justcount = fixedlen - digcharlen;
_dwarfstring_append_spaces(data,justcount);
dwarfstring_append_length(data,digptr,digcharlen);
} else {
size_t prefixcount = fixedlen - digcharlen;
_dwarfstring_append_zeros(data,prefixcount);
dwarfstring_append_length(data,digptr,digcharlen);
}
}
}
if (format[next]) {
size_t trailinglen = strlen(format+next);
dwarfstring_append_length(data,format+next,trailinglen);
}
return FALSE;
}