OpenSolaris_b135/common/util/string.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Implementations of the functions described in vsnprintf(3C) and string(3C),
* for use by the kernel, the standalone, and kmdb. Unless otherwise specified,
* these functions match the section 3C manpages.
*/
#include <sys/types.h>
#include <sys/varargs.h>
#if defined(_KERNEL)
#include <sys/systm.h>
#include <sys/debug.h>
#elif !defined(_BOOT)
#include <string.h>
#endif
#ifndef NULL
#define NULL 0l
#endif
#include "memcpy.h"
#include "string.h"
/*
* We don't need these for x86 boot or kmdb.
*/
#if !defined(_KMDB) && (!defined(_BOOT) || defined(__sparc))
#define ADDCHAR(c) if (bufp++ - buf < buflen) bufp[-1] = (c)
/*
* Given a buffer 'buf' of size 'buflen', render as much of the string
* described by <fmt, args> as possible. The string will always be
* null-terminated, so the maximum string length is 'buflen - 1'.
* Returns the number of bytes that would be necessary to render the
* entire string, not including null terminator (just like vsnprintf(3S)).
* To determine buffer size in advance, use vsnprintf(NULL, 0, fmt, args) + 1.
*
* There is no support for floating point, and the C locale is assumed.
*/
size_t
vsnprintf(char *buf, size_t buflen, const char *fmt, va_list aargs)
{
uint64_t ul, tmp;
char *bufp = buf; /* current buffer pointer */
int pad, width, base, sign, c, num;
int prec, h_count, l_count, dot_count;
int pad_count, transfer_count, left_align;
char *digits, *sp, *bs;
char numbuf[65]; /* sufficient for a 64-bit binary value */
va_list args;
/*
* Make a copy so that all our callers don't have to make a copy
*/
va_copy(args, aargs);
if ((ssize_t)buflen < 0)
buflen = 0;
while ((c = *fmt++) != '\0') {
if (c != '%') {
ADDCHAR(c);
continue;
}
width = prec = 0;
left_align = base = sign = 0;
h_count = l_count = dot_count = 0;
pad = ' ';
digits = "0123456789abcdef";
next_fmt:
if ((c = *fmt++) == '\0')
break;
if (c >= 'A' && c <= 'Z') {
c += 'a' - 'A';
digits = "0123456789ABCDEF";
}
switch (c) {
case '-':
left_align++;
goto next_fmt;
case '0':
if (dot_count == 0)
pad = '0';
/*FALLTHROUGH*/
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
num = 0;
for (;;) {
num = 10 * num + c - '0';
c = *fmt;
if (c < '0' || c > '9')
break;
else
fmt++;
}
if (dot_count > 0)
prec = num;
else
width = num;
goto next_fmt;
case '.':
dot_count++;
goto next_fmt;
case '*':
if (dot_count > 0)
prec = (int)va_arg(args, int);
else
width = (int)va_arg(args, int);
goto next_fmt;
case 'l':
l_count++;
goto next_fmt;
case 'h':
h_count++;
goto next_fmt;
case 'd':
sign = 1;
/*FALLTHROUGH*/
case 'u':
base = 10;
break;
case 'p':
l_count = 1;
/*FALLTHROUGH*/
case 'x':
base = 16;
break;
case 'o':
base = 8;
break;
case 'b':
l_count = 0;
base = 1;
break;
case 'c':
c = (char)va_arg(args, int);
ADDCHAR(c);
break;
case 's':
sp = va_arg(args, char *);
if (sp == NULL) {
sp = "<null string>";
/* avoid truncation */
prec = strlen(sp);
}
/*
* Handle simple case specially to avoid
* performance hit of strlen()
*/
if (prec == 0 && width == 0) {
while ((c = *sp++) != 0)
ADDCHAR(c);
break;
}
if (prec > 0) {
transfer_count = strnlen(sp, prec);
/* widen field if too narrow */
if (prec > width)
width = prec;
} else
transfer_count = strlen(sp);
if (width > transfer_count)
pad_count = width - transfer_count;
else
pad_count = 0;
while ((!left_align) && (pad_count-- > 0))
ADDCHAR(' ');
/* ADDCHAR() evaluates arg at most once */
while (transfer_count-- > 0)
ADDCHAR(*sp++);
while ((left_align) && (pad_count-- > 0))
ADDCHAR(' ');
break;
case '%':
ADDCHAR('%');
break;
}
if (base == 0)
continue;
if (h_count == 0 && l_count == 0)
if (sign)
ul = (int64_t)va_arg(args, int);
else
ul = (int64_t)va_arg(args, unsigned int);
else if (l_count > 1)
if (sign)
ul = (int64_t)va_arg(args, int64_t);
else
ul = (int64_t)va_arg(args, uint64_t);
else if (l_count > 0)
if (sign)
ul = (int64_t)va_arg(args, long);
else
ul = (int64_t)va_arg(args, unsigned long);
else if (h_count > 1)
if (sign)
ul = (int64_t)((char)va_arg(args, int));
else
ul = (int64_t)((unsigned char)va_arg(args,
int));
else if (h_count > 0)
if (sign)
ul = (int64_t)((short)va_arg(args, int));
else
ul = (int64_t)((unsigned short)va_arg(args,
int));
if (sign && (int64_t)ul < 0)
ul = -ul;
else
sign = 0;
if (c == 'b') {
bs = va_arg(args, char *);
base = *bs++;
}
/* avoid repeated division if width is 0 */
if (width > 0) {
tmp = ul;
do {
width--;
} while ((tmp /= base) != 0);
}
if (sign && pad == '0')
ADDCHAR('-');
while (width-- > sign)
ADDCHAR(pad);
if (sign && pad == ' ')
ADDCHAR('-');
sp = numbuf;
tmp = ul;
do {
*sp++ = digits[tmp % base];
} while ((tmp /= base) != 0);
while (sp > numbuf) {
sp--;
ADDCHAR(*sp);
}
if (c == 'b' && ul != 0) {
int any = 0;
c = *bs++;
while (c != 0) {
if (ul & (1 << (c - 1))) {
if (any++ == 0)
ADDCHAR('<');
while ((c = *bs++) >= 32)
ADDCHAR(c);
ADDCHAR(',');
} else {
while ((c = *bs++) >= 32)
continue;
}
}
if (any) {
bufp--;
ADDCHAR('>');
}
}
}
if (bufp - buf < buflen)
bufp[0] = c;
else if (buflen != 0)
buf[buflen - 1] = c;
va_end(args);
return (bufp - buf);
}
/*PRINTFLIKE1*/
size_t
snprintf(char *buf, size_t buflen, const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
buflen = vsnprintf(buf, buflen, fmt, args);
va_end(args);
return (buflen);
}
#if defined(_BOOT) && defined(__sparc)
/*
* The sprintf() and vsprintf() routines aren't shared with the kernel because
* the DDI mandates that they return the buffer rather than its length.
*/
/*PRINTFLIKE2*/
int
sprintf(char *buf, const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
(void) vsnprintf(buf, INT_MAX, fmt, args);
va_end(args);
return (strlen(buf));
}
int
vsprintf(char *buf, const char *fmt, va_list args)
{
(void) vsnprintf(buf, INT_MAX, fmt, args);
return (strlen(buf));
}
#endif /* _BOOT && __sparc */
#endif /* !_KMDB && (!_BOOT || __sparc) */
char *
strcat(char *s1, const char *s2)
{
char *os1 = s1;
while (*s1++ != '\0')
;
s1--;
while ((*s1++ = *s2++) != '\0')
;
return (os1);
}
char *
strchr(const char *sp, int c)
{
do {
if (*sp == (char)c)
return ((char *)sp);
} while (*sp++);
return (NULL);
}
int
strcmp(const char *s1, const char *s2)
{
while (*s1 == *s2++)
if (*s1++ == '\0')
return (0);
return (*(unsigned char *)s1 - *(unsigned char *)--s2);
}
int
strncmp(const char *s1, const char *s2, size_t n)
{
if (s1 == s2)
return (0);
n++;
while (--n != 0 && *s1 == *s2++)
if (*s1++ == '\0')
return (0);
return ((n == 0) ? 0 : *(unsigned char *)s1 - *(unsigned char *)--s2);
}
static const char charmap[] = {
'\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007',
'\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017',
'\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027',
'\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037',
'\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047',
'\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057',
'\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067',
'\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077',
'\100', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
'\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
'\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
'\170', '\171', '\172', '\133', '\134', '\135', '\136', '\137',
'\140', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
'\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
'\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
'\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177',
'\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
'\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217',
'\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227',
'\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237',
'\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247',
'\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
'\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
'\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
'\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307',
'\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317',
'\320', '\321', '\322', '\323', '\324', '\325', '\326', '\327',
'\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337',
'\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
'\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
'\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
'\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377',
};
int
strcasecmp(const char *s1, const char *s2)
{
const unsigned char *cm = (const unsigned char *)charmap;
const unsigned char *us1 = (const unsigned char *)s1;
const unsigned char *us2 = (const unsigned char *)s2;
while (cm[*us1] == cm[*us2++])
if (*us1++ == '\0')
return (0);
return (cm[*us1] - cm[*(us2 - 1)]);
}
int
strncasecmp(const char *s1, const char *s2, size_t n)
{
const unsigned char *cm = (const unsigned char *)charmap;
const unsigned char *us1 = (const unsigned char *)s1;
const unsigned char *us2 = (const unsigned char *)s2;
while (n != 0 && cm[*us1] == cm[*us2++]) {
if (*us1++ == '\0')
return (0);
n--;
}
return (n == 0 ? 0 : cm[*us1] - cm[*(us2 - 1)]);
}
char *
strcpy(char *s1, const char *s2)
{
char *os1 = s1;
while ((*s1++ = *s2++) != '\0')
;
return (os1);
}
char *
strncpy(char *s1, const char *s2, size_t n)
{
char *os1 = s1;
n++;
while (--n != 0 && (*s1++ = *s2++) != '\0')
;
if (n != 0)
while (--n != 0)
*s1++ = '\0';
return (os1);
}
char *
strrchr(const char *sp, int c)
{
char *r = NULL;
do {
if (*sp == (char)c)
r = (char *)sp;
} while (*sp++);
return (r);
}
char *
strstr(const char *as1, const char *as2)
{
const char *s1, *s2;
const char *tptr;
char c;
s1 = as1;
s2 = as2;
if (s2 == NULL || *s2 == '\0')
return ((char *)s1);
c = *s2;
while (*s1)
if (*s1++ == c) {
tptr = s1;
while ((c = *++s2) == *s1++ && c)
;
if (c == 0)
return ((char *)tptr - 1);
s1 = tptr;
s2 = as2;
c = *s2;
}
return (NULL);
}
char *
strpbrk(const char *string, const char *brkset)
{
const char *p;
do {
for (p = brkset; *p != '\0' && *p != *string; ++p)
;
if (*p != '\0')
return ((char *)string);
} while (*string++);
return (NULL);
}
char *
strncat(char *s1, const char *s2, size_t n)
{
char *os1 = s1;
n++;
while (*s1++ != '\0')
;
--s1;
while ((*s1++ = *s2++) != '\0') {
if (--n == 0) {
s1[-1] = '\0';
break;
}
}
return (os1);
}
#if defined(_BOOT) || defined(_KMDB)
#define bcopy(src, dst, n) (void) memcpy((dst), (src), (n))
#endif
size_t
strlcat(char *dst, const char *src, size_t dstsize)
{
char *df = dst;
size_t left = dstsize;
size_t l1;
size_t l2 = strlen(src);
size_t copied;
while (left-- != 0 && *df != '\0')
df++;
/*LINTED: possible ptrdiff_t overflow*/
l1 = (size_t)(df - dst);
if (dstsize == l1)
return (l1 + l2);
copied = l1 + l2 >= dstsize ? dstsize - l1 - 1 : l2;
bcopy(src, dst + l1, copied);
dst[l1+copied] = '\0';
return (l1 + l2);
}
size_t
strlcpy(char *dst, const char *src, size_t len)
{
size_t slen = strlen(src);
size_t copied;
if (len == 0)
return (slen);
if (slen >= len)
copied = len - 1;
else
copied = slen;
bcopy(src, dst, copied);
dst[copied] = '\0';
return (slen);
}
size_t
strspn(const char *string, const char *charset)
{
const char *p, *q;
for (q = string; *q != '\0'; ++q) {
for (p = charset; *p != '\0' && *p != *q; ++p)
;
if (*p == '\0')
break;
}
/*LINTED: possible ptrdiff_t overflow*/
return ((size_t)(q - string));
}
size_t
strcspn(const char *string, const char *charset)
{
const char *p, *q;
for (q = string; *q != '\0'; ++q) {
for (p = charset; *p != '\0' && *p != *q; ++p)
;
if (*p != '\0')
break;
}
/*LINTED E_PTRDIFF_OVERFLOW*/
return ((size_t)(q - string));
}
/*
* strsep
*
* The strsep() function locates, in the string referenced by *stringp, the
* first occurrence of any character in the string delim (or the terminating
* `\0' character) and replaces it with a `\0'. The location of the next
* character after the delimiter character (or NULL, if the end of the
* string was reached) is stored in *stringp. The original value of
* *stringp is returned.
*
* If *stringp is initially NULL, strsep() returns NULL.
*
* NOTE: This instance is left for in-kernel use. Libraries and programs
* should use strsep from libc.
*/
char *
strsep(char **stringp, const char *delim)
{
char *s;
const char *spanp;
int c, sc;
char *tok;
if ((s = *stringp) == NULL)
return (NULL);
for (tok = s; ; ) {
c = *s++;
spanp = delim;
do {
if ((sc = *spanp++) == c) {
if (c == 0)
s = NULL;
else
s[-1] = 0;
*stringp = s;
return (tok);
}
} while (sc != 0);
}
/* NOTREACHED */
}
/*
* Unless mentioned otherwise, all of the routines below should be added to
* the Solaris DDI as necessary. For now, only provide them to standalone.
*/
#if defined(_BOOT) || defined(_KMDB)
char *
strtok(char *string, const char *sepset)
{
char *p, *q, *r;
static char *savept;
/*
* Set `p' to our current location in the string.
*/
p = (string == NULL) ? savept : string;
if (p == NULL)
return (NULL);
/*
* Skip leading separators; bail if no tokens remain.
*/
q = p + strspn(p, sepset);
if (*q == '\0')
return (NULL);
/*
* Mark the end of the token and set `savept' for the next iteration.
*/
if ((r = strpbrk(q, sepset)) == NULL)
savept = NULL;
else {
*r = '\0';
savept = ++r;
}
return (q);
}
/*
* The strlen() routine isn't shared with the kernel because it has its own
* hand-tuned assembly version.
*/
size_t
strlen(const char *s)
{
size_t n = 0;
while (*s++)
n++;
return (n);
}
#endif /* _BOOT || _KMDB */
/*
* Returns the number of non-NULL bytes in string argument,
* but not more than maxlen. Does not look past str + maxlen.
*/
size_t
strnlen(const char *s, size_t maxlen)
{
size_t n = 0;
while (maxlen != 0 && *s != 0) {
s++;
maxlen--;
n++;
}
return (n);
}
#ifdef _KERNEL
/*
* Check for a valid C identifier:
* a letter or underscore, followed by
* zero or more letters, digits and underscores.
*/
#define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
#define IS_ALPHA(c) \
(((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z'))
int
strident_valid(const char *id)
{
int c = *id++;
if (!IS_ALPHA(c) && c != '_')
return (0);
while ((c = *id++) != 0) {
if (!IS_ALPHA(c) && !IS_DIGIT(c) && c != '_')
return (0);
}
return (1);
}
/*
* Convert a string into a valid C identifier by replacing invalid
* characters with '_'. Also makes sure the string is nul-terminated
* and takes up at most n bytes.
*/
void
strident_canon(char *s, size_t n)
{
char c;
char *end = s + n - 1;
ASSERT(n > 0);
if ((c = *s) == 0)
return;
if (!IS_ALPHA(c) && c != '_')
*s = '_';
while (s < end && ((c = *(++s)) != 0)) {
if (!IS_ALPHA(c) && !IS_DIGIT(c) && c != '_')
*s = '_';
}
*s = 0;
}
#endif /* _KERNEL */