diff options
Diffstat (limited to 'nx-X11/lib/misc')
| -rw-r--r-- | nx-X11/lib/misc/snprintf.c | 714 | ||||
| -rw-r--r-- | nx-X11/lib/misc/snprintf.h | 35 | ||||
| -rw-r--r-- | nx-X11/lib/misc/strlcat.c | 61 | ||||
| -rw-r--r-- | nx-X11/lib/misc/strlcpy.c | 56 |
4 files changed, 866 insertions, 0 deletions
diff --git a/nx-X11/lib/misc/snprintf.c b/nx-X11/lib/misc/snprintf.c new file mode 100644 index 000000000..6e9e2816f --- /dev/null +++ b/nx-X11/lib/misc/snprintf.c @@ -0,0 +1,714 @@ +/* + * This version of snprintf() and vsnprintf() is based on Sprint from + * SIO by Panagiotis Tsirigotis, as included with xidentd-2.2.1. + * + * The modifications were made by The XFree86 Project, Inc and are + * Copyright 1999 by The XFree86 Project, Inc. These modifications + * consist of removing the support for writing to file streams, + * renaming some functions, ansification, and making some adjustments + * to achieve the semantics for snprintf and vsnprintf() as described + * in the relevant man page for FreeBSD 2.2.8. + * + * + * The original version carries the following notice: + * + * (c) Copyright 1992, 1993 by Panagiotis Tsirigotis + * + * The author (Panagiotis Tsirigotis) grants permission to use, copy, + * and distribute this software and its documentation for any purpose + * and without fee, provided that a) the above copyright notice extant in + * files in this distribution is not removed from files included in any + * redistribution, and b) this file is also included in any redistribution. + * + * Modifications to this software may be distributed, either by distributing + * the modified software or by distributing patches to the original software, + * under the following additional terms: + * + * 1. The version number will be modified as follows: + * a. The first 3 components of the version number + * (i.e. <number>.<number>.<number>) will remain unchanged. + * b. A new component will be appended to the version number to indicate + * the modification level. The form of this component is up to the + * author of the modifications. + * + * 2. The author of the modifications will include his/her name by appending + * it along with the new version number to this file and will be + * responsible for any wrong behavior of the modified software. + * + * The author makes no representations about the suitability of this + * software for any purpose. It is provided "as is" without any express + * or implied warranty. + * + * Changes and modifications for: + * + * xinetd Version 2.1.4-bsdi + * xinetd Version 2.1.4-freebsd + * xinetd Version 2.1.4-linux + * + * are + * + * (c) Copyright 1995 by Charles Murcko + * All Rights Reserved + */ + +/* $XFree86$ */ + + +/* + * Assumption: systems that don't have snprintf and vsnprintf do have + * ecvt, fcvt and gcvt. + */ + +/* From: Id: sprint.c,v 1.5 1995/09/10 18:35:09 chuck Exp */ + +#include <ctype.h> +#include <stdlib.h> +#include <stdarg.h> +#include <string.h> +#include <sys/types.h> + +#ifndef SCOPE +#define SCOPE /**/ +#endif + +#ifndef WIDE_INT +#define WIDE_INT long +#endif + +typedef WIDE_INT wide_int; +typedef unsigned WIDE_INT u_wide_int; +typedef int bool_int; + +#ifndef FALSE +#define FALSE 0 +#define TRUE 1 +#endif + +#define NUL '\0' + +#define S_NULL "(null)" +#define S_NULL_LEN 6 + +#define FLOAT_DIGITS 6 +#define EXPONENT_LENGTH 10 + +typedef enum { NO = 0, YES = 1 } boolean_e ; + +/* + * NUM_BUF_SIZE is the size of the buffer used for arithmetic conversions + * + * XXX: this is a magic number; do not decrease it + */ +#define NUM_BUF_SIZE 512 + +/* + * The INS_CHAR macro inserts a character in the buffer. + * It uses the char pointers sp and bep: + * sp points to the next available character in the buffer + * bep points to the end-of-buffer + * While using this macro, note that the nextb pointer is NOT updated. + * + * Excess characters are discarded if the string overflows. + * + * NOTE: Evaluation of the c argument should not have any side-effects + */ +#define INS_CHAR( c, sp, bep, cc ) \ + { \ + if ( sp != NULL && sp < bep ) \ + *sp++ = c ; \ + cc++ ; \ + } + +#define NUM( c ) ( c - '0' ) + +#define STR_TO_DEC( str, num ) \ + num = NUM( *str++ ) ; \ + while ( isdigit( *str ) ) { \ + num *= 10 ; \ + num += NUM( *str++ ) ; \ + } + +/* + * This macro does zero padding so that the precision + * requirement is satisfied. The padding is done by + * adding '0's to the left of the string that is going + * to be printed. + */ +#define FIX_PRECISION( adjust, precision, s, s_len ) \ + if ( adjust ) \ + while ( s_len < precision ) { \ + *--s = '0' ; \ + s_len++ ; \ + } + +/* + * Macro that does padding. The padding is done by printing + * the character ch. + */ +#define PAD( width, len, ch ) \ + do { \ + INS_CHAR( ch, sp, bep, cc ) ; \ + width-- ; \ + } while ( width > len ) + +/* + * Prefix the character ch to the string str + * Increase length + * Set the has_prefix flag + */ +#define PREFIX( str, length, ch ) \ + *--str = ch ; length++ ; has_prefix = YES + +static char *conv_10(wide_int num, bool_int is_unsigned, + bool_int * is_negative, char *buf_end, int *len); +SCOPE int vsnprintf(char *str, size_t size, const char *fmt, va_list ap); + +/* + * snprintf is based on SIO's Sprint. + * + * Sprint is the equivalent of printf for SIO. + * It returns the # of chars written + * Assumptions: + * - all floating point arguments are passed as doubles + */ +SCOPE int +snprintf(char *str, size_t size, const char *fmt, ...) +{ + int cc; + va_list ap; + + va_start(ap, fmt); + cc = vsnprintf(str, size, fmt, ap); + va_end(ap); + return cc; +} + +/* + * Convert a floating point number to a string formats 'f', 'e' or 'E'. + * The result is placed in buf, and len denotes the length of the string + * The sign is returned in the is_negative argument (and is not placed + * in buf). Always add decimal point if add_dp is YES. + */ +static char * +conv_fp(char format, double num, boolean_e add_dp, int precision, + bool_int *is_negative, char buf[], int *len) +{ + char *s = buf; + char *p; + int decimal_point; + + if (format == 'f') + p = fcvt(num, precision, &decimal_point, is_negative); + else /* either e or E format */ + p = ecvt(num, precision + 1, &decimal_point, is_negative); + + /* + * Check for Infinity and NaN + */ + if (isalpha(*p)) { + *len = strlen(strcpy(buf, p)); + *is_negative = FALSE; + return (buf); + } + if (format == 'f') + if (decimal_point <= 0) { + *s++ = '0'; + if (precision > 0) { + *s++ = '.'; + while (decimal_point++ < 0) + *s++ = '0'; + } else if (add_dp) + *s++ = '.'; + } else { + while (decimal_point-- > 0) + *s++ = *p++; + if (precision > 0 || add_dp) + *s++ = '.'; + } else { + *s++ = *p++; + if (precision > 0 || add_dp) + *s++ = '.'; + } + + /* + * copy the rest of p, the NUL is NOT copied + */ + while (*p) + *s++ = *p++; + + if (format != 'f') { + char temp[EXPONENT_LENGTH]; /* for exponent conversion */ + int t_len; + bool_int exponent_is_negative; + + *s++ = format; /* either e or E */ + decimal_point--; + if (decimal_point != 0) { + p = conv_10((wide_int) decimal_point, FALSE, &exponent_is_negative, + &temp[EXPONENT_LENGTH], &t_len); + *s++ = exponent_is_negative ? '-' : '+'; + + /* + * Make sure the exponent has at least 2 digits + */ + if (t_len == 1) + *s++ = '0'; + while (t_len--) + *s++ = *p++; + } else { + *s++ = '+'; + *s++ = '0'; + *s++ = '0'; + } + } + *len = s - buf; + return (buf); +} + +/* + * Convert num to a base X number where X is a power of 2. nbits determines X. + * For example, if nbits is 3, we do base 8 conversion + * Return value: + * a pointer to a string containing the number + * + * The caller provides a buffer for the string: that is the buf_end argument + * which is a pointer to the END of the buffer + 1 (i.e. if the buffer + * is declared as buf[ 100 ], buf_end should be &buf[ 100 ]) + */ +static char * +conv_p2(u_wide_int num, int nbits, char format, char *buf_end, int *len) +{ + int mask = (1 << nbits) - 1; + char *p = buf_end; + static char low_digits[] = "0123456789abcdef"; + static char upper_digits[] = "0123456789ABCDEF"; + char *digits = (format == 'X') ? upper_digits : low_digits; + + do { + *--p = digits[num & mask]; + num >>= nbits; + } + while (num); + + *len = buf_end - p; + return (p); +} + +/* + * Convert num to its decimal format. + * Return value: + * - a pointer to a string containing the number (no sign) + * - len contains the length of the string + * - is_negative is set to TRUE or FALSE depending on the sign + * of the number (always set to FALSE if is_unsigned is TRUE) + * + * The caller provides a buffer for the string: that is the buf_end argument + * which is a pointer to the END of the buffer + 1 (i.e. if the buffer + * is declared as buf[ 100 ], buf_end should be &buf[ 100 ]) + */ +static char * +conv_10(wide_int num, bool_int is_unsigned, bool_int *is_negative, + char *buf_end, int *len) +{ + char *p = buf_end; + u_wide_int magnitude; + + if (is_unsigned) { + magnitude = (u_wide_int) num; + *is_negative = FALSE; + } else { + *is_negative = (num < 0); + + /* + * On a 2's complement machine, negating the most negative integer + * results in a number that cannot be represented as a signed integer. + * Here is what we do to obtain the number's magnitude: + * a. add 1 to the number + * b. negate it (becomes positive) + * c. convert it to unsigned + * d. add 1 + */ + if (*is_negative) { + wide_int t = num + 1; + + magnitude = ((u_wide_int) - t) + 1; + } else + magnitude = (u_wide_int) num; + } + + /* + * We use a do-while loop so that we write at least 1 digit + */ + do { + register u_wide_int new_magnitude = magnitude / 10; + + *--p = magnitude - new_magnitude * 10 + '0'; + magnitude = new_magnitude; + } + while (magnitude); + + *len = buf_end - p; + return (p); +} + +/* + * Do format conversion. + */ +SCOPE int +#if (defined(__UNIXWARE__) || defined(__OPENSERVER)) && !defined(__GNUC__) +vsnprintf(char *str, size_t size, const char *fmt, _VA_LIST ap) +#else +vsnprintf(char *str, size_t size, const char *fmt, va_list ap) +#endif +{ + char *sp; + char *bep; + int cc = 0; + int i; + + char *s; + char *q; + int s_len; + + int min_width; + int precision; + enum { + LEFT, RIGHT + } adjust; + char pad_char; + char prefix_char; + + double fp_num; + wide_int i_num; + u_wide_int ui_num; + + char num_buf[NUM_BUF_SIZE]; + char char_buf[2]; /* for printing %% and %<unknown> */ + + /* + * Flag variables + */ + boolean_e is_long; + boolean_e alternate_form; + boolean_e print_sign; + boolean_e print_blank; + boolean_e adjust_precision; + boolean_e adjust_width; + bool_int is_negative; + + if (size == 0 && str != NULL) + return 0; + + sp = str; + bep = str + size - 1; + + while (*fmt) { + if (*fmt != '%') { + INS_CHAR(*fmt, sp, bep, cc); + } else { + /* + * Default variable settings + */ + adjust = RIGHT; + alternate_form = print_sign = print_blank = NO; + pad_char = ' '; + prefix_char = NUL; + + fmt++; + + /* + * Try to avoid checking for flags, width or precision + */ + if (isascii(*fmt) && !islower(*fmt)) { + /* + * Recognize flags: -, #, BLANK, + + */ + for (;; fmt++) { + if (*fmt == '-') + adjust = LEFT; + else if (*fmt == '+') + print_sign = YES; + else if (*fmt == '#') + alternate_form = YES; + else if (*fmt == ' ') + print_blank = YES; + else if (*fmt == '0') + pad_char = '0'; + else + break; + } + + /* + * Check if a width was specified + */ + if (isdigit(*fmt)) { + STR_TO_DEC(fmt, min_width); + adjust_width = YES; + } else if (*fmt == '*') { + min_width = va_arg(ap, int); + + fmt++; + adjust_width = YES; + if (min_width < 0) { + adjust = LEFT; + min_width = -min_width; + } + } else + adjust_width = NO; + + /* + * Check if a precision was specified + * + * XXX: an unreasonable amount of precision may be specified + * resulting in overflow of num_buf. Currently we + * ignore this possibility. + */ + if (*fmt == '.') { + adjust_precision = YES; + fmt++; + if (isdigit(*fmt)) { + STR_TO_DEC(fmt, precision); + } else if (*fmt == '*') { + precision = va_arg(ap, int); + + fmt++; + if (precision < 0) + precision = 0; + } else + precision = 0; + } else + adjust_precision = NO; + } else + adjust_precision = adjust_width = NO; + + /* + * Modifier check + */ + if (*fmt == 'l') { + is_long = YES; + fmt++; + } else + is_long = NO; + + /* + * Argument extraction and printing. + * First we determine the argument type. + * Then, we convert the argument to a string. + * On exit from the switch, s points to the string that + * must be printed, s_len has the length of the string + * The precision requirements, if any, are reflected in s_len. + * + * NOTE: pad_char may be set to '0' because of the 0 flag. + * It is reset to ' ' by non-numeric formats + */ + switch (*fmt) { + case 'd': + case 'i': + case 'u': + if (is_long) + i_num = va_arg(ap, wide_int); + else + i_num = (wide_int) va_arg(ap, int); + + s = conv_10(i_num, (*fmt) == 'u', &is_negative, + &num_buf[NUM_BUF_SIZE], &s_len); + FIX_PRECISION(adjust_precision, precision, s, s_len); + + if (*fmt != 'u') { + if (is_negative) + prefix_char = '-'; + else if (print_sign) + prefix_char = '+'; + else if (print_blank) + prefix_char = ' '; + } + break; + + case 'o': + if (is_long) + ui_num = va_arg(ap, u_wide_int); + else + ui_num = (u_wide_int) va_arg(ap, unsigned int); + + s = conv_p2(ui_num, 3, *fmt, + &num_buf[NUM_BUF_SIZE], &s_len); + FIX_PRECISION(adjust_precision, precision, s, s_len); + if (alternate_form && *s != '0') { + *--s = '0'; + s_len++; + } + break; + + case 'x': + case 'X': + if (is_long) + ui_num = (u_wide_int) va_arg(ap, u_wide_int); + else + ui_num = (u_wide_int) va_arg(ap, unsigned int); + + s = conv_p2(ui_num, 4, *fmt, + &num_buf[NUM_BUF_SIZE], &s_len); + FIX_PRECISION(adjust_precision, precision, s, s_len); + if (alternate_form && i_num != 0) { + *--s = *fmt; /* 'x' or 'X' */ + *--s = '0'; + s_len += 2; + } + break; + + case 's': + s = va_arg(ap, char *); + + if (s != NULL) { + s_len = strlen(s); + if (adjust_precision && precision < s_len) + s_len = precision; + } else { + s = S_NULL; + s_len = S_NULL_LEN; + } + pad_char = ' '; + break; + + case 'f': + case 'e': + case 'E': + fp_num = va_arg(ap, double); + + s = conv_fp(*fmt, fp_num, alternate_form, + (adjust_precision == NO) ? FLOAT_DIGITS : precision, + &is_negative, &num_buf[1], &s_len); + if (is_negative) + prefix_char = '-'; + else if (print_sign) + prefix_char = '+'; + else if (print_blank) + prefix_char = ' '; + break; + + case 'g': + case 'G': + if (adjust_precision == NO) + precision = FLOAT_DIGITS; + else if (precision == 0) + precision = 1; + /* + * We use &num_buf[ 1 ], so that we have room for the sign + */ + s = gcvt(va_arg(ap, double), precision, &num_buf[1]); + + if (*s == '-') + prefix_char = *s++; + else if (print_sign) + prefix_char = '+'; + else if (print_blank) + prefix_char = ' '; + + s_len = strlen(s); + + if (alternate_form && (q = strchr(s, '.')) == NULL) + s[s_len++] = '.'; + if (*fmt == 'G' && (q = strchr(s, 'e')) != NULL) + *q = 'E'; + break; + + case 'c': + char_buf[0] = (char)(va_arg(ap, int)); + + s = &char_buf[0]; + s_len = 1; + pad_char = ' '; + break; + + case '%': + char_buf[0] = '%'; + s = &char_buf[0]; + s_len = 1; + pad_char = ' '; + break; + + case 'n': + *(va_arg(ap, int *)) = cc; + + break; + + /* + * If the pointer size is equal to the size of an unsigned + * integer we convert the pointer to a hex number, otherwise + * we print "%p" to indicate that we don't handle "%p". + */ + case 'p': + ui_num = (u_wide_int) va_arg(ap, void *); + + if (sizeof(void *) <= sizeof(u_wide_int)) + s = conv_p2(ui_num, 4, 'x', + &num_buf[NUM_BUF_SIZE], &s_len); + + else { + s = "%p"; + s_len = 2; + } + pad_char = ' '; + break; + + case NUL: + /* + * The last character of the format string was %. + * We ignore it. + */ + continue; + + /* + * The default case is for unrecognized %'s. + * We print %<char> to help the user identify what + * option is not understood. + * This is also useful in case the user wants to pass + * the output of __sio_converter to another function + * that understands some other %<char> (like syslog). + * Note that we can't point s inside fmt because the + * unknown <char> could be preceded by width etc. + */ + default: + char_buf[0] = '%'; + char_buf[1] = *fmt; + s = char_buf; + s_len = 2; + pad_char = ' '; + break; + } + + if (prefix_char != NUL) { + *--s = prefix_char; + s_len++; + } + if (adjust_width && adjust == RIGHT && min_width > s_len) { + if (pad_char == '0' && prefix_char != NUL) { + INS_CHAR(*s, sp, bep, cc) + s++; + s_len--; + min_width--; + } + PAD(min_width, s_len, pad_char); + } + /* + * Print the string s. + */ + for (i = s_len; i != 0; i--) { + INS_CHAR(*s, sp, bep, cc); + s++; + } + + if (adjust_width && adjust == LEFT && min_width > s_len) + PAD(min_width, s_len, pad_char); + } + fmt++; + } + if (str != NULL) { + if (cc < size) + str[cc] = NUL; + else + str[size - 1] = NUL; + } + return cc; +} + diff --git a/nx-X11/lib/misc/snprintf.h b/nx-X11/lib/misc/snprintf.h new file mode 100644 index 000000000..481e67679 --- /dev/null +++ b/nx-X11/lib/misc/snprintf.h @@ -0,0 +1,35 @@ +/* $XFree86: xc/lib/misc/snprintf.h,v 3.1 1996/08/26 14:42:33 dawes Exp $ */ + +#ifndef SNPRINTF_H +#define SNPRINTF_H + +#ifdef HAS_SNPRINTF +#ifdef LIBXT +#define _XtSnprintf snprintf +#define _XtVsnprintf vsnprintf +#endif +#ifdef LIBX11 +#define _XSnprintf snprintf +#define _XVsnprintf vsnprintf +#endif +#else /* !HAS_SNPRINTF */ + +#ifdef LIBXT +#define snprintf _XtSnprintf +#define vsnprintf _XtVsnprintf +#endif +#ifdef LIBX11 +#define snprintf _XSnprintf +#define vsnprintf _XVsnprintf +#endif + +extern int snprintf (char *str, size_t count, const char *fmt, ...); +#if (defined(__UNIXWARE__) || defined(__OPENSERVER)) && !defined(__GNUC__) +extern int vsnprintf (char *str, size_t count, const char *fmt, _VA_LIST arg); +#else +extern int vsnprintf (char *str, size_t count, const char *fmt, va_list arg); +#endif + +#endif /* HAS_SNPRINTF */ + +#endif /* SNPRINTF_H */ diff --git a/nx-X11/lib/misc/strlcat.c b/nx-X11/lib/misc/strlcat.c new file mode 100644 index 000000000..28e2338f9 --- /dev/null +++ b/nx-X11/lib/misc/strlcat.c @@ -0,0 +1,61 @@ +/* $OpenBSD: strlcat.c,v 1.10 2003/04/12 21:56:39 millert Exp $ */ + +/* + * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND TODD C. MILLER DISCLAIMS ALL + * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL TODD C. MILLER BE LIABLE + * FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +/* $XFree86$ */ + + +#ifdef HAVE_XORG_CONFIG_H +#include <xorg-config.h> +#endif + +#include <sys/types.h> +#include <string.h> + +/* + * Appends src to string dst of size siz (unlike strncat, siz is the + * full size of dst, not space left). At most siz-1 characters + * will be copied. Always NUL terminates (unless siz <= strlen(dst)). + * Returns strlen(src) + MIN(siz, strlen(initial dst)). + * If retval >= siz, truncation occurred. + */ +size_t +strlcat(char *dst, const char *src, size_t siz) +{ + register char *d = dst; + register const char *s = src; + register size_t n = siz; + size_t dlen; + + /* Find the end of dst and adjust bytes left but don't go past end */ + while (n-- != 0 && *d != '\0') + d++; + dlen = d - dst; + n = siz - dlen; + + if (n == 0) + return(dlen + strlen(s)); + while (*s != '\0') { + if (n != 1) { + *d++ = *s; + n--; + } + s++; + } + *d = '\0'; + + return(dlen + (s - src)); /* count does not include NUL */ +} diff --git a/nx-X11/lib/misc/strlcpy.c b/nx-X11/lib/misc/strlcpy.c new file mode 100644 index 000000000..42442cc30 --- /dev/null +++ b/nx-X11/lib/misc/strlcpy.c @@ -0,0 +1,56 @@ +/* $OpenBSD: strlcpy.c,v 1.7 2003/04/12 21:56:39 millert Exp $ */ + +/* + * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND TODD C. MILLER DISCLAIMS ALL + * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL TODD C. MILLER BE LIABLE + * FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +/* $XFree86$ */ + +#ifdef HAVE_XORG_CONFIG_H +#include <xorg-config.h> +#endif + +#include <sys/types.h> +#include <string.h> + +/* + * Copy src to string dst of size siz. At most siz-1 characters + * will be copied. Always NUL terminates (unless siz == 0). + * Returns strlen(src); if retval >= siz, truncation occurred. + */ +size_t +strlcpy(char *dst, const char *src, size_t siz) +{ + register char *d = dst; + register const char *s = src; + register size_t n = siz; + + /* Copy as many bytes as will fit */ + if (n != 0 && --n != 0) { + do { + if ((*d++ = *s++) == 0) + break; + } while (--n != 0); + } + + /* Not enough room in dst, add NUL and traverse rest of src */ + if (n == 0) { + if (siz != 0) + *d = '\0'; /* NUL-terminate dst */ + while (*s++) + ; + } + + return(s - src - 1); /* count does not include NUL */ +} |