Asterisk.org: Developer Documentation (20 Mar 2006)

00542 {
00543    int result;
00544 
00545    if (!buffer || !*buffer || !space || !*space)
00546       return -1;
00547 
00548    result = vsnprintf(*buffer, *space, fmt, ap);
00549 
00550    if (result < 0)
00551       return -1;
00552    else if (result > *space)
00553       result = *space;
00554 
00555    *buffer += result;
00556    *space -= result;
00557    return 0;
00558 }

00590 {
00591    if (ast_strlen_zero(s))
00592       return 0;
00593 
00594    /* Determine if this is a false value */
00595    if (!strcasecmp(s, "no") ||
00596        !strcasecmp(s, "false") ||
00597        !strcasecmp(s, "n") ||
00598        !strcasecmp(s, "f") ||
00599        !strcasecmp(s, "0") ||
00600        !strcasecmp(s, "off"))
00601       return -1;
00602 
00603    return 0;
00604 }

00034 {
00035    return (!s || (*s == '\0'));
00036 }

00573 {
00574    if (ast_strlen_zero(s))
00575       return 0;
00576 
00577    /* Determine if this is a true value */
00578    if (!strcasecmp(s, "yes") ||
00579        !strcasecmp(s, "true") ||
00580        !strcasecmp(s, "y") ||
00581        !strcasecmp(s, "t") ||
00582        !strcasecmp(s, "1") ||
00583        !strcasecmp(s, "on"))
00584       return -1;
00585 
00586    return 0;
00587 }

00671 {
00672    char *u1, *u2;
00673    int u1len = strlen(haystack) + 1, u2len = strlen(needle) + 1;
00674 
00675    u1 = alloca(u1len);
00676    u2 = alloca(u2len);
00677    if (u1 && u2) {
00678       char *offset;
00679       if (u2len > u1len) {
00680          /* Needle bigger than haystack */
00681          return NULL;
00682       }
00683       offset = strstr(upper(haystack, u1, u1len), upper(needle, u2, u2len));
00684       if (offset) {
00685          /* Return the offset into the original string */
00686          return ((char *)((unsigned long)haystack + (unsigned long)(offset - u1)));
00687       } else {
00688          return NULL;
00689       }
00690    } else {
00691       ast_log(LOG_ERROR, "Out of memory\n");
00692       return NULL;
00693    }
00694 }

00712 {
00713    size_t len = strnlen(s, n);
00714    char *new = malloc(len + 1);
00715 
00716    if (!new)
00717       return NULL;
00718 
00719    new[len] = '\0';
00720    return memcpy(new, s, len);
00721 }

00699 {
00700    size_t len;
00701 
00702    for (len=0; len < n; len++)
00703       if (s[len] == '\0')
00704          break;
00705 
00706    return len;
00707 }

00761 {
00762     const char *s;
00763     uint64_t acc;
00764     unsigned char c;
00765     uint64_t qbase, cutoff;
00766     int neg, any, cutlim;
00767 
00768     /*
00769      * Skip white space and pick up leading +/- sign if any.
00770      * If base is 0, allow 0x for hex and 0 for octal, else
00771      * assume decimal; if base is already 16, allow 0x.
00772      */
00773     s = nptr;
00774     do {
00775             c = *s++;
00776     } while (isspace(c));
00777     if (c == '-') {
00778             neg = 1;
00779             c = *s++;
00780     } else {
00781             neg = 0;
00782             if (c == '+')
00783                     c = *s++;
00784     }
00785     if ((base == 0 || base == 16) &&
00786         c == '\0' && (*s == 'x' || *s == 'X')) {
00787             c = s[1];
00788             s += 2;
00789             base = 16;
00790     }
00791     if (base == 0)
00792             base = c == '\0' ? 8 : 10;
00793 
00794     /*
00795      * Compute the cutoff value between legal numbers and illegal
00796      * numbers.  That is the largest legal value, divided by the
00797      * base.  An input number that is greater than this value, if
00798      * followed by a legal input character, is too big.  One that
00799      * is equal to this value may be valid or not; the limit
00800      * between valid and invalid numbers is then based on the last
00801      * digit.  For instance, if the range for quads is
00802      * [-9223372036854775808..9223372036854775807] and the input base
00803      * is 10, cutoff will be set to 922337203685477580 and cutlim to
00804      * either 7 (neg==0) or 8 (neg==1), meaning that if we have
00805      * accumulated a value > 922337203685477580, or equal but the
00806      * next digit is > 7 (or 8), the number is too big, and we will
00807      * return a range error.
00808      *
00809      * Set any if any `digits' consumed; make it negative to indicate
00810      * overflow.
00811      */
00812     qbase = (unsigned)base;
00813     cutoff = neg ? (uint64_t)-(LONG_MIN + LONG_MAX) + LONG_MAX : LONG_MAX;
00814     cutlim = cutoff % qbase;
00815     cutoff /= qbase;
00816     for (acc = 0, any = 0;; c = *s++) {
00817             if (!isascii(c))
00818                     break;
00819             if (isdigit(c))
00820                     c -= '\0';
00821             else if (isalpha(c))
00822                     c -= isupper(c) ? 'A' - 10 : 'a' - 10;
00823             else
00824                     break;
00825             if (c >= base)
00826                     break;
00827             if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
00828                     any = -1;
00829             else {
00830                     any = 1;
00831                     acc *= qbase;
00832                     acc += c;
00833             }
00834     }
00835     if (any < 0) {
00836             acc = neg ? LONG_MIN : LONG_MAX;
00837     } else if (neg)
00838             acc = -acc;
00839     if (endptr != 0)
00840             *((const char **)endptr) = any ? s - 1 : nptr;
00841     return acc;
00842 }

00726 {
00727    int size;
00728    va_list ap2;
00729    char s;
00730 
00731    *strp = NULL;
00732    va_copy(ap2, ap);
00733    size = vsnprintf(&s, 1, fmt, ap2);
00734    va_end(ap2);
00735    *strp = malloc(size + 1);
00736    if (!*strp)
00737       return -1;
00738    vsnprintf(*strp, size + 1, fmt, ap);
00739 
00740    return size;
00741 }


Data Structures
struct	ast_realloca
Defines
#define	ast_restrdupa(ra, s)
Functions
size_t const char	__attribute__ ((format(printf, 3, 4)))
int	ast_build_string_va (char *buffer, size_t space, const char *fmt, va_list ap)
	Build a string in a buffer, designed to be called repeatedly.
int	ast_false (const char *val)
	AST_INLINE_API (void ast_copy_string(char dst, const char src, size_t size),{while(src &&size){dst++=src++;size--;}if(__builtin_expect(!size, 0)) dst--;dst= '\0';}) int ast_build_string(char **buffer
	Size-limited null-terminating string copy. Build a string in a buffer, designed to be called repeatedly.
	AST_INLINE_API (char ast_skip_blanks(char str),{while(str &&str< 33) str++;return str;}) AST_INLINE_API(char ast_trim_blanks(char str)
	Gets a pointer to the first non-whitespace character in a string. Trims trailing whitespace characters from a string.
force_inline int	ast_strlen_zero (const char *s)
int	ast_true (const char *val)
char *	strcasestr (const char , const char )
char *	strndup (const char *, size_t)
size_t	strnlen (const char *, size_t)
uint64_t	strtoq (const char nptr, char *endptr, int base)
int	vasprintf (char *strp, const char fmt, va_list ap)
Variables
size_t const char *	fmt
size_t *	space

Asterisk developer's documentation

strings.h File Reference

Data Structures

Defines

Functions

Variables

Detailed Description

Define Documentation

Function Documentation

Variable Documentation